From: Steve Chamberlain Date: Fri, 10 May 1991 19:33:37 +0000 (+0000) Subject: Fixed all the places where there were problems with the size and X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=e5b919b168780f68a70efc886a3d2fab15113f28;p=binutils-gdb.git Fixed all the places where there were problems with the size and alignments of structures on disk and structures in memory. #ifed out all the code in coffswap.c, since it should be done using the target swap routines now. --- diff --git a/bfd/coff-code.h b/bfd/coff-code.h index 0f8eee7d7ee..41a0f7942b1 100755 --- a/bfd/coff-code.h +++ b/bfd/coff-code.h @@ -40,27 +40,42 @@ 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)); +PROTO(static void,force_indices_file_symbol_relative,(bfd *abfd, + struct internal_syment *symtab)); /* 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), + +static void +DEFUN(swap_reloc_in,(abfd, reloc_src, reloc_dst), bfd *abfd AND - RELOC *reloc) + RELOC *reloc_src AND + struct internal_reloc *reloc_dst) { - sp(reloc->r_vaddr); - sp(reloc->r_symndx); - sp(reloc->r_type); + 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 } +static void +DEFUN(swap_reloc_out,(abfd, reloc_src, reloc_dst), + bfd *abfd AND + struct internal_reloc *reloc_src AND + struct external_reloc *reloc_dst) +{ + 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 + +} static void DEFUN(swap_filehdr,(abfd, filehdr), @@ -78,6 +93,186 @@ DEFUN(swap_filehdr,(abfd, filehdr), } + +static void +DEFUN(bfd_coff_swap_name_in,(abfd, ptr), + bfd *abfd AND + long *ptr) +{ + if (ptr[0] == 0) { + /* There is an index which needs to be swapped */ + bfd_h_put_x(abfd, ptr[1], (ptr + 1)); + } + else { + /* This is a string .. leave it alone */ + } +} + +static 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); +} + +static 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(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); + } + } +} + +static 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); + } + } +} + +static 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); +} + +static void +DEFUN(bfd_coff_swap_lineno_out,(abfd, in, ext), + bfd *abfd AND + 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); +} + + + + static void DEFUN(swap_aouthdr,(abfd, aouthdr), bfd *abfd AND @@ -150,6 +345,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; } @@ -297,7 +495,7 @@ DEFUN(coff_real_object_p,(abfd, nscns, opthdr), switch (filehdr->f_magic) { #ifdef MC68MAGIC case MC68MAGIC: - case MC68DMAGIC: + case M68MAGIC: abfd->obj_arch = bfd_arch_m68k; abfd->obj_machine = 68020; break; @@ -484,8 +682,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; @@ -536,11 +735,11 @@ 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; @@ -556,31 +755,32 @@ bfd *bfd_ptr; 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 { /* Normalize the symbol flags */ if (coff_symbol_ptr->symbol.flags & BSF_FORT_COMM) { /* a common symbol is undefined with a value */ - syment->n_scnum = N_UNDEF; - syment->n_value = coff_symbol_ptr->symbol.value; + syment->n_scnum = N_UNDEF; + syment->n_value = coff_symbol_ptr->symbol.value; } else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) { syment->n_value = coff_symbol_ptr->symbol.value; } else if (coff_symbol_ptr->symbol.flags & BSF_UNDEFINED) { - syment->n_scnum = N_UNDEF; - syment->n_value = 0; + syment->n_scnum = N_UNDEF; + syment->n_value = 0; } else if (coff_symbol_ptr->symbol.flags & BSF_ABSOLUTE) { syment->n_scnum = N_ABS; 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 + @@ -590,9 +790,9 @@ bfd *bfd_ptr; /* 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 @@ -601,70 +801,67 @@ bfd *bfd_ptr; || syment->n_sclass == C_LEAFSTAT #endif ) - && last_fcn != (SYMENT *)NULL) + && last_fcn != (struct internal_syment *)NULL) { - AUXENT *auxent = (AUXENT *)(last_fcn+1); + union internal_auxent *auxent = (union internal_auxent *)(last_fcn+1); auxent->x_sym.x_fcnary.x_fcn.x_endndx = native_index; - last_fcn = (SYMENT *)NULL; + last_fcn = (struct internal_syment *)NULL; } - else if (syment->n_sclass == C_EOS && last_tagndx != (SYMENT*)NULL) + else if (syment->n_sclass == C_EOS && last_tagndx != (struct internal_syment*)NULL) { - AUXENT *auxent = (AUXENT *)(last_tagndx+1); + 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_offset; - auxent->x_sym.x_fcnary.x_fcn.x_endndx = - native_index + syment->n_numaux + 1 ; + 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 = (AUXENT *)(syment+1); - auxent->x_sym.x_tagndx = last_tagndx->n_offset; - - + 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; + 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 && + bfd_h_get_x(bfd_ptr, &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) { @@ -672,28 +869,29 @@ 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)) { last_fcn = syment; } - if (syment->n_sclass == C_BLOCK + if (bfd_h_get_x(bfd_ptr, & 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,445 +901,449 @@ bfd *bfd_ptr; static void coff_write_symbols(abfd) - bfd *abfd; -{ - unsigned int i; - unsigned int limit = bfd_get_symcount(abfd); - unsigned int written = 0; - SYMENT dummy; - asymbol **p; - unsigned int string_size = 0; - - - /* Seek to the right place */ - bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET); - - /* Output all the symbols we have */ - - written = 0; - for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) { - asymbol *symbol = *p; - coff_symbol_type *c_symbol = coff_symbol_from(abfd, symbol); - - unsigned int j; - SYMENT *native; - if (c_symbol == (coff_symbol_type *) NULL || - c_symbol->native == (SYMENT *) NULL) { - /* - This symbol has been created by the loader, or come from a non - coff format. It has no native element to inherit, make our - own - */ - - native = &dummy; - native->n_type = T_NULL; -#ifdef I960 - native->n_flags = 0; -#endif - if (symbol->flags & BSF_ABSOLUTE) { - native->n_scnum = N_ABS; - native->n_value = symbol->value; - } - else if (symbol->flags & (BSF_UNDEFINED | BSF_FORT_COMM)) { - native->n_scnum = N_UNDEF; - native->n_value = symbol->value; - } - else if (symbol->flags & BSF_DEBUGGING) { - /* - remove name so it doesn't take up any space - */ - symbol->name = ""; -#if 0 /* FIXME -- Steve hasn't decided what to do - with these */ +bfd *abfd; + { + unsigned int i; + unsigned int limit = bfd_get_symcount(abfd); + unsigned int written = 0; + 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; + struct internal_syment *native; + if (c_symbol == (coff_symbol_type *) NULL || + c_symbol->native == (struct internal_syment *) NULL) { /* - Don't do anything with debugs from the loader - */ - native->n_scnum = N_DEBUG; -#endif - continue; - } - else { - native->n_scnum = symbol->section->output_section->index + 1; - native->n_value = symbol->value + - symbol->section->output_section->vma + - symbol->section->output_offset; + 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; #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; - } + native->n_flags = 0; +#endif + if (symbol->flags & BSF_ABSOLUTE) { + native->n_scnum = N_ABS; + native->n_value = symbol->value; + } + else if (symbol->flags & (BSF_UNDEFINED | BSF_FORT_COMM)) { + native->n_scnum = N_UNDEF; + native->n_value = symbol->value; + } + else if (symbol->flags & BSF_DEBUGGING) { + /* + remove name so it doesn't take up any space + */ + symbol->name = ""; + continue; } + else { + native->n_scnum = symbol->section->output_section->index + + 1; + native->n_value = symbol->value + + symbol->section->output_section->vma + + symbol->section->output_offset; +#ifdef I960 + /* 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; + } + } #endif } - - - + #ifdef HASPAD1 - native->pad1[0] = 0; - native->pad1[0] = 0; + 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; - } - 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; + 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 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; + + } + } /* 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"; } - /* - 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++; + 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); } - c_symbol->symbol.section->output_section->moving_line_filepos += - count * sizeof(struct lineno); - + 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 != bfd_h_get_x(abfd, &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; + } } - } /* 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); - + } /* for each out symbol */ + + bfd_get_symcount(abfd) = written; + /* Now write out strings */ + + if (string_size) { + unsigned int size = string_size + 4; + size = size; + bfd_write((PTR) &size, 1, sizeof(size), abfd); + for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) { + asymbol *q = *p; + size_t name_length = strlen(q->name); + if (name_length > SYMNMLEN) { + bfd_write((PTR) (q->name), 1, name_length + 1, abfd); } - /* - Reuse somewhere in the symbol to keep the index - */ - set_index(symbol, written); - written += 1 + numaux; } } - } /* for each out symbol */ - - bfd_get_symcount(abfd) = written; - /* Now write out strings */ - - if (string_size) { - unsigned int size = string_size + 4; - bfd_h_put_x(abfd, size, &size); - bfd_write((PTR) &size, 1, sizeof(size), abfd); - for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) { - asymbol *q = *p; - size_t name_length = strlen(q->name); - if (name_length > SYMNMLEN) { - bfd_write((PTR) (q->name), 1, name_length + 1, abfd); - } + else { + /* We would normally not write anything here, but we'll write + out 4 so that any stupid coff reader which tries to read + the string table even when there isn't one won't croak. + */ + + uint32e_type size = 4; + size = size; + bfd_write((PTR)&size, 1, sizeof(size), abfd); + } + } - else { - /* We would normally not write anything here, but we'll write - out 4 so that any stupid coff reader which tries to read - the string table even when there isn't one won't croak. - */ - - uint32e_type size = 4; - bfd_h_put_x(abfd, size, &size); - bfd_write((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 + swap_reloc_out(abfd, &n, &dst); + bfd_write((PTR) &n, 1, RELSZ, abfd); + } } -} + } static void coff_write_linenumbers(abfd) - bfd *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 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,138 +1352,138 @@ coff_compute_section_file_positions(abfd) /* SUPPRESS 529 */ static boolean coff_write_object_contents(abfd) - bfd *abfd; -{ - struct filehdr file_header; - asection *current; - boolean hasrelocs = false; - boolean haslinno = false; - file_ptr reloc_base; - file_ptr lineno_base; - file_ptr sym_base; - file_ptr scn_base; - file_ptr data_base; - unsigned long reloc_size = 0; - unsigned long lnno_size = 0; - asection *text_sec = NULL; - asection *data_sec = NULL; - asection *bss_sec = NULL; - unsigned magic, - - flags; - - 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; - } - else { - scn_base = 0; - } - if (bfd_seek(abfd, scn_base, SEEK_SET) != 0) - return false; - reloc_base = obj_relocbase(abfd); - - /* Make a pass through the symbol table to count line number entries and - put them into the correct asections */ - - coff_count_linenumbers(abfd); - data_base = scn_base; - - /* Work out the size of the reloc and linno areas */ - - for (current = abfd->sections; current != NULL; current = current->next) { - reloc_size += current->reloc_count * sizeof(struct reloc); - lnno_size += current->lineno_count * sizeof(struct lineno); - data_base += sizeof(struct scnhdr); - } - - lineno_base = reloc_base + reloc_size; - sym_base = lineno_base + lnno_size; - - /* Indicate in each section->line_filepos its actual file address */ - for (current = abfd->sections; current != NULL; current = current->next) { - if (current->lineno_count) { - current->line_filepos = lineno_base; - current->moving_line_filepos = lineno_base; - lineno_base += current->lineno_count * sizeof(struct lineno); - } - else { - current->line_filepos = 0; +bfd *abfd; + { + struct filehdr file_header; + asection *current; + boolean hasrelocs = false; + boolean haslinno = false; + file_ptr reloc_base; + file_ptr lineno_base; + file_ptr sym_base; + file_ptr scn_base; + file_ptr data_base; + unsigned long reloc_size = 0; + unsigned long lnno_size = 0; + asection *text_sec = NULL; + asection *data_sec = NULL; + asection *bss_sec = NULL; + unsigned magic, + + flags; + + struct icofdata *coff = obj_icof(abfd); + + + bfd_error = system_call_error; + + + if(abfd->output_has_begun == false) { + coff_compute_section_file_positions(abfd); } - if (current->reloc_count) { - current->rel_filepos = reloc_base; - reloc_base += current->reloc_count * sizeof(struct reloc); + + if (abfd->sections != (asection *)NULL) { + scn_base = abfd->sections->filepos; } else { - current->rel_filepos = 0; + scn_base = 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; -#endif - unsigned int pad = 0; - + if (bfd_seek(abfd, scn_base, SEEK_SET) != 0) + return false; + reloc_base = obj_relocbase(abfd); + + /* Make a pass through the symbol table to count line number entries and + put them into the correct asections */ + + coff_count_linenumbers(abfd); + data_base = scn_base; + + /* Work out the size of the reloc and linno areas */ + for (current = abfd->sections; current != NULL; current = current->next) { - 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; - + 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 * LINESZ; } 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 */ + current->line_filepos = 0; } - else if (!strcmp(current->name, _DATA)) { - data_sec = current; - section.s_flags = STYP_DATA; /* kinda stupid */ + if (current->reloc_count) { + current->rel_filepos = reloc_base; + reloc_base += current->reloc_count * sizeof(struct internal_reloc); } - else if (!strcmp(current->name, _BSS)) { - bss_sec = current; - section.s_flags = STYP_BSS; /* kinda stupid */ + 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; +#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 */ + } + + #ifdef I960 - section.s_align = (current->alignment_power + section.s_align = (current->alignment_power ? 1 << current->alignment_power : 0); @@ -1466,28 +1668,29 @@ 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; + if (bfd_h_get_x(abfd, &symtab->n_sclass) == C_FILE) { + bfd_h_put_x(abfd, 0, & symtab->n_value); } - else if (symtab->n_sclass == C_ALIAS) { + else if (bfd_h_get_x(abfd, &symtab->n_sclass) == C_ALIAS) { /* These guys have indices in their values. */ - symtab->n_value += offset; - + bfd_h_put_x(abfd, bfd_h_get_x(abfd, & symtab->n_value) + offset, & symtab->n_value); + } 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) @@ -1495,281 +1698,224 @@ 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 || symtab->n_sclass == C_ENTAG || symtab->n_sclass == C_BLOCK || symtab->n_sclass == C_FCN - || ISFCN(symtab->n_type)) { - - ((AUXENT *) (symtab + 1))->x_sym.x_fcnary.x_fcn.x_endndx += offset; - + || ISFCN(bfd_h_get_x(abfd, &symtab->n_type))) { + + ((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; + if (ISFCN(bfd_h_get_x(abfd,& symtab->n_type))) { + ((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; + symtab += bfd_h_get_x(abfd, &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((char *)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((char *)(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; } @@ -1777,456 +1923,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; + 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 @@ -2250,65 +2394,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) { + if (bfd_h_get_x(abfd, &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 + bfd_h_get_x(abfd, & 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) { @@ -2319,24 +2463,24 @@ 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); - line_base = a->x_sym.x_misc.x_lnsz.x_lnno; + The linenumber is stored in the auxent + */ + union internal_auxent *a = (union internal_auxent *) (s + 1); + line_base = bfd_h_get_x(abfd, &a->x_sym.x_misc.x_lnsz.x_lnno); } } } @@ -2347,7 +2491,7 @@ DEFUN(coff_find_nearest_line,(abfd, } l++; } - + cache_abfd = abfd; cache_section = section; cache_offset = offset; @@ -2360,9 +2504,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 @@ -2370,20 +2514,20 @@ 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 = sizeof(struct filehdr) + sizeof(AOUTHDR); + } + else { + size = sizeof(struct filehdr); + } + + 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 diff --git a/bfd/coff-i960.c b/bfd/coff-i960.c index 4768104361d..b80c80dd054 100644 --- a/bfd/coff-i960.c +++ b/bfd/coff-i960.c @@ -53,7 +53,7 @@ asection *ignore_input_section; /* So the target symbol has to be of coff type, and the symbol has to have the correct native information within it */ if ((cs->symbol.the_bfd->xvec->flavour != bfd_target_coff_flavour_enum) - || (cs->native == (struct syment *)NULL)) { + || (cs->native == (struct internal_syment *)NULL)) { /* This is interesting, consider the case where we're outputting */ /* coff from a mix n match input, linking from coff to a symbol */ /* defined in a bout file will cause this match to be true. Should */ @@ -62,22 +62,23 @@ asection *ignore_input_section; result = bfd_reloc_dangerous; } else { - switch (cs->native->n_sclass) + switch (bfd_h_get_x(abfd, & cs->native->n_sclass)) { case C_LEAFSTAT: case C_LEAFEXT: /* This is a call to a leaf procedure, replace instruction with a bal to the correct location */ { - union auxent *aux = (union auxent *)(cs->native+2); + AUXENT *aux = (AUXENT *)(cs->native+2); int word = bfd_getlong(abfd, data + reloc_entry->address); - BFD_ASSERT(cs->native->n_numaux==2); + BFD_ASSERT(bfd_h_get_x(abfd, &cs->native->n_numaux)==2); /* We replace the original call instruction with a bal to */ /* the bal entry point - the offset of which is described in the */ /* 2nd auxent of the original symbol. We keep the native sym and */ /* auxents untouched, so the delta between the two is the */ /* offset of the bal entry point */ - word = ((word + (aux->x_bal.x_balntry - cs->native->n_value)) + word = ((word + (bfd_h_get_x(abfd, &aux->x_bal.x_balntry) - + bfd_h_get_x(abfd, &cs->native->n_value))) & BAL_MASK) | BAL; bfd_putlong(abfd, word, data+reloc_entry->address); } diff --git a/bfd/coffswap.c b/bfd/coffswap.c index eef2c960899..78aea536f60 100755 --- a/bfd/coffswap.c +++ b/bfd/coffswap.c @@ -26,15 +26,15 @@ You should have received a copy of the GNU General Public License along with #include "libcoff.h" /* to allow easier abstraction-breaking */ #define sp(x) bfd_h_put_x(abfd, x, &x) +#if 0 +/* All the generic swapping routines: -/* 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. */ +FIXME + These routines cater for the sizes and alignments and offsets of + all the contained fields. Because of this, the fields can change + size, so these should be phased out to use the ones specific to the + file format. + */ void DEFUN(bfd_coff_swap_name,(abfd, ptr), @@ -53,7 +53,7 @@ DEFUN(bfd_coff_swap_name,(abfd, ptr), void DEFUN(bfd_coff_swap_sym,(abfd, se), bfd *abfd AND - SYMENT *se) + struct internal_syment *se) { bfd_coff_swap_name(abfd, (long*)(se->n_name)); bfd_h_put_x(abfd, se->n_value, &se->n_value); @@ -66,7 +66,7 @@ DEFUN(bfd_coff_swap_sym,(abfd, se), void DEFUN(bfd_coff_swap_aux,(abfd, au, type, class), bfd *abfd AND - AUXENT *au AND + struct internal_auxent *au AND int type AND int class) { @@ -112,10 +112,12 @@ DEFUN(bfd_coff_swap_aux,(abfd, au, type, class), void DEFUN(bfd_coff_swap_lineno,(abfd, lineno), bfd *abfd AND - LINENO *lineno) + struct internal_lineno *lineno) { sp(lineno->l_addr.l_symndx); sp(lineno->l_lnno); } + +#endif diff --git a/bfd/libcoff.h b/bfd/libcoff.h index 67b9c987b81..f43927213d4 100644 --- a/bfd/libcoff.h +++ b/bfd/libcoff.h @@ -31,12 +31,16 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define obj_relocbase(bfd) (obj_icof(bfd)->relocbase) #define obj_raw_syments(bfd) (obj_icof(bfd)->raw_syments) #define obj_convert(bfd) (obj_icof(bfd)->conversion_table) +#if CFILE_STUFF #define obj_symbol_slew(bfd) (obj_icof(bfd)->symbol_index_slew) +#else +#define obj_symbol_slew(bfd) 0 +#endif #define obj_string_table(bfd) (obj_icof(bfd)->string_table) typedef struct { asymbol symbol; - struct syment *native; + struct internal_syment *native; struct lineno_cache_entry *lineno; } coff_symbol_type; @@ -50,7 +54,7 @@ typedef struct icofdata long symbol_index_slew; /* used during read to mark whether a C_FILE symbol as been added. */ - struct syment *raw_syments; + struct internal_syment *raw_syments; struct lineno *raw_linenos; unsigned int raw_syment_count; char *string_table;