URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [binutils/] [coffgrok.c] - Blame information for rev 595

Go to most recent revision | Details | Compare with Previous | View Log


/* coffgrok.c
   Copyright 1994, 1995, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2007
   Free Software Foundation, Inc.
 
   This file is part of GNU Binutils.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
 
 
/* Written by Steve Chamberlain (sac@cygnus.com)
 
   This module reads a coff file and builds a really simple type tree
   which can be read by other programs.  The first application is a
   coff->sysroff converter.  It can be tested with coffdump.c.  */
 
#include "sysdep.h"
#include "bfd.h"
#include "libiberty.h"
 
#include "coff/internal.h"
#include "../bfd/libcoff.h"
#include "bucomm.h"
#include "coffgrok.h"
 
static int lofile = 1;
static struct coff_scope *top_scope;
static struct coff_scope *file_scope;
static struct coff_ofile *ofile;
 
static struct coff_symbol *last_function_symbol;
static struct coff_type *last_function_type;
static struct coff_type *last_struct;
static struct coff_type *last_enum;
static struct coff_sfile *cur_sfile;
 
static struct coff_symbol **tindex;
 
 
static asymbol **syms;
static long symcount;
 
#define N(x) ((x)->_n._n_nptr[1])
 
static struct coff_ptr_struct *rawsyms;
static int rawcount;
static bfd *abfd;
 
#define PTR_SIZE        4
#define SHORT_SIZE      2
#define INT_SIZE        4
#define LONG_SIZE       4
#define FLOAT_SIZE      4
#define DOUBLE_SIZE     8
 
#define INDEXOF(p)  ((struct coff_ptr_struct *)(p)-(rawsyms))
 
static struct coff_scope *empty_scope (void);
static struct coff_symbol *empty_symbol (void);
static void push_scope (int);
static void pop_scope (void);
static void do_sections_p1 (struct coff_ofile *);
static void do_sections_p2 (struct coff_ofile *);
static struct coff_where *do_where (int);
static struct coff_line *do_lines (int, char *);
static struct coff_type *do_type (int);
static struct coff_visible *do_visible (int);
static int do_define (int, struct coff_scope *);
static struct coff_ofile *doit (void);
 
static struct coff_scope *
empty_scope (void)
{
  struct coff_scope *l;
  l = (struct coff_scope *) (xcalloc (sizeof (struct coff_scope), 1));
  return l;
}
 
static struct coff_symbol *
empty_symbol (void)
{
  return (struct coff_symbol *) (xcalloc (sizeof (struct coff_symbol), 1));
}
 
/*int l;*/
static void
push_scope (int link)
{
  struct coff_scope *n = empty_scope ();
  if (link)
    {
      if (top_scope)
        {
          if (top_scope->list_tail)
            {
              top_scope->list_tail->next = n;
            }
          else
            {
              top_scope->list_head = n;
            }
          top_scope->list_tail = n;
        }
    }
  n->parent = top_scope;
 
  top_scope = n;
}
 
static void
pop_scope (void)
{
  top_scope = top_scope->parent;
}
 
static void
do_sections_p1 (struct coff_ofile *head)
{
  asection *section;
  int idx;
  struct coff_section *all = (struct coff_section *) (xcalloc (abfd->section_count + 1,
                                             sizeof (struct coff_section)));
  head->nsections = abfd->section_count + 1;
  head->sections = all;
 
  for (idx = 0, section = abfd->sections; section; section = section->next, idx++)
    {
      long relsize;
      int i = section->target_index;
      arelent **relpp;
      long relcount;
 
      relsize = bfd_get_reloc_upper_bound (abfd, section);
      if (relsize < 0)
        bfd_fatal (bfd_get_filename (abfd));
      if (relsize == 0)
        continue;
      relpp = (arelent **) xmalloc (relsize);
      relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
      if (relcount < 0)
        bfd_fatal (bfd_get_filename (abfd));
 
      head->sections[i].name = (char *) (section->name);
      head->sections[i].code = section->flags & SEC_CODE;
      head->sections[i].data = section->flags & SEC_DATA;
      if (strcmp (section->name, ".bss") == 0)
        head->sections[i].data = 1;
      head->sections[i].address = section->lma;
      head->sections[i].size = bfd_get_section_size (section);
      head->sections[i].number = idx;
      head->sections[i].nrelocs = section->reloc_count;
      head->sections[i].relocs =
        (struct coff_reloc *) (xcalloc (section->reloc_count,
                                        sizeof (struct coff_reloc)));
      head->sections[i].bfd_section = section;
    }
  head->sections[0].name = "ABSOLUTE";
  head->sections[0].code = 0;
  head->sections[0].data = 0;
  head->sections[0].address = 0;
  head->sections[0].size = 0;
  head->sections[0].number = 0;
}
 
static void
do_sections_p2 (struct coff_ofile *head)
{
  asection *section;
  for (section = abfd->sections; section; section = section->next)
    {
      unsigned int j;
 
      for (j = 0; j < section->reloc_count; j++)
        {
          int idx;
          int i = section->target_index;
          struct coff_reloc *r = head->sections[i].relocs + j;
          arelent *sr = section->relocation + j;
          r->offset = sr->address;
          r->addend = sr->addend;
          idx = ((coff_symbol_type *) (sr->sym_ptr_ptr[0]))->native - rawsyms;
          r->symbol = tindex[idx];
        }
    }
}
 
