binutils/wrstabs.c

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