Subversion Repositories Kolibri OS

Rev

Rev 5217 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

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