/* wrstabs.c -- Output stabs debugging information
- Copyright 1996, 1997, 1998, 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1996-2020 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
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
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., 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+ 02110-1301, USA. */
/* This file contains code which writes out stabs debugging
information. */
-#include <stdio.h>
+#include "sysdep.h"
#include <assert.h>
-
#include "bfd.h"
-#include "bucomm.h"
#include "libiberty.h"
+#include "filenames.h"
#include "safe-ctype.h"
+#include "bucomm.h"
#include "debug.h"
#include "budbg.h"
-
-/* Meaningless definition needs by aout64.h. FIXME. */
-#define BYTES_IN_WORD 4
-
#include "aout/aout64.h"
#include "aout/stab_gnu.h"
/* The size of the type. */
unsigned int size;
/* Whether type string defines a new type. */
- boolean definition;
+ bfd_boolean definition;
/* String defining struct fields. */
char *fields;
/* NULL terminated array of strings defining base classes for a
};
static struct bfd_hash_entry *string_hash_newfunc
- PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
-static boolean stab_write_symbol
- PARAMS ((struct stab_write_handle *, int, int, bfd_vma, const char *));
-static boolean stab_push_string
- PARAMS ((struct stab_write_handle *, const char *, long, boolean,
- unsigned int));
-static boolean stab_push_defined_type
- PARAMS ((struct stab_write_handle *, long, unsigned int));
-static char *stab_pop_type PARAMS ((struct stab_write_handle *));
-static boolean stab_modify_type
- PARAMS ((struct stab_write_handle *, int, unsigned int, long **, size_t *));
+ (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
+static bfd_boolean stab_write_symbol
+ (struct stab_write_handle *, int, int, bfd_vma, const char *);
+static bfd_boolean stab_push_string
+ (struct stab_write_handle *, const char *, long, bfd_boolean, unsigned int);
+static bfd_boolean stab_push_defined_type
+ (struct stab_write_handle *, long, unsigned int);
+static char *stab_pop_type (struct stab_write_handle *);
+static bfd_boolean stab_modify_type
+ (struct stab_write_handle *, int, unsigned int, long **, size_t *);
static long stab_get_struct_index
- PARAMS ((struct stab_write_handle *, const char *, unsigned int,
- enum debug_type_kind, unsigned int *));
-static boolean stab_class_method_var
- PARAMS ((struct stab_write_handle *, const char *, enum debug_visibility,
- boolean, boolean, boolean, bfd_vma, boolean));
-
-static boolean stab_start_compilation_unit PARAMS ((PTR, const char *));
-static boolean stab_start_source PARAMS ((PTR, const char *));
-static boolean stab_empty_type PARAMS ((PTR));
-static boolean stab_void_type PARAMS ((PTR));
-static boolean stab_int_type PARAMS ((PTR, unsigned int, boolean));
-static boolean stab_float_type PARAMS ((PTR, unsigned int));
-static boolean stab_complex_type PARAMS ((PTR, unsigned int));
-static boolean stab_bool_type PARAMS ((PTR, unsigned int));
-static boolean stab_enum_type
- PARAMS ((PTR, const char *, const char **, bfd_signed_vma *));
-static boolean stab_pointer_type PARAMS ((PTR));
-static boolean stab_function_type PARAMS ((PTR, int, boolean));
-static boolean stab_reference_type PARAMS ((PTR));
-static boolean stab_range_type PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
-static boolean stab_array_type
- PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, boolean));
-static boolean stab_set_type PARAMS ((PTR, boolean));
-static boolean stab_offset_type PARAMS ((PTR));
-static boolean stab_method_type PARAMS ((PTR, boolean, int, boolean));
-static boolean stab_const_type PARAMS ((PTR));
-static boolean stab_volatile_type PARAMS ((PTR));
-static boolean stab_start_struct_type
- PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int));
-static boolean stab_struct_field
- PARAMS ((PTR, const char *, bfd_vma, bfd_vma, enum debug_visibility));
-static boolean stab_end_struct_type PARAMS ((PTR));
-static boolean stab_start_class_type
- PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int, boolean,
- boolean));
-static boolean stab_class_static_member
- PARAMS ((PTR, const char *, const char *, enum debug_visibility));
-static boolean stab_class_baseclass
- PARAMS ((PTR, bfd_vma, boolean, enum debug_visibility));
-static boolean stab_class_start_method PARAMS ((PTR, const char *));
-static boolean stab_class_method_variant
- PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean,
- bfd_vma, boolean));
-static boolean stab_class_static_method_variant
- PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean));
-static boolean stab_class_end_method PARAMS ((PTR));
-static boolean stab_end_class_type PARAMS ((PTR));
-static boolean stab_typedef_type PARAMS ((PTR, const char *));
-static boolean stab_tag_type
- PARAMS ((PTR, const char *, unsigned int, enum debug_type_kind));
-static boolean stab_typdef PARAMS ((PTR, const char *));
-static boolean stab_tag PARAMS ((PTR, const char *));
-static boolean stab_int_constant PARAMS ((PTR, const char *, bfd_vma));
-static boolean stab_float_constant PARAMS ((PTR, const char *, double));
-static boolean stab_typed_constant PARAMS ((PTR, const char *, bfd_vma));
-static boolean stab_variable
- PARAMS ((PTR, const char *, enum debug_var_kind, bfd_vma));
-static boolean stab_start_function PARAMS ((PTR, const char *, boolean));
-static boolean stab_function_parameter
- PARAMS ((PTR, const char *, enum debug_parm_kind, bfd_vma));
-static boolean stab_start_block PARAMS ((PTR, bfd_vma));
-static boolean stab_end_block PARAMS ((PTR, bfd_vma));
-static boolean stab_end_function PARAMS ((PTR));
-static boolean stab_lineno
- PARAMS ((PTR, const char *, unsigned long, bfd_vma));
+ (struct stab_write_handle *, const char *, unsigned int,
+ enum debug_type_kind, unsigned int *);
+static 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);
+static bfd_boolean stab_start_compilation_unit (void *, const char *);
+static bfd_boolean stab_start_source (void *, const char *);
+static bfd_boolean stab_empty_type (void *);
+static bfd_boolean stab_void_type (void *);
+static bfd_boolean stab_int_type (void *, unsigned int, bfd_boolean);
+static bfd_boolean stab_float_type (void *, unsigned int);
+static bfd_boolean stab_complex_type (void *, unsigned int);
+static bfd_boolean stab_bool_type (void *, unsigned int);
+static bfd_boolean stab_enum_type
+ (void *, const char *, const char **, bfd_signed_vma *);
+static bfd_boolean stab_pointer_type (void *);
+static bfd_boolean stab_function_type (void *, int, bfd_boolean);
+static bfd_boolean stab_reference_type (void *);
+static bfd_boolean stab_range_type (void *, bfd_signed_vma, bfd_signed_vma);
+static bfd_boolean stab_array_type
+ (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
+static bfd_boolean stab_set_type (void *, bfd_boolean);
+static bfd_boolean stab_offset_type (void *);
+static bfd_boolean stab_method_type (void *, bfd_boolean, int, bfd_boolean);
+static bfd_boolean stab_const_type (void *);
+static bfd_boolean stab_volatile_type (void *);
+static bfd_boolean stab_start_struct_type
+ (void *, const char *, unsigned int, bfd_boolean, unsigned int);
+static bfd_boolean stab_struct_field
+ (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
+static bfd_boolean stab_end_struct_type (void *);
+static bfd_boolean stab_start_class_type
+ (void *, const char *, unsigned int, bfd_boolean, unsigned int,
+ bfd_boolean, bfd_boolean);
+static bfd_boolean stab_class_static_member
+ (void *, const char *, const char *, enum debug_visibility);
+static bfd_boolean stab_class_baseclass
+ (void *, bfd_vma, bfd_boolean, enum debug_visibility);
+static bfd_boolean stab_class_start_method (void *, const char *);
+static bfd_boolean stab_class_method_variant
+ (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
+ bfd_vma, bfd_boolean);
+static bfd_boolean stab_class_static_method_variant
+ (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
+static bfd_boolean stab_class_end_method (void *);
+static bfd_boolean stab_end_class_type (void *);
+static bfd_boolean stab_typedef_type (void *, const char *);
+static bfd_boolean stab_tag_type
+ (void *, const char *, unsigned int, enum debug_type_kind);
+static bfd_boolean stab_typdef (void *, const char *);
+static bfd_boolean stab_tag (void *, const char *);
+static bfd_boolean stab_int_constant (void *, const char *, bfd_vma);
+static bfd_boolean stab_float_constant (void *, const char *, double);
+static bfd_boolean stab_typed_constant (void *, const char *, bfd_vma);
+static bfd_boolean stab_variable
+ (void *, const char *, enum debug_var_kind, bfd_vma);
+static bfd_boolean stab_start_function (void *, const char *, bfd_boolean);
+static bfd_boolean stab_function_parameter
+ (void *, const char *, enum debug_parm_kind, bfd_vma);
+static bfd_boolean stab_start_block (void *, bfd_vma);
+static bfd_boolean stab_end_block (void *, bfd_vma);
+static bfd_boolean stab_end_function (void *);
+static bfd_boolean stab_lineno (void *, const char *, unsigned long, bfd_vma);
static const struct debug_write_fns stab_fns =
{
/* Routine to create an entry in a string hash table. */
static struct bfd_hash_entry *
-string_hash_newfunc (entry, table, string)
- struct bfd_hash_entry *entry;
- struct bfd_hash_table *table;
- const char *string;
+string_hash_newfunc (struct bfd_hash_entry *entry,
+ struct bfd_hash_table *table, const char *string)
{
struct string_hash_entry *ret = (struct string_hash_entry *) entry;
/* Add a symbol to the stabs debugging information we are building. */
-static boolean
-stab_write_symbol (info, type, desc, value, string)
- struct stab_write_handle *info;
- int type;
- int desc;
- bfd_vma value;
- const char *string;
+static bfd_boolean
+stab_write_symbol (struct stab_write_handle *info, int type, int desc,
+ bfd_vma value, const char *string)
{
bfd_size_type strx;
bfd_byte sym[STAB_SYMBOL_SIZE];
{
struct string_hash_entry *h;
- h = string_hash_lookup (&info->strhash, string, true, true);
+ h = string_hash_lookup (&info->strhash, string, TRUE, TRUE);
if (h == NULL)
{
non_fatal (_("string_hash_lookup failed: %s"),
bfd_errmsg (bfd_get_error ()));
- return false;
+ return FALSE;
}
if (h->index != -1)
strx = h->index;
info->symbols_size += STAB_SYMBOL_SIZE;
- return true;
+ return TRUE;
}
/* Push a string on to the type stack. */
-static boolean
-stab_push_string (info, string, index, definition, size)
- struct stab_write_handle *info;
- const char *string;
- long index;
- boolean definition;
- unsigned int size;
+static bfd_boolean
+stab_push_string (struct stab_write_handle *info, const char *string,
+ long tindex, bfd_boolean definition, unsigned int size)
{
struct stab_type_stack *s;
s = (struct stab_type_stack *) xmalloc (sizeof *s);
s->string = xstrdup (string);
- s->index = index;
+ s->index = tindex;
s->definition = definition;
s->size = size;
s->next = info->type_stack;
info->type_stack = s;
- return true;
+ return TRUE;
}
/* Push a type index which has already been defined. */
-static boolean
-stab_push_defined_type (info, index, size)
- struct stab_write_handle *info;
- long index;
- unsigned int size;
+static bfd_boolean
+stab_push_defined_type (struct stab_write_handle *info, long tindex,
+ unsigned int size)
{
char buf[20];
- sprintf (buf, "%ld", index);
- return stab_push_string (info, buf, index, false, size);
+ sprintf (buf, "%ld", tindex);
+ return stab_push_string (info, buf, tindex, FALSE, size);
}
/* Pop a type off the type stack. The caller is responsible for
freeing the string. */
static char *
-stab_pop_type (info)
- struct stab_write_handle *info;
+stab_pop_type (struct stab_write_handle *info)
{
struct stab_type_stack *s;
char *ret;
s = info->type_stack;
- assert (s != NULL);
+ if (s == NULL)
+ return NULL;
info->type_stack = s->next;
the symbols, *PSYMSIZE the size of the symbols, *PSTRINGS to the
strings, and *PSTRINGSIZE to the size of the strings. */
-boolean
-write_stabs_in_sections_debugging_info (abfd, dhandle, psyms, psymsize,
- pstrings, pstringsize)
- bfd *abfd;
- PTR dhandle;
- bfd_byte **psyms;
- bfd_size_type *psymsize;
- bfd_byte **pstrings;
- bfd_size_type *pstringsize;
+bfd_boolean
+write_stabs_in_sections_debugging_info (bfd *abfd, void *dhandle,
+ bfd_byte **psyms,
+ bfd_size_type *psymsize,
+ bfd_byte **pstrings,
+ bfd_size_type *pstringsize)
{
struct stab_write_handle info;
struct string_hash_entry *h;
/* Reserve 1 byte for a null byte. */
info.strings_size = 1;
- if (! bfd_hash_table_init (&info.strhash.table, string_hash_newfunc)
- || ! bfd_hash_table_init (&info.typedef_hash.table, string_hash_newfunc))
+ 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 false;
+ return FALSE;
}
info.type_stack = NULL;
/* The initial symbol holds the string size. */
if (! stab_write_symbol (&info, 0, 0, 0, (const char *) NULL))
- return false;
+ return FALSE;
/* 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)))
- return false;
+ return FALSE;
- if (! debug_write (dhandle, &stab_fns, (PTR) &info))
- return false;
+ if (! debug_write (dhandle, &stab_fns, (void *) &info))
+ return FALSE;
- assert (info.pending_lbrac == (bfd_vma) -1);
+ if (info.pending_lbrac != (bfd_vma) -1)
+ return FALSE;
/* Output a trailing N_SO. */
if (! stab_write_symbol (&info, N_SO, 0, info.last_text_address,
(const char *) NULL))
- return false;
+ return FALSE;
/* Put the string size in the initial symbol. */
bfd_put_32 (abfd, info.strings_size, info.symbols + 8);
p += strlen ((char *) p) + 1;
}
- return true;
+ return TRUE;
}
/* Start writing out information for a compilation unit. */
-static boolean
-stab_start_compilation_unit (p, filename)
- PTR p;
- const char *filename;
+static bfd_boolean
+stab_start_compilation_unit (void *p, const char *filename)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
/* Start writing out information for a particular source file. */
-static boolean
-stab_start_source (p, filename)
- PTR p;
- const char *filename;
+static bfd_boolean
+stab_start_source (void *p, const char *filename)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
/* Push an empty type. This shouldn't normally happen. We just use a
void type. */
-static boolean
-stab_empty_type (p)
- PTR p;
+static bfd_boolean
+stab_empty_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
return stab_push_defined_type (info, info->type_cache.void_type, 0);
else
{
- long index;
+ long tindex;
char buf[40];
- index = info->type_index;
+ tindex = info->type_index;
++info->type_index;
- sprintf (buf, "%ld=%ld", index, index);
+ sprintf (buf, "%ld=%ld", tindex, tindex);
- return stab_push_string (info, buf, index, false, 0);
+ return stab_push_string (info, buf, tindex, FALSE, 0);
}
}
/* Push a void type. */
-static boolean
-stab_void_type (p)
- PTR p;
+static bfd_boolean
+stab_void_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
return stab_push_defined_type (info, info->type_cache.void_type, 0);
else
{
- long index;
+ long tindex;
char buf[40];
- index = info->type_index;
+ tindex = info->type_index;
++info->type_index;
- info->type_cache.void_type = index;
+ info->type_cache.void_type = tindex;
- sprintf (buf, "%ld=%ld", index, index);
+ sprintf (buf, "%ld=%ld", tindex, tindex);
- return stab_push_string (info, buf, index, true, 0);
+ return stab_push_string (info, buf, tindex, TRUE, 0);
}
}
/* Push an integer type. */
-static boolean
-stab_int_type (p, size, unsignedp)
- PTR p;
- unsigned int size;
- boolean unsignedp;
+static bfd_boolean
+stab_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
{
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"), size);
- return false;
+ return FALSE;
}
if (unsignedp)
return stab_push_defined_type (info, cache[size - 1], size);
else
{
- long index;
+ long tindex;
char buf[100];
- index = info->type_index;
+ tindex = info->type_index;
++info->type_index;
- cache[size - 1] = index;
+ cache[size - 1] = tindex;
- sprintf (buf, "%ld=r%ld;", index, index);
+ sprintf (buf, "%ld=r%ld;", tindex, tindex);
if (unsignedp)
{
strcat (buf, "0;");
abort ();
}
- return stab_push_string (info, buf, index, true, size);
+ return stab_push_string (info, buf, tindex, TRUE, size);
}
}
/* Push a floating point type. */
-static boolean
-stab_float_type (p, size)
- PTR p;
- unsigned int size;
+static bfd_boolean
+stab_float_type (void *p, unsigned int size)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
size);
else
{
- long index;
+ long tindex;
char *int_type;
char buf[50];
/* Floats are defined as a subrange of int. */
- if (! stab_int_type (info, 4, false))
- return false;
+ if (! stab_int_type (info, 4, FALSE))
+ return FALSE;
int_type = stab_pop_type (info);
- index = info->type_index;
+ tindex = 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;
+ info->type_cache.float_types[size - 1] = tindex;
- sprintf (buf, "%ld=r%s;%u;0;", index, int_type, size);
+ sprintf (buf, "%ld=r%s;%u;0;", tindex, int_type, size);
free (int_type);
- return stab_push_string (info, buf, index, true, size);
+ return stab_push_string (info, buf, tindex, TRUE, size);
}
}
/* Push a complex type. */
-static boolean
-stab_complex_type (p, size)
- PTR p;
- unsigned int size;
+static bfd_boolean
+stab_complex_type (void *p, unsigned int size)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char buf[50];
- long index;
+ long tindex;
- index = info->type_index;
+ tindex = info->type_index;
++info->type_index;
- sprintf (buf, "%ld=r%ld;%u;0;", index, index, size);
+ sprintf (buf, "%ld=r%ld;%u;0;", tindex, tindex, size);
- return stab_push_string (info, buf, index, true, size * 2);
+ return stab_push_string (info, buf, tindex, TRUE, size * 2);
}
-/* Push a boolean type. We use an XCOFF predefined type, since gdb
+/* Push a bfd_boolean type. We use an XCOFF predefined type, since gdb
always recognizes them. */
-static boolean
-stab_bool_type (p, size)
- PTR p;
- unsigned int size;
+static bfd_boolean
+stab_bool_type (void *p, unsigned int size)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- long index;
+ long tindex;
switch (size)
{
case 1:
- index = -21;
+ tindex = -21;
break;
case 2:
- index = -22;
+ tindex = -22;
break;
default:
case 4:
- index = -16;
+ tindex = -16;
break;
case 8:
- index = -33;
+ tindex = -33;
break;
}
- return stab_push_defined_type (info, index, size);
+ return stab_push_defined_type (info, tindex, size);
}
/* Push an enum type. */
-static boolean
-stab_enum_type (p, tag, names, vals)
- PTR p;
- const char *tag;
- const char **names;
- bfd_signed_vma *vals;
+static bfd_boolean
+stab_enum_type (void *p, const char *tag, const char **names,
+ bfd_signed_vma *vals)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
size_t len;
const char **pn;
char *buf;
- long index = 0;
+ long tindex = 0;
bfd_signed_vma *pv;
if (names == NULL)
{
- assert (tag != NULL);
+ if (tag == NULL)
+ return FALSE;
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, false, 4))
- return false;
+ if (! stab_push_string (info, buf, 0, FALSE, 4))
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
len = 10;
strcpy (buf, "e");
else
{
- index = info->type_index;
+ tindex = info->type_index;
++info->type_index;
- sprintf (buf, "%s:T%ld=e", tag, index);
+ sprintf (buf, "%s:T%ld=e", tag, tindex);
}
for (pn = names, pv = vals; *pn != NULL; pn++, pv++)
if (tag == NULL)
{
/* FIXME: The size is just a guess. */
- if (! stab_push_string (info, buf, 0, false, 4))
- return false;
+ if (! stab_push_string (info, buf, 0, FALSE, 4))
+ return FALSE;
}
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 false;
+ || ! stab_push_defined_type (info, tindex, 4))
+ return FALSE;
}
free (buf);
- return true;
+ return TRUE;
}
/* Push a modification of the top type on the stack. Cache the
results in CACHE and CACHE_ALLOC. */
-static boolean
-stab_modify_type (info, mod, size, cache, cache_alloc)
- struct stab_write_handle *info;
- int mod;
- unsigned int size;
- long **cache;
- size_t *cache_alloc;
+static bfd_boolean
+stab_modify_type (struct stab_write_handle *info, int mod,
+ unsigned int size, long **cache, size_t *cache_alloc)
{
long targindex;
- long index;
+ long tindex;
char *s, *buf;
- assert (info->type_stack != NULL);
+ if (info->type_stack == NULL)
+ return FALSE;
targindex = info->type_stack->index;
if (targindex <= 0
|| cache == NULL)
{
- boolean definition;
+ 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
sprintf (buf, "%c%s", mod, s);
free (s);
if (! stab_push_string (info, buf, 0, definition, size))
- return false;
+ return FALSE;
free (buf);
}
else
*cache_alloc = alloc;
}
- index = (*cache)[targindex];
- if (index != 0 && ! info->type_stack->definition)
+ tindex = (*cache)[targindex];
+ if (tindex != 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
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 false;
+ if (! stab_push_defined_type (info, tindex, size))
+ return FALSE;
}
else
{
- index = info->type_index;
+ tindex = 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);
+ sprintf (buf, "%ld=%c%s", tindex, mod, s);
free (s);
- (*cache)[targindex] = index;
+ (*cache)[targindex] = tindex;
- if (! stab_push_string (info, buf, index, true, size))
- return false;
+ if (! stab_push_string (info, buf, tindex, TRUE, size))
+ return FALSE;
free (buf);
}
}
- return true;
+ return TRUE;
}
/* Push a pointer type. */
-static boolean
-stab_pointer_type (p)
- PTR p;
+static bfd_boolean
+stab_pointer_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
/* Push a function type. */
-static boolean
-stab_function_type (p, argcount, varargs)
- PTR p;
- int argcount;
- boolean varargs ATTRIBUTE_UNUSED;
+static bfd_boolean
+stab_function_type (void *p, int argcount,
+ bfd_boolean varargs ATTRIBUTE_UNUSED)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
int i;
free (s);
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
- return false;
+ return FALSE;
free (buf);
}
/* Push a reference type. */
-static boolean
-stab_reference_type (p)
- PTR p;
+static bfd_boolean
+stab_reference_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
/* Push a range type. */
-static boolean
-stab_range_type (p, low, high)
- PTR p;
- bfd_signed_vma low;
- bfd_signed_vma high;
+static bfd_boolean
+stab_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- boolean definition;
+ bfd_boolean definition;
unsigned int size;
char *s, *buf;
free (s);
if (! stab_push_string (info, buf, 0, definition, size))
- return false;
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Push an array type. */
-static boolean
-stab_array_type (p, low, high, stringp)
- PTR p;
- bfd_signed_vma low;
- bfd_signed_vma high;
- boolean stringp;
+static bfd_boolean
+stab_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high,
+ bfd_boolean stringp)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- boolean definition;
+ bfd_boolean definition;
unsigned int element_size;
char *range, *element, *buf;
- long index;
+ long tindex;
unsigned int size;
definition = info->type_stack->definition;
if (! stringp)
{
- index = 0;
+ tindex = 0;
*buf = '\0';
}
else
{
/* We need to define a type in order to include the string
attribute. */
- index = info->type_index;
+ tindex = info->type_index;
++info->type_index;
- definition = true;
- sprintf (buf, "%ld=@S;", index);
+ definition = TRUE;
+ sprintf (buf, "%ld=@S;", tindex);
}
sprintf (buf + strlen (buf), "ar%s;%ld;%ld;%s",
size = 0;
else
size = element_size * ((high - low) + 1);
- if (! stab_push_string (info, buf, index, definition, size))
- return false;
+ if (! stab_push_string (info, buf, tindex, definition, size))
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Push a set type. */
-static boolean
-stab_set_type (p, bitstringp)
- PTR p;
- boolean bitstringp;
+static bfd_boolean
+stab_set_type (void *p, bfd_boolean bitstringp)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- boolean definition;
+ bfd_boolean definition;
char *s, *buf;
- long index;
+ long tindex;
definition = info->type_stack->definition;
if (! bitstringp)
{
*buf = '\0';
- index = 0;
+ tindex = 0;
}
else
{
/* We need to define a type in order to include the string
attribute. */
- index = info->type_index;
+ tindex = info->type_index;
++info->type_index;
- definition = true;
- sprintf (buf, "%ld=@S;", index);
+ definition = TRUE;
+ sprintf (buf, "%ld=@S;", tindex);
}
sprintf (buf + strlen (buf), "S%s", s);
free (s);
- if (! stab_push_string (info, buf, index, definition, 0))
- return false;
+ if (! stab_push_string (info, buf, tindex, definition, 0))
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Push an offset type. */
-static boolean
-stab_offset_type (p)
- PTR p;
+static bfd_boolean
+stab_offset_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- boolean definition;
+ bfd_boolean definition;
char *target, *base, *buf;
definition = info->type_stack->definition;
free (target);
if (! stab_push_string (info, buf, 0, definition, 0))
- return false;
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Push a method type. */
-static boolean
-stab_method_type (p, domainp, argcount, varargs)
- PTR p;
- boolean domainp;
- int argcount;
- boolean varargs;
+static bfd_boolean
+stab_method_type (void *p, bfd_boolean domainp, int argcount,
+ bfd_boolean varargs)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- boolean definition;
+ bfd_boolean definition;
char *domain, *return_type, *buf;
char **args;
int i;
if (! domainp)
{
if (! stab_empty_type (p))
- return false;
+ return FALSE;
}
definition = info->type_stack->definition;
{
args = (char **) xmalloc (1 * sizeof (*args));
if (! stab_empty_type (p))
- return false;
+ return FALSE;
definition = definition || info->type_stack->definition;
args[0] = stab_pop_type (info);
argcount = 1;
if (! varargs)
{
if (! stab_empty_type (p))
- return false;
+ return FALSE;
definition = definition || info->type_stack->definition;
args[argcount] = stab_pop_type (info);
++argcount;
}
strcat (buf, ";");
- if (args != NULL)
- free (args);
+ free (args);
if (! stab_push_string (info, buf, 0, definition, 0))
- return false;
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Push a const version of a type. */
-static boolean
-stab_const_type (p)
- PTR p;
+static bfd_boolean
+stab_const_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
/* Push a volatile version of a type. */
-static boolean
-stab_volatile_type (p)
- PTR p;
+static bfd_boolean
+stab_volatile_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
return -1 if it fails. */
static long
-stab_get_struct_index (info, tag, id, kind, psize)
- struct stab_write_handle *info;
- const char *tag;
- unsigned int id;
- enum debug_type_kind kind;
- unsigned int *psize;
+stab_get_struct_index (struct stab_write_handle *info, const char *tag,
+ unsigned int id, enum debug_type_kind kind,
+ unsigned int *psize)
{
if (id >= info->type_cache.struct_types_alloc)
{
/* Start outputting a struct. We ignore the tag, and handle it in
stab_tag. */
-static boolean
-stab_start_struct_type (p, tag, id, structp, size)
- PTR p;
- const char *tag;
- unsigned int id;
- boolean structp;
- unsigned int size;
+static bfd_boolean
+stab_start_struct_type (void *p, const char *tag, unsigned int id,
+ bfd_boolean structp, unsigned int size)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- long index;
- boolean definition;
- char *buf;
-
- buf = (char *) xmalloc (40);
+ long tindex;
+ bfd_boolean definition;
+ char buf[40];
if (id == 0)
{
- index = 0;
+ tindex = 0;
*buf = '\0';
- definition = false;
+ definition = FALSE;
}
else
{
- index = stab_get_struct_index (info, tag, id, DEBUG_KIND_ILLEGAL,
+ tindex = stab_get_struct_index (info, tag, id, DEBUG_KIND_ILLEGAL,
&size);
- if (index < 0)
- return false;
- sprintf (buf, "%ld=", index);
- definition = true;
+ if (tindex < 0)
+ return FALSE;
+ sprintf (buf, "%ld=", tindex);
+ definition = TRUE;
}
sprintf (buf + strlen (buf), "%c%u",
structp ? 's' : 'u',
size);
- if (! stab_push_string (info, buf, index, definition, size))
- return false;
+ if (! stab_push_string (info, buf, tindex, definition, size))
+ return FALSE;
info->type_stack->fields = (char *) xmalloc (1);
info->type_stack->fields[0] = '\0';
- return true;
+ return TRUE;
}
/* Add a field to a struct. */
-static boolean
-stab_struct_field (p, name, bitpos, bitsize, visibility)
- PTR p;
- const char *name;
- bfd_vma bitpos;
- bfd_vma bitsize;
- enum debug_visibility visibility;
+static bfd_boolean
+stab_struct_field (void *p, const char *name, bfd_vma bitpos,
+ bfd_vma bitsize, enum debug_visibility visibility)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- boolean definition;
+ bfd_boolean definition;
unsigned int size;
char *s, *n;
const char *vis;
/* Add this field to the end of the current struct fields, which is
currently on the top of the stack. */
+ if (info->type_stack->fields == NULL)
+ return FALSE;
- assert (info->type_stack->fields != NULL);
n = (char *) xmalloc (strlen (info->type_stack->fields)
+ strlen (name)
+ strlen (s)
info->type_stack->fields = n;
if (definition)
- info->type_stack->definition = true;
+ info->type_stack->definition = TRUE;
- return true;
+ return TRUE;
}
/* Finish up a struct. */
-static boolean
-stab_end_struct_type (p)
- PTR p;
+static bfd_boolean
+stab_end_struct_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- boolean definition;
- long index;
+ bfd_boolean definition;
+ long tindex;
unsigned int size;
char *fields, *first, *buf;
- assert (info->type_stack != NULL && info->type_stack->fields != NULL);
+ if (info->type_stack == NULL || info->type_stack->fields == NULL)
+ return FALSE;
definition = info->type_stack->definition;
- index = info->type_stack->index;
+ tindex = info->type_stack->index;
size = info->type_stack->size;
fields = info->type_stack->fields;
first = stab_pop_type (info);
free (first);
free (fields);
- if (! stab_push_string (info, buf, index, definition, size))
- return false;
+ if (! stab_push_string (info, buf, tindex, definition, size))
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Start outputting a class. */
-static boolean
-stab_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
- PTR p;
- const char *tag;
- unsigned int id;
- boolean structp;
- unsigned int size;
- boolean vptr;
- boolean ownvptr;
+static bfd_boolean
+stab_start_class_type (void *p, const char *tag, unsigned int id,
+ bfd_boolean structp, unsigned int size,
+ bfd_boolean vptr, bfd_boolean ownvptr)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- boolean definition;
- char *vstring;
+ bfd_boolean definition = FALSE;
+ char *vstring = NULL;
- if (! vptr || ownvptr)
- {
- definition = false;
- vstring = NULL;
- }
- else
+ if (vptr && !ownvptr)
{
definition = info->type_stack->definition;
vstring = stab_pop_type (info);
}
if (! stab_start_struct_type (p, tag, id, structp, size))
- return false;
+ return FALSE;
if (vptr)
{
if (ownvptr)
{
- assert (info->type_stack->index > 0);
+ if (info->type_stack->index < 1)
+ return FALSE;
vtable = (char *) xmalloc (20);
sprintf (vtable, "~%%%ld", info->type_stack->index);
}
else
{
+ if (vstring == NULL)
+ return FALSE;
vtable = (char *) xmalloc (strlen (vstring) + 3);
sprintf (vtable, "~%%%s", vstring);
free (vstring);
+ if (definition)
+ info->type_stack->definition = TRUE;
}
-
info->type_stack->vtable = vtable;
}
- if (definition)
- info->type_stack->definition = true;
-
- return true;
+ return TRUE;
}
/* Add a static member to the class on the type stack. */
-static boolean
-stab_class_static_member (p, name, physname, visibility)
- PTR p;
- const char *name;
- const char *physname;
- enum debug_visibility visibility;
+static bfd_boolean
+stab_class_static_member (void *p, const char *name, const char *physname,
+ enum debug_visibility visibility)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- boolean definition;
+ bfd_boolean definition;
char *s, *n;
const char *vis;
/* 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);
+ if (info->type_stack->fields == NULL)
+ return FALSE;
n = (char *) xmalloc (strlen (info->type_stack->fields)
+ strlen (name)
+ strlen (s)
info->type_stack->fields = n;
if (definition)
- info->type_stack->definition = true;
+ info->type_stack->definition = TRUE;
- return true;
+ return TRUE;
}
/* Add a base class to the class on the type stack. */
-static boolean
-stab_class_baseclass (p, bitpos, virtual, visibility)
- PTR p;
- bfd_vma bitpos;
- boolean virtual;
- enum debug_visibility visibility;
+static bfd_boolean
+stab_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual,
+ enum debug_visibility visibility)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- boolean definition;
+ bfd_boolean definition;
char *s;
char *buf;
unsigned int c;
/* Build the base class specifier. */
buf = (char *) xmalloc (strlen (s) + 25);
- buf[0] = virtual ? '1' : '0';
+ buf[0] = is_virtual ? '1' : '0';
switch (visibility)
{
default:
/* Add the new baseclass to the existing ones. */
- assert (info->type_stack != NULL && info->type_stack->fields != NULL);
+ if (info->type_stack == NULL || info->type_stack->fields == NULL)
+ return FALSE;
if (info->type_stack->baseclasses == NULL)
c = 0;
info->type_stack->baseclasses = baseclasses;
if (definition)
- info->type_stack->definition = true;
+ info->type_stack->definition = TRUE;
- return true;
+ return TRUE;
}
/* Start adding a method to the class on the type stack. */
-static boolean
-stab_class_start_method (p, name)
- PTR p;
- const char *name;
+static bfd_boolean
+stab_class_start_method (void *p, const char *name)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *m;
- assert (info->type_stack != NULL && info->type_stack->fields != NULL);
+ if (info->type_stack == NULL || info->type_stack->fields == NULL)
+ return FALSE;
if (info->type_stack->methods == NULL)
{
info->type_stack->methods = m;
- return true;
+ return TRUE;
}
/* Add a variant, either static or not, to the current method. */
-static boolean
-stab_class_method_var (info, physname, visibility, staticp, constp, volatilep,
- voffset, contextp)
- struct stab_write_handle *info;
- const char *physname;
- enum debug_visibility visibility;
- boolean staticp;
- boolean constp;
- boolean volatilep;
- bfd_vma voffset;
- boolean contextp;
+static bfd_boolean
+stab_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)
{
- boolean definition;
+ bfd_boolean definition;
char *type;
char *context = NULL;
char visc, qualc, typec;
context = stab_pop_type (info);
}
- assert (info->type_stack != NULL && info->type_stack->methods != NULL);
+ if (info->type_stack == NULL || info->type_stack->methods == NULL)
+ return FALSE;
switch (visibility)
{
}
if (definition)
- info->type_stack->definition = true;
+ info->type_stack->definition = TRUE;
- return true;
+ return TRUE;
}
/* Add a variant to the current method. */
-static boolean
-stab_class_method_variant (p, physname, visibility, constp, volatilep,
- voffset, contextp)
- PTR p;
- const char *physname;
- enum debug_visibility visibility;
- boolean constp;
- boolean volatilep;
- bfd_vma voffset;
- boolean contextp;
+static bfd_boolean
+stab_class_method_variant (void *p, const char *physname,
+ enum debug_visibility visibility,
+ bfd_boolean constp, bfd_boolean volatilep,
+ bfd_vma voffset, bfd_boolean contextp)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- return stab_class_method_var (info, physname, visibility, false, constp,
+ return stab_class_method_var (info, physname, visibility, FALSE, constp,
volatilep, voffset, contextp);
}
/* Add a static variant to the current method. */
-static boolean
-stab_class_static_method_variant (p, physname, visibility, constp, volatilep)
- PTR p;
- const char *physname;
- enum debug_visibility visibility;
- boolean constp;
- boolean volatilep;
+static bfd_boolean
+stab_class_static_method_variant (void *p, const char *physname,
+ enum debug_visibility visibility,
+ bfd_boolean constp, bfd_boolean volatilep)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- return stab_class_method_var (info, physname, visibility, true, constp,
- volatilep, 0, false);
+ return stab_class_method_var (info, physname, visibility, TRUE, constp,
+ volatilep, 0, FALSE);
}
/* Finish up a method. */
-static boolean
-stab_class_end_method (p)
- PTR p;
+static bfd_boolean
+stab_class_end_method (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- assert (info->type_stack != NULL && info->type_stack->methods != NULL);
+ if (info->type_stack == NULL || info->type_stack->methods == NULL)
+ return FALSE;
/* We allocated enough room on info->type_stack->methods to add the
trailing semicolon. */
strcat (info->type_stack->methods, ";");
- return true;
+ return TRUE;
}
/* Finish up a class. */
-static boolean
-stab_end_class_type (p)
- PTR p;
+static bfd_boolean
+stab_end_class_type (void *p)
{
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);
+ if (info->type_stack == NULL
+ || info->type_stack->string == NULL
+ || info->type_stack->fields == NULL)
+ return FALSE;
/* Work out the size we need to allocate for the class definition. */
free (info->type_stack->string);
info->type_stack->string = buf;
- return true;
+ return TRUE;
}
/* Push a typedef which was previously defined. */
-static boolean
-stab_typedef_type (p, name)
- PTR p;
- const char *name;
+static bfd_boolean
+stab_typedef_type (void *p, const char *name)
{
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);
- assert (h != NULL && h->index > 0);
+ h = string_hash_lookup (&info->typedef_hash, name, FALSE, FALSE);
+ if (h == NULL || h->index < 1)
+ return FALSE;
return stab_push_defined_type (info, h->index, h->size);
}
/* Push a struct, union or class tag. */
-static boolean
-stab_tag_type (p, name, id, kind)
- PTR p;
- const char *name;
- unsigned int id;
- enum debug_type_kind kind;
+static bfd_boolean
+stab_tag_type (void *p, const char *name, unsigned int id,
+ enum debug_type_kind kind)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- long index;
- unsigned int size;
+ long tindex;
+ unsigned int size = 0;
- index = stab_get_struct_index (info, name, id, kind, &size);
- if (index < 0)
- return false;
+ tindex = stab_get_struct_index (info, name, id, kind, &size);
+ if (tindex < 0)
+ return FALSE;
- return stab_push_defined_type (info, index, size);
+ return stab_push_defined_type (info, tindex, size);
}
/* Define a typedef. */
-static boolean
-stab_typdef (p, name)
- PTR p;
- const char *name;
+static bfd_boolean
+stab_typdef (void *p, const char *name)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- long index;
+ long tindex;
unsigned int size;
char *s, *buf;
struct string_hash_entry *h;
- index = info->type_stack->index;
+ tindex = 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)
+ if (tindex > 0)
sprintf (buf, "%s:t%s", name, s);
else
{
- index = info->type_index;
+ tindex = info->type_index;
++info->type_index;
- sprintf (buf, "%s:t%ld=%s", name, index, s);
+ sprintf (buf, "%s:t%ld=%s", name, tindex, s);
}
free (s);
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
- return false;
+ return FALSE;
free (buf);
- h = string_hash_lookup (&info->typedef_hash, name, true, false);
+ h = string_hash_lookup (&info->typedef_hash, name, TRUE, FALSE);
if (h == NULL)
{
non_fatal (_("string_hash_lookup failed: %s"),
bfd_errmsg (bfd_get_error ()));
- return false;
+ return FALSE;
}
/* I don't think we care about redefinitions. */
- h->index = index;
+ h->index = tindex;
h->size = size;
- return true;
+ return TRUE;
}
/* Define a tag. */
-static boolean
-stab_tag (p, tag)
- PTR p;
- const char *tag;
+static bfd_boolean
+stab_tag (void *p, const char *tag)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *s, *buf;
free (s);
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
- return false;
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Define an integer constant. */
-static boolean
-stab_int_constant (p, name, val)
- PTR p;
- const char *name;
- bfd_vma val;
+static bfd_boolean
+stab_int_constant (void *p, const char *name, bfd_vma val)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *buf;
sprintf (buf, "%s:c=i%ld", name, (long) val);
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
- return false;
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Define a floating point constant. */
-static boolean
-stab_float_constant (p, name, val)
- PTR p;
- const char *name;
- double val;
+static bfd_boolean
+stab_float_constant (void *p, const char *name, double val)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *buf;
sprintf (buf, "%s:c=f%g", name, val);
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
- return false;
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Define a typed constant. */
-static boolean
-stab_typed_constant (p, name, val)
- PTR p;
- const char *name;
- bfd_vma val;
+static bfd_boolean
+stab_typed_constant (void *p, const char *name, bfd_vma val)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *s, *buf;
free (s);
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
- return false;
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Record a variable. */
-static boolean
-stab_variable (p, name, kind, val)
- PTR p;
- const char *name;
- enum debug_var_kind kind;
- bfd_vma val;
+static bfd_boolean
+stab_variable (void *p, const char *name, enum debug_var_kind kind,
+ bfd_vma val)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *s, *buf;
if (! ISDIGIT (*s))
{
char *n;
- long index;
+ long tindex;
- index = info->type_index;
+ tindex = info->type_index;
++info->type_index;
n = (char *) xmalloc (strlen (s) + 20);
- sprintf (n, "%ld=%s", index, s);
+ sprintf (n, "%ld=%s", tindex, s);
free (s);
s = n;
}
free (s);
if (! stab_write_symbol (info, stab_type, 0, val, buf))
- return false;
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Start outputting a function. */
-static boolean
-stab_start_function (p, name, globalp)
- PTR p;
- const char *name;
- boolean globalp;
+static bfd_boolean
+stab_start_function (void *p, const char *name, bfd_boolean globalp)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *rettype, *buf;
- assert (info->nesting == 0 && info->fun_offset == -1);
+ if (info->nesting != 0 || info->fun_offset != -1)
+ return FALSE;
rettype = stab_pop_type (info);
info->fun_offset = info->symbols_size;
if (! stab_write_symbol (info, N_FUN, 0, 0, buf))
- return false;
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Output a function parameter. */
-static boolean
-stab_function_parameter (p, name, kind, val)
- PTR p;
- const char *name;
- enum debug_parm_kind kind;
- bfd_vma val;
+static bfd_boolean
+stab_function_parameter (void *p, const char *name, enum debug_parm_kind kind, bfd_vma val)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *s, *buf;
free (s);
if (! stab_write_symbol (info, stab_type, 0, val, buf))
- return false;
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Start a block. */
-static boolean
-stab_start_block (p, addr)
- PTR p;
- bfd_vma addr;
+static bfd_boolean
+stab_start_block (void *p, bfd_vma addr)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
if (info->nesting == 1)
{
info->fnaddr = addr;
- return true;
+ return TRUE;
}
/* We have to output the LBRAC symbol after any variables which are
{
if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac,
(const char *) NULL))
- return false;
+ return FALSE;
}
/* Remember the address and output it later. */
info->pending_lbrac = addr - info->fnaddr;
- return true;
+ return TRUE;
}
/* End a block. */
-static boolean
-stab_end_block (p, addr)
- PTR p;
- bfd_vma addr;
+static bfd_boolean
+stab_end_block (void *p, bfd_vma addr)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
{
if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac,
(const char *) NULL))
- return false;
+ return FALSE;
info->pending_lbrac = (bfd_vma) -1;
}
- assert (info->nesting > 0);
+ if (info->nesting < 1)
+ return FALSE;
--info->nesting;
/* We ignore the outermost block. */
if (info->nesting == 0)
- return true;
+ return TRUE;
return stab_write_symbol (info, N_RBRAC, 0, addr - info->fnaddr,
(const char *) NULL);
/* End a function. */
-static boolean
-stab_end_function (p)
- PTR p ATTRIBUTE_UNUSED;
+static bfd_boolean
+stab_end_function (void *p ATTRIBUTE_UNUSED)
{
- return true;
+ return TRUE;
}
/* Output a line number. */
-static boolean
-stab_lineno (p, file, lineno, addr)
- PTR p;
- const char *file;
- unsigned long lineno;
- bfd_vma addr;
+static bfd_boolean
+stab_lineno (void *p, const char *file, unsigned long lineno, bfd_vma addr)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- assert (info->lineno_filename != NULL);
+ if (info->lineno_filename == NULL)
+ return FALSE;
if (addr > info->last_text_address)
info->last_text_address = addr;
- if (strcmp (file, info->lineno_filename) != 0)
+ if (filename_cmp (file, info->lineno_filename) != 0)
{
if (! stab_write_symbol (info, N_SOL, 0, addr, file))
- return false;
+ return FALSE;
info->lineno_filename = file;
}
projects / deliverable / binutils-gdb.git / blobdiff