/* tc-xtensa.c -- Assemble Xtensa instructions. Copyright 2003 Free Software Foundation, Inc. This file is part of GAS, the GNU Assembler. GAS is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GAS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GAS; see the file COPYING. If not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include "as.h" #include "sb.h" #include "safe-ctype.h" #include "tc-xtensa.h" #include "frags.h" #include "subsegs.h" #include "xtensa-relax.h" #include "xtensa-istack.h" #include "dwarf2dbg.h" #include "struc-symbol.h" #include "xtensa-config.h" #ifndef uint32 #define uint32 unsigned int #endif #ifndef int32 #define int32 signed int #endif /* Notes: There are 3 forms for instructions, 1) the MEMORY format -- this is the encoding 2 or 3 byte instruction 2) the TInsn -- handles instructions/labels and literals; all operands are assumed to be expressions 3) the IStack -- a stack of TInsn. this allows us to reason about the generated expansion instructions Naming conventions (used somewhat inconsistently): The xtensa_ functions are exported The xg_ functions are internal We also have a couple of different extensibility mechanisms. 1) The idiom replacement: This is used when a line is first parsed to replace an instruction pattern with another instruction It is currently limited to replacements of instructions with constant operands. 2) The xtensa-relax.c mechanism that has stronger instruction replacement patterns. When an instruction's immediate field does not fit the next instruction sequence is attempted. In addition, "narrow" opcodes are supported this way. */ /* Define characters with special meanings to GAS. */ const char comment_chars[] = "#"; const char line_comment_chars[] = "#"; const char line_separator_chars[] = ";"; const char EXP_CHARS[] = "eE"; const char FLT_CHARS[] = "rRsSfFdDxXpP"; /* Flag to indicate whether the hardware supports the density option. If not, enabling density instructions (via directives or --density flag) is illegal. */ #if STATIC_LIBISA bfd_boolean density_supported = XCHAL_HAVE_DENSITY; #else bfd_boolean density_supported = TRUE; #endif #define XTENSA_FETCH_WIDTH 4 /* Flags for properties of the last instruction in a segment. */ #define FLAG_IS_A0_WRITER 0x1 #define FLAG_IS_BAD_LOOPEND 0x2 /* We define a special segment names ".literal" to place literals into. The .fini and .init sections are special because they contain code that is moved together by the linker. We give them their own special .fini.literal and .init.literal sections. */ #define LITERAL_SECTION_NAME xtensa_section_rename (".literal") #define FINI_SECTION_NAME xtensa_section_rename (".fini") #define INIT_SECTION_NAME xtensa_section_rename (".init") #define FINI_LITERAL_SECTION_NAME xtensa_section_rename (".fini.literal") #define INIT_LITERAL_SECTION_NAME xtensa_section_rename (".init.literal") /* This type is used for the directive_stack to keep track of the state of the literal collection pools. */ typedef struct lit_state_struct { const char *lit_seg_name; const char *init_lit_seg_name; const char *fini_lit_seg_name; segT lit_seg; segT init_lit_seg; segT fini_lit_seg; } lit_state; static lit_state default_lit_sections; /* We keep lists of literal segments. The seg_list type is the node for such a list. The *_literal_head locals are the heads of the various lists. All of these lists have a dummy node at the start. */ typedef struct seg_list_struct { struct seg_list_struct *next; segT seg; } seg_list; static seg_list literal_head_h; static seg_list *literal_head = &literal_head_h; static seg_list init_literal_head_h; static seg_list *init_literal_head = &init_literal_head_h; static seg_list fini_literal_head_h; static seg_list *fini_literal_head = &fini_literal_head_h; /* Lists of symbols. We keep a list of symbols that label the current instruction, so that we can adjust the symbols when inserting alignment for various instructions. We also keep a list of all the symbols on literals, so that we can fix up those symbols when the literals are later moved into the text sections. */ typedef struct sym_list_struct { struct sym_list_struct *next; symbolS *sym; } sym_list; static sym_list *insn_labels = NULL; static sym_list *free_insn_labels = NULL; static sym_list *saved_insn_labels = NULL; static sym_list *literal_syms; /* Global flag to indicate when we are emitting literals. */ int generating_literals = 0; /* Structure for saving the current state before emitting literals. */ typedef struct emit_state_struct { const char *name; segT now_seg; subsegT now_subseg; int generating_literals; } emit_state; /* Directives. */ typedef enum { directive_none = 0, directive_literal, directive_density, directive_generics, directive_relax, directive_freeregs, directive_longcalls, directive_literal_prefix } directiveE; typedef struct { const char *name; bfd_boolean can_be_negated; } directive_infoS; const directive_infoS directive_info[] = { {"none", FALSE}, {"literal", FALSE}, {"density", TRUE}, {"generics", TRUE}, {"relax", TRUE}, {"freeregs", FALSE}, {"longcalls", TRUE}, {"literal_prefix", FALSE} }; bfd_boolean directive_state[] = { FALSE, /* none */ FALSE, /* literal */ #if STATIC_LIBISA && !XCHAL_HAVE_DENSITY FALSE, /* density */ #else TRUE, /* density */ #endif TRUE, /* generics */ TRUE, /* relax */ FALSE, /* freeregs */ FALSE, /* longcalls */ FALSE /* literal_prefix */ }; enum xtensa_relax_statesE { RELAX_ALIGN_NEXT_OPCODE, /* Use the first opcode of the next fragment to determine the alignment requirements. This is ONLY used for LOOPS currently. */ RELAX_DESIRE_ALIGN_IF_TARGET, /* These are placed in front of labels. They will all be converted to RELAX_DESIRE_ALIGN / RELAX_LOOP_END or rs_fill of 0 before relaxation begins. */ RELAX_ADD_NOP_IF_A0_B_RETW, /* These are placed in front of conditional branches. It will be turned into a NOP (using a1) if the branch is immediately followed by a RETW or RETW.N. Otherwise it will be turned into an rs_fill of 0 before relaxation begins. */ RELAX_ADD_NOP_IF_PRE_LOOP_END, /* These are placed after JX instructions. It will be turned into a NOP if there is one instruction before a loop end label. Otherwise it will be turned into an rs_fill of 0 before relaxation begins. This is used to avoid a hardware TIE interlock issue prior to T1040. */ RELAX_ADD_NOP_IF_SHORT_LOOP, /* These are placed after LOOP instructions. It will be turned into a NOP when: (1) there are less than 3 instructions in the loop; we place 2 of these in a row to add up to 2 NOPS in short loops; or (2) The instructions in the loop do not include a branch or jump. Otherwise it will be turned into an rs_fill of 0 before relaxation begins. This is used to avoid hardware bug PR3830. */ RELAX_ADD_NOP_IF_CLOSE_LOOP_END, /* These are placed after LOOP instructions. It will be turned into a NOP if there are less than 12 bytes to the end of some other loop's end. Otherwise it will be turned into an rs_fill of 0 before relaxation begins. This is used to avoid hardware bug PR3830. */ RELAX_DESIRE_ALIGN, /* The next fragment like its first instruction to NOT cross a 4-byte boundary. */ RELAX_LOOP_END, /* This will be turned into a NOP or NOP.N if the previous instruction is expanded to negate a loop. */ RELAX_LOOP_END_ADD_NOP, /* When the code density option is available, this will generate a NOP.N marked RELAX_NARROW. Otherwise, it will create an rs_fill fragment with a NOP in it. */ RELAX_LITERAL, /* Another fragment could generate an expansion here but has not yet. */ RELAX_LITERAL_NR, /* Expansion has been generated by an instruction that generates a literal. However, the stretch has NOT been reported yet in this fragment. */ RELAX_LITERAL_FINAL, /* Expansion has been generated by an instruction that generates a literal. */ RELAX_LITERAL_POOL_BEGIN, RELAX_LITERAL_POOL_END, /* Technically these are not relaxations at all, but mark a location to store literals later. Note that fr_var stores the frchain for BEGIN frags and fr_var stores now_seg for END frags. */ RELAX_NARROW, /* The last instruction in this fragment (at->fr_opcode) can be freely replaced with a single wider instruction if a future alignment desires or needs it. */ RELAX_IMMED, /* The last instruction in this fragment (at->fr_opcode) contains the value defined by fr_symbol (fr_offset = 0). If the value does not fit, use the specified expansion. This is similar to "NARROW", except that these may not be expanded in order to align code. */ RELAX_IMMED_STEP1, /* The last instruction in this fragment (at->fr_opcode) contains a literal. It has already been expanded at least 1 step. */ RELAX_IMMED_STEP2 /* The last instruction in this fragment (at->fr_opcode) contains a literal. It has already been expanded at least 2 steps. */ }; /* This is used as a stopper to bound the number of steps that can be taken. */ #define RELAX_IMMED_MAXSTEPS (RELAX_IMMED_STEP2 - RELAX_IMMED) typedef bfd_boolean (*frag_predicate) (const fragS *); /* Directive functions. */ static bfd_boolean use_generics PARAMS ((void)); static bfd_boolean use_longcalls PARAMS ((void)); static bfd_boolean code_density_available PARAMS ((void)); static bfd_boolean can_relax 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_literal_prefix PARAMS ((char const *, int)); static void xtensa_literal_position PARAMS ((int)); static void xtensa_literal_pseudo PARAMS ((int)); /* 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_operand, expressionS *)); static int tokenize_arguments PARAMS ((char **, char *)); static bfd_boolean parse_arguments PARAMS ((TInsn *, int, char **)); static int xg_translate_idioms PARAMS ((char **, int *, char **)); static int xg_translate_sysreg_op PARAMS ((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 **)); /* Functions for dealing with the Xtensa ISA. */ static bfd_boolean operand_is_immed PARAMS ((xtensa_operand)); static bfd_boolean operand_is_pcrel_label PARAMS ((xtensa_operand)); static int get_relaxable_immed PARAMS ((xtensa_opcode)); static xtensa_opcode get_opcode_from_buf PARAMS ((const char *)); static bfd_boolean is_direct_call_opcode PARAMS ((xtensa_opcode)); static bfd_boolean is_call_opcode PARAMS ((xtensa_opcode)); static bfd_boolean is_entry_opcode PARAMS ((xtensa_opcode)); static bfd_boolean is_loop_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 bfd_boolean is_conditional_branch_opcode PARAMS ((xtensa_opcode)); static bfd_boolean is_branch_or_jump_opcode PARAMS ((xtensa_opcode)); static bfd_reloc_code_real_type opnum_to_reloc PARAMS ((int)); static int reloc_to_opnum PARAMS ((bfd_reloc_code_real_type)); static void xtensa_insnbuf_set_operand PARAMS ((xtensa_insnbuf, xtensa_opcode, xtensa_operand, int32, const char *, unsigned int)); static uint32 xtensa_insnbuf_get_operand PARAMS ((xtensa_insnbuf, xtensa_opcode, int)); static void xtensa_insnbuf_set_immediate_field PARAMS ((xtensa_opcode, xtensa_insnbuf, int32, const char *, unsigned int)); static bfd_boolean is_negatable_branch PARAMS ((TInsn *)); /* Various Other Internal Functions. */ static bfd_boolean is_unique_insn_expansion PARAMS ((TransitionRule *)); static int xg_get_insn_size PARAMS ((TInsn *)); 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_narrow_insn_size PARAMS ((xtensa_opcode)); 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_operand)); static int is_dnrange PARAMS ((fragS *, symbolS *, long)); 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, 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_rule PARAMS ((TInsn *, TransitionRule *)); static TransitionRule *xg_instruction_match PARAMS ((TInsn *)); 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 void xg_assemble_literal_space PARAMS ((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 PARAMS ((TInsn *, bfd_boolean)); static bfd_boolean xg_emit_insn_to_buf PARAMS ((TInsn *, char *, fragS *, offsetT, bfd_boolean)); static bfd_boolean xg_add_opcode_fix PARAMS ((xtensa_opcode, int, expressionS *, fragS *, offsetT)); static void xg_resolve_literals PARAMS ((TInsn *, symbolS *)); static void xg_resolve_labels PARAMS ((TInsn *, symbolS *)); static void xg_assemble_tokens PARAMS ((TInsn *)); 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 xtensa_opcode next_frag_opcode PARAMS ((const fragS *)); static void update_next_frag_nop_state PARAMS ((fragS *)); 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 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 *)); /* 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_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 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 *)); /* 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_widen_aligned_address PARAMS ((fragS *, addressT)); /* Helpers for xtensa_relax_frag(). */ static long relax_frag_text_align PARAMS ((fragS *, long)); static long relax_frag_add_nop PARAMS ((fragS *)); static long relax_frag_narrow PARAMS ((fragS *, long)); static bfd_boolean future_alignment_required PARAMS ((fragS *, long)); static long relax_frag_immed PARAMS ((segT, fragS *, long, int, int *)); /* Helpers for md_convert_frag(). */ static void convert_frag_align_next_opcode PARAMS ((fragS *)); static void convert_frag_narrow PARAMS ((fragS *)); static void convert_frag_immed PARAMS ((segT, fragS *, 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 *)); /* 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)); /* 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 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_section_emit_state PARAMS ((emit_state *, segT, subsegT)); static void xtensa_restore_emit_state PARAMS ((emit_state *)); static void cache_literal_section PARAMS ((seg_list *, const char *, segT *)); static segT retrieve_literal_seg PARAMS ((seg_list *, const char *)); static segT seg_present PARAMS ((const char *)); static void add_seg_list PARAMS ((seg_list *, segT)); /* Property Table (e.g., ".xt.insn" and ".xt.lit") Functions. */ static void xtensa_create_property_segments PARAMS ((frag_predicate, 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 sec, frag_predicate)); static void add_xt_block_frags PARAMS ((segT, segT, xtensa_block_info **, frag_predicate)); static bfd_boolean get_frag_is_literal PARAMS ((const fragS *)); static bfd_boolean get_frag_is_insn PARAMS ((const fragS *)); /* Import from elf32-xtensa.c in BFD library. */ extern char *xtensa_get_property_section_name PARAMS ((asection *, const char *)); /* 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_check_arguments PARAMS ((const TInsn *)); static void tinsn_from_chars PARAMS ((TInsn *, char *)); static void tinsn_immed_from_frag PARAMS ((TInsn *, fragS *)); static int get_num_stack_text_bytes PARAMS ((IStack *)); static int get_num_stack_literal_bytes PARAMS ((IStack *)); /* Expression Utilities. */ bfd_boolean expr_is_const PARAMS ((const expressionS *)); offsetT get_expr_const PARAMS ((const expressionS *)); void set_expr_const PARAMS ((expressionS *, offsetT)); void set_expr_symbol_offset PARAMS ((expressionS *, symbolS *, offsetT)); bfd_boolean expr_is_equal PARAMS ((expressionS *, expressionS *)); static void copy_expr PARAMS ((expressionS *, const expressionS *)); #ifdef XTENSA_SECTION_RENAME static void build_section_rename PARAMS ((const char *)); static void add_section_rename PARAMS ((char *, char *)); #endif /* ISA imported from bfd. */ extern xtensa_isa xtensa_default_isa; extern int target_big_endian; static xtensa_opcode xtensa_addi_opcode; static xtensa_opcode xtensa_addmi_opcode; static xtensa_opcode xtensa_call0_opcode; static xtensa_opcode xtensa_call4_opcode; static xtensa_opcode xtensa_call8_opcode; static xtensa_opcode xtensa_call12_opcode; static xtensa_opcode xtensa_callx0_opcode; static xtensa_opcode xtensa_callx4_opcode; static xtensa_opcode xtensa_callx8_opcode; static xtensa_opcode xtensa_callx12_opcode; static xtensa_opcode xtensa_entry_opcode; static xtensa_opcode xtensa_isync_opcode; static xtensa_opcode xtensa_j_opcode; static xtensa_opcode xtensa_jx_opcode; static xtensa_opcode xtensa_loop_opcode; static xtensa_opcode xtensa_loopnez_opcode; static xtensa_opcode xtensa_loopgtz_opcode; static xtensa_opcode xtensa_nop_n_opcode; static xtensa_opcode xtensa_or_opcode; static xtensa_opcode xtensa_ret_opcode; static xtensa_opcode xtensa_ret_n_opcode; static xtensa_opcode xtensa_retw_opcode; static xtensa_opcode xtensa_retw_n_opcode; static xtensa_opcode xtensa_rsr_opcode; static xtensa_opcode xtensa_waiti_opcode; /* Command-line Options. */ bfd_boolean use_literal_section = TRUE; static bfd_boolean align_targets = TRUE; static bfd_boolean align_only_targets = FALSE; static bfd_boolean software_a0_b_retw_interlock = TRUE; static bfd_boolean has_a0_b_retw = FALSE; static bfd_boolean workaround_a0_b_retw = TRUE; static bfd_boolean software_avoid_b_j_loop_end = TRUE; static bfd_boolean workaround_b_j_loop_end = TRUE; static bfd_boolean maybe_has_b_j_loop_end = FALSE; static bfd_boolean software_avoid_short_loop = TRUE; static bfd_boolean workaround_short_loop = TRUE; static bfd_boolean maybe_has_short_loop = FALSE; static bfd_boolean software_avoid_close_loop_end = TRUE; static bfd_boolean workaround_close_loop_end = TRUE; static bfd_boolean maybe_has_close_loop_end = FALSE; /* When avoid_short_loops is true, all loops with early exits must have at least 3 instructions. avoid_all_short_loops is a modifier to the avoid_short_loop flag. In addition to the avoid_short_loop actions, all straightline loopgtz and loopnez must have at least 3 instructions. */ static bfd_boolean software_avoid_all_short_loops = TRUE; static bfd_boolean workaround_all_short_loops = TRUE; /* This is on a per-instruction basis. */ static bfd_boolean specific_opcode = FALSE; enum { option_density = OPTION_MD_BASE, option_no_density, option_relax, option_no_relax, option_generics, option_no_generics, option_text_section_literals, option_no_text_section_literals, option_align_targets, option_no_align_targets, option_align_only_targets, option_no_align_only_targets, option_longcalls, option_no_longcalls, option_workaround_a0_b_retw, option_no_workaround_a0_b_retw, option_workaround_b_j_loop_end, option_no_workaround_b_j_loop_end, option_workaround_short_loop, option_no_workaround_short_loop, option_workaround_all_short_loops, option_no_workaround_all_short_loops, option_workaround_close_loop_end, option_no_workaround_close_loop_end, option_no_workarounds, #ifdef XTENSA_SECTION_RENAME option_literal_section_name, option_text_section_name, option_data_section_name, option_bss_section_name, option_rename_section_name, #endif option_eb, option_el }; const char *md_shortopts = ""; struct option md_longopts[] = { {"density", no_argument, NULL, option_density}, {"no-density", no_argument, NULL, option_no_density}, /* At least as early as alameda, --[no-]relax didn't work as documented, so as of albany, --[no-]relax is equivalent to --[no-]generics. Both of these will be deprecated in BearValley. */ {"relax", no_argument, NULL, option_generics}, {"no-relax", no_argument, NULL, option_no_generics}, {"generics", no_argument, NULL, option_generics}, {"no-generics", no_argument, NULL, option_no_generics}, {"text-section-literals", no_argument, NULL, option_text_section_literals}, {"no-text-section-literals", no_argument, NULL, option_no_text_section_literals}, /* 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}, #if 0 /* This option should do a better job aligning targets because it will only attempt to align targets that are the target of a branch. */ { "target-align-only", no_argument, NULL, option_align_only_targets }, { "no-target-align-only", no_argument, NULL, option_no_align_only_targets }, #endif /* 0 */ {"longcalls", no_argument, NULL, option_longcalls}, {"no-longcalls", no_argument, NULL, option_no_longcalls}, {"no-workaround-a0-b-retw", no_argument, NULL, option_no_workaround_a0_b_retw}, {"workaround-a0-b-retw", no_argument, NULL, option_workaround_a0_b_retw}, {"no-workaround-b-j-loop-end", no_argument, NULL, option_no_workaround_b_j_loop_end}, {"workaround-b-j-loop-end", no_argument, NULL, option_workaround_b_j_loop_end}, {"no-workaround-short-loops", no_argument, NULL, option_no_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}, {"workaround-all-short-loop", no_argument, NULL, option_workaround_all_short_loops}, {"no-workaround-close-loop-end", no_argument, NULL, option_no_workaround_close_loop_end}, {"workaround-close-loop-end", no_argument, NULL, option_workaround_close_loop_end}, {"no-workarounds", no_argument, NULL, option_no_workarounds}, #ifdef XTENSA_SECTION_RENAME {"literal-section-name", required_argument, NULL, option_literal_section_name}, {"text-section-name", required_argument, NULL, option_text_section_name}, {"data-section-name", required_argument, NULL, option_data_section_name}, {"rename-section", required_argument, NULL, option_rename_section_name}, {"bss-section-name", required_argument, NULL, option_bss_section_name}, #endif /* XTENSA_SECTION_RENAME */ {NULL, no_argument, NULL, 0} }; size_t md_longopts_size = sizeof md_longopts; int md_parse_option (c, arg) int c; char *arg; { switch (c) { case option_density: if (!density_supported) { as_bad (_("'--density' option not supported in this Xtensa " "configuration")); return 0; } directive_state[directive_density] = TRUE; return 1; case option_no_density: directive_state[directive_density] = FALSE; return 1; case option_generics: directive_state[directive_generics] = TRUE; return 1; case option_no_generics: directive_state[directive_generics] = FALSE; return 1; case option_longcalls: directive_state[directive_longcalls] = TRUE; return 1; case option_no_longcalls: directive_state[directive_longcalls] = FALSE; return 1; case option_text_section_literals: use_literal_section = FALSE; return 1; case option_no_text_section_literals: use_literal_section = TRUE; return 1; case option_workaround_a0_b_retw: workaround_a0_b_retw = TRUE; software_a0_b_retw_interlock = TRUE; return 1; case option_no_workaround_a0_b_retw: workaround_a0_b_retw = FALSE; software_a0_b_retw_interlock = FALSE; return 1; case option_workaround_b_j_loop_end: workaround_b_j_loop_end = TRUE; software_avoid_b_j_loop_end = TRUE; return 1; case option_no_workaround_b_j_loop_end: workaround_b_j_loop_end = FALSE; software_avoid_b_j_loop_end = FALSE; return 1; case option_workaround_short_loop: workaround_short_loop = TRUE; software_avoid_short_loop = TRUE; return 1; case option_no_workaround_short_loop: workaround_short_loop = FALSE; software_avoid_short_loop = FALSE; return 1; case option_workaround_all_short_loops: workaround_all_short_loops = TRUE; software_avoid_all_short_loops = TRUE; return 1; case option_no_workaround_all_short_loops: workaround_all_short_loops = FALSE; software_avoid_all_short_loops = FALSE; return 1; case option_workaround_close_loop_end: workaround_close_loop_end = TRUE; software_avoid_close_loop_end = TRUE; return 1; case option_no_workaround_close_loop_end: workaround_close_loop_end = FALSE; software_avoid_close_loop_end = FALSE; return 1; case option_no_workarounds: workaround_a0_b_retw = FALSE; software_a0_b_retw_interlock = FALSE; workaround_b_j_loop_end = FALSE; software_avoid_b_j_loop_end = FALSE; workaround_short_loop = FALSE; software_avoid_short_loop = FALSE; workaround_all_short_loops = FALSE; software_avoid_all_short_loops = FALSE; workaround_close_loop_end = FALSE; software_avoid_close_loop_end = FALSE; return 1; case option_align_targets: align_targets = TRUE; return 1; case option_no_align_targets: align_targets = FALSE; return 1; case option_align_only_targets: align_only_targets = TRUE; return 1; case option_no_align_only_targets: align_only_targets = FALSE; return 1; #ifdef XTENSA_SECTION_RENAME case option_literal_section_name: add_section_rename (".literal", arg); as_warn (_("'--literal-section-name' is deprecated; " "use '--rename-section .literal=NEWNAME'")); return 1; case option_text_section_name: add_section_rename (".text", arg); as_warn (_("'--text-section-name' is deprecated; " "use '--rename-section .text=NEWNAME'")); return 1; case option_data_section_name: add_section_rename (".data", arg); as_warn (_("'--data-section-name' is deprecated; " "use '--rename-section .data=NEWNAME'")); return 1; case option_bss_section_name: add_section_rename (".bss", arg); as_warn (_("'--bss-section-name' is deprecated; " "use '--rename-section .bss=NEWNAME'")); return 1; case option_rename_section_name: build_section_rename (arg); return 1; #endif /* XTENSA_SECTION_RENAME */ case 'Q': /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section should be emitted or not. FIXME: Not implemented. */ return 1; default: return 0; } } void md_show_usage (stream) FILE *stream; { fputs ("\nXtensa options:\n" "--[no-]density [Do not] emit density instructions\n" "--[no-]relax [Do not] perform branch relaxation\n" "--[no-]generics [Do not] transform instructions\n" "--[no-]longcalls [Do not] emit 32-bit call sequences\n" "--[no-]target-align [Do not] try to align branch targets\n" "--[no-]text-section-literals\n" " [Do not] put literals in the text section\n" "--no-workarounds Do not use any Xtensa workarounds\n" #ifdef XTENSA_SECTION_RENAME "--rename-section old=new(:old1=new1)*\n" " Rename section 'old' to 'new'\n" "\nThe following Xtensa options are deprecated\n" "--literal-section-name Name of literal section (default .literal)\n" "--text-section-name Name of text section (default .text)\n" "--data-section-name Name of data section (default .data)\n" "--bss-section-name Name of bss section (default .bss)\n" #endif , stream); } /* Directive data and functions. */ typedef struct state_stackS_struct { directiveE directive; bfd_boolean negated; bfd_boolean old_state; const char *file; unsigned int line; const void *datum; struct state_stackS_struct *prev; } state_stackS; state_stackS *directive_state_stack; const pseudo_typeS md_pseudo_table[] = { {"align", s_align_bytes, 0}, /* Defaulting is invalid (0) */ {"literal_position", xtensa_literal_position, 0}, {"frame", s_ignore, 0}, /* formerly used for STABS debugging */ {"word", cons, 4}, {"begin", xtensa_begin_directive, 0}, {"end", xtensa_end_directive, 0}, {"literal", xtensa_literal_pseudo, 0}, {NULL, 0, 0}, }; bfd_boolean use_generics () { return directive_state[directive_generics]; } bfd_boolean use_longcalls () { return directive_state[directive_longcalls]; } bfd_boolean code_density_available () { return directive_state[directive_density]; } bfd_boolean can_relax () { return use_generics (); } static void directive_push (directive, negated, datum) directiveE directive; bfd_boolean negated; const void *datum; { char *file; unsigned int line; state_stackS *stack = (state_stackS *) xmalloc (sizeof (state_stackS)); as_where (&file, &line); stack->directive = directive; stack->negated = negated; stack->old_state = directive_state[directive]; stack->file = file; stack->line = line; stack->datum = datum; stack->prev = directive_state_stack; directive_state_stack = stack; 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; { state_stackS *top = directive_state_stack; if (!directive_state_stack) { as_bad (_("unmatched end directive")); *directive = directive_none; return; } directive_state[directive_state_stack->directive] = top->old_state; *directive = top->directive; *negated = top->negated; *file = top->file; *line = top->line; *datum = top->datum; directive_state_stack = top->prev; free (top); } static void directive_balance () { while (directive_state_stack) { directiveE directive; bfd_boolean negated; const char *file; unsigned int line; const void *datum; directive_pop (&directive, &negated, &file, &line, &datum); as_warn_where ((char *) file, line, _(".begin directive with no matching .end directive")); } } static bfd_boolean inside_directive (dir) directiveE dir; { state_stackS *top = directive_state_stack; while (top && top->directive != dir) top = top->prev; return (top != NULL); } static void get_directive (directive, negated) directiveE *directive; bfd_boolean *negated; { int len; unsigned i; if (strncmp (input_line_pointer, "no-", 3) != 0) *negated = FALSE; else { *negated = TRUE; input_line_pointer += 3; } len = strspn (input_line_pointer, "abcdefghijklmnopqrstuvwxyz_/0123456789."); for (i = 0; i < sizeof (directive_info) / sizeof (*directive_info); ++i) { if (strncmp (input_line_pointer, directive_info[i].name, len) == 0) { input_line_pointer += len; *directive = (directiveE) i; if (*negated && !directive_info[i].can_be_negated) as_bad (_("directive %s can't be negated"), directive_info[i].name); return; } } as_bad (_("unknown directive")); *directive = (directiveE) XTENSA_UNDEFINED; } static void xtensa_begin_directive (ignore) int ignore ATTRIBUTE_UNUSED; { directiveE directive; bfd_boolean negated; emit_state *state; int len; lit_state *ls; md_flush_pending_output (); get_directive (&directive, &negated); if (directive == (directiveE) XTENSA_UNDEFINED) { discard_rest_of_line (); return; } switch (directive) { case directive_literal: if (!inside_directive (directive_literal)) { /* Previous labels go with whatever follows this directive, not with the literal, so save them now. */ saved_insn_labels = insn_labels; insn_labels = NULL; } state = (emit_state *) xmalloc (sizeof (emit_state)); xtensa_switch_to_literal_fragment (state); directive_push (directive_literal, negated, state); break; case directive_literal_prefix: /* Check to see if the current fragment is a literal fragment. If it is, then this operation is not allowed. */ if (frag_now->tc_frag_data.is_literal) { as_bad (_("cannot set literal_prefix inside literal fragment")); return; } /* Allocate the literal state for this section and push onto the directive stack. */ ls = xmalloc (sizeof (lit_state)); assert (ls); *ls = default_lit_sections; directive_push (directive_literal_prefix, negated, ls); /* Parse the new prefix from the input_line_pointer. */ SKIP_WHITESPACE (); len = strspn (input_line_pointer, "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz_/0123456789.$"); /* Process the new prefix. */ xtensa_literal_prefix (input_line_pointer, len); /* Skip the name in the input line. */ input_line_pointer += len; break; case directive_freeregs: /* This information is currently unused, but we'll accept the statement and just discard the rest of the line. This won't check the syntax, but it will accept every correct freeregs directive. */ input_line_pointer += strcspn (input_line_pointer, "\n"); directive_push (directive_freeregs, negated, 0); break; case directive_density: if (!density_supported && !negated) { as_warn (_("Xtensa density option not supported; ignored")); break; } /* fall through */ default: directive_push (directive, negated, 0); break; } demand_empty_rest_of_line (); } static void xtensa_end_directive (ignore) int ignore ATTRIBUTE_UNUSED; { directiveE begin_directive, end_directive; bfd_boolean begin_negated, end_negated; const char *file; unsigned int line; emit_state *state; lit_state *s; md_flush_pending_output (); get_directive (&end_directive, &end_negated); if (end_directive == (directiveE) XTENSA_UNDEFINED) { discard_rest_of_line (); return; } if (end_directive == directive_density && !density_supported && !end_negated) { as_warn (_("Xtensa density option not supported; ignored")); demand_empty_rest_of_line (); return; } directive_pop (&begin_directive, &begin_negated, &file, &line, (const void **) &state); if (begin_directive != directive_none) { if (begin_directive != end_directive || begin_negated != end_negated) { as_bad (_("does not match begin %s%s at %s:%d"), begin_negated ? "no-" : "", directive_info[begin_directive].name, file, line); } else { switch (end_directive) { case directive_literal: frag_var (rs_fill, 0, 0, 0, NULL, 0, NULL); xtensa_restore_emit_state (state); free (state); if (!inside_directive (directive_literal)) { /* Restore the list of current labels. */ xtensa_clear_insn_labels (); insn_labels = saved_insn_labels; } break; case directive_freeregs: break; case directive_literal_prefix: /* Restore the default collection sections from saved state. */ s = (lit_state *) state; assert (s); if (use_literal_section) default_lit_sections = *s; /* free the state storage */ free (s); break; default: break; } } } demand_empty_rest_of_line (); } /* Place an aligned literal fragment at the current location. */ static void xtensa_literal_position (ignore) int ignore ATTRIBUTE_UNUSED; { if (inside_directive (directive_literal)) as_warn (_(".literal_position inside literal directive; ignoring")); else if (!use_literal_section) xtensa_mark_literal_pool_location (); demand_empty_rest_of_line (); xtensa_clear_insn_labels (); } /* Support .literal label, value@plt + offset. */ static void xtensa_literal_pseudo (ignored) int ignored ATTRIBUTE_UNUSED; { emit_state state; char *p, *base_name; char c; expressionS expP; segT dest_seg; if (inside_directive (directive_literal)) { as_bad (_(".literal not allowed inside .begin literal region")); ignore_rest_of_line (); return; } /* Previous labels go with whatever follows this directive, not with the literal, so save them now. */ saved_insn_labels = insn_labels; insn_labels = NULL; /* If we are using text-section literals, then this is the right value... */ dest_seg = now_seg; base_name = input_line_pointer; xtensa_switch_to_literal_fragment (&state); /* ...but if we aren't using text-section-literals, then we need to put them in the section we just switched to. */ if (use_literal_section) dest_seg = now_seg; /* All literals are aligned to four-byte boundaries which is handled by switch to literal fragment. */ /* frag_align (2, 0, 0); */ c = get_symbol_end (); /* Just after name is now '\0'. */ p = input_line_pointer; *p = c; SKIP_WHITESPACE (); if (*input_line_pointer != ',' && *input_line_pointer != ':') { as_bad (_("expected comma or colon after symbol name; " "rest of line ignored")); ignore_rest_of_line (); xtensa_restore_emit_state (&state); return; } *p = 0; colon (base_name); do { input_line_pointer++; /* skip ',' or ':' */ expr (0, &expP); /* We only support 4-byte literals with .literal. */ emit_expr (&expP, 4); } while (*input_line_pointer == ','); *p = c; demand_empty_rest_of_line (); xtensa_restore_emit_state (&state); /* Restore the list of current labels. */ xtensa_clear_insn_labels (); insn_labels = saved_insn_labels; } static void xtensa_literal_prefix (start, len) char const *start; int len; { segT s_now; /* Storage for the current seg and subseg. */ subsegT ss_now; char *name; /* Pointer to the name itself. */ char *newname; if (!use_literal_section) return; /* Store away the current section and subsection. */ s_now = now_seg; ss_now = now_subseg; /* Get a null-terminated copy of the name. */ name = xmalloc (len + 1); assert (name); strncpy (name, start, len); name[len] = 0; /* Allocate the sections (interesting note: the memory pointing to the name is actually used for the name by the new section). */ newname = xmalloc (len + strlen (".literal") + 1); strcpy (newname, name); strcpy (newname + len, ".literal"); /* Note that retrieve_literal_seg does not create a segment if it already exists. */ default_lit_sections.lit_seg = NULL; /* retrieved on demand */ /* Canonicalizing section names allows renaming literal sections to occur correctly. */ default_lit_sections.lit_seg_name = tc_canonicalize_symbol_name (newname); free (name); /* Restore the current section and subsection and set the generation into the old segment. */ subseg_set (s_now, ss_now); } /* Parsing and Idiom Translation. */ static const char * expression_end (name) const char *name; { while (1) { switch (*name) { case ';': case '\0': case ',': return name; case ' ': case '\t': ++name; continue; default: return 0; } } } #define ERROR_REG_NUM ((unsigned) -1) static unsigned tc_get_register (prefix) const char *prefix; { unsigned reg; const char *next_expr; const char *old_line_pointer; SKIP_WHITESPACE (); old_line_pointer = input_line_pointer; if (*input_line_pointer == '$') ++input_line_pointer; /* Accept "sp" as a synonym for "a1". */ if (input_line_pointer[0] == 's' && input_line_pointer[1] == 'p' && expression_end (input_line_pointer + 2)) { input_line_pointer += 2; return 1; /* AR[1] */ } while (*input_line_pointer++ == *prefix++) ; --input_line_pointer; --prefix; if (*prefix) { as_bad (_("bad register name: %s"), old_line_pointer); return ERROR_REG_NUM; } if (!ISDIGIT ((unsigned char) *input_line_pointer)) { as_bad (_("bad register number: %s"), input_line_pointer); return ERROR_REG_NUM; } reg = 0; while (ISDIGIT ((int) *input_line_pointer)) reg = reg * 10 + *input_line_pointer++ - '0'; if (!(next_expr = expression_end (input_line_pointer))) { as_bad (_("bad register name: %s"), old_line_pointer); return ERROR_REG_NUM; } input_line_pointer = (char *) next_expr; return reg; } #define PLT_SUFFIX "@PLT" #define plt_suffix "@plt" static void expression_maybe_register (opnd, tok) xtensa_operand opnd; expressionS *tok; { char *kind = xtensa_operand_kind (opnd); if ((strlen (kind) == 1) && (*kind == 'l' || *kind == 'L' || *kind == 'i' || *kind == 'r')) { segT t = expression (tok); if (t == absolute_section && operand_is_pcrel_label (opnd)) { assert (tok->X_op == O_constant); tok->X_op = O_symbol; tok->X_add_symbol = &abs_symbol; } if (tok->X_op == O_symbol && (!strncmp (input_line_pointer, PLT_SUFFIX, strlen (PLT_SUFFIX) - 1) || !strncmp (input_line_pointer, plt_suffix, strlen (plt_suffix) - 1))) { symbol_get_tc (tok->X_add_symbol)->plt = 1; input_line_pointer += strlen (plt_suffix); } } else { unsigned reg = tc_get_register (kind); if (reg != ERROR_REG_NUM) /* Already errored */ { uint32 buf = reg; if ((xtensa_operand_encode (opnd, &buf) != xtensa_encode_result_ok) || (reg != xtensa_operand_decode (opnd, buf))) as_bad (_("register number out of range")); } tok->X_op = O_register; tok->X_add_symbol = 0; tok->X_add_number = reg; } } /* Split up the arguments for an opcode or pseudo-op. */ static int tokenize_arguments (args, str) char **args; char *str; { char *old_input_line_pointer; bfd_boolean saw_comma = FALSE; bfd_boolean saw_arg = FALSE; int num_args = 0; char *arg_end, *arg; int arg_len; /* Save and restore input_line_pointer around this function. */ old_input_line_pointer = input_line_pointer; input_line_pointer = str; while (*input_line_pointer) { SKIP_WHITESPACE (); switch (*input_line_pointer) { case '\0': goto fini; case ',': input_line_pointer++; if (saw_comma || !saw_arg) goto err; saw_comma = TRUE; break; default: if (!saw_comma && saw_arg) goto err; arg_end = input_line_pointer + 1; while (!expression_end (arg_end)) arg_end += 1; arg_len = arg_end - input_line_pointer; arg = (char *) xmalloc (arg_len + 1); args[num_args] = arg; strncpy (arg, input_line_pointer, arg_len); arg[arg_len] = '\0'; input_line_pointer = arg_end; num_args += 1; saw_comma = FALSE; saw_arg = TRUE; break; } } fini: if (saw_comma) goto err; input_line_pointer = old_input_line_pointer; return num_args; err: input_line_pointer = old_input_line_pointer; return -1; } /* 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; { expressionS *tok = insn->tok; xtensa_opcode opcode = insn->opcode; bfd_boolean had_error = TRUE; xtensa_isa isa = xtensa_default_isa; int n; int opcode_operand_count; int actual_operand_count = 0; xtensa_operand opnd = NULL; char *old_input_line_pointer; if (insn->insn_type == ITYPE_LITERAL) opcode_operand_count = 1; else opcode_operand_count = xtensa_num_operands (isa, opcode); memset (tok, 0, sizeof (*tok) * MAX_INSN_ARGS); /* Save and restore input_line_pointer around this function. */ old_input_line_pointer = input_line_pointer; for (n = 0; n < num_args; n++) { input_line_pointer = arg_strings[n]; if (actual_operand_count >= opcode_operand_count) { as_warn (_("too many arguments")); goto err; } assert (actual_operand_count < MAX_INSN_ARGS); opnd = xtensa_get_operand (isa, opcode, actual_operand_count); expression_maybe_register (opnd, tok); if (tok->X_op == O_illegal || tok->X_op == O_absent) goto err; actual_operand_count++; tok++; } insn->ntok = tok - insn->tok; had_error = FALSE; err: input_line_pointer = old_input_line_pointer; return had_error; } static void xg_reverse_shift_count (cnt_argp) char **cnt_argp; { char *cnt_arg, *new_arg; cnt_arg = *cnt_argp; /* replace the argument with "31-(argument)" */ new_arg = (char *) xmalloc (strlen (cnt_arg) + 6); sprintf (new_arg, "31-(%s)", cnt_arg); free (cnt_arg); *cnt_argp = new_arg; } /* If "arg" is a constant expression, return non-zero with the value in *valp. */ static int xg_arg_is_constant (arg, valp) char *arg; offsetT *valp; { expressionS exp; char *save_ptr = input_line_pointer; input_line_pointer = arg; expression (&exp); input_line_pointer = save_ptr; if (exp.X_op == O_constant) { *valp = exp.X_add_number; return 1; } return 0; } static void xg_replace_opname (popname, newop) char **popname; char *newop; { free (*popname); *popname = (char *) xmalloc (strlen (newop) + 1); strcpy (*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; { int num_args = *pnum_args; if (num_args < expected_num) { as_bad (_("not enough operands (%d) for '%s'; expected %d"), num_args, opname, expected_num); return -1; } if (num_args > expected_num) { as_warn (_("too many operands (%d) for '%s'; expected %d"), num_args, opname, expected_num); while (num_args-- > expected_num) { free (arg_strings[num_args]); arg_strings[num_args] = 0; } *pnum_args = expected_num; return -1; } return 0; } static int xg_translate_sysreg_op (popname, pnum_args, arg_strings) char **popname; int *pnum_args; char **arg_strings; { char *opname, *new_opname; offsetT val; bfd_boolean has_underbar = FALSE; opname = *popname; if (*opname == '_') { has_underbar = TRUE; opname += 1; } /* Opname == [rw]ur... */ if (opname[3] == '\0') { /* If the register is not specified as part of the opcode, then get it from the operand and move it to the opcode. */ if (xg_check_num_args (pnum_args, 2, opname, arg_strings)) return -1; if (!xg_arg_is_constant (arg_strings[1], &val)) { as_bad (_("register number for `%s' is not a constant"), opname); return -1; } if ((unsigned) val > 255) { as_bad (_("register number (%ld) for `%s' is out of range"), val, opname); return -1; } /* Remove the last argument, which is now part of the opcode. */ free (arg_strings[1]); arg_strings[1] = 0; *pnum_args = 1; /* Translate the opcode. */ new_opname = (char *) xmalloc (8); sprintf (new_opname, "%s%cur%u", (has_underbar ? "_" : ""), opname[0], (unsigned) val); free (*popname); *popname = new_opname; } return 0; } /* If the instruction is an idiom (i.e., a built-in macro), translate it. 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; { char *opname = *popname; bfd_boolean has_underbar = FALSE; if (*opname == '_') { has_underbar = TRUE; opname += 1; } if (strcmp (opname, "mov") == 0) { if (!has_underbar && code_density_available ()) xg_replace_opname (popname, "mov.n"); else { if (xg_check_num_args (pnum_args, 2, opname, arg_strings)) return -1; xg_replace_opname (popname, (has_underbar ? "_or" : "or")); arg_strings[2] = (char *) xmalloc (strlen (arg_strings[1]) + 1); strcpy (arg_strings[2], arg_strings[1]); *pnum_args = 3; } return 0; } if (strcmp (opname, "bbsi.l") == 0) { if (xg_check_num_args (pnum_args, 3, opname, arg_strings)) return -1; xg_replace_opname (popname, (has_underbar ? "_bbsi" : "bbsi")); if (target_big_endian) xg_reverse_shift_count (&arg_strings[1]); return 0; } if (strcmp (opname, "bbci.l") == 0) { if (xg_check_num_args (pnum_args, 3, opname, arg_strings)) return -1; xg_replace_opname (popname, (has_underbar ? "_bbci" : "bbci")); if (target_big_endian) xg_reverse_shift_count (&arg_strings[1]); return 0; } if (strcmp (opname, "nop") == 0) { if (!has_underbar && code_density_available ()) xg_replace_opname (popname, "nop.n"); else { if (xg_check_num_args (pnum_args, 0, opname, arg_strings)) return -1; xg_replace_opname (popname, (has_underbar ? "_or" : "or")); arg_strings[0] = (char *) xmalloc (3); arg_strings[1] = (char *) xmalloc (3); arg_strings[2] = (char *) xmalloc (3); strcpy (arg_strings[0], "a1"); strcpy (arg_strings[1], "a1"); strcpy (arg_strings[2], "a1"); *pnum_args = 3; } return 0; } if ((opname[0] == 'r' || opname[0] == 'w') && opname[1] == 'u' && opname[2] == 'r') return xg_translate_sysreg_op (popname, pnum_args, arg_strings); /* WIDENING DENSITY OPCODES questionable relaxations (widening) from old "tai" idioms: ADD.N --> ADD BEQZ.N --> BEQZ RET.N --> RET RETW.N --> RETW MOVI.N --> MOVI MOV.N --> MOV NOP.N --> NOP Note: this incomplete list was imported to match the "tai" behavior; other density opcodes are not handled. The xtensa-relax code may know how to do these but it doesn't do anything when these density opcodes appear inside a no-density region. Somehow GAS should either print an error when that happens or do the widening. The old "tai" behavior was to do the widening. For now, I'll make it widen but print a warning. FIXME: GAS needs to detect density opcodes inside no-density regions and treat them as errors. This code should be removed when that is done. */ if (use_generics () && !has_underbar && density_supported && !code_density_available ()) { if (strcmp (opname, "add.n") == 0) xg_replace_opname (popname, "add"); else if (strcmp (opname, "beqz.n") == 0) xg_replace_opname (popname, "beqz"); else if (strcmp (opname, "ret.n") == 0) xg_replace_opname (popname, "ret"); else if (strcmp (opname, "retw.n") == 0) xg_replace_opname (popname, "retw"); else if (strcmp (opname, "movi.n") == 0) xg_replace_opname (popname, "movi"); else if (strcmp (opname, "mov.n") == 0) { if (xg_check_num_args (pnum_args, 2, opname, arg_strings)) return -1; xg_replace_opname (popname, "or"); arg_strings[2] = (char *) xmalloc (strlen (arg_strings[1]) + 1); strcpy (arg_strings[2], arg_strings[1]); *pnum_args = 3; } else if (strcmp (opname, "nop.n") == 0) { if (xg_check_num_args (pnum_args, 0, opname, arg_strings)) return -1; xg_replace_opname (popname, "or"); arg_strings[0] = (char *) xmalloc (3); arg_strings[1] = (char *) xmalloc (3); arg_strings[2] = (char *) xmalloc (3); strcpy (arg_strings[0], "a1"); strcpy (arg_strings[1], "a1"); strcpy (arg_strings[2], "a1"); *pnum_args = 3; } } return 0; } /* Functions for dealing with the Xtensa ISA. */ /* Return true if the given operand is an immed or target instruction, i.e., has a reloc associated with it. Currently, this is only true if the operand kind is "i, "l" or "L". */ static bfd_boolean operand_is_immed (opnd) xtensa_operand opnd; { const char *opkind = xtensa_operand_kind (opnd); if (opkind[0] == '\0' || opkind[1] != '\0') return FALSE; switch (opkind[0]) { case 'i': case 'l': case 'L': return TRUE; } return FALSE; } /* Return true if the given operand is a pc-relative label. This is true for "l", "L", and "r" operand kinds. */ bfd_boolean operand_is_pcrel_label (opnd) xtensa_operand opnd; { const char *opkind = xtensa_operand_kind (opnd); if (opkind[0] == '\0' || opkind[1] != '\0') return FALSE; switch (opkind[0]) { case 'r': case 'l': case 'L': return TRUE; } return FALSE; } /* Currently the assembler only allows us to use a single target per fragment. Because of this, only one operand for a given instruction may be symbolic. If there is an operand of kind "lrL", the last one is chosen. Otherwise, the result is the number of the last operand of type "i", and if there are none of those, we fail and return -1. */ int get_relaxable_immed (opcode) xtensa_opcode opcode; { int last_immed = -1; int noperands, opi; xtensa_operand operand; if (opcode == XTENSA_UNDEFINED) return -1; noperands = xtensa_num_operands (xtensa_default_isa, opcode); for (opi = noperands - 1; opi >= 0; opi--) { operand = xtensa_get_operand (xtensa_default_isa, opcode, opi); if (operand_is_pcrel_label (operand)) return opi; if (last_immed == -1 && operand_is_immed (operand)) last_immed = opi; } return last_immed; } xtensa_opcode get_opcode_from_buf (buf) const char *buf; { static xtensa_insnbuf insnbuf = NULL; xtensa_opcode opcode; xtensa_isa isa = xtensa_default_isa; if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (isa); xtensa_insnbuf_from_chars (isa, insnbuf, buf); opcode = xtensa_decode_insn (isa, insnbuf); return opcode; } static bfd_boolean is_direct_call_opcode (opcode) xtensa_opcode opcode; { if (opcode == XTENSA_UNDEFINED) return FALSE; return (opcode == xtensa_call0_opcode || opcode == xtensa_call4_opcode || opcode == xtensa_call8_opcode || opcode == xtensa_call12_opcode); } static bfd_boolean is_call_opcode (opcode) xtensa_opcode opcode; { if (is_direct_call_opcode (opcode)) return TRUE; if (opcode == XTENSA_UNDEFINED) return FALSE; return (opcode == xtensa_callx0_opcode || opcode == xtensa_callx4_opcode || opcode == xtensa_callx8_opcode || opcode == xtensa_callx12_opcode); } /* Return true if the opcode is an entry opcode. This is used because "entry" adds an implicit ".align 4" and also the entry instruction has an extra check for an operand value. */ static bfd_boolean is_entry_opcode (opcode) xtensa_opcode opcode; { if (opcode == XTENSA_UNDEFINED) return FALSE; return (opcode == xtensa_entry_opcode); } /* Return true if it is one of the loop opcodes. Loops are special because they need automatic alignment and they have a relaxation so complex that we hard-coded it. */ static bfd_boolean is_loop_opcode (opcode) xtensa_opcode opcode; { if (opcode == XTENSA_UNDEFINED) return FALSE; return (opcode == xtensa_loop_opcode || opcode == xtensa_loopnez_opcode || opcode == xtensa_loopgtz_opcode); } static bfd_boolean is_the_loop_opcode (opcode) xtensa_opcode opcode; { if (opcode == XTENSA_UNDEFINED) return FALSE; return (opcode == xtensa_loop_opcode); } static bfd_boolean is_jx_opcode (opcode) xtensa_opcode opcode; { if (opcode == XTENSA_UNDEFINED) return FALSE; return (opcode == xtensa_jx_opcode); } /* Return true if the opcode is a retw or retw.n. Needed to add nops to avoid a hardware interlock issue. */ static bfd_boolean is_windowed_return_opcode (opcode) xtensa_opcode opcode; { if (opcode == XTENSA_UNDEFINED) return FALSE; return (opcode == xtensa_retw_opcode || opcode == xtensa_retw_n_opcode); } /* Return true if the opcode type is "l" and the opcode is NOT a jump. */ static bfd_boolean is_conditional_branch_opcode (opcode) xtensa_opcode opcode; { xtensa_isa isa = xtensa_default_isa; int num_ops, i; if (opcode == xtensa_j_opcode && opcode != XTENSA_UNDEFINED) return FALSE; num_ops = xtensa_num_operands (isa, opcode); for (i = 0; i < num_ops; i++) { xtensa_operand operand = xtensa_get_operand (isa, opcode, i); if (strcmp (xtensa_operand_kind (operand), "l") == 0) return TRUE; } return FALSE; } /* Return true if the given opcode is a conditional branch instruction, i.e., currently this is true if the instruction is a jx or has an operand with 'l' type and is not a loop. */ bfd_boolean is_branch_or_jump_opcode (opcode) xtensa_opcode opcode; { int opn, op_count; if (opcode == XTENSA_UNDEFINED) return FALSE; if (is_loop_opcode (opcode)) return FALSE; if (is_jx_opcode (opcode)) return TRUE; op_count = xtensa_num_operands (xtensa_default_isa, opcode); for (opn = 0; opn < op_count; opn++) { xtensa_operand opnd = xtensa_get_operand (xtensa_default_isa, opcode, opn); const char *opkind = xtensa_operand_kind (opnd); if (opkind && opkind[0] == 'l' && opkind[1] == '\0') return TRUE; } return FALSE; } /* Convert from operand numbers to BFD relocation type code. Return BFD_RELOC_NONE on failure. */ bfd_reloc_code_real_type opnum_to_reloc (opnum) int opnum; { switch (opnum) { case 0: return BFD_RELOC_XTENSA_OP0; case 1: return BFD_RELOC_XTENSA_OP1; case 2: return BFD_RELOC_XTENSA_OP2; default: break; } return BFD_RELOC_NONE; } /* Convert from BFD relocation type code to operand number. Return -1 on failure. */ int reloc_to_opnum (reloc) bfd_reloc_code_real_type reloc; { switch (reloc) { case BFD_RELOC_XTENSA_OP0: return 0; case BFD_RELOC_XTENSA_OP1: return 1; case BFD_RELOC_XTENSA_OP2: return 2; default: break; } return -1; } static void xtensa_insnbuf_set_operand (insnbuf, opcode, operand, value, file, line) xtensa_insnbuf insnbuf; xtensa_opcode opcode; xtensa_operand operand; int32 value; const char *file; unsigned int line; { xtensa_encode_result encode_result; uint32 valbuf = value; encode_result = xtensa_operand_encode (operand, &valbuf); switch (encode_result) { case xtensa_encode_result_ok: break; case xtensa_encode_result_align: as_bad_where ((char *) file, line, _("operand %d not properly aligned for '%s'"), value, xtensa_opcode_name (xtensa_default_isa, opcode)); break; case xtensa_encode_result_not_in_table: as_bad_where ((char *) file, line, _("operand %d not in immediate table for '%s'"), value, xtensa_opcode_name (xtensa_default_isa, opcode)); break; case xtensa_encode_result_too_high: as_bad_where ((char *) file, line, _("operand %d too large for '%s'"), value, xtensa_opcode_name (xtensa_default_isa, opcode)); break; case xtensa_encode_result_too_low: as_bad_where ((char *) file, line, _("operand %d too small for '%s'"), value, xtensa_opcode_name (xtensa_default_isa, opcode)); break; case xtensa_encode_result_not_ok: as_bad_where ((char *) file, line, _("operand %d is invalid for '%s'"), value, xtensa_opcode_name (xtensa_default_isa, opcode)); break; default: abort (); } xtensa_operand_set_field (operand, insnbuf, valbuf); } static uint32 xtensa_insnbuf_get_operand (insnbuf, opcode, opnum) xtensa_insnbuf insnbuf; xtensa_opcode opcode; int opnum; { xtensa_operand op = xtensa_get_operand (xtensa_default_isa, opcode, opnum); return xtensa_operand_decode (op, xtensa_operand_get_field (op, insnbuf)); } static void xtensa_insnbuf_set_immediate_field (opcode, insnbuf, value, file, line) xtensa_opcode opcode; xtensa_insnbuf insnbuf; int32 value; const char *file; unsigned int line; { xtensa_isa isa = xtensa_default_isa; int last_opnd = xtensa_num_operands (isa, opcode) - 1; xtensa_operand operand = xtensa_get_operand (isa, opcode, last_opnd); xtensa_insnbuf_set_operand (insnbuf, opcode, operand, value, file, line); } static bfd_boolean is_negatable_branch (insn) TInsn *insn; { xtensa_isa isa = xtensa_default_isa; int i; int num_ops = xtensa_num_operands (isa, insn->opcode); for (i = 0; i < num_ops; i++) { xtensa_operand opnd = xtensa_get_operand (isa, insn->opcode, i); char *kind = xtensa_operand_kind (opnd); if (strlen (kind) == 1 && *kind == 'l') return TRUE; } return FALSE; } /* Various Other Internal Functions. */ static bfd_boolean is_unique_insn_expansion (r) TransitionRule *r; { if (!r->to_instr || r->to_instr->next != NULL) return FALSE; if (r->to_instr->typ != INSTR_INSTR) return FALSE; return TRUE; } static int xg_get_insn_size (insn) TInsn *insn; { assert (insn->insn_type == ITYPE_INSN); return xtensa_insn_length (xtensa_default_isa, insn->opcode); } static int xg_get_build_instr_size (insn) BuildInstr *insn; { assert (insn->typ == INSTR_INSTR); return xtensa_insn_length (xtensa_default_isa, insn->opcode); } bfd_boolean xg_is_narrow_insn (insn) TInsn *insn; { TransitionTable *table = xg_build_widen_table (); TransitionList *l; int num_match = 0; assert (insn->insn_type == ITYPE_INSN); assert (insn->opcode < table->num_opcodes); for (l = table->table[insn->opcode]; l != NULL; l = l->next) { TransitionRule *rule = l->rule; if (xg_instruction_matches_rule (insn, rule) && is_unique_insn_expansion (rule)) { /* It only generates one instruction... */ assert (insn->insn_type == ITYPE_INSN); /* ...and it is a larger instruction. */ if (xg_get_insn_size (insn) < xg_get_build_instr_size (rule->to_instr)) { num_match++; if (num_match > 1) return FALSE; } } } return (num_match == 1); } bfd_boolean xg_is_single_relaxable_insn (insn) TInsn *insn; { TransitionTable *table = xg_build_widen_table (); TransitionList *l; int num_match = 0; assert (insn->insn_type == ITYPE_INSN); assert (insn->opcode < table->num_opcodes); for (l = table->table[insn->opcode]; l != NULL; l = l->next) { TransitionRule *rule = l->rule; if (xg_instruction_matches_rule (insn, rule) && is_unique_insn_expansion (rule)) { assert (insn->insn_type == ITYPE_INSN); /* ... and it is a larger instruction. */ if (xg_get_insn_size (insn) <= xg_get_build_instr_size (rule->to_instr)) { num_match++; if (num_match > 1) return FALSE; } } } return (num_match == 1); } /* Return the largest size instruction that this instruction can expand to. Currently, in all cases, this is 3 bytes. Of course we could just calculate this once and generate a table. */ int xg_get_max_narrow_insn_size (opcode) xtensa_opcode opcode; { /* Go ahead and compute it, but it better be 3. */ TransitionTable *table = xg_build_widen_table (); TransitionList *l; int old_size = xtensa_insn_length (xtensa_default_isa, opcode); assert (opcode < table->num_opcodes); /* Actually we can do better. Check to see of Only one applies. */ for (l = table->table[opcode]; l != NULL; l = l->next) { TransitionRule *rule = l->rule; /* If it only generates one instruction. */ if (is_unique_insn_expansion (rule)) { int new_size = xtensa_insn_length (xtensa_default_isa, rule->to_instr->opcode); if (new_size > old_size) { assert (new_size == 3); return 3; } } } return old_size; } /* Return the maximum number of bytes this opcode can expand to. */ int xg_get_max_insn_widen_size (opcode) xtensa_opcode opcode; { TransitionTable *table = xg_build_widen_table (); TransitionList *l; int max_size = xtensa_insn_length (xtensa_default_isa, opcode); assert (opcode < table->num_opcodes); for (l = table->table[opcode]; l != NULL; l = l->next) { TransitionRule *rule = l->rule; BuildInstr *build_list; int this_size = 0; if (!rule) continue; build_list = rule->to_instr; if (is_unique_insn_expansion (rule)) { assert (build_list->typ == INSTR_INSTR); this_size = xg_get_max_insn_widen_size (build_list->opcode); } else for (; build_list != NULL; build_list = build_list->next) { switch (build_list->typ) { case INSTR_INSTR: this_size += xtensa_insn_length (xtensa_default_isa, build_list->opcode); break; case INSTR_LITERAL_DEF: case INSTR_LABEL_DEF: default: break; } } if (this_size > max_size) max_size = this_size; } return max_size; } /* Return the maximum number of literal bytes this opcode can generate. */ int xg_get_max_insn_widen_literal_size (opcode) xtensa_opcode opcode; { TransitionTable *table = xg_build_widen_table (); TransitionList *l; int max_size = 0; assert (opcode < table->num_opcodes); for (l = table->table[opcode]; l != NULL; l = l->next) { TransitionRule *rule = l->rule; BuildInstr *build_list; int this_size = 0; if (!rule) continue; build_list = rule->to_instr; if (is_unique_insn_expansion (rule)) { assert (build_list->typ == INSTR_INSTR); this_size = xg_get_max_insn_widen_literal_size (build_list->opcode); } else for (; build_list != NULL; build_list = build_list->next) { switch (build_list->typ) { case INSTR_LITERAL_DEF: /* hard coded 4-byte literal. */ this_size += 4; break; case INSTR_INSTR: case INSTR_LABEL_DEF: default: break; } } if (this_size > max_size) max_size = this_size; } return max_size; } bfd_boolean xg_is_relaxable_insn (insn, lateral_steps) TInsn *insn; int lateral_steps; { int steps_taken = 0; TransitionTable *table = xg_build_widen_table (); TransitionList *l; assert (insn->insn_type == ITYPE_INSN); assert (insn->opcode < table->num_opcodes); for (l = table->table[insn->opcode]; l != NULL; l = l->next) { TransitionRule *rule = l->rule; if (xg_instruction_matches_rule (insn, rule)) { if (steps_taken == lateral_steps) return TRUE; steps_taken++; } } return FALSE; } static symbolS * get_special_literal_symbol () { static symbolS *sym = NULL; if (sym == NULL) sym = symbol_find_or_make ("SPECIAL_LITERAL0\001"); return sym; } static symbolS * get_special_label_symbol () { static symbolS *sym = NULL; if (sym == NULL) sym = symbol_find_or_make ("SPECIAL_LABEL0\001"); return sym; } /* Return true on success. */ bfd_boolean xg_build_to_insn (targ, insn, bi) TInsn *targ; TInsn *insn; BuildInstr *bi; { BuildOp *op; symbolS *sym; memset (targ, 0, sizeof (TInsn)); switch (bi->typ) { case INSTR_INSTR: op = bi->ops; targ->opcode = bi->opcode; targ->insn_type = ITYPE_INSN; targ->is_specific_opcode = FALSE; for (; op != NULL; op = op->next) { int op_num = op->op_num; int op_data = op->op_data; assert (op->op_num < MAX_INSN_ARGS); if (targ->ntok <= op_num) targ->ntok = op_num + 1; switch (op->typ) { case OP_CONSTANT: set_expr_const (&targ->tok[op_num], op_data); break; case OP_OPERAND: assert (op_data < insn->ntok); copy_expr (&targ->tok[op_num], &insn->tok[op_data]); break; case OP_LITERAL: sym = get_special_literal_symbol (); set_expr_symbol_offset (&targ->tok[op_num], sym, 0); break; case OP_LABEL: sym = get_special_label_symbol (); set_expr_symbol_offset (&targ->tok[op_num], sym, 0); break; default: /* currently handles: OP_OPERAND_LOW8 OP_OPERAND_HI24S OP_OPERAND_F32MINUS */ if (xg_has_userdef_op_fn (op->typ)) { assert (op_data < insn->ntok); if (expr_is_const (&insn->tok[op_data])) { long val; copy_expr (&targ->tok[op_num], &insn->tok[op_data]); val = xg_apply_userdef_op_fn (op->typ, targ->tok[op_num]. X_add_number); targ->tok[op_num].X_add_number = val; } else return FALSE; /* We cannot use a relocation for this. */ break; } assert (0); break; } } break; case INSTR_LITERAL_DEF: op = bi->ops; targ->opcode = XTENSA_UNDEFINED; targ->insn_type = ITYPE_LITERAL; targ->is_specific_opcode = FALSE; for (; op != NULL; op = op->next) { int op_num = op->op_num; int op_data = op->op_data; assert (op->op_num < MAX_INSN_ARGS); if (targ->ntok <= op_num) targ->ntok = op_num + 1; switch (op->typ) { case OP_OPERAND: assert (op_data < insn->ntok); copy_expr (&targ->tok[op_num], &insn->tok[op_data]); break; case OP_LITERAL: case OP_CONSTANT: case OP_LABEL: default: assert (0); break; } } break; case INSTR_LABEL_DEF: op = bi->ops; targ->opcode = XTENSA_UNDEFINED; targ->insn_type = ITYPE_LABEL; targ->is_specific_opcode = FALSE; /* Literal with no ops. is a label? */ assert (op == NULL); break; default: assert (0); } return TRUE; } /* Return true on success. */ bfd_boolean xg_build_to_stack (istack, insn, bi) IStack *istack; TInsn *insn; BuildInstr *bi; { for (; bi != NULL; bi = bi->next) { TInsn *next_insn = istack_push_space (istack); if (!xg_build_to_insn (next_insn, insn, bi)) return FALSE; } return TRUE; } /* Return true on valid expansion. */ bfd_boolean xg_expand_to_stack (istack, insn, lateral_steps) IStack *istack; TInsn *insn; int lateral_steps; { int stack_size = istack->ninsn; int steps_taken = 0; TransitionTable *table = xg_build_widen_table (); TransitionList *l; assert (insn->insn_type == ITYPE_INSN); assert (insn->opcode < table->num_opcodes); for (l = table->table[insn->opcode]; l != NULL; l = l->next) { TransitionRule *rule = l->rule; if (xg_instruction_matches_rule (insn, rule)) { if (lateral_steps == steps_taken) { int i; /* This is it. Expand the rule to the stack. */ if (!xg_build_to_stack (istack, insn, rule->to_instr)) return FALSE; /* Check to see if it fits. */ for (i = stack_size; i < istack->ninsn; i++) { TInsn *insn = &istack->insn[i]; if (insn->insn_type == ITYPE_INSN && !tinsn_has_symbolic_operands (insn) && !xg_immeds_fit (insn)) { istack->ninsn = stack_size; return FALSE; } } return TRUE; } steps_taken++; } } return FALSE; } bfd_boolean xg_expand_narrow (targ, insn) TInsn *targ; TInsn *insn; { TransitionTable *table = xg_build_widen_table (); TransitionList *l; assert (insn->insn_type == ITYPE_INSN); assert (insn->opcode < table->num_opcodes); for (l = table->table[insn->opcode]; l != NULL; l = l->next) { TransitionRule *rule = l->rule; if (xg_instruction_matches_rule (insn, rule) && is_unique_insn_expansion (rule)) { /* Is it a larger instruction? */ if (xg_get_insn_size (insn) <= xg_get_build_instr_size (rule->to_instr)) { xg_build_to_insn (targ, insn, rule->to_instr); return FALSE; } } } 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; { int i; int n = insn->ntok; assert (insn->insn_type == ITYPE_INSN); for (i = 0; i < n; ++i) { const expressionS *expr = &insn->tok[i]; xtensa_operand opnd = xtensa_get_operand (xtensa_default_isa, insn->opcode, i); if (!operand_is_immed (opnd)) continue; switch (expr->X_op) { case O_register: case O_constant: { if (xg_check_operand (expr->X_add_number, opnd)) 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; { symbolS *symbolP; offsetT target, pc, 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]; xtensa_operand opnd = xtensa_get_operand (xtensa_default_isa, insn->opcode, i); if (!operand_is_immed (opnd)) continue; switch (expr->X_op) { case O_register: case O_constant: if (xg_check_operand (expr->X_add_number, opnd)) 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 in the same segment as the PC.... */ if (!xtensa_operand_isPCRelative (opnd) || S_GET_SEGMENT (expr->X_add_symbol) != pc_seg) return FALSE; symbolP = expr->X_add_symbol; 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 && is_dnrange (pc_frag, symbolP, stretch)) target += stretch; new_offset = xtensa_operand_do_reloc (opnd, target, pc); if (xg_check_operand (new_offset, opnd)) 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, operand) int32 value; xtensa_operand operand; { uint32 valbuf = value; return (xtensa_operand_encode (operand, &valbuf) != xtensa_encode_result_ok); } /* Check if a symbol is pointing to somewhere after the start frag, given that the segment has stretched by stretch during relaxation. This is more complicated than it might appear at first blush because of the stretching that goes on. Here is how the check works: If the symbol and the frag are in the same segment, then the symbol could be down range. Note that this function assumes that start_frag is in now_seg. If the symbol is pointing to a frag with an address greater than than the start_frag's address, then it _could_ be down range. The problem comes because target_frag may or may not have had stretch bytes added to its address already, depending on if it is before or after start frag. (And if we knew that, then we wouldn't need this function.) start_frag has definitely already had stretch bytes added to its address. If target_frag's address hasn't been adjusted yet, then to determine if it comes after start_frag, we need to subtract stretch from start_frag's address. If target_frag's address has been adjusted, then it might have been adjusted such that it comes after start_frag's address minus stretch bytes. So, in that case, we scan for it down stream to within stretch bytes. We could search to the end of the fr_chain, but that ends up taking too much time (over a minute on some gnu tests). */ int is_dnrange (start_frag, sym, stretch) fragS *start_frag; symbolS *sym; long stretch; { if (S_GET_SEGMENT (sym) == now_seg) { fragS *cur_frag = symbol_get_frag (sym); if (cur_frag->fr_address >= start_frag->fr_address - stretch) { int distance = stretch; while (cur_frag && distance >= 0) { distance -= cur_frag->fr_fix; if (cur_frag == start_frag) return 0; cur_frag = cur_frag->fr_next; } return 1; } } return 0; } /* 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. */ { int steps_taken = 0; /* assert (has no symbolic operands) Some of its immeds don't fit. Try to build a relaxed version. This may go through a couple of stages of single instruction transformations before we get there. */ TInsn single_target; TInsn current_insn; int lateral_steps = 0; int istack_size = istack->ninsn; if (xg_symbolic_immeds_fit (insn, pc_seg, pc_frag, pc_offset, stretch) && steps_taken >= min_steps) { istack_push (istack, insn); return steps_taken; } tinsn_copy (¤t_insn, insn); /* Walk through all of the single instruction expansions. */ while (xg_is_single_relaxable_insn (¤t_insn)) { int error_val = xg_expand_narrow (&single_target, ¤t_insn); assert (!error_val); if (xg_symbolic_immeds_fit (&single_target, pc_seg, pc_frag, pc_offset, stretch)) { steps_taken++; if (steps_taken >= min_steps) { istack_push (istack, &single_target); return steps_taken; } } tinsn_copy (¤t_insn, &single_target); } /* Now check for a multi-instruction expansion. */ while (xg_is_relaxable_insn (¤t_insn, lateral_steps)) { if (xg_symbolic_immeds_fit (¤t_insn, pc_seg, pc_frag, pc_offset, stretch)) { if (steps_taken >= min_steps) { istack_push (istack, ¤t_insn); return steps_taken; } } steps_taken++; if (xg_expand_to_stack (istack, ¤t_insn, lateral_steps)) { if (steps_taken >= min_steps) return steps_taken; } lateral_steps++; istack->ninsn = istack_size; } /* It's not going to work -- use the original. */ istack_push (istack, insn); return steps_taken; } static void xg_force_frag_space (size) 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" functions. */ frag_grow (size); } void xg_finish_frag (last_insn, state, max_growth, is_insn) char *last_insn; enum xtensa_relax_statesE 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 and start a new one. In either case, return a pointer to the beginning of the growth area. */ fragS *old_frag; xg_force_frag_space (max_growth); old_frag = frag_now; frag_now->fr_opcode = last_insn; if (is_insn) frag_now->tc_frag_data.is_insn = TRUE; frag_var (rs_machine_dependent, max_growth, max_growth, state, frag_now->fr_symbol, frag_now->fr_offset, last_insn); /* Just to make sure that we did not split it up. */ assert (old_frag->fr_next == frag_now); } static bfd_boolean is_branch_jmp_to_next (insn, fragP) TInsn *insn; fragS *fragP; { xtensa_isa isa = xtensa_default_isa; int i; int num_ops = xtensa_num_operands (isa, insn->opcode); int target_op = -1; symbolS *sym; fragS *target_frag; if (is_loop_opcode (insn->opcode)) return FALSE; for (i = 0; i < num_ops; i++) { xtensa_operand opnd = xtensa_get_operand (isa, insn->opcode, i); char *kind = xtensa_operand_kind (opnd); if (strlen (kind) == 1 && *kind == 'l') { target_op = i; break; } } if (target_op == -1) return FALSE; if (insn->ntok <= target_op) return FALSE; if (insn->tok[target_op].X_op != O_symbol) return FALSE; sym = insn->tok[target_op].X_add_symbol; if (sym == NULL) return FALSE; if (insn->tok[target_op].X_add_number != 0) return FALSE; target_frag = symbol_get_frag (sym); if (target_frag == NULL) return FALSE; if (is_next_frag_target (fragP->fr_next, target_frag) && S_GET_VALUE (sym) == target_frag->fr_address) return TRUE; return FALSE; } static void xg_add_branch_and_loop_targets (insn) TInsn *insn; { xtensa_isa isa = xtensa_default_isa; int num_ops = xtensa_num_operands (isa, insn->opcode); if (is_loop_opcode (insn->opcode)) { int i = 1; xtensa_operand opnd = xtensa_get_operand (isa, insn->opcode, i); char *kind = xtensa_operand_kind (opnd); if (strlen (kind) == 1 && *kind == 'l') if (insn->tok[i].X_op == O_symbol) symbol_get_tc (insn->tok[i].X_add_symbol)->is_loop_target = TRUE; return; } /* Currently, we do not add branch targets. This is an optimization for later that tries to align only branch targets, not just any label in a text section. */ if (align_only_targets) { int i; for (i = 0; i < insn->ntok && i < num_ops; i++) { xtensa_operand opnd = xtensa_get_operand (isa, insn->opcode, i); char *kind = xtensa_operand_kind (opnd); if (strlen (kind) == 1 && *kind == 'l' && insn->tok[i].X_op == O_symbol) { symbolS *sym = insn->tok[i].X_add_symbol; symbol_get_tc (sym)->is_branch_target = TRUE; if (S_IS_DEFINED (sym)) symbol_get_frag (sym)->tc_frag_data.is_branch_target = 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)) return FALSE; 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; } 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; } } return TRUE; } TransitionRule * xg_instruction_match (insn) TInsn *insn; { TransitionTable *table = xg_build_simplify_table (); 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; { int num_ops = 0; BuildOp *b_op; switch (instr_spec->typ) { case INSTR_INSTR: new_insn->insn_type = ITYPE_INSN; new_insn->opcode = instr_spec->opcode; new_insn->is_specific_opcode = FALSE; break; case INSTR_LITERAL_DEF: new_insn->insn_type = ITYPE_LITERAL; new_insn->opcode = XTENSA_UNDEFINED; new_insn->is_specific_opcode = FALSE; break; case INSTR_LABEL_DEF: as_bad (_("INSTR_LABEL_DEF not supported yet")); break; } for (b_op = instr_spec->ops; b_op != NULL; b_op = b_op->next) { expressionS *exp; const expressionS *src_exp; num_ops++; switch (b_op->typ) { case OP_CONSTANT: /* The expression must be the constant. */ assert (b_op->op_num < MAX_INSN_ARGS); exp = &new_insn->tok[b_op->op_num]; set_expr_const (exp, b_op->op_data); break; case OP_OPERAND: assert (b_op->op_num < MAX_INSN_ARGS); assert (b_op->op_data < (unsigned) old_insn->ntok); src_exp = &old_insn->tok[b_op->op_data]; exp = &new_insn->tok[b_op->op_num]; copy_expr (exp, src_exp); break; case OP_LITERAL: case OP_LABEL: as_bad (_("can't handle generation of literal/labels yet")); assert (0); default: as_bad (_("can't handle undefined OP TYPE")); assert (0); } } new_insn->ntok = num_ops; return FALSE; } /* Return true if it was simplified. */ bfd_boolean xg_simplify_insn (old_insn, new_insn) TInsn *old_insn; TInsn *new_insn; { TransitionRule *rule = xg_instruction_match (old_insn); BuildInstr *insn_spec; if (rule == NULL) return FALSE; insn_spec = rule->to_instr; /* There should only be one. */ assert (insn_spec != NULL); assert (insn_spec->next == NULL); if (insn_spec->next != NULL) return FALSE; xg_build_token_insn (insn_spec, old_insn, new_insn); return TRUE; } /* xg_expand_assembly_insn: (1) Simplify the instruction, i.e., l32i -> l32i.n. (2) Check the number of operands. (3) Place the instruction tokens into the stack or if we can relax it at assembly time, place multiple instructions/literals onto the stack. Return false if no error. */ static bfd_boolean xg_expand_assembly_insn (istack, orig_insn) IStack *istack; TInsn *orig_insn; { int noperands; TInsn new_insn; memset (&new_insn, 0, sizeof (TInsn)); /* On return, we will be using the "use_tokens" with "use_ntok". This will reduce things like addi to addi.n. */ if (code_density_available () && !orig_insn->is_specific_opcode) { if (xg_simplify_insn (orig_insn, &new_insn)) orig_insn = &new_insn; } noperands = xtensa_num_operands (xtensa_default_isa, orig_insn->opcode); if (orig_insn->ntok < noperands) { as_bad (_("found %d operands for '%s': Expected %d"), orig_insn->ntok, xtensa_opcode_name (xtensa_default_isa, orig_insn->opcode), noperands); return TRUE; } if (orig_insn->ntok > noperands) as_warn (_("found too many (%d) operands for '%s': Expected %d"), orig_insn->ntok, xtensa_opcode_name (xtensa_default_isa, orig_insn->opcode), noperands); /* If there are not enough operands, we will assert above. If there are too many, just cut out the extras here. */ orig_insn->ntok = noperands; /* Cases: Instructions with all constant immeds: Assemble them and relax the instruction if possible. Give error if not possible; no fixup needed. Instructions with symbolic immeds: Assemble them with a Fix up (that may cause instruction expansion). Also close out the fragment if the fixup may cause instruction expansion. There are some other special cases where we need alignment. 1) before certain instructions with required alignment (OPCODE_ALIGN) 2) before labels that have jumps (LABEL_ALIGN) 3) after call instructions (RETURN_ALIGN) Multiple of these may be possible on the same fragment. If so, make sure to satisfy the required alignment. Then try to get the desired alignment. */ if (tinsn_has_invalid_symbolic_operands (orig_insn)) return TRUE; if (orig_insn->is_specific_opcode || !can_relax ()) { istack_push (istack, orig_insn); return FALSE; } if (tinsn_has_symbolic_operands (orig_insn)) { if (tinsn_has_complex_operands (orig_insn)) xg_assembly_relax (istack, orig_insn, 0, 0, 0, 0, 0); else istack_push (istack, orig_insn); } else { if (xg_immeds_fit (orig_insn)) istack_push (istack, orig_insn); else xg_assembly_relax (istack, orig_insn, 0, 0, 0, 0, 0); } #if 0 for (i = 0; i < istack->ninsn; i++) { if (xg_simplify_insn (&new_insn, &istack->insn[i])) istack->insn[i] = new_insn; } #endif return FALSE; } /* Currently all literals that are generated here are 32-bit L32R targets. */ symbolS * xg_assemble_literal (insn) /* const */ TInsn *insn; { emit_state state; symbolS *lit_sym = NULL; /* size = 4 for L32R. It could easily be larger when we move to larger constants. Add a parameter later. */ offsetT litsize = 4; offsetT litalign = 2; /* 2^2 = 4 */ expressionS saved_loc; set_expr_symbol_offset (&saved_loc, frag_now->fr_symbol, frag_now_fix ()); assert (insn->insn_type == ITYPE_LITERAL); assert (insn->ntok = 1); /* must be only one token here */ xtensa_switch_to_literal_fragment (&state); /* Force a 4-byte align here. Note that this opens a new frag, so all literals done with this function have a frag to themselves. That's important for the way text section literals work. */ frag_align (litalign, 0, 0); emit_expr (&insn->tok[0], litsize); assert (frag_now->tc_frag_data.literal_frag == NULL); frag_now->tc_frag_data.literal_frag = get_literal_pool_location (now_seg); frag_now->fr_symbol = xtensa_create_literal_symbol (now_seg, frag_now); lit_sym = frag_now->fr_symbol; frag_now->tc_frag_data.is_literal = TRUE; /* Go back. */ xtensa_restore_emit_state (&state); return lit_sym; } static void xg_assemble_literal_space (size) /* const */ int size; { emit_state state; /* We might have to do something about this alignment. It only takes effect if something is placed here. */ offsetT litalign = 2; /* 2^2 = 4 */ fragS *lit_saved_frag; expressionS saved_loc; assert (size % 4 == 0); set_expr_symbol_offset (&saved_loc, frag_now->fr_symbol, frag_now_fix ()); xtensa_switch_to_literal_fragment (&state); /* Force a 4-byte align here. */ frag_align (litalign, 0, 0); xg_force_frag_space (size); lit_saved_frag = frag_now; frag_now->tc_frag_data.literal_frag = get_literal_pool_location (now_seg); frag_now->tc_frag_data.is_literal = TRUE; frag_now->fr_symbol = xtensa_create_literal_symbol (now_seg, frag_now); xg_finish_frag (0, RELAX_LITERAL, size, FALSE); /* Go back. */ xtensa_restore_emit_state (&state); frag_now->tc_frag_data.literal_frag = lit_saved_frag; } 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); } /* Emit an instruction to the current fragment. If record_fix is true, then this instruction will not change and we can go ahead and record the fixup. If record_fix is false, then the instruction may change and we are going to close out this fragment. Go ahead and set the fr_symbol and fr_offset instead of adding a fixup. */ static bfd_boolean xg_emit_insn (t_insn, record_fix) TInsn *t_insn; bfd_boolean record_fix; { bfd_boolean ok = TRUE; xtensa_isa isa = xtensa_default_isa; xtensa_opcode opcode = t_insn->opcode; bfd_boolean has_fixup = FALSE; int noperands; int i, byte_count; fragS *oldfrag; size_t old_size; char *f; static xtensa_insnbuf insnbuf = NULL; /* Use a static pointer to the insn buffer so we don't have to call malloc each time through. */ if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa); has_fixup = tinsn_to_insnbuf (t_insn, insnbuf); noperands = xtensa_num_operands (isa, opcode); assert (noperands == t_insn->ntok); byte_count = xtensa_insn_length (isa, opcode); oldfrag = frag_now; /* This should NEVER cause us to jump into a new frag; we've already reserved space. */ old_size = frag_now_fix (); f = frag_more (byte_count); assert (oldfrag == frag_now); /* This needs to generate a record that lists the parts that are instructions. */ if (!frag_now->tc_frag_data.is_insn) { /* If we are at the beginning of a fragment, switch this fragment to an instruction fragment. */ if (now_seg != absolute_section && old_size != 0) as_warn (_("instruction fragment may contain data")); frag_now->tc_frag_data.is_insn = TRUE; } xtensa_insnbuf_to_chars (isa, insnbuf, f); dwarf2_emit_insn (byte_count); /* Now spit out the opcode fixup.... */ if (!has_fixup) return !ok; for (i = 0; i < noperands; ++i) { expressionS *expr = &t_insn->tok[i]; switch (expr->X_op) { case O_symbol: if (get_relaxable_immed (opcode) == i) { if (record_fix) { if (!xg_add_opcode_fix (opcode, i, expr, frag_now, f - frag_now->fr_literal)) ok = FALSE; } else { /* Write it to the fr_offset, fr_symbol. */ frag_now->fr_symbol = expr->X_add_symbol; frag_now->fr_offset = expr->X_add_number; } } else { as_bad (_("invalid operand %d on '%s'"), i, xtensa_opcode_name (isa, opcode)); ok = FALSE; } break; case O_constant: case O_register: break; default: as_bad (_("invalid expression for operand %d on '%s'"), i, xtensa_opcode_name (isa, opcode)); ok = FALSE; break; } } return !ok; } static bfd_boolean xg_emit_insn_to_buf (t_insn, buf, fragP, offset, build_fix) TInsn *t_insn; 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 (t_insn, insnbuf); if (has_symbolic_immed && build_fix) { /* Add a fixup. */ int opnum = get_relaxable_immed (t_insn->opcode); expressionS *exp = &t_insn->tok[opnum]; if (!xg_add_opcode_fix (t_insn->opcode, opnum, exp, fragP, offset)) ok = FALSE; } fragP->tc_frag_data.is_insn = TRUE; xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf, buf); return ok; } /* Put in a fixup record based on the opcode. Return true on success. */ bfd_boolean xg_add_opcode_fix (opcode, opnum, expr, fragP, offset) xtensa_opcode opcode; int opnum; expressionS *expr; fragS *fragP; offsetT offset; { bfd_reloc_code_real_type reloc; reloc_howto_type *howto; int insn_length; fixS *the_fix; reloc = opnum_to_reloc (opnum); if (reloc == BFD_RELOC_NONE) { as_bad (_("invalid relocation operand %i on '%s'"), opnum, xtensa_opcode_name (xtensa_default_isa, opcode)); return FALSE; } howto = bfd_reloc_type_lookup (stdoutput, reloc); if (!howto) { as_bad (_("undefined symbol for opcode \"%s\"."), xtensa_opcode_name (xtensa_default_isa, opcode)); return FALSE; } insn_length = xtensa_insn_length (xtensa_default_isa, opcode); the_fix = fix_new_exp (fragP, offset, insn_length, expr, howto->pc_relative, reloc); if (expr->X_add_symbol && (S_IS_EXTERNAL (expr->X_add_symbol) || S_IS_WEAK (expr->X_add_symbol))) the_fix->fx_plt = TRUE; return TRUE; } void xg_resolve_literals (insn, lit_sym) TInsn *insn; symbolS *lit_sym; { symbolS *sym = get_special_literal_symbol (); int i; if (lit_sym == 0) return; assert (insn->insn_type == ITYPE_INSN); for (i = 0; i < insn->ntok; i++) if (insn->tok[i].X_add_symbol == sym) insn->tok[i].X_add_symbol = lit_sym; } void xg_resolve_labels (insn, label_sym) TInsn *insn; symbolS *label_sym; { symbolS *sym = get_special_label_symbol (); int i; /* assert(!insn->is_literal); */ for (i = 0; i < insn->ntok; i++) if (insn->tok[i].X_add_symbol == sym) insn->tok[i].X_add_symbol = label_sym; } static void xg_assemble_tokens (insn) /*const */ TInsn *insn; { /* By the time we get here, there's not too much left to do. 1) Check our assumptions. 2) Check if the current instruction is "narrow". If so, then finish the frag, create another one. We could also go back to change some previous "narrow" frags into no-change ones if we have more than MAX_NARROW_ALIGNMENT of them without alignment restrictions between them. Cases: 1) It has constant operands and doesn't fit. Go ahead and assemble it so it will fail. 2) It has constant operands that fit. If narrow and !is_specific_opcode, assemble it and put in a relocation else assemble it. 3) It has a symbolic immediate operand a) Find the worst-case relaxation required b) Find the worst-case literal pool space required. Insert appropriate alignment & space in the literal. Assemble it. Add the relocation. */ assert (insn->insn_type == ITYPE_INSN); if (!tinsn_has_symbolic_operands (insn)) { if (xg_is_narrow_insn (insn) && !insn->is_specific_opcode) { /* assemble it but add max required space */ int max_size = xg_get_max_narrow_insn_size (insn->opcode); int min_size = xg_get_insn_size (insn); char *last_insn; assert (max_size == 3); /* make sure we have enough space to widen it */ xg_force_frag_space (max_size); /* Output the instruction. It may cause an error if some operands do not fit. */ last_insn = frag_more (0); if (xg_emit_insn (insn, TRUE)) as_warn (_("instruction with constant operands does not fit")); xg_finish_frag (last_insn, RELAX_NARROW, max_size - min_size, TRUE); } else { /* Assemble it. No relocation needed. */ int max_size = xg_get_insn_size (insn); xg_force_frag_space (max_size); if (xg_emit_insn (insn, FALSE)) as_warn (_("instruction with constant operands does not " "fit without widening")); /* frag_more (max_size); */ /* Special case for jx. If the jx is the next to last instruction in a loop, we will add a NOP after it. This avoids a hardware issue that could occur if the jx jumped to the next instruction. */ if (software_avoid_b_j_loop_end && is_jx_opcode (insn->opcode)) { maybe_has_b_j_loop_end = TRUE; /* add 2 of these */ frag_now->tc_frag_data.is_insn = TRUE; frag_var (rs_machine_dependent, 4, 4, RELAX_ADD_NOP_IF_PRE_LOOP_END, frag_now->fr_symbol, frag_now->fr_offset, NULL); } } } else { /* Need to assemble it with space for the relocation. */ if (!insn->is_specific_opcode) { /* Assemble it but add max required space. */ char *last_insn; int min_size = xg_get_insn_size (insn); int max_size = xg_get_max_insn_widen_size (insn->opcode); int max_literal_size = xg_get_max_insn_widen_literal_size (insn->opcode); #if 0 symbolS *immed_sym = xg_get_insn_immed_symbol (insn); set_frag_segment (frag_now, now_seg); #endif /* 0 */ /* Make sure we have enough space to widen the instruction. This may open a new fragment. */ xg_force_frag_space (max_size); if (max_literal_size != 0) xg_assemble_literal_space (max_literal_size); /* Output the instruction. It may cause an error if some operands do not fit. Emit the incomplete instruction. */ last_insn = frag_more (0); xg_emit_insn (insn, FALSE); xg_finish_frag (last_insn, RELAX_IMMED, max_size - min_size, TRUE); /* Special cases for loops: close_loop_end should be inserted AFTER short_loop. Make sure that CLOSE loops are processed BEFORE short_loops when converting them. */ /* "short_loop": add a NOP if the loop is < 4 bytes. */ if (software_avoid_short_loop && is_loop_opcode (insn->opcode)) { maybe_has_short_loop = TRUE; frag_now->tc_frag_data.is_insn = TRUE; frag_var (rs_machine_dependent, 4, 4, RELAX_ADD_NOP_IF_SHORT_LOOP, frag_now->fr_symbol, frag_now->fr_offset, NULL); frag_now->tc_frag_data.is_insn = TRUE; frag_var (rs_machine_dependent, 4, 4, RELAX_ADD_NOP_IF_SHORT_LOOP, frag_now->fr_symbol, frag_now->fr_offset, NULL); } /* "close_loop_end": Add up to 12 bytes of NOPs to keep a loop at least 12 bytes away from another loop's loop end. */ if (software_avoid_close_loop_end && is_loop_opcode (insn->opcode)) { maybe_has_close_loop_end = TRUE; frag_now->tc_frag_data.is_insn = TRUE; frag_var (rs_machine_dependent, 12, 12, RELAX_ADD_NOP_IF_CLOSE_LOOP_END, frag_now->fr_symbol, frag_now->fr_offset, NULL); } } else { /* Assemble it in place. No expansion will be required, but we'll still need a relocation record. */ int max_size = xg_get_insn_size (insn); xg_force_frag_space (max_size); if (xg_emit_insn (insn, TRUE)) as_warn (_("instruction's constant operands do not fit")); } } } /* Return true if the instruction can write to the specified integer register. */ static bfd_boolean is_register_writer (insn, regset, regnum) const TInsn *insn; const char *regset; int regnum; { int i; int num_ops; xtensa_isa isa = xtensa_default_isa; num_ops = xtensa_num_operands (isa, insn->opcode); for (i = 0; i < num_ops; i++) { xtensa_operand operand = xtensa_get_operand (isa, insn->opcode, i); char inout = xtensa_operand_inout (operand); if (inout == '>' || inout == '=') { if (strcmp (xtensa_operand_kind (operand), regset) == 0) { if ((insn->tok[i].X_op == O_register) && (insn->tok[i].X_add_number == regnum)) return TRUE; } } } return FALSE; } static bfd_boolean is_bad_loopend_opcode (tinsn) const TInsn * tinsn; { xtensa_opcode opcode = tinsn->opcode; if (opcode == XTENSA_UNDEFINED) return FALSE; if (opcode == xtensa_call0_opcode || opcode == xtensa_callx0_opcode || opcode == xtensa_call4_opcode || opcode == xtensa_callx4_opcode || opcode == xtensa_call8_opcode || opcode == xtensa_callx8_opcode || opcode == xtensa_call12_opcode || opcode == xtensa_callx12_opcode || opcode == xtensa_isync_opcode || opcode == xtensa_ret_opcode || opcode == xtensa_ret_n_opcode || opcode == xtensa_retw_opcode || opcode == xtensa_retw_n_opcode || opcode == xtensa_waiti_opcode) return TRUE; /* An RSR of LCOUNT is illegal as the last opcode in a loop. */ if (opcode == xtensa_rsr_opcode && tinsn->ntok >= 2 && tinsn->tok[1].X_op == O_constant && tinsn->tok[1].X_add_number == 2) return TRUE; return FALSE; } /* Labels that begin with ".Ln" or ".LM" are unaligned. This allows the debugger to add unaligned labels. 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; { const char *name = S_GET_NAME (sym); static size_t fake_size = 0; if (name && name[0] == '.' && name[1] == 'L' && (name[2] == 'n' || name[2] == 'M')) return TRUE; /* FAKE_LABEL_NAME followed by "F", "L" or "endfunc" */ if (fake_size == 0) fake_size = strlen (FAKE_LABEL_NAME); if (name && strncmp (FAKE_LABEL_NAME, name, fake_size) == 0 && (name[fake_size] == 'F' || name[fake_size] == 'L' || (name[fake_size] == 'e' && strncmp ("endfunc", name+fake_size, 7) == 0))) return TRUE; return FALSE; } fragS * next_non_empty_frag (fragP) const fragS *fragP; { fragS *next_fragP = fragP->fr_next; /* Sometimes an empty will end up here due storage allocation issues. So we have to skip until we find something legit. */ while (next_fragP && next_fragP->fr_fix == 0) next_fragP = next_fragP->fr_next; if (next_fragP == NULL || next_fragP->fr_fix == 0) return NULL; return next_fragP; } xtensa_opcode next_frag_opcode (fragP) const fragS * fragP; { const fragS *next_fragP = next_non_empty_frag (fragP); static xtensa_insnbuf insnbuf = NULL; xtensa_isa isa = xtensa_default_isa; if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (isa); if (next_fragP == NULL) return XTENSA_UNDEFINED; xtensa_insnbuf_from_chars (isa, insnbuf, next_fragP->fr_literal); return xtensa_decode_insn (isa, insnbuf); } /* 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; { 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; } /* If the next legit fragment is an end-of-loop marker, switch its state so it will instantiate a NOP. */ static void update_next_frag_nop_state (fragP) fragS *fragP; { fragS *next_fragP = fragP->fr_next; while (next_fragP && next_fragP->fr_fix == 0) { if (next_fragP->fr_type == rs_machine_dependent && next_fragP->fr_subtype == RELAX_LOOP_END) { next_fragP->fr_subtype = RELAX_LOOP_END_ADD_NOP; return; } next_fragP = next_fragP->fr_next; } } static bfd_boolean next_frag_is_branch_target (fragP) const fragS *fragP; { /* Sometimes an empty will end up here due storage allocation issues, so we have to skip until we find something legit. */ for (fragP = fragP->fr_next; fragP; fragP = fragP->fr_next) { if (fragP->tc_frag_data.is_branch_target) return TRUE; if (fragP->fr_fix != 0) break; } return FALSE; } static bfd_boolean next_frag_is_loop_target (fragP) const fragS *fragP; { /* Sometimes an empty will end up here due storage allocation issues. So we have to skip until we find something legit. */ for (fragP = fragP->fr_next; fragP; fragP = fragP->fr_next) { if (fragP->tc_frag_data.is_loop_target) return TRUE; if (fragP->fr_fix != 0) break; } return FALSE; } static addressT next_frag_pre_opcode_bytes (fragp) const fragS *fragp; { const fragS *next_fragp = fragp->fr_next; xtensa_opcode next_opcode = next_frag_opcode (fragp); if (!is_loop_opcode (next_opcode)) return 0; /* Sometimes an empty will end up here due storage allocation issues. So we have to skip until we find something legit. */ while (next_fragp->fr_fix == 0) next_fragp = next_fragp->fr_next; if (next_fragp->fr_type != rs_machine_dependent) return 0; /* There is some implicit knowledge encoded in here. The LOOP instructions that are NOT RELAX_IMMED have been relaxed. */ if (next_fragp->fr_subtype > RELAX_IMMED) return get_expanded_loop_offset (next_opcode); return 0; } /* Mark a location where we can later insert literal frags. Update the section's literal_pool_loc, so subsequent literals can be placed nearest to their use. */ static void xtensa_mark_literal_pool_location () { /* Any labels pointing to the current location need to be adjusted to after the literal pool. */ emit_state s; fragS *pool_location; frag_align (2, 0, 0); /* We stash info in the fr_var of these frags so we can later move the literal's fixes into this frchain's fix list. We can use fr_var because fr_var's interpretation depends solely on the fr_type and subtype. */ pool_location = frag_now; frag_variant (rs_machine_dependent, 0, (int) frchain_now, RELAX_LITERAL_POOL_BEGIN, NULL, 0, NULL); frag_variant (rs_machine_dependent, 0, (int) now_seg, RELAX_LITERAL_POOL_END, NULL, 0, NULL); /* Now put a frag into the literal pool that points to this location. */ set_literal_pool_location (now_seg, pool_location); xtensa_switch_to_literal_fragment (&s); /* Close whatever frag is there. */ frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL); frag_now->tc_frag_data.literal_frag = pool_location; frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL); xtensa_restore_emit_state (&s); } /* 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 loopend: loop a2, loopend2 would become: loop a0, loopend nop.n <===== bad! loopend: loop a2, loopend2 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 == 0) { S_SET_VALUE (lit_sym, new_offset); symbol_set_frag (lit_sym, new_frag); } } } /* 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 xtensa_insnbuf insnbuf = NULL; TInsn t_insn; if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa); tinsn_init (&t_insn); switch (size) { case 2: t_insn.opcode = xtensa_nop_n_opcode; t_insn.ntok = 0; if (t_insn.opcode == XTENSA_UNDEFINED) as_fatal (_("opcode 'NOP.N' unavailable in this configuration")); tinsn_to_insnbuf (&t_insn, insnbuf); xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf, buf); break; case 3: t_insn.opcode = xtensa_or_opcode; assert (t_insn.opcode != XTENSA_UNDEFINED); if (t_insn.opcode == XTENSA_UNDEFINED) as_fatal (_("opcode 'OR' unavailable in this configuration")); set_expr_const (&t_insn.tok[0], 1); set_expr_const (&t_insn.tok[1], 1); set_expr_const (&t_insn.tok[2], 1); t_insn.ntok = 3; tinsn_to_insnbuf (&t_insn, insnbuf); xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf, buf); break; default: as_fatal (_("invalid %d-byte NOP requested"), size); } } /* Return the number of bytes for the offset of the expanded loop instruction. This should be incorporated into the relaxation specification but is hard-coded here. This is used to auto-align the loop instruction. It is invalid to call this function if the configuration does not have loops or if the opcode is not a loop opcode. */ static addressT get_expanded_loop_offset (opcode) 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 expansion. It will be validated on fragment conversion. */ if (opcode == XTENSA_UNDEFINED) as_fatal (_("get_expanded_loop_offset: undefined opcode")); if (opcode == xtensa_loop_opcode) return 0; if (opcode == xtensa_loopnez_opcode) return 3; if (opcode == xtensa_loopgtz_opcode) return 6; as_fatal (_("get_expanded_loop_offset: invalid opcode")); return 0; } fragS * get_literal_pool_location (seg) 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; { seg_info (seg)->tc_segment_info_data.literal_pool_loc = literal_pool_loc; } /* External Functions and Other GAS Hooks. */ const char * xtensa_target_format () { return (target_big_endian ? "elf32-xtensa-be" : "elf32-xtensa-le"); } void xtensa_file_arch_init (abfd) bfd *abfd; { bfd_set_private_flags (abfd, 0x100 | 0x200); } void md_number_to_chars (buf, val, n) char *buf; valueT val; int n; { if (target_big_endian) number_to_chars_bigendian (buf, val, n); else number_to_chars_littleendian (buf, val, n); } /* This function is called once, at assembler startup time. It should set up all the tables, etc. that the MD part of the assembler will need. */ void md_begin () { segT current_section = now_seg; int current_subsec = now_subseg; xtensa_isa isa; #if STATIC_LIBISA isa = xtensa_isa_init (); #else /* ISA was already initialized by xtensa_init(). */ isa = xtensa_default_isa; #endif /* Set up the .literal, .fini.literal and .init.literal sections. */ memset (&default_lit_sections, 0, sizeof (default_lit_sections)); default_lit_sections.init_lit_seg_name = INIT_LITERAL_SECTION_NAME; default_lit_sections.fini_lit_seg_name = FINI_LITERAL_SECTION_NAME; default_lit_sections.lit_seg_name = LITERAL_SECTION_NAME; subseg_set (current_section, current_subsec); xtensa_addi_opcode = xtensa_opcode_lookup (isa, "addi"); xtensa_addmi_opcode = xtensa_opcode_lookup (isa, "addmi"); xtensa_call0_opcode = xtensa_opcode_lookup (isa, "call0"); xtensa_call4_opcode = xtensa_opcode_lookup (isa, "call4"); xtensa_call8_opcode = xtensa_opcode_lookup (isa, "call8"); xtensa_call12_opcode = xtensa_opcode_lookup (isa, "call12"); xtensa_callx0_opcode = xtensa_opcode_lookup (isa, "callx0"); xtensa_callx4_opcode = xtensa_opcode_lookup (isa, "callx4"); xtensa_callx8_opcode = xtensa_opcode_lookup (isa, "callx8"); xtensa_callx12_opcode = xtensa_opcode_lookup (isa, "callx12"); xtensa_entry_opcode = xtensa_opcode_lookup (isa, "entry"); xtensa_isync_opcode = xtensa_opcode_lookup (isa, "isync"); xtensa_j_opcode = xtensa_opcode_lookup (isa, "j"); xtensa_jx_opcode = xtensa_opcode_lookup (isa, "jx"); xtensa_loop_opcode = xtensa_opcode_lookup (isa, "loop"); xtensa_loopnez_opcode = xtensa_opcode_lookup (isa, "loopnez"); xtensa_loopgtz_opcode = xtensa_opcode_lookup (isa, "loopgtz"); xtensa_nop_n_opcode = xtensa_opcode_lookup (isa, "nop.n"); xtensa_or_opcode = xtensa_opcode_lookup (isa, "or"); xtensa_ret_opcode = xtensa_opcode_lookup (isa, "ret"); xtensa_ret_n_opcode = xtensa_opcode_lookup (isa, "ret.n"); xtensa_retw_opcode = xtensa_opcode_lookup (isa, "retw"); xtensa_retw_n_opcode = xtensa_opcode_lookup (isa, "retw.n"); xtensa_rsr_opcode = xtensa_opcode_lookup (isa, "rsr"); xtensa_waiti_opcode = xtensa_opcode_lookup (isa, "waiti"); } /* tc_frob_label hook */ void xtensa_frob_label (sym) symbolS *sym; { if (generating_literals) xtensa_add_literal_sym (sym); else xtensa_add_insn_label (sym); if (symbol_get_tc (sym)->is_loop_target && (get_last_insn_flags (now_seg, now_subseg) & FLAG_IS_BAD_LOOPEND) != 0) as_bad (_("invalid last instruction for a zero-overhead loop")); /* No target aligning in the absolute section. */ if (now_seg != absolute_section && align_targets && !is_unaligned_label (sym) && !frag_now->tc_frag_data.is_literal) { /* frag_now->tc_frag_data.is_insn = TRUE; */ frag_var (rs_machine_dependent, 4, 4, RELAX_DESIRE_ALIGN_IF_TARGET, frag_now->fr_symbol, frag_now->fr_offset, NULL); xtensa_move_labels (frag_now, 0, TRUE); /* If the label is already known to be a branch target, i.e., a forward branch, mark the frag accordingly. Backward branches are handled by xg_add_branch_and_loop_targets. */ if (symbol_get_tc (sym)->is_branch_target) symbol_get_frag (sym)->tc_frag_data.is_branch_target = TRUE; /* Loops only go forward, so they can be identified here. */ if (symbol_get_tc (sym)->is_loop_target) symbol_get_frag (sym)->tc_frag_data.is_loop_target = TRUE; } } /* md_flush_pending_output hook */ void xtensa_flush_pending_output () { /* If there is a non-zero instruction fragment, close it. */ if (frag_now_fix () != 0 && frag_now->tc_frag_data.is_insn) { frag_wane (frag_now); frag_new (0); } frag_now->tc_frag_data.is_insn = FALSE; xtensa_clear_insn_labels (); } void md_assemble (str) char *str; { xtensa_isa isa = xtensa_default_isa; char *opname; unsigned opnamelen; bfd_boolean has_underbar = FALSE; char *arg_strings[MAX_INSN_ARGS]; int num_args; IStack istack; /* Put instructions into here. */ TInsn orig_insn; /* Original instruction from the input. */ int i; symbolS *lit_sym = NULL; if (frag_now->tc_frag_data.is_literal) { static bfd_boolean reported = 0; if (reported < 4) as_bad (_("cannot assemble '%s' into a literal fragment"), str); if (reported == 3) as_bad (_("...")); reported++; return; } istack_init (&istack); tinsn_init (&orig_insn); /* Split off the opcode. */ opnamelen = strspn (str, "abcdefghijklmnopqrstuvwxyz_/0123456789."); opname = xmalloc (opnamelen + 1); memcpy (opname, str, opnamelen); opname[opnamelen] = '\0'; num_args = tokenize_arguments (arg_strings, str + opnamelen); if (num_args == -1) { as_bad (_("syntax error")); return; } if (xg_translate_idioms (&opname, &num_args, arg_strings)) return; /* Check for an underbar prefix. */ if (*opname == '_') { has_underbar = TRUE; opname += 1; } orig_insn.insn_type = ITYPE_INSN; orig_insn.ntok = 0; orig_insn.is_specific_opcode = (has_underbar || !use_generics ()); specific_opcode = orig_insn.is_specific_opcode; orig_insn.opcode = xtensa_opcode_lookup (isa, opname); if (orig_insn.opcode == XTENSA_UNDEFINED) { as_bad (_("unknown opcode %s"), opname); return; } if (frag_now_fix () != 0 && !frag_now->tc_frag_data.is_insn) { frag_wane (frag_now); frag_new (0); } if (software_a0_b_retw_interlock) { if ((get_last_insn_flags (now_seg, now_subseg) & FLAG_IS_A0_WRITER) != 0 && is_conditional_branch_opcode (orig_insn.opcode)) { has_a0_b_retw = TRUE; /* Mark this fragment with the special RELAX_ADD_NOP_IF_A0_B_RETW. After the first assembly pass we will check all of them and add a nop if needed. */ frag_now->tc_frag_data.is_insn = TRUE; frag_var (rs_machine_dependent, 4, 4, RELAX_ADD_NOP_IF_A0_B_RETW, frag_now->fr_symbol, frag_now->fr_offset, NULL); frag_now->tc_frag_data.is_insn = TRUE; frag_var (rs_machine_dependent, 4, 4, RELAX_ADD_NOP_IF_A0_B_RETW, frag_now->fr_symbol, frag_now->fr_offset, NULL); } } /* Special case: The call instructions should be marked "specific opcode" to keep them from expanding. */ if (!use_longcalls () && is_direct_call_opcode (orig_insn.opcode)) orig_insn.is_specific_opcode = TRUE; /* Parse the arguments. */ if (parse_arguments (&orig_insn, num_args, arg_strings)) { as_bad (_("syntax error")); return; } /* Free the opcode and argument strings, now that they've been parsed. */ free (has_underbar ? opname - 1 : opname); opname = 0; while (num_args-- > 0) free (arg_strings[num_args]); /* Check for the right number and type of arguments. */ if (tinsn_check_arguments (&orig_insn)) return; /* See if the instruction implies an aligned section. */ if (is_entry_opcode (orig_insn.opcode) || is_loop_opcode (orig_insn.opcode)) record_alignment (now_seg, 2); xg_add_branch_and_loop_targets (&orig_insn); /* Special cases for instructions that force an alignment... */ if (!orig_insn.is_specific_opcode && is_loop_opcode (orig_insn.opcode)) { size_t max_fill; frag_now->tc_frag_data.is_insn = TRUE; frag_now->tc_frag_data.is_no_density = !code_density_available (); max_fill = get_text_align_max_fill_size (get_text_align_power (XTENSA_FETCH_WIDTH), TRUE, frag_now->tc_frag_data.is_no_density); frag_var (rs_machine_dependent, max_fill, max_fill, RELAX_ALIGN_NEXT_OPCODE, frag_now->fr_symbol, frag_now->fr_offset, NULL); xtensa_move_labels (frag_now, 0, FALSE); } /* Special-case for "entry" instruction. */ if (is_entry_opcode (orig_insn.opcode)) { /* Check that the second opcode (#1) is >= 16. */ if (orig_insn.ntok >= 2) { expressionS *exp = &orig_insn.tok[1]; switch (exp->X_op) { case O_constant: if (exp->X_add_number < 16) as_warn (_("entry instruction with stack decrement < 16")); break; default: as_warn (_("entry instruction with non-constant decrement")); } } if (!orig_insn.is_specific_opcode) { xtensa_mark_literal_pool_location (); /* Automatically align ENTRY instructions. */ xtensa_move_labels (frag_now, 0, TRUE); frag_align (2, 0, 0); } } /* Any extra alignment frags have been inserted now, and we're about to emit a new instruction so clear the list of labels. */ xtensa_clear_insn_labels (); if (software_a0_b_retw_interlock) set_last_insn_flags (now_seg, now_subseg, FLAG_IS_A0_WRITER, is_register_writer (&orig_insn, "a", 0)); set_last_insn_flags (now_seg, now_subseg, FLAG_IS_BAD_LOOPEND, is_bad_loopend_opcode (&orig_insn)); /* Finish it off: assemble_tokens (opcode, tok, ntok); expand the tokens from the orig_insn into the stack of instructions that will not expand unless required at relaxation time. */ if (xg_expand_assembly_insn (&istack, &orig_insn)) return; for (i = 0; i < istack.ninsn; i++) { TInsn *insn = &istack.insn[i]; if (insn->insn_type == ITYPE_LITERAL) { assert (lit_sym == NULL); lit_sym = xg_assemble_literal (insn); } else { if (lit_sym) xg_resolve_literals (insn, lit_sym); xg_assemble_tokens (insn); } } /* Now, if the original opcode was a call... */ if (align_targets && is_call_opcode (orig_insn.opcode)) { frag_now->tc_frag_data.is_insn = TRUE; frag_var (rs_machine_dependent, 4, 4, RELAX_DESIRE_ALIGN, frag_now->fr_symbol, frag_now->fr_offset, NULL); } } /* TC_CONS_FIX_NEW hook: Check for "@PLT" suffix on symbol references. If found, use an XTENSA_PLT reloc for 4-byte values. Otherwise, this is the same as the standard code in read.c. */ void xtensa_cons_fix_new (frag, where, size, exp) fragS *frag; int where; int size; expressionS *exp; { bfd_reloc_code_real_type r; bfd_boolean plt = FALSE; if (*input_line_pointer == '@') { if (!strncmp (input_line_pointer, PLT_SUFFIX, strlen (PLT_SUFFIX) - 1) && !strncmp (input_line_pointer, plt_suffix, strlen (plt_suffix) - 1)) { as_bad (_("undefined @ suffix '%s', expected '%s'"), input_line_pointer, plt_suffix); ignore_rest_of_line (); return; } input_line_pointer += strlen (plt_suffix); plt = TRUE; } switch (size) { case 1: r = BFD_RELOC_8; break; case 2: r = BFD_RELOC_16; break; case 4: r = plt ? BFD_RELOC_XTENSA_PLT : BFD_RELOC_32; break; case 8: r = BFD_RELOC_64; break; default: as_bad (_("unsupported BFD relocation size %u"), size); r = BFD_RELOC_32; break; } fix_new_exp (frag, where, size, exp, 0, r); } /* TC_FRAG_INIT hook */ void xtensa_frag_init (frag) fragS *frag; { frag->tc_frag_data.is_no_density = !code_density_available (); } symbolS * md_undefined_symbol (name) char *name ATTRIBUTE_UNUSED; { return NULL; } /* Round up a section size to the appropriate boundary. */ valueT md_section_align (segment, size) segT segment ATTRIBUTE_UNUSED; valueT size; { return size; /* Byte alignment is fine. */ } long md_pcrel_from (fixP) fixS *fixP; { char *insn_p; static xtensa_insnbuf insnbuf = NULL; int opnum; xtensa_operand operand; xtensa_opcode opcode; xtensa_isa isa = xtensa_default_isa; valueT addr = fixP->fx_where + fixP->fx_frag->fr_address; if (fixP->fx_done) return addr; if (fixP->fx_r_type == BFD_RELOC_XTENSA_ASM_EXPAND) return addr; if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (isa); insn_p = &fixP->fx_frag->fr_literal[fixP->fx_where]; xtensa_insnbuf_from_chars (isa, insnbuf, insn_p); opcode = xtensa_decode_insn (isa, insnbuf); opnum = reloc_to_opnum (fixP->fx_r_type); if (opnum < 0) as_fatal (_("invalid operand relocation for '%s' instruction"), xtensa_opcode_name (isa, opcode)); if (opnum >= xtensa_num_operands (isa, opcode)) as_fatal (_("invalid relocation for operand %d in '%s' instruction"), opnum, xtensa_opcode_name (isa, opcode)); operand = xtensa_get_operand (isa, opcode, opnum); if (!operand) { as_warn_where (fixP->fx_file, fixP->fx_line, _("invalid relocation type %d for %s instruction"), fixP->fx_r_type, xtensa_opcode_name (isa, opcode)); return addr; } if (!operand_is_pcrel_label (operand)) { as_bad_where (fixP->fx_file, fixP->fx_line, _("invalid relocation for operand %d of '%s'"), opnum, xtensa_opcode_name (isa, opcode)); return addr; } if (!xtensa_operand_isPCRelative (operand)) { as_warn_where (fixP->fx_file, fixP->fx_line, _("non-PCREL relocation operand %d for '%s': %s"), opnum, xtensa_opcode_name (isa, opcode), bfd_get_reloc_code_name (fixP->fx_r_type)); return addr; } return 0 - xtensa_operand_do_reloc (operand, 0, addr); } /* tc_symbol_new_hook */ void xtensa_symbol_new_hook (symbolP) symbolS *symbolP; { symbol_get_tc (symbolP)->plt = 0; } /* tc_fix_adjustable hook */ bfd_boolean xtensa_fix_adjustable (fixP) fixS *fixP; { /* We need the symbol name for the VTABLE entries. */ if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY) return 0; return 1; } void md_apply_fix3 (fixP, valP, seg) fixS *fixP; valueT *valP; segT seg ATTRIBUTE_UNUSED; { if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0) { /* This happens when the relocation is within the current section. It seems this implies a PCREL operation. We'll catch it and error if not. */ char *const fixpos = fixP->fx_frag->fr_literal + fixP->fx_where; static xtensa_insnbuf insnbuf = NULL; xtensa_opcode opcode; xtensa_isa isa; switch (fixP->fx_r_type) { case BFD_RELOC_XTENSA_ASM_EXPAND: fixP->fx_done = 1; break; case BFD_RELOC_XTENSA_ASM_SIMPLIFY: as_bad (_("unhandled local relocation fix %s"), bfd_get_reloc_code_name (fixP->fx_r_type)); break; case BFD_RELOC_32: case BFD_RELOC_16: case BFD_RELOC_8: /* The only one we support that isn't an instruction field. */ md_number_to_chars (fixpos, *valP, fixP->fx_size); fixP->fx_done = 1; break; case BFD_RELOC_XTENSA_OP0: case BFD_RELOC_XTENSA_OP1: case BFD_RELOC_XTENSA_OP2: isa = xtensa_default_isa; if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (isa); xtensa_insnbuf_from_chars (isa, insnbuf, fixpos); opcode = xtensa_decode_insn (isa, insnbuf); if (opcode == XTENSA_UNDEFINED) as_fatal (_("undecodable FIX")); xtensa_insnbuf_set_immediate_field (opcode, insnbuf, *valP, fixP->fx_file, fixP->fx_line); fixP->fx_frag->tc_frag_data.is_insn = TRUE; xtensa_insnbuf_to_chars (isa, insnbuf, fixpos); fixP->fx_done = 1; break; case BFD_RELOC_VTABLE_INHERIT: case BFD_RELOC_VTABLE_ENTRY: fixP->fx_done = 0; break; default: as_bad (_("unhandled local relocation fix %s"), bfd_get_reloc_code_name (fixP->fx_r_type)); } } } char * md_atof (type, litP, sizeP) int type; char *litP; int *sizeP; { int prec; LITTLENUM_TYPE words[4]; char *t; int i; switch (type) { case 'f': prec = 2; break; case 'd': prec = 4; break; default: *sizeP = 0; return "bad call to md_atof"; } t = atof_ieee (input_line_pointer, type, words); if (t) input_line_pointer = t; *sizeP = prec * 2; for (i = prec - 1; i >= 0; i--) { int idx = i; if (target_big_endian) idx = (prec - 1 - i); md_number_to_chars (litP, (valueT) words[idx], 2); litP += 2; } return NULL; } int md_estimate_size_before_relax (fragP, seg) fragS *fragP; segT seg ATTRIBUTE_UNUSED; { return fragP->tc_frag_data.text_expansion; } /* Translate internal representation of relocation info to BFD target format. */ arelent * tc_gen_reloc (section, fixp) asection *section ATTRIBUTE_UNUSED; fixS *fixp; { arelent *reloc; reloc = (arelent *) xmalloc (sizeof (arelent)); reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); reloc->address = fixp->fx_frag->fr_address + fixp->fx_where; /* Make sure none of our internal relocations make it this far. They'd better have been fully resolved by this point. */ assert ((int) fixp->fx_r_type > 0); reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type); if (reloc->howto == NULL) { as_bad_where (fixp->fx_file, fixp->fx_line, _("cannot represent `%s' relocation in object file"), bfd_get_reloc_code_name (fixp->fx_r_type)); return NULL; } if (!fixp->fx_pcrel != !reloc->howto->pc_relative) { as_fatal (_("internal error? cannot generate `%s' relocation"), bfd_get_reloc_code_name (fixp->fx_r_type)); } assert (!fixp->fx_pcrel == !reloc->howto->pc_relative); reloc->addend = fixp->fx_offset; switch (fixp->fx_r_type) { case BFD_RELOC_XTENSA_OP0: case BFD_RELOC_XTENSA_OP1: case BFD_RELOC_XTENSA_OP2: case BFD_RELOC_XTENSA_ASM_EXPAND: case BFD_RELOC_32: case BFD_RELOC_XTENSA_PLT: case BFD_RELOC_VTABLE_INHERIT: case BFD_RELOC_VTABLE_ENTRY: break; case BFD_RELOC_XTENSA_ASM_SIMPLIFY: as_warn (_("emitting simplification relocation")); break; default: as_warn (_("emitting unknown relocation")); } return reloc; } void xtensa_end () { directive_balance (); xtensa_move_literals (); xtensa_reorder_segments (); xtensa_cleanup_align_frags (); xtensa_fix_target_frags (); if (software_a0_b_retw_interlock && has_a0_b_retw) xtensa_fix_a0_b_retw_frags (); if (software_avoid_b_j_loop_end && maybe_has_b_j_loop_end) xtensa_fix_b_j_loop_end_frags (); /* "close_loop_end" should be processed BEFORE "short_loop". */ if (software_avoid_close_loop_end && maybe_has_close_loop_end) xtensa_fix_close_loop_end_frags (); if (software_avoid_short_loop && maybe_has_short_loop) xtensa_fix_short_loop_frags (); xtensa_sanity_check (); } static void xtensa_cleanup_align_frags () { frchainS *frchP; for (frchP = frchain_root; frchP; frchP = frchP->frch_next) { fragS *fragP; /* Walk over all of the fragments in a subsection. */ for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next) { if ((fragP->fr_type == rs_align || fragP->fr_type == rs_align_code || (fragP->fr_type == rs_machine_dependent && (fragP->fr_subtype == RELAX_DESIRE_ALIGN || fragP->fr_subtype == RELAX_DESIRE_ALIGN_IF_TARGET))) && fragP->fr_fix == 0) { fragS * next = fragP->fr_next; while (next && next->fr_type == rs_machine_dependent && next->fr_subtype == RELAX_DESIRE_ALIGN_IF_TARGET) { frag_wane (next); next = next->fr_next; } } } } } /* Re-process all of the fragments looking to convert all of the RELAX_DESIRE_ALIGN_IF_TARGET fragments. If there is a branch target in the next fragment, convert this to RELAX_DESIRE_ALIGN. If the next fragment starts with a loop target, AND the previous fragment can be expanded to negate the branch, convert this to a RELAX_LOOP_END. Otherwise, convert to a .fill 0. */ static void xtensa_fix_target_frags () { frchainS *frchP; /* When this routine is called, all of the subsections are still intact so we walk over subsections instead of sections. */ for (frchP = frchain_root; frchP; frchP = frchP->frch_next) { bfd_boolean prev_frag_can_negate_branch = FALSE; fragS *fragP; /* Walk over all of the fragments in a subsection. */ for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next) { if (fragP->fr_type == rs_machine_dependent && fragP->fr_subtype == RELAX_DESIRE_ALIGN_IF_TARGET) { if (next_frag_is_loop_target (fragP)) { if (prev_frag_can_negate_branch) fragP->fr_subtype = RELAX_LOOP_END; else { if (!align_only_targets || next_frag_is_branch_target (fragP)) fragP->fr_subtype = RELAX_DESIRE_ALIGN; else frag_wane (fragP); } } else if (!align_only_targets || next_frag_is_branch_target (fragP)) fragP->fr_subtype = RELAX_DESIRE_ALIGN; else frag_wane (fragP); } if (fragP->fr_fix != 0) prev_frag_can_negate_branch = FALSE; if (frag_can_negate_branch (fragP)) prev_frag_can_negate_branch = TRUE; } } } static bfd_boolean frag_can_negate_branch (fragP) fragS *fragP; { if (fragP->fr_type == rs_machine_dependent && fragP->fr_subtype == RELAX_IMMED) { TInsn t_insn; tinsn_from_chars (&t_insn, fragP->fr_opcode); if (is_negatable_branch (&t_insn)) return TRUE; } return FALSE; } /* Re-process all of the fragments looking to convert all of the RELAX_ADD_NOP_IF_A0_B_RETW. If the next instruction is a 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 void xtensa_fix_a0_b_retw_frags () { frchainS *frchP; /* When this routine is called, all of the subsections are still intact so we walk over subsections instead of sections. */ for (frchP = frchain_root; frchP; frchP = frchP->frch_next) { fragS *fragP; /* Walk over all of the fragments in a subsection. */ for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next) { if (fragP->fr_type == rs_machine_dependent && fragP->fr_subtype == RELAX_ADD_NOP_IF_A0_B_RETW) { if (next_instrs_are_b_retw (fragP)) relax_frag_add_nop (fragP); else frag_wane (fragP); } } } } bfd_boolean next_instrs_are_b_retw (fragP) fragS * fragP; { xtensa_opcode opcode; const fragS *next_fragP = next_non_empty_frag (fragP); static xtensa_insnbuf insnbuf = NULL; xtensa_isa isa = xtensa_default_isa; int offset = 0; if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (isa); if (next_fragP == NULL) return FALSE; /* Check for the conditional branch. */ xtensa_insnbuf_from_chars (isa, insnbuf, &next_fragP->fr_literal[offset]); opcode = xtensa_decode_insn (isa, insnbuf); if (!is_conditional_branch_opcode (opcode)) return FALSE; offset += xtensa_insn_length (isa, opcode); if (offset == next_fragP->fr_fix) { next_fragP = next_non_empty_frag (next_fragP); offset = 0; } if (next_fragP == NULL) return FALSE; /* Check for the retw/retw.n. */ xtensa_insnbuf_from_chars (isa, insnbuf, &next_fragP->fr_literal[offset]); opcode = xtensa_decode_insn (isa, insnbuf); if (is_windowed_return_opcode (opcode)) return TRUE; return FALSE; } /* Re-process all of the fragments looking to convert all of the RELAX_ADD_NOP_IF_PRE_LOOP_END. If there is one instruction and a loop end label, convert this frag to one that will generate a NOP. In any case close it off with a .fill 0. */ static void xtensa_fix_b_j_loop_end_frags () { frchainS *frchP; /* When this routine is called, all of the subsections are still intact so we walk over subsections instead of sections. */ for (frchP = frchain_root; frchP; frchP = frchP->frch_next) { fragS *fragP; /* Walk over all of the fragments in a subsection. */ for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next) { if (fragP->fr_type == rs_machine_dependent && fragP->fr_subtype == RELAX_ADD_NOP_IF_PRE_LOOP_END) { if (next_instr_is_loop_end (fragP)) relax_frag_add_nop (fragP); else frag_wane (fragP); } } } } bfd_boolean next_instr_is_loop_end (fragP) fragS * fragP; { const fragS *next_fragP; if (next_frag_is_loop_target (fragP)) return FALSE; next_fragP = next_non_empty_frag (fragP); if (next_fragP == NULL) return FALSE; if (!next_frag_is_loop_target (next_fragP)) return FALSE; /* If the size is >= 3 then there is more than one instruction here. The hardware bug will not fire. */ if (next_fragP->fr_fix > 3) return FALSE; return TRUE; } /* Re-process all of the fragments looking to convert all of the RELAX_ADD_NOP_IF_CLOSE_LOOP_END. If there is an loop end that is not MY loop's loop end within 12 bytes, add enough nops here to make it at least 12 bytes away. In any case close it off with a .fill 0. */ static void xtensa_fix_close_loop_end_frags () { frchainS *frchP; /* When this routine is called, all of the subsections are still intact so we walk over subsections instead of sections. */ for (frchP = frchain_root; frchP; frchP = frchP->frch_next) { fragS *fragP; fragS *current_target = NULL; offsetT current_offset = 0; /* Walk over all of the fragments in a subsection. */ for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next) { if (fragP->fr_type == rs_machine_dependent && fragP->fr_subtype == RELAX_IMMED) { /* Read it. If the instruction is a loop, get the target. */ xtensa_opcode opcode = get_opcode_from_buf (fragP->fr_opcode); if (is_loop_opcode (opcode)) { TInsn t_insn; tinsn_from_chars (&t_insn, fragP->fr_opcode); tinsn_immed_from_frag (&t_insn, fragP); /* Get the current fragment target. */ if (fragP->fr_symbol) { current_target = symbol_get_frag (fragP->fr_symbol); current_offset = fragP->fr_offset; } } } if (current_target && fragP->fr_type == rs_machine_dependent && fragP->fr_subtype == RELAX_ADD_NOP_IF_CLOSE_LOOP_END) { size_t min_bytes; size_t bytes_added = 0; #define REQUIRED_LOOP_DIVIDING_BYTES 12 /* Max out at 12. */ min_bytes = min_bytes_to_other_loop_end (fragP->fr_next, current_target, current_offset, REQUIRED_LOOP_DIVIDING_BYTES); if (min_bytes < REQUIRED_LOOP_DIVIDING_BYTES) { while (min_bytes + bytes_added < REQUIRED_LOOP_DIVIDING_BYTES) { int length = 3; if (fragP->fr_var < length) as_warn (_("fr_var %lu < length %d; ignoring"), fragP->fr_var, length); else { assemble_nop (length, fragP->fr_literal + fragP->fr_fix); fragP->fr_fix += length; fragP->fr_var -= length; } bytes_added += length; } } frag_wane (fragP); } } } } 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; { size_t offset = 0; fragS *current_fragP; for (current_fragP = fragP; current_fragP; current_fragP = current_fragP->fr_next) { if (current_fragP->tc_frag_data.is_loop_target && current_fragP != current_target) return offset + current_offset; offset += unrelaxed_frag_min_size (current_fragP); if (offset + current_offset >= max_size) return max_size; } return max_size; } size_t unrelaxed_frag_min_size (fragP) fragS * fragP; { size_t size = fragP->fr_fix; /* add fill size */ if (fragP->fr_type == rs_fill) size += fragP->fr_offset; return size; } /* Re-process all of the fragments looking to convert all of the RELAX_ADD_NOP_IF_SHORT_LOOP. If: A) 1) the instruction size count to the loop end label is too short (<= 2 instructions), 2) loop has a jump or branch in it or B) 1) software_avoid_all_short_loops is true 2) The generating loop was a 'loopgtz' or 'loopnez' 3) the instruction size count to the loop end label is too short (<= 2 instructions) then convert this frag (and maybe the next one) to generate a NOP. In any case close it off with a .fill 0. */ static void xtensa_fix_short_loop_frags () { frchainS *frchP; /* When this routine is called, all of the subsections are still intact so we walk over subsections instead of sections. */ for (frchP = frchain_root; frchP; frchP = frchP->frch_next) { fragS *fragP; fragS *current_target = NULL; offsetT current_offset = 0; xtensa_opcode current_opcode = XTENSA_UNDEFINED; /* Walk over all of the fragments in a subsection. */ for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next) { /* check on the current loop */ if (fragP->fr_type == rs_machine_dependent && fragP->fr_subtype == RELAX_IMMED) { /* Read it. If the instruction is a loop, get the target. */ xtensa_opcode opcode = get_opcode_from_buf (fragP->fr_opcode); if (is_loop_opcode (opcode)) { TInsn t_insn; tinsn_from_chars (&t_insn, fragP->fr_opcode); tinsn_immed_from_frag (&t_insn, fragP); /* Get the current fragment target. */ if (fragP->fr_symbol) { current_target = symbol_get_frag (fragP->fr_symbol); current_offset = fragP->fr_offset; current_opcode = opcode; } } } if (fragP->fr_type == rs_machine_dependent && fragP->fr_subtype == RELAX_ADD_NOP_IF_SHORT_LOOP) { size_t insn_count = count_insns_to_loop_end (fragP->fr_next, TRUE, 3); if (insn_count < 3 && (branch_before_loop_end (fragP->fr_next) || (software_avoid_all_short_loops && current_opcode != XTENSA_UNDEFINED && !is_the_loop_opcode (current_opcode)))) relax_frag_add_nop (fragP); else frag_wane (fragP); } } } } 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; { fragS *fragP = NULL; size_t insn_count = 0; fragP = base_fragP; for (; fragP && !fragP->tc_frag_data.is_loop_target; fragP = fragP->fr_next) { insn_count += unrelaxed_frag_min_insn_count (fragP); if (insn_count >= max_count) return max_count; if (count_relax_add) { if (fragP->fr_type == rs_machine_dependent && fragP->fr_subtype == RELAX_ADD_NOP_IF_SHORT_LOOP) { /* In order to add the appropriate number of NOPs, we count an instruction for downstream occurrences. */ insn_count++; if (insn_count >= max_count) return max_count; } } } return insn_count; } size_t unrelaxed_frag_min_insn_count (fragP) fragS *fragP; { size_t insn_count = 0; int offset = 0; if (!fragP->tc_frag_data.is_insn) return insn_count; /* Decode the fixed instructions. */ while (offset < fragP->fr_fix) { xtensa_opcode opcode = get_opcode_from_buf (fragP->fr_literal + offset); if (opcode == XTENSA_UNDEFINED) { as_fatal (_("undecodable instruction in instruction frag")); return insn_count; } offset += xtensa_insn_length (xtensa_default_isa, opcode); insn_count++; } return insn_count; } bfd_boolean branch_before_loop_end (base_fragP) fragS *base_fragP; { fragS *fragP; for (fragP = base_fragP; fragP && !fragP->tc_frag_data.is_loop_target; fragP = fragP->fr_next) { if (unrelaxed_frag_has_b_j (fragP)) return TRUE; } return FALSE; } bfd_boolean unrelaxed_frag_has_b_j (fragP) fragS *fragP; { size_t insn_count = 0; int offset = 0; if (!fragP->tc_frag_data.is_insn) return FALSE; /* Decode the fixed instructions. */ while (offset < fragP->fr_fix) { xtensa_opcode opcode = get_opcode_from_buf (fragP->fr_literal + offset); if (opcode == XTENSA_UNDEFINED) { as_fatal (_("undecodable instruction in instruction frag")); return insn_count; } if (is_branch_or_jump_opcode (opcode)) return TRUE; offset += xtensa_insn_length (xtensa_default_isa, opcode); } return FALSE; } /* Checks to be made after initial assembly but before relaxation. */ static void xtensa_sanity_check () { char *file_name; int line; frchainS *frchP; as_where (&file_name, &line); for (frchP = frchain_root; frchP; frchP = frchP->frch_next) { fragS *fragP; /* Walk over all of the fragments in a subsection. */ for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next) { /* Currently we only check for empty loops here. */ if (fragP->fr_type == rs_machine_dependent && fragP->fr_subtype == RELAX_IMMED) { static xtensa_insnbuf insnbuf = NULL; TInsn t_insn; if (fragP->fr_opcode != NULL) { if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa); tinsn_from_chars (&t_insn, fragP->fr_opcode); tinsn_immed_from_frag (&t_insn, fragP); if (is_loop_opcode (t_insn.opcode)) { if (is_empty_loop (&t_insn, fragP)) { new_logical_line (fragP->fr_file, fragP->fr_line); as_bad (_("invalid empty loop")); } if (!is_local_forward_loop (&t_insn, fragP)) { new_logical_line (fragP->fr_file, fragP->fr_line); as_bad (_("loop target does not follow " "loop instruction in section")); } } } } } } new_logical_line (file_name, line); } #define LOOP_IMMED_OPN 1 /* Return true if the loop target is the next non-zero fragment. */ bfd_boolean is_empty_loop (insn, fragP) const TInsn *insn; fragS *fragP; { const expressionS *expr; symbolS *symbolP; fragS *next_fragP; if (insn->insn_type != ITYPE_INSN) return FALSE; if (!is_loop_opcode (insn->opcode)) return FALSE; if (insn->ntok <= LOOP_IMMED_OPN) return FALSE; expr = &insn->tok[LOOP_IMMED_OPN]; if (expr->X_op != O_symbol) return FALSE; symbolP = expr->X_add_symbol; if (!symbolP) return FALSE; if (symbol_get_frag (symbolP) == NULL) return FALSE; if (S_GET_VALUE (symbolP) != 0) return FALSE; /* Walk through the zero-size fragments from this one. If we find the target fragment, then this is a zero-size loop. */ for (next_fragP = fragP->fr_next; next_fragP != NULL; next_fragP = next_fragP->fr_next) { if (next_fragP == symbol_get_frag (symbolP)) return TRUE; if (next_fragP->fr_fix != 0) return FALSE; } return FALSE; } bfd_boolean is_local_forward_loop (insn, fragP) const TInsn *insn; fragS *fragP; { const expressionS *expr; symbolS *symbolP; fragS *next_fragP; if (insn->insn_type != ITYPE_INSN) return FALSE; if (!is_loop_opcode (insn->opcode)) return FALSE; if (insn->ntok <= LOOP_IMMED_OPN) return FALSE; expr = &insn->tok[LOOP_IMMED_OPN]; if (expr->X_op != O_symbol) return FALSE; symbolP = expr->X_add_symbol; if (!symbolP) return FALSE; if (symbol_get_frag (symbolP) == NULL) return FALSE; /* Walk through fragments until we find the target. If we do not find the target, then this is an invalid loop. */ for (next_fragP = fragP->fr_next; next_fragP != NULL; next_fragP = next_fragP->fr_next) if (next_fragP == symbol_get_frag (symbolP)) return TRUE; return FALSE; } /* Alignment Functions. */ size_t get_text_align_power (target_size) int target_size; { size_t i = 0; for (i = 0; i < sizeof (size_t); i++) { if (target_size <= (1 << i)) return i; } as_fatal (_("get_text_align_power: argument too large")); return 0; } 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; { if (!use_nops) return (1 << align_pow); if (use_no_density) return 3 * (1 << align_pow); return 1 + (1 << align_pow); } /* get_text_align_fill_size () Desired alignments: give the address target_size = size of next instruction align_pow = get_text_align_power (target_size). use_nops = 0 use_no_density = 0; Loop alignments: address = current address + loop instruction size; target_size = 3 (for 2 or 3 byte target) = 8 (for 8 byte target) align_pow = get_text_align_power (target_size); use_nops = 1 use_no_density = set appropriately Text alignments: address = current address + loop instruction size; target_size = 0 align_pow = get_text_align_power (target_size); use_nops = 0 use_no_density = 0. */ 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; { /* Input arguments: align_pow: log2 (required alignment). target_size: alignment must allow the new_address and new_address+target_size-1. use_nops: if true, then we can only use 2 or 3 byte nops. use_no_density: if use_nops and use_no_density, we can only use 3-byte nops. Usually, for non-zero target_size, the align_pow is the power of 2 that is greater than or equal to the target_size. This handles the 2-byte, 3-byte and 8-byte instructions. */ size_t alignment = (1 << align_pow); if (!use_nops) { /* This is the easy case. */ size_t mod; mod = address % alignment; if (mod != 0) mod = alignment - mod; assert ((address + mod) % alignment == 0); return mod; } /* This is the slightly harder case. */ assert ((int) alignment >= target_size); assert (target_size > 0); if (!use_no_density) { size_t i; for (i = 0; i < alignment * 2; i++) { if (i == 1) continue; if ((address + i) >> align_pow == (address + i + target_size - 1) >> align_pow) return i; } } else { size_t i; /* Can only fill multiples of 3. */ for (i = 0; i <= alignment * 3; i += 3) { if ((address + i) >> align_pow == (address + i + target_size - 1) >> align_pow) return i; } } assert (0); return 0; } /* 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; { size_t count = 0; if (use_no_density) { assert (fill_size % 3 == 0); return (fill_size / 3); } assert (fill_size != 1); /* Bad argument. */ while (fill_size > 1) { size_t insn_size = 3; if (fill_size == 2 || fill_size == 4) insn_size = 2; fill_size -= insn_size; count++; } assert (fill_size != 1); /* Bad algorithm. */ return count; } 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; { size_t count = 0; assert (get_text_align_nop_count (fill_size, use_no_density) > n); if (use_no_density) return 3; while (fill_size > 1) { size_t insn_size = 3; if (fill_size == 2 || fill_size == 4) insn_size = 2; fill_size -= insn_size; count++; if (n + 1 == count) return insn_size; } assert (0); return 0; } /* For the given fragment, find the appropriate address 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; { static xtensa_insnbuf insnbuf = NULL; size_t fill_size = 0; if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa); switch (fragP->fr_type) { case rs_machine_dependent: if (fragP->fr_subtype == RELAX_ALIGN_NEXT_OPCODE) { /* The rule is: get next fragment's FIRST instruction. Find the smallest number of bytes that need to be added to ensure that the next fragment's FIRST instruction will fit in a single word. E.G., 2 bytes : 0, 1, 2 mod 4 3 bytes: 0, 1 mod 4 If the FIRST instruction MIGHT be relaxed, assume that it will become a 3 byte instruction. */ int target_insn_size; xtensa_opcode opcode = next_frag_opcode (fragP); addressT pre_opcode_bytes; if (opcode == XTENSA_UNDEFINED) { as_bad_where (fragP->fr_file, fragP->fr_line, _("invalid opcode for RELAX_ALIGN_NEXT_OPCODE")); as_fatal (_("cannot continue")); } target_insn_size = xtensa_insn_length (xtensa_default_isa, opcode); pre_opcode_bytes = next_frag_pre_opcode_bytes (fragP); if (is_loop_opcode (opcode)) { /* next_fragP should be the loop. */ const fragS *next_fragP = next_non_empty_frag (fragP); xtensa_opcode next_opcode = next_frag_opcode (next_fragP); size_t alignment; pre_opcode_bytes += target_insn_size; /* For loops, the alignment depends on the size of the instruction following the loop, not the loop instruction. */ if (next_opcode == XTENSA_UNDEFINED) target_insn_size = 3; else { target_insn_size = xtensa_insn_length (xtensa_default_isa, next_opcode); if (target_insn_size == 2) target_insn_size = 3; /* ISA specifies this. */ } /* If it was 8, then we'll need a larger alignment for the section. */ alignment = get_text_align_power (target_insn_size); /* Is Now_seg valid */ record_alignment (now_seg, alignment); } else as_fatal (_("expected loop opcode in relax align next target")); fill_size = get_text_align_fill_size (address + pre_opcode_bytes, get_text_align_power (target_insn_size), target_insn_size, TRUE, fragP->tc_frag_data.is_no_density); } break; #if 0 case rs_align: case rs_align_code: fill_size = get_text_align_fill_size (address, fragP->fr_offset, 1, TRUE, fragP->tc_frag_data.is_no_density); break; #endif default: as_fatal (_("expected align_code or RELAX_ALIGN_NEXT_OPCODE")); } return address + fill_size; } /* 3 mechanisms for relaxing an alignment: Align to a power of 2. Align so the next fragment's instruction does not cross a word boundary. Align the current instruction so that if the next instruction were 3 bytes, it would not cross a word boundary. We can align with: zeros - This is easy; always insert zeros. nops - 3 and 2 byte instructions 2 - 2 byte nop 3 - 3 byte nop 4 - 2, 2-byte nops >=5 : 3 byte instruction + fn(n-3) widening - widen previous instructions. */ static addressT get_widen_aligned_address (fragP, address) fragS *fragP; addressT address; { addressT align_pow, new_address, loop_insn_offset; fragS *next_frag; int insn_size; xtensa_opcode opcode, next_opcode; static xtensa_insnbuf insnbuf = NULL; if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa); if (fragP->fr_type == rs_align || fragP->fr_type == rs_align_code) { align_pow = fragP->fr_offset; new_address = ((address + ((1 << align_pow) - 1)) << align_pow) >> align_pow; return new_address; } if (fragP->fr_type == rs_machine_dependent) { switch (fragP->fr_subtype) { case RELAX_DESIRE_ALIGN: /* The rule is: get the next fragment's FIRST instruction. Find the smallest number of bytes needed to be added in order to ensure that the next fragment is FIRST instruction will fit in a single word. i.e. 2 bytes : 0, 1, 2. mod 4 3 bytes: 0, 1 mod 4 If the FIRST instruction MIGHT be relaxed, assume that it will become a 3-byte instruction. */ insn_size = 3; /* Check to see if it might be 2 bytes. */ next_opcode = next_frag_opcode (fragP); if (next_opcode != XTENSA_UNDEFINED && xtensa_insn_length (xtensa_default_isa, next_opcode) == 2) insn_size = 2; assert (insn_size <= 4); for (new_address = address; new_address < address + 4; new_address++) { if (new_address >> 2 == (new_address + insn_size - 1) >> 2) return new_address; } as_bad (_("internal error aligning")); return address; case RELAX_ALIGN_NEXT_OPCODE: /* The rule is: get next fragment's FIRST instruction. Find the smallest number of bytes needed to be added in order to ensure that the next fragment's FIRST instruction will fit in a single word. i.e. 2 bytes : 0, 1, 2. mod 4 3 bytes: 0, 1 mod 4 If the FIRST instruction MIGHT be relaxed, assume that it will become a 3 byte instruction. */ opcode = next_frag_opcode (fragP); if (opcode == XTENSA_UNDEFINED) { as_bad_where (fragP->fr_file, fragP->fr_line, _("invalid opcode for RELAX_ALIGN_NEXT_OPCODE")); as_fatal (_("cannot continue")); } insn_size = xtensa_insn_length (xtensa_default_isa, opcode); assert (insn_size <= 4); assert (is_loop_opcode (opcode)); loop_insn_offset = 0; next_frag = next_non_empty_frag (fragP); /* If the loop has been expanded then the loop instruction could be at an offset from this fragment. */ if (next_frag->fr_subtype != RELAX_IMMED) loop_insn_offset = get_expanded_loop_offset (opcode); for (new_address = address; new_address < address + 4; new_address++) { if ((new_address + loop_insn_offset + insn_size) >> 2 == (new_address + loop_insn_offset + insn_size + 2) >> 2) return new_address; } as_bad (_("internal error aligning")); return address; default: as_bad (_("internal error aligning")); return address; } } as_bad (_("internal error aligning")); return address; } /* md_relax_frag Hook and Helper Functions. */ /* 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; { int unreported = fragP->tc_frag_data.unreported_expansion; long new_stretch = 0; char *file_name; int line, lit_size; as_where (&file_name, &line); new_logical_line (fragP->fr_file, fragP->fr_line); fragP->tc_frag_data.unreported_expansion = 0; switch (fragP->fr_subtype) { case RELAX_ALIGN_NEXT_OPCODE: /* Always convert. */ new_stretch = relax_frag_text_align (fragP, stretch); break; case RELAX_LOOP_END: /* Do nothing. */ break; case RELAX_LOOP_END_ADD_NOP: /* Add a NOP and switch to .fill 0. */ new_stretch = relax_frag_add_nop (fragP); break; case RELAX_DESIRE_ALIGN: /* We REALLY want to change the relaxation order here. This should do NOTHING. The narrowing before it will either align it or not. */ break; case RELAX_LITERAL: case RELAX_LITERAL_FINAL: return 0; case RELAX_LITERAL_NR: lit_size = 4; fragP->fr_subtype = RELAX_LITERAL_FINAL; assert (unreported == lit_size); memset (&fragP->fr_literal[fragP->fr_fix], 0, 4); fragP->fr_var -= lit_size; fragP->fr_fix += lit_size; new_stretch = 4; break; case RELAX_NARROW: new_stretch = relax_frag_narrow (fragP, stretch); break; case RELAX_IMMED: case RELAX_IMMED_STEP1: case RELAX_IMMED_STEP2: /* Place the immediate. */ new_stretch = relax_frag_immed (now_seg, fragP, stretch, fragP->fr_subtype - RELAX_IMMED, stretched_p); break; case RELAX_LITERAL_POOL_BEGIN: case RELAX_LITERAL_POOL_END: /* No relaxation required. */ break; default: as_bad (_("bad relaxation state")); } new_logical_line (file_name, line); return new_stretch; } static long relax_frag_text_align (fragP, stretch) fragS *fragP; long stretch; { addressT old_address, old_next_address, old_size; addressT new_address, new_next_address, new_size; addressT growth; /* Overview of the relaxation procedure for alignment inside an executable section: The old size is stored in the tc_frag_data.text_expansion field. Calculate the new address, fix up the text_expansion and return the growth. */ /* Calculate the old address of this fragment and the next fragment. */ old_address = fragP->fr_address - stretch; old_next_address = (fragP->fr_address - stretch + fragP->fr_fix + fragP->tc_frag_data.text_expansion); old_size = old_next_address - old_address; /* Calculate the new address of this fragment and the next fragment. */ new_address = fragP->fr_address; new_next_address = get_noop_aligned_address (fragP, fragP->fr_address + fragP->fr_fix); new_size = new_next_address - new_address; growth = new_size - old_size; /* Fix up the text_expansion field and return the new growth. */ fragP->tc_frag_data.text_expansion += growth; return growth; } /* Add a NOP (i.e., "or a1, a1, a1"). Use the 3-byte one because we don't know about the availability of density yet. TODO: When the flags are stored per fragment, use NOP.N when possible. */ static long relax_frag_add_nop (fragP) fragS *fragP; { static xtensa_insnbuf insnbuf = NULL; TInsn t_insn; char *nop_buf = fragP->fr_literal + fragP->fr_fix; int length; if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa); tinsn_init (&t_insn); t_insn.opcode = xtensa_or_opcode; assert (t_insn.opcode != XTENSA_UNDEFINED); t_insn.ntok = 3; set_expr_const (&t_insn.tok[0], 1); set_expr_const (&t_insn.tok[1], 1); set_expr_const (&t_insn.tok[2], 1); tinsn_to_insnbuf (&t_insn, insnbuf); fragP->tc_frag_data.is_insn = TRUE; xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf, nop_buf); length = xtensa_insn_length (xtensa_default_isa, t_insn.opcode); if (fragP->fr_var < length) { as_warn (_("fr_var (%ld) < length (%d); ignoring"), fragP->fr_var, length); frag_wane (fragP); return 0; } fragP->fr_fix += length; fragP->fr_var -= length; frag_wane (fragP); return length; } static long relax_frag_narrow (fragP, stretch) fragS *fragP; long stretch; { /* Overview of the relaxation procedure for alignment inside an executable section: Find the number of widenings required and the number of nop bytes required. Store the number of bytes ALREADY widened. If there are enough instructions to widen (must go back ONLY through NARROW fragments), mark each of the fragments as TO BE widened, recalculate the fragment addresses. */ assert (fragP->fr_type == rs_machine_dependent && fragP->fr_subtype == RELAX_NARROW); if (!future_alignment_required (fragP, 0)) { /* If already expanded but no longer needed because of a prior stretch, it is SAFE to unexpand because the next fragment will NEVER start at an address > the previous time through the relaxation. */ if (fragP->tc_frag_data.text_expansion) { if (stretch > 0) { fragP->tc_frag_data.text_expansion = 0; return -1; } /* Otherwise we have to live with this bad choice. */ return 0; } return 0; } if (fragP->tc_frag_data.text_expansion == 0) { fragP->tc_frag_data.text_expansion = 1; return 1; } return 0; } static bfd_boolean future_alignment_required (fragP, stretch) fragS *fragP; long stretch; { long address = fragP->fr_address + stretch; int num_widens = 0; addressT aligned_address; offsetT desired_diff; while (fragP) { /* Limit this to a small search. */ if (num_widens > 8) return FALSE; address += fragP->fr_fix; switch (fragP->fr_type) { case rs_fill: address += fragP->fr_offset * fragP->fr_var; break; case rs_machine_dependent: switch (fragP->fr_subtype) { case RELAX_NARROW: /* address += fragP->fr_fix; */ num_widens++; break; case RELAX_IMMED: address += (/* fragP->fr_fix + */ fragP->tc_frag_data.text_expansion); break; case RELAX_ALIGN_NEXT_OPCODE: case RELAX_DESIRE_ALIGN: /* address += fragP->fr_fix; */ aligned_address = get_widen_aligned_address (fragP, address); desired_diff = aligned_address - address; assert (desired_diff >= 0); /* If there are enough wideners in between do it. */ /* return (num_widens == desired_diff); */ if (num_widens == desired_diff) return TRUE; if (fragP->fr_subtype == RELAX_ALIGN_NEXT_OPCODE) return FALSE; break; default: return FALSE; } break; default: return FALSE; } fragP = fragP->fr_next; } return FALSE; } static long relax_frag_immed (segP, fragP, stretch, min_steps, stretched_p) segT segP; fragS *fragP; long stretch; int min_steps; int *stretched_p; { static xtensa_insnbuf insnbuf = NULL; TInsn t_insn; int old_size; bfd_boolean negatable_branch = FALSE; bfd_boolean branch_jmp_to_next = FALSE; IStack istack; offsetT frag_offset; int num_steps; fragS *lit_fragP; int num_text_bytes, num_literal_bytes; int literal_diff, text_diff; assert (fragP->fr_opcode != NULL); if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa); tinsn_from_chars (&t_insn, fragP->fr_opcode); tinsn_immed_from_frag (&t_insn, fragP); negatable_branch = is_negatable_branch (&t_insn); old_size = xtensa_insn_length (xtensa_default_isa, t_insn.opcode); if (software_avoid_b_j_loop_end) branch_jmp_to_next = is_branch_jmp_to_next (&t_insn, fragP); /* Special case: replace a branch to the next instruction with a NOP. This is required to work around a hardware bug in T1040.0 and also serves as an optimization. */ if (branch_jmp_to_next && ((old_size == 2) || (old_size == 3)) && !next_frag_is_loop_target (fragP)) return 0; /* Here is the fun stuff: Get the immediate field from this instruction. If it fits, we are done. If not, find the next instruction sequence that fits. */ frag_offset = fragP->fr_opcode - fragP->fr_literal; istack_init (&istack); num_steps = xg_assembly_relax (&istack, &t_insn, segP, fragP, frag_offset, min_steps, stretch); if (num_steps < min_steps) { as_fatal (_("internal error: relaxation failed")); return 0; } if (num_steps > RELAX_IMMED_MAXSTEPS) { as_fatal (_("internal error: relaxation requires too many steps")); return 0; } fragP->fr_subtype = (int) RELAX_IMMED + num_steps; /* Figure out the number of bytes needed. */ lit_fragP = 0; num_text_bytes = get_num_stack_text_bytes (&istack) - old_size; num_literal_bytes = get_num_stack_literal_bytes (&istack); literal_diff = num_literal_bytes - fragP->tc_frag_data.literal_expansion; text_diff = num_text_bytes - fragP->tc_frag_data.text_expansion; /* It MUST get larger. If not, we could get an infinite loop. */ know (num_text_bytes >= 0); know (literal_diff >= 0 && text_diff >= 0); fragP->tc_frag_data.text_expansion = num_text_bytes; fragP->tc_frag_data.literal_expansion = num_literal_bytes; /* Find the associated expandable literal for this. */ if (literal_diff != 0) { lit_fragP = fragP->tc_frag_data.literal_frag; if (lit_fragP) { assert (literal_diff == 4); lit_fragP->tc_frag_data.unreported_expansion += literal_diff; /* We expect that the literal section state has NOT been modified yet. */ assert (lit_fragP->fr_type == rs_machine_dependent && lit_fragP->fr_subtype == RELAX_LITERAL); lit_fragP->fr_subtype = RELAX_LITERAL_NR; /* We need to mark this section for another iteration of relaxation. */ (*stretched_p)++; } } /* This implicitly uses the assumption that a branch is negated when the size of the output increases by at least 2 bytes. */ if (negatable_branch && num_text_bytes >= 2) { /* If next frag is a loop end, then switch it to add a NOP. */ update_next_frag_nop_state (fragP); } return text_diff; } /* md_convert_frag Hook and Helper Functions. */ void md_convert_frag (abfd, sec, fragp) bfd *abfd ATTRIBUTE_UNUSED; segT sec; fragS *fragp; { char *file_name; int line; as_where (&file_name, &line); new_logical_line (fragp->fr_file, fragp->fr_line); switch (fragp->fr_subtype) { case RELAX_ALIGN_NEXT_OPCODE: /* Always convert. */ convert_frag_align_next_opcode (fragp); break; case RELAX_DESIRE_ALIGN: /* Do nothing. If not aligned already, too bad. */ break; case RELAX_LITERAL: case RELAX_LITERAL_FINAL: break; case RELAX_NARROW: /* No conversion. */ convert_frag_narrow (fragp); break; case RELAX_IMMED: case RELAX_IMMED_STEP1: case RELAX_IMMED_STEP2: /* Place the immediate. */ convert_frag_immed (sec, fragp, fragp->fr_subtype - RELAX_IMMED); break; case RELAX_LITERAL_NR: if (use_literal_section) { /* This should have been handled during relaxation. When relaxing a code segment, literals sometimes need to be added to the corresponding literal segment. If that literal segment has already been relaxed, then we end up in this situation. Marking the literal segments as data would make this happen less often (since GAS always relaxes code before data), but we could still get into trouble if there are instructions in a segment that is not marked as containing code. Until we can implement a better solution, cheat and adjust the addresses of all the following frags. This could break subsequent alignments, but the linker's literal coalescing will do that anyway. */ fragS *f; fragp->fr_subtype = RELAX_LITERAL_FINAL; assert (fragp->tc_frag_data.unreported_expansion == 4); memset (&fragp->fr_literal[fragp->fr_fix], 0, 4); fragp->fr_var -= 4; fragp->fr_fix += 4; for (f = fragp->fr_next; f; f = f->fr_next) f->fr_address += 4; } else as_bad (_("invalid relaxation fragment result")); break; } fragp->fr_var = 0; new_logical_line (file_name, line); } void convert_frag_align_next_opcode (fragp) fragS *fragp; { char *nop_buf; /* Location for Writing. */ size_t i; bfd_boolean use_no_density = fragp->tc_frag_data.is_no_density; addressT aligned_address; size_t fill_size, nop_count; aligned_address = get_noop_aligned_address (fragp, fragp->fr_address + fragp->fr_fix); fill_size = aligned_address - (fragp->fr_address + fragp->fr_fix); nop_count = get_text_align_nop_count (fill_size, use_no_density); nop_buf = fragp->fr_literal + fragp->fr_fix; for (i = 0; i < nop_count; i++) { size_t nop_size; nop_size = get_text_align_nth_nop_size (fill_size, i, use_no_density); assemble_nop (nop_size, nop_buf); nop_buf += nop_size; } fragp->fr_fix += fill_size; fragp->fr_var -= fill_size; } static void convert_frag_narrow (fragP) fragS *fragP; { static xtensa_insnbuf insnbuf = NULL; TInsn t_insn, single_target; int size, old_size, diff, error_val; offsetT frag_offset; if (fragP->tc_frag_data.text_expansion == 0) { /* No conversion. */ fragP->fr_var = 0; return; } assert (fragP->fr_opcode != NULL); if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa); tinsn_from_chars (&t_insn, fragP->fr_opcode); tinsn_immed_from_frag (&t_insn, fragP); /* Just convert it to a wide form.... */ size = 0; old_size = xtensa_insn_length (xtensa_default_isa, t_insn.opcode); tinsn_init (&single_target); frag_offset = fragP->fr_opcode - fragP->fr_literal; error_val = xg_expand_narrow (&single_target, &t_insn); if (error_val) as_bad (_("unable to widen instruction")); size = xtensa_insn_length (xtensa_default_isa, single_target.opcode); xg_emit_insn_to_buf (&single_target, fragP->fr_opcode, fragP, frag_offset, TRUE); diff = size - old_size; assert (diff >= 0); assert (diff <= fragP->fr_var); fragP->fr_var -= diff; fragP->fr_fix += diff; /* clean it up */ fragP->fr_var = 0; } static void convert_frag_immed (segP, fragP, min_steps) segT segP; fragS *fragP; int min_steps; { char *immed_instr = fragP->fr_opcode; static xtensa_insnbuf insnbuf = NULL; TInsn orig_t_insn; bfd_boolean expanded = FALSE; char *fr_opcode = fragP->fr_opcode; bfd_boolean branch_jmp_to_next = FALSE; int size; assert (fragP->fr_opcode != NULL); if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa); tinsn_from_chars (&orig_t_insn, fragP->fr_opcode); tinsn_immed_from_frag (&orig_t_insn, fragP); /* Here is the fun stuff: Get the immediate field from this instruction. If it fits, we're done. If not, find the next instruction sequence that fits. */ if (software_avoid_b_j_loop_end) branch_jmp_to_next = is_branch_jmp_to_next (&orig_t_insn, fragP); if (branch_jmp_to_next && !next_frag_is_loop_target (fragP)) { /* Conversion just inserts a NOP and marks the fix as completed. */ size = xtensa_insn_length (xtensa_default_isa, orig_t_insn.opcode); assemble_nop (size, fragP->fr_opcode); fragP->fr_var = 0; } else { IStack istack; int i; symbolS *lit_sym = NULL; int total_size = 0; int old_size; int diff; symbolS *gen_label = NULL; offsetT frag_offset; /* It does not fit. Find something that does and convert immediately. */ frag_offset = fragP->fr_opcode - fragP->fr_literal; istack_init (&istack); xg_assembly_relax (&istack, &orig_t_insn, segP, fragP, frag_offset, min_steps, 0); old_size = xtensa_insn_length (xtensa_default_isa, orig_t_insn.opcode); /* Assemble this right inline. */ /* First, create the mapping from a label name to the REAL label. */ total_size = 0; for (i = 0; i < istack.ninsn; i++) { TInsn *t_insn = &istack.insn[i]; int size = 0; fragS *lit_frag; switch (t_insn->insn_type) { case ITYPE_LITERAL: if (lit_sym != NULL) as_bad (_("multiple literals in expansion")); /* First find the appropriate space in the literal pool. */ lit_frag = fragP->tc_frag_data.literal_frag; if (lit_frag == NULL) as_bad (_("no registered fragment for literal")); if (t_insn->ntok != 1) as_bad (_("number of literal tokens != 1")); /* Set the literal symbol and add a fixup. */ lit_sym = lit_frag->fr_symbol; break; case ITYPE_LABEL: assert (gen_label == NULL); gen_label = symbol_new (FAKE_LABEL_NAME, now_seg, fragP->fr_opcode - fragP->fr_literal + total_size, fragP); break; case ITYPE_INSN: size = xtensa_insn_length (xtensa_default_isa, t_insn->opcode); total_size += size; break; } } total_size = 0; for (i = 0; i < istack.ninsn; i++) { TInsn *t_insn = &istack.insn[i]; fragS *lit_frag; int size; segT target_seg; switch (t_insn->insn_type) { case ITYPE_LITERAL: lit_frag = fragP->tc_frag_data.literal_frag; /* already checked */ assert (lit_frag != NULL); assert (lit_sym != NULL); assert (t_insn->ntok == 1); /* add a fixup */ target_seg = S_GET_SEGMENT (lit_sym); assert (target_seg); fix_new_exp_in_seg (target_seg, 0, lit_frag, 0, 4, &t_insn->tok[0], FALSE, BFD_RELOC_32); break; case ITYPE_LABEL: break; case ITYPE_INSN: xg_resolve_labels (t_insn, gen_label); xg_resolve_literals (t_insn, lit_sym); size = xtensa_insn_length (xtensa_default_isa, t_insn->opcode); total_size += size; xg_emit_insn_to_buf (t_insn, immed_instr, fragP, immed_instr - fragP->fr_literal, TRUE); immed_instr += size; break; } } diff = total_size - old_size; assert (diff >= 0); if (diff != 0) expanded = TRUE; assert (diff <= fragP->fr_var); fragP->fr_var -= diff; fragP->fr_fix += diff; } /* Clean it up. */ fragP->fr_var = 0; /* Check for undefined immediates in LOOP instructions. */ if (is_loop_opcode (orig_t_insn.opcode)) { symbolS *sym; sym = orig_t_insn.tok[1].X_add_symbol; if (sym != NULL && !S_IS_DEFINED (sym)) { as_bad (_("unresolved loop target symbol: %s"), S_GET_NAME (sym)); return; } sym = orig_t_insn.tok[1].X_op_symbol; if (sym != NULL && !S_IS_DEFINED (sym)) { as_bad (_("unresolved loop target symbol: %s"), S_GET_NAME (sym)); return; } } if (expanded && is_loop_opcode (orig_t_insn.opcode)) convert_frag_immed_finish_loop (segP, fragP, &orig_t_insn); if (expanded && is_direct_call_opcode (orig_t_insn.opcode)) { /* Add an expansion note on the expanded instruction. */ fix_new_exp_in_seg (now_seg, 0, fragP, fr_opcode - fragP->fr_literal, 4, &orig_t_insn.tok[0], TRUE, BFD_RELOC_XTENSA_ASM_EXPAND); } } /* Add a new fix expression into the desired segment. We have to 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; { fixS *new_fix; segT seg = now_seg; subsegT subseg = now_subseg; assert (new_seg != 0); subseg_set (new_seg, new_subseg); if (r_type == BFD_RELOC_32 && exp->X_add_symbol && symbol_get_tc (exp->X_add_symbol)->plt == 1) { r_type = BFD_RELOC_XTENSA_PLT; } new_fix = fix_new_exp (frag, where, size, exp, pcrel, r_type); subseg_set (seg, subseg); return new_fix; } /* Relax a loop instruction so that it can span loop >256 bytes. */ /* loop as, .L1 .L0: rsr as, LEND wsr as, LBEG addi as, as, lo8(label-.L1) addmi as, as, mid8(label-.L1) wsr as, LEND isync rsr as, LCOUNT addi as, as, 1 .L1: <> label: */ static void convert_frag_immed_finish_loop (segP, fragP, t_insn) segT segP; fragS *fragP; TInsn *t_insn; { TInsn loop_insn; TInsn addi_insn; TInsn addmi_insn; unsigned long target; static xtensa_insnbuf insnbuf = NULL; unsigned int loop_length, loop_length_hi, loop_length_lo; xtensa_isa isa = xtensa_default_isa; addressT loop_offset; addressT addi_offset = 9; addressT addmi_offset = 12; if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (isa); /* Get the loop offset. */ loop_offset = get_expanded_loop_offset (t_insn->opcode); /* Validate that there really is a LOOP at the loop_offset. */ tinsn_from_chars (&loop_insn, fragP->fr_opcode + loop_offset); if (!is_loop_opcode (loop_insn.opcode)) { as_bad_where (fragP->fr_file, fragP->fr_line, _("loop relaxation specification does not correspond")); assert (0); } addi_offset += loop_offset; addmi_offset += loop_offset; assert (t_insn->ntok == 2); target = get_expression_value (segP, &t_insn->tok[1]); know (symbolP); know (symbolP->sy_frag); know (!(S_GET_SEGMENT (symbolP) == absolute_section) || symbol_get_frag (symbolP) == &zero_address_frag); loop_length = target - (fragP->fr_address + fragP->fr_fix); loop_length_hi = loop_length & ~0x0ff; loop_length_lo = loop_length & 0x0ff; if (loop_length_lo >= 128) { loop_length_lo -= 256; loop_length_hi += 256; } /* Because addmi sign-extends the immediate, 'loop_length_hi' can be at most 32512. If the loop is larger than that, then we just fail. */ if (loop_length_hi > 32512) as_bad_where (fragP->fr_file, fragP->fr_line, _("loop too long for LOOP instruction")); tinsn_from_chars (&addi_insn, fragP->fr_opcode + addi_offset); assert (addi_insn.opcode == xtensa_addi_opcode); tinsn_from_chars (&addmi_insn, fragP->fr_opcode + addmi_offset); assert (addmi_insn.opcode == xtensa_addmi_opcode); set_expr_const (&addi_insn.tok[2], loop_length_lo); tinsn_to_insnbuf (&addi_insn, insnbuf); fragP->tc_frag_data.is_insn = TRUE; xtensa_insnbuf_to_chars (isa, insnbuf, fragP->fr_opcode + addi_offset); set_expr_const (&addmi_insn.tok[2], loop_length_hi); tinsn_to_insnbuf (&addmi_insn, insnbuf); xtensa_insnbuf_to_chars (isa, insnbuf, fragP->fr_opcode + addmi_offset); } static offsetT get_expression_value (segP, exp) segT segP; expressionS *exp; { if (exp->X_op == O_constant) return exp->X_add_number; if (exp->X_op == O_symbol) { /* Find the fragment. */ symbolS *sym = exp->X_add_symbol; assert (S_GET_SEGMENT (sym) == segP || S_GET_SEGMENT (sym) == absolute_section); return (S_GET_VALUE (sym) + exp->X_add_number); } as_bad (_("invalid expression evaluation type %d"), exp->X_op); return 0; } /* A map that keeps information on a per-subsegment basis. This is maintained during initial assembly, but is invalid once the subsegments are smashed together. I.E., it cannot be used during the relaxation. */ typedef struct subseg_map_struct { /* the key */ segT seg; subsegT subseg; /* the data */ unsigned flags; struct subseg_map_struct *next; } subseg_map; static subseg_map *sseg_map = NULL; static unsigned get_last_insn_flags (seg, subseg) segT seg; subsegT subseg; { subseg_map *subseg_e; for (subseg_e = sseg_map; subseg_e != NULL; subseg_e = subseg_e->next) if (seg == subseg_e->seg && subseg == subseg_e->subseg) return subseg_e->flags; return 0; } static void set_last_insn_flags (seg, subseg, fl, val) segT seg; subsegT subseg; unsigned fl; bfd_boolean val; { subseg_map *subseg_e; for (subseg_e = sseg_map; subseg_e; subseg_e = subseg_e->next) if (seg == subseg_e->seg && subseg == subseg_e->subseg) break; if (!subseg_e) { subseg_e = (subseg_map *) xmalloc (sizeof (subseg_map)); memset (subseg_e, 0, sizeof (subseg_map)); subseg_e->seg = seg; subseg_e->subseg = subseg; subseg_e->flags = 0; subseg_e->next = sseg_map; sseg_map = subseg_e; } if (val) subseg_e->flags |= fl; else subseg_e->flags &= ~fl; } /* Segment Lists and emit_state Stuff. */ /* Remove the segment from the global sections list. */ static void xtensa_remove_section (sec) segT sec; { /* Handle brain-dead bfd_section_list_remove macro, which expect the address of the prior section's "next" field, not just the address of the section to remove. */ segT *ps_next_ptr = &stdoutput->sections; while (*ps_next_ptr != sec && *ps_next_ptr != NULL) ps_next_ptr = &(*ps_next_ptr)->next; assert (*ps_next_ptr != NULL); bfd_section_list_remove (stdoutput, ps_next_ptr); } static void xtensa_insert_section (after_sec, sec) segT after_sec; segT sec; { segT *after_sec_next; if (after_sec == NULL) after_sec_next = &stdoutput->sections; else after_sec_next = &after_sec->next; bfd_section_list_insert (stdoutput, after_sec_next, sec); } static void xtensa_move_seg_list_to_beginning (head) seg_list *head; { head = head->next; while (head) { segT literal_section = head->seg; /* Move the literal section to the front of the section list. */ assert (literal_section); xtensa_remove_section (literal_section); xtensa_insert_section (NULL, literal_section); head = head->next; } } void xtensa_move_literals () { seg_list *segment; frchainS *frchain_from, *frchain_to; fragS *search_frag, *next_frag, *last_frag, *literal_pool, *insert_after; fragS **frag_splice; emit_state state; segT dest_seg; fixS *fix, *next_fix, **fix_splice; sym_list *lit; mark_literal_frags (literal_head->next); mark_literal_frags (init_literal_head->next); mark_literal_frags (fini_literal_head->next); if (use_literal_section) return; segment = literal_head->next; while (segment) { frchain_from = seg_info (segment->seg)->frchainP; search_frag = frchain_from->frch_root; literal_pool = NULL; frchain_to = NULL; frag_splice = &(frchain_from->frch_root); while (!search_frag->tc_frag_data.literal_frag) { assert (search_frag->fr_fix == 0 || search_frag->fr_type == rs_align); search_frag = search_frag->fr_next; } assert (search_frag->tc_frag_data.literal_frag->fr_subtype == RELAX_LITERAL_POOL_BEGIN); xtensa_switch_section_emit_state (&state, segment->seg, 0); /* Make sure that all the frags in this series are closed, and that there is at least one left over of zero-size. This prevents us from making a segment with an frchain without any frags in it. */ frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL); last_frag = frag_now; frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL); while (search_frag != frag_now) { next_frag = search_frag->fr_next; /* First, move the frag out of the literal section and to the appropriate place. */ if (search_frag->tc_frag_data.literal_frag) { literal_pool = search_frag->tc_frag_data.literal_frag; assert (literal_pool->fr_subtype == RELAX_LITERAL_POOL_BEGIN); /* Note that we set this fr_var to be a fix chain when we created the literal pool location as RELAX_LITERAL_POOL_BEGIN. */ frchain_to = (frchainS *) literal_pool->fr_var; } insert_after = literal_pool; while (insert_after->fr_next->fr_subtype != RELAX_LITERAL_POOL_END) insert_after = insert_after->fr_next; dest_seg = (segT) insert_after->fr_next->fr_var; *frag_splice = next_frag; search_frag->fr_next = insert_after->fr_next; insert_after->fr_next = search_frag; search_frag->tc_frag_data.lit_seg = dest_seg; /* Now move any fixups associated with this frag to the right section. */ fix = frchain_from->fix_root; fix_splice = &(frchain_from->fix_root); while (fix) { next_fix = fix->fx_next; if (fix->fx_frag == search_frag) { *fix_splice = next_fix; fix->fx_next = frchain_to->fix_root; frchain_to->fix_root = fix; if (frchain_to->fix_tail == NULL) frchain_to->fix_tail = fix; } else fix_splice = &(fix->fx_next); fix = next_fix; } search_frag = next_frag; } if (frchain_from->fix_root != NULL) { frchain_from = seg_info (segment->seg)->frchainP; as_warn (_("fixes not all moved from %s"), segment->seg->name); assert (frchain_from->fix_root == NULL); } frchain_from->fix_tail = NULL; xtensa_restore_emit_state (&state); segment = segment->next; } /* Now fix up the SEGMENT value for all the literal symbols. */ for (lit = literal_syms; lit; lit = lit->next) { symbolS *lit_sym = lit->sym; segT dest_seg = symbol_get_frag (lit_sym)->tc_frag_data.lit_seg; S_SET_SEGMENT (lit_sym, dest_seg); } } /* Walk over all the frags for segments in a list and mark them as containing literals. As clunky as this is, we can't rely on frag_var and frag_variant to get called in all situations. */ static void mark_literal_frags (segment) seg_list *segment; { frchainS *frchain_from; fragS *search_frag; while (segment) { frchain_from = seg_info (segment->seg)->frchainP; search_frag = frchain_from->frch_root; while (search_frag) { search_frag->tc_frag_data.is_literal = TRUE; search_frag = search_frag->fr_next; } segment = segment->next; } } static void xtensa_reorder_seg_list (head, after) seg_list *head; segT after; { /* Move all of the sections in the section list to come after "after" in the gnu segment list. */ head = head->next; while (head) { segT literal_section = head->seg; /* Move the literal section after "after". */ assert (literal_section); if (literal_section != after) { xtensa_remove_section (literal_section); xtensa_insert_section (after, literal_section); } head = head->next; } } /* Push all the literal segments to the end of the gnu list. */ void xtensa_reorder_segments () { segT sec; segT last_sec; int old_count = 0; int new_count = 0; for (sec = stdoutput->sections; sec != NULL; sec = sec->next) old_count++; /* Now that we have the last section, push all the literal sections to the end. */ last_sec = get_last_sec (); xtensa_reorder_seg_list (literal_head, last_sec); xtensa_reorder_seg_list (init_literal_head, last_sec); xtensa_reorder_seg_list (fini_literal_head, last_sec); /* Now perform the final error check. */ for (sec = stdoutput->sections; sec != NULL; sec = sec->next) new_count++; assert (new_count == old_count); } segT get_last_sec () { segT last_sec = stdoutput->sections; while (last_sec->next != NULL) last_sec = last_sec->next; return last_sec; } /* Change the emit state (seg, subseg, and frag related stuff) to the 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; { /* 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 switch_to_literal_fragment. But literal sections don't have literal pools, so their location is always null, so we would recurse forever. This is kind of hacky, but it works. */ static bfd_boolean recursive = FALSE; fragS *pool_location = get_literal_pool_location (now_seg); bfd_boolean is_init = (now_seg && !strcmp (segment_name (now_seg), INIT_SECTION_NAME)); bfd_boolean is_fini = (now_seg && !strcmp (segment_name (now_seg), FINI_SECTION_NAME)); if (pool_location == NULL && !use_literal_section && !recursive && !is_init && ! is_fini) { as_warn (_("inlining literal pool; " "specify location with .literal_position.")); recursive = TRUE; xtensa_mark_literal_pool_location (); recursive = FALSE; } /* Special case: If we are in the ".fini" or ".init" section, then we will ALWAYS be generating to the ".fini.literal" and ".init.literal" sections. */ if (is_init) { cache_literal_section (init_literal_head, default_lit_sections.init_lit_seg_name, &default_lit_sections.init_lit_seg); xtensa_switch_section_emit_state (result, default_lit_sections.init_lit_seg, 0); } else if (is_fini) { cache_literal_section (fini_literal_head, default_lit_sections.fini_lit_seg_name, &default_lit_sections.fini_lit_seg); xtensa_switch_section_emit_state (result, default_lit_sections.fini_lit_seg, 0); } else { cache_literal_section (literal_head, default_lit_sections.lit_seg_name, &default_lit_sections.lit_seg); xtensa_switch_section_emit_state (result, default_lit_sections.lit_seg, 0); } if (!use_literal_section && !is_init && !is_fini && get_literal_pool_location (now_seg) != pool_location) { /* Close whatever frag is there. */ frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL); frag_now->tc_frag_data.literal_frag = pool_location; frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL); } /* Do a 4 byte align here. */ frag_align (2, 0, 0); } /* Call this function before emitting data into the literal section. 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; { state->name = now_seg->name; state->now_seg = now_seg; state->now_subseg = now_subseg; state->generating_literals = generating_literals; generating_literals++; subseg_new (segment_name (new_now_seg), new_now_subseg); } /* Use to restore the emitting into the normal place. */ void xtensa_restore_emit_state (state) emit_state *state; { generating_literals = state->generating_literals; subseg_new (state->name, state->now_subseg); } /* Get a segment of a given name. If the segment is already present, return it; otherwise, create a new one. */ static void cache_literal_section (head, name, seg) seg_list *head; const char *name; segT *seg; { segT current_section = now_seg; int current_subsec = now_subseg; if (*seg != 0) return; *seg = retrieve_literal_seg (head, name); subseg_set (current_section, current_subsec); } /* 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 (head, name) seg_list *head; const char *name; { segT ret = 0; assert (head); ret = seg_present (name); if (!ret) { ret = subseg_new (name, (subsegT) 0); add_seg_list (head, ret); bfd_set_section_flags (stdoutput, ret, SEC_HAS_CONTENTS | SEC_READONLY | SEC_ALLOC | SEC_LOAD | SEC_CODE); bfd_set_section_alignment (stdoutput, ret, 2); } return ret; } /* Return a segment of a given name if it is present. */ static segT seg_present (name) const char *name; { segT seg; seg = stdoutput->sections; while (seg) { if (!strcmp (segment_name (seg), name)) return seg; seg = seg->next; } return 0; } /* Add a segment to a segment list. */ static void add_seg_list (head, seg) seg_list *head; segT seg; { seg_list *n; n = (seg_list *) xmalloc (sizeof (seg_list)); assert (n); n->seg = seg; n->next = head->next; head->next = n; } /* Set up Property Tables after Relaxation. */ #define XTENSA_INSN_SEC_NAME ".xt.insn" #define XTENSA_LIT_SEC_NAME ".xt.lit" void xtensa_post_relax_hook () { 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_create_property_segments (get_frag_is_insn, XTENSA_INSN_SEC_NAME, xt_insn_sec); xtensa_create_property_segments (get_frag_is_literal, XTENSA_LIT_SEC_NAME, xt_literal_sec); } static bfd_boolean get_frag_is_literal (fragP) const fragS *fragP; { assert (fragP != NULL); return (fragP->tc_frag_data.is_literal); } static bfd_boolean get_frag_is_insn (fragP) const fragS *fragP; { assert (fragP != NULL); return (fragP->tc_frag_data.is_insn); } static void xtensa_create_property_segments (property_function, section_name_base, sec_type) frag_predicate property_function; const char * section_name_base; xt_section_type sec_type; { segT *seclist; /* Walk over all of the current segments. Walk over each fragment For each fragment that has instructions Build an instruction record (append where possible). */ for (seclist = &stdoutput->sections; seclist && *seclist; seclist = &(*seclist)->next) { segT sec = *seclist; if (section_has_property (sec, property_function)) { char *property_section_name = xtensa_get_property_section_name (sec, section_name_base); segT insn_sec = retrieve_xtensa_section (property_section_name); segment_info_type *xt_seg_info = retrieve_segment_info (insn_sec); xtensa_block_info **xt_blocks = &xt_seg_info->tc_segment_info_data.blocks[sec_type]; /* Walk over all of the frchains here and add new sections. */ add_xt_block_frags (sec, insn_sec, xt_blocks, property_function); } } /* Now we fill them out.... */ for (seclist = &stdoutput->sections; seclist && *seclist; seclist = &(*seclist)->next) { segment_info_type *seginfo; xtensa_block_info *block; segT sec = *seclist; seginfo = seg_info (sec); block = seginfo->tc_segment_info_data.blocks[sec_type]; if (block) { xtensa_block_info *cur_block; /* This is a section with some data. */ size_t num_recs = 0; size_t rec_size; for (cur_block = block; cur_block; cur_block = cur_block->next) num_recs++; rec_size = num_recs * 8; bfd_set_section_size (stdoutput, sec, rec_size); /* In order to make this work with the assembler, we have to build some frags and then build the "fixups" for it. It would be easier to just set the contents then set the arlents. */ if (num_recs) { /* Allocate a fragment and leak it. */ fragS *fragP; size_t frag_size; fixS *fixes; frchainS *frchainP; size_t i; char *frag_data; frag_size = sizeof (fragS) + rec_size; fragP = (fragS *) xmalloc (frag_size); memset (fragP, 0, frag_size); fragP->fr_address = 0; fragP->fr_next = NULL; fragP->fr_fix = rec_size; fragP->fr_var = 0; fragP->fr_type = rs_fill; /* the rest are zeros */ frchainP = seginfo->frchainP; frchainP->frch_root = fragP; frchainP->frch_last = fragP; fixes = (fixS *) xmalloc (sizeof (fixS) * num_recs); memset (fixes, 0, sizeof (fixS) * num_recs); seginfo->fix_root = fixes; seginfo->fix_tail = &fixes[num_recs - 1]; cur_block = block; frag_data = &fragP->fr_literal[0]; for (i = 0; i < num_recs; i++) { fixS *fix = &fixes[i]; assert (cur_block); /* Write the fixup. */ if (i != num_recs - 1) fix->fx_next = &fixes[i + 1]; else fix->fx_next = NULL; fix->fx_size = 4; fix->fx_done = 0; fix->fx_frag = fragP; fix->fx_where = i * 8; fix->fx_addsy = section_symbol (cur_block->sec); fix->fx_offset = cur_block->offset; fix->fx_r_type = BFD_RELOC_32; fix->fx_file = "Internal Assembly"; fix->fx_line = 0; /* Write the length. */ md_number_to_chars (&frag_data[4 + 8 * i], cur_block->size, 4); cur_block = cur_block->next; } } } } } segment_info_type * retrieve_segment_info (seg) segT seg; { segment_info_type *seginfo; seginfo = (segment_info_type *) bfd_get_section_userdata (stdoutput, seg); if (!seginfo) { frchainS *frchainP; seginfo = (segment_info_type *) xmalloc (sizeof (*seginfo)); memset ((PTR) seginfo, 0, sizeof (*seginfo)); seginfo->fix_root = NULL; seginfo->fix_tail = NULL; seginfo->bfd_section = seg; seginfo->sym = 0; /* We will not be dealing with these, only our special ones. */ #if 0 if (seg == bfd_abs_section_ptr) abs_seg_info = seginfo; else if (seg == bfd_und_section_ptr) und_seg_info = seginfo; else #endif bfd_set_section_userdata (stdoutput, seg, (PTR) seginfo); #if 0 seg_fix_rootP = &segment_info[seg].fix_root; seg_fix_tailP = &segment_info[seg].fix_tail; #endif frchainP = (frchainS *) xmalloc (sizeof (frchainS)); frchainP->frch_root = NULL; frchainP->frch_last = NULL; frchainP->frch_next = NULL; frchainP->frch_seg = seg; frchainP->frch_subseg = 0; frchainP->fix_root = NULL; frchainP->fix_tail = NULL; /* Do not init the objstack. */ /* obstack_begin (&frchainP->frch_obstack, chunksize); */ /* frchainP->frch_frag_now = fragP; */ frchainP->frch_frag_now = NULL; seginfo->frchainP = frchainP; } return seginfo; } segT retrieve_xtensa_section (sec_name) char *sec_name; { bfd *abfd = stdoutput; flagword flags, out_flags, link_once_flags; segT s; flags = bfd_get_section_flags (abfd, now_seg); link_once_flags = (flags & SEC_LINK_ONCE); if (link_once_flags) link_once_flags |= (flags & SEC_LINK_DUPLICATES); out_flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY | link_once_flags); s = bfd_make_section_old_way (abfd, sec_name); if (s == NULL) as_bad (_("could not create section %s"), sec_name); if (!bfd_set_section_flags (abfd, s, out_flags)) as_bad (_("invalid flag combination on section %s"), sec_name); return s; } bfd_boolean section_has_property (sec, property_function) segT sec; frag_predicate property_function; { segment_info_type *seginfo = seg_info (sec); fragS *fragP; if (seginfo && seginfo->frchainP) { for (fragP = seginfo->frchainP->frch_root; fragP; fragP = fragP->fr_next) { if (property_function (fragP) && (fragP->fr_type != rs_fill || fragP->fr_fix != 0)) return TRUE; } } return FALSE; } /* Two types of block sections exist right now: literal and insns. */ void add_xt_block_frags (sec, xt_block_sec, xt_block, property_function) segT sec; segT xt_block_sec; xtensa_block_info **xt_block; frag_predicate property_function; { segment_info_type *seg_info; segment_info_type *xt_seg_info; bfd_vma seg_offset; fragS *fragP; xt_seg_info = retrieve_segment_info (xt_block_sec); seg_info = retrieve_segment_info (sec); /* Build it if needed. */ while (*xt_block != NULL) xt_block = &(*xt_block)->next; /* We are either at NULL at the beginning or at the end. */ /* Walk through the frags. */ seg_offset = 0; if (seg_info->frchainP) { for (fragP = seg_info->frchainP->frch_root; fragP; fragP = fragP->fr_next) { if (property_function (fragP) && (fragP->fr_type != rs_fill || fragP->fr_fix != 0)) { if (*xt_block != NULL) { if ((*xt_block)->offset + (*xt_block)->size == fragP->fr_address) (*xt_block)->size += fragP->fr_fix; else xt_block = &((*xt_block)->next); } if (*xt_block == NULL) { xtensa_block_info *new_block = (xtensa_block_info *) xmalloc (sizeof (xtensa_block_info)); new_block->sec = sec; new_block->offset = fragP->fr_address; new_block->size = fragP->fr_fix; new_block->next = NULL; *xt_block = new_block; } } } } } /* Instruction Stack Functions (from "xtensa-istack.h"). */ void istack_init (stack) IStack *stack; { memset (stack, 0, sizeof (IStack)); stack->ninsn = 0; } bfd_boolean istack_empty (stack) IStack *stack; { return (stack->ninsn == 0); } bfd_boolean istack_full (stack) IStack *stack; { return (stack->ninsn == MAX_ISTACK); } /* Return a pointer to the top IStack entry. It is an error to call this if istack_empty () is true. */ TInsn * istack_top (stack) IStack *stack; { int rec = stack->ninsn - 1; assert (!istack_empty (stack)); return &stack->insn[rec]; } /* Add a new TInsn to an IStack. It is an error to call this if istack_full () is true. */ void istack_push (stack, insn) IStack *stack; TInsn *insn; { int rec = stack->ninsn; assert (!istack_full (stack)); tinsn_copy (&stack->insn[rec], insn); stack->ninsn++; } /* Clear space for the next TInsn on the IStack and return a pointer to it. It is an error to call this if istack_full () is true. */ TInsn * istack_push_space (stack) IStack *stack; { int rec = stack->ninsn; TInsn *insn; assert (!istack_full (stack)); insn = &stack->insn[rec]; memset (insn, 0, sizeof (TInsn)); stack->ninsn++; return insn; } /* Remove the last pushed instruction. It is an error to call this if istack_empty () returns true. */ void istack_pop (stack) IStack *stack; { int rec = stack->ninsn - 1; assert (!istack_empty (stack)); stack->ninsn--; memset (&stack->insn[rec], 0, sizeof (TInsn)); } /* TInsn functions. */ void tinsn_init (dst) TInsn *dst; { memset (dst, 0, sizeof (TInsn)); } void tinsn_copy (dst, src) TInsn *dst; const TInsn *src; { tinsn_init (dst); memcpy (dst, src, sizeof (TInsn)); } /* Get the ``num''th token of the TInsn. It is illegal to call this if num > insn->ntoks. */ expressionS * tinsn_get_tok (insn, num) TInsn *insn; int num; { assert (num < insn->ntok); return &insn->tok[num]; } /* Return true if ANY of the operands in the insn are symbolic. */ static bfd_boolean tinsn_has_symbolic_operands (insn) const TInsn *insn; { int i; int n = insn->ntok; assert (insn->insn_type == ITYPE_INSN); for (i = 0; i < n; ++i) { switch (insn->tok[i].X_op) { case O_register: case O_constant: break; default: return TRUE; } } return FALSE; } bfd_boolean tinsn_has_invalid_symbolic_operands (insn) const TInsn *insn; { int i; int n = insn->ntok; assert (insn->insn_type == ITYPE_INSN); for (i = 0; i < n; ++i) { switch (insn->tok[i].X_op) { case O_register: case O_constant: break; default: if (i == get_relaxable_immed (insn->opcode)) break; as_bad (_("invalid symbolic operand %d on '%s'"), i, xtensa_opcode_name (xtensa_default_isa, insn->opcode)); return TRUE; } } return FALSE; } /* For assembly code with complex expressions (e.g. subtraction), we have to build them in the literal pool so that their results are calculated correctly after relaxation. The relaxation only handles expressions that boil down to SYMBOL + OFFSET. */ static bfd_boolean tinsn_has_complex_operands (insn) const TInsn *insn; { int i; int n = insn->ntok; assert (insn->insn_type == ITYPE_INSN); for (i = 0; i < n; ++i) { switch (insn->tok[i].X_op) { case O_register: case O_constant: case O_symbol: break; default: return TRUE; } } return FALSE; } /* Convert the constant operands in the t_insn to insnbuf. Return true if there is a symbol in the immediate field. Before this is called, 1) the number of operands are correct 2) the t_insn is a ITYPE_INSN 3) ONLY the relaxable_ is built 4) All operands are O_constant, O_symbol. All constants fit The return value tells whether there are any remaining O_symbols. */ static bfd_boolean tinsn_to_insnbuf (t_insn, insnbuf) TInsn *t_insn; xtensa_insnbuf insnbuf; { xtensa_isa isa = xtensa_default_isa; xtensa_opcode opcode = t_insn->opcode; bfd_boolean has_fixup = FALSE; int noperands = xtensa_num_operands (isa, opcode); int i; uint32 opnd_value; char *file_name; int line; assert (t_insn->insn_type == ITYPE_INSN); if (noperands != t_insn->ntok) as_fatal (_("operand number mismatch")); xtensa_encode_insn (isa, opcode, insnbuf); for (i = 0; i < noperands; ++i) { expressionS *expr = &t_insn->tok[i]; xtensa_operand operand = xtensa_get_operand (isa, opcode, i); switch (expr->X_op) { case O_register: /* The register number has already been checked in expression_maybe_register, so we don't need to check here. */ opnd_value = expr->X_add_number; (void) xtensa_operand_encode (operand, &opnd_value); xtensa_operand_set_field (operand, insnbuf, opnd_value); break; case O_constant: as_where (&file_name, &line); /* It is a constant and we called this function, then we have to try to fit it. */ xtensa_insnbuf_set_operand (insnbuf, opcode, operand, expr->X_add_number, file_name, line); break; case O_symbol: default: has_fixup = TRUE; break; } } return has_fixup; } /* Check the instruction arguments. Return true on failure. */ bfd_boolean tinsn_check_arguments (insn) const TInsn *insn; { xtensa_isa isa = xtensa_default_isa; xtensa_opcode opcode = insn->opcode; if (opcode == XTENSA_UNDEFINED) { as_bad (_("invalid opcode")); return TRUE; } if (xtensa_num_operands (isa, opcode) > insn->ntok) { as_bad (_("too few operands")); return TRUE; } if (xtensa_num_operands (isa, opcode) < insn->ntok) { as_bad (_("too many operands")); return TRUE; } return FALSE; } /* Load an instruction from its encoded form. */ static void tinsn_from_chars (t_insn, f) TInsn *t_insn; char *f; { static xtensa_insnbuf insnbuf = NULL; int i; xtensa_opcode opcode; xtensa_isa isa = xtensa_default_isa; if (!insnbuf) insnbuf = xtensa_insnbuf_alloc (isa); xtensa_insnbuf_from_chars (isa, insnbuf, f); opcode = xtensa_decode_insn (isa, insnbuf); /* Find the immed. */ tinsn_init (t_insn); t_insn->insn_type = ITYPE_INSN; t_insn->is_specific_opcode = FALSE; /* Must not be specific. */ t_insn->opcode = opcode; t_insn->ntok = xtensa_num_operands (isa, opcode); for (i = 0; i < t_insn->ntok; i++) { set_expr_const (&t_insn->tok[i], xtensa_insnbuf_get_operand (insnbuf, opcode, i)); } } /* Read the value of the relaxable immed from the fr_symbol and fr_offset. */ static void tinsn_immed_from_frag (t_insn, fragP) TInsn *t_insn; fragS *fragP; { xtensa_opcode opcode = t_insn->opcode; int opnum; if (fragP->fr_symbol) { opnum = get_relaxable_immed (opcode); set_expr_symbol_offset (&t_insn->tok[opnum], fragP->fr_symbol, fragP->fr_offset); } } static int get_num_stack_text_bytes (istack) IStack *istack; { int i; int text_bytes = 0; for (i = 0; i < istack->ninsn; i++) { TInsn *t_insn = &istack->insn[i]; if (t_insn->insn_type == ITYPE_INSN) text_bytes += xg_get_insn_size (t_insn); } return text_bytes; } static int get_num_stack_literal_bytes (istack) IStack *istack; { int i; int lit_bytes = 0; for (i = 0; i < istack->ninsn; i++) { TInsn *t_insn = &istack->insn[i]; if (t_insn->insn_type == ITYPE_LITERAL && t_insn->ntok == 1) lit_bytes += 4; } return lit_bytes; } /* Expression utilities. */ /* Return true if the expression is an integer constant. */ bfd_boolean expr_is_const (s) const expressionS *s; { return (s->X_op == O_constant); } /* Get the expression constant. Calling this is illegal if expr_is_const () returns true. */ offsetT get_expr_const (s) const expressionS *s; { assert (expr_is_const (s)); return s->X_add_number; } /* Set the expression to a constant value. */ void set_expr_const (s, val) expressionS *s; offsetT val; { s->X_op = O_constant; s->X_add_number = val; s->X_add_symbol = NULL; s->X_op_symbol = NULL; } /* Set the expression to a symbol + constant offset. */ void set_expr_symbol_offset (s, sym, offset) expressionS *s; symbolS *sym; offsetT offset; { s->X_op = O_symbol; s->X_add_symbol = sym; s->X_op_symbol = NULL; /* unused */ s->X_add_number = offset; } bfd_boolean expr_is_equal (s1, s2) expressionS *s1; expressionS *s2; { if (s1->X_op != s2->X_op) return FALSE; if (s1->X_add_symbol != s2->X_add_symbol) return FALSE; if (s1->X_op_symbol != s2->X_op_symbol) return FALSE; if (s1->X_add_number != s2->X_add_number) return FALSE; return TRUE; } static void copy_expr (dst, src) expressionS *dst; const expressionS *src; { memcpy (dst, src, sizeof (expressionS)); } /* Support for Tensilica's "--rename-section" option. */ #ifdef XTENSA_SECTION_RENAME struct rename_section_struct { char *old_name; char *new_name; struct rename_section_struct *next; }; 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; { char *this_arg = NULL; char *next_arg = NULL; for (this_arg = strdup (arg); this_arg != NULL; this_arg = next_arg) { if (this_arg) { next_arg = strchr (this_arg, ':'); if (next_arg) { *next_arg = '\0'; next_arg++; } } { char *old_name = this_arg; char *new_name = strchr (this_arg, '='); if (*old_name == '\0') { as_warn (_("ignoring extra '-rename-section' delimiter ':'")); continue; } if (!new_name || new_name[1] == '\0') { as_warn (_("ignoring invalid '-rename-section' " "specification: '%s'"), old_name); continue; } *new_name = '\0'; new_name++; add_section_rename (old_name, new_name); } } } static void add_section_rename (old_name, new_name) char *old_name; char *new_name; { struct rename_section_struct *r = section_rename; /* Check for invalid section renaming. */ for (r = section_rename; r != NULL; r = r->next) { if (strcmp (r->old_name, old_name) == 0) as_bad (_("section %s renamed multiple times"), old_name); if (strcmp (r->new_name, new_name) == 0) as_bad (_("multiple sections remapped to output section %s"), new_name); } /* Now add it. */ r = (struct rename_section_struct *) xmalloc (sizeof (struct rename_section_struct)); r->old_name = strdup (old_name); r->new_name = strdup (new_name); r->next = section_rename; section_rename = r; } const char * xtensa_section_rename (name) const char *name; { struct rename_section_struct *r = section_rename; for (r = section_rename; r != NULL; r = r->next) if (strcmp (r->old_name, name) == 0) return r->new_name; return name; } #endif /* XTENSA_SECTION_RENAME */