diff --git a/bfd/ChangeLog b/bfd/ChangeLog index bb67edb097..9de6db3c21 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,30 @@ +Thu Sep 14 14:53:58 1995 Ian Lance Taylor + + Convert i960 COFF to use COFF backend linker. + * coff-i960.c (coff_i960_relocate): Use a coff_section_data + structure to store the symbol being used. + (coff_i960_start_final_link): New static function. + (coff_i960_relocate_section): New static function. + (coff_i960_adjust_symndx): New static function. + (coff_start_final_link): Define. + (coff_relocate_section): Define. + (coff_adjust_symndx): Define. + * coffcode.h (bfd_coff_backend_data): Add new callback function + _bfd_coff_start_final_link. + (bfd_coff_start_final_link): Define. + (coff_start_final_link): Define if not defined. + (bfd_coff_std_swap_table): Add coff_start_final_link. + * cofflink.c (_bfd_coff_internal_syment_name): Make globally + visible. + (_bfd_coff_final_link): Call bfd_coff_start_final_link if the + function callback is not NULL. + * libcoff-in.h (struct coff_section_tdata): Add tdata field. + (_bfd_coff_internal_syment_name): Declare. + * libcoff.h: Rebuild. + * configure.in (icoff_big_vec): Add cofflink.o. + (icoff_little_vec): Likewise. + * configure: Rebuild. + Wed Sep 13 17:38:23 1995 Fred Fish * Makefile.in (clean-info): Remove extraneous tab from line diff --git a/bfd/coff-i960.c b/bfd/coff-i960.c index fcc8754d9f..ece069747f 100644 --- a/bfd/coff-i960.c +++ b/bfd/coff-i960.c @@ -33,6 +33,16 @@ static bfd_reloc_status_type optcall_callback PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); static bfd_reloc_status_type coff_i960_relocate PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); +static reloc_howto_type *coff_i960_reloc_type_lookup + PARAMS ((bfd *, bfd_reloc_code_real_type)); +static boolean coff_i960_start_final_link + PARAMS ((bfd *, struct bfd_link_info *)); +static boolean coff_i960_relocate_section + PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, + struct internal_reloc *, struct internal_syment *, asection **)); +static boolean coff_i960_adjust_symndx + PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, + struct internal_reloc *, boolean *)); #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3) @@ -126,7 +136,14 @@ optcall_callback (abfd, reloc_entry, symbol_in, data, than adding their values into the object file. We handle this here by converting all relocs against defined symbols into relocs against the section symbol, when generating a relocateable output - file. */ + file. + + Note that this function is only called if we are not using the COFF + specific backend linker. It only does something when doing a + relocateable link, which will almost certainly fail when not + generating COFF i960 output, so this function is actually no longer + useful. It was used before this target was converted to use the + COFF specific backend linker. */ static bfd_reloc_status_type coff_i960_relocate (abfd, reloc_entry, symbol, data, input_section, @@ -161,11 +178,12 @@ coff_i960_relocate (abfd, reloc_entry, symbol, data, input_section, } /* Convert the reloc to use the section symbol. FIXME: This method - is ridiculous. Fortunately, we don't use the used_by_bfd field - in COFF. */ + is ridiculous. */ osec = bfd_get_section (symbol)->output_section; - if (osec->used_by_bfd != NULL) - reloc_entry->sym_ptr_ptr = (asymbol **) osec->used_by_bfd; + if (coff_section_data (output_bfd, osec) != NULL + && coff_section_data (output_bfd, osec)->tdata != NULL) + reloc_entry->sym_ptr_ptr = + (asymbol **) coff_section_data (output_bfd, osec)->tdata; else { const char *sec_name; @@ -178,16 +196,28 @@ coff_i960_relocate (abfd, reloc_entry, symbol, data, input_section, { if (bfd_asymbol_name (*syms) != NULL && (*syms)->value == 0 - && strcmp (!(*syms)->section->output_section->name, sec_name)) - { - osec->used_by_bfd = (PTR) syms; - reloc_entry->sym_ptr_ptr = syms; - break; - } + && strcmp ((*syms)->section->output_section->name, + sec_name) == 0) + break; } if (syms >= sym_end) abort (); + + reloc_entry->sym_ptr_ptr = syms; + + if (coff_section_data (output_bfd, osec) == NULL) + { + osec->used_by_bfd = + ((PTR) bfd_zalloc (abfd, + sizeof (struct coff_section_tdata))); + if (osec->used_by_bfd == NULL) + { + bfd_set_error (bfd_error_no_memory); + return bfd_reloc_overflow; + } + } + coff_section_data (output_bfd, osec)->tdata = (PTR) syms; } /* Let bfd_perform_relocation do its thing, which will include @@ -239,11 +269,308 @@ coff_i960_reloc_type_lookup (abfd, code) (cache_ptr)->howto = howto_ptr; \ } -#include "coffcode.h" +/* i960 COFF is used by VxWorks 5.1. However, VxWorks 5.1 does not + appear to correctly handle a reloc against a symbol defined in the + same object file. It appears to simply discard such relocs, rather + than adding their values into the object file. We handle this by + converting all relocs against global symbols into relocs against + internal symbols at the start of the section. This routine is + called at the start of the linking process, and it creates the + necessary symbols. */ + +static boolean +coff_i960_start_final_link (abfd, info) + bfd *abfd; + struct bfd_link_info *info; +{ + bfd_size_type symesz = bfd_coff_symesz (abfd); + asection *o; + bfd_byte *esym; + + if (! info->relocateable) + return true; + + esym = (bfd_byte *) malloc (symesz); + if (esym == NULL) + { + bfd_set_error (bfd_error_no_memory); + return false; + } + + if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0) + return false; + + for (o = abfd->sections; o != NULL; o = o->next) + { + struct internal_syment isym; + + strncpy (isym._n._n_name, o->name, SYMNMLEN); + isym.n_value = 0; + isym.n_scnum = o->target_index; + isym.n_type = T_NULL; + isym.n_sclass = C_STAT; + isym.n_numaux = 0; + + bfd_coff_swap_sym_out (abfd, (PTR) &isym, (PTR) esym); + + if (bfd_write (esym, symesz, 1, abfd) != symesz) + { + free (esym); + return false; + } + + obj_raw_syment_count (abfd) += 1; + } + + free (esym); + + return true; +} + +/* The reloc processing routine for the optimized COFF linker. */ + +static boolean +coff_i960_relocate_section (output_bfd, info, input_bfd, input_section, + contents, relocs, syms, sections) + bfd *output_bfd; + struct bfd_link_info *info; + bfd *input_bfd; + asection *input_section; + bfd_byte *contents; + struct internal_reloc *relocs; + struct internal_syment *syms; + asection **sections; +{ + struct internal_reloc *rel; + struct internal_reloc *relend; + + rel = relocs; + relend = rel + input_section->reloc_count; + for (; rel < relend; rel++) + { + long symndx; + struct coff_link_hash_entry *h; + struct internal_syment *sym; + bfd_vma addend; + bfd_vma val; + reloc_howto_type *howto; + bfd_reloc_status_type rstat = bfd_reloc_ok; + boolean done; + + symndx = rel->r_symndx; + + if (symndx == -1) + { + h = NULL; + sym = NULL; + } + else + { + h = obj_coff_sym_hashes (input_bfd)[symndx]; + sym = syms + symndx; + } + + if (sym != NULL && sym->n_scnum != 0) + addend = - sym->n_value; + else + addend = 0; + + switch (rel->r_type) + { + case 17: howto = &howto_rellong; break; + case 25: howto = &howto_iprmed; break; + case 27: howto = &howto_optcall; break; + default: + bfd_set_error (bfd_error_bad_value); + return false; + } + + val = 0; + + if (h == NULL) + { + asection *sec; + + if (symndx == -1) + { + sec = bfd_abs_section_ptr; + val = 0; + } + else + { + sec = sections[symndx]; + val = (sec->output_section->vma + + sec->output_offset + + sym->n_value + - sec->vma); + } + } + else + { + if (h->root.type == bfd_link_hash_defined + || h->root.type == bfd_link_hash_defweak) + { + asection *sec; + + sec = h->root.u.def.section; + val = (h->root.u.def.value + + sec->output_section->vma + + sec->output_offset); + } + else if (! info->relocateable) + { + if (! ((*info->callbacks->undefined_symbol) + (info, h->root.root.string, input_bfd, input_section, + rel->r_vaddr - input_section->vma))) + return false; + } + } + + done = false; + + if (howto->type == R_OPTCALL && ! info->relocateable && symndx != -1) + { + int class; + + if (h != NULL) + class = h->class; + else + class = sym->n_sclass; + + switch (class) + { + case C_NULL: + /* This symbol is apparently not from a COFF input file. + We warn, and then assume that it is not a leaf + function. */ + if (! ((*info->callbacks->reloc_dangerous) + (info, + "uncertain calling convention for non-COFF symbol", + input_bfd, input_section, + rel->r_vaddr - input_section->vma))) + return false; + break; + case C_LEAFSTAT: + case C_LEAFEXT: + /* This is a call to a leaf procedure; use the bal + instruction. */ + { + long olf; + unsigned long word; + + if (h != NULL) + { + BFD_ASSERT (h->numaux == 2); + olf = h->aux[1].x_bal.x_balntry; + } + else + { + bfd_byte *esyms; + union internal_auxent aux; + + BFD_ASSERT (sym->n_numaux == 2); + esyms = (bfd_byte *) obj_coff_external_syms (input_bfd); + esyms += (symndx + 2) * bfd_coff_symesz (input_bfd); + bfd_coff_swap_aux_in (input_bfd, (PTR) esyms, sym->n_type, + sym->n_sclass, 1, sym->n_numaux, + (PTR) &aux); + olf = aux.x_bal.x_balntry; + } + + word = bfd_get_32 (input_bfd, + (contents + + (rel->r_vaddr - input_section->vma))); + word = ((word + olf - val) & BAL_MASK) | BAL; + bfd_put_32 (input_bfd, + word, + (contents + + (rel->r_vaddr - input_section->vma))); + done = true; + } + break; + case C_SCALL: + BFD_ASSERT (0); + break; + } + } + + if (! done) + rstat = _bfd_final_link_relocate (howto, input_bfd, input_section, + contents, + rel->r_vaddr - input_section->vma, + val, addend); + + switch (rstat) + { + default: + abort (); + case bfd_reloc_ok: + break; + case bfd_reloc_overflow: + { + const char *name; + char buf[SYMNMLEN + 1]; + + if (symndx == -1) + name = "*ABS*"; + else if (h != NULL) + name = h->root.root.string; + else + { + name = _bfd_coff_internal_syment_name (input_bfd, sym, buf); + if (name == NULL) + return false; + } + + if (! ((*info->callbacks->reloc_overflow) + (info, name, howto->name, (bfd_vma) 0, input_bfd, + input_section, rel->r_vaddr - input_section->vma))) + return false; + } + } + } + + return true; +} + +/* Adjust the symbol index of any reloc against a global symbol to + instead be a reloc against the internal symbol we created specially + for the section. */ + +/*ARGSUSED*/ +static boolean +coff_i960_adjust_symndx (obfd, info, ibfd, sec, irel, adjustedp) + bfd *obfd; + struct bfd_link_info *info; + bfd *ibfd; + asection *sec; + struct internal_reloc *irel; + boolean *adjustedp; +{ + struct coff_link_hash_entry *h; + + h = obj_coff_sym_hashes (ibfd)[irel->r_symndx]; + if (h == NULL + || (h->root.type != bfd_link_hash_defined + && h->root.type != bfd_link_hash_defweak)) + return true; + + irel->r_symndx = h->root.u.def.section->output_section->target_index - 1; + *adjustedp = true; + + return true; +} + +#define coff_start_final_link coff_i960_start_final_link + +#define coff_relocate_section coff_i960_relocate_section + +#define coff_adjust_symndx coff_i960_adjust_symndx -#undef coff_bfd_reloc_type_lookup #define coff_bfd_reloc_type_lookup coff_i960_reloc_type_lookup +#include "coffcode.h" + const bfd_target icoff_little_vec = { "coff-Intel-little", /* name */ diff --git a/bfd/coffcode.h b/bfd/coffcode.h index dd772a831a..e9a808c7c6 100644 --- a/bfd/coffcode.h +++ b/bfd/coffcode.h @@ -681,6 +681,9 @@ dependent COFF routines: . struct internal_syment *)); . void (*_bfd_coff_compute_section_file_positions) PARAMS (( . bfd *abfd)); +. boolean (*_bfd_coff_start_final_link) PARAMS (( +. bfd *output_bfd, +. struct bfd_link_info *info)); . boolean (*_bfd_coff_relocate_section) PARAMS (( . bfd *output_bfd, . struct bfd_link_info *info, @@ -798,6 +801,9 @@ dependent COFF routines: . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\ . (abfd)) . +.#define bfd_coff_start_final_link(obfd, info)\ +. ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\ +. (obfd, info)) .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\ . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\ . (obfd, info, ibfd, o, con, rel, isyms, secs)) @@ -2814,6 +2820,10 @@ dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr, #endif /* ! defined (coff_relocate_section) */ #define coff_bfd_link_split_section _bfd_generic_link_split_section +#ifndef coff_start_final_link +#define coff_start_final_link NULL +#endif + #ifndef coff_adjust_symndx #define coff_adjust_symndx NULL #endif @@ -2837,7 +2847,8 @@ static CONST bfd_coff_backend_data bfd_coff_std_swap_table = coff_set_alignment_hook, coff_slurp_symbol_table, symname_in_debug_hook, coff_reloc16_extra_cases, coff_reloc16_estimate, coff_sym_is_global, coff_compute_section_file_positions, - coff_relocate_section, coff_rtype_to_howto, coff_adjust_symndx + coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, + coff_adjust_symndx }; #define coff_close_and_cleanup _bfd_generic_close_and_cleanup diff --git a/bfd/cofflink.c b/bfd/cofflink.c index 10c0d68cec..81cefb02f4 100644 --- a/bfd/cofflink.c +++ b/bfd/cofflink.c @@ -87,8 +87,6 @@ static boolean coff_link_add_object_symbols PARAMS ((bfd *, struct bfd_link_info *)); static boolean coff_link_check_archive_element PARAMS ((bfd *, struct bfd_link_info *, boolean *)); -static INLINE const char *_bfd_coff_internal_syment_name - PARAMS ((bfd *, const struct internal_syment *, char *)); static boolean coff_link_check_ar_symbols PARAMS ((bfd *, struct bfd_link_info *, boolean *)); static boolean coff_link_add_symbols PARAMS ((bfd *, struct bfd_link_info *)); @@ -238,7 +236,7 @@ coff_link_check_archive_element (abfd, info, pneeded) /* Get the name of a symbol. The caller must pass in a buffer of size >= SYMNMLEN + 1. */ -static INLINE const char * +INLINE const char * _bfd_coff_internal_syment_name (abfd, sym, buf) bfd *abfd; const struct internal_syment *sym; @@ -710,6 +708,13 @@ _bfd_coff_final_link (abfd, info) table in memory as we go along. We process all the relocations for a single input file at once. */ obj_raw_syment_count (abfd) = 0; + + if (coff_backend_info (abfd)->_bfd_coff_start_final_link) + { + if (! bfd_coff_start_final_link (abfd, info)) + goto error_return; + } + for (o = abfd->sections; o != NULL; o = o->next) { for (p = o->link_order_head; p != NULL; p = p->next) diff --git a/bfd/configure b/bfd/configure index 4459986c34..484bdc13e0 100755 --- a/bfd/configure +++ b/bfd/configure @@ -1345,8 +1345,8 @@ do i386mach3_vec) tb="$tb i386mach3.o aout32.o stab-syms.o" ;; i386netbsd_vec) tb="$tb i386netbsd.o aout32.o stab-syms.o" ;; i386os9k_vec) tb="$tb i386os9k.o aout32.o stab-syms.o" ;; - icoff_big_vec) tb="$tb coff-i960.o" ;; - icoff_little_vec) tb="$tb coff-i960.o" ;; + icoff_big_vec) tb="$tb coff-i960.o cofflink.o" ;; + icoff_little_vec) tb="$tb coff-i960.o cofflink.o" ;; ieee_vec) tb="$tb ieee.o" ;; m68kcoff_vec) tb="$tb coff-m68k.o cofflink.o" ;; m68kcoffun_vec) tb="$tb coff-u68k.o coff-m68k.o cofflink.o" ;; diff --git a/bfd/configure.in b/bfd/configure.in index 5808c962fa..66eb54171f 100644 --- a/bfd/configure.in +++ b/bfd/configure.in @@ -390,8 +390,8 @@ do i386mach3_vec) tb="$tb i386mach3.o aout32.o stab-syms.o" ;; i386netbsd_vec) tb="$tb i386netbsd.o aout32.o stab-syms.o" ;; i386os9k_vec) tb="$tb i386os9k.o aout32.o stab-syms.o" ;; - icoff_big_vec) tb="$tb coff-i960.o" ;; - icoff_little_vec) tb="$tb coff-i960.o" ;; + icoff_big_vec) tb="$tb coff-i960.o cofflink.o" ;; + icoff_little_vec) tb="$tb coff-i960.o cofflink.o" ;; ieee_vec) tb="$tb ieee.o" ;; m68kcoff_vec) tb="$tb coff-m68k.o cofflink.o" ;; m68kcoffun_vec) tb="$tb coff-u68k.o coff-m68k.o cofflink.o" ;; diff --git a/bfd/libcoff-in.h b/bfd/libcoff-in.h index 8ab9aa4ae1..bb690bb5d5 100644 --- a/bfd/libcoff-in.h +++ b/bfd/libcoff-in.h @@ -115,6 +115,8 @@ struct coff_section_tdata bfd_byte *contents; /* If this is true, the contents entry may not be freed. */ boolean keep_contents; + /* Available for individual backends. */ + PTR tdata; }; /* An accessor macro for the coff_section_tdata structure. */ @@ -222,6 +224,8 @@ extern void bfd_perform_slip PARAMS ((bfd *abfd, unsigned int slip, extern struct bfd_link_hash_table *_bfd_coff_link_hash_table_create PARAMS ((bfd *)); +extern const char *_bfd_coff_internal_syment_name + PARAMS ((bfd *, const struct internal_syment *, char *)); extern boolean _bfd_coff_link_add_symbols PARAMS ((bfd *, struct bfd_link_info *)); extern boolean _bfd_coff_final_link diff --git a/bfd/libcoff.h b/bfd/libcoff.h index 7053852446..8f2a45e70b 100644 --- a/bfd/libcoff.h +++ b/bfd/libcoff.h @@ -115,6 +115,8 @@ struct coff_section_tdata bfd_byte *contents; /* If this is true, the contents entry may not be freed. */ boolean keep_contents; + /* Available for individual backends. */ + PTR tdata; }; /* An accessor macro for the coff_section_tdata structure. */ @@ -222,6 +224,8 @@ extern void bfd_perform_slip PARAMS ((bfd *abfd, unsigned int slip, extern struct bfd_link_hash_table *_bfd_coff_link_hash_table_create PARAMS ((bfd *)); +extern const char *_bfd_coff_internal_syment_name + PARAMS ((bfd *, const struct internal_syment *, char *)); extern boolean _bfd_coff_link_add_symbols PARAMS ((bfd *, struct bfd_link_info *)); extern boolean _bfd_coff_final_link @@ -413,6 +417,9 @@ typedef struct struct internal_syment *)); void (*_bfd_coff_compute_section_file_positions) PARAMS (( bfd *abfd)); + boolean (*_bfd_coff_start_final_link) PARAMS (( + bfd *output_bfd, + struct bfd_link_info *info)); boolean (*_bfd_coff_relocate_section) PARAMS (( bfd *output_bfd, struct bfd_link_info *info, @@ -530,6 +537,9 @@ typedef struct ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\ (abfd)) +#define bfd_coff_start_final_link(obfd, info)\ + ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\ + (obfd, info)) #define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\ ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\ (obfd, info, ibfd, o, con, rel, isyms, secs))