1/* coffgrok.c 2 Copyright (C) 1994-2017 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 36static int lofile = 1; 37 38static struct coff_scope * top_scope; 39static struct coff_scope * file_scope; 40static struct coff_ofile * ofile; 41static struct coff_symbol * last_function_symbol; 42static struct coff_type * last_function_type; 43static struct coff_type * last_struct; 44static struct coff_type * last_enum; 45static struct coff_sfile * cur_sfile; 46static struct coff_symbol ** tindex; 47static asymbol ** syms; 48static long symcount; 49static struct coff_ptr_struct * rawsyms; 50static unsigned int rawcount; 51static 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 65static struct coff_scope * 66empty_scope (void) 67{ 68 return (struct coff_scope *) (xcalloc (sizeof (struct coff_scope), 1)); 69} 70 71static struct coff_symbol * 72empty_symbol (void) 73{ 74 return (struct coff_symbol *) (xcalloc (sizeof (struct coff_symbol), 1)); 75} 76 77static void 78push_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 102static void 103pop_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 111static void 112do_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 164static void 165do_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 207static struct coff_where * 208do_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 279static struct coff_line * 280do_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 340static struct coff_type * 341do_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; 432 433 /* PR 17512: file: e72f3988. */ 434 if (aux->x_sym.x_tagndx.l < 0 || aux->x_sym.x_tagndx.p < rawsyms) 435 { 436 non_fatal (_("Invalid tag index %#lx encountered"), aux->x_sym.x_tagndx.l); 437 idx = 0; 438 } 439 else 440 idx = INDEXOF (aux->x_sym.x_tagndx.p); 441 442 if (idx >= rawcount) 443 { 444 if (rawcount == 0) 445 fatal (_("Symbol index %u encountered when there are no symbols"), idx); 446 non_fatal (_("Invalid symbol index %u encountered"), idx); 447 idx = 0; 448 } 449 450 /* Referring to a struct defined elsewhere. */ 451 res->type = coff_structref_type; 452 res->u.astructref.ref = tindex[idx]; 453 res->size = res->u.astructref.ref ? 454 res->u.astructref.ref->type->size : 0; 455 } 456 else 457 { 458 /* A definition of a struct. */ 459 last_struct = res; 460 res->type = coff_structdef_type; 461 res->u.astructdef.elements = empty_scope (); 462 res->u.astructdef.idx = 0; 463 res->u.astructdef.isstruct = (type & 0xf) == T_STRUCT; 464 res->size = aux->x_sym.x_misc.x_lnsz.x_size; 465 } 466 } 467 else 468 { 469 /* No auxents - it's anonymous. */ 470 res->type = coff_structref_type; 471 res->u.astructref.ref = 0; 472 res->size = 0; 473 } 474 break; 475 case T_ENUM: 476 if (aux == NULL) 477 fatal (_("Enum definition needs auxillary information")); 478 if (aux->x_sym.x_tagndx.p) 479 { 480 unsigned int idx = INDEXOF (aux->x_sym.x_tagndx.p); 481 482 /* PR 17512: file: 1ef037c7. */ 483 if (idx >= rawcount) 484 fatal (_("Invalid enum symbol index %u encountered"), idx); 485 /* Referring to a enum defined elsewhere. */ 486 res->type = coff_enumref_type; 487 res->u.aenumref.ref = tindex[idx]; 488 /* PR 17512: file: b85b67e8. */ 489 if (res->u.aenumref.ref) 490 res->size = res->u.aenumref.ref->type->size; 491 else 492 res->size = 0; 493 } 494 else 495 { 496 /* A definition of an enum. */ 497 last_enum = res; 498 res->type = coff_enumdef_type; 499 res->u.aenumdef.elements = empty_scope (); 500 res->size = aux->x_sym.x_misc.x_lnsz.x_size; 501 } 502 break; 503 case T_MOE: 504 break; 505 } 506 507 for (which_dt = 5; which_dt >= 0; which_dt--) 508 { 509 switch ((type >> ((which_dt * 2) + 4)) & 0x3) 510 { 511 case 0: 512 break; 513 case DT_ARY: 514 { 515 struct coff_type *ptr = ((struct coff_type *) 516 xmalloc (sizeof (struct coff_type))); 517 int els; 518 519 if (aux == NULL) 520 fatal (_("Array definition needs auxillary information")); 521 els = (dimind < DIMNUM 522 ? aux->x_sym.x_fcnary.x_ary.x_dimen[dimind] 523 : 0); 524 525 ++dimind; 526 ptr->type = coff_array_type; 527 /* PR 17512: file: ae1971e2. 528 Check for integer overflow. */ 529 { 530 long long a, z; 531 a = els; 532 z = res->size; 533 a *= z; 534 ptr->size = (int) a; 535 if (ptr->size != a) 536 non_fatal (_("Out of range sum for els (%#x) * size (%#x)"), els, res->size); 537 } 538 ptr->u.array.dim = els; 539 ptr->u.array.array_of = res; 540 res = ptr; 541 break; 542 } 543 case DT_PTR: 544 { 545 struct coff_type *ptr = 546 (struct coff_type *) xmalloc (sizeof (struct coff_type)); 547 548 ptr->size = PTR_SIZE; 549 ptr->type = coff_pointer_type; 550 ptr->u.pointer.points_to = res; 551 res = ptr; 552 break; 553 } 554 case DT_FCN: 555 { 556 struct coff_type *ptr 557 = (struct coff_type *) xmalloc (sizeof (struct coff_type)); 558 559 ptr->size = 0; 560 ptr->type = coff_function_type; 561 ptr->u.function.function_returns = res; 562 ptr->u.function.parameters = empty_scope (); 563 ptr->u.function.lines = do_lines (i, N(sym)); 564 ptr->u.function.code = 0; 565 last_function_type = ptr; 566 res = ptr; 567 break; 568 } 569 } 570 } 571 return res; 572} 573 574static struct coff_visible * 575do_visible (int i) 576{ 577 struct internal_syment *sym = &rawsyms[i].u.syment; 578 struct coff_visible *visible = 579 (struct coff_visible *) (xmalloc (sizeof (struct coff_visible))); 580 enum coff_vis_type t; 581 582 switch (sym->n_sclass) 583 { 584 case C_MOS: 585 case C_MOU: 586 case C_FIELD: 587 t = coff_vis_member_of_struct; 588 break; 589 case C_MOE: 590 t = coff_vis_member_of_enum; 591 break; 592 case C_REGPARM: 593 t = coff_vis_regparam; 594 break; 595 case C_REG: 596 t = coff_vis_register; 597 break; 598 case C_STRTAG: 599 case C_UNTAG: 600 case C_ENTAG: 601 case C_TPDEF: 602 t = coff_vis_tag; 603 break; 604 case C_AUTOARG: 605 case C_ARG: 606 t = coff_vis_autoparam; 607 break; 608 case C_AUTO: 609 t = coff_vis_auto; 610 break; 611 case C_LABEL: 612 case C_STAT: 613 t = coff_vis_int_def; 614 break; 615 case C_EXT: 616 if (sym->n_scnum == N_UNDEF) 617 { 618 if (sym->n_value) 619 t = coff_vis_common; 620 else 621 t = coff_vis_ext_ref; 622 } 623 else 624 t = coff_vis_ext_def; 625 break; 626 default: 627 fatal (_("Unrecognised symbol class: %d"), sym->n_sclass); 628 break; 629 } 630 visible->type = t; 631 return visible; 632} 633 634/* Define a symbol and attach to block B. */ 635 636static int 637do_define (unsigned int i, struct coff_scope *b) 638{ 639 static int symbol_index; 640 struct internal_syment *sym; 641 struct coff_symbol *s = empty_symbol (); 642 643 if (b == NULL) 644 fatal (_("ICE: do_define called without a block")); 645 if (i >= rawcount) 646 fatal (_("Out of range symbol index: %u"), i); 647 648 sym = &rawsyms[i].u.syment; 649 s->number = ++symbol_index; 650 s->name = N(sym); 651 s->sfile = cur_sfile; 652 /* Glue onto the ofile list. */ 653 if (lofile >= 0) 654 { 655 if (ofile->symbol_list_tail) 656 ofile->symbol_list_tail->next_in_ofile_list = s; 657 else 658 ofile->symbol_list_head = s; 659 ofile->symbol_list_tail = s; 660 /* And the block list. */ 661 } 662 if (b->vars_tail) 663 b->vars_tail->next = s; 664 else 665 b->vars_head = s; 666 667 b->vars_tail = s; 668 b->nvars++; 669 s->type = do_type (i); 670 s->where = do_where (i); 671 s->visible = do_visible (i); 672 673 tindex[i] = s; 674 675 /* We remember the lowest address in each section for each source file. */ 676 if (s->where->where == coff_where_memory 677 && s->type->type == coff_secdef_type) 678 { 679 struct coff_isection *is; 680 681 /* PR 17512: file: 4676c97f. */ 682 if (cur_sfile == NULL) 683 non_fatal (_("Section referenced before any file is defined")); 684 else 685 { 686 is = cur_sfile->section + s->where->section->number; 687 688 if (!is->init) 689 { 690 is->low = s->where->offset; 691 /* PR 17512: file: 37e7a80d. 692 Check for integer overflow computing low + size. */ 693 { 694 long long a, z; 695 696 a = s->where->offset; 697 z = s->type->size; 698 a += z; 699 is->high = (int) a; 700 if (a != is->high) 701 non_fatal (_("Out of range sum for offset (%#x) + size (%#x)"), 702 is->low, s->type->size); 703 } 704 /* PR 17512: file: 37e7a80d. */ 705 if (is->high < s->where->offset) 706 fatal (_("Out of range type size: %u"), s->type->size); 707 is->init = 1; 708 is->parent = s->where->section; 709 } 710 } 711 } 712 713 if (s->type->type == coff_function_type) 714 last_function_symbol = s; 715 716 return i + sym->n_numaux + 1; 717} 718 719static struct coff_ofile * 720doit (void) 721{ 722 unsigned int i; 723 bfd_boolean infile = FALSE; 724 struct coff_ofile *head = 725 (struct coff_ofile *) xmalloc (sizeof (struct coff_ofile)); 726 727 ofile = head; 728 head->source_head = 0; 729 head->source_tail = 0; 730 head->nsources = 0; 731 head->symbol_list_tail = 0; 732 head->symbol_list_head = 0; 733 do_sections_p1 (head); 734 push_scope (1); 735 736 for (i = 0; i < rawcount;) 737 { 738 struct internal_syment *sym = &rawsyms[i].u.syment; 739 740 switch (sym->n_sclass) 741 { 742 case C_FILE: 743 { 744 /* New source file announced. */ 745 struct coff_sfile *n = 746 (struct coff_sfile *) xmalloc (sizeof (struct coff_sfile)); 747 748 n->section = (struct coff_isection *) xcalloc (sizeof (struct coff_isection), abfd->section_count + 1); 749 cur_sfile = n; 750 n->name = N(sym); 751 n->next = 0; 752 753 if (infile) 754 pop_scope (); 755 else 756 infile = TRUE; 757 758 push_scope (1); 759 file_scope = n->scope = top_scope; 760 761 if (head->source_tail) 762 head->source_tail->next = n; 763 else 764 head->source_head = n; 765 head->source_tail = n; 766 head->nsources++; 767 i += sym->n_numaux + 1; 768 } 769 break; 770 case C_FCN: 771 { 772 char *name = N(sym); 773 774 if (name[1] == 'b') 775 { 776 /* Function start. */ 777 push_scope (0); 778 /* PR 17512: file: 0ef7fbaf. */ 779 if (last_function_type) 780 last_function_type->u.function.code = top_scope; 781 /* PR 17512: file: 22908266. */ 782 if (sym->n_scnum < ofile->nsections && sym->n_scnum >= 0) 783 top_scope->sec = ofile->sections + sym->n_scnum; 784 else 785 top_scope->sec = NULL; 786 top_scope->offset = sym->n_value; 787 } 788 else 789 { 790 /* PR 17512: file: e92e42e1. */ 791 if (top_scope == NULL) 792 fatal (_("Function start encountered without a top level scope.")); 793 top_scope->size = sym->n_value - top_scope->offset + 1; 794 pop_scope (); 795 } 796 i += sym->n_numaux + 1; 797 } 798 break; 799 800 case C_BLOCK: 801 { 802 char *name = N(sym); 803 804 if (name[1] == 'b') 805 { 806 /* Block start. */ 807 push_scope (1); 808 /* PR 17512: file: af7e8e83. */ 809 if (sym->n_scnum < ofile->nsections && sym->n_scnum >= 0) 810 top_scope->sec = ofile->sections + sym->n_scnum; 811 else 812 top_scope->sec = NULL; 813 top_scope->offset = sym->n_value; 814 } 815 else 816 { 817 if (top_scope == NULL) 818 fatal (_("Block start encountered without a scope for it.")); 819 top_scope->size = sym->n_value - top_scope->offset + 1; 820 pop_scope (); 821 } 822 i += sym->n_numaux + 1; 823 } 824 break; 825 case C_REGPARM: 826 case C_ARG: 827 if (last_function_symbol == NULL) 828 fatal (_("Function arguments encountered without a function definition")); 829 i = do_define (i, last_function_symbol->type->u.function.parameters); 830 break; 831 case C_MOS: 832 case C_MOU: 833 case C_FIELD: 834 /* PR 17512: file: 43ab21f4. */ 835 if (last_struct == NULL) 836 fatal (_("Structure element encountered without a structure definition")); 837 i = do_define (i, last_struct->u.astructdef.elements); 838 break; 839 case C_MOE: 840 if (last_enum == NULL) 841 fatal (_("Enum element encountered without an enum definition")); 842 i = do_define (i, last_enum->u.aenumdef.elements); 843 break; 844 case C_STRTAG: 845 case C_ENTAG: 846 case C_UNTAG: 847 /* Various definition. */ 848 if (top_scope == NULL) 849 fatal (_("Aggregate defintion encountered without a scope")); 850 i = do_define (i, top_scope); 851 break; 852 case C_EXT: 853 case C_LABEL: 854 if (file_scope == NULL) 855 fatal (_("Label defintion encountered without a file scope")); 856 i = do_define (i, file_scope); 857 break; 858 case C_STAT: 859 case C_TPDEF: 860 case C_AUTO: 861 case C_REG: 862 if (top_scope == NULL) 863 fatal (_("Variable defintion encountered without a scope")); 864 i = do_define (i, top_scope); 865 break; 866 case C_EOS: 867 i += sym->n_numaux + 1; 868 break; 869 default: 870 fatal (_("Unrecognised symbol class: %d"), sym->n_sclass); 871 } 872 } 873 do_sections_p2 (head); 874 return head; 875} 876 877struct coff_ofile * 878coff_grok (bfd *inabfd) 879{ 880 long storage; 881 struct coff_ofile *p; 882 abfd = inabfd; 883 884 if (! bfd_family_coff (abfd)) 885 { 886 non_fatal (_("%s: is not a COFF format file"), bfd_get_filename (abfd)); 887 return NULL; 888 } 889 890 storage = bfd_get_symtab_upper_bound (abfd); 891 892 if (storage < 0) 893 bfd_fatal (abfd->filename); 894 895 syms = (asymbol **) xmalloc (storage); 896 symcount = bfd_canonicalize_symtab (abfd, syms); 897 if (symcount < 0) 898 bfd_fatal (abfd->filename); 899 rawsyms = obj_raw_syments (abfd); 900 rawcount = obj_raw_syment_count (abfd); 901 tindex = (struct coff_symbol **) (xcalloc (sizeof (struct coff_symbol *), rawcount)); 902 903 p = doit (); 904 return p; 905} 906