Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Enumerations | Functions | Variables
ieee.c File Reference
#include <stdio.h>
#include <assert.h>
#include "bfd.h"
#include "ieee.h"
#include "bucomm.h"
#include "libiberty.h"
#include "debug.h"
#include "budbg.h"
#include "filenames.h"

Go to the source code of this file.

Classes

struct  ieee_block
struct  ieee_blockstack
struct  ieee_var
struct  ieee_vars
struct  ieee_type
struct  ieee_types
struct  ieee_tag
struct  ieee_info
struct  ieee_buf
struct  ieee_buflist
struct  ieee_range
struct  ieee_type_class
struct  ieee_write_type
struct  ieee_type_stack
struct  ieee_name_type
struct  ieee_name_type_hash_table
struct  ieee_name_type_hash_entry
struct  ieee_defined_enum
struct  ieee_modified_type
struct  ieee_modified_array_type
struct  ieee_pending_parm
struct  ieee_handle

Defines

#define BLOCKSTACK_SIZE   (16)
#define BUILTIN_TYPE_COUNT   (60)
#define BASEFLAGS_PRIVATE   (0x1)
#define BASEFLAGS_VIRTUAL   (0x2)
#define BASEFLAGS_FRIEND   (0x10)
#define CXXFLAGS_VISIBILITY   (0x3)
#define CXXFLAGS_VISIBILITY_PUBLIC   (0x0)
#define CXXFLAGS_VISIBILITY_PRIVATE   (0x1)
#define CXXFLAGS_VISIBILITY_PROTECTED   (0x2)
#define CXXFLAGS_STATIC   (0x4)
#define CXXFLAGS_OVERRIDE   (0x8)
#define CXXFLAGS_FRIEND   (0x10)
#define CXXFLAGS_CONST   (0x20)
#define CXXFLAGS_VOLATILE   (0x40)
#define CXXFLAGS_OVERLOADED   (0x80)
#define CXXFLAGS_OPERATOR   (0x100)
#define CXXFLAGS_CTORDTOR   (0x400)
#define CXXFLAGS_CTOR   (0x200)
#define CXXFLAGS_INLINE   (0x800)
#define EXPR_STACK_SIZE   (10)
#define IEEE_BUFSIZE   (490)
#define ieee_buffer_emptyp(buflist)   ((buflist)->head == NULL)
#define ieee_write_byte(info, b)
#define ieee_name_type_hash_lookup(table, string, create, copy)
#define ieee_name_type_hash_traverse(table, func, info)

Enumerations

enum  builtin_types {
  builtin_unknown = 0, builtin_void = 1, builtin_signed_char = 2, builtin_unsigned_char = 3,
  builtin_signed_short_int = 4, builtin_unsigned_short_int = 5, builtin_signed_long = 6, builtin_unsigned_long = 7,
  builtin_signed_long_long = 8, builtin_unsigned_long_long = 9, builtin_float = 10, builtin_double = 11,
  builtin_long_double = 12, builtin_long_long_double = 13, builtin_quoted_string = 14, builtin_instruction_address = 15,
  builtin_int = 16, builtin_unsigned = 17, builtin_unsigned_int = 18, builtin_char = 19,
  builtin_long = 20, builtin_short = 21, builtin_unsigned_short = 22, builtin_short_int = 23,
  builtin_signed_short = 24, builtin_bcd_float = 25
}

Functions

static void ieee_error (struct ieee_info *, const bfd_byte *, const char *)
static void ieee_eof (struct ieee_info *)
static char * savestring (const char *, unsigned long)
static bfd_boolean ieee_read_number (struct ieee_info *, const bfd_byte **, bfd_vma *)
static bfd_boolean ieee_read_optional_number (struct ieee_info *, const bfd_byte **, bfd_vma *, bfd_boolean *)
static bfd_boolean ieee_read_id (struct ieee_info *, const bfd_byte **, const char **, unsigned long *)
static bfd_boolean ieee_read_optional_id (struct ieee_info *, const bfd_byte **, const char **, unsigned long *, bfd_boolean *)
static bfd_boolean ieee_read_expression (struct ieee_info *, const bfd_byte **, bfd_vma *)
static debug_type ieee_builtin_type (struct ieee_info *, const bfd_byte *, unsigned int)
static bfd_boolean ieee_alloc_type (struct ieee_info *, unsigned int, bfd_boolean)
static bfd_boolean ieee_read_type_index (struct ieee_info *, const bfd_byte **, debug_type *)
static int ieee_regno_to_genreg (bfd *, int)
static int ieee_genreg_to_regno (bfd *, int)
static bfd_boolean parse_ieee_bb (struct ieee_info *, const bfd_byte **)
static bfd_boolean parse_ieee_be (struct ieee_info *, const bfd_byte **)
static bfd_boolean parse_ieee_nn (struct ieee_info *, const bfd_byte **)
static bfd_boolean parse_ieee_ty (struct ieee_info *, const bfd_byte **)
static bfd_boolean parse_ieee_atn (struct ieee_info *, const bfd_byte **)
static bfd_boolean ieee_read_cxx_misc (struct ieee_info *, const bfd_byte **, unsigned long)
static bfd_boolean ieee_read_cxx_class (struct ieee_info *, const bfd_byte **, unsigned long)
static bfd_boolean ieee_read_cxx_defaults (struct ieee_info *, const bfd_byte **, unsigned long)
static bfd_boolean ieee_read_reference (struct ieee_info *, const bfd_byte **)
static bfd_boolean ieee_require_asn (struct ieee_info *, const bfd_byte **, bfd_vma *)
static bfd_boolean ieee_require_atn65 (struct ieee_info *, const bfd_byte **, const char **, unsigned long *)
bfd_boolean parse_ieee (void *dhandle, bfd *abfd, const bfd_byte *bytes, bfd_size_type len)
static bfd_boolean ieee_init_buffer (struct ieee_handle *, struct ieee_buflist *)
static bfd_boolean ieee_change_buffer (struct ieee_handle *, struct ieee_buflist *)
static bfd_boolean ieee_append_buffer (struct ieee_handle *, struct ieee_buflist *, struct ieee_buflist *)
static bfd_boolean ieee_real_write_byte (struct ieee_handle *, int)
static bfd_boolean ieee_write_2bytes (struct ieee_handle *, int)
static bfd_boolean ieee_write_number (struct ieee_handle *, bfd_vma)
static bfd_boolean ieee_write_id (struct ieee_handle *, const char *)
static bfd_boolean ieee_write_asn (struct ieee_handle *, unsigned int, bfd_vma)
static bfd_boolean ieee_write_atn65 (struct ieee_handle *, unsigned int, const char *)
static bfd_boolean ieee_push_type (struct ieee_handle *, unsigned int, unsigned int, bfd_boolean, bfd_boolean)
static unsigned int ieee_pop_type (struct ieee_handle *)
static void ieee_pop_unused_type (struct ieee_handle *)
static unsigned int ieee_pop_type_used (struct ieee_handle *, bfd_boolean)
static bfd_boolean ieee_add_range (struct ieee_handle *, bfd_boolean, bfd_vma, bfd_vma)
static bfd_boolean ieee_start_range (struct ieee_handle *, bfd_vma)
static bfd_boolean ieee_end_range (struct ieee_handle *, bfd_vma)
static bfd_boolean ieee_define_type (struct ieee_handle *, unsigned int, bfd_boolean, bfd_boolean)
static bfd_boolean ieee_define_named_type (struct ieee_handle *, const char *, unsigned int, unsigned int, bfd_boolean, bfd_boolean, struct ieee_buflist *)
static struct ieee_modified_typeieee_get_modified_info (struct ieee_handle *, unsigned int)
static struct bfd_hash_entryieee_name_type_newfunc (struct bfd_hash_entry *, struct bfd_hash_table *, const char *)
static bfd_boolean ieee_write_undefined_tag (struct ieee_name_type_hash_entry *, void *)
static bfd_boolean ieee_finish_compilation_unit (struct ieee_handle *)
static void ieee_add_bb11_blocks (bfd *, asection *, void *)
static bfd_boolean ieee_add_bb11 (struct ieee_handle *, asection *, bfd_vma, bfd_vma)
static bfd_boolean ieee_output_pending_parms (struct ieee_handle *)
static unsigned int ieee_vis_to_flags (enum debug_visibility)
static bfd_boolean ieee_class_method_var (struct ieee_handle *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean)
static bfd_boolean ieee_start_compilation_unit (void *, const char *)
static bfd_boolean ieee_start_source (void *, const char *)
static bfd_boolean ieee_empty_type (void *)
static bfd_boolean ieee_void_type (void *)
static bfd_boolean ieee_int_type (void *, unsigned int, bfd_boolean)
static bfd_boolean ieee_float_type (void *, unsigned int)
static bfd_boolean ieee_complex_type (void *, unsigned int)
static bfd_boolean ieee_bool_type (void *, unsigned int)
static bfd_boolean ieee_enum_type (void *, const char *, const char **, bfd_signed_vma *)
static bfd_boolean ieee_pointer_type (void *)
static bfd_boolean ieee_function_type (void *, int, bfd_boolean)
static bfd_boolean ieee_reference_type (void *)
static bfd_boolean ieee_range_type (void *, bfd_signed_vma, bfd_signed_vma)
static bfd_boolean ieee_array_type (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean)
static bfd_boolean ieee_set_type (void *, bfd_boolean)
static bfd_boolean ieee_offset_type (void *)
static bfd_boolean ieee_method_type (void *, bfd_boolean, int, bfd_boolean)
static bfd_boolean ieee_const_type (void *)
static bfd_boolean ieee_volatile_type (void *)
static bfd_boolean ieee_start_struct_type (void *, const char *, unsigned int, bfd_boolean, unsigned int)
static bfd_boolean ieee_struct_field (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility)
static bfd_boolean ieee_end_struct_type (void *)
static bfd_boolean ieee_start_class_type (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean, bfd_boolean)
static bfd_boolean ieee_class_static_member (void *, const char *, const char *, enum debug_visibility)
static bfd_boolean ieee_class_baseclass (void *, bfd_vma, bfd_boolean, enum debug_visibility)
static bfd_boolean ieee_class_start_method (void *, const char *)
static bfd_boolean ieee_class_method_variant (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean)
static bfd_boolean ieee_class_static_method_variant (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean)
static bfd_boolean ieee_class_end_method (void *)
static bfd_boolean ieee_end_class_type (void *)
static bfd_boolean ieee_typedef_type (void *, const char *)
static bfd_boolean ieee_tag_type (void *, const char *, unsigned int, enum debug_type_kind)
static bfd_boolean ieee_typdef (void *, const char *)
static bfd_boolean ieee_tag (void *, const char *)
static bfd_boolean ieee_int_constant (void *, const char *, bfd_vma)
static bfd_boolean ieee_float_constant (void *, const char *, double)
static bfd_boolean ieee_typed_constant (void *, const char *, bfd_vma)
static bfd_boolean ieee_variable (void *, const char *, enum debug_var_kind, bfd_vma)
static bfd_boolean ieee_start_function (void *, const char *, bfd_boolean)
static bfd_boolean ieee_function_parameter (void *, const char *, enum debug_parm_kind, bfd_vma)
static bfd_boolean ieee_start_block (void *, bfd_vma)
static bfd_boolean ieee_end_block (void *, bfd_vma)
static bfd_boolean ieee_end_function (void *)
static bfd_boolean ieee_lineno (void *, const char *, unsigned long, bfd_vma)
static bfd_boolean ieee_init_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED, struct ieee_buflist *buflist)
static bfd_boolean ieee_append_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED, struct ieee_buflist *mainbuf, struct ieee_buflist *newbuf)
bfd_boolean write_ieee_debugging_info (bfd *abfd, void *dhandle)
static void ieee_add_bb11_blocks (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *data)
static bfd_boolean ieee_start_source (void *p ATTRIBUTE_UNUSED, const char *filename ATTRIBUTE_UNUSED)
static bfd_boolean ieee_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high, bfd_boolean stringp ATTRIBUTE_UNUSED)
static bfd_boolean ieee_set_type (void *p, bfd_boolean bitstringp ATTRIBUTE_UNUSED)
static bfd_boolean ieee_tag (void *p, const char *name ATTRIBUTE_UNUSED)
static bfd_boolean ieee_int_constant (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED, bfd_vma val ATTRIBUTE_UNUSED)
static bfd_boolean ieee_float_constant (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED, double val ATTRIBUTE_UNUSED)
static bfd_boolean ieee_typed_constant (void *p, const char *name ATTRIBUTE_UNUSED, bfd_vma val ATTRIBUTE_UNUSED)

Variables

static struct debug_write_fns

Class Documentation

struct ieee_block

Definition at line 38 of file ieee.c.

Class Members
const char * filename
unsigned int fnindx
int kind
bfd_boolean skip
struct ieee_blockstack

Definition at line 54 of file ieee.c.

Collaboration diagram for ieee_blockstack:
Class Members
struct ieee_block * bsp
struct ieee_vars

Definition at line 88 of file ieee.c.

Collaboration diagram for ieee_vars:
Class Members
unsigned int alloc
struct ieee_var * vars
struct ieee_type

Definition at line 99 of file ieee.c.

Collaboration diagram for ieee_type:
Class Members
debug_type * arg_slots
unsigned long bitsize
debug_type * pslot
debug_type type
struct ieee_types

Definition at line 114 of file ieee.c.

Collaboration diagram for ieee_types:
Class Members
unsigned int alloc
debug_type builtins
struct ieee_type * types
struct ieee_tag

Definition at line 128 of file ieee.c.

Collaboration diagram for ieee_tag:
Class Members
debug_type * fslots
const char * name
struct ieee_tag * next
debug_type slot
debug_type type
struct ieee_info

Definition at line 147 of file ieee.c.

Collaboration diagram for ieee_info:
Class Members
bfd * abfd
const bfd_byte * bytes
void * dhandle
struct ieee_types * global_types
struct ieee_vars * global_vars
const bfd_byte * pend
bfd_boolean saw_filename
struct ieee_tag * tags
struct ieee_buf

Definition at line 3603 of file ieee.c.

Collaboration diagram for ieee_buf:
Class Members
bfd_byte buf
unsigned int c
struct ieee_buf * next
struct ieee_buflist

Definition at line 3615 of file ieee.c.

Collaboration diagram for ieee_buflist:
Class Members
struct ieee_buf * head
struct ieee_buf * tail
struct ieee_range

Definition at line 3627 of file ieee.c.

Collaboration diagram for ieee_range:
Class Members
bfd_vma high
bfd_vma low
struct ieee_range * next
struct ieee_type_class

Definition at line 3639 of file ieee.c.

Class Members
unsigned int indx
const char * method
bfd_boolean ownvptr
unsigned int pmisccount
const char * vclass
bfd_vma voffset
struct ieee_write_type

Definition at line 3663 of file ieee.c.

Collaboration diagram for ieee_write_type:
Class Members
struct ieee_type_class * classdef
unsigned int ignorep: 1
unsigned int indx
unsigned int localp: 1
const char * name
unsigned int referencep: 1
unsigned int size
unsigned int unsignedp: 1
struct ieee_type_stack

Definition at line 3694 of file ieee.c.

Collaboration diagram for ieee_type_stack:
Class Members
struct ieee_type_stack * next
struct ieee_name_type

Definition at line 3705 of file ieee.c.

Collaboration diagram for ieee_name_type:
Class Members
unsigned int id
struct ieee_name_type * next
struct ieee_name_type_hash_table

Definition at line 3721 of file ieee.c.

struct ieee_name_type_hash_entry

Definition at line 3726 of file ieee.c.

Collaboration diagram for ieee_name_type_hash_entry:
Class Members
struct ieee_name_type * types
struct ieee_defined_enum

Definition at line 3735 of file ieee.c.

Collaboration diagram for ieee_defined_enum:
Class Members
bfd_boolean defined
unsigned int indx
const char ** names
struct ieee_defined_enum * next
const char * tag
bfd_signed_vma * vals
struct ieee_modified_type

Definition at line 3754 of file ieee.c.

Collaboration diagram for ieee_modified_type:
Class Members
struct ieee_modified_array_type * arrays
unsigned int const_qualified
unsigned int function
unsigned int pointer
unsigned int volatile_qualified
struct ieee_modified_array_type

Definition at line 3770 of file ieee.c.

Collaboration diagram for ieee_modified_array_type:
Class Members
bfd_signed_vma high
unsigned int indx
bfd_signed_vma low
struct ieee_modified_array_type * next
struct ieee_pending_parm

Definition at line 3785 of file ieee.c.

Collaboration diagram for ieee_pending_parm:
Class Members
const char * name
struct ieee_pending_parm * next
bfd_boolean referencep
unsigned int type
struct ieee_handle

Definition at line 3803 of file ieee.c.

Collaboration diagram for ieee_handle:
Class Members
bfd * abfd
unsigned int block_depth
unsigned int complex_double_index
unsigned int complex_float_index
struct ieee_buf * curbuf
struct ieee_buflist * current
struct ieee_defined_enum * enums
bfd_boolean error
const char * filename
unsigned int fnargcount
const char * fnname
struct ieee_range * global_ranges
bfd_vma highaddr
const char * lineno_filename
unsigned int lineno_name_indx
struct ieee_modified_type * modified
unsigned int modified_alloc
const char * modname
unsigned int name_indx
unsigned long pending_lineno
bfd_vma pending_lineno_addr
const char * pending_lineno_filename
struct ieee_pending_parm * pending_parms
struct ieee_range * pending_ranges
struct ieee_range * ranges
unsigned int type_indx
struct ieee_type_stack * type_stack

Define Documentation

#define BASEFLAGS_FRIEND   (0x10)

Definition at line 215 of file ieee.c.

#define BASEFLAGS_PRIVATE   (0x1)

Definition at line 211 of file ieee.c.

#define BASEFLAGS_VIRTUAL   (0x2)

Definition at line 213 of file ieee.c.

#define BLOCKSTACK_SIZE   (16)

Definition at line 52 of file ieee.c.

#define BUILTIN_TYPE_COUNT   (60)

Definition at line 121 of file ieee.c.

#define CXXFLAGS_CONST   (0x20)

Definition at line 237 of file ieee.c.

#define CXXFLAGS_CTOR   (0x200)

Definition at line 247 of file ieee.c.

#define CXXFLAGS_CTORDTOR   (0x400)

Definition at line 245 of file ieee.c.

#define CXXFLAGS_FRIEND   (0x10)

Definition at line 235 of file ieee.c.

#define CXXFLAGS_INLINE   (0x800)

Definition at line 249 of file ieee.c.

#define CXXFLAGS_OPERATOR   (0x100)

Definition at line 243 of file ieee.c.

#define CXXFLAGS_OVERLOADED   (0x80)

Definition at line 241 of file ieee.c.

#define CXXFLAGS_OVERRIDE   (0x8)

Definition at line 233 of file ieee.c.

#define CXXFLAGS_STATIC   (0x4)

Definition at line 231 of file ieee.c.

#define CXXFLAGS_VISIBILITY   (0x3)

