diff options
Diffstat (limited to 'bfd/coff-code.h')
| -rwxr-xr-x | bfd/coff-code.h | 2561 |
1 files changed, 2561 insertions, 0 deletions
diff --git a/bfd/coff-code.h b/bfd/coff-code.h new file mode 100755 index 0000000..8ec6ec2 --- /dev/null +++ b/bfd/coff-code.h @@ -0,0 +1,2561 @@ +/* + Copyright (C) 1990, 1991 Free Software Foundation, Inc. + +This file is part of BFD, the Binary File Diddler. + +BFD is free software; you can redistribute it and/or modify it under the + terms of the GNU General Public License as published by the Free Software + Foundation; either version 1, or (at your option) any later version. + +BFD is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + details. + +You should have received a copy of the GNU General Public License along with + BFD; see the file COPYING. If not, write to the Free Software Foundation, + 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +/* $Id$ */ +/* + FIXME-SOON. There is a major, potentially invalid assumption in this + code. Namely, that incoming symbol tables will be broken up and glued back + together but only on C_FILE boundaries. That is, if you break the symbol + table on some other boundary, or if you remove a single symbol in the + middle, it is possible to end up with garbage where you expect your + debugging info to be. This only affects debugging info. Specifically, it + affects all of the foondx's in the aux entries. C_FILE entries ARE glued + back together properly. Line numbers and relocations are tracked with + pointers so their ndx's aren't affected. + +On the other hand, if the symbol that a line number or reloc points to goes + away, or isn't included in an output bfd, then you'll end up with mush + anyway. + +I'm not sure at this point, (Sun Mar 3 00:56:11 PST 1991), but I suspect the + bfd library will need to provide at least the option of a higher and/or + lower abstraction for (at least debugging) symbols. The current + abstraction is sufficient for linking, nm, and very nearly for stripping, + but is nowhere near what would be needed for gas to create coff symbols or + for gdb to read them. + +xoxorich. +*/ + +#include "archures.h" /* Machine architectures and types */ + +/* SUPPRESS 558 */ +/* SUPPRESS 590 */ +/* SUPPRESS 529 */ +/* SUPPRESS 530 */ + +#define ALIGN(this, boundary) \ + ((( (this) + ((boundary) -1)) & (~((boundary)-1)))) + +#define sp(x) bfd_h_put_x(abfd, x, &x) + + + +/* + Align an address by rounding it up to a power of two. It leaves the + address unchanged if align == 0 (2^0 = alignment of 1 byte) +*/ +#define i960_align(addr, align) \ + ( ((addr) + ((1<<(align))-1)) & (-1 << (align))) + + +/* All the swapping routines */ + +static void +swap_reloc(abfd, reloc) + bfd *abfd; + RELOC *reloc; +{ + sp(reloc->r_vaddr); + sp(reloc->r_symndx); + sp(reloc->r_type); +} + + +static void +swap_filehdr(abfd, filehdr) + bfd *abfd; + FILHDR *filehdr; +{ + sp(filehdr->f_magic); + sp(filehdr->f_nscns); + sp(filehdr->f_timdat); + sp(filehdr->f_symptr); + sp(filehdr->f_nsyms); + sp(filehdr->f_opthdr); + sp(filehdr->f_flags); + + +} + +static void +swap_aouthdr(abfd, aouthdr) + bfd *abfd; + AOUTHDR *aouthdr; +{ + + sp(aouthdr->magic); + sp(aouthdr->vstamp); + sp(aouthdr->tsize); + sp(aouthdr->dsize); + sp(aouthdr->bsize); + sp(aouthdr->entry); + sp(aouthdr->text_start); + sp(aouthdr->data_start); +#ifdef I960 + sp(aouthdr->tagentries); +#endif +} + +static void +swap_scnhdr(abfd, scnhdr) + bfd *abfd; + SCNHDR *scnhdr; +{ + sp(scnhdr->s_vaddr); + sp(scnhdr->s_paddr); + sp(scnhdr->s_size); + sp(scnhdr->s_scnptr); + sp(scnhdr->s_relptr); + sp(scnhdr->s_lnnoptr); + sp(scnhdr->s_nreloc); + sp(scnhdr->s_nlnno); + sp(scnhdr->s_flags); +#ifdef I960 + sp(scnhdr->s_align); +#endif +} + +static void +swap_name(abfd, ptr) + bfd *abfd; + long *ptr; +{ + if (ptr[0] == 0) { + /* There is an index which needs to be swapped */ + bfd_h_put_x(abfd, ptr[1], (ptr + 1)); + } + else { + /* This is a string .. leave it alone */ + } +} + +void +bfd_coff_swap_sym(abfd, se) + bfd *abfd; + SYMENT *se; +{ + swap_name(abfd, se->n_name); + bfd_h_put_x(abfd, se->n_value, &se->n_value); + bfd_h_put_x(abfd, se->n_scnum, &se->n_scnum); + bfd_h_put_x(abfd, se->n_type, &se->n_type); + bfd_h_put_x(abfd, se->n_sclass, &se->n_sclass); + bfd_h_put_x(abfd, se->n_numaux, &se->n_numaux); +} + +void +bfd_coff_swap_aux(abfd, au, type, class) + bfd *abfd; + AUXENT *au; + int type; + int class; +{ + switch (class) { + case C_FILE: + swap_name(abfd, &au->x_file.x_n); + break; + case C_STAT: +#ifdef C_LEAFSTAT + case C_LEAFSTAT: +#endif + case C_HIDDEN: + if (type == T_NULL) { + sp(au->x_scn.x_scnlen); + sp(au->x_scn.x_nreloc); + sp(au->x_scn.x_nlinno); + break; + } + default: + sp(au->x_sym.x_tagndx); + sp(au->x_sym.x_tvndx); + + if (ISARY(type) || class == C_BLOCK) { + sp(au->x_sym.x_fcnary.x_ary.x_dimen[0]); + sp(au->x_sym.x_fcnary.x_ary.x_dimen[1]); + sp(au->x_sym.x_fcnary.x_ary.x_dimen[2]); + sp(au->x_sym.x_fcnary.x_ary.x_dimen[3]); + } + else { + sp(au->x_sym.x_fcnary.x_fcn.x_lnnoptr); + sp(au->x_sym.x_fcnary.x_fcn.x_endndx); + } + if (ISFCN(type)) { + sp(au->x_sym.x_misc.x_fsize); + } + else { + sp(au->x_sym.x_misc.x_lnsz.x_lnno); + sp(au->x_sym.x_misc.x_lnsz.x_size); + } + } +} + +void +bfd_coff_swap_lineno(abfd, lineno) + bfd *abfd; + LINENO *lineno; +{ + sp(lineno->l_addr.l_symndx); + sp(lineno->l_lnno); +} + + +/* void warning(); */ +extern asection abs_section; + + + +static int +get_index(symbol) + asymbol *symbol; +{ + return (int) symbol->value; +} + +static void +set_index(symbol, idx) + asymbol *symbol; + unsigned int idx; +{ + symbol->value = idx; +} + + +/* + initialize a section structure with information peculiar to this + particular implementation of coff +*/ + +static boolean +coff_new_section_hook(abfd_ignore, section_ignore) + bfd *abfd_ignore; + asection *section_ignore; +{ + return true; +} +/* actually it makes itself and its children from the file headers */ +static boolean +make_a_section_from_file(abfd, hdr) + bfd *abfd; + struct scnhdr *hdr; + +{ + asection *return_section; + { + char *name = malloc(9); + if (name == NULL) { + bfd_error = no_memory; + return (BFD_FAILURE); + } /* on error */ + strncpy(name, (char *) &hdr->s_name[0], 8); + + return_section = bfd_make_section(abfd, name); + (return_section->name)[8] = 0; + } + + /* s_paddr is presumed to be = to s_vaddr */ +#define assign(to, from) return_section->to = hdr->from + assign(vma, s_vaddr); + /* assign (vma, s_vaddr); */ + assign(size, s_size); + assign(filepos, s_scnptr); + assign(rel_filepos, s_relptr); + assign(reloc_count, s_nreloc); +#ifdef I960 + { + + assign(alignment_power, s_align); + { + unsigned int i; + for (i = 0; i < 32; i++) { + if ((1 << i) >= (int) (return_section->alignment_power)) { + return_section->alignment_power = i; + break; + } + } + } + } +#endif + assign(line_filepos, s_lnnoptr); + /* + return_section->linesize = hdr->s_nlnno * sizeof (struct lineno); + */ + +#undef assign + return_section->lineno_count = hdr->s_nlnno; + return_section->userdata = NULL; + return_section->next = (asection *) NULL; + if ((hdr->s_flags & STYP_TEXT) || (hdr->s_flags & STYP_DATA)) + return_section->flags = (SEC_LOAD | SEC_ALLOC); + else if (hdr->s_flags & STYP_BSS) + return_section->flags = SEC_ALLOC; + + if (hdr->s_nreloc != 0) + return_section->flags |= SEC_RELOC; + if (hdr->s_scnptr != 0) + return_section->flags |= SEC_HAS_CONTENTS; + return true; +} + + +static +bfd_target * +coff_real_object_p(abfd, nscns, opthdr) + bfd *abfd; + unsigned nscns, + opthdr; +{ + struct icofdata *tdata; + char *file_info; /* buffer for all the headers */ + size_t readsize; /* length of file_info */ + struct filehdr *filehdr; /* points into file_info */ + struct scnhdr *sections; /* points into file_info */ + /* + OK, now we know the format, read in the filehdr, soi-disant "optional + header", and all the sections. + */ + readsize = sizeof(struct filehdr) + + opthdr + + (nscns * sizeof(struct scnhdr)); + + file_info = malloc(readsize); + if (file_info == NULL) { + bfd_error = no_memory; + return 0; + } + if (bfd_seek(abfd, 0L, SEEK_SET) < 0) + return 0; + if (bfd_read((void *) file_info, 1, readsize, abfd) != readsize) + return 0; + filehdr = (struct filehdr *) file_info; + sections = (struct scnhdr *) (file_info + sizeof(struct filehdr) + opthdr); + + + swap_filehdr(abfd, filehdr); + + /* Now copy data as required; construct all asections etc */ + tdata = (struct icofdata *) malloc(sizeof(struct icofdata) + + sizeof(AOUTHDR)); + if (tdata == NULL) { + bfd_error = no_memory; + return 0; + } + tdata->symbol_index_slew = 0; + tdata->relocbase =0; + tdata->raw_syment_count = 0; + tdata->raw_linenos = 0; + tdata->raw_syments = 0; + tdata->sym_filepos =0; + + if (nscns != 0) { + unsigned int i; + for (i = 0; i < nscns; i++) { + swap_scnhdr(abfd, sections + i); + make_a_section_from_file(abfd, sections + i); + } + } + /* Determine the machine architecture and type. */ + abfd->obj_machine = 0; + switch (filehdr->f_magic) { +#ifdef MC68MAGIC + case MC68MAGIC: + case MC68DMAGIC: + abfd->obj_arch = bfd_arch_m68k; + abfd->obj_machine = 68020; + break; +#endif +#ifdef I960ROMAGIC + case I960ROMAGIC: + case I960RWMAGIC: + abfd->obj_arch = bfd_arch_i960; + switch (F_I960TYPE & filehdr->f_flags) { + case F_I960CORE: + abfd->obj_machine = bfd_mach_i960_core; + break; + case F_I960KB: + abfd->obj_machine = bfd_mach_i960_kb_sb; + break; + case F_I960MC: + abfd->obj_machine = bfd_mach_i960_mc; + break; + case F_I960XA: + abfd->obj_machine = bfd_mach_i960_xa; + break; + case F_I960CA: + abfd->obj_machine = bfd_mach_i960_ca; + break; + case F_I960KA: + abfd->obj_machine = bfd_mach_i960_ka_sa; + break; + /* + Doomed to fail but sneak out a bit of info in the process. + */ + default: + abfd->obj_machine = filehdr->f_flags & F_I960TYPE; + } + break; +#endif + + default: /* Unreadable input file type */ + abfd->obj_arch = bfd_arch_obscure; + break; + } + + if (!(filehdr->f_flags & F_RELFLG)) + abfd->flags |= HAS_RELOC; + if ((filehdr->f_flags & F_EXEC)) + abfd->flags |= EXEC_P; + if (!(filehdr->f_flags & F_LNNO)) + abfd->flags |= HAS_LINENO; + if (!(filehdr->f_flags & F_LSYMS)) + abfd->flags |= HAS_LOCALS; + + abfd->tdata = (void *) tdata; + bfd_get_symcount(abfd) = filehdr->f_nsyms; + if (filehdr->f_nsyms) + abfd->flags |= HAS_SYMS; + + tdata->sym_filepos = filehdr->f_symptr; + tdata->hdr = (struct aouthdr *) (file_info + sizeof(struct filehdr)); + + swap_aouthdr(abfd, tdata->hdr); + + tdata->symbols = (coff_symbol_type *) NULL; + bfd_get_start_address(abfd) = opthdr ? exec_hdr(abfd)->entry : 0; + + return abfd->xvec; +} +static coff_symbol_type * +coff_symbol_from(abfd, symbol) + bfd *abfd; + asymbol *symbol; +{ + return symbol->the_bfd->xvec->flavour == bfd_target_coff_flavour_enum + ? + (coff_symbol_type *) symbol + : + (coff_symbol_type *) NULL; + +} + + + +static bfd_target * +coff_object_p(abfd) + bfd *abfd; +{ + unsigned short magic, + nscns, + opthdr; + bfd_error = system_call_error; + + /* figure out how much to read */ + if (bfd_read((void *) &magic, 1, sizeof(magic), abfd) != sizeof(magic)) + return 0; + + magic = bfd_h_getshort(abfd, (bfd_byte *) (&magic)); + + if (BADMAG(*((struct filehdr *) & magic))) { + bfd_error = wrong_format; + return 0; + } + if (bfd_read((void *) &nscns, 1, sizeof(nscns), abfd) != sizeof(nscns)) + return 0; + nscns = bfd_h_getshort(abfd, (unsigned char *) &nscns); + if (bfd_seek(abfd, (file_ptr) & (((struct filehdr *) NULL)->f_opthdr), SEEK_SET) + < 0) + return (bfd_target *) NULL; + if (bfd_read((void *) &opthdr, 1, sizeof(opthdr), abfd) != sizeof(opthdr)) + return (bfd_target *) NULL; + opthdr = bfd_h_getshort(abfd, (unsigned char *) &opthdr); + + return coff_real_object_p(abfd, nscns, opthdr); +} + +static boolean +coff_mkobject(abfd) + bfd *abfd; +{ + char *rawptr; + + + bfd_error = system_call_error; + + /* Use an intermediate variable for clarity */ + rawptr = malloc(sizeof(struct icofdata) + sizeof(AOUTHDR)); + if (rawptr == NULL) { + bfd_error = no_memory; + return false; + } + abfd->tdata = (void *) ((struct icofdata *) rawptr); + exec_hdr(abfd) = (AOUTHDR *) (rawptr + sizeof(struct icofdata)); + obj_relocbase(abfd) =0; + return true; +} + + + +static void +coff_count_linenumbers(abfd) + bfd *abfd; +{ + unsigned int limit = bfd_get_symcount(abfd); + unsigned int i; + asymbol **p; + { + asection *s = abfd->sections->output_section; + while (s) { + BFD_ASSERT(s->lineno_count == 0); + s = s->next; + } + } + + + for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) { + asymbol *q_maybe = *p; + if (q_maybe->the_bfd->xvec->flavour == bfd_target_coff_flavour_enum) { + coff_symbol_type *q = coffsymbol(q_maybe); + if (q->lineno) { + /* + This symbol has a linenumber, increment the owning + section's linenumber count + */ + alent *l = q->lineno; + q->symbol.section->output_section->lineno_count++; + l++; + while (l->line_number) { + q->symbol.section->output_section->lineno_count++; + l++; + } + } + } + } +} + +/* + This function returns true if the supplied SYMENT has an auxent with + and endndx field which should be relocated as the symbol moves + within the file. +*/ +static +boolean +uses_x_sym_x_fcnary_x_fcn_x_endndx_p(native) +SYMENT *native; +{ + if (ISFCN(native->n_type)) + return true; + if (native->n_sclass == C_BLOCK) + return true; + if (native->n_sclass == C_STRTAG) + return true; + if (native->n_sclass == C_ENTAG) + return true; + if (native->n_sclass == C_UNTAG) + return true; + if (native->n_sclass == C_MOS) + return true; + if(native->n_sclass == C_EOS) + return true; + if(native->n_sclass == C_MOE) + return true; + return false; + +} +/* + This function returns true if the supplied SYMENT has an AUXENT with + a tagndx field which should be relocated. + + The coff book says that all auxents have this and should be moved, + but all the actual implementations I've looked at do this .. + (sac@cygnus.com) + +*/ +static boolean +uses_x_sym_x_tagndx_p(native) +SYMENT *native; +{ + if (BTYPE(native->n_type) == T_STRUCT) return true; + if (BTYPE(native->n_type) == T_UNION) return true; + if (BTYPE(native->n_type) == T_ENUM)return true; + return false; +} + + +/* + Return the canonical symbol we work out how far it has moved since it + started life. This is done by finding the base of the raw syments as + read in when a file was slurped, which discovers the original offset + into the file. Then we return the value which we've saved in the + n_offset field of that name - and voila. +*/ +static +unsigned int +new_idx(symbol, original_offset) +coff_symbol_type *symbol; +unsigned int original_offset; +{ + struct icofdata *coff = obj_icof(symbol->symbol.the_bfd); + + /* Point to the native we used to point to */ + SYMENT *native = coff->raw_syments + original_offset; + + /* We keep the native's new index in it's string space */ + return native->n_offset; +} + + +/* Function to run through the raw parts of a coff symbol table and + loads each SYMENT's n_offset with its output index. If a symbol has + been deleted or moved to the end, still mark the offset of the one + following it. This makes refs to symbols which have moved point to + the symbol which now sits in the spot vacated. +*/ + +static +void +preload_n_offset(abfd) +bfd *abfd; +{ + unsigned int limit = bfd_get_symcount(abfd); + asymbol **p = abfd->outsymbols; + bfd *thebfd = (bfd *)NULL; + unsigned int native_index; + + native_index = 0; + + /* First phase, mark each SYMENT with final position */ + while (limit --) { + coff_symbol_type *q = coff_symbol_from(abfd, *p); + if (q != (coff_symbol_type *)NULL && q->native) { + q->native->n_offset = native_index; + native_index += 1 + q->native->n_numaux; + } + else { + native_index++; + } + p++; + } + +} + + +/* + run through the internal symbol table and make all the pointers and things + within the table point to the right places +*/ + +static void +coff_mangle_symbols(abfd) + bfd *abfd; +{ + asymbol **p; + unsigned int native_index = 0; + + unsigned int last_file_index = 0; + unsigned int limit = bfd_get_symcount(abfd); + SYMENT *last_file_symbol = (SYMENT *) NULL; + + /* Remember the bfd from the last symbol */ + bfd *last_bfd = (bfd *) NULL; + /* Remember the native from the last symbol */ + SYMENT *last_native = (SYMENT *) NULL; + + + preload_n_offset(abfd); + + p = abfd->outsymbols; + limit = bfd_get_symcount(abfd); + native_index = 0; + while (limit--) + { + coff_symbol_type *q = coff_symbol_from(abfd, *p); + if ((*p)->the_bfd != last_bfd) { + last_bfd = (*p)->the_bfd; + last_native = 0; + last_file_index = native_index; + } + + if (!q) { + native_index++; + } + else { + SYMENT *native = q->native; + if (native == (SYMENT *) NULL) { + native_index++; + } + else { + + + /* Alter the native representation */ + if (q->symbol.flags & BSF_FORT_COMM) { + native->n_scnum = 0; + native->n_value = q->symbol.value; + } + else if (q->symbol.flags & BSF_DEBUGGING) { + /* native->n_scnum = -2; */ + native->n_value = q->symbol.value; + } + else if (q->symbol.flags & BSF_UNDEFINED) { + native->n_scnum = 0; + native->n_value = 0; + } + else if (q->symbol.flags & BSF_ABSOLUTE) { + native->n_scnum = -1; + native->n_value = q->symbol.value; + } + else { + native->n_scnum = q->symbol.section->output_section->index + 1; + native->n_value = + q->symbol.value + + q->symbol.section->output_offset + + q->symbol.section->output_section->vma; + } + if (native->n_numaux != 0) + { + union auxent *a = (union auxent *) (native + 1); + + /* If this symbol forward references another, put + into it the real index of it by looking around + */ + if (uses_x_sym_x_fcnary_x_fcn_x_endndx_p(native)) + { + /* If this is a FCN entry without a + following .bf then we cheat and + insert the correct value directy. + */ + if (ISFCN(native->n_type) && + (native+2)->n_sclass != C_BLOCK) { + a->x_sym.x_fcnary.x_fcn.x_endndx = + native_index+ native->n_numaux + 1; + } + else{ + a->x_sym.x_fcnary.x_fcn.x_endndx = + new_idx(q,a->x_sym.x_fcnary.x_fcn.x_endndx); + } + + + } + if (uses_x_sym_x_tagndx_p(native)) { + a->x_sym.x_tagndx = + new_idx(q,a->x_sym.x_tagndx); + } +#ifdef I960 + else if (native->n_sclass == C_FCN + || !strcmp((char *) q->symbol.name, ".bf")) { + a->x_sym.x_fcnary.x_fcn.x_endndx = 0; + } +#endif /* I960 */ + + } + switch (native->n_sclass) { + case C_MOS: + case C_EOS: + case C_REGPARM: + case C_REG: +#ifdef C_AUTOARG + case C_AUTOARG: /* 960-specific storage class */ +#endif + /* + Fix so that they have an absolute section + */ + native->n_scnum = -1; + break; + + case C_FILE: + if (last_file_symbol) { + if (last_file_symbol->n_value != 0) { + abort(); + } /* sanity assertion */ + last_file_symbol->n_value = native_index; + } /* Chain all the .file symbols together */ + last_file_symbol = native; + + break; + + case C_EXT: + if (!ISFCN(native->n_type) + && last_file_symbol != NULL) { + if (last_file_symbol->n_value != 0) { + abort(); + } /* sanity assertion */ + last_file_symbol->n_value = native_index; + last_file_symbol = NULL; + } /* This should be the first global variable. */ + break; + + case C_FCN: + case C_NULL: + case C_AUTO: + case C_EXTDEF: + case C_LABEL: + case C_ULABEL: + case C_USTATIC: + case C_STRTAG: + case C_BLOCK: + case C_STAT: +#ifdef I960 + case C_LEAFEXT: + case C_LEAFSTAT: +#endif + break; + default: + /* + Bogus: This should be returning an error code, not + printing something out! + */ + /* + warning("Unrecognised sclass %d", native->n_sclass); + */ + break; + } + native_index += 1 + native->n_numaux; + + /* Remember the last native here */ + last_native = native + native->n_numaux; + } + + } + + p++; + } + +} + + +static void +coff_write_symbols(abfd) + bfd *abfd; +{ + unsigned int i; + unsigned int limit = bfd_get_symcount(abfd); + unsigned int written = 0; + SYMENT dummy; + asymbol **p; + unsigned int string_size = 0; + + + /* Seek to the right place */ + bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET); + + /* Output all the symbols we have */ + + written = 0; + for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) { + asymbol *symbol = *p; + coff_symbol_type *c_symbol = coff_symbol_from(abfd, symbol); + + unsigned int j; + SYMENT *native; + if (c_symbol == (coff_symbol_type *) NULL || + c_symbol->native == (SYMENT *) NULL) { + /* + This symbol has been created by the loader, or come from a non + coff format. It has no native element to inherit, make our + own + */ + native = &dummy; + native->n_type = T_NULL; + if (symbol->flags & BSF_ABSOLUTE) { + native->n_scnum = N_ABS; + native->n_value = symbol->value; + } + else if (symbol->flags & (BSF_UNDEFINED | BSF_FORT_COMM)) { + native->n_scnum = N_UNDEF; + native->n_value = symbol->value; + } + else if (symbol->flags & BSF_DEBUGGING) { + /* + remove name so it doesn't take up any space + */ + symbol->name = ""; +#if 0 /* FIXME -- Steve hasn't decided what to do + with these */ + /* + Don't do anything with debugs from the loader + */ + native->n_scnum = N_DEBUG; +#endif + continue; + } + else { + native->n_scnum = symbol->section->output_section->index + 1; + native->n_value = symbol->value + + symbol->section->output_section->vma + + symbol->section->output_offset; + } + +#ifdef I960 + /* + FIXME-SOON: THIS IS ALREADY WRONG FOR I960. Should echo the + flags in the filehdr. (?) + */ + native->n_flags = 0; +#else /* else not I960 */ +#ifdef HASPAD1 + native->pad1[0] = 0; + native->pad1[0] = 0; +#endif +#endif /* I960 */ + native->pad2[0] = 0; + native->pad2[1] = 0; + + native->n_type = 0; + native->n_sclass = C_EXT; + native->n_numaux = 0; + } + else + /* + Does this symbol have an ascociated line number - if so then + make it remember this symbol index. Also tag the auxent of + this symbol to point to the right place in the lineno table + */ + { + alent *lineno = c_symbol->lineno; + native = c_symbol->native; + if (lineno) { + unsigned int count = 0; + lineno[count].u.offset = written; + if (native->n_numaux) { + union auxent *a = (union auxent *) (native + 1); + a->x_sym.x_fcnary.x_fcn.x_lnnoptr = + c_symbol->symbol.section->output_section->moving_line_filepos; + } + /* + And count and relocate all other linenumbers + */ + count++; + while (lineno[count].line_number) { + lineno[count].u.offset += + c_symbol->symbol.section->output_section->vma + + c_symbol->symbol.section->output_offset; + count++; + } + c_symbol->symbol.section->output_section->moving_line_filepos += + count * sizeof(struct lineno); + + } + } /* if symbol new to coff */ + + /* Fix the symbol names */ + { + unsigned int name_length; + if (symbol->name == (char *) NULL) { + /* + coff symbols always have names, so we'll make one up + */ + symbol->name = "strange"; + } + name_length = strlen(symbol->name); + if (name_length <= SYMNMLEN) { + /* This name will fit into the symbol neatly */ + strncpy(native->n_name, symbol->name, SYMNMLEN); + } + else { + native->n_offset = string_size + 4; + native->n_zeroes = 0; + string_size += name_length + 1; + } + { + unsigned int numaux = native->n_numaux; + int type = native->n_type; + int class = native->n_sclass; + bfd_coff_swap_sym(abfd, native); + bfd_write((void *) native, 1, SYMESZ, abfd); + for (j = 0; j != native->n_numaux; j++) { + bfd_coff_swap_aux(abfd, native + j + 1, type, class); + bfd_write((void *) (native + j + 1), 1, AUXESZ, abfd); + + } + /* + Reuse somewhere in the symbol to keep the index + */ + set_index(symbol, written); + written += 1 + numaux; + } + } + } /* for each out symbol */ + + bfd_get_symcount(abfd) = written; + /* Now write out strings */ + + if (string_size) { + unsigned int size = string_size + 4; + bfd_h_put_x(abfd, size, &size); + bfd_write((void *) &size, 1, sizeof(size), abfd); + for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) { + asymbol *q = *p; + size_t name_length = strlen(q->name); + if (name_length > SYMNMLEN) { + bfd_write((void *) (q->name), 1, name_length + 1, abfd); + } + } + } + else { + /* We would normally not write anything here, but we'll write + out 4 so that any stupid coff reader which tries to read + the string table even when there isn't one won't croak. + */ + + uint32e_type size = 4; + bfd_h_put_x(abfd, size, &size); + bfd_write((void *)&size, 1, sizeof(size), abfd); + + } + +} + +static void +coff_write_relocs(abfd) + bfd *abfd; +{ + asection *s; + for (s = abfd->sections; s != (asection *) NULL; s = s->next) { + unsigned int i; + arelent **p = s->orelocation; + bfd_seek(abfd, s->rel_filepos, SEEK_SET); + for (i = 0; i < s->reloc_count; i++) { + struct reloc n; + arelent *q = p[i]; + memset(&n, 0, sizeof(n)); + n.r_vaddr = q->address + s->vma; + n.r_symndx = get_index((*(q->sym_ptr_ptr))); + n.r_type = q->howto->type; + swap_reloc(abfd, &n); + bfd_write((void *) &n, 1, RELSZ, abfd); + } + } +} +static void +coff_write_linenumbers(abfd) + bfd *abfd; +{ + asection *s; + for (s = abfd->sections; s != (asection *) NULL; s = s->next) { + if (s->lineno_count) { + asymbol **q = abfd->outsymbols; + bfd_seek(abfd, s->line_filepos, SEEK_SET); + /* Find all the linenumbers in this section */ + while (*q) { + asymbol *p = *q; + alent *l = BFD_SEND(p->the_bfd, _get_lineno, (p->the_bfd, p)); + if (l) { + /* Found a linenumber entry, output */ + struct lineno out; + out.l_lnno = 0; + out.l_addr.l_symndx = l->u.offset; +#ifdef LINENO_PADDING + out.padding[0] = 0; + out.padding[1] = 0; +#endif + bfd_coff_swap_lineno(abfd, &out); + bfd_write((void *) &out, 1, LINESZ, abfd); + l++; + while (l->line_number) { + out.l_lnno = l->line_number; + out.l_addr.l_symndx = l->u.offset; + bfd_coff_swap_lineno(abfd, &out); + bfd_write((void *) &out, 1, LINESZ, abfd); + l++; + } + } + q++; + } + } + } +} + + +static asymbol * +coff_make_empty_symbol(abfd) + bfd *abfd; +{ + coff_symbol_type *new = (coff_symbol_type *) malloc(sizeof(coff_symbol_type)); + if (new == NULL) { + bfd_error = no_memory; + return (NULL); + } /* on error */ + new->native = 0; + new->lineno = (alent *) NULL; + new->symbol.the_bfd = abfd; + return &new->symbol; +} + +static void +coff_print_symbol(ignore_abfd, file, symbol, how) + bfd *ignore_abfd; + FILE *file; + asymbol *symbol; + bfd_print_symbol_enum_type how; +{ + switch (how) { + case bfd_print_symbol_name_enum: + fprintf(file, "%s", symbol->name); + break; + case bfd_print_symbol_type_enum: + fprintf(file, "coff %lx %lx", (unsigned long) coffsymbol(symbol)->native, + (unsigned long) coffsymbol(symbol)->lineno); + break; + case bfd_print_symbol_all_enum: + { + char *section_name = symbol->section == (asection *) NULL ? + "*abs" : symbol->section->name; + bfd_print_symbol_vandf((void *) file, symbol); + + fprintf(file, " %-5s %s %s %s", + section_name, + coffsymbol(symbol)->native ? "n" : "g", + coffsymbol(symbol)->lineno ? "l" : " ", + symbol->name); + } + + + break; + } +} +static alent * +coff_get_lineno(ignore_abfd, symbol) + bfd *ignore_abfd; + asymbol *symbol; +{ + return coffsymbol(symbol)->lineno; +} +/* + Set flags and magic number of a coff file from architecture and machine + type. Result is true if we can represent the arch&type, false if not. +*/ +static boolean +coff_set_flags(abfd, magicp, flagsp) + bfd *abfd; + unsigned *magicp, + *flagsp; +{ + + + switch (abfd->obj_arch) { + +#ifdef I960ROMAGIC + + case bfd_arch_i960: + + { + unsigned flags; + *magicp = I960ROMAGIC; + /* + ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC : + I960RWMAGIC); FIXME??? + */ + switch (abfd->obj_machine) { + case bfd_mach_i960_core: + flags = F_I960CORE; + break; + case bfd_mach_i960_kb_sb: + flags = F_I960KB; + break; + case bfd_mach_i960_mc: + flags = F_I960MC; + break; + case bfd_mach_i960_xa: + flags = F_I960XA; + break; + case bfd_mach_i960_ca: + flags = F_I960CA; + break; + case bfd_mach_i960_ka_sa: + flags = F_I960KA; + break; + default: + return false; + } + *flagsp = flags; + return true; + } + break; +#endif +#ifdef MC68MAGIC + case bfd_arch_m68k: + *magicp = MC68MAGIC; + return true; +#endif +#if M88DMAGIC + case bfd_arch_m88k: + *magicp = MC88DMAGIC; + return true; + break; +#endif + + default: /* Unknown architecture */ + return false; + } + + return false; +} + + +static boolean +coff_set_arch_mach(abfd, arch, machine) + bfd *abfd; + enum bfd_architecture arch; + unsigned long machine; +{ + unsigned dummy1, + dummy2; + abfd->obj_arch = arch; + abfd->obj_machine = machine; + if (arch != bfd_arch_unknown && + coff_set_flags(abfd, &dummy1, &dummy2) != true) + return false; /* We can't represent this type */ + return true; /* We're easy ... */ +} + + +/* Calculate the file position for each section. */ + +static void +coff_compute_section_file_positions(abfd) + bfd *abfd; +{ + asection *current; + file_ptr sofar = FILHSZ; + if (bfd_get_start_address(abfd)) { + /* + A start address may have been added to the original file. In this + case it will need an optional header to record it. + */ + abfd->flags |= EXEC_P; + } + if (abfd->flags & EXEC_P) + sofar += AOUTSZ; + + + sofar += abfd->section_count * SCNHSZ; + + for (current = abfd->sections; current != NULL; current = current->next) { + current->filepos = sofar; + /* Only add sections which have contents */ + if (current->flags & SEC_HAS_CONTENTS) + sofar += current->size; + } + obj_relocbase(abfd) = sofar; +} + +/* SUPPRESS 558 */ +/* SUPPRESS 529 */ +static boolean +coff_write_object_contents(abfd) + bfd *abfd; +{ + struct filehdr file_header; + asection *current; + boolean hasrelocs = false; + boolean haslinno = false; + file_ptr reloc_base; + file_ptr lineno_base; + file_ptr sym_base; + file_ptr scn_base; + file_ptr data_base; + unsigned long reloc_size = 0; + unsigned long lnno_size = 0; + asection *text_sec = NULL; + asection *data_sec = NULL; + asection *bss_sec = NULL; + unsigned magic, + flags; + bfd_error = system_call_error; + + + if(abfd->output_has_begun == false) { + coff_compute_section_file_positions(abfd); + } + scn_base = (file_ptr) (sizeof(struct filehdr) + + ((abfd->flags & EXEC_P) ? sizeof(AOUTHDR) : 0)); + + if (bfd_seek(abfd, scn_base, SEEK_SET) != 0) + return false; + reloc_base = obj_relocbase(abfd); + + + /* + Make a pass through the symbol table to count line number entries and + put them into the correct asections + */ + coff_count_linenumbers(abfd); + data_base = scn_base; + /* Work out the size of the reloc and linno areas */ + + for (current = abfd->sections; current != NULL; current = current->next) { + reloc_size += current->reloc_count * sizeof(struct reloc); + lnno_size += current->lineno_count * sizeof(struct lineno); + data_base += sizeof(struct scnhdr); + } + + + lineno_base = reloc_base + reloc_size; + sym_base = lineno_base + lnno_size; + + /* Indicate in each section->line_filepos its actual file address */ + for (current = abfd->sections; current != NULL; current = current->next) { + if (current->lineno_count) { + current->line_filepos = lineno_base; + current->moving_line_filepos = lineno_base; + lineno_base += current->lineno_count * sizeof(struct lineno); + + } + else { + current->line_filepos = 0; + } + if (current->reloc_count) { + current->rel_filepos = reloc_base; + reloc_base += current->reloc_count * sizeof(struct reloc); + } + else { + current->rel_filepos = 0; + } + } + + + + bfd_seek(abfd, + (file_ptr) ((abfd->flags & EXEC_P) ? + (FILHSZ + AOUTSZ) : FILHSZ), + SEEK_SET); + { +#if 0 + unsigned int pad = abfd->flags & D_PAGED ? data_base : 0; +#endif + unsigned int pad = 0; + for (current = abfd->sections; current != NULL; current = current->next) { + SCNHDR section; + strncpy(&(section.s_name[0]), current->name, 8); + section.s_vaddr = current->vma + pad; + section.s_paddr = current->vma + pad; + section.s_size = current->size - pad; + /* + If this section has no size or is unloadable then the scnptr + will be 0 too + */ + if (current->size - pad == 0 || + (current->flags & SEC_LOAD) == 0) { + section.s_scnptr = 0; + + } + else { + section.s_scnptr = current->filepos; + } + section.s_relptr = current->rel_filepos; + section.s_lnnoptr = current->line_filepos; + section.s_nreloc = current->reloc_count; + section.s_nlnno = current->lineno_count; + if (current->reloc_count != 0) + hasrelocs = true; + if (current->lineno_count != 0) + haslinno = true; + + if (!strcmp(current->name, _TEXT)) { + text_sec = current; + section.s_flags = STYP_TEXT; /* kind stupid optimisation */ + } + else { + + if (!strcmp(current->name, _DATA)) { + data_sec = current; + section.s_flags = STYP_DATA; /* kind stupid + optimisation */ + } + else if (!strcmp(current->name, _BSS)) { + bss_sec = current; + section.s_flags = STYP_BSS; /* kind stupid optimisation */ + } + } + + +#ifdef I960 + section.s_align = (current->alignment_power + ? 1 << current->alignment_power + : 0); + +#endif + swap_scnhdr(abfd, §ion); + bfd_write((void *) (§ion), 1, SCNHSZ, abfd); + pad = 0; + } + + } + /* OK, now set up the filehdr... */ + + bfd_h_put_x(abfd, abfd->section_count, &file_header.f_nscns); + /* + We will NOT put a fucking timestamp in the header here. Every time you + put it back, I will come in and take it out again. I'm sorry. This + field does not belong here. We fill it with a 0 so it compares the + same but is not a reasonable time. -- gnu@cygnus.com + */ + /* + Well, I like it, so I'm conditionally compiling it in. + steve@cygnus.com + */ +#ifdef COFF_TIMESTAMP + bfd_h_put_x(abfd, time(0), &file_header.f_timdat); +#else + bfd_h_put_x(abfd, 0, &file_header.f_timdat); +#endif + + if (bfd_get_symcount(abfd) != 0) + bfd_h_put_x(abfd, sym_base, &file_header.f_symptr); + else + bfd_h_put_x(abfd, 0, &file_header.f_symptr); + + file_header.f_flags = 0; + + if (abfd->flags & EXEC_P) + bfd_h_put_x(abfd, sizeof(AOUTHDR), &file_header.f_opthdr); + else + bfd_h_put_x(abfd, 0, &file_header.f_opthdr); + + if (!hasrelocs) + file_header.f_flags |= F_RELFLG; + if (!haslinno) + file_header.f_flags |= F_LNNO; + if (0 == bfd_get_symcount(abfd)) + file_header.f_flags |= F_LSYMS; + if (abfd->flags & EXEC_P) + file_header.f_flags |= F_EXEC; + if (!abfd->xvec->byteorder_big_p) + file_header.f_flags |= F_AR32WR; + /* + FIXME, should do something about the other byte orders and + architectures. + */ + + /* Set up architecture-dependent stuff */ + + magic = 0; + flags = 0; + coff_set_flags(abfd, &magic, &flags); + file_header.f_flags |= flags; + + bfd_h_put_x(abfd, magic, &file_header.f_magic); + bfd_h_put_x(abfd, file_header.f_flags, &file_header.f_flags); + + /* ...and the "opt"hdr... */ +#ifdef I960 + bfd_h_put_x(abfd, (magic == I960ROMAGIC ? NMAGIC : OMAGIC), + &(exec_hdr(abfd)->magic)); +#endif +#if M88 + exec_hdr(abfd)->magic = PAGEMAGIC3; +#endif + + /* Now should write relocs, strings, syms */ + obj_sym_filepos(abfd) = sym_base; + + if (bfd_get_symcount(abfd) != 0) { + coff_mangle_symbols(abfd); + coff_write_symbols(abfd); + coff_write_linenumbers(abfd); + coff_write_relocs(abfd); + } + if (text_sec) { + bfd_h_put_x(abfd, text_sec->size, &exec_hdr(abfd)->tsize); + bfd_h_put_x(abfd, + text_sec->size ? text_sec->vma : 0, + &exec_hdr(abfd)->text_start); + } + if (data_sec) { + bfd_h_put_x(abfd, data_sec->size, &exec_hdr(abfd)->dsize); + bfd_h_put_x(abfd, + data_sec->size ? data_sec->vma : 0, + &exec_hdr(abfd)->data_start); + } + if (bss_sec) { + bfd_h_put_x(abfd, bss_sec->size, &exec_hdr(abfd)->bsize); + } + bfd_h_put_x(abfd, bfd_get_start_address(abfd), &exec_hdr(abfd)->entry); + + + /* now write them */ + bfd_h_put_x(abfd, bfd_get_symcount(abfd), &file_header.f_nsyms); + if (bfd_seek(abfd, 0L, SEEK_SET) != 0) + return false; + + bfd_write((void *) &file_header, 1, FILHSZ, abfd); + + if (abfd->flags & EXEC_P) { + + bfd_write((void *) exec_hdr(abfd), 1, AOUTSZ, abfd); + } + return true; +} + + + +static boolean +coff_set_section_contents(abfd, section, location, offset, count) + bfd *abfd; + sec_ptr section; + void *location; + file_ptr offset; + size_t count; +{ + if (abfd->output_has_begun == false) /* set by bfd.c handler */ + coff_compute_section_file_positions(abfd); + + bfd_seek(abfd, (file_ptr) (section->filepos + offset), SEEK_SET); + + if (count != 0) { + return (bfd_write(location, 1, count, abfd) == count) ? true : false; + } + return true; +} +static boolean +coff_get_section_contents(abfd, section, location, offset, count) + bfd *abfd; + sec_ptr section; + void *location; + file_ptr offset; + int count; +{ + if (count == 0 + || offset >= section->size + || bfd_seek(abfd, section->filepos + offset, SEEK_SET) == -1 + || bfd_read(location, 1, count, abfd) != count) { + return (false); + } /* on error */ + return (true); +} /* coff_get_section_contents() */ + + +static boolean +coff_close_and_cleanup(abfd) + bfd *abfd; +{ + if (!bfd_read_p(abfd)) + switch (abfd->format) { + case bfd_archive: + if (!_bfd_write_archive_contents(abfd)) + return false; + break; + case bfd_object: + if (!coff_write_object_contents(abfd)) + return false; + break; + default: + bfd_error = invalid_operation; + return false; + } + +#define cleaner(ptr) if (abfd->ptr) free (abfd->ptr) + cleaner(tdata); + + if (abfd->my_archive) + cleaner(filename); + +#undef cleaner + return true; +} + + + + + + +static void * +buy_and_read(abfd, where, seek_direction, size) + bfd *abfd; + file_ptr where; + int seek_direction; + size_t size; +{ + void *area = (void *) malloc(size); + if (!area) { + bfd_error = no_memory; + return (NULL); + } + bfd_seek(abfd, where, seek_direction); + if (bfd_read(area, 1, size, abfd) != size) { + bfd_error = system_call_error; + free(area); + return (NULL); + } /* on error */ + return (area); +} /* buy_and_read() */ + +static void +offset_symbol_indices(symtab, count, offset) + SYMENT *symtab; + unsigned long count; + long offset; +{ + SYMENT *end = symtab + count; + for (; symtab < end; ++symtab) { + if (symtab->n_sclass == C_FILE) { + symtab->n_value = 0; + } + else if (symtab->n_sclass == C_ALIAS) { + /* + These guys have indices in their values. + */ + symtab->n_value += offset; + + } + else if (symtab->n_numaux) { + /* + anybody else without an aux, has no indices. + */ + + if (symtab->n_sclass == C_EOS + || (BTYPE(symtab->n_type) == T_STRUCT + && symtab->n_sclass != C_STRTAG) + || BTYPE(symtab->n_type) == T_UNION + || BTYPE(symtab->n_type) == T_ENUM) { + + ((AUXENT *) (symtab + 1))->x_sym.x_tagndx += offset; + + } /* These guys have a tagndx */ + if (symtab->n_sclass == C_STRTAG + || symtab->n_sclass == C_UNTAG + || symtab->n_sclass == C_ENTAG + || symtab->n_sclass == C_BLOCK + || symtab->n_sclass == C_FCN + || ISFCN(symtab->n_type)) { + + ((AUXENT *) (symtab + 1))->x_sym.x_fcnary.x_fcn.x_endndx += offset; + + } /* These guys have an endndx */ +#ifndef I960 + if (ISFCN(symtab->n_type)) { + ((AUXENT *) (symtab + 1))->x_sym.x_tvndx += offset; + } /* These guys have a tvndx. I think... + (FIXME) */ +#endif /* Not I960 */ + + } /* if value, else if aux */ + symtab += symtab->n_numaux; + } /* walk the symtab */ + + return; +} /* offset_symbol_indices() */ +/* swap the entire symbol table */ +static void +swap_raw_symtab(abfd, raw_symtab) + bfd *abfd; + SYMENT *raw_symtab; +{ + long i; + SYMENT *end = raw_symtab + bfd_get_symcount(abfd); + for (; raw_symtab < end; ++raw_symtab) { + bfd_coff_swap_sym(abfd, raw_symtab); + + for (i = raw_symtab->n_numaux; i; --i, ++raw_symtab) { + bfd_coff_swap_aux(abfd, + raw_symtab + 1, + raw_symtab->n_type, + raw_symtab->n_sclass); + } /* swap all the aux entries */ + } /* walk the symbol table */ + + return; +} /* swap_raw_symtab() */ +/* + read a symbol table into freshly mallocated memory, swap it, and knit the + symbol names into a normalized form. By normalized here I mean that all + symbols have an n_offset pointer that points to a NULL terminated string. + Oh, and the first symbol MUST be a C_FILE. If there wasn't one there + before, put one there. +*/ + +static SYMENT * +get_normalized_symtab(abfd) + bfd *abfd; +{ + SYMENT *end; + SYMENT *retval; + SYMENT *s; + char *string_table = NULL; + unsigned long size; + unsigned long string_table_size = 0; + /* + I used to SEEK_END here to read the symtab and string table all at + once. This fails if this bfd is really an archive element. Thus, the + somewhat convoluted approach to reading in the string table. xoxorich. + */ + /* + $if ((bfd_seek(abfd, 0, SEEK_END) == -1) || ((end_of_file = + bfd_tell(abfd)) == -1) || (bfd_seek(abfd, obj_sym_filepos(abfd), + SEEK_SET) == -1) || ((beginning_of_symtab = bfd_tell(abfd)) == -1)) { + + bfd_error = system_call_error; return(NULL); }$ + *//* on error */ + + /* $if ((size = end_of_file - beginning_of_symtab) == 0) {$ */ + + if ((size = bfd_get_symcount(abfd) * sizeof(SYMENT)) == 0) { + bfd_error = no_symbols; + return (NULL); + } /* no symbols */ + /* + This is a hack. Some tool chains fail to put a C_FILE symbol at the + beginning of the symbol table. To make life simpler for our users, we + inject one if it wasn't there originally. + + We'd like to keep all of this bfd's native symbols in one block to keep + table traversals simple. To do that, we need to know whether we will + be prepending the C_FILE symbol before we read the rest of the table. + */ + if ((s = (SYMENT *) malloc(sizeof(SYMENT) * 2)) == NULL) { + bfd_error = no_memory; + return (NULL); + } /* on error */ + if (bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET) == -1 + || bfd_read(s, sizeof(SYMENT), 1, abfd) != sizeof(SYMENT)) { + bfd_error = system_call_error; + return (NULL); + } /* on error */ + bfd_coff_swap_sym(abfd, s); + + if (s->n_sclass == C_FILE) { + obj_symbol_slew(abfd) = 0; + + if ((retval = (SYMENT *) malloc(size)) == NULL) { + bfd_error = no_memory; + return (NULL); + } /* on malloc error */ + } + else { + unsigned long namelength = 0; + char *filename; + obj_symbol_slew(abfd) = 2; + + if ((retval = (SYMENT *) malloc(size + + (obj_symbol_slew(abfd) + * sizeof(SYMENT)))) == NULL) { + bfd_error = no_memory; + return (NULL); + } /* on malloc error */ + bzero((char *) retval, size + (obj_symbol_slew(abfd) * sizeof(SYMENT))); + +#define FILE_ENTRY_NAME ".file" + + if ((retval->n_offset = (int) malloc(strlen(FILE_ENTRY_NAME) + + 1)) == NULL) { + bfd_error = no_memory; + return (NULL); + } /* on malloc error */ + strcpy((char *) retval->n_offset, FILE_ENTRY_NAME); + retval->n_sclass = C_FILE; + retval->n_scnum = N_DEBUG; + retval->n_numaux = 1; + +#undef FILE_ENTRY_NAME + + if ((filename = bfd_get_filename(abfd)) == NULL) { + filename = "fake"; + } /* if we know it's name */ + if ((namelength = strlen(filename)) <= FILNMLEN) { + strncpy(((AUXENT *) (retval + 1))->x_file.x_fname, filename, FILNMLEN); + } + else { + if ((((AUXENT *) (retval + 1))->x_file.x_n.x_offset + = (int) malloc(namelength)) == NULL) { + bfd_error = no_memory; + return (NULL); + } /* on error */ + strcpy((char *) (((AUXENT *) (retval + 1))->x_file.x_n.x_offset), + filename); + + } /* if "short" name */ + } /* missing file entry. */ + + free(s); + + if (bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET) == -1 + || bfd_read(retval + obj_symbol_slew(abfd), size, 1, abfd) != size) { + bfd_error = system_call_error; + return (NULL); + } /* on read error */ + /* mark the end of the symbols */ + end = retval + obj_symbol_slew(abfd) + bfd_get_symcount(abfd); + /* + FIXME SOMEDAY. A string table size of zero is very weird, but + probably possible. If one shows up, it will probably kill us. + */ + + swap_raw_symtab(abfd, retval + obj_symbol_slew(abfd)); + + /* ...and normalize symbol names. */ + + for (s = retval + obj_symbol_slew(abfd); s < end; ++s) { + + if (s->n_zeroes != 0) { + /* + This is a "short" name. Make it long. + */ + unsigned long i = 0; + char *newstring = NULL; + /* + find the length of this string without walking into memory + that isn't ours. + */ + + for (i = 0; i <= 8; ++i) { + if (s->n_name[i] == '\0') { + break; + } /* if end of string */ + } /* possible lengths of this string. */ + + if ((newstring = malloc(++i)) == NULL) { + bfd_error = no_memory; + return (NULL); + } /* on error */ + bzero(newstring, i); + strncpy(newstring, s->n_name, 8); + s->n_offset = (int) newstring; + s->n_zeroes = 0; + + } + else { + if (string_table == NULL) { + /* + NOTE: we don't read the string table until now because we + don't necessarily know that we have one until now. + */ + /* + At this point we should be "seek"'d to the end of the + symbols === the symbol table size. + */ + + if (bfd_read((char *) &string_table_size, sizeof(string_table_size), 1, abfd) != sizeof(string_table_size)) { + bfd_error = system_call_error; + return (NULL); + } /* on error */ + sp(string_table_size); + + if ((string_table = malloc(string_table_size -= 4)) == NULL) { + bfd_error = no_memory; + return (NULL); + } /* on mallocation error */ + if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size) { + bfd_error = system_call_error; + return (NULL); + } /* on error */ + } /* have not yet read the string table. */ + /* + This is a long name already. Just point it at the string in + memory. + */ + s->n_offset = (int) (string_table - 4 + s->n_offset); + } /* switch on type of symbol name */ + + s += s->n_numaux; + } /* for each symbol */ + /* + If we had to insert a C_FILE symbol, then everybody's indices are off + by 2, so correct them. + */ + + if (obj_symbol_slew(abfd) > 0) { + offset_symbol_indices(retval + 2, bfd_get_symcount(abfd), 2); + + /* and let the world know there are two more of them. */ + bfd_get_symcount(abfd) += 2; + } /* if we added a C_FILE */ + obj_raw_syments(abfd) = retval; + obj_string_table(abfd) = string_table; + + return (retval); +} /* get_normalized_symtab() */ + +static +struct sec_struct * +section_from_bfd_index(abfd, index) + bfd *abfd; + int index; +{ + if (index > 0) { + struct sec_struct *answer = abfd->sections; + while (--index) { + answer = answer->next; + } + return answer; + } + return 0; +} + +static int +coff_get_symcount_upper_bound(ignore_abfd) + bfd *ignore_abfd; +{ + BFD_ASSERT(0); + return 0; +} + +static symindex +coff_get_first_symbol(ignore_abfd) + bfd *ignore_abfd; +{ + return 0; +} + +static symindex +coff_get_next_symbol(abfd, oidx) + bfd *abfd; + symindex oidx; +{ + if (oidx == BFD_NO_MORE_SYMBOLS) + return BFD_NO_MORE_SYMBOLS; + return ++oidx >= bfd_get_symcount(abfd) ? BFD_NO_MORE_SYMBOLS : oidx; +} + +static char * +coff_symbol_name(abfd, idx) + bfd *abfd; + symindex idx; +{ + return (obj_symbols(abfd) + idx)->symbol.name; +} + +static long +coff_symbol_value(abfd, idx) + bfd *abfd; + symindex idx; +{ + return (obj_symbols(abfd) + idx)->symbol.value; +} + +static symclass +coff_classify_symbol(abfd, idx) + bfd *abfd; + symindex idx; +{ + coff_symbol_type *sym = obj_symbols(abfd) + idx; + if ((sym->symbol.flags & BSF_FORT_COMM) != 0) + return bfd_symclass_fcommon; + if ((sym->symbol.flags & BSF_GLOBAL) != 0) + return bfd_symclass_global; + if ((sym->symbol.flags & BSF_DEBUGGING) != 0) + return bfd_symclass_debugger; + if ((sym->symbol.flags & BSF_UNDEFINED) != 0) + return bfd_symclass_undefined; + + return bfd_symclass_unknown; +} + +static boolean +coff_symbol_hasclass(abfd, idx, class) + bfd *abfd; + symindex idx; + symclass class; +{ + + coff_symbol_type *sym = obj_symbols(abfd) + idx; + switch (class) { + case bfd_symclass_fcommon: + return (sym->symbol.flags & BSF_FORT_COMM) ? true : false; + case bfd_symclass_global: + return (sym->symbol.flags & BSF_GLOBAL) ? true : false; + case bfd_symclass_debugger: + return (sym->symbol.flags & BSF_DEBUGGING) ? true : false;; + case bfd_symclass_undefined: + return (sym->symbol.flags & BSF_UNDEFINED) ? true : false;; + default: + return false; + } + +} + + + + +static + boolean +coff_slurp_line_table(abfd, asect) + bfd *abfd; + asection *asect; +{ + struct lineno *native_lineno; + alent *lineno_cache; + BFD_ASSERT(asect->lineno == (alent *) NULL); + + + native_lineno = (struct lineno *) buy_and_read(abfd, + asect->line_filepos, + SEEK_SET, + (size_t) (sizeof(struct lineno) * + asect->lineno_count)); + lineno_cache = + (alent *) malloc((size_t) ((asect->lineno_count + 1) * sizeof(alent))); + if (lineno_cache == NULL) { + bfd_error = no_memory; + return (BFD_FAILURE); + } { /* on error */ + unsigned int counter = 0; + alent *cache_ptr = lineno_cache; + struct lineno *src = native_lineno; + while (counter < asect->lineno_count) { + bfd_coff_swap_lineno(abfd, src); + cache_ptr->line_number = src->l_lnno; + + if (cache_ptr->line_number == 0) { + coff_symbol_type *sym = + (coff_symbol_type *) (src->l_addr.l_symndx + + obj_symbol_slew(abfd) + + obj_raw_syments(abfd))->n_zeroes; + cache_ptr->u.sym = (asymbol *) sym; + sym->lineno = cache_ptr; + } + else { + cache_ptr->u.offset = src->l_addr.l_paddr + - bfd_section_vma(abfd, asect); + } /* If no linenumber expect a symbol index */ + + cache_ptr++; + src++; + counter++; + } + cache_ptr->line_number = 0; + + } + free(native_lineno); + asect->lineno = lineno_cache; + return true; +} /* coff_slurp_line_table() */ + +static SYMENT * +find_next_file_symbol(current, end) + SYMENT *current; + SYMENT *end; +{ + /* ignore the first symbol which is probably a C_FILE. */ + + current += current->n_numaux + 1; + + for (; current < end; ++current) { + if (current->n_sclass == C_FILE) { + return (current); + } /* found one */ + current += current->n_numaux; + } /* walk the remaining table */ + + /* not found */ + return (end); +} /* find_next_file_symbol() */ +/* + Note that C_FILE symbols can, and some do, have more than 1 aux entry. +*/ + +static void +force_indices_file_symbol_relative(abfd, symtab) + bfd *abfd; + SYMENT *symtab; +{ + SYMENT *end = symtab + bfd_get_symcount(abfd); + SYMENT *current; + SYMENT *next; + /* the first symbol had damn well better be a C_FILE. */ + BFD_ASSERT(symtab->n_sclass == C_FILE); + symtab->n_value = 0; + + for (current = find_next_file_symbol(symtab, end); + current < end; + current = next) { + offset_symbol_indices(current, + ((next = + find_next_file_symbol(current, + end)) - current), + symtab - current); + } /* walk the table */ + + return; +} /* force_indices_file_symbol_relative() */ + +static boolean +coff_slurp_symbol_table(abfd) + bfd *abfd; +{ + SYMENT *native_symbols; + coff_symbol_type *cached_area; + unsigned int *table_ptr; + char *string_table = (char *) NULL; + unsigned int number_of_symbols = 0; + if (obj_symbols(abfd)) + return true; + bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET); + + /* Read in the symbol table */ + if ((native_symbols = get_normalized_symtab(abfd)) == NULL) { + return (false); + } /* on error */ + force_indices_file_symbol_relative(abfd, native_symbols); + + /* Allocate enough room for all the symbols in cached form */ + cached_area = + (coff_symbol_type *) + malloc((size_t) (bfd_get_symcount(abfd) * sizeof(coff_symbol_type))); + + if (cached_area == NULL) { + bfd_error = no_memory; + return (BFD_FAILURE); + } /* on error */ + table_ptr = + (unsigned int *) + malloc((size_t) (bfd_get_symcount(abfd) * sizeof(unsigned int))); + + if (table_ptr == NULL) { + bfd_error = no_memory; + return (BFD_FAILURE); + } { /* on error */ + coff_symbol_type *dst = cached_area; + unsigned int last_native_index = bfd_get_symcount(abfd); + unsigned int this_index = 0; + while (this_index < last_native_index) { + SYMENT *src = native_symbols + this_index; + table_ptr[this_index] = number_of_symbols; + dst->symbol.the_bfd = abfd; + + dst->symbol.name = (char *) src->n_offset; /* which was normalized + to point to a null + terminated string. */ + /* + We use the native name field to point to the cached field + */ + src->n_zeroes = (int) dst; + dst->symbol.section = section_from_bfd_index(abfd, src->n_scnum); + + switch (src->n_sclass) { +#ifdef I960 + case C_LEAFEXT: +#if 0 + dst->symbol.value = src->n_value - dst->symbol.section->vma; + dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL; + dst->symbol.flags |= BSF_NOT_AT_END; +#endif + /* Fall through to next case */ + +#endif + + case C_EXT: + if (src->n_scnum == 0) { + if (src->n_value == 0) { + dst->symbol.flags = BSF_UNDEFINED; + } + else { + dst->symbol.flags = BSF_FORT_COMM; + dst->symbol.value = src->n_value; + } + } + else { + /* + Base the value as an index from the base of the + section + */ + if (dst->symbol.section == (asection *) NULL) { + dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL | BSF_ABSOLUTE; + dst->symbol.value = src->n_value; + } + else { + dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL; + dst->symbol.value = src->n_value - dst->symbol.section->vma; + } + if (ISFCN(src->n_type)) { + /* + A function ext does not go at the end of a file + */ + dst->symbol.flags |= BSF_NOT_AT_END; + } + } + + break; + case C_STAT: /* static */ +#ifdef I960 + case C_LEAFSTAT: /* static leaf procedure */ +#endif + case C_LABEL: /* label */ + dst->symbol.flags = BSF_LOCAL; + /* + Base the value as an index from the base of the section + */ + dst->symbol.value = src->n_value - dst->symbol.section->vma; + break; + + case C_MOS: /* member of structure */ + case C_EOS: /* end of structure */ + case C_REGPARM: /* register parameter */ + case C_REG: /* register variable */ +#ifdef C_AUTOARG + case C_AUTOARG: /* 960-specific storage class */ +#endif + case C_TPDEF: /* type definition */ + + case C_ARG: + case C_AUTO: /* automatic variable */ + case C_FIELD: /* bit field */ + case C_ENTAG: /* enumeration tag */ + case C_MOE: /* member of enumeration */ + case C_MOU: /* member of union */ + case C_UNTAG: /* union tag */ + + dst->symbol.flags = BSF_DEBUGGING; + dst->symbol.value = src->n_value; + break; + + case C_FILE: /* file name */ + case C_STRTAG: /* structure tag */ + dst->symbol.flags = BSF_DEBUGGING; + dst->symbol.value = src->n_value; + + break; + case C_BLOCK: /* ".bb" or ".eb" */ + case C_FCN: /* ".bf" or ".ef" */ + dst->symbol.flags = BSF_LOCAL; + /* + Base the value as an index from the base of the section + */ + dst->symbol.value = src->n_value - dst->symbol.section->vma; + + break; + case C_EFCN: /* physical end of function */ + case C_NULL: + case C_EXTDEF: /* external definition */ + case C_ULABEL: /* undefined label */ + case C_USTATIC: /* undefined static */ + case C_LINE: /* line # reformatted as symbol table entry */ + case C_ALIAS: /* duplicate tag */ + case C_HIDDEN: /* ext symbol in dmert public lib */ + + default: + + printf("SICK%d\n", src->n_sclass); + abort(); + dst->symbol.flags = BSF_DEBUGGING; + dst->symbol.value = src->n_value; + + break; + } + + + + + BFD_ASSERT(dst->symbol.flags != 0); + + dst->native = src; + + dst->symbol.udata = 0; + dst->lineno = (alent *) NULL; + this_index += src->n_numaux + 1; + dst++; + number_of_symbols++; + } /* walk the native symtab */ + + } /* bfdize the native symtab */ + + obj_symbols(abfd) = cached_area; + obj_raw_syments(abfd) = native_symbols; + + bfd_get_symcount(abfd) = number_of_symbols; + obj_convert(abfd) = table_ptr; + /* Slurp the line tables for each section too */ + { + asection *p; + p = abfd->sections; + while (p) { + coff_slurp_line_table(abfd, p); + p = p->next; + } + } + return true; +} /* coff_slurp_symbol_table() */ + +static unsigned int +coff_get_symtab_upper_bound(abfd) + bfd *abfd; +{ + if (!coff_slurp_symbol_table(abfd)) + return 0; + + return (bfd_get_symcount(abfd) + 1) * (sizeof(coff_symbol_type *)); +} + + +static unsigned int +coff_get_symtab(abfd, alocation) + bfd *abfd; + asymbol **alocation; +{ + unsigned int counter = 0; + coff_symbol_type *symbase; + coff_symbol_type **location = (coff_symbol_type **) (alocation); + if (!coff_slurp_symbol_table(abfd)) + return 0; + + for (symbase = obj_symbols(abfd); counter++ < bfd_get_symcount(abfd);) + *(location++) = symbase++; + *location++ = 0; + return bfd_get_symcount(abfd); +} + +static unsigned int +coff_get_reloc_upper_bound(abfd, asect) + bfd *abfd; + sec_ptr asect; +{ + if (bfd_get_format(abfd) != bfd_object) { + bfd_error = invalid_operation; + return 0; + } + return (asect->reloc_count + 1) * sizeof(arelent *); +} + + +static boolean +coff_slurp_reloc_table(abfd, asect, symbols) + bfd *abfd; + sec_ptr asect; + asymbol **symbols; +{ + struct reloc *native_relocs; + arelent *reloc_cache; + if (asect->relocation) + return true; + if (asect->reloc_count == 0) + return true; + if (!coff_slurp_symbol_table(abfd)) + return false; + native_relocs = + (struct reloc *) buy_and_read(abfd, + asect->rel_filepos, + SEEK_SET, + (size_t) (sizeof(struct reloc) * + asect->reloc_count)); + reloc_cache = (arelent *) + malloc((size_t) (asect->reloc_count * sizeof(arelent))); + + if (reloc_cache == NULL) { + bfd_error = no_memory; + return (BFD_FAILURE); + } { /* on error */ + arelent *cache_ptr; + struct reloc *src; + for (cache_ptr = reloc_cache, + src = native_relocs; + cache_ptr < reloc_cache + asect->reloc_count; + cache_ptr++, + src++) { + asymbol *ptr; + swap_reloc(abfd, src); + src->r_symndx += obj_symbol_slew(abfd); + cache_ptr->sym_ptr_ptr = symbols + obj_convert(abfd)[src->r_symndx]; + + ptr = *(cache_ptr->sym_ptr_ptr); + cache_ptr->address = src->r_vaddr; + /* + The symbols definitions that we have read in have been + relocated as if their sections started at 0. But the offsets + refering to the symbols in the raw data have not been + modified, so we have to have a negative addend to compensate. + */ + + if (ptr->the_bfd == abfd && ptr->section != (asection *) NULL) { + cache_ptr->addend = -ptr->section->vma; + } + else { + cache_ptr->addend = 0; + } + + cache_ptr->address -= asect->vma; + + cache_ptr->section = (asection *) NULL; + +#if I960 + cache_ptr->howto = howto_table + src->r_type; +#endif +#if M88 + if (src->r_type >= R_PCR16L && src->r_type <= R_VRT32) { + cache_ptr->howto = howto_table + src->r_type - R_PCR16L; + } + else { + BFD_ASSERT(0); + } +#endif +#if M68 + cache_ptr->howto = howto_table + src->r_type; +#endif + + } + + } + + free(native_relocs); + asect->relocation = reloc_cache; + return true; +} + + +/* This is stupid. This function should be a boolean predicate */ +static unsigned int +coff_canonicalize_reloc(abfd, section, relptr, symbols) + bfd *abfd; + sec_ptr section; + arelent **relptr; + asymbol **symbols; +{ + arelent *tblptr = section->relocation; + unsigned int count = 0; + if (!(tblptr || coff_slurp_reloc_table(abfd, section, symbols))) + return 0; + tblptr = section->relocation; + if (!tblptr) + return 0; + + for (; count++ < section->reloc_count;) + *relptr++ = tblptr++; + + *relptr = 0; + + return section->reloc_count; +} + + + + + +/* + provided a bfd, a section and an offset into the section, calculate and + return the name of the source file and the line nearest to the wanted + location. +*/ + +static boolean +coff_find_nearest_line(abfd, + section, + symbols, + offset, + filename_ptr, + functionname_ptr, + line_ptr) + bfd *abfd; + asection *section; + asymbol **symbols; + bfd_vma offset; + char **filename_ptr; + char **functionname_ptr; + unsigned int *line_ptr; +{ + static bfd *cache_abfd; + static asection *cache_section; + static bfd_vma cache_offset; + static unsigned int cache_i; + static alent *cache_l; + + unsigned int i = 0; + struct icofdata *cof = obj_icof(abfd); + /* Run through the raw syments if available */ + SYMENT *p = cof->raw_syments; + alent *l; + unsigned int line_base = 0; + *filename_ptr = 0; + *functionname_ptr = 0; + *line_ptr = 0; + /* + I don't know for sure what's right, but this isn't it. First off, an + object file may not have any C_FILE's in it. After + get_normalized_symtab(), it should have at least 1, the one I put + there, but otherwise, all bets are off. Point #2, the first C_FILE + isn't necessarily the right C_FILE because any given object may have + many. I think you'll have to track sections as they coelesce in order + to find the C_STAT symbol for this section. Then you'll have to work + backwards to find the previous C_FILE, or choke if you get to a C_STAT + for the same kind of section. That will mean that the original object + file didn't have a C_FILE. xoxorich. + */ + +#ifdef WEREBEINGPEDANTIC + return false; +#endif + + + + for (i = 0; i < cof->raw_syment_count; i++) { + if (p->n_sclass == C_FILE) { + /* File name is embeded in auxent */ + /* + This isn't right. The fname should probably be normalized + during get_normalized_symtab(). In any case, what was here + wasn't right because a SYMENT.n_name isn't an + AUXENT.x_file.x_fname. xoxorich. + */ + + *filename_ptr = ((AUXENT *) (p + 1))->x_file.x_fname; + break; + } + p += 1 + p->n_numaux; + } + /* Now wander though the raw linenumbers of the section */ + + + + + /* + If this is the same bfd as we were previously called with and this is + the same section, and the offset we want is further down then we can + prime the lookup loop + */ + if (abfd == cache_abfd && + section == cache_section && + offset >= cache_offset) { + i = cache_i; + l = cache_l; + } + else { + i = 0; + l = section->lineno; + } + + for (; i < section->lineno_count; i++) { + if (l->line_number == 0) { + /* Get the symbol this line number points at */ + coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym); + *functionname_ptr = coff->symbol.name; + if (coff->native) { + struct syment *s = coff->native; + s = s + 1 + s->n_numaux; + /* + S should now point to the .bf of the function + */ + if (s->n_numaux) { + /* + The linenumber is stored in the auxent + */ + union auxent *a = (union auxent *) (s + 1); + line_base = a->x_sym.x_misc.x_lnsz.x_lnno; + } + } + } + else { + if (l->u.offset > offset) + break; + *line_ptr = l->line_number + line_base + 1; + } + l++; + } + + cache_abfd = abfd; + cache_section = section; + cache_offset = offset; + cache_i = i; + cache_l = l; + return true; +} |