/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c

Bug Summary

File:	src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c
Warning:	line 1297, column 46 Assigned value is garbage or undefined
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name wrstabs.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils-2.17/obj/binutils -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -I . -I /usr/src/gnu/usr.bin/binutils-2.17/binutils -I . -D _GNU_SOURCE -I . -I /usr/src/gnu/usr.bin/binutils-2.17/binutils -I ../bfd -I /usr/src/gnu/usr.bin/binutils-2.17/binutils/../bfd -I /usr/src/gnu/usr.bin/binutils-2.17/binutils/../include -I /usr/src/gnu/usr.bin/binutils-2.17/binutils/../intl -I ../intl -D LOCALEDIR="/usr/share/locale" -D bin_dummy_emulation=bin_vanilla_emulation -D PIE_DEFAULT=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils-2.17/obj/binutils -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c
1/* wrstabs.c -- Output stabs debugging information
 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2006
 Free Software Foundation, Inc.
 Written by Ian Lance Taylor <ian@cygnus.com>.

 This file is part of GNU Binutils.

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
 02110-1301, USA.  */

23/* This file contains code which writes out stabs debugging
 information.  */

26#include <stdio.h>
27#include <assert.h>

29#include "bfd.h"
30#include "bucomm.h"
31#include "libiberty.h"
32#include "safe-ctype.h"
33#include "debug.h"
34#include "budbg.h"
35#include "aout/aout64.h"
36#include "aout/stab_gnu.h"

38/* The size of a stabs symbol.  This presumes 32 bit values.  */

40#define STAB_SYMBOL_SIZE(12) (12)

42/* An entry in a string hash table.  */

44struct string_hash_entry
45{
struct bfd_hash_entry root;
/* Next string in this table.  */
struct string_hash_entry *next;
/* Index in string table.  */
long index;
/* Size of type if this is a typedef.  */
unsigned int size;
53};

55/* A string hash table.  */

57struct string_hash_table
58{
struct bfd_hash_table table;
60};

62/* The type stack.  Each element on the stack is a string.  */

64struct stab_type_stack
65{
/* The next element on the stack.  */
struct stab_type_stack *next;
/* This element as a string.  */
char *string;
/* The type index of this element.  */
long index;
/* The size of the type.  */
unsigned int size;
/* Whether type string defines a new type.  */
bfd_boolean definition;
/* String defining struct fields.  */
char *fields;
/* NULL terminated array of strings defining base classes for a
   class.  */
char **baseclasses;
/* String defining class methods.  */
char *methods;
/* String defining vtable pointer for a class.  */
char *vtable;
85};

87/* This structure is used to keep track of type indices for tagged
 types.  */

90struct stab_tag
91{
/* The type index.  */
long index;
/* The tag name.  */
const char *tag;
/* The kind of type.  This is set to DEBUG_KIND_ILLEGAL when the
   type is defined.  */
enum debug_type_kind kind;
/* The size of the struct.  */
unsigned int size;
101};

103/* We remember various sorts of type indices.  They are not related,
 but, for convenience, we keep all the information in this
 structure.  */

107struct stab_type_cache
108{
/* The void type index.  */
long void_type;
/* Signed integer type indices, indexed by size - 1.  */
long signed_integer_types[8];
/* Unsigned integer type indices, indexed by size - 1.  */
long unsigned_integer_types[8];
/* Floating point types, indexed by size - 1.  */
long float_types[16];
/* Pointers to types, indexed by the type index.  */
long *pointer_types;
size_t pointer_types_alloc;
/* Functions returning types, indexed by the type index.  */
long *function_types;
size_t function_types_alloc;
/* References to types, indexed by the type index.  */
long *reference_types;
size_t reference_types_alloc;
/* Struct/union/class type indices, indexed by the struct id.  */
struct stab_tag *struct_types;
size_t struct_types_alloc;
129};

131/* This is the handle passed through debug_write.  */

133struct stab_write_handle
134{
/* The BFD.  */
bfd *abfd;
/* This buffer holds the symbols.  */
bfd_byte *symbols;
size_t symbols_size;
size_t symbols_alloc;
/* This is a list of hash table entries for the strings.  */
struct string_hash_entry *strings;
/* The last string hash table entry.  */
struct string_hash_entry *last_string;
/* The size of the strings.  */
size_t strings_size;
/* This hash table eliminates duplicate strings.  */
struct string_hash_table strhash;
/* The type stack.  */
struct stab_type_stack *type_stack;
/* The next type index.  */
long type_index;
/* The type cache.  */
struct stab_type_cache type_cache;
/* A mapping from typedef names to type indices.  */
struct string_hash_table typedef_hash;
/* If this is not -1, it is the offset to the most recent N_SO
   symbol, and the value of that symbol needs to be set.  */
long so_offset;
/* If this is not -1, it is the offset to the most recent N_FUN
   symbol, and the value of that symbol needs to be set.  */
long fun_offset;
/* The last text section address seen.  */
bfd_vma last_text_address;
/* The block nesting depth.  */
unsigned int nesting;
/* The function address.  */
bfd_vma fnaddr;
/* A pending LBRAC symbol.  */
bfd_vma pending_lbrac;
/* The current line number file name.  */
const char *lineno_filename;
173};