Definition at line 223 of file ieee.c.

#define CXXFLAGS_VISIBILITY_PRIVATE   (0x1)

Definition at line 227 of file ieee.c.

#define CXXFLAGS_VISIBILITY_PROTECTED   (0x2)

Definition at line 229 of file ieee.c.

#define CXXFLAGS_VISIBILITY_PUBLIC   (0x0)

Definition at line 225 of file ieee.c.

#define CXXFLAGS_VOLATILE   (0x40)

Definition at line 239 of file ieee.c.

#define EXPR_STACK_SIZE   (10)
#define ieee_buffer_emptyp (   buflist)    ((buflist)->head == NULL)

Definition at line 4052 of file ieee.c.

#define IEEE_BUFSIZE   (490)

Definition at line 3601 of file ieee.c.

#define ieee_name_type_hash_lookup (   table,
  string,
  create,
  copy 
)
Value:
((struct ieee_name_type_hash_entry *) \
   bfd_hash_lookup (&(table)->root, (string), (create), (copy)))

Definition at line 4570 of file ieee.c.

#define ieee_name_type_hash_traverse (   table,
  func,
  info 
)
Value:
(bfd_hash_traverse                                             \
   (&(table)->root,                                            \
    (bfd_boolean (*) (struct bfd_hash_entry *, void *)) (func),              \
    (info)))

Definition at line 4576 of file ieee.c.

#define ieee_write_byte (   info,
  b 
)
Value:
((info)->curbuf->c < IEEE_BUFSIZE                       \
   ? ((info)->curbuf->buf[(info)->curbuf->c++] = (b), TRUE)    \
   : ieee_real_write_byte ((info), (b)))

Definition at line 4097 of file ieee.c.


Enumeration Type Documentation

Enumerator:
builtin_unknown 
builtin_void 
builtin_signed_char 
builtin_unsigned_char 
builtin_signed_short_int 
builtin_unsigned_short_int 
builtin_signed_long 
builtin_unsigned_long 
builtin_signed_long_long 
builtin_unsigned_long_long 
builtin_float 
builtin_double 
builtin_long_double 
builtin_long_long_double 
builtin_quoted_string 
builtin_instruction_address 
builtin_int 
builtin_unsigned 
builtin_unsigned_int 
builtin_char 
builtin_long 
builtin_short 
builtin_unsigned_short 
builtin_short_int 
builtin_signed_short 
builtin_bcd_float 

Definition at line 175 of file ieee.c.


Function Documentation

static bfd_boolean ieee_add_bb11 ( struct ieee_handle info,
asection sec,
bfd_vma  low,
bfd_vma  high 
) [static]

Definition at line 5074 of file ieee.c.

{
  int kind;

  if (! ieee_buffer_emptyp (&info->vars))
    {
      if (! ieee_change_buffer (info, &info->vars))
       return FALSE;
    }
  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 = filename;

      c = xstrdup (modname);
      s = strrchr (c, '.');
      if (s != NULL)
       *s = '\0';

      if (! ieee_change_buffer (info, &info->vars)
         || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
         || ! ieee_write_byte (info, 10)
         || ! ieee_write_number (info, 0)
         || ! ieee_write_id (info, c)
         || ! ieee_write_id (info, "")
         || ! ieee_write_number (info, 0)
         || ! ieee_write_id (info, "GNU objcopy"))
       return FALSE;

      free (c);
    }

  if ((sec->flags & SEC_CODE) != 0)
    kind = 1;
  else if ((sec->flags & SEC_READONLY) != 0)
    kind = 3;
  else
    kind = 2;

  if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
      || ! ieee_write_byte (info, 11)
      || ! ieee_write_number (info, 0)
      || ! ieee_write_id (info, "")
      || ! ieee_write_number (info, kind)
      || ! ieee_write_number (info, sec->index + IEEE_SECTION_NUMBER_BASE)
      || ! ieee_write_number (info, low)
      || ! ieee_write_byte (info, (int) ieee_be_record_enum)
      || ! ieee_write_number (info, high - low))
    return FALSE;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void ieee_add_bb11_blocks ( bfd ,
asection ,
void *   
) [static]

Here is the caller graph for this function:

static void ieee_add_bb11_blocks ( bfd *abfd  ATTRIBUTE_UNUSED,
asection sec,
void *  data 
) [static]

Definition at line 5032 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) data;
  bfd_vma low, high;
  struct ieee_range *r;

  low = bfd_get_section_vma (abfd, sec);
  high = low + bfd_section_size (abfd, sec);

  /* Find the first range at or after this section.  The ranges are
     sorted by address.  */
  for (r = info->global_ranges; r != NULL; r = r->next)
    if (r->high > low)
      break;

  while (low < high)
    {
      if (r == NULL || r->low >= high)
       {
         if (! ieee_add_bb11 (info, sec, low, high))
           info->error = TRUE;
         return;
       }

      if (low < r->low
         && r->low - low > 0x100)
       {
         if (! ieee_add_bb11 (info, sec, low, r->low))
           {
             info->error = TRUE;
             return;
           }
       }
      low = r->high;

      r = r->next;
    }
}

Here is the call graph for this function:

static bfd_boolean ieee_add_range ( struct ieee_handle info,
bfd_boolean  global,
bfd_vma  low,
bfd_vma  high 
) [static]

Definition at line 4334 of file ieee.c.

{
  struct ieee_range **plist, *r, **pr;

  if (low == (bfd_vma) -1 || high == (bfd_vma) -1 || low == high)
    return TRUE;

  if (global)
    plist = &info->global_ranges;
  else
    plist = &info->ranges;

  for (r = *plist; r != NULL; r = r->next)
    {
      if (high >= r->low && low <= r->high)
       {
         /* The new range overlaps r.  */
         if (low < r->low)
           r->low = low;
         if (high > r->high)
           r->high = high;
         pr = &r->next;
         while (*pr != NULL && (*pr)->low <= r->high)
           {
             struct ieee_range *n;

             if ((*pr)->high > r->high)
              r->high = (*pr)->high;
             n = (*pr)->next;
             free (*pr);
             *pr = n;
           }
         return TRUE;
       }
    }

  r = (struct ieee_range *) xmalloc (sizeof *r);
  memset (r, 0, sizeof *r);

  r->low = low;
  r->high = high;

  /* Store the ranges sorted by address.  */
  for (pr = plist; *pr != NULL; pr = &(*pr)->next)
    if ((*pr)->low > high)
      break;
  r->next = *pr;
  *pr = r;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_alloc_type ( struct ieee_info info,
unsigned int  indx,
bfd_boolean  ref 
) [static]

Definition at line 777 of file ieee.c.

{
  unsigned int nalloc;
  register struct ieee_type *t;
  struct ieee_type *tend;

  if (indx >= info->types.alloc)
    {
      nalloc = info->types.alloc;
      if (nalloc == 0)
       nalloc = 4;
      while (indx >= nalloc)
       nalloc *= 2;

      info->types.types = ((struct ieee_type *)
                        xrealloc (info->types.types,
                                 nalloc * sizeof *info->types.types));

      memset (info->types.types + info->types.alloc, 0,
             (nalloc - info->types.alloc) * sizeof *info->types.types);

      tend = info->types.types + nalloc;
      for (t = info->types.types + info->types.alloc; t < tend; t++)
       t->type = DEBUG_TYPE_NULL;

      info->types.alloc = nalloc;
    }

  if (ref)
    {
      t = info->types.types + indx;
      if (t->type == NULL)
       {
         t->pslot = (debug_type *) xmalloc (sizeof *t->pslot);
         *t->pslot = DEBUG_TYPE_NULL;
         t->type = debug_make_indirect_type (info->dhandle, t->pslot,
                                         (const char *) NULL);
         if (t->type == NULL)
           return FALSE;
       }
    }

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_append_buffer ( struct ieee_handle *info  ATTRIBUTE_UNUSED,
struct ieee_buflist mainbuf,
struct ieee_buflist newbuf 
) [static]

Definition at line 4079 of file ieee.c.

{
  if (newbuf->head != NULL)
    {
      if (mainbuf->head == NULL)
       mainbuf->head = newbuf->head;
      else
       mainbuf->tail->next = newbuf->head;
      mainbuf->tail = newbuf->tail;
    }
  return TRUE;
}
static bfd_boolean ieee_array_type ( void *  ,
bfd_signed_vma  ,
bfd_signed_vma  ,
bfd_boolean   
) [static]
static bfd_boolean ieee_array_type ( void *  p,
bfd_signed_vma  low,
bfd_signed_vma  high,
bfd_boolean stringp  ATTRIBUTE_UNUSED 
) [static]

Definition at line 5596 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  unsigned int eleindx;
  bfd_boolean localp;
  unsigned int size;
  struct ieee_modified_type *m = NULL;
  struct ieee_modified_array_type *a;

  /* IEEE does not store the range, so we just ignore it.  */
  ieee_pop_unused_type (info);
  localp = info->type_stack->type.localp;
  size = info->type_stack->type.size;
  eleindx = ieee_pop_type (info);

  /* If we don't know the range, treat the size as exactly one
     element.  */
  if (low < high)
    size *= (high - low) + 1;

  if (! localp)
    {
      m = ieee_get_modified_info (info, eleindx);
      if (m == NULL)
       return FALSE;

      for (a = m->arrays; a != NULL; a = a->next)
       {
         if (a->low == low && a->high == high)
           return ieee_push_type (info, a->indx, size, FALSE, FALSE);
       }
    }

  if (! ieee_define_type (info, size, FALSE, localp)
      || ! ieee_write_number (info, low == 0 ? 'Z' : 'C')
      || ! ieee_write_number (info, eleindx))
    return FALSE;
  if (low != 0)
    {
      if (! ieee_write_number (info, low))
       return FALSE;
    }

  if (! ieee_write_number (info, high + 1))
    return FALSE;

  if (! localp)
    {
      a = (struct ieee_modified_array_type *) xmalloc (sizeof *a);
      memset (a, 0, sizeof *a);

      a->indx = info->type_stack->type.indx;
      a->low = low;
      a->high = high;

      a->next = m->arrays;
      m->arrays = a;
    }

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_bool_type ( void *  p,
unsigned int  size 
) [static]

Definition at line 5295 of file ieee.c.

{
  return ieee_int_type (p, size, TRUE);
}

Here is the call graph for this function:

static debug_type ieee_builtin_type ( struct ieee_info info,
const bfd_byte p,
unsigned int  indx 
) [static]

Definition at line 588 of file ieee.c.

{
  void *dhandle;
  debug_type type;
  const char *name;

  if (indx < BUILTIN_TYPE_COUNT
      && info->types.builtins[indx] != DEBUG_TYPE_NULL)
    return info->types.builtins[indx];

  dhandle = info->dhandle;

  if (indx >= 32 && indx < 64)
    {
      type = debug_make_pointer_type (dhandle,
                                  ieee_builtin_type (info, p, indx - 32));
      assert (indx < BUILTIN_TYPE_COUNT);
      info->types.builtins[indx] = type;
      return type;
    }

  switch ((enum builtin_types) indx)
    {
    default:
      ieee_error (info, p, _("unknown builtin type"));
      return NULL;

    case builtin_unknown:
      type = debug_make_void_type (dhandle);
      name = NULL;
      break;

    case builtin_void:
      type = debug_make_void_type (dhandle);
      name = "void";
      break;

    case builtin_signed_char:
      type = debug_make_int_type (dhandle, 1, FALSE);
      name = "signed char";
      break;

    case builtin_unsigned_char:
      type = debug_make_int_type (dhandle, 1, TRUE);
      name = "unsigned char";
      break;

    case builtin_signed_short_int:
      type = debug_make_int_type (dhandle, 2, FALSE);
      name = "signed short int";
      break;

    case builtin_unsigned_short_int:
      type = debug_make_int_type (dhandle, 2, TRUE);
      name = "unsigned short int";
      break;

    case builtin_signed_long:
      type = debug_make_int_type (dhandle, 4, FALSE);
      name = "signed long";
      break;

    case builtin_unsigned_long:
      type = debug_make_int_type (dhandle, 4, TRUE);
      name = "unsigned long";
      break;

    case builtin_signed_long_long:
      type = debug_make_int_type (dhandle, 8, FALSE);
      name = "signed long long";
      break;

    case builtin_unsigned_long_long:
      type = debug_make_int_type (dhandle, 8, TRUE);
      name = "unsigned long long";
      break;

    case builtin_float:
      type = debug_make_float_type (dhandle, 4);
      name = "float";
      break;

    case builtin_double:
      type = debug_make_float_type (dhandle, 8);
      name = "double";
      break;

    case builtin_long_double:
      /* FIXME: The size for this type should depend upon the
         processor.  */
      type = debug_make_float_type (dhandle, 12);
      name = "long double";
      break;

    case builtin_long_long_double:
      type = debug_make_float_type (dhandle, 16);
      name = "long long double";
      break;

    case builtin_quoted_string:
      type = debug_make_array_type (dhandle,
                                ieee_builtin_type (info, p,
                                                 ((unsigned int)
                                                 builtin_char)),
                                ieee_builtin_type (info, p,
                                                 ((unsigned int)
                                                 builtin_int)),
                                0, -1, TRUE);
      name = "QUOTED STRING";
      break;

    case builtin_instruction_address:
      /* FIXME: This should be a code address.  */
      type = debug_make_int_type (dhandle, 4, TRUE);
      name = "instruction address";
      break;

    case builtin_int:
      /* FIXME: The size for this type should depend upon the
         processor.  */
      type = debug_make_int_type (dhandle, 4, FALSE);
      name = "int";
      break;

    case builtin_unsigned:
      /* FIXME: The size for this type should depend upon the
         processor.  */
      type = debug_make_int_type (dhandle, 4, TRUE);
      name = "unsigned";
      break;

    case builtin_unsigned_int:
      /* FIXME: The size for this type should depend upon the
         processor.  */
      type = debug_make_int_type (dhandle, 4, TRUE);
      name = "unsigned int";
      break;

    case builtin_char:
      type = debug_make_int_type (dhandle, 1, FALSE);
      name = "char";
      break;

    case builtin_long:
      type = debug_make_int_type (dhandle, 4, FALSE);
      name = "long";
      break;

    case builtin_short:
      type = debug_make_int_type (dhandle, 2, FALSE);
      name = "short";
      break;

    case builtin_unsigned_short:
      type = debug_make_int_type (dhandle, 2, TRUE);
      name = "unsigned short";
      break;

    case builtin_short_int:
      type = debug_make_int_type (dhandle, 2, FALSE);
      name = "short int";
      break;

    case builtin_signed_short:
      type = debug_make_int_type (dhandle, 2, FALSE);
      name = "signed short";
      break;

    case builtin_bcd_float:
      ieee_error (info, p, _("BCD float type not supported"));
      return DEBUG_TYPE_NULL;
    }

  if (name != NULL)
    type = debug_name_type (dhandle, name, type);

  assert (indx < BUILTIN_TYPE_COUNT);

  info->types.builtins[indx] = type;

  return type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_change_buffer ( struct ieee_handle info,
struct ieee_buflist buflist 
) [static]

Definition at line 4057 of file ieee.c.

{
  if (buflist->head == NULL)
    {
      struct ieee_buf *buf;

      buf = (struct ieee_buf *) xmalloc (sizeof *buf);
      buf->next = NULL;
      buf->c = 0;
      buflist->head = buf;
      buflist->tail = buf;
    }

  info->current = buflist;
  info->curbuf = buflist->tail;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_class_baseclass ( void *  p,
bfd_vma  bitpos,
bfd_boolean  virtual,
enum debug_visibility  visibility 
) [static]

Definition at line 6197 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  const char *bname;
  bfd_boolean localp;
  unsigned int bindx;
  char *fname;
  unsigned int flags;
  unsigned int nindx;

  assert (info->type_stack != NULL
         && info->type_stack->type.name != NULL
         && info->type_stack->next != NULL
         && info->type_stack->next->type.classdef != NULL
         && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));

  bname = info->type_stack->type.name;
  localp = info->type_stack->type.localp;
  bindx = ieee_pop_type (info);

  /* We are currently defining both a struct and a class.  We must
     write out a field definition in the struct which holds the base
     class.  The stabs debugging reader will create a field named
     _vb$CLASS for a virtual base class, so we just use that.  FIXME:
     we should not depend upon a detail of stabs debugging.  */
  if (virtual)
    {
      fname = (char *) xmalloc (strlen (bname) + sizeof "_vb$");
      sprintf (fname, "_vb$%s", bname);
      flags = BASEFLAGS_VIRTUAL;
    }
  else
    {
      if (localp)
       info->type_stack->type.localp = TRUE;

      fname = (char *) xmalloc (strlen (bname) + sizeof "_b$");
      sprintf (fname, "_b$%s", bname);

      if (! ieee_change_buffer (info, &info->type_stack->type.strdef)
         || ! ieee_write_id (info, fname)
         || ! ieee_write_number (info, bindx)
         || ! ieee_write_number (info, bitpos / 8))
       return FALSE;
      flags = 0;
    }

  if (visibility == DEBUG_VISIBILITY_PRIVATE)
    flags |= BASEFLAGS_PRIVATE;

  nindx = info->type_stack->type.classdef->indx;

  if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
      || ! ieee_write_asn (info, nindx, 'b')
      || ! ieee_write_asn (info, nindx, flags)
      || ! ieee_write_atn65 (info, nindx, bname)
      || ! ieee_write_asn (info, nindx, 0)
      || ! ieee_write_atn65 (info, nindx, fname))
    return FALSE;
  info->type_stack->type.classdef->pmisccount += 5;

  free (fname);

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_class_end_method ( void *  p) [static]

Definition at line 6379 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  assert (info->type_stack != NULL
         && info->type_stack->type.classdef != NULL
         && info->type_stack->type.classdef->method != NULL);

  info->type_stack->type.classdef->method = NULL;

  return TRUE;
}
static bfd_boolean ieee_class_method_var ( struct ieee_handle info,
const char *  physname,
enum debug_visibility  visibility,
bfd_boolean  staticp,
bfd_boolean  constp,
bfd_boolean  volatilep,
bfd_vma  voffset,
bfd_boolean  context 
) [static]

Definition at line 6283 of file ieee.c.

{
  unsigned int flags;
  unsigned int nindx;
  bfd_boolean virtual;

  /* We don't need the type of the method.  An IEEE consumer which
     wants the type must track down the function by the physical name
     and get the type from that.  */
  ieee_pop_unused_type (info);

  /* We don't use the context.  FIXME: We probably ought to use it to
     adjust the voffset somehow, but I don't really know how.  */
  if (context)
    ieee_pop_unused_type (info);

  assert (info->type_stack != NULL
         && info->type_stack->type.classdef != NULL
         && info->type_stack->type.classdef->method != NULL);

  flags = ieee_vis_to_flags (visibility);

  /* FIXME: We never set CXXFLAGS_OVERRIDE, CXXFLAGS_OPERATOR,
     CXXFLAGS_CTORDTOR, CXXFLAGS_CTOR, or CXXFLAGS_INLINE.  */

  if (staticp)
    flags |= CXXFLAGS_STATIC;
  if (constp)
    flags |= CXXFLAGS_CONST;
  if (volatilep)
    flags |= CXXFLAGS_VOLATILE;

  nindx = info->type_stack->type.classdef->indx;

  virtual = context || voffset > 0;

  if (! ieee_change_buffer (info,
                         &info->type_stack->type.classdef->pmiscbuf)
      || ! ieee_write_asn (info, nindx, virtual ? 'v' : 'm')
      || ! ieee_write_asn (info, nindx, flags)
      || ! ieee_write_atn65 (info, nindx,
                          info->type_stack->type.classdef->method)
      || ! ieee_write_atn65 (info, nindx, physname))
    return FALSE;

  if (virtual)
    {
      if (voffset > info->type_stack->type.classdef->voffset)
       info->type_stack->type.classdef->voffset = voffset;
      if (! ieee_write_asn (info, nindx, voffset))
       return FALSE;
      ++info->type_stack->type.classdef->pmisccount;
    }

  if (! ieee_write_asn (info, nindx, 0))
    return FALSE;

  info->type_stack->type.classdef->pmisccount += 5;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_class_method_variant ( void *  p,
const char *  physname,
enum debug_visibility  visibility,
bfd_boolean  constp,
bfd_boolean  volatilep,
bfd_vma  voffset,
bfd_boolean  context 
) [static]

Definition at line 6352 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  return ieee_class_method_var (info, physname, visibility, FALSE, constp,
                            volatilep, voffset, context);
}

Here is the call graph for this function:

static bfd_boolean ieee_class_start_method ( void *  p,
const char *  name 
) [static]

Definition at line 6267 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  assert (info->type_stack != NULL
         && info->type_stack->type.classdef != NULL
         && info->type_stack->type.classdef->method == NULL);

  info->type_stack->type.classdef->method = name;

  return TRUE;
}
static bfd_boolean ieee_class_static_member ( void *  p,
const char *  name,
const char *  physname,
enum debug_visibility  visibility 
) [static]

