1 /* wrstabs.c -- Output stabs debugging information
2 Copyright (C) 1996-2022 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>.
4
5 This file is part of GNU Binutils.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 /* This file contains code which writes out stabs debugging
23 information. */
24
25 #include "sysdep.h"
26 #include <assert.h>
27 #include "bfd.h"
28 #include "libiberty.h"
29 #include "filenames.h"
30 #include "safe-ctype.h"
31 #include "bucomm.h"
32 #include "debug.h"
33 #include "budbg.h"
34 #include "aout/aout64.h"
35 #include "aout/stab_gnu.h"
36
37 /* The size of a stabs symbol. This presumes 32 bit values. */
38
39 #define STAB_SYMBOL_SIZE (12)
40
41 /* An entry in a string hash table. */
42
43 struct string_hash_entry
44 {
45 struct bfd_hash_entry root;
46 /* Next string in this table. */
47 struct string_hash_entry *next;
48 /* Index in string table. */
49 long index;
50 /* Size of type if this is a typedef. */
51 unsigned int size;
52 };
53
54 /* A string hash table. */
55
56 struct string_hash_table
57 {
58 struct bfd_hash_table table;
59 };
60
61 /* The type stack. Each element on the stack is a string. */
62
63 struct stab_type_stack
64 {
65 /* The next element on the stack. */
66 struct stab_type_stack *next;
67 /* This element as a string. */
68 char *string;
69 /* The type index of this element. */
70 long index;
71 /* The size of the type. */
72 unsigned int size;
73 /* Whether type string defines a new type. */
74 bool definition;
75 /* String defining struct fields. */
76 char *fields;
77 /* NULL terminated array of strings defining base classes for a
78 class. */
79 char **baseclasses;
80 /* String defining class methods. */
81 char *methods;
82 /* String defining vtable pointer for a class. */
83 char *vtable;
84 };
85
86 /* This structure is used to keep track of type indices for tagged
87 types. */
88
89 struct stab_tag
90 {
91 /* The type index. */
92 long index;
93 /* The tag name. */
94 const char *tag;
95 /* The kind of type. This is set to DEBUG_KIND_ILLEGAL when the
96 type is defined. */
97 enum debug_type_kind kind;
98 /* The size of the struct. */
99 unsigned int size;
100 };
101
102 /* We remember various sorts of type indices. They are not related,
103 but, for convenience, we keep all the information in this
104 structure. */
105
106 struct stab_type_cache
107 {
108 /* The void type index. */
109 long void_type;
110 /* Signed integer type indices, indexed by size - 1. */
111 long signed_integer_types[8];
112 /* Unsigned integer type indices, indexed by size - 1. */
113 long unsigned_integer_types[8];
114 /* Floating point types, indexed by size - 1. */
115 long float_types[16];
116 /* Pointers to types, indexed by the type index. */
117 long *pointer_types;
118 size_t pointer_types_alloc;
119 /* Functions returning types, indexed by the type index. */
120 long *function_types;
121 size_t function_types_alloc;
122 /* References to types, indexed by the type index. */
123 long *reference_types;
124 size_t reference_types_alloc;
125 /* Struct/union/class type indices, indexed by the struct id. */
126 struct stab_tag *struct_types;
127 size_t struct_types_alloc;
128 };
129
130 /* This is the handle passed through debug_write. */
131
132 struct stab_write_handle
133 {
134 /* The BFD. */
135 bfd *abfd;
136 /* This buffer holds the symbols. */
137 bfd_byte *symbols;
138 size_t symbols_size;
139 size_t symbols_alloc;
140 /* This is a list of hash table entries for the strings. */
141 struct string_hash_entry *strings;
142 /* The last string hash table entry. */
143 struct string_hash_entry *last_string;
144 /* The size of the strings. */
145 size_t strings_size;
146 /* This hash table eliminates duplicate strings. */
147 struct string_hash_table strhash;
148 /* The type stack. */
149 struct stab_type_stack *type_stack;
150 /* The next type index. */
151 long type_index;
152 /* The type cache. */
153 struct stab_type_cache type_cache;
154 /* A mapping from typedef names to type indices. */
155 struct string_hash_table typedef_hash;
156 /* If this is not -1, it is the offset to the most recent N_SO
157 symbol, and the value of that symbol needs to be set. */
158 long so_offset;
159 /* If this is not -1, it is the offset to the most recent N_FUN
160 symbol, and the value of that symbol needs to be set. */
161 long fun_offset;
162 /* The last text section address seen. */
163 bfd_vma last_text_address;
164 /* The block nesting depth. */
165 unsigned int nesting;
166 /* The function address. */
167 bfd_vma fnaddr;
168 /* A pending LBRAC symbol. */
169 bfd_vma pending_lbrac;
170 /* The current line number file name. */
171 const char *lineno_filename;
172 };
173
174 static struct bfd_hash_entry *string_hash_newfunc
175 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
176 static bool stab_write_symbol
177 (struct stab_write_handle *, int, int, bfd_vma, const char *);
178 static bool stab_push_string
179 (struct stab_write_handle *, const char *, long, bool, unsigned int);
180 static bool stab_push_defined_type
181 (struct stab_write_handle *, long, unsigned int);
182 static char *stab_pop_type (struct stab_write_handle *);
183 static bool stab_modify_type
184 (struct stab_write_handle *, int, unsigned int, long **, size_t *);
185 static long stab_get_struct_index
186 (struct stab_write_handle *, const char *, unsigned int,
187 enum debug_type_kind, unsigned int *);
188 static bool stab_class_method_var
189 (struct stab_write_handle *, const char *, enum debug_visibility,
190 bool, bool, bool, bfd_vma, bool);
191 static bool stab_start_compilation_unit (void *, const char *);
192 static bool stab_start_source (void *, const char *);
193 static bool stab_empty_type (void *);
194 static bool stab_void_type (void *);
195 static bool stab_int_type (void *, unsigned int, bool);
196 static bool stab_float_type (void *, unsigned int);
197 static bool stab_complex_type (void *, unsigned int);
198 static bool stab_bool_type (void *, unsigned int);
199 static bool stab_enum_type
200 (void *, const char *, const char **, bfd_signed_vma *);
201 static bool stab_pointer_type (void *);
202 static bool stab_function_type (void *, int, bool);
203 static bool stab_reference_type (void *);
204 static bool stab_range_type (void *, bfd_signed_vma, bfd_signed_vma);
205 static bool stab_array_type
206 (void *, bfd_signed_vma, bfd_signed_vma, bool);
207 static bool stab_set_type (void *, bool);
208 static bool stab_offset_type (void *);
209 static bool stab_method_type (void *, bool, int, bool);
210 static bool stab_const_type (void *);
211 static bool stab_volatile_type (void *);
212 static bool stab_start_struct_type
213 (void *, const char *, unsigned int, bool, unsigned int);
214 static bool stab_struct_field
215 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
216 static bool stab_end_struct_type (void *);
217 static bool stab_start_class_type
218 (void *, const char *, unsigned int, bool, unsigned int,
219 bool, bool);
220 static bool stab_class_static_member
221 (void *, const char *, const char *, enum debug_visibility);
222 static bool stab_class_baseclass
223 (void *, bfd_vma, bool, enum debug_visibility);
224 static bool stab_class_start_method (void *, const char *);
225 static bool stab_class_method_variant
226 (void *, const char *, enum debug_visibility, bool, bool,
227 bfd_vma, bool);
228 static bool stab_class_static_method_variant
229 (void *, const char *, enum debug_visibility, bool, bool);
230 static bool stab_class_end_method (void *);
231 static bool stab_end_class_type (void *);
232 static bool stab_typedef_type (void *, const char *);
233 static bool stab_tag_type
234 (void *, const char *, unsigned int, enum debug_type_kind);
235 static bool stab_typdef (void *, const char *);
236 static bool stab_tag (void *, const char *);
237 static bool stab_int_constant (void *, const char *, bfd_vma);
238 static bool stab_float_constant (void *, const char *, double);
239 static bool stab_typed_constant (void *, const char *, bfd_vma);
240 static bool stab_variable
241 (void *, const char *, enum debug_var_kind, bfd_vma);
242 static bool stab_start_function (void *, const char *, bool);
243 static bool stab_function_parameter
244 (void *, const char *, enum debug_parm_kind, bfd_vma);
245 static bool stab_start_block (void *, bfd_vma);
246 static bool stab_end_block (void *, bfd_vma);
247 static bool stab_end_function (void *);
248 static bool stab_lineno (void *, const char *, unsigned long, bfd_vma);
249
250 static const struct debug_write_fns stab_fns =
251 {
252 stab_start_compilation_unit,
253 stab_start_source,
254 stab_empty_type,
255 stab_void_type,
256 stab_int_type,
257 stab_float_type,
258 stab_complex_type,
259 stab_bool_type,
260 stab_enum_type,
261 stab_pointer_type,
262 stab_function_type,
263 stab_reference_type,
264 stab_range_type,
265 stab_array_type,
266 stab_set_type,
267 stab_offset_type,
268 stab_method_type,
269 stab_const_type,
270 stab_volatile_type,
271 stab_start_struct_type,
272 stab_struct_field,
273 stab_end_struct_type,
274 stab_start_class_type,
275 stab_class_static_member,
276 stab_class_baseclass,
277 stab_class_start_method,
278 stab_class_method_variant,
279 stab_class_static_method_variant,
280 stab_class_end_method,
281 stab_end_class_type,
282 stab_typedef_type,
283 stab_tag_type,
284 stab_typdef,
285 stab_tag,
286 stab_int_constant,
287 stab_float_constant,
288 stab_typed_constant,
289 stab_variable,
290 stab_start_function,
291 stab_function_parameter,
292 stab_start_block,
293 stab_end_block,
294 stab_end_function,
295 stab_lineno
296 };
297
298 /* Routine to create an entry in a string hash table. */
299
300 static struct bfd_hash_entry *
string_hash_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)301 string_hash_newfunc (struct bfd_hash_entry *entry,
302 struct bfd_hash_table *table, const char *string)
303 {
304 struct string_hash_entry *ret = (struct string_hash_entry *) entry;
305
306 /* Allocate the structure if it has not already been allocated by a
307 subclass. */
308 if (ret == (struct string_hash_entry *) NULL)
309 ret = ((struct string_hash_entry *)
310 bfd_hash_allocate (table, sizeof (struct string_hash_entry)));
311 if (ret == (struct string_hash_entry *) NULL)
312 return NULL;
313
314 /* Call the allocation method of the superclass. */
315 ret = ((struct string_hash_entry *)
316 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
317
318 if (ret)
319 {
320 /* Initialize the local fields. */
321 ret->next = NULL;
322 ret->index = -1;
323 ret->size = 0;
324 }
325
326 return (struct bfd_hash_entry *) ret;
327 }
328
329 /* Look up an entry in a string hash table. */
330
331 #define string_hash_lookup(t, string, create, copy) \
332 ((struct string_hash_entry *) \
333 bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
334
335 /* Add a symbol to the stabs debugging information we are building. */
336
337 static bool
stab_write_symbol(struct stab_write_handle * info,int type,int desc,bfd_vma value,const char * string)338 stab_write_symbol (struct stab_write_handle *info, int type, int desc,
339 bfd_vma value, const char *string)
340 {
341 bfd_size_type strx;
342 bfd_byte sym[STAB_SYMBOL_SIZE];
343
344 if (string == NULL)
345 strx = 0;
346 else
347 {
348 struct string_hash_entry *h;
349
350 h = string_hash_lookup (&info->strhash, string, true, true);
351 if (h == NULL)
352 {
353 non_fatal (_("string_hash_lookup failed: %s"),
354 bfd_errmsg (bfd_get_error ()));
355 return false;
356 }
357 if (h->index != -1)
358 strx = h->index;
359 else
360 {
361 strx = info->strings_size;
362 h->index = strx;
363 if (info->last_string == NULL)
364 info->strings = h;
365 else
366 info->last_string->next = h;
367 info->last_string = h;
368 info->strings_size += strlen (string) + 1;
369 }
370 }
371
372 /* This presumes 32 bit values. */
373 bfd_put_32 (info->abfd, strx, sym);
374 bfd_put_8 (info->abfd, type, sym + 4);
375 bfd_put_8 (info->abfd, 0, sym + 5);
376 bfd_put_16 (info->abfd, desc, sym + 6);
377 bfd_put_32 (info->abfd, value, sym + 8);
378
379 if (info->symbols_size + STAB_SYMBOL_SIZE > info->symbols_alloc)
380 {
381 info->symbols_alloc *= 2;
382 info->symbols = (bfd_byte *) xrealloc (info->symbols,
383 info->symbols_alloc);
384 }
385
386 memcpy (info->symbols + info->symbols_size, sym, STAB_SYMBOL_SIZE);
387
388 info->symbols_size += STAB_SYMBOL_SIZE;
389
390 return true;
391 }
392
393 /* Push a string on to the type stack. */
394
395 static bool
stab_push_string(struct stab_write_handle * info,const char * string,long tindex,bool definition,unsigned int size)396 stab_push_string (struct stab_write_handle *info, const char *string,
397 long tindex, bool definition, unsigned int size)
398 {
399 struct stab_type_stack *s;
400
401 s = (struct stab_type_stack *) xmalloc (sizeof *s);
402 s->string = xstrdup (string);
403 s->index = tindex;
404 s->definition = definition;
405 s->size = size;
406
407 s->fields = NULL;
408 s->baseclasses = NULL;
409 s->methods = NULL;
410 s->vtable = NULL;
411
412 s->next = info->type_stack;
413 info->type_stack = s;
414
415 return true;
416 }
417
418 /* Push a type index which has already been defined. */
419
420 static bool
stab_push_defined_type(struct stab_write_handle * info,long tindex,unsigned int size)421 stab_push_defined_type (struct stab_write_handle *info, long tindex,
422 unsigned int size)
423 {
424 char buf[20];
425
426 sprintf (buf, "%ld", tindex);
427 return stab_push_string (info, buf, tindex, false, size);
428 }
429
430 /* Pop a type off the type stack. The caller is responsible for
431 freeing the string. */
432
433 static char *
stab_pop_type(struct stab_write_handle * info)434 stab_pop_type (struct stab_write_handle *info)
435 {
436 struct stab_type_stack *s;
437 char *ret;
438
439 s = info->type_stack;
440 if (s == NULL)
441 return NULL;
442
443 info->type_stack = s->next;
444
445 ret = s->string;
446
447 free (s);
448
449 return ret;
450 }
451
452 /* The general routine to write out stabs in sections debugging
453 information. This accumulates the stabs symbols and the strings in
454 two obstacks. We can't easily write out the information as we go
455 along, because we need to know the section sizes before we can
456 write out the section contents. ABFD is the BFD and DHANDLE is the
457 handle for the debugging information. This sets *PSYMS to point to
458 the symbols, *PSYMSIZE the size of the symbols, *PSTRINGS to the
459 strings, and *PSTRINGSIZE to the size of the strings. */
460
461 bool
write_stabs_in_sections_debugging_info(bfd * abfd,void * dhandle,bfd_byte ** psyms,bfd_size_type * psymsize,bfd_byte ** pstrings,bfd_size_type * pstringsize)462 write_stabs_in_sections_debugging_info (bfd *abfd, void *dhandle,
463 bfd_byte **psyms,
464 bfd_size_type *psymsize,
465 bfd_byte **pstrings,
466 bfd_size_type *pstringsize)
467 {
468 struct stab_write_handle info;
469 struct string_hash_entry *h;
470 bfd_byte *p;
471
472 info.abfd = abfd;
473
474 info.symbols_size = 0;
475 info.symbols_alloc = 500;
476 info.symbols = (bfd_byte *) xmalloc (info.symbols_alloc);
477
478 info.strings = NULL;
479 info.last_string = NULL;
480 /* Reserve 1 byte for a null byte. */
481 info.strings_size = 1;
482
483 if (!bfd_hash_table_init (&info.strhash.table, string_hash_newfunc,
484 sizeof (struct string_hash_entry))
485 || !bfd_hash_table_init (&info.typedef_hash.table, string_hash_newfunc,
486 sizeof (struct string_hash_entry)))
487 {
488 non_fatal ("bfd_hash_table_init_failed: %s",
489 bfd_errmsg (bfd_get_error ()));
490 return false;
491 }
492
493 info.type_stack = NULL;
494 info.type_index = 1;
495 memset (&info.type_cache, 0, sizeof info.type_cache);
496 info.so_offset = -1;
497 info.fun_offset = -1;
498 info.last_text_address = 0;
499 info.nesting = 0;
500 info.fnaddr = 0;
501 info.pending_lbrac = (bfd_vma) -1;
502
503 /* The initial symbol holds the string size. */
504 if (! stab_write_symbol (&info, 0, 0, 0, (const char *) NULL))
505 return false;
506
507 /* Output an initial N_SO symbol. */
508 info.so_offset = info.symbols_size;
509 if (! stab_write_symbol (&info, N_SO, 0, 0, bfd_get_filename (abfd)))
510 return false;
511
512 if (! debug_write (dhandle, &stab_fns, (void *) &info))
513 return false;
514
515 if (info.pending_lbrac != (bfd_vma) -1)
516 return false;
517
518 /* Output a trailing N_SO. */
519 if (! stab_write_symbol (&info, N_SO, 0, info.last_text_address,
520 (const char *) NULL))
521 return false;
522
523 /* Put the string size in the initial symbol. */
524 bfd_put_32 (abfd, info.strings_size, info.symbols + 8);
525
526 *psyms = info.symbols;
527 *psymsize = info.symbols_size;
528
529 *pstringsize = info.strings_size;
530 *pstrings = (bfd_byte *) xmalloc (info.strings_size);
531
532 p = *pstrings;
533 *p++ = '\0';
534 for (h = info.strings; h != NULL; h = h->next)
535 {
536 strcpy ((char *) p, h->root.string);
537 p += strlen ((char *) p) + 1;
538 }
539
540 return true;
541 }
542
543 /* Start writing out information for a compilation unit. */
544
545 static bool
stab_start_compilation_unit(void * p,const char * filename)546 stab_start_compilation_unit (void *p, const char *filename)
547 {
548 struct stab_write_handle *info = (struct stab_write_handle *) p;
549
550 /* We would normally output an N_SO symbol here. However, that
551 would force us to reset all of our type information. I think we
552 will be better off just outputting an N_SOL symbol, and not
553 worrying about splitting information between files. */
554
555 info->lineno_filename = filename;
556
557 return stab_write_symbol (info, N_SOL, 0, 0, filename);
558 }
559
560 /* Start writing out information for a particular source file. */
561
562 static bool
stab_start_source(void * p,const char * filename)563 stab_start_source (void *p, const char *filename)
564 {
565 struct stab_write_handle *info = (struct stab_write_handle *) p;
566
567 /* FIXME: The symbol's value is supposed to be the text section
568 address. However, we would have to fill it in later, and gdb
569 doesn't care, so we don't bother with it. */
570
571 info->lineno_filename = filename;
572
573 return stab_write_symbol (info, N_SOL, 0, 0, filename);
574 }
575
576 /* Push an empty type. This shouldn't normally happen. We just use a
577 void type. */
578
579 static bool
stab_empty_type(void * p)580 stab_empty_type (void *p)
581 {
582 struct stab_write_handle *info = (struct stab_write_handle *) p;
583
584 /* We don't call stab_void_type if the type is not yet defined,
585 because that might screw up the typedef. */
586
587 if (info->type_cache.void_type != 0)
588 return stab_push_defined_type (info, info->type_cache.void_type, 0);
589 else
590 {
591 long tindex;
592 char buf[40];
593
594 tindex = info->type_index;
595 ++info->type_index;
596
597 sprintf (buf, "%ld=%ld", tindex, tindex);
598
599 return stab_push_string (info, buf, tindex, false, 0);
600 }
601 }
602
603 /* Push a void type. */
604
605 static bool
stab_void_type(void * p)606 stab_void_type (void *p)
607 {
608 struct stab_write_handle *info = (struct stab_write_handle *) p;
609
610 if (info->type_cache.void_type != 0)
611 return stab_push_defined_type (info, info->type_cache.void_type, 0);
612 else
613 {
614 long tindex;
615 char buf[40];
616
617 tindex = info->type_index;
618 ++info->type_index;
619
620 info->type_cache.void_type = tindex;
621
622 sprintf (buf, "%ld=%ld", tindex, tindex);
623
624 return stab_push_string (info, buf, tindex, true, 0);
625 }
626 }
627
628 /* Push an integer type. */
629
630 static bool
stab_int_type(void * p,unsigned int size,bool unsignedp)631 stab_int_type (void *p, unsigned int size, bool unsignedp)
632 {
633 struct stab_write_handle *info = (struct stab_write_handle *) p;
634 long *cache;
635
636 if (size <= 0 || (size > sizeof (long) && size != 8))
637 {
638 non_fatal (_("stab_int_type: bad size %u"), size);
639 return false;
640 }
641
642 if (unsignedp)
643 cache = info->type_cache.signed_integer_types;
644 else
645 cache = info->type_cache.unsigned_integer_types;
646
647 if (cache[size - 1] != 0)
648 return stab_push_defined_type (info, cache[size - 1], size);
649 else
650 {
651 long tindex;
652 char buf[100];
653
654 tindex = info->type_index;
655 ++info->type_index;
656
657 cache[size - 1] = tindex;
658
659 sprintf (buf, "%ld=r%ld;", tindex, tindex);
660 if (unsignedp)
661 {
662 strcat (buf, "0;");
663 if (size < sizeof (long))
664 sprintf (buf + strlen (buf), "%ld;", ((long) 1 << (size * 8)) - 1);
665 else if (size == sizeof (long))
666 strcat (buf, "-1;");
667 else if (size == 8)
668 strcat (buf, "01777777777777777777777;");
669 else
670 abort ();
671 }
672 else
673 {
674 if (size <= sizeof (long))
675 sprintf (buf + strlen (buf), "%ld;%ld;",
676 (long) - ((unsigned long) 1 << (size * 8 - 1)),
677 (long) (((unsigned long) 1 << (size * 8 - 1)) - 1));
678 else if (size == 8)
679 strcat (buf, "01000000000000000000000;0777777777777777777777;");
680 else
681 abort ();
682 }
683
684 return stab_push_string (info, buf, tindex, true, size);
685 }
686 }
687
688 /* Push a floating point type. */
689
690 static bool
stab_float_type(void * p,unsigned int size)691 stab_float_type (void *p, unsigned int size)
692 {
693 struct stab_write_handle *info = (struct stab_write_handle *) p;
694
695 if (size > 0
696 && size - 1 < (sizeof info->type_cache.float_types
697 / sizeof info->type_cache.float_types[0])
698 && info->type_cache.float_types[size - 1] != 0)
699 return stab_push_defined_type (info,
700 info->type_cache.float_types[size - 1],
701 size);
702 else
703 {
704 long tindex;
705 char *int_type;
706 char buf[50];
707
708 /* Floats are defined as a subrange of int. */
709 if (! stab_int_type (info, 4, false))
710 return false;
711 int_type = stab_pop_type (info);
712
713 tindex = info->type_index;
714 ++info->type_index;
715
716 if (size > 0
717 && size - 1 < (sizeof info->type_cache.float_types
718 / sizeof info->type_cache.float_types[0]))
719 info->type_cache.float_types[size - 1] = tindex;
720
721 sprintf (buf, "%ld=r%s;%u;0;", tindex, int_type, size);
722
723 free (int_type);
724
725 return stab_push_string (info, buf, tindex, true, size);
726 }
727 }
728
729 /* Push a complex type. */
730
731 static bool
stab_complex_type(void * p,unsigned int size)732 stab_complex_type (void *p, unsigned int size)
733 {
734 struct stab_write_handle *info = (struct stab_write_handle *) p;
735 char buf[50];
736 long tindex;
737
738 tindex = info->type_index;
739 ++info->type_index;
740
741 sprintf (buf, "%ld=r%ld;%u;0;", tindex, tindex, size);
742
743 return stab_push_string (info, buf, tindex, true, size * 2);
744 }
745
746 /* Push a bool type. We use an XCOFF predefined type, since gdb
747 always recognizes them. */
748
749 static bool
stab_bool_type(void * p,unsigned int size)750 stab_bool_type (void *p, unsigned int size)
751 {
752 struct stab_write_handle *info = (struct stab_write_handle *) p;
753 long tindex;
754
755 switch (size)
756 {
757 case 1:
758 tindex = -21;
759 break;
760
761 case 2:
762 tindex = -22;
763 break;
764
765 default:
766 case 4:
767 tindex = -16;
768 break;
769
770 case 8:
771 tindex = -33;
772 break;
773 }
774
775 return stab_push_defined_type (info, tindex, size);
776 }
777
778 /* Push an enum type. */
779
780 static bool
stab_enum_type(void * p,const char * tag,const char ** names,bfd_signed_vma * vals)781 stab_enum_type (void *p, const char *tag, const char **names,
782 bfd_signed_vma *vals)
783 {
784 struct stab_write_handle *info = (struct stab_write_handle *) p;
785 size_t len;
786 const char **pn;
787 char *buf;
788 long tindex = 0;
789 bfd_signed_vma *pv;
790
791 if (names == NULL)
792 {
793 if (tag == NULL)
794 return false;
795
796 buf = (char *) xmalloc (10 + strlen (tag));
797 sprintf (buf, "xe%s:", tag);
798 /* FIXME: The size is just a guess. */
799 if (! stab_push_string (info, buf, 0, false, 4))
800 return false;
801 free (buf);
802 return true;
803 }
804
805 len = 10;
806 if (tag != NULL)
807 len += strlen (tag);
808 for (pn = names; *pn != NULL; pn++)
809 len += strlen (*pn) + 20;
810
811 buf = (char *) xmalloc (len);
812
813 if (tag == NULL)
814 strcpy (buf, "e");
815 else
816 {
817 tindex = info->type_index;
818 ++info->type_index;
819 sprintf (buf, "%s:T%ld=e", tag, tindex);
820 }
821
822 for (pn = names, pv = vals; *pn != NULL; pn++, pv++)
823 sprintf (buf + strlen (buf), "%s:%ld,", *pn, (long) *pv);
824 strcat (buf, ";");
825
826 if (tag == NULL)
827 {
828 /* FIXME: The size is just a guess. */
829 if (! stab_push_string (info, buf, 0, false, 4))
830 return false;
831 }
832 else
833 {
834 /* FIXME: The size is just a guess. */
835 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)
836 || ! stab_push_defined_type (info, tindex, 4))
837 return false;
838 }
839
840 free (buf);
841
842 return true;
843 }
844
845 /* Push a modification of the top type on the stack. Cache the
846 results in CACHE and CACHE_ALLOC. */
847
848 static bool
stab_modify_type(struct stab_write_handle * info,int mod,unsigned int size,long ** cache,size_t * cache_alloc)849 stab_modify_type (struct stab_write_handle *info, int mod,
850 unsigned int size, long **cache, size_t *cache_alloc)
851 {
852 long targindex;
853 long tindex;
854 char *s, *buf;
855
856 if (info->type_stack == NULL)
857 return false;
858 targindex = info->type_stack->index;
859
860 if (targindex <= 0
861 || cache == NULL)
862 {
863 bool definition;
864
865 /* Either the target type has no index, or we aren't caching
866 this modifier. Either way we have no way of recording the
867 new type, so we don't bother to define one. */
868 definition = info->type_stack->definition;
869 s = stab_pop_type (info);
870 buf = (char *) xmalloc (strlen (s) + 2);
871 sprintf (buf, "%c%s", mod, s);
872 free (s);
873 if (! stab_push_string (info, buf, 0, definition, size))
874 return false;
875 free (buf);
876 }
877 else
878 {
879 if ((size_t) targindex >= *cache_alloc)
880 {
881 size_t alloc;
882
883 alloc = *cache_alloc;
884 if (alloc == 0)
885 alloc = 10;
886 while ((size_t) targindex >= alloc)
887 alloc *= 2;
888 *cache = (long *) xrealloc (*cache, alloc * sizeof (long));
889 memset (*cache + *cache_alloc, 0,
890 (alloc - *cache_alloc) * sizeof (long));
891 *cache_alloc = alloc;
892 }
893
894 tindex = (*cache)[targindex];
895 if (tindex != 0 && ! info->type_stack->definition)
896 {
897 /* We have already defined a modification of this type, and
898 the entry on the type stack is not a definition, so we
899 can safely discard it (we may have a definition on the
900 stack, even if we already defined a modification, if it
901 is a struct which we did not define at the time it was
902 referenced). */
903 free (stab_pop_type (info));
904 if (! stab_push_defined_type (info, tindex, size))
905 return false;
906 }
907 else
908 {
909 tindex = info->type_index;
910 ++info->type_index;
911
912 s = stab_pop_type (info);
913 buf = (char *) xmalloc (strlen (s) + 20);
914 sprintf (buf, "%ld=%c%s", tindex, mod, s);
915 free (s);
916
917 (*cache)[targindex] = tindex;
918
919 if (! stab_push_string (info, buf, tindex, true, size))
920 return false;
921
922 free (buf);
923 }
924 }
925
926 return true;
927 }
928
929 /* Push a pointer type. */
930
931 static bool
stab_pointer_type(void * p)932 stab_pointer_type (void *p)
933 {
934 struct stab_write_handle *info = (struct stab_write_handle *) p;
935
936 /* FIXME: The size should depend upon the architecture. */
937 return stab_modify_type (info, '*', 4, &info->type_cache.pointer_types,
938 &info->type_cache.pointer_types_alloc);
939 }
940
941 /* Push a function type. */
942
943 static bool
stab_function_type(void * p,int argcount,bool varargs ATTRIBUTE_UNUSED)944 stab_function_type (void *p, int argcount,
945 bool varargs ATTRIBUTE_UNUSED)
946 {
947 struct stab_write_handle *info = (struct stab_write_handle *) p;
948 int i;
949
950 /* We have no way to represent the argument types, so we just
951 discard them. However, if they define new types, we must output
952 them. We do this by producing empty typedefs. */
953 for (i = 0; i < argcount; i++)
954 {
955 if (! info->type_stack->definition)
956 free (stab_pop_type (info));
957 else
958 {
959 char *s, *buf;
960
961 s = stab_pop_type (info);
962
963 buf = (char *) xmalloc (strlen (s) + 3);
964 sprintf (buf, ":t%s", s);
965 free (s);
966
967 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
968 return false;
969
970 free (buf);
971 }
972 }
973
974 return stab_modify_type (info, 'f', 0, &info->type_cache.function_types,
975 &info->type_cache.function_types_alloc);
976 }
977
978 /* Push a reference type. */
979
980 static bool
stab_reference_type(void * p)981 stab_reference_type (void *p)
982 {
983 struct stab_write_handle *info = (struct stab_write_handle *) p;
984
985 /* FIXME: The size should depend upon the architecture. */
986 return stab_modify_type (info, '&', 4, &info->type_cache.reference_types,
987 &info->type_cache.reference_types_alloc);
988 }
989
990 /* Push a range type. */
991
992 static bool
stab_range_type(void * p,bfd_signed_vma low,bfd_signed_vma high)993 stab_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high)
994 {
995 struct stab_write_handle *info = (struct stab_write_handle *) p;
996 bool definition;
997 unsigned int size;
998 char *s, *buf;
999
1000 definition = info->type_stack->definition;
1001 size = info->type_stack->size;
1002
1003 s = stab_pop_type (info);
1004 buf = (char *) xmalloc (strlen (s) + 100);
1005 sprintf (buf, "r%s;%ld;%ld;", s, (long) low, (long) high);
1006 free (s);
1007
1008 if (! stab_push_string (info, buf, 0, definition, size))
1009 return false;
1010
1011 free (buf);
1012
1013 return true;
1014 }
1015
1016 /* Push an array type. */
1017
1018 static bool
stab_array_type(void * p,bfd_signed_vma low,bfd_signed_vma high,bool stringp)1019 stab_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high,
1020 bool stringp)
1021 {
1022 struct stab_write_handle *info = (struct stab_write_handle *) p;
1023 bool definition;
1024 unsigned int element_size;
1025 char *range, *element, *buf;
1026 long tindex;
1027 unsigned int size;
1028
1029 definition = info->type_stack->definition;
1030 range = stab_pop_type (info);
1031
1032 definition = definition || info->type_stack->definition;
1033 element_size = info->type_stack->size;
1034 element = stab_pop_type (info);
1035
1036 buf = (char *) xmalloc (strlen (range) + strlen (element) + 100);
1037
1038 if (! stringp)
1039 {
1040 tindex = 0;
1041 *buf = '\0';
1042 }
1043 else
1044 {
1045 /* We need to define a type in order to include the string
1046 attribute. */
1047 tindex = info->type_index;
1048 ++info->type_index;
1049 definition = true;
1050 sprintf (buf, "%ld=@S;", tindex);
1051 }
1052
1053 sprintf (buf + strlen (buf), "ar%s;%ld;%ld;%s",
1054 range, (long) low, (long) high, element);
1055 free (range);
1056 free (element);
1057
1058 if (high < low)
1059 size = 0;
1060 else
1061 size = element_size * ((high - low) + 1);
1062 if (! stab_push_string (info, buf, tindex, definition, size))
1063 return false;
1064
1065 free (buf);
1066
1067 return true;
1068 }
1069
1070 /* Push a set type. */
1071
1072 static bool
stab_set_type(void * p,bool bitstringp)1073 stab_set_type (void *p, bool bitstringp)
1074 {
1075 struct stab_write_handle *info = (struct stab_write_handle *) p;
1076 bool definition;
1077 char *s, *buf;
1078 long tindex;
1079
1080 definition = info->type_stack->definition;
1081
1082 s = stab_pop_type (info);
1083 buf = (char *) xmalloc (strlen (s) + 30);
1084
1085 if (! bitstringp)
1086 {
1087 *buf = '\0';
1088 tindex = 0;
1089 }
1090 else
1091 {
1092 /* We need to define a type in order to include the string
1093 attribute. */
1094 tindex = info->type_index;
1095 ++info->type_index;
1096 definition = true;
1097 sprintf (buf, "%ld=@S;", tindex);
1098 }
1099
1100 sprintf (buf + strlen (buf), "S%s", s);
1101 free (s);
1102
1103 if (! stab_push_string (info, buf, tindex, definition, 0))
1104 return false;
1105
1106 free (buf);
1107
1108 return true;
1109 }
1110
1111 /* Push an offset type. */
1112
1113 static bool
stab_offset_type(void * p)1114 stab_offset_type (void *p)
1115 {
1116 struct stab_write_handle *info = (struct stab_write_handle *) p;
1117 bool definition;
1118 char *target, *base, *buf;
1119
1120 definition = info->type_stack->definition;
1121 target = stab_pop_type (info);
1122
1123 definition = definition || info->type_stack->definition;
1124 base = stab_pop_type (info);
1125
1126 buf = (char *) xmalloc (strlen (target) + strlen (base) + 3);
1127 sprintf (buf, "@%s,%s", base, target);
1128 free (base);
1129 free (target);
1130
1131 if (! stab_push_string (info, buf, 0, definition, 0))
1132 return false;
1133
1134 free (buf);
1135
1136 return true;
1137 }
1138
1139 /* Push a method type. */
1140
1141 static bool
stab_method_type(void * p,bool domainp,int argcount,bool varargs)1142 stab_method_type (void *p, bool domainp, int argcount,
1143 bool varargs)
1144 {
1145 struct stab_write_handle *info = (struct stab_write_handle *) p;
1146 bool definition;
1147 char *domain, *return_type, *buf;
1148 char **args;
1149 int i;
1150 size_t len;
1151
1152 /* We don't bother with stub method types, because that would
1153 require a mangler for C++ argument types. This will waste space
1154 in the debugging output. */
1155
1156 /* We need a domain. I'm not sure DOMAINP can ever be false,
1157 anyhow. */
1158 if (! domainp)
1159 {
1160 if (! stab_empty_type (p))
1161 return false;
1162 }
1163
1164 definition = info->type_stack->definition;
1165 domain = stab_pop_type (info);
1166
1167 /* A non-varargs function is indicated by making the last parameter
1168 type be void. */
1169
1170 if (argcount < 0)
1171 {
1172 args = NULL;
1173 argcount = 0;
1174 }
1175 else if (argcount == 0)
1176 {
1177 if (varargs)
1178 args = NULL;
1179 else
1180 {
1181 args = (char **) xmalloc (1 * sizeof (*args));
1182 if (! stab_empty_type (p))
1183 return false;
1184 definition = definition || info->type_stack->definition;
1185 args[0] = stab_pop_type (info);
1186 argcount = 1;
1187 }
1188 }
1189 else
1190 {
1191 args = (char **) xmalloc ((argcount + 1) * sizeof (*args));
1192 for (i = argcount - 1; i >= 0; i--)
1193 {
1194 definition = definition || info->type_stack->definition;
1195 args[i] = stab_pop_type (info);
1196 }
1197 if (! varargs)
1198 {
1199 if (! stab_empty_type (p))
1200 return false;
1201 definition = definition || info->type_stack->definition;
1202 args[argcount] = stab_pop_type (info);
1203 ++argcount;
1204 }
1205 }
1206
1207 definition = definition || info->type_stack->definition;
1208 return_type = stab_pop_type (info);
1209
1210 len = strlen (domain) + strlen (return_type) + 10;
1211 for (i = 0; i < argcount; i++)
1212 len += strlen (args[i]);
1213
1214 buf = (char *) xmalloc (len);
1215
1216 sprintf (buf, "#%s,%s", domain, return_type);
1217 free (domain);
1218 free (return_type);
1219 for (i = 0; i < argcount; i++)
1220 {
1221 strcat (buf, ",");
1222 strcat (buf, args[i]);
1223 free (args[i]);
1224 }
1225 strcat (buf, ";");
1226
1227 free (args);
1228
1229 if (! stab_push_string (info, buf, 0, definition, 0))
1230 return false;
1231
1232 free (buf);
1233
1234 return true;
1235 }
1236
1237 /* Push a const version of a type. */
1238
1239 static bool
stab_const_type(void * p)1240 stab_const_type (void *p)
1241 {
1242 struct stab_write_handle *info = (struct stab_write_handle *) p;
1243
1244 return stab_modify_type (info, 'k', info->type_stack->size,
1245 (long **) NULL, (size_t *) NULL);
1246 }
1247
1248 /* Push a volatile version of a type. */
1249
1250 static bool
stab_volatile_type(void * p)1251 stab_volatile_type (void *p)
1252 {
1253 struct stab_write_handle *info = (struct stab_write_handle *) p;
1254
1255 return stab_modify_type (info, 'B', info->type_stack->size,
1256 (long **) NULL, (size_t *) NULL);
1257 }
1258
1259 /* Get the type index to use for a struct/union/class ID. This should
1260 return -1 if it fails. */
1261
1262 static long
stab_get_struct_index(struct stab_write_handle * info,const char * tag,unsigned int id,enum debug_type_kind kind,unsigned int * psize)1263 stab_get_struct_index (struct stab_write_handle *info, const char *tag,
1264 unsigned int id, enum debug_type_kind kind,
1265 unsigned int *psize)
1266 {
1267 if (id >= info->type_cache.struct_types_alloc)
1268 {
1269 size_t alloc;
1270
1271 alloc = info->type_cache.struct_types_alloc;
1272 if (alloc == 0)
1273 alloc = 10;
1274 while (id >= alloc)
1275 alloc *= 2;
1276 info->type_cache.struct_types =
1277 (struct stab_tag *) xrealloc (info->type_cache.struct_types,
1278 alloc * sizeof (struct stab_tag));
1279 memset ((info->type_cache.struct_types
1280 + info->type_cache.struct_types_alloc),
1281 0,
1282 ((alloc - info->type_cache.struct_types_alloc)
1283 * sizeof (struct stab_tag)));
1284 info->type_cache.struct_types_alloc = alloc;
1285 }
1286
1287 if (info->type_cache.struct_types[id].index == 0)
1288 {
1289 info->type_cache.struct_types[id].index = info->type_index;
1290 ++info->type_index;
1291 info->type_cache.struct_types[id].tag = tag;
1292 info->type_cache.struct_types[id].kind = kind;
1293 }
1294
1295 if (kind == DEBUG_KIND_ILLEGAL)
1296 {
1297 /* This is a definition of the struct. */
1298 info->type_cache.struct_types[id].kind = kind;
1299 info->type_cache.struct_types[id].size = *psize;
1300 }
1301 else
1302 *psize = info->type_cache.struct_types[id].size;
1303
1304 return info->type_cache.struct_types[id].index;
1305 }
1306
1307 /* Start outputting a struct. We ignore the tag, and handle it in
1308 stab_tag. */
1309
1310 static bool
stab_start_struct_type(void * p,const char * tag,unsigned int id,bool structp,unsigned int size)1311 stab_start_struct_type (void *p, const char *tag, unsigned int id,
1312 bool structp, unsigned int size)
1313 {
1314 struct stab_write_handle *info = (struct stab_write_handle *) p;
1315 long tindex;
1316 bool definition;
1317 char buf[40];
1318
1319 if (id == 0)
1320 {
1321 tindex = 0;
1322 *buf = '\0';
1323 definition = false;
1324 }
1325 else
1326 {
1327 tindex = stab_get_struct_index (info, tag, id, DEBUG_KIND_ILLEGAL,
1328 &size);
1329 if (tindex < 0)
1330 return false;
1331 sprintf (buf, "%ld=", tindex);
1332 definition = true;
1333 }
1334
1335 sprintf (buf + strlen (buf), "%c%u",
1336 structp ? 's' : 'u',
1337 size);
1338
1339 if (! stab_push_string (info, buf, tindex, definition, size))
1340 return false;
1341
1342 info->type_stack->fields = (char *) xmalloc (1);
1343 info->type_stack->fields[0] = '\0';
1344
1345 return true;
1346 }
1347
1348 /* Add a field to a struct. */
1349
1350 static bool
stab_struct_field(void * p,const char * name,bfd_vma bitpos,bfd_vma bitsize,enum debug_visibility visibility)1351 stab_struct_field (void *p, const char *name, bfd_vma bitpos,
1352 bfd_vma bitsize, enum debug_visibility visibility)
1353 {
1354 struct stab_write_handle *info = (struct stab_write_handle *) p;
1355 bool definition;
1356 unsigned int size;
1357 char *s, *n;
1358 const char *vis;
1359
1360 definition = info->type_stack->definition;
1361 size = info->type_stack->size;
1362 s = stab_pop_type (info);
1363
1364 /* Add this field to the end of the current struct fields, which is
1365 currently on the top of the stack. */
1366 if (info->type_stack->fields == NULL)
1367 return false;
1368
1369 n = (char *) xmalloc (strlen (info->type_stack->fields)
1370 + strlen (name)
1371 + strlen (s)
1372 + 50);
1373
1374 switch (visibility)
1375 {
1376 default:
1377 abort ();
1378
1379 case DEBUG_VISIBILITY_PUBLIC:
1380 vis = "";
1381 break;
1382
1383 case DEBUG_VISIBILITY_PRIVATE:
1384 vis = "/0";
1385 break;
1386
1387 case DEBUG_VISIBILITY_PROTECTED:
1388 vis = "/1";
1389 break;
1390 }
1391
1392 if (bitsize == 0)
1393 {
1394 bitsize = size * 8;
1395 if (bitsize == 0)
1396 non_fatal (_("%s: warning: unknown size for field `%s' in struct"),
1397 bfd_get_filename (info->abfd), name);
1398 }
1399
1400 sprintf (n, "%s%s:%s%s,%ld,%ld;", info->type_stack->fields, name, vis, s,
1401 (long) bitpos, (long) bitsize);
1402
1403 free (info->type_stack->fields);
1404 info->type_stack->fields = n;
1405
1406 if (definition)
1407 info->type_stack->definition = true;
1408
1409 return true;
1410 }
1411
1412 /* Finish up a struct. */
1413
1414 static bool
stab_end_struct_type(void * p)1415 stab_end_struct_type (void *p)
1416 {
1417 struct stab_write_handle *info = (struct stab_write_handle *) p;
1418 bool definition;
1419 long tindex;
1420 unsigned int size;
1421 char *fields, *first, *buf;
1422
1423 if (info->type_stack == NULL || info->type_stack->fields == NULL)
1424 return false;
1425
1426 definition = info->type_stack->definition;
1427 tindex = info->type_stack->index;
1428 size = info->type_stack->size;
1429 fields = info->type_stack->fields;
1430 first = stab_pop_type (info);
1431
1432 buf = (char *) xmalloc (strlen (first) + strlen (fields) + 2);
1433 sprintf (buf, "%s%s;", first, fields);
1434 free (first);
1435 free (fields);
1436
1437 if (! stab_push_string (info, buf, tindex, definition, size))
1438 return false;
1439
1440 free (buf);
1441
1442 return true;
1443 }
1444
1445 /* Start outputting a class. */
1446
1447 static bool
stab_start_class_type(void * p,const char * tag,unsigned int id,bool structp,unsigned int size,bool vptr,bool ownvptr)1448 stab_start_class_type (void *p, const char *tag, unsigned int id,
1449 bool structp, unsigned int size,
1450 bool vptr, bool ownvptr)
1451 {
1452 struct stab_write_handle *info = (struct stab_write_handle *) p;
1453 bool definition = false;
1454 char *vstring = NULL;
1455
1456 if (vptr && !ownvptr)
1457 {
1458 definition = info->type_stack->definition;
1459 vstring = stab_pop_type (info);
1460 }
1461
1462 if (! stab_start_struct_type (p, tag, id, structp, size))
1463 return false;
1464
1465 if (vptr)
1466 {
1467 char *vtable;
1468
1469 if (ownvptr)
1470 {
1471 if (info->type_stack->index < 1)
1472 return false;
1473 vtable = (char *) xmalloc (20);
1474 sprintf (vtable, "~%%%ld", info->type_stack->index);
1475 }
1476 else
1477 {
1478 if (vstring == NULL)
1479 return false;
1480 vtable = (char *) xmalloc (strlen (vstring) + 3);
1481 sprintf (vtable, "~%%%s", vstring);
1482 free (vstring);
1483 if (definition)
1484 info->type_stack->definition = true;
1485 }
1486 info->type_stack->vtable = vtable;
1487 }
1488
1489 return true;
1490 }
1491
1492 /* Add a static member to the class on the type stack. */
1493
1494 static bool
stab_class_static_member(void * p,const char * name,const char * physname,enum debug_visibility visibility)1495 stab_class_static_member (void *p, const char *name, const char *physname,
1496 enum debug_visibility visibility)
1497 {
1498 struct stab_write_handle *info = (struct stab_write_handle *) p;
1499 bool definition;
1500 char *s, *n;
1501 const char *vis;
1502
1503 definition = info->type_stack->definition;
1504 s = stab_pop_type (info);
1505
1506 /* Add this field to the end of the current struct fields, which is
1507 currently on the top of the stack. */
1508
1509 if (info->type_stack->fields == NULL)
1510 return false;
1511 n = (char *) xmalloc (strlen (info->type_stack->fields)
1512 + strlen (name)
1513 + strlen (s)
1514 + strlen (physname)
1515 + 10);
1516
1517 switch (visibility)
1518 {
1519 default:
1520 abort ();
1521
1522 case DEBUG_VISIBILITY_PUBLIC:
1523 vis = "";
1524 break;
1525
1526 case DEBUG_VISIBILITY_PRIVATE:
1527 vis = "/0";
1528 break;
1529
1530 case DEBUG_VISIBILITY_PROTECTED:
1531 vis = "/1";
1532 break;
1533 }
1534
1535 sprintf (n, "%s%s:%s%s:%s;", info->type_stack->fields, name, vis, s,
1536 physname);
1537
1538 free (info->type_stack->fields);
1539 info->type_stack->fields = n;
1540
1541 if (definition)
1542 info->type_stack->definition = true;
1543
1544 return true;
1545 }
1546
1547 /* Add a base class to the class on the type stack. */
1548
1549 static bool
stab_class_baseclass(void * p,bfd_vma bitpos,bool is_virtual,enum debug_visibility visibility)1550 stab_class_baseclass (void *p, bfd_vma bitpos, bool is_virtual,
1551 enum debug_visibility visibility)
1552 {
1553 struct stab_write_handle *info = (struct stab_write_handle *) p;
1554 bool definition;
1555 char *s;
1556 char *buf;
1557 unsigned int c;
1558 char **baseclasses;
1559
1560 definition = info->type_stack->definition;
1561 s = stab_pop_type (info);
1562
1563 /* Build the base class specifier. */
1564
1565 buf = (char *) xmalloc (strlen (s) + 25);
1566 buf[0] = is_virtual ? '1' : '0';
1567 switch (visibility)
1568 {
1569 default:
1570 abort ();
1571
1572 case DEBUG_VISIBILITY_PRIVATE:
1573 buf[1] = '0';
1574 break;
1575
1576 case DEBUG_VISIBILITY_PROTECTED:
1577 buf[1] = '1';
1578 break;
1579
1580 case DEBUG_VISIBILITY_PUBLIC:
1581 buf[1] = '2';
1582 break;
1583 }
1584
1585 sprintf (buf + 2, "%ld,%s;", (long) bitpos, s);
1586 free (s);
1587
1588 /* Add the new baseclass to the existing ones. */
1589
1590 if (info->type_stack == NULL || info->type_stack->fields == NULL)
1591 return false;
1592
1593 if (info->type_stack->baseclasses == NULL)
1594 c = 0;
1595 else
1596 {
1597 c = 0;
1598 while (info->type_stack->baseclasses[c] != NULL)
1599 ++c;
1600 }
1601
1602 baseclasses = (char **) xrealloc (info->type_stack->baseclasses,
1603 (c + 2) * sizeof (*baseclasses));
1604 baseclasses[c] = buf;
1605 baseclasses[c + 1] = NULL;
1606
1607 info->type_stack->baseclasses = baseclasses;
1608
1609 if (definition)
1610 info->type_stack->definition = true;
1611
1612 return true;
1613 }
1614
1615 /* Start adding a method to the class on the type stack. */
1616
1617 static bool
stab_class_start_method(void * p,const char * name)1618 stab_class_start_method (void *p, const char *name)
1619 {
1620 struct stab_write_handle *info = (struct stab_write_handle *) p;
1621 char *m;
1622
1623 if (info->type_stack == NULL || info->type_stack->fields == NULL)
1624 return false;
1625
1626 if (info->type_stack->methods == NULL)
1627 {
1628 m = (char *) xmalloc (strlen (name) + 3);
1629 *m = '\0';
1630 }
1631 else
1632 {
1633 m = (char *) xrealloc (info->type_stack->methods,
1634 (strlen (info->type_stack->methods)
1635 + strlen (name)
1636 + 4));
1637 }
1638
1639 sprintf (m + strlen (m), "%s::", name);
1640
1641 info->type_stack->methods = m;
1642
1643 return true;
1644 }
1645
1646 /* Add a variant, either static or not, to the current method. */
1647
1648 static bool
stab_class_method_var(struct stab_write_handle * info,const char * physname,enum debug_visibility visibility,bool staticp,bool constp,bool volatilep,bfd_vma voffset,bool contextp)1649 stab_class_method_var (struct stab_write_handle *info, const char *physname,
1650 enum debug_visibility visibility,
1651 bool staticp, bool constp,
1652 bool volatilep, bfd_vma voffset,
1653 bool contextp)
1654 {
1655 bool definition;
1656 char *type;
1657 char *context = NULL;
1658 char visc, qualc, typec;
1659
1660 definition = info->type_stack->definition;
1661 type = stab_pop_type (info);
1662
1663 if (contextp)
1664 {
1665 definition = definition || info->type_stack->definition;
1666 context = stab_pop_type (info);
1667 }
1668
1669 if (info->type_stack == NULL || info->type_stack->methods == NULL)
1670 return false;
1671
1672 switch (visibility)
1673 {
1674 default:
1675 abort ();
1676
1677 case DEBUG_VISIBILITY_PRIVATE:
1678 visc = '0';
1679 break;
1680
1681 case DEBUG_VISIBILITY_PROTECTED:
1682 visc = '1';
1683 break;
1684
1685 case DEBUG_VISIBILITY_PUBLIC:
1686 visc = '2';
1687 break;
1688 }
1689
1690 if (constp)
1691 {
1692 if (volatilep)
1693 qualc = 'D';
1694 else
1695 qualc = 'B';
1696 }
1697 else
1698 {
1699 if (volatilep)
1700 qualc = 'C';
1701 else
1702 qualc = 'A';
1703 }
1704
1705 if (staticp)
1706 typec = '?';
1707 else if (! contextp)
1708 typec = '.';
1709 else
1710 typec = '*';
1711
1712 info->type_stack->methods =
1713 (char *) xrealloc (info->type_stack->methods,
1714 (strlen (info->type_stack->methods)
1715 + strlen (type)
1716 + strlen (physname)
1717 + (contextp ? strlen (context) : 0)
1718 + 40));
1719
1720 sprintf (info->type_stack->methods + strlen (info->type_stack->methods),
1721 "%s:%s;%c%c%c", type, physname, visc, qualc, typec);
1722 free (type);
1723
1724 if (contextp)
1725 {
1726 sprintf (info->type_stack->methods + strlen (info->type_stack->methods),
1727 "%ld;%s;", (long) voffset, context);
1728 free (context);
1729 }
1730
1731 if (definition)
1732 info->type_stack->definition = true;
1733
1734 return true;
1735 }
1736
1737 /* Add a variant to the current method. */
1738
1739 static bool
stab_class_method_variant(void * p,const char * physname,enum debug_visibility visibility,bool constp,bool volatilep,bfd_vma voffset,bool contextp)1740 stab_class_method_variant (void *p, const char *physname,
1741 enum debug_visibility visibility,
1742 bool constp, bool volatilep,
1743 bfd_vma voffset, bool contextp)
1744 {
1745 struct stab_write_handle *info = (struct stab_write_handle *) p;
1746
1747 return stab_class_method_var (info, physname, visibility, false, constp,
1748 volatilep, voffset, contextp);
1749 }
1750
1751 /* Add a static variant to the current method. */
1752
1753 static bool
stab_class_static_method_variant(void * p,const char * physname,enum debug_visibility visibility,bool constp,bool volatilep)1754 stab_class_static_method_variant (void *p, const char *physname,
1755 enum debug_visibility visibility,
1756 bool constp, bool volatilep)
1757 {
1758 struct stab_write_handle *info = (struct stab_write_handle *) p;
1759
1760 return stab_class_method_var (info, physname, visibility, true, constp,
1761 volatilep, 0, false);
1762 }
1763
1764 /* Finish up a method. */
1765
1766 static bool
stab_class_end_method(void * p)1767 stab_class_end_method (void *p)
1768 {
1769 struct stab_write_handle *info = (struct stab_write_handle *) p;
1770
1771 if (info->type_stack == NULL || info->type_stack->methods == NULL)
1772 return false;
1773
1774 /* We allocated enough room on info->type_stack->methods to add the
1775 trailing semicolon. */
1776 strcat (info->type_stack->methods, ";");
1777
1778 return true;
1779 }
1780
1781 /* Finish up a class. */
1782
1783 static bool
stab_end_class_type(void * p)1784 stab_end_class_type (void *p)
1785 {
1786 struct stab_write_handle *info = (struct stab_write_handle *) p;
1787 size_t len;
1788 unsigned int i = 0;
1789 char *buf;
1790
1791 if (info->type_stack == NULL
1792 || info->type_stack->string == NULL
1793 || info->type_stack->fields == NULL)
1794 return false;
1795
1796 /* Work out the size we need to allocate for the class definition. */
1797
1798 len = (strlen (info->type_stack->string)
1799 + strlen (info->type_stack->fields)
1800 + 10);
1801 if (info->type_stack->baseclasses != NULL)
1802 {
1803 len += 20;
1804 for (i = 0; info->type_stack->baseclasses[i] != NULL; i++)
1805 len += strlen (info->type_stack->baseclasses[i]);
1806 }
1807 if (info->type_stack->methods != NULL)
1808 len += strlen (info->type_stack->methods);
1809 if (info->type_stack->vtable != NULL)
1810 len += strlen (info->type_stack->vtable);
1811
1812 /* Build the class definition. */
1813
1814 buf = (char *) xmalloc (len);
1815
1816 strcpy (buf, info->type_stack->string);
1817
1818 if (info->type_stack->baseclasses != NULL)
1819 {
1820 sprintf (buf + strlen (buf), "!%u,", i);
1821 for (i = 0; info->type_stack->baseclasses[i] != NULL; i++)
1822 {
1823 strcat (buf, info->type_stack->baseclasses[i]);
1824 free (info->type_stack->baseclasses[i]);
1825 }
1826 free (info->type_stack->baseclasses);
1827 info->type_stack->baseclasses = NULL;
1828 }
1829
1830 strcat (buf, info->type_stack->fields);
1831 free (info->type_stack->fields);
1832 info->type_stack->fields = NULL;
1833
1834 if (info->type_stack->methods != NULL)
1835 {
1836 strcat (buf, info->type_stack->methods);
1837 free (info->type_stack->methods);
1838 info->type_stack->methods = NULL;
1839 }
1840
1841 strcat (buf, ";");
1842
1843 if (info->type_stack->vtable != NULL)
1844 {
1845 strcat (buf, info->type_stack->vtable);
1846 free (info->type_stack->vtable);
1847 info->type_stack->vtable = NULL;
1848 }
1849
1850 /* Replace the string on the top of the stack with the complete
1851 class definition. */
1852 free (info->type_stack->string);
1853 info->type_stack->string = buf;
1854
1855 return true;
1856 }
1857
1858 /* Push a typedef which was previously defined. */
1859
1860 static bool
stab_typedef_type(void * p,const char * name)1861 stab_typedef_type (void *p, const char *name)
1862 {
1863 struct stab_write_handle *info = (struct stab_write_handle *) p;
1864 struct string_hash_entry *h;
1865
1866 h = string_hash_lookup (&info->typedef_hash, name, false, false);
1867 if (h == NULL || h->index < 1)
1868 return false;
1869
1870 return stab_push_defined_type (info, h->index, h->size);
1871 }
1872
1873 /* Push a struct, union or class tag. */
1874
1875 static bool
stab_tag_type(void * p,const char * name,unsigned int id,enum debug_type_kind kind)1876 stab_tag_type (void *p, const char *name, unsigned int id,
1877 enum debug_type_kind kind)
1878 {
1879 struct stab_write_handle *info = (struct stab_write_handle *) p;
1880 long tindex;
1881 unsigned int size = 0;
1882
1883 tindex = stab_get_struct_index (info, name, id, kind, &size);
1884 if (tindex < 0)
1885 return false;
1886
1887 return stab_push_defined_type (info, tindex, size);
1888 }
1889
1890 /* Define a typedef. */
1891
1892 static bool
stab_typdef(void * p,const char * name)1893 stab_typdef (void *p, const char *name)
1894 {
1895 struct stab_write_handle *info = (struct stab_write_handle *) p;
1896 long tindex;
1897 unsigned int size;
1898 char *s, *buf;
1899 struct string_hash_entry *h;
1900
1901 tindex = info->type_stack->index;
1902 size = info->type_stack->size;
1903 s = stab_pop_type (info);
1904
1905 buf = (char *) xmalloc (strlen (name) + strlen (s) + 20);
1906
1907 if (tindex > 0)
1908 sprintf (buf, "%s:t%s", name, s);
1909 else
1910 {
1911 tindex = info->type_index;
1912 ++info->type_index;
1913 sprintf (buf, "%s:t%ld=%s", name, tindex, s);
1914 }
1915
1916 free (s);
1917
1918 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
1919 return false;
1920
1921 free (buf);
1922
1923 h = string_hash_lookup (&info->typedef_hash, name, true, false);
1924 if (h == NULL)
1925 {
1926 non_fatal (_("string_hash_lookup failed: %s"),
1927 bfd_errmsg (bfd_get_error ()));
1928 return false;
1929 }
1930
1931 /* I don't think we care about redefinitions. */
1932
1933 h->index = tindex;
1934 h->size = size;
1935
1936 return true;
1937 }
1938
1939 /* Define a tag. */
1940
1941 static bool
stab_tag(void * p,const char * tag)1942 stab_tag (void *p, const char *tag)
1943 {
1944 struct stab_write_handle *info = (struct stab_write_handle *) p;
1945 char *s, *buf;
1946
1947 s = stab_pop_type (info);
1948
1949 buf = (char *) xmalloc (strlen (tag) + strlen (s) + 3);
1950
1951 sprintf (buf, "%s:T%s", tag, s);
1952 free (s);
1953
1954 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
1955 return false;
1956
1957 free (buf);
1958
1959 return true;
1960 }
1961
1962 /* Define an integer constant. */
1963
1964 static bool
stab_int_constant(void * p,const char * name,bfd_vma val)1965 stab_int_constant (void *p, const char *name, bfd_vma val)
1966 {
1967 struct stab_write_handle *info = (struct stab_write_handle *) p;
1968 char *buf;
1969
1970 buf = (char *) xmalloc (strlen (name) + 20);
1971 sprintf (buf, "%s:c=i%ld", name, (long) val);
1972
1973 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
1974 return false;
1975
1976 free (buf);
1977
1978 return true;
1979 }
1980
1981 /* Define a floating point constant. */
1982
1983 static bool
stab_float_constant(void * p,const char * name,double val)1984 stab_float_constant (void *p, const char *name, double val)
1985 {
1986 struct stab_write_handle *info = (struct stab_write_handle *) p;
1987 char *buf;
1988
1989 buf = (char *) xmalloc (strlen (name) + 20);
1990 sprintf (buf, "%s:c=f%g", name, val);
1991
1992 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
1993 return false;
1994
1995 free (buf);
1996
1997 return true;
1998 }
1999
2000 /* Define a typed constant. */
2001
2002 static bool
stab_typed_constant(void * p,const char * name,bfd_vma val)2003 stab_typed_constant (void *p, const char *name, bfd_vma val)
2004 {
2005 struct stab_write_handle *info = (struct stab_write_handle *) p;
2006 char *s, *buf;
2007
2008 s = stab_pop_type (info);
2009
2010 buf = (char *) xmalloc (strlen (name) + strlen (s) + 20);
2011 sprintf (buf, "%s:c=e%s,%ld", name, s, (long) val);
2012 free (s);
2013
2014 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
2015 return false;
2016
2017 free (buf);
2018
2019 return true;
2020 }
2021
2022 /* Record a variable. */
2023
2024 static bool
stab_variable(void * p,const char * name,enum debug_var_kind kind,bfd_vma val)2025 stab_variable (void *p, const char *name, enum debug_var_kind kind,
2026 bfd_vma val)
2027 {
2028 struct stab_write_handle *info = (struct stab_write_handle *) p;
2029 char *s, *buf;
2030 int stab_type;
2031 const char *kindstr;
2032
2033 s = stab_pop_type (info);
2034
2035 switch (kind)
2036 {
2037 default:
2038 abort ();
2039
2040 case DEBUG_GLOBAL:
2041 stab_type = N_GSYM;
2042 kindstr = "G";
2043 break;
2044
2045 case DEBUG_STATIC:
2046 stab_type = N_STSYM;
2047 kindstr = "S";
2048 break;
2049
2050 case DEBUG_LOCAL_STATIC:
2051 stab_type = N_STSYM;
2052 kindstr = "V";
2053 break;
2054
2055 case DEBUG_LOCAL:
2056 stab_type = N_LSYM;
2057 kindstr = "";
2058
2059 /* Make sure that this is a type reference or definition. */
2060 if (! ISDIGIT (*s))
2061 {
2062 char *n;
2063 long tindex;
2064
2065 tindex = info->type_index;
2066 ++info->type_index;
2067 n = (char *) xmalloc (strlen (s) + 20);
2068 sprintf (n, "%ld=%s", tindex, s);
2069 free (s);
2070 s = n;
2071 }
2072 break;
2073
2074 case DEBUG_REGISTER:
2075 stab_type = N_RSYM;
2076 kindstr = "r";
2077 break;
2078 }
2079
2080 buf = (char *) xmalloc (strlen (name) + strlen (s) + 3);
2081 sprintf (buf, "%s:%s%s", name, kindstr, s);
2082 free (s);
2083
2084 if (! stab_write_symbol (info, stab_type, 0, val, buf))
2085 return false;
2086
2087 free (buf);
2088
2089 return true;
2090 }
2091
2092 /* Start outputting a function. */
2093
2094 static bool
stab_start_function(void * p,const char * name,bool globalp)2095 stab_start_function (void *p, const char *name, bool globalp)
2096 {
2097 struct stab_write_handle *info = (struct stab_write_handle *) p;
2098 char *rettype, *buf;
2099
2100 if (info->nesting != 0 || info->fun_offset != -1)
2101 return false;
2102
2103 rettype = stab_pop_type (info);
2104
2105 buf = (char *) xmalloc (strlen (name) + strlen (rettype) + 3);
2106 sprintf (buf, "%s:%c%s", name,
2107 globalp ? 'F' : 'f',
2108 rettype);
2109
2110 /* We don't know the value now, so we set it in start_block. */
2111 info->fun_offset = info->symbols_size;
2112
2113 if (! stab_write_symbol (info, N_FUN, 0, 0, buf))
2114 return false;
2115
2116 free (buf);
2117
2118 return true;
2119 }
2120
2121 /* Output a function parameter. */
2122
2123 static bool
stab_function_parameter(void * p,const char * name,enum debug_parm_kind kind,bfd_vma val)2124 stab_function_parameter (void *p, const char *name, enum debug_parm_kind kind, bfd_vma val)
2125 {
2126 struct stab_write_handle *info = (struct stab_write_handle *) p;
2127 char *s, *buf;
2128 int stab_type;
2129 char kindc;
2130
2131 s = stab_pop_type (info);
2132
2133 switch (kind)
2134 {
2135 default:
2136 abort ();
2137
2138 case DEBUG_PARM_STACK:
2139 stab_type = N_PSYM;
2140 kindc = 'p';
2141 break;
2142
2143 case DEBUG_PARM_REG:
2144 stab_type = N_RSYM;
2145 kindc = 'P';
2146 break;
2147
2148 case DEBUG_PARM_REFERENCE:
2149 stab_type = N_PSYM;
2150 kindc = 'v';
2151 break;
2152
2153 case DEBUG_PARM_REF_REG:
2154 stab_type = N_RSYM;
2155 kindc = 'a';
2156 break;
2157 }
2158
2159 buf = (char *) xmalloc (strlen (name) + strlen (s) + 3);
2160 sprintf (buf, "%s:%c%s", name, kindc, s);
2161 free (s);
2162
2163 if (! stab_write_symbol (info, stab_type, 0, val, buf))
2164 return false;
2165
2166 free (buf);
2167
2168 return true;
2169 }
2170
2171 /* Start a block. */
2172
2173 static bool
stab_start_block(void * p,bfd_vma addr)2174 stab_start_block (void *p, bfd_vma addr)
2175 {
2176 struct stab_write_handle *info = (struct stab_write_handle *) p;
2177
2178 /* Fill in any slots which have been waiting for the first known
2179 text address. */
2180
2181 if (info->so_offset != -1)
2182 {
2183 bfd_put_32 (info->abfd, addr, info->symbols + info->so_offset + 8);
2184 info->so_offset = -1;
2185 }
2186
2187 if (info->fun_offset != -1)
2188 {
2189 bfd_put_32 (info->abfd, addr, info->symbols + info->fun_offset + 8);
2190 info->fun_offset = -1;
2191 }
2192
2193 ++info->nesting;
2194
2195 /* We will be called with a top level block surrounding the
2196 function, but stabs information does not output that block, so we
2197 ignore it. */
2198
2199 if (info->nesting == 1)
2200 {
2201 info->fnaddr = addr;
2202 return true;
2203 }
2204
2205 /* We have to output the LBRAC symbol after any variables which are
2206 declared inside the block. We postpone the LBRAC until the next
2207 start_block or end_block. */
2208
2209 /* If we have postponed an LBRAC, output it now. */
2210 if (info->pending_lbrac != (bfd_vma) -1)
2211 {
2212 if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac,
2213 (const char *) NULL))
2214 return false;
2215 }
2216
2217 /* Remember the address and output it later. */
2218
2219 info->pending_lbrac = addr - info->fnaddr;
2220
2221 return true;
2222 }
2223
2224 /* End a block. */
2225
2226 static bool
stab_end_block(void * p,bfd_vma addr)2227 stab_end_block (void *p, bfd_vma addr)
2228 {
2229 struct stab_write_handle *info = (struct stab_write_handle *) p;
2230
2231 if (addr > info->last_text_address)
2232 info->last_text_address = addr;
2233
2234 /* If we have postponed an LBRAC, output it now. */
2235 if (info->pending_lbrac != (bfd_vma) -1)
2236 {
2237 if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac,
2238 (const char *) NULL))
2239 return false;
2240 info->pending_lbrac = (bfd_vma) -1;
2241 }
2242
2243 if (info->nesting < 1)
2244 return false;
2245
2246 --info->nesting;
2247
2248 /* We ignore the outermost block. */
2249 if (info->nesting == 0)
2250 return true;
2251
2252 return stab_write_symbol (info, N_RBRAC, 0, addr - info->fnaddr,
2253 (const char *) NULL);
2254 }
2255
2256 /* End a function. */
2257
2258 static bool
stab_end_function(void * p ATTRIBUTE_UNUSED)2259 stab_end_function (void *p ATTRIBUTE_UNUSED)
2260 {
2261 return true;
2262 }
2263
2264 /* Output a line number. */
2265
2266 static bool
stab_lineno(void * p,const char * file,unsigned long lineno,bfd_vma addr)2267 stab_lineno (void *p, const char *file, unsigned long lineno, bfd_vma addr)
2268 {
2269 struct stab_write_handle *info = (struct stab_write_handle *) p;
2270
2271 if (info->lineno_filename == NULL)
2272 return false;
2273
2274 if (addr > info->last_text_address)
2275 info->last_text_address = addr;
2276
2277 if (filename_cmp (file, info->lineno_filename) != 0)
2278 {
2279 if (! stab_write_symbol (info, N_SOL, 0, addr, file))
2280 return false;
2281 info->lineno_filename = file;
2282 }
2283
2284 return stab_write_symbol (info, N_SLINE, lineno, addr - info->fnaddr,
2285 (const char *) NULL);
2286 }
2287