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