175static struct bfd_hash_entry *string_hash_newfunc
(struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
177static bfd_boolean stab_write_symbol
(struct stab_write_handle *, int, int, bfd_vma, const char *);
179static bfd_boolean stab_push_string
(struct stab_write_handle *, const char *, long, bfd_boolean, unsigned int);
181static bfd_boolean stab_push_defined_type
(struct stab_write_handle *, long, unsigned int);
183static char *stab_pop_type (struct stab_write_handle *);
184static bfd_boolean stab_modify_type
(struct stab_write_handle *, int, unsigned int, long **, size_t *);
186static long stab_get_struct_index
(struct stab_write_handle *, const char *, unsigned int,
 enum debug_type_kind, unsigned int *);
189static bfd_boolean stab_class_method_var
(struct stab_write_handle *, const char *, enum debug_visibility,
 bfd_boolean, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
192static bfd_boolean stab_start_compilation_unit (void *, const char *);
193static bfd_boolean stab_start_source (void *, const char *);
194static bfd_boolean stab_empty_type (void *);
195static bfd_boolean stab_void_type (void *);
196static bfd_boolean stab_int_type (void *, unsigned int, bfd_boolean);
197static bfd_boolean stab_float_type (void *, unsigned int);
198static bfd_boolean stab_complex_type (void *, unsigned int);
199static bfd_boolean stab_bool_type (void *, unsigned int);
200static bfd_boolean stab_enum_type
(void *, const char *, const char **, bfd_signed_vma *);
202static bfd_boolean stab_pointer_type (void *);
203static bfd_boolean stab_function_type (void *, int, bfd_boolean);
204static bfd_boolean stab_reference_type (void *);
205static bfd_boolean stab_range_type (void *, bfd_signed_vma, bfd_signed_vma);
206static bfd_boolean stab_array_type
(void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
208static bfd_boolean stab_set_type (void *, bfd_boolean);
209static bfd_boolean stab_offset_type (void *);
210static bfd_boolean stab_method_type (void *, bfd_boolean, int, bfd_boolean);
211static bfd_boolean stab_const_type (void *);
212static bfd_boolean stab_volatile_type (void *);
213static bfd_boolean stab_start_struct_type
(void *, const char *, unsigned int, bfd_boolean, unsigned int);
215static bfd_boolean stab_struct_field
(void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
217static bfd_boolean stab_end_struct_type (void *);
218static bfd_boolean stab_start_class_type
(void *, const char *, unsigned int, bfd_boolean, unsigned int,
 bfd_boolean, bfd_boolean);
221static bfd_boolean stab_class_static_member
(void *, const char *, const char *, enum debug_visibility);
223static bfd_boolean stab_class_baseclass
(void *, bfd_vma, bfd_boolean, enum debug_visibility);
225static bfd_boolean stab_class_start_method (void *, const char *);
226static bfd_boolean stab_class_method_variant
(void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
 bfd_vma, bfd_boolean);
229static bfd_boolean stab_class_static_method_variant
(void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
231static bfd_boolean stab_class_end_method (void *);
232static bfd_boolean stab_end_class_type (void *);
233static bfd_boolean stab_typedef_type (void *, const char *);
234static bfd_boolean stab_tag_type
(void *, const char *, unsigned int, enum debug_type_kind);
236static bfd_boolean stab_typdef (void *, const char *);
237static bfd_boolean stab_tag (void *, const char *);
238static bfd_boolean stab_int_constant (void *, const char *, bfd_vma);
239static bfd_boolean stab_float_constant (void *, const char *, double);
240static bfd_boolean stab_typed_constant (void *, const char *, bfd_vma);
241static bfd_boolean stab_variable
(void *, const char *, enum debug_var_kind, bfd_vma);
243static bfd_boolean stab_start_function (void *, const char *, bfd_boolean);
244static bfd_boolean stab_function_parameter
(void *, const char *, enum debug_parm_kind, bfd_vma);
246static bfd_boolean stab_start_block (void *, bfd_vma);
247static bfd_boolean stab_end_block (void *, bfd_vma);
248static bfd_boolean stab_end_function (void *);
249static bfd_boolean stab_lineno (void *, const char *, unsigned long, bfd_vma);

251static const struct debug_write_fns stab_fns =
252{
stab_start_compilation_unit,
stab_start_source,
stab_empty_type,
stab_void_type,
stab_int_type,
stab_float_type,
stab_complex_type,
stab_bool_type,
stab_enum_type,
stab_pointer_type,
stab_function_type,
stab_reference_type,
stab_range_type,
stab_array_type,
stab_set_type,
stab_offset_type,
stab_method_type,
stab_const_type,
stab_volatile_type,
stab_start_struct_type,
stab_struct_field,
stab_end_struct_type,
stab_start_class_type,
stab_class_static_member,
stab_class_baseclass,
stab_class_start_method,
stab_class_method_variant,
stab_class_static_method_variant,
stab_class_end_method,
stab_end_class_type,
stab_typedef_type,
stab_tag_type,
stab_typdef,
stab_tag,
stab_int_constant,
stab_float_constant,
stab_typed_constant,
stab_variable,
stab_start_function,
stab_function_parameter,
stab_start_block,
stab_end_block,
stab_end_function,
stab_lineno
297};
298
299/* Routine to create an entry in a string hash table.  */

301static struct bfd_hash_entry *
302string_hash_newfunc (struct bfd_hash_entry *entry,
     struct bfd_hash_table *table, const char *string)
304{
struct string_hash_entry *ret = (struct string_hash_entry *) entry;

/* Allocate the structure if it has not already been allocated by a
   subclass.  */
if (ret == (struct string_hash_entry *) NULL((void*)0))
  ret = ((struct string_hash_entry *)
  bfd_hash_allocate (table, sizeof (struct string_hash_entry)));
if (ret == (struct string_hash_entry *) NULL((void*)0))
  return NULL((void*)0);

/* Call the allocation method of the superclass.  */
ret = ((struct string_hash_entry *)
bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));

if (ret)
  {
    /* Initialize the local fields.  */
    ret->next = NULL((void*)0);
    ret->index = -1;
    ret->size = 0;
  }

return (struct bfd_hash_entry *) ret;
328}

330/* Look up an entry in a string hash table.  */

332#define string_hash_lookup(t, string, create, copy)((struct string_hash_entry *) bfd_hash_lookup (&(t)->table
, (string), (create), (copy))) \
((struct string_hash_entry *) \
 bfd_hash_lookup (&(t)->table, (string), (create), (copy)))

336/* Add a symbol to the stabs debugging information we are building.  */

338static bfd_boolean
339stab_write_symbol (struct stab_write_handle *info, int type, int desc,
   bfd_vma value, const char *string)
341{
bfd_size_type strx;
bfd_byte sym[STAB_SYMBOL_SIZE(12)];

if (string == NULL((void*)0))
  strx = 0;
else
  {
    struct string_hash_entry *h;

    h = string_hash_lookup (&info->strhash, string, TRUE, TRUE)((struct string_hash_entry *) bfd_hash_lookup (&(&info
->strhash)->table, (string), (1), (1)));
    if (h == NULL((void*)0))
{
 non_fatal (_("string_hash_lookup failed: %s")("string_hash_lookup failed: %s"),
     bfd_errmsg (bfd_get_error ()));
 return FALSE0;
}
    if (h->index != -1)
strx = h->index;
    else
{
 strx = info->strings_size;
 h->index = strx;
 if (info->last_string == NULL((void*)0))
   info->strings = h;
 else
   info->last_string->next = h;
 info->last_string = h;
 info->strings_size += strlen (string) + 1;
}
  }

/* This presumes 32 bit values.  */
bfd_put_32 (info->abfd, strx, sym)((*((info->abfd)->xvec->bfd_putx32)) ((strx),(sym)));
bfd_put_8 (info->abfd, type, sym + 4)((void) (*((unsigned char *) (sym + 4)) = (type) & 0xff));
bfd_put_8 (info->abfd, 0, sym + 5)((void) (*((unsigned char *) (sym + 5)) = (0) & 0xff));
bfd_put_16 (info->abfd, desc, sym + 6)((*((info->abfd)->xvec->bfd_putx16)) ((desc),(sym + 6
)));
bfd_put_32 (info->abfd, value, sym + 8)((*((info->abfd)->xvec->bfd_putx32)) ((value),(sym +
 8)));

if (info->symbols_size + STAB_SYMBOL_SIZE(12) > info->symbols_alloc)
  {
    info->symbols_alloc *= 2;
    info->symbols = (bfd_byte *) xrealloc (info->symbols,
			     info->symbols_alloc);
  }

memcpy (info->symbols + info->symbols_size, sym, STAB_SYMBOL_SIZE(12));

info->symbols_size += STAB_SYMBOL_SIZE(12);

return TRUE1;
392}

394/* Push a string on to the type stack.  */

396static bfd_boolean
397stab_push_string (struct stab_write_handle *info, const char *string,
  long index, bfd_boolean definition, unsigned int size)
399{
struct stab_type_stack *s;

s = (struct stab_type_stack *) xmalloc (sizeof *s);
s->string = xstrdup (string);
s->index = index;
s->definition = definition;
s->size = size;

s->fields = NULL((void*)0);
s->baseclasses = NULL((void*)0);
s->methods = NULL((void*)0);
s->vtable = NULL((void*)0);

s->next = info->type_stack;
info->type_stack = s;

return TRUE1;
417}

419/* Push a type index which has already been defined.  */

421static bfd_boolean
422stab_push_defined_type (struct stab_write_handle *info, long index,
	unsigned int size)
424{
char buf[20];

sprintf (buf, "%ld", index);
return stab_push_string (info, buf, index, FALSE0, size);
429}

431/* Pop a type off the type stack.  The caller is responsible for
 freeing the string.  */

434static char *
435stab_pop_type (struct stab_write_handle *info)
436{
struct stab_type_stack *s;
char *ret;

s = info->type_stack;
assert (s != NULL)((s != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c"
, 441, __func__, "s != NULL"));

info->type_stack = s->next;

ret = s->string;

free (s);

return ret;
450}
451
452/* The general routine to write out stabs in sections debugging
 information.  This accumulates the stabs symbols and the strings in
 two obstacks.  We can't easily write out the information as we go
 along, because we need to know the section sizes before we can
 write out the section contents.  ABFD is the BFD and DHANDLE is the
 handle for the debugging information.  This sets *PSYMS to point to
 the symbols, *PSYMSIZE the size of the symbols, *PSTRINGS to the
 strings, and *PSTRINGSIZE to the size of the strings.  */

461bfd_boolean
462write_stabs_in_sections_debugging_info (bfd *abfd, void *dhandle,
			bfd_byte **psyms,
			bfd_size_type *psymsize,
			bfd_byte **pstrings,
			bfd_size_type *pstringsize)
467{
struct stab_write_handle info;
struct string_hash_entry *h;
bfd_byte *p;

info.abfd = abfd;

info.symbols_size = 0;
info.symbols_alloc = 500;
info.symbols = (bfd_byte *) xmalloc (info.symbols_alloc);

info.strings = NULL((void*)0);
info.last_string = NULL((void*)0);
/* Reserve 1 byte for a null byte.  */
info.strings_size = 1;

if (!bfd_hash_table_init (&info.strhash.table, string_hash_newfunc,
	    sizeof (struct string_hash_entry))
    || !bfd_hash_table_init (&info.typedef_hash.table, string_hash_newfunc,
	       sizeof (struct string_hash_entry)))
  {
    non_fatal ("bfd_hash_table_init_failed: %s",
 bfd_errmsg (bfd_get_error ()));
    return FALSE0;
  }

info.type_stack = NULL((void*)0);
info.type_index = 1;
memset (&info.type_cache, 0, sizeof info.type_cache);
info.so_offset = -1;
info.fun_offset = -1;
info.last_text_address = 0;
info.nesting = 0;
info.fnaddr = 0;
info.pending_lbrac = (bfd_vma) -1;

/* The initial symbol holds the string size.  */
if (! stab_write_symbol (&info, 0, 0, 0, (const char *) NULL((void*)0)))
  return FALSE0;

/* Output an initial N_SO symbol.  */
info.so_offset = info.symbols_size;
if (! stab_write_symbol (&info, N_SO, 0, 0, bfd_get_filename (abfd)((char *) (abfd)->filename)))
  return FALSE0;

if (! debug_write (dhandle, &stab_fns, (void *) &info))
  return FALSE0;

assert (info.pending_lbrac == (bfd_vma) -1)((info.pending_lbrac == (bfd_vma) -1) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c"
, 515, __func__, "info.pending_lbrac == (bfd_vma) -1"));

/* Output a trailing N_SO.  */
if (! stab_write_symbol (&info, N_SO, 0, info.last_text_address,
	   (const char *) NULL((void*)0)))
  return FALSE0;

/* Put the string size in the initial symbol.  */
bfd_put_32 (abfd, info.strings_size, info.symbols + 8)((*((abfd)->xvec->bfd_putx32)) ((info.strings_size),(info
.symbols + 8)));

*psyms = info.symbols;
*psymsize = info.symbols_size;

*pstringsize = info.strings_size;
*pstrings = (bfd_byte *) xmalloc (info.strings_size);

p = *pstrings;
*p++ = '\0';
for (h = info.strings; h != NULL((void*)0); h = h->next)
  {
    strcpy ((char *) p, h->root.string);
    p += strlen ((char *) p) + 1;
  }

return TRUE1;
540}

542/* Start writing out information for a compilation unit.  */

544static bfd_boolean
545stab_start_compilation_unit (void *p, const char *filename)
546{
struct stab_write_handle *info = (struct stab_write_handle *) p;

/* We would normally output an N_SO symbol here.  However, that
   would force us to reset all of our type information.  I think we
   will be better off just outputting an N_SOL symbol, and not
   worrying about splitting information between files.  */

info->lineno_filename = filename;

return stab_write_symbol (info, N_SOL, 0, 0, filename);
557}

559/* Start writing out information for a particular source file.  */

561static bfd_boolean
562stab_start_source (void *p, const char *filename)
563{
struct stab_write_handle *info = (struct stab_write_handle *) p;

/* FIXME: The symbol's value is supposed to be the text section
   address.  However, we would have to fill it in later, and gdb
   doesn't care, so we don't bother with it.  */

info->lineno_filename = filename;

return stab_write_symbol (info, N_SOL, 0, 0, filename);
573}

575/* Push an empty type.  This shouldn't normally happen.  We just use a
 void type.  */

578static bfd_boolean
579stab_empty_type (void *p)
580{
struct stab_write_handle *info = (struct stab_write_handle *) p;

/* We don't call stab_void_type if the type is not yet defined,
   because that might screw up the typedef.  */

if (info->type_cache.void_type != 0)
  return stab_push_defined_type (info, info->type_cache.void_type, 0);
else
  {
    long index;
    char buf[40];

    index = info->type_index;
    ++info->type_index;

    sprintf (buf, "%ld=%ld", index, index);

    return stab_push_string (info, buf, index, FALSE0, 0);
  }
600}

602/* Push a void type.  */

604static bfd_boolean
605stab_void_type (void *p)
606{
struct stab_write_handle *info = (struct stab_write_handle *) p;

if (info->type_cache.void_type != 0)
  return stab_push_defined_type (info, info->type_cache.void_type, 0);
else
  {
    long index;
    char buf[40];

    index = info->type_index;
    ++info->type_index;

    info->type_cache.void_type = index;

    sprintf (buf, "%ld=%ld", index, index);

    return stab_push_string (info, buf, index, TRUE1, 0);
  }
625}

627/* Push an integer type.  */

629static bfd_boolean
630stab_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
631{
struct stab_write_handle *info = (struct stab_write_handle *) p;
long *cache;

if (size <= 0 || (size > sizeof (long) && size != 8))
  {
    non_fatal (_("stab_int_type: bad size %u")("stab_int_type: bad size %u"), size);
    return FALSE0;
  }

if (unsignedp)
  cache = info->type_cache.signed_integer_types;
else
  cache = info->type_cache.unsigned_integer_types;

if (cache[size - 1] != 0)
  return stab_push_defined_type (info, cache[size - 1], size);
else
  {
    long index;
    char buf[100];

    index = info->type_index;
    ++info->type_index;

    cache[size - 1] = index;

    sprintf (buf, "%ld=r%ld;", index, index);
    if (unsignedp)
{
 strcat (buf, "0;");
 if (size < sizeof (long))
   sprintf (buf + strlen (buf), "%ld;", ((long) 1 << (size * 8)) - 1);
 else if (size == sizeof (long))
   strcat (buf, "-1;");
 else if (size == 8)
   strcat (buf, "01777777777777777777777;");
 else
   abort ();
}
    else
{
 if (size <= sizeof (long))
   sprintf (buf + strlen (buf), "%ld;%ld;",
     (long) - ((unsigned long) 1 << (size * 8 - 1)),
     (long) (((unsigned long) 1 << (size * 8 - 1)) - 1));
 else if (size == 8)
   strcat (buf, "01000000000000000000000;0777777777777777777777;");
 else
   abort ();
}

    return stab_push_string (info, buf, index, TRUE1, size);
  }
685}

687/* Push a floating point type.  */

689static bfd_boolean
690stab_float_type (void *p, unsigned int size)
691{
struct stab_write_handle *info = (struct stab_write_handle *) p;

if (size > 0
    && size - 1 < (sizeof info->type_cache.float_types
     / sizeof info->type_cache.float_types[0])
    && info->type_cache.float_types[size - 1] != 0)
  return stab_push_defined_type (info,
		   info->type_cache.float_types[size - 1],
		   size);
else
  {
    long index;
    char *int_type;
    char buf[50];

    /* Floats are defined as a subrange of int.  */
    if (! stab_int_type (info, 4, FALSE0))
return FALSE0;
    int_type = stab_pop_type (info);

    index = info->type_index;
    ++info->type_index;

    if (size > 0
 && size - 1 < (sizeof info->type_cache.float_types
	 / sizeof info->type_cache.float_types[0]))
info->type_cache.float_types[size - 1] = index;

    sprintf (buf, "%ld=r%s;%u;0;", index, int_type, size);

    free (int_type);

    return stab_push_string (info, buf, index, TRUE1, size);
  }
726}

728/* Push a complex type.  */

730static bfd_boolean
731stab_complex_type (void *p, unsigned int size)
732{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char buf[50];
long index;

index = info->type_index;
++info->type_index;

sprintf (buf, "%ld=r%ld;%u;0;", index, index, size);

return stab_push_string (info, buf, index, TRUE1, size * 2);
743}

745/* Push a bfd_boolean type.  We use an XCOFF predefined type, since gdb
 always recognizes them.  */

748static bfd_boolean
749stab_bool_type (void *p, unsigned int size)
750{
struct stab_write_handle *info = (struct stab_write_handle *) p;
long index;

switch (size)
  {
  case 1:
    index = -21;
    break;

  case 2:
    index = -22;
    break;

  default:
  case 4:
    index = -16;
    break;

  case 8:
    index = -33;
    break;
  }

return stab_push_defined_type (info, index, size);
775}

777/* Push an enum type.  */

779static bfd_boolean
780stab_enum_type (void *p, const char *tag, const char **names,
bfd_signed_vma *vals)
782{
struct stab_write_handle *info = (struct stab_write_handle *) p;
size_t len;
const char **pn;
char *buf;
long index = 0;
bfd_signed_vma *pv;

if (names == NULL((void*)0))
  {
    assert (tag != NULL)((tag != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c"
, 792, __func__, "tag != NULL"));

    buf = (char *) xmalloc (10 + strlen (tag));
    sprintf (buf, "xe%s:", tag);
    /* FIXME: The size is just a guess.  */
    if (! stab_push_string (info, buf, 0, FALSE0, 4))
return FALSE0;
    free (buf);
    return TRUE1;
  }

len = 10;
if (tag != NULL((void*)0))
  len += strlen (tag);
for (pn = names; *pn != NULL((void*)0); pn++)
  len += strlen (*pn) + 20;

buf = (char *) xmalloc (len);

if (tag == NULL((void*)0))
  strcpy (buf, "e");
else
  {
    index = info->type_index;
    ++info->type_index;
    sprintf (buf, "%s:T%ld=e", tag, index);
  }

for (pn = names, pv = vals; *pn != NULL((void*)0); pn++, pv++)
  sprintf (buf + strlen (buf), "%s:%ld,", *pn, (long) *pv);
strcat (buf, ";");

if (tag == NULL((void*)0))
  {
    /* FIXME: The size is just a guess.  */
    if (! stab_push_string (info, buf, 0, FALSE0, 4))
return FALSE0;
  }
else
  {
    /* FIXME: The size is just a guess.  */
    if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)
 || ! stab_push_defined_type (info, index, 4))
return FALSE0;
  }