static struct coff_where *
do_where (int i)
{
  struct internal_syment *sym = &rawsyms[i].u.syment;
  struct coff_where *where =
    (struct coff_where *) (xmalloc (sizeof (struct coff_where)));
  where->offset = sym->n_value;
 
  if (sym->n_scnum == -1)
    sym->n_scnum = 0;
 
  switch (sym->n_sclass)
    {
    case C_FIELD:
      where->where = coff_where_member_of_struct;
      where->offset = sym->n_value / 8;
      where->bitoffset = sym->n_value % 8;
      where->bitsize = rawsyms[i + 1].u.auxent.x_sym.x_misc.x_lnsz.x_size;
      break;
    case C_MOE:
      where->where = coff_where_member_of_enum;
      break;
    case C_MOS:
    case C_MOU:
      where->where = coff_where_member_of_struct;
      break;
    case C_AUTO:
    case C_ARG:
      where->where = coff_where_stack;
      break;
    case C_EXT:
    case C_STAT:
    case C_EXTDEF:
    case C_LABEL:
      where->where = coff_where_memory;
      where->section = &ofile->sections[sym->n_scnum];
      break;
    case C_REG:
    case C_REGPARM:
      where->where = coff_where_register;
      break;
    case C_ENTAG:
      where->where = coff_where_entag;
      break;
    case C_STRTAG:
    case C_UNTAG:
      where->where = coff_where_strtag;
      break;
    case C_TPDEF:
      where->where = coff_where_typedef;
      break;
    default:
      abort ();
      break;
    }
  return where;
}
 
static
struct coff_line *
do_lines (int i, char *name ATTRIBUTE_UNUSED)
{
  struct coff_line *res = (struct coff_line *) xcalloc (sizeof (struct coff_line), 1);
  asection *s;
  unsigned int l;
 
  /* Find out if this function has any line numbers in the table */
  for (s = abfd->sections; s; s = s->next)
    {
      for (l = 0; l < s->lineno_count; l++)
        {
          if (s->lineno[l].line_number == 0)
            {
              if (rawsyms + i == ((coff_symbol_type *) (&(s->lineno[l].u.sym[0])))->native)
                {
                  /* These lines are for this function - so count them and stick them on */
                  int c = 0;
                  /* Find the linenumber of the top of the function, since coff linenumbers
                     are relative to the start of the function.  */
                  int start_line = rawsyms[i + 3].u.auxent.x_sym.x_misc.x_lnsz.x_lnno;
 
                  l++;
                  for (c = 0; s->lineno[l + c + 1].line_number; c++)
                    ;
 
                  /* Add two extra records, one for the prologue and one for the epilogue */
                  c += 1;
                  res->nlines = c;
                  res->lines = (int *) (xcalloc (sizeof (int), c));
                  res->addresses = (int *) (xcalloc (sizeof (int), c));
                  res->lines[0] = start_line;
                  res->addresses[0] = rawsyms[i].u.syment.n_value - s->vma;
                  for (c = 0; s->lineno[l + c + 1].line_number; c++)
                    {
                      res->lines[c + 1] = s->lineno[l + c].line_number + start_line - 1;
                      res->addresses[c + 1] = s->lineno[l + c].u.offset;
                    }
                  return res;
                }
            }
        }
    }
  return res;
}
 
static
struct coff_type *
do_type (int i)
{
  struct internal_syment *sym = &rawsyms[i].u.syment;
  union internal_auxent *aux = &rawsyms[i + 1].u.auxent;
  struct coff_type *res =
    (struct coff_type *) xmalloc (sizeof (struct coff_type));
  int type = sym->n_type;
  int which_dt = 0;
  int dimind = 0;
 
  res->type = coff_basic_type;
  res->u.basic = type & 0xf;
 
  switch (type & 0xf)
    {
    case T_NULL:
    case T_VOID:
      if (sym->n_numaux && sym->n_sclass == C_STAT)
        {
          /* This is probably a section definition */
          res->type = coff_secdef_type;
          res->size = aux->x_scn.x_scnlen;
        }
      else
        {
          if (type == 0)
            {
              /* Don't know what this is, let's make it a simple int */
              res->size = INT_SIZE;
              res->u.basic = T_UINT;
            }
          else
            {
              /* Else it could be a function or pointer to void */
              res->size = 0;
            }
        }
      break;
 
 
      break;
    case T_UCHAR:
    case T_CHAR:
      res->size = 1;
      break;
    case T_USHORT:
    case T_SHORT:
      res->size = SHORT_SIZE;
      break;
    case T_UINT:
    case T_INT:
      res->size = INT_SIZE;
      break;
    case T_ULONG:
    case T_LONG:
      res->size = LONG_SIZE;
      break;
    case T_FLOAT:
      res->size = FLOAT_SIZE;
      break;
    case T_DOUBLE:
      res->size = DOUBLE_SIZE;
      break;
    case T_STRUCT:
    case T_UNION:
      if (sym->n_numaux)
        {
          if (aux->x_sym.x_tagndx.p)
            {
              /* Referring to a struct defined elsewhere */
              res->type = coff_structref_type;
              res->u.astructref.ref = tindex[INDEXOF (aux->x_sym.x_tagndx.p)];
              res->size = res->u.astructref.ref ?
                res->u.astructref.ref->type->size : 0;
            }
          else
            {
              /* A definition of a struct */
              last_struct = res;
              res->type = coff_structdef_type;
              res->u.astructdef.elements = empty_scope ();
              res->u.astructdef.idx = 0;
              res->u.astructdef.isstruct = (type & 0xf) == T_STRUCT;
              res->size = aux->x_sym.x_misc.x_lnsz.x_size;
            }
        }
      else
        {
          /* No auxents - it's anonymous */
          res->type = coff_structref_type;
          res->u.astructref.ref = 0;
          res->size = 0;
        }
      break;
    case T_ENUM:
      if (aux->x_sym.x_tagndx.p)
        {
          /* Referring to a enum defined elsewhere */
          res->type = coff_enumref_type;
          res->u.aenumref.ref = tindex[INDEXOF (aux->x_sym.x_tagndx.p)];
          res->size = res->u.aenumref.ref->type->size;
        }
      else
        {
          /* A definition of an enum */
          last_enum = res;
          res->type = coff_enumdef_type;
          res->u.aenumdef.elements = empty_scope ();
          res->size = aux->x_sym.x_misc.x_lnsz.x_size;
        }
      break;
    case T_MOE:
      break;
    }
 
  for (which_dt = 5; which_dt >= 0; which_dt--)
    {
      switch ((type >> ((which_dt * 2) + 4)) & 0x3)
        {
        case 0:
          break;
        case DT_ARY:
          {
            struct coff_type *ptr = ((struct coff_type *)
                                     xmalloc (sizeof (struct coff_type)));
            int els = (dimind < DIMNUM
                       ? aux->x_sym.x_fcnary.x_ary.x_dimen[dimind]
                       : 0);
            ++dimind;
            ptr->type = coff_array_type;
            ptr->size = els * res->size;
            ptr->u.array.dim = els;
            ptr->u.array.array_of = res;
            res = ptr;
            break;
          }
        case DT_PTR:
          {
            struct coff_type *ptr =
              (struct coff_type *) xmalloc (sizeof (struct coff_type));
            ptr->size = PTR_SIZE;
            ptr->type = coff_pointer_type;
            ptr->u.pointer.points_to = res;
            res = ptr;
            break;
          }
        case DT_FCN:
          {
            struct coff_type *ptr
              = (struct coff_type *) xmalloc (sizeof (struct coff_type));
            ptr->size = 0;
            ptr->type = coff_function_type;
            ptr->u.function.function_returns = res;
            ptr->u.function.parameters = empty_scope ();
            ptr->u.function.lines = do_lines (i, sym->_n._n_nptr[1]);
            ptr->u.function.code = 0;
            last_function_type = ptr;
            res = ptr;
            break;
          }
        }
    }
  return res;
}
 
