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