free (buf);

return TRUE1;
841}

843/* Push a modification of the top type on the stack.  Cache the
 results in CACHE and CACHE_ALLOC.  */

846static bfd_boolean
847stab_modify_type (struct stab_write_handle *info, int mod,
  unsigned int size, long **cache, size_t *cache_alloc)
849{
long targindex;
long index;
char *s, *buf;

assert (info->type_stack != NULL)((info->type_stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c"
, 854, __func__, "info->type_stack != NULL"));
targindex = info->type_stack->index;

if (targindex <= 0
    || cache == NULL((void*)0))
  {
    bfd_boolean definition;

    /* Either the target type has no index, or we aren't caching
       this modifier.  Either way we have no way of recording the
       new type, so we don't bother to define one.  */
    definition = info->type_stack->definition;
    s = stab_pop_type (info);
    buf = (char *) xmalloc (strlen (s) + 2);
    sprintf (buf, "%c%s", mod, s);
    free (s);
    if (! stab_push_string (info, buf, 0, definition, size))
return FALSE0;
    free (buf);
  }
else
  {
    if ((size_t) targindex >= *cache_alloc)
{
 size_t alloc;

 alloc = *cache_alloc;
 if (alloc == 0)
   alloc = 10;
 while ((size_t) targindex >= alloc)
   alloc *= 2;
 *cache = (long *) xrealloc (*cache, alloc * sizeof (long));
 memset (*cache + *cache_alloc, 0,
  (alloc - *cache_alloc) * sizeof (long));
 *cache_alloc = alloc;
}

    index = (*cache)[targindex];
    if (index != 0 && ! info->type_stack->definition)
{
 /* We have already defined a modification of this type, and
           the entry on the type stack is not a definition, so we
           can safely discard it (we may have a definition on the
           stack, even if we already defined a modification, if it
           is a struct which we did not define at the time it was
           referenced).  */
 free (stab_pop_type (info));
 if (! stab_push_defined_type (info, index, size))
   return FALSE0;
}
    else
{
 index = info->type_index;
 ++info->type_index;

 s = stab_pop_type (info);
 buf = (char *) xmalloc (strlen (s) + 20);
 sprintf (buf, "%ld=%c%s", index, mod, s);
 free (s);

 (*cache)[targindex] = index;

 if (! stab_push_string (info, buf, index, TRUE1, size))
   return FALSE0;

 free (buf);
}
  }

return TRUE1;
924}

