diff options
| -rw-r--r-- | bfd/ChangeLog | 4 | ||||
| -rw-r--r-- | bfd/elf32-xtensa.c | 1852 | ||||
| -rw-r--r-- | gas/ChangeLog | 8 | ||||
| -rw-r--r-- | gas/config/tc-xtensa.c | 3621 | ||||
| -rw-r--r-- | gas/config/tc-xtensa.h | 70 | ||||
| -rw-r--r-- | gas/config/xtensa-istack.h | 18 | ||||
| -rw-r--r-- | gas/config/xtensa-relax.c | 474 | ||||
| -rw-r--r-- | gas/config/xtensa-relax.h | 8 | ||||
| -rw-r--r-- | ld/ChangeLog | 4 | ||||
| -rw-r--r-- | ld/emultempl/xtensaelf.em | 49 | ||||
| -rw-r--r-- | opcodes/ChangeLog | 4 | ||||
| -rw-r--r-- | opcodes/xtensa-dis.c | 26 |
12 files changed, 2335 insertions, 3803 deletions
diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 4dc9458..c0b4e3a 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,7 @@ +2004-10-12 Bob Wilson <bob.wilson@acm.org> + + * elf32-xtensa.c: Use ISO C90 formatting. + 2004-10-12 Paul Brook <paul@codesourcery.com> * elf32-arm.h (elf32_arm_merge_private_bfd_data): Rephrase error diff --git a/bfd/elf32-xtensa.c b/bfd/elf32-xtensa.c index 09ef0e1..56f317f 100644 --- a/bfd/elf32-xtensa.c +++ b/bfd/elf32-xtensa.c @@ -37,233 +37,105 @@ #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. @@ -467,9 +339,8 @@ static reloc_howto_type elf_howto_table[] = #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) { @@ -570,10 +441,9 @@ elf_xtensa_reloc_type_lookup (abfd, 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); @@ -634,9 +504,8 @@ static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] = 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 @@ -649,9 +518,7 @@ xtensa_elf_dynamic_symbol_p (h, info) 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; @@ -690,9 +557,7 @@ property_table_compare (ap, 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; @@ -710,13 +575,12 @@ property_table_matches (ap, 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; @@ -845,11 +709,10 @@ xtensa_read_table_entries (abfd, section, table_p, sec_name, output_addr) } -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; @@ -868,10 +731,9 @@ elf_xtensa_find_property_entry (property_table, property_table_size, addr) 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; @@ -884,11 +746,10 @@ elf_xtensa_in_literal_pool (lit_table, lit_table_size, addr) 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; @@ -1061,10 +922,33 @@ elf_xtensa_check_relocs (abfd, info, sec, relocs) 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. */ @@ -1078,14 +962,13 @@ elf_xtensa_hide_symbol (info, h, force_local) 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)) { @@ -1114,15 +997,15 @@ elf_xtensa_gc_mark_hook (sec, info, rel, h, sym) 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; @@ -1181,9 +1064,7 @@ elf_xtensa_gc_sweep_hook (abfd, info, sec, relocs) /* 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; @@ -1233,9 +1114,7 @@ elf_xtensa_create_dynamic_sections (dynobj, info) static bfd_boolean -add_extra_plt_sections (dynobj, count) - bfd *dynobj; - int count; +add_extra_plt_sections (bfd *dynobj, int count) { int chunk; @@ -1282,14 +1161,13 @@ add_extra_plt_sections (dynobj, count) 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); @@ -1306,35 +1184,8 @@ elf_xtensa_adjust_dynamic_symbol (info, h) } -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; @@ -1349,9 +1200,7 @@ elf_xtensa_fix_refcounts (h, 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; @@ -1366,9 +1215,7 @@ elf_xtensa_allocate_plt_size (h, 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; @@ -1383,9 +1230,8 @@ elf_xtensa_allocate_got_size (h, 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; @@ -1415,9 +1261,8 @@ elf_xtensa_allocate_local_got_size (info, srelgot) /* 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; @@ -1453,7 +1298,7 @@ elf_xtensa_size_dynamic_sections (output_bfd, info) /* 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. */ @@ -1462,7 +1307,7 @@ elf_xtensa_size_dynamic_sections (output_bfd, info) 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 @@ -1476,7 +1321,7 @@ elf_xtensa_size_dynamic_sections (output_bfd, info) 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. @@ -1684,14 +1529,13 @@ elf_xtensa_size_dynamic_sections (output_bfd, info) 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; @@ -1708,19 +1552,17 @@ elf_xtensa_modify_segment_map (abfd, info) 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; @@ -1921,7 +1763,7 @@ elf_xtensa_do_reloc (howto, abfd, input_section, relocation, 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. */ @@ -1951,9 +1793,7 @@ vsprint_msg VPARAMS ((const char *origmsg, const char *fmt, int arglen, ...)) 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; @@ -1986,15 +1826,13 @@ build_encoding_error_message (opcode, target_address) 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; @@ -2015,8 +1853,7 @@ bfd_elf_xtensa_reloc (abfd, reloc_entry, symbol, data, input_section, 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; @@ -2095,10 +1932,9 @@ bfd_elf_xtensa_reloc (abfd, reloc_entry, symbol, data, input_section, /* 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; @@ -2145,17 +1981,14 @@ elf_xtensa_create_plt_entry (dynobj, output_bfd, reloc_index) 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; @@ -2177,7 +2010,7 @@ elf_xtensa_relocate_section (output_bfd, info, input_bfd, 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"); @@ -2487,9 +2320,9 @@ elf_xtensa_relocate_section (output_bfd, info, input_bfd, 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 { @@ -2529,11 +2362,10 @@ elf_xtensa_relocate_section (output_bfd, info, input_bfd, 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) @@ -2561,10 +2393,9 @@ elf_xtensa_finish_dynamic_symbol (output_bfd, info, h, sym) 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; @@ -2669,9 +2500,8 @@ elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc) /* 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; @@ -2692,7 +2522,7 @@ elf_xtensa_finish_dynamic_sections (output_bfd, info) { 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, @@ -2700,7 +2530,7 @@ elf_xtensa_finish_dynamic_sections (output_bfd, info) } 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; @@ -2873,9 +2703,7 @@ elf_xtensa_finish_dynamic_sections (output_bfd, info) 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; @@ -2927,9 +2755,7 @@ elf_xtensa_merge_private_bfd_data (ibfd, obfd) 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); @@ -2942,17 +2768,14 @@ elf_xtensa_set_private_flags (abfd, 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; @@ -2976,8 +2799,7 @@ elf_xtensa_print_private_bfd_data (abfd, farg) /* 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; @@ -3001,9 +2823,8 @@ elf_xtensa_object_p (abfd) 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; @@ -3023,8 +2844,7 @@ elf_xtensa_final_write_processing (abfd, linker) 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)) { @@ -3039,11 +2859,10 @@ elf_xtensa_reloc_type_class (rela) 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; @@ -3164,10 +2983,9 @@ elf_xtensa_discard_info_for_section (abfd, cookie, info, sec) 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; @@ -3186,8 +3004,7 @@ elf_xtensa_discard_info (abfd, cookie, info) static bfd_boolean -elf_xtensa_ignore_discarded_relocs (sec) - asection *sec; +elf_xtensa_ignore_discarded_relocs (asection *sec) { return xtensa_is_property_section (sec); } @@ -3196,9 +3013,7 @@ elf_xtensa_ignore_discarded_relocs (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; @@ -3223,9 +3038,7 @@ elf_xtensa_grok_prstatus (abfd, note) 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) { @@ -3267,7 +3080,7 @@ static xtensa_opcode call8_op = XTENSA_UNDEFINED; static xtensa_opcode call12_op = XTENSA_UNDEFINED; static void -init_call_opcodes () +init_call_opcodes (void) { if (callx0_op == XTENSA_UNDEFINED) { @@ -3284,8 +3097,7 @@ init_call_opcodes () 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 @@ -3296,8 +3108,7 @@ is_indirect_call_opcode (opcode) 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 @@ -3308,8 +3119,7 @@ is_direct_call_opcode (opcode) 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 @@ -3351,9 +3161,7 @@ get_l32r_opcode (void) static bfd_vma -l32r_offset (addr, pc) - bfd_vma addr; - bfd_vma pc; +l32r_offset (bfd_vma addr, bfd_vma pc) { bfd_vma offset; @@ -3366,9 +3174,7 @@ l32r_offset (addr, pc) 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; @@ -3411,8 +3217,7 @@ get_relocation_opnd (opcode, r_type) int -get_relocation_slot (r_type) - int r_type; +get_relocation_slot (int r_type) { switch (r_type) { @@ -3436,11 +3241,10 @@ get_relocation_slot (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; @@ -3473,11 +3277,10 @@ get_relocation_opcode (abfd, sec, contents, irel) 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))) @@ -3488,10 +3291,9 @@ is_l32r_relocation (abfd, sec, contents, irel) 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; @@ -3512,8 +3314,7 @@ get_asm_simplify_size (contents, content_len, offset) 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); @@ -3521,8 +3322,7 @@ is_alt_relocation (r_type) bfd_boolean -is_operand_relocation (r_type) - int r_type; +is_operand_relocation (int r_type) { switch (r_type) { @@ -3548,10 +3348,9 @@ is_operand_relocation (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; @@ -3579,11 +3378,10 @@ insn_decode_len (contents, content_len, offset) 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; @@ -3617,11 +3415,10 @@ insn_decode_opcode (contents, content_len, offset, slot) 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) @@ -3631,11 +3428,10 @@ check_branch_target_aligned (contents, content_length, offset, address) 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 = @@ -3662,9 +3458,7 @@ check_loop_aligned (contents, content_length, offset, address) 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); @@ -3674,21 +3468,58 @@ check_branch_target_aligned_address (addr, len) /* 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 @@ -3697,6 +3528,12 @@ struct string_pair 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" }, @@ -3733,11 +3570,10 @@ struct string_pair widenable[] = 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; @@ -3880,11 +3716,10 @@ narrow_instruction (contents, content_length, offset, do_it) 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; @@ -4019,70 +3854,14 @@ widen_instruction (contents, content_length, offset, do_it) 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); -} - /* 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; @@ -4142,11 +3921,10 @@ elf_xtensa_do_asm_simplify (contents, address, content_length, error_message) 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, @@ -4164,8 +3942,7 @@ contract_asm_expansion (contents, content_length, irel, error_message) static xtensa_opcode -swap_callx_for_call_opcode (opcode) - xtensa_opcode opcode; +swap_callx_for_call_opcode (xtensa_opcode opcode) { init_call_opcodes (); @@ -4188,10 +3965,7 @@ swap_callx_for_call_opcode (opcode) #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; @@ -4312,23 +4086,6 @@ struct r_reloc_struct 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 @@ -4337,49 +4094,14 @@ static void print_r_reloc 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; @@ -4392,8 +4114,7 @@ r_reloc_get_target_offset (r_rel) 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); @@ -4401,8 +4122,7 @@ r_reloc_get_hash_entry (r_rel) 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); @@ -4410,8 +4130,7 @@ r_reloc_get_section (r_rel) 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) @@ -4426,12 +4145,42 @@ r_reloc_is_defined (r_rel) } +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)) { @@ -4486,23 +4235,13 @@ struct source_reloc_struct }; -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; @@ -4518,11 +4257,10 @@ init_source_reloc (reloc, source_sec, r_rel, opcode, opnd, is_abs_literal) 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; @@ -4540,9 +4278,7 @@ find_source_reloc (src_relocs, src_count, sec, irel) 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; @@ -4604,31 +4340,11 @@ struct value_map_hash_table_struct }; -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; @@ -4637,10 +4353,9 @@ init_literal_value (lit, r_rel, value, is_abs_literal) 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; @@ -4694,7 +4409,7 @@ literal_value_equal (src1, src2, final_static_link) #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; @@ -4716,8 +4431,7 @@ value_map_hash_table_init () 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); @@ -4725,16 +4439,14 @@ value_map_hash_table_delete (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; @@ -4761,10 +4473,9 @@ literal_value_hash (src) /* 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; @@ -4786,11 +4497,10 @@ value_map_get_cached_value (map, val, final_static_link) 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; @@ -4885,34 +4595,8 @@ struct text_action_list_struct }; -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; @@ -4920,9 +4604,7 @@ find_fill_action (l, sec, offset) 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, @@ -4935,17 +4617,16 @@ find_fill_action (l, sec, offset) 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); @@ -4971,10 +4652,8 @@ compute_removed_action_diff (ta, sec, offset, removed, removable_space) } -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; } @@ -4986,12 +4665,11 @@ adjust_fill_action (ta, 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; @@ -5004,9 +4682,7 @@ text_action_add (l, action, sec, offset, removed) 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, @@ -5030,12 +4706,11 @@ text_action_add (l, action, sec, offset, removed) 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; @@ -5066,10 +4741,8 @@ text_action_add_literal (l, action, loc, value, removed) } -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; @@ -5085,10 +4758,9 @@ offset_with_removed_text (action_list, offset) } -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; @@ -5102,10 +4774,8 @@ offset_with_removed_text_before_fill (action_list, offset) /* 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) @@ -5137,9 +4807,7 @@ find_insn_action (action_list, offset) #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; @@ -5203,24 +4871,13 @@ struct removed_literal_list_struct }; -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; @@ -5247,8 +4904,7 @@ add_removed_literal (removed_list, from, to) } 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; } @@ -5265,9 +4921,7 @@ add_removed_literal (removed_list, from, to) 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) @@ -5281,9 +4935,7 @@ find_removed_literal (removed_list, 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; @@ -5341,16 +4993,9 @@ struct elf_xtensa_section_data 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); @@ -5358,15 +5003,28 @@ elf_xtensa_new_section_hook (abfd, sec) 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); @@ -5392,21 +5050,6 @@ init_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; -} - /* Coalescing literals may require a relocation to refer to a section in a different input file, but the standard relocation information @@ -5432,29 +5075,14 @@ struct reloc_bfd_fix_struct }; -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; @@ -5472,9 +5100,7 @@ reloc_bfd_fix_init (src_sec, src_offset, src_type, 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; @@ -5485,9 +5111,7 @@ add_fix (src_sec, fix) 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; @@ -5499,8 +5123,7 @@ fix_compare (ap, bp) static void -cache_fix_array (sec) - asection *sec; +cache_fix_array (asection *sec) { unsigned i, count = 0; reloc_bfd_fix *r; @@ -5531,10 +5154,7 @@ cache_fix_array (sec) 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; @@ -5575,27 +5195,31 @@ struct section_cache_struct }; -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; @@ -5649,21 +5273,6 @@ section_cache_section (sec_cache, sec, link_info) 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)); - } -} - /* Extended basic blocks. */ @@ -5769,56 +5378,30 @@ struct ebb_constraint_struct }; -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; @@ -5843,9 +5426,13 @@ init_ebb (ebb, sec, contents, content_length, prop_table, ptblsize, 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; @@ -5856,8 +5443,7 @@ extend_ebb_bounds (ebb) 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; @@ -5933,8 +5519,7 @@ extend_ebb_bounds_forward (ebb) 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; @@ -5990,11 +5575,10 @@ extend_ebb_bounds_backward (ebb) 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; @@ -6011,16 +5595,16 @@ insn_block_decodable_len (contents, content_len, block_offset, block_len) } +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; @@ -6034,9 +5618,7 @@ ebb_propose_action (c, align_type, alignment_pow, action, offset, 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) @@ -6047,7 +5629,7 @@ ebb_add_proposed_action (c, action) 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; @@ -6067,10 +5649,7 @@ ebb_add_proposed_action (c, action) 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; @@ -6080,25 +5659,20 @@ retrieve_internal_relocs (abfd, sec, keep_memory) 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) @@ -6107,10 +5681,7 @@ release_internal_relocs (sec, 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; @@ -6122,7 +5693,7 @@ retrieve_contents (abfd, sec, keep_memory) { if (!bfd_malloc_and_get_section (abfd, sec, &contents)) { - if (contents != NULL) + if (contents) free (contents); return NULL; } @@ -6134,18 +5705,14 @@ retrieve_contents (abfd, sec, keep_memory) 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); @@ -6153,8 +5720,7 @@ release_contents (sec, 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; @@ -6179,87 +5745,71 @@ retrieve_local_syms (input_bfd) /* 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; @@ -6331,8 +5881,7 @@ elf_xtensa_relax_section (abfd, sec, link_info, again) 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; @@ -6403,11 +5952,10 @@ analyze_relocations (link_info) 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; @@ -6490,10 +6038,9 @@ find_relaxable_sections (abfd, sec, link_info, is_relaxable_p) 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; @@ -6650,14 +6197,12 @@ collect_source_relocs (abfd, sec, link_info) 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; @@ -6727,12 +6272,11 @@ is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info, 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; @@ -6764,10 +6308,9 @@ find_associated_l32r_irel (abfd, sec, contents, other_irel, internal_relocs) 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; @@ -6901,7 +6444,7 @@ compute_text_actions (abfd, sec, link_info) } #if DEBUG - if (relax_info->action_list.head != NULL) + if (relax_info->action_list.head) print_action_list (stderr, &relax_info->action_list); #endif @@ -6918,8 +6461,7 @@ error_return: /* 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; @@ -7080,8 +6622,7 @@ compute_ebb_proposed_actions (ebb_table) 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; @@ -7321,12 +6862,11 @@ compute_ebb_actions (ebb_table) 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; @@ -7424,8 +6964,7 @@ check_section_ebb_pcrels_fit (abfd, sec, contents, internal_relocs, constraint) 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; @@ -7444,10 +6983,9 @@ check_section_ebb_reduces (constraint) 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; @@ -7480,8 +7018,7 @@ text_action_add_proposed (l, ebb_table, sec) int -compute_fill_extra_space (entry) - property_table_entry *entry; +compute_fill_extra_space (property_table_entry *entry) { int fill_extra_space; @@ -7515,11 +7052,10 @@ compute_fill_extra_space (entry) 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; @@ -7642,10 +7178,9 @@ error_return: 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; @@ -7683,11 +7218,10 @@ get_irel_at_offset (sec, internal_relocs, offset) 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) @@ -7710,16 +7244,14 @@ is_removable_literal (rel, i, src_relocs, src_count) 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; @@ -7783,23 +7315,19 @@ remove_dead_literal (abfd, sec, link_info, internal_relocs, 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; @@ -7911,10 +7439,9 @@ identify_literal_placement (abfd, sec, contents, link_info, values, 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; @@ -7966,12 +7493,11 @@ relocations_reach (reloc, remaining_relocs, r_rel) 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; @@ -8032,16 +7558,14 @@ coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map) 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; @@ -8188,10 +7712,7 @@ move_shared_literal (sec, link_info, rel, prop_table, ptblsize, 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; @@ -8625,8 +8146,7 @@ relax_section (abfd, sec, link_info) static bfd_boolean -translate_section_fixes (sec) - asection *sec; +translate_section_fixes (asection *sec) { xtensa_relax_info *relax_info; reloc_bfd_fix *r; @@ -8647,8 +8167,7 @@ translate_section_fixes (sec) 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; @@ -8738,9 +8257,7 @@ translate_reloc_bfd_fix (fix) /* 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; @@ -8815,11 +8332,10 @@ translate_reloc (orig_rel, new_rel) 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; @@ -8919,16 +8435,14 @@ shrink_dynamic_reloc_sections (info, abfd, input_section, rel) 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; @@ -9054,10 +8568,9 @@ move_literal (abfd, link_info, sec, offset, contents, relax_info, 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; @@ -9405,9 +8918,7 @@ relax_property_section (abfd, sec, link_info) /* 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; @@ -9491,11 +9002,10 @@ relax_section_symbols (abfd, sec) /* "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; @@ -9538,12 +9048,11 @@ do_fix_for_relocatable_link (rel, input_bfd, input_section, contents) 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); @@ -9578,9 +9087,7 @@ do_fix_for_final_link (rel, input_bfd, input_section, contents, relocationp) /* 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]; @@ -9593,9 +9100,7 @@ elf_xtensa_get_plt_section (dynobj, chunk) 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]; @@ -9616,9 +9121,7 @@ elf_xtensa_get_gotplt_section (dynobj, chunk) . 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; @@ -9674,9 +9177,7 @@ get_elf_r_symndx_section (abfd, r_symndx) 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; @@ -9697,9 +9198,7 @@ get_elf_r_symndx_hash_entry (abfd, r_symndx) /* 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; @@ -9728,9 +9227,7 @@ get_elf_r_symndx_offset (abfd, r_symndx) 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; @@ -9743,11 +9240,10 @@ is_reloc_sym_weak (abfd, rel) 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; @@ -9765,8 +9261,7 @@ static int prop_sec_len = sizeof (XTENSA_PROP_SEC_NAME) - 1; 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 @@ -9784,8 +9279,7 @@ xtensa_is_property_section (sec) 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; @@ -9800,9 +9294,7 @@ xtensa_is_littable_section (sec) 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; @@ -9825,9 +9317,7 @@ internal_reloc_compare (ap, 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; @@ -9839,9 +9329,7 @@ internal_reloc_matches (ap, 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) { @@ -9878,8 +9366,7 @@ xtensa_get_property_section_name (sec, base_name) 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.", @@ -9900,12 +9387,11 @@ xtensa_get_property_predef_flags (sec) /* 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; diff --git a/gas/ChangeLog b/gas/ChangeLog index 1c954b8..043fb05 100644 --- a/gas/ChangeLog +++ b/gas/ChangeLog @@ -1,3 +1,11 @@ +2004-10-12 Bob Wilson <bob.wilson@acm.org> + + * config/tc-xtensa.c: Use ISO C90 formatting. + * config/tc-xtensa.h: Likewise. + * config/xtensa-istack.h: Likewise. + * config/xtensa-relax.c: Likewise. + * config/xtensa-relax.h: Likewise. + 2004-10-12 Paul Brook <paul@codesourcery.com> * config/tc-arm.c (md_begin): Change EF_ARM_EABI_VER3 to diff --git a/gas/config/tc-xtensa.c b/gas/config/tc-xtensa.c index ab626a4..faac466 100644 --- a/gas/config/tc-xtensa.c +++ b/gas/config/tc-xtensa.c @@ -74,7 +74,6 @@ bfd_boolean absolute_literals_supported = XSHAL_USE_ABSOLUTE_LITERALS; /* Maximum width we would pad an unreachable frag to get alignment. */ #define UNREACHABLE_MAX_WIDTH 8 -static void error_reset_cur_vinsn PARAMS ((void)); static vliw_insn cur_vinsn; size_t xtensa_fetch_width = XCHAL_INST_FETCH_WIDTH; @@ -441,543 +440,115 @@ bfd_boolean directive_state[] = #endif }; -typedef bfd_boolean (*frag_predicate) (const fragS *); -typedef void (*frag_flags_fn) (const fragS *, frag_flags *); - -/* Command-line option functions. */ -static void xtensa_setup_hw_workarounds PARAMS ((int, int)); /* Directive functions. */ -static bfd_boolean use_transform - PARAMS ((void)); -static bfd_boolean use_longcalls - PARAMS ((void)); -static bfd_boolean do_align_targets - PARAMS ((void)); -static void directive_push - PARAMS ((directiveE, bfd_boolean, const void *)); -static void directive_pop - PARAMS ((directiveE *, bfd_boolean *, const char **, - unsigned int *, const void **)); -static void directive_balance - PARAMS ((void)); -static bfd_boolean inside_directive - PARAMS ((directiveE)); -static void get_directive - PARAMS ((directiveE *, bfd_boolean *)); -static void xtensa_begin_directive - PARAMS ((int)); -static void xtensa_end_directive - PARAMS ((int)); -static void xtensa_dwarf2_directive_loc - PARAMS ((int)); -static void xtensa_dwarf2_emit_insn - PARAMS ((int, struct dwarf2_line_info *)); -static void xtensa_literal_prefix - PARAMS ((char const *, int)); -static void xtensa_literal_position - PARAMS ((int)); -static void xtensa_literal_pseudo - PARAMS ((int)); -static void xtensa_frequency_pseudo - PARAMS ((int)); -static void xtensa_elf_cons - PARAMS ((int)); -static bfd_reloc_code_real_type xtensa_elf_suffix - PARAMS ((char **, expressionS *)); - -/* Parsing and Idiom Translation Functions. */ - -static const char *expression_end - PARAMS ((const char *)); -static unsigned tc_get_register - PARAMS ((const char *)); -static void expression_maybe_register - PARAMS ((xtensa_opcode, int, expressionS *)); -static int tokenize_arguments - PARAMS ((char **, char *)); -static bfd_boolean parse_arguments - PARAMS ((TInsn *, int, char **)); -static int get_invisible_operands - PARAMS ((TInsn *)); -static int xg_translate_idioms - PARAMS ((char **, int *, char **)); -static int xg_translate_sysreg_op - PARAMS ((char **, int *, char **)); -static int xtensa_translate_old_userreg_ops - PARAMS ((char **)); -static int xtensa_translate_zero_immed - PARAMS ((char *, char *, char **, int *, char **)); -static void xg_reverse_shift_count - PARAMS ((char **)); -static int xg_arg_is_constant - PARAMS ((char *, offsetT *)); -static void xg_replace_opname - PARAMS ((char **, char *)); -static int xg_check_num_args - PARAMS ((int *, int, char *, char **)); +static void xtensa_begin_directive (int); +static void xtensa_end_directive (int); +static void xtensa_dwarf2_directive_loc (int); +static void xtensa_literal_prefix (char const *, int); +static void xtensa_literal_position (int); +static void xtensa_literal_pseudo (int); +static void xtensa_frequency_pseudo (int); +static void xtensa_elf_cons (int); -/* Functions for dealing with the Xtensa ISA. */ +/* Parsing and Idiom Translation. */ -static int get_relaxable_immed - PARAMS ((xtensa_opcode)); -static xtensa_opcode get_opcode_from_buf - PARAMS ((const char *, int)); -#ifdef TENSILICA_DEBUG -static void xtensa_print_insn_table - PARAMS ((void)); -static void print_vliw_insn - PARAMS ((xtensa_insnbuf)); -#endif -static bfd_boolean is_direct_call_opcode - PARAMS ((xtensa_opcode)); -static bfd_boolean is_entry_opcode - PARAMS ((xtensa_opcode)); -static bfd_boolean is_movi_opcode - PARAMS ((xtensa_opcode)); -static bfd_boolean is_the_loop_opcode - PARAMS ((xtensa_opcode)); -static bfd_boolean is_jx_opcode - PARAMS ((xtensa_opcode)); -static bfd_boolean is_windowed_return_opcode - PARAMS ((xtensa_opcode)); -static int decode_reloc - PARAMS ((bfd_reloc_code_real_type, int *, bfd_boolean *)); -static bfd_reloc_code_real_type encode_reloc - PARAMS ((int)); -static bfd_reloc_code_real_type encode_alt_reloc - PARAMS ((int)); -static void xtensa_insnbuf_set_operand - PARAMS ((xtensa_insnbuf, xtensa_format, int, xtensa_opcode, int, uint32, - const char *, unsigned int)); -static uint32 xtensa_insnbuf_get_operand - PARAMS ((xtensa_insnbuf, xtensa_format, int, xtensa_opcode, int)); +static bfd_reloc_code_real_type xtensa_elf_suffix (char **, expressionS *); /* Various Other Internal Functions. */ -static bfd_boolean is_unique_insn_expansion - PARAMS ((TransitionRule *)); -static int xg_get_build_instr_size - PARAMS ((BuildInstr *)); -static bfd_boolean xg_is_narrow_insn - PARAMS ((TInsn *)); -static bfd_boolean xg_is_single_relaxable_insn - PARAMS ((TInsn *)); -static int xg_get_max_insn_widen_size - PARAMS ((xtensa_opcode)); -static int xg_get_max_insn_widen_literal_size - PARAMS ((xtensa_opcode)); -static bfd_boolean xg_is_relaxable_insn - PARAMS ((TInsn *, int)); -static symbolS *get_special_literal_symbol - PARAMS ((void)); -static symbolS *get_special_label_symbol - PARAMS ((void)); -static bfd_boolean xg_build_to_insn - PARAMS ((TInsn *, TInsn *, BuildInstr *)); -static bfd_boolean xg_build_to_stack - PARAMS ((IStack *, TInsn *, BuildInstr *)); -static bfd_boolean xg_expand_to_stack - PARAMS ((IStack *, TInsn *, int)); -static bfd_boolean xg_expand_narrow - PARAMS ((TInsn *, TInsn *)); -static bfd_boolean xg_immeds_fit - PARAMS ((const TInsn *)); -static bfd_boolean xg_symbolic_immeds_fit - PARAMS ((const TInsn *, segT, fragS *, offsetT, long)); -static bfd_boolean xg_check_operand - PARAMS ((int32, xtensa_opcode, int)); -static int xg_assembly_relax - PARAMS ((IStack *, TInsn *, segT, fragS *, offsetT, int, long)); -static void xg_force_frag_space - PARAMS ((int)); -static void xg_finish_frag - PARAMS ((char *, enum xtensa_relax_statesE, enum xtensa_relax_statesE, - int, bfd_boolean)); -static bfd_boolean is_branch_jmp_to_next - PARAMS ((TInsn *, fragS *)); -static void xg_add_branch_and_loop_targets - PARAMS ((TInsn *)); -static bfd_boolean xg_instruction_matches_options - PARAMS ((TInsn *, const ReqOption *)); -static bfd_boolean xg_instruction_matches_or_options - PARAMS ((TInsn *, const ReqOrOptionList *)); -static bfd_boolean xg_instruction_matches_option_term - PARAMS ((TInsn *, const ReqOrOption *)); -static bfd_boolean xg_instruction_matches_rule - PARAMS ((TInsn *, TransitionRule *)); -static TransitionRule *xg_instruction_match - PARAMS ((TInsn *)); -static int transition_rule_cmp - PARAMS ((const TransitionRule *, const TransitionRule *)); -static bfd_boolean xg_build_token_insn - PARAMS ((BuildInstr *, TInsn *, TInsn *)); -static bfd_boolean xg_simplify_insn - PARAMS ((TInsn *, TInsn *)); -static bfd_boolean xg_expand_assembly_insn - PARAMS ((IStack *, TInsn *)); -static symbolS *xg_assemble_literal - PARAMS ((TInsn *)); -static bfd_boolean xg_valid_literal_expression - PARAMS ((const expressionS *)); -static void xg_assemble_literal_space - PARAMS ((int, int)); -static symbolS *xtensa_create_literal_symbol - PARAMS ((segT, fragS *)); -static void xtensa_add_literal_sym - PARAMS ((symbolS *)); -static void xtensa_add_insn_label - PARAMS ((symbolS *)); -static void xtensa_clear_insn_labels - PARAMS ((void)); -static bfd_boolean get_is_linkonce_section - PARAMS ((bfd *, segT)); -static bfd_boolean xg_emit_insn_to_buf - PARAMS ((TInsn *, xtensa_format, char *, fragS *, offsetT, bfd_boolean)); -static bfd_boolean xg_add_opcode_fix - PARAMS ((TInsn *, int, xtensa_format, int, expressionS *, fragS *, offsetT)); -static void xg_resolve_literals - PARAMS ((TInsn *, symbolS *)); -static void xg_resolve_labels - PARAMS ((TInsn *, symbolS *)); -static bfd_boolean is_register_writer - PARAMS ((const TInsn *, const char *, int)); -static bfd_boolean is_bad_loopend_opcode - PARAMS ((const TInsn *)); -static bfd_boolean is_unaligned_label - PARAMS ((symbolS *)); -static fragS *next_non_empty_frag - PARAMS ((const fragS *)); -static bfd_boolean next_frag_opcode_is_loop - PARAMS ((const fragS *, xtensa_opcode *)); -static int next_frag_format_size - PARAMS ((const fragS *)); -static int frag_format_size - PARAMS ((const fragS *)); -static void update_next_frag_state - PARAMS ((fragS *, bfd_boolean)); -static bfd_boolean next_frag_is_branch_target - PARAMS ((const fragS *)); -static bfd_boolean next_frag_is_loop_target - PARAMS ((const fragS *)); -static addressT next_frag_pre_opcode_bytes - PARAMS ((const fragS *)); -static bfd_boolean is_next_frag_target - PARAMS ((const fragS *, const fragS *)); -static void xtensa_mark_literal_pool_location - PARAMS ((void)); -static void xtensa_move_labels - PARAMS ((fragS *, valueT, bfd_boolean)); -static void assemble_nop - PARAMS ((size_t, char *)); -static void build_nop - PARAMS ((TInsn *, int)); -static addressT get_expanded_loop_offset - PARAMS ((xtensa_opcode)); -static fragS *get_literal_pool_location - PARAMS ((segT)); -static void set_literal_pool_location - PARAMS ((segT, fragS *)); -static void xtensa_set_frag_assembly_state - PARAMS ((fragS *)); -static bfd_boolean relaxable_section - PARAMS ((asection *)); -static void xtensa_find_unmarked_state_frags - PARAMS ((void)); -static void xtensa_find_unaligned_branch_targets - PARAMS ((bfd *, asection *, PTR)); -static void xtensa_find_unaligned_loops - PARAMS ((bfd *, asection *, PTR)); -static void xg_apply_tentative_value - PARAMS ((fixS *, valueT)); -static void finish_vinsn - PARAMS ((vliw_insn *)); -static bfd_boolean find_vinsn_conflicts - PARAMS ((vliw_insn *)); -static char check_t1_t2_reads_and_writes - PARAMS ((TInsn *, TInsn *)); -static bfd_boolean resources_conflict - PARAMS ((vliw_insn *)); -static xtensa_format xg_find_narrowest_format - PARAMS ((vliw_insn *)); -static int relaxation_requirements - PARAMS ((vliw_insn *)); -static void bundle_single_op - PARAMS ((TInsn *)); -static bfd_boolean emit_single_op - PARAMS ((TInsn *)); -static void xg_assemble_vliw_tokens - PARAMS ((vliw_insn *)); - -/* Helpers for xtensa_end(). */ - -static void xtensa_cleanup_align_frags - PARAMS ((void)); -static void xtensa_fix_target_frags - PARAMS ((void)); -static bfd_boolean frag_can_negate_branch - PARAMS ((fragS *)); -static void xtensa_mark_narrow_branches - PARAMS ((void)); -static bfd_boolean is_narrow_branch_guaranteed_in_range - PARAMS ((fragS *, TInsn *)); -static void xtensa_mark_zcl_first_insns - PARAMS ((void)); -static void xtensa_fix_a0_b_retw_frags - PARAMS ((void)); -static bfd_boolean next_instrs_are_b_retw - PARAMS ((fragS *)); -static void xtensa_fix_b_j_loop_end_frags - PARAMS ((void)); -static bfd_boolean next_instr_is_loop_end - PARAMS ((fragS *)); -static void xtensa_fix_close_loop_end_frags - PARAMS ((void)); -static size_t min_bytes_to_other_loop_end - PARAMS ((fragS *, fragS *, offsetT, size_t)); -static size_t unrelaxed_frag_min_size - PARAMS ((fragS *)); -static size_t unrelaxed_frag_max_size - PARAMS ((fragS *)); -static void xtensa_fix_short_loop_frags - PARAMS ((void)); -static size_t count_insns_to_loop_end - PARAMS ((fragS *, bfd_boolean, size_t)); -static size_t unrelaxed_frag_min_insn_count - PARAMS ((fragS *)); -static bfd_boolean branch_before_loop_end - PARAMS ((fragS *)); -static bfd_boolean unrelaxed_frag_has_b_j - PARAMS ((fragS *)); -static void xtensa_sanity_check - PARAMS ((void)); -static bfd_boolean is_empty_loop - PARAMS ((const TInsn *, fragS *)); -static bfd_boolean is_local_forward_loop - PARAMS ((const TInsn *, fragS *)); +static void xtensa_mark_literal_pool_location (void); +static addressT get_expanded_loop_offset (xtensa_opcode); +static fragS *get_literal_pool_location (segT); +static void set_literal_pool_location (segT, fragS *); +static void xtensa_set_frag_assembly_state (fragS *); +static void finish_vinsn (vliw_insn *); +static bfd_boolean emit_single_op (TInsn *); /* Alignment Functions. */ -static size_t get_text_align_power - PARAMS ((int)); -static addressT get_text_align_max_fill_size - PARAMS ((int, bfd_boolean, bfd_boolean)); -static addressT get_text_align_fill_size - PARAMS ((addressT, int, int, bfd_boolean, bfd_boolean)); -static size_t get_text_align_nop_count - PARAMS ((size_t, bfd_boolean)); -static size_t get_text_align_nth_nop_size - PARAMS ((size_t, size_t, bfd_boolean)); -static addressT get_noop_aligned_address - PARAMS ((fragS *, addressT)); -static addressT get_aligned_diff - PARAMS ((fragS *, addressT, addressT *)); +static size_t get_text_align_power (int); +static addressT get_text_align_max_fill_size (int, bfd_boolean, bfd_boolean); /* Helpers for xtensa_relax_frag(). */ -static long relax_frag_loop_align - PARAMS ((fragS *, long)); -static long relax_frag_add_nop - PARAMS ((fragS *)); -static long relax_frag_for_align - PARAMS ((fragS *, long)); -static long future_alignment_required - PARAMS ((fragS *, long)); -static addressT find_address_of_next_align_frag - PARAMS ((fragS **, int *, int *, int *, bfd_boolean *)); -static long bytes_to_stretch - PARAMS ((fragS *, int, int, int, int)); -static long relax_frag_immed - PARAMS ((segT, fragS *, long, int, xtensa_format, int, int *, bfd_boolean)); - -/* Helpers for md_convert_frag(). */ - -static void convert_frag_align_next_opcode - PARAMS ((fragS *)); -static void convert_frag_narrow - PARAMS ((segT, fragS *, xtensa_format, int)); -static void convert_frag_fill_nop - PARAMS ((fragS *)); -static void convert_frag_immed - PARAMS ((segT, fragS *, int, xtensa_format, int)); -static fixS *fix_new_exp_in_seg - PARAMS ((segT, subsegT, fragS *, int, int, expressionS *, int, - bfd_reloc_code_real_type)); -static void convert_frag_immed_finish_loop - PARAMS ((segT, fragS *, TInsn *)); -static offsetT get_expression_value - PARAMS ((segT, expressionS *)); +static long relax_frag_add_nop (fragS *); /* Flags for the Last Instruction in Each Subsegment. */ -static unsigned get_last_insn_flags - PARAMS ((segT, subsegT)); -static void set_last_insn_flags - PARAMS ((segT, subsegT, unsigned, bfd_boolean)); +static subseg_map *get_subseg_info (segT, subsegT); +static unsigned get_last_insn_flags (segT, subsegT); +static void set_last_insn_flags (segT, subsegT, unsigned, bfd_boolean); /* Segment list functions. */ -static void xtensa_remove_section - PARAMS ((segT)); -static void xtensa_insert_section - PARAMS ((segT, segT)); -static void xtensa_move_seg_list_to_beginning - PARAMS ((seg_list *)); -static subseg_map *get_subseg_info - PARAMS ((segT, subsegT)); -static void xtensa_move_literals - PARAMS ((void)); -static void mark_literal_frags - PARAMS ((seg_list *)); -static void xtensa_reorder_seg_list - PARAMS ((seg_list *, segT)); -static void xtensa_reorder_segments - PARAMS ((void)); -static segT get_last_sec - PARAMS ((void)); -static void xtensa_switch_to_literal_fragment - PARAMS ((emit_state *)); -static void xtensa_switch_to_non_abs_literal_fragment - PARAMS ((emit_state *)); -static void xtensa_switch_section_emit_state - PARAMS ((emit_state *, segT, subsegT)); -static void xtensa_restore_emit_state - PARAMS ((emit_state *)); +static void xtensa_move_literals (void); +static void xtensa_reorder_segments (void); +static void xtensa_switch_to_literal_fragment (emit_state *); +static void xtensa_switch_to_non_abs_literal_fragment (emit_state *); +static void xtensa_switch_section_emit_state (emit_state *, segT, subsegT); +static void xtensa_restore_emit_state (emit_state *); static void cache_literal_section - PARAMS ((seg_list *, const char *, segT *, bfd_boolean)); -static segT retrieve_literal_seg - PARAMS ((seg_list *, const char *, bfd_boolean)); -static segT seg_present - PARAMS ((const char *)); -static void add_seg_list - PARAMS ((seg_list *, segT)); + (seg_list *, const char *, segT *, bfd_boolean); /* Property flags on fragments and conversion to object file flags. */ -static bfd_boolean get_frag_is_literal - PARAMS ((const fragS *)); -static bfd_boolean get_frag_is_insn - PARAMS ((const fragS *)); -static bfd_boolean get_frag_is_no_transform - PARAMS ((fragS *)); -static void set_frag_is_specific_opcode - PARAMS ((fragS *, bfd_boolean)); -static void set_frag_is_no_transform - PARAMS ((fragS *, bfd_boolean)); -static void xtensa_create_property_segments - PARAMS ((frag_predicate, frag_predicate, const char *, xt_section_type)); -static void xtensa_create_xproperty_segments - PARAMS ((frag_flags_fn, const char *, xt_section_type)); -static segment_info_type *retrieve_segment_info - PARAMS ((segT)); -static segT retrieve_xtensa_section - PARAMS ((char *)); -static bfd_boolean section_has_property - PARAMS ((segT, frag_predicate)); -static bfd_boolean section_has_xproperty - PARAMS ((segT, frag_flags_fn)); -static void add_xt_block_frags - PARAMS ((segT, segT, xtensa_block_info **, frag_predicate, frag_predicate)); -static bfd_boolean xtensa_frag_flags_is_empty - PARAMS ((const frag_flags *)); -static void xtensa_frag_flags_init - PARAMS ((frag_flags *)); -static void get_frag_property_flags - PARAMS ((const fragS *, frag_flags *)); -static bfd_vma frag_flags_to_number - PARAMS ((const frag_flags *)); -static bfd_boolean xtensa_frag_flags_combinable - PARAMS ((const frag_flags *, const frag_flags *)); -static bfd_vma xt_block_aligned_size - PARAMS ((const xtensa_block_info *)); -static bfd_boolean xtensa_xt_block_combine - PARAMS ((xtensa_block_info *, const xtensa_block_info *)); -static void add_xt_prop_frags - PARAMS ((segT, segT, xtensa_block_info **, frag_flags_fn)); +static bfd_boolean get_frag_is_literal (const fragS *); +static bfd_boolean get_frag_is_insn (const fragS *); +static bfd_boolean get_frag_is_no_transform (fragS *); +static void set_frag_is_specific_opcode (fragS *, bfd_boolean); +static void set_frag_is_no_transform (fragS *, bfd_boolean); /* Import from elf32-xtensa.c in BFD library. */ -extern char *xtensa_get_property_section_name - PARAMS ((asection *, const char *)); +extern char *xtensa_get_property_section_name (asection *, const char *); /* op_placement_info functions. */ -static void init_op_placement_info_table - PARAMS ((void)); -extern bfd_boolean opcode_fits_format_slot - PARAMS ((xtensa_opcode, xtensa_format, int)); -static int xg_get_single_size - PARAMS ((xtensa_opcode)); -static xtensa_format xg_get_single_format - PARAMS ((xtensa_opcode)); +static void init_op_placement_info_table (void); +extern bfd_boolean opcode_fits_format_slot (xtensa_opcode, xtensa_format, int); +static int xg_get_single_size (xtensa_opcode); +static xtensa_format xg_get_single_format (xtensa_opcode); /* TInsn and IStack functions. */ -static bfd_boolean tinsn_has_symbolic_operands - PARAMS ((const TInsn *)); -static bfd_boolean tinsn_has_invalid_symbolic_operands - PARAMS ((const TInsn *)); -static bfd_boolean tinsn_has_complex_operands - PARAMS ((const TInsn *)); -static bfd_boolean tinsn_to_insnbuf - PARAMS ((TInsn *, xtensa_insnbuf)); -static bfd_boolean tinsn_to_slotbuf - PARAMS ((xtensa_format, int, TInsn *, xtensa_insnbuf)); -static bfd_boolean tinsn_check_arguments - PARAMS ((const TInsn *)); -static void tinsn_from_chars - PARAMS ((TInsn *, char *, int)); -static void tinsn_from_insnbuf - PARAMS ((TInsn *, xtensa_insnbuf, xtensa_format, int)); -static void tinsn_immed_from_frag - PARAMS ((TInsn *, fragS *, int)); -static int get_num_stack_text_bytes - PARAMS ((IStack *)); -static int get_num_stack_literal_bytes - PARAMS ((IStack *)); +static bfd_boolean tinsn_has_symbolic_operands (const TInsn *); +static bfd_boolean tinsn_has_invalid_symbolic_operands (const TInsn *); +static bfd_boolean tinsn_has_complex_operands (const TInsn *); +static bfd_boolean tinsn_to_insnbuf (TInsn *, xtensa_insnbuf); +static bfd_boolean tinsn_check_arguments (const TInsn *); +static void tinsn_from_chars (TInsn *, char *, int); +static void tinsn_immed_from_frag (TInsn *, fragS *, int); +static int get_num_stack_text_bytes (IStack *); +static int get_num_stack_literal_bytes (IStack *); /* vliw_insn functions. */ -static void xg_init_vinsn - PARAMS ((vliw_insn *)); -static void xg_clear_vinsn - PARAMS ((vliw_insn *)); -static bfd_boolean vinsn_has_specific_opcodes - PARAMS ((vliw_insn *)); -static void xg_free_vinsn - PARAMS ((vliw_insn *)); +static void xg_init_vinsn (vliw_insn *); +static void xg_clear_vinsn (vliw_insn *); +static bfd_boolean vinsn_has_specific_opcodes (vliw_insn *); +static void xg_free_vinsn (vliw_insn *); static bfd_boolean vinsn_to_insnbuf - PARAMS ((vliw_insn *, char *, fragS *, bfd_boolean)); -static void vinsn_from_chars - PARAMS ((vliw_insn *, char *)); + (vliw_insn *, char *, fragS *, bfd_boolean); +static void vinsn_from_chars (vliw_insn *, char *); /* Expression Utilities. */ -bfd_boolean expr_is_const - PARAMS ((const expressionS *)); -offsetT get_expr_const - PARAMS ((const expressionS *)); -void set_expr_const - PARAMS ((expressionS *, offsetT)); -bfd_boolean expr_is_register - PARAMS ((const expressionS *)); -offsetT get_expr_register - PARAMS ((const expressionS *)); -void set_expr_symbol_offset - PARAMS ((expressionS *, symbolS *, offsetT)); +bfd_boolean expr_is_const (const expressionS *); +offsetT get_expr_const (const expressionS *); +void set_expr_const (expressionS *, offsetT); +bfd_boolean expr_is_register (const expressionS *); +offsetT get_expr_register (const expressionS *); +void set_expr_symbol_offset (expressionS *, symbolS *, offsetT); static void set_expr_symbol_offset_diff - PARAMS ((expressionS *, symbolS *, symbolS *, offsetT)); -bfd_boolean expr_is_equal - PARAMS ((expressionS *, expressionS *)); -static void copy_expr - PARAMS ((expressionS *, const expressionS *)); + (expressionS *, symbolS *, symbolS *, offsetT); +bfd_boolean expr_is_equal (expressionS *, expressionS *); +static void copy_expr (expressionS *, const expressionS *); #ifdef XTENSA_SECTION_RENAME -static void build_section_rename - PARAMS ((const char *)); -static void add_section_rename - PARAMS ((char *, char *)); +static void build_section_rename (const char *); +static void add_section_rename (char *, char *); #endif @@ -1038,6 +609,25 @@ static bfd_boolean maybe_has_close_loop_end = FALSE; static bfd_boolean workaround_all_short_loops = FALSE; + +static void +xtensa_setup_hw_workarounds (int earliest, int latest) +{ + if (earliest > latest) + as_fatal (_("illegal range of target hardware versions")); + + /* Enable all workarounds for pre-T1050.0 hardware. */ + if (earliest < 105000 || latest < 105000) + { + workaround_a0_b_retw |= TRUE; + workaround_b_j_loop_end |= TRUE; + workaround_short_loop |= TRUE; + workaround_close_loop_end |= TRUE; + workaround_all_short_loops |= TRUE; + } +} + + enum { option_density = OPTION_MD_BASE, @@ -1120,9 +710,9 @@ struct option md_longopts[] = /* This option was changed from -align-target to -target-align because it conflicted with the "-al" option. */ { "target-align", no_argument, NULL, option_align_targets }, - { "no-target-align", no_argument, NULL, - option_no_align_targets }, - { "warn-unaligned-targets", no_argument, NULL, option_warn_unaligned_targets }, + { "no-target-align", no_argument, NULL, option_no_align_targets }, + { "warn-unaligned-targets", no_argument, NULL, + option_warn_unaligned_targets }, { "longcalls", no_argument, NULL, option_longcalls }, { "no-longcalls", no_argument, NULL, option_no_longcalls }, @@ -1137,7 +727,8 @@ struct option md_longopts[] = { "no-workaround-short-loops", no_argument, NULL, option_no_workaround_short_loop }, - { "workaround-short-loops", no_argument, NULL, option_workaround_short_loop }, + { "workaround-short-loops", no_argument, NULL, + option_workaround_short_loop }, { "no-workaround-all-short-loops", no_argument, NULL, option_no_workaround_all_short_loops }, @@ -1155,8 +746,7 @@ struct option md_longopts[] = option_workaround_close_loop_end }, #ifdef XTENSA_SECTION_RENAME - { "rename-section", required_argument, NULL, - option_rename_section_name }, + { "rename-section", required_argument, NULL, option_rename_section_name }, #endif /* XTENSA_SECTION_RENAME */ { "link-relax", no_argument, NULL, option_link_relax }, @@ -1171,9 +761,7 @@ size_t md_longopts_size = sizeof md_longopts; int -md_parse_option (c, arg) - int c; - char *arg; +md_parse_option (int c, char *arg) { switch (c) { @@ -1346,8 +934,7 @@ md_parse_option (c, arg) void -md_show_usage (stream) - FILE *stream; +md_show_usage (FILE *stream) { fputs ("\n\ Xtensa options:\n\ @@ -1365,23 +952,77 @@ Xtensa options:\n\ , stream); } + +/* Functions related to the list of current label symbols. */ static void -xtensa_setup_hw_workarounds (earliest, latest) - int earliest; - int latest; +xtensa_add_insn_label (symbolS *sym) { - if (earliest > latest) - as_fatal (_("illegal range of target hardware versions")); + sym_list *l; - /* Enable all workarounds for pre-T1050.0 hardware. */ - if (earliest < 105000 || latest < 105000) + if (!free_insn_labels) + l = (sym_list *) xmalloc (sizeof (sym_list)); + else { - workaround_a0_b_retw |= TRUE; - workaround_b_j_loop_end |= TRUE; - workaround_short_loop |= TRUE; - workaround_close_loop_end |= TRUE; - workaround_all_short_loops |= TRUE; + l = free_insn_labels; + free_insn_labels = l->next; + } + + l->sym = sym; + l->next = insn_labels; + insn_labels = l; +} + + +static void +xtensa_clear_insn_labels (void) +{ + sym_list **pl; + + for (pl = &free_insn_labels; *pl != NULL; pl = &(*pl)->next) + ; + *pl = insn_labels; + insn_labels = NULL; +} + + +/* The "loops_ok" argument is provided to allow ignoring labels that + define loop ends. This fixes a bug where the NOPs to align a + loop opcode were included in a previous zero-cost loop: + + loop a0, loopend + <loop1 body> + loopend: + + loop a2, loopend2 + <loop2 body> + + would become: + + loop a0, loopend + <loop1 body> + nop.n <===== bad! + loopend: + + loop a2, loopend2 + <loop2 body> + + This argument is used to prevent moving the NOP to before the + loop-end label, which is what you want in this special case. */ + +static void +xtensa_move_labels (fragS *new_frag, valueT new_offset, bfd_boolean loops_ok) +{ + sym_list *lit; + + for (lit = insn_labels; lit; lit = lit->next) + { + symbolS *lit_sym = lit->sym; + if (loops_ok || ! symbol_get_tc (lit_sym)->is_loop_target) + { + S_SET_VALUE (lit_sym, new_offset); + symbol_set_frag (lit_sym, new_frag); + } } } @@ -1418,8 +1059,8 @@ const pseudo_typeS md_pseudo_table[] = }; -bfd_boolean -use_transform () +static bfd_boolean +use_transform (void) { /* After md_end, you should be checking frag by frag, rather than state directives. */ @@ -1428,8 +1069,8 @@ use_transform () } -bfd_boolean -use_longcalls () +static bfd_boolean +use_longcalls (void) { /* After md_end, you should be checking frag by frag, rather than state directives. */ @@ -1438,8 +1079,8 @@ use_longcalls () } -bfd_boolean -do_align_targets () +static bfd_boolean +do_align_targets (void) { /* After md_end, you should be checking frag by frag, rather than state directives. */ @@ -1449,10 +1090,7 @@ do_align_targets () static void -directive_push (directive, negated, datum) - directiveE directive; - bfd_boolean negated; - const void *datum; +directive_push (directiveE directive, bfd_boolean negated, const void *datum) { char *file; unsigned int line; @@ -1472,13 +1110,13 @@ directive_push (directive, negated, datum) directive_state[directive] = !negated; } + static void -directive_pop (directive, negated, file, line, datum) - directiveE *directive; - bfd_boolean *negated; - const char **file; - unsigned int *line; - const void **datum; +directive_pop (directiveE *directive, + bfd_boolean *negated, + const char **file, + unsigned int *line, + const void **datum) { state_stackS *top = directive_state_stack; @@ -1501,7 +1139,7 @@ directive_pop (directive, negated, file, line, datum) static void -directive_balance () +directive_balance (void) { while (directive_state_stack) { @@ -1519,8 +1157,7 @@ directive_balance () static bfd_boolean -inside_directive (dir) - directiveE dir; +inside_directive (directiveE dir) { state_stackS *top = directive_state_stack; @@ -1532,9 +1169,7 @@ inside_directive (dir) static void -get_directive (directive, negated) - directiveE *directive; - bfd_boolean *negated; +get_directive (directiveE *directive, bfd_boolean *negated) { int len; unsigned i; @@ -1587,8 +1222,7 @@ get_directive (directive, negated) static void -xtensa_begin_directive (ignore) - int ignore ATTRIBUTE_UNUSED; +xtensa_begin_directive (int ignore ATTRIBUTE_UNUSED) { directiveE directive; bfd_boolean negated; @@ -1699,8 +1333,7 @@ xtensa_begin_directive (ignore) static void -xtensa_end_directive (ignore) - int ignore ATTRIBUTE_UNUSED; +xtensa_end_directive (int ignore ATTRIBUTE_UNUSED) { directiveE begin_directive, end_directive; bfd_boolean begin_negated, end_negated; @@ -1802,8 +1435,7 @@ xtensa_end_directive (ignore) static bfd_boolean xtensa_loc_directive_seen = FALSE; static void -xtensa_dwarf2_directive_loc (x) - int x; +xtensa_dwarf2_directive_loc (int x) { xtensa_loc_directive_seen = TRUE; dwarf2_directive_loc (x); @@ -1811,9 +1443,7 @@ xtensa_dwarf2_directive_loc (x) static void -xtensa_dwarf2_emit_insn (size, loc) - int size; - struct dwarf2_line_info *loc; +xtensa_dwarf2_emit_insn (int size, struct dwarf2_line_info *loc) { if (debug_type != DEBUG_DWARF2 && ! xtensa_loc_directive_seen) return; @@ -1825,8 +1455,7 @@ xtensa_dwarf2_emit_insn (size, loc) /* Place an aligned literal fragment at the current location. */ static void -xtensa_literal_position (ignore) - int ignore ATTRIBUTE_UNUSED; +xtensa_literal_position (int ignore ATTRIBUTE_UNUSED) { md_flush_pending_output (); @@ -1842,8 +1471,7 @@ xtensa_literal_position (ignore) /* Support .literal label, expr, ... */ static void -xtensa_literal_pseudo (ignored) - int ignored ATTRIBUTE_UNUSED; +xtensa_literal_pseudo (int ignored ATTRIBUTE_UNUSED) { emit_state state; char *p, *base_name; @@ -1912,9 +1540,7 @@ xtensa_literal_pseudo (ignored) static void -xtensa_literal_prefix (start, len) - char const *start; - int len; +xtensa_literal_prefix (char const *start, int len) { char *name, *linkonce_suffix; char *newname, *newname4; @@ -1976,8 +1602,7 @@ xtensa_literal_prefix (start, len) /* Support ".frequency branch_target_frequency fall_through_frequency". */ static void -xtensa_frequency_pseudo (ignored) - int ignored ATTRIBUTE_UNUSED; +xtensa_frequency_pseudo (int ignored ATTRIBUTE_UNUSED) { float fall_through_f, target_f; subseg_map *seginfo; @@ -2010,8 +1635,7 @@ xtensa_frequency_pseudo (ignored) Clobbers input_line_pointer, checks end-of-line. */ static void -xtensa_elf_cons (nbytes) - int nbytes; +xtensa_elf_cons (int nbytes) { expressionS exp; bfd_reloc_code_real_type reloc; @@ -2066,12 +1690,12 @@ xtensa_elf_cons (nbytes) demand_empty_rest_of_line (); } + +/* Parsing and Idiom Translation. */ /* Parse @plt, etc. and return the desired relocation. */ static bfd_reloc_code_real_type -xtensa_elf_suffix (str_p, exp_p) - char **str_p; - expressionS *exp_p; +xtensa_elf_suffix (char **str_p, expressionS *exp_p) { struct map_bfd { @@ -2142,12 +1766,9 @@ xtensa_elf_suffix (str_p, exp_p) return BFD_RELOC_UNUSED; } - -/* Parsing and Idiom Translation. */ static const char * -expression_end (name) - const char *name; +expression_end (const char *name) { while (1) { @@ -2173,8 +1794,7 @@ expression_end (name) #define ERROR_REG_NUM ((unsigned) -1) static unsigned -tc_get_register (prefix) - const char *prefix; +tc_get_register (const char *prefix) { unsigned reg; const char *next_expr; @@ -2229,10 +1849,7 @@ tc_get_register (prefix) static void -expression_maybe_register (opc, opnd, tok) - xtensa_opcode opc; - int opnd; - expressionS *tok; +expression_maybe_register (xtensa_opcode opc, int opnd, expressionS *tok) { xtensa_isa isa = xtensa_default_isa; @@ -2302,9 +1919,7 @@ expression_maybe_register (opc, opnd, tok) /* Split up the arguments for an opcode or pseudo-op. */ static int -tokenize_arguments (args, str) - char **args; - char *str; +tokenize_arguments (char **args, char *str) { char *old_input_line_pointer; bfd_boolean saw_comma = FALSE; @@ -2390,10 +2005,7 @@ err: /* Parse the arguments to an opcode. Return TRUE on error. */ static bfd_boolean -parse_arguments (insn, num_args, arg_strings) - TInsn *insn; - int num_args; - char **arg_strings; +parse_arguments (TInsn *insn, int num_args, char **arg_strings) { expressionS *tok, *last_tok; xtensa_opcode opcode = insn->opcode; @@ -2491,8 +2103,7 @@ parse_arguments (insn, num_args, arg_strings) static int -get_invisible_operands (insn) - TInsn *insn; +get_invisible_operands (TInsn *insn) { xtensa_isa isa = xtensa_default_isa; static xtensa_insnbuf slotbuf = NULL; @@ -2560,8 +2171,7 @@ get_invisible_operands (insn) static void -xg_reverse_shift_count (cnt_argp) - char **cnt_argp; +xg_reverse_shift_count (char **cnt_argp) { char *cnt_arg, *new_arg; cnt_arg = *cnt_argp; @@ -2579,9 +2189,7 @@ xg_reverse_shift_count (cnt_argp) in *valp. */ static int -xg_arg_is_constant (arg, valp) - char *arg; - offsetT *valp; +xg_arg_is_constant (char *arg, offsetT *valp) { expressionS exp; char *save_ptr = input_line_pointer; @@ -2601,9 +2209,7 @@ xg_arg_is_constant (arg, valp) static void -xg_replace_opname (popname, newop) - char **popname; - char *newop; +xg_replace_opname (char **popname, char *newop) { free (*popname); *popname = (char *) xmalloc (strlen (newop) + 1); @@ -2612,11 +2218,10 @@ xg_replace_opname (popname, newop) static int -xg_check_num_args (pnum_args, expected_num, opname, arg_strings) - int *pnum_args; - int expected_num; - char *opname; - char **arg_strings; +xg_check_num_args (int *pnum_args, + int expected_num, + char *opname, + char **arg_strings) { int num_args = *pnum_args; @@ -2648,10 +2253,7 @@ xg_check_num_args (pnum_args, expected_num, opname, arg_strings) then get it from the operand and move it to the opcode. */ static int -xg_translate_sysreg_op (popname, pnum_args, arg_strings) - char **popname; - int *pnum_args; - char **arg_strings; +xg_translate_sysreg_op (char **popname, int *pnum_args, char **arg_strings) { xtensa_isa isa = xtensa_default_isa; xtensa_sysreg sr; @@ -2721,8 +2323,7 @@ xg_translate_sysreg_op (popname, pnum_args, arg_strings) static int -xtensa_translate_old_userreg_ops (popname) - char **popname; +xtensa_translate_old_userreg_ops (char **popname) { xtensa_isa isa = xtensa_default_isa; xtensa_sysreg sr; @@ -2783,12 +2384,11 @@ xtensa_translate_old_userreg_ops (popname) static int -xtensa_translate_zero_immed (old_op, new_op, popname, pnum_args, arg_strings) - char *old_op; - char *new_op; - char **popname; - int *pnum_args; - char **arg_strings; +xtensa_translate_zero_immed (char *old_op, + char *new_op, + char **popname, + int *pnum_args, + char **arg_strings) { char *opname; offsetT val; @@ -2818,10 +2418,7 @@ xtensa_translate_zero_immed (old_op, new_op, popname, pnum_args, arg_strings) Returns non-zero if an error was found. */ static int -xg_translate_idioms (popname, pnum_args, arg_strings) - char **popname; - int *pnum_args; - char **arg_strings; +xg_translate_idioms (char **popname, int *pnum_args, char **arg_strings) { char *opname = *popname; bfd_boolean has_underbar = FALSE; @@ -2940,9 +2537,8 @@ xg_translate_idioms (popname, pnum_args, arg_strings) last immediate operand, and if there are none of those, we fail and return -1. */ -int -get_relaxable_immed (opcode) - xtensa_opcode opcode; +static int +get_relaxable_immed (xtensa_opcode opcode) { int last_immed = -1; int noperands, opi; @@ -2966,9 +2562,7 @@ get_relaxable_immed (opcode) static xtensa_opcode -get_opcode_from_buf (buf, slot) - const char *buf; - int slot; +get_opcode_from_buf (const char *buf, int slot) { static xtensa_insnbuf insnbuf = NULL; static xtensa_insnbuf slotbuf = NULL; @@ -2998,8 +2592,8 @@ get_opcode_from_buf (buf, slot) /* For debugging, print out the mapping of opcode numbers to opcodes. */ -void -xtensa_print_insn_table () +static void +xtensa_print_insn_table (void) { int num_opcodes, num_operands; xtensa_opcode opcode; @@ -3032,8 +2626,7 @@ xtensa_print_insn_table () static void -print_vliw_insn (vbuf) - xtensa_insnbuf vbuf; +print_vliw_insn (xtensa_insnbuf vbuf) { xtensa_isa isa = xtensa_default_isa; xtensa_format f = xtensa_format_decode (isa, vbuf); @@ -3074,8 +2667,7 @@ print_vliw_insn (vbuf) static bfd_boolean -is_direct_call_opcode (opcode) - xtensa_opcode opcode; +is_direct_call_opcode (xtensa_opcode opcode) { xtensa_isa isa = xtensa_default_isa; int n, num_operands; @@ -3099,8 +2691,7 @@ is_direct_call_opcode (opcode) has an extra check for an operand value. */ static bfd_boolean -is_entry_opcode (opcode) - xtensa_opcode opcode; +is_entry_opcode (xtensa_opcode opcode) { if (opcode == XTENSA_UNDEFINED) return FALSE; @@ -3113,8 +2704,7 @@ is_entry_opcode (opcode) so we can relax "movi aX, foo" in the front end. */ static bfd_boolean -is_movi_opcode (opcode) - xtensa_opcode opcode; +is_movi_opcode (xtensa_opcode opcode) { if (opcode == XTENSA_UNDEFINED) return FALSE; @@ -3125,8 +2715,7 @@ is_movi_opcode (opcode) static bfd_boolean -is_the_loop_opcode (opcode) - xtensa_opcode opcode; +is_the_loop_opcode (xtensa_opcode opcode) { if (opcode == XTENSA_UNDEFINED) return FALSE; @@ -3136,8 +2725,7 @@ is_the_loop_opcode (opcode) static bfd_boolean -is_jx_opcode (opcode) - xtensa_opcode opcode; +is_jx_opcode (xtensa_opcode opcode) { if (opcode == XTENSA_UNDEFINED) return FALSE; @@ -3150,8 +2738,7 @@ is_jx_opcode (opcode) Needed to add nops to avoid a hardware interlock issue. */ static bfd_boolean -is_windowed_return_opcode (opcode) - xtensa_opcode opcode; +is_windowed_return_opcode (xtensa_opcode opcode) { if (opcode == XTENSA_UNDEFINED) return FALSE; @@ -3164,10 +2751,7 @@ is_windowed_return_opcode (opcode) Returns non-zero on failure. */ static int -decode_reloc (reloc, slot, is_alt) - bfd_reloc_code_real_type reloc; - int *slot; - bfd_boolean *is_alt; +decode_reloc (bfd_reloc_code_real_type reloc, int *slot, bfd_boolean *is_alt) { if (reloc >= BFD_RELOC_XTENSA_SLOT0_OP && reloc <= BFD_RELOC_XTENSA_SLOT14_OP) @@ -3193,8 +2777,7 @@ decode_reloc (reloc, slot, is_alt) failure. */ static bfd_reloc_code_real_type -encode_reloc (slot) - int slot; +encode_reloc (int slot) { if (slot < 0 || slot > 14) return BFD_RELOC_NONE; @@ -3207,8 +2790,7 @@ encode_reloc (slot) "alternate" relocations. Return BFD_RELOC_NONE on failure. */ static bfd_reloc_code_real_type -encode_alt_reloc (slot) - int slot; +encode_alt_reloc (int slot) { if (slot < 0 || slot > 14) return BFD_RELOC_NONE; @@ -3218,16 +2800,14 @@ encode_alt_reloc (slot) static void -xtensa_insnbuf_set_operand (slotbuf, fmt, slot, opcode, operand, value, - file, line) - xtensa_insnbuf slotbuf; - xtensa_format fmt; - int slot; - xtensa_opcode opcode; - int operand; - uint32 value; - const char *file; - unsigned int line; +xtensa_insnbuf_set_operand (xtensa_insnbuf slotbuf, + xtensa_format fmt, + int slot, + xtensa_opcode opcode, + int operand, + uint32 value, + const char *file, + unsigned int line) { uint32 valbuf = value; @@ -3251,12 +2831,11 @@ xtensa_insnbuf_set_operand (slotbuf, fmt, slot, opcode, operand, value, static uint32 -xtensa_insnbuf_get_operand (slotbuf, fmt, slot, opcode, opnum) - xtensa_insnbuf slotbuf; - xtensa_format fmt; - int slot; - xtensa_opcode opcode; - int opnum; +xtensa_insnbuf_get_operand (xtensa_insnbuf slotbuf, + xtensa_format fmt, + int slot, + xtensa_opcode opcode, + int opnum) { uint32 val = 0; (void) xtensa_operand_get_field (xtensa_default_isa, opcode, opnum, @@ -3266,11 +2845,247 @@ xtensa_insnbuf_get_operand (slotbuf, fmt, slot, opcode, opnum) } +/* Checks for rules from xtensa-relax tables. */ + +/* The routine xg_instruction_matches_option_term must return TRUE + when a given option term is true. The meaning of all of the option + terms is given interpretation by this function. This is needed when + an option depends on the state of a directive, but there are no such + options in use right now. */ + +static bfd_boolean +xg_instruction_matches_option_term (TInsn *insn ATTRIBUTE_UNUSED, + const ReqOrOption *option) +{ + if (strcmp (option->option_name, "realnop") == 0 + || strncmp (option->option_name, "IsaUse", 6) == 0) + { + /* These conditions were evaluated statically when building the + relaxation table. There's no need to reevaluate them now. */ + return TRUE; + } + else + { + as_fatal (_("internal error: unknown option name '%s'"), + option->option_name); + } +} + + +static bfd_boolean +xg_instruction_matches_or_options (TInsn *insn, + const ReqOrOptionList *or_option) +{ + const ReqOrOption *option; + /* Must match each of the AND terms. */ + for (option = or_option; option != NULL; option = option->next) + { + if (xg_instruction_matches_option_term (insn, option)) + return TRUE; + } + return FALSE; +} + + +static bfd_boolean +xg_instruction_matches_options (TInsn *insn, const ReqOptionList *options) +{ + const ReqOption *req_options; + /* Must match each of the AND terms. */ + for (req_options = options; + req_options != NULL; + req_options = req_options->next) + { + /* Must match one of the OR clauses. */ + if (!xg_instruction_matches_or_options (insn, + req_options->or_option_terms)) + return FALSE; + } + return TRUE; +} + + +/* Return the transition rule that matches or NULL if none matches. */ + +static bfd_boolean +xg_instruction_matches_rule (TInsn *insn, TransitionRule *rule) +{ + PreconditionList *condition_l; + + if (rule->opcode != insn->opcode) + return FALSE; + + for (condition_l = rule->conditions; + condition_l != NULL; + condition_l = condition_l->next) + { + expressionS *exp1; + expressionS *exp2; + Precondition *cond = condition_l->precond; + + switch (cond->typ) + { + case OP_CONSTANT: + /* The expression must be the constant. */ + assert (cond->op_num < insn->ntok); + exp1 = &insn->tok[cond->op_num]; + if (expr_is_const (exp1)) + { + switch (cond->cmp) + { + case OP_EQUAL: + if (get_expr_const (exp1) != cond->op_data) + return FALSE; + break; + case OP_NOTEQUAL: + if (get_expr_const (exp1) == cond->op_data) + return FALSE; + break; + default: + return FALSE; + } + } + else if (expr_is_register (exp1)) + { + switch (cond->cmp) + { + case OP_EQUAL: + if (get_expr_register (exp1) != cond->op_data) + return FALSE; + break; + case OP_NOTEQUAL: + if (get_expr_register (exp1) == cond->op_data) + return FALSE; + break; + default: + return FALSE; + } + } + else + return FALSE; + break; + + case OP_OPERAND: + assert (cond->op_num < insn->ntok); + assert (cond->op_data < insn->ntok); + exp1 = &insn->tok[cond->op_num]; + exp2 = &insn->tok[cond->op_data]; + + switch (cond->cmp) + { + case OP_EQUAL: + if (!expr_is_equal (exp1, exp2)) + return FALSE; + break; + case OP_NOTEQUAL: + if (expr_is_equal (exp1, exp2)) + return FALSE; + break; + } + break; + + case OP_LITERAL: + case OP_LABEL: + default: + return FALSE; + } + } + if (!xg_instruction_matches_options (insn, rule->options)) + return FALSE; + + return TRUE; +} + + +static int +transition_rule_cmp (const TransitionRule *a, const TransitionRule *b) +{ + bfd_boolean a_greater = FALSE; + bfd_boolean b_greater = FALSE; + + ReqOptionList *l_a = a->options; + ReqOptionList *l_b = b->options; + + /* We only care if they both are the same except for + a const16 vs. an l32r. */ + + while (l_a && l_b && ((l_a->next == NULL) == (l_b->next == NULL))) + { + ReqOrOptionList *l_or_a = l_a->or_option_terms; + ReqOrOptionList *l_or_b = l_b->or_option_terms; + while (l_or_a && l_or_b && ((l_a->next == NULL) == (l_b->next == NULL))) + { + if (l_or_a->is_true != l_or_b->is_true) + return 0; + if (strcmp (l_or_a->option_name, l_or_b->option_name) != 0) + { + /* This is the case we care about. */ + if (strcmp (l_or_a->option_name, "IsaUseConst16") == 0 + && strcmp (l_or_b->option_name, "IsaUseL32R") == 0) + { + if (prefer_const16) + a_greater = TRUE; + else + b_greater = TRUE; + } + else if (strcmp (l_or_a->option_name, "IsaUseL32R") == 0 + && strcmp (l_or_b->option_name, "IsaUseConst16") == 0) + { + if (prefer_const16) + b_greater = TRUE; + else + a_greater = TRUE; + } + else + return 0; + } + l_or_a = l_or_a->next; + l_or_b = l_or_b->next; + } + if (l_or_a || l_or_b) + return 0; + + l_a = l_a->next; + l_b = l_b->next; + } + if (l_a || l_b) + return 0; + + /* Incomparable if the substitution was used differently in two cases. */ + if (a_greater && b_greater) + return 0; + + if (b_greater) + return 1; + if (a_greater) + return -1; + + return 0; +} + + +static TransitionRule * +xg_instruction_match (TInsn *insn) +{ + TransitionTable *table = xg_build_simplify_table (&transition_rule_cmp); + TransitionList *l; + assert (insn->opcode < table->num_opcodes); + + /* Walk through all of the possible transitions. */ + for (l = table->table[insn->opcode]; l != NULL; l = l->next) + { + TransitionRule *rule = l->rule; + if (xg_instruction_matches_rule (insn, rule)) + return rule; + } + return NULL; +} + + /* Various Other Internal Functions. */ static bfd_boolean -is_unique_insn_expansion (r) - TransitionRule *r; +is_unique_insn_expansion (TransitionRule *r) { if (!r->to_instr || r->to_instr->next != NULL) return FALSE; @@ -3281,17 +3096,15 @@ is_unique_insn_expansion (r) static int -xg_get_build_instr_size (insn) - BuildInstr *insn; +xg_get_build_instr_size (BuildInstr *insn) { assert (insn->typ == INSTR_INSTR); return xg_get_single_size (insn->opcode); } -bfd_boolean -xg_is_narrow_insn (insn) - TInsn *insn; +static bfd_boolean +xg_is_narrow_insn (TInsn *insn) { TransitionTable *table = xg_build_widen_table (&transition_rule_cmp); TransitionList *l; @@ -3322,9 +3135,8 @@ xg_is_narrow_insn (insn) } -bfd_boolean -xg_is_single_relaxable_insn (insn) - TInsn *insn; +static bfd_boolean +xg_is_single_relaxable_insn (TInsn *insn) { TransitionTable *table = xg_build_widen_table (&transition_rule_cmp); TransitionList *l; @@ -3357,9 +3169,8 @@ xg_is_single_relaxable_insn (insn) /* Return the maximum number of bytes this opcode can expand to. */ -int -xg_get_max_insn_widen_size (opcode) - xtensa_opcode opcode; +static int +xg_get_max_insn_widen_size (xtensa_opcode opcode) { TransitionTable *table = xg_build_widen_table (&transition_rule_cmp); TransitionList *l; @@ -3404,9 +3215,8 @@ xg_get_max_insn_widen_size (opcode) /* Return the maximum number of literal bytes this opcode can generate. */ -int -xg_get_max_insn_widen_literal_size (opcode) - xtensa_opcode opcode; +static int +xg_get_max_insn_widen_literal_size (xtensa_opcode opcode) { TransitionTable *table = xg_build_widen_table (&transition_rule_cmp); TransitionList *l; @@ -3450,10 +3260,8 @@ xg_get_max_insn_widen_literal_size (opcode) } -bfd_boolean -xg_is_relaxable_insn (insn, lateral_steps) - TInsn *insn; - int lateral_steps; +static bfd_boolean +xg_is_relaxable_insn (TInsn *insn, int lateral_steps) { int steps_taken = 0; TransitionTable *table = xg_build_widen_table (&transition_rule_cmp); @@ -3478,7 +3286,7 @@ xg_is_relaxable_insn (insn, lateral_steps) static symbolS * -get_special_literal_symbol () +get_special_literal_symbol (void) { static symbolS *sym = NULL; @@ -3489,7 +3297,7 @@ get_special_literal_symbol () static symbolS * -get_special_label_symbol () +get_special_label_symbol (void) { static symbolS *sym = NULL; @@ -3499,13 +3307,170 @@ get_special_label_symbol () } +static bfd_boolean +xg_valid_literal_expression (const expressionS *exp) +{ + switch (exp->X_op) + { + case O_constant: + case O_symbol: + case O_big: + case O_uminus: + case O_subtract: + case O_pltrel: + return TRUE; + default: + return FALSE; + } +} + + +/* This will check to see if the value can be converted into the + operand type. It will return TRUE if it does not fit. */ + +static bfd_boolean +xg_check_operand (int32 value, xtensa_opcode opcode, int operand) +{ + uint32 valbuf = value; + if (xtensa_operand_encode (xtensa_default_isa, opcode, operand, &valbuf)) + return TRUE; + return FALSE; +} + + +/* Assumes: All immeds are constants. Check that all constants fit + into their immeds; return FALSE if not. */ + +static bfd_boolean +xg_immeds_fit (const TInsn *insn) +{ + xtensa_isa isa = xtensa_default_isa; + int i; + + int n = insn->ntok; + assert (insn->insn_type == ITYPE_INSN); + for (i = 0; i < n; ++i) + { + const expressionS *expr = &insn->tok[i]; + if (xtensa_operand_is_register (isa, insn->opcode, i) == 1) + continue; + + switch (expr->X_op) + { + case O_register: + case O_constant: + if (xg_check_operand (expr->X_add_number, insn->opcode, i)) + return FALSE; + break; + + default: + /* The symbol should have a fixup associated with it. */ + assert (FALSE); + break; + } + } + return TRUE; +} + + +/* This should only be called after we have an initial + estimate of the addresses. */ + +static bfd_boolean +xg_symbolic_immeds_fit (const TInsn *insn, + segT pc_seg, + fragS *pc_frag, + offsetT pc_offset, + long stretch) +{ + xtensa_isa isa = xtensa_default_isa; + symbolS *symbolP; + fragS *sym_frag; + offsetT target, pc; + uint32 new_offset; + int i; + int n = insn->ntok; + + assert (insn->insn_type == ITYPE_INSN); + + for (i = 0; i < n; ++i) + { + const expressionS *expr = &insn->tok[i]; + if (xtensa_operand_is_register (isa, insn->opcode, i) == 1) + continue; + + switch (expr->X_op) + { + case O_register: + case O_constant: + if (xg_check_operand (expr->X_add_number, insn->opcode, i)) + return FALSE; + break; + + case O_lo16: + case O_hi16: + /* Check for the worst case. */ + if (xg_check_operand (0xffff, insn->opcode, i)) + return FALSE; + break; + + case O_symbol: + /* We only allow symbols for pc-relative stuff. + If pc_frag == 0, then we don't have frag locations yet. */ + if (pc_frag == 0) + return FALSE; + + /* If it is PC-relative and the symbol is not in the same + segment as the PC.... */ + if (xtensa_operand_is_PCrelative (isa, insn->opcode, i) == 0 + || S_GET_SEGMENT (expr->X_add_symbol) != pc_seg) + return FALSE; + + /* If it is a weak symbol, then assume it won't reach. This will + only affect calls when longcalls are enabled, because if + longcalls are disabled, then the call is marked as a specific + opcode. */ + if (S_IS_WEAK (expr->X_add_symbol)) + return FALSE; + + symbolP = expr->X_add_symbol; + sym_frag = symbol_get_frag (symbolP); + target = S_GET_VALUE (symbolP) + expr->X_add_number; + pc = pc_frag->fr_address + pc_offset; + + /* If frag has yet to be reached on this pass, assume it + will move by STRETCH just as we did. If this is not so, + it will be because some frag between grows, and that will + force another pass. Beware zero-length frags. There + should be a faster way to do this. */ + + if (stretch != 0 + && sym_frag->relax_marker != pc_frag->relax_marker + && S_GET_SEGMENT (symbolP) == pc_seg) + { + target += stretch; + } + + new_offset = target; + xtensa_operand_do_reloc (isa, insn->opcode, i, &new_offset, pc); + if (xg_check_operand (new_offset, insn->opcode, i)) + return FALSE; + break; + + default: + /* The symbol should have a fixup associated with it. */ + return FALSE; + } + } + + return TRUE; +} + + /* Return TRUE on success. */ -bfd_boolean -xg_build_to_insn (targ, insn, bi) - TInsn *targ; - TInsn *insn; - BuildInstr *bi; +static bfd_boolean +xg_build_to_insn (TInsn *targ, TInsn *insn, BuildInstr *bi) { BuildOp *op; symbolS *sym; @@ -3658,11 +3623,8 @@ xg_build_to_insn (targ, insn, bi) /* Return TRUE on success. */ -bfd_boolean -xg_build_to_stack (istack, insn, bi) - IStack *istack; - TInsn *insn; - BuildInstr *bi; +static bfd_boolean +xg_build_to_stack (IStack *istack, TInsn *insn, BuildInstr *bi) { for (; bi != NULL; bi = bi->next) { @@ -3677,11 +3639,8 @@ xg_build_to_stack (istack, insn, bi) /* Return TRUE on valid expansion. */ -bfd_boolean -xg_expand_to_stack (istack, insn, lateral_steps) - IStack *istack; - TInsn *insn; - int lateral_steps; +static bfd_boolean +xg_expand_to_stack (IStack *istack, TInsn *insn, int lateral_steps) { int stack_size = istack->ninsn; int steps_taken = 0; @@ -3727,10 +3686,8 @@ xg_expand_to_stack (istack, insn, lateral_steps) } -bfd_boolean -xg_expand_narrow (targ, insn) - TInsn *targ; - TInsn *insn; +static bfd_boolean +xg_expand_narrow (TInsn *targ, TInsn *insn) { TransitionTable *table = xg_build_widen_table (&transition_rule_cmp); TransitionList *l; @@ -3756,168 +3713,18 @@ xg_expand_narrow (targ, insn) return TRUE; } - -/* Assumes: All immeds are constants. Check that all constants fit - into their immeds; return FALSE if not. */ - -static bfd_boolean -xg_immeds_fit (insn) - const TInsn *insn; -{ - xtensa_isa isa = xtensa_default_isa; - int i; - - int n = insn->ntok; - assert (insn->insn_type == ITYPE_INSN); - for (i = 0; i < n; ++i) - { - const expressionS *expr = &insn->tok[i]; - if (xtensa_operand_is_register (isa, insn->opcode, i) == 1) - continue; - - switch (expr->X_op) - { - case O_register: - case O_constant: - if (xg_check_operand (expr->X_add_number, insn->opcode, i)) - return FALSE; - break; - - default: - /* The symbol should have a fixup associated with it. */ - assert (FALSE); - break; - } - } - return TRUE; -} - - -/* This should only be called after we have an initial - estimate of the addresses. */ - -static bfd_boolean -xg_symbolic_immeds_fit (insn, pc_seg, pc_frag, pc_offset, stretch) - const TInsn *insn; - segT pc_seg; - fragS *pc_frag; - offsetT pc_offset; - long stretch; -{ - xtensa_isa isa = xtensa_default_isa; - symbolS *symbolP; - fragS *sym_frag; - offsetT target, pc; - uint32 new_offset; - int i; - int n = insn->ntok; - - assert (insn->insn_type == ITYPE_INSN); - - for (i = 0; i < n; ++i) - { - const expressionS *expr = &insn->tok[i]; - if (xtensa_operand_is_register (isa, insn->opcode, i) == 1) - continue; - - switch (expr->X_op) - { - case O_register: - case O_constant: - if (xg_check_operand (expr->X_add_number, insn->opcode, i)) - return FALSE; - break; - - case O_lo16: - case O_hi16: - /* Check for the worst case. */ - if (xg_check_operand (0xffff, insn->opcode, i)) - return FALSE; - break; - - case O_symbol: - /* We only allow symbols for pc-relative stuff. - If pc_frag == 0, then we don't have frag locations yet. */ - if (pc_frag == 0) - return FALSE; - - /* If it is PC-relative and the symbol is not in the same - segment as the PC.... */ - if (xtensa_operand_is_PCrelative (isa, insn->opcode, i) == 0 - || S_GET_SEGMENT (expr->X_add_symbol) != pc_seg) - return FALSE; - - /* If it is a weak symbol, then assume it won't reach. This will - only affect calls when longcalls are enabled, because if - longcalls are disabled, then the call is marked as a specific - opcode. */ - if (S_IS_WEAK (expr->X_add_symbol)) - return FALSE; - - symbolP = expr->X_add_symbol; - sym_frag = symbol_get_frag (symbolP); - target = S_GET_VALUE (symbolP) + expr->X_add_number; - pc = pc_frag->fr_address + pc_offset; - - /* If frag has yet to be reached on this pass, assume it - will move by STRETCH just as we did. If this is not so, - it will be because some frag between grows, and that will - force another pass. Beware zero-length frags. There - should be a faster way to do this. */ - - if (stretch != 0 - && sym_frag->relax_marker != pc_frag->relax_marker - && S_GET_SEGMENT (symbolP) == pc_seg) - { - target += stretch; - } - - new_offset = target; - xtensa_operand_do_reloc (isa, insn->opcode, i, &new_offset, pc); - if (xg_check_operand (new_offset, insn->opcode, i)) - return FALSE; - break; - - default: - /* The symbol should have a fixup associated with it. */ - return FALSE; - } - } - - return TRUE; -} - - -/* This will check to see if the value can be converted into the - operand type. It will return TRUE if it does not fit. */ - -static bfd_boolean -xg_check_operand (value, opcode, operand) - int32 value; - xtensa_opcode opcode; - int operand; -{ - uint32 valbuf = value; - if (xtensa_operand_encode (xtensa_default_isa, opcode, operand, &valbuf)) - return TRUE; - return FALSE; -} - - /* Relax the assembly instruction at least "min_steps". Return the number of steps taken. */ -int -xg_assembly_relax (istack, insn, pc_seg, pc_frag, pc_offset, min_steps, - stretch) - IStack *istack; - TInsn *insn; - segT pc_seg; - fragS *pc_frag; /* if pc_frag == 0, then no pc-relative */ - offsetT pc_offset; /* offset in fragment */ - int min_steps; /* minimum number of conversion steps */ - long stretch; /* number of bytes stretched so far */ +static int +xg_assembly_relax (IStack *istack, + TInsn *insn, + segT pc_seg, + fragS *pc_frag, /* if pc_frag == 0, not pc-relative */ + offsetT pc_offset, /* offset in fragment */ + int min_steps, /* minimum conversion steps */ + long stretch) /* number of bytes stretched so far */ { int steps_taken = 0; @@ -3990,8 +3797,7 @@ xg_assembly_relax (istack, insn, pc_seg, pc_frag, pc_offset, min_steps, static void -xg_force_frag_space (size) - int size; +xg_force_frag_space (int size) { /* This may have the side effect of creating a new fragment for the space to go into. I just do not like the name of the "frag" @@ -4000,13 +3806,12 @@ xg_force_frag_space (size) } -void -xg_finish_frag (last_insn, frag_state, slot0_state, max_growth, is_insn) - char *last_insn; - enum xtensa_relax_statesE frag_state; - enum xtensa_relax_statesE slot0_state; - int max_growth; - bfd_boolean is_insn; +static void +xg_finish_frag (char *last_insn, + enum xtensa_relax_statesE frag_state, + enum xtensa_relax_statesE slot0_state, + int max_growth, + bfd_boolean is_insn) { /* Finish off this fragment so that it has at LEAST the desired max_growth. If it doesn't fit in this fragment, close this one @@ -4034,10 +3839,34 @@ xg_finish_frag (last_insn, frag_state, slot0_state, max_growth, is_insn) } +/* Return TRUE if the target frag is one of the next non-empty frags. */ + +static bfd_boolean +is_next_frag_target (const fragS *fragP, const fragS *target) +{ + if (fragP == NULL) + return FALSE; + + for (; fragP; fragP = fragP->fr_next) + { + if (fragP == target) + return TRUE; + if (fragP->fr_fix != 0) + return FALSE; + if (fragP->fr_type == rs_fill && fragP->fr_offset != 0) + return FALSE; + if ((fragP->fr_type == rs_align || fragP->fr_type == rs_align_code) + && ((fragP->fr_address % (1 << fragP->fr_offset)) != 0)) + return FALSE; + if (fragP->fr_type == rs_space) + return FALSE; + } + return FALSE; +} + + static bfd_boolean -is_branch_jmp_to_next (insn, fragP) - TInsn *insn; - fragS *fragP; +is_branch_jmp_to_next (TInsn *insn, fragS *fragP) { xtensa_isa isa = xtensa_default_isa; int i; @@ -4087,8 +3916,7 @@ is_branch_jmp_to_next (insn, fragP) static void -xg_add_branch_and_loop_targets (insn) - TInsn *insn; +xg_add_branch_and_loop_targets (TInsn *insn) { xtensa_isa isa = xtensa_default_isa; int num_ops = xtensa_opcode_num_operands (isa, insn->opcode); @@ -4122,257 +3950,10 @@ xg_add_branch_and_loop_targets (insn) } -/* The routine xg_instruction_matches_option_term must return TRUE - when a given option term is true. The meaning of all of the option - terms is given interpretation by this function. This is needed when - an option depends on the state of a directive, but there are no such - options in use right now. */ - -bfd_boolean -xg_instruction_matches_option_term (insn, option) - TInsn *insn ATTRIBUTE_UNUSED; - const ReqOrOption *option; -{ - if (strcmp (option->option_name, "realnop") == 0 - || strncmp (option->option_name, "IsaUse", 6) == 0) - { - /* These conditions were evaluated statically when building the - relaxation table. There's no need to reevaluate them now. */ - return TRUE; - } - else - { - as_fatal (_("internal error: unknown option name '%s'"), - option->option_name); - } -} - - -bfd_boolean -xg_instruction_matches_or_options (insn, or_option) - TInsn *insn; - const ReqOrOptionList *or_option; -{ - const ReqOrOption *option; - /* Must match each of the AND terms. */ - for (option = or_option; option != NULL; option = option->next) - { - if (xg_instruction_matches_option_term (insn, option)) - return TRUE; - } - return FALSE; -} - - -bfd_boolean -xg_instruction_matches_options (insn, options) - TInsn *insn; - const ReqOptionList *options; -{ - const ReqOption *req_options; - /* Must match each of the AND terms. */ - for (req_options = options; - req_options != NULL; - req_options = req_options->next) - { - /* Must match one of the OR clauses. */ - if (!xg_instruction_matches_or_options (insn, - req_options->or_option_terms)) - return FALSE; - } - return TRUE; -} - - -/* Return the transition rule that matches or NULL if none matches. */ - -bfd_boolean -xg_instruction_matches_rule (insn, rule) - TInsn *insn; - TransitionRule *rule; -{ - PreconditionList *condition_l; - - if (rule->opcode != insn->opcode) - return FALSE; - - for (condition_l = rule->conditions; - condition_l != NULL; - condition_l = condition_l->next) - { - expressionS *exp1; - expressionS *exp2; - Precondition *cond = condition_l->precond; - - switch (cond->typ) - { - case OP_CONSTANT: - /* The expression must be the constant. */ - assert (cond->op_num < insn->ntok); - exp1 = &insn->tok[cond->op_num]; - if (expr_is_const (exp1)) - { - switch (cond->cmp) - { - case OP_EQUAL: - if (get_expr_const (exp1) != cond->op_data) - return FALSE; - break; - case OP_NOTEQUAL: - if (get_expr_const (exp1) == cond->op_data) - return FALSE; - break; - default: - return FALSE; - } - } - else if (expr_is_register (exp1)) - { - switch (cond->cmp) - { - case OP_EQUAL: - if (get_expr_register (exp1) != cond->op_data) - return FALSE; - break; - case OP_NOTEQUAL: - if (get_expr_register (exp1) == cond->op_data) - return FALSE; - break; - default: - return FALSE; - } - } - else - return FALSE; - break; - - case OP_OPERAND: - assert (cond->op_num < insn->ntok); - assert (cond->op_data < insn->ntok); - exp1 = &insn->tok[cond->op_num]; - exp2 = &insn->tok[cond->op_data]; - - switch (cond->cmp) - { - case OP_EQUAL: - if (!expr_is_equal (exp1, exp2)) - return FALSE; - break; - case OP_NOTEQUAL: - if (expr_is_equal (exp1, exp2)) - return FALSE; - break; - } - break; - - case OP_LITERAL: - case OP_LABEL: - default: - return FALSE; - } - } - if (!xg_instruction_matches_options (insn, rule->options)) - return FALSE; - - return TRUE; -} - - -static int -transition_rule_cmp (a, b) - const TransitionRule *a; - const TransitionRule *b; -{ - bfd_boolean a_greater = FALSE; - bfd_boolean b_greater = FALSE; - - ReqOptionList *l_a = a->options; - ReqOptionList *l_b = b->options; - - /* We only care if they both are the same except for - a const16 vs. an l32r. */ - - while (l_a && l_b && ((l_a->next == NULL) == (l_b->next == NULL))) - { - ReqOrOptionList *l_or_a = l_a->or_option_terms; - ReqOrOptionList *l_or_b = l_b->or_option_terms; - while (l_or_a && l_or_b && ((l_a->next == NULL) == (l_b->next == NULL))) - { - if (l_or_a->is_true != l_or_b->is_true) - return 0; - if (strcmp (l_or_a->option_name, l_or_b->option_name) != 0) - { - /* This is the case we care about. */ - if (strcmp (l_or_a->option_name, "IsaUseConst16") == 0 - && strcmp (l_or_b->option_name, "IsaUseL32R") == 0) - { - if (prefer_const16) - a_greater = TRUE; - else - b_greater = TRUE; - } - else if (strcmp (l_or_a->option_name, "IsaUseL32R") == 0 - && strcmp (l_or_b->option_name, "IsaUseConst16") == 0) - { - if (prefer_const16) - b_greater = TRUE; - else - a_greater = TRUE; - } - else - return 0; - } - l_or_a = l_or_a->next; - l_or_b = l_or_b->next; - } - if (l_or_a || l_or_b) - return 0; - - l_a = l_a->next; - l_b = l_b->next; - } - if (l_a || l_b) - return 0; - - /* Incomparable if the substitution was used differently in two cases. */ - if (a_greater && b_greater) - return 0; - - if (b_greater) - return 1; - if (a_greater) - return -1; - - return 0; -} - - -TransitionRule * -xg_instruction_match (insn) - TInsn *insn; -{ - TransitionTable *table = xg_build_simplify_table (&transition_rule_cmp); - TransitionList *l; - assert (insn->opcode < table->num_opcodes); - - /* Walk through all of the possible transitions. */ - for (l = table->table[insn->opcode]; l != NULL; l = l->next) - { - TransitionRule *rule = l->rule; - if (xg_instruction_matches_rule (insn, rule)) - return rule; - } - return NULL; -} - - /* Return FALSE if no error. */ -bfd_boolean -xg_build_token_insn (instr_spec, old_insn, new_insn) - BuildInstr *instr_spec; - TInsn *old_insn; - TInsn *new_insn; +static bfd_boolean +xg_build_token_insn (BuildInstr *instr_spec, TInsn *old_insn, TInsn *new_insn) { int num_ops = 0; BuildOp *b_op; @@ -4437,10 +4018,8 @@ xg_build_token_insn (instr_spec, old_insn, new_insn) /* Return TRUE if it was simplified. */ -bfd_boolean -xg_simplify_insn (old_insn, new_insn) - TInsn *old_insn; - TInsn *new_insn; +static bfd_boolean +xg_simplify_insn (TInsn *old_insn, TInsn *new_insn) { TransitionRule *rule; BuildInstr *insn_spec; @@ -4472,9 +4051,7 @@ xg_simplify_insn (old_insn, new_insn) error. */ static bfd_boolean -xg_expand_assembly_insn (istack, orig_insn) - IStack *istack; - TInsn *orig_insn; +xg_expand_assembly_insn (IStack *istack, TInsn *orig_insn) { int noperands; TInsn new_insn; @@ -4552,11 +4129,74 @@ xg_expand_assembly_insn (istack, orig_insn) } +/* Return TRUE if the section flags are marked linkonce + or the name is .gnu.linkonce*. */ + +static bfd_boolean +get_is_linkonce_section (bfd *abfd ATTRIBUTE_UNUSED, segT sec) +{ + flagword flags, link_once_flags; + + flags = bfd_get_section_flags (abfd, sec); + link_once_flags = (flags & SEC_LINK_ONCE); + + /* Flags might not be set yet. */ + if (!link_once_flags) + { + static size_t len = sizeof ".gnu.linkonce.t."; + + if (strncmp (segment_name (sec), ".gnu.linkonce.t.", len - 1) == 0) + link_once_flags = SEC_LINK_ONCE; + } + return (link_once_flags != 0); +} + + +static void +xtensa_add_literal_sym (symbolS *sym) +{ + sym_list *l; + + l = (sym_list *) xmalloc (sizeof (sym_list)); + l->sym = sym; + l->next = literal_syms; + literal_syms = l; +} + + +static symbolS * +xtensa_create_literal_symbol (segT sec, fragS *frag) +{ + static int lit_num = 0; + static char name[256]; + symbolS *symbolP; + + sprintf (name, ".L_lit_sym%d", lit_num); + + /* Create a local symbol. If it is in a linkonce section, we have to + be careful to make sure that if it is used in a relocation that the + symbol will be in the output file. */ + if (get_is_linkonce_section (stdoutput, sec)) + { + symbolP = symbol_new (name, sec, 0, frag); + S_CLEAR_EXTERNAL (symbolP); + /* symbolP->local = 1; */ + } + else + symbolP = symbol_new (name, sec, 0, frag); + + xtensa_add_literal_sym (symbolP); + + frag->tc_frag_data.is_literal = TRUE; + lit_num++; + return symbolP; +} + + /* Currently all literals that are generated here are 32-bit L32R targets. */ -symbolS * -xg_assemble_literal (insn) - /* const */ TInsn *insn; +static symbolS * +xg_assemble_literal (/* const */ TInsn *insn) { emit_state state; symbolS *lit_sym = NULL; @@ -4621,29 +4261,8 @@ xg_assemble_literal (insn) } -bfd_boolean -xg_valid_literal_expression (exp) - const expressionS *exp; -{ - switch (exp->X_op) - { - case O_constant: - case O_symbol: - case O_big: - case O_uminus: - case O_subtract: - case O_pltrel: - return TRUE; - default: - return FALSE; - } -} - - static void -xg_assemble_literal_space (size, slot) - /* const */ int size; - int slot; +xg_assemble_literal_space (/* const */ int size, int slot) { emit_state state; /* We might have to do something about this alignment. It only @@ -4673,150 +4292,17 @@ xg_assemble_literal_space (size, slot) } -symbolS * -xtensa_create_literal_symbol (sec, frag) - segT sec; - fragS *frag; -{ - static int lit_num = 0; - static char name[256]; - symbolS *symbolP; - - sprintf (name, ".L_lit_sym%d", lit_num); - - /* Create a local symbol. If it is in a linkonce section, we have to - be careful to make sure that if it is used in a relocation that the - symbol will be in the output file. */ - if (get_is_linkonce_section (stdoutput, sec)) - { - symbolP = symbol_new (name, sec, 0, frag); - S_CLEAR_EXTERNAL (symbolP); - /* symbolP->local = 1; */ - } - else - symbolP = symbol_new (name, sec, 0, frag); - - xtensa_add_literal_sym (symbolP); - - frag->tc_frag_data.is_literal = TRUE; - lit_num++; - return symbolP; -} - - -static void -xtensa_add_literal_sym (sym) - symbolS *sym; -{ - sym_list *l; - - l = (sym_list *) xmalloc (sizeof (sym_list)); - l->sym = sym; - l->next = literal_syms; - literal_syms = l; -} - - -static void -xtensa_add_insn_label (sym) - symbolS *sym; -{ - sym_list *l; - - if (!free_insn_labels) - l = (sym_list *) xmalloc (sizeof (sym_list)); - else - { - l = free_insn_labels; - free_insn_labels = l->next; - } - - l->sym = sym; - l->next = insn_labels; - insn_labels = l; -} - - -static void -xtensa_clear_insn_labels (void) -{ - sym_list **pl; - - for (pl = &free_insn_labels; *pl != NULL; pl = &(*pl)->next) - ; - *pl = insn_labels; - insn_labels = NULL; -} - - -/* Return TRUE if the section flags are marked linkonce - or the name is .gnu.linkonce*. */ - -bfd_boolean -get_is_linkonce_section (abfd, sec) - bfd *abfd ATTRIBUTE_UNUSED; - segT sec; -{ - flagword flags, link_once_flags; - - flags = bfd_get_section_flags (abfd, sec); - link_once_flags = (flags & SEC_LINK_ONCE); - - /* Flags might not be set yet. */ - if (!link_once_flags) - { - static size_t len = sizeof ".gnu.linkonce.t."; - - if (strncmp (segment_name (sec), ".gnu.linkonce.t.", len - 1) == 0) - link_once_flags = SEC_LINK_ONCE; - } - return (link_once_flags != 0); -} - - -static bfd_boolean -xg_emit_insn_to_buf (tinsn, fmt, buf, fragP, offset, build_fix) - TInsn *tinsn; - xtensa_format fmt; - char *buf; - fragS *fragP; - offsetT offset; - bfd_boolean build_fix; -{ - static xtensa_insnbuf insnbuf = NULL; - bfd_boolean has_symbolic_immed = FALSE; - bfd_boolean ok = TRUE; - if (!insnbuf) - insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa); - - has_symbolic_immed = tinsn_to_insnbuf (tinsn, insnbuf); - if (has_symbolic_immed && build_fix) - { - /* Add a fixup. */ - int opnum = get_relaxable_immed (tinsn->opcode); - expressionS *exp = &tinsn->tok[opnum]; - - if (!xg_add_opcode_fix (tinsn, opnum, fmt, 0, exp, fragP, offset)) - ok = FALSE; - } - fragP->tc_frag_data.is_insn = TRUE; - xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf, buf, 0); - return ok; -} - - /* Put in a fixup record based on the opcode. Return TRUE on success. */ -bfd_boolean -xg_add_opcode_fix (tinsn, opnum, fmt, slot, expr, fragP, offset) - TInsn *tinsn; - int opnum; - xtensa_format fmt; - int slot; - expressionS *expr; - fragS *fragP; - offsetT offset; +static bfd_boolean +xg_add_opcode_fix (TInsn *tinsn, + int opnum, + xtensa_format fmt, + int slot, + expressionS *expr, + fragS *fragP, + offsetT offset) { xtensa_opcode opcode = tinsn->opcode; bfd_reloc_code_real_type reloc; @@ -4897,10 +4383,38 @@ xg_add_opcode_fix (tinsn, opnum, fmt, slot, expr, fragP, offset) } -void -xg_resolve_literals (insn, lit_sym) - TInsn *insn; - symbolS *lit_sym; +static bfd_boolean +xg_emit_insn_to_buf (TInsn *tinsn, + xtensa_format fmt, + char *buf, + fragS *fragP, + offsetT offset, + bfd_boolean build_fix) +{ + static xtensa_insnbuf insnbuf = NULL; + bfd_boolean has_symbolic_immed = FALSE; + bfd_boolean ok = TRUE; + if (!insnbuf) + insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa); + + has_symbolic_immed = tinsn_to_insnbuf (tinsn, insnbuf); + if (has_symbolic_immed && build_fix) + { + /* Add a fixup. */ + int opnum = get_relaxable_immed (tinsn->opcode); + expressionS *exp = &tinsn->tok[opnum]; + + if (!xg_add_opcode_fix (tinsn, opnum, fmt, 0, exp, fragP, offset)) + ok = FALSE; + } + fragP->tc_frag_data.is_insn = TRUE; + xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf, buf, 0); + return ok; +} + + +static void +xg_resolve_literals (TInsn *insn, symbolS *lit_sym) { symbolS *sym = get_special_literal_symbol (); int i; @@ -4914,10 +4428,8 @@ xg_resolve_literals (insn, lit_sym) } -void -xg_resolve_labels (insn, label_sym) - TInsn *insn; - symbolS *label_sym; +static void +xg_resolve_labels (TInsn *insn, symbolS *label_sym) { symbolS *sym = get_special_label_symbol (); int i; @@ -4933,10 +4445,7 @@ xg_resolve_labels (insn, label_sym) integer register. */ static bfd_boolean -is_register_writer (insn, regset, regnum) - const TInsn *insn; - const char *regset; - int regnum; +is_register_writer (const TInsn *insn, const char *regset, int regnum) { int i; int num_ops; @@ -4966,8 +4475,7 @@ is_register_writer (insn, regset, regnum) static bfd_boolean -is_bad_loopend_opcode (tinsn) - const TInsn * tinsn; +is_bad_loopend_opcode (const TInsn *tinsn) { xtensa_opcode opcode = tinsn->opcode; @@ -5000,9 +4508,8 @@ is_bad_loopend_opcode (tinsn) Also, the assembler generates stabs labels that need not be aligned: FAKE_LABEL_NAME . {"F", "L", "endfunc"}. */ -bfd_boolean -is_unaligned_label (sym) - symbolS *sym; +static bfd_boolean +is_unaligned_label (symbolS *sym) { const char *name = S_GET_NAME (sym); static size_t fake_size = 0; @@ -5028,9 +4535,8 @@ is_unaligned_label (sym) } -fragS * -next_non_empty_frag (fragP) - const fragS *fragP; +static fragS * +next_non_empty_frag (const fragS *fragP) { fragS *next_fragP = fragP->fr_next; @@ -5047,9 +4553,7 @@ next_non_empty_frag (fragP) static bfd_boolean -next_frag_opcode_is_loop (fragP, opcode) - const fragS *fragP; - xtensa_opcode *opcode; +next_frag_opcode_is_loop (const fragS *fragP, xtensa_opcode *opcode) { xtensa_opcode out_opcode; const fragS *next_fragP = next_non_empty_frag (fragP); @@ -5068,17 +4572,7 @@ next_frag_opcode_is_loop (fragP, opcode) static int -next_frag_format_size (fragP) - const fragS *fragP; -{ - const fragS *next_fragP = next_non_empty_frag (fragP); - return frag_format_size (next_fragP); -} - - -static int -frag_format_size (fragP) - const fragS * fragP; +frag_format_size (const fragS *fragP) { static xtensa_insnbuf insnbuf = NULL; xtensa_isa isa = xtensa_default_isa; @@ -5132,31 +4626,11 @@ frag_format_size (fragP) } -/* Return TRUE if the target frag is one of the next non-empty frags. */ - -bfd_boolean -is_next_frag_target (fragP, target) - const fragS *fragP; - const fragS *target; +static int +next_frag_format_size (const fragS *fragP) { - if (fragP == NULL) - return FALSE; - - for (; fragP; fragP = fragP->fr_next) - { - if (fragP == target) - return TRUE; - if (fragP->fr_fix != 0) - return FALSE; - if (fragP->fr_type == rs_fill && fragP->fr_offset != 0) - return FALSE; - if ((fragP->fr_type == rs_align || fragP->fr_type == rs_align_code) - && ((fragP->fr_address % (1 << fragP->fr_offset)) != 0)) - return FALSE; - if (fragP->fr_type == rs_space) - return FALSE; - } - return FALSE; + const fragS *next_fragP = next_non_empty_frag (fragP); + return frag_format_size (next_fragP); } @@ -5164,9 +4638,7 @@ is_next_frag_target (fragP, target) switch its state so it will instantiate a NOP. */ static void -update_next_frag_state (fragP, unreachable) - fragS *fragP; - bfd_boolean unreachable; +update_next_frag_state (fragS *fragP, bfd_boolean unreachable) { fragS *next_fragP = fragP->fr_next; fragS *new_target = NULL; @@ -5229,8 +4701,7 @@ update_next_frag_state (fragP, unreachable) static bfd_boolean -next_frag_is_branch_target (fragP) - const fragS *fragP; +next_frag_is_branch_target (const fragS *fragP) { /* Sometimes an empty will end up here due to storage allocation issues, so we have to skip until we find something legit. */ @@ -5246,8 +4717,7 @@ next_frag_is_branch_target (fragP) static bfd_boolean -next_frag_is_loop_target (fragP) - const fragS *fragP; +next_frag_is_loop_target (const fragS *fragP) { /* Sometimes an empty will end up here due storage allocation issues. So we have to skip until we find something legit. */ @@ -5263,8 +4733,7 @@ next_frag_is_loop_target (fragP) static addressT -next_frag_pre_opcode_bytes (fragp) - const fragS *fragp; +next_frag_pre_opcode_bytes (const fragS *fragp) { const fragS *next_fragp = fragp->fr_next; xtensa_opcode next_opcode; @@ -5296,7 +4765,7 @@ next_frag_pre_opcode_bytes (fragp) placed nearest to their use. */ static void -xtensa_mark_literal_pool_location () +xtensa_mark_literal_pool_location (void) { /* Any labels pointing to the current location need to be adjusted to after the literal pool. */ @@ -5337,56 +4806,10 @@ xtensa_mark_literal_pool_location () } -/* The "loops_ok" argument is provided to allow ignoring labels that - define loop ends. This fixes a bug where the NOPs to align a - loop opcode were included in a previous zero-cost loop: - - loop a0, loopend - <loop1 body> - loopend: - - loop a2, loopend2 - <loop2 body> - - would become: - - loop a0, loopend - <loop1 body> - nop.n <===== bad! - loopend: - - loop a2, loopend2 - <loop2 body> - - This argument is used to prevent moving the NOP to before the - loop-end label, which is what you want in this special case. */ - -static void -xtensa_move_labels (new_frag, new_offset, loops_ok) - fragS *new_frag; - valueT new_offset; - bfd_boolean loops_ok; -{ - sym_list *lit; - - for (lit = insn_labels; lit; lit = lit->next) - { - symbolS *lit_sym = lit->sym; - if (loops_ok || ! symbol_get_tc (lit_sym)->is_loop_target) - { - S_SET_VALUE (lit_sym, new_offset); - symbol_set_frag (lit_sym, new_frag); - } - } -} - - /* Build a nop of the correct size into tinsn. */ static void -build_nop (tinsn, size) - TInsn *tinsn; - int size; +build_nop (TInsn *tinsn, int size) { tinsn_init (tinsn); switch (size) @@ -5418,10 +4841,8 @@ build_nop (tinsn, size) /* Assemble a NOP of the requested size in the buffer. User must have allocated "buf" with at least "size" bytes. */ -void -assemble_nop (size, buf) - size_t size; - char *buf; +static void +assemble_nop (size_t size, char *buf) { static xtensa_insnbuf insnbuf = NULL; TInsn tinsn; @@ -5444,8 +4865,7 @@ assemble_nop (size, buf) opcode. */ static addressT -get_expanded_loop_offset (opcode) - xtensa_opcode opcode; +get_expanded_loop_offset (xtensa_opcode opcode) { /* This is the OFFSET of the loop instruction in the expanded loop. This MUST correspond directly to the specification of the loop @@ -5462,18 +4882,15 @@ get_expanded_loop_offset (opcode) } -fragS * -get_literal_pool_location (seg) - segT seg; +static fragS * +get_literal_pool_location (segT seg) { return seg_info (seg)->tc_segment_info_data.literal_pool_loc; } static void -set_literal_pool_location (seg, literal_pool_loc) - segT seg; - fragS *literal_pool_loc; +set_literal_pool_location (segT seg, fragS *literal_pool_loc) { seg_info (seg)->tc_segment_info_data.literal_pool_loc = literal_pool_loc; } @@ -5482,9 +4899,8 @@ set_literal_pool_location (seg, literal_pool_loc) /* Set frag assembly state should be called when a new frag is opened and after a frag has been closed. */ -void -xtensa_set_frag_assembly_state (fragP) - fragS *fragP; +static void +xtensa_set_frag_assembly_state (fragS *fragP) { if (!density_supported) fragP->tc_frag_data.is_no_density = TRUE; @@ -5500,16 +4916,15 @@ xtensa_set_frag_assembly_state (fragP) } -bfd_boolean -relaxable_section (sec) - asection *sec; +static bfd_boolean +relaxable_section (asection *sec) { return (sec->flags & SEC_DEBUGGING) == 0; } static void -xtensa_find_unmarked_state_frags () +xtensa_find_unmarked_state_frags (void) { segT *seclist; @@ -5566,10 +4981,9 @@ xtensa_find_unmarked_state_frags () static void -xtensa_find_unaligned_branch_targets (abfd, sec, unused) - bfd *abfd ATTRIBUTE_UNUSED; - asection *sec; - PTR unused ATTRIBUTE_UNUSED; +xtensa_find_unaligned_branch_targets (bfd *abfd ATTRIBUTE_UNUSED, + asection *sec, + void *unused ATTRIBUTE_UNUSED) { flagword flags = bfd_get_section_flags (abfd, sec); segment_info_type *seginfo = seg_info (sec); @@ -5604,10 +5018,9 @@ xtensa_find_unaligned_branch_targets (abfd, sec, unused) static void -xtensa_find_unaligned_loops (abfd, sec, unused) - bfd *abfd ATTRIBUTE_UNUSED; - asection *sec; - PTR unused ATTRIBUTE_UNUSED; +xtensa_find_unaligned_loops (bfd *abfd ATTRIBUTE_UNUSED, + asection *sec, + void *unused ATTRIBUTE_UNUSED) { flagword flags = bfd_get_section_flags (abfd, sec); segment_info_type *seginfo = seg_info (sec); @@ -5642,10 +5055,8 @@ xtensa_find_unaligned_loops (abfd, sec, unused) } -void -xg_apply_tentative_value (fixP, val) - fixS *fixP; - valueT val; +static void +xg_apply_tentative_value (fixS *fixP, valueT val) { xtensa_isa isa = xtensa_default_isa; static xtensa_insnbuf insnbuf = NULL; @@ -5695,25 +5106,21 @@ xg_apply_tentative_value (fixP, val) /* External Functions and Other GAS Hooks. */ const char * -xtensa_target_format () +xtensa_target_format (void) { return (target_big_endian ? "elf32-xtensa-be" : "elf32-xtensa-le"); } void -xtensa_file_arch_init (abfd) - bfd *abfd; +xtensa_file_arch_init (bfd *abfd) { bfd_set_private_flags (abfd, 0x100 | 0x200); } void -md_number_to_chars (buf, val, n) - char *buf; - valueT val; - int n; +md_number_to_chars (char *buf, valueT val, int n) { if (target_big_endian) number_to_chars_bigendian (buf, val, n); @@ -5727,7 +5134,7 @@ md_number_to_chars (buf, val, n) need. */ void -md_begin () +md_begin (void) { segT current_section = now_seg; int current_subsec = now_subseg; @@ -5790,8 +5197,7 @@ md_begin () /* TC_INIT_FIX_DATA hook */ void -xtensa_init_fix_data (x) - fixS *x; +xtensa_init_fix_data (fixS *x) { x->tc_fix_data.slot = 0; x->tc_fix_data.X_add_symbol = NULL; @@ -5802,8 +5208,7 @@ xtensa_init_fix_data (x) /* tc_frob_label hook */ void -xtensa_frob_label (sym) - symbolS *sym; +xtensa_frob_label (symbolS *sym) { /* Since the label was already attached to a frag associated with the previous basic block, it now needs to be reset to the current frag. */ @@ -5869,8 +5274,7 @@ xtensa_frob_label (sym) /* tc_unrecognized_line hook */ int -xtensa_unrecognized_line (ch) - int ch; +xtensa_unrecognized_line (int ch) { switch (ch) { @@ -5915,7 +5319,7 @@ xtensa_unrecognized_line (ch) /* md_flush_pending_output hook */ void -xtensa_flush_pending_output () +xtensa_flush_pending_output (void) { if (cur_vinsn.inside_bundle) as_bad (_("missing closing brace")); @@ -5940,7 +5344,7 @@ xtensa_flush_pending_output () and bad things happen. */ static void -error_reset_cur_vinsn () +error_reset_cur_vinsn (void) { if (cur_vinsn.inside_bundle) { @@ -5953,8 +5357,7 @@ error_reset_cur_vinsn () void -md_assemble (str) - char *str; +md_assemble (char *str) { xtensa_isa isa = xtensa_default_isa; char *opname; @@ -6105,8 +5508,7 @@ md_assemble (str) property section corresponding to this section. */ void -xtensa_handle_align (fragP) - fragS *fragP; +xtensa_handle_align (fragS *fragP) { if (linkrelax && !get_frag_is_literal (fragP) @@ -6134,16 +5536,14 @@ xtensa_handle_align (fragP) /* TC_FRAG_INIT hook */ void -xtensa_frag_init (frag) - fragS *frag; +xtensa_frag_init (fragS *frag) { xtensa_set_frag_assembly_state (frag); } symbolS * -md_undefined_symbol (name) - char *name ATTRIBUTE_UNUSED; +md_undefined_symbol (char *name ATTRIBUTE_UNUSED) { return NULL; } @@ -6152,17 +5552,14 @@ md_undefined_symbol (name) /* Round up a section size to the appropriate boundary. */ valueT -md_section_align (segment, size) - segT segment ATTRIBUTE_UNUSED; - valueT size; +md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size) { return size; /* Byte alignment is fine. */ } long -md_pcrel_from (fixP) - fixS *fixP; +md_pcrel_from (fixS *fixP) { char *insn_p; static xtensa_insnbuf insnbuf = NULL; @@ -6229,8 +5626,7 @@ md_pcrel_from (fixP) /* TC_FORCE_RELOCATION hook */ int -xtensa_force_relocation (fix) - fixS *fix; +xtensa_force_relocation (fixS *fix) { switch (fix->fx_r_type) { @@ -6271,7 +5667,7 @@ xtensa_force_relocation (fix) seems wrong. */ bfd_boolean -xtensa_check_inside_bundle () +xtensa_check_inside_bundle (void) { if (cur_vinsn.inside_bundle && input_line_pointer[-1] == '.') as_bad (_("directives are not valid inside bundles")); @@ -6285,7 +5681,7 @@ xtensa_check_inside_bundle () /* md_elf_section_change_hook */ void -xtensa_elf_section_change_hook () +xtensa_elf_section_change_hook (void) { /* Set up the assembly state. */ if (!frag_now->tc_frag_data.is_assembly_state_set) @@ -6296,8 +5692,7 @@ xtensa_elf_section_change_hook () /* tc_fix_adjustable hook */ bfd_boolean -xtensa_fix_adjustable (fixP) - fixS *fixP; +xtensa_fix_adjustable (fixS *fixP) { /* An offset is not allowed in combination with the difference of two symbols, but that cannot be easily detected after a local symbol @@ -6331,10 +5726,7 @@ xtensa_fix_adjustable (fixP) void -md_apply_fix3 (fixP, valP, seg) - fixS *fixP; - valueT *valP; - segT seg ATTRIBUTE_UNUSED; +md_apply_fix3 (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED) { if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0) { @@ -6373,10 +5765,7 @@ md_apply_fix3 (fixP, valP, seg) char * -md_atof (type, litP, sizeP) - int type; - char *litP; - int *sizeP; +md_atof (int type, char *litP, int *sizeP) { int prec; LITTLENUM_TYPE words[4]; @@ -6419,9 +5808,7 @@ md_atof (type, litP, sizeP) int -md_estimate_size_before_relax (fragP, seg) - fragS *fragP; - segT seg ATTRIBUTE_UNUSED; +md_estimate_size_before_relax (fragS *fragP, segT seg ATTRIBUTE_UNUSED) { return fragP->tc_frag_data.text_expansion[0]; } @@ -6431,9 +5818,7 @@ md_estimate_size_before_relax (fragP, seg) format. */ arelent * -tc_gen_reloc (section, fixp) - asection *section; - fixS *fixp; +tc_gen_reloc (asection *section, fixS *fixp) { arelent *reloc; bfd_boolean apply_tentative_value = FALSE; @@ -6606,42 +5991,199 @@ tc_gen_reloc (section, fixp) return reloc; } + +/* Checks for resource conflicts between instructions. */ -/* md_post_relax_hook */ +/* The func unit stuff could be implemented as bit-vectors rather + than the iterative approach here. If it ends up being too + slow, we will switch it. */ -#define XTENSA_INSN_SEC_NAME ".xt.insn" -#define XTENSA_LIT_SEC_NAME ".xt.lit" -#define XTENSA_PROP_SEC_NAME ".xt.prop" +resource_table * +new_resource_table (void *data, + int cycles, + int nu, + unit_num_copies_func uncf, + opcode_num_units_func onuf, + opcode_funcUnit_use_unit_func ouuf, + opcode_funcUnit_use_stage_func ousf) +{ + int i; + resource_table *rt = (resource_table *) xmalloc (sizeof (resource_table)); + rt->data = data; + rt->cycles = cycles; + rt->allocated_cycles = cycles; + rt->num_units = nu; + rt->unit_num_copies = uncf; + rt->opcode_num_units = onuf; + rt->opcode_unit_use = ouuf; + rt->opcode_unit_stage = ousf; -void -xtensa_post_relax_hook () + rt->units = (char **) xcalloc (cycles, sizeof (char *)); + for (i = 0; i < cycles; i++) + rt->units[i] = (char *) xcalloc (nu, sizeof (char)); + + return rt; +} + + +void +clear_resource_table (resource_table *rt) { - xtensa_move_seg_list_to_beginning (literal_head); - xtensa_move_seg_list_to_beginning (init_literal_head); - xtensa_move_seg_list_to_beginning (fini_literal_head); + int i, j; + for (i = 0; i < rt->allocated_cycles; i++) + for (j = 0; j < rt->num_units; j++) + rt->units[i][j] = 0; +} - xtensa_find_unmarked_state_frags (); - if (use_literal_section) - xtensa_create_property_segments (get_frag_is_literal, - NULL, - XTENSA_LIT_SEC_NAME, - xt_literal_sec); - xtensa_create_xproperty_segments (get_frag_property_flags, - XTENSA_PROP_SEC_NAME, - xt_prop_sec); +/* We never shrink it, just fake it into thinking so. */ - if (warn_unaligned_branch_targets) - bfd_map_over_sections (stdoutput, xtensa_find_unaligned_branch_targets, 0); - bfd_map_over_sections (stdoutput, xtensa_find_unaligned_loops, 0); +void +resize_resource_table (resource_table *rt, int cycles) +{ + int i, old_cycles; + + rt->cycles = cycles; + if (cycles <= rt->allocated_cycles) + return; + + old_cycles = rt->allocated_cycles; + rt->allocated_cycles = cycles; + + rt->units = xrealloc (rt->units, sizeof (char *) * rt->allocated_cycles); + for (i = 0; i < old_cycles; i++) + rt->units[i] = xrealloc (rt->units[i], sizeof (char) * rt->num_units); + for (i = old_cycles; i < cycles; i++) + rt->units[i] = xcalloc (rt->num_units, sizeof (char)); +} + + +bfd_boolean +resources_available (resource_table *rt, xtensa_opcode opcode, int cycle) +{ + int i; + int uses = (rt->opcode_num_units) (rt->data, opcode); + + for (i = 0; i < uses; i++) + { + xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i); + int stage = (rt->opcode_unit_stage) (rt->data, opcode, i); + int copies_in_use = rt->units[stage + cycle][unit]; + int copies = (rt->unit_num_copies) (rt->data, unit); + if (copies_in_use >= copies) + return FALSE; + } + return TRUE; +} + + +void +reserve_resources (resource_table *rt, xtensa_opcode opcode, int cycle) +{ + int i; + int uses = (rt->opcode_num_units) (rt->data, opcode); + + for (i = 0; i < uses; i++) + { + xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i); + int stage = (rt->opcode_unit_stage) (rt->data, opcode, i); + /* Note that this allows resources to be oversubscribed. That's + essential to the way the optional scheduler works. + resources_available reports when a resource is over-subscribed, + so it's easy to tell. */ + rt->units[stage + cycle][unit]++; + } } +void +release_resources (resource_table *rt, xtensa_opcode opcode, int cycle) +{ + int i; + int uses = (rt->opcode_num_units) (rt->data, opcode); + + for (i = 0; i < uses; i++) + { + xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i); + int stage = (rt->opcode_unit_stage) (rt->data, opcode, i); + rt->units[stage + cycle][unit]--; + assert (rt->units[stage + cycle][unit] >= 0); + } +} + + +/* Wrapper functions make parameterized resource reservation + more convenient. */ + +int +opcode_funcUnit_use_unit (void *data, xtensa_opcode opcode, int idx) +{ + xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx); + return use->unit; +} + + +int +opcode_funcUnit_use_stage (void *data, xtensa_opcode opcode, int idx) +{ + xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx); + return use->stage; +} + + +/* Note that this function does not check issue constraints, but + solely whether the hardware is available to execute the given + instructions together. It also doesn't check if the tinsns + write the same state, or access the same tieports. That is + checked by check_t1_t2_read_write. */ + +static bfd_boolean +resources_conflict (vliw_insn *vinsn) +{ + int i; + static resource_table *rt = NULL; + + /* This is the most common case by far. Optimize it. */ + if (vinsn->num_slots == 1) + return FALSE; + + if (rt == NULL) + { + xtensa_isa isa = xtensa_default_isa; + rt = new_resource_table + (isa, xtensa_isa_num_pipe_stages (isa), + xtensa_isa_num_funcUnits (isa), + (unit_num_copies_func) xtensa_funcUnit_num_copies, + (opcode_num_units_func) xtensa_opcode_num_funcUnit_uses, + opcode_funcUnit_use_unit, + opcode_funcUnit_use_stage); + } + + clear_resource_table (rt); + + for (i = 0; i < vinsn->num_slots; i++) + { + if (!resources_available (rt, vinsn->slots[i].opcode, 0)) + return TRUE; + reserve_resources (rt, vinsn->slots[i].opcode, 0); + } + + return FALSE; +} + + +/* finish_vinsn, emit_single_op and helper functions. */ + +static bfd_boolean find_vinsn_conflicts (vliw_insn *); +static xtensa_format xg_find_narrowest_format (vliw_insn *); +static void bundle_single_op (TInsn *); +static void xg_assemble_vliw_tokens (vliw_insn *); + + /* We have reached the end of a bundle; emit into the frag. */ static void -finish_vinsn (vinsn) - vliw_insn *vinsn; +finish_vinsn (vliw_insn *vinsn) { IStack slotstack; int i; @@ -6831,9 +6373,10 @@ finish_vinsn (vinsn) because the value of a0 is trashed before the second add can read it. */ +static char check_t1_t2_reads_and_writes (TInsn *, TInsn *); + static bfd_boolean -find_vinsn_conflicts (vinsn) - vliw_insn *vinsn; +find_vinsn_conflicts (vliw_insn *vinsn) { int i, j; int branches = 0; @@ -6919,9 +6462,7 @@ find_vinsn_conflicts (vinsn) */ static char -check_t1_t2_reads_and_writes (t1, t2) - TInsn *t1; - TInsn *t2; +check_t1_t2_reads_and_writes (TInsn *t1, TInsn *t2) { xtensa_isa isa = xtensa_default_isa; xtensa_regfile t1_regfile, t2_regfile; @@ -7080,207 +6621,8 @@ check_t1_t2_reads_and_writes (t1, t2) } -/* The func unit stuff could be implemented as bit-vectors rather - than the iterative approach here. If it ends up being too - slow, we will switch it. */ - -resource_table * -new_resource_table (data, cycles, nu, uncf, onuf, ouuf, ousf) - void *data; - int cycles; - int nu; - unit_num_copies_func uncf; - opcode_num_units_func onuf; - opcode_funcUnit_use_unit_func ouuf; - opcode_funcUnit_use_stage_func ousf; -{ - int i; - resource_table *rt = (resource_table *) xmalloc (sizeof (resource_table)); - rt->data = data; - rt->cycles = cycles; - rt->allocated_cycles = cycles; - rt->num_units = nu; - rt->unit_num_copies = uncf; - rt->opcode_num_units = onuf; - rt->opcode_unit_use = ouuf; - rt->opcode_unit_stage = ousf; - - rt->units = (char **) xcalloc (cycles, sizeof (char *)); - for (i = 0; i < cycles; i++) - rt->units[i] = (char *) xcalloc (nu, sizeof (char)); - - return rt; -} - - -void -clear_resource_table (rt) - resource_table *rt; -{ - int i, j; - for (i = 0; i < rt->allocated_cycles; i++) - for (j = 0; j < rt->num_units; j++) - rt->units[i][j] = 0; -} - - -/* We never shrink it, just fake it into thinking so. */ - -void -resize_resource_table (rt, cycles) - resource_table *rt; - int cycles; -{ - int i, old_cycles; - - rt->cycles = cycles; - if (cycles <= rt->allocated_cycles) - return; - - old_cycles = rt->allocated_cycles; - rt->allocated_cycles = cycles; - - rt->units = xrealloc (rt->units, sizeof (char *) * rt->allocated_cycles); - for (i = 0; i < old_cycles; i++) - rt->units[i] = xrealloc (rt->units[i], sizeof (char) * rt->num_units); - for (i = old_cycles; i < cycles; i++) - rt->units[i] = xcalloc (rt->num_units, sizeof (char)); -} - - -bfd_boolean -resources_available (rt, opcode, cycle) - resource_table *rt; - xtensa_opcode opcode; - int cycle; -{ - int i; - int uses = (rt->opcode_num_units) (rt->data, opcode); - - for (i = 0; i < uses; i++) - { - xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i); - int stage = (rt->opcode_unit_stage) (rt->data, opcode, i); - int copies_in_use = rt->units[stage + cycle][unit]; - int copies = (rt->unit_num_copies) (rt->data, unit); - if (copies_in_use >= copies) - return FALSE; - } - return TRUE; -} - - -void -reserve_resources (rt, opcode, cycle) - resource_table *rt; - xtensa_opcode opcode; - int cycle; -{ - int i; - int uses = (rt->opcode_num_units) (rt->data, opcode); - - for (i = 0; i < uses; i++) - { - xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i); - int stage = (rt->opcode_unit_stage) (rt->data, opcode, i); - /* Note that this allows resources to be oversubscribed. That's - essential to the way the optional scheduler works. - resources_available reports when a resource is over-subscribed, - so it's easy to tell. */ - rt->units[stage + cycle][unit]++; - } -} - - -void -release_resources (rt, opcode, cycle) - resource_table *rt; - xtensa_opcode opcode; - int cycle; -{ - int i; - int uses = (rt->opcode_num_units) (rt->data, opcode); - - for (i = 0; i < uses; i++) - { - xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i); - int stage = (rt->opcode_unit_stage) (rt->data, opcode, i); - rt->units[stage + cycle][unit]--; - assert (rt->units[stage + cycle][unit] >= 0); - } -} - - -/* Wrapper functions make parameterized resource reservation - more convenient. */ - -int -opcode_funcUnit_use_unit (data, opcode, idx) - void *data; - xtensa_opcode opcode; - int idx; -{ - xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx); - return use->unit; -} - - -int -opcode_funcUnit_use_stage (data, opcode, idx) - void *data; - xtensa_opcode opcode; - int idx; -{ - xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx); - return use->stage; -} - - -/* Note that this function does not check issue constraints, but - solely whether the hardware is available to execute the given - instructions together. It also doesn't check if the tinsns - write the same state, or access the same tieports. That is - checked by check_t1_t2_read_write. */ - -static bfd_boolean -resources_conflict (vinsn) - vliw_insn *vinsn; -{ - int i; - static resource_table *rt = NULL; - - /* This is the most common case by far. Optimize it. */ - if (vinsn->num_slots == 1) - return FALSE; - - if (rt == NULL) - { - xtensa_isa isa = xtensa_default_isa; - rt = new_resource_table - (isa, xtensa_isa_num_pipe_stages (isa), - xtensa_isa_num_funcUnits (isa), - (unit_num_copies_func) xtensa_funcUnit_num_copies, - (opcode_num_units_func) xtensa_opcode_num_funcUnit_uses, - opcode_funcUnit_use_unit, - opcode_funcUnit_use_stage); - } - - clear_resource_table (rt); - - for (i = 0; i < vinsn->num_slots; i++) - { - if (!resources_available (rt, vinsn->slots[i].opcode, 0)) - return TRUE; - reserve_resources (rt, vinsn->slots[i].opcode, 0); - } - - return FALSE; -} - - static xtensa_format -xg_find_narrowest_format (vinsn) - vliw_insn *vinsn; +xg_find_narrowest_format (vliw_insn *vinsn) { /* Right now we assume that the ops within the vinsn are properly ordered for the slots that the programmer wanted them in. In @@ -7311,33 +6653,30 @@ xg_find_narrowest_format (vinsn) if (opcode_fits_format_slot (v_copy.slots[slot].opcode, format, slot)) fit++; - else + else if (v_copy.num_slots > 1) { - if (v_copy.num_slots > 1) + TInsn widened; + /* Try the widened version. */ + if (!v_copy.slots[slot].keep_wide + && !v_copy.slots[slot].is_specific_opcode + && xg_is_narrow_insn (&v_copy.slots[slot]) + && !xg_expand_narrow (&widened, &v_copy.slots[slot]) + && opcode_fits_format_slot (widened.opcode, + format, slot)) { - TInsn widened; - /* Try the widened version. */ - if (!v_copy.slots[slot].keep_wide - && !v_copy.slots[slot].is_specific_opcode - && xg_is_narrow_insn (&v_copy.slots[slot]) - && !xg_expand_narrow (&widened, &v_copy.slots[slot]) - && opcode_fits_format_slot (widened.opcode, - format, slot)) - { - /* The xg_is_narrow clause requires some explanation: + /* The xg_is_narrow clause requires some explanation: - addi can be "widened" to an addmi, which is then - expanded to an addmi/addi pair if the immediate - requires it, but here we must have a single widen - only. + addi can be "widened" to an addmi, which is then + expanded to an addmi/addi pair if the immediate + requires it, but here we must have a single widen + only. - xg_is_narrow tells us that addi isn't really - narrow. The widen_spec_list says that there are - other cases. */ + xg_is_narrow tells us that addi isn't really + narrow. The widen_spec_list says that there are + other cases. */ - v_copy.slots[slot] = widened; - fit++; - } + v_copy.slots[slot] = widened; + fit++; } } } @@ -7364,8 +6703,7 @@ xg_find_narrowest_format (vinsn) each tinsn in the vinsn. */ static int -relaxation_requirements (vinsn) - vliw_insn *vinsn; +relaxation_requirements (vliw_insn *vinsn) { int extra_space = 0; int slot; @@ -7429,8 +6767,7 @@ relaxation_requirements (vinsn) static void -bundle_single_op (orig_insn) - TInsn *orig_insn; +bundle_single_op (TInsn *orig_insn) { xtensa_isa isa = xtensa_default_isa; vliw_insn v; @@ -7468,8 +6805,7 @@ bundle_single_op (orig_insn) static bfd_boolean -emit_single_op (orig_insn) - TInsn *orig_insn; +emit_single_op (TInsn *orig_insn) { int i; IStack istack; /* put instructions into here */ @@ -7529,9 +6865,8 @@ emit_single_op (orig_insn) /* Emit a vliw instruction to the current fragment. */ -void -xg_assemble_vliw_tokens (vinsn) - vliw_insn *vinsn; +static void +xg_assemble_vliw_tokens (vliw_insn *vinsn) { bfd_boolean finish_frag = FALSE; bfd_boolean is_jump = FALSE; @@ -7790,8 +7125,20 @@ xg_assemble_vliw_tokens (vinsn) } +/* xtensa_end and helper functions. */ + +static void xtensa_cleanup_align_frags (void); +static void xtensa_fix_target_frags (void); +static void xtensa_mark_narrow_branches (void); +static void xtensa_mark_zcl_first_insns (void); +static void xtensa_fix_a0_b_retw_frags (void); +static void xtensa_fix_b_j_loop_end_frags (void); +static void xtensa_fix_close_loop_end_frags (void); +static void xtensa_fix_short_loop_frags (void); +static void xtensa_sanity_check (void); + void -xtensa_end () +xtensa_end (void) { directive_balance (); xtensa_flush_pending_output (); @@ -7822,7 +7169,7 @@ xtensa_end () static void -xtensa_cleanup_align_frags () +xtensa_cleanup_align_frags (void) { frchainS *frchP; @@ -7873,8 +7220,10 @@ xtensa_cleanup_align_frags () fragment can be expanded to negate the branch, convert this to a RELAX_LOOP_END. Otherwise, convert to a .fill 0. */ +static bfd_boolean frag_can_negate_branch (fragS *); + static void -xtensa_fix_target_frags () +xtensa_fix_target_frags (void) { frchainS *frchP; @@ -7923,8 +7272,7 @@ xtensa_fix_target_frags () static bfd_boolean -frag_can_negate_branch (fragP) - fragS *fragP; +frag_can_negate_branch (fragS *fragP) { xtensa_isa isa = xtensa_default_isa; vliw_insn vinsn; @@ -7947,8 +7295,10 @@ frag_can_negate_branch (fragP) } +static bfd_boolean is_narrow_branch_guaranteed_in_range (fragS *, TInsn *); + static void -xtensa_mark_narrow_branches () +xtensa_mark_narrow_branches (void) { frchainS *frchP; @@ -8001,10 +7351,10 @@ xtensa_mark_narrow_branches () /* the range in bytes of a bnez.n and beqz.n */ #define MAX_IMMED6 68 +static size_t unrelaxed_frag_max_size (fragS *); + static bfd_boolean -is_narrow_branch_guaranteed_in_range (fragP, tinsn) - fragS *fragP; - TInsn *tinsn; +is_narrow_branch_guaranteed_in_range (fragS *fragP, TInsn *tinsn) { const expressionS *expr = &tinsn->tok[1]; symbolS *symbolP = expr->X_add_symbol; @@ -8029,7 +7379,7 @@ is_narrow_branch_guaranteed_in_range (fragP, tinsn) static void -xtensa_mark_zcl_first_insns () +xtensa_mark_zcl_first_insns (void) { frchainS *frchP; @@ -8067,8 +7417,10 @@ xtensa_mark_zcl_first_insns () conditional branch or a retw/retw.n, convert this frag to one that will generate a NOP. In any case close it off with a .fill 0. */ +static bfd_boolean next_instrs_are_b_retw (fragS *); + static void -xtensa_fix_a0_b_retw_frags () +xtensa_fix_a0_b_retw_frags (void) { frchainS *frchP; @@ -8098,9 +7450,8 @@ xtensa_fix_a0_b_retw_frags () } -bfd_boolean -next_instrs_are_b_retw (fragP) - fragS *fragP; +static bfd_boolean +next_instrs_are_b_retw (fragS *fragP) { xtensa_opcode opcode; xtensa_format fmt; @@ -8174,8 +7525,10 @@ next_instrs_are_b_retw (fragP) loop end label, convert this frag to one that will generate a NOP. In any case close it off with a .fill 0. */ +static bfd_boolean next_instr_is_loop_end (fragS *); + static void -xtensa_fix_b_j_loop_end_frags () +xtensa_fix_b_j_loop_end_frags (void) { frchainS *frchP; @@ -8205,9 +7558,8 @@ xtensa_fix_b_j_loop_end_frags () } -bfd_boolean -next_instr_is_loop_end (fragP) - fragS * fragP; +static bfd_boolean +next_instr_is_loop_end (fragS *fragP) { const fragS *next_fragP; @@ -8236,8 +7588,10 @@ next_instr_is_loop_end (fragP) make it at least 12 bytes away. In any case close it off with a .fill 0. */ +static size_t min_bytes_to_other_loop_end (fragS *, fragS *, offsetT, size_t); + static void -xtensa_fix_close_loop_end_frags () +xtensa_fix_close_loop_end_frags (void) { frchainS *frchP; @@ -8322,12 +7676,13 @@ xtensa_fix_close_loop_end_frags () } +static size_t unrelaxed_frag_min_size (fragS *); + static size_t -min_bytes_to_other_loop_end (fragP, current_target, current_offset, max_size) - fragS *fragP; - fragS *current_target; - offsetT current_offset; - size_t max_size; +min_bytes_to_other_loop_end (fragS *fragP, + fragS *current_target, + offsetT current_offset, + size_t max_size) { size_t offset = 0; fragS *current_fragP; @@ -8350,8 +7705,7 @@ min_bytes_to_other_loop_end (fragP, current_target, current_offset, max_size) static size_t -unrelaxed_frag_min_size (fragP) - fragS *fragP; +unrelaxed_frag_min_size (fragS *fragP) { size_t size = fragP->fr_fix; @@ -8364,8 +7718,7 @@ unrelaxed_frag_min_size (fragP) static size_t -unrelaxed_frag_max_size (fragP) - fragS *fragP; +unrelaxed_frag_max_size (fragS *fragP) { size_t size = fragP->fr_fix; switch (fragP->fr_type) @@ -8417,8 +7770,11 @@ unrelaxed_frag_max_size (fragP) then convert this frag (and maybe the next one) to generate a NOP. In any case close it off with a .fill 0. */ +static size_t count_insns_to_loop_end (fragS *, bfd_boolean, size_t); +static bfd_boolean branch_before_loop_end (fragS *); + static void -xtensa_fix_short_loop_frags () +xtensa_fix_short_loop_frags (void) { frchainS *frchP; @@ -8482,11 +7838,12 @@ xtensa_fix_short_loop_frags () } +static size_t unrelaxed_frag_min_insn_count (fragS *); + static size_t -count_insns_to_loop_end (base_fragP, count_relax_add, max_count) - fragS *base_fragP; - bfd_boolean count_relax_add; - size_t max_count; +count_insns_to_loop_end (fragS *base_fragP, + bfd_boolean count_relax_add, + size_t max_count) { fragS *fragP = NULL; size_t insn_count = 0; @@ -8518,8 +7875,7 @@ count_insns_to_loop_end (base_fragP, count_relax_add, max_count) static size_t -unrelaxed_frag_min_insn_count (fragP) - fragS *fragP; +unrelaxed_frag_min_insn_count (fragS *fragP) { xtensa_isa isa = xtensa_default_isa; static xtensa_insnbuf insnbuf = NULL; @@ -8553,9 +7909,10 @@ unrelaxed_frag_min_insn_count (fragP) } +static bfd_boolean unrelaxed_frag_has_b_j (fragS *); + static bfd_boolean -branch_before_loop_end (base_fragP) - fragS *base_fragP; +branch_before_loop_end (fragS *base_fragP) { fragS *fragP; @@ -8571,8 +7928,7 @@ branch_before_loop_end (base_fragP) static bfd_boolean -unrelaxed_frag_has_b_j (fragP) - fragS *fragP; +unrelaxed_frag_has_b_j (fragS *fragP) { static xtensa_insnbuf insnbuf = NULL; xtensa_isa isa = xtensa_default_isa; @@ -8611,8 +7967,11 @@ unrelaxed_frag_has_b_j (fragP) /* Checks to be made after initial assembly but before relaxation. */ +static bfd_boolean is_empty_loop (const TInsn *, fragS *); +static bfd_boolean is_local_forward_loop (const TInsn *, fragS *); + static void -xtensa_sanity_check () +xtensa_sanity_check (void) { char *file_name; int line; @@ -8668,10 +8027,8 @@ xtensa_sanity_check () /* Return TRUE if the loop target is the next non-zero fragment. */ -bfd_boolean -is_empty_loop (insn, fragP) - const TInsn *insn; - fragS *fragP; +static bfd_boolean +is_empty_loop (const TInsn *insn, fragS *fragP) { const expressionS *expr; symbolS *symbolP; @@ -8717,10 +8074,8 @@ is_empty_loop (insn, fragP) } -bfd_boolean -is_local_forward_loop (insn, fragP) - const TInsn *insn; - fragS *fragP; +static bfd_boolean +is_local_forward_loop (const TInsn *insn, fragS *fragP) { const expressionS *expr; symbolS *symbolP; @@ -8765,8 +8120,7 @@ is_local_forward_loop (insn, fragP) /* Alignment Functions. */ static size_t -get_text_align_power (target_size) - int target_size; +get_text_align_power (int target_size) { size_t i = 0; for (i = 0; i < sizeof (size_t); i++) @@ -8780,10 +8134,9 @@ get_text_align_power (target_size) static addressT -get_text_align_max_fill_size (align_pow, use_nops, use_no_density) - int align_pow; - bfd_boolean use_nops; - bfd_boolean use_no_density; +get_text_align_max_fill_size (int align_pow, + bfd_boolean use_nops, + bfd_boolean use_no_density) { if (!use_nops) return (1 << align_pow); @@ -8818,13 +8171,11 @@ get_text_align_max_fill_size (align_pow, use_nops, use_no_density) use_no_density = 0. */ static addressT -get_text_align_fill_size (address, align_pow, target_size, - use_nops, use_no_density) - addressT address; - int align_pow; - int target_size; - bfd_boolean use_nops; - bfd_boolean use_no_density; +get_text_align_fill_size (addressT address, + int align_pow, + int target_size, + bfd_boolean use_nops, + bfd_boolean use_no_density) { /* Input arguments: @@ -8904,10 +8255,8 @@ get_text_align_fill_size (address, align_pow, target_size, /* This will assert if it is not possible. */ -size_t -get_text_align_nop_count (fill_size, use_no_density) - size_t fill_size; - bfd_boolean use_no_density; +static size_t +get_text_align_nop_count (size_t fill_size, bfd_boolean use_no_density) { size_t count = 0; if (use_no_density) @@ -8931,11 +8280,10 @@ get_text_align_nop_count (fill_size, use_no_density) } -size_t -get_text_align_nth_nop_size (fill_size, n, use_no_density) - size_t fill_size; - size_t n; - bfd_boolean use_no_density; +static size_t +get_text_align_nth_nop_size (size_t fill_size, + size_t n, + bfd_boolean use_no_density) { size_t count = 0; @@ -8963,9 +8311,7 @@ get_text_align_nth_nop_size (fill_size, n, use_no_density) for it to begin at if we are using NOPs to align it. */ static addressT -get_noop_aligned_address (fragP, address) - fragS *fragP; - addressT address; +get_noop_aligned_address (fragS *fragP, addressT address) { /* The rule is: get next fragment's FIRST instruction. Find the smallest number of bytes that need to be added to @@ -9051,10 +8397,7 @@ get_noop_aligned_address (fragP, address) widening - widen previous instructions. */ static addressT -get_aligned_diff (fragP, address, max_diff) - fragS *fragP; - addressT address; - addressT *max_diff; +get_aligned_diff (fragS *fragP, addressT address, addressT *max_diff) { addressT target_address, loop_insn_offset; int target_size; @@ -9120,14 +8463,17 @@ get_aligned_diff (fragP, address, max_diff) /* md_relax_frag Hook and Helper Functions. */ +static long relax_frag_loop_align (fragS *, long); +static long relax_frag_for_align (fragS *, long); +static long relax_frag_immed + (segT, fragS *, long, int, xtensa_format, int, int *, bfd_boolean); + + /* Return the number of bytes added to this fragment, given that the input has been stretched already by "stretch". */ long -xtensa_relax_frag (fragP, stretch, stretched_p) - fragS *fragP; - long stretch; - int *stretched_p; +xtensa_relax_frag (fragS *fragP, long stretch, int *stretched_p) { xtensa_isa isa = xtensa_default_isa; int unreported = fragP->tc_frag_data.unreported_expansion; @@ -9244,9 +8590,7 @@ xtensa_relax_frag (fragP, stretch, stretched_p) static long -relax_frag_loop_align (fragP, stretch) - fragS *fragP; - long stretch; +relax_frag_loop_align (fragS *fragP, long stretch) { addressT old_address, old_next_address, old_size; addressT new_address, new_next_address, new_size; @@ -9279,8 +8623,7 @@ relax_frag_loop_align (fragP, stretch) /* Add a NOP instruction. */ static long -relax_frag_add_nop (fragP) - fragS *fragP; +relax_frag_add_nop (fragS *fragP) { char *nop_buf = fragP->fr_literal + fragP->fr_fix; int length = fragP->tc_frag_data.is_no_density ? 3 : 2; @@ -9299,10 +8642,10 @@ relax_frag_add_nop (fragP) } +static long future_alignment_required (fragS *, long); + static long -relax_frag_for_align (fragP, stretch) - fragS *fragP; - long stretch; +relax_frag_for_align (fragS *fragP, long stretch) { /* Overview of the relaxation procedure for alignment: We can widen with NOPs or by widening instructions or by filling @@ -9356,13 +8699,11 @@ relax_frag_for_align (fragP, stretch) aligned. */ static addressT -find_address_of_next_align_frag (fragPP, wide_nops, narrow_nops, - widens, paddable) - fragS **fragPP; - int *wide_nops; - int *narrow_nops; - int *widens; - bfd_boolean *paddable; +find_address_of_next_align_frag (fragS **fragPP, + int *wide_nops, + int *narrow_nops, + int *widens, + bfd_boolean *paddable) { fragS *fragP = *fragPP; addressT address = fragP->fr_address; @@ -9439,15 +8780,15 @@ find_address_of_next_align_frag (fragPP, wide_nops, narrow_nops, } +static long bytes_to_stretch (fragS *, int, int, int, int); + /* Undefine LOOKAHEAD_ALIGNER to get the older behavior. I'll leave this in until I am more confident this works. */ #define LOOKAHEAD_ALIGNER 1 static long -future_alignment_required (fragP, stretch) - fragS *fragP; - long stretch ATTRIBUTE_UNUSED; +future_alignment_required (fragS *fragP, long stretch ATTRIBUTE_UNUSED) { fragS *this_frag = fragP; long address; @@ -9462,9 +8803,8 @@ future_alignment_required (fragP, stretch) int local_stretch_amount; int global_stretch_amount; - address - = find_address_of_next_align_frag (&fragP, &wide_nops, &narrow_nops, - &num_widens, &paddable); + address = find_address_of_next_align_frag + (&fragP, &wide_nops, &narrow_nops, &num_widens, &paddable); if (address) { @@ -9487,9 +8827,8 @@ future_alignment_required (fragP, stretch) int dnn = 0; int dw = 0; bfd_boolean glob_pad = 0; - address = - find_address_of_next_align_frag (&fragP, &glob_widens, - &dnn, &dw, &glob_pad); + address = find_address_of_next_align_frag + (&fragP, &glob_widens, &dnn, &dw, &glob_pad); /* If there is a padable portion, then skip. */ if (glob_pad || (glob_widens >= xtensa_fetch_width)) break; @@ -9607,12 +8946,11 @@ future_alignment_required (fragP, stretch) */ static long -bytes_to_stretch (this_frag, wide_nops, narrow_nops, num_widens, desired_diff) - fragS *this_frag; - int wide_nops; - int narrow_nops; - int num_widens; - int desired_diff; +bytes_to_stretch (fragS *this_frag, + int wide_nops, + int narrow_nops, + int num_widens, + int desired_diff) { int bytes_short = desired_diff - num_widens; @@ -9742,16 +9080,14 @@ bytes_to_stretch (this_frag, wide_nops, narrow_nops, num_widens, desired_diff) static long -relax_frag_immed (segP, fragP, stretch, min_steps, fmt, slot, stretched_p, - estimate_only) - segT segP; - fragS *fragP; - long stretch; - int min_steps; - xtensa_format fmt; - int slot; - int *stretched_p; - bfd_boolean estimate_only; +relax_frag_immed (segT segP, + fragS *fragP, + long stretch, + int min_steps, + xtensa_format fmt, + int slot, + int *stretched_p, + bfd_boolean estimate_only) { TInsn tinsn; vliw_insn orig_vinsn; @@ -9881,11 +9217,13 @@ relax_frag_immed (segP, fragP, stretch, min_steps, fmt, slot, stretched_p, /* md_convert_frag Hook and Helper Functions. */ +static void convert_frag_align_next_opcode (fragS *); +static void convert_frag_narrow (segT, fragS *, xtensa_format, int); +static void convert_frag_fill_nop (fragS *); +static void convert_frag_immed (segT, fragS *, int, xtensa_format, int); + void -md_convert_frag (abfd, sec, fragp) - bfd *abfd ATTRIBUTE_UNUSED; - segT sec; - fragS *fragp; +md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec, fragS *fragp) { static xtensa_insnbuf vbuf = NULL; xtensa_isa isa = xtensa_default_isa; @@ -9998,9 +9336,8 @@ md_convert_frag (abfd, sec, fragp) } -void -convert_frag_align_next_opcode (fragp) - fragS *fragp; +static void +convert_frag_align_next_opcode (fragS *fragp) { char *nop_buf; /* Location for Writing. */ size_t i; @@ -10030,11 +9367,7 @@ convert_frag_align_next_opcode (fragp) static void -convert_frag_narrow (segP, fragP, fmt, slot) - segT segP; - fragS *fragP; - xtensa_format fmt; - int slot; +convert_frag_narrow (segT segP, fragS *fragP, xtensa_format fmt, int slot) { TInsn tinsn, single_target; xtensa_format single_fmt; @@ -10098,8 +9431,7 @@ convert_frag_narrow (segP, fragP, fmt, slot) static void -convert_frag_fill_nop (fragP) - fragS *fragP; +convert_frag_fill_nop (fragS *fragP) { char *loc = &fragP->fr_literal[fragP->fr_fix]; int size = fragP->tc_frag_data.text_expansion[0]; @@ -10119,13 +9451,17 @@ convert_frag_fill_nop (fragP) } +static fixS *fix_new_exp_in_seg + (segT, subsegT, fragS *, int, int, expressionS *, int, + bfd_reloc_code_real_type); +static void convert_frag_immed_finish_loop (segT, fragS *, TInsn *); + static void -convert_frag_immed (segP, fragP, min_steps, fmt, slot) - segT segP; - fragS *fragP; - int min_steps; - xtensa_format fmt; - int slot; +convert_frag_immed (segT segP, + fragS *fragP, + int min_steps, + xtensa_format fmt, + int slot) { char *immed_instr = fragP->fr_opcode; TInsn orig_tinsn; @@ -10421,16 +9757,14 @@ convert_frag_immed (segP, fragP, min_steps, fmt, slot) switch to that segment to do this. */ static fixS * -fix_new_exp_in_seg (new_seg, new_subseg, - frag, where, size, exp, pcrel, r_type) - segT new_seg; - subsegT new_subseg; - fragS *frag; - int where; - int size; - expressionS *exp; - int pcrel; - bfd_reloc_code_real_type r_type; +fix_new_exp_in_seg (segT new_seg, + subsegT new_subseg, + fragS *frag, + int where, + int size, + expressionS *exp, + int pcrel, + bfd_reloc_code_real_type r_type) { fixS *new_fix; segT seg = now_seg; @@ -10462,11 +9796,10 @@ fix_new_exp_in_seg (new_seg, new_subseg, label: */ +static offsetT get_expression_value (segT, expressionS *); + static void -convert_frag_immed_finish_loop (segP, fragP, tinsn) - segT segP; - fragS *fragP; - TInsn *tinsn; +convert_frag_immed_finish_loop (segT segP, fragS *fragP, TInsn *tinsn) { TInsn loop_insn; TInsn addi_insn; @@ -10555,9 +9888,7 @@ convert_frag_immed_finish_loop (segP, fragP, tinsn) static offsetT -get_expression_value (segP, exp) - segT segP; - expressionS *exp; +get_expression_value (segT segP, expressionS *exp) { if (exp->X_op == O_constant) return exp->X_add_number; @@ -10578,21 +9909,8 @@ get_expression_value (segP, exp) static subseg_map *sseg_map = NULL; - -static unsigned -get_last_insn_flags (seg, subseg) - segT seg; - subsegT subseg; -{ - subseg_map *subseg_e = get_subseg_info (seg, subseg); - return subseg_e->flags; -} - - static subseg_map * -get_subseg_info (seg, subseg) - segT seg; - subsegT subseg; +get_subseg_info (segT seg, subsegT subseg) { subseg_map *subseg_e; @@ -10616,12 +9934,20 @@ get_subseg_info (seg, subseg) return subseg_e; } + +static unsigned +get_last_insn_flags (segT seg, subsegT subseg) +{ + subseg_map *subseg_e = get_subseg_info (seg, subseg); + return subseg_e->flags; +} + + static void -set_last_insn_flags (seg, subseg, fl, val) - segT seg; - subsegT subseg; - unsigned fl; - bfd_boolean val; +set_last_insn_flags (segT seg, + subsegT subseg, + unsigned fl, + bfd_boolean val) { subseg_map *subseg_e = get_subseg_info (seg, subseg); if (val) @@ -10636,8 +9962,7 @@ set_last_insn_flags (seg, subseg, fl, val) /* Remove the segment from the global sections list. */ static void -xtensa_remove_section (sec) - segT sec; +xtensa_remove_section (segT sec) { /* Handle brain-dead bfd_section_list_remove macro, which expect the address of the prior section's "next" field, not @@ -10654,9 +9979,7 @@ xtensa_remove_section (sec) static void -xtensa_insert_section (after_sec, sec) - segT after_sec; - segT sec; +xtensa_insert_section (segT after_sec, segT sec) { segT *after_sec_next; if (after_sec == NULL) @@ -10669,8 +9992,7 @@ xtensa_insert_section (after_sec, sec) static void -xtensa_move_seg_list_to_beginning (head) - seg_list *head; +xtensa_move_seg_list_to_beginning (seg_list *head) { head = head->next; while (head) @@ -10687,8 +10009,10 @@ xtensa_move_seg_list_to_beginning (head) } -void -xtensa_move_literals () +static void mark_literal_frags (seg_list *); + +static void +xtensa_move_literals (void) { seg_list *segment; frchainS *frchain_from, *frchain_to; @@ -10813,8 +10137,7 @@ xtensa_move_literals () and frag_variant to get called in all situations. */ static void -mark_literal_frags (segment) - seg_list *segment; +mark_literal_frags (seg_list *segment) { frchainS *frchain_from; fragS *search_frag; @@ -10834,9 +10157,7 @@ mark_literal_frags (segment) static void -xtensa_reorder_seg_list (head, after) - seg_list *head; - segT after; +xtensa_reorder_seg_list (seg_list *head, segT after) { /* Move all of the sections in the section list to come after "after" in the gnu segment list. */ @@ -10861,8 +10182,10 @@ xtensa_reorder_seg_list (head, after) /* Push all the literal segments to the end of the gnu list. */ -void -xtensa_reorder_segments () +static segT get_last_sec (void); + +static void +xtensa_reorder_segments (void) { segT sec; segT last_sec; @@ -10886,8 +10209,8 @@ xtensa_reorder_segments () } -segT -get_last_sec () +static segT +get_last_sec (void) { segT last_sec = stdoutput->sections; while (last_sec->next != NULL) @@ -10901,9 +10224,8 @@ get_last_sec () correct location. Return a emit_state which can be passed to xtensa_restore_emit_state to return to current fragment. */ -void -xtensa_switch_to_literal_fragment (result) - emit_state *result; +static void +xtensa_switch_to_literal_fragment (emit_state *result) { if (directive_state[directive_absolute_literals]) { @@ -10921,9 +10243,8 @@ xtensa_switch_to_literal_fragment (result) } -void -xtensa_switch_to_non_abs_literal_fragment (result) - emit_state *result; +static void +xtensa_switch_to_non_abs_literal_fragment (emit_state *result) { /* When we mark a literal pool location, we want to put a frag in the literal pool that points to it. But to do that, we want to @@ -10997,11 +10318,10 @@ xtensa_switch_to_non_abs_literal_fragment (result) This is a helper function for xtensa_switch_to_literal_fragment. This is similar to a .section new_now_seg subseg. */ -void -xtensa_switch_section_emit_state (state, new_now_seg, new_now_subseg) - emit_state *state; - segT new_now_seg; - subsegT new_now_subseg; +static void +xtensa_switch_section_emit_state (emit_state *state, + segT new_now_seg, + subsegT new_now_subseg) { state->name = now_seg->name; state->now_seg = now_seg; @@ -11014,9 +10334,8 @@ xtensa_switch_section_emit_state (state, new_now_seg, new_now_subseg) /* Use to restore the emitting into the normal place. */ -void -xtensa_restore_emit_state (state) - emit_state *state; +static void +xtensa_restore_emit_state (emit_state *state) { generating_literals = state->generating_literals; subseg_new (state->name, state->now_subseg); @@ -11026,12 +10345,13 @@ xtensa_restore_emit_state (state) /* Get a segment of a given name. If the segment is already present, return it; otherwise, create a new one. */ +static segT retrieve_literal_seg (seg_list *, const char *, bfd_boolean); + static void -cache_literal_section (head, name, seg, is_code) - seg_list *head; - const char *name; - segT *seg; - bfd_boolean is_code; +cache_literal_section (seg_list *head, + const char *name, + segT *seg, + bfd_boolean is_code) { segT current_section = now_seg; int current_subsec = now_subseg; @@ -11046,11 +10366,11 @@ cache_literal_section (head, name, seg, is_code) /* Get a segment of a given name. If the segment is already present, return it; otherwise, create a new one. */ +static segT seg_present (const char *); +static void add_seg_list (seg_list *, segT); + static segT -retrieve_literal_seg (head, name, is_code) - seg_list *head; - const char *name; - bfd_boolean is_code; +retrieve_literal_seg (seg_list *head, const char *name, bfd_boolean is_code) { segT ret = 0; @@ -11073,8 +10393,7 @@ retrieve_literal_seg (head, name, is_code) /* Return a segment of a given name if it is present. */ static segT -seg_present (name) - const char *name; +seg_present (const char *name) { segT seg; seg = stdoutput->sections; @@ -11093,9 +10412,7 @@ seg_present (name) /* Add a segment to a segment list. */ static void -add_seg_list (head, seg) - seg_list *head; - segT seg; +add_seg_list (seg_list *head, segT seg) { seg_list *n; n = (seg_list *) xmalloc (sizeof (seg_list)); @@ -11109,11 +10426,60 @@ add_seg_list (head, seg) /* Property Tables Stuff. */ +#define XTENSA_INSN_SEC_NAME ".xt.insn" +#define XTENSA_LIT_SEC_NAME ".xt.lit" +#define XTENSA_PROP_SEC_NAME ".xt.prop" + +typedef bfd_boolean (*frag_predicate) (const fragS *); +typedef void (*frag_flags_fn) (const fragS *, frag_flags *); + +static void xtensa_create_property_segments + (frag_predicate, frag_predicate, const char *, xt_section_type); +static void xtensa_create_xproperty_segments + (frag_flags_fn, const char *, xt_section_type); +static segment_info_type *retrieve_segment_info (segT); +static segT retrieve_xtensa_section (char *); +static bfd_boolean section_has_property (segT, frag_predicate); +static bfd_boolean section_has_xproperty (segT, frag_flags_fn); +static void add_xt_block_frags + (segT, segT, xtensa_block_info **, frag_predicate, frag_predicate); +static bfd_boolean xtensa_frag_flags_is_empty (const frag_flags *); +static void xtensa_frag_flags_init (frag_flags *); +static void get_frag_property_flags (const fragS *, frag_flags *); +static bfd_vma frag_flags_to_number (const frag_flags *); +static void add_xt_prop_frags + (segT, segT, xtensa_block_info **, frag_flags_fn); + +/* Set up property tables after relaxation. */ + +void +xtensa_post_relax_hook (void) +{ + xtensa_move_seg_list_to_beginning (literal_head); + xtensa_move_seg_list_to_beginning (init_literal_head); + xtensa_move_seg_list_to_beginning (fini_literal_head); + + xtensa_find_unmarked_state_frags (); + + if (use_literal_section) + xtensa_create_property_segments (get_frag_is_literal, + NULL, + XTENSA_LIT_SEC_NAME, + xt_literal_sec); + xtensa_create_xproperty_segments (get_frag_property_flags, + XTENSA_PROP_SEC_NAME, + xt_prop_sec); + + if (warn_unaligned_branch_targets) + bfd_map_over_sections (stdoutput, xtensa_find_unaligned_branch_targets, 0); + bfd_map_over_sections (stdoutput, xtensa_find_unaligned_loops, 0); +} + + /* This function is only meaningful after xtensa_move_literals. */ static bfd_boolean -get_frag_is_literal (fragP) - const fragS *fragP; +get_frag_is_literal (const fragS *fragP) { assert (fragP != NULL); return fragP->tc_frag_data.is_literal; @@ -11121,47 +10487,39 @@ get_frag_is_literal (fragP) static bfd_boolean -get_frag_is_insn (fragP) - const fragS *fragP; +get_frag_is_insn (const fragS *fragP) { assert (fragP != NULL); return fragP->tc_frag_data.is_insn; } -bfd_boolean -get_frag_is_no_transform (fragP) - fragS *fragP; +static bfd_boolean +get_frag_is_no_transform (fragS *fragP) { return fragP->tc_frag_data.is_no_transform; } -void -set_frag_is_specific_opcode (fragP, is_specific_opcode) - fragS *fragP; - bfd_boolean is_specific_opcode; +static void +set_frag_is_specific_opcode (fragS *fragP, bfd_boolean is_specific_opcode) { fragP->tc_frag_data.is_specific_opcode = is_specific_opcode; } -void -set_frag_is_no_transform (fragP, is_no_transform) - fragS *fragP; - bfd_boolean is_no_transform; +static void +set_frag_is_no_transform (fragS *fragP, bfd_boolean is_no_transform) { fragP->tc_frag_data.is_no_transform = is_no_transform; } static void -xtensa_create_property_segments (property_function, end_property_function, - section_name_base, sec_type) - frag_predicate property_function; - frag_predicate end_property_function; - const char *section_name_base; - xt_section_type sec_type; +xtensa_create_property_segments (frag_predicate property_function, + frag_predicate end_property_function, + const char *section_name_base, + xt_section_type sec_type) { segT *seclist; @@ -11291,11 +10649,10 @@ xtensa_create_property_segments (property_function, end_property_function, } -void -xtensa_create_xproperty_segments (flag_fn, section_name_base, sec_type) - frag_flags_fn flag_fn; - const char *section_name_base; - xt_section_type sec_type; +static void +xtensa_create_xproperty_segments (frag_flags_fn flag_fn, + const char *section_name_base, + xt_section_type sec_type) { segT *seclist; @@ -11428,9 +10785,8 @@ xtensa_create_xproperty_segments (flag_fn, section_name_base, sec_type) } -segment_info_type * -retrieve_segment_info (seg) - segT seg; +static segment_info_type * +retrieve_segment_info (segT seg) { segment_info_type *seginfo; seginfo = (segment_info_type *) bfd_get_section_userdata (stdoutput, seg); @@ -11439,7 +10795,7 @@ retrieve_segment_info (seg) frchainS *frchainP; seginfo = (segment_info_type *) xmalloc (sizeof (*seginfo)); - memset ((PTR) seginfo, 0, sizeof (*seginfo)); + memset ((void *) seginfo, 0, sizeof (*seginfo)); seginfo->fix_root = NULL; seginfo->fix_tail = NULL; seginfo->bfd_section = seg; @@ -11452,7 +10808,7 @@ retrieve_segment_info (seg) und_seg_info = seginfo; else #endif - bfd_set_section_userdata (stdoutput, seg, (PTR) seginfo); + bfd_set_section_userdata (stdoutput, seg, (void *) seginfo); #if 0 seg_fix_rootP = &segment_info[seg].fix_root; seg_fix_tailP = &segment_info[seg].fix_tail; @@ -11478,9 +10834,8 @@ retrieve_segment_info (seg) } -segT -retrieve_xtensa_section (sec_name) - char *sec_name; +static segT +retrieve_xtensa_section (char *sec_name) { bfd *abfd = stdoutput; flagword flags, out_flags, link_once_flags; @@ -11502,10 +10857,8 @@ retrieve_xtensa_section (sec_name) } -bfd_boolean -section_has_property (sec, property_function) - segT sec; - frag_predicate property_function; +static bfd_boolean +section_has_property (segT sec, frag_predicate property_function) { segment_info_type *seginfo = seg_info (sec); fragS *fragP; @@ -11523,10 +10876,8 @@ section_has_property (sec, property_function) } -bfd_boolean -section_has_xproperty (sec, property_function) - segT sec; - frag_flags_fn property_function; +static bfd_boolean +section_has_xproperty (segT sec, frag_flags_fn property_function) { segment_info_type *seginfo = seg_info (sec); fragS *fragP; @@ -11547,14 +10898,12 @@ section_has_xproperty (sec, property_function) /* Two types of block sections exist right now: literal and insns. */ -void -add_xt_block_frags (sec, xt_block_sec, xt_block, property_function, - end_property_function) - segT sec; - segT xt_block_sec; - xtensa_block_info **xt_block; - frag_predicate property_function; - frag_predicate end_property_function; +static void +add_xt_block_frags (segT sec, + segT xt_block_sec, + xtensa_block_info **xt_block, + frag_predicate property_function, + frag_predicate end_property_function) { segment_info_type *seg_info; segment_info_type *xt_seg_info; @@ -11613,9 +10962,8 @@ add_xt_block_frags (sec, xt_block_sec, xt_block, property_function, /* Break the encapsulation of add_xt_prop_frags here. */ -bfd_boolean -xtensa_frag_flags_is_empty (prop_flags) - const frag_flags *prop_flags; +static bfd_boolean +xtensa_frag_flags_is_empty (const frag_flags *prop_flags) { if (prop_flags->is_literal || prop_flags->is_insn @@ -11626,26 +10974,21 @@ xtensa_frag_flags_is_empty (prop_flags) } -void -xtensa_frag_flags_init (prop_flags) - frag_flags *prop_flags; +static void +xtensa_frag_flags_init (frag_flags *prop_flags) { memset (prop_flags, 0, sizeof (frag_flags)); } -void -get_frag_property_flags (fragP, prop_flags) - const fragS *fragP; - frag_flags *prop_flags; +static void +get_frag_property_flags (const fragS *fragP, frag_flags *prop_flags) { xtensa_frag_flags_init (prop_flags); if (fragP->tc_frag_data.is_literal) prop_flags->is_literal = TRUE; if (fragP->tc_frag_data.is_unreachable) - { - prop_flags->is_unreachable = TRUE; - } + prop_flags->is_unreachable = TRUE; else if (fragP->tc_frag_data.is_insn) { prop_flags->is_insn = TRUE; @@ -11671,9 +11014,8 @@ get_frag_property_flags (fragP, prop_flags) } -bfd_vma -frag_flags_to_number (prop_flags) - const frag_flags *prop_flags; +static bfd_vma +frag_flags_to_number (const frag_flags *prop_flags) { bfd_vma num = 0; if (prop_flags->is_literal) @@ -11712,9 +11054,8 @@ frag_flags_to_number (prop_flags) static bfd_boolean -xtensa_frag_flags_combinable (prop_flags_1, prop_flags_2) - const frag_flags *prop_flags_1; - const frag_flags *prop_flags_2; +xtensa_frag_flags_combinable (const frag_flags *prop_flags_1, + const frag_flags *prop_flags_2) { /* Cannot combine with an end marker. */ @@ -11753,9 +11094,8 @@ xtensa_frag_flags_combinable (prop_flags_1, prop_flags_2) } -bfd_vma -xt_block_aligned_size (xt_block) - const xtensa_block_info *xt_block; +static bfd_vma +xt_block_aligned_size (const xtensa_block_info *xt_block) { bfd_vma end_addr; size_t align_bits; @@ -11771,9 +11111,8 @@ xt_block_aligned_size (xt_block) static bfd_boolean -xtensa_xt_block_combine (xt_block, xt_block_2) - xtensa_block_info *xt_block; - const xtensa_block_info *xt_block_2; +xtensa_xt_block_combine (xtensa_block_info *xt_block, + const xtensa_block_info *xt_block_2) { if (xt_block->sec != xt_block_2->sec) return FALSE; @@ -11819,12 +11158,11 @@ xtensa_xt_block_combine (xt_block, xt_block_2) } -void -add_xt_prop_frags (sec, xt_block_sec, xt_block, property_function) - segT sec; - segT xt_block_sec; - xtensa_block_info **xt_block; - frag_flags_fn property_function; +static void +add_xt_prop_frags (segT sec, + segT xt_block_sec, + xtensa_block_info **xt_block, + frag_flags_fn property_function) { segment_info_type *seg_info; segment_info_type *xt_seg_info; @@ -11881,7 +11219,7 @@ add_xt_prop_frags (sec, xt_block_sec, xt_block, property_function) ops can go in which slots. */ static void -init_op_placement_info_table () +init_op_placement_info_table (void) { xtensa_isa isa = xtensa_default_isa; xtensa_insnbuf ibuf = xtensa_insnbuf_alloc (isa); @@ -11951,10 +11289,7 @@ init_op_placement_info_table () bfd_boolean -opcode_fits_format_slot (opcode, fmt, slot) - xtensa_opcode opcode; - xtensa_format fmt; - int slot; +opcode_fits_format_slot (xtensa_opcode opcode, xtensa_format fmt, int slot) { return bit_is_set (slot, op_placement_table[opcode].slots[fmt]); } @@ -11962,18 +11297,16 @@ opcode_fits_format_slot (opcode, fmt, slot) /* If the opcode is available in a single slot format, return its size. */ -int -xg_get_single_size (opcode) - xtensa_opcode opcode; +static int +xg_get_single_size (xtensa_opcode opcode) { assert (op_placement_table[opcode].single != XTENSA_UNDEFINED); return op_placement_table[opcode].single_size; } -xtensa_format -xg_get_single_format (opcode) - xtensa_opcode opcode; +static xtensa_format +xg_get_single_format (xtensa_opcode opcode) { return op_placement_table[opcode].single; } @@ -11982,8 +11315,7 @@ xg_get_single_format (opcode) /* Instruction Stack Functions (from "xtensa-istack.h"). */ void -istack_init (stack) - IStack *stack; +istack_init (IStack *stack) { memset (stack, 0, sizeof (IStack)); stack->ninsn = 0; @@ -11991,16 +11323,14 @@ istack_init (stack) bfd_boolean -istack_empty (stack) - IStack *stack; +istack_empty (IStack *stack) { return (stack->ninsn == 0); } bfd_boolean -istack_full (stack) - IStack *stack; +istack_full (IStack *stack) { return (stack->ninsn == MAX_ISTACK); } @@ -12010,8 +11340,7 @@ istack_full (stack) It is an error to call this if istack_empty () is TRUE. */ TInsn * -istack_top (stack) - IStack *stack; +istack_top (IStack *stack) { int rec = stack->ninsn - 1; assert (!istack_empty (stack)); @@ -12023,9 +11352,7 @@ istack_top (stack) It is an error to call this if istack_full () is TRUE. */ void -istack_push (stack, insn) - IStack *stack; - TInsn *insn; +istack_push (IStack *stack, TInsn *insn) { int rec = stack->ninsn; assert (!istack_full (stack)); @@ -12038,8 +11365,7 @@ istack_push (stack, insn) to it. It is an error to call this if istack_full () is TRUE. */ TInsn * -istack_push_space (stack) - IStack *stack; +istack_push_space (IStack *stack) { int rec = stack->ninsn; TInsn *insn; @@ -12055,8 +11381,7 @@ istack_push_space (stack) istack_empty () returns TRUE. */ void -istack_pop (stack) - IStack *stack; +istack_pop (IStack *stack) { int rec = stack->ninsn - 1; assert (!istack_empty (stack)); @@ -12068,8 +11393,7 @@ istack_pop (stack) /* TInsn functions. */ void -tinsn_init (dst) - TInsn *dst; +tinsn_init (TInsn *dst) { memset (dst, 0, sizeof (TInsn)); } @@ -12079,9 +11403,7 @@ tinsn_init (dst) It is illegal to call this if num > insn->ntoks. */ expressionS * -tinsn_get_tok (insn, num) - TInsn *insn; - int num; +tinsn_get_tok (TInsn *insn, int num) { assert (num < insn->ntok); return &insn->tok[num]; @@ -12091,8 +11413,7 @@ tinsn_get_tok (insn, num) /* Return TRUE if ANY of the operands in the insn are symbolic. */ static bfd_boolean -tinsn_has_symbolic_operands (insn) - const TInsn *insn; +tinsn_has_symbolic_operands (const TInsn *insn) { int i; int n = insn->ntok; @@ -12115,8 +11436,7 @@ tinsn_has_symbolic_operands (insn) bfd_boolean -tinsn_has_invalid_symbolic_operands (insn) - const TInsn *insn; +tinsn_has_invalid_symbolic_operands (const TInsn *insn) { xtensa_isa isa = xtensa_default_isa; int i; @@ -12168,8 +11488,7 @@ tinsn_has_invalid_symbolic_operands (insn) boil down to SYMBOL + OFFSET. */ static bfd_boolean -tinsn_has_complex_operands (insn) - const TInsn *insn; +tinsn_has_complex_operands (const TInsn *insn) { int i; int n = insn->ntok; @@ -12203,9 +11522,7 @@ tinsn_has_complex_operands (insn) The return value tells whether there are any remaining O_symbols. */ static bfd_boolean -tinsn_to_insnbuf (tinsn, insnbuf) - TInsn *tinsn; - xtensa_insnbuf insnbuf; +tinsn_to_insnbuf (TInsn *tinsn, xtensa_insnbuf insnbuf) { static xtensa_insnbuf slotbuf = 0; xtensa_isa isa = xtensa_default_isa; @@ -12282,11 +11599,10 @@ tinsn_to_insnbuf (tinsn, insnbuf) The return value tells whether there are any remaining O_symbols. */ static bfd_boolean -tinsn_to_slotbuf (fmt, slot, tinsn, slotbuf) - xtensa_format fmt; - int slot; - TInsn *tinsn; - xtensa_insnbuf slotbuf; +tinsn_to_slotbuf (xtensa_format fmt, + int slot, + TInsn *tinsn, + xtensa_insnbuf slotbuf) { xtensa_isa isa = xtensa_default_isa; xtensa_opcode opcode = tinsn->opcode; @@ -12351,9 +11667,8 @@ tinsn_to_slotbuf (fmt, slot, tinsn, slotbuf) /* Check the instruction arguments. Return TRUE on failure. */ -bfd_boolean -tinsn_check_arguments (insn) - const TInsn *insn; +static bfd_boolean +tinsn_check_arguments (const TInsn *insn) { xtensa_isa isa = xtensa_default_isa; xtensa_opcode opcode = insn->opcode; @@ -12382,10 +11697,7 @@ tinsn_check_arguments (insn) /* Load an instruction from its encoded form. */ static void -tinsn_from_chars (tinsn, f, slot) - TInsn *tinsn; - char *f; - int slot; +tinsn_from_chars (TInsn *tinsn, char *f, int slot) { vliw_insn vinsn; @@ -12398,11 +11710,10 @@ tinsn_from_chars (tinsn, f, slot) static void -tinsn_from_insnbuf (tinsn, slotbuf, fmt, slot) - TInsn *tinsn; - xtensa_insnbuf slotbuf; - xtensa_format fmt; - int slot; +tinsn_from_insnbuf (TInsn *tinsn, + xtensa_insnbuf slotbuf, + xtensa_format fmt, + int slot) { int i; xtensa_isa isa = xtensa_default_isa; @@ -12425,10 +11736,7 @@ tinsn_from_insnbuf (tinsn, slotbuf, fmt, slot) /* Read the value of the relaxable immed from the fr_symbol and fr_offset. */ static void -tinsn_immed_from_frag (tinsn, fragP, slot) - TInsn *tinsn; - fragS *fragP; - int slot; +tinsn_immed_from_frag (TInsn *tinsn, fragS *fragP, int slot) { xtensa_opcode opcode = tinsn->opcode; int opnum; @@ -12457,8 +11765,7 @@ tinsn_immed_from_frag (tinsn, fragP, slot) static int -get_num_stack_text_bytes (istack) - IStack *istack; +get_num_stack_text_bytes (IStack *istack) { int i; int text_bytes = 0; @@ -12474,8 +11781,7 @@ get_num_stack_text_bytes (istack) static int -get_num_stack_literal_bytes (istack) - IStack *istack; +get_num_stack_literal_bytes (IStack *istack) { int i; int lit_bytes = 0; @@ -12492,9 +11798,8 @@ get_num_stack_literal_bytes (istack) /* vliw_insn functions. */ -void -xg_init_vinsn (v) - vliw_insn *v; +static void +xg_init_vinsn (vliw_insn *v) { int i; xtensa_isa isa = xtensa_default_isa; @@ -12516,9 +11821,8 @@ xg_init_vinsn (v) } -void -xg_clear_vinsn (v) - vliw_insn *v; +static void +xg_clear_vinsn (vliw_insn *v) { int i; v->format = XTENSA_UNDEFINED; @@ -12536,9 +11840,8 @@ xg_clear_vinsn (v) } -bfd_boolean -vinsn_has_specific_opcodes (v) - vliw_insn *v; +static bfd_boolean +vinsn_has_specific_opcodes (vliw_insn *v) { int i; @@ -12551,9 +11854,8 @@ vinsn_has_specific_opcodes (v) } -void -xg_free_vinsn (v) - vliw_insn *v; +static void +xg_free_vinsn (vliw_insn *v) { int i; xtensa_insnbuf_free (xtensa_default_isa, v->insnbuf); @@ -12575,11 +11877,10 @@ xg_free_vinsn (v) The return value tells whether there are any remaining O_symbols. */ static bfd_boolean -vinsn_to_insnbuf (vinsn, frag_offset, fragP, record_fixup) - vliw_insn *vinsn; - char *frag_offset; - fragS *fragP; - bfd_boolean record_fixup; +vinsn_to_insnbuf (vliw_insn *vinsn, + char *frag_offset, + fragS *fragP, + bfd_boolean record_fixup) { xtensa_isa isa = xtensa_default_isa; xtensa_format fmt = vinsn->format; @@ -12675,9 +11976,7 @@ vinsn_to_insnbuf (vinsn, frag_offset, fragP, record_fixup) static void -vinsn_from_chars (vinsn, f) - vliw_insn *vinsn; - char *f; +vinsn_from_chars (vliw_insn *vinsn, char *f) { static xtensa_insnbuf insnbuf = NULL; static xtensa_insnbuf slotbuf = NULL; @@ -12712,8 +12011,7 @@ vinsn_from_chars (vinsn, f) /* Return TRUE if the expression is an integer constant. */ bfd_boolean -expr_is_const (s) - const expressionS *s; +expr_is_const (const expressionS *s) { return (s->X_op == O_constant); } @@ -12723,8 +12021,7 @@ expr_is_const (s) Calling this is illegal if expr_is_const () returns TRUE. */ offsetT -get_expr_const (s) - const expressionS *s; +get_expr_const (const expressionS *s) { assert (expr_is_const (s)); return s->X_add_number; @@ -12734,9 +12031,7 @@ get_expr_const (s) /* Set the expression to a constant value. */ void -set_expr_const (s, val) - expressionS *s; - offsetT val; +set_expr_const (expressionS *s, offsetT val) { s->X_op = O_constant; s->X_add_number = val; @@ -12746,8 +12041,7 @@ set_expr_const (s, val) bfd_boolean -expr_is_register (s) - const expressionS *s; +expr_is_register (const expressionS *s) { return (s->X_op == O_register); } @@ -12757,8 +12051,7 @@ expr_is_register (s) Calling this is illegal if expr_is_const () returns TRUE. */ offsetT -get_expr_register (s) - const expressionS *s; +get_expr_register (const expressionS *s) { assert (expr_is_register (s)); return s->X_add_number; @@ -12768,10 +12061,7 @@ get_expr_register (s) /* Set the expression to a symbol + constant offset. */ void -set_expr_symbol_offset (s, sym, offset) - expressionS *s; - symbolS *sym; - offsetT offset; +set_expr_symbol_offset (expressionS *s, symbolS *sym, offsetT offset) { s->X_op = O_symbol; s->X_add_symbol = sym; @@ -12782,12 +12072,11 @@ set_expr_symbol_offset (s, sym, offset) /* Set the expression to symbol - minus_sym + offset. */ -void -set_expr_symbol_offset_diff (s, sym, minus_sym, offset) - expressionS *s; - symbolS *sym; - symbolS *minus_sym; - offsetT offset; +static void +set_expr_symbol_offset_diff (expressionS *s, + symbolS *sym, + symbolS *minus_sym, + offsetT offset) { s->X_op = O_subtract; s->X_add_symbol = sym; @@ -12799,9 +12088,7 @@ set_expr_symbol_offset_diff (s, sym, minus_sym, offset) /* Return TRUE if the two expressions are equal. */ bfd_boolean -expr_is_equal (s1, s2) - expressionS *s1; - expressionS *s2; +expr_is_equal (expressionS *s1, expressionS *s2) { if (s1->X_op != s2->X_op) return FALSE; @@ -12816,9 +12103,7 @@ expr_is_equal (s1, s2) static void -copy_expr (dst, src) - expressionS *dst; - const expressionS *src; +copy_expr (expressionS *dst, const expressionS *src) { memcpy (dst, src, sizeof (expressionS)); } @@ -12841,9 +12126,8 @@ static struct rename_section_struct *section_rename; /* Parse the string oldname=new_name:oldname2=new_name2 and call add_section_rename. */ -void -build_section_rename (arg) - const char *arg; +static void +build_section_rename (const char *arg) { char *this_arg = NULL; char *next_arg = NULL; @@ -12883,9 +12167,7 @@ build_section_rename (arg) static void -add_section_rename (old_name, new_name) - char *old_name; - char *new_name; +add_section_rename (char *old_name, char *new_name) { struct rename_section_struct *r = section_rename; @@ -12910,8 +12192,7 @@ add_section_rename (old_name, new_name) const char * -xtensa_section_rename (name) - const char *name; +xtensa_section_rename (const char *name) { struct rename_section_struct *r = section_rename; diff --git a/gas/config/tc-xtensa.h b/gas/config/tc-xtensa.h index 3be75c7..0bd19a3 100644 --- a/gas/config/tc-xtensa.h +++ b/gas/config/tc-xtensa.h @@ -289,46 +289,29 @@ typedef struct xtensa_segment_info_struct /* Section renaming is only supported in Tensilica's version of GAS. */ #ifdef XTENSA_SECTION_RENAME -extern const char *xtensa_section_rename - PARAMS ((const char *)); +extern const char *xtensa_section_rename (const char *); #else /* Tensilica's section renaming feature is not included here. */ #define xtensa_section_rename(name) (name) #endif /* XTENSA_SECTION_RENAME */ -extern const char *xtensa_target_format - PARAMS ((void)); -extern void xtensa_init_fix_data - PARAMS ((struct fix *)); -extern void xtensa_frag_init - PARAMS ((fragS *)); -extern int xtensa_force_relocation - PARAMS ((struct fix *)); -extern void xtensa_frob_label - PARAMS ((struct symbol *)); -extern void xtensa_end - PARAMS ((void)); -extern void xtensa_post_relax_hook - PARAMS ((void)); -extern void xtensa_file_arch_init - PARAMS ((bfd *)); -extern void xtensa_flush_pending_output - PARAMS ((void)); -extern bfd_boolean xtensa_fix_adjustable - PARAMS ((struct fix *)); -extern void xtensa_symbol_new_hook - PARAMS ((symbolS *)); -extern long xtensa_relax_frag - PARAMS ((fragS *, long, int *)); -extern void xtensa_elf_section_change_hook - PARAMS ((void)); -extern int xtensa_unrecognized_line - PARAMS ((int)); -extern bfd_boolean xtensa_check_inside_bundle - PARAMS ((void)); -extern void xtensa_handle_align - PARAMS ((fragS *)); +extern const char *xtensa_target_format (void); +extern void xtensa_init_fix_data (struct fix *); +extern void xtensa_frag_init (fragS *); +extern int xtensa_force_relocation (struct fix *); +extern void xtensa_frob_label (struct symbol *); +extern void xtensa_end (void); +extern void xtensa_post_relax_hook (void); +extern void xtensa_file_arch_init (bfd *); +extern void xtensa_flush_pending_output (void); +extern bfd_boolean xtensa_fix_adjustable (struct fix *); +extern void xtensa_symbol_new_hook (symbolS *); +extern long xtensa_relax_frag (fragS *, long, int *); +extern void xtensa_elf_section_change_hook (void); +extern int xtensa_unrecognized_line (int); +extern bfd_boolean xtensa_check_inside_bundle (void); +extern void xtensa_handle_align (fragS *); #define TARGET_FORMAT xtensa_target_format () #define TARGET_ARCH bfd_arch_xtensa @@ -421,8 +404,8 @@ typedef int (*opcode_funcUnit_use_stage_func) (void *, xtensa_opcode, int); Of course the optional scheduler has its own reservation table and functions. */ -int opcode_funcUnit_use_unit PARAMS ((void *, xtensa_opcode, int)); -int opcode_funcUnit_use_stage PARAMS ((void *, xtensa_opcode, int)); +int opcode_funcUnit_use_unit (void *, xtensa_opcode, int); +int opcode_funcUnit_use_stage (void *, xtensa_opcode, int); typedef struct { @@ -438,13 +421,12 @@ typedef struct } resource_table; resource_table *new_resource_table - PARAMS ((void *, int, int, unit_num_copies_func, opcode_num_units_func, - opcode_funcUnit_use_unit_func, opcode_funcUnit_use_stage_func)); -void resize_resource_table PARAMS ((resource_table *, int)); -void clear_resource_table PARAMS ((resource_table *)); -bfd_boolean resources_available - PARAMS ((resource_table *, xtensa_opcode, int)); -void reserve_resources PARAMS ((resource_table *, xtensa_opcode, int)); -void release_resources PARAMS ((resource_table *, xtensa_opcode, int)); + (void *, int, int, unit_num_copies_func, opcode_num_units_func, + opcode_funcUnit_use_unit_func, opcode_funcUnit_use_stage_func); +void resize_resource_table (resource_table *, int); +void clear_resource_table (resource_table *); +bfd_boolean resources_available (resource_table *, xtensa_opcode, int); +void reserve_resources (resource_table *, xtensa_opcode, int); +void release_resources (resource_table *, xtensa_opcode, int); #endif /* TC_XTENSA */ diff --git a/gas/config/xtensa-istack.h b/gas/config/xtensa-istack.h index bb9f989..47082a9 100644 --- a/gas/config/xtensa-istack.h +++ b/gas/config/xtensa-istack.h @@ -72,17 +72,17 @@ typedef struct tinsn_stack } IStack; -void istack_init PARAMS ((IStack *)); -bfd_boolean istack_empty PARAMS ((IStack *)); -bfd_boolean istack_full PARAMS ((IStack *)); -TInsn *istack_top PARAMS ((IStack *)); -void istack_push PARAMS ((IStack *, TInsn *)); -TInsn *istack_push_space PARAMS ((IStack *)); -void istack_pop PARAMS ((IStack *)); +void istack_init (IStack *); +bfd_boolean istack_empty (IStack *); +bfd_boolean istack_full (IStack *); +TInsn *istack_top (IStack *); +void istack_push (IStack *, TInsn *); +TInsn *istack_push_space (IStack *); +void istack_pop (IStack *); /* TInsn utilities. */ -void tinsn_init PARAMS ((TInsn *)); -expressionS *tinsn_get_tok PARAMS ((TInsn *, int)); +void tinsn_init (TInsn *); +expressionS *tinsn_get_tok (TInsn *, int); /* vliw_insn: bundles of TInsns. */ diff --git a/gas/config/xtensa-relax.c b/gas/config/xtensa-relax.c index 4d2d01a..d54a55c 100644 --- a/gas/config/xtensa-relax.c +++ b/gas/config/xtensa-relax.c @@ -442,148 +442,17 @@ string_pattern_pair simplify_spec_list[] = (sizeof (simplify_spec_list) / sizeof (string_pattern_pair)) -/* Transition generation helpers. */ - -static void append_transition - PARAMS ((TransitionTable *, xtensa_opcode, TransitionRule *, - transition_cmp_fn)); -static void append_condition - PARAMS ((TransitionRule *, Precondition *)); -static void append_value_condition - PARAMS ((TransitionRule *, CmpOp, unsigned, unsigned)); -static void append_constant_value_condition - PARAMS ((TransitionRule *, CmpOp, unsigned, unsigned)); -static void append_build_insn - PARAMS ((TransitionRule *, BuildInstr *)); -static void append_op - PARAMS ((BuildInstr *, BuildOp *)); -static void append_literal_op - PARAMS ((BuildInstr *, unsigned, unsigned)); -static void append_label_op - PARAMS ((BuildInstr *, unsigned, unsigned)); -static void append_constant_op - PARAMS ((BuildInstr *, unsigned, unsigned)); -static void append_field_op - PARAMS ((BuildInstr *, unsigned, unsigned)); -static void append_user_fn_field_op - PARAMS ((BuildInstr *, unsigned, OpType, unsigned)); -static long operand_function_HI24S - PARAMS ((long)); -static long operand_function_F32MINUS - PARAMS ((long)); -static long operand_function_LOW8 - PARAMS ((long)); -static long operand_function_LOW16U - PARAMS ((long)); -static long operand_function_HI16U - PARAMS ((long)); - /* Externally visible functions. */ -extern bfd_boolean xg_has_userdef_op_fn - PARAMS ((OpType)); -extern long xg_apply_userdef_op_fn - PARAMS ((OpType, long)); - -/* Parsing helpers. */ - -static const char *enter_opname_n - PARAMS ((const char *, int)); -static const char *enter_opname - PARAMS ((const char *)); - -/* Construction and destruction. */ - -static void init_opname_map - PARAMS ((opname_map *)); -static void clear_opname_map - PARAMS ((opname_map *)); -static void init_precond_list - PARAMS ((precond_list *)); -static void clear_precond_list - PARAMS ((precond_list *)); -static void init_insn_templ - PARAMS ((insn_templ *)); -static void clear_insn_templ - PARAMS ((insn_templ *)); -static void init_insn_pattern - PARAMS ((insn_pattern *)); -static void clear_insn_pattern - PARAMS ((insn_pattern *)); -static void init_insn_repl - PARAMS ((insn_repl *)); -static void clear_insn_repl - PARAMS ((insn_repl *)); -static void init_split_rec - PARAMS ((split_rec *)); -static void clear_split_rec - PARAMS ((split_rec *)); -static void clear_req_or_option_list - PARAMS ((ReqOrOption **)); -static void clear_req_option_list - PARAMS ((ReqOption **)); -static ReqOrOption *clone_req_or_option_list - PARAMS ((ReqOrOption *)); -static ReqOption *clone_req_option_list - PARAMS ((ReqOption *)); - -/* Operand and insn_templ helpers. */ - -static bfd_boolean same_operand_name - PARAMS ((const opname_map_e *, const opname_map_e *)); -static opname_map_e *get_opmatch - PARAMS ((opname_map *, const char *)); -static bfd_boolean op_is_constant - PARAMS ((const opname_map_e *)); -static unsigned op_get_constant - PARAMS ((const opname_map_e *)); -static int insn_templ_operand_count - PARAMS ((const insn_templ *)); - -/* Parsing helpers. */ - -static const char *skip_white - PARAMS ((const char *)); -static void trim_whitespace - PARAMS ((char *)); -static void split_string - PARAMS ((split_rec *, const char *, char, bfd_boolean)); - -/* Language parsing. */ - -static bfd_boolean parse_insn_pattern - PARAMS ((const char *, insn_pattern *)); -static bfd_boolean parse_insn_repl - PARAMS ((const char *, insn_repl *)); -static bfd_boolean parse_insn_templ - PARAMS ((const char *, insn_templ *)); -static bfd_boolean parse_special_fn - PARAMS ((const char *, const char **, const char **)); -static bfd_boolean parse_precond - PARAMS ((const char *, precond_e *)); -static bfd_boolean parse_constant - PARAMS ((const char *, unsigned *)); -static bfd_boolean parse_id_constant - PARAMS ((const char *, const char *, unsigned *)); -static bfd_boolean parse_option_cond - PARAMS ((const char *, ReqOption *)); - -/* Transition table building code. */ - -static bfd_boolean transition_applies - PARAMS ((insn_pattern *, const char *, const char *)); -static TransitionRule *build_transition - PARAMS ((insn_pattern *, insn_repl *, const char *, const char *)); -static TransitionTable *build_transition_table - PARAMS ((const string_pattern_pair *, int, transition_cmp_fn)); +extern bfd_boolean xg_has_userdef_op_fn (OpType); +extern long xg_apply_userdef_op_fn (OpType, long); - -void -append_transition (tt, opcode, t, cmp) - TransitionTable *tt; - xtensa_opcode opcode; - TransitionRule *t; - transition_cmp_fn cmp; + +static void +append_transition (TransitionTable *tt, + xtensa_opcode opcode, + TransitionRule *t, + transition_cmp_fn cmp) { TransitionList *tl = (TransitionList *) xmalloc (sizeof (TransitionList)); TransitionList *prev; @@ -614,10 +483,8 @@ append_transition (tt, opcode, t, cmp) } -void -append_condition (tr, cond) - TransitionRule *tr; - Precondition *cond; +static void +append_condition (TransitionRule *tr, Precondition *cond) { PreconditionList *pl = (PreconditionList *) xmalloc (sizeof (PreconditionList)); @@ -641,12 +508,11 @@ append_condition (tr, cond) } -void -append_value_condition (tr, cmp, op1, op2) - TransitionRule *tr; - CmpOp cmp; - unsigned op1; - unsigned op2; +static void +append_value_condition (TransitionRule *tr, + CmpOp cmp, + unsigned op1, + unsigned op2) { Precondition *cond = (Precondition *) xmalloc (sizeof (Precondition)); @@ -658,12 +524,11 @@ append_value_condition (tr, cmp, op1, op2) } -void -append_constant_value_condition (tr, cmp, op1, cnst) - TransitionRule *tr; - CmpOp cmp; - unsigned op1; - unsigned cnst; +static void +append_constant_value_condition (TransitionRule *tr, + CmpOp cmp, + unsigned op1, + unsigned cnst) { Precondition *cond = (Precondition *) xmalloc (sizeof (Precondition)); @@ -675,10 +540,8 @@ append_constant_value_condition (tr, cmp, op1, cnst) } -void -append_build_insn (tr, bi) - TransitionRule *tr; - BuildInstr *bi; +static void +append_build_insn (TransitionRule *tr, BuildInstr *bi) { BuildInstr *prev = tr->to_instr; BuildInstr *nxt; @@ -699,10 +562,8 @@ append_build_insn (tr, bi) } -void -append_op (bi, b_op) - BuildInstr *bi; - BuildOp *b_op; +static void +append_op (BuildInstr *bi, BuildOp *b_op) { BuildOp *prev = bi->ops; BuildOp *nxt; @@ -722,11 +583,8 @@ append_op (bi, b_op) } -void -append_literal_op (bi, op1, litnum) - BuildInstr *bi; - unsigned op1; - unsigned litnum; +static void +append_literal_op (BuildInstr *bi, unsigned op1, unsigned litnum) { BuildOp *b_op = (BuildOp *) xmalloc (sizeof (BuildOp)); @@ -738,11 +596,8 @@ append_literal_op (bi, op1, litnum) } -void -append_label_op (bi, op1, labnum) - BuildInstr *bi; - unsigned op1; - unsigned labnum; +static void +append_label_op (BuildInstr *bi, unsigned op1, unsigned labnum) { BuildOp *b_op = (BuildOp *) xmalloc (sizeof (BuildOp)); @@ -754,11 +609,8 @@ append_label_op (bi, op1, labnum) } -void -append_constant_op (bi, op1, cnst) - BuildInstr *bi; - unsigned op1; - unsigned cnst; +static void +append_constant_op (BuildInstr *bi, unsigned op1, unsigned cnst) { BuildOp *b_op = (BuildOp *) xmalloc (sizeof (BuildOp)); @@ -770,11 +622,8 @@ append_constant_op (bi, op1, cnst) } -void -append_field_op (bi, op1, src_op) - BuildInstr *bi; - unsigned op1; - unsigned src_op; +static void +append_field_op (BuildInstr *bi, unsigned op1, unsigned src_op) { BuildOp *b_op = (BuildOp *) xmalloc (sizeof (BuildOp)); @@ -788,12 +637,11 @@ append_field_op (bi, op1, src_op) /* These could be generated but are not currently. */ -void -append_user_fn_field_op (bi, op1, typ, src_op) - BuildInstr *bi; - unsigned op1; - OpType typ; - unsigned src_op; +static void +append_user_fn_field_op (BuildInstr *bi, + unsigned op1, + OpType typ, + unsigned src_op) { BuildOp *b_op = (BuildOp *) xmalloc (sizeof (BuildOp)); @@ -808,9 +656,8 @@ append_user_fn_field_op (bi, op1, typ, src_op) /* These operand functions are the semantics of user-defined operand functions. */ -long -operand_function_HI24S (a) - long a; +static long +operand_function_HI24S (long a) { if (a & 0x80) return (a & (~0xff)) + 0x100; @@ -819,17 +666,15 @@ operand_function_HI24S (a) } -long -operand_function_F32MINUS (a) - long a; +static long +operand_function_F32MINUS (long a) { return (32 - a); } -long -operand_function_LOW8 (a) - long a; +static long +operand_function_LOW8 (long a) { if (a & 0x80) return (a & 0xff) | ~0xff; @@ -838,17 +683,15 @@ operand_function_LOW8 (a) } -long -operand_function_LOW16U (a) - long a; +static long +operand_function_LOW16U (long a) { return (a & 0xffff); } -long -operand_function_HI16U (a) - long a; +static long +operand_function_HI16U (long a) { unsigned long b = a & 0xffff0000; return (long) (b >> 16); @@ -856,8 +699,7 @@ operand_function_HI16U (a) bfd_boolean -xg_has_userdef_op_fn (op) - OpType op; +xg_has_userdef_op_fn (OpType op) { switch (op) { @@ -875,9 +717,7 @@ xg_has_userdef_op_fn (op) long -xg_apply_userdef_op_fn (op, a) - OpType op; - long a; +xg_apply_userdef_op_fn (OpType op, long a) { switch (op) { @@ -900,10 +740,8 @@ xg_apply_userdef_op_fn (op, a) /* Generate a transition table. */ -const char * -enter_opname_n (name, len) - const char *name; - int len; +static const char * +enter_opname_n (const char *name, int len) { opname_e *op; @@ -922,8 +760,7 @@ enter_opname_n (name, len) static const char * -enter_opname (name) - const char *name; +enter_opname (const char *name) { opname_e *op; @@ -938,18 +775,16 @@ enter_opname (name) } -void -init_opname_map (m) - opname_map *m; +static void +init_opname_map (opname_map *m) { m->head = NULL; m->tail = &m->head; } -void -clear_opname_map (m) - opname_map *m; +static void +clear_opname_map (opname_map *m) { opname_map_e *e; @@ -964,9 +799,7 @@ clear_opname_map (m) static bfd_boolean -same_operand_name (m1, m2) - const opname_map_e *m1; - const opname_map_e *m2; +same_operand_name (const opname_map_e *m1, const opname_map_e *m2) { if (m1->operand_name == NULL || m1->operand_name == NULL) return FALSE; @@ -974,10 +807,8 @@ same_operand_name (m1, m2) } -opname_map_e * -get_opmatch (map, operand_name) - opname_map *map; - const char *operand_name; +static opname_map_e * +get_opmatch (opname_map *map, const char *operand_name) { opname_map_e *m; @@ -990,35 +821,31 @@ get_opmatch (map, operand_name) } -bfd_boolean -op_is_constant (m1) - const opname_map_e *m1; +static bfd_boolean +op_is_constant (const opname_map_e *m1) { return (m1->operand_name == NULL); } static unsigned -op_get_constant (m1) - const opname_map_e *m1; +op_get_constant (const opname_map_e *m1) { assert (m1->operand_name == NULL); return m1->constant_value; } -void -init_precond_list (l) - precond_list *l; +static void +init_precond_list (precond_list *l) { l->head = NULL; l->tail = &l->head; } -void -clear_precond_list (l) - precond_list *l; +static void +clear_precond_list (precond_list *l) { precond_e *e; @@ -1032,26 +859,23 @@ clear_precond_list (l) } -void -init_insn_templ (t) - insn_templ *t; +static void +init_insn_templ (insn_templ *t) { t->opcode_name = NULL; init_opname_map (&t->operand_map); } -void -clear_insn_templ (t) - insn_templ *t; +static void +clear_insn_templ (insn_templ *t) { clear_opname_map (&t->operand_map); } -void -init_insn_pattern (p) - insn_pattern *p; +static void +init_insn_pattern (insn_pattern *p) { init_insn_templ (&p->t); init_precond_list (&p->preconds); @@ -1059,27 +883,24 @@ init_insn_pattern (p) } -void -clear_insn_pattern (p) - insn_pattern *p; +static void +clear_insn_pattern (insn_pattern *p) { clear_insn_templ (&p->t); clear_precond_list (&p->preconds); } -void -init_insn_repl (r) - insn_repl *r; +static void +init_insn_repl (insn_repl *r) { r->head = NULL; r->tail = &r->head; } -void -clear_insn_repl (r) - insn_repl *r; +static void +clear_insn_repl (insn_repl *r) { insn_repl_e *e; @@ -1094,8 +915,7 @@ clear_insn_repl (r) static int -insn_templ_operand_count (t) - const insn_templ *t; +insn_templ_operand_count (const insn_templ *t) { int i = 0; const opname_map_e *op; @@ -1108,10 +928,8 @@ insn_templ_operand_count (t) /* Convert a string to a number. E.G.: parse_constant("10", &num) */ -bfd_boolean -parse_constant (in, val_p) - const char *in; - unsigned *val_p; +static bfd_boolean +parse_constant (const char *in, unsigned *val_p) { unsigned val = 0; const char *p; @@ -1137,11 +955,8 @@ parse_constant (in, val_p) parse_id_constant("foo1", "foo", &num). This may also be used to just match a number. */ -bfd_boolean -parse_id_constant (in, name, val_p) - const char *in; - const char *name; - unsigned *val_p; +static bfd_boolean +parse_id_constant (const char *in, const char *name, unsigned *val_p) { unsigned namelen = 0; const char *p; @@ -1161,10 +976,9 @@ parse_id_constant (in, name, val_p) static bfd_boolean -parse_special_fn (name, fn_name_p, arg_name_p) - const char *name; - const char **fn_name_p; - const char **arg_name_p; +parse_special_fn (const char *name, + const char **fn_name_p, + const char **arg_name_p) { char *p_start; const char *p_end; @@ -1187,9 +1001,8 @@ parse_special_fn (name, fn_name_p, arg_name_p) } -const char * -skip_white (p) - const char *p; +static const char * +skip_white (const char *p) { if (p == NULL) return p; @@ -1199,9 +1012,8 @@ skip_white (p) } -void -trim_whitespace (in) - char *in; +static void +trim_whitespace (char *in) { char *last_white = NULL; char *p = in; @@ -1228,12 +1040,11 @@ trim_whitespace (in) /* Split a string into component strings where "c" is the delimiter. Place the result in the split_rec. */ -void -split_string (rec, in, c, elide_whitespace) - split_rec *rec; - const char *in; - char c; - bfd_boolean elide_whitespace; +static void +split_string (split_rec *rec, + const char *in, + char c, + bfd_boolean elide_whitespace) { int cnt = 0; int i; @@ -1284,9 +1095,8 @@ split_string (rec, in, c, elide_whitespace) } -void -clear_split_rec (rec) - split_rec *rec; +static void +clear_split_rec (split_rec *rec) { int i; @@ -1301,9 +1111,8 @@ clear_split_rec (rec) /* Initialize a split record. The split record must be initialized before split_string is called. */ -void -init_split_rec (rec) - split_rec *rec; +static void +init_split_rec (split_rec *rec) { rec->vec = NULL; rec->count = 0; @@ -1312,10 +1121,8 @@ init_split_rec (rec) /* Parse an instruction template like "insn op1, op2, op3". */ -bfd_boolean -parse_insn_templ (s, t) - const char *s; - insn_templ *t; +static bfd_boolean +parse_insn_templ (const char *s, insn_templ *t) { const char *p = s; int insn_name_len; @@ -1374,10 +1181,8 @@ parse_insn_templ (s, t) } -bfd_boolean -parse_precond (s, precond) - const char *s; - precond_e *precond; +static bfd_boolean +parse_precond (const char *s, precond_e *precond) { /* All preconditions are currently of the form: a == b or a != b or a == k (where k is a constant). @@ -1430,9 +1235,8 @@ parse_precond (s, precond) } -void -clear_req_or_option_list (r_p) - ReqOrOption **r_p; +static void +clear_req_or_option_list (ReqOrOption **r_p) { if (*r_p == NULL) return; @@ -1443,9 +1247,8 @@ clear_req_or_option_list (r_p) } -void -clear_req_option_list (r_p) - ReqOption **r_p; +static void +clear_req_option_list (ReqOption **r_p) { if (*r_p == NULL) return; @@ -1456,9 +1259,8 @@ clear_req_option_list (r_p) } -ReqOrOption * -clone_req_or_option_list (req_or_option) - ReqOrOption *req_or_option; +static ReqOrOption * +clone_req_or_option_list (ReqOrOption *req_or_option) { ReqOrOption *new_req_or_option; @@ -1474,9 +1276,8 @@ clone_req_or_option_list (req_or_option) } -ReqOption * -clone_req_option_list (req_option) - ReqOption *req_option; +static ReqOption * +clone_req_option_list (ReqOption *req_option) { ReqOption *new_req_option; @@ -1493,10 +1294,8 @@ clone_req_option_list (req_option) } -bfd_boolean -parse_option_cond (s, option) - const char *s; - ReqOption *option; +static bfd_boolean +parse_option_cond (const char *s, ReqOption *option) { int i; split_rec option_term_rec; @@ -1560,10 +1359,8 @@ parse_option_cond (s, option) split_string, it requires that '|' and '?' are only used as delimiters for predicates and required options. */ -bfd_boolean -parse_insn_pattern (in, insn) - const char *in; - insn_pattern *insn; +static bfd_boolean +parse_insn_pattern (const char *in, insn_pattern *insn) { split_rec rec; split_rec optionrec; @@ -1644,10 +1441,8 @@ parse_insn_pattern (in, insn) } -bfd_boolean -parse_insn_repl (in, r_p) - const char *in; - insn_repl *r_p; +static bfd_boolean +parse_insn_repl (const char *in, insn_repl *r_p) { /* This is a list of instruction templates separated by ';'. */ split_rec rec; @@ -1674,11 +1469,10 @@ parse_insn_repl (in, r_p) } -bfd_boolean -transition_applies (initial_insn, from_string, to_string) - insn_pattern *initial_insn; - const char *from_string ATTRIBUTE_UNUSED; - const char *to_string ATTRIBUTE_UNUSED; +static bfd_boolean +transition_applies (insn_pattern *initial_insn, + const char *from_string ATTRIBUTE_UNUSED, + const char *to_string ATTRIBUTE_UNUSED) { ReqOption *req_option; @@ -1727,12 +1521,11 @@ transition_applies (initial_insn, from_string, to_string) } -TransitionRule * -build_transition (initial_insn, replace_insns, from_string, to_string) - insn_pattern *initial_insn; - insn_repl *replace_insns; - const char *from_string; - const char *to_string; +static TransitionRule * +build_transition (insn_pattern *initial_insn, + insn_repl *replace_insns, + const char *from_string, + const char *to_string) { TransitionRule *tr = NULL; xtensa_opcode opcode; @@ -2019,11 +1812,10 @@ build_transition (initial_insn, replace_insns, from_string, to_string) } -TransitionTable * -build_transition_table (transitions, transition_count, cmp) - const string_pattern_pair *transitions; - int transition_count; - transition_cmp_fn cmp; +static TransitionTable * +build_transition_table (const string_pattern_pair *transitions, + int transition_count, + transition_cmp_fn cmp) { TransitionTable *table = NULL; int num_opcodes = xtensa_isa_num_opcodes (xtensa_default_isa); @@ -2090,8 +1882,7 @@ build_transition_table (transitions, transition_count, cmp) extern TransitionTable * -xg_build_widen_table (cmp) - transition_cmp_fn cmp; +xg_build_widen_table (transition_cmp_fn cmp) { static TransitionTable *table = NULL; if (table == NULL) @@ -2101,8 +1892,7 @@ xg_build_widen_table (cmp) extern TransitionTable * -xg_build_simplify_table (cmp) - transition_cmp_fn cmp; +xg_build_simplify_table (transition_cmp_fn cmp) { static TransitionTable *table = NULL; if (table == NULL) diff --git a/gas/config/xtensa-relax.h b/gas/config/xtensa-relax.h index 2a228bc..31fa8b0 100644 --- a/gas/config/xtensa-relax.h +++ b/gas/config/xtensa-relax.h @@ -173,10 +173,10 @@ struct transition_rule typedef int (*transition_cmp_fn) (const TransitionRule *, const TransitionRule *); -extern TransitionTable *xg_build_simplify_table PARAMS ((transition_cmp_fn)); -extern TransitionTable *xg_build_widen_table PARAMS ((transition_cmp_fn)); +extern TransitionTable *xg_build_simplify_table (transition_cmp_fn); +extern TransitionTable *xg_build_widen_table (transition_cmp_fn); -extern bfd_boolean xg_has_userdef_op_fn PARAMS ((OpType)); -extern long xg_apply_userdef_op_fn PARAMS ((OpType, long)); +extern bfd_boolean xg_has_userdef_op_fn (OpType); +extern long xg_apply_userdef_op_fn (OpType, long); #endif /* !XTENSA_RELAX_H */ diff --git a/ld/ChangeLog b/ld/ChangeLog index 1058f03..d6b409d 100644 --- a/ld/ChangeLog +++ b/ld/ChangeLog @@ -1,3 +1,7 @@ +2004-10-12 Bob Wilson <bob.wilson@acm.org> + + * emultempl/xtensaelf.em: Use ISO C90 formatting. + 2004-10-11 Jakub Jelinek <jakub@redhat.com> * emultempl/elf32.em (gld${EMULATION_NAME}_parse_ld_so_conf): Avoid diff --git a/ld/emultempl/xtensaelf.em b/ld/emultempl/xtensaelf.em index 386bf8a..b29ec49 100644 --- a/ld/emultempl/xtensaelf.em +++ b/ld/emultempl/xtensaelf.em @@ -32,10 +32,6 @@ cat >>e${EMULATION_NAME}.c <<EOF static void xtensa_wild_group_interleave (lang_statement_union_type *); static void xtensa_colocate_output_literals (lang_statement_union_type *); -static void remove_section (bfd *, asection *); -static bfd_boolean replace_insn_sec_with_prop_sec (bfd *, const char *, - const char *, char **); -static void replace_instruction_table_sections (bfd *, asection *); /* Flag for the emulation-specific "--no-relax" option. */ @@ -82,10 +78,8 @@ elf_xtensa_before_parse (void) } -void -remove_section (abfd, os) - bfd *abfd; - asection *os; +static void +remove_section (bfd *abfd, asection *os) { asection **spp; for (spp = &abfd->sections; *spp; spp = &(*spp)->next) @@ -98,13 +92,11 @@ remove_section (abfd, os) } -bfd_boolean -replace_insn_sec_with_prop_sec (abfd, insn_sec_name, prop_sec_name, - error_message) - bfd *abfd; - const char *insn_sec_name; - const char *prop_sec_name; - char **error_message; +static bfd_boolean +replace_insn_sec_with_prop_sec (bfd *abfd, + const char *insn_sec_name, + const char *prop_sec_name, + char **error_message) { asection *insn_sec; asection *prop_sec; @@ -269,10 +261,8 @@ replace_insn_sec_with_prop_sec (abfd, insn_sec_name, prop_sec_name, #define LINKONCE_SEC_OLD_TEXT_BASE_NAME ".gnu.linkonce.x." -void -replace_instruction_table_sections (abfd, sec) - bfd *abfd; - asection *sec; +static void +replace_instruction_table_sections (bfd *abfd, asection *sec) { char *message = ""; const char *insn_sec_name = NULL; @@ -445,8 +435,7 @@ typedef void (*deps_callback_t) (asection *, /* src_sec */ extern bfd_boolean xtensa_callback_required_dependence (bfd *, asection *, struct bfd_link_info *, deps_callback_t, void *); -static void xtensa_ldlang_clear_addresses - (lang_statement_union_type *); +static void xtensa_ldlang_clear_addresses (lang_statement_union_type *); static bfd_boolean ld_local_file_relocations_fit (lang_statement_union_type *, const reloc_deps_graph *); static bfd_vma ld_assign_relative_paged_dot @@ -455,8 +444,7 @@ static bfd_vma ld_assign_relative_paged_dot static bfd_vma ld_xtensa_insert_page_offsets (bfd_vma, lang_statement_union_type *, reloc_deps_graph *, bfd_boolean); #if EXTRA_VALIDATION -static size_t ld_count_children - (lang_statement_union_type *); +static size_t ld_count_children (lang_statement_union_type *); #endif extern lang_statement_list_type constructor_list; @@ -634,6 +622,7 @@ section_is_target (const reloc_deps_graph *deps ATTRIBUTE_UNUSED, return sec_deps && sec_deps->preds != NULL; } + static bfd_boolean section_is_source_or_target (const reloc_deps_graph *deps ATTRIBUTE_UNUSED, lang_statement_union_type *s) @@ -860,8 +849,7 @@ iter_stack_create (xtensa_ld_iter_stack **stack_p, static void -iter_stack_copy_current (xtensa_ld_iter_stack **stack_p, - xtensa_ld_iter *front) +iter_stack_copy_current (xtensa_ld_iter_stack **stack_p, xtensa_ld_iter *front) { *front = (*stack_p)->iterloc; } @@ -1027,9 +1015,7 @@ xtensa_move_dependencies_to_front (reloc_deps_graph *deps, static bfd_boolean -deps_has_sec_edge (const reloc_deps_graph *deps, - asection *src, - asection *tgt) +deps_has_sec_edge (const reloc_deps_graph *deps, asection *src, asection *tgt) { const reloc_deps_section *sec_deps; const reloc_deps_e *sec_deps_e; @@ -1071,9 +1057,7 @@ deps_has_edge (const reloc_deps_graph *deps, static void -add_deps_edge (reloc_deps_graph *deps, - asection *src_sec, - asection *tgt_sec) +add_deps_edge (reloc_deps_graph *deps, asection *src_sec, asection *tgt_sec) { reloc_deps_section *src_sec_deps; reloc_deps_section *tgt_sec_deps; @@ -1295,8 +1279,7 @@ xtensa_wild_group_interleave (lang_statement_union_type *s) static void -xtensa_layout_wild (const reloc_deps_graph *deps, - lang_wild_statement_type *w) +xtensa_layout_wild (const reloc_deps_graph *deps, lang_wild_statement_type *w) { /* If it does not fit initially, we need to do this step. Move all of the wild literal sections to a new list, then move each of diff --git a/opcodes/ChangeLog b/opcodes/ChangeLog index 3b5f4fa..ad47507 100644 --- a/opcodes/ChangeLog +++ b/opcodes/ChangeLog @@ -1,3 +1,7 @@ +2004-10-12 Bob Wilson <bob.wilson@acm.org> + + * xtensa-dis.c: Use ISO C90 formatting. + 2004-10-09 Alan Modra <amodra@bigpond.net.au> * ppc-opc.c: Revert 2004-09-09 change. diff --git a/opcodes/xtensa-dis.c b/opcodes/xtensa-dis.c index d7554a7..16fc4a9 100644 --- a/opcodes/xtensa-dis.c +++ b/opcodes/xtensa-dis.c @@ -39,11 +39,6 @@ extern xtensa_isa xtensa_default_isa; int show_raw_fields; -static int fetch_data - PARAMS ((struct disassemble_info *, bfd_vma)); -static void print_xtensa_operand - PARAMS ((bfd_vma, struct disassemble_info *, xtensa_opcode, int, unsigned)); - struct dis_private { bfd_byte *byte_buf; @@ -52,9 +47,7 @@ struct dis_private static int -fetch_data (info, memaddr) - struct disassemble_info *info; - bfd_vma memaddr; +fetch_data (struct disassemble_info *info, bfd_vma memaddr) { int length, status = 0; struct dis_private *priv = (struct dis_private *) info->private_data; @@ -79,12 +72,11 @@ fetch_data (info, memaddr) static void -print_xtensa_operand (memaddr, info, opc, opnd, operand_val) - bfd_vma memaddr; - struct disassemble_info *info; - xtensa_opcode opc; - int opnd; - unsigned operand_val; +print_xtensa_operand (bfd_vma memaddr, + struct disassemble_info *info, + xtensa_opcode opc, + int opnd, + unsigned operand_val) { xtensa_isa isa = xtensa_default_isa; int signed_operand_val; @@ -141,9 +133,7 @@ print_xtensa_operand (memaddr, info, opc, opnd, operand_val) Returns length of the instruction in bytes. */ int -print_insn_xtensa (memaddr, info) - bfd_vma memaddr; - struct disassemble_info *info; +print_insn_xtensa (bfd_vma memaddr, struct disassemble_info *info) { unsigned operand_val; int bytes_fetched, size, maxsize, i, n, noperands, nslots; @@ -184,7 +174,7 @@ print_insn_xtensa (memaddr, info) priv.byte_buf = byte_buf; - info->private_data = (PTR) &priv; + info->private_data = (void *) &priv; if (setjmp (priv.bailout) != 0) /* Error return. */ return -1; |