GDB (xrefs)
/tmp/gdb-7.10/gdb/stabsread.c
Go to the documentation of this file.
1 /* Support routines for decoding "stabs" debugging information format.
2 
3  Copyright (C) 1986-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
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, see <http://www.gnu.org/licenses/>. */
19 
20 /* Support routines for reading and decoding debugging information in
21  the "stabs" format. This format is used with many systems that use
22  the a.out object file format, as well as some systems that use
23  COFF or ELF where the stabs data is placed in a special section.
24  Avoid placing any object file format specific code in this file. */
25 
26 #include "defs.h"
27 #include "bfd.h"
28 #include "gdb_obstack.h"
29 #include "symtab.h"
30 #include "gdbtypes.h"
31 #include "expression.h"
32 #include "symfile.h"
33 #include "objfiles.h"
34 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native. */
35 #include "libaout.h"
36 #include "aout/aout64.h"
37 #include "gdb-stabs.h"
38 #include "buildsym.h"
39 #include "complaints.h"
40 #include "demangle.h"
41 #include "gdb-demangle.h"
42 #include "language.h"
43 #include "doublest.h"
44 #include "cp-abi.h"
45 #include "cp-support.h"
46 #include <ctype.h>
47 
48 /* Ask stabsread.h to define the vars it normally declares `extern'. */
49 #define EXTERN
50 
51 #include "stabsread.h" /* Our own declarations */
52 #undef EXTERN
53 
54 extern void _initialize_stabsread (void);
55 
56 struct nextfield
57 {
58  struct nextfield *next;
59 
60  /* This is the raw visibility from the stab. It is not checked
61  for being one of the visibilities we recognize, so code which
62  examines this field better be able to deal. */
64 
65  struct field field;
66 };
67 
69 {
72 };
73 
74 /* The routines that read and process a complete stabs for a C struct or
75  C++ class pass lists of data member fields and lists of member function
76  fields in an instance of a field_info structure, as defined below.
77  This is part of some reorganization of low level C++ support and is
78  expected to eventually go away... (FIXME) */
79 
80 struct field_info
81  {
82  struct nextfield *list;
84  };
85 
86 static void
87 read_one_struct_field (struct field_info *, char **, char *,
88  struct type *, struct objfile *);
89 
90 static struct type *dbx_alloc_type (int[2], struct objfile *);
91 
92 static long read_huge_number (char **, int, int *, int);
93 
94 static struct type *error_type (char **, struct objfile *);
95 
96 static void
97 patch_block_stabs (struct pending *, struct pending_stabs *,
98  struct objfile *);
99 
100 static void fix_common_block (struct symbol *, CORE_ADDR);
101 
102 static int read_type_number (char **, int *);
103 
104 static struct type *read_type (char **, struct objfile *);
105 
106 static struct type *read_range_type (char **, int[2], int, struct objfile *);
107 
108 static struct type *read_sun_builtin_type (char **, int[2], struct objfile *);
109 
110 static struct type *read_sun_floating_type (char **, int[2],
111  struct objfile *);
112 
113 static struct type *read_enum_type (char **, struct type *, struct objfile *);
114 
115 static struct type *rs6000_builtin_type (int, struct objfile *);
116 
117 static int
118 read_member_functions (struct field_info *, char **, struct type *,
119  struct objfile *);
120 
121 static int
122 read_struct_fields (struct field_info *, char **, struct type *,
123  struct objfile *);
124 
125 static int
126 read_baseclasses (struct field_info *, char **, struct type *,
127  struct objfile *);
128 
129 static int
130 read_tilde_fields (struct field_info *, char **, struct type *,
131  struct objfile *);
132 
133 static int attach_fn_fields_to_type (struct field_info *, struct type *);
134 
135 static int attach_fields_to_type (struct field_info *, struct type *,
136  struct objfile *);
137 
138 static struct type *read_struct_type (char **, struct type *,
139  enum type_code,
140  struct objfile *);
141 
142 static struct type *read_array_type (char **, struct type *,
143  struct objfile *);
144 
145 static struct field *read_args (char **, int, struct objfile *, int *, int *);
146 
147 static void add_undefined_type (struct type *, int[2]);
148 
149 static int
150 read_cpp_abbrev (struct field_info *, char **, struct type *,
151  struct objfile *);
152 
153 static char *find_name_end (char *name);
154 
155 static int process_reference (char **string);
156 
157 void stabsread_clear_cache (void);
158 
159 static const char vptr_name[] = "_vptr$";
160 static const char vb_name[] = "_vb$";
161 
162 static void
164 {
165  complaint (&symfile_complaints, _("invalid C++ abbreviation `%s'"), arg1);
166 }
167 
168 static void
169 reg_value_complaint (int regnum, int num_regs, const char *sym)
170 {
172  _("register number %d too large (max %d) in symbol %s"),
173  regnum, num_regs - 1, sym);
174 }
175 
176 static void
177 stabs_general_complaint (const char *arg1)
178 {
179  complaint (&symfile_complaints, "%s", arg1);
180 }
181 
182 /* Make a list of forward references which haven't been defined. */
183 
184 static struct type **undef_types;
187 static struct symbol *current_symbol = NULL;
188 
189 /* Make a list of nameless types that are undefined.
190  This happens when another type is referenced by its number
191  before this type is actually defined. For instance "t(0,1)=k(0,2)"
192  and type (0,2) is defined only later. */
193 
194 struct nat
195 {
196  int typenums[2];
197  struct type *type;
198 };
199 static struct nat *noname_undefs;
202 
203 /* Check for and handle cretinous stabs symbol name continuation! */
204 #define STABS_CONTINUE(pp,objfile) \
205  do { \
206  if (**(pp) == '\\' || (**(pp) == '?' && (*(pp))[1] == '\0')) \
207  *(pp) = next_symbol_text (objfile); \
208  } while (0)
209 
210 /* Vector of types defined so far, indexed by their type numbers.
211  (In newer sun systems, dbx uses a pair of numbers in parens,
212  as in "(SUBFILENUM,NUMWITHINSUBFILE)".
213  Then these numbers must be translated through the type_translations
214  hash table to get the index into the type vector.) */
215 
216 static struct type **type_vector;
217 
218 /* Number of elements allocated for type_vector currently. */
219 
221 
222 /* Initial size of type vector. Is realloc'd larger if needed, and
223  realloc'd down to the size actually used, when completed. */
224 
225 #define INITIAL_TYPE_VECTOR_LENGTH 160
226 
227 
228 /* Look up a dbx type-number pair. Return the address of the slot
229  where the type for that number-pair is stored.
230  The number-pair is in TYPENUMS.
231 
232  This can be used for finding the type associated with that pair
233  or for associating a new type with the pair. */
234 
235 static struct type **
236 dbx_lookup_type (int typenums[2], struct objfile *objfile)
237 {
238  int filenum = typenums[0];
239  int index = typenums[1];
240  unsigned old_len;
241  int real_filenum;
242  struct header_file *f;
243  int f_orig_length;
244 
245  if (filenum == -1) /* -1,-1 is for temporary types. */
246  return 0;
247 
248  if (filenum < 0 || filenum >= n_this_object_header_files)
249  {
251  _("Invalid symbol data: type number "
252  "(%d,%d) out of range at symtab pos %d."),
253  filenum, index, symnum);
254  goto error_return;
255  }
256 
257  if (filenum == 0)
258  {
259  if (index < 0)
260  {
261  /* Caller wants address of address of type. We think
262  that negative (rs6k builtin) types will never appear as
263  "lvalues", (nor should they), so we stuff the real type
264  pointer into a temp, and return its address. If referenced,
265  this will do the right thing. */
266  static struct type *temp_type;
267 
268  temp_type = rs6000_builtin_type (index, objfile);
269  return &temp_type;
270  }
271 
272  /* Type is defined outside of header files.
273  Find it in this object file's type vector. */
274  if (index >= type_vector_length)
275  {
276  old_len = type_vector_length;
277  if (old_len == 0)
278  {
280  type_vector = (struct type **)
281  xmalloc (type_vector_length * sizeof (struct type *));
282  }
283  while (index >= type_vector_length)
284  {
285  type_vector_length *= 2;
286  }
287  type_vector = (struct type **)
288  xrealloc ((char *) type_vector,
289  (type_vector_length * sizeof (struct type *)));
290  memset (&type_vector[old_len], 0,
291  (type_vector_length - old_len) * sizeof (struct type *));
292  }
293  return (&type_vector[index]);
294  }
295  else
296  {
297  real_filenum = this_object_header_files[filenum];
298 
299  if (real_filenum >= N_HEADER_FILES (objfile))
300  {
301  static struct type *temp_type;
302 
303  warning (_("GDB internal error: bad real_filenum"));
304 
305  error_return:
306  temp_type = objfile_type (objfile)->builtin_error;
307  return &temp_type;
308  }
309 
310  f = HEADER_FILES (objfile) + real_filenum;
311 
312  f_orig_length = f->length;
313  if (index >= f_orig_length)
314  {
315  while (index >= f->length)
316  {
317  f->length *= 2;
318  }
319  f->vector = (struct type **)
320  xrealloc ((char *) f->vector, f->length * sizeof (struct type *));
321  memset (&f->vector[f_orig_length], 0,
322  (f->length - f_orig_length) * sizeof (struct type *));
323  }
324  return (&f->vector[index]);
325  }
326 }
327 
328 /* Make sure there is a type allocated for type numbers TYPENUMS
329  and return the type object.
330  This can create an empty (zeroed) type object.
331  TYPENUMS may be (-1, -1) to return a new type object that is not
332  put into the type vector, and so may not be referred to by number. */
333 
334 static struct type *
335 dbx_alloc_type (int typenums[2], struct objfile *objfile)
336 {
337  struct type **type_addr;
338 
339  if (typenums[0] == -1)
340  {
341  return (alloc_type (objfile));
342  }
343 
344  type_addr = dbx_lookup_type (typenums, objfile);
345 
346  /* If we are referring to a type not known at all yet,
347  allocate an empty type for it.
348  We will fill it in later if we find out how. */
349  if (*type_addr == 0)
350  {
351  *type_addr = alloc_type (objfile);
352  }
353 
354  return (*type_addr);
355 }
356 
357 /* for all the stabs in a given stab vector, build appropriate types
358  and fix their symbols in given symbol vector. */
359 
360 static void
361 patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
362  struct objfile *objfile)
363 {
364  int ii;
365  char *name;
366  char *pp;
367  struct symbol *sym;
368 
369  if (stabs)
370  {
371  /* for all the stab entries, find their corresponding symbols and
372  patch their types! */
373 
374  for (ii = 0; ii < stabs->count; ++ii)
375  {
376  name = stabs->stab[ii];
377  pp = (char *) strchr (name, ':');
378  gdb_assert (pp); /* Must find a ':' or game's over. */
379  while (pp[1] == ':')
380  {
381  pp += 2;
382  pp = (char *) strchr (pp, ':');
383  }
384  sym = find_symbol_in_list (symbols, name, pp - name);
385  if (!sym)
386  {
387  /* FIXME-maybe: it would be nice if we noticed whether
388  the variable was defined *anywhere*, not just whether
389  it is defined in this compilation unit. But neither
390  xlc or GCC seem to need such a definition, and until
391  we do psymtabs (so that the minimal symbols from all
392  compilation units are available now), I'm not sure
393  how to get the information. */
394 
395  /* On xcoff, if a global is defined and never referenced,
396  ld will remove it from the executable. There is then
397  a N_GSYM stab for it, but no regular (C_EXT) symbol. */
398  sym = allocate_symbol (objfile);
399  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
402  (sym, obstack_copy0 (&objfile->objfile_obstack,
403  name, pp - name));
404  pp += 2;
405  if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
406  {
407  /* I don't think the linker does this with functions,
408  so as far as I know this is never executed.
409  But it doesn't hurt to check. */
410  SYMBOL_TYPE (sym) =
411  lookup_function_type (read_type (&pp, objfile));
412  }
413  else
414  {
415  SYMBOL_TYPE (sym) = read_type (&pp, objfile);
416  }
418  }
419  else
420  {
421  pp += 2;
422  if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
423  {
424  SYMBOL_TYPE (sym) =
425  lookup_function_type (read_type (&pp, objfile));
426  }
427  else
428  {
429  SYMBOL_TYPE (sym) = read_type (&pp, objfile);
430  }
431  }
432  }
433  }
434 }
435 
436 
437 /* Read a number by which a type is referred to in dbx data,
438  or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
439  Just a single number N is equivalent to (0,N).
440  Return the two numbers by storing them in the vector TYPENUMS.
441  TYPENUMS will then be used as an argument to dbx_lookup_type.
442 
443  Returns 0 for success, -1 for error. */
444 
445 static int
446 read_type_number (char **pp, int *typenums)
447 {
448  int nbits;
449 
450  if (**pp == '(')
451  {
452  (*pp)++;
453  typenums[0] = read_huge_number (pp, ',', &nbits, 0);
454  if (nbits != 0)
455  return -1;
456  typenums[1] = read_huge_number (pp, ')', &nbits, 0);
457  if (nbits != 0)
458  return -1;
459  }
460  else
461  {
462  typenums[0] = 0;
463  typenums[1] = read_huge_number (pp, 0, &nbits, 0);
464  if (nbits != 0)
465  return -1;
466  }
467  return 0;
468 }
469 
470 
471 #define VISIBILITY_PRIVATE '0' /* Stabs character for private field */
472 #define VISIBILITY_PROTECTED '1' /* Stabs character for protected fld */
473 #define VISIBILITY_PUBLIC '2' /* Stabs character for public field */
474 #define VISIBILITY_IGNORE '9' /* Optimized out or zero length */
475 
476 /* Structure for storing pointers to reference definitions for fast lookup
477  during "process_later". */
478 
479 struct ref_map
480 {
481  char *stabs;
483  struct symbol *sym;
484 };
485 
486 #define MAX_CHUNK_REFS 100
487 #define REF_CHUNK_SIZE (MAX_CHUNK_REFS * sizeof (struct ref_map))
488 #define REF_MAP_SIZE(ref_chunk) ((ref_chunk) * REF_CHUNK_SIZE)
489 
490 static struct ref_map *ref_map;
491 
492 /* Ptr to free cell in chunk's linked list. */
493 static int ref_count = 0;
494 
495 /* Number of chunks malloced. */
496 static int ref_chunk = 0;
497 
498 /* This file maintains a cache of stabs aliases found in the symbol
499  table. If the symbol table changes, this cache must be cleared
500  or we are left holding onto data in invalid obstacks. */
501 void
503 {
504  ref_count = 0;
505  ref_chunk = 0;
506 }
507 
508 /* Create array of pointers mapping refids to symbols and stab strings.
509  Add pointers to reference definition symbols and/or their values as we
510  find them, using their reference numbers as our index.
511  These will be used later when we resolve references. */
512 void
513 ref_add (int refnum, struct symbol *sym, char *stabs, CORE_ADDR value)
514 {
515  if (ref_count == 0)
516  ref_chunk = 0;
517  if (refnum >= ref_count)
518  ref_count = refnum + 1;
520  {
521  int new_slots = ref_count - ref_chunk * MAX_CHUNK_REFS;
522  int new_chunks = new_slots / MAX_CHUNK_REFS + 1;
523 
524  ref_map = (struct ref_map *)
525  xrealloc (ref_map, REF_MAP_SIZE (ref_chunk + new_chunks));
526  memset (ref_map + ref_chunk * MAX_CHUNK_REFS, 0,
527  new_chunks * REF_CHUNK_SIZE);
528  ref_chunk += new_chunks;
529  }
530  ref_map[refnum].stabs = stabs;
531  ref_map[refnum].sym = sym;
532  ref_map[refnum].value = value;
533 }
534 
535 /* Return defined sym for the reference REFNUM. */
536 struct symbol *
537 ref_search (int refnum)
538 {
539  if (refnum < 0 || refnum > ref_count)
540  return 0;
541  return ref_map[refnum].sym;
542 }
543 
544 /* Parse a reference id in STRING and return the resulting
545  reference number. Move STRING beyond the reference id. */
546 
547 static int
548 process_reference (char **string)
549 {
550  char *p;
551  int refnum = 0;
552 
553  if (**string != '#')
554  return 0;
555 
556  /* Advance beyond the initial '#'. */
557  p = *string + 1;
558 
559  /* Read number as reference id. */
560  while (*p && isdigit (*p))
561  {
562  refnum = refnum * 10 + *p - '0';
563  p++;
564  }
565  *string = p;
566  return refnum;
567 }
568 
569 /* If STRING defines a reference, store away a pointer to the reference
570  definition for later use. Return the reference number. */
571 
572 int
574 {
575  char *p = *string;
576  int refnum = 0;
577 
578  refnum = process_reference (&p);
579 
580  /* Defining symbols end in '='. */
581  if (*p == '=')
582  {
583  /* Symbol is being defined here. */
584  *string = p + 1;
585  return refnum;
586  }
587  else
588  {
589  /* Must be a reference. Either the symbol has already been defined,
590  or this is a forward reference to it. */
591  *string = p;
592  return -1;
593  }
594 }
595 
596 static int
597 stab_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
598 {
599  int regno = gdbarch_stab_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
600 
601  if (regno >= gdbarch_num_regs (gdbarch)
602  + gdbarch_num_pseudo_regs (gdbarch))
603  {
604  reg_value_complaint (regno,
605  gdbarch_num_regs (gdbarch)
606  + gdbarch_num_pseudo_regs (gdbarch),
607  SYMBOL_PRINT_NAME (sym));
608 
609  regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless. */
610  }
611 
612  return regno;
613 }
614 
615 static const struct symbol_register_ops stab_register_funcs = {
617 };
618 
619 /* The "aclass" indices for computed symbols. */
620 
623 
624 struct symbol *
625 define_symbol (CORE_ADDR valu, char *string, int desc, int type,
626  struct objfile *objfile)
627 {
628  struct gdbarch *gdbarch = get_objfile_arch (objfile);
629  struct symbol *sym;
630  char *p = (char *) find_name_end (string);
631  int deftype;
632  int synonym = 0;
633  int i;
634  char *new_name = NULL;
635 
636  /* We would like to eliminate nameless symbols, but keep their types.
637  E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
638  to type 2, but, should not create a symbol to address that type. Since
639  the symbol will be nameless, there is no way any user can refer to it. */
640 
641  int nameless;
642 
643  /* Ignore syms with empty names. */
644  if (string[0] == 0)
645  return 0;
646 
647  /* Ignore old-style symbols from cc -go. */
648  if (p == 0)
649  return 0;
650 
651  while (p[1] == ':')
652  {
653  p += 2;
654  p = strchr (p, ':');
655  if (p == NULL)
656  {
658  _("Bad stabs string '%s'"), string);
659  return NULL;
660  }
661  }
662 
663  /* If a nameless stab entry, all we need is the type, not the symbol.
664  e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
665  nameless = (p == string || ((string[0] == ' ') && (string[1] == ':')));
666 
667  current_symbol = sym = allocate_symbol (objfile);
668 
670  {
671  /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
672  number of bytes occupied by a type or object, which we ignore. */
673  SYMBOL_LINE (sym) = desc;
674  }
675  else
676  {
677  SYMBOL_LINE (sym) = 0; /* unknown */
678  }
679 
681  &objfile->objfile_obstack);
682 
683  if (is_cplus_marker (string[0]))
684  {
685  /* Special GNU C++ names. */
686  switch (string[1])
687  {
688  case 't':
689  SYMBOL_SET_LINKAGE_NAME (sym, "this");
690  break;
691 
692  case 'v': /* $vtbl_ptr_type */
693  goto normal;
694 
695  case 'e':
696  SYMBOL_SET_LINKAGE_NAME (sym, "eh_throw");
697  break;
698 
699  case '_':
700  /* This was an anonymous type that was never fixed up. */
701  goto normal;
702 
703  case 'X':
704  /* SunPRO (3.0 at least) static variable encoding. */
705  if (gdbarch_static_transform_name_p (gdbarch))
706  goto normal;
707  /* ... fall through ... */
708 
709  default:
710  complaint (&symfile_complaints, _("Unknown C++ symbol name `%s'"),
711  string);
712  goto normal; /* Do *something* with it. */
713  }
714  }
715  else
716  {
717  normal:
718  if (SYMBOL_LANGUAGE (sym) == language_cplus)
719  {
720  char *name = alloca (p - string + 1);
721 
722  memcpy (name, string, p - string);
723  name[p - string] = '\0';
724  new_name = cp_canonicalize_string (name);
725  }
726  if (new_name != NULL)
727  {
728  SYMBOL_SET_NAMES (sym, new_name, strlen (new_name), 1, objfile);
729  xfree (new_name);
730  }
731  else
732  SYMBOL_SET_NAMES (sym, string, p - string, 1, objfile);
733 
734  if (SYMBOL_LANGUAGE (sym) == language_cplus)
735  cp_scan_for_anonymous_namespaces (sym, objfile);
736 
737  }
738  p++;
739 
740  /* Determine the type of name being defined. */
741 #if 0
742  /* Getting GDB to correctly skip the symbol on an undefined symbol
743  descriptor and not ever dump core is a very dodgy proposition if
744  we do things this way. I say the acorn RISC machine can just
745  fix their compiler. */
746  /* The Acorn RISC machine's compiler can put out locals that don't
747  start with "234=" or "(3,4)=", so assume anything other than the
748  deftypes we know how to handle is a local. */
749  if (!strchr ("cfFGpPrStTvVXCR", *p))
750 #else
751  if (isdigit (*p) || *p == '(' || *p == '-')
752 #endif
753  deftype = 'l';
754  else
755  deftype = *p++;
756 
757  switch (deftype)
758  {
759  case 'c':
760  /* c is a special case, not followed by a type-number.
761  SYMBOL:c=iVALUE for an integer constant symbol.
762  SYMBOL:c=rVALUE for a floating constant symbol.
763  SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
764  e.g. "b:c=e6,0" for "const b = blob1"
765  (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
766  if (*p != '=')
767  {
769  SYMBOL_TYPE (sym) = error_type (&p, objfile);
770  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
772  return sym;
773  }
774  ++p;
775  switch (*p++)
776  {
777  case 'r':
778  {
779  double d = atof (p);
780  gdb_byte *dbl_valu;
781  struct type *dbl_type;
782 
783  /* FIXME-if-picky-about-floating-accuracy: Should be using
784  target arithmetic to get the value. real.c in GCC
785  probably has the necessary code. */
786 
787  dbl_type = objfile_type (objfile)->builtin_double;
788  dbl_valu =
789  obstack_alloc (&objfile->objfile_obstack,
790  TYPE_LENGTH (dbl_type));
791  store_typed_floating (dbl_valu, dbl_type, d);
792 
793  SYMBOL_TYPE (sym) = dbl_type;
794  SYMBOL_VALUE_BYTES (sym) = dbl_valu;
796  }
797  break;
798  case 'i':
799  {
800  /* Defining integer constants this way is kind of silly,
801  since 'e' constants allows the compiler to give not
802  only the value, but the type as well. C has at least
803  int, long, unsigned int, and long long as constant
804  types; other languages probably should have at least
805  unsigned as well as signed constants. */
806 
807  SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_long;
808  SYMBOL_VALUE (sym) = atoi (p);
810  }
811  break;
812 
813  case 'c':
814  {
815  SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_char;
816  SYMBOL_VALUE (sym) = atoi (p);
818  }
819  break;
820 
821  case 's':
822  {
823  struct type *range_type;
824  int ind = 0;
825  char quote = *p++;
826  gdb_byte *string_local = (gdb_byte *) alloca (strlen (p));
827  gdb_byte *string_value;
828 
829  if (quote != '\'' && quote != '"')
830  {
832  SYMBOL_TYPE (sym) = error_type (&p, objfile);
833  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
835  return sym;
836  }
837 
838  /* Find matching quote, rejecting escaped quotes. */
839  while (*p && *p != quote)
840  {
841  if (*p == '\\' && p[1] == quote)
842  {
843  string_local[ind] = (gdb_byte) quote;
844  ind++;
845  p += 2;
846  }
847  else if (*p)
848  {
849  string_local[ind] = (gdb_byte) (*p);
850  ind++;
851  p++;
852  }
853  }
854  if (*p != quote)
855  {
857  SYMBOL_TYPE (sym) = error_type (&p, objfile);
858  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
860  return sym;
861  }
862 
863  /* NULL terminate the string. */
864  string_local[ind] = 0;
865  range_type
866  = create_static_range_type (NULL,
867  objfile_type (objfile)->builtin_int,
868  0, ind);
869  SYMBOL_TYPE (sym) = create_array_type (NULL,
870  objfile_type (objfile)->builtin_char,
871  range_type);
872  string_value = obstack_alloc (&objfile->objfile_obstack, ind + 1);
873  memcpy (string_value, string_local, ind + 1);
874  p++;
875 
876  SYMBOL_VALUE_BYTES (sym) = string_value;
878  }
879  break;
880 
881  case 'e':
882  /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
883  can be represented as integral.
884  e.g. "b:c=e6,0" for "const b = blob1"
885  (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
886  {
888  SYMBOL_TYPE (sym) = read_type (&p, objfile);
889 
890  if (*p != ',')
891  {
892  SYMBOL_TYPE (sym) = error_type (&p, objfile);
893  break;
894  }
895  ++p;
896 
897  /* If the value is too big to fit in an int (perhaps because
898  it is unsigned), or something like that, we silently get
899  a bogus value. The type and everything else about it is
900  correct. Ideally, we should be using whatever we have
901  available for parsing unsigned and long long values,
902  however. */
903  SYMBOL_VALUE (sym) = atoi (p);
904  }
905  break;
906  default:
907  {
909  SYMBOL_TYPE (sym) = error_type (&p, objfile);
910  }
911  }
912  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
914  return sym;
915 
916  case 'C':
917  /* The name of a caught exception. */
918  SYMBOL_TYPE (sym) = read_type (&p, objfile);
920  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
921  SYMBOL_VALUE_ADDRESS (sym) = valu;
923  break;
924 
925  case 'f':
926  /* A static function definition. */
927  SYMBOL_TYPE (sym) = read_type (&p, objfile);
929  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
931  /* fall into process_function_types. */
932 
933  process_function_types:
934  /* Function result types are described as the result type in stabs.
935  We need to convert this to the function-returning-type-X type
936  in GDB. E.g. "int" is converted to "function returning int". */
937  if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_FUNC)
939 
940  /* All functions in C++ have prototypes. Stabs does not offer an
941  explicit way to identify prototyped or unprototyped functions,
942  but both GCC and Sun CC emit stabs for the "call-as" type rather
943  than the "declared-as" type for unprototyped functions, so
944  we treat all functions as if they were prototyped. This is used
945  primarily for promotion when calling the function from GDB. */
946  TYPE_PROTOTYPED (SYMBOL_TYPE (sym)) = 1;
947 
948  /* fall into process_prototype_types. */
949 
950  process_prototype_types:
951  /* Sun acc puts declared types of arguments here. */
952  if (*p == ';')
953  {
954  struct type *ftype = SYMBOL_TYPE (sym);
955  int nsemi = 0;
956  int nparams = 0;
957  char *p1 = p;
958 
959  /* Obtain a worst case guess for the number of arguments
960  by counting the semicolons. */
961  while (*p1)
962  {
963  if (*p1++ == ';')
964  nsemi++;
965  }
966 
967  /* Allocate parameter information fields and fill them in. */
968  TYPE_FIELDS (ftype) = (struct field *)
969  TYPE_ALLOC (ftype, nsemi * sizeof (struct field));
970  while (*p++ == ';')
971  {
972  struct type *ptype;
973 
974  /* A type number of zero indicates the start of varargs.
975  FIXME: GDB currently ignores vararg functions. */
976  if (p[0] == '0' && p[1] == '\0')
977  break;
978  ptype = read_type (&p, objfile);
979 
980  /* The Sun compilers mark integer arguments, which should
981  be promoted to the width of the calling conventions, with
982  a type which references itself. This type is turned into
983  a TYPE_CODE_VOID type by read_type, and we have to turn
984  it back into builtin_int here.
985  FIXME: Do we need a new builtin_promoted_int_arg ? */
986  if (TYPE_CODE (ptype) == TYPE_CODE_VOID)
987  ptype = objfile_type (objfile)->builtin_int;
988  TYPE_FIELD_TYPE (ftype, nparams) = ptype;
989  TYPE_FIELD_ARTIFICIAL (ftype, nparams++) = 0;
990  }
991  TYPE_NFIELDS (ftype) = nparams;
992  TYPE_PROTOTYPED (ftype) = 1;
993  }
994  break;
995 
996  case 'F':
997  /* A global function definition. */
998  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1000  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1002  goto process_function_types;
1003 
1004  case 'G':
1005  /* For a class G (global) symbol, it appears that the
1006  value is not correct. It is necessary to search for the
1007  corresponding linker definition to find the value.
1008  These definitions appear at the end of the namelist. */
1009  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1011  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1012  /* Don't add symbol references to global_sym_chain.
1013  Symbol references don't have valid names and wont't match up with
1014  minimal symbols when the global_sym_chain is relocated.
1015  We'll fixup symbol references when we fixup the defining symbol. */
1016  if (SYMBOL_LINKAGE_NAME (sym) && SYMBOL_LINKAGE_NAME (sym)[0] != '#')
1017  {
1018  i = hashname (SYMBOL_LINKAGE_NAME (sym));
1020  global_sym_chain[i] = sym;
1021  }
1023  break;
1024 
1025  /* This case is faked by a conditional above,
1026  when there is no code letter in the dbx data.
1027  Dbx data never actually contains 'l'. */
1028  case 's':
1029  case 'l':
1030  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1032  SYMBOL_VALUE (sym) = valu;
1033  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1035  break;
1036 
1037  case 'p':
1038  if (*p == 'F')
1039  /* pF is a two-letter code that means a function parameter in Fortran.
1040  The type-number specifies the type of the return value.
1041  Translate it into a pointer-to-function type. */
1042  {
1043  p++;
1044  SYMBOL_TYPE (sym)
1046  (lookup_function_type (read_type (&p, objfile)));
1047  }
1048  else
1049  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1050 
1051  SYMBOL_ACLASS_INDEX (sym) = LOC_ARG;
1052  SYMBOL_VALUE (sym) = valu;
1053  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1054  SYMBOL_IS_ARGUMENT (sym) = 1;
1056 
1057  if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_BIG)
1058  {
1059  /* On little-endian machines, this crud is never necessary,
1060  and, if the extra bytes contain garbage, is harmful. */
1061  break;
1062  }
1063 
1064  /* If it's gcc-compiled, if it says `short', believe it. */
1066  || gdbarch_believe_pcc_promotion (gdbarch))
1067  break;
1068 
1069  if (!gdbarch_believe_pcc_promotion (gdbarch))
1070  {
1071  /* If PCC says a parameter is a short or a char, it is
1072  really an int. */
1073  if (TYPE_LENGTH (SYMBOL_TYPE (sym))
1074  < gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT
1075  && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
1076  {
1077  SYMBOL_TYPE (sym) =
1078  TYPE_UNSIGNED (SYMBOL_TYPE (sym))
1079  ? objfile_type (objfile)->builtin_unsigned_int
1080  : objfile_type (objfile)->builtin_int;
1081  }
1082  break;
1083  }
1084 
1085  case 'P':
1086  /* acc seems to use P to declare the prototypes of functions that
1087  are referenced by this file. gdb is not prepared to deal
1088  with this extra information. FIXME, it ought to. */
1089  if (type == N_FUN)
1090  {
1091  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1092  goto process_prototype_types;
1093  }
1094  /*FALLTHROUGH */
1095 
1096  case 'R':
1097  /* Parameter which is in a register. */
1098  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1100  SYMBOL_IS_ARGUMENT (sym) = 1;
1101  SYMBOL_VALUE (sym) = valu;
1102  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1104  break;
1105 
1106  case 'r':
1107  /* Register variable (either global or local). */
1108  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1110  SYMBOL_VALUE (sym) = valu;
1111  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1112  if (within_function)
1113  {
1114  /* Sun cc uses a pair of symbols, one 'p' and one 'r', with
1115  the same name to represent an argument passed in a
1116  register. GCC uses 'P' for the same case. So if we find
1117  such a symbol pair we combine it into one 'P' symbol.
1118  For Sun cc we need to do this regardless of
1119  stabs_argument_has_addr, because the compiler puts out
1120  the 'p' symbol even if it never saves the argument onto
1121  the stack.
1122 
1123  On most machines, we want to preserve both symbols, so
1124  that we can still get information about what is going on
1125  with the stack (VAX for computing args_printed, using
1126  stack slots instead of saved registers in backtraces,
1127  etc.).
1128 
1129  Note that this code illegally combines
1130  main(argc) struct foo argc; { register struct foo argc; }
1131  but this case is considered pathological and causes a warning
1132  from a decent compiler. */
1133 
1134  if (local_symbols
1135  && local_symbols->nsyms > 0
1136  && gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym)))
1137  {
1138  struct symbol *prev_sym;
1139 
1140  prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
1141  if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
1142  || SYMBOL_CLASS (prev_sym) == LOC_ARG)
1143  && strcmp (SYMBOL_LINKAGE_NAME (prev_sym),
1144  SYMBOL_LINKAGE_NAME (sym)) == 0)
1145  {
1147  /* Use the type from the LOC_REGISTER; that is the type
1148  that is actually in that register. */
1149  SYMBOL_TYPE (prev_sym) = SYMBOL_TYPE (sym);
1150  SYMBOL_VALUE (prev_sym) = SYMBOL_VALUE (sym);
1151  sym = prev_sym;
1152  break;
1153  }
1154  }
1156  }
1157  else
1159  break;
1160 
1161  case 'S':
1162  /* Static symbol at top level of file. */
1163  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1165  SYMBOL_VALUE_ADDRESS (sym) = valu;
1166  if (gdbarch_static_transform_name_p (gdbarch)
1167  && gdbarch_static_transform_name (gdbarch,
1168  SYMBOL_LINKAGE_NAME (sym))
1169  != SYMBOL_LINKAGE_NAME (sym))
1170  {
1171  struct bound_minimal_symbol msym;
1172 
1174  NULL, objfile);
1175  if (msym.minsym != NULL)
1176  {
1177  const char *new_name = gdbarch_static_transform_name
1178  (gdbarch, SYMBOL_LINKAGE_NAME (sym));
1179 
1180  SYMBOL_SET_LINKAGE_NAME (sym, new_name);
1182  }
1183  }
1184  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1186  break;
1187 
1188  case 't':
1189  /* In Ada, there is no distinction between typedef and non-typedef;
1190  any type declaration implicitly has the equivalent of a typedef,
1191  and thus 't' is in fact equivalent to 'Tt'.
1192 
1193  Therefore, for Ada units, we check the character immediately
1194  before the 't', and if we do not find a 'T', then make sure to
1195  create the associated symbol in the STRUCT_DOMAIN ('t' definitions
1196  will be stored in the VAR_DOMAIN). If the symbol was indeed
1197  defined as 'Tt' then the STRUCT_DOMAIN symbol will be created
1198  elsewhere, so we don't need to take care of that.
1199 
1200  This is important to do, because of forward references:
1201  The cleanup of undefined types stored in undef_types only uses
1202  STRUCT_DOMAIN symbols to perform the replacement. */
1203  synonym = (SYMBOL_LANGUAGE (sym) == language_ada && p[-2] != 'T');
1204 
1205  /* Typedef */
1206  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1207 
1208  /* For a nameless type, we don't want a create a symbol, thus we
1209  did not use `sym'. Return without further processing. */
1210  if (nameless)
1211  return NULL;
1212 
1214  SYMBOL_VALUE (sym) = valu;
1215  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1216  /* C++ vagaries: we may have a type which is derived from
1217  a base type which did not have its name defined when the
1218  derived class was output. We fill in the derived class's
1219  base part member's name here in that case. */
1220  if (TYPE_NAME (SYMBOL_TYPE (sym)) != NULL)
1221  if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
1222  || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
1223  && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)))
1224  {
1225  int j;
1226 
1227  for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
1228  if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
1229  TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) =
1231  }
1232 
1233  if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL)
1234  {
1235  /* gcc-2.6 or later (when using -fvtable-thunks)
1236  emits a unique named type for a vtable entry.
1237  Some gdb code depends on that specific name. */
1238  extern const char vtbl_ptr_name[];
1239 
1240  if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
1241  && strcmp (SYMBOL_LINKAGE_NAME (sym), vtbl_ptr_name))
1242  || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
1243  {
1244  /* If we are giving a name to a type such as "pointer to
1245  foo" or "function returning foo", we better not set
1246  the TYPE_NAME. If the program contains "typedef char
1247  *caddr_t;", we don't want all variables of type char
1248  * to print as caddr_t. This is not just a
1249  consequence of GDB's type management; PCC and GCC (at
1250  least through version 2.4) both output variables of
1251  either type char * or caddr_t with the type number
1252  defined in the 't' symbol for caddr_t. If a future
1253  compiler cleans this up it GDB is not ready for it
1254  yet, but if it becomes ready we somehow need to
1255  disable this check (without breaking the PCC/GCC2.4
1256  case).
1257 
1258  Sigh.
1259 
1260  Fortunately, this check seems not to be necessary
1261  for anything except pointers or functions. */
1262  /* ezannoni: 2000-10-26. This seems to apply for
1263  versions of gcc older than 2.8. This was the original
1264  problem: with the following code gdb would tell that
1265  the type for name1 is caddr_t, and func is char().
1266 
1267  typedef char *caddr_t;
1268  char *name2;
1269  struct x
1270  {
1271  char *name1;
1272  } xx;
1273  char *func()
1274  {
1275  }
1276  main () {}
1277  */
1278 
1279  /* Pascal accepts names for pointer types. */
1281  {
1282  TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
1283  }
1284  }
1285  else
1286  TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
1287  }
1288 
1290 
1291  if (synonym)
1292  {
1293  /* Create the STRUCT_DOMAIN clone. */
1294  struct symbol *struct_sym = allocate_symbol (objfile);
1295 
1296  *struct_sym = *sym;
1297  SYMBOL_ACLASS_INDEX (struct_sym) = LOC_TYPEDEF;
1298  SYMBOL_VALUE (struct_sym) = valu;
1299  SYMBOL_DOMAIN (struct_sym) = STRUCT_DOMAIN;
1300  if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1301  TYPE_NAME (SYMBOL_TYPE (sym))
1302  = obconcat (&objfile->objfile_obstack,
1303  SYMBOL_LINKAGE_NAME (sym),
1304  (char *) NULL);
1305  add_symbol_to_list (struct_sym, &file_symbols);
1306  }
1307 
1308  break;
1309 
1310  case 'T':
1311  /* Struct, union, or enum tag. For GNU C++, this can be be followed
1312  by 't' which means we are typedef'ing it as well. */
1313  synonym = *p == 't';
1314 
1315  if (synonym)
1316  p++;
1317 
1318  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1319 
1320  /* For a nameless type, we don't want a create a symbol, thus we
1321  did not use `sym'. Return without further processing. */
1322  if (nameless)
1323  return NULL;
1324 
1326  SYMBOL_VALUE (sym) = valu;
1327  SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
1328  if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
1329  TYPE_TAG_NAME (SYMBOL_TYPE (sym))
1330  = obconcat (&objfile->objfile_obstack,
1331  SYMBOL_LINKAGE_NAME (sym),
1332  (char *) NULL);
1334 
1335  if (synonym)
1336  {
1337  /* Clone the sym and then modify it. */
1338  struct symbol *typedef_sym = allocate_symbol (objfile);
1339 
1340  *typedef_sym = *sym;
1341  SYMBOL_ACLASS_INDEX (typedef_sym) = LOC_TYPEDEF;
1342  SYMBOL_VALUE (typedef_sym) = valu;
1343  SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
1344  if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1345  TYPE_NAME (SYMBOL_TYPE (sym))
1346  = obconcat (&objfile->objfile_obstack,
1347  SYMBOL_LINKAGE_NAME (sym),
1348  (char *) NULL);
1349  add_symbol_to_list (typedef_sym, &file_symbols);
1350  }
1351  break;
1352 
1353  case 'V':
1354  /* Static symbol of local scope. */
1355  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1357  SYMBOL_VALUE_ADDRESS (sym) = valu;
1358  if (gdbarch_static_transform_name_p (gdbarch)
1359  && gdbarch_static_transform_name (gdbarch,
1360  SYMBOL_LINKAGE_NAME (sym))
1361  != SYMBOL_LINKAGE_NAME (sym))
1362  {
1363  struct bound_minimal_symbol msym;
1364 
1366  NULL, objfile);
1367  if (msym.minsym != NULL)
1368  {
1369  const char *new_name = gdbarch_static_transform_name
1370  (gdbarch, SYMBOL_LINKAGE_NAME (sym));
1371 
1372  SYMBOL_SET_LINKAGE_NAME (sym, new_name);
1374  }
1375  }
1376  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1378  break;
1379 
1380  case 'v':
1381  /* Reference parameter */
1382  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1384  SYMBOL_IS_ARGUMENT (sym) = 1;
1385  SYMBOL_VALUE (sym) = valu;
1386  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1388  break;
1389 
1390  case 'a':
1391  /* Reference parameter which is in a register. */
1392  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1394  SYMBOL_IS_ARGUMENT (sym) = 1;
1395  SYMBOL_VALUE (sym) = valu;
1396  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1398  break;
1399 
1400  case 'X':
1401  /* This is used by Sun FORTRAN for "function result value".
1402  Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1403  that Pascal uses it too, but when I tried it Pascal used
1404  "x:3" (local symbol) instead. */
1405  SYMBOL_TYPE (sym) = read_type (&p, objfile);
1407  SYMBOL_VALUE (sym) = valu;
1408  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1410  break;
1411 
1412  default:
1413  SYMBOL_TYPE (sym) = error_type (&p, objfile);
1415  SYMBOL_VALUE (sym) = 0;
1416  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1418  break;
1419  }
1420 
1421  /* Some systems pass variables of certain types by reference instead
1422  of by value, i.e. they will pass the address of a structure (in a
1423  register or on the stack) instead of the structure itself. */
1424 
1425  if (gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym))
1426  && SYMBOL_IS_ARGUMENT (sym))
1427  {
1428  /* We have to convert LOC_REGISTER to LOC_REGPARM_ADDR (for
1429  variables passed in a register). */
1430  if (SYMBOL_CLASS (sym) == LOC_REGISTER)
1432  /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
1433  and subsequent arguments on SPARC, for example). */
1434  else if (SYMBOL_CLASS (sym) == LOC_ARG)
1436  }
1437 
1438  return sym;
1439 }
1440 
1441 /* Skip rest of this symbol and return an error type.
1442 
1443  General notes on error recovery: error_type always skips to the
1444  end of the symbol (modulo cretinous dbx symbol name continuation).
1445  Thus code like this:
1446 
1447  if (*(*pp)++ != ';')
1448  return error_type (pp, objfile);
1449 
1450  is wrong because if *pp starts out pointing at '\0' (typically as the
1451  result of an earlier error), it will be incremented to point to the
1452  start of the next symbol, which might produce strange results, at least
1453  if you run off the end of the string table. Instead use
1454 
1455  if (**pp != ';')
1456  return error_type (pp, objfile);
1457  ++*pp;
1458 
1459  or
1460 
1461  if (**pp != ';')
1462  foo = error_type (pp, objfile);
1463  else
1464  ++*pp;
1465 
1466  And in case it isn't obvious, the point of all this hair is so the compiler
1467  can define new types and new syntaxes, and old versions of the
1468  debugger will be able to read the new symbol tables. */
1469 
1470 static struct type *
1471 error_type (char **pp, struct objfile *objfile)
1472 {
1474  _("couldn't parse type; debugger out of date?"));
1475  while (1)
1476  {
1477  /* Skip to end of symbol. */
1478  while (**pp != '\0')
1479  {
1480  (*pp)++;
1481  }
1482 
1483  /* Check for and handle cretinous dbx symbol name continuation! */
1484  if ((*pp)[-1] == '\\' || (*pp)[-1] == '?')
1485  {
1486  *pp = next_symbol_text (objfile);
1487  }
1488  else
1489  {
1490  break;
1491  }
1492  }
1493  return objfile_type (objfile)->builtin_error;
1494 }
1495 
1496 
1497 /* Read type information or a type definition; return the type. Even
1498  though this routine accepts either type information or a type
1499  definition, the distinction is relevant--some parts of stabsread.c
1500  assume that type information starts with a digit, '-', or '(' in
1501  deciding whether to call read_type. */
1502 
1503 static struct type *
1504 read_type (char **pp, struct objfile *objfile)
1505 {
1506  struct type *type = 0;
1507  struct type *type1;
1508  int typenums[2];
1509  char type_descriptor;
1510 
1511  /* Size in bits of type if specified by a type attribute, or -1 if
1512  there is no size attribute. */
1513  int type_size = -1;
1514 
1515  /* Used to distinguish string and bitstring from char-array and set. */
1516  int is_string = 0;
1517 
1518  /* Used to distinguish vector from array. */
1519  int is_vector = 0;
1520 
1521  /* Read type number if present. The type number may be omitted.
1522  for instance in a two-dimensional array declared with type
1523  "ar1;1;10;ar1;1;10;4". */
1524  if ((**pp >= '0' && **pp <= '9')
1525  || **pp == '('
1526  || **pp == '-')
1527  {
1528  if (read_type_number (pp, typenums) != 0)
1529  return error_type (pp, objfile);
1530 
1531  if (**pp != '=')
1532  {
1533  /* Type is not being defined here. Either it already
1534  exists, or this is a forward reference to it.
1535  dbx_alloc_type handles both cases. */
1536  type = dbx_alloc_type (typenums, objfile);
1537 
1538  /* If this is a forward reference, arrange to complain if it
1539  doesn't get patched up by the time we're done
1540  reading. */
1541  if (TYPE_CODE (type) == TYPE_CODE_UNDEF)
1542  add_undefined_type (type, typenums);
1543 
1544  return type;
1545  }
1546 
1547  /* Type is being defined here. */
1548  /* Skip the '='.
1549  Also skip the type descriptor - we get it below with (*pp)[-1]. */
1550  (*pp) += 2;
1551  }
1552  else
1553  {
1554  /* 'typenums=' not present, type is anonymous. Read and return
1555  the definition, but don't put it in the type vector. */
1556  typenums[0] = typenums[1] = -1;
1557  (*pp)++;
1558  }
1559 
1560 again:
1561  type_descriptor = (*pp)[-1];
1562  switch (type_descriptor)
1563  {
1564  case 'x':
1565  {
1566  enum type_code code;
1567 
1568  /* Used to index through file_symbols. */
1569  struct pending *ppt;
1570  int i;
1571 
1572  /* Name including "struct", etc. */
1573  char *type_name;
1574 
1575  {
1576  char *from, *to, *p, *q1, *q2;
1577 
1578  /* Set the type code according to the following letter. */
1579  switch ((*pp)[0])
1580  {
1581  case 's':
1582  code = TYPE_CODE_STRUCT;
1583  break;
1584  case 'u':
1585  code = TYPE_CODE_UNION;
1586  break;
1587  case 'e':
1588  code = TYPE_CODE_ENUM;
1589  break;
1590  default:
1591  {
1592  /* Complain and keep going, so compilers can invent new
1593  cross-reference types. */
1595  _("Unrecognized cross-reference type `%c'"),
1596  (*pp)[0]);
1597  code = TYPE_CODE_STRUCT;
1598  break;
1599  }
1600  }
1601 
1602  q1 = strchr (*pp, '<');
1603  p = strchr (*pp, ':');
1604  if (p == NULL)
1605  return error_type (pp, objfile);
1606  if (q1 && p > q1 && p[1] == ':')
1607  {
1608  int nesting_level = 0;
1609 
1610  for (q2 = q1; *q2; q2++)
1611  {
1612  if (*q2 == '<')
1613  nesting_level++;
1614  else if (*q2 == '>')
1615  nesting_level--;
1616  else if (*q2 == ':' && nesting_level == 0)
1617  break;
1618  }
1619  p = q2;
1620  if (*p != ':')
1621  return error_type (pp, objfile);
1622  }
1623  type_name = NULL;
1625  {
1626  char *new_name, *name = alloca (p - *pp + 1);
1627 
1628  memcpy (name, *pp, p - *pp);
1629  name[p - *pp] = '\0';
1630  new_name = cp_canonicalize_string (name);
1631  if (new_name != NULL)
1632  {
1633  type_name = obstack_copy0 (&objfile->objfile_obstack,
1634  new_name, strlen (new_name));
1635  xfree (new_name);
1636  }
1637  }
1638  if (type_name == NULL)
1639  {
1640  to = type_name = (char *)
1641  obstack_alloc (&objfile->objfile_obstack, p - *pp + 1);
1642 
1643  /* Copy the name. */
1644  from = *pp + 1;
1645  while (from < p)
1646  *to++ = *from++;
1647  *to = '\0';
1648  }
1649 
1650  /* Set the pointer ahead of the name which we just read, and
1651  the colon. */
1652  *pp = p + 1;
1653  }
1654 
1655  /* If this type has already been declared, then reuse the same
1656  type, rather than allocating a new one. This saves some
1657  memory. */
1658 
1659  for (ppt = file_symbols; ppt; ppt = ppt->next)
1660  for (i = 0; i < ppt->nsyms; i++)
1661  {
1662  struct symbol *sym = ppt->symbol[i];
1663 
1664  if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
1665  && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
1666  && (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
1667  && strcmp (SYMBOL_LINKAGE_NAME (sym), type_name) == 0)
1668  {
1669  obstack_free (&objfile->objfile_obstack, type_name);
1670  type = SYMBOL_TYPE (sym);
1671  if (typenums[0] != -1)
1672  *dbx_lookup_type (typenums, objfile) = type;
1673  return type;
1674  }
1675  }
1676 
1677  /* Didn't find the type to which this refers, so we must
1678  be dealing with a forward reference. Allocate a type
1679  structure for it, and keep track of it so we can
1680  fill in the rest of the fields when we get the full
1681  type. */
1682  type = dbx_alloc_type (typenums, objfile);
1683  TYPE_CODE (type) = code;
1684  TYPE_TAG_NAME (type) = type_name;
1685  INIT_CPLUS_SPECIFIC (type);
1686  TYPE_STUB (type) = 1;
1687 
1688  add_undefined_type (type, typenums);
1689  return type;
1690  }
1691 
1692  case '-': /* RS/6000 built-in type */
1693  case '0':
1694  case '1':
1695  case '2':
1696  case '3':
1697  case '4':
1698  case '5':
1699  case '6':
1700  case '7':
1701  case '8':
1702  case '9':
1703  case '(':
1704  (*pp)--;
1705 
1706  /* We deal with something like t(1,2)=(3,4)=... which
1707  the Lucid compiler and recent gcc versions (post 2.7.3) use. */
1708 
1709  /* Allocate and enter the typedef type first.
1710  This handles recursive types. */
1711  type = dbx_alloc_type (typenums, objfile);
1712  TYPE_CODE (type) = TYPE_CODE_TYPEDEF;
1713  {
1714  struct type *xtype = read_type (pp, objfile);
1715 
1716  if (type == xtype)
1717  {
1718  /* It's being defined as itself. That means it is "void". */
1719  TYPE_CODE (type) = TYPE_CODE_VOID;
1720  TYPE_LENGTH (type) = 1;
1721  }
1722  else if (type_size >= 0 || is_string)
1723  {
1724  /* This is the absolute wrong way to construct types. Every
1725  other debug format has found a way around this problem and
1726  the related problems with unnecessarily stubbed types;
1727  someone motivated should attempt to clean up the issue
1728  here as well. Once a type pointed to has been created it
1729  should not be modified.
1730 
1731  Well, it's not *absolutely* wrong. Constructing recursive
1732  types (trees, linked lists) necessarily entails modifying
1733  types after creating them. Constructing any loop structure
1734  entails side effects. The Dwarf 2 reader does handle this
1735  more gracefully (it never constructs more than once
1736  instance of a type object, so it doesn't have to copy type
1737  objects wholesale), but it still mutates type objects after
1738  other folks have references to them.
1739 
1740  Keep in mind that this circularity/mutation issue shows up
1741  at the source language level, too: C's "incomplete types",
1742  for example. So the proper cleanup, I think, would be to
1743  limit GDB's type smashing to match exactly those required
1744  by the source language. So GDB could have a
1745  "complete_this_type" function, but never create unnecessary
1746  copies of a type otherwise. */
1747  replace_type (type, xtype);
1748  TYPE_NAME (type) = NULL;
1749  TYPE_TAG_NAME (type) = NULL;
1750  }
1751  else
1752  {
1753  TYPE_TARGET_STUB (type) = 1;
1754  TYPE_TARGET_TYPE (type) = xtype;
1755  }
1756  }
1757  break;
1758 
1759  /* In the following types, we must be sure to overwrite any existing
1760  type that the typenums refer to, rather than allocating a new one
1761  and making the typenums point to the new one. This is because there
1762  may already be pointers to the existing type (if it had been
1763  forward-referenced), and we must change it to a pointer, function,
1764  reference, or whatever, *in-place*. */
1765 
1766  case '*': /* Pointer to another type */
1767  type1 = read_type (pp, objfile);
1768  type = make_pointer_type (type1, dbx_lookup_type (typenums, objfile));
1769  break;
1770 
1771  case '&': /* Reference to another type */
1772  type1 = read_type (pp, objfile);
1773  type = make_reference_type (type1, dbx_lookup_type (typenums, objfile));
1774  break;
1775 
1776  case 'f': /* Function returning another type */
1777  type1 = read_type (pp, objfile);
1778  type = make_function_type (type1, dbx_lookup_type (typenums, objfile));
1779  break;
1780 
1781  case 'g': /* Prototyped function. (Sun) */
1782  {
1783  /* Unresolved questions:
1784 
1785  - According to Sun's ``STABS Interface Manual'', for 'f'
1786  and 'F' symbol descriptors, a `0' in the argument type list
1787  indicates a varargs function. But it doesn't say how 'g'
1788  type descriptors represent that info. Someone with access
1789  to Sun's toolchain should try it out.
1790 
1791  - According to the comment in define_symbol (search for
1792  `process_prototype_types:'), Sun emits integer arguments as
1793  types which ref themselves --- like `void' types. Do we
1794  have to deal with that here, too? Again, someone with
1795  access to Sun's toolchain should try it out and let us
1796  know. */
1797 
1798  const char *type_start = (*pp) - 1;
1799  struct type *return_type = read_type (pp, objfile);
1800  struct type *func_type
1801  = make_function_type (return_type,
1802  dbx_lookup_type (typenums, objfile));
1803  struct type_list {
1804  struct type *type;
1805  struct type_list *next;
1806  } *arg_types = 0;
1807  int num_args = 0;
1808 
1809  while (**pp && **pp != '#')
1810  {
1811  struct type *arg_type = read_type (pp, objfile);
1812  struct type_list *newobj = alloca (sizeof (*newobj));
1813  newobj->type = arg_type;
1814  newobj->next = arg_types;
1815  arg_types = newobj;
1816  num_args++;
1817  }
1818  if (**pp == '#')
1819  ++*pp;
1820  else
1821  {
1823  _("Prototyped function type didn't "
1824  "end arguments with `#':\n%s"),
1825  type_start);
1826  }
1827 
1828  /* If there is just one argument whose type is `void', then
1829  that's just an empty argument list. */
1830  if (arg_types
1831  && ! arg_types->next
1832  && TYPE_CODE (arg_types->type) == TYPE_CODE_VOID)
1833  num_args = 0;
1834 
1835  TYPE_FIELDS (func_type)
1836  = (struct field *) TYPE_ALLOC (func_type,
1837  num_args * sizeof (struct field));
1838  memset (TYPE_FIELDS (func_type), 0, num_args * sizeof (struct field));
1839  {
1840  int i;
1841  struct type_list *t;
1842 
1843  /* We stuck each argument type onto the front of the list
1844  when we read it, so the list is reversed. Build the
1845  fields array right-to-left. */
1846  for (t = arg_types, i = num_args - 1; t; t = t->next, i--)
1847  TYPE_FIELD_TYPE (func_type, i) = t->type;
1848  }
1849  TYPE_NFIELDS (func_type) = num_args;
1850  TYPE_PROTOTYPED (func_type) = 1;
1851 
1852  type = func_type;
1853  break;
1854  }
1855 
1856  case 'k': /* Const qualifier on some type (Sun) */
1857  type = read_type (pp, objfile);
1858  type = make_cv_type (1, TYPE_VOLATILE (type), type,
1859  dbx_lookup_type (typenums, objfile));
1860  break;
1861 
1862  case 'B': /* Volatile qual on some type (Sun) */
1863  type = read_type (pp, objfile);
1864  type = make_cv_type (TYPE_CONST (type), 1, type,
1865  dbx_lookup_type (typenums, objfile));
1866  break;
1867 
1868  case '@':
1869  if (isdigit (**pp) || **pp == '(' || **pp == '-')
1870  { /* Member (class & variable) type */
1871  /* FIXME -- we should be doing smash_to_XXX types here. */
1872 
1873  struct type *domain = read_type (pp, objfile);
1874  struct type *memtype;
1875 
1876  if (**pp != ',')
1877  /* Invalid member type data format. */
1878  return error_type (pp, objfile);
1879  ++*pp;
1880 
1881  memtype = read_type (pp, objfile);
1882  type = dbx_alloc_type (typenums, objfile);
1883  smash_to_memberptr_type (type, domain, memtype);
1884  }
1885  else
1886  /* type attribute */
1887  {
1888  char *attr = *pp;
1889 
1890  /* Skip to the semicolon. */
1891  while (**pp != ';' && **pp != '\0')
1892  ++(*pp);
1893  if (**pp == '\0')
1894  return error_type (pp, objfile);
1895  else
1896  ++ * pp; /* Skip the semicolon. */
1897 
1898  switch (*attr)
1899  {
1900  case 's': /* Size attribute */
1901  type_size = atoi (attr + 1);
1902  if (type_size <= 0)
1903  type_size = -1;
1904  break;
1905 
1906  case 'S': /* String attribute */
1907  /* FIXME: check to see if following type is array? */
1908  is_string = 1;
1909  break;
1910 
1911  case 'V': /* Vector attribute */
1912  /* FIXME: check to see if following type is array? */
1913  is_vector = 1;
1914  break;
1915 
1916  default:
1917  /* Ignore unrecognized type attributes, so future compilers
1918  can invent new ones. */
1919  break;
1920  }
1921  ++*pp;
1922  goto again;
1923  }
1924  break;
1925 
1926  case '#': /* Method (class & fn) type */
1927  if ((*pp)[0] == '#')
1928  {
1929  /* We'll get the parameter types from the name. */
1930  struct type *return_type;
1931 
1932  (*pp)++;
1933  return_type = read_type (pp, objfile);
1934  if (*(*pp)++ != ';')
1936  _("invalid (minimal) member type "
1937  "data format at symtab pos %d."),
1938  symnum);
1939  type = allocate_stub_method (return_type);
1940  if (typenums[0] != -1)
1941  *dbx_lookup_type (typenums, objfile) = type;
1942  }
1943  else
1944  {
1945  struct type *domain = read_type (pp, objfile);
1946  struct type *return_type;
1947  struct field *args;
1948  int nargs, varargs;
1949 
1950  if (**pp != ',')
1951  /* Invalid member type data format. */
1952  return error_type (pp, objfile);
1953  else
1954  ++(*pp);
1955 
1956  return_type = read_type (pp, objfile);
1957  args = read_args (pp, ';', objfile, &nargs, &varargs);
1958  if (args == NULL)
1959  return error_type (pp, objfile);
1960  type = dbx_alloc_type (typenums, objfile);
1961  smash_to_method_type (type, domain, return_type, args,
1962  nargs, varargs);
1963  }
1964  break;
1965 
1966  case 'r': /* Range type */
1967  type = read_range_type (pp, typenums, type_size, objfile);
1968  if (typenums[0] != -1)
1969  *dbx_lookup_type (typenums, objfile) = type;
1970  break;
1971 
1972  case 'b':
1973  {
1974  /* Sun ACC builtin int type */
1975  type = read_sun_builtin_type (pp, typenums, objfile);
1976  if (typenums[0] != -1)
1977  *dbx_lookup_type (typenums, objfile) = type;
1978  }
1979  break;
1980 
1981  case 'R': /* Sun ACC builtin float type */
1982  type = read_sun_floating_type (pp, typenums, objfile);
1983  if (typenums[0] != -1)
1984  *dbx_lookup_type (typenums, objfile) = type;
1985  break;
1986 
1987  case 'e': /* Enumeration type */
1988  type = dbx_alloc_type (typenums, objfile);
1989  type = read_enum_type (pp, type, objfile);
1990  if (typenums[0] != -1)
1991  *dbx_lookup_type (typenums, objfile) = type;
1992  break;
1993 
1994  case 's': /* Struct type */
1995  case 'u': /* Union type */
1996  {
1998  type = dbx_alloc_type (typenums, objfile);
1999  switch (type_descriptor)
2000  {
2001  case 's':
2002  type_code = TYPE_CODE_STRUCT;
2003  break;
2004  case 'u':
2005  type_code = TYPE_CODE_UNION;
2006  break;
2007  }
2008  type = read_struct_type (pp, type, type_code, objfile);
2009  break;
2010  }
2011 
2012  case 'a': /* Array type */
2013  if (**pp != 'r')
2014  return error_type (pp, objfile);
2015  ++*pp;
2016 
2017  type = dbx_alloc_type (typenums, objfile);
2018  type = read_array_type (pp, type, objfile);
2019  if (is_string)
2020  TYPE_CODE (type) = TYPE_CODE_STRING;
2021  if (is_vector)
2022  make_vector_type (type);
2023  break;
2024 
2025  case 'S': /* Set type */
2026  type1 = read_type (pp, objfile);
2027  type = create_set_type ((struct type *) NULL, type1);
2028  if (typenums[0] != -1)
2029  *dbx_lookup_type (typenums, objfile) = type;
2030  break;
2031 
2032  default:
2033  --*pp; /* Go back to the symbol in error. */
2034  /* Particularly important if it was \0! */
2035  return error_type (pp, objfile);
2036  }
2037 
2038  if (type == 0)
2039  {
2040  warning (_("GDB internal error, type is NULL in stabsread.c."));
2041  return error_type (pp, objfile);
2042  }
2043 
2044  /* Size specified in a type attribute overrides any other size. */
2045  if (type_size != -1)
2046  TYPE_LENGTH (type) = (type_size + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
2047 
2048  return type;
2049 }
2050 
2051 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
2052  Return the proper type node for a given builtin type number. */
2053 
2054 static const struct objfile_data *rs6000_builtin_type_data;
2055 
2056 static struct type *
2057 rs6000_builtin_type (int typenum, struct objfile *objfile)
2058 {
2059  struct type **negative_types = objfile_data (objfile,
2061 
2062  /* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
2063 #define NUMBER_RECOGNIZED 34
2064  struct type *rettype = NULL;
2065 
2066  if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
2067  {
2068  complaint (&symfile_complaints, _("Unknown builtin type %d"), typenum);
2069  return objfile_type (objfile)->builtin_error;
2070  }
2071 
2072  if (!negative_types)
2073  {
2074  /* This includes an empty slot for type number -0. */
2075  negative_types = OBSTACK_CALLOC (&objfile->objfile_obstack,
2076  NUMBER_RECOGNIZED + 1, struct type *);
2077  set_objfile_data (objfile, rs6000_builtin_type_data, negative_types);
2078  }
2079 
2080  if (negative_types[-typenum] != NULL)
2081  return negative_types[-typenum];
2082 
2083 #if TARGET_CHAR_BIT != 8
2084 #error This code wrong for TARGET_CHAR_BIT not 8
2085  /* These definitions all assume that TARGET_CHAR_BIT is 8. I think
2086  that if that ever becomes not true, the correct fix will be to
2087  make the size in the struct type to be in bits, not in units of
2088  TARGET_CHAR_BIT. */
2089 #endif
2090 
2091  switch (-typenum)
2092  {
2093  case 1:
2094  /* The size of this and all the other types are fixed, defined
2095  by the debugging format. If there is a type called "int" which
2096  is other than 32 bits, then it should use a new negative type
2097  number (or avoid negative type numbers for that case).
2098  See stabs.texinfo. */
2099  rettype = init_type (TYPE_CODE_INT, 4, 0, "int", objfile);
2100  break;
2101  case 2:
2102  rettype = init_type (TYPE_CODE_INT, 1, 0, "char", objfile);
2103  break;
2104  case 3:
2105  rettype = init_type (TYPE_CODE_INT, 2, 0, "short", objfile);
2106  break;
2107  case 4:
2108  rettype = init_type (TYPE_CODE_INT, 4, 0, "long", objfile);
2109  break;
2110  case 5:
2112  "unsigned char", objfile);
2113  break;
2114  case 6:
2115  rettype = init_type (TYPE_CODE_INT, 1, 0, "signed char", objfile);
2116  break;
2117  case 7:
2119  "unsigned short", objfile);
2120  break;
2121  case 8:
2123  "unsigned int", objfile);
2124  break;
2125  case 9:
2127  "unsigned", objfile);
2128  break;
2129  case 10:
2131  "unsigned long", objfile);
2132  break;
2133  case 11:
2134  rettype = init_type (TYPE_CODE_VOID, 1, 0, "void", objfile);
2135  break;
2136  case 12:
2137  /* IEEE single precision (32 bit). */
2138  rettype = init_type (TYPE_CODE_FLT, 4, 0, "float", objfile);
2139  break;
2140  case 13:
2141  /* IEEE double precision (64 bit). */
2142  rettype = init_type (TYPE_CODE_FLT, 8, 0, "double", objfile);
2143  break;
2144  case 14:
2145  /* This is an IEEE double on the RS/6000, and different machines with
2146  different sizes for "long double" should use different negative
2147  type numbers. See stabs.texinfo. */
2148  rettype = init_type (TYPE_CODE_FLT, 8, 0, "long double", objfile);
2149  break;
2150  case 15:
2151  rettype = init_type (TYPE_CODE_INT, 4, 0, "integer", objfile);
2152  break;
2153  case 16:
2155  "boolean", objfile);
2156  break;
2157  case 17:
2158  rettype = init_type (TYPE_CODE_FLT, 4, 0, "short real", objfile);
2159  break;
2160  case 18:
2161  rettype = init_type (TYPE_CODE_FLT, 8, 0, "real", objfile);
2162  break;
2163  case 19:
2164  rettype = init_type (TYPE_CODE_ERROR, 0, 0, "stringptr", objfile);
2165  break;
2166  case 20:
2168  "character", objfile);
2169  break;
2170  case 21:
2172  "logical*1", objfile);
2173  break;
2174  case 22:
2176  "logical*2", objfile);
2177  break;
2178  case 23:
2180  "logical*4", objfile);
2181  break;
2182  case 24:
2184  "logical", objfile);
2185  break;
2186  case 25:
2187  /* Complex type consisting of two IEEE single precision values. */
2188  rettype = init_type (TYPE_CODE_COMPLEX, 8, 0, "complex", objfile);
2189  TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 4, 0, "float",
2190  objfile);
2191  break;
2192  case 26:
2193  /* Complex type consisting of two IEEE double precision values. */
2194  rettype = init_type (TYPE_CODE_COMPLEX, 16, 0, "double complex", NULL);
2195  TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 8, 0, "double",
2196  objfile);
2197  break;
2198  case 27:
2199  rettype = init_type (TYPE_CODE_INT, 1, 0, "integer*1", objfile);
2200  break;
2201  case 28:
2202  rettype = init_type (TYPE_CODE_INT, 2, 0, "integer*2", objfile);
2203  break;
2204  case 29:
2205  rettype = init_type (TYPE_CODE_INT, 4, 0, "integer*4", objfile);
2206  break;
2207  case 30:
2208  rettype = init_type (TYPE_CODE_CHAR, 2, 0, "wchar", objfile);
2209  break;
2210  case 31:
2211  rettype = init_type (TYPE_CODE_INT, 8, 0, "long long", objfile);
2212  break;
2213  case 32:
2215  "unsigned long long", objfile);
2216  break;
2217  case 33:
2219  "logical*8", objfile);
2220  break;
2221  case 34:
2222  rettype = init_type (TYPE_CODE_INT, 8, 0, "integer*8", objfile);
2223  break;
2224  }
2225  negative_types[-typenum] = rettype;
2226  return rettype;
2227 }
2228 
2229 /* This page contains subroutines of read_type. */
2230 
2231 /* Wrapper around method_name_from_physname to flag a complaint
2232  if there is an error. */
2233 
2234 static char *
2235 stabs_method_name_from_physname (const char *physname)
2236 {
2237  char *method_name;
2238 
2239  method_name = method_name_from_physname (physname);
2240 
2241  if (method_name == NULL)
2242  {
2244  _("Method has bad physname %s\n"), physname);
2245  return NULL;
2246  }
2247 
2248  return method_name;
2249 }
2250 
2251 /* Read member function stabs info for C++ classes. The form of each member
2252  function data is:
2253 
2254  NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2255 
2256  An example with two member functions is:
2257 
2258  afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2259 
2260  For the case of overloaded operators, the format is op$::*.funcs, where
2261  $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2262  name (such as `+=') and `.' marks the end of the operator name.
2263 
2264  Returns 1 for success, 0 for failure. */
2265 
2266 static int
2267 read_member_functions (struct field_info *fip, char **pp, struct type *type,
2268  struct objfile *objfile)
2269 {
2270  int nfn_fields = 0;
2271  int length = 0;
2272  int i;
2273  struct next_fnfield
2274  {
2275  struct next_fnfield *next;
2276  struct fn_field fn_field;
2277  }
2278  *sublist;
2279  struct type *look_ahead_type;
2280  struct next_fnfieldlist *new_fnlist;
2281  struct next_fnfield *new_sublist;
2282  char *main_fn_name;
2283  char *p;
2284 
2285  /* Process each list until we find something that is not a member function
2286  or find the end of the functions. */
2287 
2288  while (**pp != ';')
2289  {
2290  /* We should be positioned at the start of the function name.
2291  Scan forward to find the first ':' and if it is not the
2292  first of a "::" delimiter, then this is not a member function. */
2293  p = *pp;
2294  while (*p != ':')
2295  {
2296  p++;
2297  }
2298  if (p[1] != ':')
2299  {
2300  break;
2301  }
2302 
2303  sublist = NULL;
2304  look_ahead_type = NULL;
2305  length = 0;
2306 
2307  new_fnlist = (struct next_fnfieldlist *)
2308  xmalloc (sizeof (struct next_fnfieldlist));
2309  make_cleanup (xfree, new_fnlist);
2310  memset (new_fnlist, 0, sizeof (struct next_fnfieldlist));
2311 
2312  if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2]))
2313  {
2314  /* This is a completely wierd case. In order to stuff in the
2315  names that might contain colons (the usual name delimiter),
2316  Mike Tiemann defined a different name format which is
2317  signalled if the identifier is "op$". In that case, the
2318  format is "op$::XXXX." where XXXX is the name. This is
2319  used for names like "+" or "=". YUUUUUUUK! FIXME! */
2320  /* This lets the user type "break operator+".
2321  We could just put in "+" as the name, but that wouldn't
2322  work for "*". */
2323  static char opname[32] = "op$";
2324  char *o = opname + 3;
2325 
2326  /* Skip past '::'. */
2327  *pp = p + 2;
2328 
2329  STABS_CONTINUE (pp, objfile);
2330  p = *pp;
2331  while (*p != '.')
2332  {
2333  *o++ = *p++;
2334  }
2335  main_fn_name = savestring (opname, o - opname);
2336  /* Skip past '.' */
2337  *pp = p + 1;
2338  }
2339  else
2340  {
2341  main_fn_name = savestring (*pp, p - *pp);
2342  /* Skip past '::'. */
2343  *pp = p + 2;
2344  }
2345  new_fnlist->fn_fieldlist.name = main_fn_name;
2346 
2347  do
2348  {
2349  new_sublist =
2350  (struct next_fnfield *) xmalloc (sizeof (struct next_fnfield));
2351  make_cleanup (xfree, new_sublist);
2352  memset (new_sublist, 0, sizeof (struct next_fnfield));
2353 
2354  /* Check for and handle cretinous dbx symbol name continuation! */
2355  if (look_ahead_type == NULL)
2356  {
2357  /* Normal case. */
2358  STABS_CONTINUE (pp, objfile);
2359 
2360  new_sublist->fn_field.type = read_type (pp, objfile);
2361  if (**pp != ':')
2362  {
2363  /* Invalid symtab info for member function. */
2364  return 0;
2365  }
2366  }
2367  else
2368  {
2369  /* g++ version 1 kludge */
2370  new_sublist->fn_field.type = look_ahead_type;
2371  look_ahead_type = NULL;
2372  }
2373 
2374  (*pp)++;
2375  p = *pp;
2376  while (*p != ';')
2377  {
2378  p++;
2379  }
2380 
2381  /* These are methods, not functions. */
2382  if (TYPE_CODE (new_sublist->fn_field.type) == TYPE_CODE_FUNC)
2383  TYPE_CODE (new_sublist->fn_field.type) = TYPE_CODE_METHOD;
2384  else
2385  gdb_assert (TYPE_CODE (new_sublist->fn_field.type)
2386  == TYPE_CODE_METHOD);
2387 
2388  /* If this is just a stub, then we don't have the real name here. */
2389  if (TYPE_STUB (new_sublist->fn_field.type))
2390  {
2391  if (!TYPE_SELF_TYPE (new_sublist->fn_field.type))
2392  set_type_self_type (new_sublist->fn_field.type, type);
2393  new_sublist->fn_field.is_stub = 1;
2394  }
2395 
2396  new_sublist->fn_field.physname = savestring (*pp, p - *pp);
2397  *pp = p + 1;
2398 
2399  /* Set this member function's visibility fields. */
2400  switch (*(*pp)++)
2401  {
2402  case VISIBILITY_PRIVATE:
2403  new_sublist->fn_field.is_private = 1;
2404  break;
2405  case VISIBILITY_PROTECTED:
2406  new_sublist->fn_field.is_protected = 1;
2407  break;
2408  }
2409 
2410  STABS_CONTINUE (pp, objfile);
2411  switch (**pp)
2412  {
2413  case 'A': /* Normal functions. */
2414  new_sublist->fn_field.is_const = 0;
2415  new_sublist->fn_field.is_volatile = 0;
2416  (*pp)++;
2417  break;
2418  case 'B': /* `const' member functions. */
2419  new_sublist->fn_field.is_const = 1;
2420  new_sublist->fn_field.is_volatile = 0;
2421  (*pp)++;
2422  break;
2423  case 'C': /* `volatile' member function. */
2424  new_sublist->fn_field.is_const = 0;
2425  new_sublist->fn_field.is_volatile = 1;
2426  (*pp)++;
2427  break;
2428  case 'D': /* `const volatile' member function. */
2429  new_sublist->fn_field.is_const = 1;
2430  new_sublist->fn_field.is_volatile = 1;
2431  (*pp)++;
2432  break;
2433  case '*': /* File compiled with g++ version 1 --
2434  no info. */
2435  case '?':
2436  case '.':
2437  break;
2438  default:
2440  _("const/volatile indicator missing, got '%c'"),
2441  **pp);
2442  break;
2443  }
2444 
2445  switch (*(*pp)++)
2446  {
2447  case '*':
2448  {
2449  int nbits;
2450  /* virtual member function, followed by index.
2451  The sign bit is set to distinguish pointers-to-methods
2452  from virtual function indicies. Since the array is
2453  in words, the quantity must be shifted left by 1
2454  on 16 bit machine, and by 2 on 32 bit machine, forcing
2455  the sign bit out, and usable as a valid index into
2456  the array. Remove the sign bit here. */
2457  new_sublist->fn_field.voffset =
2458  (0x7fffffff & read_huge_number (pp, ';', &nbits, 0)) + 2;
2459  if (nbits != 0)
2460  return 0;
2461 
2462  STABS_CONTINUE (pp, objfile);
2463  if (**pp == ';' || **pp == '\0')
2464  {
2465  /* Must be g++ version 1. */
2466  new_sublist->fn_field.fcontext = 0;
2467  }
2468  else
2469  {
2470  /* Figure out from whence this virtual function came.
2471  It may belong to virtual function table of
2472  one of its baseclasses. */
2473  look_ahead_type = read_type (pp, objfile);
2474  if (**pp == ':')
2475  {
2476  /* g++ version 1 overloaded methods. */
2477  }
2478  else
2479  {
2480  new_sublist->fn_field.fcontext = look_ahead_type;
2481  if (**pp != ';')
2482  {
2483  return 0;
2484  }
2485  else
2486  {
2487  ++*pp;
2488  }
2489  look_ahead_type = NULL;
2490  }
2491  }
2492  break;
2493  }
2494  case '?':
2495  /* static member function. */
2496  {
2497  int slen = strlen (main_fn_name);
2498 
2499  new_sublist->fn_field.voffset = VOFFSET_STATIC;
2500 
2501  /* For static member functions, we can't tell if they
2502  are stubbed, as they are put out as functions, and not as
2503  methods.
2504  GCC v2 emits the fully mangled name if
2505  dbxout.c:flag_minimal_debug is not set, so we have to
2506  detect a fully mangled physname here and set is_stub
2507  accordingly. Fully mangled physnames in v2 start with
2508  the member function name, followed by two underscores.
2509  GCC v3 currently always emits stubbed member functions,
2510  but with fully mangled physnames, which start with _Z. */
2511  if (!(strncmp (new_sublist->fn_field.physname,
2512  main_fn_name, slen) == 0
2513  && new_sublist->fn_field.physname[slen] == '_'
2514  && new_sublist->fn_field.physname[slen + 1] == '_'))
2515  {
2516  new_sublist->fn_field.is_stub = 1;
2517  }
2518  break;
2519  }
2520 
2521  default:
2522  /* error */
2524  _("member function type missing, got '%c'"),
2525  (*pp)[-1]);
2526  /* Fall through into normal member function. */
2527 
2528  case '.':
2529  /* normal member function. */
2530  new_sublist->fn_field.voffset = 0;
2531  new_sublist->fn_field.fcontext = 0;
2532  break;
2533  }
2534 
2535  new_sublist->next = sublist;
2536  sublist = new_sublist;
2537  length++;
2538  STABS_CONTINUE (pp, objfile);
2539  }
2540  while (**pp != ';' && **pp != '\0');
2541 
2542  (*pp)++;
2543  STABS_CONTINUE (pp, objfile);
2544 
2545  /* Skip GCC 3.X member functions which are duplicates of the callable
2546  constructor/destructor. */
2547  if (strcmp_iw (main_fn_name, "__base_ctor ") == 0
2548  || strcmp_iw (main_fn_name, "__base_dtor ") == 0
2549  || strcmp (main_fn_name, "__deleting_dtor") == 0)
2550  {
2551  xfree (main_fn_name);
2552  }
2553  else
2554  {
2555  int has_stub = 0;
2556  int has_destructor = 0, has_other = 0;
2557  int is_v3 = 0;
2558  struct next_fnfield *tmp_sublist;
2559 
2560  /* Various versions of GCC emit various mostly-useless
2561  strings in the name field for special member functions.
2562 
2563  For stub methods, we need to defer correcting the name
2564  until we are ready to unstub the method, because the current
2565  name string is used by gdb_mangle_name. The only stub methods
2566  of concern here are GNU v2 operators; other methods have their
2567  names correct (see caveat below).
2568 
2569  For non-stub methods, in GNU v3, we have a complete physname.
2570  Therefore we can safely correct the name now. This primarily
2571  affects constructors and destructors, whose name will be
2572  __comp_ctor or __comp_dtor instead of Foo or ~Foo. Cast
2573  operators will also have incorrect names; for instance,
2574  "operator int" will be named "operator i" (i.e. the type is
2575  mangled).
2576 
2577  For non-stub methods in GNU v2, we have no easy way to
2578  know if we have a complete physname or not. For most
2579  methods the result depends on the platform (if CPLUS_MARKER
2580  can be `$' or `.', it will use minimal debug information, or
2581  otherwise the full physname will be included).
2582 
2583  Rather than dealing with this, we take a different approach.
2584  For v3 mangled names, we can use the full physname; for v2,
2585  we use cplus_demangle_opname (which is actually v2 specific),
2586  because the only interesting names are all operators - once again
2587  barring the caveat below. Skip this process if any method in the
2588  group is a stub, to prevent our fouling up the workings of
2589  gdb_mangle_name.
2590 
2591  The caveat: GCC 2.95.x (and earlier?) put constructors and
2592  destructors in the same method group. We need to split this
2593  into two groups, because they should have different names.
2594  So for each method group we check whether it contains both
2595  routines whose physname appears to be a destructor (the physnames
2596  for and destructors are always provided, due to quirks in v2
2597  mangling) and routines whose physname does not appear to be a
2598  destructor. If so then we break up the list into two halves.
2599  Even if the constructors and destructors aren't in the same group
2600  the destructor will still lack the leading tilde, so that also
2601  needs to be fixed.
2602 
2603  So, to summarize what we expect and handle here:
2604 
2605  Given Given Real Real Action
2606  method name physname physname method name
2607 
2608  __opi [none] __opi__3Foo operator int opname
2609  [now or later]
2610  Foo _._3Foo _._3Foo ~Foo separate and
2611  rename
2612  operator i _ZN3FoocviEv _ZN3FoocviEv operator int demangle
2613  __comp_ctor _ZN3FooC1ERKS_ _ZN3FooC1ERKS_ Foo demangle
2614  */
2615 
2616  tmp_sublist = sublist;
2617  while (tmp_sublist != NULL)
2618  {
2619  if (tmp_sublist->fn_field.is_stub)
2620  has_stub = 1;
2621  if (tmp_sublist->fn_field.physname[0] == '_'
2622  && tmp_sublist->fn_field.physname[1] == 'Z')
2623  is_v3 = 1;
2624 
2625  if (is_destructor_name (tmp_sublist->fn_field.physname))
2626  has_destructor++;
2627  else
2628  has_other++;
2629 
2630  tmp_sublist = tmp_sublist->next;
2631  }
2632 
2633  if (has_destructor && has_other)
2634  {
2635  struct next_fnfieldlist *destr_fnlist;
2636  struct next_fnfield *last_sublist;
2637 
2638  /* Create a new fn_fieldlist for the destructors. */
2639 
2640  destr_fnlist = (struct next_fnfieldlist *)
2641  xmalloc (sizeof (struct next_fnfieldlist));
2642  make_cleanup (xfree, destr_fnlist);
2643  memset (destr_fnlist, 0, sizeof (struct next_fnfieldlist));
2644  destr_fnlist->fn_fieldlist.name
2645  = obconcat (&objfile->objfile_obstack, "~",
2646  new_fnlist->fn_fieldlist.name, (char *) NULL);
2647 
2648  destr_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
2649  obstack_alloc (&objfile->objfile_obstack,
2650  sizeof (struct fn_field) * has_destructor);
2651  memset (destr_fnlist->fn_fieldlist.fn_fields, 0,
2652  sizeof (struct fn_field) * has_destructor);
2653  tmp_sublist = sublist;
2654  last_sublist = NULL;
2655  i = 0;
2656  while (tmp_sublist != NULL)
2657  {
2658  if (!is_destructor_name (tmp_sublist->fn_field.physname))
2659  {
2660  tmp_sublist = tmp_sublist->next;
2661  continue;
2662  }
2663 
2664  destr_fnlist->fn_fieldlist.fn_fields[i++]
2665  = tmp_sublist->fn_field;
2666  if (last_sublist)
2667  last_sublist->next = tmp_sublist->next;
2668  else
2669  sublist = tmp_sublist->next;
2670  last_sublist = tmp_sublist;
2671  tmp_sublist = tmp_sublist->next;
2672  }
2673 
2674  destr_fnlist->fn_fieldlist.length = has_destructor;
2675  destr_fnlist->next = fip->fnlist;
2676  fip->fnlist = destr_fnlist;
2677  nfn_fields++;
2678  length -= has_destructor;
2679  }
2680  else if (is_v3)
2681  {
2682  /* v3 mangling prevents the use of abbreviated physnames,
2683  so we can do this here. There are stubbed methods in v3
2684  only:
2685  - in -gstabs instead of -gstabs+
2686  - or for static methods, which are output as a function type
2687  instead of a method type. */
2688  char *new_method_name =
2689  stabs_method_name_from_physname (sublist->fn_field.physname);
2690 
2691  if (new_method_name != NULL
2692  && strcmp (new_method_name,
2693  new_fnlist->fn_fieldlist.name) != 0)
2694  {
2695  new_fnlist->fn_fieldlist.name = new_method_name;
2696  xfree (main_fn_name);
2697  }
2698  else
2699  xfree (new_method_name);
2700  }
2701  else if (has_destructor && new_fnlist->fn_fieldlist.name[0] != '~')
2702  {
2703  new_fnlist->fn_fieldlist.name =
2704  obconcat (&objfile->objfile_obstack,
2705  "~", main_fn_name, (char *)NULL);
2706  xfree (main_fn_name);
2707  }
2708  else if (!has_stub)
2709  {
2710  char dem_opname[256];
2711  int ret;
2712 
2713  ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
2714  dem_opname, DMGL_ANSI);
2715  if (!ret)
2716  ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
2717  dem_opname, 0);
2718  if (ret)
2719  new_fnlist->fn_fieldlist.name
2720  = obstack_copy0 (&objfile->objfile_obstack,
2721  dem_opname, strlen (dem_opname));
2722  xfree (main_fn_name);
2723  }
2724 
2725  new_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
2726  obstack_alloc (&objfile->objfile_obstack,
2727  sizeof (struct fn_field) * length);
2728  memset (new_fnlist->fn_fieldlist.fn_fields, 0,
2729  sizeof (struct fn_field) * length);
2730  for (i = length; (i--, sublist); sublist = sublist->next)
2731  {
2732  new_fnlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
2733  }
2734 
2735  new_fnlist->fn_fieldlist.length = length;
2736  new_fnlist->next = fip->fnlist;
2737  fip->fnlist = new_fnlist;
2738  nfn_fields++;
2739  }
2740  }
2741 
2742  if (nfn_fields)
2743  {
2745  TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
2746  TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * nfn_fields);
2747  memset (TYPE_FN_FIELDLISTS (type), 0,
2748  sizeof (struct fn_fieldlist) * nfn_fields);
2749  TYPE_NFN_FIELDS (type) = nfn_fields;
2750  }
2751 
2752  return 1;
2753 }
2754 
2755 /* Special GNU C++ name.
2756 
2757  Returns 1 for success, 0 for failure. "failure" means that we can't
2758  keep parsing and it's time for error_type(). */
2759 
2760 static int
2761 read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
2762  struct objfile *objfile)
2763 {
2764  char *p;
2765  const char *name;
2766  char cpp_abbrev;
2767  struct type *context;
2768 
2769  p = *pp;
2770  if (*++p == 'v')
2771  {
2772  name = NULL;
2773  cpp_abbrev = *++p;
2774 
2775  *pp = p + 1;
2776 
2777  /* At this point, *pp points to something like "22:23=*22...",
2778  where the type number before the ':' is the "context" and
2779  everything after is a regular type definition. Lookup the
2780  type, find it's name, and construct the field name. */
2781 
2782  context = read_type (pp, objfile);
2783 
2784  switch (cpp_abbrev)
2785  {
2786  case 'f': /* $vf -- a virtual function table pointer */
2787  name = type_name_no_tag (context);
2788  if (name == NULL)
2789  {
2790  name = "";
2791  }
2792  fip->list->field.name = obconcat (&objfile->objfile_obstack,
2793  vptr_name, name, (char *) NULL);
2794  break;
2795 
2796  case 'b': /* $vb -- a virtual bsomethingorother */
2797  name = type_name_no_tag (context);
2798  if (name == NULL)
2799  {
2801  _("C++ abbreviated type name "
2802  "unknown at symtab pos %d"),
2803  symnum);
2804  name = "FOO";
2805  }
2806  fip->list->field.name = obconcat (&objfile->objfile_obstack, vb_name,
2807  name, (char *) NULL);
2808  break;
2809 
2810  default:
2812  fip->list->field.name = obconcat (&objfile->objfile_obstack,
2813  "INVALID_CPLUSPLUS_ABBREV",
2814  (char *) NULL);
2815  break;
2816  }
2817 
2818  /* At this point, *pp points to the ':'. Skip it and read the
2819  field type. */
2820 
2821  p = ++(*pp);
2822  if (p[-1] != ':')
2823  {
2825  return 0;
2826  }
2827  fip->list->field.type = read_type (pp, objfile);
2828  if (**pp == ',')
2829  (*pp)++; /* Skip the comma. */
2830  else
2831  return 0;
2832 
2833  {
2834  int nbits;
2835 
2836  SET_FIELD_BITPOS (fip->list->field,
2837  read_huge_number (pp, ';', &nbits, 0));
2838  if (nbits != 0)
2839  return 0;
2840  }
2841  /* This field is unpacked. */
2842  FIELD_BITSIZE (fip->list->field) = 0;
2844  }
2845  else
2846  {
2848  /* We have no idea what syntax an unrecognized abbrev would have, so
2849  better return 0. If we returned 1, we would need to at least advance
2850  *pp to avoid an infinite loop. */
2851  return 0;
2852  }
2853  return 1;
2854 }
2855 
2856 static void
2857 read_one_struct_field (struct field_info *fip, char **pp, char *p,
2858  struct type *type, struct objfile *objfile)
2859 {
2860  struct gdbarch *gdbarch = get_objfile_arch (objfile);
2861 
2862  fip->list->field.name =
2863  obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
2864  *pp = p + 1;
2865 
2866  /* This means we have a visibility for a field coming. */
2867  if (**pp == '/')
2868  {
2869  (*pp)++;
2870  fip->list->visibility = *(*pp)++;
2871  }
2872  else
2873  {
2874  /* normal dbx-style format, no explicit visibility */
2876  }
2877 
2878  fip->list->field.type = read_type (pp, objfile);
2879  if (**pp == ':')
2880  {
2881  p = ++(*pp);
2882 #if 0
2883  /* Possible future hook for nested types. */
2884  if (**pp == '!')
2885  {
2886  fip->list->field.bitpos = (long) -2; /* nested type */
2887  p = ++(*pp);
2888  }
2889  else
2890  ...;
2891 #endif
2892  while (*p != ';')
2893  {
2894  p++;
2895  }
2896  /* Static class member. */
2897  SET_FIELD_PHYSNAME (fip->list->field, savestring (*pp, p - *pp));
2898  *pp = p + 1;
2899  return;
2900  }
2901  else if (**pp != ',')
2902  {
2903  /* Bad structure-type format. */
2904  stabs_general_complaint ("bad structure-type format");
2905  return;
2906  }
2907 
2908  (*pp)++; /* Skip the comma. */
2909 
2910  {
2911  int nbits;
2912 
2913  SET_FIELD_BITPOS (fip->list->field,
2914  read_huge_number (pp, ',', &nbits, 0));
2915  if (nbits != 0)
2916  {
2917  stabs_general_complaint ("bad structure-type format");
2918  return;
2919  }
2920  FIELD_BITSIZE (fip->list->field) = read_huge_number (pp, ';', &nbits, 0);
2921  if (nbits != 0)
2922  {
2923  stabs_general_complaint ("bad structure-type format");
2924  return;
2925  }
2926  }
2927 
2928  if (FIELD_BITPOS (fip->list->field) == 0
2929  && FIELD_BITSIZE (fip->list->field) == 0)
2930  {
2931  /* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
2932  it is a field which has been optimized out. The correct stab for
2933  this case is to use VISIBILITY_IGNORE, but that is a recent
2934  invention. (2) It is a 0-size array. For example
2935  union { int num; char str[0]; } foo. Printing _("<no value>" for
2936  str in "p foo" is OK, since foo.str (and thus foo.str[3])
2937  will continue to work, and a 0-size array as a whole doesn't
2938  have any contents to print.
2939 
2940  I suspect this probably could also happen with gcc -gstabs (not
2941  -gstabs+) for static fields, and perhaps other C++ extensions.
2942  Hopefully few people use -gstabs with gdb, since it is intended
2943  for dbx compatibility. */
2944 
2945  /* Ignore this field. */
2947  }
2948  else
2949  {
2950  /* Detect an unpacked field and mark it as such.
2951  dbx gives a bit size for all fields.
2952  Note that forward refs cannot be packed,
2953  and treat enums as if they had the width of ints. */
2954 
2955  struct type *field_type = check_typedef (FIELD_TYPE (fip->list->field));
2956 
2957  if (TYPE_CODE (field_type) != TYPE_CODE_INT
2958  && TYPE_CODE (field_type) != TYPE_CODE_RANGE
2959  && TYPE_CODE (field_type) != TYPE_CODE_BOOL
2960  && TYPE_CODE (field_type) != TYPE_CODE_ENUM)
2961  {
2962  FIELD_BITSIZE (fip->list->field) = 0;
2963  }
2964  if ((FIELD_BITSIZE (fip->list->field)
2965  == TARGET_CHAR_BIT * TYPE_LENGTH (field_type)
2966  || (TYPE_CODE (field_type) == TYPE_CODE_ENUM
2967  && FIELD_BITSIZE (fip->list->field)
2968  == gdbarch_int_bit (gdbarch))
2969  )
2970  &&
2971  FIELD_BITPOS (fip->list->field) % 8 == 0)
2972  {
2973  FIELD_BITSIZE (fip->list->field) = 0;
2974  }
2975  }
2976 }
2977 
2978 
2979 /* Read struct or class data fields. They have the form:
2980 
2981  NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2982 
2983  At the end, we see a semicolon instead of a field.
2984 
2985  In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2986  a static field.
2987 
2988  The optional VISIBILITY is one of:
2989 
2990  '/0' (VISIBILITY_PRIVATE)
2991  '/1' (VISIBILITY_PROTECTED)
2992  '/2' (VISIBILITY_PUBLIC)
2993  '/9' (VISIBILITY_IGNORE)
2994 
2995  or nothing, for C style fields with public visibility.
2996 
2997  Returns 1 for success, 0 for failure. */
2998 
2999 static int
3000 read_struct_fields (struct field_info *fip, char **pp, struct type *type,
3001  struct objfile *objfile)
3002 {
3003  char *p;
3004  struct nextfield *newobj;
3005 
3006  /* We better set p right now, in case there are no fields at all... */
3007 
3008  p = *pp;
3009 
3010  /* Read each data member type until we find the terminating ';' at the end of
3011  the data member list, or break for some other reason such as finding the
3012  start of the member function list. */
3013  /* Stab string for structure/union does not end with two ';' in
3014  SUN C compiler 5.3 i.e. F6U2, hence check for end of string. */
3015 
3016  while (**pp != ';' && **pp != '\0')
3017  {
3018  STABS_CONTINUE (pp, objfile);
3019  /* Get space to record the next field's data. */
3020  newobj = (struct nextfield *) xmalloc (sizeof (struct nextfield));
3021  make_cleanup (xfree, newobj);
3022  memset (newobj, 0, sizeof (struct nextfield));
3023  newobj->next = fip->list;
3024  fip->list = newobj;
3025 
3026  /* Get the field name. */
3027  p = *pp;
3028 
3029  /* If is starts with CPLUS_MARKER it is a special abbreviation,
3030  unless the CPLUS_MARKER is followed by an underscore, in
3031  which case it is just the name of an anonymous type, which we
3032  should handle like any other type name. */
3033 
3034  if (is_cplus_marker (p[0]) && p[1] != '_')
3035  {
3036  if (!read_cpp_abbrev (fip, pp, type, objfile))
3037  return 0;
3038  continue;
3039  }
3040 
3041  /* Look for the ':' that separates the field name from the field
3042  values. Data members are delimited by a single ':', while member
3043  functions are delimited by a pair of ':'s. When we hit the member
3044  functions (if any), terminate scan loop and return. */
3045 
3046  while (*p != ':' && *p != '\0')
3047  {
3048  p++;
3049  }
3050  if (*p == '\0')
3051  return 0;
3052 
3053  /* Check to see if we have hit the member functions yet. */
3054  if (p[1] == ':')
3055  {
3056  break;
3057  }
3058  read_one_struct_field (fip, pp, p, type, objfile);
3059  }
3060  if (p[0] == ':' && p[1] == ':')
3061  {
3062  /* (the deleted) chill the list of fields: the last entry (at
3063  the head) is a partially constructed entry which we now
3064  scrub. */
3065  fip->list = fip->list->next;
3066  }
3067  return 1;
3068 }
3069 /* *INDENT-OFF* */
3070 /* The stabs for C++ derived classes contain baseclass information which
3071  is marked by a '!' character after the total size. This function is
3072  called when we encounter the baseclass marker, and slurps up all the
3073  baseclass information.
3074 
3075  Immediately following the '!' marker is the number of base classes that
3076  the class is derived from, followed by information for each base class.
3077  For each base class, there are two visibility specifiers, a bit offset
3078  to the base class information within the derived class, a reference to
3079  the type for the base class, and a terminating semicolon.
3080 
3081  A typical example, with two base classes, would be "!2,020,19;0264,21;".
3082  ^^ ^ ^ ^ ^ ^ ^
3083  Baseclass information marker __________________|| | | | | | |
3084  Number of baseclasses __________________________| | | | | | |
3085  Visibility specifiers (2) ________________________| | | | | |
3086  Offset in bits from start of class _________________| | | | |
3087  Type number for base class ___________________________| | | |
3088  Visibility specifiers (2) _______________________________| | |
3089  Offset in bits from start of class ________________________| |
3090  Type number of base class ____________________________________|
3091 
3092  Return 1 for success, 0 for (error-type-inducing) failure. */
3093 /* *INDENT-ON* */
3094 
3095 
3096 
3097 static int
3098 read_baseclasses (struct field_info *fip, char **pp, struct type *type,
3099  struct objfile *objfile)
3100 {
3101  int i;
3102  struct nextfield *newobj;
3103 
3104  if (**pp != '!')
3105  {
3106  return 1;
3107  }
3108  else
3109  {
3110  /* Skip the '!' baseclass information marker. */
3111  (*pp)++;
3112  }
3113 
3115  {
3116  int nbits;
3117 
3118  TYPE_N_BASECLASSES (type) = read_huge_number (pp, ',', &nbits, 0);
3119  if (nbits != 0)
3120  return 0;
3121  }
3122 
3123 #if 0
3124  /* Some stupid compilers have trouble with the following, so break
3125  it up into simpler expressions. */
3126  TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *)
3127  TYPE_ALLOC (type, B_BYTES (TYPE_N_BASECLASSES (type)));
3128 #else
3129  {
3130  int num_bytes = B_BYTES (TYPE_N_BASECLASSES (type));
3131  char *pointer;
3132 
3133  pointer = (char *) TYPE_ALLOC (type, num_bytes);
3134  TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
3135  }
3136 #endif /* 0 */
3137 
3139 
3140  for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
3141  {
3142  newobj = (struct nextfield *) xmalloc (sizeof (struct nextfield));
3143  make_cleanup (xfree, newobj);
3144  memset (newobj, 0, sizeof (struct nextfield));
3145  newobj->next = fip->list;
3146  fip->list = newobj;
3147  FIELD_BITSIZE (newobj->field) = 0; /* This should be an unpacked
3148  field! */
3149 
3150  STABS_CONTINUE (pp, objfile);
3151  switch (**pp)
3152  {
3153  case '0':
3154  /* Nothing to do. */
3155  break;
3156  case '1':
3157  SET_TYPE_FIELD_VIRTUAL (type, i);
3158  break;
3159  default:
3160  /* Unknown character. Complain and treat it as non-virtual. */
3161  {
3163  _("Unknown virtual character `%c' for baseclass"),
3164  **pp);
3165  }
3166  }
3167  ++(*pp);
3168 
3169  newobj->visibility = *(*pp)++;
3170  switch (newobj->visibility)
3171  {
3172  case VISIBILITY_PRIVATE:
3173  case VISIBILITY_PROTECTED:
3174  case VISIBILITY_PUBLIC:
3175  break;
3176  default:
3177  /* Bad visibility format. Complain and treat it as
3178  public. */
3179  {
3181  _("Unknown visibility `%c' for baseclass"),
3182  newobj->visibility);
3183  newobj->visibility = VISIBILITY_PUBLIC;
3184  }
3185  }
3186 
3187  {
3188  int nbits;
3189 
3190  /* The remaining value is the bit offset of the portion of the object
3191  corresponding to this baseclass. Always zero in the absence of
3192  multiple inheritance. */
3193 
3194  SET_FIELD_BITPOS (newobj->field, read_huge_number (pp, ',', &nbits, 0));
3195  if (nbits != 0)
3196  return 0;
3197  }
3198 
3199  /* The last piece of baseclass information is the type of the
3200  base class. Read it, and remember it's type name as this
3201  field's name. */
3202 
3203  newobj->field.type = read_type (pp, objfile);
3204  newobj->field.name = type_name_no_tag (newobj->field.type);
3205 
3206  /* Skip trailing ';' and bump count of number of fields seen. */
3207  if (**pp == ';')
3208  (*pp)++;
3209  else
3210  return 0;
3211  }
3212  return 1;
3213 }
3214 
3215 /* The tail end of stabs for C++ classes that contain a virtual function
3216  pointer contains a tilde, a %, and a type number.
3217  The type number refers to the base class (possibly this class itself) which
3218  contains the vtable pointer for the current class.
3219 
3220  This function is called when we have parsed all the method declarations,
3221  so we can look for the vptr base class info. */
3222 
3223 static int
3224 read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
3225  struct objfile *objfile)
3226 {
3227  char *p;
3228 
3229  STABS_CONTINUE (pp, objfile);
3230 
3231  /* If we are positioned at a ';', then skip it. */
3232  if (**pp == ';')
3233  {
3234  (*pp)++;
3235  }
3236 
3237  if (**pp == '~')
3238  {
3239  (*pp)++;
3240 
3241  if (**pp == '=' || **pp == '+' || **pp == '-')
3242  {
3243  /* Obsolete flags that used to indicate the presence
3244  of constructors and/or destructors. */
3245  (*pp)++;
3246  }
3247 
3248  /* Read either a '%' or the final ';'. */
3249  if (*(*pp)++ == '%')
3250  {
3251  /* The next number is the type number of the base class
3252  (possibly our own class) which supplies the vtable for
3253  this class. Parse it out, and search that class to find
3254  its vtable pointer, and install those into TYPE_VPTR_BASETYPE
3255  and TYPE_VPTR_FIELDNO. */
3256 
3257  struct type *t;
3258  int i;
3259 
3260  t = read_type (pp, objfile);
3261  p = (*pp)++;
3262  while (*p != '\0' && *p != ';')
3263  {
3264  p++;
3265  }
3266  if (*p == '\0')
3267  {
3268  /* Premature end of symbol. */
3269  return 0;
3270  }
3271 
3272  set_type_vptr_basetype (type, t);
3273  if (type == t) /* Our own class provides vtbl ptr. */
3274  {
3275  for (i = TYPE_NFIELDS (t) - 1;
3276  i >= TYPE_N_BASECLASSES (t);
3277  --i)
3278  {
3279  const char *name = TYPE_FIELD_NAME (t, i);
3280 
3281  if (!strncmp (name, vptr_name, sizeof (vptr_name) - 2)
3282  && is_cplus_marker (name[sizeof (vptr_name) - 2]))
3283  {
3284  set_type_vptr_fieldno (type, i);
3285  goto gotit;
3286  }
3287  }
3288  /* Virtual function table field not found. */
3290  _("virtual function table pointer "
3291  "not found when defining class `%s'"),
3292  TYPE_NAME (type));
3293  return 0;
3294  }
3295  else
3296  {
3298  }
3299 
3300  gotit:
3301  *pp = p + 1;
3302  }
3303  }
3304  return 1;
3305 }
3306 
3307 static int
3309 {
3310  int n;
3311 
3312  for (n = TYPE_NFN_FIELDS (type);
3313  fip->fnlist != NULL;
3314  fip->fnlist = fip->fnlist->next)
3315  {
3316  --n; /* Circumvent Sun3 compiler bug. */
3317  TYPE_FN_FIELDLISTS (type)[n] = fip->fnlist->fn_fieldlist;
3318  }
3319  return 1;
3320 }
3321 
3322 /* Create the vector of fields, and record how big it is.
3323  We need this info to record proper virtual function table information
3324  for this class's virtual functions. */
3325 
3326 static int
3328  struct objfile *objfile)
3329 {
3330  int nfields = 0;
3331  int non_public_fields = 0;
3332  struct nextfield *scan;
3333 
3334  /* Count up the number of fields that we have, as well as taking note of
3335  whether or not there are any non-public fields, which requires us to
3336  allocate and build the private_field_bits and protected_field_bits
3337  bitfields. */
3338 
3339  for (scan = fip->list; scan != NULL; scan = scan->next)
3340  {
3341  nfields++;
3342  if (scan->visibility != VISIBILITY_PUBLIC)
3343  {
3344  non_public_fields++;
3345  }
3346  }
3347 
3348  /* Now we know how many fields there are, and whether or not there are any
3349  non-public fields. Record the field count, allocate space for the
3350  array of fields, and create blank visibility bitfields if necessary. */
3351 
3352  TYPE_NFIELDS (type) = nfields;
3353  TYPE_FIELDS (type) = (struct field *)
3354  TYPE_ALLOC (type, sizeof (struct field) * nfields);
3355  memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
3356 
3357  if (non_public_fields)
3358  {
3360 
3361  TYPE_FIELD_PRIVATE_BITS (type) =
3362  (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3363  B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
3364 
3365  TYPE_FIELD_PROTECTED_BITS (type) =
3366  (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3367  B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
3368 
3369  TYPE_FIELD_IGNORE_BITS (type) =
3370  (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3371  B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
3372  }
3373 
3374  /* Copy the saved-up fields into the field vector. Start from the
3375  head of the list, adding to the tail of the field array, so that
3376  they end up in the same order in the array in which they were
3377  added to the list. */
3378 
3379  while (nfields-- > 0)
3380  {
3381  TYPE_FIELD (type, nfields) = fip->list->field;
3382  switch (fip->list->visibility)
3383  {
3384  case VISIBILITY_PRIVATE:
3385  SET_TYPE_FIELD_PRIVATE (type, nfields);
3386  break;
3387 
3388  case VISIBILITY_PROTECTED:
3389  SET_TYPE_FIELD_PROTECTED (type, nfields);
3390  break;
3391 
3392  case VISIBILITY_IGNORE:
3393  SET_TYPE_FIELD_IGNORE (type, nfields);
3394  break;
3395 
3396  case VISIBILITY_PUBLIC:
3397  break;
3398 
3399  default:
3400  /* Unknown visibility. Complain and treat it as public. */
3401  {
3403  _("Unknown visibility `%c' for field"),
3404  fip->list->visibility);
3405  }
3406  break;
3407  }
3408  fip->list = fip->list->next;
3409  }
3410  return 1;
3411 }
3412 
3413 
3414 /* Complain that the compiler has emitted more than one definition for the
3415  structure type TYPE. */
3416 static void
3418 {
3419  const char *name = "";
3420  const char *kind = "";
3421 
3422  if (TYPE_TAG_NAME (type))
3423  {
3424  name = TYPE_TAG_NAME (type);
3425  switch (TYPE_CODE (type))
3426  {
3427  case TYPE_CODE_STRUCT: kind = "struct "; break;
3428  case TYPE_CODE_UNION: kind = "union "; break;
3429  case TYPE_CODE_ENUM: kind = "enum "; break;
3430  default: kind = "";
3431  }
3432  }
3433  else if (TYPE_NAME (type))
3434  {
3435  name = TYPE_NAME (type);
3436  kind = "";
3437  }
3438  else
3439  {
3440  name = "<unknown>";
3441  kind = "";
3442  }
3443 
3445  _("struct/union type gets multiply defined: %s%s"), kind, name);
3446 }
3447 
3448 /* Set the length for all variants of a same main_type, which are
3449  connected in the closed chain.
3450 
3451  This is something that needs to be done when a type is defined *after*
3452  some cross references to this type have already been read. Consider
3453  for instance the following scenario where we have the following two
3454  stabs entries:
3455 
3456  .stabs "t:p(0,21)=*(0,22)=k(0,23)=xsdummy:",160,0,28,-24
3457  .stabs "dummy:T(0,23)=s16x:(0,1),0,3[...]"
3458 
3459  A stubbed version of type dummy is created while processing the first
3460  stabs entry. The length of that type is initially set to zero, since
3461  it is unknown at this point. Also, a "constant" variation of type
3462  "dummy" is created as well (this is the "(0,22)=k(0,23)" section of
3463  the stabs line).
3464 
3465  The second stabs entry allows us to replace the stubbed definition
3466  with the real definition. However, we still need to adjust the length
3467  of the "constant" variation of that type, as its length was left
3468  untouched during the main type replacement... */
3469 
3470 static void
3472 {
3473  struct type *ntype = TYPE_CHAIN (type);
3474 
3475  while (ntype != type)
3476  {
3477  if (TYPE_LENGTH(ntype) == 0)
3478  TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
3479  else
3481  ntype = TYPE_CHAIN (ntype);
3482  }
3483 }
3484 
3485 /* Read the description of a structure (or union type) and return an object
3486  describing the type.
3487 
3488  PP points to a character pointer that points to the next unconsumed token
3489  in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
3490  *PP will point to "4a:1,0,32;;".
3491 
3492  TYPE points to an incomplete type that needs to be filled in.
3493 
3494  OBJFILE points to the current objfile from which the stabs information is
3495  being read. (Note that it is redundant in that TYPE also contains a pointer
3496  to this same objfile, so it might be a good idea to eliminate it. FIXME).
3497  */
3498 
3499 static struct type *
3500 read_struct_type (char **pp, struct type *type, enum type_code type_code,
3501  struct objfile *objfile)
3502 {
3503  struct cleanup *back_to;
3504  struct field_info fi;
3505 
3506  fi.list = NULL;
3507  fi.fnlist = NULL;
3508 
3509  /* When describing struct/union/class types in stabs, G++ always drops
3510  all qualifications from the name. So if you've got:
3511  struct A { ... struct B { ... }; ... };
3512  then G++ will emit stabs for `struct A::B' that call it simply
3513  `struct B'. Obviously, if you've got a real top-level definition for
3514  `struct B', or other nested definitions, this is going to cause
3515  problems.
3516 
3517  Obviously, GDB can't fix this by itself, but it can at least avoid
3518  scribbling on existing structure type objects when new definitions
3519  appear. */
3520  if (! (TYPE_CODE (type) == TYPE_CODE_UNDEF
3521  || TYPE_STUB (type)))
3522  {
3524 
3525  /* It's probably best to return the type unchanged. */
3526  return type;
3527  }
3528 
3529  back_to = make_cleanup (null_cleanup, 0);
3530 
3531  INIT_CPLUS_SPECIFIC (type);
3532  TYPE_CODE (type) = type_code;
3533  TYPE_STUB (type) = 0;
3534 
3535  /* First comes the total size in bytes. */
3536 
3537  {
3538  int nbits;
3539 
3540  TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0);
3541  if (nbits != 0)
3542  {
3543  do_cleanups (back_to);
3544  return error_type (pp, objfile);
3545  }
3546  set_length_in_type_chain (type);
3547  }
3548 
3549  /* Now read the baseclasses, if any, read the regular C struct or C++
3550  class member fields, attach the fields to the type, read the C++
3551  member functions, attach them to the type, and then read any tilde
3552  field (baseclass specifier for the class holding the main vtable). */
3553 
3554  if (!read_baseclasses (&fi, pp, type, objfile)
3555  || !read_struct_fields (&fi, pp, type, objfile)
3556  || !attach_fields_to_type (&fi, type, objfile)
3557  || !read_member_functions (&fi, pp, type, objfile)
3558  || !attach_fn_fields_to_type (&fi, type)
3559  || !read_tilde_fields (&fi, pp, type, objfile))
3560  {
3561  type = error_type (pp, objfile);
3562  }
3563 
3564  do_cleanups (back_to);
3565  return (type);
3566 }
3567 
3568 /* Read a definition of an array type,
3569  and create and return a suitable type object.
3570  Also creates a range type which represents the bounds of that
3571  array. */
3572 
3573 static struct type *
3574 read_array_type (char **pp, struct type *type,
3575  struct objfile *objfile)
3576 {
3577  struct type *index_type, *element_type, *range_type;
3578  int lower, upper;
3579  int adjustable = 0;
3580  int nbits;
3581 
3582  /* Format of an array type:
3583  "ar<index type>;lower;upper;<array_contents_type>".
3584  OS9000: "arlower,upper;<array_contents_type>".
3585 
3586  Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3587  for these, produce a type like float[][]. */
3588 
3589  {
3590  index_type = read_type (pp, objfile);
3591  if (**pp != ';')
3592  /* Improper format of array type decl. */
3593  return error_type (pp, objfile);
3594  ++*pp;
3595  }
3596 
3597  if (!(**pp >= '0' && **pp <= '9') && **pp != '-')
3598  {
3599  (*pp)++;
3600  adjustable = 1;
3601  }
3602  lower = read_huge_number (pp, ';', &nbits, 0);
3603 
3604  if (nbits != 0)
3605  return error_type (pp, objfile);
3606 
3607  if (!(**pp >= '0' && **pp <= '9') && **pp != '-')
3608  {
3609  (*pp)++;
3610  adjustable = 1;
3611  }
3612  upper = read_huge_number (pp, ';', &nbits, 0);
3613  if (nbits != 0)
3614  return error_type (pp, objfile);
3615 
3616  element_type = read_type (pp, objfile);
3617 
3618  if (adjustable)
3619  {
3620  lower = 0;
3621  upper = -1;
3622  }
3623 
3624  range_type =
3625  create_static_range_type ((struct type *) NULL, index_type, lower, upper);
3626  type = create_array_type (type, element_type, range_type);
3627 
3628  return type;
3629 }
3630 
3631 
3632 /* Read a definition of an enumeration type,
3633  and create and return a suitable type object.
3634  Also defines the symbols that represent the values of the type. */
3635 
3636 static struct type *
3637 read_enum_type (char **pp, struct type *type,
3638  struct objfile *objfile)
3639 {
3640  struct gdbarch *gdbarch = get_objfile_arch (objfile);
3641  char *p;
3642  char *name;
3643  long n;
3644  struct symbol *sym;
3645  int nsyms = 0;
3646  struct pending **symlist;
3647  struct pending *osyms, *syms;
3648  int o_nsyms;
3649  int nbits;
3650  int unsigned_enum = 1;
3651 
3652 #if 0
3653  /* FIXME! The stabs produced by Sun CC merrily define things that ought
3654  to be file-scope, between N_FN entries, using N_LSYM. What's a mother
3655  to do? For now, force all enum values to file scope. */
3656  if (within_function)
3657  symlist = &local_symbols;
3658  else
3659 #endif
3660  symlist = &file_symbols;
3661  osyms = *symlist;
3662  o_nsyms = osyms ? osyms->nsyms : 0;
3663 
3664  /* The aix4 compiler emits an extra field before the enum members;
3665  my guess is it's a type of some sort. Just ignore it. */
3666  if (**pp == '-')
3667  {
3668  /* Skip over the type. */
3669  while (**pp != ':')
3670  (*pp)++;
3671 
3672  /* Skip over the colon. */
3673  (*pp)++;
3674  }
3675 
3676  /* Read the value-names and their values.
3677  The input syntax is NAME:VALUE,NAME:VALUE, and so on.
3678  A semicolon or comma instead of a NAME means the end. */
3679  while (**pp && **pp != ';' && **pp != ',')
3680  {
3681  STABS_CONTINUE (pp, objfile);
3682  p = *pp;
3683  while (*p != ':')
3684  p++;
3685  name = obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
3686  *pp = p + 1;
3687  n = read_huge_number (pp, ',', &nbits, 0);
3688  if (nbits != 0)
3689  return error_type (pp, objfile);
3690 
3691  sym = allocate_symbol (objfile);
3692  SYMBOL_SET_LINKAGE_NAME (sym, name);
3694  &objfile->objfile_obstack);
3696  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
3697  SYMBOL_VALUE (sym) = n;
3698  if (n < 0)
3699  unsigned_enum = 0;
3700  add_symbol_to_list (sym, symlist);
3701  nsyms++;
3702  }
3703 
3704  if (**pp == ';')
3705  (*pp)++; /* Skip the semicolon. */
3706 
3707  /* Now fill in the fields of the type-structure. */
3708 
3709  TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
3710  set_length_in_type_chain (type);
3711  TYPE_CODE (type) = TYPE_CODE_ENUM;
3712  TYPE_STUB (type) = 0;
3713  if (unsigned_enum)
3714  TYPE_UNSIGNED (type) = 1;
3715  TYPE_NFIELDS (type) = nsyms;
3716  TYPE_FIELDS (type) = (struct field *)
3717  TYPE_ALLOC (type, sizeof (struct field) * nsyms);
3718  memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nsyms);
3719 
3720  /* Find the symbols for the values and put them into the type.
3721  The symbols can be found in the symlist that we put them on
3722  to cause them to be defined. osyms contains the old value
3723  of that symlist; everything up to there was defined by us. */
3724  /* Note that we preserve the order of the enum constants, so
3725  that in something like "enum {FOO, LAST_THING=FOO}" we print
3726  FOO, not LAST_THING. */
3727 
3728  for (syms = *symlist, n = nsyms - 1; syms; syms = syms->next)
3729  {
3730  int last = syms == osyms ? o_nsyms : 0;
3731  int j = syms->nsyms;
3732 
3733  for (; --j >= last; --n)
3734  {
3735  struct symbol *xsym = syms->symbol[j];
3736 
3737  SYMBOL_TYPE (xsym) = type;
3738  TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym);
3739  SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
3740  TYPE_FIELD_BITSIZE (type, n) = 0;
3741  }
3742  if (syms == osyms)
3743  break;
3744  }
3745 
3746  return type;
3747 }
3748 
3749 /* Sun's ACC uses a somewhat saner method for specifying the builtin
3750  typedefs in every file (for int, long, etc):
3751 
3752  type = b <signed> <width> <format type>; <offset>; <nbits>
3753  signed = u or s.
3754  optional format type = c or b for char or boolean.
3755  offset = offset from high order bit to start bit of type.
3756  width is # bytes in object of this type, nbits is # bits in type.
3757 
3758  The width/offset stuff appears to be for small objects stored in
3759  larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
3760  FIXME. */
3761 
3762 static struct type *
3763 read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
3764 {
3765  int type_bits;
3766  int nbits;
3767  int signed_type;
3768  enum type_code code = TYPE_CODE_INT;
3769 
3770  switch (**pp)
3771  {
3772  case 's':
3773  signed_type = 1;
3774  break;
3775  case 'u':
3776  signed_type = 0;
3777  break;
3778  default:
3779  return error_type (pp, objfile);
3780  }
3781  (*pp)++;
3782 
3783  /* For some odd reason, all forms of char put a c here. This is strange
3784  because no other type has this honor. We can safely ignore this because
3785  we actually determine 'char'acterness by the number of bits specified in
3786  the descriptor.
3787  Boolean forms, e.g Fortran logical*X, put a b here. */
3788 
3789  if (**pp == 'c')
3790  (*pp)++;
3791  else if (**pp == 'b')
3792  {
3793  code = TYPE_CODE_BOOL;
3794  (*pp)++;
3795  }
3796 
3797  /* The first number appears to be the number of bytes occupied
3798  by this type, except that unsigned short is 4 instead of 2.
3799  Since this information is redundant with the third number,
3800  we will ignore it. */
3801  read_huge_number (pp, ';', &nbits, 0);
3802  if (nbits != 0)
3803  return error_type (pp, objfile);
3804 
3805  /* The second number is always 0, so ignore it too. */
3806  read_huge_number (pp, ';', &nbits, 0);
3807  if (nbits != 0)
3808  return error_type (pp, objfile);
3809 
3810  /* The third number is the number of bits for this type. */
3811  type_bits = read_huge_number (pp, 0, &nbits, 0);
3812  if (nbits != 0)
3813  return error_type (pp, objfile);
3814  /* The type *should* end with a semicolon. If it are embedded
3815  in a larger type the semicolon may be the only way to know where
3816  the type ends. If this type is at the end of the stabstring we
3817  can deal with the omitted semicolon (but we don't have to like
3818  it). Don't bother to complain(), Sun's compiler omits the semicolon
3819  for "void". */
3820  if (**pp == ';')
3821  ++(*pp);
3822 
3823  if (type_bits == 0)
3824  return init_type (TYPE_CODE_VOID, 1,
3825  signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL,
3826  objfile);
3827  else
3828  return init_type (code,
3829  type_bits / TARGET_CHAR_BIT,
3830  signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL,
3831  objfile);
3832 }
3833 
3834 static struct type *
3835 read_sun_floating_type (char **pp, int typenums[2], struct objfile *objfile)
3836 {
3837  int nbits;
3838  int details;
3839  int nbytes;
3840  struct type *rettype;
3841 
3842  /* The first number has more details about the type, for example
3843  FN_COMPLEX. */
3844  details = read_huge_number (pp, ';', &nbits, 0);
3845  if (nbits != 0)
3846  return error_type (pp, objfile);
3847 
3848  /* The second number is the number of bytes occupied by this type. */
3849  nbytes = read_huge_number (pp, ';', &nbits, 0);
3850  if (nbits != 0)
3851  return error_type (pp, objfile);
3852 
3853  if (details == NF_COMPLEX || details == NF_COMPLEX16
3854  || details == NF_COMPLEX32)
3855  {
3856  rettype = init_type (TYPE_CODE_COMPLEX, nbytes, 0, NULL, objfile);
3857  TYPE_TARGET_TYPE (rettype)
3858  = init_type (TYPE_CODE_FLT, nbytes / 2, 0, NULL, objfile);
3859  return rettype;
3860  }
3861 
3862  return init_type (TYPE_CODE_FLT, nbytes, 0, NULL, objfile);
3863 }
3864 
3865 /* Read a number from the string pointed to by *PP.
3866  The value of *PP is advanced over the number.
3867  If END is nonzero, the character that ends the
3868  number must match END, or an error happens;
3869  and that character is skipped if it does match.
3870  If END is zero, *PP is left pointing to that character.
3871 
3872  If TWOS_COMPLEMENT_BITS is set to a strictly positive value and if
3873  the number is represented in an octal representation, assume that
3874  it is represented in a 2's complement representation with a size of
3875  TWOS_COMPLEMENT_BITS.
3876 
3877  If the number fits in a long, set *BITS to 0 and return the value.
3878  If not, set *BITS to be the number of bits in the number and return 0.
3879 
3880  If encounter garbage, set *BITS to -1 and return 0. */
3881 
3882 static long
3883 read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
3884 {
3885  char *p = *pp;
3886  int sign = 1;
3887  int sign_bit = 0;
3888  long n = 0;
3889  int radix = 10;
3890  char overflow = 0;
3891  int nbits = 0;
3892  int c;
3893  long upper_limit;
3894  int twos_complement_representation = 0;
3895 
3896  if (*p == '-')
3897  {
3898  sign = -1;
3899  p++;
3900  }
3901 
3902  /* Leading zero means octal. GCC uses this to output values larger
3903  than an int (because that would be hard in decimal). */
3904  if (*p == '0')
3905  {
3906  radix = 8;
3907  p++;
3908  }
3909 
3910  /* Skip extra zeros. */
3911  while (*p == '0')
3912  p++;
3913 
3914  if (sign > 0 && radix == 8 && twos_complement_bits > 0)
3915  {
3916  /* Octal, possibly signed. Check if we have enough chars for a
3917  negative number. */
3918 
3919  size_t len;
3920  char *p1 = p;
3921 
3922  while ((c = *p1) >= '0' && c < '8')
3923  p1++;
3924 
3925  len = p1 - p;
3926  if (len > twos_complement_bits / 3
3927  || (twos_complement_bits % 3 == 0
3928  && len == twos_complement_bits / 3))
3929  {
3930  /* Ok, we have enough characters for a signed value, check
3931  for signness by testing if the sign bit is set. */
3932  sign_bit = (twos_complement_bits % 3 + 2) % 3;
3933  c = *p - '0';
3934  if (c & (1 << sign_bit))
3935  {
3936  /* Definitely signed. */
3937  twos_complement_representation = 1;
3938  sign = -1;
3939  }
3940  }
3941  }
3942 
3943  upper_limit = LONG_MAX / radix;
3944 
3945  while ((c = *p++) >= '0' && c < ('0' + radix))
3946  {
3947  if (n <= upper_limit)
3948  {
3949  if (twos_complement_representation)
3950  {
3951  /* Octal, signed, twos complement representation. In
3952  this case, n is the corresponding absolute value. */
3953  if (n == 0)
3954  {
3955  long sn = c - '0' - ((2 * (c - '0')) | (2 << sign_bit));
3956 
3957  n = -sn;
3958  }
3959  else
3960  {
3961  n *= radix;
3962  n -= c - '0';
3963  }
3964  }
3965  else
3966  {
3967  /* unsigned representation */
3968  n *= radix;
3969  n += c - '0'; /* FIXME this overflows anyway. */
3970  }
3971  }
3972  else
3973  overflow = 1;
3974 
3975  /* This depends on large values being output in octal, which is
3976  what GCC does. */
3977  if (radix == 8)
3978  {
3979  if (nbits == 0)
3980  {
3981  if (c == '0')
3982  /* Ignore leading zeroes. */
3983  ;
3984  else if (c == '1')
3985  nbits = 1;
3986  else if (c == '2' || c == '3')
3987  nbits = 2;
3988  else
3989  nbits = 3;
3990  }
3991  else
3992  nbits += 3;
3993  }
3994  }
3995  if (end)
3996  {
3997  if (c && c != end)
3998  {
3999  if (bits != NULL)
4000  *bits = -1;
4001  return 0;
4002  }
4003  }
4004  else
4005  --p;
4006 
4007  if (radix == 8 && twos_complement_bits > 0 && nbits > twos_complement_bits)
4008  {
4009  /* We were supposed to parse a number with maximum
4010  TWOS_COMPLEMENT_BITS bits, but something went wrong. */
4011  if (bits != NULL)
4012  *bits = -1;
4013  return 0;
4014  }
4015 
4016  *pp = p;
4017  if (overflow)
4018  {
4019  if (nbits == 0)
4020  {
4021  /* Large decimal constants are an error (because it is hard to
4022  count how many bits are in them). */
4023  if (bits != NULL)
4024  *bits = -1;
4025  return 0;
4026  }
4027 
4028  /* -0x7f is the same as 0x80. So deal with it by adding one to
4029  the number of bits. Two's complement represention octals
4030  can't have a '-' in front. */
4031  if (sign == -1 && !twos_complement_representation)
4032  ++nbits;
4033  if (bits)
4034  *bits = nbits;
4035  }
4036  else
4037  {
4038  if (bits)
4039  *bits = 0;
4040  return n * sign;
4041  }
4042  /* It's *BITS which has the interesting information. */
4043  return 0;
4044 }
4045 
4046 static struct type *
4047 read_range_type (char **pp, int typenums[2], int type_size,
4048  struct objfile *objfile)
4049 {
4050  struct gdbarch *gdbarch = get_objfile_arch (objfile);
4051  char *orig_pp = *pp;
4052  int rangenums[2];
4053  long n2, n3;
4054  int n2bits, n3bits;
4055  int self_subrange;
4056  struct type *result_type;
4057  struct type *index_type = NULL;
4058 
4059  /* First comes a type we are a subrange of.
4060  In C it is usually 0, 1 or the type being defined. */
4061  if (read_type_number (pp, rangenums) != 0)
4062  return error_type (pp, objfile);
4063  self_subrange = (rangenums[0] == typenums[0] &&
4064  rangenums[1] == typenums[1]);
4065 
4066  if (**pp == '=')
4067  {
4068  *pp = orig_pp;
4069  index_type = read_type (pp, objfile);
4070  }
4071 
4072  /* A semicolon should now follow; skip it. */
4073  if (**pp == ';')
4074  (*pp)++;
4075 
4076  /* The remaining two operands are usually lower and upper bounds
4077  of the range. But in some special cases they mean something else. */
4078  n2 = read_huge_number (pp, ';', &n2bits, type_size);
4079  n3 = read_huge_number (pp, ';', &n3bits, type_size);
4080 
4081  if (n2bits == -1 || n3bits == -1)
4082  return error_type (pp, objfile);
4083 
4084  if (index_type)
4085  goto handle_true_range;
4086 
4087  /* If limits are huge, must be large integral type. */
4088  if (n2bits != 0 || n3bits != 0)
4089  {
4090  char got_signed = 0;
4091  char got_unsigned = 0;
4092  /* Number of bits in the type. */
4093  int nbits = 0;
4094 
4095  /* If a type size attribute has been specified, the bounds of
4096  the range should fit in this size. If the lower bounds needs
4097  more bits than the upper bound, then the type is signed. */
4098  if (n2bits <= type_size && n3bits <= type_size)
4099  {
4100  if (n2bits == type_size && n2bits > n3bits)
4101  got_signed = 1;
4102  else
4103  got_unsigned = 1;
4104  nbits = type_size;
4105  }
4106  /* Range from 0 to <large number> is an unsigned large integral type. */
4107  else if ((n2bits == 0 && n2 == 0) && n3bits != 0)
4108  {
4109  got_unsigned = 1;
4110  nbits = n3bits;
4111  }
4112  /* Range from <large number> to <large number>-1 is a large signed
4113  integral type. Take care of the case where <large number> doesn't
4114  fit in a long but <large number>-1 does. */
4115  else if ((n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
4116  || (n2bits != 0 && n3bits == 0
4117  && (n2bits == sizeof (long) * HOST_CHAR_BIT)
4118  && n3 == LONG_MAX))
4119  {
4120  got_signed = 1;
4121  nbits = n2bits;
4122  }
4123 
4124  if (got_signed || got_unsigned)
4125  {
4126  return init_type (TYPE_CODE_INT, nbits / TARGET_CHAR_BIT,
4127  got_unsigned ? TYPE_FLAG_UNSIGNED : 0, NULL,
4128  objfile);
4129  }
4130  else
4131  return error_type (pp, objfile);
4132  }
4133 
4134  /* A type defined as a subrange of itself, with bounds both 0, is void. */
4135  if (self_subrange && n2 == 0 && n3 == 0)
4136  return init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
4137 
4138  /* If n3 is zero and n2 is positive, we want a floating type, and n2
4139  is the width in bytes.
4140 
4141  Fortran programs appear to use this for complex types also. To
4142  distinguish between floats and complex, g77 (and others?) seem
4143  to use self-subranges for the complexes, and subranges of int for
4144  the floats.
4145 
4146  Also note that for complexes, g77 sets n2 to the size of one of
4147  the member floats, not the whole complex beast. My guess is that
4148  this was to work well with pre-COMPLEX versions of gdb. */
4149 
4150  if (n3 == 0 && n2 > 0)
4151  {
4152  struct type *float_type
4153  = init_type (TYPE_CODE_FLT, n2, 0, NULL, objfile);
4154 
4155  if (self_subrange)
4156  {
4157  struct type *complex_type =
4158  init_type (TYPE_CODE_COMPLEX, 2 * n2, 0, NULL, objfile);
4159 
4160  TYPE_TARGET_TYPE (complex_type) = float_type;
4161  return complex_type;
4162  }
4163  else
4164  return float_type;
4165  }
4166 
4167  /* If the upper bound is -1, it must really be an unsigned integral. */
4168 
4169  else if (n2 == 0 && n3 == -1)
4170  {
4171  int bits = type_size;
4172 
4173  if (bits <= 0)
4174  {
4175  /* We don't know its size. It is unsigned int or unsigned
4176  long. GCC 2.3.3 uses this for long long too, but that is
4177  just a GDB 3.5 compatibility hack. */
4178  bits = gdbarch_int_bit (gdbarch);
4179  }
4180 
4181  return init_type (TYPE_CODE_INT, bits / TARGET_CHAR_BIT,
4182  TYPE_FLAG_UNSIGNED, NULL, objfile);
4183  }
4184 
4185  /* Special case: char is defined (Who knows why) as a subrange of
4186  itself with range 0-127. */
4187  else if (self_subrange && n2 == 0 && n3 == 127)
4188  return init_type (TYPE_CODE_INT, 1, TYPE_FLAG_NOSIGN, NULL, objfile);
4189 
4190  /* We used to do this only for subrange of self or subrange of int. */
4191  else if (n2 == 0)
4192  {
4193  /* -1 is used for the upper bound of (4 byte) "unsigned int" and
4194  "unsigned long", and we already checked for that,
4195  so don't need to test for it here. */
4196 
4197  if (n3 < 0)
4198  /* n3 actually gives the size. */
4200  NULL, objfile);
4201 
4202  /* Is n3 == 2**(8n)-1 for some integer n? Then it's an
4203  unsigned n-byte integer. But do require n to be a power of
4204  two; we don't want 3- and 5-byte integers flying around. */
4205  {
4206  int bytes;
4207  unsigned long bits;
4208 
4209  bits = n3;
4210  for (bytes = 0; (bits & 0xff) == 0xff; bytes++)
4211  bits >>= 8;
4212  if (bits == 0
4213  && ((bytes - 1) & bytes) == 0) /* "bytes is a power of two" */
4214  return init_type (TYPE_CODE_INT, bytes, TYPE_FLAG_UNSIGNED, NULL,
4215  objfile);
4216  }
4217  }
4218  /* I think this is for Convex "long long". Since I don't know whether
4219  Convex sets self_subrange, I also accept that particular size regardless
4220  of self_subrange. */
4221  else if (n3 == 0 && n2 < 0
4222  && (self_subrange
4223  || n2 == -gdbarch_long_long_bit
4224  (gdbarch) / TARGET_CHAR_BIT))
4225  return init_type (TYPE_CODE_INT, -n2, 0, NULL, objfile);
4226  else if (n2 == -n3 - 1)
4227  {
4228  if (n3 == 0x7f)
4229  return init_type (TYPE_CODE_INT, 1, 0, NULL, objfile);
4230  if (n3 == 0x7fff)
4231  return init_type (TYPE_CODE_INT, 2, 0, NULL, objfile);
4232  if (n3 == 0x7fffffff)
4233  return init_type (TYPE_CODE_INT, 4, 0, NULL, objfile);
4234  }
4235 
4236  /* We have a real range type on our hands. Allocate space and
4237  return a real pointer. */
4238 handle_true_range:
4239 
4240  if (self_subrange)
4241  index_type = objfile_type (objfile)->builtin_int;
4242  else
4243  index_type = *dbx_lookup_type (rangenums, objfile);
4244  if (index_type == NULL)
4245  {
4246  /* Does this actually ever happen? Is that why we are worrying
4247  about dealing with it rather than just calling error_type? */
4248 
4250  _("base type %d of range type is not defined"), rangenums[1]);
4251 
4252  index_type = objfile_type (objfile)->builtin_int;
4253  }
4254 
4255  result_type
4256  = create_static_range_type ((struct type *) NULL, index_type, n2, n3);
4257  return (result_type);
4258 }
4259 
4260 /* Read in an argument list. This is a list of types, separated by commas
4261  and terminated with END. Return the list of types read in, or NULL
4262  if there is an error. */
4263 
4264 static struct field *
4265 read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
4266  int *varargsp)
4267 {
4268  /* FIXME! Remove this arbitrary limit! */
4269  struct type *types[1024]; /* Allow for fns of 1023 parameters. */
4270  int n = 0, i;
4271  struct field *rval;
4272 
4273  while (**pp != end)
4274  {
4275  if (**pp != ',')
4276  /* Invalid argument list: no ','. */
4277  return NULL;
4278  (*pp)++;
4279  STABS_CONTINUE (pp, objfile);
4280  types[n++] = read_type (pp, objfile);
4281  }
4282  (*pp)++; /* get past `end' (the ':' character). */
4283 
4284  if (n == 0)
4285  {
4286  /* We should read at least the THIS parameter here. Some broken stabs
4287  output contained `(0,41),(0,42)=@s8;-16;,(0,43),(0,1);' where should
4288  have been present ";-16,(0,43)" reference instead. This way the
4289  excessive ";" marker prematurely stops the parameters parsing. */
4290 
4291  complaint (&symfile_complaints, _("Invalid (empty) method arguments"));
4292  *varargsp = 0;
4293  }
4294  else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
4295  *varargsp = 1;
4296  else
4297  {
4298  n--;
4299  *varargsp = 0;
4300  }
4301 
4302  rval = (struct field *) xmalloc (n * sizeof (struct field));
4303  memset (rval, 0, n * sizeof (struct field));
4304  for (i = 0; i < n; i++)
4305  rval[i].type = types[i];
4306  *nargsp = n;
4307  return rval;
4308 }
4309 
4310 /* Common block handling. */
4311 
4312 /* List of symbols declared since the last BCOMM. This list is a tail
4313  of local_symbols. When ECOMM is seen, the symbols on the list
4314  are noted so their proper addresses can be filled in later,
4315  using the common block base address gotten from the assembler
4316  stabs. */
4317 
4318 static struct pending *common_block;
4319 static int common_block_i;
4320 
4321 /* Name of the current common block. We get it from the BCOMM instead of the
4322  ECOMM to match IBM documentation (even though IBM puts the name both places
4323  like everyone else). */
4324 static char *common_block_name;
4325 
4326 /* Process a N_BCOMM symbol. The storage for NAME is not guaranteed
4327  to remain after this function returns. */
4328 
4329 void
4331 {
4332  if (common_block_name != NULL)
4333  {
4335  _("Invalid symbol data: common block within common block"));
4336  }
4337  common_block = local_symbols;
4339  common_block_name = obstack_copy0 (&objfile->objfile_obstack,
4340  name, strlen (name));
4341 }
4342 
4343 /* Process a N_ECOMM symbol. */
4344 
4345 void
4347 {
4348  /* Symbols declared since the BCOMM are to have the common block
4349  start address added in when we know it. common_block and
4350  common_block_i point to the first symbol after the BCOMM in
4351  the local_symbols list; copy the list and hang it off the
4352  symbol for the common block name for later fixup. */
4353  int i;
4354  struct symbol *sym;
4355  struct pending *newobj = 0;
4356  struct pending *next;
4357  int j;
4358 
4359  if (common_block_name == NULL)
4360  {
4361  complaint (&symfile_complaints, _("ECOMM symbol unmatched by BCOMM"));
4362  return;
4363  }
4364 
4365  sym = allocate_symbol (objfile);
4366  /* Note: common_block_name already saved on objfile_obstack. */
4369 
4370  /* Now we copy all the symbols which have been defined since the BCOMM. */
4371 
4372  /* Copy all the struct pendings before common_block. */
4373  for (next = local_symbols;
4374  next != NULL && next != common_block;
4375  next = next->next)
4376  {
4377  for (j = 0; j < next->nsyms; j++)
4378  add_symbol_to_list (next->symbol[j], &newobj);
4379  }
4380 
4381  /* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is
4382  NULL, it means copy all the local symbols (which we already did
4383  above). */
4384 
4385  if (common_block != NULL)
4386  for (j = common_block_i; j < common_block->nsyms; j++)
4387  add_symbol_to_list (common_block->symbol[j], &newobj);
4388 
4389  SYMBOL_TYPE (sym) = (struct type *) newobj;
4390 
4391  /* Should we be putting local_symbols back to what it was?
4392  Does it matter? */
4393 
4394  i = hashname (SYMBOL_LINKAGE_NAME (sym));
4396  global_sym_chain[i] = sym;
4397  common_block_name = NULL;
4398 }
4399 
4400 /* Add a common block's start address to the offset of each symbol
4401  declared to be in it (by being between a BCOMM/ECOMM pair that uses
4402  the common block name). */
4403 
4404 static void
4405 fix_common_block (struct symbol *sym, CORE_ADDR valu)
4406 {
4407  struct pending *next = (struct pending *) SYMBOL_TYPE (sym);
4408 
4409  for (; next; next = next->next)
4410  {
4411  int j;
4412 
4413  for (j = next->nsyms - 1; j >= 0; j--)
4414  SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu;
4415  }
4416 }
4417 
4418 
4419 
4420 /* Add {TYPE, TYPENUMS} to the NONAME_UNDEFS vector.
4421  See add_undefined_type for more details. */
4422 
4423 static void
4424 add_undefined_type_noname (struct type *type, int typenums[2])
4425 {
4426  struct nat nat;
4427 
4428  nat.typenums[0] = typenums [0];
4429  nat.typenums[1] = typenums [1];
4430  nat.type = type;
4431 
4433  {
4435  noname_undefs = (struct nat *)
4436  xrealloc ((char *) noname_undefs,
4437  noname_undefs_allocated * sizeof (struct nat));
4438  }
4439  noname_undefs[noname_undefs_length++] = nat;
4440 }
4441 
4442 /* Add TYPE to the UNDEF_TYPES vector.
4443  See add_undefined_type for more details. */
4444 
4445 static void
4447 {
4449  {
4450  undef_types_allocated *= 2;
4451  undef_types = (struct type **)
4452  xrealloc ((char *) undef_types,
4453  undef_types_allocated * sizeof (struct type *));
4454  }
4455  undef_types[undef_types_length++] = type;
4456 }
4457 
4458 /* What about types defined as forward references inside of a small lexical
4459  scope? */
4460 /* Add a type to the list of undefined types to be checked through
4461  once this file has been read in.
4462 
4463  In practice, we actually maintain two such lists: The first list
4464  (UNDEF_TYPES) is used for types whose name has been provided, and
4465  concerns forward references (eg 'xs' or 'xu' forward references);
4466  the second list (NONAME_UNDEFS) is used for types whose name is
4467  unknown at creation time, because they were referenced through
4468  their type number before the actual type was declared.
4469  This function actually adds the given type to the proper list. */
4470 
4471 static void
4472 add_undefined_type (struct type *type, int typenums[2])
4473 {
4474  if (TYPE_TAG_NAME (type) == NULL)
4475  add_undefined_type_noname (type, typenums);
4476  else
4477  add_undefined_type_1 (type);
4478 }
4479 
4480 /* Try to fix all undefined types pushed on the UNDEF_TYPES vector. */
4481 
4482 static void
4484 {
4485  int i;
4486 
4487  for (i = 0; i < noname_undefs_length; i++)
4488  {
4489  struct nat nat = noname_undefs[i];
4490  struct type **type;
4491 
4492  type = dbx_lookup_type (nat.typenums, objfile);
4493  if (nat.type != *type && TYPE_CODE (*type) != TYPE_CODE_UNDEF)
4494  {
4495  /* The instance flags of the undefined type are still unset,
4496  and needs to be copied over from the reference type.
4497  Since replace_type expects them to be identical, we need
4498  to set these flags manually before hand. */
4500  replace_type (nat.type, *type);
4501  }
4502  }
4503 
4504  noname_undefs_length = 0;
4505 }
4506 
4507 /* Go through each undefined type, see if it's still undefined, and fix it
4508  up if possible. We have two kinds of undefined types:
4509 
4510  TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
4511  Fix: update array length using the element bounds
4512  and the target type's length.
4513  TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
4514  yet defined at the time a pointer to it was made.
4515  Fix: Do a full lookup on the struct/union tag. */
4516 
4517 static void
4519 {
4520  struct type **type;
4521 
4522  /* Iterate over every undefined type, and look for a symbol whose type
4523  matches our undefined type. The symbol matches if:
4524  1. It is a typedef in the STRUCT domain;
4525  2. It has the same name, and same type code;
4526  3. The instance flags are identical.
4527 
4528  It is important to check the instance flags, because we have seen
4529  examples where the debug info contained definitions such as:
4530 
4531  "foo_t:t30=B31=xefoo_t:"
4532 
4533  In this case, we have created an undefined type named "foo_t" whose
4534  instance flags is null (when processing "xefoo_t"), and then created
4535  another type with the same name, but with different instance flags
4536  ('B' means volatile). I think that the definition above is wrong,
4537  since the same type cannot be volatile and non-volatile at the same
4538  time, but we need to be able to cope with it when it happens. The
4539  approach taken here is to treat these two types as different. */
4540 
4541  for (type = undef_types; type < undef_types + undef_types_length; type++)
4542  {
4543  switch (TYPE_CODE (*type))
4544  {
4545 
4546  case TYPE_CODE_STRUCT:
4547  case TYPE_CODE_UNION:
4548  case TYPE_CODE_ENUM:
4549  {
4550  /* Check if it has been defined since. Need to do this here
4551  as well as in check_typedef to deal with the (legitimate in
4552  C though not C++) case of several types with the same name
4553  in different source files. */
4554  if (TYPE_STUB (*type))
4555  {
4556  struct pending *ppt;
4557  int i;
4558  /* Name of the type, without "struct" or "union". */
4559  const char *type_name = TYPE_TAG_NAME (*type);
4560 
4561  if (type_name == NULL)
4562  {
4563  complaint (&symfile_complaints, _("need a type name"));
4564  break;
4565  }
4566  for (ppt = file_symbols; ppt; ppt = ppt->next)
4567  {
4568  for (i = 0; i < ppt->nsyms; i++)
4569  {
4570  struct symbol *sym = ppt->symbol[i];
4571 
4572  if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
4573  && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4574  && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
4575  TYPE_CODE (*type))
4576  && (TYPE_INSTANCE_FLAGS (*type) ==
4578  && strcmp (SYMBOL_LINKAGE_NAME (sym),
4579  type_name) == 0)
4580  replace_type (*type, SYMBOL_TYPE (sym));
4581  }
4582  }
4583  }
4584  }
4585  break;
4586 
4587  default:
4588  {
4590  _("forward-referenced types left unresolved, "
4591  "type code %d."),
4592  TYPE_CODE (*type));
4593  }
4594  break;
4595  }
4596  }
4597 
4598  undef_types_length = 0;
4599 }
4600 
4601 /* Try to fix all the undefined types we ecountered while processing
4602  this unit. */
4603 
4604 void
4606 {
4609 }
4610 
4611 /* Scan through all of the global symbols defined in the object file,
4612  assigning values to the debugging symbols that need to be assigned
4613  to. Get these symbols from the minimal symbol table. */
4614 
4615 void
4617 {
4618  int hash;
4619  struct minimal_symbol *msymbol;
4620  struct symbol *sym, *prev;
4621  struct objfile *resolve_objfile;
4622 
4623  /* SVR4 based linkers copy referenced global symbols from shared
4624  libraries to the main executable.
4625  If we are scanning the symbols for a shared library, try to resolve
4626  them from the minimal symbols of the main executable first. */
4627 
4628  if (symfile_objfile && objfile != symfile_objfile)
4629  resolve_objfile = symfile_objfile;
4630  else
4631  resolve_objfile = objfile;
4632 
4633  while (1)
4634  {
4635  /* Avoid expensive loop through all minimal symbols if there are
4636  no unresolved symbols. */
4637  for (hash = 0; hash < HASHSIZE; hash++)
4638  {
4639  if (global_sym_chain[hash])
4640  break;
4641  }
4642  if (hash >= HASHSIZE)
4643  return;
4644 
4645  ALL_OBJFILE_MSYMBOLS (resolve_objfile, msymbol)
4646  {
4647  QUIT;
4648 
4649  /* Skip static symbols. */
4650  switch (MSYMBOL_TYPE (msymbol))
4651  {
4652  case mst_file_text:
4653  case mst_file_data:
4654  case mst_file_bss:
4655  continue;
4656  default:
4657  break;
4658  }
4659 
4660  prev = NULL;
4661 
4662  /* Get the hash index and check all the symbols
4663  under that hash index. */
4664 
4665  hash = hashname (MSYMBOL_LINKAGE_NAME (msymbol));
4666 
4667  for (sym = global_sym_chain[hash]; sym;)
4668  {
4669  if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
4670  SYMBOL_LINKAGE_NAME (sym)) == 0)
4671  {
4672  /* Splice this symbol out of the hash chain and
4673  assign the value we have to it. */
4674  if (prev)
4675  {
4676  SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
4677  }
4678  else
4679  {
4681  }
4682 
4683  /* Check to see whether we need to fix up a common block. */
4684  /* Note: this code might be executed several times for
4685  the same symbol if there are multiple references. */
4686  if (sym)
4687  {
4688  if (SYMBOL_CLASS (sym) == LOC_BLOCK)
4689  {
4690  fix_common_block (sym,
4691  MSYMBOL_VALUE_ADDRESS (resolve_objfile,
4692  msymbol));
4693  }
4694  else
4695  {
4696  SYMBOL_VALUE_ADDRESS (sym)
4697  = MSYMBOL_VALUE_ADDRESS (resolve_objfile, msymbol);
4698  }
4699  SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msymbol);
4700  }
4701 
4702  if (prev)
4703  {
4704  sym = SYMBOL_VALUE_CHAIN (prev);
4705  }
4706  else
4707  {
4708  sym = global_sym_chain[hash];
4709  }
4710  }
4711  else
4712  {
4713  prev = sym;
4714  sym = SYMBOL_VALUE_CHAIN (sym);
4715  }
4716  }
4717  }
4718  if (resolve_objfile == objfile)
4719  break;
4720  resolve_objfile = objfile;
4721  }
4722 
4723  /* Change the storage class of any remaining unresolved globals to
4724  LOC_UNRESOLVED and remove them from the chain. */
4725  for (hash = 0; hash < HASHSIZE; hash++)
4726  {
4727  sym = global_sym_chain[hash];
4728  while (sym)
4729  {
4730  prev = sym;
4731  sym = SYMBOL_VALUE_CHAIN (sym);
4732 
4733  /* Change the symbol address from the misleading chain value
4734  to address zero. */
4735  SYMBOL_VALUE_ADDRESS (prev) = 0;
4736 
4737  /* Complain about unresolved common block symbols. */
4738  if (SYMBOL_CLASS (prev) == LOC_STATIC)
4740  else
4742  _("%s: common block `%s' from "
4743  "global_sym_chain unresolved"),
4744  objfile_name (objfile), SYMBOL_PRINT_NAME (prev));
4745  }
4746  }
4747  memset (global_sym_chain, 0, sizeof (global_sym_chain));
4748 }
4749 
4750 /* Initialize anything that needs initializing when starting to read
4751  a fresh piece of a symbol file, e.g. reading in the stuff corresponding
4752  to a psymtab. */
4753 
4754 void
4756 {
4757 }
4758 
4759 /* Initialize anything that needs initializing when a completely new
4760  symbol file is specified (not just adding some symbols from another
4761  file, e.g. a shared library). */
4762 
4763 void
4765 {
4766  /* Empty the hash table of global syms looking for values. */
4767  memset (global_sym_chain, 0, sizeof (global_sym_chain));
4768 }
4769 
4770 /* Initialize anything that needs initializing at the same time as
4771  start_symtab() is called. */
4772 
4773 void
4775 {
4776  global_stabs = NULL; /* AIX COFF */
4777  /* Leave FILENUM of 0 free for builtin types and this file's types. */
4779  type_vector_length = 0;
4780  type_vector = (struct type **) 0;
4781 
4782  /* FIXME: If common_block_name is not already NULL, we should complain(). */
4783  common_block_name = NULL;
4784 }
4785 
4786 /* Call after end_symtab(). */
4787 
4788 void
4790 {
4791  if (type_vector)
4792  {
4793  xfree (type_vector);
4794  }
4795  type_vector = 0;
4796  type_vector_length = 0;
4797  previous_stab_code = 0;
4798 }
4799 
4800 void
4802 {
4803  if (global_stabs)
4804  {
4806  xfree (global_stabs);
4807  global_stabs = NULL;
4808  }
4809 }
4810 
4811 /* Find the end of the name, delimited by a ':', but don't match
4812  ObjC symbols which look like -[Foo bar::]:bla. */
4813 static char *
4815 {
4816  char *s = name;
4817 
4818  if (s[0] == '-' || *s == '+')
4819  {
4820  /* Must be an ObjC method symbol. */
4821  if (s[1] != '[')
4822  {
4823  error (_("invalid symbol name \"%s\""), name);
4824  }
4825  s = strchr (s, ']');
4826  if (s == NULL)
4827  {
4828  error (_("invalid symbol name \"%s\""), name);
4829  }
4830  return strchr (s, ':');
4831  }
4832  else
4833  {
4834  return strchr (s, ':');
4835  }
4836 }
4837 
4838 /* Initializer for this module. */
4839 
4840 void
4842 {
4843  rs6000_builtin_type_data = register_objfile_data ();
4844 
4845  undef_types_allocated = 20;
4846  undef_types_length = 0;
4847  undef_types = (struct type **)
4848  xmalloc (undef_types_allocated * sizeof (struct type *));
4849 
4852  noname_undefs = (struct nat *)
4853  xmalloc (noname_undefs_allocated * sizeof (struct nat));
4854 
4856  &stab_register_funcs);
4858  &stab_register_funcs);
4859 }
void set_type_vptr_basetype(struct type *type, struct type *basetype)
Definition: gdbtypes.c:1715
const char * string
Definition: signals.c:50
int gdbarch_stab_reg_to_regnum(struct gdbarch *gdbarch, int stab_regnr)
Definition: gdbarch.c:2049
#define VISIBILITY_PRIVATE
Definition: stabsread.c:471
static struct type * read_type(char **, struct objfile *)
Definition: stabsread.c:1504
#define VISIBILITY_IGNORE
Definition: stabsread.c:474
type_code
Definition: gdbtypes.h:85
static int attach_fields_to_type(struct field_info *, struct type *, struct objfile *)
Definition: stabsread.c:3327
#define STABS_CONTINUE(pp, objfile)
Definition: stabsread.c:204
static void read_one_struct_field(struct field_info *, char **, char *, struct type *, struct objfile *)
Definition: stabsread.c:2857
void stabsread_new_init(void)
Definition: stabsread.c:4764
#define B_TYPE
Definition: gdbtypes.h:78
#define OBSTACK_CALLOC(OBSTACK, NUMBER, TYPE)
Definition: gdb_obstack.h:30
struct field field
Definition: dwarf2read.c:1305
static int read_baseclasses(struct field_info *, char **, struct type *, struct objfile *)
Definition: stabsread.c:3098
void common_block_end(struct objfile *objfile)
Definition: stabsread.c:4346
struct type * create_static_range_type(struct type *result_type, struct type *index_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:867
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
static int attach_fn_fields_to_type(struct field_info *, struct type *)
Definition: stabsread.c:3308
#define TYPE_FIELD_PRIVATE_BITS(thistype)
Definition: gdbtypes.h:1380
static void add_undefined_type_noname(struct type *type, int typenums[2])
Definition: stabsread.c:4424
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:409
bfd_vma CORE_ADDR
Definition: common-types.h:41
static void add_undefined_type_1(struct type *type)
Definition: stabsread.c:4446
struct fn_field * fn_fields
Definition: gdbtypes.h:831
void replace_type(struct type *ntype, struct type *type)
Definition: gdbtypes.c:739
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1369
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1327
static struct type * error_type(char **, struct objfile *)
Definition: stabsread.c:1471
void xfree(void *)
Definition: common-utils.c:97
int hashname(const char *name)
Definition: buildsym.c:1664
struct next_fnfieldlist * fnlist
Definition: stabsread.c:83
int strcmp_iw(const char *string1, const char *string2)
Definition: utils.c:2511
void _initialize_stabsread(void)
Definition: stabsread.c:4841
#define TYPE_NFN_FIELDS(thistype)
Definition: gdbtypes.h:1307
void add_symbol_to_list(struct symbol *symbol, struct pending **listhead)
Definition: buildsym.c:216
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1490
static void fix_common_block(struct symbol *, CORE_ADDR)
Definition: stabsread.c:4405
EXTERN unsigned char processing_gcc_compilation
Definition: buildsym.h:78
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
struct type * builtin_double
Definition: gdbtypes.h:1583
static char * common_block_name
Definition: stabsread.c:4324
void warning(const char *fmt,...)
Definition: errors.c:26
static void scan(struct macro_buffer *dest, struct macro_buffer *src, struct macro_name_list *no_loop, macro_lookup_ftype *lookup_func, void *lookup_baton)
Definition: macroexp.c:1367
struct type * create_array_type(struct type *result_type, struct type *element_type, struct type *range_type)
Definition: gdbtypes.c:1119
void set_type_vptr_fieldno(struct type *type, int fieldno)
Definition: gdbtypes.c:1689
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1227
#define TYPE_FIELD_ARTIFICIAL(thistype, n)
Definition: gdbtypes.h:1376
#define INIT_CPLUS_SPECIFIC(type)
Definition: gdbtypes.h:1195
static struct type * read_enum_type(char **, struct type *, struct objfile *)
Definition: stabsread.c:3637
#define TYPE_VOLATILE(t)
Definition: gdbtypes.h:350
static struct ref_map * ref_map
Definition: stabsread.c:490
struct symbol * sym
Definition: stabsread.c:483
void scan_file_globals(struct objfile *objfile)
Definition: stabsread.c:4616
#define TYPE_FIELD_VIRTUAL_BITS(thistype)
Definition: gdbtypes.h:1386
#define SYMBOL_SET_LINKAGE_NAME(symbol, linkage_name)
Definition: symtab.h:207
static struct type * dbx_alloc_type(int[2], struct objfile *)
Definition: stabsread.c:335
const struct objfile_type * objfile_type(struct objfile *objfile)
Definition: gdbtypes.c:4909
EXPORTED_CONST char vtbl_ptr_name[]
Definition: cp-valprint.c:91
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:793
struct type * make_function_type(struct type *type, struct type **typeptr)
Definition: gdbtypes.c:452
EXTERN struct pending * file_symbols
Definition: buildsym.h:109
void start_stabs(void)
Definition: stabsread.c:4774
#define TYPE_FIELD_PROTECTED_BITS(thistype)
Definition: gdbtypes.h:1382
static struct type * read_sun_floating_type(char **, int[2], struct objfile *)
Definition: stabsread.c:3835
void smash_to_method_type(struct type *type, struct type *self_type, struct type *to_type, struct field *args, int nargs, int varargs)
Definition: gdbtypes.c:1342
static char * find_name_end(char *name)
Definition: stabsread.c:4814
struct symbol * symbol[PENDINGSIZE]
Definition: buildsym.h:102
struct type * make_pointer_type(struct type *type, struct type **typeptr)
Definition: gdbtypes.c:306
static struct type ** dbx_lookup_type(int typenums[2], struct objfile *objfile)
Definition: stabsread.c:236
static int read_cpp_abbrev(struct field_info *, char **, struct type *, struct objfile *)
Definition: stabsread.c:2761
static int type_vector_length
Definition: stabsread.c:220
struct type * init_type(enum type_code code, int length, int flags, const char *name, struct objfile *objfile)
Definition: gdbtypes.c:2616
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
#define _(String)
Definition: gdb_locale.h:40
char * stabs
Definition: stabsread.c:481
#define TYPE_FIELD_IGNORE_BITS(thistype)
Definition: gdbtypes.h:1384
#define SET_FIELD_BITPOS(thisfld, bitpos)
Definition: gdbtypes.h:1349
struct type * builtin_long
Definition: gdbtypes.h:1574
#define TYPE_FIELD(thistype, n)
Definition: gdbtypes.h:1367
#define bits(obj, st, fn)
#define TYPE_PROTOTYPED(t)
Definition: gdbtypes.h:267
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
static struct pending * common_block
Definition: stabsread.c:4318
#define VISIBILITY_PROTECTED
Definition: stabsread.c:472
int gdbarch_stabs_argument_has_addr(struct gdbarch *gdbarch, struct type *type)
Definition: gdbarch.c:2942
char * method_name_from_physname(const char *physname)
Definition: cp-support.c:822
int gdbarch_believe_pcc_promotion(struct gdbarch *gdbarch)
Definition: gdbarch.c:2397
Definition: stabsread.c:194
static void set_length_in_type_chain(struct type *type)
Definition: stabsread.c:3471
EXTERN struct subfile * current_subfile
Definition: buildsym.h:73
struct obstack objfile_obstack
Definition: objfiles.h:328
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1916
void null_cleanup(void *arg)
Definition: cleanups.c:295
struct type * make_reference_type(struct type *type, struct type **typeptr)
Definition: gdbtypes.c:379
void common_block_start(char *name, struct objfile *objfile)
Definition: stabsread.c:4330
static int ref_count
Definition: stabsread.c:493
#define TYPE_VPTR_FIELDNO(thistype)
Definition: gdbtypes.h:1304
int is_cplus_marker(int c)
Definition: demangle.c:154
const char *const name
Definition: aarch64-tdep.c:68
void finish_global_stabs(struct objfile *objfile)
Definition: stabsread.c:4801
int * from
Definition: varobj.h:282
#define TYPE_INSTANCE_FLAGS(thistype)
Definition: gdbtypes.h:1225
EXTERN unsigned int symnum
Definition: buildsym.h:90
#define SYMBOL_ACLASS_INDEX(symbol)
Definition: symtab.h:792
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:182
int nsyms
Definition: buildsym.h:101
struct type * create_set_type(struct type *result_type, struct type *domain_type)
Definition: gdbtypes.c:1176
static struct type * read_sun_builtin_type(char **, int[2], struct objfile *)
Definition: stabsread.c:3763
static void reg_value_complaint(int regnum, int num_regs, const char *sym)
Definition: stabsread.c:169
#define SYMBOL_DOMAIN(symbol)
Definition: symtab.h:790
EXTERN struct pending * global_symbols
Definition: buildsym.h:113
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1981
struct pending * next
Definition: buildsym.h:100
int visibility
Definition: stabsread.c:63
static int read_type_number(char **, int *)
Definition: stabsread.c:446
#define LONG_MAX
Definition: defs.h:521
#define SYMBOL_SET_LANGUAGE(symbol, language, obstack)
Definition: symtab.h:196
static int undef_types_allocated
Definition: stabsread.c:185
static int undef_types_length
Definition: stabsread.c:186
static struct type * read_array_type(char **, struct type *, struct objfile *)
Definition: stabsread.c:3574
static struct type ** type_vector
Definition: stabsread.c:216
struct type * builtin_char
Definition: gdbtypes.h:1571
#define MAX_CHUNK_REFS
Definition: stabsread.c:486
char * obconcat(struct obstack *obstackp,...)
Definition: gdb_obstack.c:29
static void cleanup_undefined_types_1(void)
Definition: stabsread.c:4518
char * stab[1]
Definition: stabsread.h:52
#define ALLOCATE_CPLUS_STRUCT_TYPE(type)
Definition: gdbtypes.h:1200
void cleanup_undefined_stabs_types(struct objfile *objfile)
Definition: stabsread.c:4605
const char * name
Definition: gdbtypes.h:823
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
struct type ** vector
Definition: stabsread.h:97
void complaint(struct complaints **complaints, const char *fmt,...)
Definition: complaints.c:251
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
#define SET_TYPE_FIELD_IGNORE(thistype, n)
Definition: gdbtypes.h:1392
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
EXTERN struct pending * local_symbols
Definition: buildsym.h:117
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
#define B_BYTES(x)
Definition: gdbtypes.h:79
int typenums[2]
Definition: stabsread.c:196
Definition: gdbtypes.h:749
enum dtor_kinds is_destructor_name(const char *name)
Definition: cp-abi.c:44
#define TYPE_TARGET_STUB(t)
Definition: gdbtypes.h:253
struct type * type
Definition: gdbtypes.h:553
#define next_symbol_text(objfile)
Definition: buildsym.h:182
#define SET_TYPE_FIELD_PRIVATE(thistype, n)
Definition: gdbtypes.h:1388
struct symbol * define_symbol(CORE_ADDR valu, char *string, int desc, int type, struct objfile *objfile)
Definition: stabsread.c:625
static int process_reference(char **string)
Definition: stabsread.c:548
struct type * alloc_type(struct objfile *objfile)
Definition: gdbtypes.c:165
static const char * type
Definition: language.c:103
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static struct type * rs6000_builtin_type(int, struct objfile *)
Definition: stabsread.c:2057
#define SYMBOL_LINE(symbol)
Definition: symtab.h:800
EXTERN int previous_stab_code
Definition: stabsread.h:60
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
void stabsread_clear_cache(void)
Definition: stabsread.c:502
#define symfile_objfile
Definition: progspace.h:216
#define B_CLRALL(a, x)
Definition: gdbtypes.h:80
#define SET_FIELD_ENUMVAL(thisfld, enumval)
Definition: gdbtypes.h:1352
static int noname_undefs_length
Definition: stabsread.c:201
static void cleanup_undefined_types_noname(struct objfile *objfile)
Definition: stabsread.c:4483
#define REF_CHUNK_SIZE
Definition: stabsread.c:487
static char * stabs_method_name_from_physname(const char *physname)
Definition: stabsread.c:2235
#define TYPE_BASECLASS(thistype, index)
Definition: gdbtypes.h:1326
int regnum
Definition: aarch64-tdep.c:69
#define TYPE_FIELDS(thistype)
Definition: gdbtypes.h:1242
char * cp_canonicalize_string(const char *string)
Definition: cp-support.c:587
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
#define FIELD_BITSIZE(thisfld)
Definition: gdbtypes.h:1365
void * xmalloc(YYSIZE_T)
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1377
#define N_HEADER_FILES(OBJFILE)
Definition: stabsread.h:109
static void invalid_cpp_abbrev_complaint(const char *arg1)
Definition: stabsread.c:163
EXTERN int n_this_object_header_files
Definition: stabsread.h:127
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:233
#define SYMBOL_VALUE(symbol)
Definition: symtab.h:181
static int ref_chunk
Definition: stabsread.c:496
#define SYMBOL_VALUE_CHAIN(symbol)
Definition: symtab.h:186
Definition: value.c:172
struct type * builtin_int
Definition: gdbtypes.h:1573
unsigned long hash(const void *addr, int length)
Definition: bcache.c:98
void smash_to_memberptr_type(struct type *type, struct type *self_type, struct type *to_type)
Definition: gdbtypes.c:1305
EXTERN struct pending_stabs * global_stabs
Definition: stabsread.h:55
static int stab_regparm_index
Definition: stabsread.c:622
CORE_ADDR value
Definition: stabsread.c:482
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
static struct field * read_args(char **, int, struct objfile *, int *, int *)
Definition: stabsread.c:4265
#define REF_MAP_SIZE(ref_chunk)
Definition: stabsread.c:488
bfd_byte gdb_byte
Definition: common-types.h:38
void cp_scan_for_anonymous_namespaces(const struct symbol *const symbol, struct objfile *const objfile)
Definition: cp-namespace.c:51
#define TYPE_CHAIN(thistype)
Definition: gdbtypes.h:1232
#define SYMBOL_SET_NAMES(symbol, linkage_name, len, copy_name, objfile)
Definition: symtab.h:212
struct nextfield * next
Definition: dwarf2read.c:1302
unsigned length
Definition: gdbtypes.h:807
#define MSYMBOL_TYPE(msymbol)
Definition: symtab.h:382
struct type * make_cv_type(int cnst, int voltl, struct type *type, struct type **typeptr)
Definition: gdbtypes.c:651
#define SET_TYPE_FIELD_VIRTUAL(thistype, n)
Definition: gdbtypes.h:1394
struct next_fnfieldlist * next
Definition: stabsread.c:70
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
struct symbol * allocate_symbol(struct objfile *objfile)
Definition: symtab.c:6204
static struct type * read_struct_type(char **, struct type *, enum type_code, struct objfile *)
Definition: stabsread.c:3500
#define VISIBILITY_PUBLIC
Definition: stabsread.c:473
void set_type_self_type(struct type *type, struct type *self_type)
Definition: gdbtypes.c:1271
#define INITIAL_TYPE_VECTOR_LENGTH
Definition: stabsread.c:225
void ref_add(int refnum, struct symbol *sym, char *stabs, CORE_ADDR value)
Definition: stabsread.c:513
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
#define HEADER_FILES(OBJFILE)
Definition: stabsread.h:106
#define TYPE_BASECLASS_NAME(thistype, index)
Definition: gdbtypes.h:1328
int symbol_reference_defined(char **string)
Definition: stabsread.c:573
struct complaints * symfile_complaints
Definition: complaints.c:105
const char * gdbarch_static_transform_name(struct gdbarch *gdbarch, const char *name)
Definition: gdbarch.c:3830
const char * name
Definition: gdbtypes.h:559
static struct type * read_range_type(char **, int[2], int, struct objfile *)
Definition: stabsread.c:4047
int gdbarch_long_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1524
static const char vptr_name[]
Definition: stabsread.c:159
#define MSYMBOL_SECTION(symbol)
Definition: symtab.h:401
static void stabs_general_complaint(const char *arg1)
Definition: stabsread.c:177
EXTERN int * this_object_header_files
Definition: stabsread.h:125
static void add_undefined_type(struct type *, int[2])
Definition: stabsread.c:4472
int code
Definition: ser-unix.c:684
int register_symbol_register_impl(enum address_class aclass, const struct symbol_register_ops *ops)
Definition: symtab.c:6154
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
static struct type ** undef_types
Definition: stabsread.c:184
#define SYMBOL_LANGUAGE(symbol)
Definition: symtab.h:187
static struct nat * noname_undefs
Definition: stabsread.c:199
static void complain_about_struct_wipeout(struct type *type)
Definition: stabsread.c:3417
#define SET_TYPE_FIELD_PROTECTED(thistype, n)
Definition: gdbtypes.h:1390
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1228
#define TYPE_STUB(t)
Definition: gdbtypes.h:245
#define HASHSIZE
Definition: buildsym.h:46
static int stab_reg_to_regnum(struct symbol *sym, struct gdbarch *gdbarch)
Definition: stabsread.c:597
#define ALL_OBJFILE_MSYMBOLS(objfile, m)
Definition: objfiles.h:602
static const char vb_name[]
Definition: stabsread.c:160
char * savestring(const char *ptr, size_t len)
Definition: common-utils.c:148
double atof(const char *)
struct type * builtin_unsigned_int
Definition: gdbtypes.h:1579
#define NUMBER_RECOGNIZED
static int read_tilde_fields(struct field_info *, char **, struct type *, struct objfile *)
Definition: stabsread.c:3224
#define TYPE_ALLOC(t, size)
Definition: gdbtypes.h:1631
enum language language
Definition: buildsym.h:69
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
struct type * allocate_stub_method(struct type *type)
Definition: gdbtypes.c:808
Definition: symtab.h:703
struct symbol * find_symbol_in_list(struct pending *list, char *name, int length)
Definition: buildsym.c:250
static long read_huge_number(char **, int, int *, int)
Definition: stabsread.c:3883
#define VOFFSET_STATIC
Definition: gdbtypes.h:895
#define TYPE_FN_FIELDLISTS(thistype)
Definition: gdbtypes.h:1409
const char * type_name_no_tag(const struct type *type)
Definition: gdbtypes.c:1361
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
int int * to
Definition: varobj.h:282
void stabsread_init(void)
Definition: stabsread.c:4755
struct type * type
Definition: stabsread.c:197
static int common_block_i
Definition: stabsread.c:4319
static int noname_undefs_allocated
Definition: stabsread.c:200
#define SYMBOL_SECTION(symbol)
Definition: symtab.h:188
#define HOST_CHAR_BIT
Definition: host-defs.h:40
#define FIELD_BITPOS(thisfld)
Definition: gdbtypes.h:1343
static const struct objfile_data * rs6000_builtin_type_data
Definition: stabsread.c:2054
#define SYMBOL_VALUE_BYTES(symbol)
Definition: symtab.h:183
#define QUIT
Definition: defs.h:160
int gdbarch_static_transform_name_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3823
EXTERN int within_function
Definition: buildsym.h:174
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
static int read_struct_fields(struct field_info *, char **, struct type *, struct objfile *)
Definition: stabsread.c:3000
#define TYPE_CONST(t)
Definition: gdbtypes.h:345
static void patch_block_stabs(struct pending *, struct pending_stabs *, struct objfile *)
Definition: stabsread.c:361
static int stab_register_index
Definition: stabsread.c:621
#define TYPE_SELF_TYPE(thistype)
Definition: gdbtypes.h:1295
void make_vector_type(struct type *array_type)
Definition: gdbtypes.c:1206
void error(const char *fmt,...)
Definition: errors.c:38
struct symbol * ref_search(int refnum)
Definition: stabsread.c:537
void store_typed_floating(void *addr, const struct type *type, DOUBLEST val)
Definition: doublest.c:830
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:368
static int read_member_functions(struct field_info *, char **, struct type *, struct objfile *)
Definition: stabsread.c:2267
EXTERN struct symbol * global_sym_chain[HASHSIZE]
Definition: stabsread.h:41
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
#define MSYMBOL_VALUE_ADDRESS(objfile, symbol)
Definition: symtab.h:389
void end_stabs(void)
Definition: stabsread.c:4789
#define FIELD_TYPE(thisfld)
Definition: gdbtypes.h:1339
struct type * builtin_error
Definition: gdbtypes.h:1591
struct type * lookup_function_type(struct type *type)
Definition: gdbtypes.c:482
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:795
#define SET_FIELD_PHYSNAME(thisfld, name)
Definition: gdbtypes.h:1355
const ULONGEST const LONGEST len
Definition: target.h:309
struct fn_fieldlist fn_fieldlist
Definition: stabsread.c:71
struct nextfield * list
Definition: stabsread.c:82