X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fcoff-code.h;h=904023652639c3b1ed29b94f2a268a9abdb1d338;hb=14dd454bea3944270aae97d60b5a7f1d8ea46d60;hp=c64928560142e41b99806404aadd49c9f96b2886;hpb=fc7233808a1d88db99a5181e1ee0f6865f8f5206;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/coff-code.h b/bfd/coff-code.h index c649285601..9040236526 100755 --- a/bfd/coff-code.h +++ b/bfd/coff-code.h @@ -40,98 +40,348 @@ You should have received a copy of the GNU General Public License along with #define sp(x) bfd_h_put_x(abfd, x, &x) -PROTO(static void,force_indices_file_symbol_relative,(bfd *abfd, SYMENT *symtab)); +#ifndef I960 +#define GDB_EXPORT static +#else +#define GDB_EXPORT /* nothing */ +#endif + +PROTO(static void,force_indices_file_symbol_relative,(bfd *abfd, + struct internal_syment *symtab)); + + +/* void warning(); */ +extern asection abs_section; + +static int +DEFUN(get_index,(symbol), + asymbol *symbol) +{ + return (int) symbol->value; +} + +static void +DEFUN(set_index,(symbol, idx), + asymbol *symbol AND + unsigned int idx) +{ + symbol->value = idx; +} + + + + /* All the swapping routines: +*/ - FIXME, these routines assume that the sizes, alignments, and offsets of - these fields are the same in the host and target. This is an invalid - assumption, which in particular breaks on the 386 and SPARC. Fix this - the same way that a.out.h and sunos.c were fixed: define char arrays - that represent the headers in the target systems' file, and have these - functions translate in from that format, and out to that format. */ -static void -DEFUN(swap_reloc,(abfd, reloc), +GDB_EXPORT +void +DEFUN(bfd_swap_reloc_in,(abfd, reloc_src, reloc_dst), + bfd *abfd AND + RELOC *reloc_src AND + struct internal_reloc *reloc_dst) +{ + reloc_dst->r_vaddr = bfd_h_getlong(abfd, reloc_src->r_vaddr); + reloc_dst->r_symndx = bfd_h_getlong(abfd, reloc_src->r_symndx); + reloc_dst->r_type = bfd_h_getshort(abfd, reloc_src->r_type); +#if M88 + reloc_dst->r_offset = bfd_h_getshort(abfd, reloc_src->r_offset); +#endif +} + +GDB_EXPORT + void +DEFUN(bfd_swap_reloc_out,(abfd, reloc_src, reloc_dst), bfd *abfd AND - RELOC *reloc) + struct internal_reloc *reloc_src AND + struct external_reloc *reloc_dst) { - sp(reloc->r_vaddr); - sp(reloc->r_symndx); - sp(reloc->r_type); + bfd_h_putlong(abfd, reloc_src->r_vaddr, reloc_dst->r_vaddr); + bfd_h_putlong(abfd, reloc_src->r_symndx, reloc_dst->r_symndx); + bfd_h_putshort(abfd, reloc_src->r_type, reloc_dst->r_type); +#if M88 + bfd_h_putshort(abfd, reloc_src->r_offset, reloc_dst->r_offset); +#endif + } +GDB_EXPORT void +DEFUN(bfd_swap_filehdr_in,(abfd, filehdr_src, filehdr_dst), + bfd *abfd AND + FILHDR *filehdr_src AND + struct internal_filehdr *filehdr_dst) +{ + filehdr_dst->f_magic = bfd_h_get_x(abfd, filehdr_src->f_magic); + filehdr_dst->f_nscns = bfd_h_get_x(abfd,filehdr_src-> f_nscns); + filehdr_dst->f_timdat = bfd_h_get_x(abfd,filehdr_src-> f_timdat); + filehdr_dst->f_symptr = bfd_h_get_x(abfd,filehdr_src-> f_symptr); + filehdr_dst->f_nsyms = bfd_h_get_x(abfd,filehdr_src-> f_nsyms); + filehdr_dst->f_opthdr = bfd_h_get_x(abfd,filehdr_src-> f_opthdr); + filehdr_dst->f_flags = bfd_h_get_x(abfd,filehdr_src-> f_flags); +} -static void -DEFUN(swap_filehdr,(abfd, filehdr), +GDB_EXPORT void +DEFUN(bfd_swap_filehdr_out,(abfd, filehdr_in, filehdr_out), bfd *abfd AND - FILHDR *filehdr) + struct internal_filehdr *filehdr_in AND + FILHDR *filehdr_out) { - 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); + bfd_h_put_x(abfd, filehdr_in->f_magic, filehdr_out->f_magic); + bfd_h_put_x(abfd, filehdr_in->f_nscns, filehdr_out->f_nscns); + bfd_h_put_x(abfd, filehdr_in->f_timdat, filehdr_out->f_timdat); + bfd_h_put_x(abfd, filehdr_in->f_symptr, filehdr_out->f_symptr); + bfd_h_put_x(abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms); + bfd_h_put_x(abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr); + bfd_h_put_x(abfd, filehdr_in->f_flags, filehdr_out->f_flags); +} + +GDB_EXPORT +void +DEFUN(bfd_coff_swap_sym_in,(abfd, ext, in), + bfd *abfd AND + SYMENT *ext AND + struct internal_syment *in) +{ + if( ext->e.e_name[0] == 0) { + in->_n._n_n._n_zeroes = 0; + in->_n._n_n._n_offset = bfd_h_getlong(abfd, ext->e.e.e_offset); + } + else { + memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN); + } + in->n_value = bfd_h_get_x(abfd, ext->e_value); + in->n_scnum = bfd_h_get_x(abfd, ext->e_scnum); + in->n_type = bfd_h_get_x(abfd, ext->e_type); + in->n_sclass = bfd_h_get_x(abfd, ext->e_sclass); + in->n_numaux = bfd_h_get_x(abfd, ext->e_numaux); +} +GDB_EXPORT void +DEFUN(bfd_coff_swap_sym_out,(abfd,in, ext), + bfd *abfd AND + struct internal_syment *in AND + SYMENT *ext) +{ + if(in->_n._n_name[0] == 0) { + bfd_h_putlong(abfd, 0, ext->e.e.e_zeroes); + bfd_h_putlong(abfd, in->_n._n_n._n_offset, ext->e.e.e_offset); + } + else { + memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN); + } + bfd_h_put_x(abfd, in->n_value , ext->e_value); + bfd_h_put_x(abfd, in->n_scnum , ext->e_scnum); + bfd_h_put_x(abfd, in->n_type , ext->e_type); + bfd_h_put_x(abfd, in->n_sclass , ext->e_sclass); + bfd_h_put_x(abfd, in->n_numaux , ext->e_numaux); } -static void -DEFUN(swap_aouthdr,(abfd, aouthdr), +GDB_EXPORT void +DEFUN(bfd_coff_swap_aux_in,(abfd, ext, type, class, in), + bfd *abfd AND + AUXENT *ext AND + int type AND + int class AND + union internal_auxent *in) +{ + switch (class) { + case C_FILE: + if (ext->x_file.x_fname[0] == 0) { + in->x_file.x_n.x_zeroes = 0; + in->x_file.x_n.x_offset = bfd_h_getlong(abfd, ext->x_file.x_n.x_offset); + } + + break; + case C_STAT: +#ifdef C_LEAFSTAT + case C_LEAFSTAT: +#endif + case C_HIDDEN: + if (type == T_NULL) { + in->x_scn.x_scnlen = bfd_h_get_x(abfd, ext->x_scn.x_scnlen); + in->x_scn.x_nreloc = bfd_h_get_x(abfd, ext->x_scn.x_nreloc); + in->x_scn.x_nlinno = bfd_h_get_x(abfd, ext->x_scn.x_nlinno); + break; + } + default: + in->x_sym.x_tagndx = bfd_h_get_x(abfd, ext->x_sym.x_tagndx); + in->x_sym.x_tvndx = bfd_h_get_x(abfd, ext->x_sym.x_tvndx); + + if (ISARY(type) || class == C_BLOCK) { + in->x_sym.x_fcnary.x_ary.x_dimen[0] = bfd_h_get_x(abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]); + in->x_sym.x_fcnary.x_ary.x_dimen[1] = bfd_h_get_x(abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]); + in->x_sym.x_fcnary.x_ary.x_dimen[2] = bfd_h_get_x(abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]); + in->x_sym.x_fcnary.x_ary.x_dimen[3] = bfd_h_get_x(abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]); + } + else { + in->x_sym.x_fcnary.x_fcn.x_lnnoptr = bfd_h_get_x(abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr); + in->x_sym.x_fcnary.x_fcn.x_endndx = bfd_h_get_x(abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx); + } + if (ISFCN(type)) { + in->x_sym.x_misc.x_fsize = bfd_h_get_x(abfd, ext->x_sym.x_misc.x_fsize); + } + else { + in->x_sym.x_misc.x_lnsz.x_lnno = bfd_h_get_x(abfd, ext->x_sym.x_misc.x_lnsz.x_lnno); + in->x_sym.x_misc.x_lnsz.x_size = bfd_h_get_x(abfd, ext->x_sym.x_misc.x_lnsz.x_size); + } + } +} + +GDB_EXPORT void +DEFUN(bfd_coff_swap_aux_out,(abfd, in, type, class, ext), + bfd *abfd AND + union internal_auxent *in AND + int type AND + int class AND + AUXENT *ext) +{ + switch (class) { + case C_FILE: + if (in->x_file.x_fname[0] == 0) { + bfd_h_put_x(abfd, 0, ext->x_file.x_n.x_zeroes ); + bfd_h_put_x(abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset); + } + + break; + case C_STAT: +#ifdef C_LEAFSTAT + case C_LEAFSTAT: +#endif + case C_HIDDEN: + if (type == T_NULL) { + bfd_h_put_x(abfd, in->x_scn.x_scnlen, ext->x_scn.x_scnlen); + bfd_h_put_x(abfd, in->x_scn.x_nreloc, ext->x_scn.x_nreloc); + bfd_h_put_x(abfd, in->x_scn.x_nlinno, ext->x_scn.x_nlinno); + break; + } + default: + bfd_h_put_x(abfd, in->x_sym.x_tagndx, ext->x_sym.x_tagndx); + bfd_h_put_x(abfd, in->x_sym.x_tvndx , ext->x_sym.x_tvndx); + + if (ISARY(type) || class == C_BLOCK) { + bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],ext->x_sym.x_fcnary.x_ary.x_dimen[0]); + bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],ext->x_sym.x_fcnary.x_ary.x_dimen[1]); + bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],ext->x_sym.x_fcnary.x_ary.x_dimen[2]); + bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],ext->x_sym.x_fcnary.x_ary.x_dimen[3]); + } + else { + bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr); + bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx, ext->x_sym.x_fcnary.x_fcn.x_endndx); + } + if (ISFCN(type)) { + bfd_h_put_x(abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize); + } + else { + bfd_h_put_x(abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext->x_sym.x_misc.x_lnsz.x_lnno); + bfd_h_put_x(abfd, in->x_sym.x_misc.x_lnsz.x_size, ext->x_sym.x_misc.x_lnsz.x_size); + } + } +} + +GDB_EXPORT void +DEFUN(bfd_coff_swap_lineno_in,(abfd, ext, in), + bfd *abfd AND + LINENO *ext AND + struct internal_lineno *in) +{ + in->l_addr.l_symndx = bfd_h_get_x(abfd, ext->l_addr.l_symndx); + in->l_lnno = bfd_h_get_x(abfd, ext->l_lnno); +} + +GDB_EXPORT void +DEFUN(bfd_coff_swap_lineno_out,(abfd, in, ext), bfd *abfd AND - AOUTHDR *aouthdr) + struct internal_lineno *in AND + struct external_lineno *ext) { + bfd_h_put_x(abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx); + bfd_h_put_x(abfd, in->l_lnno, ext->l_lnno); +} + + - 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); + +GDB_EXPORT void +DEFUN(bfd_swap_aouthdr_in,(abfd, aouthdr_ext, aouthdr_int), + bfd *abfd AND + AOUTHDR *aouthdr_ext AND + struct internal_aouthdr *aouthdr_int) +{ + aouthdr_int->magic = bfd_h_get_x(abfd, aouthdr_ext->magic); + aouthdr_int->vstamp = bfd_h_get_x(abfd, aouthdr_ext->vstamp); + aouthdr_int->tsize = bfd_h_get_x(abfd, aouthdr_ext->tsize); + aouthdr_int->dsize = bfd_h_get_x(abfd, aouthdr_ext->dsize); + aouthdr_int->bsize = bfd_h_get_x(abfd, aouthdr_ext->bsize); + aouthdr_int->entry = bfd_h_get_x(abfd, aouthdr_ext->entry); + aouthdr_int->text_start = bfd_h_get_x(abfd, aouthdr_ext->text_start); + aouthdr_int->data_start = bfd_h_get_x(abfd, aouthdr_ext->data_start); #ifdef I960 - sp(aouthdr->tagentries); + aouthdr_int->tagentries = bfd_h_get_x(abfd, aouthdr_ext->tagentries); #endif } -static void -DEFUN(swap_scnhdr,(abfd, scnhdr), +GDB_EXPORT void +DEFUN(bfd_swap_aouthdr_out,(abfd, aouthdr_in, aouthdr_out), bfd *abfd AND - SCNHDR *scnhdr) + struct internal_aouthdr *aouthdr_in AND + AOUTHDR *aouthdr_out) { - 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); + bfd_h_put_x(abfd, aouthdr_in->magic, aouthdr_out->magic); + bfd_h_put_x(abfd, aouthdr_in->vstamp, aouthdr_out->vstamp); + bfd_h_put_x(abfd, aouthdr_in->tsize, aouthdr_out->tsize); + bfd_h_put_x(abfd, aouthdr_in->dsize, aouthdr_out->dsize); + bfd_h_put_x(abfd, aouthdr_in->bsize, aouthdr_out->bsize); + bfd_h_put_x(abfd, aouthdr_in->entry, aouthdr_out->entry); + bfd_h_put_x(abfd, aouthdr_in->text_start, aouthdr_out->text_start); + bfd_h_put_x(abfd, aouthdr_in->data_start, aouthdr_out->data_start); #ifdef I960 - sp(scnhdr->s_align); + bfd_h_put_x(abfd, aouthdr_in->tagentries, aouthdr_out->tagentries); #endif } - -/* void warning(); */ -extern asection abs_section; -static int -DEFUN(get_index,(symbol), - asymbol *symbol) +GDB_EXPORT void +DEFUN(bfd_coff_swap_scnhdr_in,(abfd, scnhdr_ext, scnhdr_int), + bfd *abfd AND + SCNHDR *scnhdr_ext AND + struct internal_scnhdr *scnhdr_int) { - return (int) symbol->value; + memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof(scnhdr_int->s_name)); + scnhdr_int->s_vaddr = bfd_h_get_x(abfd, scnhdr_ext->s_vaddr); + scnhdr_int->s_paddr = bfd_h_get_x(abfd, scnhdr_ext->s_paddr); + scnhdr_int->s_size = bfd_h_get_x(abfd, scnhdr_ext->s_size); + scnhdr_int->s_scnptr = bfd_h_get_x(abfd, scnhdr_ext->s_scnptr); + scnhdr_int->s_relptr = bfd_h_get_x(abfd, scnhdr_ext->s_relptr); + scnhdr_int->s_lnnoptr = bfd_h_get_x(abfd, scnhdr_ext->s_lnnoptr); + scnhdr_int->s_nreloc = bfd_h_get_x(abfd, scnhdr_ext->s_nreloc); + scnhdr_int->s_nlnno = bfd_h_get_x(abfd, scnhdr_ext->s_nlnno); + scnhdr_int->s_flags = bfd_h_get_x(abfd, scnhdr_ext->s_flags); +#ifdef I960 + scnhdr_int->s_align = bfd_h_get_x(abfd, scnhdr_ext->s_align); +#endif } -static void -DEFUN(set_index,(symbol, idx), - asymbol *symbol AND - unsigned int idx) +static void +DEFUN(swap_scnhdr_out,(abfd, scnhdr_int, scnhdr_ext), + bfd *abfd AND + struct internal_scnhdr *scnhdr_int AND + SCNHDR *scnhdr_ext) { - symbol->value = idx; + memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name)); + bfd_h_put_x(abfd, scnhdr_int->s_vaddr, scnhdr_ext->s_vaddr); + bfd_h_put_x(abfd, scnhdr_int->s_paddr, scnhdr_ext->s_paddr); + bfd_h_put_x(abfd, scnhdr_int->s_size, scnhdr_ext->s_size); + bfd_h_put_x(abfd, scnhdr_int->s_scnptr, scnhdr_ext->s_scnptr); + bfd_h_put_x(abfd, scnhdr_int->s_relptr, scnhdr_ext->s_relptr); + bfd_h_put_x(abfd, scnhdr_int->s_lnnoptr, scnhdr_ext->s_lnnoptr); + bfd_h_put_x(abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc); + bfd_h_put_x(abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno); + bfd_h_put_x(abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags); +#ifdef I960 + bfd_h_put_x(abfd, scnhdr_int->s_align, scnhdr_ext->s_align); +#endif } /* @@ -150,6 +400,9 @@ DEFUN(coff_new_section_hook,(abfd_ignore, section_ignore), knowing its magic number? */ /* Align to at least 16 bytes */ section_ignore->alignment_power = 4; +#endif +#if M68 + section_ignore->alignment_power = 3; #endif return true; } @@ -159,8 +412,7 @@ DEFUN(coff_new_section_hook,(abfd_ignore, section_ignore), static boolean DEFUN(make_a_section_from_file,(abfd, hdr), bfd *abfd AND - struct scnhdr *hdr) - + struct internal_scnhdr *hdr) { asection *return_section; @@ -209,6 +461,7 @@ DEFUN(make_a_section_from_file,(abfd, hdr), return_section->lineno_count = hdr->s_nlnno; return_section->userdata = NULL; return_section->next = (asection *) NULL; + return_section->flags = 0; 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) @@ -220,12 +473,11 @@ DEFUN(make_a_section_from_file,(abfd, hdr), return_section->flags |= SEC_HAS_CONTENTS; return true; } - static boolean DEFUN(coff_mkobject,(abfd), bfd *abfd) { - set_tdata (abfd, bfd_alloc (abfd,sizeof(coff_data_type))); + set_tdata (abfd, bfd_zalloc (abfd,sizeof(coff_data_type))); if (coff_data(abfd) == 0) { bfd_error = no_memory; return false; @@ -236,48 +488,30 @@ DEFUN(coff_mkobject,(abfd), static bfd_target * -DEFUN(coff_real_object_p,(abfd, nscns, opthdr), +DEFUN(coff_real_object_p,(abfd, nscns, internal_f, internal_a), bfd *abfd AND unsigned nscns AND - unsigned opthdr) + struct internal_filehdr *internal_f AND + struct internal_aouthdr *internal_a) { coff_data_type *coff; - 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 */ + size_t readsize; /* length of file_info */ + SCNHDR *external_sections; + /* Build a play area */ if (coff_mkobject(abfd) != true) return 0; coff = coff_data(abfd); - - /* 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 = (PTR) bfd_alloc(abfd, readsize); - if (file_info == NULL) { - bfd_error = no_memory; - goto fail; - } - - if (bfd_seek(abfd, 0L, SEEK_SET) < 0) { - bfd_release (abfd, (PTR)file_info); - goto fail; - } - if (bfd_read((PTR) file_info, 1, readsize, abfd) != readsize) { - bfd_release (abfd, (PTR)file_info); + + + external_sections = (SCNHDR *)bfd_alloc(abfd, readsize = (nscns * SCNHSZ)); + if (bfd_read((PTR)external_sections, 1, readsize, abfd) != readsize) { goto fail; } - 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 */ coff->symbol_index_slew = 0; coff->relocbase =0; @@ -285,20 +519,30 @@ DEFUN(coff_real_object_p,(abfd, nscns, opthdr), coff->raw_linenos = 0; coff->raw_syments = 0; coff->sym_filepos =0; - coff->flags = filehdr->f_flags; + coff->flags = internal_f->f_flags; 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); + struct internal_scnhdr tmp; + bfd_coff_swap_scnhdr_in(abfd, external_sections + i, &tmp); + make_a_section_from_file(abfd,&tmp); } } /* Determine the machine architecture and type. */ abfd->obj_machine = 0; - switch (filehdr->f_magic) { + switch (internal_f->f_magic) { +#ifdef MIPS +case MIPS_MAGIC_1: +case MIPS_MAGIC_2: +case MIPS_MAGIC_3: + abfd->obj_arch = bfd_arch_mips; + abfd->obj_machine = 0; + break; +#endif + #ifdef MC68MAGIC case MC68MAGIC: - case MC68DMAGIC: + case M68MAGIC: abfd->obj_arch = bfd_arch_m68k; abfd->obj_machine = 68020; break; @@ -311,11 +555,12 @@ DEFUN(coff_real_object_p,(abfd, nscns, opthdr), abfd->obj_machine = 88100; break; #endif +#ifdef I960 #ifdef I960ROMAGIC case I960ROMAGIC: case I960RWMAGIC: abfd->obj_arch = bfd_arch_i960; - switch (F_I960TYPE & filehdr->f_flags) + switch (F_I960TYPE & internal_f->f_flags) { default: case F_I960CORE: @@ -336,42 +581,97 @@ DEFUN(coff_real_object_p,(abfd, nscns, opthdr), case F_I960KA: abfd->obj_machine = bfd_mach_i960_ka_sa; break; - + } break; #endif - +#endif + default: /* Unreadable input file type */ abfd->obj_arch = bfd_arch_obscure; break; } - - if (!(filehdr->f_flags & F_RELFLG)) + + if (!(internal_f->f_flags & F_RELFLG)) abfd->flags |= HAS_RELOC; - if ((filehdr->f_flags & F_EXEC)) + if ((internal_f->f_flags & F_EXEC)) abfd->flags |= EXEC_P; - if (!(filehdr->f_flags & F_LNNO)) + if (!(internal_f->f_flags & F_LNNO)) abfd->flags |= HAS_LINENO; - if (!(filehdr->f_flags & F_LSYMS)) + if (!(internal_f->f_flags & F_LSYMS)) abfd->flags |= HAS_LOCALS; - - - bfd_get_symcount(abfd) = filehdr->f_nsyms; - if (filehdr->f_nsyms) + + + bfd_get_symcount(abfd) = internal_f->f_nsyms; + if (internal_f->f_nsyms) abfd->flags |= HAS_SYMS; - - coff->sym_filepos = filehdr->f_symptr; - swap_aouthdr(abfd, &coff->hdr); - + + coff->sym_filepos = internal_f->f_symptr; + + + coff->symbols = (coff_symbol_type *) NULL; - bfd_get_start_address(abfd) = opthdr ? exec_hdr(abfd).entry : 0; - + bfd_get_start_address(abfd) = internal_f->f_opthdr ? internal_a->entry : 0; + return abfd->xvec; fail: bfd_release(abfd, coff); return (bfd_target *)NULL; } +static bfd_target * +DEFUN(coff_object_p,(abfd), + bfd *abfd) + { + int nscns; + FILHDR filehdr; + AOUTHDR opthdr; + struct internal_filehdr internal_f; + struct internal_aouthdr internal_a; + + bfd_error = system_call_error; + + /* figure out how much to read */ + if (bfd_read((PTR) &filehdr, 1, FILHSZ, abfd) != FILHSZ) + return 0; + + bfd_swap_filehdr_in(abfd, &filehdr, &internal_f); + + if (BADMAG(internal_f)) { + bfd_error = wrong_format; + return 0; + } + nscns =internal_f.f_nscns; + + if (internal_f.f_opthdr) { + if (bfd_read((PTR) &opthdr, 1,AOUTSZ, abfd) != AOUTSZ) { + return 0; + } + bfd_swap_aouthdr_in(abfd, &opthdr, &internal_a); + } + + /* Seek past the opt hdr stuff */ + bfd_seek(abfd, internal_f.f_opthdr + FILHSZ, SEEK_SET); + + /* if the optional header is NULL or not the correct size then + quit; the only difference I can see between m88k dgux headers (MC88DMAGIC) + and Intel 960 readwrite headers (I960WRMAGIC) is that the + optional header is of a different size. + + But the mips keeps extra stuff in it's opthdr, so dont check + when doing that + */ + +#ifndef MIPS + if (internal_f.f_opthdr != 0 && AOUTSZ != internal_f.f_opthdr) + return (bfd_target *)NULL; +#endif + + return coff_real_object_p(abfd, nscns, &internal_f, &internal_a); + } + + + /* Takes a bfd and a symbol, returns a pointer to the coff specific area @@ -393,47 +693,6 @@ DEFUN(coff_symbol_from,(abfd, symbol), -static bfd_target * -DEFUN(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((PTR) &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((PTR) &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 0; - if (bfd_read((PTR) &opthdr, 1, sizeof(opthdr), abfd) != sizeof(opthdr)) - return 0; - opthdr = bfd_h_getshort(abfd, (unsigned char *) &opthdr); - - /* if the optional header is NULL or not the correct size then - quit; the only difference I can see between m88k dgux headers (MC88DMAGIC) - and Intel 960 readwrite headers (I960WRMAGIC) is that the - optional header is of a different size - */ - - if (opthdr != 0 && - opthdr != AOUTSZ) - return (bfd_target *)NULL; - - return coff_real_object_p(abfd, nscns, opthdr); -} @@ -485,8 +744,9 @@ DEFUN(coff_count_linenumbers,(abfd), */ static boolean -DEFUN(uses_x_sym_x_tagndx_p,(native), - SYMENT *native) +DEFUN(uses_x_sym_x_tagndx_p,(abfd, native), + bfd *abfd AND + struct internal_syment *native) { if (BTYPE(native->n_type) == T_STRUCT) return true; if (BTYPE(native->n_type) == T_UNION) return true; @@ -532,16 +792,16 @@ We store in the name field of each syment the actual native index applied so we can dig it out through a pointer. */ static void -coff_mangle_symbols(bfd_ptr) -bfd *bfd_ptr; +DEFUN(coff_mangle_symbols,(bfd_ptr), + bfd *bfd_ptr) { unsigned int symbol_count = bfd_get_symcount(bfd_ptr); asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols; - SYMENT *last_tagndx = (SYMENT *)NULL; - SYMENT *last_file = (SYMENT *)NULL; - SYMENT *last_fcn = (SYMENT *)NULL; - SYMENT *block_stack[50]; - SYMENT **last_block = &block_stack[0]; + struct internal_syment *last_tagndx = (struct internal_syment *)NULL; + struct internal_syment *last_file = (struct internal_syment *)NULL; + struct internal_syment *last_fcn = (struct internal_syment *)NULL; + struct internal_syment *block_stack[50]; + struct internal_syment **last_block = &block_stack[0]; boolean first_time = true; unsigned int symbol_index; unsigned int native_index = 0; @@ -551,14 +811,14 @@ bfd *bfd_ptr; coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]); if (coff_symbol_ptr == (coff_symbol_type *)NULL) { /* - This symbol has no coff information in it, it will take up - only one slot in the output symbol table - */ + This symbol has no coff information in it, it will take up + only one slot in the output symbol table + */ native_index++; } else { - SYMENT *syment = coff_symbol_ptr->native; - if (syment == (SYMENT *)NULL) { + struct internal_syment *syment = coff_symbol_ptr->native; + if (syment == (struct internal_syment *)NULL) { native_index++; } else { @@ -580,20 +840,21 @@ bfd *bfd_ptr; syment->n_value = coff_symbol_ptr->symbol.value; } else { - syment->n_scnum = + syment->n_scnum = coff_symbol_ptr->symbol.section->output_section->index+1; + syment->n_value = coff_symbol_ptr->symbol.value + coff_symbol_ptr->symbol.section->output_offset + coff_symbol_ptr->symbol.section->output_section->vma; } - - + + /* If this symbol ties up something then do it */ - if (syment->n_sclass == C_FILE && last_file != (SYMENT *)NULL) + if (syment->n_sclass == C_FILE && last_file != (struct internal_syment *)NULL) { - last_file->n_value = native_index; + last_file->n_value = native_index; } else if ((syment->n_sclass == C_EXT || syment->n_sclass == C_STAT @@ -602,70 +863,67 @@ bfd *bfd_ptr; || syment->n_sclass == C_LEAFSTAT #endif ) - && last_fcn != (SYMENT *)NULL) - { - AUXENT *auxent = (AUXENT *)(last_fcn+1); - auxent->x_sym.x_fcnary.x_fcn.x_endndx = native_index; - last_fcn = (SYMENT *)NULL; - - } - else if (syment->n_sclass == C_EOS && last_tagndx != (SYMENT*)NULL) - { - AUXENT *auxent = (AUXENT *)(last_tagndx+1); - /* Remember that we keep the native index in the offset - so patch the beginning of the struct to point to this - */ - auxent->x_sym.x_tagndx = last_tagndx->n_offset; - auxent->x_sym.x_fcnary.x_fcn.x_endndx = - native_index + syment->n_numaux + 1 ; - /* Now point the eos to the structure */ - auxent = (AUXENT *)(syment+1); - auxent->x_sym.x_tagndx = last_tagndx->n_offset; + && last_fcn != (struct internal_syment *)NULL) + { + union internal_auxent *auxent = (union internal_auxent *)(last_fcn+1); + auxent->x_sym.x_fcnary.x_fcn.x_endndx = native_index; + last_fcn = (struct internal_syment *)NULL; - - } + } + else if (syment->n_sclass == C_EOS && last_tagndx != (struct internal_syment*)NULL) + { + union internal_auxent *auxent = (union internal_auxent *)(last_tagndx+1); + /* Remember that we keep the native index in the offset + so patch the beginning of the struct to point to this + */ + auxent->x_sym.x_tagndx = last_tagndx->_n._n_n._n_offset; + auxent->x_sym.x_fcnary.x_fcn.x_endndx = syment->n_numaux + 1 + native_index; + /* Now point the eos to the structure */ + auxent = (union internal_auxent *)(syment+1); + auxent->x_sym.x_tagndx = last_tagndx->_n._n_n._n_offset; + } else if (syment->n_sclass == C_BLOCK && coff_symbol_ptr->symbol.name[1] == 'e') - { - AUXENT *auxent = (AUXENT *)((*(--last_block))+1); - auxent->x_sym.x_fcnary.x_fcn.x_endndx = - native_index + syment->n_numaux + 1; - } + { + union internal_auxent *auxent = (union internal_auxent *)((*(--last_block))+1); + auxent->x_sym.x_fcnary.x_fcn.x_endndx = native_index + syment->n_numaux + 1; + } if (syment->n_sclass == C_EXT && !ISFCN(syment->n_type) && first_time == true - && last_file != (SYMENT *)NULL) { + && last_file != (struct internal_syment *)NULL) { /* This is the first external symbol seen which isn't a function place it in the last .file entry */ last_file->n_value = native_index; first_time = false; } #ifdef C_LEAFPROC - if (syment->n_sclass == C_LEAFPROC && syment->n_numaux == 2) { - AUXENT *auxent = (AUXENT *)(syment+2); + if (syment->n_sclass == C_LEAFPROC && + syment->n_numaux == 2) { + union internal_auxent *auxent = (union internal_auxent *)(syment+2); /* This is the definition of a leaf proc, we'll relocate the - address */ - - auxent->x_bal.x_balntry += - coff_symbol_ptr->symbol.section->output_offset + - coff_symbol_ptr->symbol.section->output_section->vma ; + address */ + auxent->x_bal.x_balntry = + coff_symbol_ptr->symbol.section->output_offset + + coff_symbol_ptr->symbol.section->output_section->vma + + auxent->x_bal.x_balntry ; } #endif /* If this symbol needs to be tied up then remember some facts */ if (syment->n_sclass == C_FILE) - { - last_file = syment; - } + { + last_file = syment; + } if (syment->n_numaux != 0) { /* - If this symbol would like to point to something in the - future then remember where it is - */ - if (uses_x_sym_x_tagndx_p(syment)) { + If this symbol would like to point to something in the + future then remember where it is + */ + if (uses_x_sym_x_tagndx_p(bfd_ptr, syment)) { /* - If this is a ref to a structure then we'll tie it up - now - there are never any forward refs for one - */ + If this is a ref to a structure then we'll tie it up + now - there are never any forward refs for one + */ if (syment->n_sclass == C_STRTAG || syment->n_sclass == C_ENTAG || syment->n_sclass == C_UNTAG) { @@ -673,16 +931,17 @@ bfd *bfd_ptr; } else { /* - This is a ref to a structure - the structure must - have been defined within the same file, and previous - to this point, so we can deduce the new tagndx - directly. - */ - AUXENT *auxent = (AUXENT *)(syment+1); + This is a ref to a structure - the structure must + have been defined within the same file, and previous + to this point, so we can deduce the new tagndx + directly. + */ + union internal_auxent *auxent = (union internal_auxent *)(syment+1); bfd *bfd_ptr = coff_symbol_ptr->symbol.the_bfd; - SYMENT *base = obj_raw_syments(bfd_ptr); - auxent->x_sym.x_tagndx = base[auxent->x_sym.x_tagndx].n_offset; - + struct internal_syment *base = obj_raw_syments(bfd_ptr); + auxent->x_sym.x_tagndx = base[auxent->x_sym.x_tagndx]._n._n_n._n_offset; + + } } if (ISFCN(syment->n_type)) { @@ -690,11 +949,11 @@ bfd *bfd_ptr; } if (syment->n_sclass == C_BLOCK && coff_symbol_ptr->symbol.name[1] == 'b') - { - *last_block++ = syment; - } + { + *last_block++ = syment; + } } - syment->n_offset = native_index; + syment->_n._n_n._n_offset = native_index; native_index = native_index + 1 + syment->n_numaux; } } @@ -703,172 +962,168 @@ bfd *bfd_ptr; static void -coff_write_symbols(abfd) - bfd *abfd; +DEFUN(coff_write_symbols,(abfd), +bfd *abfd) { unsigned int i; unsigned int limit = bfd_get_symcount(abfd); unsigned int written = 0; - SYMENT dummy; + struct internal_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; + struct internal_syment *native; if (c_symbol == (coff_symbol_type *) NULL || - c_symbol->native == (SYMENT *) NULL) { + c_symbol->native == (struct internal_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 - */ - + 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; + native->n_type = T_NULL; #ifdef I960 - native->n_flags = 0; + native->n_flags = 0; #endif if (symbol->flags & BSF_ABSOLUTE) { - native->n_scnum = N_ABS; - native->n_value = symbol->value; + 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; + 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 - */ + 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 + + 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 /* Copy the any flags from the the file hdr into the symbol */ - { - coff_symbol_type *c = coff_symbol_from(abfd, symbol); - if (c != (coff_symbol_type *)NULL) { - native->n_flags = c->symbol.the_bfd->flags; + { + coff_symbol_type *c = coff_symbol_from(abfd, symbol); + if (c != (coff_symbol_type *)NULL) { + native->n_flags = c->symbol.the_bfd->flags; + } } - } #endif - } - - - + } + #ifdef HASPAD1 native->pad1[0] = 0; native->pad1[0] = 0; #endif - - native->pad2[0] = 0; - native->pad2[1] = 0; - - native->n_type = 0; - native->n_sclass = C_EXT; - native->n_numaux = 0; + + native->n_type = 0; + if (symbol->flags & BSF_LOCAL) + native->n_sclass = C_STAT; + else + 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; + 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 internal_auxent *a = (union internal_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 * LINESZ; + } - c_symbol->symbol.section->output_section->moving_line_filepos += - count * sizeof(struct lineno); - - } - } /* if symbol new to coff */ - + } /* 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((PTR) native, 1, SYMESZ, abfd); - for (j = 0; j != native->n_numaux; j++) { - bfd_coff_swap_aux(abfd, (AUXENT *)(native + j + 1), type, class); - bfd_write((PTR) (native + j + 1), 1, AUXESZ, abfd); - + unsigned int name_length; + if (symbol->name == (char *) NULL) { + /* + coff symbols always have names, so we'll make one up + */ + symbol->name = "strange"; } - /* - Reuse somewhere in the symbol to keep the index - */ - set_index(symbol, written); - written += 1 + numaux; + name_length = strlen(symbol->name); + if (name_length <= SYMNMLEN) { + /* This name will fit into the symbol neatly */ + strncpy(native->_n._n_name, symbol->name, SYMNMLEN); + } + else { + native->_n._n_n._n_offset = string_size + 4; + native->_n._n_n._n_zeroes = 0; + string_size += name_length + 1; + } + { + unsigned int numaux = native->n_numaux; + int type = native->n_type; + int class = native->n_sclass; + SYMENT buf; + bfd_coff_swap_sym_out(abfd, native, &buf); + bfd_write((PTR)& buf, 1, SYMESZ, abfd); + for (j = 0; j != native->n_numaux; + j++) { + AUXENT buf1; + bfd_coff_swap_aux_out(abfd, + (union internal_auxent *)(native + j + 1), type, class, &buf1); + bfd_write((PTR) (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 */ - + } /* 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); + size = size; bfd_write((PTR) &size, 1, sizeof(size), abfd); for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) { asymbol *q = *p; @@ -883,266 +1138,279 @@ coff_write_symbols(abfd) 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); + size = size; bfd_write((PTR)&size, 1, sizeof(size), abfd); - + } - + } static void coff_write_relocs(abfd) - bfd *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((PTR)&n, 0, sizeof(n)); - n.r_vaddr = q->address + s->vma; - if (q->sym_ptr_ptr) { - n.r_symndx = get_index((*(q->sym_ptr_ptr))); - } - n.r_type = q->howto->type; - swap_reloc(abfd, &n); - bfd_write((PTR) &n, 1, RELSZ, abfd); + unsigned int i; + struct external_reloc dst; + + arelent **p = s->orelocation; + bfd_seek(abfd, s->rel_filepos, SEEK_SET); + for (i = 0; i < s->reloc_count; i++) { + struct internal_reloc n; + arelent *q = p[i]; + memset((PTR)&n, 0, sizeof(n)); + n.r_vaddr = q->address + s->vma; + if (q->sym_ptr_ptr) { + n.r_symndx = get_index((*(q->sym_ptr_ptr))); } +#ifdef SELECT_RELOC + /* Work out reloc type from what is required */ + SELECT_RELOC(n.r_type, q->howto); +#else + n.r_type = q->howto->type; +#endif + bfd_swap_reloc_out(abfd, &n, &dst); + bfd_write((PTR) &n, 1, RELSZ, abfd); + } } -} + } static void -coff_write_linenumbers(abfd) - bfd *abfd; -{ +DEFUN(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; - bzero( (PTR)&out, sizeof(out)); - out.l_lnno = 0; - out.l_addr.l_symndx = l->u.offset; - bfd_coff_swap_lineno(abfd, &out); - bfd_write((PTR) &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((PTR) &out, 1, LINESZ, abfd); - l++; - } - } - q++; + 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 internal_lineno out; + LINENO buff; + bzero( (PTR)&out, sizeof(out)); + out.l_lnno = 0; + out.l_addr.l_symndx = l->u.offset; + bfd_coff_swap_lineno_out(abfd, &out, &buff); + bfd_write((PTR) &buff, 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_out(abfd, &out, &buff); + bfd_write((PTR) &buff, 1, LINESZ, abfd); + l++; } + } + q++; } + } } -} + } static asymbol * coff_make_empty_symbol(abfd) - bfd *abfd; -{ +bfd *abfd; + { coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type)); if (new == NULL) { - bfd_error = no_memory; - return (NULL); - } /* on error */ + 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; -{ +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; + 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; + fprintf(file, "coff %lx %lx", (unsigned long) coffsymbol(symbol)->native, + (unsigned long) coffsymbol(symbol)->lineno); + break; case bfd_print_symbol_all_enum: { - CONST char *section_name = symbol->section == (asection *) NULL ? + CONST char *section_name = symbol->section == (asection *) NULL ? "*abs" : symbol->section->name; - bfd_print_symbol_vandf((PTR) file, symbol); - - fprintf(file, " %-5s %s %s %s", - section_name, - coffsymbol(symbol)->native ? "n" : "g", - coffsymbol(symbol)->lineno ? "l" : " ", - symbol->name); + bfd_print_symbol_vandf((PTR) file, symbol); + + fprintf(file, " %-5s %s %s %s", + section_name, + coffsymbol(symbol)->native ? "n" : "g", + coffsymbol(symbol)->lineno ? "l" : " ", + symbol->name); } - - - break; + + + break; } -} + } static alent * coff_get_lineno(ignore_abfd, symbol) - bfd *ignore_abfd; - asymbol *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. +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; -{ - +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; + 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 MIPS + case bfd_arch_mips: + *magicp = MIPS_MAGIC_2; + return true; + break; +#endif #ifdef MC68MAGIC - case bfd_arch_m68k: + case bfd_arch_m68k: *magicp = MC68MAGIC; return true; #endif - + #ifdef MC88MAGIC - case bfd_arch_m88k: + case bfd_arch_m88k: *magicp = MC88OMAGIC; return true; break; #endif - - default: /* Unknown architecture */ + + 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; -{ +bfd *abfd; +enum bfd_architecture arch; +unsigned long machine; + { unsigned dummy1, - dummy2; + 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 ... */ -} + 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; -{ +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; + /* + 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 += AOUTSZ; + + sofar += abfd->section_count * SCNHSZ; - + for (current = abfd->sections; current != NULL; current = current->next) { /* Only deal with sections which have contents */ if (!(current->flags & SEC_HAS_CONTENTS)) continue; - + /* Align the sections in the file to the same boundary on - which they are aligned in virtual memory. I960 doesn't - do this (FIXME) so we can stay in sync with Intel. 960 - doesn't yet page from files... */ + which they are aligned in virtual memory. I960 doesn't + do this (FIXME) so we can stay in sync with Intel. 960 + doesn't yet page from files... */ #ifndef I960 sofar = ALIGN(sofar, 1 << current->alignment_power); #endif /* FIXME, in demand paged files, the low order bits of the file - offset must match the low order bits of the virtual address. - "Low order" is apparently implementation defined. Add code - here to round sofar up to match the virtual address. */ - + offset must match the low order bits of the virtual address. + "Low order" is apparently implementation defined. Add code + here to round sofar up to match the virtual address. */ + current->filepos = sofar; sofar += current->size; } obj_relocbase(abfd) = sofar; -} + } @@ -1150,10 +1418,9 @@ coff_compute_section_file_positions(abfd) /* SUPPRESS 558 */ /* SUPPRESS 529 */ static boolean -coff_write_object_contents(abfd) - bfd *abfd; +DEFUN(coff_write_object_contents,(abfd), +bfd *abfd) { - struct filehdr file_header; asection *current; boolean hasrelocs = false; boolean haslinno = false; @@ -1167,20 +1434,20 @@ coff_write_object_contents(abfd) asection *text_sec = NULL; asection *data_sec = NULL; asection *bss_sec = NULL; - unsigned magic, - - flags; + struct internal_filehdr internal_f; + struct internal_aouthdr internal_a; + struct icofdata *coff = obj_icof(abfd); - - + + bfd_error = system_call_error; - - + + if(abfd->output_has_begun == false) { coff_compute_section_file_positions(abfd); } - + if (abfd->sections != (asection *)NULL) { scn_base = abfd->sections->filepos; } @@ -1190,115 +1457,116 @@ coff_write_object_contents(abfd) 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 - */ + + /* 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); + reloc_size += current->reloc_count * RELSZ; + lnno_size += current->lineno_count * LINESZ; + data_base += SCNHSZ; } - - + 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); + lineno_base += current->lineno_count * LINESZ; } else { current->line_filepos = 0; } if (current->reloc_count) { current->rel_filepos = reloc_base; - reloc_base += current->reloc_count * sizeof(struct reloc); + reloc_base += current->reloc_count * sizeof(struct internal_reloc); } else { current->rel_filepos = 0; } } - + /* Write section headers to the file. */ - + 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; + 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; /* kinda stupid */ - } - else if (!strcmp(current->name, _DATA)) { - data_sec = current; - section.s_flags = STYP_DATA; /* kinda stupid */ - } - else if (!strcmp(current->name, _BSS)) { - bss_sec = current; - section.s_flags = STYP_BSS; /* kinda stupid */ - } - - + unsigned int pad = 0; + + for (current = abfd->sections; current != NULL; current = current->next) { + struct internal_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; /* kinda stupid */ + } + else if (!strcmp(current->name, _DATA)) { + data_sec = current; + section.s_flags = STYP_DATA; /* kinda stupid */ + } + else if (!strcmp(current->name, _BSS)) { + bss_sec = current; + section.s_flags = STYP_BSS; /* kinda stupid */ + } + + #ifdef I960 - section.s_align = (current->alignment_power - ? 1 << current->alignment_power - : 0); + section.s_align = (current->alignment_power + ? 1 << current->alignment_power + : 0); #endif - swap_scnhdr(abfd, §ion); - bfd_write((PTR) (§ion), 1, SCNHSZ, abfd); - pad = 0; + { + SCNHDR buff; + + swap_scnhdr_out(abfd, §ion, &buff); + bfd_write((PTR) (&buff), 1, SCNHSZ, abfd); + + } + pad = 0; + } } - } /* OK, now set up the filehdr... */ - - bfd_h_put_x(abfd, abfd->section_count, &file_header.f_nscns); + internal_f.f_nscns = abfd->section_count; /* 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 @@ -1310,36 +1578,36 @@ coff_write_object_contents(abfd) steve@cygnus.com */ #ifdef COFF_TIMESTAMP - bfd_h_put_x(abfd, time(0), &file_header.f_timdat); + internal_f.f_timdat = time(0); #else - bfd_h_put_x(abfd, 0, &file_header.f_timdat); + internal_f.f_timdat = 0; #endif if (bfd_get_symcount(abfd) != 0) - bfd_h_put_x(abfd, sym_base, &file_header.f_symptr); + internal_f.f_symptr = sym_base; else - bfd_h_put_x(abfd, 0, &file_header.f_symptr); + internal_f.f_symptr = 0; - file_header.f_flags = 0; + internal_f.f_flags = 0; if (abfd->flags & EXEC_P) - bfd_h_put_x(abfd, sizeof(AOUTHDR), &file_header.f_opthdr); + internal_f.f_opthdr = AOUTSZ; else - bfd_h_put_x(abfd, 0, &file_header.f_opthdr); + internal_f.f_opthdr = 0; if (!hasrelocs) - file_header.f_flags |= F_RELFLG; + internal_f.f_flags |= F_RELFLG; if (!haslinno) - file_header.f_flags |= F_LNNO; + internal_f.f_flags |= F_LNNO; if (0 == bfd_get_symcount(abfd)) - file_header.f_flags |= F_LSYMS; + internal_f.f_flags |= F_LSYMS; if (abfd->flags & EXEC_P) - file_header.f_flags |= F_EXEC; + internal_f.f_flags |= F_EXEC; #if M88 - file_header.f_flags |= F_AR32W; + internal_f.f_flags |= F_AR32W; #else if (!abfd->xvec->byteorder_big_p) - file_header.f_flags |= F_AR32WR; + internal_f.f_flags |= F_AR32WR; #endif /* FIXME, should do something about the other byte orders and @@ -1348,23 +1616,21 @@ coff_write_object_contents(abfd) /* Set up architecture-dependent stuff */ - magic = 0; - flags = 0; - coff_set_flags(abfd, &magic, &flags); - file_header.f_flags |= flags; + { int magic = 0; + int flags = 0; + coff_set_flags(abfd, &magic, &flags); + internal_f.f_magic = magic; + internal_f.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... */ - /* ...and the "opt"hdr... */ #ifdef I960 - bfd_h_put_x(abfd, (magic == I960ROMAGIC ? NMAGIC : OMAGIC), - &(exec_hdr(abfd).magic)); + internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC); #endif #if M88 - exec_hdr(abfd).magic = PAGEMAGICBCS; + internal_a.magic = PAGEMAGICBCS; #endif - + } /* Now should write relocs, strings, syms */ obj_sym_filepos(abfd) = sym_base; @@ -1375,32 +1641,32 @@ coff_write_object_contents(abfd) coff_write_relocs(abfd); } if (text_sec) { - bfd_h_put_x(abfd, text_sec->size, &coff->hdr.tsize); - bfd_h_put_x(abfd, - text_sec->size ? text_sec->vma : 0, - &exec_hdr(abfd).text_start); + internal_a.tsize = text_sec->size; + internal_a.text_start =text_sec->size ? text_sec->vma : 0; } if (data_sec) { - bfd_h_put_x(abfd, data_sec->size, &coff->hdr.dsize); - bfd_h_put_x(abfd, - data_sec->size ? data_sec->vma : 0, - &exec_hdr(abfd).data_start); + internal_a.dsize = data_sec->size; + internal_a.data_start = data_sec->size ? data_sec->vma : 0; } if (bss_sec) { - bfd_h_put_x(abfd, bss_sec->size, &coff->hdr.bsize); + internal_a.bsize = bss_sec->size; } - bfd_h_put_x(abfd, bfd_get_start_address(abfd), &coff->hdr.entry); - bfd_h_put_x(abfd, bfd_get_symcount(abfd), &file_header.f_nsyms); + internal_a.entry = bfd_get_start_address(abfd); + internal_f.f_nsyms = bfd_get_symcount(abfd); /* now write them */ if (bfd_seek(abfd, 0L, SEEK_SET) != 0) return false; - - bfd_write((PTR) &file_header, 1, FILHSZ, abfd); - + { + FILHDR buff; + bfd_swap_filehdr_out(abfd, &internal_f, &buff); + bfd_write((PTR) &buff, 1, FILHSZ, abfd); + } if (abfd->flags & EXEC_P) { - bfd_write((PTR) &coff->hdr, 1, AOUTSZ, abfd); + AOUTHDR buff; + bfd_swap_aouthdr_out(abfd, &internal_a, &buff); + bfd_write((PTR) &buff, 1, AOUTSZ, abfd); } return true; } @@ -1424,24 +1690,6 @@ coff_set_section_contents(abfd, section, location, offset, count) return true; } -static boolean -coff_get_section_contents(abfd, section, location, offset, count) - bfd *abfd; - sec_ptr section; - PTR 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; @@ -1488,12 +1736,13 @@ buy_and_read(abfd, where, seek_direction, size) } /* buy_and_read() */ static void -offset_symbol_indices(symtab, count, offset) - SYMENT *symtab; - unsigned long count; - long offset; +DEFUN(offset_symbol_indices,(abfd, symtab, count, offset), + bfd *abfd AND + struct internal_syment *symtab AND + unsigned long count AND + long offset) { - SYMENT *end = symtab + count; + struct internal_syment *end = symtab + count; for (; symtab < end; ++symtab) { if (symtab->n_sclass == C_FILE) { symtab->n_value = 0; @@ -1502,14 +1751,13 @@ offset_symbol_indices(symtab, count, offset) /* These guys have indices in their values. */ - symtab->n_value += offset; - + symtab->n_value = 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) @@ -1517,11 +1765,11 @@ offset_symbol_indices(symtab, count, offset) || BTYPE(symtab->n_type) == T_ENUM) { /* If the tagndx is 0 then the struct hasn't really been defined, so leave it alone */ - - if(((AUXENT *) (symtab + 1))->x_sym.x_tagndx != 0) { - ((AUXENT *) (symtab + 1))->x_sym.x_tagndx += offset; + + if(((union internal_auxent *) (symtab + 1))->x_sym.x_tagndx != 0) { + ((union internal_auxent *) (symtab + 1))->x_sym.x_tagndx += offset; } - + } /* These guys have a tagndx */ if (symtab->n_sclass == C_STRTAG || symtab->n_sclass == C_UNTAG @@ -1529,268 +1777,212 @@ offset_symbol_indices(symtab, count, offset) || 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; - + + ((union internal_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; + ((union internal_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 */ +#if 0 +/* swap the entire symbol table - we c*/ static void swap_raw_symtab(abfd, raw_symtab) - bfd *abfd; - SYMENT *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, - (AUXENT *)(raw_symtab + 1), - raw_symtab->n_type, - raw_symtab->n_sclass); - } /* swap all the aux entries */ + bfd_coff_swap_sym(abfd, raw_symtab); + + for (i = raw_symtab->n_numaux; i; --i, ++raw_symtab) { + bfd_coff_swap_aux(abfd, + (AUXENT *)(raw_symtab + 1), + raw_symtab->n_type, + raw_symtab->n_sclass); + } /* swap all the aux entries */ } /* walk the symbol table */ - + return; -} /* swap_raw_symtab() */ - + } /* swap_raw_symtab() */ +#endif /* - 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. +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; +static struct internal_syment * +DEFUN(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; - - 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 *) bfd_alloc(abfd, 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 *) bfd_alloc(abfd, size)) == NULL) { - bfd_error = no_memory; - return (NULL); - } /* on malloc error */ - } - else { - unsigned long namelength = 0; - CONST char *filename; - obj_symbol_slew(abfd) = 2; - - if ((retval = (SYMENT *) bfd_alloc(abfd, 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) bfd_alloc(abfd, 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; - retval->n_value = 2; /* Say that externals follow */ - -#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) bfd_alloc(abfd, namelength+1)) == 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. */ - - - - 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 = (PTR) bfd_alloc(abfd, ++i)) == NULL) { - bfd_error = no_memory; - return (NULL); - } /* on error */ - bzero(newstring, i); - strncpy(newstring, s->n_name, i-1); - s->n_offset = (int) newstring; - s->n_zeroes = 0; + struct internal_syment *internal; + struct internal_syment *internal_ptr; + struct internal_syment *internal_end; + SYMENT *raw; + SYMENT *raw_src; + SYMENT *raw_end; + char *string_table = NULL; + unsigned long size; + char string_table_size_buffer[4]; + unsigned long string_table_size = 0; + unsigned int raw_size; + if (obj_raw_syments(abfd) != (struct internal_syment *)NULL) { + return obj_raw_syments(abfd); + } + if ((size = bfd_get_symcount(abfd) * sizeof(struct internal_syment)) == 0) { + bfd_error = no_symbols; + return (NULL); + } - } - 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. - */ + internal = (struct internal_syment *)bfd_alloc(abfd, size); + internal_end = internal + bfd_get_symcount(abfd); - 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 = (PTR) bfd_alloc(abfd, 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 */ + raw_size = bfd_get_symcount(abfd) * SYMESZ; + raw = (SYMENT *)bfd_alloc(abfd,raw_size); - 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 (bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET) == -1 + || bfd_read((PTR)raw, raw_size, 1, abfd) != raw_size) { + bfd_error = system_call_error; + return (NULL); + } + /* mark the end of the symbols */ + raw_end = raw + 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. */ - 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; + /* Swap all the raw entries */ + for (raw_src = raw, internal_ptr = internal; raw_src < raw_end; raw_src++, internal_ptr++) { + unsigned int i; + bfd_coff_swap_sym_in(abfd, raw_src,internal_ptr); + for (i = internal_ptr->n_numaux; i; --i, raw_src++, internal_ptr++) { + bfd_coff_swap_aux_in(abfd, (AUXENT *)(raw_src +1), internal_ptr->n_type, + internal_ptr->n_sclass, (union + internal_auxent *)(internal_ptr +1)); + } + } + + /* Free all the raw stuff */ + bfd_release(abfd, raw_src); + for (internal_ptr = internal; internal_ptr < internal_end; internal_ptr ++) { - } /* if we added a C_FILE */ + if (internal_ptr->_n._n_n._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 (internal_ptr->_n._n_name[i] == '\0') { + break; + } /* if end of string */ + } /* possible lengths of this string. */ + + if ((newstring = (PTR) bfd_alloc(abfd, ++i)) == NULL) { + bfd_error = no_memory; + return (NULL); + } /* on error */ + bzero(newstring, i); + strncpy(newstring, internal_ptr->_n._n_name, i-1); + internal_ptr->_n._n_n._n_offset = (int) newstring; + internal_ptr->_n._n_n._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_buffer, + sizeof(string_table_size_buffer), + 1, abfd) != sizeof(string_table_size)) { + bfd_error = system_call_error; + return (NULL); + } /* on error */ + + string_table_size = bfd_h_getlong(abfd, string_table_size_buffer); + + if ((string_table = (PTR) bfd_alloc(abfd, 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. + */ + internal_ptr->_n._n_n._n_offset = (int) (string_table - 4 + internal_ptr->_n._n_n._n_offset); + } /* switch on type of symbol name */ + + internal_ptr += internal_ptr->n_numaux; + } /* for each symbol */ +#if 0 #ifndef GNU960 - /* I'm not sure of the repercussions of this, so the Intel - folks will always do the force - */ - if (obj_symbol_slew(abfd) > 0) - force_indices_file_symbol_relative(abfd, retval); + /* I'm not sure of the repercussions of this, so the Intel + folks will always do the force + */ + if (obj_symbol_slew(abfd) > 0) + force_indices_file_symbol_relative(abfd, internal); #else - force_indices_file_symbol_relative(abfd, retval); + force_indices_file_symbol_relative(abfd, internal); #endif - - obj_raw_syments(abfd) = retval; - obj_string_table(abfd) = string_table; - - return (retval); +#endif + obj_raw_syments(abfd) = internal; + obj_string_table(abfd) = string_table; + + return (internal); } /* get_normalized_symtab() */ static struct sec * -section_from_bfd_index(abfd, index) - bfd *abfd; - int index; +DEFUN(section_from_bfd_index,(abfd, index), + bfd *abfd AND + int index) { - if (index > 0) { - struct sec *answer = abfd->sections; - while (--index) { - answer = answer->next; - } - return answer; + if (index > 0) { + struct sec *answer = abfd->sections; + while (--index) { + answer = answer->next; } - return 0; + return answer; + } + return 0; } @@ -1798,456 +1990,454 @@ section_from_bfd_index(abfd, index) static boolean coff_slurp_line_table(abfd, asect) - bfd *abfd; - asection *asect; -{ - struct lineno *native_lineno; +bfd *abfd; +asection *asect; + { + 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)); + + native_lineno = (LINENO *) buy_and_read(abfd, + asect->line_filepos, + SEEK_SET, + (size_t) (LINESZ * + asect->lineno_count)); lineno_cache = - (alent *) bfd_alloc(abfd, (size_t) ((asect->lineno_count + 1) * sizeof(alent))); + (alent *) bfd_alloc(abfd, (size_t) ((asect->lineno_count + 1) * sizeof(alent))); if (lineno_cache == NULL) { - bfd_error = no_memory; - return false; + bfd_error = no_memory; + return false; } else { - 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++; + unsigned int counter = 0; + alent *cache_ptr = lineno_cache; + LINENO *src = native_lineno; + + while (counter < asect->lineno_count) { + struct internal_lineno dst; + bfd_coff_swap_lineno_in(abfd, src, &dst); + cache_ptr->line_number = dst.l_lnno; + + if (cache_ptr->line_number == 0) { + coff_symbol_type *sym = + (coff_symbol_type *) (dst.l_addr.l_symndx + + obj_symbol_slew(abfd) + + obj_raw_syments(abfd))->_n._n_n._n_zeroes; + cache_ptr->u.sym = (asymbol *) sym; + sym->lineno = cache_ptr; } - cache_ptr->line_number = 0; - + else { + cache_ptr->u.offset = dst.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; + } asect->lineno = lineno_cache; /* FIXME, free native_lineno here, or use alloca or something. */ return true; -} /* coff_slurp_line_table() */ + } /* coff_slurp_line_table() */ -static SYMENT * -find_next_file_symbol(current, end) - SYMENT *current; - SYMENT *end; +static struct internal_syment * +DEFUN(find_next_file_symbol,(abfd, current, end), + bfd *abfd AND + struct internal_syment *current AND + struct internal_syment *end) { current += current->n_numaux + 1; - + while (current < end) { - if (current->n_sclass == C_FILE) { + if (current->n_sclass== C_FILE) { return (current); } current += current->n_numaux + 1; } - return end; } /* - Note that C_FILE symbols can, and some do, have more than 1 aux entry. +Note that C_FILE symbols can, and some do, have more than 1 aux entry. */ static void DEFUN(force_indices_file_symbol_relative,(abfd, symtab), bfd *abfd AND - SYMENT *symtab) + struct internal_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); - - 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() */ + struct internal_syment *end = symtab + bfd_get_symcount(abfd); + struct internal_syment *current; + struct internal_syment *next; + /* the first symbol had damn well better be a C_FILE. */ + BFD_ASSERT(symtab->n_sclass == C_FILE); + + for (current = find_next_file_symbol(abfd, symtab, end); + current < end; + current = next) { + offset_symbol_indices(abfd, current, + ((next = + find_next_file_symbol(abfd, current, + end)) - current), + symtab - current); + } + return; +} static boolean -coff_slurp_symbol_table(abfd) - bfd *abfd; -{ - SYMENT *native_symbols; +DEFUN(coff_slurp_symbol_table,(abfd), + bfd *abfd) + { + struct internal_syment *native_symbols; coff_symbol_type *cached_area; unsigned int *table_ptr; - + unsigned int number_of_symbols = 0; if (obj_symbols(abfd)) - return true; + 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); + return (false); } /* on error */ - - + + /* Allocate enough room for all the symbols in cached form */ cached_area = - (coff_symbol_type *) + (coff_symbol_type *) bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(coff_symbol_type))); - + if (cached_area == NULL) { - bfd_error = no_memory; - return false; + bfd_error = no_memory; + return false; } /* on error */ table_ptr = - (unsigned int *) + (unsigned int *) bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(unsigned int))); - + if (table_ptr == NULL) { - bfd_error = no_memory; - return false; + bfd_error = no_memory; + return false; } else { - 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 + 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) { + struct internal_syment *src = native_symbols + this_index; + table_ptr[this_index] = number_of_symbols; + dst->symbol.the_bfd = abfd; + + dst->symbol.name = (char *)(src->_n._n_n._n_offset); + /* + 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) { + src->_n._n_n._n_zeroes = (int) dst; + dst->symbol.section = section_from_bfd_index(abfd, + src->n_scnum); + switch (src->n_sclass) { #ifdef I960 - case C_LEAFEXT: + 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; + 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 */ - + /* 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 */ + + case C_EXT: + if ((src->n_scnum) == 0) { + if ((src->n_value) == 0) { + dst->symbol.flags = BSF_UNDEFINED; + dst->symbol.value= 0; + } + 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 */ + 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 */ + 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 */ + 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 */ + 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: + + 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; + coff_slurp_line_table(abfd, p); + p = p->next; } - } + } return true; -} /* coff_slurp_symbol_table() */ + } /* coff_slurp_symbol_table() */ static unsigned int coff_get_symtab_upper_bound(abfd) - bfd *abfd; -{ +bfd *abfd; + { if (!coff_slurp_symbol_table(abfd)) - return 0; - + return 0; + return (bfd_get_symcount(abfd) + 1) * (sizeof(coff_symbol_type *)); -} + } static unsigned int coff_get_symtab(abfd, alocation) - bfd *abfd; - asymbol **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; - + return 0; + for (symbase = obj_symbols(abfd); counter++ < bfd_get_symcount(abfd);) - *(location++) = symbase++; + *(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; +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 *); } - 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 *) - bfd_alloc(abfd, (size_t) (asect->reloc_count * sizeof(arelent))); - - if (reloc_cache == NULL) { - bfd_error = no_memory; - return false; - } { /* 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. +DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols), + bfd *abfd AND + sec_ptr asect AND + asymbol **symbols) + { + 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 = + (RELOC *) buy_and_read(abfd, + asect->rel_filepos, + SEEK_SET, + (size_t) (RELSZ * + asect->reloc_count)); + reloc_cache = (arelent *) + bfd_alloc(abfd, (size_t) (asect->reloc_count * sizeof(arelent))); + + if (reloc_cache == NULL) { + bfd_error = no_memory; + return false; + } { /* on error */ + arelent *cache_ptr; + RELOC *src; + for (cache_ptr = reloc_cache, + src = native_relocs; + cache_ptr < reloc_cache + asect->reloc_count; + cache_ptr++, + src++) { + struct internal_reloc dst; + asymbol *ptr; + bfd_swap_reloc_in(abfd, src, &dst); + dst.r_symndx += obj_symbol_slew(abfd); + cache_ptr->sym_ptr_ptr = symbols + obj_convert(abfd)[dst.r_symndx]; + + ptr = *(cache_ptr->sym_ptr_ptr); + cache_ptr->address = dst.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. + + Note that symbols which used to be common must be left alone + */ + + if (ptr->the_bfd == abfd + && ptr->section != (asection *) NULL + && ((ptr->flags & BSF_OLD_COMMON)== 0)) + { + cache_ptr->addend = -(ptr->section->vma + ptr->value); + } + else { + cache_ptr->addend = 0; + } + + cache_ptr->address -= asect->vma; + + cache_ptr->section = (asection *) NULL; - Note that symbols which used to be common must be left alone - */ - - if (ptr->the_bfd == abfd - && ptr->section != (asection *) NULL - && ((ptr->flags & BSF_OLD_COMMON)== 0)) - { - cache_ptr->addend = -(ptr->section->vma + ptr->value); - } - 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; - cache_ptr->addend += src->r_offset << 16; - } - else { - BFD_ASSERT(0); - } + cache_ptr->howto = howto_table + dst.r_type; #endif #if M68 - cache_ptr->howto = howto_table + src->r_type; + cache_ptr->howto = howto_table + dst.r_type - R_RELBYTE; #endif - +#if M88 + if (dst.r_type >= R_PCR16L && dst.r_type <= R_VRT32) { + cache_ptr->howto = howto_table + dst.r_type - R_PCR16L; + cache_ptr->addend += dst.r_offset << 16; + } + else { + BFD_ASSERT(0); + } +#endif + + } + } - + + asect->relocation = reloc_cache; + return true; } - 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; -{ +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; + return 0; tblptr = section->relocation; if (!tblptr) - return 0; - + return 0; + for (; count++ < section->reloc_count;) - *relptr++ = tblptr++; - + *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. +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 @@ -2271,65 +2461,65 @@ DEFUN(coff_find_nearest_line,(abfd, 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; + struct internal_syment *p; alent *l; unsigned int line_base = 0; - - + + *filename_ptr = 0; *functionname_ptr = 0; *line_ptr = 0; - + /* Don't try and find line numbers in a non coff file */ if (abfd->xvec->flavour != bfd_target_coff_flavour_enum) return false; - + if (cof == (struct icofdata *)NULL) return false; - + p = cof->raw_syments; /* - 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. - */ - + 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. - */ - + 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; + 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 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) { @@ -2340,23 +2530,23 @@ DEFUN(coff_find_nearest_line,(abfd, 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; + struct internal_syment *s = coff->native; s = s + 1 + s->n_numaux; /* - S should now point to the .bf of the function - */ + 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); + The linenumber is stored in the auxent + */ + union internal_auxent *a = (union internal_auxent *) (s + 1); line_base = a->x_sym.x_misc.x_lnsz.x_lnno; } } @@ -2368,7 +2558,7 @@ DEFUN(coff_find_nearest_line,(abfd, } l++; } - + cache_abfd = abfd; cache_section = section; cache_offset = offset; @@ -2381,9 +2571,9 @@ DEFUN(coff_find_nearest_line,(abfd, file_ptr coff_sym_filepos(abfd) bfd *abfd; -{ -return obj_sym_filepos(abfd); -} + { + return obj_sym_filepos(abfd); + } #endif @@ -2391,26 +2581,28 @@ static int DEFUN(coff_sizeof_headers,(abfd, reloc), bfd *abfd AND boolean reloc) -{ - size_t size; - - if (reloc == false) { - size = sizeof(struct filehdr) + sizeof(AOUTHDR); - } - else { - size = sizeof(struct filehdr); + { + size_t size; + + if (reloc == false) { + size = FILHSZ + AOUTSZ; + } + else { + size = FILHSZ; + } + + size += abfd->section_count * SCNHSZ; + return size; } - size += abfd->section_count * SCNHSZ; - return size; -} - -#define coff_core_file_failing_command _bfd_dummy_core_file_failing_command -#define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal -#define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p -#define coff_slurp_armap bfd_slurp_coff_armap -#define coff_slurp_extended_name_table _bfd_slurp_extended_name_table -#define coff_truncate_arname bfd_dont_truncate_arname -#define coff_openr_next_archived_file bfd_generic_openr_next_archived_file -#define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt +#define coff_core_file_failing_command _bfd_dummy_core_file_failing_command +#define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal +#define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p +#define coff_slurp_armap bfd_slurp_coff_armap +#define coff_slurp_extended_name_table _bfd_slurp_extended_name_table +#define coff_truncate_arname bfd_dont_truncate_arname +#define coff_openr_next_archived_file bfd_generic_openr_next_archived_file +#define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt +#define coff_get_section_contents bfd_generic_get_section_contents +#define coff_close_and_cleanup bfd_generic_close_and_cleanup