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"
#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 */
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 */
};
/* 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;
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;
/* 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;
}
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)
{
}
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;
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;
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;
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;
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;
/* 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;
/* 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;
}
/* 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;
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;
/* 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:
/* Enable debugging printout at stdout with a value of 1. */
#define DEBUG_RELAX 0
+/* 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)
+{
+ Elf_Internal_Shdr *symtab_hdr;
+ unsigned int sec_shndx;
+ bfd_byte *contents;
+ Elf_Internal_Rela *irel, *irelend;
+ Elf_Internal_Rela *irelalign;
+ Elf_Internal_Sym *isym;
+ Elf_Internal_Sym *isymbuf = NULL;
+ Elf_Internal_Sym *isymend;
+ bfd_vma toaddr;
+ struct elf_link_hash_entry **sym_hashes;
+ struct elf_link_hash_entry **end_hashes;
+ unsigned int symcount;
+
+ symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
+ contents = elf_section_data (sec)->this_hdr.contents;
+
+ /* The deletion must stop at the next ALIGN reloc for an aligment
+ power larger than the number of bytes we are deleting. */
+
+ irelalign = NULL;
+ toaddr = sec->size;
+
+ irel = elf_section_data (sec)->relocs;
+ irelend = irel + sec->reloc_count;
+
+ /* Actually delete the bytes. */
+ if (toaddr - addr - count > 0)
+ memmove (contents + addr, contents + addr + count,
+ (size_t) (toaddr - addr - count));
+ sec->size -= count;
+
+ /* Adjust all the relocs. */
+ for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
+ {
+ bfd_vma symval;
+ bfd_vma old_reloc_address;
+ bfd_vma shrinked_insn_address;
+
+ old_reloc_address = (sec->output_section->vma
+ + sec->output_offset + irel->r_offset);
+ shrinked_insn_address = (sec->output_section->vma
+ + sec->output_offset + addr - count);
+
+ /* Get the new reloc address. */
+ if ((irel->r_offset > addr
+ && irel->r_offset < toaddr))
+ {
+ 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",
+ (unsigned int) old_reloc_address,
+ (unsigned int) irel->r_offset,
+ (unsigned int) ((irel->r_offset) - count));
+
+ irel->r_offset -= count;
+ }
+
+ /* The reloc's own addresses are now ok. However, we need to readjust
+ 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.
+
+ This should happen only for local symbols that are progmem related. */
+
+ /* 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)
+ return FALSE;
+ }
+
+ /* 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;
+
+ if (DEBUG_RELAX)
+ printf ("Checking if the relocation's "
+ "addend needs corrections.\n"
+ "Address of anchor symbol: 0x%x \n"
+ "Address of relocation target: 0x%x \n"
+ "Address of relaxed insn: 0x%x \n",
+ (unsigned int) symval,
+ (unsigned int) (symval + irel->r_addend),
+ (unsigned int) shrinked_insn_address);
+
+ if (symval <= shrinked_insn_address
+ && (symval + irel->r_addend) > shrinked_insn_address)
+ {
+ irel->r_addend -= count;
+
+ if (DEBUG_RELAX)
+ printf ("Anchor symbol and relocation target bracket "
+ "shrinked insn address.\n"
+ "Need for new addend : 0x%x\n",
+ (unsigned int) irel->r_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. */
+ isym = (Elf_Internal_Sym *) symtab_hdr->contents;
+ isymend = isym + symtab_hdr->sh_info;
+ for (; isym < isymend; isym++)
+ {
+ if (isym->st_shndx == sec_shndx
+ && isym->st_value > addr
+ && isym->st_value < toaddr)
+ isym->st_value -= count;
+ }
+
+ /* Now adjust the global symbols defined in this section. */
+ 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 > addr
+ && sym_hash->root.u.def.value < toaddr)
+ {
+ sym_hash->root.u.def.value -= count;
+ }
+ }
+
+ return TRUE;
+}
+
/* 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
+ and jump -> rjmp (safes also 2 bytes).
+ As well we now optimize seqences of
- call/rcall function
- ret
to yield
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.
+ ".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
+ 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
+ contains 4-byte jump instructions whose relative offset must not
be changed. */
-
+
static bfd_boolean
-elf32_avr_relax_section (bfd *abfd, asection *sec,
+elf32_avr_relax_section (bfd *abfd,
+ asection *sec,
struct bfd_link_info *link_info,
bfd_boolean *again)
{
|| 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));
+ (abfd, sec, NULL, NULL, link_info->keep_memory));
if (internal_relocs == NULL)
goto error_return;
{
bfd_vma symval;
- if (ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
+ 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)
{
else
{
/* Go get them off disk. */
- if (!bfd_malloc_and_get_section (abfd, sec, &contents))
+ if (! bfd_malloc_and_get_section (abfd, sec, &contents))
goto error_return;
}
}
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;
- }
+ /* 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);
/* 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. */
+ 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!
+ 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. */
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. */
-
+ 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)
+
+ if (rgap >= (-4092 + safety_margin)
&& rgap <= (4094 - safety_margin))
- distance_short_enough = 1;
- }
+ distance_short_enough = 1;
+ }
if (distance_short_enough)
{
bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
}
- else
+ else
abort ();
/* Fix the relocation's type. */
}
}
}
+
default:
{
unsigned char code_msb;
/* 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
+
+ /* 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))
{
if (irel->r_offset + 3 < sec->size)
{
- next_insn_msb =
+ next_insn_msb =
bfd_get_8 (abfd, contents + irel->r_offset + 3);
- next_insn_lsb =
+ next_insn_lsb =
bfd_get_8 (abfd, contents + irel->r_offset + 2);
}
- if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
+
+ 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)
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
break;
}
}
- else if ((0xc0 == (code_msb & 0xf0))
- || ((0x94 == (code_msb & 0xfe))
+ else if ((0xc0 == (code_msb & 0xf0))
+ || ((0x94 == (code_msb & 0xfe))
&& (0x0c == (code_lsb & 0x0e))))
{
- /* this insn is a rjmp or a jmp. */
+ /* This insn is a rjmp or a jmp. */
unsigned char next_insn_msb = 0;
unsigned char next_insn_lsb = 0;
int insn_size;
if (irel->r_offset + insn_size + 1 < sec->size)
{
- next_insn_msb =
- bfd_get_8 (abfd, contents + irel->r_offset
+ 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
+ next_insn_lsb =
+ bfd_get_8 (abfd, contents + irel->r_offset
+ insn_size);
}
address_of_ret = dot + insn_size;
if (DEBUG_RELAX && (insn_size == 2))
- printf ("found rjmp / ret sequence at "
- "address 0x%x\n",
+ 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",
+ printf ("found jmp / ret sequence at address 0x%x\n",
(int) dot);
/* We have to make sure that there is a preceeding insn. */
{
unsigned char preceeding_msb;
unsigned char preceeding_lsb;
- preceeding_msb =
+ preceeding_msb =
bfd_get_8 (abfd, contents + irel->r_offset - 1);
- preceeding_lsb =
+ preceeding_lsb =
bfd_get_8 (abfd, contents + irel->r_offset - 2);
/* sbic. */
- if (0x99 == preceeding_msb)
+ if (0x99 == preceeding_msb)
there_is_preceeding_non_skip_insn = 0;
/* sbis. */
- if (0x9b == preceeding_msb)
+ if (0x9b == preceeding_msb)
there_is_preceeding_non_skip_insn = 0;
/* sbrc */
&& (0x00 == (preceeding_lsb & 0x08))))
there_is_preceeding_non_skip_insn = 0;
- /* sbrs */
+ /* 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"
{
/* There is no previous instruction. */
there_is_preceeding_non_skip_insn = 0;
- }
+ }
if (there_is_preceeding_non_skip_insn)
{
in this section pointing to the ret. */
int deleting_ret_is_safe = 1;
- unsigned int section_offset_of_ret_insn =
+ 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);
+
+ sec_shndx =
+ _bfd_elf_section_from_bfd_section (abfd, sec);
/* Check for local symbols. */
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
struct elf_link_hash_entry **sym_hashes;
struct elf_link_hash_entry **end_hashes;
- symcount = (symtab_hdr->sh_size
+ 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 =
+ 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.type ==
+ bfd_link_hash_defweak)
&& sym_hash->root.u.def.section == sec
- && sym_hash->root.u.def.value ==
- section_offset_of_ret_insn)
+ && sym_hash->root.u.def.value == section_offset_of_ret_insn)
{
deleting_ret_is_safe = 0;
if (DEBUG_RELAX)
Elf_Internal_Rela *relend;
Elf_Internal_Shdr *symtab_hdr;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
- relend = elf_section_data (sec)->relocs
+ symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ relend = elf_section_data (sec)->relocs
+ sec->reloc_count;
- for (irel = elf_section_data (sec)->relocs;
+ 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
+
+ /* 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 *)
+ 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);
+ 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
+
+ /* Get the value of the symbol referred to
by the reloc. */
- if (ELF32_R_SYM (irel->r_info)
+ if (ELF32_R_SYM (irel->r_info)
< symtab_hdr->sh_info)
{
/* A local symbol. */
Elf_Internal_Sym *isym;
asection *sym_sec;
- isym = isymbuf
+ 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
+ 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 +=
+ {
+ 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. */
+ /* Reference symbol is absolute. */
}
}
- else
- {
- /* reference symbol is extern. */
- }
-
+ /* else ... reference symbol is extern. */
+
if (address_of_ret == reloc_target)
- {
+ {
deleting_ret_is_safe = 0;
if (DEBUG_RELAX)
printf ("ret from "
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
+ /* That will change things, so, we should relax
+ again. Note that this is not required, and it
may be slow. */
-
*again = TRUE;
break;
}
}
-
- }
- }
+
+ }
+ }
break;
}
}
&& 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)
-{
- Elf_Internal_Shdr *symtab_hdr;
- unsigned int sec_shndx;
- bfd_byte *contents;
- Elf_Internal_Rela *irel, *irelend;
- Elf_Internal_Rela *irelalign;
- Elf_Internal_Sym *isym;
- Elf_Internal_Sym *isymbuf = NULL;
- Elf_Internal_Sym *isymend;
- bfd_vma toaddr;
- struct elf_link_hash_entry **sym_hashes;
- struct elf_link_hash_entry **end_hashes;
- unsigned int symcount;
-
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
- sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
- contents = elf_section_data (sec)->this_hdr.contents;
-
- /* The deletion must stop at the next ALIGN reloc for an aligment
- power larger than the number of bytes we are deleting. */
-
- irelalign = NULL;
- toaddr = sec->size;
-
- irel = elf_section_data (sec)->relocs;
- irelend = irel + sec->reloc_count;
-
- /* Actually delete the bytes. */
- if (toaddr - addr - count > 0)
- memmove (contents + addr, contents + addr + count,
- (size_t) (toaddr - addr - count));
- sec->size -= count;
-
- /* Adjust all the relocs. */
- for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
- {
- bfd_vma symval;
- bfd_vma old_reloc_address;
- bfd_vma shrinked_insn_address;
-
- old_reloc_address = (sec->output_section->vma
- + sec->output_offset + irel->r_offset);
- shrinked_insn_address = (sec->output_section->vma
- + sec->output_offset + addr - count);
-
- /* Get the new reloc address. */
- if ((irel->r_offset > addr
- && irel->r_offset < toaddr))
- {
- 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",
- (unsigned int) old_reloc_address,
- (unsigned int) irel->r_offset,
- (unsigned int) ((irel->r_offset) - count));
-
- irel->r_offset -= count;
- }
-
- /* The reloc's own addresses are now ok. However, we need to readjust
- 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.
-
- This should happen only for local symbols that are progmem related. */
-
- /* 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)
- return FALSE;
- }
-
- /* 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;
-
- if (DEBUG_RELAX)
- printf ("Checking if the relocation's "
- "addend needs corrections.\n"
- "Address of anchor symbol: 0x%x \n"
- "Address of relocation target: 0x%x \n"
- "Address of relaxed insn: 0x%x \n",
- (unsigned int) symval,
- (unsigned int) (symval + irel->r_addend),
- (unsigned int) shrinked_insn_address);
-
- if ( symval <= shrinked_insn_address
- && (symval + irel->r_addend) > shrinked_insn_address)
- {
- irel->r_addend -= count;
-
- if (DEBUG_RELAX)
- printf ("Anchor symbol and relocation target bracket "
- "shrinked insn address.\n"
- "Need for new addend : 0x%x\n",
- (unsigned int) irel->r_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. */
- isym = (Elf_Internal_Sym *) symtab_hdr->contents;
- isymend = isym + symtab_hdr->sh_info;
- for (; isym < isymend; isym++)
- {
- if (isym->st_shndx == sec_shndx
- && isym->st_value > addr
- && isym->st_value < toaddr)
- isym->st_value -= count;
- }
-
- /* Now adjust the global symbols defined in this section. */
- 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 > addr
- && sym_hash->root.u.def.value < toaddr)
- {
- sym_hash->root.u.def.value -= count;
- }
- }
-
- return TRUE;
+ return FALSE;
}
/* This is a version of bfd_generic_get_relocated_section_contents
- which uses elf32_avr_relocate_section.
+ which uses elf32_avr_relocate_section.
- For avr it's essentially a cut and paste taken from the H8300 port.
+ 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 *
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;
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;
projects / external / binutils.git / commitdiff