From 4cdc7696f5ce43e61bb7e234ed10b2ad03fca9e8 Mon Sep 17 00:00:00 2001 From: Nick Clifton Date: Fri, 3 Mar 2006 15:54:23 +0000 Subject: [PATCH] Update formatting to ISO-C90 --- bfd/ChangeLog | 5 + bfd/cpu-avr.c | 108 ++-- bfd/elf32-avr.c | 1463 +++++++++++++++++++++++------------------------ 3 files changed, 762 insertions(+), 814 deletions(-) diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 4d9052100f..e52fdfb7b7 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,8 @@ +2006-03-03 Nick Clifton + + * cpu-avr.c: Update to ISO-C90 formatting. + * elf32-avr.c: Likewise. + 2006-03-03 Bjoern Haase * elf32-avr.c (avr_reloc_map): Insert BFD_RELOC_AVR_MS8_LDI diff --git a/bfd/cpu-avr.c b/bfd/cpu-avr.c index 70c04d641d..4c8c193f61 100644 --- a/bfd/cpu-avr.c +++ b/bfd/cpu-avr.c @@ -1,75 +1,34 @@ /* BFD library support routines for the AVR architecture. - Copyright 1999, 2000, 2002 Free Software Foundation, Inc. + Copyright 1999, 2000, 2002, 2006 Free Software Foundation, Inc. Contributed by Denis Chertykov -This file is part of BFD, the Binary File Descriptor library. + This file is part of BFD, the Binary File Descriptor library. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ #include "bfd.h" #include "sysdep.h" #include "libbfd.h" -static const bfd_arch_info_type *compatible - PARAMS ((const bfd_arch_info_type *, const bfd_arch_info_type *)); - -#define N(addr_bits, machine, print, default, next) \ -{ \ - 8, /* 8 bits in a word */ \ - addr_bits, /* bits in an address */ \ - 8, /* 8 bits in a byte */ \ - bfd_arch_avr, \ - machine, /* machine */ \ - "avr", /* arch_name */ \ - print, /* printable name */ \ - 1, /* section align power */ \ - default, /* the default machine */ \ - compatible, \ - bfd_default_scan, \ - next \ -} - -static const bfd_arch_info_type arch_info_struct[] = -{ - /* AT90S1200, ATtiny1x, ATtiny28 */ - N (16, bfd_mach_avr1, "avr:1", FALSE, & arch_info_struct[1]), - - /* AT90S2xxx, AT90S4xxx, AT90S8xxx, ATtiny22 */ - N (16, bfd_mach_avr2, "avr:2", FALSE, & arch_info_struct[2]), - - /* ATmega103, ATmega603 */ - N (22, bfd_mach_avr3, "avr:3", FALSE, & arch_info_struct[3]), - - /* ATmega83, ATmega85 */ - N (16, bfd_mach_avr4, "avr:4", FALSE, & arch_info_struct[4]), - - /* ATmega161, ATmega163, ATmega32, AT94K */ - N (22, bfd_mach_avr5, "avr:5", FALSE, NULL) -}; - -const bfd_arch_info_type bfd_avr_arch = - N (16, bfd_mach_avr2, "avr", TRUE, & arch_info_struct[0]); - /* This routine is provided two arch_infos and works out which AVR machine which would be compatible with both and returns a pointer to its info structure. */ static const bfd_arch_info_type * -compatible (a,b) - const bfd_arch_info_type * a; - const bfd_arch_info_type * b; +compatible (const bfd_arch_info_type * a, + const bfd_arch_info_type * b) { /* If a & b are for different architectures we can do nothing. */ if (a->arch != b->arch) @@ -91,3 +50,40 @@ compatible (a,b) /* Never reached! */ return NULL; } + +#define N(addr_bits, machine, print, default, next) \ +{ \ + 8, /* 8 bits in a word. */ \ + addr_bits, /* bits in an address. */ \ + 8, /* 8 bits in a byte. */ \ + bfd_arch_avr, \ + machine, /* Machine number. */ \ + "avr", /* Architecture name. */ \ + print, /* Printable name. */ \ + 1, /* Section align power. */ \ + default, /* Is this the default ? */ \ + compatible, \ + bfd_default_scan, \ + next \ +} + +static const bfd_arch_info_type arch_info_struct[] = +{ + /* AT90S1200, ATtiny1x, ATtiny28. */ + N (16, bfd_mach_avr1, "avr:1", FALSE, & arch_info_struct[1]), + + /* AT90S2xxx, AT90S4xxx, AT90S8xxx, ATtiny22. */ + N (16, bfd_mach_avr2, "avr:2", FALSE, & arch_info_struct[2]), + + /* ATmega103, ATmega603. */ + N (22, bfd_mach_avr3, "avr:3", FALSE, & arch_info_struct[3]), + + /* ATmega83, ATmega85. */ + N (16, bfd_mach_avr4, "avr:4", FALSE, & arch_info_struct[4]), + + /* ATmega161, ATmega163, ATmega32, AT94K. */ + N (22, bfd_mach_avr5, "avr:5", FALSE, NULL) +}; + +const bfd_arch_info_type bfd_avr_arch = + N (16, bfd_mach_avr2, "avr", TRUE, & arch_info_struct[0]); diff --git a/bfd/elf32-avr.c b/bfd/elf32-avr.c index 32268ccce1..ec42bb335d 100644 --- a/bfd/elf32-avr.c +++ b/bfd/elf32-avr.c @@ -17,7 +17,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street - Fifth Floor, + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ #include "bfd.h" @@ -26,37 +26,6 @@ #include "elf-bfd.h" #include "elf/avr.h" -static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup - PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); -static void avr_info_to_howto_rela - PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); -static asection *elf32_avr_gc_mark_hook - PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *, - struct elf_link_hash_entry *, Elf_Internal_Sym *)); -static bfd_boolean elf32_avr_gc_sweep_hook - PARAMS ((bfd *, struct bfd_link_info *, asection *, - const Elf_Internal_Rela *)); -static bfd_boolean elf32_avr_check_relocs - PARAMS ((bfd *, struct bfd_link_info *, asection *, - const Elf_Internal_Rela *)); -static bfd_reloc_status_type avr_final_link_relocate - PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *, - Elf_Internal_Rela *, bfd_vma)); -static bfd_boolean elf32_avr_relocate_section - PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, - Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); -static void bfd_elf_avr_final_write_processing PARAMS ((bfd *, bfd_boolean)); -static bfd_boolean elf32_avr_object_p PARAMS ((bfd *)); - -/* Relaxing stuff */ -static bfd_boolean elf32_avr_relax_section - PARAMS((bfd *, asection *, struct bfd_link_info *, bfd_boolean *)); -static bfd_boolean elf32_avr_relax_delete_bytes - PARAMS((bfd *, asection *, bfd_vma, int)); -static bfd_byte *elf32_avr_get_relocated_section_contents - PARAMS((bfd *, struct bfd_link_info *, struct bfd_link_order *, - bfd_byte *, bfd_boolean, asymbol **)); - static reloc_howto_type elf_avr_howto_table[] = { HOWTO (R_AVR_NONE, /* type */ @@ -177,7 +146,7 @@ static reloc_howto_type elf_avr_howto_table[] = 0xffff, /* dst_mask */ FALSE), /* pcrel_offset */ /* A high 6 bit absolute relocation of 22 bit address. - For LDI command. As well second most significant 8 bit value of + For LDI command. As well second most significant 8 bit value of a 32 bit link-time constant. */ HOWTO (R_AVR_HH8_LDI, /* type */ 16, /* rightshift */ @@ -453,25 +422,24 @@ struct avr_reloc_map }; /* Meant to be filled one day with the wrap around address for the - specific device. I.e. should get the value 0x4000 for 16k devices, + specific device. I.e. should get the value 0x4000 for 16k devices, 0x8000 for 32k devices and so on. - + We initialize it here with a value of 0x1000000 resulting in - that we will never suggest a wrap-around jump during relaxation. - The logic of the source code later on assumes that in + that we will never suggest a wrap-around jump during relaxation. + The logic of the source code later on assumes that in avr_pc_wrap_around one single bit is set. */ - + unsigned int avr_pc_wrap_around = 0x10000000; /* Calculates the effective distance of a pc relative jump/call. */ static int avr_relative_distance_considering_wrap_around (unsigned int distance) -{ +{ unsigned int wrap_around_mask = avr_pc_wrap_around - 1; - int dist_with_wrap_around = distance & wrap_around_mask; - if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1)) ) + if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1))) dist_with_wrap_around -= avr_pc_wrap_around; return dist_with_wrap_around; @@ -479,9 +447,8 @@ avr_relative_distance_considering_wrap_around (unsigned int distance) static reloc_howto_type * -bfd_elf32_bfd_reloc_type_lookup (abfd, code) - bfd *abfd ATTRIBUTE_UNUSED; - bfd_reloc_code_real_type code; +bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, + bfd_reloc_code_real_type code) { unsigned int i; @@ -499,10 +466,9 @@ bfd_elf32_bfd_reloc_type_lookup (abfd, code) /* Set the howto pointer for an AVR ELF reloc. */ static void -avr_info_to_howto_rela (abfd, cache_ptr, dst) - bfd *abfd ATTRIBUTE_UNUSED; - arelent *cache_ptr; - Elf_Internal_Rela *dst; +avr_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED, + arelent *cache_ptr, + Elf_Internal_Rela *dst) { unsigned int r_type; @@ -512,12 +478,11 @@ avr_info_to_howto_rela (abfd, cache_ptr, dst) } static asection * -elf32_avr_gc_mark_hook (sec, info, rel, h, sym) - asection *sec; - struct bfd_link_info *info ATTRIBUTE_UNUSED; - Elf_Internal_Rela *rel; - struct elf_link_hash_entry *h; - Elf_Internal_Sym *sym; +elf32_avr_gc_mark_hook (asection *sec, + struct bfd_link_info *info ATTRIBUTE_UNUSED, + Elf_Internal_Rela *rel, + struct elf_link_hash_entry *h, + Elf_Internal_Sym *sym) { if (h != NULL) { @@ -545,11 +510,10 @@ elf32_avr_gc_mark_hook (sec, info, rel, h, sym) } static bfd_boolean -elf32_avr_gc_sweep_hook (abfd, info, sec, relocs) - bfd *abfd ATTRIBUTE_UNUSED; - struct bfd_link_info *info ATTRIBUTE_UNUSED; - asection *sec ATTRIBUTE_UNUSED; - const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED; +elf32_avr_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED, + struct bfd_link_info *info ATTRIBUTE_UNUSED, + asection *sec ATTRIBUTE_UNUSED, + const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED) { /* We don't use got and plt entries for avr. */ return TRUE; @@ -560,11 +524,10 @@ elf32_avr_gc_sweep_hook (abfd, info, sec, relocs) virtual table relocs for gc. */ static bfd_boolean -elf32_avr_check_relocs (abfd, info, sec, relocs) - bfd *abfd; - struct bfd_link_info *info; - asection *sec; - const Elf_Internal_Rela *relocs; +elf32_avr_check_relocs (bfd *abfd, + struct bfd_link_info *info, + asection *sec, + const Elf_Internal_Rela *relocs) { Elf_Internal_Shdr *symtab_hdr; struct elf_link_hash_entry **sym_hashes, **sym_hashes_end; @@ -576,7 +539,7 @@ elf32_avr_check_relocs (abfd, info, sec, relocs) symtab_hdr = &elf_tdata (abfd)->symtab_hdr; sym_hashes = elf_sym_hashes (abfd); - sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym); + sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym); if (!elf_bad_symtab (abfd)) sym_hashes_end -= symtab_hdr->sh_info; @@ -605,14 +568,12 @@ elf32_avr_check_relocs (abfd, info, sec, relocs) routines, but a few relocs, we have to do them ourselves. */ static bfd_reloc_status_type -avr_final_link_relocate (howto, input_bfd, input_section, - contents, rel, relocation) - reloc_howto_type * howto; - bfd * input_bfd; - asection * input_section; - bfd_byte * contents; - Elf_Internal_Rela * rel; - bfd_vma relocation; +avr_final_link_relocate (reloc_howto_type * howto, + bfd * input_bfd, + asection * input_section, + bfd_byte * contents, + Elf_Internal_Rela * rel, + bfd_vma relocation) { bfd_reloc_status_type r = bfd_reloc_ok; bfd_vma x; @@ -688,8 +649,8 @@ avr_final_link_relocate (howto, input_bfd, input_section, case R_AVR_LDI: contents += rel->r_offset; srel = (bfd_signed_vma) relocation + rel->r_addend; - if ( ((srel > 0) && (srel & 0xffff) > 255) - || ((srel < 0) && ( (-srel) & 0xffff) > 128)) + if (((srel > 0) && (srel & 0xffff) > 255) + || ((srel < 0) && ((-srel) & 0xffff) > 128)) /* Remove offset for data/eeprom section. */ return bfd_reloc_overflow; @@ -705,7 +666,7 @@ avr_final_link_relocate (howto, input_bfd, input_section, /* Remove offset for data/eeprom section. */ return bfd_reloc_overflow; x = bfd_get_16 (input_bfd, contents); - x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7) + x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7) | ((srel & (1 << 5)) << 8)); bfd_put_16 (input_bfd, x, contents); break; @@ -717,7 +678,7 @@ avr_final_link_relocate (howto, input_bfd, input_section, /* Remove offset for data/eeprom section. */ return bfd_reloc_overflow; x = bfd_get_16 (input_bfd, contents); - x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2); + x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2); bfd_put_16 (input_bfd, x, contents); break; @@ -882,17 +843,16 @@ avr_final_link_relocate (howto, input_bfd, input_section, } /* Relocate an AVR ELF section. */ + static bfd_boolean -elf32_avr_relocate_section (output_bfd, info, input_bfd, input_section, - contents, relocs, local_syms, local_sections) - bfd *output_bfd ATTRIBUTE_UNUSED; - struct bfd_link_info *info; - bfd *input_bfd; - asection *input_section; - bfd_byte *contents; - Elf_Internal_Rela *relocs; - Elf_Internal_Sym *local_syms; - asection **local_sections; +elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED, + struct bfd_link_info *info, + bfd *input_bfd, + asection *input_section, + bfd_byte *contents, + Elf_Internal_Rela *relocs, + Elf_Internal_Sym *local_syms, + asection **local_sections) { Elf_Internal_Shdr * symtab_hdr; struct elf_link_hash_entry ** sym_hashes; @@ -1003,9 +963,8 @@ elf32_avr_relocate_section (output_bfd, info, input_bfd, input_section, number. */ static void -bfd_elf_avr_final_write_processing (abfd, linker) - bfd *abfd; - bfd_boolean linker ATTRIBUTE_UNUSED; +bfd_elf_avr_final_write_processing (bfd *abfd, + bfd_boolean linker ATTRIBUTE_UNUSED) { unsigned long val; @@ -1042,14 +1001,15 @@ bfd_elf_avr_final_write_processing (abfd, linker) /* Set the right machine number. */ static bfd_boolean -elf32_avr_object_p (abfd) - bfd *abfd; +elf32_avr_object_p (bfd *abfd) { unsigned int e_set = bfd_mach_avr2; + if (elf_elfheader (abfd)->e_machine == EM_AVR || elf_elfheader (abfd)->e_machine == EM_AVR_OLD) { int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH; + switch (e_mach) { default: @@ -1082,656 +1042,16 @@ elf32_avr_object_p (abfd) /* Enable debugging printout at stdout with a value of 1. */ #define DEBUG_RELAX 0 -/* This function handles relaxing for the avr. - Many important relaxing opportunities within functions are already - realized by the compiler itself. - Here we try to replace call (4 bytes) -> rcall (2 bytes) - and jump -> rjmp (safes also 2 bytes). - As well we now optimize seqences of - - call/rcall function - - ret - to yield - - jmp/rjmp function - - ret - . In case that within a sequence - - jmp/rjmp label - - ret - the ret could no longer be reached it is optimized away. In order - to check if the ret is no longer needed, it is checked that the ret's address - is not the target of a branch or jump within the same section, it is checked - that there is no skip instruction before the jmp/rjmp and that there - is no local or global label place at the address of the ret. - - We refrain from relaxing within sections ".vectors" and - ".jumptables" in order to maintain the position of the instructions. - There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop - if possible. (In future one could possibly use the space of the nop - for the first instruction of the irq service function. - - The .jumptables sections is meant to be used for a future tablejump variant - for the devices with 3-byte program counter where the table itself - contains 4-byte jump instructions whose relative offset must not - be changed. */ - -static bfd_boolean -elf32_avr_relax_section (bfd *abfd, asection *sec, - struct bfd_link_info *link_info, - bfd_boolean *again) -{ - Elf_Internal_Shdr *symtab_hdr; - Elf_Internal_Rela *internal_relocs; - Elf_Internal_Rela *irel, *irelend; - bfd_byte *contents = NULL; - Elf_Internal_Sym *isymbuf = NULL; - static asection *last_input_section = NULL; - static Elf_Internal_Rela *last_reloc = NULL; - - /* Assume nothing changes. */ - *again = FALSE; - - /* We don't have to do anything for a relocatable link, if - this section does not have relocs, or if this is not a - code section. */ - if (link_info->relocatable - || (sec->flags & SEC_RELOC) == 0 - || sec->reloc_count == 0 - || (sec->flags & SEC_CODE) == 0) - return TRUE; - - /* Check if the object file to relax uses internal symbols so that we - could fix up the relocations. */ - - if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED)) - return TRUE; - - - symtab_hdr = &elf_tdata (abfd)->symtab_hdr; - - /* Get a copy of the native relocations. */ - internal_relocs = (_bfd_elf_link_read_relocs - (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL, - link_info->keep_memory)); - if (internal_relocs == NULL) - goto error_return; - - if (sec != last_input_section) - last_reloc = NULL; - - last_input_section = sec; - - /* Walk through the relocs looking for relaxing opportunities. */ - irelend = internal_relocs + sec->reloc_count; - for (irel = internal_relocs; irel < irelend; irel++) - { - bfd_vma symval; - - if (ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL - && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL - && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL) - continue; - - /* Get the section contents if we haven't done so already. */ - if (contents == NULL) - { - /* Get cached copy if it exists. */ - if (elf_section_data (sec)->this_hdr.contents != NULL) - contents = elf_section_data (sec)->this_hdr.contents; - else - { - /* Go get them off disk. */ - if (!bfd_malloc_and_get_section (abfd, sec, &contents)) - goto error_return; - } - } - - /* Read this BFD's local symbols if we haven't done so already. */ - if (isymbuf == NULL && symtab_hdr->sh_info != 0) - { - isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; - if (isymbuf == NULL) - isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, - symtab_hdr->sh_info, 0, - NULL, NULL, NULL); - if (isymbuf == NULL) - goto error_return; - } - - - /* Get the value of the symbol referred to by the reloc. */ - if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) - { - /* A local symbol. */ - Elf_Internal_Sym *isym; - asection *sym_sec; - - isym = isymbuf + ELF32_R_SYM (irel->r_info); - sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); - symval = isym->st_value; - /* If the reloc is absolute, it will not have - a symbol or section associated with it. */ - if (sym_sec) - symval += sym_sec->output_section->vma - + sym_sec->output_offset; - } - else - { - unsigned long indx; - struct elf_link_hash_entry *h; - - /* An external symbol. */ - indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; - h = elf_sym_hashes (abfd)[indx]; - BFD_ASSERT (h != NULL); - if (h->root.type != bfd_link_hash_defined - && h->root.type != bfd_link_hash_defweak) - { - /* This appears to be a reference to an undefined - symbol. Just ignore it--it will be caught by the - regular reloc processing. */ - continue; - } - symval = (h->root.u.def.value - + h->root.u.def.section->output_section->vma - + h->root.u.def.section->output_offset); - } - - /* For simplicity of coding, we are going to modify the section - contents, the section relocs, and the BFD symbol table. We - must tell the rest of the code not to free up this - information. It would be possible to instead create a table - of changes which have to be made, as is done in coff-mips.c; - that would be more work, but would require less memory when - the linker is run. */ - switch (ELF32_R_TYPE (irel->r_info)) - { - /* Try to turn a 22-bit absolute call/jump into an 13-bit - pc-relative rcall/rjmp. */ - case R_AVR_CALL: - { - bfd_vma value = symval + irel->r_addend; - bfd_vma dot, gap; - int distance_short_enough = 0; - - /* Get the address of this instruction. */ - dot = (sec->output_section->vma - + sec->output_offset + irel->r_offset); - - /* Compute the distance from this insn to the branch target. */ - gap = value - dot; - - /* If the distance is within -4094..+4098 inclusive, then we can - relax this jump/call. +4098 because the call/jump target - will be closer after the relaxation. */ - if ((int) gap >= -4094 && (int) gap <= 4098) - distance_short_enough = 1; - - /* Here we handle the wrap-around case. E.g. for a 16k device - we could use a rjmp to jump from address 0x100 to 0x3d00! - In order to make this work properly, we need to fill the - vaiable avr_pc_wrap_around with the appropriate value. - I.e. 0x4000 for a 16k device. */ - { - /* Shrinking the code size makes the gaps larger in the - case of wrap-arounds. So we use a heuristical safety - margin to avoid that during relax the distance gets - again too large for the short jumps. Let's assume - a typical code-size reduction due to relax for a - 16k device of 600 bytes. So let's use twice the - typical value as safety margin. */ - - int rgap; - int safety_margin; - - int assumed_shrink = 600; - if (avr_pc_wrap_around > 0x4000) - assumed_shrink = 900; - - safety_margin = 2 * assumed_shrink; - - rgap = avr_relative_distance_considering_wrap_around (gap); - - if (rgap >= (-4092 + safety_margin) - && rgap <= (4094 - safety_margin)) - distance_short_enough = 1; - } - - if (distance_short_enough) - { - unsigned char code_msb; - unsigned char code_lsb; - - if (DEBUG_RELAX) - printf ("shrinking jump/call instruction at address 0x%x" - " in section %s\n\n", - (int) dot, sec->name); - - /* Note that we've changed the relocs, section contents, - etc. */ - elf_section_data (sec)->relocs = internal_relocs; - elf_section_data (sec)->this_hdr.contents = contents; - symtab_hdr->contents = (unsigned char *) isymbuf; - - /* Get the instruction code for relaxing. */ - code_lsb = bfd_get_8 (abfd, contents + irel->r_offset); - code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1); - - /* Mask out the relocation bits. */ - code_msb &= 0x94; - code_lsb &= 0x0E; - if (code_msb == 0x94 && code_lsb == 0x0E) - { - /* we are changing call -> rcall . */ - bfd_put_8 (abfd, 0x00, contents + irel->r_offset); - bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1); - } - else if (code_msb == 0x94 && code_lsb == 0x0C) - { - /* we are changeing jump -> rjmp. */ - bfd_put_8 (abfd, 0x00, contents + irel->r_offset); - bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1); - } - else - abort (); - - /* Fix the relocation's type. */ - irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), - R_AVR_13_PCREL); - - /* Check for the vector section. There we don't want to - modify the ordering! */ - - if (!strcmp (sec->name,".vectors") - || !strcmp (sec->name,".jumptables")) - { - /* Let's insert a nop. */ - bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2); - bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3); - } - else - { - /* Delete two bytes of data. */ - if (!elf32_avr_relax_delete_bytes (abfd, sec, - irel->r_offset + 2, 2)) - goto error_return; - - /* That will change things, so, we should relax again. - Note that this is not required, and it may be slow. */ - *again = TRUE; - } - } - } - default: - { - unsigned char code_msb; - unsigned char code_lsb; - bfd_vma dot; - - code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1); - code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0); - - /* Get the address of this instruction. */ - dot = (sec->output_section->vma - + sec->output_offset + irel->r_offset); - - /* Here we look for rcall/ret or call/ret sequences that could be - safely replaced by rjmp/ret or jmp/ret */ - if (0xd0 == (code_msb & 0xf0)) - { - /* This insn is a rcall. */ - unsigned char next_insn_msb = 0; - unsigned char next_insn_lsb = 0; - - if (irel->r_offset + 3 < sec->size) - { - next_insn_msb = - bfd_get_8 (abfd, contents + irel->r_offset + 3); - next_insn_lsb = - bfd_get_8 (abfd, contents + irel->r_offset + 2); - } - if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb)) - { - /* The next insn is a ret. We now convert the rcall insn - into a rjmp instruction. */ - - code_msb &= 0xef; - bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1); - if (DEBUG_RELAX) - printf ("converted rcall/ret sequence at address 0x%x" - " into rjmp/ret sequence. Section is %s\n\n", - (int) dot, sec->name); - *again = TRUE; - break; - } - } - else if ((0x94 == (code_msb & 0xfe)) - && (0x0e == (code_lsb & 0x0e))) - { - /* This insn is a call. */ - unsigned char next_insn_msb = 0; - unsigned char next_insn_lsb = 0; - - if (irel->r_offset + 5 < sec->size) - { - next_insn_msb = - bfd_get_8 (abfd, contents + irel->r_offset + 5); - next_insn_lsb = - bfd_get_8 (abfd, contents + irel->r_offset + 4); - } - if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb)) - { - /* The next insn is a ret. We now convert the call insn - into a jmp instruction. */ - - code_lsb &= 0xfd; - bfd_put_8 (abfd, code_lsb, contents + irel->r_offset); - if (DEBUG_RELAX) - printf ("converted call/ret sequence at address 0x%x" - " into jmp/ret sequence. Section is %s\n\n", - (int) dot, sec->name); - *again = TRUE; - break; - } - } - else if ((0xc0 == (code_msb & 0xf0)) - || ((0x94 == (code_msb & 0xfe)) - && (0x0c == (code_lsb & 0x0e)))) - { - /* this insn is a rjmp or a jmp. */ - unsigned char next_insn_msb = 0; - unsigned char next_insn_lsb = 0; - int insn_size; - - if (0xc0 == (code_msb & 0xf0)) - insn_size = 2; /* rjmp insn */ - else - insn_size = 4; /* jmp insn */ - - if (irel->r_offset + insn_size + 1 < sec->size) - { - next_insn_msb = - bfd_get_8 (abfd, contents + irel->r_offset - + insn_size + 1); - next_insn_lsb = - bfd_get_8 (abfd, contents + irel->r_offset - + insn_size); - } - - if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb)) - { - /* The next insn is a ret. We possibly could delete - this ret. First we need to check for preceeding - sbis/sbic/sbrs or cpse "skip" instructions. */ - - int there_is_preceeding_non_skip_insn = 1; - bfd_vma address_of_ret; - - address_of_ret = dot + insn_size; - - if (DEBUG_RELAX && (insn_size == 2)) - printf ("found rjmp / ret sequence at " - "address 0x%x\n", - (int) dot); - if (DEBUG_RELAX && (insn_size == 4)) - printf ("found jmp / ret sequence at " - "address 0x%x\n", - (int) dot); - - /* We have to make sure that there is a preceeding insn. */ - if (irel->r_offset >= 2) - { - unsigned char preceeding_msb; - unsigned char preceeding_lsb; - preceeding_msb = - bfd_get_8 (abfd, contents + irel->r_offset - 1); - preceeding_lsb = - bfd_get_8 (abfd, contents + irel->r_offset - 2); - - /* sbic. */ - if (0x99 == preceeding_msb) - there_is_preceeding_non_skip_insn = 0; - - /* sbis. */ - if (0x9b == preceeding_msb) - there_is_preceeding_non_skip_insn = 0; - - /* sbrc */ - if ((0xfc == (preceeding_msb & 0xfe) - && (0x00 == (preceeding_lsb & 0x08)))) - there_is_preceeding_non_skip_insn = 0; - - /* sbrs */ - if ((0xfe == (preceeding_msb & 0xfe) - && (0x00 == (preceeding_lsb & 0x08)))) - there_is_preceeding_non_skip_insn = 0; - - /* cpse */ - if (0x10 == (preceeding_msb & 0xfc)) - there_is_preceeding_non_skip_insn = 0; - - if (there_is_preceeding_non_skip_insn == 0) - if (DEBUG_RELAX) - printf ("preceeding skip insn prevents deletion of" - " ret insn at addr 0x%x in section %s\n", - (int) dot + 2, sec->name); - } - else - { - /* There is no previous instruction. */ - there_is_preceeding_non_skip_insn = 0; - } - - if (there_is_preceeding_non_skip_insn) - { - /* We now only have to make sure that there is no - local label defined at the address of the ret - instruction and that there is no local relocation - in this section pointing to the ret. */ - - int deleting_ret_is_safe = 1; - unsigned int section_offset_of_ret_insn = - irel->r_offset + insn_size; - Elf_Internal_Sym *isym, *isymend; - unsigned int sec_shndx; - - sec_shndx = - _bfd_elf_section_from_bfd_section (abfd, sec); - - /* Check for local symbols. */ - isym = (Elf_Internal_Sym *) symtab_hdr->contents; - isymend = isym + symtab_hdr->sh_info; - for (; isym < isymend; isym++) - { - if (isym->st_value == section_offset_of_ret_insn - && isym->st_shndx == sec_shndx) - { - deleting_ret_is_safe = 0; - if (DEBUG_RELAX) - printf ("local label prevents deletion of ret " - "insn at address 0x%x\n", - (int) dot + insn_size); - } - } - - /* Now check for global symbols. */ - { - int symcount; - struct elf_link_hash_entry **sym_hashes; - struct elf_link_hash_entry **end_hashes; - - symcount = (symtab_hdr->sh_size - / sizeof (Elf32_External_Sym) - - symtab_hdr->sh_info); - sym_hashes = elf_sym_hashes (abfd); - end_hashes = sym_hashes + symcount; - for (; sym_hashes < end_hashes; sym_hashes++) - { - struct elf_link_hash_entry *sym_hash = - *sym_hashes; - if ((sym_hash->root.type == bfd_link_hash_defined - || sym_hash->root.type == - bfd_link_hash_defweak) - && sym_hash->root.u.def.section == sec - && sym_hash->root.u.def.value == - section_offset_of_ret_insn) - { - deleting_ret_is_safe = 0; - if (DEBUG_RELAX) - printf ("global label prevents deletion of " - "ret insn at address 0x%x\n", - (int) dot + insn_size); - } - } - } - /* Now we check for relocations pointing to ret. */ - { - Elf_Internal_Rela *irel; - Elf_Internal_Rela *relend; - Elf_Internal_Shdr *symtab_hdr; - - symtab_hdr = &elf_tdata (abfd)->symtab_hdr; - relend = elf_section_data (sec)->relocs - + sec->reloc_count; - - for (irel = elf_section_data (sec)->relocs; - irel < relend; irel++) - { - bfd_vma reloc_target = 0; - bfd_vma symval; - Elf_Internal_Sym *isymbuf = NULL; - - /* Read this BFD's local symbols if we haven't - done so already. */ - if (isymbuf == NULL && symtab_hdr->sh_info != 0) - { - isymbuf = (Elf_Internal_Sym *) - symtab_hdr->contents; - if (isymbuf == NULL) - isymbuf = bfd_elf_get_elf_syms ( - abfd, - symtab_hdr, - symtab_hdr->sh_info, 0, - NULL, NULL, NULL); - if (isymbuf == NULL) - break; - } - - /* Get the value of the symbol referred to - by the reloc. */ - if (ELF32_R_SYM (irel->r_info) - < symtab_hdr->sh_info) - { - /* A local symbol. */ - Elf_Internal_Sym *isym; - asection *sym_sec; - - isym = isymbuf - + ELF32_R_SYM (irel->r_info); - sym_sec = bfd_section_from_elf_index ( - abfd, isym->st_shndx); - symval = isym->st_value; - - /* If the reloc is absolute, it will not - have a symbol or section associated - with it. */ - - if (sym_sec) - { - symval += - sym_sec->output_section->vma - + sym_sec->output_offset; - reloc_target = symval + irel->r_addend; - } - else - { - reloc_target = symval + irel->r_addend; - /* reference symbol is absolute. */ - } - } - else - { - /* reference symbol is extern. */ - } - - if (address_of_ret == reloc_target) - { - deleting_ret_is_safe = 0; - if (DEBUG_RELAX) - printf ("ret from " - "rjmp/jmp ret sequence at address" - " 0x%x could not be deleted. ret" - " is target of a relocation.\n", - (int) address_of_ret); - } - } - } - - if (deleting_ret_is_safe) - { - if (DEBUG_RELAX) - printf ("unreachable ret instruction " - "at address 0x%x deleted.\n", - (int) dot + insn_size); - - /* Delete two bytes of data. */ - if (!elf32_avr_relax_delete_bytes (abfd, sec, - irel->r_offset + insn_size, 2)) - goto error_return; - - /* That will change things, so, we should relax - again. Note that this is not required, and it - may be slow. */ - - *again = TRUE; - break; - } - } - - } - } - break; - } - } - } - - if (contents != NULL - && elf_section_data (sec)->this_hdr.contents != contents) - { - if (! link_info->keep_memory) - free (contents); - else - { - /* Cache the section contents for elf_link_input_bfd. */ - elf_section_data (sec)->this_hdr.contents = contents; - } - } - - if (internal_relocs != NULL - && elf_section_data (sec)->relocs != internal_relocs) - free (internal_relocs); - - return TRUE; - - error_return: - if (isymbuf != NULL - && symtab_hdr->contents != (unsigned char *) isymbuf) - free (isymbuf); - if (contents != NULL - && elf_section_data (sec)->this_hdr.contents != contents) - free (contents); - if (internal_relocs != NULL - && elf_section_data (sec)->relocs != internal_relocs) - free (internal_relocs); - - return FALSE; -} - /* Delete some bytes from a section while changing the size of an instruction. The parameter "addr" denotes the section-relative offset pointing just behind the shrinked instruction. "addr+count" point at the first byte just behind the original unshrinked instruction. */ + static bfd_boolean -elf32_avr_relax_delete_bytes (bfd *abfd, asection *sec, - bfd_vma addr, int count) +elf32_avr_relax_delete_bytes (bfd *abfd, + asection *sec, + bfd_vma addr, + int count) { Elf_Internal_Shdr *symtab_hdr; unsigned int sec_shndx; @@ -1783,9 +1103,9 @@ elf32_avr_relax_delete_bytes (bfd *abfd, asection *sec, { if (DEBUG_RELAX) printf ("Relocation at address 0x%x needs to be moved.\n" - "Old section offset: 0x%x, New section offset: 0x%x \n", + "Old section offset: 0x%x, New section offset: 0x%x \n", (unsigned int) old_reloc_address, - (unsigned int) irel->r_offset, + (unsigned int) irel->r_offset, (unsigned int) ((irel->r_offset) - count)); irel->r_offset -= count; @@ -1795,8 +1115,8 @@ elf32_avr_relax_delete_bytes (bfd *abfd, asection *sec, the reloc's addend if two conditions are met: 1.) the reloc is relative to a symbol in this section that is located in front of the shrinked instruction - 2.) symbol plus addend end up behind the shrinked instruction. - + 2.) symbol plus addend end up behind the shrinked instruction. + This should happen only for local symbols that are progmem related. */ /* Read this BFD's local symbols if we haven't done so already. */ @@ -1824,7 +1144,7 @@ elf32_avr_relax_delete_bytes (bfd *abfd, asection *sec, /* If the reloc is absolute, it will not have a symbol or section associated with it. */ if (sym_sec) - { + { symval += sym_sec->output_section->vma + sym_sec->output_offset; @@ -1838,7 +1158,7 @@ elf32_avr_relax_delete_bytes (bfd *abfd, asection *sec, (unsigned int) (symval + irel->r_addend), (unsigned int) shrinked_insn_address); - if ( symval <= shrinked_insn_address + if (symval <= shrinked_insn_address && (symval + irel->r_addend) > shrinked_insn_address) { irel->r_addend -= count; @@ -1850,15 +1170,9 @@ elf32_avr_relax_delete_bytes (bfd *abfd, asection *sec, (unsigned int) irel->r_addend); } } - else - { - /* Reference symbol is absolute. No adjustment needed. */ - } - } - else - { - /* Reference symbol is extern. No need for adjusting the addend. */ + /* else ... Reference symbol is absolute. No adjustment needed. */ } + /* else ... Reference symbol is extern. No need for adjusting the addend. */ } /* Adjust the local symbols defined in this section. */ @@ -1893,12 +1207,646 @@ elf32_avr_relax_delete_bytes (bfd *abfd, asection *sec, return TRUE; } -/* This is a version of bfd_generic_get_relocated_section_contents - which uses elf32_avr_relocate_section. +/* This function handles relaxing for the avr. + Many important relaxing opportunities within functions are already + realized by the compiler itself. + Here we try to replace call (4 bytes) -> rcall (2 bytes) + and jump -> rjmp (safes also 2 bytes). + As well we now optimize seqences of + - call/rcall function + - ret + to yield + - jmp/rjmp function + - ret + . In case that within a sequence + - jmp/rjmp label + - ret + the ret could no longer be reached it is optimized away. In order + to check if the ret is no longer needed, it is checked that the ret's address + is not the target of a branch or jump within the same section, it is checked + that there is no skip instruction before the jmp/rjmp and that there + is no local or global label place at the address of the ret. - For avr it's essentially a cut and paste taken from the H8300 port. + We refrain from relaxing within sections ".vectors" and + ".jumptables" in order to maintain the position of the instructions. + There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop + if possible. (In future one could possibly use the space of the nop + for the first instruction of the irq service function. + + The .jumptables sections is meant to be used for a future tablejump variant + for the devices with 3-byte program counter where the table itself + contains 4-byte jump instructions whose relative offset must not + be changed. */ + +static bfd_boolean +elf32_avr_relax_section (bfd *abfd, + asection *sec, + struct bfd_link_info *link_info, + bfd_boolean *again) +{ + Elf_Internal_Shdr *symtab_hdr; + Elf_Internal_Rela *internal_relocs; + Elf_Internal_Rela *irel, *irelend; + bfd_byte *contents = NULL; + Elf_Internal_Sym *isymbuf = NULL; + static asection *last_input_section = NULL; + static Elf_Internal_Rela *last_reloc = NULL; + + /* Assume nothing changes. */ + *again = FALSE; + + /* We don't have to do anything for a relocatable link, if + this section does not have relocs, or if this is not a + code section. */ + if (link_info->relocatable + || (sec->flags & SEC_RELOC) == 0 + || sec->reloc_count == 0 + || (sec->flags & SEC_CODE) == 0) + return TRUE; + + /* Check if the object file to relax uses internal symbols so that we + could fix up the relocations. */ + if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED)) + return TRUE; + + symtab_hdr = &elf_tdata (abfd)->symtab_hdr; + + /* Get a copy of the native relocations. */ + internal_relocs = (_bfd_elf_link_read_relocs + (abfd, sec, NULL, NULL, link_info->keep_memory)); + if (internal_relocs == NULL) + goto error_return; + + if (sec != last_input_section) + last_reloc = NULL; + + last_input_section = sec; + + /* Walk through the relocs looking for relaxing opportunities. */ + irelend = internal_relocs + sec->reloc_count; + for (irel = internal_relocs; irel < irelend; irel++) + { + bfd_vma symval; + + if ( ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL + && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL + && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL) + continue; + + /* Get the section contents if we haven't done so already. */ + if (contents == NULL) + { + /* Get cached copy if it exists. */ + if (elf_section_data (sec)->this_hdr.contents != NULL) + contents = elf_section_data (sec)->this_hdr.contents; + else + { + /* Go get them off disk. */ + if (! bfd_malloc_and_get_section (abfd, sec, &contents)) + goto error_return; + } + } + + /* Read this BFD's local symbols if we haven't done so already. */ + if (isymbuf == NULL && symtab_hdr->sh_info != 0) + { + isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; + if (isymbuf == NULL) + isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, + symtab_hdr->sh_info, 0, + NULL, NULL, NULL); + if (isymbuf == NULL) + goto error_return; + } + + + /* Get the value of the symbol referred to by the reloc. */ + if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) + { + /* A local symbol. */ + Elf_Internal_Sym *isym; + asection *sym_sec; + + isym = isymbuf + ELF32_R_SYM (irel->r_info); + sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); + symval = isym->st_value; + /* If the reloc is absolute, it will not have + a symbol or section associated with it. */ + if (sym_sec) + symval += sym_sec->output_section->vma + + sym_sec->output_offset; + } + else + { + unsigned long indx; + struct elf_link_hash_entry *h; + + /* An external symbol. */ + indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; + h = elf_sym_hashes (abfd)[indx]; + BFD_ASSERT (h != NULL); + if (h->root.type != bfd_link_hash_defined + && h->root.type != bfd_link_hash_defweak) + /* This appears to be a reference to an undefined + symbol. Just ignore it--it will be caught by the + regular reloc processing. */ + continue; + + symval = (h->root.u.def.value + + h->root.u.def.section->output_section->vma + + h->root.u.def.section->output_offset); + } + + /* For simplicity of coding, we are going to modify the section + contents, the section relocs, and the BFD symbol table. We + must tell the rest of the code not to free up this + information. It would be possible to instead create a table + of changes which have to be made, as is done in coff-mips.c; + that would be more work, but would require less memory when + the linker is run. */ + switch (ELF32_R_TYPE (irel->r_info)) + { + /* Try to turn a 22-bit absolute call/jump into an 13-bit + pc-relative rcall/rjmp. */ + case R_AVR_CALL: + { + bfd_vma value = symval + irel->r_addend; + bfd_vma dot, gap; + int distance_short_enough = 0; + + /* Get the address of this instruction. */ + dot = (sec->output_section->vma + + sec->output_offset + irel->r_offset); + + /* Compute the distance from this insn to the branch target. */ + gap = value - dot; + + /* If the distance is within -4094..+4098 inclusive, then we can + relax this jump/call. +4098 because the call/jump target + will be closer after the relaxation. */ + if ((int) gap >= -4094 && (int) gap <= 4098) + distance_short_enough = 1; + + /* Here we handle the wrap-around case. E.g. for a 16k device + we could use a rjmp to jump from address 0x100 to 0x3d00! + In order to make this work properly, we need to fill the + vaiable avr_pc_wrap_around with the appropriate value. + I.e. 0x4000 for a 16k device. */ + { + /* Shrinking the code size makes the gaps larger in the + case of wrap-arounds. So we use a heuristical safety + margin to avoid that during relax the distance gets + again too large for the short jumps. Let's assume + a typical code-size reduction due to relax for a + 16k device of 600 bytes. So let's use twice the + typical value as safety margin. */ + int rgap; + int safety_margin; + + int assumed_shrink = 600; + if (avr_pc_wrap_around > 0x4000) + assumed_shrink = 900; + + safety_margin = 2 * assumed_shrink; + + rgap = avr_relative_distance_considering_wrap_around (gap); + + if (rgap >= (-4092 + safety_margin) + && rgap <= (4094 - safety_margin)) + distance_short_enough = 1; + } + + if (distance_short_enough) + { + unsigned char code_msb; + unsigned char code_lsb; + + if (DEBUG_RELAX) + printf ("shrinking jump/call instruction at address 0x%x" + " in section %s\n\n", + (int) dot, sec->name); + + /* Note that we've changed the relocs, section contents, + etc. */ + elf_section_data (sec)->relocs = internal_relocs; + elf_section_data (sec)->this_hdr.contents = contents; + symtab_hdr->contents = (unsigned char *) isymbuf; + + /* Get the instruction code for relaxing. */ + code_lsb = bfd_get_8 (abfd, contents + irel->r_offset); + code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1); + + /* Mask out the relocation bits. */ + code_msb &= 0x94; + code_lsb &= 0x0E; + if (code_msb == 0x94 && code_lsb == 0x0E) + { + /* we are changing call -> rcall . */ + bfd_put_8 (abfd, 0x00, contents + irel->r_offset); + bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1); + } + else if (code_msb == 0x94 && code_lsb == 0x0C) + { + /* we are changeing jump -> rjmp. */ + bfd_put_8 (abfd, 0x00, contents + irel->r_offset); + bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1); + } + else + abort (); + + /* Fix the relocation's type. */ + irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), + R_AVR_13_PCREL); + + /* Check for the vector section. There we don't want to + modify the ordering! */ + + if (!strcmp (sec->name,".vectors") + || !strcmp (sec->name,".jumptables")) + { + /* Let's insert a nop. */ + bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2); + bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3); + } + else + { + /* Delete two bytes of data. */ + if (!elf32_avr_relax_delete_bytes (abfd, sec, + irel->r_offset + 2, 2)) + goto error_return; + + /* That will change things, so, we should relax again. + Note that this is not required, and it may be slow. */ + *again = TRUE; + } + } + } + + default: + { + unsigned char code_msb; + unsigned char code_lsb; + bfd_vma dot; + + code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1); + code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0); + + /* Get the address of this instruction. */ + dot = (sec->output_section->vma + + sec->output_offset + irel->r_offset); + + /* Here we look for rcall/ret or call/ret sequences that could be + safely replaced by rjmp/ret or jmp/ret */ + if (0xd0 == (code_msb & 0xf0)) + { + /* This insn is a rcall. */ + unsigned char next_insn_msb = 0; + unsigned char next_insn_lsb = 0; + + if (irel->r_offset + 3 < sec->size) + { + next_insn_msb = + bfd_get_8 (abfd, contents + irel->r_offset + 3); + next_insn_lsb = + bfd_get_8 (abfd, contents + irel->r_offset + 2); + } + + if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb)) + { + /* The next insn is a ret. We now convert the rcall insn + into a rjmp instruction. */ + code_msb &= 0xef; + bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1); + if (DEBUG_RELAX) + printf ("converted rcall/ret sequence at address 0x%x" + " into rjmp/ret sequence. Section is %s\n\n", + (int) dot, sec->name); + *again = TRUE; + break; + } + } + else if ((0x94 == (code_msb & 0xfe)) + && (0x0e == (code_lsb & 0x0e))) + { + /* This insn is a call. */ + unsigned char next_insn_msb = 0; + unsigned char next_insn_lsb = 0; + + if (irel->r_offset + 5 < sec->size) + { + next_insn_msb = + bfd_get_8 (abfd, contents + irel->r_offset + 5); + next_insn_lsb = + bfd_get_8 (abfd, contents + irel->r_offset + 4); + } + + if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb)) + { + /* The next insn is a ret. We now convert the call insn + into a jmp instruction. */ + + code_lsb &= 0xfd; + bfd_put_8 (abfd, code_lsb, contents + irel->r_offset); + if (DEBUG_RELAX) + printf ("converted call/ret sequence at address 0x%x" + " into jmp/ret sequence. Section is %s\n\n", + (int) dot, sec->name); + *again = TRUE; + break; + } + } + else if ((0xc0 == (code_msb & 0xf0)) + || ((0x94 == (code_msb & 0xfe)) + && (0x0c == (code_lsb & 0x0e)))) + { + /* This insn is a rjmp or a jmp. */ + unsigned char next_insn_msb = 0; + unsigned char next_insn_lsb = 0; + int insn_size; + + if (0xc0 == (code_msb & 0xf0)) + insn_size = 2; /* rjmp insn */ + else + insn_size = 4; /* jmp insn */ + + if (irel->r_offset + insn_size + 1 < sec->size) + { + next_insn_msb = + bfd_get_8 (abfd, contents + irel->r_offset + + insn_size + 1); + next_insn_lsb = + bfd_get_8 (abfd, contents + irel->r_offset + + insn_size); + } + + if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb)) + { + /* The next insn is a ret. We possibly could delete + this ret. First we need to check for preceeding + sbis/sbic/sbrs or cpse "skip" instructions. */ + + int there_is_preceeding_non_skip_insn = 1; + bfd_vma address_of_ret; + + address_of_ret = dot + insn_size; + + if (DEBUG_RELAX && (insn_size == 2)) + printf ("found rjmp / ret sequence at address 0x%x\n", + (int) dot); + if (DEBUG_RELAX && (insn_size == 4)) + printf ("found jmp / ret sequence at address 0x%x\n", + (int) dot); + + /* We have to make sure that there is a preceeding insn. */ + if (irel->r_offset >= 2) + { + unsigned char preceeding_msb; + unsigned char preceeding_lsb; + preceeding_msb = + bfd_get_8 (abfd, contents + irel->r_offset - 1); + preceeding_lsb = + bfd_get_8 (abfd, contents + irel->r_offset - 2); + + /* sbic. */ + if (0x99 == preceeding_msb) + there_is_preceeding_non_skip_insn = 0; + + /* sbis. */ + if (0x9b == preceeding_msb) + there_is_preceeding_non_skip_insn = 0; + + /* sbrc */ + if ((0xfc == (preceeding_msb & 0xfe) + && (0x00 == (preceeding_lsb & 0x08)))) + there_is_preceeding_non_skip_insn = 0; + + /* sbrs */ + if ((0xfe == (preceeding_msb & 0xfe) + && (0x00 == (preceeding_lsb & 0x08)))) + there_is_preceeding_non_skip_insn = 0; + + /* cpse */ + if (0x10 == (preceeding_msb & 0xfc)) + there_is_preceeding_non_skip_insn = 0; + + if (there_is_preceeding_non_skip_insn == 0) + if (DEBUG_RELAX) + printf ("preceeding skip insn prevents deletion of" + " ret insn at addr 0x%x in section %s\n", + (int) dot + 2, sec->name); + } + else + { + /* There is no previous instruction. */ + there_is_preceeding_non_skip_insn = 0; + } + + if (there_is_preceeding_non_skip_insn) + { + /* We now only have to make sure that there is no + local label defined at the address of the ret + instruction and that there is no local relocation + in this section pointing to the ret. */ + + int deleting_ret_is_safe = 1; + unsigned int section_offset_of_ret_insn = + irel->r_offset + insn_size; + Elf_Internal_Sym *isym, *isymend; + unsigned int sec_shndx; + + sec_shndx = + _bfd_elf_section_from_bfd_section (abfd, sec); + + /* Check for local symbols. */ + isym = (Elf_Internal_Sym *) symtab_hdr->contents; + isymend = isym + symtab_hdr->sh_info; + for (; isym < isymend; isym++) + { + if (isym->st_value == section_offset_of_ret_insn + && isym->st_shndx == sec_shndx) + { + deleting_ret_is_safe = 0; + if (DEBUG_RELAX) + printf ("local label prevents deletion of ret " + "insn at address 0x%x\n", + (int) dot + insn_size); + } + } + + /* Now check for global symbols. */ + { + int symcount; + struct elf_link_hash_entry **sym_hashes; + struct elf_link_hash_entry **end_hashes; + + symcount = (symtab_hdr->sh_size + / sizeof (Elf32_External_Sym) + - symtab_hdr->sh_info); + sym_hashes = elf_sym_hashes (abfd); + end_hashes = sym_hashes + symcount; + for (; sym_hashes < end_hashes; sym_hashes++) + { + struct elf_link_hash_entry *sym_hash = + *sym_hashes; + if ((sym_hash->root.type == bfd_link_hash_defined + || sym_hash->root.type == + bfd_link_hash_defweak) + && sym_hash->root.u.def.section == sec + && sym_hash->root.u.def.value == section_offset_of_ret_insn) + { + deleting_ret_is_safe = 0; + if (DEBUG_RELAX) + printf ("global label prevents deletion of " + "ret insn at address 0x%x\n", + (int) dot + insn_size); + } + } + } + /* Now we check for relocations pointing to ret. */ + { + Elf_Internal_Rela *irel; + Elf_Internal_Rela *relend; + Elf_Internal_Shdr *symtab_hdr; + + symtab_hdr = &elf_tdata (abfd)->symtab_hdr; + relend = elf_section_data (sec)->relocs + + sec->reloc_count; + + for (irel = elf_section_data (sec)->relocs; + irel < relend; irel++) + { + bfd_vma reloc_target = 0; + bfd_vma symval; + Elf_Internal_Sym *isymbuf = NULL; + + /* Read this BFD's local symbols if we haven't + done so already. */ + if (isymbuf == NULL && symtab_hdr->sh_info != 0) + { + isymbuf = (Elf_Internal_Sym *) + symtab_hdr->contents; + if (isymbuf == NULL) + isymbuf = bfd_elf_get_elf_syms + (abfd, + symtab_hdr, + symtab_hdr->sh_info, 0, + NULL, NULL, NULL); + if (isymbuf == NULL) + break; + } + + /* Get the value of the symbol referred to + by the reloc. */ + if (ELF32_R_SYM (irel->r_info) + < symtab_hdr->sh_info) + { + /* A local symbol. */ + Elf_Internal_Sym *isym; + asection *sym_sec; + + isym = isymbuf + + ELF32_R_SYM (irel->r_info); + sym_sec = bfd_section_from_elf_index + (abfd, isym->st_shndx); + symval = isym->st_value; + + /* If the reloc is absolute, it will not + have a symbol or section associated + with it. */ + + if (sym_sec) + { + symval += + sym_sec->output_section->vma + + sym_sec->output_offset; + reloc_target = symval + irel->r_addend; + } + else + { + reloc_target = symval + irel->r_addend; + /* Reference symbol is absolute. */ + } + } + /* else ... reference symbol is extern. */ + + if (address_of_ret == reloc_target) + { + deleting_ret_is_safe = 0; + if (DEBUG_RELAX) + printf ("ret from " + "rjmp/jmp ret sequence at address" + " 0x%x could not be deleted. ret" + " is target of a relocation.\n", + (int) address_of_ret); + } + } + } + + if (deleting_ret_is_safe) + { + if (DEBUG_RELAX) + printf ("unreachable ret instruction " + "at address 0x%x deleted.\n", + (int) dot + insn_size); + + /* Delete two bytes of data. */ + if (!elf32_avr_relax_delete_bytes (abfd, sec, + irel->r_offset + insn_size, 2)) + goto error_return; + + /* That will change things, so, we should relax + again. Note that this is not required, and it + may be slow. */ + *again = TRUE; + break; + } + } + + } + } + break; + } + } + } + + if (contents != NULL + && elf_section_data (sec)->this_hdr.contents != contents) + { + if (! link_info->keep_memory) + free (contents); + else + { + /* Cache the section contents for elf_link_input_bfd. */ + elf_section_data (sec)->this_hdr.contents = contents; + } + } + + if (internal_relocs != NULL + && elf_section_data (sec)->relocs != internal_relocs) + free (internal_relocs); + + return TRUE; + + error_return: + if (isymbuf != NULL + && symtab_hdr->contents != (unsigned char *) isymbuf) + free (isymbuf); + if (contents != NULL + && elf_section_data (sec)->this_hdr.contents != contents) + free (contents); + if (internal_relocs != NULL + && elf_section_data (sec)->relocs != internal_relocs) + free (internal_relocs); + + return FALSE; +} + +/* This is a version of bfd_generic_get_relocated_section_contents + which uses elf32_avr_relocate_section. + + For avr it's essentially a cut and paste taken from the H8300 port. The author of the relaxation support patch for avr had absolutely no - clue what is happening here but found out that this part of the code + clue what is happening here but found out that this part of the code seems to be important. */ static bfd_byte * @@ -1937,8 +1885,7 @@ elf32_avr_get_relocated_section_contents (bfd *output_bfd, bfd_size_type amt; internal_relocs = (_bfd_elf_link_read_relocs - (input_bfd, input_section, (PTR) NULL, - (Elf_Internal_Rela *) NULL, FALSE)); + (input_bfd, input_section, NULL, NULL, FALSE)); if (internal_relocs == NULL) goto error_return; @@ -1955,7 +1902,7 @@ elf32_avr_get_relocated_section_contents (bfd *output_bfd, amt = symtab_hdr->sh_info; amt *= sizeof (asection *); - sections = (asection **) bfd_malloc (amt); + sections = bfd_malloc (amt); if (sections == NULL && amt != 0) goto error_return;