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