projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Move putchar_filtered() to utils.c.
[deliverable/binutils-gdb.git] / binutils / wrstabs.c
CommitLineData
252b5132 1/* wrstabs.c -- Output stabs debugging information
37cc8ec1 2 Copyright (C) 1996, 97, 98, 99, 2000 Free Software Foundation, Inc.
252b5132
RH		 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 {
37cc8ec1
AM		 366 non_fatal (_("string_hash_lookup failed: %s"),
367 bfd_errmsg (bfd_get_error ()));
252b5132
RH		 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 {
37cc8ec1
AM		 508 non_fatal ("bfd_hash_table_init_failed: %s",
509 bfd_errmsg (bfd_get_error ()));
252b5132
RH		 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 {
37cc8ec1 666 non_fatal (_("stab_int_type: bad size %u"), size);
252b5132
RH		 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;
b4c96d0d 987 boolean varargs ATTRIBUTE_UNUSED;
252b5132
RH		 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)
37cc8ec1
AM		 1467 non_fatal (_("%s: warning: unknown size for field `%s' in struct"),
1468 bfd_get_filename (info->abfd), name);
252b5132
RH		 1469 }
1470
1471 sprintf (n, "%s%s:%s%s,%ld,%ld;", info->type_stack->fields, name, vis, s,
1472 (long) bitpos, (long) bitsize);
1473
1474 free (info->type_stack->fields);
1475 info->type_stack->fields = n;
1476
1477 if (definition)
1478 info->type_stack->definition = true;
1479
1480 return true;
1481}
1482
1483/* Finish up a struct. */
1484
1485static boolean
1486stab_end_struct_type (p)
1487 PTR p;
1488{
1489 struct stab_write_handle *info = (struct stab_write_handle *) p;
1490 boolean definition;
1491 long index;
1492 unsigned int size;
1493 char *fields, *first, *buf;
1494
1495 assert (info->type_stack != NULL && info->type_stack->fields != NULL);
1496
1497 definition = info->type_stack->definition;
1498 index = info->type_stack->index;
1499 size = info->type_stack->size;
1500 fields = info->type_stack->fields;
1501 first = stab_pop_type (info);
1502
1503 buf = (char *) xmalloc (strlen (first) + strlen (fields) + 2);
1504 sprintf (buf, "%s%s;", first, fields);
1505 free (first);
1506 free (fields);
1507
1508 if (! stab_push_string (info, buf, index, definition, size))
1509 return false;
1510
1511 free (buf);
1512
1513 return true;
1514}
1515
1516/* Start outputting a class. */
1517
1518static boolean
1519stab_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
1520 PTR p;
1521 const char *tag;
1522 unsigned int id;
1523 boolean structp;
1524 unsigned int size;
1525 boolean vptr;
1526 boolean ownvptr;
1527{
1528 struct stab_write_handle *info = (struct stab_write_handle *) p;
1529 boolean definition;
1530 char *vstring;
1531
1532 if (! vptr || ownvptr)
1533 {
1534 definition = false;
1535 vstring = NULL;
1536 }
1537 else
1538 {
1539 definition = info->type_stack->definition;
1540 vstring = stab_pop_type (info);
1541 }
1542
1543 if (! stab_start_struct_type (p, tag, id, structp, size))
1544 return false;
1545
1546 if (vptr)
1547 {
1548 char *vtable;
1549
1550 if (ownvptr)
1551 {
1552 assert (info->type_stack->index > 0);
1553 vtable = (char *) xmalloc (20);
1554 sprintf (vtable, "~%%%ld", info->type_stack->index);
1555 }
1556 else
1557 {
1558 vtable = (char *) xmalloc (strlen (vstring) + 3);
1559 sprintf (vtable, "~%%%s", vstring);
1560 free (vstring);
1561 }
1562
1563 info->type_stack->vtable = vtable;
1564 }
1565
1566 if (definition)
1567 info->type_stack->definition = true;
1568
1569 return true;
1570}
1571
1572/* Add a static member to the class on the type stack. */
1573
1574static boolean
1575stab_class_static_member (p, name, physname, visibility)
1576 PTR p;
1577 const char *name;
1578 const char *physname;
1579 enum debug_visibility visibility;
1580{
1581 struct stab_write_handle *info = (struct stab_write_handle *) p;
1582 boolean definition;
1583 char *s, *n;
1584 const char *vis;
1585
1586 definition = info->type_stack->definition;
1587 s = stab_pop_type (info);
1588
1589 /* Add this field to the end of the current struct fields, which is
1590 currently on the top of the stack. */
1591
1592 assert (info->type_stack->fields != NULL);
1593 n = (char *) xmalloc (strlen (info->type_stack->fields)
1594 + strlen (name)
1595 + strlen (s)
1596 + strlen (physname)
1597 + 10);
1598
1599 switch (visibility)
1600 {
1601 default:
1602 abort ();
1603
1604 case DEBUG_VISIBILITY_PUBLIC:
1605 vis = "";
1606 break;
1607
1608 case DEBUG_VISIBILITY_PRIVATE:
1609 vis = "/0";
1610 break;
1611
1612 case DEBUG_VISIBILITY_PROTECTED:
1613 vis = "/1";
1614 break;
1615 }
1616
1617 sprintf (n, "%s%s:%s%s:%s;", info->type_stack->fields, name, vis, s,
1618 physname);
1619
1620 free (info->type_stack->fields);
1621 info->type_stack->fields = n;
1622
1623 if (definition)
1624 info->type_stack->definition = true;
1625
1626 return true;
1627}
1628
1629/* Add a base class to the class on the type stack. */
1630
1631static boolean
1632stab_class_baseclass (p, bitpos, virtual, visibility)
1633 PTR p;
1634 bfd_vma bitpos;
1635 boolean virtual;
1636 enum debug_visibility visibility;
1637{
1638 struct stab_write_handle *info = (struct stab_write_handle *) p;
1639 boolean definition;
1640 char *s;
1641 char *buf;
1642 unsigned int c;
1643 char **baseclasses;
1644
1645 definition = info->type_stack->definition;
1646 s = stab_pop_type (info);
1647
1648 /* Build the base class specifier. */
1649
1650 buf = (char *) xmalloc (strlen (s) + 25);
1651 buf[0] = virtual ? '1' : '0';
1652 switch (visibility)
1653 {
1654 default:
1655 abort ();
1656
1657 case DEBUG_VISIBILITY_PRIVATE:
1658 buf[1] = '0';
1659 break;
1660
1661 case DEBUG_VISIBILITY_PROTECTED:
1662 buf[1] = '1';
1663 break;
1664
1665 case DEBUG_VISIBILITY_PUBLIC:
1666 buf[1] = '2';
1667 break;
1668 }
1669
1670 sprintf (buf + 2, "%ld,%s;", (long) bitpos, s);
1671 free (s);
1672
1673 /* Add the new baseclass to the existing ones. */
1674
1675 assert (info->type_stack != NULL && info->type_stack->fields != NULL);
1676
1677 if (info->type_stack->baseclasses == NULL)
1678 c = 0;
1679 else
1680 {
1681 c = 0;
1682 while (info->type_stack->baseclasses[c] != NULL)
1683 ++c;
1684 }
1685
1686 baseclasses = (char **) xrealloc (info->type_stack->baseclasses,
1687 (c + 2) * sizeof (*baseclasses));
1688 baseclasses[c] = buf;
1689 baseclasses[c + 1] = NULL;
1690
1691 info->type_stack->baseclasses = baseclasses;
1692
1693 if (definition)
1694 info->type_stack->definition = true;
1695
1696 return true;
1697}
1698
1699/* Start adding a method to the class on the type stack. */
1700
1701static boolean
1702stab_class_start_method (p, name)
1703 PTR p;
1704 const char *name;
1705{
1706 struct stab_write_handle *info = (struct stab_write_handle *) p;
1707 char *m;
1708
1709 assert (info->type_stack != NULL && info->type_stack->fields != NULL);
1710
1711 if (info->type_stack->methods == NULL)
1712 {
1713 m = (char *) xmalloc (strlen (name) + 3);
1714 *m = '\0';
1715 }
1716 else
1717 {
1718 m = (char *) xrealloc (info->type_stack->methods,
1719 (strlen (info->type_stack->methods)
1720 + strlen (name)
1721 + 4));
1722 }
1723
1724 sprintf (m + strlen (m), "%s::", name);
1725
1726 info->type_stack->methods = m;
1727
1728 return true;
1729}
1730
1731/* Add a variant, either static or not, to the current method. */
1732
1733static boolean
1734stab_class_method_var (info, physname, visibility, staticp, constp, volatilep,
1735 voffset, contextp)
1736 struct stab_write_handle *info;
1737 const char *physname;
1738 enum debug_visibility visibility;
1739 boolean staticp;
1740 boolean constp;
1741 boolean volatilep;
1742 bfd_vma voffset;
1743 boolean contextp;
1744{
1745 boolean definition;
1746 char *type;
1747 char *context = NULL;
1748 char visc, qualc, typec;
1749
1750 definition = info->type_stack->definition;
1751 type = stab_pop_type (info);
1752
1753 if (contextp)
1754 {
1755 definition = definition || info->type_stack->definition;
1756 context = stab_pop_type (info);
1757 }
1758
1759 assert (info->type_stack != NULL && info->type_stack->methods != NULL);
1760
1761 switch (visibility)
1762 {
1763 default:
1764 abort ();
1765
1766 case DEBUG_VISIBILITY_PRIVATE:
1767 visc = '0';
1768 break;
1769
1770 case DEBUG_VISIBILITY_PROTECTED:
1771 visc = '1';
1772 break;
1773
1774 case DEBUG_VISIBILITY_PUBLIC:
1775 visc = '2';
1776 break;
1777 }
1778
1779 if (constp)
1780 {
1781 if (volatilep)
1782 qualc = 'D';
1783 else
1784 qualc = 'B';
1785 }
1786 else
1787 {
1788 if (volatilep)
1789 qualc = 'C';
1790 else
1791 qualc = 'A';
1792 }
1793
1794 if (staticp)
1795 typec = '?';
1796 else if (! contextp)
1797 typec = '.';
1798 else
1799 typec = '*';
1800
1801 info->type_stack->methods =
1802 (char *) xrealloc (info->type_stack->methods,
1803 (strlen (info->type_stack->methods)
1804 + strlen (type)
1805 + strlen (physname)
1806 + (contextp ? strlen (context) : 0)
1807 + 40));
1808
1809 sprintf (info->type_stack->methods + strlen (info->type_stack->methods),
1810 "%s:%s;%c%c%c", type, physname, visc, qualc, typec);
1811 free (type);
1812
1813 if (contextp)
1814 {
1815 sprintf (info->type_stack->methods + strlen (info->type_stack->methods),
1816 "%ld;%s;", (long) voffset, context);
1817 free (context);
1818 }
1819
1820 if (definition)
1821 info->type_stack->definition = true;
1822
1823 return true;
1824}
1825
1826/* Add a variant to the current method. */
1827
1828static boolean
1829stab_class_method_variant (p, physname, visibility, constp, volatilep,
1830 voffset, contextp)
1831 PTR p;
1832 const char *physname;
1833 enum debug_visibility visibility;
1834 boolean constp;
1835 boolean volatilep;
1836 bfd_vma voffset;
1837 boolean contextp;
1838{
1839 struct stab_write_handle *info = (struct stab_write_handle *) p;
1840
1841 return stab_class_method_var (info, physname, visibility, false, constp,
1842 volatilep, voffset, contextp);
1843}
1844
1845/* Add a static variant to the current method. */
1846
1847static boolean
1848stab_class_static_method_variant (p, physname, visibility, constp, volatilep)
1849 PTR p;
1850 const char *physname;
1851 enum debug_visibility visibility;
1852 boolean constp;
1853 boolean volatilep;
1854{
1855 struct stab_write_handle *info = (struct stab_write_handle *) p;
1856
1857 return stab_class_method_var (info, physname, visibility, true, constp,
1858 volatilep, 0, false);
1859}
1860
1861/* Finish up a method. */
1862
1863static boolean
1864stab_class_end_method (p)
1865 PTR p;
1866{
1867 struct stab_write_handle *info = (struct stab_write_handle *) p;
1868
1869 assert (info->type_stack != NULL && info->type_stack->methods != NULL);
1870
1871 /* We allocated enough room on info->type_stack->methods to add the
1872 trailing semicolon. */
1873 strcat (info->type_stack->methods, ";");
1874
1875 return true;
1876}
1877
1878/* Finish up a class. */
1879
1880static boolean
1881stab_end_class_type (p)
1882 PTR p;
1883{
1884 struct stab_write_handle *info = (struct stab_write_handle *) p;
1885 size_t len;
1886 unsigned int i = 0;
1887 char *buf;
1888
1889 assert (info->type_stack != NULL && info->type_stack->fields != NULL);
1890
1891 /* Work out the size we need to allocate for the class definition. */
1892
1893 len = (strlen (info->type_stack->string)
1894 + strlen (info->type_stack->fields)
1895 + 10);
1896 if (info->type_stack->baseclasses != NULL)
1897 {
1898 len += 20;
1899 for (i = 0; info->type_stack->baseclasses[i] != NULL; i++)
1900 len += strlen (info->type_stack->baseclasses[i]);
1901 }
1902 if (info->type_stack->methods != NULL)
1903 len += strlen (info->type_stack->methods);
1904 if (info->type_stack->vtable != NULL)
1905 len += strlen (info->type_stack->vtable);
1906
1907 /* Build the class definition. */
1908
1909 buf = (char *) xmalloc (len);
1910
1911 strcpy (buf, info->type_stack->string);
1912
1913 if (info->type_stack->baseclasses != NULL)
1914 {
1915 sprintf (buf + strlen (buf), "!%u,", i);
1916 for (i = 0; info->type_stack->baseclasses[i] != NULL; i++)
1917 {
1918 strcat (buf, info->type_stack->baseclasses[i]);
1919 free (info->type_stack->baseclasses[i]);
1920 }
1921 free (info->type_stack->baseclasses);
1922 info->type_stack->baseclasses = NULL;
1923 }
1924
1925 strcat (buf, info->type_stack->fields);
1926 free (info->type_stack->fields);
1927 info->type_stack->fields = NULL;
1928
1929 if (info->type_stack->methods != NULL)
1930 {
1931 strcat (buf, info->type_stack->methods);
1932 free (info->type_stack->methods);
1933 info->type_stack->methods = NULL;
1934 }
1935
1936 strcat (buf, ";");
1937
1938 if (info->type_stack->vtable != NULL)
1939 {
1940 strcat (buf, info->type_stack->vtable);
1941 free (info->type_stack->vtable);
1942 info->type_stack->vtable = NULL;
1943 }
1944
1945 /* Replace the string on the top of the stack with the complete
1946 class definition. */
1947 free (info->type_stack->string);
1948 info->type_stack->string = buf;
1949
1950 return true;
1951}
1952
1953/* Push a typedef which was previously defined. */
1954
1955static boolean
1956stab_typedef_type (p, name)
1957 PTR p;
1958 const char *name;
1959{
1960 struct stab_write_handle *info = (struct stab_write_handle *) p;
1961 struct string_hash_entry *h;
1962
1963 h = string_hash_lookup (&info->typedef_hash, name, false, false);
1964 assert (h != NULL && h->index > 0);
1965
1966 return stab_push_defined_type (info, h->index, h->size);
1967}
1968
1969/* Push a struct, union or class tag. */
1970
1971static boolean
1972stab_tag_type (p, name, id, kind)
1973 PTR p;
1974 const char *name;
1975 unsigned int id;
1976 enum debug_type_kind kind;
1977{
1978 struct stab_write_handle *info = (struct stab_write_handle *) p;
1979 long index;
1980 unsigned int size;
1981
1982 index = stab_get_struct_index (info, name, id, kind, &size);
1983 if (index < 0)
1984 return false;
1985
1986 return stab_push_defined_type (info, index, size);
1987}
1988
1989/* Define a typedef. */
1990
1991static boolean
1992stab_typdef (p, name)
1993 PTR p;
1994 const char *name;
1995{
1996 struct stab_write_handle *info = (struct stab_write_handle *) p;
1997 long index;
1998 unsigned int size;
1999 char *s, *buf;
2000 struct string_hash_entry *h;
2001
2002 index = info->type_stack->index;
2003 size = info->type_stack->size;
2004 s = stab_pop_type (info);
2005
2006 buf = (char *) xmalloc (strlen (name) + strlen (s) + 20);
2007
2008 if (index > 0)
2009 sprintf (buf, "%s:t%s", name, s);
2010 else
2011 {
2012 index = info->type_index;
2013 ++info->type_index;
2014 sprintf (buf, "%s:t%ld=%s", name, index, s);
2015 }
2016
2017 free (s);
2018
2019 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
2020 return false;
2021
2022 free (buf);
2023
2024 h = string_hash_lookup (&info->typedef_hash, name, true, false);
2025 if (h == NULL)
2026 {
37cc8ec1
AM		 2027 non_fatal (_("string_hash_lookup failed: %s"),
2028 bfd_errmsg (bfd_get_error ()));
252b5132
RH		 2029 return false;
2030 }
2031
2032 /* I don't think we care about redefinitions. */
2033
2034 h->index = index;
2035 h->size = size;
2036
2037 return true;
2038}
2039
2040/* Define a tag. */
2041
2042static boolean
2043stab_tag (p, tag)
2044 PTR p;
2045 const char *tag;
2046{
2047 struct stab_write_handle *info = (struct stab_write_handle *) p;
2048 char *s, *buf;
2049
2050 s = stab_pop_type (info);
2051
2052 buf = (char *) xmalloc (strlen (tag) + strlen (s) + 3);
2053
2054 sprintf (buf, "%s:T%s", tag, s);
2055 free (s);
2056
2057 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
2058 return false;
2059
2060 free (buf);
2061
2062 return true;
2063}
2064
2065/* Define an integer constant. */
2066
2067static boolean
2068stab_int_constant (p, name, val)
2069 PTR p;
2070 const char *name;
2071 bfd_vma val;
2072{
2073 struct stab_write_handle *info = (struct stab_write_handle *) p;
2074 char *buf;
2075
2076 buf = (char *) xmalloc (strlen (name) + 20);
2077 sprintf (buf, "%s:c=i%ld", name, (long) val);
2078
2079 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
2080 return false;
2081
2082 free (buf);
2083
2084 return true;
2085}
2086
2087/* Define a floating point constant. */
2088
2089static boolean
2090stab_float_constant (p, name, val)
2091 PTR p;
2092 const char *name;
2093 double val;
2094{
2095 struct stab_write_handle *info = (struct stab_write_handle *) p;
2096 char *buf;
2097
2098 buf = (char *) xmalloc (strlen (name) + 20);
2099 sprintf (buf, "%s:c=f%g", name, val);
2100
2101 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
2102 return false;
2103
2104 free (buf);
2105
2106 return true;
2107}
2108
2109/* Define a typed constant. */
2110
2111static boolean
2112stab_typed_constant (p, name, val)
2113 PTR p;
2114 const char *name;
2115 bfd_vma val;
2116{
2117 struct stab_write_handle *info = (struct stab_write_handle *) p;
2118 char *s, *buf;
2119
2120 s = stab_pop_type (info);
2121
2122 buf = (char *) xmalloc (strlen (name) + strlen (s) + 20);
2123 sprintf (buf, "%s:c=e%s,%ld", name, s, (long) val);
2124 free (s);
2125
2126 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
2127 return false;
2128
2129 free (buf);
2130
2131 return true;
2132}
2133
2134/* Record a variable. */
2135
2136static boolean
2137stab_variable (p, name, kind, val)
2138 PTR p;
2139 const char *name;
2140 enum debug_var_kind kind;
2141 bfd_vma val;
2142{
2143 struct stab_write_handle *info = (struct stab_write_handle *) p;
2144 char *s, *buf;
2145 int stab_type;
2146 const char *kindstr;
2147
2148 s = stab_pop_type (info);
2149
2150 switch (kind)
2151 {
2152 default:
2153 abort ();
2154
2155 case DEBUG_GLOBAL:
2156 stab_type = N_GSYM;
2157 kindstr = "G";
2158 break;
2159
2160 case DEBUG_STATIC:
2161 stab_type = N_STSYM;
2162 kindstr = "S";
2163 break;
2164
2165 case DEBUG_LOCAL_STATIC:
2166 stab_type = N_STSYM;
2167 kindstr = "V";
2168 break;
2169
2170 case DEBUG_LOCAL:
2171 stab_type = N_LSYM;
2172 kindstr = "";
2173
2174 /* Make sure that this is a type reference or definition. */
2175 if (! isdigit ((unsigned char) *s))
2176 {
2177 char *n;
2178 long index;
2179
2180 index = info->type_index;
2181 ++info->type_index;
2182 n = (char *) xmalloc (strlen (s) + 20);
2183 sprintf (n, "%ld=%s", index, s);
2184 free (s);
2185 s = n;
2186 }
2187 break;
2188
2189 case DEBUG_REGISTER:
2190 stab_type = N_RSYM;
2191 kindstr = "r";
2192 break;
2193 }
2194
2195 buf = (char *) xmalloc (strlen (name) + strlen (s) + 3);
2196 sprintf (buf, "%s:%s%s", name, kindstr, s);
2197 free (s);
2198
2199 if (! stab_write_symbol (info, stab_type, 0, val, buf))
2200 return false;
2201
2202 free (buf);
2203
2204 return true;
2205}
2206
2207/* Start outputting a function. */
2208
2209static boolean
2210stab_start_function (p, name, globalp)
2211 PTR p;
2212 const char *name;
2213 boolean globalp;
2214{
2215 struct stab_write_handle *info = (struct stab_write_handle *) p;
2216 char *rettype, *buf;
2217
2218 assert (info->nesting == 0 && info->fun_offset == -1);
2219
2220 rettype = stab_pop_type (info);
2221
2222 buf = (char *) xmalloc (strlen (name) + strlen (rettype) + 3);
2223 sprintf (buf, "%s:%c%s", name,
2224 globalp ? 'F' : 'f',
2225 rettype);
2226
2227 /* We don't know the value now, so we set it in start_block. */
2228 info->fun_offset = info->symbols_size;
2229
2230 if (! stab_write_symbol (info, N_FUN, 0, 0, buf))
2231 return false;
2232
2233 free (buf);
2234
2235 return true;
2236}
2237
2238/* Output a function parameter. */
2239
2240static boolean
2241stab_function_parameter (p, name, kind, val)
2242 PTR p;
2243 const char *name;
2244 enum debug_parm_kind kind;
2245 bfd_vma val;
2246{
2247 struct stab_write_handle *info = (struct stab_write_handle *) p;
2248 char *s, *buf;
2249 int stab_type;
2250 char kindc;
2251
2252 s = stab_pop_type (info);
2253
2254 switch (kind)
2255 {
2256 default:
2257 abort ();
2258
2259 case DEBUG_PARM_STACK:
2260 stab_type = N_PSYM;
2261 kindc = 'p';
2262 break;
2263
2264 case DEBUG_PARM_REG:
2265 stab_type = N_RSYM;
2266 kindc = 'P';
2267 break;
2268
2269 case DEBUG_PARM_REFERENCE:
2270 stab_type = N_PSYM;
2271 kindc = 'v';
2272 break;
2273
2274 case DEBUG_PARM_REF_REG:
2275 stab_type = N_RSYM;
2276 kindc = 'a';
2277 break;
2278 }
2279
2280 buf = (char *) xmalloc (strlen (name) + strlen (s) + 3);
2281 sprintf (buf, "%s:%c%s", name, kindc, s);
2282 free (s);
2283
2284 if (! stab_write_symbol (info, stab_type, 0, val, buf))
2285 return false;
2286
2287 free (buf);
2288
2289 return true;
2290}
2291
2292/* Start a block. */
2293
2294static boolean
2295stab_start_block (p, addr)
2296 PTR p;
2297 bfd_vma addr;
2298{
2299 struct stab_write_handle *info = (struct stab_write_handle *) p;
2300
2301 /* Fill in any slots which have been waiting for the first known
2302 text address. */
2303
2304 if (info->so_offset != -1)
2305 {
2306 bfd_put_32 (info->abfd, addr, info->symbols + info->so_offset + 8);
2307 info->so_offset = -1;
2308 }
2309
2310 if (info->fun_offset != -1)
2311 {
2312 bfd_put_32 (info->abfd, addr, info->symbols + info->fun_offset + 8);
2313 info->fun_offset = -1;
2314 }
2315
2316 ++info->nesting;
2317
2318 /* We will be called with a top level block surrounding the
2319 function, but stabs information does not output that block, so we
2320 ignore it. */
2321
2322 if (info->nesting == 1)
2323 {
2324 info->fnaddr = addr;
2325 return true;
2326 }
2327
2328 /* We have to output the LBRAC symbol after any variables which are
2329 declared inside the block. We postpone the LBRAC until the next
2330 start_block or end_block. */
2331
2332 /* If we have postponed an LBRAC, output it now. */
2333 if (info->pending_lbrac != (bfd_vma) -1)
2334 {
2335 if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac,
2336 (const char *) NULL))
2337 return false;
2338 }
2339
2340 /* Remember the address and output it later. */
2341
2342 info->pending_lbrac = addr - info->fnaddr;
2343
2344 return true;
2345}
2346
2347/* End a block. */
2348
2349static boolean
2350stab_end_block (p, addr)
2351 PTR p;
2352 bfd_vma addr;
2353{
2354 struct stab_write_handle *info = (struct stab_write_handle *) p;
2355
2356 if (addr > info->last_text_address)
2357 info->last_text_address = addr;
2358
2359 /* If we have postponed an LBRAC, output it now. */
2360 if (info->pending_lbrac != (bfd_vma) -1)
2361 {
2362 if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac,
2363 (const char *) NULL))
2364 return false;
2365 info->pending_lbrac = (bfd_vma) -1;
2366 }
2367
2368 assert (info->nesting > 0);
2369
2370 --info->nesting;
2371
2372 /* We ignore the outermost block. */
2373 if (info->nesting == 0)
2374 return true;
2375
2376 return stab_write_symbol (info, N_RBRAC, 0, addr - info->fnaddr,
2377 (const char *) NULL);
2378}
2379
2380/* End a function. */
2381
2382/*ARGSUSED*/
2383static boolean
2384stab_end_function (p)
b4c96d0d 2385 PTR p ATTRIBUTE_UNUSED;
252b5132
RH		 2386{
2387 return true;
2388}
2389
2390/* Output a line number. */
2391
2392static boolean
2393stab_lineno (p, file, lineno, addr)
2394 PTR p;
2395 const char *file;
2396 unsigned long lineno;
2397 bfd_vma addr;
2398{
2399 struct stab_write_handle *info = (struct stab_write_handle *) p;
2400
2401 assert (info->lineno_filename != NULL);
2402
2403 if (addr > info->last_text_address)
2404 info->last_text_address = addr;
2405
2406 if (strcmp (file, info->lineno_filename) != 0)
2407 {
2408 if (! stab_write_symbol (info, N_SOL, 0, addr, file))
2409 return false;
2410 info->lineno_filename = file;
2411 }
2412
2413 return stab_write_symbol (info, N_SLINE, lineno, addr - info->fnaddr,
2414 (const char *) NULL);
2415}
GDB Binutils - Deliverables
This page took 0.144125 seconds and 4 git commands to generate.