1 /* wrstabs.c -- Output stabs debugging information
2 Copyright (C) 1996-2020 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 /* This file contains code which writes out stabs debugging
28 #include "libiberty.h"
29 #include "filenames.h"
30 #include "safe-ctype.h"
34 #include "aout/aout64.h"
35 #include "aout/stab_gnu.h"
37 /* The size of a stabs symbol. This presumes 32 bit values. */
39 #define STAB_SYMBOL_SIZE (12)
41 /* An entry in a string hash table. */
43 struct string_hash_entry
45 struct bfd_hash_entry root
;
46 /* Next string in this table. */
47 struct string_hash_entry
*next
;
48 /* Index in string table. */
50 /* Size of type if this is a typedef. */
54 /* A string hash table. */
56 struct string_hash_table
58 struct bfd_hash_table table
;
61 /* The type stack. Each element on the stack is a string. */
63 struct stab_type_stack
65 /* The next element on the stack. */
66 struct stab_type_stack
*next
;
67 /* This element as a string. */
69 /* The type index of this element. */
71 /* The size of the type. */
73 /* Whether type string defines a new type. */
74 bfd_boolean definition
;
75 /* String defining struct fields. */
77 /* NULL terminated array of strings defining base classes for a
80 /* String defining class methods. */
82 /* String defining vtable pointer for a class. */
86 /* This structure is used to keep track of type indices for tagged
95 /* The kind of type. This is set to DEBUG_KIND_ILLEGAL when the
97 enum debug_type_kind kind
;
98 /* The size of the struct. */
102 /* We remember various sorts of type indices. They are not related,
103 but, for convenience, we keep all the information in this
106 struct stab_type_cache
108 /* The void type index. */
110 /* Signed integer type indices, indexed by size - 1. */
111 long signed_integer_types
[8];
112 /* Unsigned integer type indices, indexed by size - 1. */
113 long unsigned_integer_types
[8];
114 /* Floating point types, indexed by size - 1. */
115 long float_types
[16];
116 /* Pointers to types, indexed by the type index. */
118 size_t pointer_types_alloc
;
119 /* Functions returning types, indexed by the type index. */
120 long *function_types
;
121 size_t function_types_alloc
;
122 /* References to types, indexed by the type index. */
123 long *reference_types
;
124 size_t reference_types_alloc
;
125 /* Struct/union/class type indices, indexed by the struct id. */
126 struct stab_tag
*struct_types
;
127 size_t struct_types_alloc
;
130 /* This is the handle passed through debug_write. */
132 struct stab_write_handle
136 /* This buffer holds the symbols. */
139 size_t symbols_alloc
;
140 /* This is a list of hash table entries for the strings. */
141 struct string_hash_entry
*strings
;
142 /* The last string hash table entry. */
143 struct string_hash_entry
*last_string
;
144 /* The size of the strings. */
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. */
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. */
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. */
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. */
168 /* A pending LBRAC symbol. */
169 bfd_vma pending_lbrac
;
170 /* The current line number file name. */
171 const char *lineno_filename
;
174 static struct bfd_hash_entry
*string_hash_newfunc
175 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
176 static bfd_boolean stab_write_symbol
177 (struct stab_write_handle
*, int, int, bfd_vma
, const char *);
178 static bfd_boolean stab_push_string
179 (struct stab_write_handle
*, const char *, long, bfd_boolean
, unsigned int);
180 static bfd_boolean stab_push_defined_type
181 (struct stab_write_handle
*, long, unsigned int);
182 static char *stab_pop_type (struct stab_write_handle
*);
183 static bfd_boolean stab_modify_type
184 (struct stab_write_handle
*, int, unsigned int, long **, size_t *);
185 static long stab_get_struct_index
186 (struct stab_write_handle
*, const char *, unsigned int,
187 enum debug_type_kind
, unsigned int *);
188 static bfd_boolean stab_class_method_var
189 (struct stab_write_handle
*, const char *, enum debug_visibility
,
190 bfd_boolean
, bfd_boolean
, bfd_boolean
, bfd_vma
, bfd_boolean
);
191 static bfd_boolean
stab_start_compilation_unit (void *, const char *);
192 static bfd_boolean
stab_start_source (void *, const char *);
193 static bfd_boolean
stab_empty_type (void *);
194 static bfd_boolean
stab_void_type (void *);
195 static bfd_boolean
stab_int_type (void *, unsigned int, bfd_boolean
);
196 static bfd_boolean
stab_float_type (void *, unsigned int);
197 static bfd_boolean
stab_complex_type (void *, unsigned int);
198 static bfd_boolean
stab_bool_type (void *, unsigned int);
199 static bfd_boolean stab_enum_type
200 (void *, const char *, const char **, bfd_signed_vma
*);
201 static bfd_boolean
stab_pointer_type (void *);
202 static bfd_boolean
stab_function_type (void *, int, bfd_boolean
);
203 static bfd_boolean
stab_reference_type (void *);
204 static bfd_boolean
stab_range_type (void *, bfd_signed_vma
, bfd_signed_vma
);
205 static bfd_boolean stab_array_type
206 (void *, bfd_signed_vma
, bfd_signed_vma
, bfd_boolean
);
207 static bfd_boolean
stab_set_type (void *, bfd_boolean
);
208 static bfd_boolean
stab_offset_type (void *);
209 static bfd_boolean
stab_method_type (void *, bfd_boolean
, int, bfd_boolean
);
210 static bfd_boolean
stab_const_type (void *);
211 static bfd_boolean
stab_volatile_type (void *);
212 static bfd_boolean stab_start_struct_type
213 (void *, const char *, unsigned int, bfd_boolean
, unsigned int);
214 static bfd_boolean stab_struct_field
215 (void *, const char *, bfd_vma
, bfd_vma
, enum debug_visibility
);
216 static bfd_boolean
stab_end_struct_type (void *);
217 static bfd_boolean stab_start_class_type
218 (void *, const char *, unsigned int, bfd_boolean
, unsigned int,
219 bfd_boolean
, bfd_boolean
);
220 static bfd_boolean stab_class_static_member
221 (void *, const char *, const char *, enum debug_visibility
);
222 static bfd_boolean stab_class_baseclass
223 (void *, bfd_vma
, bfd_boolean
, enum debug_visibility
);
224 static bfd_boolean
stab_class_start_method (void *, const char *);
225 static bfd_boolean stab_class_method_variant
226 (void *, const char *, enum debug_visibility
, bfd_boolean
, bfd_boolean
,
227 bfd_vma
, bfd_boolean
);
228 static bfd_boolean stab_class_static_method_variant
229 (void *, const char *, enum debug_visibility
, bfd_boolean
, bfd_boolean
);
230 static bfd_boolean
stab_class_end_method (void *);
231 static bfd_boolean
stab_end_class_type (void *);
232 static bfd_boolean
stab_typedef_type (void *, const char *);
233 static bfd_boolean stab_tag_type
234 (void *, const char *, unsigned int, enum debug_type_kind
);
235 static bfd_boolean
stab_typdef (void *, const char *);
236 static bfd_boolean
stab_tag (void *, const char *);
237 static bfd_boolean
stab_int_constant (void *, const char *, bfd_vma
);
238 static bfd_boolean
stab_float_constant (void *, const char *, double);
239 static bfd_boolean
stab_typed_constant (void *, const char *, bfd_vma
);
240 static bfd_boolean stab_variable
241 (void *, const char *, enum debug_var_kind
, bfd_vma
);
242 static bfd_boolean
stab_start_function (void *, const char *, bfd_boolean
);
243 static bfd_boolean stab_function_parameter
244 (void *, const char *, enum debug_parm_kind
, bfd_vma
);
245 static bfd_boolean
stab_start_block (void *, bfd_vma
);
246 static bfd_boolean
stab_end_block (void *, bfd_vma
);
247 static bfd_boolean
stab_end_function (void *);
248 static bfd_boolean
stab_lineno (void *, const char *, unsigned long, bfd_vma
);
250 static const struct debug_write_fns stab_fns
=
252 stab_start_compilation_unit
,
271 stab_start_struct_type
,
273 stab_end_struct_type
,
274 stab_start_class_type
,
275 stab_class_static_member
,
276 stab_class_baseclass
,
277 stab_class_start_method
,
278 stab_class_method_variant
,
279 stab_class_static_method_variant
,
280 stab_class_end_method
,
291 stab_function_parameter
,
298 /* Routine to create an entry in a string hash table. */
300 static struct bfd_hash_entry
*
301 string_hash_newfunc (struct bfd_hash_entry
*entry
,
302 struct bfd_hash_table
*table
, const char *string
)
304 struct string_hash_entry
*ret
= (struct string_hash_entry
*) entry
;
306 /* Allocate the structure if it has not already been allocated by a
308 if (ret
== (struct string_hash_entry
*) NULL
)
309 ret
= ((struct string_hash_entry
*)
310 bfd_hash_allocate (table
, sizeof (struct string_hash_entry
)));
311 if (ret
== (struct string_hash_entry
*) NULL
)
314 /* Call the allocation method of the superclass. */
315 ret
= ((struct string_hash_entry
*)
316 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
320 /* Initialize the local fields. */
326 return (struct bfd_hash_entry
*) ret
;
329 /* Look up an entry in a string hash table. */
331 #define string_hash_lookup(t, string, create, copy) \
332 ((struct string_hash_entry *) \
333 bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
335 /* Add a symbol to the stabs debugging information we are building. */
338 stab_write_symbol (struct stab_write_handle
*info
, int type
, int desc
,
339 bfd_vma value
, const char *string
)
342 bfd_byte sym
[STAB_SYMBOL_SIZE
];
348 struct string_hash_entry
*h
;
350 h
= string_hash_lookup (&info
->strhash
, string
, TRUE
, TRUE
);
353 non_fatal (_("string_hash_lookup failed: %s"),
354 bfd_errmsg (bfd_get_error ()));
361 strx
= info
->strings_size
;
363 if (info
->last_string
== NULL
)
366 info
->last_string
->next
= h
;
367 info
->last_string
= h
;
368 info
->strings_size
+= strlen (string
) + 1;
372 /* This presumes 32 bit values. */
373 bfd_put_32 (info
->abfd
, strx
, sym
);
374 bfd_put_8 (info
->abfd
, type
, sym
+ 4);
375 bfd_put_8 (info
->abfd
, 0, sym
+ 5);
376 bfd_put_16 (info
->abfd
, desc
, sym
+ 6);
377 bfd_put_32 (info
->abfd
, value
, sym
+ 8);
379 if (info
->symbols_size
+ STAB_SYMBOL_SIZE
> info
->symbols_alloc
)
381 info
->symbols_alloc
*= 2;
382 info
->symbols
= (bfd_byte
*) xrealloc (info
->symbols
,
383 info
->symbols_alloc
);
386 memcpy (info
->symbols
+ info
->symbols_size
, sym
, STAB_SYMBOL_SIZE
);
388 info
->symbols_size
+= STAB_SYMBOL_SIZE
;
393 /* Push a string on to the type stack. */
396 stab_push_string (struct stab_write_handle
*info
, const char *string
,
397 long tindex
, bfd_boolean definition
, unsigned int size
)
399 struct stab_type_stack
*s
;
401 s
= (struct stab_type_stack
*) xmalloc (sizeof *s
);
402 s
->string
= xstrdup (string
);
404 s
->definition
= definition
;
408 s
->baseclasses
= NULL
;
412 s
->next
= info
->type_stack
;
413 info
->type_stack
= s
;
418 /* Push a type index which has already been defined. */
421 stab_push_defined_type (struct stab_write_handle
*info
, long tindex
,
426 sprintf (buf
, "%ld", tindex
);
427 return stab_push_string (info
, buf
, tindex
, FALSE
, size
);
430 /* Pop a type off the type stack. The caller is responsible for
431 freeing the string. */
434 stab_pop_type (struct stab_write_handle
*info
)
436 struct stab_type_stack
*s
;
439 s
= info
->type_stack
;
443 info
->type_stack
= s
->next
;
452 /* The general routine to write out stabs in sections debugging
453 information. This accumulates the stabs symbols and the strings in
454 two obstacks. We can't easily write out the information as we go
455 along, because we need to know the section sizes before we can
456 write out the section contents. ABFD is the BFD and DHANDLE is the
457 handle for the debugging information. This sets *PSYMS to point to
458 the symbols, *PSYMSIZE the size of the symbols, *PSTRINGS to the
459 strings, and *PSTRINGSIZE to the size of the strings. */
462 write_stabs_in_sections_debugging_info (bfd
*abfd
, void *dhandle
,
464 bfd_size_type
*psymsize
,
466 bfd_size_type
*pstringsize
)
468 struct stab_write_handle info
;
469 struct string_hash_entry
*h
;
474 info
.symbols_size
= 0;
475 info
.symbols_alloc
= 500;
476 info
.symbols
= (bfd_byte
*) xmalloc (info
.symbols_alloc
);
479 info
.last_string
= NULL
;
480 /* Reserve 1 byte for a null byte. */
481 info
.strings_size
= 1;
483 if (!bfd_hash_table_init (&info
.strhash
.table
, string_hash_newfunc
,
484 sizeof (struct string_hash_entry
))
485 || !bfd_hash_table_init (&info
.typedef_hash
.table
, string_hash_newfunc
,
486 sizeof (struct string_hash_entry
)))
488 non_fatal ("bfd_hash_table_init_failed: %s",
489 bfd_errmsg (bfd_get_error ()));
493 info
.type_stack
= NULL
;
495 memset (&info
.type_cache
, 0, sizeof info
.type_cache
);
497 info
.fun_offset
= -1;
498 info
.last_text_address
= 0;
501 info
.pending_lbrac
= (bfd_vma
) -1;
503 /* The initial symbol holds the string size. */
504 if (! stab_write_symbol (&info
, 0, 0, 0, (const char *) NULL
))
507 /* Output an initial N_SO symbol. */
508 info
.so_offset
= info
.symbols_size
;
509 if (! stab_write_symbol (&info
, N_SO
, 0, 0, bfd_get_filename (abfd
)))
512 if (! debug_write (dhandle
, &stab_fns
, (void *) &info
))
515 if (info
.pending_lbrac
!= (bfd_vma
) -1)
518 /* Output a trailing N_SO. */
519 if (! stab_write_symbol (&info
, N_SO
, 0, info
.last_text_address
,
520 (const char *) NULL
))
523 /* Put the string size in the initial symbol. */
524 bfd_put_32 (abfd
, info
.strings_size
, info
.symbols
+ 8);
526 *psyms
= info
.symbols
;
527 *psymsize
= info
.symbols_size
;
529 *pstringsize
= info
.strings_size
;
530 *pstrings
= (bfd_byte
*) xmalloc (info
.strings_size
);
534 for (h
= info
.strings
; h
!= NULL
; h
= h
->next
)
536 strcpy ((char *) p
, h
->root
.string
);
537 p
+= strlen ((char *) p
) + 1;
543 /* Start writing out information for a compilation unit. */
546 stab_start_compilation_unit (void *p
, const char *filename
)
548 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
550 /* We would normally output an N_SO symbol here. However, that
551 would force us to reset all of our type information. I think we
552 will be better off just outputting an N_SOL symbol, and not
553 worrying about splitting information between files. */
555 info
->lineno_filename
= filename
;
557 return stab_write_symbol (info
, N_SOL
, 0, 0, filename
);
560 /* Start writing out information for a particular source file. */
563 stab_start_source (void *p
, const char *filename
)
565 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
567 /* FIXME: The symbol's value is supposed to be the text section
568 address. However, we would have to fill it in later, and gdb
569 doesn't care, so we don't bother with it. */
571 info
->lineno_filename
= filename
;
573 return stab_write_symbol (info
, N_SOL
, 0, 0, filename
);
576 /* Push an empty type. This shouldn't normally happen. We just use a
580 stab_empty_type (void *p
)
582 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
584 /* We don't call stab_void_type if the type is not yet defined,
585 because that might screw up the typedef. */
587 if (info
->type_cache
.void_type
!= 0)
588 return stab_push_defined_type (info
, info
->type_cache
.void_type
, 0);
594 tindex
= info
->type_index
;
597 sprintf (buf
, "%ld=%ld", tindex
, tindex
);
599 return stab_push_string (info
, buf
, tindex
, FALSE
, 0);
603 /* Push a void type. */
606 stab_void_type (void *p
)
608 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
610 if (info
->type_cache
.void_type
!= 0)
611 return stab_push_defined_type (info
, info
->type_cache
.void_type
, 0);
617 tindex
= info
->type_index
;
620 info
->type_cache
.void_type
= tindex
;
622 sprintf (buf
, "%ld=%ld", tindex
, tindex
);
624 return stab_push_string (info
, buf
, tindex
, TRUE
, 0);
628 /* Push an integer type. */
631 stab_int_type (void *p
, unsigned int size
, bfd_boolean unsignedp
)
633 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
636 if (size
<= 0 || (size
> sizeof (long) && size
!= 8))
638 non_fatal (_("stab_int_type: bad size %u"), size
);
643 cache
= info
->type_cache
.signed_integer_types
;
645 cache
= info
->type_cache
.unsigned_integer_types
;
647 if (cache
[size
- 1] != 0)
648 return stab_push_defined_type (info
, cache
[size
- 1], size
);
654 tindex
= info
->type_index
;
657 cache
[size
- 1] = tindex
;
659 sprintf (buf
, "%ld=r%ld;", tindex
, tindex
);
663 if (size
< sizeof (long))
664 sprintf (buf
+ strlen (buf
), "%ld;", ((long) 1 << (size
* 8)) - 1);
665 else if (size
== sizeof (long))
668 strcat (buf
, "01777777777777777777777;");
674 if (size
<= sizeof (long))
675 sprintf (buf
+ strlen (buf
), "%ld;%ld;",
676 (long) - ((unsigned long) 1 << (size
* 8 - 1)),
677 (long) (((unsigned long) 1 << (size
* 8 - 1)) - 1));
679 strcat (buf
, "01000000000000000000000;0777777777777777777777;");
684 return stab_push_string (info
, buf
, tindex
, TRUE
, size
);
688 /* Push a floating point type. */
691 stab_float_type (void *p
, unsigned int size
)
693 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
696 && size
- 1 < (sizeof info
->type_cache
.float_types
697 / sizeof info
->type_cache
.float_types
[0])
698 && info
->type_cache
.float_types
[size
- 1] != 0)
699 return stab_push_defined_type (info
,
700 info
->type_cache
.float_types
[size
- 1],
708 /* Floats are defined as a subrange of int. */
709 if (! stab_int_type (info
, 4, FALSE
))
711 int_type
= stab_pop_type (info
);
713 tindex
= info
->type_index
;
717 && size
- 1 < (sizeof info
->type_cache
.float_types
718 / sizeof info
->type_cache
.float_types
[0]))
719 info
->type_cache
.float_types
[size
- 1] = tindex
;
721 sprintf (buf
, "%ld=r%s;%u;0;", tindex
, int_type
, size
);
725 return stab_push_string (info
, buf
, tindex
, TRUE
, size
);
729 /* Push a complex type. */
732 stab_complex_type (void *p
, unsigned int size
)
734 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
738 tindex
= info
->type_index
;
741 sprintf (buf
, "%ld=r%ld;%u;0;", tindex
, tindex
, size
);
743 return stab_push_string (info
, buf
, tindex
, TRUE
, size
* 2);
746 /* Push a bfd_boolean type. We use an XCOFF predefined type, since gdb
747 always recognizes them. */
750 stab_bool_type (void *p
, unsigned int size
)
752 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
775 return stab_push_defined_type (info
, tindex
, size
);
778 /* Push an enum type. */
781 stab_enum_type (void *p
, const char *tag
, const char **names
,
782 bfd_signed_vma
*vals
)
784 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
796 buf
= (char *) xmalloc (10 + strlen (tag
));
797 sprintf (buf
, "xe%s:", tag
);
798 /* FIXME: The size is just a guess. */
799 if (! stab_push_string (info
, buf
, 0, FALSE
, 4))
808 for (pn
= names
; *pn
!= NULL
; pn
++)
809 len
+= strlen (*pn
) + 20;
811 buf
= (char *) xmalloc (len
);
817 tindex
= info
->type_index
;
819 sprintf (buf
, "%s:T%ld=e", tag
, tindex
);
822 for (pn
= names
, pv
= vals
; *pn
!= NULL
; pn
++, pv
++)
823 sprintf (buf
+ strlen (buf
), "%s:%ld,", *pn
, (long) *pv
);
828 /* FIXME: The size is just a guess. */
829 if (! stab_push_string (info
, buf
, 0, FALSE
, 4))
834 /* FIXME: The size is just a guess. */
835 if (! stab_write_symbol (info
, N_LSYM
, 0, 0, buf
)
836 || ! stab_push_defined_type (info
, tindex
, 4))
845 /* Push a modification of the top type on the stack. Cache the
846 results in CACHE and CACHE_ALLOC. */
849 stab_modify_type (struct stab_write_handle
*info
, int mod
,
850 unsigned int size
, long **cache
, size_t *cache_alloc
)
856 if (info
->type_stack
== NULL
)
858 targindex
= info
->type_stack
->index
;
863 bfd_boolean definition
;
865 /* Either the target type has no index, or we aren't caching
866 this modifier. Either way we have no way of recording the
867 new type, so we don't bother to define one. */
868 definition
= info
->type_stack
->definition
;
869 s
= stab_pop_type (info
);
870 buf
= (char *) xmalloc (strlen (s
) + 2);
871 sprintf (buf
, "%c%s", mod
, s
);
873 if (! stab_push_string (info
, buf
, 0, definition
, size
))
879 if ((size_t) targindex
>= *cache_alloc
)
883 alloc
= *cache_alloc
;
886 while ((size_t) targindex
>= alloc
)
888 *cache
= (long *) xrealloc (*cache
, alloc
* sizeof (long));
889 memset (*cache
+ *cache_alloc
, 0,
890 (alloc
- *cache_alloc
) * sizeof (long));
891 *cache_alloc
= alloc
;
894 tindex
= (*cache
)[targindex
];
895 if (tindex
!= 0 && ! info
->type_stack
->definition
)
897 /* We have already defined a modification of this type, and
898 the entry on the type stack is not a definition, so we
899 can safely discard it (we may have a definition on the
900 stack, even if we already defined a modification, if it
901 is a struct which we did not define at the time it was
903 free (stab_pop_type (info
));
904 if (! stab_push_defined_type (info
, tindex
, size
))
909 tindex
= info
->type_index
;
912 s
= stab_pop_type (info
);
913 buf
= (char *) xmalloc (strlen (s
) + 20);
914 sprintf (buf
, "%ld=%c%s", tindex
, mod
, s
);
917 (*cache
)[targindex
] = tindex
;
919 if (! stab_push_string (info
, buf
, tindex
, TRUE
, size
))
929 /* Push a pointer type. */
932 stab_pointer_type (void *p
)
934 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
936 /* FIXME: The size should depend upon the architecture. */
937 return stab_modify_type (info
, '*', 4, &info
->type_cache
.pointer_types
,
938 &info
->type_cache
.pointer_types_alloc
);
941 /* Push a function type. */
944 stab_function_type (void *p
, int argcount
,
945 bfd_boolean varargs ATTRIBUTE_UNUSED
)
947 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
950 /* We have no way to represent the argument types, so we just
951 discard them. However, if they define new types, we must output
952 them. We do this by producing empty typedefs. */
953 for (i
= 0; i
< argcount
; i
++)
955 if (! info
->type_stack
->definition
)
956 free (stab_pop_type (info
));
961 s
= stab_pop_type (info
);
963 buf
= (char *) xmalloc (strlen (s
) + 3);
964 sprintf (buf
, ":t%s", s
);
967 if (! stab_write_symbol (info
, N_LSYM
, 0, 0, buf
))
974 return stab_modify_type (info
, 'f', 0, &info
->type_cache
.function_types
,
975 &info
->type_cache
.function_types_alloc
);
978 /* Push a reference type. */
981 stab_reference_type (void *p
)
983 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
985 /* FIXME: The size should depend upon the architecture. */
986 return stab_modify_type (info
, '&', 4, &info
->type_cache
.reference_types
,
987 &info
->type_cache
.reference_types_alloc
);
990 /* Push a range type. */
993 stab_range_type (void *p
, bfd_signed_vma low
, bfd_signed_vma high
)
995 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
996 bfd_boolean definition
;
1000 definition
= info
->type_stack
->definition
;
1001 size
= info
->type_stack
->size
;
1003 s
= stab_pop_type (info
);
1004 buf
= (char *) xmalloc (strlen (s
) + 100);
1005 sprintf (buf
, "r%s;%ld;%ld;", s
, (long) low
, (long) high
);
1008 if (! stab_push_string (info
, buf
, 0, definition
, size
))
1016 /* Push an array type. */
1019 stab_array_type (void *p
, bfd_signed_vma low
, bfd_signed_vma high
,
1020 bfd_boolean stringp
)
1022 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1023 bfd_boolean definition
;
1024 unsigned int element_size
;
1025 char *range
, *element
, *buf
;
1029 definition
= info
->type_stack
->definition
;
1030 range
= stab_pop_type (info
);
1032 definition
= definition
|| info
->type_stack
->definition
;
1033 element_size
= info
->type_stack
->size
;
1034 element
= stab_pop_type (info
);
1036 buf
= (char *) xmalloc (strlen (range
) + strlen (element
) + 100);
1045 /* We need to define a type in order to include the string
1047 tindex
= info
->type_index
;
1050 sprintf (buf
, "%ld=@S;", tindex
);
1053 sprintf (buf
+ strlen (buf
), "ar%s;%ld;%ld;%s",
1054 range
, (long) low
, (long) high
, element
);
1061 size
= element_size
* ((high
- low
) + 1);
1062 if (! stab_push_string (info
, buf
, tindex
, definition
, size
))
1070 /* Push a set type. */
1073 stab_set_type (void *p
, bfd_boolean bitstringp
)
1075 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1076 bfd_boolean definition
;
1080 definition
= info
->type_stack
->definition
;
1082 s
= stab_pop_type (info
);
1083 buf
= (char *) xmalloc (strlen (s
) + 30);
1092 /* We need to define a type in order to include the string
1094 tindex
= info
->type_index
;
1097 sprintf (buf
, "%ld=@S;", tindex
);
1100 sprintf (buf
+ strlen (buf
), "S%s", s
);
1103 if (! stab_push_string (info
, buf
, tindex
, definition
, 0))
1111 /* Push an offset type. */
1114 stab_offset_type (void *p
)
1116 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1117 bfd_boolean definition
;
1118 char *target
, *base
, *buf
;
1120 definition
= info
->type_stack
->definition
;
1121 target
= stab_pop_type (info
);
1123 definition
= definition
|| info
->type_stack
->definition
;
1124 base
= stab_pop_type (info
);
1126 buf
= (char *) xmalloc (strlen (target
) + strlen (base
) + 3);
1127 sprintf (buf
, "@%s,%s", base
, target
);
1131 if (! stab_push_string (info
, buf
, 0, definition
, 0))
1139 /* Push a method type. */
1142 stab_method_type (void *p
, bfd_boolean domainp
, int argcount
,
1143 bfd_boolean varargs
)
1145 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1146 bfd_boolean definition
;
1147 char *domain
, *return_type
, *buf
;
1152 /* We don't bother with stub method types, because that would
1153 require a mangler for C++ argument types. This will waste space
1154 in the debugging output. */
1156 /* We need a domain. I'm not sure DOMAINP can ever be false,
1160 if (! stab_empty_type (p
))
1164 definition
= info
->type_stack
->definition
;
1165 domain
= stab_pop_type (info
);
1167 /* A non-varargs function is indicated by making the last parameter
1175 else if (argcount
== 0)
1181 args
= (char **) xmalloc (1 * sizeof (*args
));
1182 if (! stab_empty_type (p
))
1184 definition
= definition
|| info
->type_stack
->definition
;
1185 args
[0] = stab_pop_type (info
);
1191 args
= (char **) xmalloc ((argcount
+ 1) * sizeof (*args
));
1192 for (i
= argcount
- 1; i
>= 0; i
--)
1194 definition
= definition
|| info
->type_stack
->definition
;
1195 args
[i
] = stab_pop_type (info
);
1199 if (! stab_empty_type (p
))
1201 definition
= definition
|| info
->type_stack
->definition
;
1202 args
[argcount
] = stab_pop_type (info
);
1207 definition
= definition
|| info
->type_stack
->definition
;
1208 return_type
= stab_pop_type (info
);
1210 len
= strlen (domain
) + strlen (return_type
) + 10;
1211 for (i
= 0; i
< argcount
; i
++)
1212 len
+= strlen (args
[i
]);
1214 buf
= (char *) xmalloc (len
);
1216 sprintf (buf
, "#%s,%s", domain
, return_type
);
1219 for (i
= 0; i
< argcount
; i
++)
1222 strcat (buf
, args
[i
]);
1230 if (! stab_push_string (info
, buf
, 0, definition
, 0))
1238 /* Push a const version of a type. */
1241 stab_const_type (void *p
)
1243 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1245 return stab_modify_type (info
, 'k', info
->type_stack
->size
,
1246 (long **) NULL
, (size_t *) NULL
);
1249 /* Push a volatile version of a type. */
1252 stab_volatile_type (void *p
)
1254 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1256 return stab_modify_type (info
, 'B', info
->type_stack
->size
,
1257 (long **) NULL
, (size_t *) NULL
);
1260 /* Get the type index to use for a struct/union/class ID. This should
1261 return -1 if it fails. */
1264 stab_get_struct_index (struct stab_write_handle
*info
, const char *tag
,
1265 unsigned int id
, enum debug_type_kind kind
,
1266 unsigned int *psize
)
1268 if (id
>= info
->type_cache
.struct_types_alloc
)
1272 alloc
= info
->type_cache
.struct_types_alloc
;
1277 info
->type_cache
.struct_types
=
1278 (struct stab_tag
*) xrealloc (info
->type_cache
.struct_types
,
1279 alloc
* sizeof (struct stab_tag
));
1280 memset ((info
->type_cache
.struct_types
1281 + info
->type_cache
.struct_types_alloc
),
1283 ((alloc
- info
->type_cache
.struct_types_alloc
)
1284 * sizeof (struct stab_tag
)));
1285 info
->type_cache
.struct_types_alloc
= alloc
;
1288 if (info
->type_cache
.struct_types
[id
].index
== 0)
1290 info
->type_cache
.struct_types
[id
].index
= info
->type_index
;
1292 info
->type_cache
.struct_types
[id
].tag
= tag
;
1293 info
->type_cache
.struct_types
[id
].kind
= kind
;
1296 if (kind
== DEBUG_KIND_ILLEGAL
)
1298 /* This is a definition of the struct. */
1299 info
->type_cache
.struct_types
[id
].kind
= kind
;
1300 info
->type_cache
.struct_types
[id
].size
= *psize
;
1303 *psize
= info
->type_cache
.struct_types
[id
].size
;
1305 return info
->type_cache
.struct_types
[id
].index
;
1308 /* Start outputting a struct. We ignore the tag, and handle it in
1312 stab_start_struct_type (void *p
, const char *tag
, unsigned int id
,
1313 bfd_boolean structp
, unsigned int size
)
1315 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1317 bfd_boolean definition
;
1328 tindex
= stab_get_struct_index (info
, tag
, id
, DEBUG_KIND_ILLEGAL
,
1332 sprintf (buf
, "%ld=", tindex
);
1336 sprintf (buf
+ strlen (buf
), "%c%u",
1337 structp
? 's' : 'u',
1340 if (! stab_push_string (info
, buf
, tindex
, definition
, size
))
1343 info
->type_stack
->fields
= (char *) xmalloc (1);
1344 info
->type_stack
->fields
[0] = '\0';
1349 /* Add a field to a struct. */
1352 stab_struct_field (void *p
, const char *name
, bfd_vma bitpos
,
1353 bfd_vma bitsize
, enum debug_visibility visibility
)
1355 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1356 bfd_boolean definition
;
1361 definition
= info
->type_stack
->definition
;
1362 size
= info
->type_stack
->size
;
1363 s
= stab_pop_type (info
);
1365 /* Add this field to the end of the current struct fields, which is
1366 currently on the top of the stack. */
1367 if (info
->type_stack
->fields
== NULL
)
1370 n
= (char *) xmalloc (strlen (info
->type_stack
->fields
)
1380 case DEBUG_VISIBILITY_PUBLIC
:
1384 case DEBUG_VISIBILITY_PRIVATE
:
1388 case DEBUG_VISIBILITY_PROTECTED
:
1397 non_fatal (_("%s: warning: unknown size for field `%s' in struct"),
1398 bfd_get_filename (info
->abfd
), name
);
1401 sprintf (n
, "%s%s:%s%s,%ld,%ld;", info
->type_stack
->fields
, name
, vis
, s
,
1402 (long) bitpos
, (long) bitsize
);
1404 free (info
->type_stack
->fields
);
1405 info
->type_stack
->fields
= n
;
1408 info
->type_stack
->definition
= TRUE
;
1413 /* Finish up a struct. */
1416 stab_end_struct_type (void *p
)
1418 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1419 bfd_boolean definition
;
1422 char *fields
, *first
, *buf
;
1424 if (info
->type_stack
== NULL
|| info
->type_stack
->fields
== NULL
)
1427 definition
= info
->type_stack
->definition
;
1428 tindex
= info
->type_stack
->index
;
1429 size
= info
->type_stack
->size
;
1430 fields
= info
->type_stack
->fields
;
1431 first
= stab_pop_type (info
);
1433 buf
= (char *) xmalloc (strlen (first
) + strlen (fields
) + 2);
1434 sprintf (buf
, "%s%s;", first
, fields
);
1438 if (! stab_push_string (info
, buf
, tindex
, definition
, size
))
1446 /* Start outputting a class. */
1449 stab_start_class_type (void *p
, const char *tag
, unsigned int id
,
1450 bfd_boolean structp
, unsigned int size
,
1451 bfd_boolean vptr
, bfd_boolean ownvptr
)
1453 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1454 bfd_boolean definition
= FALSE
;
1455 char *vstring
= NULL
;
1457 if (vptr
&& !ownvptr
)
1459 definition
= info
->type_stack
->definition
;
1460 vstring
= stab_pop_type (info
);
1463 if (! stab_start_struct_type (p
, tag
, id
, structp
, size
))
1472 if (info
->type_stack
->index
< 1)
1474 vtable
= (char *) xmalloc (20);
1475 sprintf (vtable
, "~%%%ld", info
->type_stack
->index
);
1479 if (vstring
== NULL
)
1481 vtable
= (char *) xmalloc (strlen (vstring
) + 3);
1482 sprintf (vtable
, "~%%%s", vstring
);
1485 info
->type_stack
->definition
= TRUE
;
1487 info
->type_stack
->vtable
= vtable
;
1493 /* Add a static member to the class on the type stack. */
1496 stab_class_static_member (void *p
, const char *name
, const char *physname
,
1497 enum debug_visibility visibility
)
1499 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1500 bfd_boolean definition
;
1504 definition
= info
->type_stack
->definition
;
1505 s
= stab_pop_type (info
);
1507 /* Add this field to the end of the current struct fields, which is
1508 currently on the top of the stack. */
1510 if (info
->type_stack
->fields
== NULL
)
1512 n
= (char *) xmalloc (strlen (info
->type_stack
->fields
)
1523 case DEBUG_VISIBILITY_PUBLIC
:
1527 case DEBUG_VISIBILITY_PRIVATE
:
1531 case DEBUG_VISIBILITY_PROTECTED
:
1536 sprintf (n
, "%s%s:%s%s:%s;", info
->type_stack
->fields
, name
, vis
, s
,
1539 free (info
->type_stack
->fields
);
1540 info
->type_stack
->fields
= n
;
1543 info
->type_stack
->definition
= TRUE
;
1548 /* Add a base class to the class on the type stack. */
1551 stab_class_baseclass (void *p
, bfd_vma bitpos
, bfd_boolean is_virtual
,
1552 enum debug_visibility visibility
)
1554 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1555 bfd_boolean definition
;
1561 definition
= info
->type_stack
->definition
;
1562 s
= stab_pop_type (info
);
1564 /* Build the base class specifier. */
1566 buf
= (char *) xmalloc (strlen (s
) + 25);
1567 buf
[0] = is_virtual
? '1' : '0';
1573 case DEBUG_VISIBILITY_PRIVATE
:
1577 case DEBUG_VISIBILITY_PROTECTED
:
1581 case DEBUG_VISIBILITY_PUBLIC
:
1586 sprintf (buf
+ 2, "%ld,%s;", (long) bitpos
, s
);
1589 /* Add the new baseclass to the existing ones. */
1591 if (info
->type_stack
== NULL
|| info
->type_stack
->fields
== NULL
)
1594 if (info
->type_stack
->baseclasses
== NULL
)
1599 while (info
->type_stack
->baseclasses
[c
] != NULL
)
1603 baseclasses
= (char **) xrealloc (info
->type_stack
->baseclasses
,
1604 (c
+ 2) * sizeof (*baseclasses
));
1605 baseclasses
[c
] = buf
;
1606 baseclasses
[c
+ 1] = NULL
;
1608 info
->type_stack
->baseclasses
= baseclasses
;
1611 info
->type_stack
->definition
= TRUE
;
1616 /* Start adding a method to the class on the type stack. */
1619 stab_class_start_method (void *p
, const char *name
)
1621 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1624 if (info
->type_stack
== NULL
|| info
->type_stack
->fields
== NULL
)
1627 if (info
->type_stack
->methods
== NULL
)
1629 m
= (char *) xmalloc (strlen (name
) + 3);
1634 m
= (char *) xrealloc (info
->type_stack
->methods
,
1635 (strlen (info
->type_stack
->methods
)
1640 sprintf (m
+ strlen (m
), "%s::", name
);
1642 info
->type_stack
->methods
= m
;
1647 /* Add a variant, either static or not, to the current method. */
1650 stab_class_method_var (struct stab_write_handle
*info
, const char *physname
,
1651 enum debug_visibility visibility
,
1652 bfd_boolean staticp
, bfd_boolean constp
,
1653 bfd_boolean volatilep
, bfd_vma voffset
,
1654 bfd_boolean contextp
)
1656 bfd_boolean definition
;
1658 char *context
= NULL
;
1659 char visc
, qualc
, typec
;
1661 definition
= info
->type_stack
->definition
;
1662 type
= stab_pop_type (info
);
1666 definition
= definition
|| info
->type_stack
->definition
;
1667 context
= stab_pop_type (info
);
1670 if (info
->type_stack
== NULL
|| info
->type_stack
->methods
== NULL
)
1678 case DEBUG_VISIBILITY_PRIVATE
:
1682 case DEBUG_VISIBILITY_PROTECTED
:
1686 case DEBUG_VISIBILITY_PUBLIC
:
1708 else if (! contextp
)
1713 info
->type_stack
->methods
=
1714 (char *) xrealloc (info
->type_stack
->methods
,
1715 (strlen (info
->type_stack
->methods
)
1718 + (contextp
? strlen (context
) : 0)
1721 sprintf (info
->type_stack
->methods
+ strlen (info
->type_stack
->methods
),
1722 "%s:%s;%c%c%c", type
, physname
, visc
, qualc
, typec
);
1727 sprintf (info
->type_stack
->methods
+ strlen (info
->type_stack
->methods
),
1728 "%ld;%s;", (long) voffset
, context
);
1733 info
->type_stack
->definition
= TRUE
;
1738 /* Add a variant to the current method. */
1741 stab_class_method_variant (void *p
, const char *physname
,
1742 enum debug_visibility visibility
,
1743 bfd_boolean constp
, bfd_boolean volatilep
,
1744 bfd_vma voffset
, bfd_boolean contextp
)
1746 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1748 return stab_class_method_var (info
, physname
, visibility
, FALSE
, constp
,
1749 volatilep
, voffset
, contextp
);
1752 /* Add a static variant to the current method. */
1755 stab_class_static_method_variant (void *p
, const char *physname
,
1756 enum debug_visibility visibility
,
1757 bfd_boolean constp
, bfd_boolean volatilep
)
1759 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1761 return stab_class_method_var (info
, physname
, visibility
, TRUE
, constp
,
1762 volatilep
, 0, FALSE
);
1765 /* Finish up a method. */
1768 stab_class_end_method (void *p
)
1770 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1772 if (info
->type_stack
== NULL
|| info
->type_stack
->methods
== NULL
)
1775 /* We allocated enough room on info->type_stack->methods to add the
1776 trailing semicolon. */
1777 strcat (info
->type_stack
->methods
, ";");
1782 /* Finish up a class. */
1785 stab_end_class_type (void *p
)
1787 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1792 if (info
->type_stack
== NULL
1793 || info
->type_stack
->string
== NULL
1794 || info
->type_stack
->fields
== NULL
)
1797 /* Work out the size we need to allocate for the class definition. */
1799 len
= (strlen (info
->type_stack
->string
)
1800 + strlen (info
->type_stack
->fields
)
1802 if (info
->type_stack
->baseclasses
!= NULL
)
1805 for (i
= 0; info
->type_stack
->baseclasses
[i
] != NULL
; i
++)
1806 len
+= strlen (info
->type_stack
->baseclasses
[i
]);
1808 if (info
->type_stack
->methods
!= NULL
)
1809 len
+= strlen (info
->type_stack
->methods
);
1810 if (info
->type_stack
->vtable
!= NULL
)
1811 len
+= strlen (info
->type_stack
->vtable
);
1813 /* Build the class definition. */
1815 buf
= (char *) xmalloc (len
);
1817 strcpy (buf
, info
->type_stack
->string
);
1819 if (info
->type_stack
->baseclasses
!= NULL
)
1821 sprintf (buf
+ strlen (buf
), "!%u,", i
);
1822 for (i
= 0; info
->type_stack
->baseclasses
[i
] != NULL
; i
++)
1824 strcat (buf
, info
->type_stack
->baseclasses
[i
]);
1825 free (info
->type_stack
->baseclasses
[i
]);
1827 free (info
->type_stack
->baseclasses
);
1828 info
->type_stack
->baseclasses
= NULL
;
1831 strcat (buf
, info
->type_stack
->fields
);
1832 free (info
->type_stack
->fields
);
1833 info
->type_stack
->fields
= NULL
;
1835 if (info
->type_stack
->methods
!= NULL
)
1837 strcat (buf
, info
->type_stack
->methods
);
1838 free (info
->type_stack
->methods
);
1839 info
->type_stack
->methods
= NULL
;
1844 if (info
->type_stack
->vtable
!= NULL
)
1846 strcat (buf
, info
->type_stack
->vtable
);
1847 free (info
->type_stack
->vtable
);
1848 info
->type_stack
->vtable
= NULL
;
1851 /* Replace the string on the top of the stack with the complete
1852 class definition. */
1853 free (info
->type_stack
->string
);
1854 info
->type_stack
->string
= buf
;
1859 /* Push a typedef which was previously defined. */
1862 stab_typedef_type (void *p
, const char *name
)
1864 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1865 struct string_hash_entry
*h
;
1867 h
= string_hash_lookup (&info
->typedef_hash
, name
, FALSE
, FALSE
);
1868 if (h
== NULL
|| h
->index
< 1)
1871 return stab_push_defined_type (info
, h
->index
, h
->size
);
1874 /* Push a struct, union or class tag. */
1877 stab_tag_type (void *p
, const char *name
, unsigned int id
,
1878 enum debug_type_kind kind
)
1880 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1882 unsigned int size
= 0;
1884 tindex
= stab_get_struct_index (info
, name
, id
, kind
, &size
);
1888 return stab_push_defined_type (info
, tindex
, size
);
1891 /* Define a typedef. */
1894 stab_typdef (void *p
, const char *name
)
1896 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1900 struct string_hash_entry
*h
;
1902 tindex
= info
->type_stack
->index
;
1903 size
= info
->type_stack
->size
;
1904 s
= stab_pop_type (info
);
1906 buf
= (char *) xmalloc (strlen (name
) + strlen (s
) + 20);
1909 sprintf (buf
, "%s:t%s", name
, s
);
1912 tindex
= info
->type_index
;
1914 sprintf (buf
, "%s:t%ld=%s", name
, tindex
, s
);
1919 if (! stab_write_symbol (info
, N_LSYM
, 0, 0, buf
))
1924 h
= string_hash_lookup (&info
->typedef_hash
, name
, TRUE
, FALSE
);
1927 non_fatal (_("string_hash_lookup failed: %s"),
1928 bfd_errmsg (bfd_get_error ()));
1932 /* I don't think we care about redefinitions. */
1943 stab_tag (void *p
, const char *tag
)
1945 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1948 s
= stab_pop_type (info
);
1950 buf
= (char *) xmalloc (strlen (tag
) + strlen (s
) + 3);
1952 sprintf (buf
, "%s:T%s", tag
, s
);
1955 if (! stab_write_symbol (info
, N_LSYM
, 0, 0, buf
))
1963 /* Define an integer constant. */
1966 stab_int_constant (void *p
, const char *name
, bfd_vma val
)
1968 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1971 buf
= (char *) xmalloc (strlen (name
) + 20);
1972 sprintf (buf
, "%s:c=i%ld", name
, (long) val
);
1974 if (! stab_write_symbol (info
, N_LSYM
, 0, 0, buf
))
1982 /* Define a floating point constant. */
1985 stab_float_constant (void *p
, const char *name
, double val
)
1987 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
1990 buf
= (char *) xmalloc (strlen (name
) + 20);
1991 sprintf (buf
, "%s:c=f%g", name
, val
);
1993 if (! stab_write_symbol (info
, N_LSYM
, 0, 0, buf
))
2001 /* Define a typed constant. */
2004 stab_typed_constant (void *p
, const char *name
, bfd_vma val
)
2006 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
2009 s
= stab_pop_type (info
);
2011 buf
= (char *) xmalloc (strlen (name
) + strlen (s
) + 20);
2012 sprintf (buf
, "%s:c=e%s,%ld", name
, s
, (long) val
);
2015 if (! stab_write_symbol (info
, N_LSYM
, 0, 0, buf
))
2023 /* Record a variable. */
2026 stab_variable (void *p
, const char *name
, enum debug_var_kind kind
,
2029 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
2032 const char *kindstr
;
2034 s
= stab_pop_type (info
);
2047 stab_type
= N_STSYM
;
2051 case DEBUG_LOCAL_STATIC
:
2052 stab_type
= N_STSYM
;
2060 /* Make sure that this is a type reference or definition. */
2066 tindex
= info
->type_index
;
2068 n
= (char *) xmalloc (strlen (s
) + 20);
2069 sprintf (n
, "%ld=%s", tindex
, s
);
2075 case DEBUG_REGISTER
:
2081 buf
= (char *) xmalloc (strlen (name
) + strlen (s
) + 3);
2082 sprintf (buf
, "%s:%s%s", name
, kindstr
, s
);
2085 if (! stab_write_symbol (info
, stab_type
, 0, val
, buf
))
2093 /* Start outputting a function. */
2096 stab_start_function (void *p
, const char *name
, bfd_boolean globalp
)
2098 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
2099 char *rettype
, *buf
;
2101 if (info
->nesting
!= 0 || info
->fun_offset
!= -1)
2104 rettype
= stab_pop_type (info
);
2106 buf
= (char *) xmalloc (strlen (name
) + strlen (rettype
) + 3);
2107 sprintf (buf
, "%s:%c%s", name
,
2108 globalp
? 'F' : 'f',
2111 /* We don't know the value now, so we set it in start_block. */
2112 info
->fun_offset
= info
->symbols_size
;
2114 if (! stab_write_symbol (info
, N_FUN
, 0, 0, buf
))
2122 /* Output a function parameter. */
2125 stab_function_parameter (void *p
, const char *name
, enum debug_parm_kind kind
, bfd_vma val
)
2127 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
2132 s
= stab_pop_type (info
);
2139 case DEBUG_PARM_STACK
:
2144 case DEBUG_PARM_REG
:
2149 case DEBUG_PARM_REFERENCE
:
2154 case DEBUG_PARM_REF_REG
:
2160 buf
= (char *) xmalloc (strlen (name
) + strlen (s
) + 3);
2161 sprintf (buf
, "%s:%c%s", name
, kindc
, s
);
2164 if (! stab_write_symbol (info
, stab_type
, 0, val
, buf
))
2172 /* Start a block. */
2175 stab_start_block (void *p
, bfd_vma addr
)
2177 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
2179 /* Fill in any slots which have been waiting for the first known
2182 if (info
->so_offset
!= -1)
2184 bfd_put_32 (info
->abfd
, addr
, info
->symbols
+ info
->so_offset
+ 8);
2185 info
->so_offset
= -1;
2188 if (info
->fun_offset
!= -1)
2190 bfd_put_32 (info
->abfd
, addr
, info
->symbols
+ info
->fun_offset
+ 8);
2191 info
->fun_offset
= -1;
2196 /* We will be called with a top level block surrounding the
2197 function, but stabs information does not output that block, so we
2200 if (info
->nesting
== 1)
2202 info
->fnaddr
= addr
;
2206 /* We have to output the LBRAC symbol after any variables which are
2207 declared inside the block. We postpone the LBRAC until the next
2208 start_block or end_block. */
2210 /* If we have postponed an LBRAC, output it now. */
2211 if (info
->pending_lbrac
!= (bfd_vma
) -1)
2213 if (! stab_write_symbol (info
, N_LBRAC
, 0, info
->pending_lbrac
,
2214 (const char *) NULL
))
2218 /* Remember the address and output it later. */
2220 info
->pending_lbrac
= addr
- info
->fnaddr
;
2228 stab_end_block (void *p
, bfd_vma addr
)
2230 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
2232 if (addr
> info
->last_text_address
)
2233 info
->last_text_address
= addr
;
2235 /* If we have postponed an LBRAC, output it now. */
2236 if (info
->pending_lbrac
!= (bfd_vma
) -1)
2238 if (! stab_write_symbol (info
, N_LBRAC
, 0, info
->pending_lbrac
,
2239 (const char *) NULL
))
2241 info
->pending_lbrac
= (bfd_vma
) -1;
2244 if (info
->nesting
< 1)
2249 /* We ignore the outermost block. */
2250 if (info
->nesting
== 0)
2253 return stab_write_symbol (info
, N_RBRAC
, 0, addr
- info
->fnaddr
,
2254 (const char *) NULL
);
2257 /* End a function. */
2260 stab_end_function (void *p ATTRIBUTE_UNUSED
)
2265 /* Output a line number. */
2268 stab_lineno (void *p
, const char *file
, unsigned long lineno
, bfd_vma addr
)
2270 struct stab_write_handle
*info
= (struct stab_write_handle
*) p
;
2272 if (info
->lineno_filename
== NULL
)
2275 if (addr
> info
->last_text_address
)
2276 info
->last_text_address
= addr
;
2278 if (filename_cmp (file
, info
->lineno_filename
) != 0)
2280 if (! stab_write_symbol (info
, N_SOL
, 0, addr
, file
))
2282 info
->lineno_filename
= file
;
2285 return stab_write_symbol (info
, N_SLINE
, lineno
, addr
- info
->fnaddr
,
2286 (const char *) NULL
);