926/* Push a pointer type.  */

928static bfd_boolean
929stab_pointer_type (void *p)
930{
struct stab_write_handle *info = (struct stab_write_handle *) p;

/* FIXME: The size should depend upon the architecture.  */
return stab_modify_type (info, '*', 4, &info->type_cache.pointer_types,
	   &info->type_cache.pointer_types_alloc);
936}

938/* Push a function type.  */

940static bfd_boolean
941stab_function_type (void *p, int argcount,
    bfd_boolean varargs ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
943{
struct stab_write_handle *info = (struct stab_write_handle *) p;
int i;

/* We have no way to represent the argument types, so we just
   discard them.  However, if they define new types, we must output
   them.  We do this by producing empty typedefs.  */
for (i = 0; i < argcount; i++)
  {
    if (! info->type_stack->definition)
free (stab_pop_type (info));
    else
{
 char *s, *buf;

 s = stab_pop_type (info);

 buf = (char *) xmalloc (strlen (s) + 3);
 sprintf (buf, ":t%s", s);
 free (s);

 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
   return FALSE0;

 free (buf);
}
  }

return stab_modify_type (info, 'f', 0, &info->type_cache.function_types,
	   &info->type_cache.function_types_alloc);
973}

975/* Push a reference type.  */

977static bfd_boolean
978stab_reference_type (void *p)
979{
struct stab_write_handle *info = (struct stab_write_handle *) p;

/* FIXME: The size should depend upon the architecture.  */
return stab_modify_type (info, '&', 4, &info->type_cache.reference_types,
	   &info->type_cache.reference_types_alloc);
985}

987/* Push a range type.  */

989static bfd_boolean
990stab_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high)
991{
struct stab_write_handle *info = (struct stab_write_handle *) p;
bfd_boolean definition;
unsigned int size;
char *s, *buf;

definition = info->type_stack->definition;
size = info->type_stack->size;

s = stab_pop_type (info);
buf = (char *) xmalloc (strlen (s) + 100);
sprintf (buf, "r%s;%ld;%ld;", s, (long) low, (long) high);
free (s);

if (! stab_push_string (info, buf, 0, definition, size))
  return FALSE0;

free (buf);

return TRUE1;
1011}

1013/* Push an array type.  */

1015static bfd_boolean
1016stab_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high,
 bfd_boolean stringp)
1018{
struct stab_write_handle *info = (struct stab_write_handle *) p;
bfd_boolean definition;
unsigned int element_size;
char *range, *element, *buf;
long index;
unsigned int size;

definition = info->type_stack->definition;
range = stab_pop_type (info);

definition = definition || info->type_stack->definition;
element_size = info->type_stack->size;
element = stab_pop_type (info);

buf = (char *) xmalloc (strlen (range) + strlen (element) + 100);

if (! stringp)
  {
    index = 0;
    *buf = '\0';
  }
else
  {
    /* We need to define a type in order to include the string
       attribute.  */
    index = info->type_index;
    ++info->type_index;
    definition = TRUE1;
    sprintf (buf, "%ld=@S;", index);
  }

sprintf (buf + strlen (buf), "ar%s;%ld;%ld;%s",
  range, (long) low, (long) high, element);
free (range);
free (element);

if (high < low)
  size = 0;
else
  size = element_size * ((high - low) + 1);
if (! stab_push_string (info, buf, index, definition, size))
  return FALSE0;

free (buf);

return TRUE1;
1065}

1067/* Push a set type.  */

