2 Copyright (C) 1994-2015 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
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.
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.
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. */
22 /* Written by Steve Chamberlain (sac@cygnus.com)
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. */
30 #include "libiberty.h"
31 #include "coff/internal.h"
32 #include "../bfd/libcoff.h"
36 static int lofile = 1;
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;
49 static struct coff_ptr_struct * rawsyms;
50 static unsigned int rawcount;
53 #define N(x) ((x)->_n._n_nptr[1])
62 #define INDEXOF(p) ((struct coff_ptr_struct *)(p)-(rawsyms))
65 static struct coff_scope *
68 return (struct coff_scope *) (xcalloc (sizeof (struct coff_scope), 1));
71 static struct coff_symbol *
74 return (struct coff_symbol *) (xcalloc (sizeof (struct coff_symbol), 1));
78 push_scope (int slink)
80 struct coff_scope *n = empty_scope ();
86 if (top_scope->list_tail)
88 top_scope->list_tail->next = n;
92 top_scope->list_head = n;
94 top_scope->list_tail = n;
97 n->parent = top_scope;
105 /* PR 17512: file: 809933ac. */
106 if (top_scope == NULL)
107 fatal (_("Out of context scope change encountered"));
108 top_scope = top_scope->parent;
112 do_sections_p1 (struct coff_ofile *head)
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;
121 for (idx = 0, section = abfd->sections; section; section = section->next, idx++)
124 unsigned int i = section->target_index;
128 /* PR 17512: file: 2d6effca. */
129 if (i > abfd->section_count)
130 fatal (_("Invalid section target index: %u"), i);
132 relsize = bfd_get_reloc_upper_bound (abfd, section);
134 bfd_fatal (bfd_get_filename (abfd));
137 relpp = (arelent **) xmalloc (relsize);
138 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
140 bfd_fatal (bfd_get_filename (abfd));
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;
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;
165 do_sections_p2 (struct coff_ofile *head)
169 for (section = abfd->sections; section; section = section->next)
173 /* PR 17512: file: 7c1a36e8.
174 A corrupt COFF binary might have a reloc count but no relocs.
176 if (section->relocation == NULL)
179 for (j = 0; j < section->reloc_count; j++)
182 int i = section->target_index;
183 struct coff_reloc *r;
184 arelent *sr = section->relocation + j;
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;
198 fatal (_("Symbol index %u encountered when there are no symbols"), idx);
199 non_fatal (_("Invalid symbol index %u encountered"), idx);
202 r->symbol = tindex[idx];
207 static struct coff_where *
208 do_where (unsigned int i)
210 struct internal_syment *sym;
211 struct coff_where *where =
212 (struct coff_where *) (xmalloc (sizeof (struct coff_where)));
215 fatal ("Invalid symbol index: %d\n", i);
217 sym = &rawsyms[i].u.syment;
218 where->offset = sym->n_value;
220 if (sym->n_scnum == -1)
223 switch (sym->n_sclass)
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;
232 where->where = coff_where_member_of_enum;
236 where->where = coff_where_member_of_struct;
240 where->where = coff_where_stack;
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)
251 non_fatal (_("Invalid section number (%d) encountered"),
253 where->section = ofile->sections;
256 where->section = &ofile->sections[sym->n_scnum];
260 where->where = coff_where_register;
263 where->where = coff_where_entag;
267 where->where = coff_where_strtag;
270 where->where = coff_where_typedef;
273 fatal (_("Unrecognized symbol class: %d"), sym->n_sclass);
279 static struct coff_line *
280 do_lines (int i, char *name ATTRIBUTE_UNUSED)
282 struct coff_line *res = (struct coff_line *) xcalloc (sizeof (struct coff_line), 1);
286 /* Find out if this function has any line numbers in the table. */
287 for (s = abfd->sections; s; s = s->next)
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)
296 for (l = 0; l < s->lineno_count; l++)
298 if (s->lineno[l].line_number == 0)
300 if (rawsyms + i == ((coff_symbol_type *) (&(s->lineno[l].u.sym[0])))->native)
302 /* These lines are for this function - so count them and stick them on. */
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;
310 /* PR 17512: file: c2825452. */
311 l + c + 1 < s->lineno_count
312 && s->lineno[l + c + 1].line_number;
316 /* Add two extra records, one for the prologue and one for the epilogue. */
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;
324 /* PR 17512: file: c2825452. */
325 l + c + 1 < s->lineno_count
326 && s->lineno[l + c + 1].line_number;
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;
340 static struct coff_type *
341 do_type (unsigned int i)
343 struct internal_syment *sym;
344 union internal_auxent *aux;
345 struct coff_type *res = (struct coff_type *) xmalloc (sizeof (struct coff_type));
351 fatal (_("Type entry %u does not have enough symbolic information"), i);
353 if (!rawsyms[i].is_sym)
354 fatal (_("Type entry %u does not refer to a symbol"), i);
355 sym = &rawsyms[i].u.syment;
357 if (sym->n_numaux == 0 || i >= rawcount -1 || rawsyms[i + 1].is_sym)
360 aux = &rawsyms[i + 1].u.auxent;
364 res->type = coff_basic_type;
365 res->u.basic = type & 0xf;
371 if (sym->n_numaux && sym->n_sclass == C_STAT)
373 /* This is probably a section definition. */
374 res->type = coff_secdef_type;
376 fatal (_("Section definition needs a section length"));
377 res->size = aux->x_scn.x_scnlen;
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;
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;
394 /* Else it could be a function or pointer to void. */
406 res->size = SHORT_SIZE;
410 res->size = INT_SIZE;
414 res->size = LONG_SIZE;
417 res->size = FLOAT_SIZE;
420 res->size = DOUBLE_SIZE;
427 fatal (_("Aggregate definition needs auxillary information"));
429 if (aux->x_sym.x_tagndx.p)
431 unsigned int idx = INDEXOF (aux->x_sym.x_tagndx.p);
436 fatal (_("Symbol index %u encountered when there are no symbols"), idx);
437 non_fatal (_("Invalid symbol index %u encountered"), idx);
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;
449 /* A definition of a struct. */
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;
460 /* No auxents - it's anonymous. */
461 res->type = coff_structref_type;
462 res->u.astructref.ref = 0;
468 fatal (_("Enum definition needs auxillary information"));
469 if (aux->x_sym.x_tagndx.p)
471 unsigned int idx = INDEXOF (aux->x_sym.x_tagndx.p);
473 /* PR 17512: file: 1ef037c7. */
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;
483 /* A definition of an enum. */
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;
494 for (which_dt = 5; which_dt >= 0; which_dt--)
496 switch ((type >> ((which_dt * 2) + 4)) & 0x3)
502 struct coff_type *ptr = ((struct coff_type *)
503 xmalloc (sizeof (struct coff_type)));
507 fatal (_("Array definition needs auxillary information"));
508 els = (dimind < DIMNUM
509 ? aux->x_sym.x_fcnary.x_ary.x_dimen[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;
522 struct coff_type *ptr =
523 (struct coff_type *) xmalloc (sizeof (struct coff_type));
525 ptr->size = PTR_SIZE;
526 ptr->type = coff_pointer_type;
527 ptr->u.pointer.points_to = res;
533 struct coff_type *ptr
534 = (struct coff_type *) xmalloc (sizeof (struct coff_type));
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;
551 static struct coff_visible *
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;
559 switch (sym->n_sclass)
564 t = coff_vis_member_of_struct;
567 t = coff_vis_member_of_enum;
570 t = coff_vis_regparam;
573 t = coff_vis_register;
583 t = coff_vis_autoparam;
590 t = coff_vis_int_def;
593 if (sym->n_scnum == N_UNDEF)
598 t = coff_vis_ext_ref;
601 t = coff_vis_ext_def;
604 fatal (_("Unrecognised symbol class: %d"), sym->n_sclass);
611 /* Define a symbol and attach to block B. */
614 do_define (unsigned int i, struct coff_scope *b)
616 static int symbol_index;
617 struct internal_syment *sym;
618 struct coff_symbol *s = empty_symbol ();
621 fatal (_("ICE: do_define called without a block"));
623 fatal (_("Out of range symbol index: %u"), i);
625 sym = &rawsyms[i].u.syment;
626 s->number = ++symbol_index;
628 s->sfile = cur_sfile;
629 /* Glue onto the ofile list. */
632 if (ofile->symbol_list_tail)
633 ofile->symbol_list_tail->next_in_ofile_list = s;
635 ofile->symbol_list_head = s;
636 ofile->symbol_list_tail = s;
637 /* And the block list. */
640 b->vars_tail->next = s;
646 s->type = do_type (i);
647 s->where = do_where (i);
648 s->visible = do_visible (i);
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)
656 struct coff_isection *is;
658 /* PR 17512: file: 4676c97f. */
659 if (cur_sfile == NULL)
660 non_fatal (_("Section referenced before any file is defined"));
663 is = cur_sfile->section + s->where->section->number;
667 is->low = s->where->offset;
668 is->high = s->where->offset + s->type->size;
670 is->parent = s->where->section;
675 if (s->type->type == coff_function_type)
676 last_function_symbol = s;
678 return i + sym->n_numaux + 1;
681 static struct coff_ofile *
685 bfd_boolean infile = FALSE;
686 struct coff_ofile *head =
687 (struct coff_ofile *) xmalloc (sizeof (struct coff_ofile));
690 head->source_head = 0;
691 head->source_tail = 0;
693 head->symbol_list_tail = 0;
694 head->symbol_list_head = 0;
695 do_sections_p1 (head);
698 for (i = 0; i < rawcount;)
700 struct internal_syment *sym = &rawsyms[i].u.syment;
702 switch (sym->n_sclass)
706 /* New source file announced. */
707 struct coff_sfile *n =
708 (struct coff_sfile *) xmalloc (sizeof (struct coff_sfile));
710 n->section = (struct coff_isection *) xcalloc (sizeof (struct coff_isection), abfd->section_count + 1);
721 file_scope = n->scope = top_scope;
723 if (head->source_tail)
724 head->source_tail->next = n;
726 head->source_head = n;
727 head->source_tail = n;
729 i += sym->n_numaux + 1;
738 /* Function start. */
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;
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;
755 i += sym->n_numaux + 1;
767 top_scope->sec = ofile->sections + sym->n_scnum;
768 top_scope->offset = sym->n_value;
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;
777 i += sym->n_numaux + 1;
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);
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);
795 if (last_enum == NULL)
796 fatal (_("Enum element encountered without an enum definition"));
797 i = do_define (i, last_enum->u.aenumdef.elements);
802 /* Various definition. */
803 if (top_scope == NULL)
804 fatal (_("Aggregate defintion encountered without a scope"));
805 i = do_define (i, top_scope);
809 if (file_scope == NULL)
810 fatal (_("Label defintion encountered without a file scope"));
811 i = do_define (i, file_scope);
817 if (top_scope == NULL)
818 fatal (_("Variable defintion encountered without a scope"));
819 i = do_define (i, top_scope);
822 i += sym->n_numaux + 1;
825 fatal (_("Unrecognised symbol class: %d"), sym->n_sclass);
828 do_sections_p2 (head);
833 coff_grok (bfd *inabfd)
836 struct coff_ofile *p;
839 if (! bfd_family_coff (abfd))
841 non_fatal (_("%s: is not a COFF format file"), bfd_get_filename (abfd));
845 storage = bfd_get_symtab_upper_bound (abfd);
848 bfd_fatal (abfd->filename);
850 syms = (asymbol **) xmalloc (storage);
851 symcount = bfd_canonicalize_symtab (abfd, syms);
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));