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           /* PR 17512: file: b85b67e8.  */
 480           if (res->u.aenumref.ref)
 481             res->size = res->u.aenumref.ref->type->size;
 482           else
 483             res->size = 0;
 484         }
 485       else
 486         {
 487           /* A definition of an enum.  */
 488           last_enum = res;
 489           res->type = coff_enumdef_type;
 490           res->u.aenumdef.elements = empty_scope ();
 491           res->size = aux->x_sym.x_misc.x_lnsz.x_size;
 492         }
 493       break;
 494     case T_MOE:
 495       break;
 496     }
 497
 498   for (which_dt = 5; which_dt >= 0; which_dt--)
 499     {
 500       switch ((type >> ((which_dt * 2) + 4)) & 0x3)
 501         {
 502         case 0:
 503           break;
 504         case DT_ARY:
 505           {
 506             struct coff_type *ptr = ((struct coff_type *)
 507                                      xmalloc (sizeof (struct coff_type)));
 508             int els;
 509
 510             if (aux == NULL)
 511               fatal (_("Array definition needs auxillary information"));
 512             els = (dimind < DIMNUM
 513                    ? aux->x_sym.x_fcnary.x_ary.x_dimen[dimind]
 514                    : 0);
 515
 516             ++dimind;
 517             ptr->type = coff_array_type;
 518             ptr->size = els * res->size;
 519             ptr->u.array.dim = els;
 520             ptr->u.array.array_of = res;
 521             res = ptr;
 522             break;
 523           }
 524         case DT_PTR:
 525           {
 526             struct coff_type *ptr =
 527               (struct coff_type *) xmalloc (sizeof (struct coff_type));
 528
 529             ptr->size = PTR_SIZE;
 530             ptr->type = coff_pointer_type;
 531             ptr->u.pointer.points_to = res;
 532             res = ptr;
 533             break;
 534           }
 535         case DT_FCN:
 536           {
 537             struct coff_type *ptr
 538               = (struct coff_type *) xmalloc (sizeof (struct coff_type));
 539
 540             ptr->size = 0;
 541             ptr->type = coff_function_type;
 542             ptr->u.function.function_returns = res;
 543             ptr->u.function.parameters = empty_scope ();
 544             ptr->u.function.lines = do_lines (i, N(sym));
 545             ptr->u.function.code = 0;
 546             last_function_type = ptr;
 547             res = ptr;
 548             break;
 549           }
 550         }
 551     }
 552   return res;
 553 }
 554
 555 static struct coff_visible *
 556 do_visible (int i)
 557 {
 558   struct internal_syment *sym = &rawsyms[i].u.syment;
 559   struct coff_visible *visible =
 560     (struct coff_visible *) (xmalloc (sizeof (struct coff_visible)));
 561   enum coff_vis_type t;
 562
 563   switch (sym->n_sclass)
 564     {
 565     case C_MOS:
 566     case C_MOU:
 567     case C_FIELD:
 568       t = coff_vis_member_of_struct;
 569       break;
 570     case C_MOE:
 571       t = coff_vis_member_of_enum;
 572       break;
 573     case C_REGPARM:
 574       t = coff_vis_regparam;
 575       break;
 576     case C_REG:
 577       t = coff_vis_register;
 578       break;
 579     case C_STRTAG:
 580     case C_UNTAG:
 581     case C_ENTAG:
 582     case C_TPDEF:
 583       t = coff_vis_tag;
 584       break;
 585     case C_AUTOARG:
 586     case C_ARG:
 587       t = coff_vis_autoparam;
 588       break;
 589     case C_AUTO:
 590       t = coff_vis_auto;
 591       break;
 592     case C_LABEL:
 593     case C_STAT:
 594       t = coff_vis_int_def;
 595       break;
 596     case C_EXT:
 597       if (sym->n_scnum == N_UNDEF)
 598         {
 599           if (sym->n_value)
 600             t = coff_vis_common;
 601           else
 602             t = coff_vis_ext_ref;
 603         }
 604       else
 605         t = coff_vis_ext_def;
 606       break;
 607     default:
 608       fatal (_("Unrecognised symbol class: %d"), sym->n_sclass);
 609       break;
 610     }
 611   visible->type = t;
 612   return visible;
 613 }
 614
 615 /* Define a symbol and attach to block B.  */
 616
 617 static int
 618 do_define (unsigned int i, struct coff_scope *b)
 619 {
 620   static int symbol_index;
 621   struct internal_syment *sym;
 622   struct coff_symbol *s = empty_symbol ();
 623
 624   if (b == NULL)
 625     fatal (_("ICE: do_define called without a block"));
 626   if (i >= rawcount)
 627     fatal (_("Out of range symbol index: %u"), i);
 628
 629   sym = &rawsyms[i].u.syment;
 630   s->number = ++symbol_index;
 631   s->name = N(sym);
 632   s->sfile = cur_sfile;
 633   /* Glue onto the ofile list.  */
 634   if (lofile >= 0)
 635     {
 636       if (ofile->symbol_list_tail)
 637         ofile->symbol_list_tail->next_in_ofile_list = s;
 638       else
 639         ofile->symbol_list_head = s;
 640       ofile->symbol_list_tail = s;
 641       /* And the block list.  */
 642     }
 643   if (b->vars_tail)
 644     b->vars_tail->next = s;
 645   else
 646     b->vars_head = s;
 647
 648   b->vars_tail = s;
 649   b->nvars++;
 650   s->type = do_type (i);
 651   s->where = do_where (i);
 652   s->visible = do_visible (i);
 653
 654   tindex[i] = s;
 655
 656   /* We remember the lowest address in each section for each source file.  */
 657   if (s->where->where == coff_where_memory
 658       && s->type->type == coff_secdef_type)
 659     {
 660       struct coff_isection *is;
 661
 662       /* PR 17512: file: 4676c97f.  */
 663       if (cur_sfile == NULL)
 664         non_fatal (_("Section referenced before any file is defined"));
 665       else
 666         {
 667           is = cur_sfile->section + s->where->section->number;
 668
 669           if (!is->init)
 670             {
 671               is->low = s->where->offset;
 672               is->high = s->where->offset + s->type->size;
 673               is->init = 1;
 674               is->parent = s->where->section;
 675             }
 676         }
 677     }
 678
 679   if (s->type->type == coff_function_type)
 680     last_function_symbol = s;
 681
 682   return i + sym->n_numaux + 1;
 683 }
 684
 685 static struct coff_ofile *
 686 doit (void)
 687 {
 688   unsigned int i;
 689   bfd_boolean infile = FALSE;
 690   struct coff_ofile *head =
 691     (struct coff_ofile *) xmalloc (sizeof (struct coff_ofile));
 692
 693   ofile = head;
 694   head->source_head = 0;
 695   head->source_tail = 0;
 696   head->nsources = 0;
 697   head->symbol_list_tail = 0;
 698   head->symbol_list_head = 0;
 699   do_sections_p1 (head);
 700   push_scope (1);
 701
 702   for (i = 0; i < rawcount;)
 703     {
 704       struct internal_syment *sym = &rawsyms[i].u.syment;
 705
 706       switch (sym->n_sclass)
 707         {
 708         case C_FILE:
 709           {
 710             /* New source file announced.  */
 711             struct coff_sfile *n =
 712               (struct coff_sfile *) xmalloc (sizeof (struct coff_sfile));
 713
 714             n->section = (struct coff_isection *) xcalloc (sizeof (struct coff_isection), abfd->section_count + 1);
 715             cur_sfile = n;
 716             n->name = N(sym);
 717             n->next = 0;
 718
 719             if (infile)
 720               pop_scope ();
 721             else
 722               infile = TRUE;
 723
 724             push_scope (1);
 725             file_scope = n->scope = top_scope;
 726
 727             if (head->source_tail)
 728               head->source_tail->next = n;
 729             else
 730               head->source_head = n;
 731             head->source_tail = n;
 732             head->nsources++;
 733             i += sym->n_numaux + 1;
 734           }
 735           break;
 736         case C_FCN:
 737           {
 738             char *name = N(sym);
 739
 740             if (name[1] == 'b')
 741               {
 742                 /* Function start.  */
 743                 push_scope (0);
 744                 /* PR 17512: file: 0ef7fbaf.  */
 745                 if (last_function_type)
 746                   last_function_type->u.function.code = top_scope;
 747                 /* PR 17512: file: 22908266.  */
 748                 if (sym->n_scnum < ofile->nsections && sym->n_scnum >= 0)
 749                   top_scope->sec = ofile->sections + sym->n_scnum;
 750                 else
 751                   top_scope->sec = NULL;
 752                 top_scope->offset = sym->n_value;
 753               }
 754             else
 755               {
 756                 /* PR 17512: file: e92e42e1.  */
 757                 if (top_scope == NULL)
 758                   fatal (_("Function start encountered without a top level scope."));
 759                 top_scope->size = sym->n_value - top_scope->offset + 1;
 760                 pop_scope ();
 761               }
 762             i += sym->n_numaux + 1;
 763           }
 764           break;
 765
 766         case C_BLOCK:
 767           {
 768             char *name = N(sym);
 769
 770             if (name[1] == 'b')
 771               {
 772                 /* Block start.  */
 773                 push_scope (1);
 774                 /* PR 17512: file: af7e8e83.  */
 775                 if (sym->n_scnum < ofile->nsections && sym->n_scnum >= 0)
 776                   top_scope->sec = ofile->sections + sym->n_scnum;
 777                 else
 778                   top_scope->sec = NULL;
 779                 top_scope->offset = sym->n_value;
 780               }
 781             else
 782               {
 783                 if (top_scope == NULL)
 784                   fatal (_("Block start encountered without a scope for it."));
 785                 top_scope->size = sym->n_value - top_scope->offset + 1;
 786                 pop_scope ();
 787               }
 788             i += sym->n_numaux + 1;
 789           }
 790           break;
 791         case C_REGPARM:
 792         case C_ARG:
 793           if (last_function_symbol == NULL)
 794             fatal (_("Function arguments encountered without a function definition"));
 795           i = do_define (i, last_function_symbol->type->u.function.parameters);
 796           break;
 797         case C_MOS:
 798         case C_MOU:
 799         case C_FIELD:
 800           /* PR 17512: file: 43ab21f4.  */
 801           if (last_struct == NULL)
 802             fatal (_("Structure element encountered without a structure definition"));
 803           i = do_define (i, last_struct->u.astructdef.elements);
 804           break;
 805         case C_MOE:
 806           if (last_enum == NULL)
 807             fatal (_("Enum element encountered without an enum definition"));
 808           i = do_define (i, last_enum->u.aenumdef.elements);
 809           break;
 810         case C_STRTAG:
 811         case C_ENTAG:
 812         case C_UNTAG:
 813           /* Various definition.  */
 814           if (top_scope == NULL)
 815             fatal (_("Aggregate defintion encountered without a scope"));
 816           i = do_define (i, top_scope);
 817           break;
 818         case C_EXT:
 819         case C_LABEL:
 820           if (file_scope == NULL)
 821             fatal (_("Label defintion encountered without a file scope"));
 822           i = do_define (i, file_scope);
 823           break;
 824         case C_STAT:
 825         case C_TPDEF:
 826         case C_AUTO:
 827         case C_REG:
 828           if (top_scope == NULL)
 829             fatal (_("Variable defintion encountered without a scope"));
 830           i = do_define (i, top_scope);
 831           break;
 832         case C_EOS:
 833           i += sym->n_numaux + 1;
 834           break;
 835         default:
 836           fatal (_("Unrecognised symbol class: %d"), sym->n_sclass);
 837         }
 838     }
 839   do_sections_p2 (head);
 840   return head;
 841 }
 842
 843 struct coff_ofile *
 844 coff_grok (bfd *inabfd)
 845 {
 846   long storage;
 847   struct coff_ofile *p;
 848   abfd = inabfd;
 849
 850   if (! bfd_family_coff (abfd))
 851     {
 852       non_fatal (_("%s: is not a COFF format file"), bfd_get_filename (abfd));
 853       return NULL;
 854     }
 855
 856   storage = bfd_get_symtab_upper_bound (abfd);
 857
 858   if (storage < 0)
 859     bfd_fatal (abfd->filename);
 860
 861   syms = (asymbol **) xmalloc (storage);
 862   symcount = bfd_canonicalize_symtab (abfd, syms);
 863   if (symcount < 0)
 864     bfd_fatal (abfd->filename);
 865   rawsyms = obj_raw_syments (abfd);
 866   rawcount = obj_raw_syment_count (abfd);
 867   tindex = (struct coff_symbol **) (xcalloc (sizeof (struct coff_symbol *), rawcount));
 868
 869   p = doit ();
 870   return p;
 871 }