binutils/coffgrok.c

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