#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));
+
+\f
+/* 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
}
-\f
-/* 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
}
/*
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;
}
static boolean
DEFUN(make_a_section_from_file,(abfd, hdr),
bfd *abfd AND
- struct scnhdr *hdr)
+ struct internal_scnhdr *hdr)
{
asection *return_section;
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)
return_section->flags |= SEC_HAS_CONTENTS;
return true;
}
-
static boolean
DEFUN(coff_mkobject,(abfd),
bfd *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;
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;
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:
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
-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);
-}
*/
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;
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;
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 {
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
|| 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) {
}
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)) {
}
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;
}
}
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;
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;
-}
+ }
/* 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;
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;
}
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
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
/* 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;
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;
}
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;
} /* 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;
/*
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)
|| 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_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;
}
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
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) {
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;
}
}
}
l++;
}
-
+
cache_abfd = abfd;
cache_section = section;
cache_offset = offset;
file_ptr
coff_sym_filepos(abfd)
bfd *abfd;
-{
-return obj_sym_filepos(abfd);
-}
+ {
+ return obj_sym_filepos(abfd);
+ }
#endif
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
projects / deliverable / binutils-gdb.git / blobdiff