1069static bfd_boolean
1070stab_set_type (void *p, bfd_boolean bitstringp)
1071{
struct stab_write_handle *info = (struct stab_write_handle *) p;
bfd_boolean definition;
char *s, *buf;
long index;

definition = info->type_stack->definition;

s = stab_pop_type (info);
buf = (char *) xmalloc (strlen (s) + 30);

if (! bitstringp)
  {
    *buf = '\0';
    index = 0;
  }
else
  {
    /* We need to define a type in order to include the string
       attribute.  */
    index = info->type_index;
    ++info->type_index;
    definition = TRUE1;
    sprintf (buf, "%ld=@S;", index);
  }

sprintf (buf + strlen (buf), "S%s", s);
free (s);

if (! stab_push_string (info, buf, index, definition, 0))
  return FALSE0;

free (buf);

return TRUE1;
1106}

1108/* Push an offset type.  */

1110static bfd_boolean
1111stab_offset_type (void *p)
1112{
struct stab_write_handle *info = (struct stab_write_handle *) p;
bfd_boolean definition;
char *target, *base, *buf;

definition = info->type_stack->definition;
target = stab_pop_type (info);

definition = definition || info->type_stack->definition;
base = stab_pop_type (info);

buf = (char *) xmalloc (strlen (target) + strlen (base) + 3);
sprintf (buf, "@%s,%s", base, target);
free (base);
free (target);

if (! stab_push_string (info, buf, 0, definition, 0))
  return FALSE0;

free (buf);

return TRUE1;
1134}

1136/* Push a method type.  */

1138static bfd_boolean
1139stab_method_type (void *p, bfd_boolean domainp, int argcount,
  bfd_boolean varargs)
1141{
struct stab_write_handle *info = (struct stab_write_handle *) p;
bfd_boolean definition;
char *domain, *return_type, *buf;
char **args;
int i;
size_t len;

/* We don't bother with stub method types, because that would
   require a mangler for C++ argument types.  This will waste space
   in the debugging output.  */

/* We need a domain.  I'm not sure DOMAINP can ever be false,
   anyhow.  */
if (! domainp)
  {
    if (! stab_empty_type (p))
return FALSE0;
  }

definition = info->type_stack->definition;
domain = stab_pop_type (info);

/* A non-varargs function is indicated by making the last parameter
   type be void.  */

if (argcount < 0)
  {
    args = NULL((void*)0);
    argcount = 0;
  }
else if (argcount == 0)
  {
    if (varargs)
args = NULL((void*)0);
    else
{
 args = (char **) xmalloc (1 * sizeof (*args));
 if (! stab_empty_type (p))
   return FALSE0;
 definition = definition || info->type_stack->definition;
 args[0] = stab_pop_type (info);
 argcount = 1;
}
  }
else
  {
    args = (char **) xmalloc ((argcount + 1) * sizeof (*args));
    for (i = argcount - 1; i >= 0; i--)
{
 definition = definition || info->type_stack->definition;
 args[i] = stab_pop_type (info);
}
    if (! varargs)
{
 if (! stab_empty_type (p))
   return FALSE0;
 definition = definition || info->type_stack->definition;
 args[argcount] = stab_pop_type (info);
 ++argcount;
}
  }

definition = definition || info->type_stack->definition;
return_type = stab_pop_type (info);

len = strlen (domain) + strlen (return_type) + 10;
for (i = 0; i < argcount; i++)
  len += strlen (args[i]);

buf = (char *) xmalloc (len);

sprintf (buf, "#%s,%s", domain, return_type);
free (domain);
free (return_type);
for (i = 0; i < argcount; i++)
  {
    strcat (buf, ",");
    strcat (buf, args[i]);
    free (args[i]);
  }
strcat (buf, ";");

if (args != NULL((void*)0))
  free (args);

if (! stab_push_string (info, buf, 0, definition, 0))
  return FALSE0;

free (buf);

return TRUE1;
1233}

1235/* Push a const version of a type.  */

1237static bfd_boolean
1238stab_const_type (void *p)
1239{
struct stab_write_handle *info = (struct stab_write_handle *) p;

return stab_modify_type (info, 'k', info->type_stack->size,
	   (long **) NULL((void*)0), (size_t *) NULL((void*)0));
1244}

1246/* Push a volatile version of a type.  */

1248static bfd_boolean
1249stab_volatile_type (void *p)
1250{
struct stab_write_handle *info = (struct stab_write_handle *) p;

return stab_modify_type (info, 'B', info->type_stack->size,
	   (long **) NULL((void*)0), (size_t *) NULL((void*)0));
1255}

1257/* Get the type index to use for a struct/union/class ID.  This should
 return -1 if it fails.  */

1260static long
1261stab_get_struct_index (struct stab_write_handle *info, const char *tag,
       unsigned int id, enum debug_type_kind kind,
       unsigned int *psize)
1264{
if (id >= info->type_cache.struct_types_alloc)
3
←
Assuming 'id' is < field 'struct_types_alloc'→
4
←
Taking false branch→
  {
    size_t alloc;

    alloc = info->type_cache.struct_types_alloc;
    if (alloc == 0)
alloc = 10;
    while (id >= alloc)
alloc *= 2;
    info->type_cache.struct_types =
(struct stab_tag *) xrealloc (info->type_cache.struct_types,
		      alloc * sizeof (struct stab_tag));
    memset ((info->type_cache.struct_types
      + info->type_cache.struct_types_alloc),
     0,
     ((alloc - info->type_cache.struct_types_alloc)
      * sizeof (struct stab_tag)));
    info->type_cache.struct_types_alloc = alloc;
  }

if (info->type_cache.struct_types[id].index == 0)
5
←
Assuming field 'index' is not equal to 0→
6
←
Taking false branch→
  {
    info->type_cache.struct_types[id].index = info->type_index;
    ++info->type_index;
    info->type_cache.struct_types[id].tag = tag;
    info->type_cache.struct_types[id].kind = kind;
  }

if (kind == DEBUG_KIND_ILLEGAL)
7
←
Assuming 'kind' is equal to DEBUG_KIND_ILLEGAL→
8
←
Taking true branch→
  {
    /* This is a definition of the struct.  */
    info->type_cache.struct_types[id].kind = kind;
    info->type_cache.struct_types[id].size = *psize;
9
←
Assigned value is garbage or undefined
  }
else
  *psize = info->type_cache.struct_types[id].size;

return info->type_cache.struct_types[id].index;
1303}

1305/* Start outputting a struct.  We ignore the tag, and handle it in
 stab_tag.  */

1308static bfd_boolean
1309stab_start_struct_type (void *p, const char *tag, unsigned int id,
	bfd_boolean structp, unsigned int size)
1311{
struct stab_write_handle *info = (struct stab_write_handle *) p;
long index;
bfd_boolean definition;
char *buf;

buf = (char *) xmalloc (40);

if (id == 0)
  {
    index = 0;
    *buf = '\0';
    definition = FALSE0;
  }
else
  {
    index = stab_get_struct_index (info, tag, id, DEBUG_KIND_ILLEGAL,
		     &size);
    if (index < 0)
return FALSE0;
    sprintf (buf, "%ld=", index);
    definition = TRUE1;
  }

sprintf (buf + strlen (buf), "%c%u",
  structp ? 's' : 'u',
  size);

if (! stab_push_string (info, buf, index, definition, size))
  return FALSE0;

info->type_stack->fields = (char *) xmalloc (1);
info->type_stack->fields[0] = '\0';

return TRUE1;
1346}

1348/* Add a field to a struct.  */

1350static bfd_boolean
1351stab_struct_field (void *p, const char *name, bfd_vma bitpos,
   bfd_vma bitsize, enum debug_visibility visibility)
