#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 *));
-
+extern flagword elf_xtensa_get_private_bfd_flags (bfd *);
/* 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 *build_encoding_error_message (xtensa_opcode, bfd_vma);
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;
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;
}
-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;
/* 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;
static bfd_boolean
-add_extra_plt_sections (dynobj, count)
- bfd *dynobj;
- int count;
+add_extra_plt_sections (bfd *dynobj, int count)
{
int chunk;
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.
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;
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;
+build_encoding_error_message (xtensa_opcode opcode, bfd_vma target_address)
{
const char *opname = xtensa_opcode_name (xtensa_default_isa, opcode);
const char *msg;
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;
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;
/* 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");
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
{
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;
+elf_xtensa_get_private_bfd_flags (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;
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;
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;
/* 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 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_add_proposed_action (ebb_constraint *, proposed_action *);
+
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;
+ebb_propose_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;
static void
-ebb_add_proposed_action (c, action)
- ebb_constraint *c;
- proposed_action *action;
+ebb_add_proposed_action (ebb_constraint *c, proposed_action *action)
{
unsigned i;
if (c->action_allocated <= c->action_count)
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;
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;
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;
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;
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)
{
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;
OSDN Git Service
