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