1353{
struct stab_write_handle *info = (struct stab_write_handle *) p;
bfd_boolean definition;
unsigned int size;
char *s, *n;
const char *vis;

definition = info->type_stack->definition;
size = info->type_stack->size;
s = stab_pop_type (info);

/* Add this field to the end of the current struct fields, which is
   currently on the top of the stack.  */

assert (info->type_stack->fields != NULL)((info->type_stack->fields != ((void*)0)) ? (void)0 : __assert2
("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c", 1367
, __func__, "info->type_stack->fields != NULL"));
n = (char *) xmalloc (strlen (info->type_stack->fields)
	+ strlen (name)
	+ strlen (s)
	+ 50);

switch (visibility)
  {
  default:
    abort ();

  case DEBUG_VISIBILITY_PUBLIC:
    vis = "";
    break;

  case DEBUG_VISIBILITY_PRIVATE:
    vis = "/0";
    break;

  case DEBUG_VISIBILITY_PROTECTED:
    vis = "/1";
    break;
  }

if (bitsize == 0)
  {
    bitsize = size * 8;
    if (bitsize == 0)
non_fatal (_("%s: warning: unknown size for field `%s' in struct")("%s: warning: unknown size for field `%s' in struct"),
   bfd_get_filename (info->abfd)((char *) (info->abfd)->filename), name);
  }

sprintf (n, "%s%s:%s%s,%ld,%ld;", info->type_stack->fields, name, vis, s,
  (long) bitpos, (long) bitsize);

free (info->type_stack->fields);
info->type_stack->fields = n;

if (definition)
  info->type_stack->definition = TRUE1;

return TRUE1;
1409}

1411/* Finish up a struct.  */

1413static bfd_boolean
1414stab_end_struct_type (void *p)
1415{
struct stab_write_handle *info = (struct stab_write_handle *) p;
bfd_boolean definition;
long index;
unsigned int size;
char *fields, *first, *buf;

assert (info->type_stack != NULL && info->type_stack->fields != NULL)((info->type_stack != ((void*)0) && info->type_stack
->fields != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c"
, 1422, __func__, "info->type_stack != NULL && info->type_stack->fields != NULL"
));

definition = info->type_stack->definition;
index = info->type_stack->index;
size = info->type_stack->size;
fields = info->type_stack->fields;
first = stab_pop_type (info);

buf = (char *) xmalloc (strlen (first) + strlen (fields) + 2);
sprintf (buf, "%s%s;", first, fields);
free (first);
free (fields);

if (! stab_push_string (info, buf, index, definition, size))
  return FALSE0;

free (buf);

return TRUE1;
1441}

1443/* Start outputting a class.  */

1445static bfd_boolean
1446stab_start_class_type (void *p, const char *tag, unsigned int id, bfd_boolean structp, unsigned int size, bfd_boolean vptr, bfd_boolean ownvptr)
1447{
struct stab_write_handle *info = (struct stab_write_handle *) p;
bfd_boolean definition;
char *vstring;

if (! vptr || ownvptr)
  {
    definition = FALSE0;
    vstring = NULL((void*)0);
  }
else
  {
    definition = info->type_stack->definition;
    vstring = stab_pop_type (info);
  }

if (! stab_start_struct_type (p, tag, id, structp, size))
  return FALSE0;

if (vptr)
  {
    char *vtable;

    if (ownvptr)
{
 assert (info->type_stack->index > 0)((info->type_stack->index > 0) ? (void)0 : __assert2
("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c", 1472
, __func__, "info->type_stack->index > 0"));
 vtable = (char *) xmalloc (20);
 sprintf (vtable, "~%%%ld", info->type_stack->index);
}
    else
{
 vtable = (char *) xmalloc (strlen (vstring) + 3);
 sprintf (vtable, "~%%%s", vstring);
 free (vstring);
}

    info->type_stack->vtable = vtable;
  }

if (definition)
  info->type_stack->definition = TRUE1;

return TRUE1;
1490}

1492/* Add a static member to the class on the type stack.  */

1494static bfd_boolean
1495stab_class_static_member (void *p, const char *name, const char *physname,
	  enum debug_visibility visibility)
1497{
struct stab_write_handle *info = (struct stab_write_handle *) p;
bfd_boolean definition;
char *s, *n;
const char *vis;

definition = info->type_stack->definition;
s = stab_pop_type (info);

/* Add this field to the end of the current struct fields, which is
   currently on the top of the stack.  */

assert (info->type_stack->fields != NULL)((info->type_stack->fields != ((void*)0)) ? (void)0 : __assert2
("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c", 1509
, __func__, "info->type_stack->fields != NULL"));
n = (char *) xmalloc (strlen (info->type_stack->fields)
	+ strlen (name)
	+ strlen (s)
	+ strlen (physname)
	+ 10);

switch (visibility)
  {
  default:
    abort ();

  case DEBUG_VISIBILITY_PUBLIC:
    vis = "";
    break;

  case DEBUG_VISIBILITY_PRIVATE:
    vis = "/0";
    break;

  case DEBUG_VISIBILITY_PROTECTED:
    vis = "/1";
    break;
  }

sprintf (n, "%s%s:%s%s:%s;", info->type_stack->fields, name, vis, s,
  physname);

free (info->type_stack->fields);
info->type_stack->fields = n;

if (definition)
  info->type_stack->definition = TRUE1;

return TRUE1;
1544}

1546/* Add a base class to the class on the type stack.  */

1548static bfd_boolean
1549stab_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean virtual,
      enum debug_visibility visibility)
1551{
struct stab_write_handle *info = (struct stab_write_handle *) p;
bfd_boolean definition;
char *s;
char *buf;
unsigned int c;
char **baseclasses;

definition = info->type_stack->definition;
s = stab_pop_type (info);

/* Build the base class specifier.  */

buf = (char *) xmalloc (strlen (s) + 25);
buf[0] = virtual ? '1' : '0';
switch (visibility)
  {
  default:
    abort ();

  case DEBUG_VISIBILITY_PRIVATE:
    buf[1] = '0';
    break;

  case DEBUG_VISIBILITY_PROTECTED:
    buf[1] = '1';
    break;

  case DEBUG_VISIBILITY_PUBLIC:
    buf[1] = '2';
    break;
  }

sprintf (buf + 2, "%ld,%s;", (long) bitpos, s);
free (s);

/* Add the new baseclass to the existing ones.  */

assert (info->type_stack != NULL && info->type_stack->fields != NULL)((info->type_stack != ((void*)0) && info->type_stack
->fields != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c"
, 1589, __func__, "info->type_stack != NULL && info->type_stack->fields != NULL"
));

if (info->type_stack->baseclasses == NULL((void*)0))
  c = 0;
else
  {
    c = 0;
    while (info->type_stack->baseclasses[c] != NULL((void*)0))
++c;
  }

baseclasses = (char **) xrealloc (info->type_stack->baseclasses,
		    (c + 2) * sizeof (*baseclasses));
baseclasses[c] = buf;
baseclasses[c + 1] = NULL((void*)0);

info->type_stack->baseclasses = baseclasses;

if (definition)
  info->type_stack->definition = TRUE1;

return TRUE1;
1611}

1613/* Start adding a method to the class on the type stack.  */

1615static bfd_boolean
1616stab_class_start_method (void *p, const char *name)
1617{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *m;

assert (info->type_stack != NULL && info->type_stack->fields != NULL)((info->type_stack != ((void*)0) && info->type_stack
->fields != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c"
, 1621, __func__, "info->type_stack != NULL && info->type_stack->fields != NULL"
));

if (info->type_stack->methods == NULL((void*)0))
  {
    m = (char *) xmalloc (strlen (name) + 3);
    *m = '\0';
  }
else
  {
    m = (char *) xrealloc (info->type_stack->methods,
	     (strlen (info->type_stack->methods)
	      + strlen (name)
	      + 4));
  }

sprintf (m + strlen (m), "%s::", name);

info->type_stack->methods = m;

return TRUE1;
1641}

1643/* Add a variant, either static or not, to the current method.  */

1645static bfd_boolean
1646stab_class_method_var (struct stab_write_handle *info, const char *physname,
       enum debug_visibility visibility,
       bfd_boolean staticp, bfd_boolean constp,
       bfd_boolean volatilep, bfd_vma voffset,
       bfd_boolean contextp)
