/* ieee.c -- Read and write IEEE-695 debugging information.
- Copyright (C) 1996 Free Software Foundation, Inc.
+ Copyright 1996, 1998, 2000, 2001 Free Software Foundation, Inc.
Written by Ian Lance Taylor <ian@cygnus.com>.
This file is part of GNU Binutils.
#include "libiberty.h"
#include "debug.h"
#include "budbg.h"
+#include "filenames.h"
/* This structure holds an entry on the block stack. */
struct ieee_info *info;
{
ieee_error (info, (const bfd_byte *) NULL,
- "unexpected end of debugging information");
+ _("unexpected end of debugging information"));
}
/* Save a string in memory. */
return true;
}
- ieee_error (info, *pp - 1, "invalid number");
- return false;
+ ieee_error (info, *pp - 1, _("invalid number"));
+ return false;
}
/* Read a required string from an IEEE file. */
*ppresent = false;
return true;
}
- ieee_error (info, *pp - 1, "invalid string length");
+ ieee_error (info, *pp - 1, _("invalid string length"));
return false;
}
{
if (esp - expr_stack >= EXPR_STACK_SIZE)
{
- ieee_error (info, start, "expression stack overflow");
+ ieee_error (info, start, _("expression stack overflow"));
return false;
}
*esp++ = val;
switch (c)
{
default:
- ieee_error (info, start, "unsupported IEEE expression operator");
+ ieee_error (info, start, _("unsupported IEEE expression operator"));
break;
case ieee_variable_R_enum:
break;
if (s == NULL)
{
- ieee_error (info, start, "unknown section");
+ ieee_error (info, start, _("unknown section"));
return false;
}
-
+
if (esp - expr_stack >= EXPR_STACK_SIZE)
{
- ieee_error (info, start, "expression stack overflow");
+ ieee_error (info, start, _("expression stack overflow"));
return false;
}
if (esp - expr_stack < 2)
{
- ieee_error (info, start, "expression stack underflow");
+ ieee_error (info, start, _("expression stack underflow"));
return false;
}
if (esp - 1 != expr_stack)
{
- ieee_error (info, expr_start, "expression stack mismatch");
+ ieee_error (info, expr_start, _("expression stack mismatch"));
return false;
}
switch ((enum builtin_types) indx)
{
default:
- ieee_error (info, p, "unknown builtin type");
+ ieee_error (info, p, _("unknown builtin type"));
return NULL;
case builtin_unknown:
break;
case builtin_bcd_float:
- ieee_error (info, p, "BCD float type not supported");
- return false;
+ ieee_error (info, p, _("BCD float type not supported"));
+ return DEBUG_TYPE_NULL;
}
if (name != NULL)
info.saw_filename = false;
info.vars.alloc = 0;
info.vars.vars = NULL;
+ info.global_vars = NULL;
info.types.alloc = 0;
info.types.types = NULL;
+ info.global_types = NULL;
info.tags = NULL;
for (i = 0; i < BUILTIN_TYPE_COUNT; i++)
info.types.builtins[i] = DEBUG_TYPE_NULL;
if (c <= ieee_number_repeat_end_enum)
{
- ieee_error (&info, record_start, "unexpected number");
+ ieee_error (&info, record_start, _("unexpected number"));
return false;
}
switch (c)
{
default:
- ieee_error (&info, record_start, "unexpected record type");
+ ieee_error (&info, record_start, _("unexpected record type"));
return false;
case ieee_bb_record_enum:
if (info.blockstack.bsp != info.blockstack.stack)
{
ieee_error (&info, (const bfd_byte *) NULL,
- "blocks left on stack at end");
+ _("blocks left on stack at end"));
return false;
}
bfd_vma size;
const char *name;
unsigned long namlen;
- char *namcopy;
+ char *namcopy = NULL;
unsigned int fnindx;
boolean skip;
break;
default:
- ieee_error (info, block_start, "unknown BB type");
+ ieee_error (info, block_start, _("unknown BB type"));
return false;
}
if (info->blockstack.bsp >= info->blockstack.stack + BLOCKSTACK_SIZE)
{
- ieee_error (info, (const bfd_byte *) NULL, "stack overflow");
+ ieee_error (info, (const bfd_byte *) NULL, _("stack overflow"));
return false;
}
if (info->blockstack.bsp <= info->blockstack.stack)
{
- ieee_error (info, *pp, "stack underflow");
+ ieee_error (info, *pp, _("stack underflow"));
return false;
}
--info->blockstack.bsp;
if (varindx < 32)
{
- ieee_error (info, nn_start, "illegal variable index");
+ ieee_error (info, nn_start, _("illegal variable index"));
return false;
}
varindx -= 32;
if (typeindx < 256)
{
- ieee_error (info, ty_start, "illegal type index");
+ ieee_error (info, ty_start, _("illegal type index"));
return false;
}
if (**pp != 0xce)
{
- ieee_error (info, *pp, "unknown TY code");
+ ieee_error (info, *pp, _("unknown TY code"));
return false;
}
++*pp;
if (varindx < 32)
{
- ieee_error (info, ty_var_start, "illegal variable index");
+ ieee_error (info, ty_var_start, _("illegal variable index"));
return false;
}
varindx -= 32;
if (varindx >= info->vars.alloc || info->vars.vars[varindx].name == NULL)
{
- ieee_error (info, ty_var_start, "undefined variable in TY");
+ ieee_error (info, ty_var_start, _("undefined variable in TY"));
return false;
}
switch (tc)
{
default:
- ieee_error (info, ty_code_start, "unknown TY code");
+ ieee_error (info, ty_code_start, _("unknown TY code"));
return false;
case '!':
case 'f':
/* Pascal file name. FIXME. */
- ieee_error (info, ty_code_start, "Pascal file name not supported");
+ ieee_error (info, ty_code_start, _("Pascal file name not supported"));
return false;
case 'g':
switch (kind)
{
default:
- ieee_error (info, ty_start, "unsupported qualifer");
+ ieee_error (info, ty_start, _("unsupported qualifer"));
return false;
case 1:
}
else if (varindx < 32)
{
- ieee_error (info, atn_start, "illegal variable index");
+ /* The MRI compiler reportedly sometimes emits variable lifetime
+ information for a register. We just ignore it. */
+ if (atn_code == 9)
+ return ieee_read_number (info, pp, &v);
+
+ ieee_error (info, atn_start, _("illegal variable index"));
return false;
}
else
}
else
{
- ieee_error (info, atn_start, "undefined variable in ATN");
+ ieee_error (info, atn_start, _("undefined variable in ATN"));
return false;
}
}
switch (atn_code)
{
default:
- ieee_error (info, atn_code_start, "unknown ATN type");
+ ieee_error (info, atn_code_start, _("unknown ATN type"));
return false;
case 1:
case 11:
/* Reserved for FORTRAN common. */
- ieee_error (info, atn_code_start, "unsupported ATN11");
+ ieee_error (info, atn_code_start, _("unsupported ATN11"));
/* Return true to keep going. */
return true;
/* We have no way to record this information. FIXME. */
- ieee_error (info, atn_code_start, "unsupported ATN12");
+ ieee_error (info, atn_code_start, _("unsupported ATN12"));
/* Return true to keep going. */
return true;
if (present)
{
ieee_error (info, atn_code_start,
- "unexpected string in C++ misc");
+ _("unexpected string in C++ misc"));
return false;
}
return ieee_read_cxx_misc (info, pp, v2);
switch ((ieee_record_enum_type) **pp)
{
default:
- ieee_error (info, *pp, "bad misc record");
+ ieee_error (info, *pp, _("bad misc record"));
return false;
case ieee_at_record_enum:
switch (category)
{
default:
- ieee_error (info, start, "unrecognized C++ misc record");
+ ieee_error (info, start, _("unrecognized C++ misc record"));
return false;
case 'T':
break;
if (it == NULL)
{
- ieee_error (info, start, "undefined C++ object");
+ ieee_error (info, start, _("undefined C++ object"));
return false;
}
switch (id)
{
default:
- ieee_error (info, spec_start, "unrecognized C++ object spec");
+ ieee_error (info, spec_start, _("unrecognized C++ object spec"));
return false;
case 'b':
if ((fieldlen == 0) == (cinline == 0))
{
- ieee_error (info, start, "unsupported C++ object type");
+ ieee_error (info, start, _("unsupported C++ object type"));
return false;
}
free (basecopy);
if (basetype == DEBUG_TYPE_NULL)
{
- ieee_error (info, start, "C++ base class not defined");
+ ieee_error (info, start, _("C++ base class not defined"));
return false;
}
if (structfields == NULL)
{
- ieee_error (info, start, "C++ object has no fields");
+ ieee_error (info, start, _("C++ object has no fields"));
return false;
}
if (*pf == DEBUG_FIELD_NULL)
{
ieee_error (info, start,
- "C++ base class not found in container");
+ _("C++ base class not found in container"));
return false;
}
char *fieldcopy;
boolean staticp;
debug_type ftype;
- const debug_field *pf;
+ const debug_field *pf = NULL;
enum debug_visibility visibility;
debug_field field;
if (structfields == NULL)
{
- ieee_error (info, start, "C++ object has no fields");
+ ieee_error (info, start, _("C++ object has no fields"));
return false;
}
if (*pf == DEBUG_FIELD_NULL)
{
ieee_error (info, start,
- "C++ data member not found in container");
+ _("C++ data member not found in container"));
return false;
}
switch (flags & CXXFLAGS_VISIBILITY)
{
default:
- ieee_error (info, start, "unknown C++ visibility");
+ ieee_error (info, start, _("unknown C++ visibility"));
return false;
case CXXFLAGS_VISIBILITY_PUBLIC:
bitsize = debug_get_field_bitsize (dhandle, *pf);
if (bitpos == (bfd_vma) -1 || bitsize == (bfd_vma) -1)
{
- ieee_error (info, start, "bad C++ field bit pos or size");
+ ieee_error (info, start, _("bad C++ field bit pos or size"));
return false;
}
field = debug_make_field (dhandle, fieldcopy, ftype, bitpos,
!= DEBUG_KIND_FUNCTION)
{
ieee_error (info, start,
- "bad type for C++ method function");
+ _("bad type for C++ method function"));
return false;
}
if (return_type == DEBUG_TYPE_NULL || arg_types == NULL)
{
ieee_error (info, start,
- "no type information for C++ method function");
+ _("no type information for C++ method function"));
return false;
}
switch (flags & CXXFLAGS_VISIBILITY)
{
default:
- ieee_error (info, start, "unknown C++ visibility");
+ ieee_error (info, start, _("unknown C++ visibility"));
return false;
case CXXFLAGS_VISIBILITY_PUBLIC:
{
if (id == 'v')
{
- ieee_error (info, start, "C++ static virtual method");
+ ieee_error (info, start, _("C++ static virtual method"));
return false;
}
mv = debug_make_static_method_variant (dhandle, mangledcopy,
else
{
ieee_error (info, start,
- "unrecognized C++ object overhead spec");
+ _("unrecognized C++ object overhead spec"));
return false;
}
}
free (basecopy);
if (vptrbase == DEBUG_TYPE_NULL)
{
- ieee_error (info, start, "undefined C++ vtable");
+ ieee_error (info, start, _("undefined C++ vtable"));
return false;
}
}
if (info->blockstack.bsp <= info->blockstack.stack
|| info->blockstack.bsp[-1].fnindx == (unsigned int) -1)
{
- ieee_error (info, start, "C++ default values not in a function");
+ ieee_error (info, start, _("C++ default values not in a function"));
return false;
}
break;
default:
- ieee_error (info, start, "unrecognized C++ default type");
+ ieee_error (info, start, _("unrecognized C++ default type"));
return false;
}
|| (debug_get_type_kind (dhandle, arg_slots[indx])
!= DEBUG_KIND_POINTER))
{
- ieee_error (info, start, "reference parameter is not a pointer");
+ ieee_error (info, start, _("reference parameter is not a pointer"));
return false;
}
{
default:
ieee_error (info, start,
- "unrecognized C++ reference type");
+ _("unrecognized C++ reference type"));
return false;
case 0:
if (pslot == NULL)
{
- ieee_error (info, start, "C++ reference not found");
+ ieee_error (info, start, _("C++ reference not found"));
return false;
}
to *pslot, which we can now update to be a reference type. */
if (debug_get_type_kind (info->dhandle, *pslot) != DEBUG_KIND_POINTER)
{
- ieee_error (info, start, "C++ reference is not pointer");
+ ieee_error (info, start, _("C++ reference is not pointer"));
return false;
}
c = (ieee_record_enum_type) **pp;
if (c != ieee_e2_first_byte_enum)
{
- ieee_error (info, start, "missing required ASN");
+ ieee_error (info, start, _("missing required ASN"));
return false;
}
++*pp;
c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
if (c != ieee_asn_record_enum)
{
- ieee_error (info, start, "missing required ASN");
+ ieee_error (info, start, _("missing required ASN"));
return false;
}
++*pp;
c = (ieee_record_enum_type) **pp;
if (c != ieee_at_record_enum)
{
- ieee_error (info, start, "missing required ATN65");
+ ieee_error (info, start, _("missing required ATN65"));
return false;
}
++*pp;
c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
if (c != ieee_atn_record_enum)
{
- ieee_error (info, start, "missing required ATN65");
+ ieee_error (info, start, _("missing required ATN65"));
return false;
}
++*pp;
if (type_indx != 0 || atn_code != 65)
{
- ieee_error (info, start, "bad ATN65 record");
+ ieee_error (info, start, _("bad ATN65 record"));
return false;
}
/*ARGSUSED*/
static boolean
ieee_init_buffer (info, buflist)
- struct ieee_handle *info;
+ struct ieee_handle *info ATTRIBUTE_UNUSED;
struct ieee_buflist *buflist;
{
buflist->head = NULL;
/*ARGSUSED*/
static boolean
ieee_append_buffer (info, mainbuf, newbuf)
- struct ieee_handle *info;
+ struct ieee_handle *info ATTRIBUTE_UNUSED;
struct ieee_buflist *mainbuf;
struct ieee_buflist *newbuf;
{
if (c > (unsigned int) (ieee_number_repeat_end_enum
- ieee_number_repeat_start_enum))
{
- fprintf (stderr, "IEEE numeric overflow: 0x");
+ fprintf (stderr, _("IEEE numeric overflow: 0x"));
fprintf_vma (stderr, v);
fprintf (stderr, "\n");
return false;
}
else
{
- fprintf (stderr, "IEEE string length overflow: %u\n", len);
+ fprintf (stderr, _("IEEE string length overflow: %u\n"), len);
return false;
}
r->next = info->pending_ranges;
info->pending_ranges = r;
return true;
-}
+}
/* Finish a range started by ieee_start_range. */
{
struct ieee_handle *info = (struct ieee_handle *) p;
const char *modname;
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+ const char *backslash;
+#endif
char *c, *s;
unsigned int nindx;
info->filename = filename;
modname = strrchr (filename, '/');
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+ /* We could have a mixed forward/back slash case. */
+ backslash = strrchr (filename, '\\');
+ if (modname == NULL || (backslash != NULL && backslash > modname))
+ modname = backslash;
+#endif
+
if (modname != NULL)
++modname;
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+ else if (filename[0] && filename[1] == ':')
+ modname = filename + 2;
+#endif
else
- {
- modname = strrchr (filename, '\\');
- if (modname != NULL)
- ++modname;
- else
- modname = filename;
- }
+ modname = filename;
+
c = xstrdup (modname);
s = strrchr (c, '.');
if (s != NULL)
static void
ieee_add_bb11_blocks (abfd, sec, data)
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
asection *sec;
PTR data;
{
else
{
const char *filename, *modname;
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+ const char *backslash;
+#endif
char *c, *s;
/* Start the enclosing BB10 block. */
filename = bfd_get_filename (info->abfd);
modname = strrchr (filename, '/');
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+ backslash = strrchr (filename, '\\');
+ if (modname == NULL || (backslash != NULL && backslash > modname))
+ modname = backslash;
+#endif
+
if (modname != NULL)
++modname;
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+ else if (filename[0] && filename[1] == ':')
+ modname = filename + 2;
+#endif
else
- {
- modname = strrchr (filename, '\\');
- if (modname != NULL)
- ++modname;
- else
- modname = filename;
- }
+ modname = filename;
+
c = xstrdup (modname);
s = strrchr (c, '.');
if (s != NULL)
/*ARGSUSED*/
static boolean
ieee_start_source (p, filename)
- PTR p;
- const char *filename;
+ PTR p ATTRIBUTE_UNUSED;
+ const char *filename ATTRIBUTE_UNUSED;
{
return true;
}
indx = (int) builtin_signed_long_long;
break;
default:
- fprintf (stderr, "IEEE unsupported integer type size %u\n", size);
+ fprintf (stderr, _("IEEE unsupported integer type size %u\n"), size);
return false;
}
indx = (int) builtin_long_long_double;
break;
default:
- fprintf (stderr, "IEEE unsupported float type size %u\n", size);
+ fprintf (stderr, _("IEEE unsupported float type size %u\n"), size);
return false;
}
code = 'd';
break;
default:
- fprintf (stderr, "IEEE unsupported complex type size %u\n", size);
+ fprintf (stderr, _("IEEE unsupported complex type size %u\n"), size);
return false;
}
struct ieee_defined_enum *e;
boolean localp, simple;
unsigned int indx;
- int i;
+ int i = 0;
localp = false;
indx = (unsigned int) -1;
PTR p;
bfd_signed_vma low;
bfd_signed_vma high;
- boolean stringp;
+ boolean stringp ATTRIBUTE_UNUSED;
{
struct ieee_handle *info = (struct ieee_handle *) p;
unsigned int eleindx;
static boolean
ieee_set_type (p, bitstringp)
PTR p;
- boolean bitstringp;
+ boolean bitstringp ATTRIBUTE_UNUSED;
{
struct ieee_handle *info = (struct ieee_handle *) p;
boolean localp;
which seems pretty important. I'm going to punt this for now. */
return ieee_int_type (p, 4, true);
-}
+}
/* Make a method type. */
static boolean
ieee_tag (p, name)
PTR p;
- const char *name;
+ const char *name ATTRIBUTE_UNUSED;
{
struct ieee_handle *info = (struct ieee_handle *) p;
static boolean
ieee_int_constant (p, name, val)
- PTR p;
- const char *name;
- bfd_vma val;
+ PTR p ATTRIBUTE_UNUSED;
+ const char *name ATTRIBUTE_UNUSED;
+ bfd_vma val ATTRIBUTE_UNUSED;
{
/* FIXME. */
return true;
static boolean
ieee_float_constant (p, name, val)
- PTR p;
- const char *name;
- double val;
+ PTR p ATTRIBUTE_UNUSED;
+ const char *name ATTRIBUTE_UNUSED;
+ double val ATTRIBUTE_UNUSED;
{
/* FIXME. */
return true;
static boolean
ieee_typed_constant (p, name, val)
PTR p;
- const char *name;
- bfd_vma val;
+ const char *name ATTRIBUTE_UNUSED;
+ bfd_vma val ATTRIBUTE_UNUSED;
{
struct ieee_handle *info = (struct ieee_handle *) p;
return false;
++info->fnargcount;
- return true;
+ return true;
}
/* Output pending function parameters. */
return false;
}
- if (addr < info->highaddr)
- {
- info->pending_lineno_filename = filename;
- info->pending_lineno = lineno;
- info->pending_lineno_addr = addr;
- }
+ info->pending_lineno_filename = filename;
+ info->pending_lineno = lineno;
+ info->pending_lineno_addr = addr;
return true;
}
projects / deliverable / binutils-gdb.git / blobdiff