1 /* stabs.c -- Parse stabs debugging information
2 Copyright (C) 1995-2024 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>.
4
5 This file is part of GNU Binutils.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 /* This file contains code which parses stabs debugging information.
23 The organization of this code is based on the gdb stabs reading
24 code. The job it does is somewhat different, because it is not
25 trying to identify the correct address for anything. */
26
27 #include "sysdep.h"
28 #include "bfd.h"
29 #include "libiberty.h"
30 #include "safe-ctype.h"
31 #include "demangle.h"
32 #include "debug.h"
33 #include "budbg.h"
34 #include "filenames.h"
35 #include "aout/aout64.h"
36 #include "aout/stab_gnu.h"
37
38 /* The number of predefined XCOFF types. */
39
40 #define XCOFF_TYPE_COUNT 34
41
42 /* This structure is used as a handle so that the stab parsing doesn't
43 need to use any static variables. */
44
45 struct stab_handle
46 {
47 /* The BFD. */
48 bfd *abfd;
49 /* TRUE if this is stabs in sections. */
50 bool sections;
51 /* The symbol table. */
52 asymbol **syms;
53 /* The number of symbols. */
54 long symcount;
55 /* The accumulated file name string. */
56 char *so_string;
57 /* The value of the last N_SO symbol. */
58 bfd_vma so_value;
59 /* The value of the start of the file, so that we can handle file
60 relative N_LBRAC and N_RBRAC symbols. */
61 bfd_vma file_start_offset;
62 /* The offset of the start of the function, so that we can handle
63 function relative N_LBRAC and N_RBRAC symbols. */
64 bfd_vma function_start_offset;
65 /* The version number of gcc which compiled the current compilation
66 unit, 0 if not compiled by gcc. */
67 int gcc_compiled;
68 /* Whether an N_OPT symbol was seen that was not generated by gcc,
69 so that we can detect the SunPRO compiler. */
70 bool n_opt_found;
71 /* The main file name. */
72 char *main_filename;
73 /* A stack of unfinished N_BINCL files. */
74 struct bincl_file *bincl_stack;
75 /* A list of finished N_BINCL files. */
76 struct bincl_file *bincl_list;
77 /* Whether we are inside a function or not. */
78 bool within_function;
79 /* The address of the end of the function, used if we have seen an
80 N_FUN symbol while in a function. This is -1 if we have not seen
81 an N_FUN (the normal case). */
82 bfd_vma function_end;
83 /* The depth of block nesting. */
84 int block_depth;
85 /* List of pending variable definitions. */
86 struct stab_pending_var *pending;
87 /* Number of files for which we have types. */
88 unsigned int files;
89 /* Lists of types per file. */
90 struct stab_types **file_types;
91 /* Predefined XCOFF types. */
92 debug_type xcoff_types[XCOFF_TYPE_COUNT];
93 /* Undefined tags. */
94 struct stab_tag *tags;
95 /* Set by parse_stab_type if it sees a structure defined as a cross
96 reference to itself. Reset by parse_stab_type otherwise. */
97 bool self_crossref;
98 };
99
100 /* A list of these structures is used to hold pending variable
101 definitions seen before the N_LBRAC of a block. */
102
103 struct stab_pending_var
104 {
105 /* Next pending variable definition. */
106 struct stab_pending_var *next;
107 /* Name. */
108 const char *name;
109 /* Type. */
110 debug_type type;
111 /* Kind. */
112 enum debug_var_kind kind;
113 /* Value. */
114 bfd_vma val;
115 };
116
117 /* A list of these structures is used to hold the types for a single
118 file. */
119
120 struct stab_types
121 {
122 /* Next set of slots for this file. */
123 struct stab_types *next;
124 /* Where the TYPES array starts. */
125 unsigned int base_index;
126 /* Types indexed by type number. */
127 #define STAB_TYPES_SLOTS (16)
128 debug_type types[STAB_TYPES_SLOTS];
129 };
130
131 /* We keep a list of undefined tags that we encounter, so that we can
132 fill them in if the tag is later defined. */
133
134 struct stab_tag
135 {
136 /* Next undefined tag. */
137 struct stab_tag *next;
138 /* Tag name. */
139 const char *name;
140 /* Type kind. */
141 enum debug_type_kind kind;
142 /* Slot to hold real type when we discover it. If we don't, we fill
143 in an undefined tag type. */
144 debug_type slot;
145 /* Indirect type we have created to point at slot. */
146 debug_type type;
147 };
148
149 static void bad_stab (const char *);
150 static void warn_stab (const char *, const char *);
151 static bool parse_stab_string
152 (void *, struct stab_handle *, int, int, bfd_vma,
153 const char *, const char *);
154 static debug_type parse_stab_type
155 (void *, struct stab_handle *, const char *, const char **,
156 debug_type **, const char *);
157 static bool parse_stab_type_number
158 (const char **, int *, const char *);
159 static debug_type parse_stab_range_type
160 (void *, struct stab_handle *, const char *, const char **,
161 const int *, const char *);
162 static debug_type parse_stab_sun_builtin_type
163 (void *, const char **, const char *);
164 static debug_type parse_stab_sun_floating_type
165 (void *, const char **, const char *);
166 static debug_type parse_stab_enum_type
167 (void *, const char **, const char *);
168 static debug_type parse_stab_struct_type
169 (void *, struct stab_handle *, const char *, const char **,
170 bool, const int *, const char *);
171 static bool parse_stab_baseclasses
172 (void *, struct stab_handle *, const char **, debug_baseclass **,
173 const char *);
174 static bool parse_stab_struct_fields
175 (void *, struct stab_handle *, const char **, debug_field **,
176 bool *, const char *);
177 static bool parse_stab_cpp_abbrev
178 (void *, struct stab_handle *, const char **, debug_field *, const char *);
179 static bool parse_stab_one_struct_field
180 (void *, struct stab_handle *, const char **, const char *,
181 debug_field *, bool *, const char *);
182 static bool parse_stab_members
183 (void *, struct stab_handle *, const char *, const char **, const int *,
184 debug_method **, const char *);
185 static debug_type parse_stab_argtypes
186 (void *, struct stab_handle *, debug_type, const char *, const char *,
187 debug_type, const char *, bool, bool, const char **);
188 static bool parse_stab_tilde_field
189 (void *, struct stab_handle *, const char **, const int *, debug_type *,
190 bool *, const char *);
191 static debug_type parse_stab_array_type
192 (void *, struct stab_handle *, const char **, bool, const char *);
193 static void push_bincl (void *, struct stab_handle *, const char *, bfd_vma);
194 static const char *pop_bincl (struct stab_handle *);
195 static bool find_excl (struct stab_handle *, const char *, bfd_vma);
196 static bool stab_record_variable
197 (void *, struct stab_handle *, const char *, debug_type,
198 enum debug_var_kind, bfd_vma);
199 static bool stab_emit_pending_vars (void *, struct stab_handle *);
200 static debug_type *stab_find_slot (void *, struct stab_handle *, const int *);
201 static debug_type stab_find_type (void *, struct stab_handle *, const int *);
202 static bool stab_record_type
203 (void *, struct stab_handle *, const int *, debug_type);
204 static debug_type stab_xcoff_builtin_type
205 (void *, struct stab_handle *, unsigned int);
206 static debug_type stab_find_tagged_type
207 (void *, struct stab_handle *, const char *, int, enum debug_type_kind);
208 static debug_type *stab_demangle_argtypes
209 (void *, struct stab_handle *, const char *, bool *, unsigned int);
210 static debug_type *stab_demangle_v3_argtypes
211 (void *, struct stab_handle *, const char *, bool *);
212 static debug_type *stab_demangle_v3_arglist
213 (void *, struct stab_handle *, struct demangle_component *, bool *);
214 static debug_type stab_demangle_v3_arg
215 (void *, struct stab_handle *, struct demangle_component *, debug_type,
216 bool *);
217
218 static int demangle_flags = DMGL_ANSI;
219
220 /* Save a string in memory. */
221
222 static char *
savestring(void * dhandle,const char * start,size_t len)223 savestring (void *dhandle, const char *start, size_t len)
224 {
225 char *ret;
226
227 ret = debug_xalloc (dhandle, len + 1);
228 memcpy (ret, start, len);
229 ret[len] = '\0';
230 return ret;
231 }
232
233 /* Read a number from a string. */
234
235 static bfd_vma
parse_number(const char ** pp,bool * poverflow,const char * p_end)236 parse_number (const char **pp, bool *poverflow, const char *p_end)
237 {
238 unsigned long ul;
239 const char *orig;
240
241 if (poverflow != NULL)
242 *poverflow = false;
243
244 orig = *pp;
245 if (orig >= p_end)
246 return (bfd_vma) 0;
247
248 /* Stop early if we are passed an empty string. */
249 if (*orig == 0)
250 return (bfd_vma) 0;
251
252 errno = 0;
253 ul = strtoul (*pp, (char **) pp, 0);
254 if (ul + 1 != 0 || errno == 0)
255 {
256 /* If bfd_vma is larger than unsigned long, and the number is
257 meant to be negative, we have to make sure that we sign
258 extend properly. */
259 if (*orig == '-')
260 return (bfd_vma) (bfd_signed_vma) (long) ul;
261 return (bfd_vma) ul;
262 }
263
264 /* Note that even though strtoul overflowed, it should have set *pp
265 to the end of the number, which is where we want it. */
266 if (sizeof (bfd_vma) > sizeof (unsigned long))
267 {
268 const char *p;
269 bool neg;
270 int base;
271 bfd_vma over, lastdig;
272 bool overflow;
273 bfd_vma v;
274
275 /* Our own version of strtoul, for a bfd_vma. */
276 p = orig;
277
278 neg = false;
279 if (*p == '+')
280 ++p;
281 else if (*p == '-')
282 {
283 neg = true;
284 ++p;
285 }
286
287 base = 10;
288 if (*p == '0')
289 {
290 if (p[1] == 'x' || p[1] == 'X')
291 {
292 base = 16;
293 p += 2;
294 }
295 else
296 {
297 base = 8;
298 ++p;
299 }
300 }
301
302 over = ((bfd_vma) (bfd_signed_vma) -1) / (bfd_vma) base;
303 lastdig = ((bfd_vma) (bfd_signed_vma) -1) % (bfd_vma) base;
304
305 overflow = false;
306 v = 0;
307 while (1)
308 {
309 int d;
310
311 d = *p++;
312 if (ISDIGIT (d))
313 d -= '0';
314 else if (ISUPPER (d))
315 d -= 'A';
316 else if (ISLOWER (d))
317 d -= 'a';
318 else
319 break;
320
321 if (d >= base)
322 break;
323
324 if (v > over || (v == over && (bfd_vma) d > lastdig))
325 {
326 overflow = true;
327 break;
328 }
329 }
330
331 if (! overflow)
332 {
333 if (neg)
334 v = - v;
335 return v;
336 }
337 }
338
339 /* If we get here, the number is too large to represent in a
340 bfd_vma. */
341 if (poverflow != NULL)
342 *poverflow = true;
343 else
344 warn_stab (orig, _("numeric overflow"));
345
346 return 0;
347 }
348
349 /* Give an error for a bad stab string. */
350
351 static void
bad_stab(const char * p)352 bad_stab (const char *p)
353 {
354 fprintf (stderr, _("Bad stab: %s\n"), p);
355 }
356
357 /* Warn about something in a stab string. */
358
359 static void
warn_stab(const char * p,const char * err)360 warn_stab (const char *p, const char *err)
361 {
362 fprintf (stderr, _("Warning: %s: %s\n"), err, p);
363 }
364
365 /* Create a handle to parse stabs symbols with. */
366
367 void *
start_stab(void * dhandle ATTRIBUTE_UNUSED,bfd * abfd,bool sections,asymbol ** syms,long symcount)368 start_stab (void *dhandle ATTRIBUTE_UNUSED, bfd *abfd, bool sections,
369 asymbol **syms, long symcount)
370 {
371 struct stab_handle *ret;
372
373 ret = xmalloc (sizeof (*ret));
374 memset (ret, 0, sizeof (*ret));
375 ret->abfd = abfd;
376 ret->sections = sections;
377 ret->syms = syms;
378 ret->symcount = symcount;
379 ret->files = 1;
380 ret->file_types = xmalloc (sizeof (*ret->file_types));
381 ret->file_types[0] = NULL;
382 ret->function_end = -1;
383 return ret;
384 }
385
386 /* When we have processed all the stabs information, we need to go
387 through and fill in all the undefined tags. */
388
389 bool
finish_stab(void * dhandle,void * handle,bool emit)390 finish_stab (void *dhandle, void *handle, bool emit)
391 {
392 struct stab_handle *info = (struct stab_handle *) handle;
393 struct stab_tag *st;
394 bool ret = true;
395
396 if (emit && info->within_function)
397 {
398 if (! stab_emit_pending_vars (dhandle, info)
399 || ! debug_end_function (dhandle, info->function_end))
400 ret = false;
401 }
402
403 if (emit && ret)
404 for (st = info->tags; st != NULL; st = st->next)
405 {
406 enum debug_type_kind kind;
407
408 kind = st->kind;
409 if (kind == DEBUG_KIND_ILLEGAL)
410 kind = DEBUG_KIND_STRUCT;
411 st->slot = debug_make_undefined_tagged_type (dhandle, st->name, kind);
412 if (st->slot == DEBUG_TYPE_NULL)
413 {
414 ret = false;
415 break;
416 }
417 }
418
419 free (info->file_types);
420 free (info->so_string);
421 free (info);
422 return ret;
423 }
424
425 /* Handle a single stabs symbol. */
426
427 bool
parse_stab(void * dhandle,void * handle,int type,int desc,bfd_vma value,const char * string)428 parse_stab (void *dhandle, void *handle, int type, int desc, bfd_vma value,
429 const char *string)
430 {
431 const char * string_end;
432 struct stab_handle *info = (struct stab_handle *) handle;
433 char *copy;
434 size_t len;
435
436 /* gcc will emit two N_SO strings per compilation unit, one for the
437 directory name and one for the file name. We just collect N_SO
438 strings as we see them, and start the new compilation unit when
439 we see a non N_SO symbol. */
440 if (info->so_string != NULL
441 && (type != N_SO || *string == '\0' || value != info->so_value))
442 {
443 len = strlen (info->so_string) + 1;
444 copy = debug_xalloc (dhandle, len);
445 memcpy (copy, info->so_string, len);
446 if (! debug_set_filename (dhandle, copy))
447 return false;
448 info->main_filename = copy;
449
450 free (info->so_string);
451 info->so_string = NULL;
452
453 info->gcc_compiled = 0;
454 info->n_opt_found = false;
455
456 /* Generally, for stabs in the symbol table, the N_LBRAC and
457 N_RBRAC symbols are relative to the N_SO symbol value. */
458 if (! info->sections)
459 info->file_start_offset = info->so_value;
460
461 /* We need to reset the mapping from type numbers to types. We
462 can only free the file_types array, not the stab_types
463 list entries due to the use of debug_make_indirect_type. */
464 info->files = 1;
465 info->file_types = xrealloc (info->file_types, sizeof (*info->file_types));
466 info->file_types[0] = NULL;
467
468 /* Now process whatever type we just got. */
469 }
470
471 string_end = string + strlen (string);
472
473 switch (type)
474 {
475 case N_FN:
476 case N_FN_SEQ:
477 break;
478
479 case N_LBRAC:
480 /* Ignore extra outermost context from SunPRO cc and acc. */
481 if (info->n_opt_found && desc == 1)
482 break;
483
484 if (! info->within_function)
485 {
486 fprintf (stderr, _("N_LBRAC not within function\n"));
487 return false;
488 }
489
490 /* Start an inner lexical block. */
491 if (! debug_start_block (dhandle,
492 (value
493 + info->file_start_offset
494 + info->function_start_offset)))
495 return false;
496
497 /* Emit any pending variable definitions. */
498 if (! stab_emit_pending_vars (dhandle, info))
499 return false;
500
501 ++info->block_depth;
502 break;
503
504 case N_RBRAC:
505 /* Ignore extra outermost context from SunPRO cc and acc. */
506 if (info->n_opt_found && desc == 1)
507 break;
508
509 /* We shouldn't have any pending variable definitions here, but,
510 if we do, we probably need to emit them before closing the
511 block. */
512 if (! stab_emit_pending_vars (dhandle, info))
513 return false;
514
515 /* End an inner lexical block. */
516 if (! debug_end_block (dhandle,
517 (value
518 + info->file_start_offset
519 + info->function_start_offset)))
520 return false;
521
522 --info->block_depth;
523 if (info->block_depth < 0)
524 {
525 fprintf (stderr, _("Too many N_RBRACs\n"));
526 return false;
527 }
528 break;
529
530 case N_SO:
531 /* This always ends a function. */
532 if (info->within_function)
533 {
534 bfd_vma endval;
535
536 endval = value;
537 if (*string != '\0'
538 && info->function_end != (bfd_vma) -1
539 && info->function_end < endval)
540 endval = info->function_end;
541 if (! stab_emit_pending_vars (dhandle, info)
542 || ! debug_end_function (dhandle, endval))
543 return false;
544 info->within_function = false;
545 info->function_end = (bfd_vma) -1;
546 }
547
548 /* An empty string is emitted by gcc at the end of a compilation
549 unit. */
550 if (*string == '\0')
551 return true;
552
553 /* Just accumulate strings until we see a non N_SO symbol. If
554 the string starts with a directory separator or some other
555 form of absolute path specification, we discard the previously
556 accumulated strings. */
557 if (info->so_string == NULL)
558 info->so_string = xstrdup (string);
559 else
560 {
561 char *f;
562
563 f = info->so_string;
564
565 if (IS_ABSOLUTE_PATH (string))
566 info->so_string = xstrdup (string);
567 else
568 info->so_string = concat (info->so_string, string,
569 (const char *) NULL);
570 free (f);
571 }
572
573 info->so_value = value;
574
575 break;
576
577 case N_SOL:
578 /* Start an include file. */
579 len = strlen (string) + 1;
580 copy = debug_xalloc (dhandle, len);
581 memcpy (copy, string, len);
582 if (! debug_start_source (dhandle, copy))
583 return false;
584 break;
585
586 case N_BINCL:
587 /* Start an include file which may be replaced. */
588 len = strlen (string) + 1;
589 copy = debug_xalloc (dhandle, len);
590 memcpy (copy, string, len);
591 push_bincl (dhandle, info, copy, value);
592 if (! debug_start_source (dhandle, copy))
593 return false;
594 break;
595
596 case N_EINCL:
597 /* End an N_BINCL include. */
598 if (! debug_start_source (dhandle, pop_bincl (info)))
599 return false;
600 break;
601
602 case N_EXCL:
603 /* This is a duplicate of a header file named by N_BINCL which
604 was eliminated by the linker. */
605 if (! find_excl (info, string, value))
606 return false;
607 break;
608
609 case N_SLINE:
610 if (! debug_record_line (dhandle, desc,
611 value + (info->within_function
612 ? info->function_start_offset : 0)))
613 return false;
614 break;
615
616 case N_BCOMM:
617 if (! debug_start_common_block (dhandle, string))
618 return false;
619 break;
620
621 case N_ECOMM:
622 if (! debug_end_common_block (dhandle, string))
623 return false;
624 break;
625
626 case N_FUN:
627 if (*string == '\0')
628 {
629 if (info->within_function)
630 {
631 /* This always marks the end of a function; we don't
632 need to worry about info->function_end. */
633 if (info->sections)
634 value += info->function_start_offset;
635 if (! stab_emit_pending_vars (dhandle, info)
636 || ! debug_end_function (dhandle, value))
637 return false;
638 info->within_function = false;
639 info->function_end = (bfd_vma) -1;
640 }
641 break;
642 }
643
644 /* A const static symbol in the .text section will have an N_FUN
645 entry. We need to use these to mark the end of the function,
646 in case we are looking at gcc output before it was changed to
647 always emit an empty N_FUN. We can't call debug_end_function
648 here, because it might be a local static symbol. */
649 if (info->within_function
650 && (info->function_end == (bfd_vma) -1
651 || value < info->function_end))
652 info->function_end = value;
653
654 /* Fall through. */
655 /* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM
656 symbols, and if it does not start with :S, gdb relocates the
657 value to the start of the section. gcc always seems to use
658 :S, so we don't worry about this. */
659 /* Fall through. */
660 default:
661 {
662 const char *colon;
663
664 colon = strchr (string, ':');
665 if (colon != NULL
666 && (colon[1] == 'f' || colon[1] == 'F'))
667 {
668 if (info->within_function)
669 {
670 bfd_vma endval;
671
672 endval = value;
673 if (info->function_end != (bfd_vma) -1
674 && info->function_end < endval)
675 endval = info->function_end;
676 if (! stab_emit_pending_vars (dhandle, info)
677 || ! debug_end_function (dhandle, endval))
678 return false;
679 info->function_end = (bfd_vma) -1;
680 }
681 /* For stabs in sections, line numbers and block addresses
682 are offsets from the start of the function. */
683 if (info->sections)
684 info->function_start_offset = value;
685 info->within_function = true;
686 }
687
688 if (! parse_stab_string (dhandle, info, type, desc, value, string, string_end))
689 return false;
690 }
691 break;
692
693 case N_OPT:
694 if (string != NULL && strcmp (string, "gcc2_compiled.") == 0)
695 info->gcc_compiled = 2;
696 else if (string != NULL && strcmp (string, "gcc_compiled.") == 0)
697 info->gcc_compiled = 1;
698 else
699 info->n_opt_found = true;
700 break;
701
702 case N_OBJ:
703 case N_ENDM:
704 case N_MAIN:
705 case N_WARNING:
706 break;
707 }
708
709 return true;
710 }
711
712 /* Parse the stabs string. */
713
714 static bool
parse_stab_string(void * dhandle,struct stab_handle * info,int stabtype,int desc ATTRIBUTE_UNUSED,bfd_vma value,const char * string,const char * string_end)715 parse_stab_string (void *dhandle, struct stab_handle *info, int stabtype,
716 int desc ATTRIBUTE_UNUSED, bfd_vma value,
717 const char *string, const char * string_end)
718 {
719 const char *p;
720 char *name;
721 int type;
722 debug_type dtype;
723 bool synonym;
724 bool self_crossref;
725 debug_type *slot;
726
727 p = strchr (string, ':');
728 if (p == NULL)
729 return true;
730
731 while (p[1] == ':')
732 {
733 p += 2;
734 p = strchr (p, ':');
735 if (p == NULL)
736 {
737 bad_stab (string);
738 return false;
739 }
740 }
741
742 /* FIXME: Sometimes the special C++ names start with '.'. */
743 name = NULL;
744 if (string[0] == '$')
745 {
746 switch (string[1])
747 {
748 case 't':
749 name = "this";
750 break;
751 case 'v':
752 /* Was: name = "vptr"; */
753 break;
754 case 'e':
755 name = "eh_throw";
756 break;
757 case '_':
758 /* This was an anonymous type that was never fixed up. */
759 break;
760 case 'X':
761 /* SunPRO (3.0 at least) static variable encoding. */
762 break;
763 default:
764 warn_stab (string, _("unknown C++ encoded name"));
765 break;
766 }
767 }
768
769 if (name == NULL)
770 {
771 if (p == string || (string[0] == ' ' && p == string + 1))
772 name = NULL;
773 else
774 name = savestring (dhandle, string, p - string);
775 }
776
777 ++p;
778 if (ISDIGIT (*p) || *p == '(' || *p == '-')
779 type = 'l';
780 else if (*p == 0)
781 {
782 bad_stab (string);
783 return false;
784 }
785 else
786 type = *p++;
787
788 switch (type)
789 {
790 case 'c':
791 /* c is a special case, not followed by a type-number.
792 SYMBOL:c=iVALUE for an integer constant symbol.
793 SYMBOL:c=rVALUE for a floating constant symbol.
794 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
795 e.g. "b:c=e6,0" for "const b = blob1"
796 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
797 if (*p != '=')
798 {
799 bad_stab (string);
800 return false;
801 }
802 ++p;
803 switch (*p++)
804 {
805 case 'r':
806 /* Floating point constant. */
807 if (! debug_record_float_const (dhandle, name, atof (p)))
808 return false;
809 break;
810 case 'i':
811 /* Integer constant. */
812 /* Defining integer constants this way is kind of silly,
813 since 'e' constants allows the compiler to give not only
814 the value, but the type as well. C has at least int,
815 long, unsigned int, and long long as constant types;
816 other languages probably should have at least unsigned as
817 well as signed constants. */
818 if (! debug_record_int_const (dhandle, name, atoi (p)))
819 return false;
820 break;
821 case 'e':
822 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
823 can be represented as integral.
824 e.g. "b:c=e6,0" for "const b = blob1"
825 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
826 dtype = parse_stab_type (dhandle, info, (const char *) NULL,
827 &p, (debug_type **) NULL, string_end);
828 if (dtype == DEBUG_TYPE_NULL)
829 return false;
830 if (*p != ',')
831 {
832 bad_stab (string);
833 return false;
834 }
835 if (! debug_record_typed_const (dhandle, name, dtype, atoi (p)))
836 return false;
837 break;
838 default:
839 bad_stab (string);
840 return false;
841 }
842
843 break;
844
845 case 'C':
846 /* The name of a caught exception. */
847 dtype = parse_stab_type (dhandle, info, (const char *) NULL,
848 &p, (debug_type **) NULL, string_end);
849 if (dtype == DEBUG_TYPE_NULL)
850 return false;
851 if (! debug_record_label (dhandle, name, dtype, value))
852 return false;
853 break;
854
855 case 'f':
856 case 'F':
857 /* A function definition. */
858 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
859 (debug_type **) NULL, string_end);
860 if (dtype == DEBUG_TYPE_NULL)
861 return false;
862 if (! debug_record_function (dhandle, name, dtype, type == 'F', value))
863 return false;
864
865 /* Sun acc puts declared types of arguments here. We don't care
866 about their actual types (FIXME -- we should remember the whole
867 function prototype), but the list may define some new types
868 that we have to remember, so we must scan it now. */
869 while (*p == ';')
870 {
871 ++p;
872 if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
873 (debug_type **) NULL, string_end)
874 == DEBUG_TYPE_NULL)
875 return false;
876 }
877
878 break;
879
880 case 'G':
881 {
882 asymbol **ps;
883
884 /* A global symbol. The value must be extracted from the
885 symbol table. */
886 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
887 (debug_type **) NULL, string_end);
888 if (dtype == DEBUG_TYPE_NULL)
889 return false;
890 if (name != NULL)
891 {
892 char leading;
893 long c;
894
895 leading = bfd_get_symbol_leading_char (info->abfd);
896 for (c = info->symcount, ps = info->syms; c > 0; --c, ++ps)
897 {
898 const char *n;
899
900 n = bfd_asymbol_name (*ps);
901 if (leading != '\0' && *n == leading)
902 ++n;
903 if (*n == *name && strcmp (n, name) == 0)
904 break;
905 }
906
907 if (c > 0)
908 value = bfd_asymbol_value (*ps);
909 }
910
911 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_GLOBAL,
912 value))
913 return false;
914 }
915 break;
916
917 /* This case is faked by a conditional above, when there is no
918 code letter in the dbx data. Dbx data never actually
919 contains 'l'. */
920 case 'l':
921 case 's':
922 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
923 (debug_type **) NULL, string_end);
924 if (dtype == DEBUG_TYPE_NULL)
925 return false;
926 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
927 value))
928 return false;
929 break;
930
931 case 'p':
932 /* A function parameter. */
933 if (*p != 'F')
934 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
935 (debug_type **) NULL, string_end);
936 else
937 {
938 /* pF is a two-letter code that means a function parameter in
939 Fortran. The type-number specifies the type of the return
940 value. Translate it into a pointer-to-function type. */
941 ++p;
942 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
943 (debug_type **) NULL, string_end);
944 if (dtype != DEBUG_TYPE_NULL)
945 {
946 debug_type ftype;
947
948 ftype = debug_make_function_type (dhandle, dtype,
949 (debug_type *) NULL, false);
950 dtype = debug_make_pointer_type (dhandle, ftype);
951 }
952 }
953 if (dtype == DEBUG_TYPE_NULL)
954 return false;
955 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_STACK,
956 value))
957 return false;
958
959 /* FIXME: At this point gdb considers rearranging the parameter
960 address on a big endian machine if it is smaller than an int.
961 We have no way to do that, since we don't really know much
962 about the target. */
963 break;
964
965 case 'P':
966 if (stabtype == N_FUN)
967 {
968 /* Prototype of a function referenced by this file. */
969 while (*p == ';')
970 {
971 ++p;
972 if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
973 (debug_type **) NULL, string_end)
974 == DEBUG_TYPE_NULL)
975 return false;
976 }
977 break;
978 }
979 /* Fall through. */
980 case 'R':
981 /* Parameter which is in a register. */
982 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
983 (debug_type **) NULL, string_end);
984 if (dtype == DEBUG_TYPE_NULL)
985 return false;
986 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REG,
987 value))
988 return false;
989 break;
990
991 case 'r':
992 /* Register variable (either global or local). */
993 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
994 (debug_type **) NULL, string_end);
995 if (dtype == DEBUG_TYPE_NULL)
996 return false;
997 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_REGISTER,
998 value))
999 return false;
1000
1001 /* FIXME: At this point gdb checks to combine pairs of 'p' and
1002 'r' stabs into a single 'P' stab. */
1003 break;
1004
1005 case 'S':
1006 /* Static symbol at top level of file. */
1007 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1008 (debug_type **) NULL, string_end);
1009 if (dtype == DEBUG_TYPE_NULL)
1010 return false;
1011 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_STATIC,
1012 value))
1013 return false;
1014 break;
1015
1016 case 't':
1017 /* A typedef. */
1018 dtype = parse_stab_type (dhandle, info, name, &p, &slot, string_end);
1019 if (dtype == DEBUG_TYPE_NULL)
1020 return false;
1021 if (name == NULL)
1022 {
1023 /* A nameless type. Nothing to do. */
1024 return true;
1025 }
1026
1027 dtype = debug_name_type (dhandle, name, dtype);
1028 if (dtype == DEBUG_TYPE_NULL)
1029 return false;
1030
1031 if (slot != NULL)
1032 *slot = dtype;
1033
1034 break;
1035
1036 case 'T':
1037 /* Struct, union, or enum tag. For GNU C++, this can be followed
1038 by 't' which means we are typedef'ing it as well. */
1039 if (*p != 't')
1040 {
1041 synonym = false;
1042 /* FIXME: gdb sets synonym to TRUE if the current language
1043 is C++. */
1044 }
1045 else
1046 {
1047 synonym = true;
1048 ++p;
1049 }
1050
1051 dtype = parse_stab_type (dhandle, info, name, &p, &slot, string_end);
1052 if (dtype == DEBUG_TYPE_NULL)
1053 return false;
1054 if (name == NULL)
1055 return true;
1056
1057 /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
1058 a cross reference to itself. These are generated by some
1059 versions of g++. */
1060 self_crossref = info->self_crossref;
1061
1062 dtype = debug_tag_type (dhandle, name, dtype);
1063 if (dtype == DEBUG_TYPE_NULL)
1064 return false;
1065 if (slot != NULL)
1066 *slot = dtype;
1067
1068 /* See if we have a cross reference to this tag which we can now
1069 fill in. Avoid filling in a cross reference to ourselves,
1070 because that would lead to circular debugging information. */
1071 if (! self_crossref)
1072 {
1073 register struct stab_tag **pst;
1074
1075 for (pst = &info->tags; *pst != NULL; pst = &(*pst)->next)
1076 {
1077 if ((*pst)->name[0] == name[0]
1078 && strcmp ((*pst)->name, name) == 0)
1079 {
1080 (*pst)->slot = dtype;
1081 *pst = (*pst)->next;
1082 break;
1083 }
1084 }
1085 }
1086
1087 if (synonym)
1088 {
1089 dtype = debug_name_type (dhandle, name, dtype);
1090 if (dtype == DEBUG_TYPE_NULL)
1091 return false;
1092
1093 if (slot != NULL)
1094 *slot = dtype;
1095 }
1096
1097 break;
1098
1099 case 'V':
1100 /* Static symbol of local scope */
1101 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1102 (debug_type **) NULL, string_end);
1103 if (dtype == DEBUG_TYPE_NULL)
1104 return false;
1105 /* FIXME: gdb checks os9k_stabs here. */
1106 if (! stab_record_variable (dhandle, info, name, dtype,
1107 DEBUG_LOCAL_STATIC, value))
1108 return false;
1109 break;
1110
1111 case 'v':
1112 /* Reference parameter. */
1113 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1114 (debug_type **) NULL, string_end);
1115 if (dtype == DEBUG_TYPE_NULL)
1116 return false;
1117 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REFERENCE,
1118 value))
1119 return false;
1120 break;
1121
1122 case 'a':
1123 /* Reference parameter which is in a register. */
1124 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1125 (debug_type **) NULL, string_end);
1126 if (dtype == DEBUG_TYPE_NULL)
1127 return false;
1128 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REF_REG,
1129 value))
1130 return false;
1131 break;
1132
1133 case 'X':
1134 /* This is used by Sun FORTRAN for "function result value".
1135 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1136 that Pascal uses it too, but when I tried it Pascal used
1137 "x:3" (local symbol) instead. */
1138 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1139 (debug_type **) NULL, string_end);
1140 if (dtype == DEBUG_TYPE_NULL)
1141 return false;
1142 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
1143 value))
1144 return false;
1145 break;
1146
1147 case 'Y':
1148 /* SUNPro C++ Namespace =Yn0. */
1149 /* Skip the namespace mapping, as it is not used now. */
1150 if (*p++ != 0 && *p++ == 'n' && *p++ == '0')
1151 {
1152 /* =Yn0name; */
1153 while (*p && *p != ';')
1154 ++p;
1155 if (*p)
1156 return true;
1157 }
1158 /* TODO SUNPro C++ support:
1159 Support default arguments after F,P parameters
1160 Ya = Anonymous unions
1161 YM,YD = Pointers to class members
1162 YT,YI = Templates
1163 YR = Run-time type information (RTTI) */
1164
1165 /* Fall through. */
1166
1167 default:
1168 bad_stab (string);
1169 return false;
1170 }
1171
1172 /* FIXME: gdb converts structure values to structure pointers in a
1173 couple of cases, depending upon the target. */
1174
1175 return true;
1176 }
1177
1178 /* Parse a stabs type. The typename argument is non-NULL if this is a
1179 typedef or a tag definition. The pp argument points to the stab
1180 string, and is updated. The slotp argument points to a place to
1181 store the slot used if the type is being defined. */
1182
1183 static debug_type
parse_stab_type(void * dhandle,struct stab_handle * info,const char * type_name,const char ** pp,debug_type ** slotp,const char * p_end)1184 parse_stab_type (void * dhandle,
1185 struct stab_handle * info,
1186 const char * type_name,
1187 const char ** pp,
1188 debug_type ** slotp,
1189 const char * p_end)
1190 {
1191 const char *orig;
1192 int typenums[2];
1193 int size;
1194 bool stringp;
1195 int descriptor;
1196 debug_type dtype;
1197
1198 if (slotp != NULL)
1199 *slotp = NULL;
1200
1201 orig = *pp;
1202 if (orig >= p_end)
1203 return DEBUG_TYPE_NULL;
1204
1205 size = -1;
1206 stringp = false;
1207
1208 info->self_crossref = false;
1209
1210 /* Read type number if present. The type number may be omitted.
1211 for instance in a two-dimensional array declared with type
1212 "ar1;1;10;ar1;1;10;4". */
1213 if (! ISDIGIT (**pp) && **pp != '(' && **pp != '-')
1214 {
1215 /* 'typenums=' not present, type is anonymous. Read and return
1216 the definition, but don't put it in the type vector. */
1217 typenums[0] = typenums[1] = -1;
1218 }
1219 else
1220 {
1221 if (! parse_stab_type_number (pp, typenums, p_end))
1222 return DEBUG_TYPE_NULL;
1223
1224 if (**pp != '=')
1225 /* Type is not being defined here. Either it already
1226 exists, or this is a forward reference to it. */
1227 return stab_find_type (dhandle, info, typenums);
1228
1229 /* Only set the slot if the type is being defined. This means
1230 that the mapping from type numbers to types will only record
1231 the name of the typedef which defines a type. If we don't do
1232 this, then something like
1233 typedef int foo;
1234 int i;
1235 will record that i is of type foo. Unfortunately, stabs
1236 information is ambiguous about variable types. For this code,
1237 typedef int foo;
1238 int i;
1239 foo j;
1240 the stabs information records both i and j as having the same
1241 type. This could be fixed by patching the compiler. */
1242 if (slotp != NULL && typenums[0] >= 0 && typenums[1] >= 0)
1243 *slotp = stab_find_slot (dhandle, info, typenums);
1244
1245 /* Type is being defined here. */
1246 /* Skip the '='. */
1247 ++*pp;
1248
1249 while (**pp == '@')
1250 {
1251 const char *p = *pp + 1;
1252 const char *attr;
1253
1254 if (ISDIGIT (*p) || *p == '(' || *p == '-')
1255 /* Member type. */
1256 break;
1257
1258 /* Type attributes. */
1259 attr = p;
1260
1261 for (; *p != ';'; ++p)
1262 {
1263 if (*p == '\0')
1264 {
1265 bad_stab (orig);
1266 return DEBUG_TYPE_NULL;
1267 }
1268 }
1269 *pp = p + 1;
1270
1271 switch (*attr)
1272 {
1273 case 's':
1274 size = atoi (attr + 1);
1275 size /= 8; /* Size is in bits. We store it in bytes. */
1276 if (size <= 0)
1277 size = -1;
1278 break;
1279
1280 case 'S':
1281 stringp = true;
1282 break;
1283
1284 case 0:
1285 bad_stab (orig);
1286 return DEBUG_TYPE_NULL;
1287
1288 default:
1289 /* Ignore unrecognized type attributes, so future
1290 compilers can invent new ones. */
1291 break;
1292 }
1293 }
1294 }
1295
1296 descriptor = **pp;
1297 ++*pp;
1298
1299 switch (descriptor)
1300 {
1301 case 'x':
1302 {
1303 enum debug_type_kind code;
1304 const char *q1, *q2, *p;
1305
1306 /* A cross reference to another type. */
1307 switch (**pp)
1308 {
1309 case 's':
1310 code = DEBUG_KIND_STRUCT;
1311 break;
1312 case 'u':
1313 code = DEBUG_KIND_UNION;
1314 break;
1315 case 'e':
1316 code = DEBUG_KIND_ENUM;
1317 break;
1318 case 0:
1319 bad_stab (orig);
1320 return DEBUG_TYPE_NULL;
1321
1322 default:
1323 /* Complain and keep going, so compilers can invent new
1324 cross-reference types. */
1325 warn_stab (orig, _("unrecognized cross reference type"));
1326 code = DEBUG_KIND_STRUCT;
1327 break;
1328 }
1329 ++*pp;
1330
1331 q1 = strchr (*pp, '<');
1332 p = strchr (*pp, ':');
1333 if (p == NULL)
1334 {
1335 bad_stab (orig);
1336 return DEBUG_TYPE_NULL;
1337 }
1338 if (q1 != NULL && p > q1 && p[1] == ':')
1339 {
1340 int nest = 0;
1341
1342 for (q2 = q1; *q2 != '\0'; ++q2)
1343 {
1344 if (*q2 == '<')
1345 ++nest;
1346 else if (*q2 == '>')
1347 --nest;
1348 else if (*q2 == ':' && nest == 0)
1349 break;
1350 }
1351 p = q2;
1352 if (*p != ':')
1353 {
1354 bad_stab (orig);
1355 return DEBUG_TYPE_NULL;
1356 }
1357 }
1358
1359 /* Some versions of g++ can emit stabs like
1360 fleep:T20=xsfleep:
1361 which define structures in terms of themselves. We need to
1362 tell the caller to avoid building a circular structure. */
1363 if (type_name != NULL
1364 && strncmp (type_name, *pp, p - *pp) == 0
1365 && type_name[p - *pp] == '\0')
1366 info->self_crossref = true;
1367
1368 dtype = stab_find_tagged_type (dhandle, info, *pp, p - *pp, code);
1369
1370 *pp = p + 1;
1371 }
1372 break;
1373
1374 case '-':
1375 case '0':
1376 case '1':
1377 case '2':
1378 case '3':
1379 case '4':
1380 case '5':
1381 case '6':
1382 case '7':
1383 case '8':
1384 case '9':
1385 case '(':
1386 {
1387 const char *hold;
1388 int xtypenums[2];
1389
1390 /* This type is defined as another type. */
1391 (*pp)--;
1392 hold = *pp;
1393
1394 /* Peek ahead at the number to detect void. */
1395 if (! parse_stab_type_number (pp, xtypenums, p_end))
1396 return DEBUG_TYPE_NULL;
1397
1398 if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1])
1399 {
1400 /* This type is being defined as itself, which means that
1401 it is void. */
1402 dtype = debug_make_void_type (dhandle);
1403 }
1404 else
1405 {
1406 *pp = hold;
1407
1408 /* Go back to the number and have parse_stab_type get it.
1409 This means that we can deal with something like
1410 t(1,2)=(3,4)=... which the Lucid compiler uses. */
1411 dtype = parse_stab_type (dhandle, info, (const char *) NULL,
1412 pp, (debug_type **) NULL, p_end);
1413 if (dtype == DEBUG_TYPE_NULL)
1414 return DEBUG_TYPE_NULL;
1415 }
1416
1417 if (typenums[0] != -1)
1418 {
1419 if (! stab_record_type (dhandle, info, typenums, dtype))
1420 return DEBUG_TYPE_NULL;
1421 }
1422
1423 break;
1424 }
1425
1426 case '*':
1427 dtype = debug_make_pointer_type (dhandle,
1428 parse_stab_type (dhandle, info,
1429 (const char *) NULL,
1430 pp,
1431 (debug_type **) NULL,
1432 p_end));
1433 break;
1434
1435 case '&':
1436 /* Reference to another type. */
1437 dtype = (debug_make_reference_type
1438 (dhandle,
1439 parse_stab_type (dhandle, info, (const char *) NULL, pp,
1440 (debug_type **) NULL, p_end)));
1441 break;
1442
1443 case 'f':
1444 /* Function returning another type. */
1445 /* FIXME: gdb checks os9k_stabs here. */
1446 dtype = (debug_make_function_type
1447 (dhandle,
1448 parse_stab_type (dhandle, info, (const char *) NULL, pp,
1449 (debug_type **) NULL, p_end),
1450 (debug_type *) NULL, false));
1451 break;
1452
1453 case 'k':
1454 /* Const qualifier on some type (Sun). */
1455 /* FIXME: gdb accepts 'c' here if os9k_stabs. */
1456 dtype = debug_make_const_type (dhandle,
1457 parse_stab_type (dhandle, info,
1458 (const char *) NULL,
1459 pp,
1460 (debug_type **) NULL,
1461 p_end));
1462 break;
1463
1464 case 'B':
1465 /* Volatile qual on some type (Sun). */
1466 /* FIXME: gdb accepts 'i' here if os9k_stabs. */
1467 dtype = (debug_make_volatile_type
1468 (dhandle,
1469 parse_stab_type (dhandle, info, (const char *) NULL, pp,
1470 (debug_type **) NULL, p_end)));
1471 break;
1472
1473 case '@':
1474 /* Offset (class & variable) type. This is used for a pointer
1475 relative to an object. */
1476 {
1477 debug_type domain;
1478 debug_type memtype;
1479
1480 /* Member type. */
1481
1482 domain = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1483 (debug_type **) NULL, p_end);
1484 if (domain == DEBUG_TYPE_NULL)
1485 return DEBUG_TYPE_NULL;
1486
1487 if (**pp != ',')
1488 {
1489 bad_stab (orig);
1490 return DEBUG_TYPE_NULL;
1491 }
1492 ++*pp;
1493
1494 memtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1495 (debug_type **) NULL, p_end);
1496 if (memtype == DEBUG_TYPE_NULL)
1497 return DEBUG_TYPE_NULL;
1498
1499 dtype = debug_make_offset_type (dhandle, domain, memtype);
1500 }
1501 break;
1502
1503 case '#':
1504 /* Method (class & fn) type. */
1505 if (**pp == '#')
1506 {
1507 debug_type return_type;
1508
1509 ++*pp;
1510 return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1511 pp, (debug_type **) NULL, p_end);
1512 if (return_type == DEBUG_TYPE_NULL)
1513 return DEBUG_TYPE_NULL;
1514 if (**pp != ';')
1515 {
1516 bad_stab (orig);
1517 return DEBUG_TYPE_NULL;
1518 }
1519 ++*pp;
1520 dtype = debug_make_method_type (dhandle, return_type,
1521 DEBUG_TYPE_NULL,
1522 (debug_type *) NULL, false);
1523 }
1524 else
1525 {
1526 debug_type domain;
1527 debug_type return_type;
1528 debug_type *args, *xargs;
1529 unsigned int n;
1530 unsigned int alloc;
1531 bool varargs;
1532
1533 domain = parse_stab_type (dhandle, info, (const char *) NULL,
1534 pp, (debug_type **) NULL, p_end);
1535 if (domain == DEBUG_TYPE_NULL)
1536 return DEBUG_TYPE_NULL;
1537
1538 if (**pp != ',')
1539 {
1540 bad_stab (orig);
1541 return DEBUG_TYPE_NULL;
1542 }
1543 ++*pp;
1544
1545 return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1546 pp, (debug_type **) NULL, p_end);
1547 if (return_type == DEBUG_TYPE_NULL)
1548 return DEBUG_TYPE_NULL;
1549
1550 alloc = 10;
1551 args = xmalloc (alloc * sizeof (*args));
1552 n = 0;
1553 while (**pp != ';')
1554 {
1555 if (**pp != ',')
1556 {
1557 bad_stab (orig);
1558 free (args);
1559 return DEBUG_TYPE_NULL;
1560 }
1561 ++*pp;
1562
1563 if (n + 1 >= alloc)
1564 {
1565 alloc += 10;
1566 args = xrealloc (args, alloc * sizeof (*args));
1567 }
1568
1569 args[n] = parse_stab_type (dhandle, info, (const char *) NULL,
1570 pp, (debug_type **) NULL, p_end);
1571 if (args[n] == DEBUG_TYPE_NULL)
1572 {
1573 free (args);
1574 return DEBUG_TYPE_NULL;
1575 }
1576 ++n;
1577 }
1578 ++*pp;
1579
1580 /* If the last type is not void, then this function takes a
1581 variable number of arguments. Otherwise, we must strip
1582 the void type. */
1583 if (n == 0
1584 || debug_get_type_kind (dhandle, args[n - 1]) != DEBUG_KIND_VOID)
1585 varargs = true;
1586 else
1587 {
1588 --n;
1589 varargs = false;
1590 }
1591
1592 args[n] = DEBUG_TYPE_NULL;
1593 xargs = debug_xalloc (dhandle, (n + 1) * sizeof (*args));
1594 memcpy (xargs, args, (n + 1) * sizeof (*args));
1595 free (args);
1596
1597 dtype = debug_make_method_type (dhandle, return_type, domain, xargs,
1598 varargs);
1599 }
1600 break;
1601
1602 case 'r':
1603 /* Range type. */
1604 dtype = parse_stab_range_type (dhandle, info, type_name, pp, typenums, p_end);
1605 break;
1606
1607 case 'b':
1608 /* FIXME: gdb checks os9k_stabs here. */
1609 /* Sun ACC builtin int type. */
1610 dtype = parse_stab_sun_builtin_type (dhandle, pp, p_end);
1611 break;
1612
1613 case 'R':
1614 /* Sun ACC builtin float type. */
1615 dtype = parse_stab_sun_floating_type (dhandle, pp, p_end);
1616 break;
1617
1618 case 'e':
1619 /* Enumeration type. */
1620 dtype = parse_stab_enum_type (dhandle, pp, p_end);
1621 break;
1622
1623 case 's':
1624 case 'u':
1625 /* Struct or union type. */
1626 dtype = parse_stab_struct_type (dhandle, info, type_name, pp,
1627 descriptor == 's', typenums, p_end);
1628 break;
1629
1630 case 'a':
1631 /* Array type. */
1632 if (**pp != 'r')
1633 {
1634 bad_stab (orig);
1635 return DEBUG_TYPE_NULL;
1636 }
1637 ++*pp;
1638
1639 dtype = parse_stab_array_type (dhandle, info, pp, stringp, p_end);
1640 break;
1641
1642 case 'S':
1643 dtype = debug_make_set_type (dhandle,
1644 parse_stab_type (dhandle, info,
1645 (const char *) NULL,
1646 pp,
1647 (debug_type **) NULL,
1648 p_end),
1649 stringp);
1650 break;
1651
1652 default:
1653 bad_stab (orig);
1654 return DEBUG_TYPE_NULL;
1655 }
1656
1657 if (dtype == DEBUG_TYPE_NULL)
1658 return DEBUG_TYPE_NULL;
1659
1660 if (typenums[0] != -1)
1661 {
1662 if (! stab_record_type (dhandle, info, typenums, dtype))
1663 return DEBUG_TYPE_NULL;
1664 }
1665
1666 if (size != -1)
1667 {
1668 if (! debug_record_type_size (dhandle, dtype, (unsigned int) size))
1669 return DEBUG_TYPE_NULL;
1670 }
1671
1672 return dtype;
1673 }
1674
1675 /* Read a number by which a type is referred to in dbx data, or
1676 perhaps read a pair (FILENUM, TYPENUM) in parentheses. Just a
1677 single number N is equivalent to (0,N). Return the two numbers by
1678 storing them in the vector TYPENUMS. */
1679
1680 static bool
parse_stab_type_number(const char ** pp,int * typenums,const char * p_end)1681 parse_stab_type_number (const char **pp, int *typenums, const char *p_end)
1682 {
1683 const char *orig;
1684
1685 orig = *pp;
1686
1687 if (**pp != '(')
1688 {
1689 typenums[0] = 0;
1690 typenums[1] = (int) parse_number (pp, (bool *) NULL, p_end);
1691 return true;
1692 }
1693
1694 ++*pp;
1695 typenums[0] = (int) parse_number (pp, (bool *) NULL, p_end);
1696 if (**pp != ',')
1697 {
1698 bad_stab (orig);
1699 return false;
1700 }
1701
1702 ++*pp;
1703 typenums[1] = (int) parse_number (pp, (bool *) NULL, p_end);
1704 if (**pp != ')')
1705 {
1706 bad_stab (orig);
1707 return false;
1708 }
1709
1710 ++*pp;
1711 return true;
1712 }
1713
1714 /* Parse a range type. */
1715
1716 static debug_type
parse_stab_range_type(void * dhandle,struct stab_handle * info,const char * type_name,const char ** pp,const int * typenums,const char * p_end)1717 parse_stab_range_type (void * dhandle,
1718 struct stab_handle * info,
1719 const char * type_name,
1720 const char ** pp,
1721 const int * typenums,
1722 const char * p_end)
1723 {
1724 const char *orig;
1725 int rangenums[2];
1726 bool self_subrange;
1727 debug_type index_type;
1728 const char *s2, *s3;
1729 bfd_signed_vma n2, n3;
1730 bool ov2, ov3;
1731
1732 orig = *pp;
1733 if (orig >= p_end)
1734 return DEBUG_TYPE_NULL;
1735
1736 index_type = DEBUG_TYPE_NULL;
1737
1738 /* First comes a type we are a subrange of.
1739 In C it is usually 0, 1 or the type being defined. */
1740 if (! parse_stab_type_number (pp, rangenums, p_end))
1741 return DEBUG_TYPE_NULL;
1742
1743 self_subrange = (rangenums[0] == typenums[0]
1744 && rangenums[1] == typenums[1]);
1745
1746 if (**pp == '=')
1747 {
1748 *pp = orig;
1749 index_type = parse_stab_type (dhandle, info, (const char *) NULL,
1750 pp, (debug_type **) NULL, p_end);
1751 if (index_type == DEBUG_TYPE_NULL)
1752 return DEBUG_TYPE_NULL;
1753 }
1754
1755 if (**pp == ';')
1756 ++*pp;
1757
1758 /* The remaining two operands are usually lower and upper bounds of
1759 the range. But in some special cases they mean something else. */
1760 s2 = *pp;
1761 n2 = parse_number (pp, &ov2, p_end);
1762 if (**pp != ';')
1763 {
1764 bad_stab (orig);
1765 return DEBUG_TYPE_NULL;
1766 }
1767 ++*pp;
1768
1769 s3 = *pp;
1770 n3 = parse_number (pp, &ov3, p_end);
1771 if (**pp != ';')
1772 {
1773 bad_stab (orig);
1774 return DEBUG_TYPE_NULL;
1775 }
1776 ++*pp;
1777
1778 if (ov2 || ov3)
1779 {
1780 /* gcc will emit range stabs for long long types. Handle this
1781 as a special case. FIXME: This needs to be more general. */
1782 #define LLLOW "01000000000000000000000;"
1783 #define LLHIGH "0777777777777777777777;"
1784 #define ULLHIGH "01777777777777777777777;"
1785 if (index_type == DEBUG_TYPE_NULL)
1786 {
1787 if (startswith (s2, LLLOW)
1788 && startswith (s3, LLHIGH))
1789 return debug_make_int_type (dhandle, 8, false);
1790 if (! ov2
1791 && n2 == 0
1792 && startswith (s3, ULLHIGH))
1793 return debug_make_int_type (dhandle, 8, true);
1794 }
1795
1796 warn_stab (orig, _("numeric overflow"));
1797 }
1798
1799 if (index_type == DEBUG_TYPE_NULL)
1800 {
1801 /* A type defined as a subrange of itself, with both bounds 0,
1802 is void. */
1803 if (self_subrange && n2 == 0 && n3 == 0)
1804 return debug_make_void_type (dhandle);
1805
1806 /* A type defined as a subrange of itself, with n2 positive and
1807 n3 zero, is a complex type, and n2 is the number of bytes. */
1808 if (self_subrange && n3 == 0 && n2 > 0)
1809 return debug_make_complex_type (dhandle, n2);
1810
1811 /* If n3 is zero and n2 is positive, this is a floating point
1812 type, and n2 is the number of bytes. */
1813 if (n3 == 0 && n2 > 0)
1814 return debug_make_float_type (dhandle, n2);
1815
1816 /* If the upper bound is -1, this is an unsigned int. */
1817 if (n2 == 0 && n3 == -1)
1818 {
1819 /* When gcc is used with -gstabs, but not -gstabs+, it will emit
1820 long long int:t6=r1;0;-1;
1821 long long unsigned int:t7=r1;0;-1;
1822 We hack here to handle this reasonably. */
1823 if (type_name != NULL)
1824 {
1825 if (strcmp (type_name, "long long int") == 0)
1826 return debug_make_int_type (dhandle, 8, false);
1827 else if (strcmp (type_name, "long long unsigned int") == 0)
1828 return debug_make_int_type (dhandle, 8, true);
1829 }
1830 /* FIXME: The size here really depends upon the target. */
1831 return debug_make_int_type (dhandle, 4, true);
1832 }
1833
1834 /* A range of 0 to 127 is char. */
1835 if (self_subrange && n2 == 0 && n3 == 127)
1836 return debug_make_int_type (dhandle, 1, false);
1837
1838 /* FIXME: gdb checks for the language CHILL here. */
1839
1840 if (n2 == 0)
1841 {
1842 if (n3 < 0)
1843 return debug_make_int_type (dhandle, - n3, true);
1844 else if (n3 == 0xff)
1845 return debug_make_int_type (dhandle, 1, true);
1846 else if (n3 == 0xffff)
1847 return debug_make_int_type (dhandle, 2, true);
1848 else if (n3 == (bfd_signed_vma) 0xffffffff)
1849 return debug_make_int_type (dhandle, 4, true);
1850 #ifdef BFD64
1851 else if (n3 == (bfd_signed_vma) 0xffffffffffffffffLL)
1852 return debug_make_int_type (dhandle, 8, true);
1853 #endif
1854 }
1855 else if (n3 == 0
1856 && n2 < 0
1857 && (self_subrange || n2 == -8))
1858 return debug_make_int_type (dhandle, - n2, true);
1859 else if (n2 == - n3 - 1 || n2 == n3 + 1)
1860 {
1861 if (n3 == 0x7f)
1862 return debug_make_int_type (dhandle, 1, false);
1863 else if (n3 == 0x7fff)
1864 return debug_make_int_type (dhandle, 2, false);
1865 else if (n3 == 0x7fffffff)
1866 return debug_make_int_type (dhandle, 4, false);
1867 #ifdef BFD64
1868 else if (n3 == ((((bfd_vma) 0x7fffffff) << 32) | 0xffffffff))
1869 return debug_make_int_type (dhandle, 8, false);
1870 #endif
1871 }
1872 }
1873
1874 /* At this point I don't have the faintest idea how to deal with a
1875 self_subrange type; I'm going to assume that this is used as an
1876 idiom, and that all of them are special cases. So . . . */
1877 if (self_subrange)
1878 {
1879 bad_stab (orig);
1880 return DEBUG_TYPE_NULL;
1881 }
1882
1883 index_type = stab_find_type (dhandle, info, rangenums);
1884 if (index_type == DEBUG_TYPE_NULL)
1885 {
1886 /* Does this actually ever happen? Is that why we are worrying
1887 about dealing with it rather than just calling error_type? */
1888 warn_stab (orig, _("missing index type"));
1889 index_type = debug_make_int_type (dhandle, 4, false);
1890 }
1891
1892 return debug_make_range_type (dhandle, index_type, n2, n3);
1893 }
1894
1895 /* Sun's ACC uses a somewhat saner method for specifying the builtin
1896 typedefs in every file (for int, long, etc):
1897
1898 type = b <signed> <width>; <offset>; <nbits>
1899 signed = u or s. Possible c in addition to u or s (for char?).
1900 offset = offset from high order bit to start bit of type.
1901 width is # bytes in object of this type, nbits is # bits in type.
1902
1903 The width/offset stuff appears to be for small objects stored in
1904 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
1905 FIXME. */
1906
1907 static debug_type
parse_stab_sun_builtin_type(void * dhandle,const char ** pp,const char * p_end)1908 parse_stab_sun_builtin_type (void *dhandle, const char **pp, const char * p_end)
1909 {
1910 const char *orig;
1911 bool unsignedp;
1912 bfd_vma bits;
1913
1914 orig = *pp;
1915 if (orig >= p_end)
1916 return DEBUG_TYPE_NULL;
1917
1918 switch (**pp)
1919 {
1920 case 's':
1921 unsignedp = false;
1922 break;
1923 case 'u':
1924 unsignedp = true;
1925 break;
1926 default:
1927 bad_stab (orig);
1928 return DEBUG_TYPE_NULL;
1929 }
1930 ++*pp;
1931
1932 /* OpenSolaris source code indicates that one of "cbv" characters
1933 can come next and specify the intrinsic 'iformat' encoding.
1934 'c' is character encoding, 'b' is boolean encoding, and 'v' is
1935 varargs encoding. This field can be safely ignored because
1936 the type of the field is determined from the bitwidth extracted
1937 below. */
1938 if (**pp == 'c' || **pp == 'b' || **pp == 'v')
1939 ++*pp;
1940
1941 /* The first number appears to be the number of bytes occupied
1942 by this type, except that unsigned short is 4 instead of 2.
1943 Since this information is redundant with the third number,
1944 we will ignore it. */
1945 (void) parse_number (pp, (bool *) NULL, p_end);
1946 if (**pp != ';')
1947 {
1948 bad_stab (orig);
1949 return DEBUG_TYPE_NULL;
1950 }
1951 ++*pp;
1952
1953 /* The second number is always 0, so ignore it too. */
1954 (void) parse_number (pp, (bool *) NULL, p_end);
1955 if (**pp != ';')
1956 {
1957 bad_stab (orig);
1958 return DEBUG_TYPE_NULL;
1959 }
1960 ++*pp;
1961
1962 /* The third number is the number of bits for this type. */
1963 bits = parse_number (pp, (bool *) NULL, p_end);
1964
1965 /* The type *should* end with a semicolon. If it are embedded
1966 in a larger type the semicolon may be the only way to know where
1967 the type ends. If this type is at the end of the stabstring we
1968 can deal with the omitted semicolon (but we don't have to like
1969 it). Don't bother to complain(), Sun's compiler omits the semicolon
1970 for "void". */
1971 if (**pp == ';')
1972 ++*pp;
1973
1974 if (bits == 0)
1975 return debug_make_void_type (dhandle);
1976
1977 return debug_make_int_type (dhandle, bits / 8, unsignedp);
1978 }
1979
1980 /* Parse a builtin floating type generated by the Sun compiler. */
1981
1982 static debug_type
parse_stab_sun_floating_type(void * dhandle,const char ** pp,const char * p_end)1983 parse_stab_sun_floating_type (void *dhandle, const char **pp, const char *p_end)
1984 {
1985 const char *orig;
1986 bfd_vma details;
1987 bfd_vma bytes;
1988
1989 orig = *pp;
1990 if (orig >= p_end)
1991 return DEBUG_TYPE_NULL;
1992
1993 /* The first number has more details about the type, for example
1994 FN_COMPLEX. */
1995 details = parse_number (pp, (bool *) NULL, p_end);
1996 if (**pp != ';')
1997 {
1998 bad_stab (orig);
1999 return DEBUG_TYPE_NULL;
2000 }
2001
2002 /* The second number is the number of bytes occupied by this type */
2003 bytes = parse_number (pp, (bool *) NULL, p_end);
2004 if (**pp != ';')
2005 {
2006 bad_stab (orig);
2007 return DEBUG_TYPE_NULL;
2008 }
2009
2010 if (details == NF_COMPLEX
2011 || details == NF_COMPLEX16
2012 || details == NF_COMPLEX32)
2013 return debug_make_complex_type (dhandle, bytes);
2014
2015 return debug_make_float_type (dhandle, bytes);
2016 }
2017
2018 /* Handle an enum type. */
2019
2020 static debug_type
parse_stab_enum_type(void * dhandle,const char ** pp,const char * p_end)2021 parse_stab_enum_type (void *dhandle, const char **pp, const char * p_end)
2022 {
2023 const char *orig;
2024 const char **names, **xnames;
2025 bfd_signed_vma *values, *xvalues;
2026 unsigned int n;
2027 unsigned int alloc;
2028
2029 orig = *pp;
2030 if (orig >= p_end)
2031 return DEBUG_TYPE_NULL;
2032
2033 /* FIXME: gdb checks os9k_stabs here. */
2034
2035 /* The aix4 compiler emits an extra field before the enum members;
2036 my guess is it's a type of some sort. Just ignore it. */
2037 if (**pp == '-')
2038 {
2039 while (**pp != ':' && **pp != 0)
2040 ++*pp;
2041
2042 if (**pp == 0)
2043 {
2044 bad_stab (orig);
2045 return DEBUG_TYPE_NULL;
2046 }
2047 ++*pp;
2048 }
2049
2050 /* Read the value-names and their values.
2051 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2052 A semicolon or comma instead of a NAME means the end. */
2053 alloc = 10;
2054 names = xmalloc (alloc * sizeof (*names));
2055 values = xmalloc (alloc * sizeof (*values));
2056 n = 0;
2057 while (**pp != '\0' && **pp != ';' && **pp != ',')
2058 {
2059 const char *p;
2060 char *name;
2061 bfd_signed_vma val;
2062
2063 p = *pp;
2064 while (*p != ':' && *p != 0)
2065 ++p;
2066
2067 if (*p == 0)
2068 {
2069 bad_stab (orig);
2070 free (names);
2071 free (values);
2072 return DEBUG_TYPE_NULL;
2073 }
2074
2075 name = savestring (dhandle, *pp, p - *pp);
2076
2077 *pp = p + 1;
2078 val = (bfd_signed_vma) parse_number (pp, (bool *) NULL, p_end);
2079 if (**pp != ',')
2080 {
2081 bad_stab (orig);
2082 free (names);
2083 free (values);
2084 return DEBUG_TYPE_NULL;
2085 }
2086 ++*pp;
2087
2088 if (n + 1 >= alloc)
2089 {
2090 alloc += 10;
2091 names = xrealloc (names, alloc * sizeof (*names));
2092 values = xrealloc (values, alloc * sizeof (*values));
2093 }
2094
2095 names[n] = name;
2096 values[n] = val;
2097 ++n;
2098 }
2099
2100 names[n] = NULL;
2101 values[n] = 0;
2102 xnames = debug_xalloc (dhandle, (n + 1) * sizeof (*names));
2103 memcpy (xnames, names, (n + 1) * sizeof (*names));
2104 free (names);
2105 xvalues = debug_xalloc (dhandle, (n + 1) * sizeof (*names));
2106 memcpy (xvalues, values, (n + 1) * sizeof (*names));
2107 free (values);
2108
2109 if (**pp == ';')
2110 ++*pp;
2111
2112 return debug_make_enum_type (dhandle, xnames, xvalues);
2113 }
2114
2115 /* Read the description of a structure (or union type) and return an object
2116 describing the type.
2117
2118 PP points to a character pointer that points to the next unconsumed token
2119 in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
2120 *PP will point to "4a:1,0,32;;". */
2121
2122 static debug_type
parse_stab_struct_type(void * dhandle,struct stab_handle * info,const char * tagname,const char ** pp,bool structp,const int * typenums,const char * p_end)2123 parse_stab_struct_type (void *dhandle,
2124 struct stab_handle *info,
2125 const char *tagname,
2126 const char **pp,
2127 bool structp,
2128 const int *typenums,
2129 const char *p_end)
2130 {
2131 bfd_vma size;
2132 debug_baseclass *baseclasses;
2133 debug_field *fields = NULL;
2134 bool statics;
2135 debug_method *methods;
2136 debug_type vptrbase;
2137 bool ownvptr;
2138
2139 /* Get the size. */
2140 size = parse_number (pp, (bool *) NULL, p_end);
2141
2142 /* Get the other information. */
2143 if (! parse_stab_baseclasses (dhandle, info, pp, &baseclasses, p_end)
2144 || ! parse_stab_struct_fields (dhandle, info, pp, &fields, &statics, p_end)
2145 || ! parse_stab_members (dhandle, info, tagname, pp, typenums, &methods, p_end)
2146 || ! parse_stab_tilde_field (dhandle, info, pp, typenums, &vptrbase,
2147 &ownvptr, p_end))
2148 return DEBUG_TYPE_NULL;
2149
2150 if (! statics
2151 && baseclasses == NULL
2152 && methods == NULL
2153 && vptrbase == DEBUG_TYPE_NULL
2154 && ! ownvptr)
2155 return debug_make_struct_type (dhandle, structp, size, fields);
2156
2157 return debug_make_object_type (dhandle, structp, size, fields, baseclasses,
2158 methods, vptrbase, ownvptr);
2159 }
2160
2161 /* The stabs for C++ derived classes contain baseclass information which
2162 is marked by a '!' character after the total size. This function is
2163 called when we encounter the baseclass marker, and slurps up all the
2164 baseclass information.
2165
2166 Immediately following the '!' marker is the number of base classes that
2167 the class is derived from, followed by information for each base class.
2168 For each base class, there are two visibility specifiers, a bit offset
2169 to the base class information within the derived class, a reference to
2170 the type for the base class, and a terminating semicolon.
2171
2172 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2173 ^^ ^ ^ ^ ^ ^ ^
2174 Baseclass information marker __________________|| | | | | | |
2175 Number of baseclasses __________________________| | | | | | |
2176 Visibility specifiers (2) ________________________| | | | | |
2177 Offset in bits from start of class _________________| | | | |
2178 Type number for base class ___________________________| | | |
2179 Visibility specifiers (2) _______________________________| | |
2180 Offset in bits from start of class ________________________| |
2181 Type number of base class ____________________________________|
2182
2183 Return TRUE for success, FALSE for failure. */
2184
2185 static bool
parse_stab_baseclasses(void * dhandle,struct stab_handle * info,const char ** pp,debug_baseclass ** retp,const char * p_end)2186 parse_stab_baseclasses (void * dhandle,
2187 struct stab_handle * info,
2188 const char ** pp,
2189 debug_baseclass ** retp,
2190 const char * p_end)
2191 {
2192 const char *orig;
2193 unsigned int c, i;
2194 debug_baseclass *classes;
2195
2196 *retp = NULL;
2197
2198 orig = *pp;
2199 if (orig >= p_end)
2200 return false;
2201
2202 if (**pp != '!')
2203 {
2204 /* No base classes. */
2205 return true;
2206 }
2207 ++*pp;
2208
2209 c = (unsigned int) parse_number (pp, (bool *) NULL, p_end);
2210
2211 if (**pp != ',')
2212 {
2213 bad_stab (orig);
2214 return false;
2215 }
2216 ++*pp;
2217
2218 classes = debug_xalloc (dhandle, (c + 1) * sizeof (*classes));
2219
2220 for (i = 0; i < c; i++)
2221 {
2222 bool is_virtual;
2223 enum debug_visibility visibility;
2224 bfd_vma bitpos;
2225 debug_type type;
2226
2227 switch (**pp)
2228 {
2229 case '0':
2230 is_virtual = false;
2231 break;
2232 case '1':
2233 is_virtual = true;
2234 break;
2235 case 0:
2236 bad_stab (orig);
2237 return false;
2238 default:
2239 warn_stab (orig, _("unknown virtual character for baseclass"));
2240 is_virtual = false;
2241 break;
2242 }
2243 ++*pp;
2244
2245 switch (**pp)
2246 {
2247 case '0':
2248 visibility = DEBUG_VISIBILITY_PRIVATE;
2249 break;
2250 case '1':
2251 visibility = DEBUG_VISIBILITY_PROTECTED;
2252 break;
2253 case '2':
2254 visibility = DEBUG_VISIBILITY_PUBLIC;
2255 break;
2256 case 0:
2257 bad_stab (orig);
2258 return false;
2259 default:
2260 warn_stab (orig, _("unknown visibility character for baseclass"));
2261 visibility = DEBUG_VISIBILITY_PUBLIC;
2262 break;
2263 }
2264 ++*pp;
2265
2266 /* The remaining value is the bit offset of the portion of the
2267 object corresponding to this baseclass. Always zero in the
2268 absence of multiple inheritance. */
2269 bitpos = parse_number (pp, (bool *) NULL, p_end);
2270 if (**pp != ',')
2271 {
2272 bad_stab (orig);
2273 return false;
2274 }
2275 ++*pp;
2276
2277 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2278 (debug_type **) NULL, p_end);
2279 if (type == DEBUG_TYPE_NULL)
2280 return false;
2281
2282 classes[i] = debug_make_baseclass (dhandle, type, bitpos, is_virtual,
2283 visibility);
2284 if (classes[i] == DEBUG_BASECLASS_NULL)
2285 return false;
2286
2287 if (**pp != ';')
2288 return false;
2289 ++*pp;
2290 }
2291
2292 classes[i] = DEBUG_BASECLASS_NULL;
2293
2294 *retp = classes;
2295
2296 return true;
2297 }
2298
2299 /* Read struct or class data fields. They have the form:
2300
2301 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2302
2303 At the end, we see a semicolon instead of a field.
2304
2305 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2306 a static field.
2307
2308 The optional VISIBILITY is one of:
2309
2310 '/0' (VISIBILITY_PRIVATE)
2311 '/1' (VISIBILITY_PROTECTED)
2312 '/2' (VISIBILITY_PUBLIC)
2313 '/9' (VISIBILITY_IGNORE)
2314
2315 or nothing, for C style fields with public visibility.
2316
2317 Returns 1 for success, 0 for failure. */
2318
2319 static bool
parse_stab_struct_fields(void * dhandle,struct stab_handle * info,const char ** pp,debug_field ** retp,bool * staticsp,const char * p_end)2320 parse_stab_struct_fields (void *dhandle,
2321 struct stab_handle *info,
2322 const char **pp,
2323 debug_field **retp,
2324 bool *staticsp,
2325 const char * p_end)
2326 {
2327 const char *orig;
2328 const char *p;
2329 debug_field *fields, *xfields;
2330 unsigned int c;
2331 unsigned int alloc;
2332
2333 *retp = NULL;
2334 *staticsp = false;
2335
2336 orig = *pp;
2337 if (orig >= p_end)
2338 return false;
2339
2340 c = 0;
2341 alloc = 10;
2342 fields = xmalloc (alloc * sizeof (*fields));
2343 while (**pp != ';')
2344 {
2345 /* FIXME: gdb checks os9k_stabs here. */
2346
2347 p = *pp;
2348
2349 /* Add 1 to c to leave room for NULL pointer at end. */
2350 if (c + 1 >= alloc)
2351 {
2352 alloc += 10;
2353 fields = xrealloc (fields, alloc * sizeof (*fields));
2354 }
2355
2356 /* If it starts with CPLUS_MARKER it is a special abbreviation,
2357 unless the CPLUS_MARKER is followed by an underscore, in
2358 which case it is just the name of an anonymous type, which we
2359 should handle like any other type name. We accept either '$'
2360 or '.', because a field name can never contain one of these
2361 characters except as a CPLUS_MARKER. */
2362
2363 if ((*p == '$' || *p == '.') && p[1] != '_')
2364 {
2365 ++*pp;
2366 if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c, p_end))
2367 {
2368 free (fields);
2369 return false;
2370 }
2371 ++c;
2372 continue;
2373 }
2374
2375 /* Look for the ':' that separates the field name from the field
2376 values. Data members are delimited by a single ':', while member
2377 functions are delimited by a pair of ':'s. When we hit the member
2378 functions (if any), terminate scan loop and return. */
2379
2380 p = strchr (p, ':');
2381 if (p == NULL)
2382 {
2383 bad_stab (orig);
2384 free (fields);
2385 return false;
2386 }
2387
2388 if (p[1] == ':')
2389 break;
2390
2391 if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c,
2392 staticsp, p_end))
2393 {
2394 free (fields);
2395 return false;
2396 }
2397
2398 ++c;
2399 }
2400
2401 fields[c] = DEBUG_FIELD_NULL;
2402 xfields = debug_xalloc (dhandle, (c + 1) * sizeof (*fields));
2403 memcpy (xfields, fields, (c + 1) * sizeof (*fields));
2404 free (fields);
2405
2406 *retp = xfields;
2407
2408 return true;
2409 }
2410
2411 /* Special GNU C++ name. */
2412
2413 static bool
parse_stab_cpp_abbrev(void * dhandle,struct stab_handle * info,const char ** pp,debug_field * retp,const char * p_end)2414 parse_stab_cpp_abbrev (void * dhandle,
2415 struct stab_handle * info,
2416 const char ** pp,
2417 debug_field * retp,
2418 const char * p_end)
2419 {
2420 const char *orig;
2421 int cpp_abbrev;
2422 debug_type context;
2423 const char *name;
2424 const char *type_name;
2425 debug_type type;
2426 bfd_vma bitpos;
2427 size_t len;
2428
2429 *retp = DEBUG_FIELD_NULL;
2430
2431 orig = *pp;
2432 if (orig >= p_end)
2433 return false;
2434
2435 if (**pp != 'v')
2436 {
2437 bad_stab (*pp);
2438 return false;
2439 }
2440 ++*pp;
2441
2442 cpp_abbrev = **pp;
2443 if (cpp_abbrev == 0)
2444 {
2445 bad_stab (orig);
2446 return false;
2447 }
2448 ++*pp;
2449
2450 /* At this point, *pp points to something like "22:23=*22...", where
2451 the type number before the ':' is the "context" and everything
2452 after is a regular type definition. Lookup the type, find it's
2453 name, and construct the field name. */
2454
2455 context = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2456 (debug_type **) NULL, p_end);
2457 if (context == DEBUG_TYPE_NULL)
2458 return false;
2459
2460 switch (cpp_abbrev)
2461 {
2462 case 'f':
2463 /* $vf -- a virtual function table pointer. */
2464 name = "_vptr$";
2465 break;
2466 case 'b':
2467 /* $vb -- a virtual bsomethingorother */
2468 type_name = debug_get_type_name (dhandle, context);
2469 if (type_name == NULL)
2470 {
2471 warn_stab (orig, _("unnamed $vb type"));
2472 type_name = "FOO";
2473 }
2474 len = strlen (type_name);
2475 name = debug_xalloc (dhandle, len + sizeof ("_vb$"));
2476 memcpy ((char *) name, "_vb$", sizeof ("_vb$") - 1);
2477 memcpy ((char *) name + sizeof ("_vb$") - 1, type_name, len + 1);
2478 break;
2479 default:
2480 warn_stab (orig, _("unrecognized C++ abbreviation"));
2481 name = "INVALID_CPLUSPLUS_ABBREV";
2482 break;
2483 }
2484
2485 if (**pp != ':')
2486 {
2487 bad_stab (orig);
2488 return false;
2489 }
2490 ++*pp;
2491
2492 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2493 (debug_type **) NULL, p_end);
2494 if (**pp != ',')
2495 {
2496 bad_stab (orig);
2497 return false;
2498 }
2499 ++*pp;
2500
2501 bitpos = parse_number (pp, (bool *) NULL, p_end);
2502 if (**pp != ';')
2503 {
2504 bad_stab (orig);
2505 return false;
2506 }
2507 ++*pp;
2508
2509 *retp = debug_make_field (dhandle, name, type, bitpos, 0,
2510 DEBUG_VISIBILITY_PRIVATE);
2511 if (*retp == DEBUG_FIELD_NULL)
2512 return false;
2513
2514 return true;
2515 }
2516
2517 /* Parse a single field in a struct or union. */
2518
2519 static bool
parse_stab_one_struct_field(void * dhandle,struct stab_handle * info,const char ** pp,const char * p,debug_field * retp,bool * staticsp,const char * p_end)2520 parse_stab_one_struct_field (void *dhandle,
2521 struct stab_handle *info,
2522 const char **pp,
2523 const char *p,
2524 debug_field *retp,
2525 bool *staticsp,
2526 const char *p_end)
2527 {
2528 const char *orig;
2529 char *name;
2530 enum debug_visibility visibility;
2531 debug_type type;
2532 bfd_vma bitpos;
2533 bfd_vma bitsize;
2534
2535 orig = *pp;
2536 if (orig >= p_end)
2537 return false;
2538
2539 /* FIXME: gdb checks ARM_DEMANGLING here. */
2540
2541 name = savestring (dhandle, *pp, p - *pp);
2542
2543 *pp = p + 1;
2544
2545 if (**pp != '/')
2546 visibility = DEBUG_VISIBILITY_PUBLIC;
2547 else
2548 {
2549 ++*pp;
2550 switch (**pp)
2551 {
2552 case '0':
2553 visibility = DEBUG_VISIBILITY_PRIVATE;
2554 break;
2555 case '1':
2556 visibility = DEBUG_VISIBILITY_PROTECTED;
2557 break;
2558 case '2':
2559 visibility = DEBUG_VISIBILITY_PUBLIC;
2560 break;
2561 case 0:
2562 bad_stab (orig);
2563 return false;
2564 default:
2565 warn_stab (orig, _("unknown visibility character for field"));
2566 visibility = DEBUG_VISIBILITY_PUBLIC;
2567 break;
2568 }
2569 ++*pp;
2570 }
2571
2572 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2573 (debug_type **) NULL, p_end);
2574 if (type == DEBUG_TYPE_NULL)
2575 return false;
2576
2577 if (**pp == ':')
2578 {
2579 char *varname;
2580
2581 /* This is a static class member. */
2582 ++*pp;
2583 p = strchr (*pp, ';');
2584 if (p == NULL)
2585 {
2586 bad_stab (orig);
2587 return false;
2588 }
2589
2590 varname = savestring (dhandle, *pp, p - *pp);
2591
2592 *pp = p + 1;
2593
2594 *retp = debug_make_static_member (dhandle, name, type, varname,
2595 visibility);
2596 *staticsp = true;
2597
2598 return true;
2599 }
2600
2601 if (**pp != ',')
2602 {
2603 bad_stab (orig);
2604 return false;
2605 }
2606 ++*pp;
2607
2608 bitpos = parse_number (pp, (bool *) NULL, p_end);
2609 if (**pp != ',')
2610 {
2611 bad_stab (orig);
2612 return false;
2613 }
2614 ++*pp;
2615
2616 bitsize = parse_number (pp, (bool *) NULL, p_end);
2617 if (**pp != ';')
2618 {
2619 bad_stab (orig);
2620 return false;
2621 }
2622 ++*pp;
2623
2624 if (bitpos == 0 && bitsize == 0)
2625 {
2626 /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2627 so, it is a field which has been optimized out. The correct
2628 stab for this case is to use VISIBILITY_IGNORE, but that is a
2629 recent invention. (2) It is a 0-size array. For example
2630 union { int num; char str[0]; } foo. Printing "<no value>"
2631 for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2632 will continue to work, and a 0-size array as a whole doesn't
2633 have any contents to print.
2634
2635 I suspect this probably could also happen with gcc -gstabs
2636 (not -gstabs+) for static fields, and perhaps other C++
2637 extensions. Hopefully few people use -gstabs with gdb, since
2638 it is intended for dbx compatibility. */
2639 visibility = DEBUG_VISIBILITY_IGNORE;
2640 }
2641
2642 /* FIXME: gdb does some stuff here to mark fields as unpacked. */
2643
2644 *retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility);
2645
2646 return true;
2647 }
2648
2649 /* Read member function stabs info for C++ classes. The form of each member
2650 function data is:
2651
2652 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2653
2654 An example with two member functions is:
2655
2656 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2657
2658 For the case of overloaded operators, the format is op$::*.funcs, where
2659 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2660 name (such as `+=') and `.' marks the end of the operator name. */
2661
2662 static bool
parse_stab_members(void * dhandle,struct stab_handle * info,const char * tagname,const char ** pp,const int * typenums,debug_method ** retp,const char * p_end)2663 parse_stab_members (void * dhandle,
2664 struct stab_handle * info,
2665 const char * tagname,
2666 const char ** pp,
2667 const int * typenums,
2668 debug_method ** retp,
2669 const char * p_end)
2670 {
2671 const char *orig;
2672 debug_method *methods, *xmethods;
2673 unsigned int c;
2674 unsigned int alloc;
2675 char *name = NULL;
2676 debug_method_variant *variants = NULL, *xvariants;
2677 char *argtypes = NULL;
2678
2679 *retp = NULL;
2680
2681 orig = *pp;
2682 if (orig >= p_end)
2683 return false;
2684
2685 alloc = 0;
2686 methods = NULL;
2687 c = 0;
2688
2689 while (**pp != ';')
2690 {
2691 const char *p;
2692 unsigned int cvars;
2693 unsigned int allocvars;
2694 debug_type look_ahead_type;
2695
2696 p = strchr (*pp, ':');
2697 if (p == NULL || p[1] != ':')
2698 break;
2699
2700 /* FIXME: Some systems use something other than '$' here. */
2701 if ((*pp)[0] != 'o' || (*pp)[1] != 'p' || (*pp)[2] != '$')
2702 {
2703 name = savestring (dhandle, *pp, p - *pp);
2704 *pp = p + 2;
2705 }
2706 else
2707 {
2708 /* This is a completely weird case. In order to stuff in the
2709 names that might contain colons (the usual name delimiter),
2710 Mike Tiemann defined a different name format which is
2711 signalled if the identifier is "op$". In that case, the
2712 format is "op$::XXXX." where XXXX is the name. This is
2713 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2714 *pp = p + 2;
2715 for (p = *pp; *p != '.' && *p != '\0'; p++)
2716 ;
2717 if (*p != '.')
2718 {
2719 bad_stab (orig);
2720 goto fail;
2721 }
2722 name = savestring (dhandle, *pp, p - *pp);
2723 *pp = p + 1;
2724 }
2725
2726 allocvars = 10;
2727 variants = xmalloc (allocvars * sizeof (*variants));
2728 cvars = 0;
2729
2730 look_ahead_type = DEBUG_TYPE_NULL;
2731
2732 do
2733 {
2734 debug_type type;
2735 bool stub;
2736 enum debug_visibility visibility;
2737 bool constp, volatilep, staticp;
2738 bfd_vma voffset;
2739 debug_type context;
2740 const char *physname;
2741 bool varargs;
2742
2743 if (look_ahead_type != DEBUG_TYPE_NULL)
2744 {
2745 /* g++ version 1 kludge */
2746 type = look_ahead_type;
2747 look_ahead_type = DEBUG_TYPE_NULL;
2748 }
2749 else
2750 {
2751 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2752 (debug_type **) NULL, p_end);
2753 if (type == DEBUG_TYPE_NULL)
2754 goto fail;
2755
2756 if (**pp != ':')
2757 {
2758 bad_stab (orig);
2759 goto fail;
2760 }
2761 }
2762
2763 ++*pp;
2764 p = strchr (*pp, ';');
2765 if (p == NULL)
2766 {
2767 bad_stab (orig);
2768 goto fail;
2769 }
2770
2771 stub = false;
2772 if (debug_get_type_kind (dhandle, type) == DEBUG_KIND_METHOD
2773 && debug_get_parameter_types (dhandle, type, &varargs) == NULL)
2774 stub = true;
2775
2776 argtypes = savestring (dhandle, *pp, p - *pp);
2777 *pp = p + 1;
2778
2779 switch (**pp)
2780 {
2781 case '0':
2782 visibility = DEBUG_VISIBILITY_PRIVATE;
2783 break;
2784 case '1':
2785 visibility = DEBUG_VISIBILITY_PROTECTED;
2786 break;
2787 case 0:
2788 bad_stab (orig);
2789 goto fail;
2790 default:
2791 visibility = DEBUG_VISIBILITY_PUBLIC;
2792 break;
2793 }
2794 ++*pp;
2795
2796 constp = false;
2797 volatilep = false;
2798 switch (**pp)
2799 {
2800 case 'A':
2801 /* Normal function. */
2802 ++*pp;
2803 break;
2804 case 'B':
2805 /* const member function. */
2806 constp = true;
2807 ++*pp;
2808 break;
2809 case 'C':
2810 /* volatile member function. */
2811 volatilep = true;
2812 ++*pp;
2813 break;
2814 case 'D':
2815 /* const volatile member function. */
2816 constp = true;
2817 volatilep = true;
2818 ++*pp;
2819 break;
2820 case '*':
2821 case '?':
2822 case '.':
2823 /* File compiled with g++ version 1; no information. */
2824 break;
2825 default:
2826 warn_stab (orig, _("const/volatile indicator missing"));
2827 break;
2828 }
2829
2830 staticp = false;
2831 switch (**pp)
2832 {
2833 case '*':
2834 /* virtual member function, followed by index. The sign
2835 bit is supposedly set to distinguish
2836 pointers-to-methods from virtual function indices. */
2837 ++*pp;
2838 voffset = parse_number (pp, (bool *) NULL, p_end);
2839 if (**pp != ';')
2840 {
2841 bad_stab (orig);
2842 goto fail;
2843 }
2844 ++*pp;
2845 voffset &= 0x7fffffff;
2846
2847 if (**pp == ';' || **pp == '\0')
2848 {
2849 /* Must be g++ version 1. */
2850 context = DEBUG_TYPE_NULL;
2851 }
2852 else
2853 {
2854 /* Figure out from whence this virtual function
2855 came. It may belong to virtual function table of
2856 one of its baseclasses. */
2857 look_ahead_type = parse_stab_type (dhandle, info,
2858 (const char *) NULL,
2859 pp,
2860 (debug_type **) NULL,
2861 p_end);
2862 if (**pp == ':')
2863 {
2864 /* g++ version 1 overloaded methods. */
2865 context = DEBUG_TYPE_NULL;
2866 }
2867 else
2868 {
2869 context = look_ahead_type;
2870 look_ahead_type = DEBUG_TYPE_NULL;
2871 if (**pp != ';')
2872 {
2873 bad_stab (orig);
2874 goto fail;
2875 }
2876 ++*pp;
2877 }
2878 }
2879 break;
2880
2881 case '?':
2882 /* static member function. */
2883 ++*pp;
2884 staticp = true;
2885 voffset = 0;
2886 context = DEBUG_TYPE_NULL;
2887 if (strncmp (argtypes, name, strlen (name)) != 0)
2888 stub = true;
2889 break;
2890
2891 default:
2892 warn_stab (orig, "member function type missing");
2893 voffset = 0;
2894 context = DEBUG_TYPE_NULL;
2895 break;
2896
2897 case '.':
2898 ++*pp;
2899 voffset = 0;
2900 context = DEBUG_TYPE_NULL;
2901 break;
2902 }
2903
2904 /* If the type is not a stub, then the argtypes string is
2905 the physical name of the function. Otherwise the
2906 argtypes string is the mangled form of the argument
2907 types, and the full type and the physical name must be
2908 extracted from them. */
2909 physname = argtypes;
2910 if (stub)
2911 {
2912 debug_type class_type, return_type;
2913
2914 class_type = stab_find_type (dhandle, info, typenums);
2915 if (class_type == DEBUG_TYPE_NULL)
2916 goto fail;
2917 return_type = debug_get_return_type (dhandle, type);
2918 if (return_type == DEBUG_TYPE_NULL)
2919 {
2920 bad_stab (orig);
2921 goto fail;
2922 }
2923 type = parse_stab_argtypes (dhandle, info, class_type, name,
2924 tagname, return_type, argtypes,
2925 constp, volatilep, &physname);
2926 if (type == DEBUG_TYPE_NULL)
2927 goto fail;
2928 }
2929
2930 if (cvars + 1 >= allocvars)
2931 {
2932 allocvars += 10;
2933 variants = xrealloc (variants, allocvars * sizeof (*variants));
2934 }
2935
2936 if (! staticp)
2937 variants[cvars] = debug_make_method_variant (dhandle, physname,
2938 type, visibility,
2939 constp, volatilep,
2940 voffset, context);
2941 else
2942 variants[cvars] = debug_make_static_method_variant (dhandle,
2943 physname,
2944 type,
2945 visibility,
2946 constp,
2947 volatilep);
2948 if (variants[cvars] == DEBUG_METHOD_VARIANT_NULL)
2949 goto fail;
2950
2951 ++cvars;
2952 }
2953 while (**pp != ';' && **pp != '\0');
2954
2955 variants[cvars] = DEBUG_METHOD_VARIANT_NULL;
2956 xvariants = debug_xalloc (dhandle, (cvars + 1) * sizeof (*variants));
2957 memcpy (xvariants, variants, (cvars + 1) * sizeof (*variants));
2958 free (variants);
2959
2960 if (**pp != '\0')
2961 ++*pp;
2962
2963 if (c + 1 >= alloc)
2964 {
2965 alloc += 10;
2966 methods = xrealloc (methods, alloc * sizeof (*methods));
2967 }
2968
2969 methods[c] = debug_make_method (dhandle, name, xvariants);
2970
2971 ++c;
2972 }
2973
2974 xmethods = methods;
2975 if (methods != NULL)
2976 {
2977 methods[c] = DEBUG_METHOD_NULL;
2978 xmethods = debug_xalloc (dhandle, (c + 1) * sizeof (*methods));
2979 memcpy (xmethods, methods, (c + 1) * sizeof (*methods));
2980 free (methods);
2981 }
2982
2983 *retp = xmethods;
2984
2985 return true;
2986
2987 fail:
2988 free (variants);
2989 free (methods);
2990 return false;
2991 }
2992
2993 /* Parse a string representing argument types for a method. Stabs
2994 tries to save space by packing argument types into a mangled
2995 string. This string should give us enough information to extract
2996 both argument types and the physical name of the function, given
2997 the tag name. */
2998
2999 static debug_type
parse_stab_argtypes(void * dhandle,struct stab_handle * info,debug_type class_type,const char * fieldname,const char * tagname,debug_type return_type,const char * argtypes,bool constp,bool volatilep,const char ** pphysname)3000 parse_stab_argtypes (void *dhandle, struct stab_handle *info,
3001 debug_type class_type, const char *fieldname,
3002 const char *tagname, debug_type return_type,
3003 const char *argtypes, bool constp,
3004 bool volatilep, const char **pphysname)
3005 {
3006 bool is_full_physname_constructor;
3007 bool is_constructor;
3008 bool is_destructor;
3009 bool is_v3;
3010 debug_type *args;
3011 bool varargs;
3012 unsigned int physname_len = 0;
3013
3014 /* Constructors are sometimes handled specially. */
3015 is_full_physname_constructor = ((argtypes[0] == '_'
3016 && argtypes[1] == '_'
3017 && (ISDIGIT (argtypes[2])
3018 || argtypes[2] == 'Q'
3019 || argtypes[2] == 't'))
3020 || startswith (argtypes, "__ct"));
3021
3022 is_constructor = (is_full_physname_constructor
3023 || (tagname != NULL
3024 && strcmp (fieldname, tagname) == 0));
3025 is_destructor = ((argtypes[0] == '_'
3026 && (argtypes[1] == '$' || argtypes[1] == '.')
3027 && argtypes[2] == '_')
3028 || startswith (argtypes, "__dt"));
3029 is_v3 = argtypes[0] == '_' && argtypes[1] == 'Z';
3030
3031 if (!(is_destructor || is_full_physname_constructor || is_v3))
3032 {
3033 unsigned int len, buf_len;
3034 const char *const_prefix;
3035 const char *volatile_prefix;
3036 char buf[20];
3037 unsigned int mangled_name_len;
3038 char *physname;
3039
3040 len = tagname == NULL ? 0 : strlen (tagname);
3041 const_prefix = constp ? "C" : "";
3042 volatile_prefix = volatilep ? "V" : "";
3043
3044 if (len == 0)
3045 buf_len = sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
3046 else if (tagname != NULL && strchr (tagname, '<') != NULL)
3047 {
3048 /* Template methods are fully mangled. */
3049 buf_len = sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
3050 tagname = NULL;
3051 len = 0;
3052 }
3053 else
3054 buf_len = sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
3055
3056 mangled_name_len = ((is_constructor ? 0 : strlen (fieldname))
3057 + buf_len
3058 + len
3059 + strlen (argtypes)
3060 + 1);
3061
3062 if (fieldname[0] == 'o'
3063 && fieldname[1] == 'p'
3064 && (fieldname[2] == '$' || fieldname[2] == '.'))
3065 {
3066 /* Opname selection is no longer supported by libiberty's demangler. */
3067 return DEBUG_TYPE_NULL;
3068 }
3069
3070 physname = debug_xalloc (dhandle, mangled_name_len);
3071 if (is_constructor)
3072 physname[0] = '\0';
3073 else
3074 strcpy (physname, fieldname);
3075
3076 physname_len = strlen (physname);
3077 strcat (physname, buf);
3078 if (tagname != NULL)
3079 strcat (physname, tagname);
3080 strcat (physname, argtypes);
3081
3082 *pphysname = physname;
3083 }
3084
3085 if (*argtypes == '\0' || is_destructor)
3086 {
3087 args = debug_xalloc (dhandle, sizeof (*args));
3088 *args = NULL;
3089 return debug_make_method_type (dhandle, return_type, class_type, args,
3090 false);
3091 }
3092
3093 args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len);
3094 if (args == NULL)
3095 return DEBUG_TYPE_NULL;
3096
3097 return debug_make_method_type (dhandle, return_type, class_type, args,
3098 varargs);
3099 }
3100
3101 /* The tail end of stabs for C++ classes that contain a virtual function
3102 pointer contains a tilde, a %, and a type number.
3103 The type number refers to the base class (possibly this class itself) which
3104 contains the vtable pointer for the current class.
3105
3106 This function is called when we have parsed all the method declarations,
3107 so we can look for the vptr base class info. */
3108
3109 static bool
parse_stab_tilde_field(void * dhandle,struct stab_handle * info,const char ** pp,const int * typenums,debug_type * retvptrbase,bool * retownvptr,const char * p_end)3110 parse_stab_tilde_field (void *dhandle,
3111 struct stab_handle *info,
3112 const char **pp,
3113 const int *typenums,
3114 debug_type *retvptrbase,
3115 bool *retownvptr,
3116 const char *p_end)
3117 {
3118 const char *orig;
3119 const char *hold;
3120 int vtypenums[2];
3121
3122 *retvptrbase = DEBUG_TYPE_NULL;
3123 *retownvptr = false;
3124
3125 orig = *pp;
3126 if (orig >= p_end)
3127 return false;
3128
3129 /* If we are positioned at a ';', then skip it. */
3130 if (**pp == ';')
3131 ++*pp;
3132
3133 if (**pp != '~')
3134 return true;
3135 ++*pp;
3136
3137 if (**pp == '=' || **pp == '+' || **pp == '-')
3138 {
3139 /* Obsolete flags that used to indicate the presence of
3140 constructors and/or destructors. */
3141 ++*pp;
3142 }
3143
3144 if (**pp != '%')
3145 return true;
3146 ++*pp;
3147
3148 hold = *pp;
3149
3150 /* The next number is the type number of the base class (possibly
3151 our own class) which supplies the vtable for this class. */
3152 if (! parse_stab_type_number (pp, vtypenums, p_end))
3153 return false;
3154
3155 if (vtypenums[0] == typenums[0]
3156 && vtypenums[1] == typenums[1])
3157 *retownvptr = true;
3158 else
3159 {
3160 debug_type vtype;
3161 const char *p;
3162
3163 *pp = hold;
3164
3165 vtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3166 (debug_type **) NULL, p_end);
3167 for (p = *pp; *p != ';' && *p != '\0'; p++)
3168 ;
3169 if (*p != ';')
3170 {
3171 bad_stab (orig);
3172 return false;
3173 }
3174
3175 *retvptrbase = vtype;
3176
3177 *pp = p + 1;
3178 }
3179
3180 return true;
3181 }
3182
3183 /* Read a definition of an array type. */
3184
3185 static debug_type
parse_stab_array_type(void * dhandle,struct stab_handle * info,const char ** pp,bool stringp,const char * p_end)3186 parse_stab_array_type (void *dhandle,
3187 struct stab_handle *info,
3188 const char **pp,
3189 bool stringp,
3190 const char *p_end)
3191 {
3192 const char *orig;
3193 const char *p;
3194 int typenums[2];
3195 debug_type index_type;
3196 bool adjustable;
3197 bfd_signed_vma lower, upper;
3198 debug_type element_type;
3199
3200 /* Format of an array type:
3201 "ar<index type>;lower;upper;<array_contents_type>".
3202 OS9000: "arlower,upper;<array_contents_type>".
3203
3204 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3205 for these, produce a type like float[][]. */
3206
3207 orig = *pp;
3208 if (orig >= p_end)
3209 return DEBUG_TYPE_NULL;
3210
3211 /* FIXME: gdb checks os9k_stabs here. */
3212
3213 /* If the index type is type 0, we take it as int. */
3214 p = *pp;
3215 if (! parse_stab_type_number (&p, typenums, p_end))
3216 return DEBUG_TYPE_NULL;
3217
3218 if (typenums[0] == 0 && typenums[1] == 0 && **pp != '=')
3219 {
3220 index_type = debug_find_named_type (dhandle, "int");
3221 if (index_type == DEBUG_TYPE_NULL)
3222 {
3223 index_type = debug_make_int_type (dhandle, 4, false);
3224 if (index_type == DEBUG_TYPE_NULL)
3225 return DEBUG_TYPE_NULL;
3226 }
3227 *pp = p;
3228 }
3229 else
3230 {
3231 index_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3232 (debug_type **) NULL, p_end);
3233 }
3234
3235 if (**pp != ';')
3236 {
3237 bad_stab (orig);
3238 return DEBUG_TYPE_NULL;
3239 }
3240 ++*pp;
3241
3242 adjustable = false;
3243
3244 if (! ISDIGIT (**pp) && **pp != '-' && **pp != 0)
3245 {
3246 ++*pp;
3247 adjustable = true;
3248 }
3249
3250 lower = (bfd_signed_vma) parse_number (pp, (bool *) NULL, p_end);
3251 if (**pp != ';')
3252 {
3253 bad_stab (orig);
3254 return DEBUG_TYPE_NULL;
3255 }
3256 ++*pp;
3257
3258 if (! ISDIGIT (**pp) && **pp != '-' && **pp != 0)
3259 {
3260 ++*pp;
3261 adjustable = true;
3262 }
3263
3264 upper = (bfd_signed_vma) parse_number (pp, (bool *) NULL, p_end);
3265 if (**pp != ';')
3266 {
3267 bad_stab (orig);
3268 return DEBUG_TYPE_NULL;
3269 }
3270 ++*pp;
3271
3272 element_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3273 (debug_type **) NULL, p_end);
3274 if (element_type == DEBUG_TYPE_NULL)
3275 return DEBUG_TYPE_NULL;
3276
3277 if (adjustable)
3278 {
3279 lower = 0;
3280 upper = -1;
3281 }
3282
3283 return debug_make_array_type (dhandle, element_type, index_type, lower,
3284 upper, stringp);
3285 }
3286
3287 /* This struct holds information about files we have seen using
3288 N_BINCL. */
3289
3290 struct bincl_file
3291 {
3292 /* The next N_BINCL file. */
3293 struct bincl_file *next;
3294 /* The next N_BINCL on the stack. */
3295 struct bincl_file *next_stack;
3296 /* The file name. */
3297 const char *name;
3298 /* The hash value. */
3299 bfd_vma hash;
3300 /* The file index. */
3301 unsigned int file;
3302 /* The list of types defined in this file. */
3303 struct stab_types *file_types;
3304 };
3305
3306 /* Start a new N_BINCL file, pushing it onto the stack. */
3307
3308 static void
push_bincl(void * dhandle,struct stab_handle * info,const char * name,bfd_vma hash)3309 push_bincl (void *dhandle, struct stab_handle *info, const char *name,
3310 bfd_vma hash)
3311 {
3312 struct bincl_file *n;
3313
3314 n = debug_xalloc (dhandle, sizeof *n);
3315 n->next = info->bincl_list;
3316 n->next_stack = info->bincl_stack;
3317 n->name = name;
3318 n->hash = hash;
3319 n->file = info->files;
3320 n->file_types = NULL;
3321 info->bincl_list = n;
3322 info->bincl_stack = n;
3323
3324 ++info->files;
3325 info->file_types = xrealloc (info->file_types,
3326 info->files * sizeof (*info->file_types));
3327 info->file_types[n->file] = NULL;
3328 }
3329
3330 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3331 stack. */
3332
3333 static const char *
pop_bincl(struct stab_handle * info)3334 pop_bincl (struct stab_handle *info)
3335 {
3336 struct bincl_file *o;
3337
3338 o = info->bincl_stack;
3339 if (o == NULL)
3340 return info->main_filename;
3341 info->bincl_stack = o->next_stack;
3342
3343 if (o->file >= info->files)
3344 return info->main_filename;
3345
3346 o->file_types = info->file_types[o->file];
3347
3348 if (info->bincl_stack == NULL)
3349 return info->main_filename;
3350 return info->bincl_stack->name;
3351 }
3352
3353 /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
3354
3355 static bool
find_excl(struct stab_handle * info,const char * name,bfd_vma hash)3356 find_excl (struct stab_handle *info, const char *name, bfd_vma hash)
3357 {
3358 struct bincl_file *l;
3359
3360 ++info->files;
3361 info->file_types = xrealloc (info->file_types,
3362 info->files * sizeof (*info->file_types));
3363
3364 for (l = info->bincl_list; l != NULL; l = l->next)
3365 if (l->hash == hash && strcmp (l->name, name) == 0)
3366 break;
3367 if (l == NULL)
3368 {
3369 warn_stab (name, _("Undefined N_EXCL"));
3370 info->file_types[info->files - 1] = NULL;
3371 return true;
3372 }
3373
3374 info->file_types[info->files - 1] = l->file_types;
3375
3376 return true;
3377 }
3378
3379 /* Handle a variable definition. gcc emits variable definitions for a
3380 block before the N_LBRAC, so we must hold onto them until we see
3381 it. The SunPRO compiler emits variable definitions after the
3382 N_LBRAC, so we can call debug_record_variable immediately. */
3383
3384 static bool
stab_record_variable(void * dhandle,struct stab_handle * info,const char * name,debug_type type,enum debug_var_kind kind,bfd_vma val)3385 stab_record_variable (void *dhandle, struct stab_handle *info,
3386 const char *name, debug_type type,
3387 enum debug_var_kind kind, bfd_vma val)
3388 {
3389 struct stab_pending_var *v;
3390
3391 if ((kind == DEBUG_GLOBAL || kind == DEBUG_STATIC)
3392 || ! info->within_function
3393 || (info->gcc_compiled == 0 && info->n_opt_found))
3394 return debug_record_variable (dhandle, name, type, kind, val);
3395
3396 v = debug_xzalloc (dhandle, sizeof (*v));
3397
3398 v->next = info->pending;
3399 v->name = name;
3400 v->type = type;
3401 v->kind = kind;
3402 v->val = val;
3403 info->pending = v;
3404
3405 return true;
3406 }
3407
3408 /* Emit pending variable definitions. This is called after we see the
3409 N_LBRAC that starts the block. */
3410
3411 static bool
stab_emit_pending_vars(void * dhandle,struct stab_handle * info)3412 stab_emit_pending_vars (void *dhandle, struct stab_handle *info)
3413 {
3414 struct stab_pending_var *v;
3415
3416 v = info->pending;
3417 while (v != NULL)
3418 {
3419 if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val))
3420 return false;
3421
3422 v = v->next;
3423 }
3424
3425 info->pending = NULL;
3426
3427 return true;
3428 }
3429
3430 /* Find the slot for a type in the database. */
3431
3432 static debug_type *
stab_find_slot(void * dhandle,struct stab_handle * info,const int * typenums)3433 stab_find_slot (void *dhandle, struct stab_handle *info, const int *typenums)
3434 {
3435 unsigned int filenum;
3436 unsigned int tindex;
3437 unsigned int base_index;
3438 struct stab_types **ps;
3439
3440 filenum = typenums[0];
3441 tindex = typenums[1];
3442
3443 if (filenum >= info->files)
3444 {
3445 fprintf (stderr, _("Type file number %d out of range\n"), filenum);
3446 return NULL;
3447 }
3448
3449 ps = info->file_types + filenum;
3450 base_index = tindex / STAB_TYPES_SLOTS * STAB_TYPES_SLOTS;
3451 tindex -= base_index;
3452 while (*ps && (*ps)->base_index < base_index)
3453 ps = &(*ps)->next;
3454
3455 if (*ps == NULL || (*ps)->base_index != base_index)
3456 {
3457 struct stab_types *n = debug_xzalloc (dhandle, sizeof (*n));
3458 n->next = *ps;
3459 n->base_index = base_index;
3460 *ps = n;
3461 }
3462
3463 return (*ps)->types + tindex;
3464 }
3465
3466 /* Find a type given a type number. If the type has not been
3467 allocated yet, create an indirect type. */
3468
3469 static debug_type
stab_find_type(void * dhandle,struct stab_handle * info,const int * typenums)3470 stab_find_type (void *dhandle, struct stab_handle *info, const int *typenums)
3471 {
3472 debug_type *slot;
3473
3474 if (typenums[0] == 0 && typenums[1] < 0)
3475 {
3476 /* A negative type number indicates an XCOFF builtin type. */
3477 return stab_xcoff_builtin_type (dhandle, info, typenums[1]);
3478 }
3479
3480 slot = stab_find_slot (dhandle, info, typenums);
3481 if (slot == NULL)
3482 return DEBUG_TYPE_NULL;
3483
3484 if (*slot == DEBUG_TYPE_NULL)
3485 return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
3486
3487 return *slot;
3488 }
3489
3490 /* Record that a given type number refers to a given type. */
3491
3492 static bool
stab_record_type(void * dhandle,struct stab_handle * info,const int * typenums,debug_type type)3493 stab_record_type (void *dhandle, struct stab_handle *info,
3494 const int *typenums, debug_type type)
3495 {
3496 debug_type *slot;
3497
3498 slot = stab_find_slot (dhandle, info, typenums);
3499 if (slot == NULL)
3500 return false;
3501
3502 /* gdb appears to ignore type redefinitions, so we do as well. */
3503
3504 *slot = type;
3505
3506 return true;
3507 }
3508
3509 /* Return an XCOFF builtin type. */
3510
3511 static debug_type
stab_xcoff_builtin_type(void * dhandle,struct stab_handle * info,unsigned int typenum)3512 stab_xcoff_builtin_type (void *dhandle, struct stab_handle *info,
3513 unsigned int typenum)
3514 {
3515 debug_type rettype;
3516 const char *name;
3517
3518 typenum = -typenum - 1;
3519 if (typenum >= XCOFF_TYPE_COUNT)
3520 {
3521 fprintf (stderr, _("Unrecognized XCOFF type %d\n"), -typenum - 1);
3522 return DEBUG_TYPE_NULL;
3523 }
3524 if (info->xcoff_types[typenum] != NULL)
3525 return info->xcoff_types[typenum];
3526
3527 switch (typenum)
3528 {
3529 case 0:
3530 /* The size of this and all the other types are fixed, defined
3531 by the debugging format. */
3532 name = "int";
3533 rettype = debug_make_int_type (dhandle, 4, false);
3534 break;
3535 case 1:
3536 name = "char";
3537 rettype = debug_make_int_type (dhandle, 1, false);
3538 break;
3539 case 2:
3540 name = "short";
3541 rettype = debug_make_int_type (dhandle, 2, false);
3542 break;
3543 case 3:
3544 name = "long";
3545 rettype = debug_make_int_type (dhandle, 4, false);
3546 break;
3547 case 4:
3548 name = "unsigned char";
3549 rettype = debug_make_int_type (dhandle, 1, true);
3550 break;
3551 case 5:
3552 name = "signed char";
3553 rettype = debug_make_int_type (dhandle, 1, false);
3554 break;
3555 case 6:
3556 name = "unsigned short";
3557 rettype = debug_make_int_type (dhandle, 2, true);
3558 break;
3559 case 7:
3560 name = "unsigned int";
3561 rettype = debug_make_int_type (dhandle, 4, true);
3562 break;
3563 case 8:
3564 name = "unsigned";
3565 rettype = debug_make_int_type (dhandle, 4, true);
3566 break;
3567 case 9:
3568 name = "unsigned long";
3569 rettype = debug_make_int_type (dhandle, 4, true);
3570 break;
3571 case 10:
3572 name = "void";
3573 rettype = debug_make_void_type (dhandle);
3574 break;
3575 case 11:
3576 /* IEEE single precision (32 bit). */
3577 name = "float";
3578 rettype = debug_make_float_type (dhandle, 4);
3579 break;
3580 case 12:
3581 /* IEEE double precision (64 bit). */
3582 name = "double";
3583 rettype = debug_make_float_type (dhandle, 8);
3584 break;
3585 case 13:
3586 /* This is an IEEE double on the RS/6000, and different machines
3587 with different sizes for "long double" should use different
3588 negative type numbers. See stabs.texinfo. */
3589 name = "long double";
3590 rettype = debug_make_float_type (dhandle, 8);
3591 break;
3592 case 14:
3593 name = "integer";
3594 rettype = debug_make_int_type (dhandle, 4, false);
3595 break;
3596 case 15:
3597 name = "boolean";
3598 rettype = debug_make_bool_type (dhandle, 4);
3599 break;
3600 case 16:
3601 name = "short real";
3602 rettype = debug_make_float_type (dhandle, 4);
3603 break;
3604 case 17:
3605 name = "real";
3606 rettype = debug_make_float_type (dhandle, 8);
3607 break;
3608 case 18:
3609 /* FIXME */
3610 name = "stringptr";
3611 rettype = NULL;
3612 break;
3613 case 19:
3614 /* FIXME */
3615 name = "character";
3616 rettype = debug_make_int_type (dhandle, 1, true);
3617 break;
3618 case 20:
3619 name = "logical*1";
3620 rettype = debug_make_bool_type (dhandle, 1);
3621 break;
3622 case 21:
3623 name = "logical*2";
3624 rettype = debug_make_bool_type (dhandle, 2);
3625 break;
3626 case 22:
3627 name = "logical*4";
3628 rettype = debug_make_bool_type (dhandle, 4);
3629 break;
3630 case 23:
3631 name = "logical";
3632 rettype = debug_make_bool_type (dhandle, 4);
3633 break;
3634 case 24:
3635 /* Complex type consisting of two IEEE single precision values. */
3636 name = "complex";
3637 rettype = debug_make_complex_type (dhandle, 8);
3638 break;
3639 case 25:
3640 /* Complex type consisting of two IEEE double precision values. */
3641 name = "double complex";
3642 rettype = debug_make_complex_type (dhandle, 16);
3643 break;
3644 case 26:
3645 name = "integer*1";
3646 rettype = debug_make_int_type (dhandle, 1, false);
3647 break;
3648 case 27:
3649 name = "integer*2";
3650 rettype = debug_make_int_type (dhandle, 2, false);
3651 break;
3652 case 28:
3653 name = "integer*4";
3654 rettype = debug_make_int_type (dhandle, 4, false);
3655 break;
3656 case 29:
3657 /* FIXME */
3658 name = "wchar";
3659 rettype = debug_make_int_type (dhandle, 2, false);
3660 break;
3661 case 30:
3662 name = "long long";
3663 rettype = debug_make_int_type (dhandle, 8, false);
3664 break;
3665 case 31:
3666 name = "unsigned long long";
3667 rettype = debug_make_int_type (dhandle, 8, true);
3668 break;
3669 case 32:
3670 name = "logical*8";
3671 rettype = debug_make_bool_type (dhandle, 8);
3672 break;
3673 case 33:
3674 name = "integer*8";
3675 rettype = debug_make_int_type (dhandle, 8, false);
3676 break;
3677 default:
3678 abort ();
3679 }
3680
3681 rettype = debug_name_type (dhandle, name, rettype);
3682 info->xcoff_types[typenum] = rettype;
3683 return rettype;
3684 }
3685
3686 /* Find or create a tagged type. */
3687
3688 static debug_type
stab_find_tagged_type(void * dhandle,struct stab_handle * info,const char * p,int len,enum debug_type_kind kind)3689 stab_find_tagged_type (void *dhandle, struct stab_handle *info,
3690 const char *p, int len, enum debug_type_kind kind)
3691 {
3692 char *name;
3693 debug_type dtype;
3694 struct stab_tag *st;
3695
3696 name = savestring (dhandle, p, len);
3697
3698 /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3699 namespace. This is right for C, and I don't know how to handle
3700 other languages. FIXME. */
3701 dtype = debug_find_tagged_type (dhandle, name, DEBUG_KIND_ILLEGAL);
3702 if (dtype != DEBUG_TYPE_NULL)
3703 return dtype;
3704
3705 /* We need to allocate an entry on the undefined tag list. */
3706 for (st = info->tags; st != NULL; st = st->next)
3707 {
3708 if (st->name[0] == name[0]
3709 && strcmp (st->name, name) == 0)
3710 {
3711 if (st->kind == DEBUG_KIND_ILLEGAL)
3712 st->kind = kind;
3713 break;
3714 }
3715 }
3716 if (st == NULL)
3717 {
3718 st = debug_xzalloc (dhandle, sizeof (*st));
3719
3720 st->next = info->tags;
3721 st->name = name;
3722 st->kind = kind;
3723 st->slot = DEBUG_TYPE_NULL;
3724 st->type = debug_make_indirect_type (dhandle, &st->slot, name);
3725 info->tags = st;
3726 }
3727
3728 return st->type;
3729 }
3730
3731 /* In order to get the correct argument types for a stubbed method, we
3732 need to extract the argument types from a C++ mangled string.
3733 Since the argument types can refer back to the return type, this
3734 means that we must demangle the entire physical name. In gdb this
3735 is done by calling cplus_demangle and running the results back
3736 through the C++ expression parser. Since we have no expression
3737 parser, we must duplicate much of the work of cplus_demangle here.
3738
3739 We assume that GNU style demangling is used, since this is only
3740 done for method stubs, and only g++ should output that form of
3741 debugging information. */
3742
3743 /* This structure is used to hold a pointer to type information which
3744 demangling a string. */
3745
3746 struct stab_demangle_typestring
3747 {
3748 /* The start of the type. This is not null terminated. */
3749 const char *typestring;
3750 /* The length of the type. */
3751 unsigned int len;
3752 };
3753
3754 /* This structure is used to hold information while demangling a
3755 string. */
3756
3757 struct stab_demangle_info
3758 {
3759 /* The debugging information handle. */
3760 void *dhandle;
3761 /* The stab information handle. */
3762 struct stab_handle *info;
3763 /* The array of arguments we are building. */
3764 debug_type *args;
3765 /* Whether the method takes a variable number of arguments. */
3766 bool varargs;
3767 /* The array of types we have remembered. */
3768 struct stab_demangle_typestring *typestrings;
3769 /* The number of typestrings. */
3770 unsigned int typestring_count;
3771 /* The number of typestring slots we have allocated. */
3772 unsigned int typestring_alloc;
3773 };
3774
3775 static void stab_bad_demangle (const char *);
3776 static unsigned int stab_demangle_count (const char **);
3777 static bool stab_demangle_get_count (const char **, unsigned int *);
3778 static bool stab_demangle_prefix
3779 (struct stab_demangle_info *, const char **, unsigned int);
3780 static bool stab_demangle_function_name
3781 (struct stab_demangle_info *, const char **, const char *);
3782 static bool stab_demangle_signature
3783 (struct stab_demangle_info *, const char **);
3784 static bool stab_demangle_qualified
3785 (struct stab_demangle_info *, const char **, debug_type *);
3786 static bool stab_demangle_template
3787 (struct stab_demangle_info *, const char **, char **);
3788 static bool stab_demangle_class
3789 (struct stab_demangle_info *, const char **, const char **);
3790 static bool stab_demangle_args
3791 (struct stab_demangle_info *, const char **, debug_type **, bool *);
3792 static bool stab_demangle_arg
3793 (struct stab_demangle_info *, const char **, debug_type **,
3794 unsigned int *, unsigned int *);
3795 static bool stab_demangle_type
3796 (struct stab_demangle_info *, const char **, debug_type *);
3797 static bool stab_demangle_fund_type
3798 (struct stab_demangle_info *, const char **, debug_type *);
3799 static bool stab_demangle_remember_type
3800 (struct stab_demangle_info *, const char *, int);
3801
3802 /* Warn about a bad demangling. */
3803
3804 static void
stab_bad_demangle(const char * s)3805 stab_bad_demangle (const char *s)
3806 {
3807 fprintf (stderr, _("bad mangled name `%s'\n"), s);
3808 }
3809
3810 /* Get a count from a stab string. */
3811
3812 static unsigned int
stab_demangle_count(const char ** pp)3813 stab_demangle_count (const char **pp)
3814 {
3815 unsigned int count;
3816
3817 count = 0;
3818 while (ISDIGIT (**pp))
3819 {
3820 count *= 10;
3821 count += **pp - '0';
3822 ++*pp;
3823 }
3824 return count;
3825 }
3826
3827 /* Require a count in a string. The count may be multiple digits, in
3828 which case it must end in an underscore. */
3829
3830 static bool
stab_demangle_get_count(const char ** pp,unsigned int * pi)3831 stab_demangle_get_count (const char **pp, unsigned int *pi)
3832 {
3833 if (! ISDIGIT (**pp))
3834 return false;
3835
3836 *pi = **pp - '0';
3837 ++*pp;
3838 if (ISDIGIT (**pp))
3839 {
3840 unsigned int count;
3841 const char *p;
3842
3843 count = *pi;
3844 p = *pp;
3845 do
3846 {
3847 count *= 10;
3848 count += *p - '0';
3849 ++p;
3850 }
3851 while (ISDIGIT (*p));
3852 if (*p == '_')
3853 {
3854 *pp = p + 1;
3855 *pi = count;
3856 }
3857 }
3858
3859 return true;
3860 }
3861
3862 /* This function demangles a physical name, returning a NULL
3863 terminated array of argument types. */
3864
3865 static debug_type *
stab_demangle_argtypes(void * dhandle,struct stab_handle * info,const char * physname,bool * pvarargs,unsigned int physname_len)3866 stab_demangle_argtypes (void *dhandle, struct stab_handle *info,
3867 const char *physname, bool *pvarargs,
3868 unsigned int physname_len)
3869 {
3870 struct stab_demangle_info minfo;
3871
3872 /* Check for the g++ V3 ABI. */
3873 if (physname[0] == '_' && physname[1] == 'Z')
3874 return stab_demangle_v3_argtypes (dhandle, info, physname, pvarargs);
3875
3876 minfo.dhandle = dhandle;
3877 minfo.info = info;
3878 minfo.args = NULL;
3879 minfo.varargs = false;
3880 minfo.typestring_alloc = 10;
3881 minfo.typestrings
3882 = xmalloc (minfo.typestring_alloc * sizeof (*minfo.typestrings));
3883 minfo.typestring_count = 0;
3884
3885 /* cplus_demangle checks for special GNU mangled forms, but we can't
3886 see any of them in mangled method argument types. */
3887
3888 if (! stab_demangle_prefix (&minfo, &physname, physname_len))
3889 goto error_return;
3890
3891 if (*physname != '\0')
3892 {
3893 if (! stab_demangle_signature (&minfo, &physname))
3894 goto error_return;
3895 }
3896
3897 free (minfo.typestrings);
3898
3899 if (minfo.args == NULL)
3900 fprintf (stderr, _("no argument types in mangled string\n"));
3901
3902 *pvarargs = minfo.varargs;
3903 return minfo.args;
3904
3905 error_return:
3906 free (minfo.typestrings);
3907 return NULL;
3908 }
3909
3910 /* Demangle the prefix of the mangled name. */
3911
3912 static bool
stab_demangle_prefix(struct stab_demangle_info * minfo,const char ** pp,unsigned int physname_len)3913 stab_demangle_prefix (struct stab_demangle_info *minfo, const char **pp,
3914 unsigned int physname_len)
3915 {
3916 const char *scan;
3917 unsigned int i;
3918
3919 /* cplus_demangle checks for global constructors and destructors,
3920 but we can't see them in mangled argument types. */
3921
3922 if (physname_len)
3923 scan = *pp + physname_len;
3924 else
3925 {
3926 /* Look for `__'. */
3927 scan = *pp;
3928 do
3929 scan = strchr (scan, '_');
3930 while (scan != NULL && *++scan != '_');
3931
3932 if (scan == NULL)
3933 {
3934 stab_bad_demangle (*pp);
3935 return false;
3936 }
3937
3938 --scan;
3939
3940 /* We found `__'; move ahead to the last contiguous `__' pair. */
3941 i = strspn (scan, "_");
3942 if (i > 2)
3943 scan += i - 2;
3944 }
3945
3946 if (scan == *pp
3947 && (ISDIGIT (scan[2])
3948 || scan[2] == 'Q'
3949 || scan[2] == 't'))
3950 {
3951 /* This is a GNU style constructor name. */
3952 *pp = scan + 2;
3953 return true;
3954 }
3955 else if (scan == *pp
3956 && ! ISDIGIT (scan[2])
3957 && scan[2] != 't')
3958 {
3959 /* Look for the `__' that separates the prefix from the
3960 signature. */
3961 while (*scan == '_')
3962 ++scan;
3963 scan = strstr (scan, "__");
3964 if (scan == NULL || scan[2] == '\0')
3965 {
3966 stab_bad_demangle (*pp);
3967 return false;
3968 }
3969
3970 return stab_demangle_function_name (minfo, pp, scan);
3971 }
3972 else if (scan[2] != '\0')
3973 {
3974 /* The name doesn't start with `__', but it does contain `__'. */
3975 return stab_demangle_function_name (minfo, pp, scan);
3976 }
3977 else
3978 {
3979 stab_bad_demangle (*pp);
3980 return false;
3981 }
3982 /*NOTREACHED*/
3983 }
3984
3985 /* Demangle a function name prefix. The scan argument points to the
3986 double underscore which separates the function name from the
3987 signature. */
3988
3989 static bool
stab_demangle_function_name(struct stab_demangle_info * minfo,const char ** pp,const char * scan)3990 stab_demangle_function_name (struct stab_demangle_info *minfo,
3991 const char **pp, const char *scan)
3992 {
3993 const char *name;
3994
3995 /* The string from *pp to scan is the name of the function. We
3996 don't care about the name, since we just looking for argument
3997 types. However, for conversion operators, the name may include a
3998 type which we must remember in order to handle backreferences. */
3999
4000 name = *pp;
4001 *pp = scan + 2;
4002
4003 if (*pp - name >= 5
4004 && startswith (name, "type")
4005 && (name[4] == '$' || name[4] == '.'))
4006 {
4007 const char *tem;
4008
4009 /* This is a type conversion operator. */
4010 tem = name + 5;
4011 if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
4012 return false;
4013 }
4014 else if (name[0] == '_'
4015 && name[1] == '_'
4016 && name[2] == 'o'
4017 && name[3] == 'p')
4018 {
4019 const char *tem;
4020
4021 /* This is a type conversion operator. */
4022 tem = name + 4;
4023 if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
4024 return false;
4025 }
4026
4027 return true;
4028 }
4029
4030 /* Demangle the signature. This is where the argument types are
4031 found. */
4032
4033 static bool
stab_demangle_signature(struct stab_demangle_info * minfo,const char ** pp)4034 stab_demangle_signature (struct stab_demangle_info *minfo, const char **pp)
4035 {
4036 const char *orig;
4037 bool expect_func, func_done;
4038 const char *hold;
4039
4040 orig = *pp;
4041
4042 expect_func = false;
4043 func_done = false;
4044 hold = NULL;
4045
4046 while (**pp != '\0')
4047 {
4048 switch (**pp)
4049 {
4050 case 'Q':
4051 hold = *pp;
4052 if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL)
4053 || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
4054 return false;
4055 expect_func = true;
4056 hold = NULL;
4057 break;
4058
4059 case 'S':
4060 /* Static member function. FIXME: Can this happen? */
4061 if (hold == NULL)
4062 hold = *pp;
4063 ++*pp;
4064 break;
4065
4066 case 'C':
4067 /* Const member function. */
4068 if (hold == NULL)
4069 hold = *pp;
4070 ++*pp;
4071 break;
4072
4073 case '0': case '1': case '2': case '3': case '4':
4074 case '5': case '6': case '7': case '8': case '9':
4075 if (hold == NULL)
4076 hold = *pp;
4077 if (! stab_demangle_class (minfo, pp, (const char **) NULL)
4078 || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
4079 return false;
4080 expect_func = true;
4081 hold = NULL;
4082 break;
4083
4084 case 'F':
4085 /* Function. I don't know if this actually happens with g++
4086 output. */
4087 hold = NULL;
4088 func_done = true;
4089 ++*pp;
4090 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
4091 return false;
4092 break;
4093
4094 case 't':
4095 /* Template. */
4096 if (hold == NULL)
4097 hold = *pp;
4098 if (! stab_demangle_template (minfo, pp, (char **) NULL)
4099 || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
4100 return false;
4101 hold = NULL;
4102 expect_func = true;
4103 break;
4104
4105 case '_':
4106 /* At the outermost level, we cannot have a return type
4107 specified, so if we run into another '_' at this point we
4108 are dealing with a mangled name that is either bogus, or
4109 has been mangled by some algorithm we don't know how to
4110 deal with. So just reject the entire demangling. */
4111 stab_bad_demangle (orig);
4112 return false;
4113
4114 default:
4115 /* Assume we have stumbled onto the first outermost function
4116 argument token, and start processing args. */
4117 func_done = true;
4118 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
4119 return false;
4120 break;
4121 }
4122
4123 if (expect_func)
4124 {
4125 func_done = true;
4126 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
4127 return false;
4128 }
4129 }
4130
4131 if (! func_done)
4132 {
4133 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
4134 bar__3fooi is 'foo::bar(int)'. We get here when we find the
4135 first case, and need to ensure that the '(void)' gets added
4136 to the current declp. */
4137 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
4138 return false;
4139 }
4140
4141 return true;
4142 }
4143
4144 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the
4145 mangled form of "Outer::Inner". */
4146
4147 static bool
stab_demangle_qualified(struct stab_demangle_info * minfo,const char ** pp,debug_type * ptype)4148 stab_demangle_qualified (struct stab_demangle_info *minfo, const char **pp,
4149 debug_type *ptype)
4150 {
4151 const char *orig;
4152 const char *p;
4153 unsigned int qualifiers;
4154 debug_type context;
4155
4156 orig = *pp;
4157
4158 switch ((*pp)[1])
4159 {
4160 case '_':
4161 /* GNU mangled name with more than 9 classes. The count is
4162 preceded by an underscore (to distinguish it from the <= 9
4163 case) and followed by an underscore. */
4164 p = *pp + 2;
4165 if (! ISDIGIT (*p) || *p == '0')
4166 {
4167 stab_bad_demangle (orig);
4168 return false;
4169 }
4170 qualifiers = atoi (p);
4171 while (ISDIGIT (*p))
4172 ++p;
4173 if (*p != '_')
4174 {
4175 stab_bad_demangle (orig);
4176 return false;
4177 }
4178 *pp = p + 1;
4179 break;
4180
4181 case '1': case '2': case '3': case '4': case '5':
4182 case '6': case '7': case '8': case '9':
4183 qualifiers = (*pp)[1] - '0';
4184 /* Skip an optional underscore after the count. */
4185 if ((*pp)[2] == '_')
4186 ++*pp;
4187 *pp += 2;
4188 break;
4189
4190 case '0':
4191 default:
4192 stab_bad_demangle (orig);
4193 return false;
4194 }
4195
4196 context = DEBUG_TYPE_NULL;
4197
4198 /* Pick off the names. */
4199 while (qualifiers-- > 0)
4200 {
4201 if (**pp == '_')
4202 ++*pp;
4203 if (**pp == 't')
4204 {
4205 char *name;
4206
4207 if (! stab_demangle_template (minfo, pp,
4208 ptype != NULL ? &name : NULL))
4209 return false;
4210
4211 if (ptype != NULL)
4212 {
4213 context = stab_find_tagged_type (minfo->dhandle, minfo->info,
4214 name, strlen (name),
4215 DEBUG_KIND_CLASS);
4216 if (context == DEBUG_TYPE_NULL)
4217 return false;
4218 }
4219 }
4220 else
4221 {
4222 unsigned int len;
4223
4224 len = stab_demangle_count (pp);
4225 if (strlen (*pp) < len)
4226 {
4227 stab_bad_demangle (orig);
4228 return false;
4229 }
4230
4231 if (ptype != NULL)
4232 {
4233 const debug_field *fields;
4234
4235 fields = NULL;
4236 if (context != DEBUG_TYPE_NULL)
4237 fields = debug_get_fields (minfo->dhandle, context);
4238
4239 context = DEBUG_TYPE_NULL;
4240
4241 if (fields != NULL)
4242 {
4243 char *name;
4244
4245 /* Try to find the type by looking through the
4246 fields of context until we find a field with the
4247 same type. This ought to work for a class
4248 defined within a class, but it won't work for,
4249 e.g., an enum defined within a class. stabs does
4250 not give us enough information to figure out the
4251 latter case. */
4252
4253 name = savestring (minfo->dhandle, *pp, len);
4254
4255 for (; *fields != DEBUG_FIELD_NULL; fields++)
4256 {
4257 debug_type ft;
4258 const char *dn;
4259
4260 ft = debug_get_field_type (minfo->dhandle, *fields);
4261 if (ft == NULL)
4262 return false;
4263 dn = debug_get_type_name (minfo->dhandle, ft);
4264 if (dn != NULL && strcmp (dn, name) == 0)
4265 {
4266 context = ft;
4267 break;
4268 }
4269 }
4270 }
4271
4272 if (context == DEBUG_TYPE_NULL)
4273 {
4274 /* We have to fall back on finding the type by name.
4275 If there are more types to come, then this must
4276 be a class. Otherwise, it could be anything. */
4277
4278 if (qualifiers == 0)
4279 {
4280 char *name;
4281
4282 name = savestring (minfo->dhandle, *pp, len);
4283 context = debug_find_named_type (minfo->dhandle,
4284 name);
4285 }
4286
4287 if (context == DEBUG_TYPE_NULL)
4288 {
4289 context = stab_find_tagged_type (minfo->dhandle,
4290 minfo->info,
4291 *pp, len,
4292 (qualifiers == 0
4293 ? DEBUG_KIND_ILLEGAL
4294 : DEBUG_KIND_CLASS));
4295 if (context == DEBUG_TYPE_NULL)
4296 return false;
4297 }
4298 }
4299 }
4300
4301 *pp += len;
4302 }
4303 }
4304
4305 if (ptype != NULL)
4306 *ptype = context;
4307
4308 return true;
4309 }
4310
4311 /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
4312 string representation of the template. */
4313
4314 static bool
stab_demangle_template(struct stab_demangle_info * minfo,const char ** pp,char ** pname)4315 stab_demangle_template (struct stab_demangle_info *minfo, const char **pp,
4316 char **pname)
4317 {
4318 const char *orig;
4319 unsigned int r, i;
4320
4321 orig = *pp;
4322
4323 ++*pp;
4324
4325 /* Skip the template name. */
4326 r = stab_demangle_count (pp);
4327 if (r == 0 || strlen (*pp) < r)
4328 {
4329 stab_bad_demangle (orig);
4330 return false;
4331 }
4332 *pp += r;
4333
4334 /* Get the size of the parameter list. */
4335 if (stab_demangle_get_count (pp, &r) == 0)
4336 {
4337 stab_bad_demangle (orig);
4338 return false;
4339 }
4340
4341 for (i = 0; i < r; i++)
4342 {
4343 if (**pp == 'Z')
4344 {
4345 /* This is a type parameter. */
4346 ++*pp;
4347 if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4348 return false;
4349 }
4350 else
4351 {
4352 const char *old_p;
4353 bool pointerp, realp, integralp, charp, boolp;
4354 bool done;
4355
4356 old_p = *pp;
4357 pointerp = false;
4358 realp = false;
4359 integralp = false;
4360 charp = false;
4361 boolp = false;
4362 done = false;
4363
4364 /* This is a value parameter. */
4365
4366 if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4367 return false;
4368
4369 while (*old_p != '\0' && ! done)
4370 {
4371 switch (*old_p)
4372 {
4373 case 'P':
4374 case 'p':
4375 case 'R':
4376 pointerp = true;
4377 done = true;
4378 break;
4379 case 'C': /* Const. */
4380 case 'S': /* Signed. */
4381 case 'U': /* Unsigned. */
4382 case 'V': /* Volatile. */
4383 case 'F': /* Function. */
4384 case 'M': /* Member function. */
4385 case 'O': /* ??? */
4386 ++old_p;
4387 break;
4388 case 'Q': /* Qualified name. */
4389 integralp = true;
4390 done = true;
4391 break;
4392 case 'T': /* Remembered type. */
4393 abort ();
4394 case 'v': /* Void. */
4395 abort ();
4396 case 'x': /* Long long. */
4397 case 'l': /* Long. */
4398 case 'i': /* Int. */
4399 case 's': /* Short. */
4400 case 'w': /* Wchar_t. */
4401 integralp = true;
4402 done = true;
4403 break;
4404 case 'b': /* Bool. */
4405 boolp = true;
4406 done = true;
4407 break;
4408 case 'c': /* Char. */
4409 charp = true;
4410 done = true;
4411 break;
4412 case 'r': /* Long double. */
4413 case 'd': /* Double. */
4414 case 'f': /* Float. */
4415 realp = true;
4416 done = true;
4417 break;
4418 default:
4419 /* Assume it's a user defined integral type. */
4420 integralp = true;
4421 done = true;
4422 break;
4423 }
4424 }
4425
4426 if (integralp)
4427 {
4428 if (**pp == 'm')
4429 ++*pp;
4430 while (ISDIGIT (**pp))
4431 ++*pp;
4432 }
4433 else if (charp)
4434 {
4435 unsigned int val;
4436
4437 if (**pp == 'm')
4438 ++*pp;
4439 val = stab_demangle_count (pp);
4440 if (val == 0)
4441 {
4442 stab_bad_demangle (orig);
4443 return false;
4444 }
4445 }
4446 else if (boolp)
4447 {
4448 unsigned int val;
4449
4450 val = stab_demangle_count (pp);
4451 if (val != 0 && val != 1)
4452 {
4453 stab_bad_demangle (orig);
4454 return false;
4455 }
4456 }
4457 else if (realp)
4458 {
4459 if (**pp == 'm')
4460 ++*pp;
4461 while (ISDIGIT (**pp))
4462 ++*pp;
4463 if (**pp == '.')
4464 {
4465 ++*pp;
4466 while (ISDIGIT (**pp))
4467 ++*pp;
4468 }
4469 if (**pp == 'e')
4470 {
4471 ++*pp;
4472 while (ISDIGIT (**pp))
4473 ++*pp;
4474 }
4475 }
4476 else if (pointerp)
4477 {
4478 unsigned int len;
4479
4480 len = stab_demangle_count (pp);
4481 if (len == 0)
4482 {
4483 stab_bad_demangle (orig);
4484 return false;
4485 }
4486 *pp += len;
4487 }
4488 }
4489 }
4490
4491 /* We can translate this to a string fairly easily by invoking the
4492 regular demangling routine. */
4493 if (pname != NULL)
4494 {
4495 char *s1, *s2, *s3, *s4 = NULL;
4496 char *from, *to;
4497
4498 s1 = savestring (minfo->dhandle, orig, *pp - orig);
4499
4500 s2 = concat ("NoSuchStrinG__", s1, (const char *) NULL);
4501
4502 s3 = cplus_demangle (s2, demangle_flags);
4503
4504 free (s2);
4505
4506 if (s3 != NULL)
4507 s4 = strstr (s3, "::NoSuchStrinG");
4508 if (s3 == NULL || s4 == NULL)
4509 {
4510 stab_bad_demangle (orig);
4511 free (s3);
4512 return false;
4513 }
4514
4515 /* Eliminating all spaces, except those between > characters,
4516 makes it more likely that the demangled name will match the
4517 name which g++ used as the structure name. */
4518 for (from = to = s3; from != s4; ++from)
4519 if (*from != ' '
4520 || (from[1] == '>' && from > s3 && from[-1] == '>'))
4521 *to++ = *from;
4522
4523 *pname = savestring (minfo->dhandle, s3, to - s3);
4524
4525 free (s3);
4526 }
4527
4528 return true;
4529 }
4530
4531 /* Demangle a class name. */
4532
4533 static bool
stab_demangle_class(struct stab_demangle_info * minfo ATTRIBUTE_UNUSED,const char ** pp,const char ** pstart)4534 stab_demangle_class (struct stab_demangle_info *minfo ATTRIBUTE_UNUSED,
4535 const char **pp, const char **pstart)
4536 {
4537 const char *orig;
4538 unsigned int n;
4539
4540 orig = *pp;
4541
4542 n = stab_demangle_count (pp);
4543 if (strlen (*pp) < n)
4544 {
4545 stab_bad_demangle (orig);
4546 return false;
4547 }
4548
4549 if (pstart != NULL)
4550 *pstart = *pp;
4551
4552 *pp += n;
4553
4554 return true;
4555 }
4556
4557 /* Demangle function arguments. If the pargs argument is not NULL, it
4558 is set to a NULL terminated array holding the arguments. */
4559
4560 static bool
stab_demangle_args(struct stab_demangle_info * minfo,const char ** pp,debug_type ** pargs,bool * pvarargs)4561 stab_demangle_args (struct stab_demangle_info *minfo, const char **pp,
4562 debug_type **pargs, bool *pvarargs)
4563 {
4564 const char *orig;
4565 unsigned int alloc, count;
4566
4567 orig = *pp;
4568
4569 alloc = 10;
4570 if (pargs != NULL)
4571 *pargs = xmalloc (alloc * sizeof (**pargs));
4572 if (pvarargs != NULL)
4573 *pvarargs = false;
4574 count = 0;
4575
4576 while (**pp != '_' && **pp != '\0' && **pp != 'e')
4577 {
4578 if (**pp == 'N' || **pp == 'T')
4579 {
4580 char temptype;
4581 unsigned int r, t;
4582
4583 temptype = **pp;
4584 ++*pp;
4585
4586 if (temptype == 'T')
4587 r = 1;
4588 else
4589 {
4590 if (! stab_demangle_get_count (pp, &r))
4591 goto bad;
4592 }
4593
4594 if (!stab_demangle_get_count (pp, &t)
4595 || t >= minfo->typestring_count)
4596 goto bad;
4597
4598 while (r-- > 0)
4599 {
4600 const char *tem;
4601
4602 tem = minfo->typestrings[t].typestring;
4603 if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc))
4604 goto fail;
4605 }
4606 }
4607 else
4608 {
4609 if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc))
4610 goto fail;
4611 }
4612 }
4613
4614 if (pargs != NULL)
4615 {
4616 debug_type *xargs;
4617 (*pargs)[count] = DEBUG_TYPE_NULL;
4618 xargs = debug_xalloc (minfo->dhandle, (count + 1) * sizeof (*xargs));
4619 memcpy (xargs, *pargs, (count + 1) * sizeof (*xargs));
4620 free (*pargs);
4621 *pargs = xargs;
4622 }
4623
4624 if (**pp == 'e')
4625 {
4626 if (pvarargs != NULL)
4627 *pvarargs = true;
4628 ++*pp;
4629 }
4630 return true;
4631
4632 bad:
4633 stab_bad_demangle (orig);
4634 fail:
4635 if (pargs != NULL)
4636 {
4637 free (*pargs);
4638 *pargs = NULL;
4639 }
4640 return false;
4641 }
4642
4643 /* Demangle a single argument. */
4644
4645 static bool
stab_demangle_arg(struct stab_demangle_info * minfo,const char ** pp,debug_type ** pargs,unsigned int * pcount,unsigned int * palloc)4646 stab_demangle_arg (struct stab_demangle_info *minfo, const char **pp,
4647 debug_type **pargs, unsigned int *pcount,
4648 unsigned int *palloc)
4649 {
4650 const char *start;
4651 debug_type type;
4652
4653 start = *pp;
4654 if (! stab_demangle_type (minfo, pp,
4655 pargs == NULL ? (debug_type *) NULL : &type)
4656 || ! stab_demangle_remember_type (minfo, start, *pp - start))
4657 return false;
4658
4659 if (pargs != NULL)
4660 {
4661 if (type == DEBUG_TYPE_NULL)
4662 return false;
4663
4664 if (*pcount + 1 >= *palloc)
4665 {
4666 *palloc += 10;
4667 *pargs = xrealloc (*pargs, *palloc * sizeof (**pargs));
4668 }
4669 (*pargs)[*pcount] = type;
4670 ++*pcount;
4671 }
4672
4673 return true;
4674 }
4675
4676 /* Demangle a type. If the ptype argument is not NULL, *ptype is set
4677 to the newly allocated type. */
4678
4679 static bool
stab_demangle_type(struct stab_demangle_info * minfo,const char ** pp,debug_type * ptype)4680 stab_demangle_type (struct stab_demangle_info *minfo, const char **pp,
4681 debug_type *ptype)
4682 {
4683 const char *orig;
4684
4685 orig = *pp;
4686
4687 switch (**pp)
4688 {
4689 case 'P':
4690 case 'p':
4691 /* A pointer type. */
4692 ++*pp;
4693 if (! stab_demangle_type (minfo, pp, ptype))
4694 return false;
4695 if (ptype != NULL)
4696 *ptype = debug_make_pointer_type (minfo->dhandle, *ptype);
4697 break;
4698
4699 case 'R':
4700 /* A reference type. */
4701 ++*pp;
4702 if (! stab_demangle_type (minfo, pp, ptype))
4703 return false;
4704 if (ptype != NULL)
4705 *ptype = debug_make_reference_type (minfo->dhandle, *ptype);
4706 break;
4707
4708 case 'A':
4709 /* An array. */
4710 {
4711 unsigned long high;
4712
4713 ++*pp;
4714 high = 0;
4715 while (**pp != '\0' && **pp != '_')
4716 {
4717 if (! ISDIGIT (**pp))
4718 {
4719 stab_bad_demangle (orig);
4720 return false;
4721 }
4722 high *= 10;
4723 high += **pp - '0';
4724 ++*pp;
4725 }
4726 if (**pp != '_')
4727 {
4728 stab_bad_demangle (orig);
4729 return false;
4730 }
4731 ++*pp;
4732
4733 if (! stab_demangle_type (minfo, pp, ptype))
4734 return false;
4735 if (ptype != NULL)
4736 {
4737 debug_type int_type;
4738
4739 int_type = debug_find_named_type (minfo->dhandle, "int");
4740 if (int_type == NULL)
4741 int_type = debug_make_int_type (minfo->dhandle, 4, false);
4742 *ptype = debug_make_array_type (minfo->dhandle, *ptype, int_type,
4743 0, high, false);
4744 }
4745 }
4746 break;
4747
4748 case 'T':
4749 /* A back reference to a remembered type. */
4750 {
4751 unsigned int i;
4752 const char *p;
4753
4754 ++*pp;
4755 if (! stab_demangle_get_count (pp, &i))
4756 {
4757 stab_bad_demangle (orig);
4758 return false;
4759 }
4760 if (i >= minfo->typestring_count)
4761 {
4762 stab_bad_demangle (orig);
4763 return false;
4764 }
4765 p = minfo->typestrings[i].typestring;
4766 if (! stab_demangle_type (minfo, &p, ptype))
4767 return false;
4768 }
4769 break;
4770
4771 case 'F':
4772 /* A function. */
4773 {
4774 debug_type *args;
4775 bool varargs;
4776
4777 ++*pp;
4778 if (! stab_demangle_args (minfo, pp,
4779 (ptype == NULL
4780 ? (debug_type **) NULL
4781 : &args),
4782 (ptype == NULL
4783 ? (bool *) NULL
4784 : &varargs)))
4785 return false;
4786 if (**pp != '_')
4787 {
4788 /* cplus_demangle will accept a function without a return
4789 type, but I don't know when that will happen, or what
4790 to do if it does. */
4791 stab_bad_demangle (orig);
4792 return false;
4793 }
4794 ++*pp;
4795 if (! stab_demangle_type (minfo, pp, ptype))
4796 return false;
4797 if (ptype != NULL)
4798 *ptype = debug_make_function_type (minfo->dhandle, *ptype, args,
4799 varargs);
4800
4801 }
4802 break;
4803
4804 case 'M':
4805 case 'O':
4806 {
4807 bool memberp;
4808 debug_type class_type = DEBUG_TYPE_NULL;
4809 debug_type *args;
4810 bool varargs;
4811 unsigned int n;
4812 const char *name;
4813
4814 memberp = **pp == 'M';
4815 args = NULL;
4816 varargs = false;
4817
4818 ++*pp;
4819 if (ISDIGIT (**pp))
4820 {
4821 n = stab_demangle_count (pp);
4822 if (strlen (*pp) < n)
4823 {
4824 stab_bad_demangle (orig);
4825 return false;
4826 }
4827 name = *pp;
4828 *pp += n;
4829
4830 if (ptype != NULL)
4831 {
4832 class_type = stab_find_tagged_type (minfo->dhandle,
4833 minfo->info,
4834 name, (int) n,
4835 DEBUG_KIND_CLASS);
4836 if (class_type == DEBUG_TYPE_NULL)
4837 return false;
4838 }
4839 }
4840 else if (**pp == 'Q')
4841 {
4842 if (! stab_demangle_qualified (minfo, pp,
4843 (ptype == NULL
4844 ? (debug_type *) NULL
4845 : &class_type)))
4846 return false;
4847 }
4848 else
4849 {
4850 stab_bad_demangle (orig);
4851 return false;
4852 }
4853
4854 if (memberp)
4855 {
4856 if (**pp == 'C')
4857 {
4858 ++*pp;
4859 }
4860 else if (**pp == 'V')
4861 {
4862 ++*pp;
4863 }
4864 if (**pp != 'F')
4865 {
4866 stab_bad_demangle (orig);
4867 return false;
4868 }
4869 ++*pp;
4870 if (! stab_demangle_args (minfo, pp,
4871 (ptype == NULL
4872 ? (debug_type **) NULL
4873 : &args),
4874 (ptype == NULL
4875 ? (bool *) NULL
4876 : &varargs)))
4877 return false;
4878 }
4879
4880 if (**pp != '_')
4881 {
4882 stab_bad_demangle (orig);
4883 return false;
4884 }
4885 ++*pp;
4886
4887 if (! stab_demangle_type (minfo, pp, ptype))
4888 return false;
4889
4890 if (ptype != NULL)
4891 {
4892 if (! memberp)
4893 *ptype = debug_make_offset_type (minfo->dhandle, class_type,
4894 *ptype);
4895 else
4896 {
4897 /* FIXME: We have no way to record constp or
4898 volatilep. */
4899 *ptype = debug_make_method_type (minfo->dhandle, *ptype,
4900 class_type, args, varargs);
4901 }
4902 }
4903 }
4904 break;
4905
4906 case 'G':
4907 ++*pp;
4908 if (! stab_demangle_type (minfo, pp, ptype))
4909 return false;
4910 break;
4911
4912 case 'C':
4913 ++*pp;
4914 if (! stab_demangle_type (minfo, pp, ptype))
4915 return false;
4916 if (ptype != NULL)
4917 *ptype = debug_make_const_type (minfo->dhandle, *ptype);
4918 break;
4919
4920 case 'Q':
4921 {
4922 if (! stab_demangle_qualified (minfo, pp, ptype))
4923 return false;
4924 }
4925 break;
4926
4927 default:
4928 if (! stab_demangle_fund_type (minfo, pp, ptype))
4929 return false;
4930 break;
4931 }
4932
4933 return true;
4934 }
4935
4936 /* Demangle a fundamental type. If the ptype argument is not NULL,
4937 *ptype is set to the newly allocated type. */
4938
4939 static bool
stab_demangle_fund_type(struct stab_demangle_info * minfo,const char ** pp,debug_type * ptype)4940 stab_demangle_fund_type (struct stab_demangle_info *minfo, const char **pp,
4941 debug_type *ptype)
4942 {
4943 const char *orig;
4944 bool constp, volatilep, unsignedp, signedp;
4945 bool done;
4946
4947 orig = *pp;
4948
4949 constp = false;
4950 volatilep = false;
4951 unsignedp = false;
4952 signedp = false;
4953
4954 done = false;
4955 while (! done)
4956 {
4957 switch (**pp)
4958 {
4959 case 'C':
4960 constp = true;
4961 ++*pp;
4962 break;
4963
4964 case 'U':
4965 unsignedp = true;
4966 ++*pp;
4967 break;
4968
4969 case 'S':
4970 signedp = true;
4971 ++*pp;
4972 break;
4973
4974 case 'V':
4975 volatilep = true;
4976 ++*pp;
4977 break;
4978
4979 default:
4980 done = true;
4981 break;
4982 }
4983 }
4984
4985 switch (**pp)
4986 {
4987 case '\0':
4988 case '_':
4989 /* cplus_demangle permits this, but I don't know what it means. */
4990 stab_bad_demangle (orig);
4991 break;
4992
4993 case 'v': /* void */
4994 if (ptype != NULL)
4995 {
4996 *ptype = debug_find_named_type (minfo->dhandle, "void");
4997 if (*ptype == DEBUG_TYPE_NULL)
4998 *ptype = debug_make_void_type (minfo->dhandle);
4999 }
5000 ++*pp;
5001 break;
5002
5003 case 'x': /* long long */
5004 if (ptype != NULL)
5005 {
5006 *ptype = debug_find_named_type (minfo->dhandle,
5007 (unsignedp
5008 ? "long long unsigned int"
5009 : "long long int"));
5010 if (*ptype == DEBUG_TYPE_NULL)
5011 *ptype = debug_make_int_type (minfo->dhandle, 8, unsignedp);
5012 }
5013 ++*pp;
5014 break;
5015
5016 case 'l': /* long */
5017 if (ptype != NULL)
5018 {
5019 *ptype = debug_find_named_type (minfo->dhandle,
5020 (unsignedp
5021 ? "long unsigned int"
5022 : "long int"));
5023 if (*ptype == DEBUG_TYPE_NULL)
5024 *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
5025 }
5026 ++*pp;
5027 break;
5028
5029 case 'i': /* int */
5030 if (ptype != NULL)
5031 {
5032 *ptype = debug_find_named_type (minfo->dhandle,
5033 (unsignedp
5034 ? "unsigned int"
5035 : "int"));
5036 if (*ptype == DEBUG_TYPE_NULL)
5037 *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
5038 }
5039 ++*pp;
5040 break;
5041
5042 case 's': /* short */
5043 if (ptype != NULL)
5044 {
5045 *ptype = debug_find_named_type (minfo->dhandle,
5046 (unsignedp
5047 ? "short unsigned int"
5048 : "short int"));
5049 if (*ptype == DEBUG_TYPE_NULL)
5050 *ptype = debug_make_int_type (minfo->dhandle, 2, unsignedp);
5051 }
5052 ++*pp;
5053 break;
5054
5055 case 'b': /* bool */
5056 if (ptype != NULL)
5057 {
5058 *ptype = debug_find_named_type (minfo->dhandle, "bool");
5059 if (*ptype == DEBUG_TYPE_NULL)
5060 *ptype = debug_make_bool_type (minfo->dhandle, 4);
5061 }
5062 ++*pp;
5063 break;
5064
5065 case 'c': /* char */
5066 if (ptype != NULL)
5067 {
5068 *ptype = debug_find_named_type (minfo->dhandle,
5069 (unsignedp
5070 ? "unsigned char"
5071 : (signedp
5072 ? "signed char"
5073 : "char")));
5074 if (*ptype == DEBUG_TYPE_NULL)
5075 *ptype = debug_make_int_type (minfo->dhandle, 1, unsignedp);
5076 }
5077 ++*pp;
5078 break;
5079
5080 case 'w': /* wchar_t */
5081 if (ptype != NULL)
5082 {
5083 *ptype = debug_find_named_type (minfo->dhandle, "__wchar_t");
5084 if (*ptype == DEBUG_TYPE_NULL)
5085 *ptype = debug_make_int_type (minfo->dhandle, 2, true);
5086 }
5087 ++*pp;
5088 break;
5089
5090 case 'r': /* long double */
5091 if (ptype != NULL)
5092 {
5093 *ptype = debug_find_named_type (minfo->dhandle, "long double");
5094 if (*ptype == DEBUG_TYPE_NULL)
5095 *ptype = debug_make_float_type (minfo->dhandle, 8);
5096 }
5097 ++*pp;
5098 break;
5099
5100 case 'd': /* double */
5101 if (ptype != NULL)
5102 {
5103 *ptype = debug_find_named_type (minfo->dhandle, "double");
5104 if (*ptype == DEBUG_TYPE_NULL)
5105 *ptype = debug_make_float_type (minfo->dhandle, 8);
5106 }
5107 ++*pp;
5108 break;
5109
5110 case 'f': /* float */
5111 if (ptype != NULL)
5112 {
5113 *ptype = debug_find_named_type (minfo->dhandle, "float");
5114 if (*ptype == DEBUG_TYPE_NULL)
5115 *ptype = debug_make_float_type (minfo->dhandle, 4);
5116 }
5117 ++*pp;
5118 break;
5119
5120 case 'G':
5121 ++*pp;
5122 if (! ISDIGIT (**pp))
5123 {
5124 stab_bad_demangle (orig);
5125 return false;
5126 }
5127 /* Fall through. */
5128 case '0': case '1': case '2': case '3': case '4':
5129 case '5': case '6': case '7': case '8': case '9':
5130 {
5131 const char *hold;
5132
5133 if (! stab_demangle_class (minfo, pp, &hold))
5134 return false;
5135 if (ptype != NULL)
5136 {
5137 char *name;
5138
5139 name = savestring (minfo->dhandle, hold, *pp - hold);
5140 *ptype = debug_find_named_type (minfo->dhandle, name);
5141 if (*ptype == DEBUG_TYPE_NULL)
5142 {
5143 /* FIXME: It is probably incorrect to assume that
5144 undefined types are tagged types. */
5145 *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5146 hold, *pp - hold,
5147 DEBUG_KIND_ILLEGAL);
5148 if (*ptype == DEBUG_TYPE_NULL)
5149 return false;
5150 }
5151 }
5152 }
5153 break;
5154
5155 case 't':
5156 {
5157 char *name;
5158
5159 if (! stab_demangle_template (minfo, pp,
5160 ptype != NULL ? &name : NULL))
5161 return false;
5162 if (ptype != NULL)
5163 {
5164 *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5165 name, strlen (name),
5166 DEBUG_KIND_CLASS);
5167 if (*ptype == DEBUG_TYPE_NULL)
5168 return false;
5169 }
5170 }
5171 break;
5172
5173 default:
5174 stab_bad_demangle (orig);
5175 return false;
5176 }
5177
5178 if (ptype != NULL)
5179 {
5180 if (constp)
5181 *ptype = debug_make_const_type (minfo->dhandle, *ptype);
5182 if (volatilep)
5183 *ptype = debug_make_volatile_type (minfo->dhandle, *ptype);
5184 }
5185
5186 return true;
5187 }
5188
5189 /* Remember a type string in a demangled string. */
5190
5191 static bool
stab_demangle_remember_type(struct stab_demangle_info * minfo,const char * p,int len)5192 stab_demangle_remember_type (struct stab_demangle_info *minfo,
5193 const char *p, int len)
5194 {
5195 if (minfo->typestring_count >= minfo->typestring_alloc)
5196 {
5197 minfo->typestring_alloc += 10;
5198 minfo->typestrings
5199 = xrealloc (minfo->typestrings,
5200 minfo->typestring_alloc * sizeof (*minfo->typestrings));
5201 }
5202
5203 minfo->typestrings[minfo->typestring_count].typestring = p;
5204 minfo->typestrings[minfo->typestring_count].len = (unsigned int) len;
5205 ++minfo->typestring_count;
5206
5207 return true;
5208 }
5209
5210 /* Demangle names encoded using the g++ V3 ABI. The newer versions of
5211 g++ which use this ABI do not encode ordinary method argument types
5212 in a mangled name; they simply output the argument types. However,
5213 for a static method, g++ simply outputs the return type and the
5214 physical name. So in that case we need to demangle the name here.
5215 Here PHYSNAME is the physical name of the function, and we set the
5216 variable pointed at by PVARARGS to indicate whether this function
5217 is varargs. This returns NULL, or a NULL terminated array of
5218 argument types. */
5219
5220 static debug_type *
stab_demangle_v3_argtypes(void * dhandle,struct stab_handle * info,const char * physname,bool * pvarargs)5221 stab_demangle_v3_argtypes (void *dhandle, struct stab_handle *info,
5222 const char *physname, bool *pvarargs)
5223 {
5224 struct demangle_component *dc;
5225 void *mem;
5226 debug_type *pargs;
5227
5228 dc = cplus_demangle_v3_components (physname, DMGL_PARAMS | demangle_flags, &mem);
5229 if (dc == NULL)
5230 {
5231 stab_bad_demangle (physname);
5232 return NULL;
5233 }
5234
5235 /* We expect to see TYPED_NAME, and the right subtree describes the
5236 function type. */
5237 if (dc->type != DEMANGLE_COMPONENT_TYPED_NAME
5238 || dc->u.s_binary.right->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5239 {
5240 fprintf (stderr, _("Demangled name is not a function\n"));
5241 free (mem);
5242 return NULL;
5243 }
5244
5245 pargs = stab_demangle_v3_arglist (dhandle, info,
5246 dc->u.s_binary.right->u.s_binary.right,
5247 pvarargs);
5248
5249 free (mem);
5250
5251 return pargs;
5252 }
5253
5254 /* Demangle an argument list in a struct demangle_component tree.
5255 Returns a DEBUG_TYPE_NULL terminated array of argument types, and
5256 sets *PVARARGS to indicate whether this is a varargs function. */
5257
5258 static debug_type *
stab_demangle_v3_arglist(void * dhandle,struct stab_handle * info,struct demangle_component * arglist,bool * pvarargs)5259 stab_demangle_v3_arglist (void *dhandle, struct stab_handle *info,
5260 struct demangle_component *arglist,
5261 bool *pvarargs)
5262 {
5263 struct demangle_component *dc;
5264 unsigned int alloc, count;
5265 debug_type *pargs, *xargs;
5266
5267 alloc = 10;
5268 pargs = xmalloc (alloc * sizeof (*pargs));
5269 *pvarargs = false;
5270
5271 count = 0;
5272
5273 for (dc = arglist;
5274 dc != NULL;
5275 dc = dc->u.s_binary.right)
5276 {
5277 debug_type arg;
5278 bool varargs;
5279
5280 if (dc->type != DEMANGLE_COMPONENT_ARGLIST)
5281 {
5282 fprintf (stderr, _("Unexpected type in v3 arglist demangling\n"));
5283 free (pargs);
5284 return NULL;
5285 }
5286
5287 /* PR 13925: Cope if the demangler returns an empty
5288 context for a function with no arguments. */
5289 if (dc->u.s_binary.left == NULL)
5290 break;
5291
5292 arg = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5293 NULL, &varargs);
5294 if (arg == NULL)
5295 {
5296 if (varargs)
5297 {
5298 *pvarargs = true;
5299 continue;
5300 }
5301 free (pargs);
5302 return NULL;
5303 }
5304
5305 if (count + 1 >= alloc)
5306 {
5307 alloc += 10;
5308 pargs = xrealloc (pargs, alloc * sizeof (*pargs));
5309 }
5310
5311 pargs[count] = arg;
5312 ++count;
5313 }
5314
5315 pargs[count] = DEBUG_TYPE_NULL;
5316 xargs = debug_xalloc (dhandle, (count + 1) * sizeof (*pargs));
5317 memcpy (xargs, pargs, (count + 1) * sizeof (*pargs));
5318 free (pargs);
5319
5320 return xargs;
5321 }
5322
5323 /* Convert a struct demangle_component tree describing an argument
5324 type into a debug_type. */
5325
5326 static debug_type
stab_demangle_v3_arg(void * dhandle,struct stab_handle * info,struct demangle_component * dc,debug_type context,bool * pvarargs)5327 stab_demangle_v3_arg (void *dhandle, struct stab_handle *info,
5328 struct demangle_component *dc, debug_type context,
5329 bool *pvarargs)
5330 {
5331 debug_type dt;
5332
5333 if (pvarargs != NULL)
5334 *pvarargs = false;
5335
5336 switch (dc->type)
5337 {
5338 /* FIXME: These are demangle component types which we probably
5339 need to handle one way or another. */
5340 case DEMANGLE_COMPONENT_LOCAL_NAME:
5341 case DEMANGLE_COMPONENT_TYPED_NAME:
5342 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
5343 case DEMANGLE_COMPONENT_CTOR:
5344 case DEMANGLE_COMPONENT_DTOR:
5345 case DEMANGLE_COMPONENT_JAVA_CLASS:
5346 case DEMANGLE_COMPONENT_RESTRICT_THIS:
5347 case DEMANGLE_COMPONENT_VOLATILE_THIS:
5348 case DEMANGLE_COMPONENT_CONST_THIS:
5349 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5350 case DEMANGLE_COMPONENT_COMPLEX:
5351 case DEMANGLE_COMPONENT_IMAGINARY:
5352 case DEMANGLE_COMPONENT_VENDOR_TYPE:
5353 case DEMANGLE_COMPONENT_ARRAY_TYPE:
5354 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5355 case DEMANGLE_COMPONENT_ARGLIST:
5356 default:
5357 fprintf (stderr, _("Unrecognized demangle component %d\n"),
5358 (int) dc->type);
5359 return NULL;
5360
5361 case DEMANGLE_COMPONENT_NAME:
5362 if (context != NULL)
5363 {
5364 const debug_field *fields;
5365
5366 fields = debug_get_fields (dhandle, context);
5367 if (fields != NULL)
5368 {
5369 /* Try to find this type by looking through the context
5370 class. */
5371 for (; *fields != DEBUG_FIELD_NULL; fields++)
5372 {
5373 debug_type ft;
5374 const char *dn;
5375
5376 ft = debug_get_field_type (dhandle, *fields);
5377 if (ft == NULL)
5378 return NULL;
5379 dn = debug_get_type_name (dhandle, ft);
5380 if (dn != NULL
5381 && (int) strlen (dn) == dc->u.s_name.len
5382 && strncmp (dn, dc->u.s_name.s, dc->u.s_name.len) == 0)
5383 return ft;
5384 }
5385 }
5386 }
5387 return stab_find_tagged_type (dhandle, info, dc->u.s_name.s,
5388 dc->u.s_name.len, DEBUG_KIND_ILLEGAL);
5389
5390 case DEMANGLE_COMPONENT_QUAL_NAME:
5391 context = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5392 context, NULL);
5393 if (context == NULL)
5394 return NULL;
5395 return stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.right,
5396 context, NULL);
5397
5398 case DEMANGLE_COMPONENT_TEMPLATE:
5399 {
5400 char *p;
5401 size_t alc;
5402
5403 /* We print this component to get a class name which we can
5404 use. FIXME: This probably won't work if the template uses
5405 template parameters which refer to an outer template. */
5406 p = cplus_demangle_print (DMGL_PARAMS | demangle_flags, dc, 20, &alc);
5407 if (p == NULL)
5408 {
5409 fprintf (stderr, _("Failed to print demangled template\n"));
5410 return NULL;
5411 }
5412 dt = stab_find_tagged_type (dhandle, info, p, strlen (p),
5413 DEBUG_KIND_CLASS);
5414 free (p);
5415 return dt;
5416 }
5417
5418 case DEMANGLE_COMPONENT_SUB_STD:
5419 return stab_find_tagged_type (dhandle, info, dc->u.s_string.string,
5420 dc->u.s_string.len, DEBUG_KIND_ILLEGAL);
5421
5422 case DEMANGLE_COMPONENT_RESTRICT:
5423 case DEMANGLE_COMPONENT_VOLATILE:
5424 case DEMANGLE_COMPONENT_CONST:
5425 case DEMANGLE_COMPONENT_POINTER:
5426 case DEMANGLE_COMPONENT_REFERENCE:
5427 dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5428 NULL);
5429 if (dt == NULL)
5430 return NULL;
5431
5432 switch (dc->type)
5433 {
5434 default:
5435 abort ();
5436 case DEMANGLE_COMPONENT_RESTRICT:
5437 /* FIXME: We have no way to represent restrict. */
5438 return dt;
5439 case DEMANGLE_COMPONENT_VOLATILE:
5440 return debug_make_volatile_type (dhandle, dt);
5441 case DEMANGLE_COMPONENT_CONST:
5442 return debug_make_const_type (dhandle, dt);
5443 case DEMANGLE_COMPONENT_POINTER:
5444 return debug_make_pointer_type (dhandle, dt);
5445 case DEMANGLE_COMPONENT_REFERENCE:
5446 return debug_make_reference_type (dhandle, dt);
5447 }
5448
5449 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
5450 {
5451 debug_type *pargs;
5452 bool varargs;
5453
5454 if (dc->u.s_binary.left == NULL)
5455 {
5456 /* In this case the return type is actually unknown.
5457 However, I'm not sure this will ever arise in practice;
5458 normally an unknown return type would only appear at
5459 the top level, which is handled above. */
5460 dt = debug_make_void_type (dhandle);
5461 }
5462 else
5463 dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5464 NULL);
5465 if (dt == NULL)
5466 return NULL;
5467
5468 pargs = stab_demangle_v3_arglist (dhandle, info,
5469 dc->u.s_binary.right,
5470 &varargs);
5471 if (pargs == NULL)
5472 return NULL;
5473
5474 return debug_make_function_type (dhandle, dt, pargs, varargs);
5475 }
5476
5477 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
5478 {
5479 char *p;
5480 size_t alc;
5481 debug_type ret;
5482
5483 /* We print this component in order to find out the type name.
5484 FIXME: Should we instead expose the
5485 demangle_builtin_type_info structure? */
5486 p = cplus_demangle_print (DMGL_PARAMS | demangle_flags, dc, 20, &alc);
5487 if (p == NULL)
5488 {
5489 fprintf (stderr, _("Couldn't get demangled builtin type\n"));
5490 return NULL;
5491 }
5492
5493 /* The mangling is based on the type, but does not itself
5494 indicate what the sizes are. So we have to guess. */
5495 if (strcmp (p, "signed char") == 0)
5496 ret = debug_make_int_type (dhandle, 1, false);
5497 else if (strcmp (p, "bool") == 0)
5498 ret = debug_make_bool_type (dhandle, 1);
5499 else if (strcmp (p, "char") == 0)
5500 ret = debug_make_int_type (dhandle, 1, false);
5501 else if (strcmp (p, "double") == 0)
5502 ret = debug_make_float_type (dhandle, 8);
5503 else if (strcmp (p, "long double") == 0)
5504 ret = debug_make_float_type (dhandle, 8);
5505 else if (strcmp (p, "float") == 0)
5506 ret = debug_make_float_type (dhandle, 4);
5507 else if (strcmp (p, "__float128") == 0)
5508 ret = debug_make_float_type (dhandle, 16);
5509 else if (strcmp (p, "unsigned char") == 0)
5510 ret = debug_make_int_type (dhandle, 1, true);
5511 else if (strcmp (p, "int") == 0)
5512 ret = debug_make_int_type (dhandle, 4, false);
5513 else if (strcmp (p, "unsigned int") == 0)
5514 ret = debug_make_int_type (dhandle, 4, true);
5515 else if (strcmp (p, "long") == 0)
5516 ret = debug_make_int_type (dhandle, 4, false);
5517 else if (strcmp (p, "unsigned long") == 0)
5518 ret = debug_make_int_type (dhandle, 4, true);
5519 else if (strcmp (p, "__int128") == 0)
5520 ret = debug_make_int_type (dhandle, 16, false);
5521 else if (strcmp (p, "unsigned __int128") == 0)
5522 ret = debug_make_int_type (dhandle, 16, true);
5523 else if (strcmp (p, "short") == 0)
5524 ret = debug_make_int_type (dhandle, 2, false);
5525 else if (strcmp (p, "unsigned short") == 0)
5526 ret = debug_make_int_type (dhandle, 2, true);
5527 else if (strcmp (p, "void") == 0)
5528 ret = debug_make_void_type (dhandle);
5529 else if (strcmp (p, "wchar_t") == 0)
5530 ret = debug_make_int_type (dhandle, 4, true);
5531 else if (strcmp (p, "long long") == 0)
5532 ret = debug_make_int_type (dhandle, 8, false);
5533 else if (strcmp (p, "unsigned long long") == 0)
5534 ret = debug_make_int_type (dhandle, 8, true);
5535 else if (strcmp (p, "...") == 0)
5536 {
5537 if (pvarargs == NULL)
5538 fprintf (stderr, _("Unexpected demangled varargs\n"));
5539 else
5540 *pvarargs = true;
5541 ret = NULL;
5542 }
5543 else
5544 {
5545 fprintf (stderr, _("Unrecognized demangled builtin type\n"));
5546 ret = NULL;
5547 }
5548
5549 free (p);
5550
5551 return ret;
5552 }
5553 }
5554 }
5555