/* wrstabs.c -- Output stabs debugging information
- Copyright 1996, 1997, 1998, 2000, 2001 Free Software Foundation, Inc.
+ Copyright 1996, 1997, 1998, 2000, 2001, 2002
+ Free Software Foundation, Inc.
Written by Ian Lance Taylor <ian@cygnus.com>.
This file is part of GNU Binutils.
/* 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
+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 =
/* 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, 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
+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;
{
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;
+ 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);
p += strlen ((char *) p) + 1;
}
- return true;
+ 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))
{
non_fatal (_("stab_int_type: bad size %u"), size);
- return false;
+ 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;
/* 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;
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
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 ATTRIBUTE_UNUSED;
+ 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
+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);
}
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. */
-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;
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;
{
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)
{
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->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;
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. */
-static boolean
+static bfd_boolean
stab_end_function (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;
}