binutils/wrstabs.c

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