static struct coff_visible *
do_visible (int i)
{
  struct internal_syment *sym = &rawsyms[i].u.syment;
  struct coff_visible *visible =
    (struct coff_visible *) (xmalloc (sizeof (struct coff_visible)));
  enum coff_vis_type t;
  switch (sym->n_sclass)
    {
    case C_MOS:
    case C_MOU:
    case C_FIELD:
      t = coff_vis_member_of_struct;
      break;
    case C_MOE:
      t = coff_vis_member_of_enum;
      break;
 
    case C_REGPARM:
      t = coff_vis_regparam;
      break;
 
    case C_REG:
      t = coff_vis_register;
      break;
    case C_STRTAG:
    case C_UNTAG:
    case C_ENTAG:
    case C_TPDEF:
      t = coff_vis_tag;
      break;
    case C_AUTOARG:
    case C_ARG:
      t = coff_vis_autoparam;
      break;
    case C_AUTO:
 
 
      t = coff_vis_auto;
      break;
    case C_LABEL:
    case C_STAT:
      t = coff_vis_int_def;
      break;
    case C_EXT:
      if (sym->n_scnum == N_UNDEF)
        {
          if (sym->n_value)
            t = coff_vis_common;
          else
            t = coff_vis_ext_ref;
        }
      else
        t = coff_vis_ext_def;
      break;
    default:
      abort ();
      break;
 
    }
  visible->type = t;
  return visible;
}
 
static int
do_define (int i, struct coff_scope *b)
{
  static int symbol_index;
  struct internal_syment *sym = &rawsyms[i].u.syment;
 
  /* Define a symbol and attach to block b */
  struct coff_symbol *s = empty_symbol ();
 
  s->number = ++symbol_index;
  s->name = sym->_n._n_nptr[1];
  s->sfile = cur_sfile;
  /* Glue onto the ofile list */
  if (lofile >= 0)
    {
      if (ofile->symbol_list_tail)
        ofile->symbol_list_tail->next_in_ofile_list = s;
      else
        ofile->symbol_list_head = s;
      ofile->symbol_list_tail = s;
      /* And the block list */
    }
  if (b->vars_tail)
    b->vars_tail->next = s;
  else
    b->vars_head = s;
 
  b->vars_tail = s;
  b->nvars++;
  s->type = do_type (i);
  s->where = do_where (i);
  s->visible = do_visible (i);
 
  tindex[i] = s;
 
  /* We remember the lowest address in each section for each source file */
 
  if (s->where->where == coff_where_memory
      && s->type->type == coff_secdef_type)
    {
      struct coff_isection *is = cur_sfile->section + s->where->section->number;
 
      if (!is->init)
        {
          is->low = s->where->offset;
          is->high = s->where->offset + s->type->size;
          is->init = 1;
          is->parent = s->where->section;
        }
 
    }
 
  if (s->type->type == coff_function_type)
    last_function_symbol = s;
 
  return i + sym->n_numaux + 1;
}
 
 
static
struct coff_ofile *
doit (void)
{
  int i;
  int infile = 0;
  struct coff_ofile *head =
    (struct coff_ofile *) xmalloc (sizeof (struct coff_ofile));
  ofile = head;
  head->source_head = 0;
  head->source_tail = 0;
  head->nsources = 0;
  head->symbol_list_tail = 0;
  head->symbol_list_head = 0;
  do_sections_p1 (head);
  push_scope (1);
 
  for (i = 0; i < rawcount;)
    {
      struct internal_syment *sym = &rawsyms[i].u.syment;
      switch (sym->n_sclass)
        {
        case C_FILE:
          {
            /* new source file announced */
            struct coff_sfile *n =
              (struct coff_sfile *) xmalloc (sizeof (struct coff_sfile));
            n->section = (struct coff_isection *) xcalloc (sizeof (struct coff_isection), abfd->section_count + 1);
            cur_sfile = n;
            n->name = sym->_n._n_nptr[1];
            n->next = 0;
 
            if (infile)
              {
                pop_scope ();
              }
            infile = 1;
            push_scope (1);
            file_scope = n->scope = top_scope;
 
            if (head->source_tail)
              head->source_tail->next = n;
            else
              head->source_head = n;
            head->source_tail = n;
            head->nsources++;
            i += sym->n_numaux + 1;
          }
          break;
        case C_FCN:
          {
            char *name = sym->_n._n_nptr[1];
            if (name[1] == 'b')
              {
                /* Function start */
                push_scope (0);
                last_function_type->u.function.code = top_scope;
                top_scope->sec = ofile->sections + sym->n_scnum;
                top_scope->offset = sym->n_value;
              }
            else
              {
                top_scope->size = sym->n_value - top_scope->offset + 1;
                pop_scope ();
 
              }
            i += sym->n_numaux + 1;
          }
          break;
 
        case C_BLOCK:
          {
            char *name = sym->_n._n_nptr[1];
            if (name[1] == 'b')
              {
                /* Block start */
                push_scope (1);
                top_scope->sec = ofile->sections + sym->n_scnum;
                top_scope->offset = sym->n_value;
 
              }
            else
              {
                top_scope->size = sym->n_value - top_scope->offset + 1;
                pop_scope ();
              }
            i += sym->n_numaux + 1;
          }
          break;
        case C_REGPARM:
        case C_ARG:
          i = do_define (i, last_function_symbol->type->u.function.parameters);
          break;
        case C_MOS:
        case C_MOU:
        case C_FIELD:
          i = do_define (i, last_struct->u.astructdef.elements);
          break;
        case C_MOE:
          i = do_define (i, last_enum->u.aenumdef.elements);
          break;
        case C_STRTAG:
        case C_ENTAG:
        case C_UNTAG:
          /* Various definition */
          i = do_define (i, top_scope);
          break;
        case C_EXT:
        case C_LABEL:
          i = do_define (i, file_scope);
          break;
        case C_STAT:
        case C_TPDEF:
        case C_AUTO:
        case C_REG:
          i = do_define (i, top_scope);
          break;
        default:
          abort ();
        case C_EOS:
          i += sym->n_numaux + 1;
          break;
        }
    }
  do_sections_p2 (head);
  return head;
}
 