1651{
bfd_boolean definition;
char *type;
char *context = NULL((void*)0);
char visc, qualc, typec;

definition = info->type_stack->definition;
type = stab_pop_type (info);

if (contextp)
  {
    definition = definition || info->type_stack->definition;
    context = stab_pop_type (info);
  }

assert (info->type_stack != NULL && info->type_stack->methods != NULL)((info->type_stack != ((void*)0) && info->type_stack
->methods != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c"
, 1666, __func__, "info->type_stack != NULL && info->type_stack->methods != NULL"
));

switch (visibility)
  {
  default:
    abort ();

  case DEBUG_VISIBILITY_PRIVATE:
    visc = '0';
    break;

  case DEBUG_VISIBILITY_PROTECTED:
    visc = '1';
    break;

  case DEBUG_VISIBILITY_PUBLIC:
    visc = '2';
    break;
  }

if (constp)
  {
    if (volatilep)
qualc = 'D';
    else
qualc = 'B';
  }
else
  {
    if (volatilep)
qualc = 'C';
    else
qualc = 'A';
  }

if (staticp)
  typec = '?';
else if (! contextp)
  typec = '.';
else
  typec = '*';

info->type_stack->methods =
  (char *) xrealloc (info->type_stack->methods,
       (strlen (info->type_stack->methods)
	+ strlen (type)
	+ strlen (physname)
	+ (contextp ? strlen (context) : 0)
	+ 40));

sprintf (info->type_stack->methods + strlen (info->type_stack->methods),
  "%s:%s;%c%c%c", type, physname, visc, qualc, typec);
free (type);

if (contextp)
  {
    sprintf (info->type_stack->methods + strlen (info->type_stack->methods),
      "%ld;%s;", (long) voffset, context);
    free (context);
  }

if (definition)
  info->type_stack->definition = TRUE1;

return TRUE1;
1731}

1733/* Add a variant to the current method.  */

1735static bfd_boolean
1736stab_class_method_variant (void *p, const char *physname,
	   enum debug_visibility visibility,
	   bfd_boolean constp, bfd_boolean volatilep,
	   bfd_vma voffset, bfd_boolean contextp)
1740{
struct stab_write_handle *info = (struct stab_write_handle *) p;

return stab_class_method_var (info, physname, visibility, FALSE0, constp,
		volatilep, voffset, contextp);
1745}

1747/* Add a static variant to the current method.  */

1749static bfd_boolean
1750stab_class_static_method_variant (void *p, const char *physname,
		  enum debug_visibility visibility,
		  bfd_boolean constp, bfd_boolean volatilep)
1753{
struct stab_write_handle *info = (struct stab_write_handle *) p;

return stab_class_method_var (info, physname, visibility, TRUE1, constp,
		volatilep, 0, FALSE0);
1758}

1760/* Finish up a method.  */

1762static bfd_boolean
1763stab_class_end_method (void *p)
1764{
struct stab_write_handle *info = (struct stab_write_handle *) p;

assert (info->type_stack != NULL && info->type_stack->methods != NULL)((info->type_stack != ((void*)0) && info->type_stack
->methods != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c"
, 1767, __func__, "info->type_stack != NULL && info->type_stack->methods != NULL"
));

/* We allocated enough room on info->type_stack->methods to add the
   trailing semicolon.  */
strcat (info->type_stack->methods, ";");

return TRUE1;
1774}

1776/* Finish up a class.  */

1778static bfd_boolean
1779stab_end_class_type (void *p)
1780{
struct stab_write_handle *info = (struct stab_write_handle *) p;
size_t len;
unsigned int i = 0;
char *buf;

assert (info->type_stack != NULL && info->type_stack->fields != NULL)((info->type_stack != ((void*)0) && info->type_stack
->fields != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c"
, 1786, __func__, "info->type_stack != NULL && info->type_stack->fields != NULL"
));

/* Work out the size we need to allocate for the class definition.  */

len = (strlen (info->type_stack->string)
+ strlen (info->type_stack->fields)
+ 10);
if (info->type_stack->baseclasses != NULL((void*)0))
  {
    len += 20;
    for (i = 0; info->type_stack->baseclasses[i] != NULL((void*)0); i++)
len += strlen (info->type_stack->baseclasses[i]);
  }
if (info->type_stack->methods != NULL((void*)0))
  len += strlen (info->type_stack->methods);
if (info->type_stack->vtable != NULL((void*)0))
  len += strlen (info->type_stack->vtable);

/* Build the class definition.  */

buf = (char *) xmalloc (len);

strcpy (buf, info->type_stack->string);

if (info->type_stack->baseclasses != NULL((void*)0))
  {
    sprintf (buf + strlen (buf), "!%u,", i);
    for (i = 0; info->type_stack->baseclasses[i] != NULL((void*)0); i++)
{
 strcat (buf, info->type_stack->baseclasses[i]);
 free (info->type_stack->baseclasses[i]);
}
    free (info->type_stack->baseclasses);
    info->type_stack->baseclasses = NULL((void*)0);
  }

strcat (buf, info->type_stack->fields);
free (info->type_stack->fields);
info->type_stack->fields = NULL((void*)0);

if (info->type_stack->methods != NULL((void*)0))
  {
    strcat (buf, info->type_stack->methods);
    free (info->type_stack->methods);
    info->type_stack->methods = NULL((void*)0);
  }

strcat (buf, ";");

if (info->type_stack->vtable != NULL((void*)0))
  {
    strcat (buf, info->type_stack->vtable);
    free (info->type_stack->vtable);
    info->type_stack->vtable = NULL((void*)0);
  }

/* Replace the string on the top of the stack with the complete
   class definition.  */
free (info->type_stack->string);
info->type_stack->string = buf;

return TRUE1;
1848}

1850/* Push a typedef which was previously defined.  */

1852static bfd_boolean
1853stab_typedef_type (void *p, const char *name)
1854{
struct stab_write_handle *info = (struct stab_write_handle *) p;
struct string_hash_entry *h;

h = string_hash_lookup (&info->typedef_hash, name, FALSE, FALSE)((struct string_hash_entry *) bfd_hash_lookup (&(&info
->typedef_hash)->table, (name), (0), (0)));
assert (h != NULL && h->index > 0)((h != ((void*)0) && h->index > 0) ? (void)0 : __assert2
("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c", 1859
, __func__, "h != NULL && h->index > 0"));

return stab_push_defined_type (info, h->index, h->size);
1862}

1864/* Push a struct, union or class tag.  */

1866static bfd_boolean
1867stab_tag_type (void *p, const char *name, unsigned int id,
      enum debug_type_kind kind)
1869{
struct stab_write_handle *info = (struct stab_write_handle *) p;
long index;
unsigned int size;
1
'size' declared without an initial value→

index = stab_get_struct_index (info, name, id, kind, &size);
2
←
Calling 'stab_get_struct_index'→
if (index < 0)
  return FALSE0;

return stab_push_defined_type (info, index, size);
1879}

1881/* Define a typedef.  */

1883static bfd_boolean
1884stab_typdef (void *p, const char *name)
1885{
struct stab_write_handle *info = (struct stab_write_handle *) p;
long index;
unsigned int size;
char *s, *buf;
struct string_hash_entry *h;

index = info->type_stack->index;
size = info->type_stack->size;
s = stab_pop_type (info);

buf = (char *) xmalloc (strlen (name) + strlen (s) + 20);

if (index > 0)
  sprintf (buf, "%s:t%s", name, s);
else
  {
    index = info->type_index;
    ++info->type_index;
    sprintf (buf, "%s:t%ld=%s", name, index, s);
  }

free (s);

if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
  return FALSE0;

free (buf);

h = string_hash_lookup (&info->typedef_hash, name, TRUE, FALSE)((struct string_hash_entry *) bfd_hash_lookup (&(&info
->typedef_hash)->table, (name), (1), (0)));
if (h == NULL((void*)0))
  {
    non_fatal (_("string_hash_lookup failed: %s")("string_hash_lookup failed: %s"),
 bfd_errmsg (bfd_get_error ()));
    return FALSE0;
  }

/* I don't think we care about redefinitions.  */

h->index = index;
h->size = size;

return TRUE1;
1928}

1930/* Define a tag.  */

1932static bfd_boolean
1933stab_tag (void *p, const char *tag)
1934{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *s, *buf;

s = stab_pop_type (info);

buf = (char *) xmalloc (strlen (tag) + strlen (s) + 3);

sprintf (buf, "%s:T%s", tag, s);
free (s);

if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
  return FALSE0;

free (buf);

return TRUE1;
1951}

