/* wrstabs.c -- Output stabs debugging information
- Copyright (C) 1996 Free Software Foundation, Inc.
+ Copyright 1996, 1997, 1998, 2000, 2001, 2002, 2003
+ Free Software Foundation, Inc.
Written by Ian Lance Taylor <ian@cygnus.com>.
This file is part of GNU Binutils.
information. */
#include <stdio.h>
-#include <ctype.h>
#include <assert.h>
#include "bfd.h"
#include "bucomm.h"
#include "libiberty.h"
+#include "safe-ctype.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"
struct string_hash_entry
{
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. */
/* 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
bfd_byte *symbols;
size_t symbols_size;
size_t symbols_alloc;
- /* This buffer holds the strings. */
- bfd_byte *strings;
+ /* 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;
- size_t strings_alloc;
/* This hash table eliminates duplicate strings. */
struct string_hash_table strhash;
/* The type stack. */
static struct bfd_hash_entry *string_hash_newfunc
PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
-static boolean stab_write_symbol
+static bfd_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,
+static bfd_boolean stab_push_string
+ PARAMS ((struct stab_write_handle *, const char *, long, bfd_boolean,
unsigned int));
-static boolean stab_push_defined_type
+static bfd_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
+static char *stab_pop_type
+ PARAMS ((struct stab_write_handle *));
+static bfd_boolean stab_modify_type
PARAMS ((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
+static bfd_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
+ bfd_boolean, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean));
+static bfd_boolean stab_start_compilation_unit
+ PARAMS ((PTR, const char *));
+static bfd_boolean stab_start_source
+ PARAMS ((PTR, const char *));
+static bfd_boolean stab_empty_type
+ PARAMS ((PTR));
+static bfd_boolean stab_void_type
+ PARAMS ((PTR));
+static bfd_boolean stab_int_type
+ PARAMS ((PTR, unsigned int, bfd_boolean));
+static bfd_boolean stab_float_type
+ PARAMS ((PTR, unsigned int));
+static bfd_boolean stab_complex_type
+ PARAMS ((PTR, unsigned int));
+static bfd_boolean stab_bool_type
+ PARAMS ((PTR, unsigned int));
+static bfd_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
+static bfd_boolean stab_pointer_type
+ PARAMS ((PTR));
+static bfd_boolean stab_function_type
+ PARAMS ((PTR, int, bfd_boolean));
+static bfd_boolean stab_reference_type
+ PARAMS ((PTR));
+static bfd_boolean stab_range_type
+ PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
+static bfd_boolean stab_array_type
+ PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, bfd_boolean));
+static bfd_boolean stab_set_type
+ PARAMS ((PTR, bfd_boolean));
+static bfd_boolean stab_offset_type
+ PARAMS ((PTR));
+static bfd_boolean stab_method_type
+ PARAMS ((PTR, bfd_boolean, int, bfd_boolean));
+static bfd_boolean stab_const_type
+ PARAMS ((PTR));
+static bfd_boolean stab_volatile_type
+ PARAMS ((PTR));
+static bfd_boolean stab_start_struct_type
+ PARAMS ((PTR, const char *, unsigned int, bfd_boolean, unsigned int));
+static bfd_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
+static bfd_boolean stab_end_struct_type
+ PARAMS ((PTR));
+static bfd_boolean stab_start_class_type
+ PARAMS ((PTR, const char *, unsigned int, bfd_boolean, unsigned int,
+ bfd_boolean, bfd_boolean));
+static bfd_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
+static bfd_boolean stab_class_baseclass
+ PARAMS ((PTR, bfd_vma, bfd_boolean, enum debug_visibility));
+static bfd_boolean stab_class_start_method
+ PARAMS ((PTR, const char *));
+static bfd_boolean stab_class_method_variant
+ PARAMS ((PTR, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
+ bfd_vma, bfd_boolean));
+static bfd_boolean stab_class_static_method_variant
+ PARAMS ((PTR, const char *, enum debug_visibility, bfd_boolean,
+ bfd_boolean));
+static bfd_boolean stab_class_end_method
+ PARAMS ((PTR));
+static bfd_boolean stab_end_class_type
+ PARAMS ((PTR));
+static bfd_boolean stab_typedef_type
+ PARAMS ((PTR, const char *));
+static bfd_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
+static bfd_boolean stab_typdef
+ PARAMS ((PTR, const char *));
+static bfd_boolean stab_tag
+ PARAMS ((PTR, const char *));
+static bfd_boolean stab_int_constant
+ PARAMS ((PTR, const char *, bfd_vma));
+static bfd_boolean stab_float_constant
+ PARAMS ((PTR, const char *, double));
+static bfd_boolean stab_typed_constant
+ PARAMS ((PTR, const char *, bfd_vma));
+static bfd_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
+static bfd_boolean stab_start_function
+ PARAMS ((PTR, const char *, bfd_boolean));
+static bfd_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
+static bfd_boolean stab_start_block
+ PARAMS ((PTR, bfd_vma));
+static bfd_boolean stab_end_block
+ PARAMS ((PTR, bfd_vma));
+static bfd_boolean stab_end_function
+ PARAMS ((PTR));
+static bfd_boolean stab_lineno
PARAMS ((PTR, const char *, unsigned long, bfd_vma));
static const struct debug_write_fns stab_fns =
if (ret)
{
/* Initialize the local fields. */
+ ret->next = NULL;
ret->index = -1;
ret->size = 0;
}
/* Add a symbol to the stabs debugging information we are building. */
-static boolean
+static bfd_boolean
stab_write_symbol (info, type, desc, value, string)
struct stab_write_handle *info;
int type;
{
struct string_hash_entry *h;
- h = string_hash_lookup (&info->strhash, string, true, false);
+ h = string_hash_lookup (&info->strhash, string, TRUE, TRUE);
if (h == NULL)
{
- fprintf (stderr, "string_hash_lookup failed: %s\n",
- bfd_errmsg (bfd_get_error ()));
- return false;
+ non_fatal (_("string_hash_lookup failed: %s"),
+ bfd_errmsg (bfd_get_error ()));
+ return FALSE;
}
if (h->index != -1)
strx = h->index;
else
{
- size_t len;
-
strx = info->strings_size;
h->index = strx;
-
- len = strlen (string);
- while (info->strings_size + len + 1 > info->strings_alloc)
- {
- info->strings_alloc *= 2;
- info->strings = (bfd_byte *) xrealloc (info->strings,
- info->strings_alloc);
- }
- strcpy (info->strings + info->strings_size, string);
- info->strings_size += len + 1;
+ if (info->last_string == NULL)
+ info->strings = h;
+ else
+ info->last_string->next = h;
+ info->last_string = h;
+ info->strings_size += strlen (string) + 1;
}
}
info->symbols_size += STAB_SYMBOL_SIZE;
- return true;
+ return TRUE;
}
/* Push a string on to the type stack. */
-static boolean
+static bfd_boolean
stab_push_string (info, string, index, definition, size)
struct stab_write_handle *info;
const char *string;
long index;
- boolean definition;
+ bfd_boolean definition;
unsigned int size;
{
struct stab_type_stack *s;
s->next = info->type_stack;
info->type_stack = s;
- return true;
+ return TRUE;
}
/* Push a type index which has already been defined. */
-static boolean
+static bfd_boolean
stab_push_defined_type (info, index, size)
struct stab_write_handle *info;
long index;
char buf[20];
sprintf (buf, "%ld", index);
- return stab_push_string (info, buf, index, false, size);
+ return stab_push_string (info, buf, index, FALSE, size);
}
/* Pop a type off the type stack. The caller is responsible for
the symbols, *PSYMSIZE the size of the symbols, *PSTRINGS to the
strings, and *PSTRINGSIZE to the size of the strings. */
-boolean
+bfd_boolean
write_stabs_in_sections_debugging_info (abfd, dhandle, psyms, psymsize,
pstrings, pstringsize)
bfd *abfd;
bfd_size_type *pstringsize;
{
struct stab_write_handle info;
+ struct string_hash_entry *h;
+ bfd_byte *p;
info.abfd = abfd;
info.symbols_alloc = 500;
info.symbols = (bfd_byte *) xmalloc (info.symbols_alloc);
+ info.strings = NULL;
+ info.last_string = NULL;
+ /* Reserve 1 byte for a null byte. */
info.strings_size = 1;
- info.strings_alloc = 500;
- info.strings = (bfd_byte *) xmalloc (info.strings_alloc);
- info.strings[0] = '\0';
if (! bfd_hash_table_init (&info.strhash.table, string_hash_newfunc)
|| ! bfd_hash_table_init (&info.typedef_hash.table, string_hash_newfunc))
{
- fprintf (stderr, "bfd_hash_table_init_failed: %s\n",
- bfd_errmsg (bfd_get_error ()));
- return false;
+ non_fatal ("bfd_hash_table_init_failed: %s",
+ bfd_errmsg (bfd_get_error ()));
+ 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;
+ return FALSE;
assert (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))
- return false;
+ return FALSE;
/* Put the string size in the initial symbol. */
bfd_put_32 (abfd, info.strings_size, info.symbols + 8);
*psyms = info.symbols;
*psymsize = info.symbols_size;
- *pstrings = info.strings;
*pstringsize = info.strings_size;
+ *pstrings = (bfd_byte *) xmalloc (info.strings_size);
- return true;
+ p = *pstrings;
+ *p++ = '\0';
+ for (h = info.strings; h != NULL; h = h->next)
+ {
+ strcpy ((char *) p, h->root.string);
+ p += strlen ((char *) p) + 1;
+ }
+
+ return TRUE;
}
/* Start writing out information for a compilation unit. */
-static boolean
+static bfd_boolean
stab_start_compilation_unit (p, filename)
PTR p;
const char *filename;
/* Start writing out information for a particular source file. */
-static boolean
+static bfd_boolean
stab_start_source (p, filename)
PTR p;
const char *filename;
/* Push an empty type. This shouldn't normally happen. We just use a
void type. */
-static boolean
+static bfd_boolean
stab_empty_type (p)
PTR p;
{
sprintf (buf, "%ld=%ld", index, index);
- return stab_push_string (info, buf, index, false, 0);
+ return stab_push_string (info, buf, index, FALSE, 0);
}
}
/* Push a void type. */
-static boolean
+static bfd_boolean
stab_void_type (p)
PTR p;
{
sprintf (buf, "%ld=%ld", index, index);
- return stab_push_string (info, buf, index, true, 0);
+ return stab_push_string (info, buf, index, TRUE, 0);
}
}
/* Push an integer type. */
-static boolean
+static bfd_boolean
stab_int_type (p, size, unsignedp)
PTR p;
unsigned int size;
- boolean unsignedp;
+ bfd_boolean unsignedp;
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
long *cache;
if (size <= 0 || (size > sizeof (long) && size != 8))
{
- fprintf (stderr, "stab_int_type: bad size %u\n", size);
- return false;
+ non_fatal (_("stab_int_type: bad size %u"), size);
+ return FALSE;
}
if (unsignedp)
abort ();
}
- return stab_push_string (info, buf, index, true, size);
+ return stab_push_string (info, buf, index, TRUE, size);
}
}
/* Push a floating point type. */
-static boolean
+static bfd_boolean
stab_float_type (p, size)
PTR p;
unsigned int size;
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;
free (int_type);
- return stab_push_string (info, buf, index, true, size);
+ return stab_push_string (info, buf, index, TRUE, size);
}
}
/* Push a complex type. */
-static boolean
+static bfd_boolean
stab_complex_type (p, size)
PTR p;
unsigned int size;
sprintf (buf, "%ld=r%ld;%u;0;", index, index, size);
- return stab_push_string (info, buf, index, true, size * 2);
+ return stab_push_string (info, buf, index, 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
+static bfd_boolean
stab_bool_type (p, size)
PTR p;
unsigned int size;
case 2:
index = -22;
break;
-
+
default:
case 4:
index = -16;
/* Push an enum type. */
-static boolean
+static bfd_boolean
stab_enum_type (p, tag, names, vals)
PTR p;
const char *tag;
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;
for (pn = names; *pn != NULL; pn++)
len += strlen (*pn) + 20;
+ buf = (char *) xmalloc (len);
+
if (tag == NULL)
strcpy (buf, "e");
else
sprintf (buf, "%s:T%ld=e", tag, index);
}
- buf = (char *) xmalloc (len);
for (pn = names, pv = vals; *pn != NULL; pn++, pv++)
sprintf (buf + strlen (buf), "%s:%ld,", *pn, (long) *pv);
strcat (buf, ";");
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;
+ 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
+static bfd_boolean
stab_modify_type (info, mod, size, cache, cache_alloc)
struct stab_write_handle *info;
int mod;
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
{
- if (targindex >= *cache_alloc)
+ if ((size_t) targindex >= *cache_alloc)
{
size_t alloc;
alloc = *cache_alloc;
if (alloc == 0)
alloc = 10;
- while (targindex >= alloc)
+ while ((size_t) targindex >= alloc)
alloc *= 2;
*cache = (long *) xrealloc (*cache, alloc * sizeof (long));
memset (*cache + *cache_alloc, 0,
}
index = (*cache)[targindex];
- if (index != 0)
+ if (index != 0 && ! info->type_stack->definition)
{
- /* If we have already defined a modification of this type,
- then the entry on the type stack can not be a definition,
- so we can safely discard it. */
- assert (! 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 false;
+ return FALSE;
}
else
{
(*cache)[targindex] = index;
- if (! stab_push_string (info, buf, index, true, size))
- return false;
+ if (! stab_push_string (info, buf, index, TRUE, size))
+ return FALSE;
free (buf);
}
}
- return true;
-}
+ return TRUE;
+}
/* Push a pointer type. */
-static boolean
+static bfd_boolean
stab_pointer_type (p)
PTR p;
{
/* Push a function type. */
-static boolean
+static bfd_boolean
stab_function_type (p, argcount, varargs)
PTR p;
int argcount;
- boolean varargs;
+ bfd_boolean varargs ATTRIBUTE_UNUSED;
{
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 meaningless typedefs. */
+ them. We do this by producing empty typedefs. */
for (i = 0; i < argcount; i++)
{
if (! info->type_stack->definition)
else
{
char *s, *buf;
- long index;
s = stab_pop_type (info);
- buf = (char *) xmalloc (strlen (s) + 40);
- index = info->type_index;
- ++info->type_index;
- sprintf (buf, "__fake_type_%ld:t%s", index, s);
-
+ buf = (char *) xmalloc (strlen (s) + 3);
+ sprintf (buf, ":t%s", s);
free (s);
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
- return false;
+ return FALSE;
free (buf);
}
/* Push a reference type. */
-static boolean
+static bfd_boolean
stab_reference_type (p)
PTR p;
{
/* Push a range type. */
-static boolean
+static bfd_boolean
stab_range_type (p, low, high)
PTR 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
+static bfd_boolean
stab_array_type (p, low, high, stringp)
PTR p;
bfd_signed_vma low;
bfd_signed_vma high;
- boolean stringp;
+ 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;
attribute. */
index = info->type_index;
++info->type_index;
- definition = true;
+ definition = TRUE;
sprintf (buf, "%ld=@S;", index);
}
- sprintf (buf + strlen (buf), "ar%s;%ld;%ld;%s", range, low, high, element);
+ sprintf (buf + strlen (buf), "ar%s;%ld;%ld;%s",
+ range, (long) low, (long) high, element);
free (range);
free (element);
- if (high <= low)
+ if (high < low)
size = 0;
else
size = element_size * ((high - low) + 1);
if (! stab_push_string (info, buf, index, definition, size))
- return false;
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Push a set type. */
-static boolean
+static bfd_boolean
stab_set_type (p, bitstringp)
PTR p;
- boolean bitstringp;
+ bfd_boolean bitstringp;
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- boolean definition;
+ bfd_boolean definition;
char *s, *buf;
long index;
attribute. */
index = info->type_index;
++info->type_index;
- definition = true;
+ definition = TRUE;
sprintf (buf, "%ld=@S;", index);
}
free (s);
if (! stab_push_string (info, buf, index, definition, 0))
- return false;
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Push an offset type. */
-static boolean
+static bfd_boolean
stab_offset_type (p)
PTR 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
+static bfd_boolean
stab_method_type (p, domainp, argcount, varargs)
PTR p;
- boolean domainp;
+ bfd_boolean domainp;
int argcount;
- boolean varargs;
+ 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;
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
+static bfd_boolean
stab_const_type (p)
PTR p;
{
/* Push a volatile version of a type. */
-static boolean
+static bfd_boolean
stab_volatile_type (p)
PTR p;
{
/* Start outputting a struct. We ignore the tag, and handle it in
stab_tag. */
-/*ARGSUSED*/
-static boolean
+static bfd_boolean
stab_start_struct_type (p, tag, id, structp, size)
PTR p;
const char *tag;
unsigned int id;
- boolean structp;
+ bfd_boolean structp;
unsigned int size;
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
long index;
- boolean definition;
+ bfd_boolean definition;
char *buf;
buf = (char *) xmalloc (40);
{
index = 0;
*buf = '\0';
- definition = false;
+ definition = FALSE;
}
else
{
index = stab_get_struct_index (info, tag, id, DEBUG_KIND_ILLEGAL,
&size);
if (index < 0)
- return false;
+ return FALSE;
sprintf (buf, "%ld=", index);
- definition = true;
+ definition = TRUE;
}
sprintf (buf + strlen (buf), "%c%u",
size);
if (! stab_push_string (info, buf, index, definition, size))
- return false;
+ 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
+static bfd_boolean
stab_struct_field (p, name, bitpos, bitsize, visibility)
PTR p;
const char *name;
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;
{
bitsize = size * 8;
if (bitsize == 0)
- fprintf (stderr,
- "%s: warning: unknown size for field `%s' in struct\n",
- bfd_get_filename (info->abfd), name);
+ non_fatal (_("%s: warning: unknown size for field `%s' in struct"),
+ bfd_get_filename (info->abfd), name);
}
sprintf (n, "%s%s:%s%s,%ld,%ld;", info->type_stack->fields, name, vis, 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
+static bfd_boolean
stab_end_struct_type (p)
PTR p;
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- boolean definition;
+ bfd_boolean definition;
long index;
unsigned int size;
char *fields, *first, *buf;
free (fields);
if (! stab_push_string (info, buf, index, definition, size))
- return false;
+ return FALSE;
free (buf);
- return true;
+ return TRUE;
}
/* Start outputting a class. */
-static boolean
+static bfd_boolean
stab_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
PTR p;
const char *tag;
unsigned int id;
- boolean structp;
+ bfd_boolean structp;
unsigned int size;
- boolean vptr;
- boolean ownvptr;
+ bfd_boolean vptr;
+ bfd_boolean ownvptr;
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- boolean definition;
+ bfd_boolean definition;
char *vstring;
if (! vptr || ownvptr)
{
- definition = false;
+ definition = FALSE;
vstring = NULL;
}
else
}
if (! stab_start_struct_type (p, tag, id, structp, size))
- return false;
+ return FALSE;
if (vptr)
{
}
if (definition)
- info->type_stack->definition = true;
+ info->type_stack->definition = TRUE;
- return true;
+ return TRUE;
}
/* Add a static member to the class on the type stack. */
-static boolean
+static bfd_boolean
stab_class_static_member (p, name, physname, visibility)
PTR p;
const char *name;
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;
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
+static bfd_boolean
stab_class_baseclass (p, bitpos, virtual, visibility)
PTR p;
bfd_vma bitpos;
- boolean virtual;
+ bfd_boolean 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;
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
+static bfd_boolean
stab_class_start_method (p, name)
PTR p;
const char *name;
info->type_stack->methods = m;
- return true;
+ return TRUE;
}
/* Add a variant, either static or not, to the current method. */
-static boolean
+static bfd_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_boolean staticp;
+ bfd_boolean constp;
+ bfd_boolean volatilep;
bfd_vma voffset;
- boolean contextp;
+ bfd_boolean contextp;
{
- boolean definition;
+ bfd_boolean definition;
char *type;
char *context = NULL;
char visc, qualc, typec;
}
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
+static bfd_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_boolean constp;
+ bfd_boolean volatilep;
bfd_vma voffset;
- boolean contextp;
+ 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
+static bfd_boolean
stab_class_static_method_variant (p, physname, visibility, constp, volatilep)
PTR p;
const char *physname;
enum debug_visibility visibility;
- boolean constp;
- boolean volatilep;
+ 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
+static bfd_boolean
stab_class_end_method (p)
PTR p;
{
trailing semicolon. */
strcat (info->type_stack->methods, ";");
- return true;
+ return TRUE;
}
/* Finish up a class. */
-static boolean
+static bfd_boolean
stab_end_class_type (p)
PTR p;
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
size_t len;
- unsigned int i;
+ unsigned int i = 0;
char *buf;
assert (info->type_stack != NULL && info->type_stack->fields != NULL);
free (info->type_stack->string);
info->type_stack->string = buf;
- return true;
+ return TRUE;
}
/* Push a typedef which was previously defined. */
-static boolean
+static bfd_boolean
stab_typedef_type (p, name)
PTR 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);
+ h = string_hash_lookup (&info->typedef_hash, name, FALSE, FALSE);
assert (h != NULL && h->index > 0);
return stab_push_defined_type (info, h->index, h->size);
/* Push a struct, union or class tag. */
-static boolean
+static bfd_boolean
stab_tag_type (p, name, id, kind)
PTR p;
const char *name;
index = stab_get_struct_index (info, name, id, kind, &size);
if (index < 0)
- return false;
+ return FALSE;
return stab_push_defined_type (info, index, size);
}
/* Define a typedef. */
-static boolean
+static bfd_boolean
stab_typdef (p, name)
PTR p;
const char *name;
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)
{
- fprintf (stderr, "string_hash_lookup failed: %s\n",
- bfd_errmsg (bfd_get_error ()));
- return false;
+ non_fatal (_("string_hash_lookup failed: %s"),
+ bfd_errmsg (bfd_get_error ()));
+ return FALSE;
}
/* I don't think we care about redefinitions. */
h->index = index;
h->size = size;
- return true;
+ return TRUE;
}
/* Define a tag. */
-static boolean
+static bfd_boolean
stab_tag (p, tag)
PTR p;
const char *tag;
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
+static bfd_boolean
stab_int_constant (p, name, val)
PTR p;
const char *name;
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
+static bfd_boolean
stab_float_constant (p, name, val)
PTR p;
const char *name;
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
+static bfd_boolean
stab_typed_constant (p, name, val)
PTR p;
const char *name;
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
+static bfd_boolean
stab_variable (p, name, kind, val)
PTR p;
const char *name;
kindstr = "";
/* Make sure that this is a type reference or definition. */
- if (! isdigit (*s))
+ if (! ISDIGIT (*s))
{
char *n;
long index;
break;
case DEBUG_REGISTER:
- stab_type = N_LSYM;
+ stab_type = N_RSYM;
kindstr = "r";
break;
}
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
+static bfd_boolean
stab_start_function (p, name, globalp)
PTR p;
const char *name;
- boolean globalp;
+ bfd_boolean globalp;
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *rettype, *buf;
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
+static bfd_boolean
stab_function_parameter (p, name, kind, val)
PTR p;
const char *name;
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
+static bfd_boolean
stab_start_block (p, addr)
PTR p;
bfd_vma addr;
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
+static bfd_boolean
stab_end_block (p, addr)
PTR p;
bfd_vma addr;
{
if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac,
(const char *) NULL))
- return false;
+ return FALSE;
info->pending_lbrac = (bfd_vma) -1;
}
/* 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. */
-/*ARGSUSED*/
-static boolean
+static bfd_boolean
stab_end_function (p)
- PTR p;
+ PTR p ATTRIBUTE_UNUSED;
{
- return true;
+ return TRUE;
}
/* Output a line number. */
-static boolean
+static bfd_boolean
stab_lineno (p, file, lineno, addr)
PTR p;
const char *file;
if (strcmp (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