Definition at line 6163 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  unsigned int flags;
  unsigned int nindx;

  /* We don't care about the type.  Hopefully there will be a call to
     ieee_variable declaring the physical name and the type, since
     that is where an IEEE consumer must get the type.  */
  ieee_pop_unused_type (info);

  assert (info->type_stack != NULL
         && info->type_stack->type.classdef != NULL);

  flags = ieee_vis_to_flags (visibility);
  flags |= CXXFLAGS_STATIC;

  nindx = info->type_stack->type.classdef->indx;

  if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
      || ! ieee_write_asn (info, nindx, 'd')
      || ! ieee_write_asn (info, nindx, flags)
      || ! ieee_write_atn65 (info, nindx, name)
      || ! ieee_write_atn65 (info, nindx, physname))
    return FALSE;
  info->type_stack->type.classdef->pmisccount += 4;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_class_static_method_variant ( void *  p,
const char *  physname,
enum debug_visibility  visibility,
bfd_boolean  constp,
bfd_boolean  volatilep 
) [static]

Definition at line 6366 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  return ieee_class_method_var (info, physname, visibility, TRUE, constp,
                            volatilep, 0, FALSE);
}

Here is the call graph for this function:

static bfd_boolean ieee_complex_type ( void *  p,
unsigned int  size 
) [static]

Definition at line 5249 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  char code;

  switch (size)
    {
    case 4:
      if (info->complex_float_index != 0)
       return ieee_push_type (info, info->complex_float_index, size * 2,
                            FALSE, FALSE);
      code = 'c';
      break;
    case 12:
    case 16:
      /* These cases can be output by gcc -gstabs.  Outputting the
         wrong type is better than crashing.  */
    case 8:
      if (info->complex_double_index != 0)
       return ieee_push_type (info, info->complex_double_index, size * 2,
                            FALSE, FALSE);
      code = 'd';
      break;
    default:
      fprintf (stderr, _("IEEE unsupported complex type size %u\n"), size);
      return FALSE;
    }

  /* FIXME: I don't know what the string is for.  */
  if (! ieee_define_type (info, size * 2, FALSE, FALSE)
      || ! ieee_write_number (info, code)
      || ! ieee_write_id (info, ""))
    return FALSE;

  if (size == 4)
    info->complex_float_index = info->type_stack->type.indx;
  else
    info->complex_double_index = info->type_stack->type.indx;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_const_type ( void *  p) [static]

Definition at line 5721 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  unsigned int size;
  bfd_boolean unsignedp, localp;
  unsigned int indx;
  struct ieee_modified_type *m = NULL;

  size = info->type_stack->type.size;
  unsignedp = info->type_stack->type.unsignedp;
  localp = info->type_stack->type.localp;
  indx = ieee_pop_type (info);

  if (! localp)
    {
      m = ieee_get_modified_info (info, indx);
      if (m == NULL)
       return FALSE;

      if (m->const_qualified > 0)
       return ieee_push_type (info, m->const_qualified, size, unsignedp,
                            FALSE);
    }

  if (! ieee_define_type (info, size, unsignedp, localp)
      || ! ieee_write_number (info, 'n')
      || ! ieee_write_number (info, 1)
      || ! ieee_write_number (info, indx))
    return FALSE;

  if (! localp)
    m->const_qualified = info->type_stack->type.indx;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_define_named_type ( struct ieee_handle info,
const char *  name,
unsigned int  indx,
unsigned int  size,
bfd_boolean  unsignedp,
bfd_boolean  localp,
struct ieee_buflist buflist 
) [static]

Definition at line 4432 of file ieee.c.