1953/* Define an integer constant.  */

1955static bfd_boolean
1956stab_int_constant (void *p, const char *name, bfd_vma val)
1957{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *buf;

buf = (char *) xmalloc (strlen (name) + 20);
sprintf (buf, "%s:c=i%ld", name, (long) val);

if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
  return FALSE0;

free (buf);

return TRUE1;
1970}

1972/* Define a floating point constant.  */

1974static bfd_boolean
1975stab_float_constant (void *p, const char *name, double val)
1976{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *buf;

buf = (char *) xmalloc (strlen (name) + 20);
sprintf (buf, "%s:c=f%g", name, val);

if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
  return FALSE0;

free (buf);

return TRUE1;
1989}

1991/* Define a typed constant.  */

1993static bfd_boolean
1994stab_typed_constant (void *p, const char *name, bfd_vma val)
1995{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *s, *buf;

s = stab_pop_type (info);

buf = (char *) xmalloc (strlen (name) + strlen (s) + 20);
sprintf (buf, "%s:c=e%s,%ld", name, s, (long) val);
free (s);

if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
  return FALSE0;

free (buf);

return TRUE1;
2011}

2013/* Record a variable.  */

2015static bfd_boolean
2016stab_variable (void *p, const char *name, enum debug_var_kind kind,
      bfd_vma val)
2018{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *s, *buf;
int stab_type;
const char *kindstr;

s = stab_pop_type (info);

switch (kind)
  {
  default:
    abort ();

  case DEBUG_GLOBAL:
    stab_type = N_GSYM;
    kindstr = "G";
    break;

  case DEBUG_STATIC:
    stab_type = N_STSYM;
    kindstr = "S";
    break;

  case DEBUG_LOCAL_STATIC:
    stab_type = N_STSYM;
    kindstr = "V";
    break;

  case DEBUG_LOCAL:
    stab_type = N_LSYM;
    kindstr = "";

    /* Make sure that this is a type reference or definition.  */
    if (! ISDIGIT (*s)(_sch_istable[(*s) & 0xff] & (unsigned short)(_sch_isdigit
)))
{
 char *n;
 long index;

 index = info->type_index;
 ++info->type_index;
 n = (char *) xmalloc (strlen (s) + 20);
 sprintf (n, "%ld=%s", index, s);
 free (s);
 s = n;
}
    break;

  case DEBUG_REGISTER:
    stab_type = N_RSYM;
    kindstr = "r";
    break;
  }

buf = (char *) xmalloc (strlen (name) + strlen (s) + 3);
sprintf (buf, "%s:%s%s", name, kindstr, s);
free (s);

if (! stab_write_symbol (info, stab_type, 0, val, buf))
  return FALSE0;

free (buf);

return TRUE1;
2081}

2083/* Start outputting a function.  */

2085static bfd_boolean
2086stab_start_function (void *p, const char *name, bfd_boolean globalp)
2087{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *rettype, *buf;

assert (info->nesting == 0 && info->fun_offset == -1)((info->nesting == 0 && info->fun_offset == -1)
 ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c"
, 2091, __func__, "info->nesting == 0 && info->fun_offset == -1"
));

rettype = stab_pop_type (info);

buf = (char *) xmalloc (strlen (name) + strlen (rettype) + 3);
sprintf (buf, "%s:%c%s", name,
  globalp ? 'F' : 'f',
  rettype);

/* We don't know the value now, so we set it in start_block.  */
info->fun_offset = info->symbols_size;

if (! stab_write_symbol (info, N_FUN, 0, 0, buf))
  return FALSE0;

free (buf);

return TRUE1;
2109}

2111/* Output a function parameter.  */

2113static bfd_boolean
2114stab_function_parameter (void *p, const char *name, enum debug_parm_kind kind, bfd_vma val)
2115{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *s, *buf;
int stab_type;
char kindc;

s = stab_pop_type (info);

switch (kind)
  {
  default:
    abort ();

  case DEBUG_PARM_STACK:
    stab_type = N_PSYM;
    kindc = 'p';
    break;

  case DEBUG_PARM_REG:
    stab_type = N_RSYM;
    kindc = 'P';
    break;

  case DEBUG_PARM_REFERENCE:
    stab_type = N_PSYM;
    kindc = 'v';
    break;

  case DEBUG_PARM_REF_REG:
    stab_type = N_RSYM;
    kindc = 'a';
    break;
  }

buf = (char *) xmalloc (strlen (name) + strlen (s) + 3);
sprintf (buf, "%s:%c%s", name, kindc, s);
free (s);

if (! stab_write_symbol (info, stab_type, 0, val, buf))
  return FALSE0;

free (buf);

return TRUE1;
2159}

2161/* Start a block.  */

2163static bfd_boolean
2164stab_start_block (void *p, bfd_vma addr)
2165{
struct stab_write_handle *info = (struct stab_write_handle *) p;

/* Fill in any slots which have been waiting for the first known
   text address.  */

if (info->so_offset != -1)
  {
    bfd_put_32 (info->abfd, addr, info->symbols + info->so_offset + 8)((*((info->abfd)->xvec->bfd_putx32)) ((addr),(info->
symbols + info->so_offset + 8)));
    info->so_offset = -1;
  }

if (info->fun_offset != -1)
  {
    bfd_put_32 (info->abfd, addr, info->symbols + info->fun_offset + 8)((*((info->abfd)->xvec->bfd_putx32)) ((addr),(info->
symbols + info->fun_offset + 8)));
    info->fun_offset = -1;
  }

++info->nesting;

/* We will be called with a top level block surrounding the
   function, but stabs information does not output that block, so we
   ignore it.  */

if (info->nesting == 1)
  {
    info->fnaddr = addr;
    return TRUE1;
  }

/* We have to output the LBRAC symbol after any variables which are
   declared inside the block.  We postpone the LBRAC until the next
   start_block or end_block.  */

/* If we have postponed an LBRAC, output it now.  */
if (info->pending_lbrac != (bfd_vma) -1)
  {
    if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac,
	       (const char *) NULL((void*)0)))
return FALSE0;
  }

/* Remember the address and output it later.  */

info->pending_lbrac = addr - info->fnaddr;

return TRUE1;
2212}

2214/* End a block.  */

2216static bfd_boolean
2217stab_end_block (void *p, bfd_vma addr)
2218{
struct stab_write_handle *info = (struct stab_write_handle *) p;

if (addr > info->last_text_address)
  info->last_text_address = addr;

/* If we have postponed an LBRAC, output it now.  */
if (info->pending_lbrac != (bfd_vma) -1)
  {
    if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac,
	       (const char *) NULL((void*)0)))
return FALSE0;
    info->pending_lbrac = (bfd_vma) -1;
  }

assert (info->nesting > 0)((info->nesting > 0) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c"
, 2233, __func__, "info->nesting > 0"));

--info->nesting;

/* We ignore the outermost block.  */
if (info->nesting == 0)
  return TRUE1;

return stab_write_symbol (info, N_RBRAC, 0, addr - info->fnaddr,
	    (const char *) NULL((void*)0));
2243}

2245/* End a function.  */

2247static bfd_boolean
2248stab_end_function (void *p ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2249{
return TRUE1;
2251}

2253/* Output a line number.  */

2255static bfd_boolean
2256stab_lineno (void *p, const char *file, unsigned long lineno, bfd_vma addr)
2257{
struct stab_write_handle *info = (struct stab_write_handle *) p;

assert (info->lineno_filename != NULL)((info->lineno_filename != ((void*)0)) ? (void)0 : __assert2
("/usr/src/gnu/usr.bin/binutils-2.17/binutils/wrstabs.c", 2260
, __func__, "info->lineno_filename != NULL"));

if (addr > info->last_text_address)
  info->last_text_address = addr;

if (strcmp (file, info->lineno_filename) != 0)
  {
    if (! stab_write_symbol (info, N_SOL, 0, addr, file))
return FALSE0;
    info->lineno_filename = file;
  }

return stab_write_symbol (info, N_SLINE, lineno, addr - info->fnaddr,
	    (const char *) NULL((void*)0));
2274}