/* Xtensa-specific support for 32-bit ELF.
- Copyright 2003, 2004 Free Software Foundation, Inc.
+ Copyright 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
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., 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+ 02110-1301, USA. */
#include "bfd.h"
#include "sysdep.h"
-#ifdef ANSI_PROTOTYPES
#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
#include <strings.h>
#include "bfdlink.h"
#define XTENSA_NO_NOP_REMOVAL 0
-/* Main interface functions. */
-static void elf_xtensa_info_to_howto_rela
- PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
-static reloc_howto_type *elf_xtensa_reloc_type_lookup
- PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
-extern int xtensa_read_table_entries
- PARAMS ((bfd *, asection *, property_table_entry **, const char *,
- bfd_boolean));
-static bfd_boolean elf_xtensa_check_relocs
- PARAMS ((bfd *, struct bfd_link_info *, asection *,
- const Elf_Internal_Rela *));
-static void elf_xtensa_hide_symbol
- PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean));
-static asection *elf_xtensa_gc_mark_hook
- PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
- struct elf_link_hash_entry *, Elf_Internal_Sym *));
-static bfd_boolean elf_xtensa_gc_sweep_hook
- PARAMS ((bfd *, struct bfd_link_info *, asection *,
- const Elf_Internal_Rela *));
-static bfd_boolean elf_xtensa_create_dynamic_sections
- PARAMS ((bfd *, struct bfd_link_info *));
-static bfd_boolean elf_xtensa_adjust_dynamic_symbol
- PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
-static bfd_boolean elf_xtensa_size_dynamic_sections
- PARAMS ((bfd *, struct bfd_link_info *));
-static bfd_boolean elf_xtensa_modify_segment_map
- PARAMS ((bfd *, struct bfd_link_info *));
-static bfd_boolean elf_xtensa_relocate_section
- PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
- Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
-static bfd_boolean elf_xtensa_relax_section
- PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *again));
-static bfd_boolean elf_xtensa_finish_dynamic_symbol
- PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
- Elf_Internal_Sym *));
-static bfd_boolean elf_xtensa_finish_dynamic_sections
- PARAMS ((bfd *, struct bfd_link_info *));
-static bfd_boolean elf_xtensa_merge_private_bfd_data
- PARAMS ((bfd *, bfd *));
-static bfd_boolean elf_xtensa_set_private_flags
- PARAMS ((bfd *, flagword));
-extern flagword elf_xtensa_get_private_bfd_flags
- PARAMS ((bfd *));
-static bfd_boolean elf_xtensa_print_private_bfd_data
- PARAMS ((bfd *, PTR));
-static bfd_boolean elf_xtensa_object_p
- PARAMS ((bfd *));
-static void elf_xtensa_final_write_processing
- PARAMS ((bfd *, bfd_boolean));
-static enum elf_reloc_type_class elf_xtensa_reloc_type_class
- PARAMS ((const Elf_Internal_Rela *));
-static bfd_boolean elf_xtensa_discard_info
- PARAMS ((bfd *, struct elf_reloc_cookie *, struct bfd_link_info *));
-static bfd_boolean elf_xtensa_ignore_discarded_relocs
- PARAMS ((asection *));
-static bfd_boolean elf_xtensa_grok_prstatus
- PARAMS ((bfd *, Elf_Internal_Note *));
-static bfd_boolean elf_xtensa_grok_psinfo
- PARAMS ((bfd *, Elf_Internal_Note *));
-static bfd_boolean elf_xtensa_new_section_hook
- PARAMS ((bfd *, asection *));
-
-
/* Local helper functions. */
-static bfd_boolean xtensa_elf_dynamic_symbol_p
- PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *));
-static int property_table_compare
- PARAMS ((const PTR, const PTR));
-static int property_table_matches
- PARAMS ((const PTR, const PTR));
-static property_table_entry *elf_xtensa_find_property_entry
- PARAMS ((property_table_entry *, int, bfd_vma));
-static bfd_boolean elf_xtensa_in_literal_pool
- PARAMS ((property_table_entry *, int, bfd_vma));
-static void elf_xtensa_make_sym_local
- PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
-static bfd_boolean add_extra_plt_sections
- PARAMS ((bfd *, int));
-static bfd_boolean elf_xtensa_fix_refcounts
- PARAMS ((struct elf_link_hash_entry *, PTR));
-static bfd_boolean elf_xtensa_allocate_plt_size
- PARAMS ((struct elf_link_hash_entry *, PTR));
-static bfd_boolean elf_xtensa_allocate_got_size
- PARAMS ((struct elf_link_hash_entry *, PTR));
-static void elf_xtensa_allocate_local_got_size
- PARAMS ((struct bfd_link_info *, asection *));
-static bfd_reloc_status_type elf_xtensa_do_reloc
- PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_vma, bfd_byte *,
- bfd_vma, bfd_boolean, char **));
-static char * vsprint_msg
- VPARAMS ((const char *, const char *, int, ...));
-static char *build_encoding_error_message
- PARAMS ((xtensa_opcode, bfd_vma));
+static bfd_boolean add_extra_plt_sections (bfd *, int);
+static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
static bfd_reloc_status_type bfd_elf_xtensa_reloc
- PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+ (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
static bfd_boolean do_fix_for_relocatable_link
- PARAMS ((Elf_Internal_Rela *, bfd *, asection *, bfd_byte *));
+ (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *);
static void do_fix_for_final_link
- PARAMS ((Elf_Internal_Rela *, bfd *, asection *, bfd_byte *, bfd_vma *));
-static bfd_vma elf_xtensa_create_plt_entry
- PARAMS ((bfd *, bfd *, unsigned));
-static int elf_xtensa_combine_prop_entries
- PARAMS ((bfd *, asection *, asection *));
-static bfd_boolean elf_xtensa_discard_info_for_section
- PARAMS ((bfd *, struct elf_reloc_cookie *, struct bfd_link_info *,
- asection *));
+ (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *, bfd_vma *);
/* Local functions to handle Xtensa configurability. */
-static void init_call_opcodes
- PARAMS ((void));
-static bfd_boolean is_indirect_call_opcode
- PARAMS ((xtensa_opcode));
-static bfd_boolean is_direct_call_opcode
- PARAMS ((xtensa_opcode));
-static bfd_boolean is_windowed_call_opcode
- PARAMS ((xtensa_opcode));
-static xtensa_opcode get_const16_opcode
- PARAMS ((void));
-static xtensa_opcode get_l32r_opcode
- PARAMS ((void));
-static bfd_vma l32r_offset
- PARAMS ((bfd_vma, bfd_vma));
-static int get_relocation_opnd
- PARAMS ((xtensa_opcode, int));
-static int get_relocation_slot
- PARAMS ((int));
+static bfd_boolean is_indirect_call_opcode (xtensa_opcode);
+static bfd_boolean is_direct_call_opcode (xtensa_opcode);
+static bfd_boolean is_windowed_call_opcode (xtensa_opcode);
+static xtensa_opcode get_const16_opcode (void);
+static xtensa_opcode get_l32r_opcode (void);
+static bfd_vma l32r_offset (bfd_vma, bfd_vma);
+static int get_relocation_opnd (xtensa_opcode, int);
+static int get_relocation_slot (int);
static xtensa_opcode get_relocation_opcode
- PARAMS ((bfd *, asection *, bfd_byte *, Elf_Internal_Rela *));
+ (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
static bfd_boolean is_l32r_relocation
- PARAMS ((bfd *, asection *, bfd_byte *, Elf_Internal_Rela *));
-static bfd_boolean is_alt_relocation
- PARAMS ((int));
-static bfd_boolean is_operand_relocation
- PARAMS ((int));
+ (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
+static bfd_boolean is_alt_relocation (int);
+static bfd_boolean is_operand_relocation (int);
static bfd_size_type insn_decode_len
- PARAMS ((bfd_byte *, bfd_size_type, bfd_size_type));
+ (bfd_byte *, bfd_size_type, bfd_size_type);
static xtensa_opcode insn_decode_opcode
- PARAMS ((bfd_byte *, bfd_size_type, bfd_size_type, int));
+ (bfd_byte *, bfd_size_type, bfd_size_type, int);
static bfd_boolean check_branch_target_aligned
- PARAMS ((bfd_byte *, bfd_size_type, bfd_vma, bfd_vma));
+ (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
static bfd_boolean check_loop_aligned
- PARAMS ((bfd_byte *, bfd_size_type, bfd_vma, bfd_vma));
-static bfd_boolean check_branch_target_aligned_address
- PARAMS ((bfd_vma, int));
+ (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
+static bfd_boolean check_branch_target_aligned_address (bfd_vma, int);
static bfd_size_type get_asm_simplify_size
- PARAMS ((bfd_byte *, bfd_size_type, bfd_size_type));
+ (bfd_byte *, bfd_size_type, bfd_size_type);
/* Functions for link-time code simplifications. */
static bfd_reloc_status_type elf_xtensa_do_asm_simplify
- PARAMS ((bfd_byte *, bfd_vma, bfd_vma, char **));
+ (bfd_byte *, bfd_vma, bfd_vma, char **);
static bfd_reloc_status_type contract_asm_expansion
- PARAMS ((bfd_byte *, bfd_vma, Elf_Internal_Rela *, char **));
-static xtensa_opcode swap_callx_for_call_opcode
- PARAMS ((xtensa_opcode));
-static xtensa_opcode get_expanded_call_opcode
- PARAMS ((bfd_byte *, int, bfd_boolean *));
+ (bfd_byte *, bfd_vma, Elf_Internal_Rela *, char **);
+static xtensa_opcode swap_callx_for_call_opcode (xtensa_opcode);
+static xtensa_opcode get_expanded_call_opcode (bfd_byte *, int, bfd_boolean *);
/* Access to internal relocations, section contents and symbols. */
static Elf_Internal_Rela *retrieve_internal_relocs
- PARAMS ((bfd *, asection *, bfd_boolean));
-static void pin_internal_relocs
- PARAMS ((asection *, Elf_Internal_Rela *));
-static void release_internal_relocs
- PARAMS ((asection *, Elf_Internal_Rela *));
-static bfd_byte *retrieve_contents
- PARAMS ((bfd *, asection *, bfd_boolean));
-static void pin_contents
- PARAMS ((asection *, bfd_byte *));
-static void release_contents
- PARAMS ((asection *, bfd_byte *));
-static Elf_Internal_Sym *retrieve_local_syms
- PARAMS ((bfd *));
+ (bfd *, asection *, bfd_boolean);
+static void pin_internal_relocs (asection *, Elf_Internal_Rela *);
+static void release_internal_relocs (asection *, Elf_Internal_Rela *);
+static bfd_byte *retrieve_contents (bfd *, asection *, bfd_boolean);
+static void pin_contents (asection *, bfd_byte *);
+static void release_contents (asection *, bfd_byte *);
+static Elf_Internal_Sym *retrieve_local_syms (bfd *);
/* Miscellaneous utility functions. */
-static asection *elf_xtensa_get_plt_section
- PARAMS ((bfd *, int));
-static asection *elf_xtensa_get_gotplt_section
- PARAMS ((bfd *, int));
-static asection *get_elf_r_symndx_section
- PARAMS ((bfd *, unsigned long));
+static asection *elf_xtensa_get_plt_section (bfd *, int);
+static asection *elf_xtensa_get_gotplt_section (bfd *, int);
+static asection *get_elf_r_symndx_section (bfd *, unsigned long);
static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry
- PARAMS ((bfd *, unsigned long));
-static bfd_vma get_elf_r_symndx_offset
- PARAMS ((bfd *, unsigned long));
-static bfd_boolean is_reloc_sym_weak
- PARAMS ((bfd *, Elf_Internal_Rela *));
-static bfd_boolean pcrel_reloc_fits
- PARAMS ((xtensa_opcode, int, bfd_vma, bfd_vma));
-static bfd_boolean xtensa_is_property_section
- PARAMS ((asection *));
-static bfd_boolean xtensa_is_littable_section
- PARAMS ((asection *));
-static int internal_reloc_compare
- PARAMS ((const PTR, const PTR));
-static int internal_reloc_matches
- PARAMS ((const PTR, const PTR));
-extern char *xtensa_get_property_section_name
- PARAMS ((asection *, const char *));
-static flagword xtensa_get_property_predef_flags
- PARAMS ((asection *));
+ (bfd *, unsigned long);
+static bfd_vma get_elf_r_symndx_offset (bfd *, unsigned long);
+static bfd_boolean is_reloc_sym_weak (bfd *, Elf_Internal_Rela *);
+static bfd_boolean pcrel_reloc_fits (xtensa_opcode, int, bfd_vma, bfd_vma);
+static bfd_boolean xtensa_is_property_section (asection *);
+static bfd_boolean xtensa_is_littable_section (asection *);
+static int internal_reloc_compare (const void *, const void *);
+static int internal_reloc_matches (const void *, const void *);
+extern char *xtensa_get_property_section_name (asection *, const char *);
+static flagword xtensa_get_property_predef_flags (asection *);
/* Other functions called directly by the linker. */
typedef void (*deps_callback_t)
- PARAMS ((asection *, bfd_vma, asection *, bfd_vma, PTR));
+ (asection *, bfd_vma, asection *, bfd_vma, void *);
extern bfd_boolean xtensa_callback_required_dependence
- PARAMS ((bfd *, asection *, struct bfd_link_info *,
- deps_callback_t, PTR));
+ (bfd *, asection *, struct bfd_link_info *, deps_callback_t, void *);
/* Globally visible flag for choosing size optimization of NOP removal
instead of branch-target-aware minimization for NOP removal.
When nonzero, narrow all instructions and remove all NOPs possible
around longcall expansions. */
+
int elf32xtensa_size_opt;
/* The "new_section_hook" is used to set up a per-section
"xtensa_relax_info" data structure with additional information used
during relaxation. */
-typedef struct xtensa_relax_info_struct xtensa_relax_info;
+typedef struct xtensa_relax_info_struct xtensa_relax_info;
/* Total count of PLT relocations seen during check_relocs.
#endif
static reloc_howto_type *
-elf_xtensa_reloc_type_lookup (abfd, code)
- bfd *abfd ATTRIBUTE_UNUSED;
- bfd_reloc_code_real_type code;
+elf_xtensa_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
+ bfd_reloc_code_real_type code)
{
switch (code)
{
it in the BFD internal arelent representation of the relocation. */
static void
-elf_xtensa_info_to_howto_rela (abfd, cache_ptr, dst)
- bfd *abfd ATTRIBUTE_UNUSED;
- arelent *cache_ptr;
- Elf_Internal_Rela *dst;
+elf_xtensa_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
+ arelent *cache_ptr,
+ Elf_Internal_Rela *dst)
{
unsigned int r_type = ELF32_R_TYPE (dst->r_info);
static inline bfd_boolean
-xtensa_elf_dynamic_symbol_p (h, info)
- struct elf_link_hash_entry *h;
- struct bfd_link_info *info;
+xtensa_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
+ struct bfd_link_info *info)
{
/* Check if we should do dynamic things to this symbol. The
"ignore_protected" argument need not be set, because Xtensa code
\f
static int
-property_table_compare (ap, bp)
- const PTR ap;
- const PTR bp;
+property_table_compare (const void *ap, const void *bp)
{
const property_table_entry *a = (const property_table_entry *) ap;
const property_table_entry *b = (const property_table_entry *) bp;
if (a->address == b->address)
{
- /* The only circumstance where two entries may legitimately have the
- same address is when one of them is a zero-size placeholder to
- mark a place where fill can be inserted. The zero-size entry should
- come first. */
- BFD_ASSERT ((a->size == 0 || b->size == 0));
-
if (a->size != b->size)
return (a->size - b->size);
static int
-property_table_matches (ap, bp)
- const PTR ap;
- const PTR bp;
+property_table_matches (const void *ap, const void *bp)
{
const property_table_entry *a = (const property_table_entry *) ap;
const property_table_entry *b = (const property_table_entry *) bp;
section. Sets TABLE_P and returns the number of entries. On
error, returns a negative value. */
-int
-xtensa_read_table_entries (abfd, section, table_p, sec_name, output_addr)
- bfd *abfd;
- asection *section;
- property_table_entry **table_p;
- const char *sec_name;
- bfd_boolean output_addr;
+static int
+xtensa_read_table_entries (bfd *abfd,
+ asection *section,
+ property_table_entry **table_p,
+ const char *sec_name,
+ bfd_boolean output_addr)
{
asection *table_section;
char *table_section_name;
bfd_size_type table_size = 0;
bfd_byte *table_data;
property_table_entry *blocks;
- int block_count;
+ int blk, block_count;
bfd_size_type num_records;
Elf_Internal_Rela *internal_relocs;
bfd_vma section_addr;
/* Now sort them into address order for easy reference. */
qsort (blocks, block_count, sizeof (property_table_entry),
property_table_compare);
+
+ /* Check that the table contents are valid. Problems may occur,
+ for example, if an unrelocated object file is stripped. */
+ for (blk = 1; blk < block_count; blk++)
+ {
+ /* The only circumstance where two entries may legitimately
+ have the same address is when one of them is a zero-size
+ placeholder to mark a place where fill can be inserted.
+ The zero-size entry should come first. */
+ if (blocks[blk - 1].address == blocks[blk].address &&
+ blocks[blk - 1].size != 0)
+ {
+ (*_bfd_error_handler) (_("%B(%A): invalid property table"),
+ abfd, section);
+ bfd_set_error (bfd_error_bad_value);
+ free (blocks);
+ return -1;
+ }
+ }
}
*table_p = blocks;
}
-property_table_entry *
-elf_xtensa_find_property_entry (property_table, property_table_size, addr)
- property_table_entry *property_table;
- int property_table_size;
- bfd_vma addr;
+static property_table_entry *
+elf_xtensa_find_property_entry (property_table_entry *property_table,
+ int property_table_size,
+ bfd_vma addr)
{
property_table_entry entry;
property_table_entry *rv;
static bfd_boolean
-elf_xtensa_in_literal_pool (lit_table, lit_table_size, addr)
- property_table_entry *lit_table;
- int lit_table_size;
- bfd_vma addr;
+elf_xtensa_in_literal_pool (property_table_entry *lit_table,
+ int lit_table_size,
+ bfd_vma addr)
{
if (elf_xtensa_find_property_entry (lit_table, lit_table_size, addr))
return TRUE;
calculate needed space in the dynamic reloc sections. */
static bfd_boolean
-elf_xtensa_check_relocs (abfd, info, sec, relocs)
- bfd *abfd;
- struct bfd_link_info *info;
- asection *sec;
- const Elf_Internal_Rela *relocs;
+elf_xtensa_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;
static void
-elf_xtensa_hide_symbol (info, h, force_local)
- struct bfd_link_info *info;
- struct elf_link_hash_entry *h;
- bfd_boolean force_local;
+elf_xtensa_make_sym_local (struct bfd_link_info *info,
+ struct elf_link_hash_entry *h)
+{
+ if (info->shared)
+ {
+ if (h->plt.refcount > 0)
+ {
+ /* Will use RELATIVE relocs instead of JMP_SLOT relocs. */
+ if (h->got.refcount < 0)
+ h->got.refcount = 0;
+ h->got.refcount += h->plt.refcount;
+ h->plt.refcount = 0;
+ }
+ }
+ else
+ {
+ /* Don't need any dynamic relocations at all. */
+ h->plt.refcount = 0;
+ h->got.refcount = 0;
+ }
+}
+
+
+static void
+elf_xtensa_hide_symbol (struct bfd_link_info *info,
+ struct elf_link_hash_entry *h,
+ bfd_boolean force_local)
{
/* For a shared link, move the plt refcount to the got refcount to leave
space for RELATIVE relocs. */
relocation. */
static asection *
-elf_xtensa_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;
+elf_xtensa_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)
+ if (h)
{
switch (ELF32_R_TYPE (rel->r_info))
{
return NULL;
}
+
/* Update the GOT & PLT entry reference counts
for the section being removed. */
static bfd_boolean
-elf_xtensa_gc_sweep_hook (abfd, info, sec, relocs)
- bfd *abfd;
- struct bfd_link_info *info ATTRIBUTE_UNUSED;
- asection *sec;
- const Elf_Internal_Rela *relocs;
+elf_xtensa_gc_sweep_hook (bfd *abfd,
+ struct bfd_link_info *info ATTRIBUTE_UNUSED,
+ asection *sec,
+ const Elf_Internal_Rela *relocs)
{
Elf_Internal_Shdr *symtab_hdr;
struct elf_link_hash_entry **sym_hashes;
r_symndx = ELF32_R_SYM (rel->r_info);
if (r_symndx >= symtab_hdr->sh_info)
- h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+ {
+ h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+ while (h->root.type == bfd_link_hash_indirect
+ || h->root.type == bfd_link_hash_warning)
+ h = (struct elf_link_hash_entry *) h->root.u.i.link;
+ }
r_type = ELF32_R_TYPE (rel->r_info);
switch (r_type)
/* Create all the dynamic sections. */
static bfd_boolean
-elf_xtensa_create_dynamic_sections (dynobj, info)
- bfd *dynobj;
- struct bfd_link_info *info;
+elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
{
flagword flags, noalloc_flags;
asection *s;
return FALSE;
/* Create ".rela.got". */
- s = bfd_make_section (dynobj, ".rela.got");
+ s = bfd_make_section_with_flags (dynobj, ".rela.got", flags);
if (s == NULL
- || ! bfd_set_section_flags (dynobj, s, flags)
|| ! bfd_set_section_alignment (dynobj, s, 2))
return FALSE;
/* Create ".got.loc" (literal tables for use by dynamic linker). */
- s = bfd_make_section (dynobj, ".got.loc");
+ s = bfd_make_section_with_flags (dynobj, ".got.loc", flags);
if (s == NULL
- || ! bfd_set_section_flags (dynobj, s, flags)
|| ! bfd_set_section_alignment (dynobj, s, 2))
return FALSE;
/* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
- s = bfd_make_section (dynobj, ".xt.lit.plt");
+ s = bfd_make_section_with_flags (dynobj, ".xt.lit.plt",
+ noalloc_flags);
if (s == NULL
- || ! bfd_set_section_flags (dynobj, s, noalloc_flags)
|| ! bfd_set_section_alignment (dynobj, s, 2))
return FALSE;
static bfd_boolean
-add_extra_plt_sections (dynobj, count)
- bfd *dynobj;
- int count;
+add_extra_plt_sections (bfd *dynobj, int count)
{
int chunk;
sname = (char *) bfd_malloc (10);
sprintf (sname, ".plt.%u", chunk);
- s = bfd_make_section (dynobj, sname);
+ s = bfd_make_section_with_flags (dynobj, sname,
+ flags | SEC_CODE);
if (s == NULL
- || ! bfd_set_section_flags (dynobj, s, flags | SEC_CODE)
|| ! bfd_set_section_alignment (dynobj, s, 2))
return FALSE;
sname = (char *) bfd_malloc (14);
sprintf (sname, ".got.plt.%u", chunk);
- s = bfd_make_section (dynobj, sname);
+ s = bfd_make_section_with_flags (dynobj, sname, flags);
if (s == NULL
- || ! bfd_set_section_flags (dynobj, s, flags)
|| ! bfd_set_section_alignment (dynobj, s, 2))
return FALSE;
}
understand. */
static bfd_boolean
-elf_xtensa_adjust_dynamic_symbol (info, h)
- struct bfd_link_info *info ATTRIBUTE_UNUSED;
- struct elf_link_hash_entry *h;
+elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+ struct elf_link_hash_entry *h)
{
/* If this is a weak symbol, and there is a real definition, the
processor independent code will have arranged for us to see the
real definition first, and we can just use the same value. */
- if (h->u.weakdef != NULL)
+ if (h->u.weakdef)
{
BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
|| h->u.weakdef->root.type == bfd_link_hash_defweak);
}
-static void
-elf_xtensa_make_sym_local (info, h)
- struct bfd_link_info *info;
- struct elf_link_hash_entry *h;
-{
- if (info->shared)
- {
- if (h->plt.refcount > 0)
- {
- /* Will use RELATIVE relocs instead of JMP_SLOT relocs. */
- if (h->got.refcount < 0)
- h->got.refcount = 0;
- h->got.refcount += h->plt.refcount;
- h->plt.refcount = 0;
- }
- }
- else
- {
- /* Don't need any dynamic relocations at all. */
- h->plt.refcount = 0;
- h->got.refcount = 0;
- }
-}
-
-
static bfd_boolean
-elf_xtensa_fix_refcounts (h, arg)
- struct elf_link_hash_entry *h;
- PTR arg;
+elf_xtensa_fix_refcounts (struct elf_link_hash_entry *h, void *arg)
{
struct bfd_link_info *info = (struct bfd_link_info *) arg;
static bfd_boolean
-elf_xtensa_allocate_plt_size (h, arg)
- struct elf_link_hash_entry *h;
- PTR arg;
+elf_xtensa_allocate_plt_size (struct elf_link_hash_entry *h, void *arg)
{
asection *srelplt = (asection *) arg;
static bfd_boolean
-elf_xtensa_allocate_got_size (h, arg)
- struct elf_link_hash_entry *h;
- PTR arg;
+elf_xtensa_allocate_got_size (struct elf_link_hash_entry *h, void *arg)
{
asection *srelgot = (asection *) arg;
static void
-elf_xtensa_allocate_local_got_size (info, srelgot)
- struct bfd_link_info *info;
- asection *srelgot;
+elf_xtensa_allocate_local_got_size (struct bfd_link_info *info,
+ asection *srelgot)
{
bfd *i;
/* Set the sizes of the dynamic sections. */
static bfd_boolean
-elf_xtensa_size_dynamic_sections (output_bfd, info)
- bfd *output_bfd ATTRIBUTE_UNUSED;
- struct bfd_link_info *info;
+elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
+ struct bfd_link_info *info)
{
bfd *dynobj, *abfd;
asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
/* Adjust refcounts for symbols that we now know are not "dynamic". */
elf_link_hash_traverse (elf_hash_table (info),
elf_xtensa_fix_refcounts,
- (PTR) info);
+ (void *) info);
/* Allocate space in ".rela.got" for literals that reference
global symbols. */
abort ();
elf_link_hash_traverse (elf_hash_table (info),
elf_xtensa_allocate_got_size,
- (PTR) srelgot);
+ (void *) srelgot);
/* If we are generating a shared object, we also need space in
".rela.got" for R_XTENSA_RELATIVE relocs for literals that
abort ();
elf_link_hash_traverse (elf_hash_table (info),
elf_xtensa_allocate_plt_size,
- (PTR) srelplt);
+ (void *) srelplt);
/* Allocate space in ".plt" to match the size of ".rela.plt". For
each PLT entry, we need the PLT code plus a 4-byte literal.
for (s = dynobj->sections; s != NULL; s = s->next)
{
const char *name;
- bfd_boolean strip;
if ((s->flags & SEC_LINKER_CREATED) == 0)
continue;
of the dynobj section names depend upon the input files. */
name = bfd_get_section_name (dynobj, s);
- strip = FALSE;
-
if (strncmp (name, ".rela", 5) == 0)
{
- if (strcmp (name, ".rela.plt") == 0)
- relplt = TRUE;
- else if (strcmp (name, ".rela.got") == 0)
- relgot = TRUE;
-
- /* We use the reloc_count field as a counter if we need
- to copy relocs into the output file. */
- s->reloc_count = 0;
- }
- else if (strncmp (name, ".plt.", 5) == 0
- || strncmp (name, ".got.plt.", 9) == 0)
- {
- if (s->size == 0)
+ if (s->size != 0)
{
- /* If we don't need this section, strip it from the output
- file. We must create the ".plt*" and ".got.plt*"
- sections in create_dynamic_sections and/or check_relocs
- based on a conservative estimate of the PLT relocation
- count, because the sections must be created before the
- linker maps input sections to output sections. The
- linker does that before size_dynamic_sections, where we
- compute the exact size of the PLT, so there may be more
- of these sections than are actually needed. */
- strip = TRUE;
+ if (strcmp (name, ".rela.plt") == 0)
+ relplt = TRUE;
+ else if (strcmp (name, ".rela.got") == 0)
+ relgot = TRUE;
+
+ /* We use the reloc_count field as a counter if we need
+ to copy relocs into the output file. */
+ s->reloc_count = 0;
}
}
- else if (strcmp (name, ".got") != 0
+ else if (strncmp (name, ".plt.", 5) != 0
+ && strncmp (name, ".got.plt.", 9) != 0
+ && strcmp (name, ".got") != 0
&& strcmp (name, ".plt") != 0
&& strcmp (name, ".got.plt") != 0
&& strcmp (name, ".xt.lit.plt") != 0
continue;
}
- if (strip)
- _bfd_strip_section_from_output (info, s);
- else
+ if (s->size == 0)
+ {
+ /* If we don't need this section, strip it from the output
+ file. We must create the ".plt*" and ".got.plt*"
+ sections in create_dynamic_sections and/or check_relocs
+ based on a conservative estimate of the PLT relocation
+ count, because the sections must be created before the
+ linker maps input sections to output sections. The
+ linker does that before size_dynamic_sections, where we
+ compute the exact size of the PLT, so there may be more
+ of these sections than are actually needed. */
+ s->flags |= SEC_EXCLUDE;
+ }
+ else if ((s->flags & SEC_HAS_CONTENTS) != 0)
{
/* Allocate memory for the section contents. */
s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
- if (s->contents == NULL && s->size != 0)
+ if (s->contents == NULL)
return FALSE;
}
}
this and it probably ought to be moved into elf.c as well. */
static bfd_boolean
-elf_xtensa_modify_segment_map (abfd, info)
- bfd *abfd;
- struct bfd_link_info *info ATTRIBUTE_UNUSED;
+elf_xtensa_modify_segment_map (bfd *abfd,
+ struct bfd_link_info *info ATTRIBUTE_UNUSED)
{
struct elf_segment_map **m_p;
m_p = &elf_tdata (abfd)->segment_map;
- while (*m_p != NULL)
+ while (*m_p)
{
if ((*m_p)->p_type == PT_LOAD && (*m_p)->count == 0)
*m_p = (*m_p)->next;
howto. */
#define CALL_SEGMENT_BITS (30)
-#define CALL_SEGMENT_SIZE (1<<CALL_SEGMENT_BITS)
+#define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
static bfd_reloc_status_type
-elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
- contents, address, is_weak_undef, error_message)
- reloc_howto_type *howto;
- bfd *abfd;
- asection *input_section;
- bfd_vma relocation;
- bfd_byte *contents;
- bfd_vma address;
- bfd_boolean is_weak_undef;
- char **error_message;
+elf_xtensa_do_reloc (reloc_howto_type *howto,
+ bfd *abfd,
+ asection *input_section,
+ bfd_vma relocation,
+ bfd_byte *contents,
+ bfd_vma address,
+ bfd_boolean is_weak_undef,
+ char **error_message)
{
xtensa_format fmt;
xtensa_opcode opcode;
|| xtensa_operand_set_field (isa, opcode, opnd, fmt, slot,
sbuff, newval))
{
- *error_message = build_encoding_error_message (opcode, relocation);
+ const char *opname = xtensa_opcode_name (isa, opcode);
+ const char *msg;
+
+ msg = "cannot encode";
+ if (is_direct_call_opcode (opcode))
+ {
+ if ((relocation & 0x3) != 0)
+ msg = "misaligned call target";
+ else
+ msg = "call target out of range";
+ }
+ else if (opcode == get_l32r_opcode ())
+ {
+ if ((relocation & 0x3) != 0)
+ msg = "misaligned literal target";
+ else if (is_alt_relocation (howto->type))
+ msg = "literal target out of range (too many literals)";
+ else if (self_address > relocation)
+ msg = "literal target out of range (try using text-section-literals)";
+ else
+ msg = "literal placed after use";
+ }
+
+ *error_message = vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
return bfd_reloc_dangerous;
}
static char *
-vsprint_msg VPARAMS ((const char *origmsg, const char *fmt, int arglen, ...))
+vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
{
/* To reduce the size of the memory leak,
we only use a single message buffer. */
}
-static char *
-build_encoding_error_message (opcode, target_address)
- xtensa_opcode opcode;
- bfd_vma target_address;
-{
- const char *opname = xtensa_opcode_name (xtensa_default_isa, opcode);
- const char *msg;
-
- msg = "cannot encode";
- if (is_direct_call_opcode (opcode))
- {
- if ((target_address & 0x3) != 0)
- msg = "misaligned call target";
- else
- msg = "call target out of range";
- }
- else if (opcode == get_l32r_opcode ())
- {
- if ((target_address & 0x3) != 0)
- msg = "misaligned literal target";
- else
- msg = "literal target out of range";
- }
-
- return vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
-}
-
-
/* This function is registered as the "special_function" in the
Xtensa howto for handling simplify operations.
bfd_perform_relocation / bfd_install_relocation use it to
stripped-down version of bfd_perform_relocation. */
static bfd_reloc_status_type
-bfd_elf_xtensa_reloc (abfd, reloc_entry, symbol, data, input_section,
- output_bfd, error_message)
- bfd *abfd;
- arelent *reloc_entry;
- asymbol *symbol;
- PTR data;
- asection *input_section;
- bfd *output_bfd;
- char **error_message;
+bfd_elf_xtensa_reloc (bfd *abfd,
+ arelent *reloc_entry,
+ asymbol *symbol,
+ void *data,
+ asection *input_section,
+ bfd *output_bfd,
+ char **error_message)
{
bfd_vma relocation;
bfd_reloc_status_type flag;
asection *reloc_target_output_section;
bfd_boolean is_weak_undef;
+ if (!xtensa_default_isa)
+ xtensa_default_isa = xtensa_isa_init (0, 0);
+
/* ELF relocs are against symbols. If we are producing relocatable
output, and the reloc is against an external symbol, the resulting
reloc will also be against the same symbol. In such a case, we
relocs to begin with, but that's a long story and there's little we
can do about it now....) */
- if (output_bfd != (bfd *) NULL
- && (symbol->flags & BSF_SECTION_SYM) == 0)
+ if (output_bfd && (symbol->flags & BSF_SECTION_SYM) == 0)
{
reloc_entry->address += input_section->output_offset;
return bfd_reloc_ok;
*error_message = "";
*error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
strlen (symbol->name) + 17,
- symbol->name, reloc_entry->addend);
+ symbol->name,
+ (unsigned long) reloc_entry->addend);
}
return flag;
/* Set up an entry in the procedure linkage table. */
static bfd_vma
-elf_xtensa_create_plt_entry (dynobj, output_bfd, reloc_index)
- bfd *dynobj;
- bfd *output_bfd;
- unsigned reloc_index;
+elf_xtensa_create_plt_entry (bfd *dynobj,
+ bfd *output_bfd,
+ unsigned reloc_index)
{
asection *splt, *sgotplt;
bfd_vma plt_base, got_base;
both relocatable and final links. */
static bfd_boolean
-elf_xtensa_relocate_section (output_bfd, info, input_bfd,
- input_section, contents, relocs,
- local_syms, local_sections)
- bfd *output_bfd;
- 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_xtensa_relocate_section (bfd *output_bfd,
+ 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;
Elf_Internal_Rela *rel;
srelgot = NULL;
srelplt = NULL;
- if (dynobj != NULL)
+ if (dynobj)
{
srelgot = bfd_get_section_by_name (dynobj, ".rela.got");;
srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
&& !((input_section->flags & SEC_DEBUGGING) != 0
&& h->def_dynamic))
(*_bfd_error_handler)
- (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
+ (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
(long) rel->r_offset,
+ howto->name,
h->root.root.string);
/* There's no point in calling bfd_perform_relocation here.
const char *name;
BFD_ASSERT (r == bfd_reloc_dangerous || r == bfd_reloc_other);
- BFD_ASSERT (error_message != (char *) NULL);
+ BFD_ASSERT (error_message != NULL);
- if (h != NULL)
+ if (h)
name = h->root.root.string;
else
{
else
error_message = vsprint_msg (error_message, ": (%s+0x%x)",
strlen (name) + 22,
- name, rel->r_addend);
+ name, (int)rel->r_addend);
}
if (!((*info->callbacks->reloc_dangerous)
the PLT and GOT entries are all set up by relocate_section. */
static bfd_boolean
-elf_xtensa_finish_dynamic_symbol (output_bfd, info, h, sym)
- bfd *output_bfd ATTRIBUTE_UNUSED;
- struct bfd_link_info *info ATTRIBUTE_UNUSED;
- struct elf_link_hash_entry *h;
- Elf_Internal_Sym *sym;
+elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
+ struct bfd_link_info *info ATTRIBUTE_UNUSED,
+ struct elf_link_hash_entry *h,
+ Elf_Internal_Sym *sym)
{
if (h->needs_plt
&& !h->def_regular)
on error. */
static int
-elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc)
- bfd *output_bfd;
- asection *sxtlit;
- asection *sgotloc;
+elf_xtensa_combine_prop_entries (bfd *output_bfd,
+ asection *sxtlit,
+ asection *sgotloc)
{
bfd_byte *contents;
property_table_entry *table;
/* Finish up the dynamic sections. */
static bfd_boolean
-elf_xtensa_finish_dynamic_sections (output_bfd, info)
- bfd *output_bfd;
- struct bfd_link_info *info;
+elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
+ struct bfd_link_info *info)
{
bfd *dynobj;
asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
{
BFD_ASSERT (sgot->size == 4);
if (sdyn == NULL)
- bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
+ bfd_put_32 (output_bfd, 0, sgot->contents);
else
bfd_put_32 (output_bfd,
sdyn->output_section->vma + sdyn->output_offset,
}
srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
- if (srelplt != NULL && srelplt->size != 0)
+ if (srelplt && srelplt->size != 0)
{
asection *sgotplt, *srelgot, *spltlittbl;
int chunk, plt_chunks, plt_entries;
object file when linking. */
static bfd_boolean
-elf_xtensa_merge_private_bfd_data (ibfd, obfd)
- bfd *ibfd;
- bfd *obfd;
+elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
{
unsigned out_mach, in_mach;
flagword out_flag, in_flag;
static bfd_boolean
-elf_xtensa_set_private_flags (abfd, flags)
- bfd *abfd;
- flagword flags;
+elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
{
BFD_ASSERT (!elf_flags_init (abfd)
|| elf_elfheader (abfd)->e_flags == flags);
}
-extern flagword
-elf_xtensa_get_private_bfd_flags (abfd)
- bfd *abfd;
-{
- return elf_elfheader (abfd)->e_flags;
-}
-
-
static bfd_boolean
-elf_xtensa_print_private_bfd_data (abfd, farg)
- bfd *abfd;
- PTR farg;
+elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
{
FILE *f = (FILE *) farg;
flagword e_flags = elf_elfheader (abfd)->e_flags;
/* Set the right machine number for an Xtensa ELF file. */
static bfd_boolean
-elf_xtensa_object_p (abfd)
- bfd *abfd;
+elf_xtensa_object_p (bfd *abfd)
{
int mach;
unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
number. */
static void
-elf_xtensa_final_write_processing (abfd, linker)
- bfd *abfd;
- bfd_boolean linker ATTRIBUTE_UNUSED;
+elf_xtensa_final_write_processing (bfd *abfd,
+ bfd_boolean linker ATTRIBUTE_UNUSED)
{
int mach;
unsigned long val;
static enum elf_reloc_type_class
-elf_xtensa_reloc_type_class (rela)
- const Elf_Internal_Rela *rela;
+elf_xtensa_reloc_type_class (const Elf_Internal_Rela *rela)
{
switch ((int) ELF32_R_TYPE (rela->r_info))
{
\f
static bfd_boolean
-elf_xtensa_discard_info_for_section (abfd, cookie, info, sec)
- bfd *abfd;
- struct elf_reloc_cookie *cookie;
- struct bfd_link_info *info;
- asection *sec;
+elf_xtensa_discard_info_for_section (bfd *abfd,
+ struct elf_reloc_cookie *cookie,
+ struct bfd_link_info *info,
+ asection *sec)
{
bfd_byte *contents;
bfd_vma section_size;
static bfd_boolean
-elf_xtensa_discard_info (abfd, cookie, info)
- bfd *abfd;
- struct elf_reloc_cookie *cookie;
- struct bfd_link_info *info;
+elf_xtensa_discard_info (bfd *abfd,
+ struct elf_reloc_cookie *cookie,
+ struct bfd_link_info *info)
{
asection *sec;
bfd_boolean changed = FALSE;
static bfd_boolean
-elf_xtensa_ignore_discarded_relocs (sec)
- asection *sec;
+elf_xtensa_ignore_discarded_relocs (asection *sec)
{
return xtensa_is_property_section (sec);
}
/* Support for core dump NOTE sections. */
static bfd_boolean
-elf_xtensa_grok_prstatus (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
{
int offset;
unsigned int size;
static bfd_boolean
-elf_xtensa_grok_psinfo (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
{
switch (note->descsz)
{
static xtensa_opcode call12_op = XTENSA_UNDEFINED;
static void
-init_call_opcodes ()
+init_call_opcodes (void)
{
if (callx0_op == XTENSA_UNDEFINED)
{
static bfd_boolean
-is_indirect_call_opcode (opcode)
- xtensa_opcode opcode;
+is_indirect_call_opcode (xtensa_opcode opcode)
{
init_call_opcodes ();
return (opcode == callx0_op
static bfd_boolean
-is_direct_call_opcode (opcode)
- xtensa_opcode opcode;
+is_direct_call_opcode (xtensa_opcode opcode)
{
init_call_opcodes ();
return (opcode == call0_op
static bfd_boolean
-is_windowed_call_opcode (opcode)
- xtensa_opcode opcode;
+is_windowed_call_opcode (xtensa_opcode opcode)
{
init_call_opcodes ();
return (opcode == call4_op
static bfd_vma
-l32r_offset (addr, pc)
- bfd_vma addr;
- bfd_vma pc;
+l32r_offset (bfd_vma addr, bfd_vma pc)
{
bfd_vma offset;
static int
-get_relocation_opnd (opcode, r_type)
- xtensa_opcode opcode;
- int r_type;
+get_relocation_opnd (xtensa_opcode opcode, int r_type)
{
xtensa_isa isa = xtensa_default_isa;
int last_immed, last_opnd, opi;
int
-get_relocation_slot (r_type)
- int r_type;
+get_relocation_slot (int r_type)
{
switch (r_type)
{
/* Get the opcode for a relocation. */
static xtensa_opcode
-get_relocation_opcode (abfd, sec, contents, irel)
- bfd *abfd;
- asection *sec;
- bfd_byte *contents;
- Elf_Internal_Rela *irel;
+get_relocation_opcode (bfd *abfd,
+ asection *sec,
+ bfd_byte *contents,
+ Elf_Internal_Rela *irel)
{
static xtensa_insnbuf ibuff = NULL;
static xtensa_insnbuf sbuff = NULL;
bfd_boolean
-is_l32r_relocation (abfd, sec, contents, irel)
- bfd *abfd;
- asection *sec;
- bfd_byte *contents;
- Elf_Internal_Rela *irel;
+is_l32r_relocation (bfd *abfd,
+ asection *sec,
+ bfd_byte *contents,
+ Elf_Internal_Rela *irel)
{
xtensa_opcode opcode;
if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
static bfd_size_type
-get_asm_simplify_size (contents, content_len, offset)
- bfd_byte *contents;
- bfd_size_type content_len;
- bfd_size_type offset;
+get_asm_simplify_size (bfd_byte *contents,
+ bfd_size_type content_len,
+ bfd_size_type offset)
{
bfd_size_type insnlen, size = 0;
bfd_boolean
-is_alt_relocation (r_type)
- int r_type;
+is_alt_relocation (int r_type)
{
return (r_type >= R_XTENSA_SLOT0_ALT
&& r_type <= R_XTENSA_SLOT14_ALT);
bfd_boolean
-is_operand_relocation (r_type)
- int r_type;
+is_operand_relocation (int r_type)
{
switch (r_type)
{
/* Return 0 if it fails to decode. */
bfd_size_type
-insn_decode_len (contents, content_len, offset)
- bfd_byte *contents;
- bfd_size_type content_len;
- bfd_size_type offset;
+insn_decode_len (bfd_byte *contents,
+ bfd_size_type content_len,
+ bfd_size_type offset)
{
int insn_len;
xtensa_isa isa = xtensa_default_isa;
Return 0 if it fails to decode or the instruction is multi-slot. */
xtensa_opcode
-insn_decode_opcode (contents, content_len, offset, slot)
- bfd_byte *contents;
- bfd_size_type content_len;
- bfd_size_type offset;
- int slot;
+insn_decode_opcode (bfd_byte *contents,
+ bfd_size_type content_len,
+ bfd_size_type offset,
+ int slot)
{
xtensa_isa isa = xtensa_default_isa;
xtensa_format fmt;
The address is the address of that offset. */
static bfd_boolean
-check_branch_target_aligned (contents, content_length, offset, address)
- bfd_byte *contents;
- bfd_size_type content_length;
- bfd_vma offset;
- bfd_vma address;
+check_branch_target_aligned (bfd_byte *contents,
+ bfd_size_type content_length,
+ bfd_vma offset,
+ bfd_vma address)
{
bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
if (insn_len == 0)
static bfd_boolean
-check_loop_aligned (contents, content_length, offset, address)
- bfd_byte *contents;
- bfd_size_type content_length;
- bfd_vma offset;
- bfd_vma address;
+check_loop_aligned (bfd_byte *contents,
+ bfd_size_type content_length,
+ bfd_vma offset,
+ bfd_vma address)
{
bfd_size_type loop_len, insn_len;
xtensa_opcode opcode =
static bfd_boolean
-check_branch_target_aligned_address (addr, len)
- bfd_vma addr;
- int len;
+check_branch_target_aligned_address (bfd_vma addr, int len)
{
if (len == 8)
return (addr % 8 == 0);
\f
/* Instruction widening and narrowing. */
-static bfd_boolean narrow_instruction
- PARAMS ((bfd_byte *, bfd_size_type, bfd_size_type, bfd_boolean));
-static bfd_boolean widen_instruction
- PARAMS ((bfd_byte *, bfd_size_type, bfd_size_type, bfd_boolean));
-static xtensa_format get_single_format
- PARAMS ((xtensa_opcode));
-static void init_op_single_format_table
- PARAMS ((void));
+/* When FLIX is available we need to access certain instructions only
+ when they are 16-bit or 24-bit instructions. This table caches
+ information about such instructions by walking through all the
+ opcodes and finding the smallest single-slot format into which each
+ can be encoded. */
+
+static xtensa_format *op_single_fmt_table = NULL;
-struct string_pair
+static void
+init_op_single_format_table (void)
{
- const char *wide;
- const char *narrow;
-};
+ xtensa_isa isa = xtensa_default_isa;
+ xtensa_insnbuf ibuf;
+ xtensa_opcode opcode;
+ xtensa_format fmt;
+ int num_opcodes;
+
+ if (op_single_fmt_table)
+ return;
+
+ ibuf = xtensa_insnbuf_alloc (isa);
+ num_opcodes = xtensa_isa_num_opcodes (isa);
+
+ op_single_fmt_table = (xtensa_format *)
+ bfd_malloc (sizeof (xtensa_format) * num_opcodes);
+ for (opcode = 0; opcode < num_opcodes; opcode++)
+ {
+ op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
+ for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
+ {
+ if (xtensa_format_num_slots (isa, fmt) == 1
+ && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
+ {
+ xtensa_opcode old_fmt = op_single_fmt_table[opcode];
+ int fmt_length = xtensa_format_length (isa, fmt);
+ if (old_fmt == XTENSA_UNDEFINED
+ || fmt_length < xtensa_format_length (isa, old_fmt))
+ op_single_fmt_table[opcode] = fmt;
+ }
+ }
+ }
+ xtensa_insnbuf_free (isa, ibuf);
+}
+
+
+static xtensa_format
+get_single_format (xtensa_opcode opcode)
+{
+ init_op_single_format_table ();
+ return op_single_fmt_table[opcode];
+}
/* For the set of narrowable instructions we do NOT include the
re-expand in some conditions. Also, the narrowing "or" -> mov.n
requires special case code to ensure it only works when op1 == op2. */
+struct string_pair
+{
+ const char *wide;
+ const char *narrow;
+};
+
struct string_pair narrowable[] =
{
{ "add", "add.n" },
but require some special case operand checks in some cases. */
static bfd_boolean
-narrow_instruction (contents, content_length, offset, do_it)
- bfd_byte *contents;
- bfd_size_type content_length;
- bfd_size_type offset;
- bfd_boolean do_it;
+narrow_instruction (bfd_byte *contents,
+ bfd_size_type content_length,
+ bfd_size_type offset,
+ bfd_boolean do_it)
{
xtensa_opcode opcode;
bfd_size_type insn_len, opi;
|| xtensa_format_length (isa, o_fmt) != 2)
return FALSE;
- xtensa_format_encode (isa, o_fmt, o_slotbuf);
xtensa_format_encode (isa, o_fmt, o_insnbuf);
operand_count = xtensa_opcode_num_operands (isa, opcode);
o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
cases. */
static bfd_boolean
-widen_instruction (contents, content_length, offset, do_it)
- bfd_byte *contents;
- bfd_size_type content_length;
- bfd_size_type offset;
- bfd_boolean do_it;
+widen_instruction (bfd_byte *contents,
+ bfd_size_type content_length,
+ bfd_size_type offset,
+ bfd_boolean do_it)
{
xtensa_opcode opcode;
bfd_size_type insn_len, opi;
|| xtensa_format_length (isa, o_fmt) != 3)
return FALSE;
- xtensa_format_encode (isa, o_fmt, o_slotbuf);
xtensa_format_encode (isa, o_fmt, o_insnbuf);
operand_count = xtensa_opcode_num_operands (isa, opcode);
o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
return FALSE;
}
-
-/* When FLIX is available we need to access certain instructions only
- when they are 16-bit or 24-bit instructions. This table caches
- information about such instructions by walking through all the
- opcodes and finding the smallest single-slot format into which each
- can be encoded. */
-
-static xtensa_format *op_single_fmt_table = NULL;
-
-
-static xtensa_format
-get_single_format (opcode)
- xtensa_opcode opcode;
-{
- init_op_single_format_table ();
- return op_single_fmt_table[opcode];
-}
-
-
-static void
-init_op_single_format_table ()
-{
- xtensa_isa isa = xtensa_default_isa;
- xtensa_insnbuf ibuf;
- xtensa_opcode opcode;
- xtensa_format fmt;
- int num_opcodes;
-
- if (op_single_fmt_table != NULL)
- return;
-
- ibuf = xtensa_insnbuf_alloc (isa);
- num_opcodes = xtensa_isa_num_opcodes (isa);
-
- op_single_fmt_table = (xtensa_format *)
- bfd_malloc (sizeof (xtensa_format) * num_opcodes);
- for (opcode = 0; opcode < num_opcodes; opcode++)
- {
- op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
- for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
- {
- if (xtensa_format_num_slots (isa, fmt) == 1
- && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
- {
- xtensa_opcode old_fmt = op_single_fmt_table[opcode];
- int fmt_length = xtensa_format_length (isa, fmt);
- if (old_fmt == XTENSA_UNDEFINED
- || fmt_length < xtensa_format_length (isa, old_fmt))
- op_single_fmt_table[opcode] = fmt;
- }
- }
- }
- xtensa_insnbuf_free (isa, ibuf);
-}
-
\f
/* Code for transforming CALLs at link-time. */
static bfd_reloc_status_type
-elf_xtensa_do_asm_simplify (contents, address, content_length, error_message)
- bfd_byte *contents;
- bfd_vma address;
- bfd_vma content_length;
- char **error_message;
+elf_xtensa_do_asm_simplify (bfd_byte *contents,
+ bfd_vma address,
+ bfd_vma content_length,
+ char **error_message)
{
static xtensa_insnbuf insnbuf = NULL;
static xtensa_insnbuf slotbuf = NULL;
static bfd_reloc_status_type
-contract_asm_expansion (contents, content_length, irel, error_message)
- bfd_byte *contents;
- bfd_vma content_length;
- Elf_Internal_Rela *irel;
- char **error_message;
+contract_asm_expansion (bfd_byte *contents,
+ bfd_vma content_length,
+ Elf_Internal_Rela *irel,
+ char **error_message)
{
bfd_reloc_status_type retval =
elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
static xtensa_opcode
-swap_callx_for_call_opcode (opcode)
- xtensa_opcode opcode;
+swap_callx_for_call_opcode (xtensa_opcode opcode)
{
init_call_opcodes ();
#define CALLN_SOURCE_OPERAND 0
static xtensa_opcode
-get_expanded_call_opcode (buf, bufsize, p_uses_l32r)
- bfd_byte *buf;
- int bufsize;
- bfd_boolean *p_uses_l32r;
+get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
{
static xtensa_insnbuf insnbuf = NULL;
static xtensa_insnbuf slotbuf = NULL;
bfd_vma virtual_offset;
};
-static bfd_boolean r_reloc_is_const
- PARAMS ((const r_reloc *));
-static void r_reloc_init
- PARAMS ((r_reloc *, bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_size_type));
-static bfd_vma r_reloc_get_target_offset
- PARAMS ((const r_reloc *));
-static asection *r_reloc_get_section
- PARAMS ((const r_reloc *));
-static bfd_boolean r_reloc_is_defined
- PARAMS ((const r_reloc *));
-static struct elf_link_hash_entry *r_reloc_get_hash_entry
- PARAMS ((const r_reloc *));
-#if DEBUG
-static void print_r_reloc
- PARAMS ((FILE *fp, const r_reloc *r));
-#endif /* DEBUG */
-
/* The r_reloc structure is included by value in literal_value, but not
every literal_value has an associated relocation -- some are simple
detect this case. */
static bfd_boolean
-r_reloc_is_const (r_rel)
- const r_reloc *r_rel;
+r_reloc_is_const (const r_reloc *r_rel)
{
return (r_rel->abfd == NULL);
}
-static void
-r_reloc_init (r_rel, abfd, irel, contents, content_length)
- r_reloc *r_rel;
- bfd *abfd;
- Elf_Internal_Rela *irel;
- bfd_byte *contents;
- bfd_size_type content_length;
-{
- int r_type;
- reloc_howto_type *howto;
-
- if (irel != NULL)
- {
- r_rel->rela = *irel;
- r_rel->abfd = abfd;
- r_rel->target_offset = r_reloc_get_target_offset (r_rel);
- r_rel->virtual_offset = 0;
- r_type = ELF32_R_TYPE (r_rel->rela.r_info);
- howto = &elf_howto_table[r_type];
- if (howto->partial_inplace)
- {
- bfd_vma inplace_val;
- BFD_ASSERT (r_rel->rela.r_offset < content_length);
-
- inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
- r_rel->target_offset += inplace_val;
- }
- }
- else
- memset (r_rel, 0, sizeof (r_reloc));
-}
-
-
static bfd_vma
-r_reloc_get_target_offset (r_rel)
- const r_reloc *r_rel;
+r_reloc_get_target_offset (const r_reloc *r_rel)
{
bfd_vma target_offset;
unsigned long r_symndx;
static struct elf_link_hash_entry *
-r_reloc_get_hash_entry (r_rel)
- const r_reloc *r_rel;
+r_reloc_get_hash_entry (const r_reloc *r_rel)
{
unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
static asection *
-r_reloc_get_section (r_rel)
- const r_reloc *r_rel;
+r_reloc_get_section (const r_reloc *r_rel)
{
unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
static bfd_boolean
-r_reloc_is_defined (r_rel)
- const r_reloc *r_rel;
+r_reloc_is_defined (const r_reloc *r_rel)
{
asection *sec;
if (r_rel == NULL)
}
+static void
+r_reloc_init (r_reloc *r_rel,
+ bfd *abfd,
+ Elf_Internal_Rela *irel,
+ bfd_byte *contents,
+ bfd_size_type content_length)
+{
+ int r_type;
+ reloc_howto_type *howto;
+
+ if (irel)
+ {
+ r_rel->rela = *irel;
+ r_rel->abfd = abfd;
+ r_rel->target_offset = r_reloc_get_target_offset (r_rel);
+ r_rel->virtual_offset = 0;
+ r_type = ELF32_R_TYPE (r_rel->rela.r_info);
+ howto = &elf_howto_table[r_type];
+ if (howto->partial_inplace)
+ {
+ bfd_vma inplace_val;
+ BFD_ASSERT (r_rel->rela.r_offset < content_length);
+
+ inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
+ r_rel->target_offset += inplace_val;
+ }
+ }
+ else
+ memset (r_rel, 0, sizeof (r_reloc));
+}
+
+
#if DEBUG
static void
-print_r_reloc (fp, r_rel)
- FILE *fp;
- const r_reloc *r_rel;
+print_r_reloc (FILE *fp, const r_reloc *r_rel)
{
if (r_reloc_is_defined (r_rel))
{
};
-static void init_source_reloc
- PARAMS ((source_reloc *, asection *, const r_reloc *,
- xtensa_opcode, int, bfd_boolean));
-static source_reloc *find_source_reloc
- PARAMS ((source_reloc *, int, asection *, Elf_Internal_Rela *));
-static int source_reloc_compare
- PARAMS ((const PTR, const PTR));
-
-
static void
-init_source_reloc (reloc, source_sec, r_rel, opcode, opnd, is_abs_literal)
- source_reloc *reloc;
- asection *source_sec;
- const r_reloc *r_rel;
- xtensa_opcode opcode;
- int opnd;
- bfd_boolean is_abs_literal;
+init_source_reloc (source_reloc *reloc,
+ asection *source_sec,
+ const r_reloc *r_rel,
+ xtensa_opcode opcode,
+ int opnd,
+ bfd_boolean is_abs_literal)
{
reloc->source_sec = source_sec;
reloc->r_rel = *r_rel;
just a linear search. */
static source_reloc *
-find_source_reloc (src_relocs, src_count, sec, irel)
- source_reloc *src_relocs;
- int src_count;
- asection *sec;
- Elf_Internal_Rela *irel;
+find_source_reloc (source_reloc *src_relocs,
+ int src_count,
+ asection *sec,
+ Elf_Internal_Rela *irel)
{
int i;
static int
-source_reloc_compare (ap, bp)
- const PTR ap;
- const PTR bp;
+source_reloc_compare (const void *ap, const void *bp)
{
const source_reloc *a = (const source_reloc *) ap;
const source_reloc *b = (const source_reloc *) bp;
};
-static void init_literal_value
- PARAMS ((literal_value *, const r_reloc *, unsigned long, bfd_boolean));
-static bfd_boolean literal_value_equal
- PARAMS ((const literal_value *, const literal_value *, bfd_boolean));
-static value_map_hash_table *value_map_hash_table_init
- PARAMS ((void));
-static void value_map_hash_table_delete
- PARAMS ((value_map_hash_table *));
-static unsigned literal_value_hash
- PARAMS ((const literal_value *));
-static unsigned hash_bfd_vma
- PARAMS ((bfd_vma));
-static value_map *value_map_get_cached_value
- PARAMS ((value_map_hash_table *, const literal_value *, bfd_boolean));
-static value_map *add_value_map
- PARAMS ((value_map_hash_table *, const literal_value *, const r_reloc *,
- bfd_boolean));
-
-
static void
-init_literal_value (lit, r_rel, value, is_abs_literal)
- literal_value *lit;
- const r_reloc *r_rel;
- unsigned long value;
- bfd_boolean is_abs_literal;
+init_literal_value (literal_value *lit,
+ const r_reloc *r_rel,
+ unsigned long value,
+ bfd_boolean is_abs_literal)
{
lit->r_rel = *r_rel;
lit->value = value;
static bfd_boolean
-literal_value_equal (src1, src2, final_static_link)
- const literal_value *src1;
- const literal_value *src2;
- bfd_boolean final_static_link;
+literal_value_equal (const literal_value *src1,
+ const literal_value *src2,
+ bfd_boolean final_static_link)
{
struct elf_link_hash_entry *h1, *h2;
#define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
static value_map_hash_table *
-value_map_hash_table_init ()
+value_map_hash_table_init (void)
{
value_map_hash_table *values;
static void
-value_map_hash_table_delete (table)
- value_map_hash_table *table;
+value_map_hash_table_delete (value_map_hash_table *table)
{
free (table->buckets);
free (table);
static unsigned
-hash_bfd_vma (val)
- bfd_vma val;
+hash_bfd_vma (bfd_vma val)
{
return (val >> 2) + (val >> 10);
}
static unsigned
-literal_value_hash (src)
- const literal_value *src;
+literal_value_hash (const literal_value *src)
{
unsigned hash_val;
sec_or_hash = r_reloc_get_section (&src->r_rel);
else
sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
- hash_val += hash_bfd_vma ((bfd_vma) (unsigned) sec_or_hash);
+ hash_val += hash_bfd_vma ((bfd_vma) (size_t) sec_or_hash);
}
return hash_val;
}
/* Check if the specified literal_value has been seen before. */
static value_map *
-value_map_get_cached_value (map, val, final_static_link)
- value_map_hash_table *map;
- const literal_value *val;
- bfd_boolean final_static_link;
+value_map_get_cached_value (value_map_hash_table *map,
+ const literal_value *val,
+ bfd_boolean final_static_link)
{
value_map *map_e;
value_map *bucket;
already has an entry here. */
static value_map *
-add_value_map (map, val, loc, final_static_link)
- value_map_hash_table *map;
- const literal_value *val;
- const r_reloc *loc;
- bfd_boolean final_static_link;
+add_value_map (value_map_hash_table *map,
+ const literal_value *val,
+ const r_reloc *loc,
+ bfd_boolean final_static_link)
{
value_map **bucket_p;
unsigned idx;
};
-static text_action *find_fill_action
- PARAMS ((text_action_list *, asection *, bfd_vma));
-static int compute_removed_action_diff
- PARAMS ((const text_action *, asection *, bfd_vma, int, int));
-static void adjust_fill_action
- PARAMS ((text_action *, int));
-static void text_action_add
- PARAMS ((text_action_list *, text_action_t, asection *, bfd_vma, int));
-static void text_action_add_literal
- PARAMS ((text_action_list *, text_action_t, const r_reloc *,
- const literal_value *, int));
-static bfd_vma offset_with_removed_text
- PARAMS ((text_action_list *, bfd_vma));
-static bfd_vma offset_with_removed_text_before_fill
- PARAMS ((text_action_list *, bfd_vma));
-static text_action *find_insn_action
- PARAMS ((text_action_list *, bfd_vma));
-#if DEBUG
-static void print_action_list
- PARAMS ((FILE *, text_action_list *));
-#endif
-
-
-text_action *
-find_fill_action (l, sec, offset)
- text_action_list *l;
- asection *sec;
- bfd_vma offset;
+static text_action *
+find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
{
text_action **m_p;
if (sec->size == offset)
return NULL;
- for (m_p = &l->head;
- *m_p != NULL && (*m_p)->offset <= offset;
- m_p = &(*m_p)->next)
+ for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
{
text_action *t = *m_p;
/* When the action is another fill at the same address,
static int
-compute_removed_action_diff (ta, sec, offset, removed, removable_space)
- const text_action *ta;
- asection *sec;
- bfd_vma offset;
- int removed;
- int removable_space;
+compute_removed_action_diff (const text_action *ta,
+ asection *sec,
+ bfd_vma offset,
+ int removed,
+ int removable_space)
{
int new_removed;
int current_removed = 0;
- if (ta != NULL)
+ if (ta)
current_removed = ta->removed_bytes;
BFD_ASSERT (ta == NULL || ta->offset == offset);
}
-void
-adjust_fill_action (ta, fill_diff)
- text_action *ta;
- int fill_diff;
+static void
+adjust_fill_action (text_action *ta, int fill_diff)
{
ta->removed_bytes += fill_diff;
}
negative removed value is a fill. */
static void
-text_action_add (l, action, sec, offset, removed)
- text_action_list *l;
- text_action_t action;
- asection *sec;
- bfd_vma offset;
- int removed;
+text_action_add (text_action_list *l,
+ text_action_t action,
+ asection *sec,
+ bfd_vma offset,
+ int removed)
{
text_action **m_p;
text_action *ta;
if (action == ta_fill && removed == 0)
return;
- for (m_p = &l->head;
- *m_p != NULL && (*m_p)->offset <= offset;
- m_p = &(*m_p)->next)
+ for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
{
text_action *t = *m_p;
/* When the action is another fill at the same address,
static void
-text_action_add_literal (l, action, loc, value, removed)
- text_action_list *l;
- text_action_t action;
- const r_reloc *loc;
- const literal_value *value;
- int removed;
+text_action_add_literal (text_action_list *l,
+ text_action_t action,
+ const r_reloc *loc,
+ const literal_value *value,
+ int removed)
{
text_action **m_p;
text_action *ta;
}
-bfd_vma
-offset_with_removed_text (action_list, offset)
- text_action_list *action_list;
- bfd_vma offset;
+static bfd_vma
+offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
{
text_action *r;
int removed = 0;
}
-bfd_vma
-offset_with_removed_text_before_fill (action_list, offset)
- text_action_list *action_list;
- bfd_vma offset;
+static unsigned
+action_list_count (text_action_list *action_list)
+{
+ text_action *r = action_list->head;
+ unsigned count = 0;
+ for (r = action_list->head; r != NULL; r = r->next)
+ {
+ count++;
+ }
+ return count;
+}
+
+
+static bfd_vma
+offset_with_removed_text_before_fill (text_action_list *action_list,
+ bfd_vma offset)
{
text_action *r;
int removed = 0;
/* The find_insn_action routine will only find non-fill actions. */
-text_action *
-find_insn_action (action_list, offset)
- text_action_list *action_list;
- bfd_vma offset;
+static text_action *
+find_insn_action (text_action_list *action_list, bfd_vma offset)
{
text_action *t;
for (t = action_list->head; t; t = t->next)
#if DEBUG
static void
-print_action_list (fp, action_list)
- FILE *fp;
- text_action_list *action_list;
+print_action_list (FILE *fp, text_action_list *action_list)
{
text_action *r;
};
-static void add_removed_literal
- PARAMS ((removed_literal_list *, const r_reloc *, const r_reloc *));
-static removed_literal *find_removed_literal
- PARAMS ((removed_literal_list *, bfd_vma));
-#if DEBUG
-static void print_removed_literals
- PARAMS ((FILE *, removed_literal_list *));
-#endif /* DEBUG */
-
-
/* Record that the literal at "from" is being removed. If "to" is not
NULL, the "from" literal is being coalesced with the "to" literal. */
static void
-add_removed_literal (removed_list, from, to)
- removed_literal_list *removed_list;
- const r_reloc *from;
- const r_reloc *to;
+add_removed_literal (removed_literal_list *removed_list,
+ const r_reloc *from,
+ const r_reloc *to)
{
removed_literal *r, *new_r, *next_r;
}
else
{
- while (r->from.target_offset < from->target_offset
- && r->next != NULL)
+ while (r->from.target_offset < from->target_offset && r->next)
{
r = r->next;
}
given address. Return the entry if found. */
static removed_literal *
-find_removed_literal (removed_list, addr)
- removed_literal_list *removed_list;
- bfd_vma addr;
+find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
{
removed_literal *r = removed_list->head;
while (r && r->from.target_offset < addr)
#if DEBUG
static void
-print_removed_literals (fp, removed_list)
- FILE *fp;
- removed_literal_list *removed_list;
+print_removed_literals (FILE *fp, removed_literal_list *removed_list)
{
removed_literal *r;
r = removed_list->head;
xtensa_relax_info relax_info;
};
-static void init_xtensa_relax_info
- PARAMS ((asection *));
-static xtensa_relax_info *get_xtensa_relax_info
- PARAMS ((asection *));
-
static bfd_boolean
-elf_xtensa_new_section_hook (abfd, sec)
- bfd *abfd;
- asection *sec;
+elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
{
struct elf_xtensa_section_data *sdata;
bfd_size_type amt = sizeof (*sdata);
sdata = (struct elf_xtensa_section_data *) bfd_zalloc (abfd, amt);
if (sdata == NULL)
return FALSE;
- sec->used_by_bfd = (PTR) sdata;
+ sec->used_by_bfd = (void *) sdata;
return _bfd_elf_new_section_hook (abfd, sec);
}
+static xtensa_relax_info *
+get_xtensa_relax_info (asection *sec)
+{
+ struct elf_xtensa_section_data *section_data;
+
+ /* No info available if no section or if it is an output section. */
+ if (!sec || sec == sec->output_section)
+ return NULL;
+
+ section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
+ return §ion_data->relax_info;
+}
+
+
static void
-init_xtensa_relax_info (sec)
- asection *sec;
+init_xtensa_relax_info (asection *sec)
{
xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
relax_info->allocated_relocs_count = 0;
}
-
-static xtensa_relax_info *
-get_xtensa_relax_info (sec)
- asection *sec;
-{
- struct elf_xtensa_section_data *section_data;
-
- /* No info available if no section or if it is an output section. */
- if (!sec || sec == sec->output_section)
- return NULL;
-
- section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
- return §ion_data->relax_info;
-}
-
\f
/* Coalescing literals may require a relocation to refer to a section in
a different input file, but the standard relocation information
};
-static reloc_bfd_fix *reloc_bfd_fix_init
- PARAMS ((asection *, bfd_vma, unsigned, bfd *, asection *, bfd_vma,
- bfd_boolean));
-static void add_fix
- PARAMS ((asection *, reloc_bfd_fix *));
-static int fix_compare
- PARAMS ((const PTR, const PTR));
-static void cache_fix_array
- PARAMS ((asection *));
-static reloc_bfd_fix *get_bfd_fix
- PARAMS ((asection *, bfd_vma, unsigned));
-
-
static reloc_bfd_fix *
-reloc_bfd_fix_init (src_sec, src_offset, src_type,
- target_abfd, target_sec, target_offset, translated)
- asection *src_sec;
- bfd_vma src_offset;
- unsigned src_type;
- bfd *target_abfd;
- asection *target_sec;
- bfd_vma target_offset;
- bfd_boolean translated;
+reloc_bfd_fix_init (asection *src_sec,
+ bfd_vma src_offset,
+ unsigned src_type,
+ bfd *target_abfd,
+ asection *target_sec,
+ bfd_vma target_offset,
+ bfd_boolean translated)
{
reloc_bfd_fix *fix;
static void
-add_fix (src_sec, fix)
- asection *src_sec;
- reloc_bfd_fix *fix;
+add_fix (asection *src_sec, reloc_bfd_fix *fix)
{
xtensa_relax_info *relax_info;
static int
-fix_compare (ap, bp)
- const PTR ap;
- const PTR bp;
+fix_compare (const void *ap, const void *bp)
{
const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
static void
-cache_fix_array (sec)
- asection *sec;
+cache_fix_array (asection *sec)
{
unsigned i, count = 0;
reloc_bfd_fix *r;
static reloc_bfd_fix *
-get_bfd_fix (sec, offset, type)
- asection *sec;
- bfd_vma offset;
- unsigned type;
+get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
{
xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
reloc_bfd_fix *rv;
};
-static void init_section_cache
- PARAMS ((section_cache_t *));
-static bfd_boolean section_cache_section
- PARAMS ((section_cache_t *, asection *, struct bfd_link_info *));
-static void clear_section_cache
- PARAMS ((section_cache_t *));
+static void
+init_section_cache (section_cache_t *sec_cache)
+{
+ memset (sec_cache, 0, sizeof (*sec_cache));
+}
static void
-init_section_cache (sec_cache)
- section_cache_t *sec_cache;
+clear_section_cache (section_cache_t *sec_cache)
{
- memset (sec_cache, 0, sizeof (*sec_cache));
+ if (sec_cache->sec)
+ {
+ release_contents (sec_cache->sec, sec_cache->contents);
+ release_internal_relocs (sec_cache->sec, sec_cache->relocs);
+ if (sec_cache->ptbl)
+ free (sec_cache->ptbl);
+ memset (sec_cache, 0, sizeof (sec_cache));
+ }
}
static bfd_boolean
-section_cache_section (sec_cache, sec, link_info)
- section_cache_t *sec_cache;
- asection *sec;
- struct bfd_link_info *link_info;
+section_cache_section (section_cache_t *sec_cache,
+ asection *sec,
+ struct bfd_link_info *link_info)
{
bfd *abfd;
property_table_entry *prop_table = NULL;
return FALSE;
}
-
-static void
-clear_section_cache (sec_cache)
- section_cache_t *sec_cache;
-{
- if (sec_cache->sec)
- {
- release_contents (sec_cache->sec, sec_cache->contents);
- release_internal_relocs (sec_cache->sec, sec_cache->relocs);
- if (sec_cache->ptbl)
- free (sec_cache->ptbl);
- memset (sec_cache, 0, sizeof (sec_cache));
- }
-}
-
\f
/* Extended basic blocks. */
};
-static void init_ebb_constraint
- PARAMS ((ebb_constraint *));
-static void free_ebb_constraint
- PARAMS ((ebb_constraint *));
-static void init_ebb
- PARAMS ((ebb_t *, asection *, bfd_byte *, bfd_size_type,
- property_table_entry *, unsigned, Elf_Internal_Rela *, unsigned));
-static bfd_boolean extend_ebb_bounds
- PARAMS ((ebb_t *));
-static bfd_boolean extend_ebb_bounds_forward
- PARAMS ((ebb_t *));
-static bfd_boolean extend_ebb_bounds_backward
- PARAMS ((ebb_t *));
-static bfd_size_type insn_block_decodable_len
- PARAMS ((bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type));
-static void ebb_propose_action
- PARAMS ((ebb_constraint *, enum ebb_target_enum, bfd_vma, text_action_t,
- bfd_vma, int, bfd_boolean));
-static void ebb_add_proposed_action
- PARAMS ((ebb_constraint *, proposed_action *));
-
-
static void
-init_ebb_constraint (c)
- ebb_constraint *c;
+init_ebb_constraint (ebb_constraint *c)
{
memset (c, 0, sizeof (ebb_constraint));
}
static void
-free_ebb_constraint (c)
- ebb_constraint *c;
+free_ebb_constraint (ebb_constraint *c)
{
- if (c->actions != NULL)
+ if (c->actions)
free (c->actions);
}
static void
-init_ebb (ebb, sec, contents, content_length, prop_table, ptblsize,
- internal_relocs, reloc_count)
- ebb_t *ebb;
- asection *sec;
- bfd_byte *contents;
- bfd_size_type content_length;
- property_table_entry *prop_table;
- unsigned ptblsize;
- Elf_Internal_Rela *internal_relocs;
- unsigned reloc_count;
+init_ebb (ebb_t *ebb,
+ asection *sec,
+ bfd_byte *contents,
+ bfd_size_type content_length,
+ property_table_entry *prop_table,
+ unsigned ptblsize,
+ Elf_Internal_Rela *internal_relocs,
+ unsigned reloc_count)
{
memset (ebb, 0, sizeof (ebb_t));
ebb->sec = sec;
a block that cannot be transformed. Then we push it backwards
searching for similar conditions. */
+static bfd_boolean extend_ebb_bounds_forward (ebb_t *);
+static bfd_boolean extend_ebb_bounds_backward (ebb_t *);
+static bfd_size_type insn_block_decodable_len
+ (bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type);
+
static bfd_boolean
-extend_ebb_bounds (ebb)
- ebb_t *ebb;
+extend_ebb_bounds (ebb_t *ebb)
{
if (!extend_ebb_bounds_forward (ebb))
return FALSE;
static bfd_boolean
-extend_ebb_bounds_forward (ebb)
- ebb_t *ebb;
+extend_ebb_bounds_forward (ebb_t *ebb)
{
property_table_entry *the_entry, *new_entry;
static bfd_boolean
-extend_ebb_bounds_backward (ebb)
- ebb_t *ebb;
+extend_ebb_bounds_backward (ebb_t *ebb)
{
property_table_entry *the_entry, *new_entry;
static bfd_size_type
-insn_block_decodable_len (contents, content_len, block_offset, block_len)
- bfd_byte *contents;
- bfd_size_type content_len;
- bfd_vma block_offset;
- bfd_size_type block_len;
+insn_block_decodable_len (bfd_byte *contents,
+ bfd_size_type content_len,
+ bfd_vma block_offset,
+ bfd_size_type block_len)
{
bfd_vma offset = block_offset;
static void
-ebb_propose_action (c, align_type, alignment_pow, action, offset,
- removed_bytes, do_action)
- ebb_constraint *c;
- bfd_vma alignment_pow;
- enum ebb_target_enum align_type;
- text_action_t action;
- bfd_vma offset;
- int removed_bytes;
- bfd_boolean do_action;
-{
- proposed_action paction;
- paction.align_type = align_type;
- paction.alignment_pow = alignment_pow;
- paction.action = action;
- paction.offset = offset;
- paction.removed_bytes = removed_bytes;
- paction.do_action = do_action;
- ebb_add_proposed_action (c, &paction);
-}
-
-
-static void
-ebb_add_proposed_action (c, action)
- ebb_constraint *c;
- proposed_action *action;
+ebb_propose_action (ebb_constraint *c,
+ enum ebb_target_enum align_type,
+ bfd_vma alignment_pow,
+ text_action_t action,
+ bfd_vma offset,
+ int removed_bytes,
+ bfd_boolean do_action)
{
- unsigned i;
+ proposed_action *act;
+
if (c->action_allocated <= c->action_count)
{
- unsigned new_allocated = (c->action_count + 2) * 2;
- proposed_action *new_actions = (proposed_action *)
+ unsigned new_allocated, i;
+ proposed_action *new_actions;
+
+ new_allocated = (c->action_count + 2) * 2;
+ new_actions = (proposed_action *)
bfd_zmalloc (sizeof (proposed_action) * new_allocated);
for (i = 0; i < c->action_count; i++)
new_actions[i] = c->actions[i];
- if (c->actions != NULL)
+ if (c->actions)
free (c->actions);
c->actions = new_actions;
c->action_allocated = new_allocated;
}
- c->actions[c->action_count] = *action;
+
+ act = &c->actions[c->action_count];
+ act->align_type = align_type;
+ act->alignment_pow = alignment_pow;
+ act->action = action;
+ act->offset = offset;
+ act->removed_bytes = removed_bytes;
+ act->do_action = do_action;
+
c->action_count++;
}
standard BFD functions to take care of this for us. */
static Elf_Internal_Rela *
-retrieve_internal_relocs (abfd, sec, keep_memory)
- bfd *abfd;
- asection *sec;
- bfd_boolean keep_memory;
+retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
{
Elf_Internal_Rela *internal_relocs;
internal_relocs = elf_section_data (sec)->relocs;
if (internal_relocs == NULL)
internal_relocs = (_bfd_elf_link_read_relocs
- (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
- keep_memory));
+ (abfd, sec, NULL, NULL, keep_memory));
return internal_relocs;
}
static void
-pin_internal_relocs (sec, internal_relocs)
- asection *sec;
- Elf_Internal_Rela *internal_relocs;
+pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
{
elf_section_data (sec)->relocs = internal_relocs;
}
static void
-release_internal_relocs (sec, internal_relocs)
- asection *sec;
- Elf_Internal_Rela *internal_relocs;
+release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
{
if (internal_relocs
&& elf_section_data (sec)->relocs != internal_relocs)
static bfd_byte *
-retrieve_contents (abfd, sec, keep_memory)
- bfd *abfd;
- asection *sec;
- bfd_boolean keep_memory;
+retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
{
bfd_byte *contents;
bfd_size_type sec_size;
{
if (!bfd_malloc_and_get_section (abfd, sec, &contents))
{
- if (contents != NULL)
+ if (contents)
free (contents);
return NULL;
}
static void
-pin_contents (sec, contents)
- asection *sec;
- bfd_byte *contents;
+pin_contents (asection *sec, bfd_byte *contents)
{
elf_section_data (sec)->this_hdr.contents = contents;
}
static void
-release_contents (sec, contents)
- asection *sec;
- bfd_byte *contents;
+release_contents (asection *sec, bfd_byte *contents)
{
if (contents && elf_section_data (sec)->this_hdr.contents != contents)
free (contents);
static Elf_Internal_Sym *
-retrieve_local_syms (input_bfd)
- bfd *input_bfd;
+retrieve_local_syms (bfd *input_bfd)
{
Elf_Internal_Shdr *symtab_hdr;
Elf_Internal_Sym *isymbuf;
/* Code for link-time relaxation. */
/* Initialization for relaxation: */
-static bfd_boolean analyze_relocations
- PARAMS ((struct bfd_link_info *));
+static bfd_boolean analyze_relocations (struct bfd_link_info *);
static bfd_boolean find_relaxable_sections
- PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
+ (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
static bfd_boolean collect_source_relocs
- PARAMS ((bfd *, asection *, struct bfd_link_info *));
+ (bfd *, asection *, struct bfd_link_info *);
static bfd_boolean is_resolvable_asm_expansion
- PARAMS ((bfd *, asection *, bfd_byte *, Elf_Internal_Rela *,
- struct bfd_link_info *, bfd_boolean *));
+ (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
+ bfd_boolean *);
static Elf_Internal_Rela *find_associated_l32r_irel
- PARAMS ((bfd *, asection *, bfd_byte *, Elf_Internal_Rela *,
- Elf_Internal_Rela *));
+ (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
static bfd_boolean compute_text_actions
- PARAMS ((bfd *, asection *, struct bfd_link_info *));
-static bfd_boolean compute_ebb_proposed_actions
- PARAMS ((ebb_constraint *));
-static bfd_boolean compute_ebb_actions
- PARAMS ((ebb_constraint *));
+ (bfd *, asection *, struct bfd_link_info *);
+static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
+static bfd_boolean compute_ebb_actions (ebb_constraint *);
static bfd_boolean check_section_ebb_pcrels_fit
- PARAMS ((bfd *, asection *, bfd_byte *, Elf_Internal_Rela *,
- const ebb_constraint *));
-static bfd_boolean check_section_ebb_reduces
- PARAMS ((const ebb_constraint *));
+ (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, const ebb_constraint *);
+static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
static void text_action_add_proposed
- PARAMS ((text_action_list *, const ebb_constraint *, asection *));
-static int compute_fill_extra_space
- PARAMS ((property_table_entry *));
+ (text_action_list *, const ebb_constraint *, asection *);
+static int compute_fill_extra_space (property_table_entry *);
/* First pass: */
static bfd_boolean compute_removed_literals
- PARAMS ((bfd *, asection *, struct bfd_link_info *, value_map_hash_table *));
+ (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
static Elf_Internal_Rela *get_irel_at_offset
- PARAMS ((asection *, Elf_Internal_Rela *, bfd_vma));
+ (asection *, Elf_Internal_Rela *, bfd_vma);
static bfd_boolean is_removable_literal
- PARAMS ((const source_reloc *, int, const source_reloc *, int));
+ (const source_reloc *, int, const source_reloc *, int);
static bfd_boolean remove_dead_literal
- PARAMS ((bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
- Elf_Internal_Rela *, source_reloc *, property_table_entry *, int));
-static bfd_boolean identify_literal_placement
- PARAMS ((bfd *, asection *, bfd_byte *, struct bfd_link_info *,
- value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
- source_reloc *, property_table_entry *, int, section_cache_t *,
- bfd_boolean));
-static bfd_boolean relocations_reach
- PARAMS ((source_reloc *, int, const r_reloc *));
+ (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
+ Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
+static bfd_boolean identify_literal_placement
+ (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
+ value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
+ source_reloc *, property_table_entry *, int, section_cache_t *,
+ bfd_boolean);
+static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
static bfd_boolean coalesce_shared_literal
- PARAMS ((asection *, source_reloc *, property_table_entry *, int,
- value_map *));
+ (asection *, source_reloc *, property_table_entry *, int, value_map *);
static bfd_boolean move_shared_literal
- PARAMS ((asection *, struct bfd_link_info *, source_reloc *,
- property_table_entry *, int, const r_reloc *,
- const literal_value *, section_cache_t *));
+ (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
+ int, const r_reloc *, const literal_value *, section_cache_t *);
/* Second pass: */
-static bfd_boolean relax_section
- PARAMS ((bfd *, asection *, struct bfd_link_info *));
-static bfd_boolean translate_section_fixes
- PARAMS ((asection *));
-static bfd_boolean translate_reloc_bfd_fix
- PARAMS ((reloc_bfd_fix *));
-static void translate_reloc
- PARAMS ((const r_reloc *, r_reloc *));
+static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
+static bfd_boolean translate_section_fixes (asection *);
+static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
+static void translate_reloc (const r_reloc *, r_reloc *);
static void shrink_dynamic_reloc_sections
- PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *));
+ (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
static bfd_boolean move_literal
- PARAMS ((bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
- xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *));
+ (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
+ xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
static bfd_boolean relax_property_section
- PARAMS ((bfd *, asection *, struct bfd_link_info *));
+ (bfd *, asection *, struct bfd_link_info *);
/* Third pass: */
-static bfd_boolean relax_section_symbols
- PARAMS ((bfd *, asection *));
+static bfd_boolean relax_section_symbols (bfd *, asection *);
static bfd_boolean
-elf_xtensa_relax_section (abfd, sec, link_info, again)
- bfd *abfd;
- asection *sec;
- struct bfd_link_info *link_info;
- bfd_boolean *again;
+elf_xtensa_relax_section (bfd *abfd,
+ asection *sec,
+ struct bfd_link_info *link_info,
+ bfd_boolean *again)
{
static value_map_hash_table *values = NULL;
static bfd_boolean relocations_analyzed = FALSE;
branch target alignments. */
static bfd_boolean
-analyze_relocations (link_info)
- struct bfd_link_info *link_info;
+analyze_relocations (struct bfd_link_info *link_info)
{
bfd *abfd;
asection *sec;
relaxable literal section. */
static bfd_boolean
-find_relaxable_sections (abfd, sec, link_info, is_relaxable_p)
- bfd *abfd;
- asection *sec;
- struct bfd_link_info *link_info;
- bfd_boolean *is_relaxable_p;
+find_relaxable_sections (bfd *abfd,
+ asection *sec,
+ struct bfd_link_info *link_info,
+ bfd_boolean *is_relaxable_p)
{
Elf_Internal_Rela *internal_relocs;
bfd_byte *contents;
ASM_SIMPLIFY or by removing them. */
static bfd_boolean
-collect_source_relocs (abfd, sec, link_info)
- bfd *abfd;
- asection *sec;
- struct bfd_link_info *link_info;
+collect_source_relocs (bfd *abfd,
+ asection *sec,
+ struct bfd_link_info *link_info)
{
Elf_Internal_Rela *internal_relocs;
bfd_byte *contents;
for this section and the target section. */
bfd_boolean
-is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
- is_reachable_p)
- bfd *abfd;
- asection *sec;
- bfd_byte *contents;
- Elf_Internal_Rela *irel;
- struct bfd_link_info *link_info;
- bfd_boolean *is_reachable_p;
+is_resolvable_asm_expansion (bfd *abfd,
+ asection *sec,
+ bfd_byte *contents,
+ Elf_Internal_Rela *irel,
+ struct bfd_link_info *link_info,
+ bfd_boolean *is_reachable_p)
{
asection *target_sec;
bfd_vma target_offset;
static Elf_Internal_Rela *
-find_associated_l32r_irel (abfd, sec, contents, other_irel, internal_relocs)
- bfd *abfd;
- asection *sec;
- bfd_byte *contents;
- Elf_Internal_Rela *other_irel;
- Elf_Internal_Rela *internal_relocs;
+find_associated_l32r_irel (bfd *abfd,
+ asection *sec,
+ bfd_byte *contents,
+ Elf_Internal_Rela *other_irel,
+ Elf_Internal_Rela *internal_relocs)
{
unsigned i;
pass. */
bfd_boolean
-compute_text_actions (abfd, sec, link_info)
- bfd *abfd;
- asection *sec;
- struct bfd_link_info *link_info;
+compute_text_actions (bfd *abfd,
+ asection *sec,
+ struct bfd_link_info *link_info)
{
xtensa_relax_info *relax_info;
bfd_byte *contents;
}
#if DEBUG
- if (relax_info->action_list.head != NULL)
+ if (relax_info->action_list.head)
print_action_list (stderr, &relax_info->action_list);
#endif
/* Find all of the possible actions for an extended basic block. */
bfd_boolean
-compute_ebb_proposed_actions (ebb_table)
- ebb_constraint *ebb_table;
+compute_ebb_proposed_actions (ebb_constraint *ebb_table)
{
const ebb_t *ebb = &ebb_table->ebb;
unsigned rel_idx = ebb->start_reloc_idx;
of the EBB prevents it. */
bfd_boolean
-compute_ebb_actions (ebb_table)
- ebb_constraint *ebb_table;
+compute_ebb_actions (ebb_constraint *ebb_table)
{
unsigned i = 0;
unsigned j;
}
+/* The xlate_map is a sorted array of address mappings designed to
+ answer the offset_with_removed_text() query with a binary search instead
+ of a linear search through the section's action_list. */
+
+typedef struct xlate_map_entry xlate_map_entry_t;
+typedef struct xlate_map xlate_map_t;
+
+struct xlate_map_entry
+{
+ unsigned orig_address;
+ unsigned new_address;
+ unsigned size;
+};
+
+struct xlate_map
+{
+ unsigned entry_count;
+ xlate_map_entry_t *entry;
+};
+
+
+static int
+xlate_compare (const void *a_v, const void *b_v)
+{
+ const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
+ const xlate_map_entry_t *b = (const xlate_map_entry_t *) b_v;
+ if (a->orig_address < b->orig_address)
+ return -1;
+ if (a->orig_address > (b->orig_address + b->size - 1))
+ return 1;
+ return 0;
+}
+
+
+static bfd_vma
+xlate_offset_with_removed_text (const xlate_map_t *map,
+ text_action_list *action_list,
+ bfd_vma offset)
+{
+ xlate_map_entry_t tmp;
+ void *r;
+ xlate_map_entry_t *e;
+
+ if (map == NULL)
+ return offset_with_removed_text (action_list, offset);
+
+ if (map->entry_count == 0)
+ return offset;
+
+ tmp.orig_address = offset;
+ tmp.new_address = offset;
+ tmp.size = 1;
+
+ r = bsearch (&offset, map->entry, map->entry_count,
+ sizeof (xlate_map_entry_t), &xlate_compare);
+ e = (xlate_map_entry_t *) r;
+
+ BFD_ASSERT (e != NULL);
+ if (e == NULL)
+ return offset;
+ return e->new_address - e->orig_address + offset;
+}
+
+
+/* Build a binary searchable offset translation map from a section's
+ action list. */
+
+static xlate_map_t *
+build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
+{
+ xlate_map_t *map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
+ text_action_list *action_list = &relax_info->action_list;
+ unsigned num_actions = 0;
+ text_action *r;
+ int removed;
+ xlate_map_entry_t *current_entry;
+
+ if (map == NULL)
+ return NULL;
+
+ num_actions = action_list_count (action_list);
+ map->entry = (xlate_map_entry_t *)
+ bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
+ if (map->entry == NULL)
+ {
+ free (map);
+ return NULL;
+ }
+ map->entry_count = 0;
+
+ removed = 0;
+ current_entry = &map->entry[0];
+
+ current_entry->orig_address = 0;
+ current_entry->new_address = 0;
+ current_entry->size = 0;
+
+ for (r = action_list->head; r != NULL; r = r->next)
+ {
+ unsigned orig_size = 0;
+ switch (r->action)
+ {
+ case ta_none:
+ case ta_remove_insn:
+ case ta_convert_longcall:
+ case ta_remove_literal:
+ case ta_add_literal:
+ break;
+ case ta_remove_longcall:
+ orig_size = 6;
+ break;
+ case ta_narrow_insn:
+ orig_size = 3;
+ break;
+ case ta_widen_insn:
+ orig_size = 2;
+ break;
+ case ta_fill:
+ break;
+ }
+ current_entry->size =
+ r->offset + orig_size - current_entry->orig_address;
+ if (current_entry->size != 0)
+ {
+ current_entry++;
+ map->entry_count++;
+ }
+ current_entry->orig_address = r->offset + orig_size;
+ removed += r->removed_bytes;
+ current_entry->new_address = r->offset + orig_size - removed;
+ current_entry->size = 0;
+ }
+
+ current_entry->size = (bfd_get_section_limit (sec->owner, sec)
+ - current_entry->orig_address);
+ if (current_entry->size != 0)
+ map->entry_count++;
+
+ return map;
+}
+
+
+/* Free an offset translation map. */
+
+static void
+free_xlate_map (xlate_map_t *map)
+{
+ if (map && map->entry)
+ free (map->entry);
+ if (map)
+ free (map);
+}
+
+
/* Use check_section_ebb_pcrels_fit to make sure that all of the
relocations in a section will fit if a proposed set of actions
are performed. */
static bfd_boolean
-check_section_ebb_pcrels_fit (abfd, sec, contents, internal_relocs, constraint)
- bfd *abfd;
- asection *sec;
- bfd_byte *contents;
- Elf_Internal_Rela *internal_relocs;
- const ebb_constraint *constraint;
+check_section_ebb_pcrels_fit (bfd *abfd,
+ asection *sec,
+ bfd_byte *contents,
+ Elf_Internal_Rela *internal_relocs,
+ const ebb_constraint *constraint)
{
unsigned i, j;
Elf_Internal_Rela *irel;
+ xlate_map_t *xmap = NULL;
+ bfd_boolean ok = TRUE;
xtensa_relax_info *relax_info;
relax_info = get_xtensa_relax_info (sec);
+ if (relax_info && sec->reloc_count > 100)
+ {
+ xmap = build_xlate_map (sec, relax_info);
+ /* NULL indicates out of memory, but the slow version
+ can still be used. */
+ }
+
for (i = 0; i < sec->reloc_count; i++)
{
r_reloc r_rel;
if (relax_info)
{
- self_offset = offset_with_removed_text (&relax_info->action_list,
- orig_self_offset);
- target_offset = offset_with_removed_text (&relax_info->action_list,
- orig_target_offset);
+ self_offset =
+ xlate_offset_with_removed_text (xmap, &relax_info->action_list,
+ orig_self_offset);
+ target_offset =
+ xlate_offset_with_removed_text (xmap, &relax_info->action_list,
+ orig_target_offset);
}
self_removed_bytes = 0;
opcode = get_relocation_opcode (abfd, sec, contents, irel);
if (opcode == XTENSA_UNDEFINED)
- return FALSE;
+ {
+ ok = FALSE;
+ break;
+ }
opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
if (opnum == XTENSA_UNDEFINED)
- return FALSE;
+ {
+ ok = FALSE;
+ break;
+ }
if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
- return FALSE;
+ {
+ ok = FALSE;
+ break;
+ }
}
}
- return TRUE;
+ if (xmap)
+ free_xlate_map (xmap);
+
+ return ok;
}
static bfd_boolean
-check_section_ebb_reduces (constraint)
- const ebb_constraint *constraint;
+check_section_ebb_reduces (const ebb_constraint *constraint)
{
int removed = 0;
unsigned i;
void
-text_action_add_proposed (l, ebb_table, sec)
- text_action_list *l;
- const ebb_constraint *ebb_table;
- asection *sec;
+text_action_add_proposed (text_action_list *l,
+ const ebb_constraint *ebb_table,
+ asection *sec)
{
unsigned i;
int
-compute_fill_extra_space (entry)
- property_table_entry *entry;
+compute_fill_extra_space (property_table_entry *entry)
{
int fill_extra_space;
actual changes are deferred until the next pass. */
static bfd_boolean
-compute_removed_literals (abfd, sec, link_info, values)
- bfd *abfd;
- asection *sec;
- struct bfd_link_info *link_info;
- value_map_hash_table *values;
+compute_removed_literals (bfd *abfd,
+ asection *sec,
+ struct bfd_link_info *link_info,
+ value_map_hash_table *values)
{
xtensa_relax_info *relax_info;
bfd_byte *contents;
static Elf_Internal_Rela *
-get_irel_at_offset (sec, internal_relocs, offset)
- asection *sec;
- Elf_Internal_Rela *internal_relocs;
- bfd_vma offset;
+get_irel_at_offset (asection *sec,
+ Elf_Internal_Rela *internal_relocs,
+ bfd_vma offset)
{
unsigned i;
Elf_Internal_Rela *irel;
bfd_boolean
-is_removable_literal (rel, i, src_relocs, src_count)
- const source_reloc *rel;
- int i;
- const source_reloc *src_relocs;
- int src_count;
+is_removable_literal (const source_reloc *rel,
+ int i,
+ const source_reloc *src_relocs,
+ int src_count)
{
const source_reloc *curr_rel;
if (!rel->is_null)
bfd_boolean
-remove_dead_literal (abfd, sec, link_info, internal_relocs,
- irel, rel, prop_table, ptblsize)
- bfd *abfd;
- asection *sec;
- struct bfd_link_info *link_info;
- Elf_Internal_Rela *internal_relocs;
- Elf_Internal_Rela *irel;
- source_reloc *rel;
- property_table_entry *prop_table;
- int ptblsize;
+remove_dead_literal (bfd *abfd,
+ asection *sec,
+ struct bfd_link_info *link_info,
+ Elf_Internal_Rela *internal_relocs,
+ Elf_Internal_Rela *irel,
+ source_reloc *rel,
+ property_table_entry *prop_table,
+ int ptblsize)
{
property_table_entry *entry;
xtensa_relax_info *relax_info;
bfd_boolean
-identify_literal_placement (abfd, sec, contents, link_info, values,
- last_loc_is_prev_p, irel, remaining_src_rels,
- rel, prop_table, ptblsize, target_sec_cache,
- is_abs_literal)
- bfd *abfd;
- asection *sec;
- bfd_byte *contents;
- struct bfd_link_info *link_info;
- value_map_hash_table *values;
- bfd_boolean *last_loc_is_prev_p;
- Elf_Internal_Rela *irel;
- int remaining_src_rels;
- source_reloc *rel;
- property_table_entry *prop_table;
- int ptblsize;
- section_cache_t *target_sec_cache;
- bfd_boolean is_abs_literal;
+identify_literal_placement (bfd *abfd,
+ asection *sec,
+ bfd_byte *contents,
+ struct bfd_link_info *link_info,
+ value_map_hash_table *values,
+ bfd_boolean *last_loc_is_prev_p,
+ Elf_Internal_Rela *irel,
+ int remaining_src_rels,
+ source_reloc *rel,
+ property_table_entry *prop_table,
+ int ptblsize,
+ section_cache_t *target_sec_cache,
+ bfd_boolean is_abs_literal)
{
literal_value val;
value_map *val_map;
literal will be contiguous. */
static bfd_boolean
-relocations_reach (reloc, remaining_relocs, r_rel)
- source_reloc *reloc;
- int remaining_relocs;
- const r_reloc *r_rel;
+relocations_reach (source_reloc *reloc,
+ int remaining_relocs,
+ const r_reloc *r_rel)
{
bfd_vma from_offset, source_address, dest_address;
asection *sec;
!= sec->output_section)
return FALSE;
+ /* Absolute literals in the same output section can always be
+ combined. */
+ if (reloc[i].is_abs_literal)
+ continue;
+
/* A literal with no PC-relative relocations can be moved anywhere. */
if (reloc[i].opnd != -1)
{
the same as the other literal value. */
static bfd_boolean
-coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map)
- asection *sec;
- source_reloc *rel;
- property_table_entry *prop_table;
- int ptblsize;
- value_map *val_map;
+coalesce_shared_literal (asection *sec,
+ source_reloc *rel,
+ property_table_entry *prop_table,
+ int ptblsize,
+ value_map *val_map)
{
property_table_entry *entry;
text_action *fa;
this carefully. Also, it may make a branch go out of range. */
static bfd_boolean
-move_shared_literal (sec, link_info, rel, prop_table, ptblsize,
- target_loc, lit_value, target_sec_cache)
- asection *sec;
- struct bfd_link_info *link_info;
- source_reloc *rel;
- property_table_entry *prop_table;
- int ptblsize;
- const r_reloc *target_loc;
- const literal_value *lit_value;
- section_cache_t *target_sec_cache;
+move_shared_literal (asection *sec,
+ struct bfd_link_info *link_info,
+ source_reloc *rel,
+ property_table_entry *prop_table,
+ int ptblsize,
+ const r_reloc *target_loc,
+ const literal_value *lit_value,
+ section_cache_t *target_sec_cache)
{
property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
text_action *fa, *target_fa;
section size. */
bfd_boolean
-relax_section (abfd, sec, link_info)
- bfd *abfd;
- asection *sec;
- struct bfd_link_info *link_info;
+relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
{
Elf_Internal_Rela *internal_relocs;
xtensa_relax_info *relax_info;
static bfd_boolean
-translate_section_fixes (sec)
- asection *sec;
+translate_section_fixes (asection *sec)
{
xtensa_relax_info *relax_info;
reloc_bfd_fix *r;
section. If it has already been translated, no work is required. */
static bfd_boolean
-translate_reloc_bfd_fix (fix)
- reloc_bfd_fix *fix;
+translate_reloc_bfd_fix (reloc_bfd_fix *fix)
{
reloc_bfd_fix new_fix;
asection *sec;
/* Fix up a relocation to take account of removed literals. */
static void
-translate_reloc (orig_rel, new_rel)
- const r_reloc *orig_rel;
- r_reloc *new_rel;
+translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel)
{
asection *sec;
xtensa_relax_info *relax_info;
nothing else that needs to be done. */
static void
-shrink_dynamic_reloc_sections (info, abfd, input_section, rel)
- struct bfd_link_info *info;
- bfd *abfd;
- asection *input_section;
- Elf_Internal_Rela *rel;
+shrink_dynamic_reloc_sections (struct bfd_link_info *info,
+ bfd *abfd,
+ asection *input_section,
+ Elf_Internal_Rela *rel)
{
Elf_Internal_Shdr *symtab_hdr;
struct elf_link_hash_entry **sym_hashes;
section must be pinned after calling this routine. */
static bfd_boolean
-move_literal (abfd, link_info, sec, offset, contents, relax_info,
- internal_relocs_p, lit)
- bfd *abfd;
- struct bfd_link_info *link_info;
- asection *sec;
- bfd_vma offset;
- bfd_byte *contents;
- xtensa_relax_info *relax_info;
- Elf_Internal_Rela **internal_relocs_p;
- const literal_value *lit;
+move_literal (bfd *abfd,
+ struct bfd_link_info *link_info,
+ asection *sec,
+ bfd_vma offset,
+ bfd_byte *contents,
+ xtensa_relax_info *relax_info,
+ Elf_Internal_Rela **internal_relocs_p,
+ const literal_value *lit)
{
Elf_Internal_Rela *new_relocs = NULL;
size_t new_relocs_count = 0;
property sections. */
static bfd_boolean
-relax_property_section (abfd, sec, link_info)
- bfd *abfd;
- asection *sec;
- struct bfd_link_info *link_info;
+relax_property_section (bfd *abfd,
+ asection *sec,
+ struct bfd_link_info *link_info)
{
Elf_Internal_Rela *internal_relocs;
bfd_byte *contents;
/* Change symbol values to account for removed literals. */
bfd_boolean
-relax_section_symbols (abfd, sec)
- bfd *abfd;
- asection *sec;
+relax_section_symbols (bfd *abfd, asection *sec)
{
xtensa_relax_info *relax_info;
unsigned int sec_shndx;
/* "Fix" handling functions, called while performing relocations. */
static bfd_boolean
-do_fix_for_relocatable_link (rel, input_bfd, input_section, contents)
- Elf_Internal_Rela *rel;
- bfd *input_bfd;
- asection *input_section;
- bfd_byte *contents;
+do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
+ bfd *input_bfd,
+ asection *input_section,
+ bfd_byte *contents)
{
r_reloc r_rel;
asection *sec, *old_sec;
static void
-do_fix_for_final_link (rel, input_bfd, input_section, contents, relocationp)
- Elf_Internal_Rela *rel;
- bfd *input_bfd;
- asection *input_section;
- bfd_byte *contents;
- bfd_vma *relocationp;
+do_fix_for_final_link (Elf_Internal_Rela *rel,
+ bfd *input_bfd,
+ asection *input_section,
+ bfd_byte *contents,
+ bfd_vma *relocationp)
{
asection *sec;
int r_type = ELF32_R_TYPE (rel->r_info);
/* Miscellaneous utility functions.... */
static asection *
-elf_xtensa_get_plt_section (dynobj, chunk)
- bfd *dynobj;
- int chunk;
+elf_xtensa_get_plt_section (bfd *dynobj, int chunk)
{
char plt_name[10];
static asection *
-elf_xtensa_get_gotplt_section (dynobj, chunk)
- bfd *dynobj;
- int chunk;
+elf_xtensa_get_gotplt_section (bfd *dynobj, int chunk)
{
char got_name[14];
. an absolute value, return the absolute section. */
static asection *
-get_elf_r_symndx_section (abfd, r_symndx)
- bfd *abfd;
- unsigned long r_symndx;
+get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
{
Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
asection *target_sec = NULL;
static struct elf_link_hash_entry *
-get_elf_r_symndx_hash_entry (abfd, r_symndx)
- bfd *abfd;
- unsigned long r_symndx;
+get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
{
unsigned long indx;
struct elf_link_hash_entry *h;
/* Get the section-relative offset for a symbol number. */
static bfd_vma
-get_elf_r_symndx_offset (abfd, r_symndx)
- bfd *abfd;
- unsigned long r_symndx;
+get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
{
Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
bfd_vma offset = 0;
static bfd_boolean
-is_reloc_sym_weak (abfd, rel)
- bfd *abfd;
- Elf_Internal_Rela *rel;
+is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
{
unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
struct elf_link_hash_entry *h;
static bfd_boolean
-pcrel_reloc_fits (opc, opnd, self_address, dest_address)
- xtensa_opcode opc;
- int opnd;
- bfd_vma self_address;
- bfd_vma dest_address;
+pcrel_reloc_fits (xtensa_opcode opc,
+ int opnd,
+ bfd_vma self_address,
+ bfd_vma dest_address)
{
xtensa_isa isa = xtensa_default_isa;
uint32 valp = dest_address;
static bfd_boolean
-xtensa_is_property_section (sec)
- asection *sec;
+xtensa_is_property_section (asection *sec)
{
if (strncmp (XTENSA_INSN_SEC_NAME, sec->name, insn_sec_len) == 0
|| strncmp (XTENSA_LIT_SEC_NAME, sec->name, lit_sec_len) == 0
static bfd_boolean
-xtensa_is_littable_section (sec)
- asection *sec;
+xtensa_is_littable_section (asection *sec)
{
if (strncmp (XTENSA_LIT_SEC_NAME, sec->name, lit_sec_len) == 0)
return TRUE;
static int
-internal_reloc_compare (ap, bp)
- const PTR ap;
- const PTR bp;
+internal_reloc_compare (const void *ap, const void *bp)
{
const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
static int
-internal_reloc_matches (ap, bp)
- const PTR ap;
- const PTR bp;
+internal_reloc_matches (const void *ap, const void *bp)
{
const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
char *
-xtensa_get_property_section_name (sec, base_name)
- asection *sec;
- const char *base_name;
+xtensa_get_property_section_name (asection *sec, const char *base_name)
{
if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
{
char *linkonce_kind = 0;
if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
- linkonce_kind = "x";
+ linkonce_kind = "x.";
else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
- linkonce_kind = "p";
+ linkonce_kind = "p.";
else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
linkonce_kind = "prop.";
else
flagword
-xtensa_get_property_predef_flags (sec)
- asection *sec;
+xtensa_get_property_predef_flags (asection *sec)
{
if (strcmp (sec->name, XTENSA_INSN_SEC_NAME) == 0
|| strncmp (sec->name, ".gnu.linkonce.x.",
/* Other functions called directly by the linker. */
bfd_boolean
-xtensa_callback_required_dependence (abfd, sec, link_info, callback, closure)
- bfd *abfd;
- asection *sec;
- struct bfd_link_info *link_info;
- deps_callback_t callback;
- PTR closure;
+xtensa_callback_required_dependence (bfd *abfd,
+ asection *sec,
+ struct bfd_link_info *link_info,
+ deps_callback_t callback,
+ void *closure)
{
Elf_Internal_Rela *internal_relocs;
bfd_byte *contents;
/* The default literal sections should always be marked as "code" (i.e.,
SHF_EXECINSTR). This is particularly important for the Linux kernel
module loader so that the literals are not placed after the text. */
-static struct bfd_elf_special_section const elf_xtensa_special_sections[]=
+static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
{
- { ".literal", 8, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
- { ".init.literal", 13, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
{ ".fini.literal", 13, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
+ { ".init.literal", 13, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
+ { ".literal", 8, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
{ NULL, 0, 0, 0, 0 }
};
-
\f
#ifndef ELF_ARCH
#define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
#define TARGET_BIG_NAME "elf32-xtensa-be"
#define ELF_ARCH bfd_arch_xtensa
-/* The new EM_XTENSA value will be recognized beginning in the Xtensa T1040
- release. However, we still have to generate files with the EM_XTENSA_OLD
- value so that pre-T1040 tools can read the files. As soon as we stop
- caring about pre-T1040 tools, the following two values should be
- swapped. At the same time, any other code that uses EM_XTENSA_OLD
- should be changed to use EM_XTENSA. */
-#define ELF_MACHINE_CODE EM_XTENSA_OLD
-#define ELF_MACHINE_ALT1 EM_XTENSA
+#define ELF_MACHINE_CODE EM_XTENSA
+#define ELF_MACHINE_ALT1 EM_XTENSA_OLD
#if XCHAL_HAVE_MMU
#define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
projects / deliverable / binutils-gdb.git / blobdiff