{
  unsigned int type_indx;
  unsigned int name_indx;

  if (indx != (unsigned int) -1)
    type_indx = indx;
  else
    {
      type_indx = info->type_indx;
      ++info->type_indx;
    }

  name_indx = info->name_indx;
  ++info->name_indx;

  if (name == NULL)
    name = "";

  /* If we were given a buffer, use it; otherwise, use either the
     local or the global type information, and make sure that the type
     block is started.  */
  if (buflist != NULL)
    {
      if (! ieee_change_buffer (info, buflist))
       return FALSE;
    }
  else if (localp)
    {
      if (! ieee_buffer_emptyp (&info->types))
       {
         if (! ieee_change_buffer (info, &info->types))
           return FALSE;
       }
      else
       {
         if (! ieee_change_buffer (info, &info->types)
             || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
             || ! ieee_write_byte (info, 1)
             || ! ieee_write_number (info, 0)
             || ! ieee_write_id (info, info->modname))
           return FALSE;
       }
    }
  else
    {
      if (! ieee_buffer_emptyp (&info->global_types))
       {
         if (! ieee_change_buffer (info, &info->global_types))
           return FALSE;
       }
      else
       {
         if (! ieee_change_buffer (info, &info->global_types)
             || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
             || ! ieee_write_byte (info, 2)
             || ! ieee_write_number (info, 0)
             || ! ieee_write_id (info, ""))
           return FALSE;
       }
    }

  /* Push the new type on the type stack, write out an NN record, and
     write out the start of a TY record.  The caller will then finish
     the TY record.  */
  if (! ieee_push_type (info, type_indx, size, unsignedp, localp))
    return FALSE;

  return (ieee_write_byte (info, (int) ieee_nn_record)
         && ieee_write_number (info, name_indx)
         && ieee_write_id (info, name)
         && ieee_write_byte (info, (int) ieee_ty_record_enum)
         && ieee_write_number (info, type_indx)
         && ieee_write_byte (info, 0xce)
         && ieee_write_number (info, name_indx));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_define_type ( struct ieee_handle info,
unsigned int  size,
bfd_boolean  unsignedp,
bfd_boolean  localp 
) [static]

Definition at line 4421 of file ieee.c.

{
  return ieee_define_named_type (info, (const char *) NULL,
                             (unsigned int) -1, size, unsignedp,
                             localp, (struct ieee_buflist *) NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_empty_type ( void *  p) [static]

Definition at line 5165 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  return ieee_push_type (info, (int) builtin_unknown, 0, FALSE, FALSE);
}

Here is the call graph for this function:

static bfd_boolean ieee_end_block ( void *  p,
bfd_vma  addr 
) [static]

Definition at line 7237 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  /* The address we are given is the end of the block, but IEEE seems
     to want to the address of the last byte in the block, so we
     subtract one.  */
  if (! ieee_change_buffer (info, &info->vars)
      || ! ieee_write_byte (info, (int) ieee_be_record_enum)
      || ! ieee_write_number (info, addr - 1))
    return FALSE;

  if (! ieee_end_range (info, addr))
    return FALSE;

  --info->block_depth;

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

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_end_class_type ( void *  p) [static]

Definition at line 6395 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  unsigned int nindx;

  assert (info->type_stack != NULL
         && info->type_stack->type.classdef != NULL);

  /* If we were ignoring this class definition because it was a
     duplicate definition, just through away whatever bytes we have
     accumulated.  Leave the type on the stack.  */
  if (info->type_stack->type.ignorep)
    return TRUE;

  nindx = info->type_stack->type.classdef->indx;

  /* If we have a virtual table, we can write out the information now.  */
  if (info->type_stack->type.classdef->vclass != NULL
      || info->type_stack->type.classdef->ownvptr)
    {
      if (! ieee_change_buffer (info,
                            &info->type_stack->type.classdef->pmiscbuf)
         || ! ieee_write_asn (info, nindx, 'z')
         || ! ieee_write_atn65 (info, nindx, "")
         || ! ieee_write_asn (info, nindx,
                            info->type_stack->type.classdef->voffset))
       return FALSE;
      if (info->type_stack->type.classdef->ownvptr)
       {
         if (! ieee_write_atn65 (info, nindx, ""))
           return FALSE;
       }
      else
       {
         if (! ieee_write_atn65 (info, nindx,
                              info->type_stack->type.classdef->vclass))
           return FALSE;
       }
      if (! ieee_write_asn (info, nindx, 0))
       return FALSE;
      info->type_stack->type.classdef->pmisccount += 5;
    }

  /* Now that we know the number of pmisc records, we can write out
     the atn62 which starts the pmisc records, and append them to the
     C++ buffers.  */

  if (! ieee_change_buffer (info, &info->cxx)
      || ! ieee_write_byte (info, (int) ieee_nn_record)
      || ! ieee_write_number (info, nindx)
      || ! ieee_write_id (info, "")
      || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
      || ! ieee_write_number (info, nindx)
      || ! ieee_write_number (info, 0)
      || ! ieee_write_number (info, 62)
      || ! ieee_write_number (info, 80)
      || ! ieee_write_number (info,
                           info->type_stack->type.classdef->pmisccount))
    return FALSE;

  if (! ieee_append_buffer (info, &info->cxx,
                         &info->type_stack->type.classdef->pmiscbuf))
    return FALSE;
  if (! ieee_buffer_emptyp (&info->type_stack->type.classdef->refs))
    {
      if (! ieee_append_buffer (info, &info->cxx,
                            &info->type_stack->type.classdef->refs))
       return FALSE;
    }

  return ieee_end_struct_type (p);
}

Here is the call graph for this function:

static bfd_boolean ieee_end_function ( void *  p) [static]

Definition at line 7263 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  assert (info->block_depth == 1);

  --info->block_depth;

  /* Now we can finish up fntype, and add it to the typdef section.
     At this point, fntype is the 'x' type up to the argument count,
     and fnargs is the argument types.  We must add the argument
     count, and we must add the level.  FIXME: We don't record varargs
     functions correctly.  In fact, stabs debugging does not give us
     enough information to do so.  */
  if (! ieee_change_buffer (info, &info->fntype)
      || ! ieee_write_number (info, info->fnargcount)
      || ! ieee_change_buffer (info, &info->fnargs)
      || ! ieee_write_number (info, 0))
    return FALSE;

  /* Make sure the typdef block has been started.  */
  if (ieee_buffer_emptyp (&info->types))
    {
      if (! ieee_change_buffer (info, &info->types)
         || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
         || ! ieee_write_byte (info, 1)
         || ! ieee_write_number (info, 0)
         || ! ieee_write_id (info, info->modname))
       return FALSE;
    }

  if (! ieee_append_buffer (info, &info->types, &info->fntype)
      || ! ieee_append_buffer (info, &info->types, &info->fnargs))
    return FALSE;

  info->fnname = NULL;
  if (! ieee_init_buffer (info, &info->fntype)
      || ! ieee_init_buffer (info, &info->fnargs))
    return FALSE;
  info->fnargcount = 0;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_end_range ( struct ieee_handle info,
bfd_vma  high 
) [static]

Definition at line 4405 of file ieee.c.

{
  struct ieee_range *r;
  bfd_vma low;

  assert (info->pending_ranges != NULL);
  r = info->pending_ranges;
  low = r->low;
  info->pending_ranges = r->next;
  free (r);
  return ieee_add_range (info, FALSE, low, high);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_end_struct_type ( void *  p) [static]

Definition at line 6033 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  struct ieee_buflist *pb;

  assert (info->type_stack != NULL
         && ! ieee_buffer_emptyp (&info->type_stack->type.strdef));

  /* If we were ignoring this struct definition because it was a
     duplicate definition, just through away whatever bytes we have
     accumulated.  Leave the type on the stack.  */
  if (info->type_stack->type.ignorep)
    return TRUE;

  /* If this is not a duplicate definition of this tag, then localp
     will be FALSE, and we can put it in the global type block.
     FIXME: We should avoid outputting duplicate definitions which are
     the same.  */
  if (! info->type_stack->type.localp)
    {
      /* Make sure we have started the global type block.  */
      if (ieee_buffer_emptyp (&info->global_types))
       {
         if (! ieee_change_buffer (info, &info->global_types)
             || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
             || ! ieee_write_byte (info, 2)
             || ! ieee_write_number (info, 0)
             || ! ieee_write_id (info, ""))
           return FALSE;
       }
      pb = &info->global_types;
    }
  else
    {
      /* Make sure we have started the types block.  */
      if (ieee_buffer_emptyp (&info->types))
       {
         if (! ieee_change_buffer (info, &info->types)
             || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
             || ! ieee_write_byte (info, 1)
             || ! ieee_write_number (info, 0)
             || ! ieee_write_id (info, info->modname))
           return FALSE;
       }
      pb = &info->types;
    }

  /* Append the struct definition to the types.  */
  if (! ieee_append_buffer (info, pb, &info->type_stack->type.strdef)
      || ! ieee_init_buffer (info, &info->type_stack->type.strdef))
    return FALSE;

  /* Leave the struct on the type stack.  */

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_enum_type ( void *  p,
const char *  tag,
const char **  names,
bfd_signed_vma vals 
) [static]

Definition at line 5303 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  struct ieee_defined_enum *e;
  bfd_boolean localp, simple;
  unsigned int indx;
  int i = 0;

  localp = FALSE;
  indx = (unsigned int) -1;
  for (e = info->enums; e != NULL; e = e->next)
    {
      if (tag == NULL)
       {
         if (e->tag != NULL)
           continue;
       }
      else
       {
         if (e->tag == NULL
             || tag[0] != e->tag[0]
             || strcmp (tag, e->tag) != 0)
           continue;
       }

      if (! e->defined)
       {
         /* This enum tag has been seen but not defined.  */
         indx = e->indx;
         break;
       }

      if (names != NULL && e->names != NULL)
       {
         for (i = 0; names[i] != NULL && e->names[i] != NULL; i++)
           {
             if (names[i][0] != e->names[i][0]
                || vals[i] != e->vals[i]
                || strcmp (names[i], e->names[i]) != 0)
              break;
           }
       }

      if ((names == NULL && e->names == NULL)
         || (names != NULL
             && e->names != NULL
             && names[i] == NULL
             && e->names[i] == NULL))
       {
         /* We've seen this enum before.  */
         return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
       }

      if (tag != NULL)
       {
         /* We've already seen an enum of the same name, so we must make
            sure to output this one locally.  */
         localp = TRUE;
         break;
       }
    }

  /* If this is a simple enumeration, in which the values start at 0
     and always increment by 1, we can use type E.  Otherwise we must
     use type N.  */

  simple = TRUE;
  if (names != NULL)
    {
      for (i = 0; names[i] != NULL; i++)
       {
         if (vals[i] != i)
           {
             simple = FALSE;
             break;
           }
       }
    }

  if (! ieee_define_named_type (info, tag, indx, 0, TRUE, localp,
                            (struct ieee_buflist *) NULL)
      || ! ieee_write_number (info, simple ? 'E' : 'N'))
    return FALSE;
  if (simple)
    {
      /* FIXME: This is supposed to be the enumeration size, but we
         don't store that.  */
      if (! ieee_write_number (info, 4))
       return FALSE;
    }
  if (names != NULL)
    {
      for (i = 0; names[i] != NULL; i++)
       {
         if (! ieee_write_id (info, names[i]))
           return FALSE;
         if (! simple)
           {
             if (! ieee_write_number (info, vals[i]))
              return FALSE;
           }
       }
    }

  if (! localp)
    {
      if (indx == (unsigned int) -1)
       {
         e = (struct ieee_defined_enum *) xmalloc (sizeof *e);
         memset (e, 0, sizeof *e);
         e->indx = info->type_stack->type.indx;
         e->tag = tag;

         e->next = info->enums;
         info->enums = e;
       }

      e->names = names;
      e->vals = vals;
      e->defined = TRUE;
    }

  return TRUE;
}

Here is the call graph for this function:

static void ieee_eof ( struct ieee_info info) [static]

Definition at line 308 of file ieee.c.

{
  ieee_error (info, (const bfd_byte *) NULL,
             _("unexpected end of debugging information"));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void ieee_error ( struct ieee_info info,
const bfd_byte p,
const char *  s 
) [static]

Definition at line 296 of file ieee.c.

{
  if (p != NULL)
    fprintf (stderr, "%s: 0x%lx: %s (0x%x)\n", bfd_get_filename (info->abfd),
            (unsigned long) (p - info->bytes), s, *p);
  else
    fprintf (stderr, "%s: %s\n", bfd_get_filename (info->abfd), s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 4883 of file ieee.c.

{
  struct ieee_range *r;

  if (! ieee_buffer_emptyp (&info->types))
    {
      if (! ieee_change_buffer (info, &info->types)
         || ! ieee_write_byte (info, (int) ieee_be_record_enum))
       return FALSE;
    }

  if (! ieee_buffer_emptyp (&info->cxx))
    {
      /* Append any C++ information to the global function and
         variable information.  */
      assert (! ieee_buffer_emptyp (&info->vars));
      if (! ieee_change_buffer (info, &info->vars))
       return FALSE;

      /* We put the pmisc records in a dummy procedure, just as the
         MRI compiler does.  */
      if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
         || ! ieee_write_byte (info, 6)
         || ! ieee_write_number (info, 0)
         || ! ieee_write_id (info, "__XRYCPP")
         || ! ieee_write_number (info, 0)
         || ! ieee_write_number (info, 0)
         || ! ieee_write_number (info, info->highaddr - 1)
         || ! ieee_append_buffer (info, &info->vars, &info->cxx)
         || ! ieee_change_buffer (info, &info->vars)
         || ! ieee_write_byte (info, (int) ieee_be_record_enum)
         || ! ieee_write_number (info, info->highaddr - 1))
       return FALSE;
    }

  if (! ieee_buffer_emptyp (&info->vars))
    {
      if (! ieee_change_buffer (info, &info->vars)
         || ! ieee_write_byte (info, (int) ieee_be_record_enum))
       return FALSE;
    }

  if (info->pending_lineno_filename != NULL)
    {
      /* Force out the pending line number.  */
      if (! ieee_lineno ((void *) info, (const char *) NULL, 0, (bfd_vma) -1))
       return FALSE;
    }
  if (! ieee_buffer_emptyp (&info->linenos))
    {
      if (! ieee_change_buffer (info, &info->linenos)
         || ! ieee_write_byte (info, (int) ieee_be_record_enum))
       return FALSE;
      if (strcmp (info->filename, info->lineno_filename) != 0)
       {
         /* We were not in the main file.  We just closed the
             included line number block, and now we must close the
             main line number block.  */
         if (! ieee_write_byte (info, (int) ieee_be_record_enum))
           return FALSE;
       }
    }

  if (! ieee_append_buffer (info, &info->data, &info->types)
      || ! ieee_append_buffer (info, &info->data, &info->vars)
      || ! ieee_append_buffer (info, &info->data, &info->linenos))
    return FALSE;

  /* Build BB10/BB11 blocks based on the ranges we recorded.  */
  if (! ieee_change_buffer (info, &info->data))
    return FALSE;

  if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
      || ! ieee_write_byte (info, 10)
      || ! ieee_write_number (info, 0)
      || ! ieee_write_id (info, info->modname)
      || ! ieee_write_id (info, "")
      || ! ieee_write_number (info, 0)
      || ! ieee_write_id (info, "GNU objcopy"))
    return FALSE;

  for (r = info->ranges; r != NULL; r = r->next)
    {
      bfd_vma low, high;
      asection *s;
      int kind;

      low = r->low;
      high = r->high;

      /* Find the section corresponding to this range.  */
      for (s = info->abfd->sections; s != NULL; s = s->next)
       {
         if (bfd_get_section_vma (info->abfd, s) <= low
             && high <= (bfd_get_section_vma (info->abfd, s)
                       + bfd_section_size (info->abfd, s)))
           break;
       }

      if (s == NULL)
       {
         /* Just ignore this range.  */
         continue;
       }

      /* Coalesce ranges if it seems reasonable.  */
      while (r->next != NULL
            && high + 0x1000 >= r->next->low
            && (r->next->high
               <= (bfd_get_section_vma (info->abfd, s)
                   + bfd_section_size (info->abfd, s))))
       {
         r = r->next;
         high = r->high;
       }

      if ((s->flags & SEC_CODE) != 0)
       kind = 1;
      else if ((s->flags & SEC_READONLY) != 0)
       kind = 3;
      else
       kind = 2;

      if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
         || ! ieee_write_byte (info, 11)
         || ! ieee_write_number (info, 0)
         || ! ieee_write_id (info, "")
         || ! ieee_write_number (info, kind)
         || ! ieee_write_number (info, s->index + IEEE_SECTION_NUMBER_BASE)
         || ! ieee_write_number (info, low)
         || ! ieee_write_byte (info, (int) ieee_be_record_enum)
         || ! ieee_write_number (info, high - low))
       return FALSE;

      /* Add this range to the list of global ranges.  */
      if (! ieee_add_range (info, TRUE, low, high))
       return FALSE;
    }

  if (! ieee_write_byte (info, (int) ieee_be_record_enum))
    return FALSE;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_float_constant ( void *  ,
const char *  ,
double   
) [static]
static bfd_boolean ieee_float_constant ( void *p  ATTRIBUTE_UNUSED,
const char *name  ATTRIBUTE_UNUSED,
double val  ATTRIBUTE_UNUSED 
) [static]

Definition at line 6852 of file ieee.c.

{
  /* FIXME.  */
  return TRUE;
}
static bfd_boolean ieee_float_type ( void *  p,
unsigned int  size 
) [static]

Definition at line 5218 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  unsigned int indx;

  switch (size)
    {
    case 4:
      indx = (int) builtin_float;
      break;
    case 8:
      indx = (int) builtin_double;
      break;
    case 12:
      /* FIXME: This size really depends upon the processor.  */
      indx = (int) builtin_long_double;
      break;
    case 16:
      indx = (int) builtin_long_long_double;
      break;
    default:
      fprintf (stderr, _("IEEE unsupported float type size %u\n"), size);
      return FALSE;
    }

  return ieee_push_type (info, indx, size, FALSE, FALSE);
}

Here is the call graph for this function:

static bfd_boolean ieee_function_parameter ( void *  p,
const char *  name,
enum debug_parm_kind  kind,
bfd_vma  val 
) [static]

Definition at line 7078 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  struct ieee_pending_parm *m, **pm;

  assert (info->block_depth == 1);

  m = (struct ieee_pending_parm *) xmalloc (sizeof *m);
  memset (m, 0, sizeof *m);

  m->next = NULL;
  m->name = name;
  m->referencep = info->type_stack->type.referencep;
  m->type = ieee_pop_type (info);
  m->kind = kind;
  m->val = val;

  for (pm = &info->pending_parms; *pm != NULL; pm = &(*pm)->next)
    ;
  *pm = m;

  /* Add the type to the fnargs list.  */
  if (! ieee_change_buffer (info, &info->fnargs)
      || ! ieee_write_number (info, m->type))
    return FALSE;
  ++info->fnargcount;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_function_type ( void *  p,
int  argcount,
bfd_boolean  varargs 
) [static]

Definition at line 5475 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  bfd_boolean localp;
  unsigned int *args = NULL;
  int i;
  unsigned int retindx;
  struct ieee_buflist fndef;
  struct ieee_modified_type *m;

  localp = FALSE;

  if (argcount > 0)
    {
      args = (unsigned int *) xmalloc (argcount * sizeof *args);
      for (i = argcount - 1; i >= 0; i--)
       {
         if (info->type_stack->type.localp)
           localp = TRUE;
         args[i] = ieee_pop_type (info);
       }
    }
  else if (argcount < 0)
    varargs = FALSE;

  if (info->type_stack->type.localp)
    localp = TRUE;
  retindx = ieee_pop_type (info);

  m = NULL;
  if (argcount < 0 && ! localp)
    {
      m = ieee_get_modified_info (p, retindx);
      if (m == NULL)
       return FALSE;

      if (m->function > 0)
       return ieee_push_type (info, m->function, 0, TRUE, FALSE);
    }

  /* An attribute of 0x41 means that the frame and push mask are
     unknown.  */
  if (! ieee_init_buffer (info, &fndef)
      || ! ieee_define_named_type (info, (const char *) NULL,
                               (unsigned int) -1, 0, TRUE, localp,
                               &fndef)
      || ! ieee_write_number (info, 'x')
      || ! ieee_write_number (info, 0x41)
      || ! ieee_write_number (info, 0)
      || ! ieee_write_number (info, 0)
      || ! ieee_write_number (info, retindx)
      || ! ieee_write_number (info, (bfd_vma) argcount + (varargs ? 1 : 0)))
    return FALSE;
  if (argcount > 0)
    {
      for (i = 0; i < argcount; i++)
       if (! ieee_write_number (info, args[i]))
         return FALSE;
      free (args);
    }
  if (varargs)
    {
      /* A varargs function is represented by writing out the last
         argument as type void *, although this makes little sense.  */
      if (! ieee_write_number (info, (bfd_vma) builtin_void + 32))
       return FALSE;
    }

  if (! ieee_write_number (info, 0))
    return FALSE;

  /* We wrote the information into fndef, in case we don't need it.
     It will be appended to info->types by ieee_pop_type.  */
  info->type_stack->type.fndef = fndef;

  if (m != NULL)
    m->function = info->type_stack->type.indx;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int ieee_genreg_to_regno ( bfd abfd,
int  r 
) [static]

Definition at line 3570 of file ieee.c.

{
  switch (bfd_get_arch (abfd))
    {
    case bfd_arch_m68k:
      /* For some reason stabs add 2 to the floating point register
         numbers.  */
      if (r >= 18)
       r -= 2;
      break;

    case bfd_arch_i960:
      /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
         32 to 35 for fp0 to fp3.  */
      ++r;
      break;

    default:
      break;
    }

  return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct ieee_modified_type * ieee_get_modified_info ( struct ieee_handle info,
unsigned int  indx 
) [static, read]

Definition at line 4515 of file ieee.c.

{
  if (indx >= info->modified_alloc)
    {
      unsigned int nalloc;

      nalloc = info->modified_alloc;
      if (nalloc == 0)
       nalloc = 16;
      while (indx >= nalloc)
       nalloc *= 2;
      info->modified = ((struct ieee_modified_type *)
                     xrealloc (info->modified,
                              nalloc * sizeof *info->modified));
      memset (info->modified + info->modified_alloc, 0,
             (nalloc - info->modified_alloc) * sizeof *info->modified);
      info->modified_alloc = nalloc;
    }

  return info->modified + indx;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_init_buffer ( struct ieee_handle *info  ATTRIBUTE_UNUSED,
struct ieee_buflist buflist 
) [static]

Definition at line 4042 of file ieee.c.

{
  buflist->head = NULL;
  buflist->tail = NULL;
  return TRUE;
}
static bfd_boolean ieee_int_constant ( void *  ,
const char *  ,
bfd_vma   
) [static]
static bfd_boolean ieee_int_constant ( void *p  ATTRIBUTE_UNUSED,
const char *name  ATTRIBUTE_UNUSED,
bfd_vma val  ATTRIBUTE_UNUSED 
) [static]

Definition at line 6842 of file ieee.c.

{
  /* FIXME.  */
  return TRUE;
}
static bfd_boolean ieee_int_type ( void *  p,
unsigned int  size,
bfd_boolean  unsignedp 
) [static]

Definition at line 5185 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  unsigned int indx;

  switch (size)
    {
    case 1:
      indx = (int) builtin_signed_char;
      break;
    case 2:
      indx = (int) builtin_signed_short_int;
      break;
    case 4:
      indx = (int) builtin_signed_long;
      break;
    case 8:
      indx = (int) builtin_signed_long_long;
      break;
    default:
      fprintf (stderr, _("IEEE unsupported integer type size %u\n"), size);
      return FALSE;
    }

  if (unsignedp)
    ++indx;

  return ieee_push_type (info, indx, size, unsignedp, FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_lineno ( void *  p,
const char *  filename,
unsigned long  lineno,
bfd_vma  addr 
) [static]

Definition at line 7310 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  assert (info->filename != NULL);

  /* The HP simulator seems to get confused when more than one line is
     listed for the same address, at least if they are in different
     files.  We handle this by always listing the last line for a
     given address, since that seems to be the one that gdb uses.  */
  if (info->pending_lineno_filename != NULL
      && addr != info->pending_lineno_addr)
    {
      /* Make sure we have a line number block.  */
      if (! ieee_buffer_emptyp (&info->linenos))
       {
         if (! ieee_change_buffer (info, &info->linenos))
           return FALSE;
       }
      else
       {
         info->lineno_name_indx = info->name_indx;
         ++info->name_indx;
         if (! ieee_change_buffer (info, &info->linenos)
             || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
             || ! ieee_write_byte (info, 5)
             || ! ieee_write_number (info, 0)
             || ! ieee_write_id (info, info->filename)
             || ! ieee_write_byte (info, (int) ieee_nn_record)
             || ! ieee_write_number (info, info->lineno_name_indx)
             || ! ieee_write_id (info, ""))
           return FALSE;
         info->lineno_filename = info->filename;
       }

      if (strcmp (info->pending_lineno_filename, info->lineno_filename) != 0)
       {
         if (strcmp (info->filename, info->lineno_filename) != 0)
           {
             /* We were not in the main file.  Close the block for the
               included file.  */
             if (! ieee_write_byte (info, (int) ieee_be_record_enum))
              return FALSE;
             if (strcmp (info->filename, info->pending_lineno_filename) == 0)
              {
                /* We need a new NN record, and we aren't about to
                   output one.  */
                info->lineno_name_indx = info->name_indx;
                ++info->name_indx;
                if (! ieee_write_byte (info, (int) ieee_nn_record)
                    || ! ieee_write_number (info, info->lineno_name_indx)
                    || ! ieee_write_id (info, ""))
                  return FALSE;
              }
           }
         if (strcmp (info->filename, info->pending_lineno_filename) != 0)
           {
             /* We are not changing to the main file.  Open a block for
               the new included file.  */
             info->lineno_name_indx = info->name_indx;
             ++info->name_indx;
             if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
                || ! ieee_write_byte (info, 5)
                || ! ieee_write_number (info, 0)
                || ! ieee_write_id (info, info->pending_lineno_filename)
                || ! ieee_write_byte (info, (int) ieee_nn_record)
                || ! ieee_write_number (info, info->lineno_name_indx)
                || ! ieee_write_id (info, ""))
              return FALSE;
           }
         info->lineno_filename = info->pending_lineno_filename;
       }

      if (! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
         || ! ieee_write_number (info, info->lineno_name_indx)
         || ! ieee_write_number (info, 0)
         || ! ieee_write_number (info, 7)
         || ! ieee_write_number (info, info->pending_lineno)
         || ! ieee_write_number (info, 0)
         || ! ieee_write_asn (info, info->lineno_name_indx,
                            info->pending_lineno_addr))
       return FALSE;
    }

  info->pending_lineno_filename = filename;
  info->pending_lineno = lineno;
  info->pending_lineno_addr = addr;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_method_type ( void *  p,
bfd_boolean  domain,
int  argcount,
bfd_boolean  varargs 
) [static]

Definition at line 5703 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  /* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a
     method, but the definition is incomplete.  We just output an 'x'
     type.  */

  if (domain)
    ieee_pop_unused_type (info);

  return ieee_function_type (p, argcount, varargs);
}

Here is the call graph for this function:

static struct bfd_hash_entry * ieee_name_type_newfunc ( struct bfd_hash_entry entry,
struct bfd_hash_table table,
const char *  string 
) [static, read]

Definition at line 4542 of file ieee.c.

{
  struct ieee_name_type_hash_entry *ret =
    (struct ieee_name_type_hash_entry *) entry;

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

  /* Call the allocation method of the superclass.  */
  ret = ((struct ieee_name_type_hash_entry *)
        bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
  if (ret)
    {
      /* Set local fields.  */
      ret->types = NULL;
    }

  return (struct bfd_hash_entry *) ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_offset_type ( void *  p) [static]

Definition at line 5682 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  unsigned int targetindx, baseindx;

  targetindx = ieee_pop_type (info);
  baseindx = ieee_pop_type (info);

  /* FIXME: The MRI C++ compiler does not appear to generate any
     useful type information about an offset type.  It just records a
     pointer to member as an integer.  The MRI/HP IEEE spec does
     describe a pmisc record which can be used for a pointer to
     member.  Unfortunately, it does not describe the target type,
     which seems pretty important.  I'm going to punt this for now.  */

  return ieee_int_type (p, 4, TRUE);
}

Here is the call graph for this function:

Definition at line 7112 of file ieee.c.

{
  struct ieee_pending_parm *m;
  unsigned int refcount;

  refcount = 0;
  for (m = info->pending_parms; m != NULL; m = m->next)
    {
      enum debug_var_kind vkind;

      switch (m->kind)
       {
       default:
         abort ();
         return FALSE;
       case DEBUG_PARM_STACK:
       case DEBUG_PARM_REFERENCE:
         vkind = DEBUG_LOCAL;
         break;
       case DEBUG_PARM_REG:
       case DEBUG_PARM_REF_REG:
         vkind = DEBUG_REGISTER;
         break;
       }

      if (! ieee_push_type (info, m->type, 0, FALSE, FALSE))
       return FALSE;
      info->type_stack->type.referencep = m->referencep;
      if (m->referencep)
       ++refcount;
      if (! ieee_variable ((void *) info, m->name, vkind, m->val))
       return FALSE;
    }

  /* If there are any reference parameters, we need to output a
     miscellaneous record indicating them.  */
  if (refcount > 0)
    {
      unsigned int nindx, varindx;

      /* FIXME: The MRI compiler outputs the demangled function name
         here, but we are outputting the mangled name.  */
      nindx = info->name_indx;
      ++info->name_indx;
      if (! ieee_change_buffer (info, &info->vars)
         || ! ieee_write_byte (info, (int) ieee_nn_record)
         || ! ieee_write_number (info, nindx)
         || ! ieee_write_id (info, "")
         || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
         || ! ieee_write_number (info, nindx)
         || ! ieee_write_number (info, 0)
         || ! ieee_write_number (info, 62)
         || ! ieee_write_number (info, 80)
         || ! ieee_write_number (info, refcount + 3)
         || ! ieee_write_asn (info, nindx, 'B')
         || ! ieee_write_atn65 (info, nindx, info->fnname)
         || ! ieee_write_asn (info, nindx, 0))
       return FALSE;
      for (m = info->pending_parms, varindx = 1;
          m != NULL;
          m = m->next, varindx++)
       {
         if (m->referencep)
           {
             if (! ieee_write_asn (info, nindx, varindx))
              return FALSE;
           }
       }
    }

  m = info->pending_parms;
  while (m != NULL)
    {
      struct ieee_pending_parm *next;

      next = m->next;
      free (m);
      m = next;
    }

  info->pending_parms = NULL;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_pointer_type ( void *  p) [static]

Definition at line 5432 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  bfd_boolean localp;
  unsigned int indx;
  struct ieee_modified_type *m = NULL;

  localp = info->type_stack->type.localp;
  indx = ieee_pop_type (info);

  /* A pointer to a simple builtin type can be obtained by adding 32.
     FIXME: Will this be a short pointer, and will that matter?  */
  if (indx < 32)
    return ieee_push_type (info, indx + 32, 0, TRUE, FALSE);

  if (! localp)
    {
      m = ieee_get_modified_info (p, indx);
      if (m == NULL)
       return FALSE;

      /* FIXME: The size should depend upon the architecture.  */
      if (m->pointer > 0)
       return ieee_push_type (info, m->pointer, 4, TRUE, FALSE);
    }

  if (! ieee_define_type (info, 4, TRUE, localp)
      || ! ieee_write_number (info, 'P')
      || ! ieee_write_number (info, indx))
    return FALSE;

  if (! localp)
    m->pointer = info->type_stack->type.indx;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static unsigned int ieee_pop_type ( struct ieee_handle info) [static]

Definition at line 4262 of file ieee.c.

{
  return ieee_pop_type_used (info, TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static unsigned int ieee_pop_type_used ( struct ieee_handle info,
bfd_boolean  used 
) [static]

Definition at line 4278 of file ieee.c.

{
  struct ieee_type_stack *ts;
  unsigned int ret;

  ts = info->type_stack;
  assert (ts != NULL);

  /* If this is a function type, and we need it, we need to append the
     actual definition to the typedef block now.  */
  if (used && ! ieee_buffer_emptyp (&ts->type.fndef))
    {
      struct ieee_buflist *buflist;

      if (ts->type.localp)
       {
         /* Make sure we have started the types block.  */
         if (ieee_buffer_emptyp (&info->types))
           {
             if (! ieee_change_buffer (info, &info->types)
                || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
                || ! ieee_write_byte (info, 1)
                || ! ieee_write_number (info, 0)
                || ! ieee_write_id (info, info->modname))
              return FALSE;
           }
         buflist = &info->types;
       }
      else
       {
         /* Make sure we started the global type block.  */
         if (ieee_buffer_emptyp (&info->global_types))
           {
             if (! ieee_change_buffer (info, &info->global_types)
                || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
                || ! ieee_write_byte (info, 2)
                || ! ieee_write_number (info, 0)
                || ! ieee_write_id (info, ""))
              return FALSE;
           }
         buflist = &info->global_types;
       }

      if (! ieee_append_buffer (info, buflist, &ts->type.fndef))
       return FALSE;
    }

  ret = ts->type.indx;
  info->type_stack = ts->next;
  free (ts);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void ieee_pop_unused_type ( struct ieee_handle info) [static]

Definition at line 4270 of file ieee.c.

{
  (void) ieee_pop_type_used (info, FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_push_type ( struct ieee_handle info,
unsigned int  indx,
unsigned int  size,
bfd_boolean  unsignedp,
bfd_boolean  localp 
) [static]

Definition at line 4240 of file ieee.c.

{
  struct ieee_type_stack *ts;

  ts = (struct ieee_type_stack *) xmalloc (sizeof *ts);
  memset (ts, 0, sizeof *ts);

  ts->type.indx = indx;
  ts->type.size = size;
  ts->type.unsignedp = unsignedp;
  ts->type.localp = localp;

  ts->next = info->type_stack;
  info->type_stack = ts;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_range_type ( void *  p,
bfd_signed_vma  low,
bfd_signed_vma  high 
) [static]

Definition at line 5575 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  unsigned int size;
  bfd_boolean unsignedp, localp;

  size = info->type_stack->type.size;
  unsignedp = info->type_stack->type.unsignedp;
  localp = info->type_stack->type.localp;
  ieee_pop_unused_type (info);
  return (ieee_define_type (info, size, unsignedp, localp)
         && ieee_write_number (info, 'R')
         && ieee_write_number (info, (bfd_vma) low)
         && ieee_write_number (info, (bfd_vma) high)
         && ieee_write_number (info, unsignedp ? 0 : 1)
         && ieee_write_number (info, size));
}

Here is the call graph for this function:

static bfd_boolean ieee_read_cxx_class ( struct ieee_info info,
const bfd_byte **  pp,
unsigned long  count 
) [static]

Definition at line 2523 of file ieee.c.

{
  const bfd_byte *start;
  bfd_vma class;
  const char *tag;
  unsigned long taglen;
  struct ieee_tag *it;
  void *dhandle;
  debug_field *fields;
  unsigned int field_count, field_alloc;
  debug_baseclass *baseclasses;
  unsigned int baseclasses_count, baseclasses_alloc;
  const debug_field *structfields;
  struct ieee_method
    {
      const char *name;
      unsigned long namlen;
      debug_method_variant *variants;
      unsigned count;
      unsigned int alloc;
    } *methods;
  unsigned int methods_count, methods_alloc;
  debug_type vptrbase;
  bfd_boolean ownvptr;
  debug_method *dmethods;

  start = *pp;

  if (! ieee_require_asn (info, pp, &class))
    return FALSE;
  --count;

  if (! ieee_require_atn65 (info, pp, &tag, &taglen))
    return FALSE;
  --count;

  /* Find the C struct with this name.  */
  for (it = info->tags; it != NULL; it = it->next)
    if (it->name[0] == tag[0]
       && strncmp (it->name, tag, taglen) == 0
       && strlen (it->name) == taglen)
      break;
  if (it == NULL)
    {
      ieee_error (info, start, _("undefined C++ object"));
      return FALSE;
    }

  dhandle = info->dhandle;

  fields = NULL;
  field_count = 0;
  field_alloc = 0;
  baseclasses = NULL;
  baseclasses_count = 0;
  baseclasses_alloc = 0;
  methods = NULL;
  methods_count = 0;
  methods_alloc = 0;
  vptrbase = DEBUG_TYPE_NULL;
  ownvptr = FALSE;

  structfields = debug_get_fields (dhandle, it->type);

  while (count > 0)
    {
      bfd_vma id;
      const bfd_byte *spec_start;

      spec_start = *pp;

      if (! ieee_require_asn (info, pp, &id))
       return FALSE;
      --count;

      switch (id)
       {
       default:
         ieee_error (info, spec_start, _("unrecognized C++ object spec"));
         return FALSE;

       case 'b':
         {
           bfd_vma flags, cinline;
           const char *basename, *fieldname;
           unsigned long baselen, fieldlen;
           char *basecopy;
           debug_type basetype;
           bfd_vma bitpos;
           bfd_boolean virtualp;
           enum debug_visibility visibility;
           debug_baseclass baseclass;

           /* This represents a base or friend class.  */

           if (! ieee_require_asn (info, pp, &flags)
              || ! ieee_require_atn65 (info, pp, &basename, &baselen)
              || ! ieee_require_asn (info, pp, &cinline)
              || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen))
             return FALSE;
           count -= 4;

           /* We have no way of recording friend information, so we
               just ignore it.  */
           if ((flags & BASEFLAGS_FRIEND) != 0)
             break;

           /* I assume that either all of the members of the
               baseclass are included in the object, starting at the
               beginning of the object, or that none of them are
               included.  */

           if ((fieldlen == 0) == (cinline == 0))
             {
              ieee_error (info, start, _("unsupported C++ object type"));
              return FALSE;
             }

           basecopy = savestring (basename, baselen);
           basetype = debug_find_tagged_type (dhandle, basecopy,
                                          DEBUG_KIND_ILLEGAL);
           free (basecopy);
           if (basetype == DEBUG_TYPE_NULL)
             {
              ieee_error (info, start, _("C++ base class not defined"));
              return FALSE;
             }

           if (fieldlen == 0)
             bitpos = 0;
           else
             {
              const debug_field *pf;

              if (structfields == NULL)
                {
                  ieee_error (info, start, _("C++ object has no fields"));
                  return FALSE;
                }

              for (pf = structfields; *pf != DEBUG_FIELD_NULL; pf++)
                {
                  const char *fname;

                  fname = debug_get_field_name (dhandle, *pf);
                  if (fname == NULL)
                    return FALSE;
                  if (fname[0] == fieldname[0]
                     && strncmp (fname, fieldname, fieldlen) == 0
                     && strlen (fname) == fieldlen)
                    break;
                }
              if (*pf == DEBUG_FIELD_NULL)
                {
                  ieee_error (info, start,
                            _("C++ base class not found in container"));
                  return FALSE;
                }

              bitpos = debug_get_field_bitpos (dhandle, *pf);
             }

           if ((flags & BASEFLAGS_VIRTUAL) != 0)
             virtualp = TRUE;
           else
             virtualp = FALSE;
           if ((flags & BASEFLAGS_PRIVATE) != 0)
             visibility = DEBUG_VISIBILITY_PRIVATE;
           else
             visibility = DEBUG_VISIBILITY_PUBLIC;

           baseclass = debug_make_baseclass (dhandle, basetype, bitpos,
                                         virtualp, visibility);
           if (baseclass == DEBUG_BASECLASS_NULL)
             return FALSE;

           if (baseclasses_count + 1 >= baseclasses_alloc)
             {
              baseclasses_alloc += 10;
              baseclasses = ((debug_baseclass *)
                            xrealloc (baseclasses,
                                    (baseclasses_alloc
                                     * sizeof *baseclasses)));
             }

           baseclasses[baseclasses_count] = baseclass;
           ++baseclasses_count;
           baseclasses[baseclasses_count] = DEBUG_BASECLASS_NULL;
         }
         break;

       case 'd':
         {
           bfd_vma flags;
           const char *fieldname, *mangledname;
           unsigned long fieldlen, mangledlen;
           char *fieldcopy;
           bfd_boolean staticp;
           debug_type ftype;
           const debug_field *pf = NULL;
           enum debug_visibility visibility;
           debug_field field;

           /* This represents a data member.  */

           if (! ieee_require_asn (info, pp, &flags)
              || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen)
              || ! ieee_require_atn65 (info, pp, &mangledname, &mangledlen))
             return FALSE;
           count -= 3;

           fieldcopy = savestring (fieldname, fieldlen);

           staticp = (flags & CXXFLAGS_STATIC) != 0 ? TRUE : FALSE;

           if (staticp)
             {
              struct ieee_var *pv, *pvend;

              /* See if we can find a definition for this variable.  */
              pv = info->vars.vars;
              pvend = pv + info->vars.alloc;
              for (; pv < pvend; pv++)
                if (pv->namlen == mangledlen
                    && strncmp (pv->name, mangledname, mangledlen) == 0)
                  break;
              if (pv < pvend)
                ftype = pv->type;
              else
                {
                  /* This can happen if the variable is never used.  */
                  ftype = ieee_builtin_type (info, start,
                                          (unsigned int) builtin_void);
                }
             }
           else
             {
              unsigned int findx;

              if (structfields == NULL)
                {
                  ieee_error (info, start, _("C++ object has no fields"));
                  return FALSE;
                }

              for (pf = structfields, findx = 0;
                   *pf != DEBUG_FIELD_NULL;
                   pf++, findx++)
                {
                  const char *fname;

                  fname = debug_get_field_name (dhandle, *pf);
                  if (fname == NULL)
                    return FALSE;
                  if (fname[0] == mangledname[0]
                     && strncmp (fname, mangledname, mangledlen) == 0
                     && strlen (fname) == mangledlen)
                    break;
                }
              if (*pf == DEBUG_FIELD_NULL)
                {
                  ieee_error (info, start,
                            _("C++ data member not found in container"));
                  return FALSE;
                }

              ftype = debug_get_field_type (dhandle, *pf);

              if (debug_get_type_kind (dhandle, ftype) == DEBUG_KIND_POINTER)
                {
                  /* We might need to convert this field into a
                       reference type later on, so make it an indirect
                       type.  */
                  if (it->fslots == NULL)
                    {
                     unsigned int fcnt;
                     const debug_field *pfcnt;

                     fcnt = 0;
                     for (pfcnt = structfields;
                          *pfcnt != DEBUG_FIELD_NULL;
                          pfcnt++)
                       ++fcnt;
                     it->fslots = ((debug_type *)
                                  xmalloc (fcnt * sizeof *it->fslots));
                     memset (it->fslots, 0,
                            fcnt * sizeof *it->fslots);
                    }

                  if (ftype == DEBUG_TYPE_NULL)
                    return FALSE;
                  it->fslots[findx] = ftype;
                  ftype = debug_make_indirect_type (dhandle,
                                                it->fslots + findx,
                                                (const char *) NULL);
                }
             }
           if (ftype == DEBUG_TYPE_NULL)
             return FALSE;

           switch (flags & CXXFLAGS_VISIBILITY)
             {
             default:
              ieee_error (info, start, _("unknown C++ visibility"));
              return FALSE;

             case CXXFLAGS_VISIBILITY_PUBLIC:
              visibility = DEBUG_VISIBILITY_PUBLIC;
              break;

             case CXXFLAGS_VISIBILITY_PRIVATE:
              visibility = DEBUG_VISIBILITY_PRIVATE;
              break;

             case CXXFLAGS_VISIBILITY_PROTECTED:
              visibility = DEBUG_VISIBILITY_PROTECTED;
              break;
             }

           if (staticp)
             {
              char *mangledcopy;

              mangledcopy = savestring (mangledname, mangledlen);

              field = debug_make_static_member (dhandle, fieldcopy,
                                            ftype, mangledcopy,
                                            visibility);
             }
           else
             {
              bfd_vma bitpos, bitsize;

              bitpos = debug_get_field_bitpos (dhandle, *pf);
              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"));
                  return FALSE;
                }
              field = debug_make_field (dhandle, fieldcopy, ftype, bitpos,
                                     bitsize, visibility);
             }

           if (field == DEBUG_FIELD_NULL)
             return FALSE;

           if (field_count + 1 >= field_alloc)
             {
              field_alloc += 10;
              fields = ((debug_field *)
                       xrealloc (fields, field_alloc * sizeof *fields));
             }

           fields[field_count] = field;
           ++field_count;
           fields[field_count] = DEBUG_FIELD_NULL;
         }
         break;

       case 'm':
       case 'v':
         {
           bfd_vma flags, voffset, control;
           const char *name, *mangled;
           unsigned long namlen, mangledlen;
           struct ieee_var *pv, *pvend;
           debug_type type;
           enum debug_visibility visibility;
           bfd_boolean constp, volatilep;
           char *mangledcopy;
           debug_method_variant mv;
           struct ieee_method *meth;
           unsigned int im;

           if (! ieee_require_asn (info, pp, &flags)
              || ! ieee_require_atn65 (info, pp, &name, &namlen)
              || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
             return FALSE;
           count -= 3;
           if (id != 'v')
             voffset = 0;
           else
             {
              if (! ieee_require_asn (info, pp, &voffset))
                return FALSE;
              --count;
             }
           if (! ieee_require_asn (info, pp, &control))
             return FALSE;
           --count;

           /* We just ignore the control information.  */

           /* We have no way to represent friend information, so we
               just ignore it.  */
           if ((flags & CXXFLAGS_FRIEND) != 0)
             break;

           /* We should already have seen a type for the function.  */
           pv = info->vars.vars;
           pvend = pv + info->vars.alloc;
           for (; pv < pvend; pv++)
             if (pv->namlen == mangledlen
                && strncmp (pv->name, mangled, mangledlen) == 0)
              break;

           if (pv >= pvend)
             {
              /* We won't have type information for this function if
                 it is not included in this file.  We don't try to
                 handle this case.  FIXME.  */
              type = (debug_make_function_type
                     (dhandle,
                      ieee_builtin_type (info, start,
                                       (unsigned int) builtin_void),
                      (debug_type *) NULL,
                      FALSE));
             }
           else
             {
              debug_type return_type;
              const debug_type *arg_types;
              bfd_boolean varargs;

              if (debug_get_type_kind (dhandle, pv->type)
                  != DEBUG_KIND_FUNCTION)
                {
                  ieee_error (info, start,
                            _("bad type for C++ method function"));
                  return FALSE;
                }

              return_type = debug_get_return_type (dhandle, pv->type);
              arg_types = debug_get_parameter_types (dhandle, pv->type,
                                                 &varargs);
              if (return_type == DEBUG_TYPE_NULL || arg_types == NULL)
                {
                  ieee_error (info, start,
                            _("no type information for C++ method function"));
                  return FALSE;
                }

              type = debug_make_method_type (dhandle, return_type, it->type,
                                          (debug_type *) arg_types,
                                          varargs);
             }
           if (type == DEBUG_TYPE_NULL)
             return FALSE;

           switch (flags & CXXFLAGS_VISIBILITY)
             {
             default:
              ieee_error (info, start, _("unknown C++ visibility"));
              return FALSE;

             case CXXFLAGS_VISIBILITY_PUBLIC:
              visibility = DEBUG_VISIBILITY_PUBLIC;
              break;

             case CXXFLAGS_VISIBILITY_PRIVATE:
              visibility = DEBUG_VISIBILITY_PRIVATE;
              break;

             case CXXFLAGS_VISIBILITY_PROTECTED:
              visibility = DEBUG_VISIBILITY_PROTECTED;
              break;
             }

           constp = (flags & CXXFLAGS_CONST) != 0 ? TRUE : FALSE;
           volatilep = (flags & CXXFLAGS_VOLATILE) != 0 ? TRUE : FALSE;

           mangledcopy = savestring (mangled, mangledlen);

           if ((flags & CXXFLAGS_STATIC) != 0)
             {
              if (id == 'v')
                {
                  ieee_error (info, start, _("C++ static virtual method"));
                  return FALSE;
                }
              mv = debug_make_static_method_variant (dhandle, mangledcopy,
                                                 type, visibility,
                                                 constp, volatilep);
             }
           else
             {
              debug_type vcontext;

              if (id != 'v')
                vcontext = DEBUG_TYPE_NULL;
              else
                {
                  /* FIXME: How can we calculate this correctly?  */
                  vcontext = it->type;
                }
              mv = debug_make_method_variant (dhandle, mangledcopy, type,
                                          visibility, constp,
                                          volatilep, voffset,
                                          vcontext);
             }
           if (mv == DEBUG_METHOD_VARIANT_NULL)
             return FALSE;

           for (meth = methods, im = 0; im < methods_count; meth++, im++)
             if (meth->namlen == namlen
                && strncmp (meth->name, name, namlen) == 0)
              break;
           if (im >= methods_count)
             {
              if (methods_count >= methods_alloc)
                {
                  methods_alloc += 10;
                  methods = ((struct ieee_method *)
                            xrealloc (methods,
                                    methods_alloc * sizeof *methods));
                }
              methods[methods_count].name = name;
              methods[methods_count].namlen = namlen;
              methods[methods_count].variants = NULL;
              methods[methods_count].count = 0;
              methods[methods_count].alloc = 0;
              meth = methods + methods_count;
              ++methods_count;
             }

           if (meth->count + 1 >= meth->alloc)
             {
              meth->alloc += 10;
              meth->variants = ((debug_method_variant *)
                              xrealloc (meth->variants,
                                       (meth->alloc
                                        * sizeof *meth->variants)));
             }

           meth->variants[meth->count] = mv;
           ++meth->count;
           meth->variants[meth->count] = DEBUG_METHOD_VARIANT_NULL;
         }
         break;

       case 'o':
         {
           bfd_vma spec;

           /* We have no way to store this information, so we just
              ignore it.  */
           if (! ieee_require_asn (info, pp, &spec))
             return FALSE;
           --count;
           if ((spec & 4) != 0)
             {
              const char *filename;
              unsigned long filenamlen;
              bfd_vma lineno;

              if (! ieee_require_atn65 (info, pp, &filename, &filenamlen)
                  || ! ieee_require_asn (info, pp, &lineno))
                return FALSE;
              count -= 2;
             }
           else if ((spec & 8) != 0)
             {
              const char *mangled;
              unsigned long mangledlen;

              if (! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
                return FALSE;
              --count;
             }
           else
             {
              ieee_error (info, start,
                         _("unrecognized C++ object overhead spec"));
              return FALSE;
             }
         }
         break;

       case 'z':
         {
           const char *vname, *basename;
           unsigned long vnamelen, baselen;
           bfd_vma vsize, control;

           /* A virtual table pointer.  */

           if (! ieee_require_atn65 (info, pp, &vname, &vnamelen)
              || ! ieee_require_asn (info, pp, &vsize)
              || ! ieee_require_atn65 (info, pp, &basename, &baselen)
              || ! ieee_require_asn (info, pp, &control))
             return FALSE;
           count -= 4;

           /* We just ignore the control number.  We don't care what
              the virtual table name is.  We have no way to store the
              virtual table size, and I don't think we care anyhow.  */

           /* FIXME: We can't handle multiple virtual table pointers.  */

           if (baselen == 0)
             ownvptr = TRUE;
           else
             {
              char *basecopy;

              basecopy = savestring (basename, baselen);
              vptrbase = debug_find_tagged_type (dhandle, basecopy,
                                             DEBUG_KIND_ILLEGAL);
              free (basecopy);
              if (vptrbase == DEBUG_TYPE_NULL)
                {
                  ieee_error (info, start, _("undefined C++ vtable"));
                  return FALSE;
                }
             }
         }
         break;
       }
    }

  /* Now that we have seen all the method variants, we can call
     debug_make_method for each one.  */

  if (methods_count == 0)
    dmethods = NULL;
  else
    {
      unsigned int i;

      dmethods = ((debug_method *)
                xmalloc ((methods_count + 1) * sizeof *dmethods));
      for (i = 0; i < methods_count; i++)
       {
         char *namcopy;

         namcopy = savestring (methods[i].name, methods[i].namlen);
         dmethods[i] = debug_make_method (dhandle, namcopy,
                                      methods[i].variants);
         if (dmethods[i] == DEBUG_METHOD_NULL)
           return FALSE;
       }
      dmethods[i] = DEBUG_METHOD_NULL;
      free (methods);
    }

  /* The struct type was created as an indirect type pointing at
     it->slot.  We update it->slot to automatically update all
     references to this struct.  */
  it->slot = debug_make_object_type (dhandle,
                                 class != 'u',
                                 debug_get_type_size (dhandle,
                                                   it->slot),
                                 fields, baseclasses, dmethods,
                                 vptrbase, ownvptr);
  if (it->slot == DEBUG_TYPE_NULL)
    return FALSE;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_read_cxx_defaults ( struct ieee_info info,
const bfd_byte **  pp,
unsigned long  count 
) [static]

Definition at line 3188 of file ieee.c.

{
  const bfd_byte *start;
  const char *fnname;
  unsigned long fnlen;
  bfd_vma defcount;

  start = *pp;

  /* Giving the function name before the argument count is an addendum
     to the spec.  The function name is demangled, though, so this
     record must always refer to the current function.  */

  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"));
      return FALSE;
    }

  if (! ieee_require_atn65 (info, pp, &fnname, &fnlen)
      || ! ieee_require_asn (info, pp, &defcount))
    return FALSE;
  count -= 2;

  while (defcount-- > 0)
    {
      bfd_vma type, val;
      const char *strval;
      unsigned long strvallen;

      if (! ieee_require_asn (info, pp, &type))
       return FALSE;
      --count;

      switch (type)
       {
       case 0:
       case 4:
         break;

       case 1:
       case 2:
         if (! ieee_require_asn (info, pp, &val))
           return FALSE;
         --count;
         break;

       case 3:
       case 7:
         if (! ieee_require_atn65 (info, pp, &strval, &strvallen))
           return FALSE;
         --count;
         break;

       default:
         ieee_error (info, start, _("unrecognized C++ default type"));
         return FALSE;
       }

      /* We have no way to record the default argument values, so we
         just ignore them.  FIXME.  */
    }

  /* Any remaining arguments are indices of parameters that are really
     reference type.  */
  if (count > 0)
    {
      void *dhandle;
      debug_type *arg_slots;

      dhandle = info->dhandle;
      arg_slots = info->types.types[info->blockstack.bsp[-1].fnindx].arg_slots;
      while (count-- > 0)
       {
         bfd_vma indx;
         debug_type target;

         if (! ieee_require_asn (info, pp, &indx))
           return FALSE;
         /* The index is 1 based.  */
         --indx;
         if (arg_slots == NULL
             || arg_slots[indx] == DEBUG_TYPE_NULL
             || (debug_get_type_kind (dhandle, arg_slots[indx])
                != DEBUG_KIND_POINTER))
           {
             ieee_error (info, start, _("reference parameter is not a pointer"));
             return FALSE;
           }

         target = debug_get_target_type (dhandle, arg_slots[indx]);
         arg_slots[indx] = debug_make_reference_type (dhandle, target);
         if (arg_slots[indx] == DEBUG_TYPE_NULL)
           return FALSE;
       }
    }

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_read_cxx_misc ( struct ieee_info info,
const bfd_byte **  pp,
unsigned long  count 
) [static]

Definition at line 2437 of file ieee.c.

{
  const bfd_byte *start;
  bfd_vma category;

  start = *pp;

  /* Get the category of C++ misc record.  */
  if (! ieee_require_asn (info, pp, &category))
    return FALSE;
  --count;

  switch (category)
    {
    default:
      ieee_error (info, start, _("unrecognized C++ misc record"));
      return FALSE;

    case 'T':
      if (! ieee_read_cxx_class (info, pp, count))
       return FALSE;
      break;

    case 'M':
      {
       bfd_vma flags;
       const char *name;
       unsigned long namlen;

       /* The IEEE spec indicates that the 'M' record only has a
           flags field.  The MRI compiler also emits the name of the
           function.  */

       if (! ieee_require_asn (info, pp, &flags))
         return FALSE;
       if (*pp < info->pend
           && (ieee_record_enum_type) **pp == ieee_at_record_enum)
         {
           if (! ieee_require_atn65 (info, pp, &name, &namlen))
             return FALSE;
         }

       /* This is emitted for method functions, but I don't think we
           care very much.  It might help if it told us useful
           information like the class with which this function is
           associated, but it doesn't, so it isn't helpful.  */
      }
      break;

    case 'B':
      if (! ieee_read_cxx_defaults (info, pp, count))
       return FALSE;
      break;

    case 'z':
      {
       const char *name, *mangled, *class;
       unsigned long namlen, mangledlen, classlen;
       bfd_vma control;

       /* Pointer to member.  */

       if (! ieee_require_atn65 (info, pp, &name, &namlen)
           || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen)
           || ! ieee_require_atn65 (info, pp, &class, &classlen)
           || ! ieee_require_asn (info, pp, &control))
         return FALSE;

       /* FIXME: We should now track down name and change its type.  */
      }
      break;

    case 'R':
      if (! ieee_read_reference (info, pp))
       return FALSE;
      break;
    }

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_read_expression ( struct ieee_info info,
const bfd_byte **  pp,
bfd_vma pv 
) [static]

Definition at line 478 of file ieee.c.

{
  const bfd_byte *expr_start;
#define EXPR_STACK_SIZE (10)
  bfd_vma expr_stack[EXPR_STACK_SIZE];
  bfd_vma *esp;

  expr_start = *pp;

  esp = expr_stack;

  while (1)
    {
      const bfd_byte *start;
      bfd_vma val;
      bfd_boolean present;
      ieee_record_enum_type c;

      start = *pp;

      if (! ieee_read_optional_number (info, pp, &val, &present))
       return FALSE;

      if (present)
       {
         if (esp - expr_stack >= EXPR_STACK_SIZE)
           {
             ieee_error (info, start, _("expression stack overflow"));
             return FALSE;
           }
         *esp++ = val;
         continue;
       }

      c = (ieee_record_enum_type) **pp;

      if (c >= ieee_module_beginning_enum)
       break;

      ++*pp;

      if (c == ieee_comma)
       break;

      switch (c)
       {
       default:
         ieee_error (info, start, _("unsupported IEEE expression operator"));
         break;

       case ieee_variable_R_enum:
         {
           bfd_vma indx;
           asection *s;

           if (! ieee_read_number (info, pp, &indx))
             return FALSE;
           for (s = info->abfd->sections; s != NULL; s = s->next)
             if ((bfd_vma) s->target_index == indx)
              break;
           if (s == NULL)
             {
              ieee_error (info, start, _("unknown section"));
              return FALSE;
             }

           if (esp - expr_stack >= EXPR_STACK_SIZE)
             {
              ieee_error (info, start, _("expression stack overflow"));
              return FALSE;
             }

           *esp++ = bfd_get_section_vma (info->abfd, s);
         }
         break;

       case ieee_function_plus_enum:
       case ieee_function_minus_enum:
         {
           bfd_vma v1, v2;

           if (esp - expr_stack < 2)
             {
              ieee_error (info, start, _("expression stack underflow"));
              return FALSE;
             }

           v1 = *--esp;
           v2 = *--esp;
           *esp++ = v1 + v2;
         }
         break;
       }
    }

  if (esp - 1 != expr_stack)
    {
      ieee_error (info, expr_start, _("expression stack mismatch"));
      return FALSE;
    }

  *pv = *--esp;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_read_id ( struct ieee_info info,
const bfd_byte **  pp,
const char **  pname,
unsigned long pnamlen 
) [static]

Definition at line 405 of file ieee.c.

{
  return ieee_read_optional_id (info, pp, pname, pnamlen, (bfd_boolean *) NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_read_number ( struct ieee_info info,
const bfd_byte **  pp,
bfd_vma pv 
) [static]

Definition at line 330 of file ieee.c.

{
  return ieee_read_optional_number (info, pp, pv, (bfd_boolean *) NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_read_optional_id ( struct ieee_info info,
const bfd_byte **  pp,
const char **  pname,
unsigned long pnamlen,
bfd_boolean ppresent 
) [static]

Definition at line 415 of file ieee.c.

{
  bfd_byte b;
  unsigned long len;

  if (*pp >= info->pend)
    {
      ieee_eof (info);
      return FALSE;
    }

  b = **pp;
  ++*pp;

  if (b <= 0x7f)
    len = b;
  else if ((ieee_record_enum_type) b == ieee_extension_length_1_enum)
    {
      len = **pp;
      ++*pp;
    }
  else if ((ieee_record_enum_type) b == ieee_extension_length_2_enum)
    {
      len = (**pp << 8) + (*pp)[1];
      *pp += 2;
    }
  else
    {
      if (ppresent != NULL)
       {
         --*pp;
         *ppresent = FALSE;
         return TRUE;
       }
      ieee_error (info, *pp - 1, _("invalid string length"));
      return FALSE;
    }

  if ((unsigned long) (info->pend - *pp) < len)
    {
      ieee_eof (info);
      return FALSE;
    }

  *pname = (const char *) *pp;
  *pnamlen = len;
  *pp += len;

  if (ppresent != NULL)
    *ppresent = TRUE;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_read_optional_number ( struct ieee_info info,
const bfd_byte **  pp,
bfd_vma pv,
bfd_boolean ppresent 
) [static]

Definition at line 339 of file ieee.c.

{
  ieee_record_enum_type b;

  if (*pp >= info->pend)
    {
      if (ppresent != NULL)
       {
         *ppresent = FALSE;
         return TRUE;
       }
      ieee_eof (info);
      return FALSE;
    }

  b = (ieee_record_enum_type) **pp;
  ++*pp;

  if (b <= ieee_number_end_enum)
    {
      *pv = (bfd_vma) b;
      if (ppresent != NULL)
       *ppresent = TRUE;
      return TRUE;
    }

  if (b >= ieee_number_repeat_start_enum && b <= ieee_number_repeat_end_enum)
    {
      unsigned int i;

      i = (int) b - (int) ieee_number_repeat_start_enum;
      if (*pp + i - 1 >= info->pend)
       {
         ieee_eof (info);
         return FALSE;
       }

      *pv = 0;
      for (; i > 0; i--)
       {
         *pv <<= 8;
         *pv += **pp;
         ++*pp;
       }

      if (ppresent != NULL)
       *ppresent = TRUE;

      return TRUE;
    }

  if (ppresent != NULL)
    {
      --*pp;
      *ppresent = FALSE;
      return TRUE;
    }

  ieee_error (info, *pp - 1, _("invalid number"));
  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_read_reference ( struct ieee_info info,
const bfd_byte **  pp 
) [static]

Definition at line 3293 of file ieee.c.

{
  const bfd_byte *start;
  bfd_vma flags;
  const char *class, *name;
  unsigned long classlen, namlen;
  debug_type *pslot;
  debug_type target;

  start = *pp;

  if (! ieee_require_asn (info, pp, &flags))
    return FALSE;

  /* Giving the class name before the member name is in an addendum to
     the spec.  */
  if (flags == 3)
    {
      if (! ieee_require_atn65 (info, pp, &class, &classlen))
       return FALSE;
    }

  if (! ieee_require_atn65 (info, pp, &name, &namlen))
    return FALSE;

  pslot = NULL;
  if (flags != 3)
    {
      int pass;

      /* We search from the last variable indices to the first in
        hopes of finding local variables correctly.  We search the
        local variables on the first pass, and the global variables
        on the second.  FIXME: This probably won't work in all cases.
        On the other hand, I don't know what will.  */
      for (pass = 0; pass < 2; pass++)
       {
         struct ieee_vars *vars;
         int i;
         struct ieee_var *pv = NULL;

         if (pass == 0)
           vars = &info->vars;
         else
           {
             vars = info->global_vars;
             if (vars == NULL)
              break;
           }

         for (i = (int) vars->alloc - 1; i >= 0; i--)
           {
             bfd_boolean found;

             pv = vars->vars + i;

             if (pv->pslot == NULL
                || pv->namlen != namlen
                || strncmp (pv->name, name, namlen) != 0)
              continue;

             found = FALSE;
             switch (flags)
              {
              default:
                ieee_error (info, start,
                           _("unrecognized C++ reference type"));
                return FALSE;

              case 0:
                /* Global variable or function.  */
                if (pv->kind == IEEE_GLOBAL
                    || pv->kind == IEEE_EXTERNAL
                    || pv->kind == IEEE_FUNCTION)
                  found = TRUE;
                break;

              case 1:
                /* Global static variable or function.  */
                if (pv->kind == IEEE_STATIC
                    || pv->kind == IEEE_FUNCTION)
                  found = TRUE;
                break;

              case 2:
                /* Local variable.  */
                if (pv->kind == IEEE_LOCAL)
                  found = TRUE;
                break;
              }

             if (found)
              break;
           }

         if (i >= 0)
           {
             pslot = pv->pslot;
             break;
           }
       }
    }
  else
    {
      struct ieee_tag *it;

      for (it = info->tags; it != NULL; it = it->next)
       {
         if (it->name[0] == class[0]
             && strncmp (it->name, class, classlen) == 0
             && strlen (it->name) == classlen)
           {
             if (it->fslots != NULL)
              {
                const debug_field *pf;
                unsigned int findx;

                pf = debug_get_fields (info->dhandle, it->type);
                if (pf == NULL)
                  {
                    ieee_error (info, start,
                              "C++ reference in class with no fields");
                    return FALSE;
                  }

                for (findx = 0; *pf != DEBUG_FIELD_NULL; pf++, findx++)
                  {
                    const char *fname;

                    fname = debug_get_field_name (info->dhandle, *pf);
                    if (fname == NULL)
                     return FALSE;
                    if (strncmp (fname, name, namlen) == 0
                       && strlen (fname) == namlen)
                     {
                       pslot = it->fslots + findx;
                       break;
                     }
                  }
              }

             break;
           }
       }
    }

  if (pslot == NULL)
    {
      ieee_error (info, start, _("C++ reference not found"));
      return FALSE;
    }

  /* We allocated the type of the object as an indirect type pointing
     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"));
      return FALSE;
    }

  target = debug_get_target_type (info->dhandle, *pslot);
  *pslot = debug_make_reference_type (info->dhandle, target);
  if (*pslot == DEBUG_TYPE_NULL)
    return FALSE;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_read_type_index ( struct ieee_info info,
const bfd_byte **  pp,
debug_type ptype 
) [static]

Definition at line 825 of file ieee.c.

{
  const bfd_byte *start;
  bfd_vma indx;

  start = *pp;

  if (! ieee_read_number (info, pp, &indx))
    return FALSE;

  if (indx < 256)
    {
      *ptype = ieee_builtin_type (info, start, indx);
      if (*ptype == NULL)
       return FALSE;
      return TRUE;
    }

  indx -= 256;
  if (! ieee_alloc_type (info, indx, TRUE))
    return FALSE;

  *ptype = info->types.types[indx].type;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_real_write_byte ( struct ieee_handle info,
int  b 
) [static]

Definition at line 4103 of file ieee.c.

{
  if (info->curbuf->c >= IEEE_BUFSIZE)
    {
      struct ieee_buf *n;

      n = (struct ieee_buf *) xmalloc (sizeof *n);
      n->next = NULL;
      n->c = 0;
      if (info->current->head == NULL)
       info->current->head = n;
      else
       info->current->tail->next = n;
      info->current->tail = n;
      info->curbuf = n;
    }

  info->curbuf->buf[info->curbuf->c] = b;
  ++info->curbuf->c;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_reference_type ( void *  p) [static]

Definition at line 5559 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  /* IEEE appears to record a normal pointer type, and then use a
     pmisc record to indicate that it is really a reference.  */

  if (! ieee_pointer_type (p))
    return FALSE;
  info->type_stack->type.referencep = TRUE;
  return TRUE;
}

Here is the call graph for this function:

static int ieee_regno_to_genreg ( bfd abfd,
int  r 
) [static]

Definition at line 3543 of file ieee.c.

{
  switch (bfd_get_arch (abfd))
    {
    case bfd_arch_m68k:
      /* For some reasons stabs adds 2 to the floating point register
         numbers.  */
      if (r >= 16)
       r += 2;
      break;

    case bfd_arch_i960:
      /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
         32 to 35 for fp0 to fp3.  */
      --r;
      break;

    default:
      break;
    }

  return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_require_asn ( struct ieee_info info,
const bfd_byte **  pp,
bfd_vma pv 
) [static]

Definition at line 3464 of file ieee.c.

{
  const bfd_byte *start;
  ieee_record_enum_type c;
  bfd_vma varindx;

  start = *pp;

  c = (ieee_record_enum_type) **pp;
  if (c != ieee_e2_first_byte_enum)
    {
      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"));
      return FALSE;
    }
  ++*pp;

  /* Just ignore the variable index.  */
  if (! ieee_read_number (info, pp, &varindx))
    return FALSE;

  return ieee_read_expression (info, pp, pv);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_require_atn65 ( struct ieee_info info,
const bfd_byte **  pp,
const char **  pname,
unsigned long pnamlen 
) [static]

Definition at line 3498 of file ieee.c.

{
  const bfd_byte *start;
  ieee_record_enum_type c;
  bfd_vma name_indx, type_indx, atn_code;

  start = *pp;

  c = (ieee_record_enum_type) **pp;
  if (c != ieee_at_record_enum)
    {
      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"));
      return FALSE;
    }
  ++*pp;

  if (! ieee_read_number (info, pp, &name_indx)
      || ! ieee_read_number (info, pp, &type_indx)
      || ! ieee_read_number (info, pp, &atn_code))
    return FALSE;

  /* Just ignore name_indx.  */

  if (type_indx != 0 || atn_code != 65)
    {
      ieee_error (info, start, _("bad ATN65 record"));
      return FALSE;
    }

  return ieee_read_id (info, pp, pname, pnamlen);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_set_type ( void *  ,
bfd_boolean   
) [static]
static bfd_boolean ieee_set_type ( void *  p,
bfd_boolean bitstringp  ATTRIBUTE_UNUSED 
) [static]

Definition at line 5662 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  bfd_boolean localp;
  unsigned int eleindx;

  localp = info->type_stack->type.localp;
  eleindx = ieee_pop_type (info);

  /* FIXME: We don't know the size, so we just use 4.  */

  return (ieee_define_type (info, 0, TRUE, localp)
         && ieee_write_number (info, 's')
         && ieee_write_number (info, 4)
         && ieee_write_number (info, eleindx));
}

Here is the call graph for this function:

static bfd_boolean ieee_start_block ( void *  p,
bfd_vma  addr 
) [static]

Definition at line 7201 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  if (! ieee_change_buffer (info, &info->vars))
    return FALSE;

  if (info->block_depth == 1)
    {
      if (! ieee_write_number (info, addr)
         || ! ieee_output_pending_parms (info))
       return FALSE;
    }
  else
    {
      if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
         || ! ieee_write_byte (info, 6)
         || ! ieee_write_number (info, 0)
         || ! ieee_write_id (info, "")
         || ! ieee_write_number (info, 0)
         || ! ieee_write_number (info, 0)
         || ! ieee_write_number (info, addr))
       return FALSE;
    }

  if (! ieee_start_range (info, addr))
    return FALSE;

  ++info->block_depth;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_start_class_type ( void *  p,
const char *  tag,
unsigned int  id,
bfd_boolean  structp,
unsigned int  size,
bfd_boolean  vptr,
bfd_boolean  ownvptr 
) [static]

Definition at line 6093 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  const char *vclass;
  struct ieee_buflist pmiscbuf;
  unsigned int indx;
  struct ieee_type_class *classdef;

  /* A C++ class is output as a C++ struct along with a set of pmisc
     records describing the class.  */

  /* We need to have a name so that we can associate the struct and
     the class.  */
  if (tag == NULL)
    {
      char *t;

      t = (char *) xmalloc (20);
      sprintf (t, "__anon%u", id);
      tag = t;
    }

  /* We can't write out the virtual table information until we have
     finished the class, because we don't know the virtual table size.
     We get the size from the largest voffset we see.  */
  vclass = NULL;
  if (vptr && ! ownvptr)
    {
      vclass = info->type_stack->type.name;
      assert (vclass != NULL);
      /* We don't call ieee_pop_unused_type, since the class should
         get defined.  */
      (void) ieee_pop_type (info);
    }

  if (! ieee_start_struct_type (p, tag, id, structp, size))
    return FALSE;

  indx = info->name_indx;
  ++info->name_indx;

  /* We write out pmisc records into the classdef field.  We will
     write out the pmisc start after we know the number of records we
     need.  */
  if (! ieee_init_buffer (info, &pmiscbuf)
      || ! ieee_change_buffer (info, &pmiscbuf)
      || ! ieee_write_asn (info, indx, 'T')
      || ! ieee_write_asn (info, indx, structp ? 'o' : 'u')
      || ! ieee_write_atn65 (info, indx, tag))
    return FALSE;

  classdef = (struct ieee_type_class *) xmalloc (sizeof *classdef);
  memset (classdef, 0, sizeof *classdef);

  classdef->indx = indx;
  classdef->pmiscbuf = pmiscbuf;
  classdef->pmisccount = 3;
  classdef->vclass = vclass;
  classdef->ownvptr = ownvptr;

  info->type_stack->type.classdef = classdef;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_start_compilation_unit ( void *  p,
const char *  filename 
) [static]

Definition at line 4812 of file ieee.c.

{
  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;

  if (info->filename != NULL)
    {
      if (! ieee_finish_compilation_unit (info))
       return FALSE;
    }

  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 = filename;

  c = xstrdup (modname);
  s = strrchr (c, '.');
  if (s != NULL)
    *s = '\0';
  info->modname = c;

  if (! ieee_init_buffer (info, &info->types)
      || ! ieee_init_buffer (info, &info->vars)
      || ! ieee_init_buffer (info, &info->cxx)
      || ! ieee_init_buffer (info, &info->linenos))
    return FALSE;
  info->ranges = NULL;

  /* Always include a BB1 and a BB3 block.  That is what the output of
     the MRI linker seems to look like.  */
  if (! ieee_change_buffer (info, &info->types)
      || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
      || ! ieee_write_byte (info, 1)
      || ! ieee_write_number (info, 0)
      || ! ieee_write_id (info, info->modname))
    return FALSE;

  nindx = info->name_indx;
  ++info->name_indx;
  if (! ieee_change_buffer (info, &info->vars)
      || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
      || ! ieee_write_byte (info, 3)
      || ! ieee_write_number (info, 0)
      || ! ieee_write_id (info, info->modname))
    return FALSE;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_start_function ( void *  p,
const char *  name,
bfd_boolean  global 
) [static]

Definition at line 6996 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  bfd_boolean referencep;
  unsigned int retindx, typeindx;

  referencep = info->type_stack->type.referencep;
  retindx = ieee_pop_type (info);

  /* Besides recording a BB4 or BB6 block, we record the type of the
     function in the BB1 typedef block.  We can't write out the full
     type until we have seen all the parameters, so we accumulate it
     in info->fntype and info->fnargs.  */
  if (! ieee_buffer_emptyp (&info->fntype))
    {
      /* FIXME: This might happen someday if we support nested
         functions.  */
      abort ();
    }

  info->fnname = name;

  /* An attribute of 0x40 means that the push mask is unknown.  */
  if (! ieee_define_named_type (info, name, (unsigned int) -1, 0, FALSE, TRUE,
                            &info->fntype)
      || ! ieee_write_number (info, 'x')
      || ! ieee_write_number (info, 0x40)
      || ! ieee_write_number (info, 0)
      || ! ieee_write_number (info, 0)
      || ! ieee_write_number (info, retindx))
    return FALSE;

  typeindx = ieee_pop_type (info);

  if (! ieee_init_buffer (info, &info->fnargs))
    return FALSE;
  info->fnargcount = 0;

  /* If the function return value is actually a reference type, we
     must add a record indicating that.  */
  if (referencep)
    {
      unsigned int nindx;

      nindx = info->name_indx;
      ++info->name_indx;
      if (! ieee_change_buffer (info, &info->cxx)
         || ! ieee_write_byte (info, (int) ieee_nn_record)
         || ! ieee_write_number (info, nindx)
         || ! ieee_write_id (info, "")
         || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
         || ! ieee_write_number (info, nindx)
         || ! ieee_write_number (info, 0)
         || ! ieee_write_number (info, 62)
         || ! ieee_write_number (info, 80)
         || ! ieee_write_number (info, 3)
         || ! ieee_write_asn (info, nindx, 'R')
         || ! ieee_write_asn (info, nindx, global ? 0 : 1)
         || ! ieee_write_atn65 (info, nindx, name))
       return FALSE;
    }

  assert (! ieee_buffer_emptyp (&info->vars));
  if (! ieee_change_buffer (info, &info->vars))
    return FALSE;

  /* The address is written out as the first block.  */

  ++info->block_depth;

  return (ieee_write_byte (info, (int) ieee_bb_record_enum)
         && ieee_write_byte (info, global ? 4 : 6)
         && ieee_write_number (info, 0)
         && ieee_write_id (info, name)
         && ieee_write_number (info, 0)
         && ieee_write_number (info, typeindx));
}

Here is the call graph for this function:

static bfd_boolean ieee_start_range ( struct ieee_handle info,
bfd_vma  low 
) [static]

Definition at line 4390 of file ieee.c.

{
  struct ieee_range *r;

  r = (struct ieee_range *) xmalloc (sizeof *r);
  memset (r, 0, sizeof *r);
  r->low = low;
  r->next = info->pending_ranges;
  info->pending_ranges = r;
  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_start_source ( void *  ,
const char *   
) [static]
static bfd_boolean ieee_start_source ( void *p  ATTRIBUTE_UNUSED,
const char *filename  ATTRIBUTE_UNUSED 
) [static]

Definition at line 5156 of file ieee.c.

{
  return TRUE;
}
static bfd_boolean ieee_start_struct_type ( void *  p,
const char *  tag,
unsigned int  id,
bfd_boolean  structp,
unsigned int  size 
) [static]

Definition at line 5820 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  bfd_boolean localp, ignorep;
  bfd_boolean copy;
  char ab[20];
  const char *look;
  struct ieee_name_type_hash_entry *h;
  struct ieee_name_type *nt, *ntlook;
  struct ieee_buflist strdef;

  localp = FALSE;
  ignorep = FALSE;

  /* We need to create a tag for internal use even if we don't want
     one for external use.  This will let us refer to an anonymous
     struct.  */
  if (tag != NULL)
    {
      look = tag;
      copy = FALSE;
    }
  else
    {
      sprintf (ab, "__anon%u", id);
      look = ab;
      copy = TRUE;
    }

  /* If we already have references to the tag, we must use the
     existing type index.  */
  h = ieee_name_type_hash_lookup (&info->tags, look, TRUE, copy);
  if (h == NULL)
    return FALSE;

  nt = NULL;
  for (ntlook = h->types; ntlook != NULL; ntlook = ntlook->next)
    {
      if (ntlook->id == id)
       nt = ntlook;
      else if (! ntlook->type.localp)
       {
         /* We are creating a duplicate definition of a globally
            defined tag.  Force it to be local to avoid
            confusion.  */
         localp = TRUE;
       }
    }

  if (nt != NULL)
    {
      assert (localp == nt->type.localp);
      if (nt->kind == DEBUG_KIND_ILLEGAL && ! localp)
       {
         /* We've already seen a global definition of the type.
             Ignore this new definition.  */
         ignorep = TRUE;
       }
    }
  else
    {
      nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
      memset (nt, 0, sizeof *nt);
      nt->id = id;
      nt->type.name = h->root.string;
      nt->next = h->types;
      h->types = nt;
      nt->type.indx = info->type_indx;
      ++info->type_indx;
    }

  nt->kind = DEBUG_KIND_ILLEGAL;

  if (! ieee_init_buffer (info, &strdef)
      || ! ieee_define_named_type (info, tag, nt->type.indx, size, TRUE,
                               localp, &strdef)
      || ! ieee_write_number (info, structp ? 'S' : 'U')
      || ! ieee_write_number (info, size))
    return FALSE;

  if (! ignorep)
    {
      const char *hold;

      /* We never want nt->type.name to be NULL.  We want the rest of
        the type to be the object set up on the type stack; it will
        have a NULL name if tag is NULL.  */
      hold = nt->type.name;
      nt->type = info->type_stack->type;
      nt->type.name = hold;
    }

  info->type_stack->type.name = tag;
  info->type_stack->type.strdef = strdef;
  info->type_stack->type.ignorep = ignorep;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_struct_field ( void *  p,
const char *  name,
bfd_vma  bitpos,
bfd_vma  bitsize,
enum debug_visibility  visibility 
) [static]

Definition at line 5923 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  unsigned int size;
  bfd_boolean unsignedp;
  bfd_boolean referencep;
  bfd_boolean localp;
  unsigned int indx;
  bfd_vma offset;

  assert (info->type_stack != NULL
         && info->type_stack->next != NULL
         && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));

  /* If we are ignoring this struct definition, just pop and ignore
     the type.  */
  if (info->type_stack->next->type.ignorep)
    {
      ieee_pop_unused_type (info);
      return TRUE;
    }

  size = info->type_stack->type.size;
  unsignedp = info->type_stack->type.unsignedp;
  referencep = info->type_stack->type.referencep;
  localp = info->type_stack->type.localp;
  indx = ieee_pop_type (info);

  if (localp)
    info->type_stack->type.localp = TRUE;

  if (info->type_stack->type.classdef != NULL)
    {
      unsigned int flags;
      unsigned int nindx;

      /* This is a class.  We must add a description of this field to
         the class records we are building.  */

      flags = ieee_vis_to_flags (visibility);
      nindx = info->type_stack->type.classdef->indx;
      if (! ieee_change_buffer (info,
                            &info->type_stack->type.classdef->pmiscbuf)
         || ! ieee_write_asn (info, nindx, 'd')
         || ! ieee_write_asn (info, nindx, flags)
         || ! ieee_write_atn65 (info, nindx, name)
         || ! ieee_write_atn65 (info, nindx, name))
       return FALSE;
      info->type_stack->type.classdef->pmisccount += 4;

      if (referencep)
       {
         unsigned int nindx;

         /* We need to output a record recording that this field is
             really of reference type.  We put this on the refs field
             of classdef, so that it can be appended to the C++
             records after the class is defined.  */

         nindx = info->name_indx;
         ++info->name_indx;

         if (! ieee_change_buffer (info,
                                &info->type_stack->type.classdef->refs)
             || ! ieee_write_byte (info, (int) ieee_nn_record)
             || ! ieee_write_number (info, nindx)
             || ! ieee_write_id (info, "")
             || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
             || ! ieee_write_number (info, nindx)
             || ! ieee_write_number (info, 0)
             || ! ieee_write_number (info, 62)
             || ! ieee_write_number (info, 80)
             || ! ieee_write_number (info, 4)
             || ! ieee_write_asn (info, nindx, 'R')
             || ! ieee_write_asn (info, nindx, 3)
             || ! ieee_write_atn65 (info, nindx, info->type_stack->type.name)
             || ! ieee_write_atn65 (info, nindx, name))
           return FALSE;
       }
    }

  /* If the bitsize doesn't match the expected size, we need to output
     a bitfield type.  */
  if (size == 0 || bitsize == 0 || bitsize == size * 8)
    offset = bitpos / 8;
  else
    {
      if (! ieee_define_type (info, 0, unsignedp,
                           info->type_stack->type.localp)
         || ! ieee_write_number (info, 'g')
         || ! ieee_write_number (info, unsignedp ? 0 : 1)
         || ! ieee_write_number (info, bitsize)
         || ! ieee_write_number (info, indx))
       return FALSE;
      indx = ieee_pop_type (info);
      offset = bitpos;
    }

  /* Switch to the struct we are building in order to output this
     field definition.  */
  return (ieee_change_buffer (info, &info->type_stack->type.strdef)
         && ieee_write_id (info, name)
         && ieee_write_number (info, indx)
         && ieee_write_number (info, offset));
}

Here is the call graph for this function:

static bfd_boolean ieee_tag ( void *  ,
const char *   
) [static]
static bfd_boolean ieee_tag ( void *  p,
const char *name  ATTRIBUTE_UNUSED 
) [static]

Definition at line 6829 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  /* This should not be ieee_pop_unused_type, since we want the type
     to be defined.  */
  (void) ieee_pop_type (info);
  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_tag_type ( void *  p,
const char *  name,
unsigned int  id,
enum debug_type_kind  kind 
) [static]

Definition at line 6501 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  bfd_boolean localp;
  bfd_boolean copy;
  char ab[20];
  struct ieee_name_type_hash_entry *h;
  struct ieee_name_type *nt;

  if (kind == DEBUG_KIND_ENUM)
    {
      struct ieee_defined_enum *e;

      if (name == NULL)
       abort ();
      for (e = info->enums; e != NULL; e = e->next)
       if (e->tag != NULL && strcmp (e->tag, name) == 0)
         return ieee_push_type (info, e->indx, 0, TRUE, FALSE);

      e = (struct ieee_defined_enum *) xmalloc (sizeof *e);
      memset (e, 0, sizeof *e);

      e->indx = info->type_indx;
      ++info->type_indx;
      e->tag = name;
      e->defined = FALSE;

      e->next = info->enums;
      info->enums = e;

      return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
    }

  localp = FALSE;

  copy = FALSE;
  if (name == NULL)
    {
      sprintf (ab, "__anon%u", id);
      name = ab;
      copy = TRUE;
    }

  h = ieee_name_type_hash_lookup (&info->tags, name, TRUE, copy);
  if (h == NULL)
    return FALSE;

  for (nt = h->types; nt != NULL; nt = nt->next)
    {
      if (nt->id == id)
       {
         if (! ieee_push_type (info, nt->type.indx, nt->type.size,
                            nt->type.unsignedp, nt->type.localp))
           return FALSE;
         /* Copy over any other type information we may have.  */
         info->type_stack->type = nt->type;
         return TRUE;
       }

      if (! nt->type.localp)
       {
         /* This is a duplicate of a global type, so it must be
             local.  */
         localp = TRUE;
       }
    }

  nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
  memset (nt, 0, sizeof *nt);

  nt->id = id;
  nt->type.name = h->root.string;
  nt->type.indx = info->type_indx;
  nt->type.localp = localp;
  ++info->type_indx;
  nt->kind = kind;

  nt->next = h->types;
  h->types = nt;

  if (! ieee_push_type (info, nt->type.indx, 0, FALSE, localp))
    return FALSE;

  info->type_stack->type.name = h->root.string;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_typdef ( void *  p,
const char *  name 
) [static]

Definition at line 6593 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  struct ieee_write_type type;
  unsigned int indx;
  bfd_boolean found;
  bfd_boolean localp;
  struct ieee_name_type_hash_entry *h;
  struct ieee_name_type *nt;

  type = info->type_stack->type;
  indx = type.indx;

  /* If this is a simple builtin type using a builtin name, we don't
     want to output the typedef itself.  We also want to change the
     type index to correspond to the name being used.  We recognize
     names used in stabs debugging output even if they don't exactly
     correspond to the names used for the IEEE builtin types.  */
  found = FALSE;
  if (indx <= (unsigned int) builtin_bcd_float)
    {
      switch ((enum builtin_types) indx)
       {
       default:
         break;

       case builtin_void:
         if (strcmp (name, "void") == 0)
           found = TRUE;
         break;

       case builtin_signed_char:
       case builtin_char:
         if (strcmp (name, "signed char") == 0)
           {
             indx = (unsigned int) builtin_signed_char;
             found = TRUE;
           }
         else if (strcmp (name, "char") == 0)
           {
             indx = (unsigned int) builtin_char;
             found = TRUE;
           }
         break;

       case builtin_unsigned_char:
         if (strcmp (name, "unsigned char") == 0)
           found = TRUE;
         break;

       case builtin_signed_short_int:
       case builtin_short:
       case builtin_short_int:
       case builtin_signed_short:
         if (strcmp (name, "signed short int") == 0)
           {
             indx = (unsigned int) builtin_signed_short_int;
             found = TRUE;
           }
         else if (strcmp (name, "short") == 0)
           {
             indx = (unsigned int) builtin_short;
             found = TRUE;
           }
         else if (strcmp (name, "short int") == 0)
           {
             indx = (unsigned int) builtin_short_int;
             found = TRUE;
           }
         else if (strcmp (name, "signed short") == 0)
           {
             indx = (unsigned int) builtin_signed_short;
             found = TRUE;
           }
         break;

       case builtin_unsigned_short_int:
       case builtin_unsigned_short:
         if (strcmp (name, "unsigned short int") == 0
             || strcmp (name, "short unsigned int") == 0)
           {
             indx = builtin_unsigned_short_int;
             found = TRUE;
           }
         else if (strcmp (name, "unsigned short") == 0)
           {
             indx = builtin_unsigned_short;
             found = TRUE;
           }
         break;

       case builtin_signed_long:
       case builtin_int: /* FIXME: Size depends upon architecture.  */
       case builtin_long:
         if (strcmp (name, "signed long") == 0)
           {
             indx = builtin_signed_long;
             found = TRUE;
           }
         else if (strcmp (name, "int") == 0)
           {
             indx = builtin_int;
             found = TRUE;
           }
         else if (strcmp (name, "long") == 0
                 || strcmp (name, "long int") == 0)
           {
             indx = builtin_long;
             found = TRUE;
           }
         break;

       case builtin_unsigned_long:
       case builtin_unsigned: /* FIXME: Size depends upon architecture.  */
       case builtin_unsigned_int: /* FIXME: Like builtin_unsigned.  */
         if (strcmp (name, "unsigned long") == 0
             || strcmp (name, "long unsigned int") == 0)
           {
             indx = builtin_unsigned_long;
             found = TRUE;
           }
         else if (strcmp (name, "unsigned") == 0)
           {
             indx = builtin_unsigned;
             found = TRUE;
           }
         else if (strcmp (name, "unsigned int") == 0)
           {
             indx = builtin_unsigned_int;
             found = TRUE;
           }
         break;

       case builtin_signed_long_long:
         if (strcmp (name, "signed long long") == 0
             || strcmp (name, "long long int") == 0)
           found = TRUE;
         break;

       case builtin_unsigned_long_long:
         if (strcmp (name, "unsigned long long") == 0
             || strcmp (name, "long long unsigned int") == 0)
           found = TRUE;
         break;

       case builtin_float:
         if (strcmp (name, "float") == 0)
           found = TRUE;
         break;

       case builtin_double:
         if (strcmp (name, "double") == 0)
           found = TRUE;
         break;

       case builtin_long_double:
         if (strcmp (name, "long double") == 0)
           found = TRUE;
         break;

       case builtin_long_long_double:
         if (strcmp (name, "long long double") == 0)
           found = TRUE;
         break;
       }

      if (found)
       type.indx = indx;
    }

  h = ieee_name_type_hash_lookup (&info->typedefs, name, TRUE, FALSE);
  if (h == NULL)
    return FALSE;

  /* See if we have already defined this type with this name.  */
  localp = type.localp;
  for (nt = h->types; nt != NULL; nt = nt->next)
    {
      if (nt->id == indx)
       {
         /* If this is a global definition, then we don't need to
            do anything here.  */
         if (! nt->type.localp)
           {
             ieee_pop_unused_type (info);
             return TRUE;
           }
       }
      else
       {
         /* This is a duplicate definition, so make this one local.  */
         localp = TRUE;
       }
    }

  /* We need to add a new typedef for this type.  */

  nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
  memset (nt, 0, sizeof *nt);
  nt->id = indx;
  nt->type = type;
  nt->type.name = name;
  nt->type.localp = localp;
  nt->kind = DEBUG_KIND_ILLEGAL;

  nt->next = h->types;
  h->types = nt;

  if (found)
    {
      /* This is one of the builtin typedefs, so we don't need to
         actually define it.  */
      ieee_pop_unused_type (info);
      return TRUE;
    }

  indx = ieee_pop_type (info);

  if (! ieee_define_named_type (info, name, (unsigned int) -1, type.size,
                            type.unsignedp,      localp,
                            (struct ieee_buflist *) NULL)
      || ! ieee_write_number (info, 'T')
      || ! ieee_write_number (info, indx))
    return FALSE;

  /* Remove the type we just added to the type stack.  This should not
     be ieee_pop_unused_type, since the type is used, we just don't
     need it now.  */
  (void) ieee_pop_type (info);

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_typed_constant ( void *  ,
const char *  ,
bfd_vma   
) [static]
static bfd_boolean ieee_typed_constant ( void *  p,
const char *name  ATTRIBUTE_UNUSED,
bfd_vma val  ATTRIBUTE_UNUSED 
) [static]

Definition at line 6863 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  /* FIXME.  */
  ieee_pop_unused_type (info);
  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_typedef_type ( void *  p,
const char *  name 
) [static]

Definition at line 6471 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  struct ieee_name_type_hash_entry *h;
  struct ieee_name_type *nt;

  h = ieee_name_type_hash_lookup (&info->typedefs, name, FALSE, FALSE);

  /* h should never be NULL, since that would imply that the generic
     debugging code has asked for a typedef which it has not yet
     defined.  */
  assert (h != NULL);

  /* We always use the most recently defined type for this name, which
     will be the first one on the list.  */

  nt = h->types;
  if (! ieee_push_type (info, nt->type.indx, nt->type.size,
                     nt->type.unsignedp, nt->type.localp))
    return FALSE;

  /* Copy over any other type information we may have.  */
  info->type_stack->type = nt->type;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_variable ( void *  p,
const char *  name,
enum debug_var_kind  kind,
bfd_vma  val 
) [static]

Definition at line 6876 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  unsigned int name_indx;
  unsigned int size;
  bfd_boolean referencep;
  unsigned int type_indx;
  bfd_boolean asn;
  int refflag;

  size = info->type_stack->type.size;
  referencep = info->type_stack->type.referencep;
  type_indx = ieee_pop_type (info);

  assert (! ieee_buffer_emptyp (&info->vars));
  if (! ieee_change_buffer (info, &info->vars))
    return FALSE;

  name_indx = info->name_indx;
  ++info->name_indx;

  /* Write out an NN and an ATN record for this variable.  */
  if (! ieee_write_byte (info, (int) ieee_nn_record)
      || ! ieee_write_number (info, name_indx)
      || ! ieee_write_id (info, name)
      || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
      || ! ieee_write_number (info, name_indx)
      || ! ieee_write_number (info, type_indx))
    return FALSE;
  switch (kind)
    {
    default:
      abort ();
      return FALSE;
    case DEBUG_GLOBAL:
      if (! ieee_write_number (info, 8)
         || ! ieee_add_range (info, FALSE, val, val + size))
       return FALSE;
      refflag = 0;
      asn = TRUE;
      break;
    case DEBUG_STATIC:
      if (! ieee_write_number (info, 3)
         || ! ieee_add_range (info, FALSE, val, val + size))
       return FALSE;
      refflag = 1;
      asn = TRUE;
      break;
    case DEBUG_LOCAL_STATIC:
      if (! ieee_write_number (info, 3)
         || ! ieee_add_range (info, FALSE, val, val + size))
       return FALSE;
      refflag = 2;
      asn = TRUE;
      break;
    case DEBUG_LOCAL:
      if (! ieee_write_number (info, 1)
         || ! ieee_write_number (info, val))
       return FALSE;
      refflag = 2;
      asn = FALSE;
      break;
    case DEBUG_REGISTER:
      if (! ieee_write_number (info, 2)
         || ! ieee_write_number (info,
                              ieee_genreg_to_regno (info->abfd, val)))
       return FALSE;
      refflag = 2;
      asn = FALSE;
      break;
    }

  if (asn)
    {
      if (! ieee_write_asn (info, name_indx, val))
       return FALSE;
    }

  /* If this is really a reference type, then we just output it with
     pointer type, and must now output a C++ record indicating that it
     is really reference type.  */
  if (referencep)
    {
      unsigned int nindx;

      nindx = info->name_indx;
      ++info->name_indx;

      /* If this is a global variable, we want to output the misc
         record in the C++ misc record block.  Otherwise, we want to
         output it just after the variable definition, which is where
         the current buffer is.  */
      if (refflag != 2)
       {
         if (! ieee_change_buffer (info, &info->cxx))
           return FALSE;
       }

      if (! ieee_write_byte (info, (int) ieee_nn_record)
         || ! ieee_write_number (info, nindx)
         || ! ieee_write_id (info, "")
         || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
         || ! ieee_write_number (info, nindx)
         || ! ieee_write_number (info, 0)
         || ! ieee_write_number (info, 62)
         || ! ieee_write_number (info, 80)
         || ! ieee_write_number (info, 3)
         || ! ieee_write_asn (info, nindx, 'R')
         || ! ieee_write_asn (info, nindx, refflag)
         || ! ieee_write_atn65 (info, nindx, name))
       return FALSE;
    }

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static unsigned int ieee_vis_to_flags ( enum debug_visibility  visibility) [static]

Definition at line 5799 of file ieee.c.

Here is the caller graph for this function:

static bfd_boolean ieee_void_type ( void *  p) [static]

Definition at line 5175 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;

  return ieee_push_type (info, (int) builtin_void, 0, FALSE, FALSE);
}

Here is the call graph for this function:

static bfd_boolean ieee_volatile_type ( void *  p) [static]

Definition at line 5760 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  unsigned int size;
  bfd_boolean unsignedp, localp;
  unsigned int indx;
  struct ieee_modified_type *m = NULL;

  size = info->type_stack->type.size;
  unsignedp = info->type_stack->type.unsignedp;
  localp = info->type_stack->type.localp;
  indx = ieee_pop_type (info);

  if (! localp)
    {
      m = ieee_get_modified_info (info, indx);
      if (m == NULL)
       return FALSE;

      if (m->volatile_qualified > 0)
       return ieee_push_type (info, m->volatile_qualified, size, unsignedp,
                            FALSE);
    }

  if (! ieee_define_type (info, size, unsignedp, localp)
      || ! ieee_write_number (info, 'n')
      || ! ieee_write_number (info, 2)
      || ! ieee_write_number (info, indx))
    return FALSE;

  if (! localp)
    m->volatile_qualified = info->type_stack->type.indx;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean ieee_write_2bytes ( struct ieee_handle info,
int  i 
) [static]

Definition at line 4129 of file ieee.c.

{
  return (ieee_write_byte (info, i >> 8)
         && ieee_write_byte (info, i & 0xff));
}

Here is the caller graph for this function:

static bfd_boolean ieee_write_asn ( struct ieee_handle info,
unsigned int  indx,
bfd_vma  val 
) [static]

Definition at line 4218 of file ieee.c.

{
  return (ieee_write_2bytes (info, (int) ieee_asn_record_enum)
         && ieee_write_number (info, indx)
         && ieee_write_number (info, val));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_write_atn65 ( struct ieee_handle info,
unsigned int  indx,
const char *  s 
) [static]

Definition at line 4228 of file ieee.c.

{
  return (ieee_write_2bytes (info, (int) ieee_atn_record_enum)
         && ieee_write_number (info, indx)
         && ieee_write_number (info, 0)
         && ieee_write_number (info, 65)
         && ieee_write_id (info, s));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_write_id ( struct ieee_handle info,
const char *  s 
) [static]

Definition at line 4180 of file ieee.c.

{
  unsigned int len;

  len = strlen (s);
  if (len <= 0x7f)
    {
      if (! ieee_write_byte (info, len))
       return FALSE;
    }
  else if (len <= 0xff)
    {
      if (! ieee_write_byte (info, (int) ieee_extension_length_1_enum)
         || ! ieee_write_byte (info, len))
       return FALSE;
    }
  else if (len <= 0xffff)
    {
      if (! ieee_write_byte (info, (int) ieee_extension_length_2_enum)
         || ! ieee_write_2bytes (info, len))
       return FALSE;
    }
  else
    {
      fprintf (stderr, _("IEEE string length overflow: %u\n"), len);
      return FALSE;
    }

  for (; *s != '\0'; s++)
    if (! ieee_write_byte (info, *s))
      return FALSE;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_write_number ( struct ieee_handle info,
bfd_vma  v 
) [static]

Definition at line 4138 of file ieee.c.

{
  bfd_vma t;
  bfd_byte ab[20];
  bfd_byte *p;
  unsigned int c;

  if (v <= (bfd_vma) ieee_number_end_enum)
    return ieee_write_byte (info, (int) v);

  t = v;
  p = ab + sizeof ab;
  while (t != 0)
    {
      *--p = t & 0xff;
      t >>= 8;
    }
  c = (ab + 20) - p;

  if (c > (unsigned int) (ieee_number_repeat_end_enum
                       - ieee_number_repeat_start_enum))
    {
      fprintf (stderr, _("IEEE numeric overflow: 0x"));
      fprintf_vma (stderr, v);
      fprintf (stderr, "\n");
      return FALSE;
    }

  if (! ieee_write_byte (info, (int) ieee_number_repeat_start_enum + c))
    return FALSE;
  for (; c > 0; --c, ++p)
    {
      if (! ieee_write_byte (info, *p))
       return FALSE;
    }

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean ieee_write_undefined_tag ( struct ieee_name_type_hash_entry h,
void *  p 
) [static]

Definition at line 4732 of file ieee.c.

{
  struct ieee_handle *info = (struct ieee_handle *) p;
  struct ieee_name_type *nt;

  for (nt = h->types; nt != NULL; nt = nt->next)
    {
      unsigned int name_indx;
      char code;

      if (nt->kind == DEBUG_KIND_ILLEGAL)
       continue;

      if (ieee_buffer_emptyp (&info->global_types))
       {
         if (! ieee_change_buffer (info, &info->global_types)
             || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
             || ! ieee_write_byte (info, 2)
             || ! ieee_write_number (info, 0)
             || ! ieee_write_id (info, ""))
           {
             info->error = TRUE;
             return FALSE;
           }
       }
      else
       {
         if (! ieee_change_buffer (info, &info->global_types))
           {
             info->error = TRUE;
             return FALSE;
           }
       }

      name_indx = info->name_indx;
      ++info->name_indx;
      if (! ieee_write_byte (info, (int) ieee_nn_record)
         || ! ieee_write_number (info, name_indx)
         || ! ieee_write_id (info, nt->type.name)
         || ! ieee_write_byte (info, (int) ieee_ty_record_enum)
         || ! ieee_write_number (info, nt->type.indx)
         || ! ieee_write_byte (info, 0xce)
         || ! ieee_write_number (info, name_indx))
       {
         info->error = TRUE;
         return FALSE;
       }

      switch (nt->kind)
       {
       default:
         abort ();
         info->error = TRUE;
         return FALSE;
       case DEBUG_KIND_STRUCT:
       case DEBUG_KIND_CLASS:
         code = 'S';
         break;
       case DEBUG_KIND_UNION:
       case DEBUG_KIND_UNION_CLASS:
         code = 'U';
         break;
       case DEBUG_KIND_ENUM:
         code = 'E';
         break;
       }
      if (! ieee_write_number (info, code)
         || ! ieee_write_number (info, 0))
       {
         info->error = TRUE;
         return FALSE;
       }
    }

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bfd_boolean parse_ieee ( void *  dhandle,
bfd abfd,
const bfd_byte bytes,
bfd_size_type  len 
)

Definition at line 857 of file ieee.c.

{
  struct ieee_info info;
  unsigned int i;
  const bfd_byte *p, *pend;

  info.dhandle = dhandle;
  info.abfd = abfd;
  info.bytes = bytes;
  info.pend = bytes + len;
  info.blockstack.bsp = info.blockstack.stack;
  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;

  p = bytes;
  pend = info.pend;
  while (p < pend)
    {
      const bfd_byte *record_start;
      ieee_record_enum_type c;

      record_start = p;

      c = (ieee_record_enum_type) *p++;

      if (c == ieee_at_record_enum)
       c = (ieee_record_enum_type) (((unsigned int) c << 8) | *p++);

      if (c <= ieee_number_repeat_end_enum)
       {
         ieee_error (&info, record_start, _("unexpected number"));
         return FALSE;
       }

      switch (c)
       {
       default:
         ieee_error (&info, record_start, _("unexpected record type"));
         return FALSE;

       case ieee_bb_record_enum:
         if (! parse_ieee_bb (&info, &p))
           return FALSE;
         break;

       case ieee_be_record_enum:
         if (! parse_ieee_be (&info, &p))
           return FALSE;
         break;

       case ieee_nn_record:
         if (! parse_ieee_nn (&info, &p))
           return FALSE;
         break;

       case ieee_ty_record_enum:
         if (! parse_ieee_ty (&info, &p))
           return FALSE;
         break;

       case ieee_atn_record_enum:
         if (! parse_ieee_atn (&info, &p))
           return FALSE;
         break;
       }
    }

  if (info.blockstack.bsp != info.blockstack.stack)
    {
      ieee_error (&info, (const bfd_byte *) NULL,
                _("blocks left on stack at end"));
      return FALSE;
    }

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean parse_ieee_atn ( struct ieee_info info,
const bfd_byte **  pp 
) [static]

Definition at line 2070 of file ieee.c.

{
  const bfd_byte *atn_start, *atn_code_start;
  bfd_vma varindx;
  struct ieee_var *pvar;
  debug_type type;
  bfd_vma atn_code;
  void *dhandle;
  bfd_vma v, v2, v3, v4, v5;
  const char *name;
  unsigned long namlen;
  char *namcopy;
  bfd_boolean present;
  int blocktype;

  atn_start = *pp;

  if (! ieee_read_number (info, pp, &varindx)
      || ! ieee_read_type_index (info, pp, &type))
    return FALSE;

  atn_code_start = *pp;

  if (! ieee_read_number (info, pp, &atn_code))
    return FALSE;

  if (varindx == 0)
    {
      pvar = NULL;
      name = "";
      namlen = 0;
    }
  else if (varindx < 32)
    {
      /* 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
    {
      varindx -= 32;
      if (varindx >= info->vars.alloc
         || info->vars.vars[varindx].name == NULL)
       {
         /* The MRI compiler or linker sometimes omits the NN record
             for a pmisc record.  */
         if (atn_code == 62)
           {
             if (varindx >= info->vars.alloc)
              {
                unsigned int alloc;

                alloc = info->vars.alloc;
                if (alloc == 0)
                  alloc = 4;
                while (varindx >= alloc)
                  alloc *= 2;
                info->vars.vars = ((struct ieee_var *)
                                 xrealloc (info->vars.vars,
                                          (alloc
                                          * sizeof *info->vars.vars)));
                memset (info->vars.vars + info->vars.alloc, 0,
                       ((alloc - info->vars.alloc)
                        * sizeof *info->vars.vars));
                info->vars.alloc = alloc;
              }

             pvar = info->vars.vars + varindx;
             pvar->name = "";
             pvar->namlen = 0;
           }
         else
           {
             ieee_error (info, atn_start, _("undefined variable in ATN"));
             return FALSE;
           }
       }

      pvar = info->vars.vars + varindx;

      pvar->type = type;

      name = pvar->name;
      namlen = pvar->namlen;
    }

  dhandle = info->dhandle;

  /* If we are going to call debug_record_variable with a pointer
     type, change the type to an indirect type so that we can later
     change it to a reference type if we encounter a C++ pmisc 'R'
     record.  */
  if (pvar != NULL
      && type != DEBUG_TYPE_NULL
      && debug_get_type_kind (dhandle, type) == DEBUG_KIND_POINTER)
    {
      switch (atn_code)
       {
       case 1:
       case 2:
       case 3:
       case 5:
       case 8:
       case 10:
         pvar->pslot = (debug_type *) xmalloc (sizeof *pvar->pslot);
         *pvar->pslot = type;
         type = debug_make_indirect_type (dhandle, pvar->pslot,
                                      (const char *) NULL);