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