struct coff_ofile *
coff_grok (bfd *inabfd)
{
  long storage;
  struct coff_ofile *p;
  abfd = inabfd;
  storage = bfd_get_symtab_upper_bound (abfd);
 
  if (storage < 0)
    bfd_fatal (abfd->filename);
 
  syms = (asymbol **) xmalloc (storage);
  symcount = bfd_canonicalize_symtab (abfd, syms);
  if (symcount < 0)
    bfd_fatal (abfd->filename);
  rawsyms = obj_raw_syments (abfd);
  rawcount = obj_raw_syment_count (abfd);;
  tindex = (struct coff_symbol **) (xcalloc (sizeof (struct coff_symbol *), rawcount));
 
  p = doit ();
  return p;
}

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [binutils/] [coffgrok.c] - Blame information for rev 595

Line No.	Rev	Author	Line
1	205	julius	`/* coffgrok.c`
2			`Copyright 1994, 1995, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2007`
3			`Free Software Foundation, Inc.`
4
5			`This file is part of GNU Binutils.`
6
7			`This program is free software; you can redistribute it and/or modify`
8			`it under the terms of the GNU General Public License as published by`
9			`the Free Software Foundation; either version 3 of the License, or`
10			`(at your option) any later version.`
11
12			`This program is distributed in the hope that it will be useful,`
13			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
14			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15			`GNU General Public License for more details.`
16
17			`You should have received a copy of the GNU General Public License`
18			`along with this program; if not, write to the Free Software`
19			`Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,`
20			`MA 02110-1301, USA. */`
21
22
23			`/* Written by Steve Chamberlain (sac@cygnus.com)`
24
25			`This module reads a coff file and builds a really simple type tree`
26			`which can be read by other programs. The first application is a`
27			`coff->sysroff converter. It can be tested with coffdump.c. */`
28
29			`#include "sysdep.h"`
30			`#include "bfd.h"`
31			`#include "libiberty.h"`
32
33			`#include "coff/internal.h"`
34			`#include "../bfd/libcoff.h"`
35			`#include "bucomm.h"`
36			`#include "coffgrok.h"`
37
38			`static int lofile = 1;`
39			`static struct coff_scope *top_scope;`
40			`static struct coff_scope *file_scope;`
41			`static struct coff_ofile *ofile;`
42
43			`static struct coff_symbol *last_function_symbol;`
44			`static struct coff_type *last_function_type;`
45			`static struct coff_type *last_struct;`
46			`static struct coff_type *last_enum;`
47			`static struct coff_sfile *cur_sfile;`
48
49			`static struct coff_symbol **tindex;`
50
51
52			`static asymbol **syms;`
53			`static long symcount;`
54
55			`#define N(x) ((x)->_n._n_nptr[1])`
56
57			`static struct coff_ptr_struct *rawsyms;`
58			`static int rawcount;`
59			`static bfd *abfd;`
60
61			`#define PTR_SIZE 4`
62			`#define SHORT_SIZE 2`
63			`#define INT_SIZE 4`
64			`#define LONG_SIZE 4`
65			`#define FLOAT_SIZE 4`
66			`#define DOUBLE_SIZE 8`
67
68			`#define INDEXOF(p) ((struct coff_ptr_struct *)(p)-(rawsyms))`
69
70			`static struct coff_scope *empty_scope (void);`
71			`static struct coff_symbol *empty_symbol (void);`
72			`static void push_scope (int);`
73			`static void pop_scope (void);`
74			`static void do_sections_p1 (struct coff_ofile *);`
75			`static void do_sections_p2 (struct coff_ofile *);`
76			`static struct coff_where *do_where (int);`
77			`static struct coff_line do_lines (int, char );`
78			`static struct coff_type *do_type (int);`
79			`static struct coff_visible *do_visible (int);`
80			`static int do_define (int, struct coff_scope *);`
81			`static struct coff_ofile *doit (void);`
82
83			`static struct coff_scope *`
84			`empty_scope (void)`
85			`{`
86			`struct coff_scope *l;`
87			`l = (struct coff_scope *) (xcalloc (sizeof (struct coff_scope), 1));`
88			`return l;`
89			`}`
90
91			`static struct coff_symbol *`
92			`empty_symbol (void)`
93			`{`
94			`return (struct coff_symbol *) (xcalloc (sizeof (struct coff_symbol), 1));`
95			`}`
96
97			`/int l;/`
98			`static void`
99			`push_scope (int link)`
100			`{`
101			`struct coff_scope *n = empty_scope ();`
102			`if (link)`
103			`{`
104			`if (top_scope)`
105			`{`
106			`if (top_scope->list_tail)`
107			`{`
108			`top_scope->list_tail->next = n;`
109			`}`
110			`else`
111			`{`
112			`top_scope->list_head = n;`
113			`}`
114			`top_scope->list_tail = n;`
115			`}`
116			`}`
117			`n->parent = top_scope;`
118
119			`top_scope = n;`
120			`}`
121
122			`static void`
123			`pop_scope (void)`
124			`{`
125			`top_scope = top_scope->parent;`
126			`}`
127
128			`static void`
129			`do_sections_p1 (struct coff_ofile *head)`
130			`{`
131			`asection *section;`
132			`int idx;`
133			`struct coff_section all = (struct coff_section ) (xcalloc (abfd->section_count + 1,`
134			`sizeof (struct coff_section)));`
135			`head->nsections = abfd->section_count + 1;`
136			`head->sections = all;`
137
138			`for (idx = 0, section = abfd->sections; section; section = section->next, idx++)`
139			`{`
140			`long relsize;`
141			`int i = section->target_index;`
142			`arelent **relpp;`
143			`long relcount;`
144
145			`relsize = bfd_get_reloc_upper_bound (abfd, section);`
146			`if (relsize < 0)`
147			`bfd_fatal (bfd_get_filename (abfd));`
148			`if (relsize == 0)`
149			`continue;`
150			`relpp = (arelent **) xmalloc (relsize);`
151			`relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);`
152			`if (relcount < 0)`
153			`bfd_fatal (bfd_get_filename (abfd));`
154
155			`head->sections[i].name = (char *) (section->name);`
156			`head->sections[i].code = section->flags & SEC_CODE;`
157			`head->sections[i].data = section->flags & SEC_DATA;`
158			`if (strcmp (section->name, ".bss") == 0)`
159			`head->sections[i].data = 1;`
160			`head->sections[i].address = section->lma;`
161			`head->sections[i].size = bfd_get_section_size (section);`
162			`head->sections[i].number = idx;`
163			`head->sections[i].nrelocs = section->reloc_count;`
164			`head->sections[i].relocs =`
165			`(struct coff_reloc *) (xcalloc (section->reloc_count,`
166			`sizeof (struct coff_reloc)));`
167			`head->sections[i].bfd_section = section;`
168			`}`
169			`head->sections[0].name = "ABSOLUTE";`
170			`head->sections[0].code = 0;`
171			`head->sections[0].data = 0;`
172			`head->sections[0].address = 0;`
173			`head->sections[0].size = 0;`
174			`head->sections[0].number = 0;`
175			`}`
176
177			`static void`
178			`do_sections_p2 (struct coff_ofile *head)`
179			`{`
180			`asection *section;`
181			`for (section = abfd->sections; section; section = section->next)`
182			`{`
183			`unsigned int j;`
184
185			`for (j = 0; j < section->reloc_count; j++)`
186			`{`
187			`int idx;`
188			`int i = section->target_index;`
189			`struct coff_reloc *r = head->sections[i].relocs + j;`
190			`arelent *sr = section->relocation + j;`
191			`r->offset = sr->address;`
192			`r->addend = sr->addend;`
193			`idx = ((coff_symbol_type *) (sr->sym_ptr_ptr[0]))->native - rawsyms;`
194			`r->symbol = tindex[idx];`
195			`}`
196			`}`
197			`}`
198
199			`static struct coff_where *`
200			`do_where (int i)`
201			`{`
202			`struct internal_syment *sym = &rawsyms[i].u.syment;`
203			`struct coff_where *where =`
204			`(struct coff_where *) (xmalloc (sizeof (struct coff_where)));`
205			`where->offset = sym->n_value;`
206
207			`if (sym->n_scnum == -1)`
208			`sym->n_scnum = 0;`
209
210			`switch (sym->n_sclass)`
211			`{`
212			`case C_FIELD:`
213			`where->where = coff_where_member_of_struct;`
214			`where->offset = sym->n_value / 8;`
215			`where->bitoffset = sym->n_value % 8;`
216			`where->bitsize = rawsyms[i + 1].u.auxent.x_sym.x_misc.x_lnsz.x_size;`
217			`break;`
218			`case C_MOE:`
219			`where->where = coff_where_member_of_enum;`
220			`break;`
221			`case C_MOS:`
222			`case C_MOU:`
223			`where->where = coff_where_member_of_struct;`
224			`break;`
225			`case C_AUTO:`
226			`case C_ARG:`
227			`where->where = coff_where_stack;`
228			`break;`
229			`case C_EXT:`
230			`case C_STAT:`
231			`case C_EXTDEF:`
232			`case C_LABEL:`
233			`where->where = coff_where_memory;`
234			`where->section = &ofile->sections[sym->n_scnum];`
235			`break;`
236			`case C_REG:`
237			`case C_REGPARM:`
238			`where->where = coff_where_register;`
239			`break;`
240			`case C_ENTAG:`
241			`where->where = coff_where_entag;`
242			`break;`
243			`case C_STRTAG:`
244			`case C_UNTAG:`
245			`where->where = coff_where_strtag;`
246			`break;`
247			`case C_TPDEF:`
248			`where->where = coff_where_typedef;`
249			`break;`
250			`default:`
251			`abort ();`
252			`break;`
253			`}`
254			`return where;`
255			`}`
256
257			`static`
258			`struct coff_line *`
259			`do_lines (int i, char *name ATTRIBUTE_UNUSED)`
260			`{`
261			`struct coff_line res = (struct coff_line ) xcalloc (sizeof (struct coff_line), 1);`
262			`asection *s;`
263			`unsigned int l;`
264
265			`/* Find out if this function has any line numbers in the table */`
266			`for (s = abfd->sections; s; s = s->next)`
267			`{`
268			`for (l = 0; l < s->lineno_count; l++)`
269			`{`
270			`if (s->lineno[l].line_number == 0)`
271			`{`
272			`if (rawsyms + i == ((coff_symbol_type *) (&(s->lineno[l].u.sym[0])))->native)`
273			`{`
274			`/* These lines are for this function - so count them and stick them on */`
275			`int c = 0;`
276			`/* Find the linenumber of the top of the function, since coff linenumbers`
277			`are relative to the start of the function. */`
278			`int start_line = rawsyms[i + 3].u.auxent.x_sym.x_misc.x_lnsz.x_lnno;`
279
280			`l++;`
281			`for (c = 0; s->lineno[l + c + 1].line_number; c++)`
282			`;`
283
284			`/* Add two extra records, one for the prologue and one for the epilogue */`
285			`c += 1;`
286			`res->nlines = c;`
287			`res->lines = (int *) (xcalloc (sizeof (int), c));`
288			`res->addresses = (int *) (xcalloc (sizeof (int), c));`
289			`res->lines[0] = start_line;`
290			`res->addresses[0] = rawsyms[i].u.syment.n_value - s->vma;`
291			`for (c = 0; s->lineno[l + c + 1].line_number; c++)`
292			`{`
293			`res->lines[c + 1] = s->lineno[l + c].line_number + start_line - 1;`
294			`res->addresses[c + 1] = s->lineno[l + c].u.offset;`
295			`}`
296			`return res;`
297			`}`
298			`}`
299			`}`
300			`}`
301			`return res;`
302			`}`
303
304			`static`
305			`struct coff_type *`
306			`do_type (int i)`
307			`{`
308			`struct internal_syment *sym = &rawsyms[i].u.syment;`
309			`union internal_auxent *aux = &rawsyms[i + 1].u.auxent;`
310			`struct coff_type *res =`
311			`(struct coff_type *) xmalloc (sizeof (struct coff_type));`
312			`int type = sym->n_type;`
313			`int which_dt = 0;`
314			`int dimind = 0;`
315
316			`res->type = coff_basic_type;`
317			`res->u.basic = type & 0xf;`
318
319			`switch (type & 0xf)`
320			`{`
321			`case T_NULL:`
322			`case T_VOID:`
323			`if (sym->n_numaux && sym->n_sclass == C_STAT)`
324			`{`
325			`/* This is probably a section definition */`
326			`res->type = coff_secdef_type;`
327			`res->size = aux->x_scn.x_scnlen;`
328			`}`
329			`else`
330			`{`
331			`if (type == 0)`
332			`{`
333			`/* Don't know what this is, let's make it a simple int */`
334			`res->size = INT_SIZE;`
335			`res->u.basic = T_UINT;`
336			`}`
337			`else`
338			`{`
339			`/* Else it could be a function or pointer to void */`
340			`res->size = 0;`
341			`}`
342			`}`
343			`break;`
344
345
346			`break;`
347			`case T_UCHAR:`
348			`case T_CHAR:`
349			`res->size = 1;`
350			`break;`
351			`case T_USHORT:`
352			`case T_SHORT:`
353			`res->size = SHORT_SIZE;`
354			`break;`
355			`case T_UINT:`
356			`case T_INT:`
357			`res->size = INT_SIZE;`
358			`break;`
359			`case T_ULONG:`
360			`case T_LONG:`
361			`res->size = LONG_SIZE;`
362			`break;`
363			`case T_FLOAT:`
364			`res->size = FLOAT_SIZE;`
365			`break;`
366			`case T_DOUBLE:`
367			`res->size = DOUBLE_SIZE;`
368			`break;`
369			`case T_STRUCT:`
370			`case T_UNION:`
371			`if (sym->n_numaux)`
372			`{`
373			`if (aux->x_sym.x_tagndx.p)`
374			`{`
375			`/* Referring to a struct defined elsewhere */`
376			`res->type = coff_structref_type;`
377			`res->u.astructref.ref = tindex[INDEXOF (aux->x_sym.x_tagndx.p)];`
378			`res->size = res->u.astructref.ref ?`
379			`res->u.astructref.ref->type->size : 0;`
380			`}`
381			`else`
382			`{`
383			`/* A definition of a struct */`
384			`last_struct = res;`
385			`res->type = coff_structdef_type;`
386			`res->u.astructdef.elements = empty_scope ();`
387			`res->u.astructdef.idx = 0;`
388			`res->u.astructdef.isstruct = (type & 0xf) == T_STRUCT;`
389			`res->size = aux->x_sym.x_misc.x_lnsz.x_size;`
390			`}`
391			`}`
392			`else`
393			`{`
394			`/* No auxents - it's anonymous */`
395			`res->type = coff_structref_type;`
396			`res->u.astructref.ref = 0;`
397			`res->size = 0;`
398			`}`
399			`break;`
400			`case T_ENUM:`
401			`if (aux->x_sym.x_tagndx.p)`
402			`{`
403			`/* Referring to a enum defined elsewhere */`
404			`res->type = coff_enumref_type;`
405			`res->u.aenumref.ref = tindex[INDEXOF (aux->x_sym.x_tagndx.p)];`
406			`res->size = res->u.aenumref.ref->type->size;`
407			`}`
408			`else`
409			`{`
410			`/* A definition of an enum */`
411			`last_enum = res;`
412			`res->type = coff_enumdef_type;`
413			`res->u.aenumdef.elements = empty_scope ();`
414			`res->size = aux->x_sym.x_misc.x_lnsz.x_size;`
415			`}`
416			`break;`
417			`case T_MOE:`
418			`break;`
419			`}`
420
421			`for (which_dt = 5; which_dt >= 0; which_dt--)`
422			`{`
423			`switch ((type >> ((which_dt * 2) + 4)) & 0x3)`
424			`{`
425			`case 0:`
426			`break;`
427			`case DT_ARY:`
428			`{`
429			`struct coff_type ptr = ((struct coff_type )`
430			`xmalloc (sizeof (struct coff_type)));`
431			`int els = (dimind < DIMNUM`
432			`? aux->x_sym.x_fcnary.x_ary.x_dimen[dimind]`
433			`: 0);`
434			`++dimind;`
435			`ptr->type = coff_array_type;`
436			`ptr->size = els * res->size;`
437			`ptr->u.array.dim = els;`
438			`ptr->u.array.array_of = res;`
439			`res = ptr;`
440			`break;`
441			`}`
442			`case DT_PTR:`
443			`{`
444			`struct coff_type *ptr =`
445			`(struct coff_type *) xmalloc (sizeof (struct coff_type));`
446			`ptr->size = PTR_SIZE;`
447			`ptr->type = coff_pointer_type;`
448			`ptr->u.pointer.points_to = res;`
449			`res = ptr;`
450			`break;`
451			`}`
452			`case DT_FCN:`
453			`{`
454			`struct coff_type *ptr`
455			`= (struct coff_type *) xmalloc (sizeof (struct coff_type));`
456			`ptr->size = 0;`
457			`ptr->type = coff_function_type;`
458			`ptr->u.function.function_returns = res;`
459			`ptr->u.function.parameters = empty_scope ();`
460			`ptr->u.function.lines = do_lines (i, sym->_n._n_nptr[1]);`
461			`ptr->u.function.code = 0;`
462			`last_function_type = ptr;`
463			`res = ptr;`
464			`break;`
465			`}`
466			`}`
467			`}`
468			`return res;`
469			`}`
470
471			`static struct coff_visible *`
472			`do_visible (int i)`
473			`{`
474			`struct internal_syment *sym = &rawsyms[i].u.syment;`
475			`struct coff_visible *visible =`
476			`(struct coff_visible *) (xmalloc (sizeof (struct coff_visible)));`
477			`enum coff_vis_type t;`
478			`switch (sym->n_sclass)`
479			`{`
480			`case C_MOS:`
481			`case C_MOU:`
482			`case C_FIELD:`
483			`t = coff_vis_member_of_struct;`
484			`break;`
485			`case C_MOE:`
486			`t = coff_vis_member_of_enum;`
487			`break;`
488
489			`case C_REGPARM:`
490			`t = coff_vis_regparam;`
491			`break;`
492
493			`case C_REG:`
494			`t = coff_vis_register;`
495			`break;`
496			`case C_STRTAG:`
497			`case C_UNTAG:`
498			`case C_ENTAG:`
499			`case C_TPDEF:`
500			`t = coff_vis_tag;`
501			`break;`
502			`case C_AUTOARG:`
503			`case C_ARG:`
504			`t = coff_vis_autoparam;`
505			`break;`
506			`case C_AUTO:`
507
508
509			`t = coff_vis_auto;`
510			`break;`
511			`case C_LABEL:`
512			`case C_STAT:`
513			`t = coff_vis_int_def;`
514			`break;`
515			`case C_EXT:`
516			`if (sym->n_scnum == N_UNDEF)`
517			`{`
518			`if (sym->n_value)`
519			`t = coff_vis_common;`
520			`else`
521			`t = coff_vis_ext_ref;`
522			`}`
523			`else`
524			`t = coff_vis_ext_def;`
525			`break;`
526			`default:`
527			`abort ();`
528			`break;`
529
530			`}`
531			`visible->type = t;`
532			`return visible;`
533			`}`
534
535			`static int`
536			`do_define (int i, struct coff_scope *b)`
537			`{`
538			`static int symbol_index;`
539			`struct internal_syment *sym = &rawsyms[i].u.syment;`
540
541			`/* Define a symbol and attach to block b */`
542			`struct coff_symbol *s = empty_symbol ();`
543
544			`s->number = ++symbol_index;`
545			`s->name = sym->_n._n_nptr[1];`
546			`s->sfile = cur_sfile;`
547			`/* Glue onto the ofile list */`
548			`if (lofile >= 0)`
549			`{`
550			`if (ofile->symbol_list_tail)`
551			`ofile->symbol_list_tail->next_in_ofile_list = s;`
552			`else`
553			`ofile->symbol_list_head = s;`
554			`ofile->symbol_list_tail = s;`
555			`/* And the block list */`
556			`}`
557			`if (b->vars_tail)`
558			`b->vars_tail->next = s;`
559			`else`
560			`b->vars_head = s;`
561
562			`b->vars_tail = s;`
563			`b->nvars++;`
564			`s->type = do_type (i);`
565			`s->where = do_where (i);`
566			`s->visible = do_visible (i);`
567
568			`tindex[i] = s;`
569
570			`/* We remember the lowest address in each section for each source file */`
571
572			`if (s->where->where == coff_where_memory`
573			`&& s->type->type == coff_secdef_type)`
574			`{`
575			`struct coff_isection *is = cur_sfile->section + s->where->section->number;`
576
577			`if (!is->init)`
578			`{`
579			`is->low = s->where->offset;`
580			`is->high = s->where->offset + s->type->size;`
581			`is->init = 1;`
582			`is->parent = s->where->section;`
583			`}`
584
585			`}`
586
587			`if (s->type->type == coff_function_type)`
588			`last_function_symbol = s;`
589
590			`return i + sym->n_numaux + 1;`
591			`}`
592
593
594			`static`
595			`struct coff_ofile *`
596			`doit (void)`
597			`{`
598			`int i;`
599			`int infile = 0;`
600			`struct coff_ofile *head =`
601			`(struct coff_ofile *) xmalloc (sizeof (struct coff_ofile));`
602			`ofile = head;`
603			`head->source_head = 0;`
604			`head->source_tail = 0;`
605			`head->nsources = 0;`
606			`head->symbol_list_tail = 0;`
607			`head->symbol_list_head = 0;`
608			`do_sections_p1 (head);`
609			`push_scope (1);`
610
611			`for (i = 0; i < rawcount;)`
612			`{`
613			`struct internal_syment *sym = &rawsyms[i].u.syment;`
614			`switch (sym->n_sclass)`
615			`{`
616			`case C_FILE:`
617			`{`
618			`/* new source file announced */`
619			`struct coff_sfile *n =`
620			`(struct coff_sfile *) xmalloc (sizeof (struct coff_sfile));`
621			`n->section = (struct coff_isection *) xcalloc (sizeof (struct coff_isection), abfd->section_count + 1);`
622			`cur_sfile = n;`
623			`n->name = sym->_n._n_nptr[1];`
624			`n->next = 0;`
625
626			`if (infile)`
627			`{`
628			`pop_scope ();`
629			`}`
630			`infile = 1;`
631			`push_scope (1);`
632			`file_scope = n->scope = top_scope;`
633
634			`if (head->source_tail)`
635			`head->source_tail->next = n;`
636			`else`
637			`head->source_head = n;`
638			`head->source_tail = n;`
639			`head->nsources++;`
640			`i += sym->n_numaux + 1;`
641			`}`
642			`break;`
643			`case C_FCN:`
644			`{`
645			`char *name = sym->_n._n_nptr[1];`
646			`if (name[1] == 'b')`
647			`{`
648			`/* Function start */`
649			`push_scope (0);`
650			`last_function_type->u.function.code = top_scope;`
651			`top_scope->sec = ofile->sections + sym->n_scnum;`
652			`top_scope->offset = sym->n_value;`
653			`}`
654			`else`
655			`{`
656			`top_scope->size = sym->n_value - top_scope->offset + 1;`
657			`pop_scope ();`
658
659			`}`
660			`i += sym->n_numaux + 1;`
661			`}`
662			`break;`
663
664			`case C_BLOCK:`
665			`{`
666			`char *name = sym->_n._n_nptr[1];`
667			`if (name[1] == 'b')`
668			`{`
669			`/* Block start */`
670			`push_scope (1);`
671			`top_scope->sec = ofile->sections + sym->n_scnum;`
672			`top_scope->offset = sym->n_value;`
673
674			`}`
675			`else`
676			`{`
677			`top_scope->size = sym->n_value - top_scope->offset + 1;`
678			`pop_scope ();`
679			`}`
680			`i += sym->n_numaux + 1;`
681			`}`
682			`break;`
683			`case C_REGPARM:`
684			`case C_ARG:`
685			`i = do_define (i, last_function_symbol->type->u.function.parameters);`
686			`break;`
687			`case C_MOS:`
688			`case C_MOU:`
689			`case C_FIELD:`
690			`i = do_define (i, last_struct->u.astructdef.elements);`
691			`break;`
692			`case C_MOE:`
693			`i = do_define (i, last_enum->u.aenumdef.elements);`
694			`break;`
695			`case C_STRTAG:`
696			`case C_ENTAG:`
697			`case C_UNTAG:`
698			`/* Various definition */`
699			`i = do_define (i, top_scope);`
700			`break;`
701			`case C_EXT:`
702			`case C_LABEL:`
703			`i = do_define (i, file_scope);`
704			`break;`
705			`case C_STAT:`
706			`case C_TPDEF:`
707			`case C_AUTO:`
708			`case C_REG:`
709			`i = do_define (i, top_scope);`
710			`break;`
711			`default:`
712			`abort ();`
713			`case C_EOS:`
714			`i += sym->n_numaux + 1;`
715			`break;`
716			`}`
717			`}`
718			`do_sections_p2 (head);`
719			`return head;`
720			`}`
721
722			`struct coff_ofile *`
723			`coff_grok (bfd *inabfd)`
724			`{`
725			`long storage;`
726			`struct coff_ofile *p;`
727			`abfd = inabfd;`
728			`storage = bfd_get_symtab_upper_bound (abfd);`
729
730			`if (storage < 0)`
731			`bfd_fatal (abfd->filename);`
732
733			`syms = (asymbol **) xmalloc (storage);`
734			`symcount = bfd_canonicalize_symtab (abfd, syms);`
735			`if (symcount < 0)`
736			`bfd_fatal (abfd->filename);`
737			`rawsyms = obj_raw_syments (abfd);`
738			`rawcount = obj_raw_syment_count (abfd);;`
739			`tindex = (struct coff_symbol *) (xcalloc (sizeof (struct coff_symbol ), rawcount));`
740
741			`p = doit ();`
742			`return p;`
743			`}`