blob: d062044d42f7992f32493622a87cb8c691429097 [file] [log] [blame]
/* tc-xtensa.c -- Assemble Xtensa instructions.
Copyright (C) 2003-2016 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 3, 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, 51 Franklin Street - Fifth Floor, Boston,
MA 02110-1301, USA. */
#include "as.h"
#include <limits.h>
#include "sb.h"
#include "safe-ctype.h"
#include "tc-xtensa.h"
#include "subsegs.h"
#include "xtensa-relax.h"
#include "dwarf2dbg.h"
#include "xtensa-istack.h"
#include "struc-symbol.h"
#include "xtensa-config.h"
#include "elf/xtensa.h"
/* Provide default values for new configuration settings. */
#ifndef XSHAL_ABI
#define XSHAL_ABI 0
#endif
#ifndef uint32
#define uint32 unsigned int
#endif
#ifndef int32
#define int32 signed int
#endif
/* Notes:
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";
/* Flags to indicate whether the hardware supports the density and
absolute literals options. */
bfd_boolean density_supported = XCHAL_HAVE_DENSITY;
bfd_boolean absolute_literals_supported = XSHAL_USE_ABSOLUTE_LITERALS;
static vliw_insn cur_vinsn;
unsigned xtensa_num_pipe_stages;
unsigned xtensa_fetch_width = XCHAL_INST_FETCH_WIDTH;
static enum debug_info_type xt_saved_debug_type = DEBUG_NONE;
/* Some functions are only valid in the front end. This variable
allows us to assert that we haven't crossed over into the
back end. */
static bfd_boolean past_xtensa_end = FALSE;
/* 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 LIT4_SECTION_NAME xtensa_section_rename (".lit4")
#define INIT_SECTION_NAME xtensa_section_rename (".init")
#define FINI_SECTION_NAME xtensa_section_rename (".fini")
/* This type is used for the directive_stack to keep track of the
state of the literal collection pools. If lit_prefix is set, it is
used to determine the literal section names; otherwise, the literal
sections are determined based on the current text section. The
lit_seg and lit4_seg fields cache these literal sections, with the
current_text_seg field used a tag to indicate whether the cached
values are valid. */
typedef struct lit_state_struct
{
char *lit_prefix;
segT current_text_seg;
segT lit_seg;
segT lit4_seg;
} lit_state;
static lit_state default_lit_sections;
/* We keep a list of literal segments. The seg_list type is the node
for this list. The literal_head pointer is the head of the list,
with the literal_head_h 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;
/* 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;
/* Flags to determine whether to prefer const16 or l32r
if both options are available. */
int prefer_const16 = 0;
int prefer_l32r = 0;
/* Global flag to indicate when we are emitting literals. */
int generating_literals = 0;
/* The following PROPERTY table definitions are copied from
<elf/xtensa.h> and must be kept in sync with the code there. */
/* Flags in the property tables to specify whether blocks of memory
are literals, instructions, data, or unreachable. For
instructions, blocks that begin loop targets and branch targets are
designated. Blocks that do not allow density, instruction
reordering or transformation are also specified. Finally, for
branch targets, branch target alignment priority is included.
Alignment of the next block is specified in the current block
and the size of the current block does not include any fill required
to align to the next block. */
#define XTENSA_PROP_LITERAL 0x00000001
#define XTENSA_PROP_INSN 0x00000002
#define XTENSA_PROP_DATA 0x00000004
#define XTENSA_PROP_UNREACHABLE 0x00000008
/* Instruction only properties at beginning of code. */
#define XTENSA_PROP_INSN_LOOP_TARGET 0x00000010
#define XTENSA_PROP_INSN_BRANCH_TARGET 0x00000020
/* Instruction only properties about code. */
#define XTENSA_PROP_INSN_NO_DENSITY 0x00000040
#define XTENSA_PROP_INSN_NO_REORDER 0x00000080
/* Historically, NO_TRANSFORM was a property of instructions,
but it should apply to literals under certain circumstances. */
#define XTENSA_PROP_NO_TRANSFORM 0x00000100
/* Branch target alignment information. This transmits information
to the linker optimization about the priority of aligning a
particular block for branch target alignment: None, low priority,
high priority, or required. These only need to be checked in
instruction blocks marked as XTENSA_PROP_INSN_BRANCH_TARGET.
Common usage is
switch (GET_XTENSA_PROP_BT_ALIGN (flags))
case XTENSA_PROP_BT_ALIGN_NONE:
case XTENSA_PROP_BT_ALIGN_LOW:
case XTENSA_PROP_BT_ALIGN_HIGH:
case XTENSA_PROP_BT_ALIGN_REQUIRE:
*/
#define XTENSA_PROP_BT_ALIGN_MASK 0x00000600
/* No branch target alignment. */
#define XTENSA_PROP_BT_ALIGN_NONE 0x0
/* Low priority branch target alignment. */
#define XTENSA_PROP_BT_ALIGN_LOW 0x1
/* High priority branch target alignment. */
#define XTENSA_PROP_BT_ALIGN_HIGH 0x2
/* Required branch target alignment. */
#define XTENSA_PROP_BT_ALIGN_REQUIRE 0x3
#define SET_XTENSA_PROP_BT_ALIGN(flag, align) \
(((flag) & (~XTENSA_PROP_BT_ALIGN_MASK)) | \
(((align) << 9) & XTENSA_PROP_BT_ALIGN_MASK))
/* Alignment is specified in the block BEFORE the one that needs
alignment. Up to 5 bits. Use GET_XTENSA_PROP_ALIGNMENT(flags) to
get the required alignment specified as a power of 2. Use
SET_XTENSA_PROP_ALIGNMENT(flags, pow2) to set the required
alignment. Be careful of side effects since the SET will evaluate
flags twice. Also, note that the SIZE of a block in the property
table does not include the alignment size, so the alignment fill
must be calculated to determine if two blocks are contiguous.
TEXT_ALIGN is not currently implemented but is a placeholder for a
possible future implementation. */
#define XTENSA_PROP_ALIGN 0x00000800
#define XTENSA_PROP_ALIGNMENT_MASK 0x0001f000
#define SET_XTENSA_PROP_ALIGNMENT(flag, align) \
(((flag) & (~XTENSA_PROP_ALIGNMENT_MASK)) | \
(((align) << 12) & XTENSA_PROP_ALIGNMENT_MASK))
#define XTENSA_PROP_INSN_ABSLIT 0x00020000
/* Structure for saving instruction and alignment per-fragment data
that will be written to the object file. This structure is
equivalent to the actual data that will be written out to the file
but is easier to use. We provide a conversion to file flags
in frag_flags_to_number. */
typedef struct frag_flags_struct frag_flags;
struct frag_flags_struct
{
/* is_literal should only be used after xtensa_move_literals.
If you need to check if you are generating a literal fragment,
then use the generating_literals global. */
unsigned is_literal : 1;
unsigned is_insn : 1;
unsigned is_data : 1;
unsigned is_unreachable : 1;
/* is_specific_opcode implies no_transform. */
unsigned is_no_transform : 1;
struct
{
unsigned is_loop_target : 1;
unsigned is_branch_target : 1; /* Branch targets have a priority. */
unsigned bt_align_priority : 2;
unsigned is_no_density : 1;
/* no_longcalls flag does not need to be placed in the object file. */
unsigned is_no_reorder : 1;
/* Uses absolute literal addressing for l32r. */
unsigned is_abslit : 1;
} insn;
unsigned is_align : 1;
unsigned alignment : 5;
};
/* Structure for saving information about a block of property data
for frags that have the same flags. */
struct xtensa_block_info_struct
{
segT sec;
bfd_vma offset;
size_t size;
frag_flags flags;
struct xtensa_block_info_struct *next;
};
/* 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;
/* Opcode placement information */
typedef unsigned long long bitfield;
#define bit_is_set(bit, bf) ((bf) & (0x01ll << (bit)))
#define set_bit(bit, bf) ((bf) |= (0x01ll << (bit)))
#define clear_bit(bit, bf) ((bf) &= ~(0x01ll << (bit)))
#define MAX_FORMATS 32
typedef struct op_placement_info_struct
{
int num_formats;
/* A number describing how restrictive the issue is for this
opcode. For example, an opcode that fits lots of different
formats has a high freedom, as does an opcode that fits
only one format but many slots in that format. The most
restrictive is the opcode that fits only one slot in one
format. */
int issuef;
xtensa_format narrowest;
char narrowest_size;
char narrowest_slot;
/* formats is a bitfield with the Nth bit set
if the opcode fits in the Nth xtensa_format. */
bitfield formats;
/* slots[N]'s Mth bit is set if the op fits in the
Mth slot of the Nth xtensa_format. */
bitfield slots[MAX_FORMATS];
/* A count of the number of slots in a given format
an op can fit (i.e., the bitcount of the slot field above). */
char slots_in_format[MAX_FORMATS];
} op_placement_info, *op_placement_info_table;
op_placement_info_table op_placement_table;
/* Extra expression types. */
#define O_pltrel O_md1 /* like O_symbol but use a PLT reloc */
#define O_hi16 O_md2 /* use high 16 bits of symbolic value */
#define O_lo16 O_md3 /* use low 16 bits of symbolic value */
#define O_pcrel O_md4 /* value is a PC-relative offset */
#define O_tlsfunc O_md5 /* TLS_FUNC/TLSDESC_FN relocation */
#define O_tlsarg O_md6 /* TLS_ARG/TLSDESC_ARG relocation */
#define O_tlscall O_md7 /* TLS_CALL relocation */
#define O_tpoff O_md8 /* TPOFF relocation */
#define O_dtpoff O_md9 /* DTPOFF relocation */
struct suffix_reloc_map
{
const char *suffix;
int length;
bfd_reloc_code_real_type reloc;
operatorT operator;
};
#define SUFFIX_MAP(str, reloc, op) { str, sizeof (str) - 1, reloc, op }
static struct suffix_reloc_map suffix_relocs[] =
{
SUFFIX_MAP ("l", BFD_RELOC_LO16, O_lo16),
SUFFIX_MAP ("h", BFD_RELOC_HI16, O_hi16),
SUFFIX_MAP ("plt", BFD_RELOC_XTENSA_PLT, O_pltrel),
SUFFIX_MAP ("pcrel", BFD_RELOC_32_PCREL, O_pcrel),
SUFFIX_MAP ("tlsfunc", BFD_RELOC_XTENSA_TLS_FUNC, O_tlsfunc),
SUFFIX_MAP ("tlsarg", BFD_RELOC_XTENSA_TLS_ARG, O_tlsarg),
SUFFIX_MAP ("tlscall", BFD_RELOC_XTENSA_TLS_CALL, O_tlscall),
SUFFIX_MAP ("tpoff", BFD_RELOC_XTENSA_TLS_TPOFF, O_tpoff),
SUFFIX_MAP ("dtpoff", BFD_RELOC_XTENSA_TLS_DTPOFF, O_dtpoff),
};
/* Directives. */
typedef enum
{
directive_none = 0,
directive_literal,
directive_density,
directive_transform,
directive_freeregs,
directive_longcalls,
directive_literal_prefix,
directive_schedule,
directive_absolute_literals,
directive_last_directive
} directiveE;
typedef struct
{
const char *name;
bfd_boolean can_be_negated;
} directive_infoS;
const directive_infoS directive_info[] =
{
{ "none", FALSE },
{ "literal", FALSE },
{ "density", TRUE },
{ "transform", TRUE },
{ "freeregs", FALSE },
{ "longcalls", TRUE },
{ "literal_prefix", FALSE },
{ "schedule", TRUE },
{ "absolute-literals", TRUE }
};
bfd_boolean directive_state[] =
{
FALSE, /* none */
FALSE, /* literal */
#if !XCHAL_HAVE_DENSITY
FALSE, /* density */
#else
TRUE, /* density */
#endif
TRUE, /* transform */
FALSE, /* freeregs */
FALSE, /* longcalls */
FALSE, /* literal_prefix */
FALSE, /* schedule */
#if XSHAL_USE_ABSOLUTE_LITERALS
TRUE /* absolute_literals */
#else
FALSE /* absolute_literals */
#endif
};
/* A circular list of all potential and actual literal pool locations
in a segment. */
struct litpool_frag
{
struct litpool_frag *next;
struct litpool_frag *prev;
fragS *fragP;
addressT addr;
short priority; /* 1, 2, or 3 -- 1 is highest */
short original_priority;
};
/* Map a segment to its litpool_frag list. */
struct litpool_seg
{
struct litpool_seg *next;
asection *seg;
struct litpool_frag frag_list;
int frag_count; /* since last litpool location */
};
static struct litpool_seg litpool_seg_list;
/* Directive functions. */
static void xtensa_begin_directive (int);
static void xtensa_end_directive (int);
static void xtensa_literal_prefix (void);
static void xtensa_literal_position (int);
static void xtensa_literal_pseudo (int);
static void xtensa_frequency_pseudo (int);
static void xtensa_elf_cons (int);
static void xtensa_leb128 (int);
/* Parsing and Idiom Translation. */
static bfd_reloc_code_real_type xtensa_elf_suffix (char **, expressionS *);
/* Various Other Internal Functions. */
extern bfd_boolean xg_is_single_relaxable_insn (TInsn *, TInsn *, bfd_boolean);
static bfd_boolean xg_build_to_insn (TInsn *, TInsn *, BuildInstr *);
static void xtensa_mark_literal_pool_location (void);
static addressT get_expanded_loop_offset (xtensa_opcode);
static fragS *get_literal_pool_location (segT);
static void set_literal_pool_location (segT, fragS *);
static void xtensa_set_frag_assembly_state (fragS *);
static void finish_vinsn (vliw_insn *);
static bfd_boolean emit_single_op (TInsn *);
static int total_frag_text_expansion (fragS *);
static bfd_boolean use_trampolines = TRUE;
static void xtensa_check_frag_count (void);
static void xtensa_create_trampoline_frag (bfd_boolean);
static void xtensa_maybe_create_trampoline_frag (void);
struct trampoline_frag;
static int init_trampoline_frag (struct trampoline_frag *);
static void xtensa_maybe_create_literal_pool_frag (bfd_boolean, bfd_boolean);
static bfd_boolean auto_litpools = FALSE;
static int auto_litpool_limit = 10000;
/* Alignment Functions. */
static int get_text_align_power (unsigned);
static int get_text_align_max_fill_size (int, bfd_boolean, bfd_boolean);
static int branch_align_power (segT);
/* Helpers for xtensa_relax_frag(). */
static long relax_frag_add_nop (fragS *);
/* Accessors for additional per-subsegment information. */
static unsigned get_last_insn_flags (segT, subsegT);
static void set_last_insn_flags (segT, subsegT, unsigned, bfd_boolean);
static float get_subseg_total_freq (segT, subsegT);
static float get_subseg_target_freq (segT, subsegT);
static void set_subseg_freq (segT, subsegT, float, float);
/* Segment list functions. */
static void xtensa_move_literals (void);
static void xtensa_reorder_segments (void);
static void xtensa_switch_to_literal_fragment (emit_state *);
static void xtensa_switch_to_non_abs_literal_fragment (emit_state *);
static void xtensa_switch_section_emit_state (emit_state *, segT, subsegT);
static void xtensa_restore_emit_state (emit_state *);
static segT cache_literal_section (bfd_boolean);
/* op_placement_info functions. */
static void init_op_placement_info_table (void);
extern bfd_boolean opcode_fits_format_slot (xtensa_opcode, xtensa_format, int);
static int xg_get_single_size (xtensa_opcode);
static xtensa_format xg_get_single_format (xtensa_opcode);
static int xg_get_single_slot (xtensa_opcode);
/* TInsn and IStack functions. */
static bfd_boolean tinsn_has_symbolic_operands (const TInsn *);
static bfd_boolean tinsn_has_invalid_symbolic_operands (const TInsn *);
static bfd_boolean tinsn_has_complex_operands (const TInsn *);
static bfd_boolean tinsn_to_insnbuf (TInsn *, xtensa_insnbuf);
static bfd_boolean tinsn_check_arguments (const TInsn *);
static void tinsn_from_chars (TInsn *, char *, int);
static void tinsn_immed_from_frag (TInsn *, fragS *, int);
static int get_num_stack_text_bytes (IStack *);
static int get_num_stack_literal_bytes (IStack *);
static bfd_boolean tinsn_to_slotbuf (xtensa_format, int, TInsn *, xtensa_insnbuf);
/* vliw_insn functions. */
static void xg_init_vinsn (vliw_insn *);
static void xg_copy_vinsn (vliw_insn *, vliw_insn *);
static void xg_clear_vinsn (vliw_insn *);
static bfd_boolean vinsn_has_specific_opcodes (vliw_insn *);
static void xg_free_vinsn (vliw_insn *);
static bfd_boolean vinsn_to_insnbuf
(vliw_insn *, char *, fragS *, bfd_boolean);
static void vinsn_from_chars (vliw_insn *, char *);
/* Expression Utilities. */
bfd_boolean expr_is_const (const expressionS *);
offsetT get_expr_const (const expressionS *);
void set_expr_const (expressionS *, offsetT);
bfd_boolean expr_is_register (const expressionS *);
offsetT get_expr_register (const expressionS *);
void set_expr_symbol_offset (expressionS *, symbolS *, offsetT);
bfd_boolean expr_is_equal (expressionS *, expressionS *);
static void copy_expr (expressionS *, const expressionS *);
/* Section renaming. */
static void build_section_rename (const char *);
/* 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_const16_opcode;
static xtensa_opcode xtensa_entry_opcode;
static xtensa_opcode xtensa_extui_opcode;
static xtensa_opcode xtensa_movi_opcode;
static xtensa_opcode xtensa_movi_n_opcode;
static xtensa_opcode xtensa_isync_opcode;
static xtensa_opcode xtensa_j_opcode;
static xtensa_opcode xtensa_jx_opcode;
static xtensa_opcode xtensa_l32r_opcode;
static xtensa_opcode xtensa_loop_opcode;
static xtensa_opcode xtensa_loopnez_opcode;
static xtensa_opcode xtensa_loopgtz_opcode;
static xtensa_opcode xtensa_nop_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_lcount_opcode;
static xtensa_opcode xtensa_waiti_opcode;
static int config_max_slots = 0;
/* Command-line Options. */
bfd_boolean use_literal_section = TRUE;
enum flix_level produce_flix = FLIX_ALL;
static bfd_boolean align_targets = TRUE;
static bfd_boolean warn_unaligned_branch_targets = FALSE;
static bfd_boolean has_a0_b_retw = FALSE;
static bfd_boolean workaround_a0_b_retw = FALSE;
static bfd_boolean workaround_b_j_loop_end = FALSE;
static bfd_boolean workaround_short_loop = FALSE;
static bfd_boolean maybe_has_short_loop = FALSE;
static bfd_boolean workaround_close_loop_end = FALSE;
static bfd_boolean maybe_has_close_loop_end = FALSE;
static bfd_boolean enforce_three_byte_loop_align = FALSE;
/* When workaround_short_loops is TRUE, all loops with early exits must
have at least 3 instructions. workaround_all_short_loops is a modifier
to the workaround_short_loop flag. In addition to the
workaround_short_loop actions, all straightline loopgtz and loopnez
must have at least 3 instructions. */
static bfd_boolean workaround_all_short_loops = FALSE;
static void
xtensa_setup_hw_workarounds (int earliest, int latest)
{
if (earliest > latest)
as_fatal (_("illegal range of target hardware versions"));
/* Enable all workarounds for pre-T1050.0 hardware. */
if (earliest < 105000 || latest < 105000)
{
workaround_a0_b_retw |= TRUE;
workaround_b_j_loop_end |= TRUE;
workaround_short_loop |= TRUE;
workaround_close_loop_end |= TRUE;
workaround_all_short_loops |= TRUE;
enforce_three_byte_loop_align = TRUE;
}
}
enum
{
option_density = OPTION_MD_BASE,
option_no_density,
option_flix,
option_no_generate_flix,
option_no_flix,
option_relax,
option_no_relax,
option_link_relax,
option_no_link_relax,
option_generics,
option_no_generics,
option_transform,
option_no_transform,
option_text_section_literals,
option_no_text_section_literals,
option_absolute_literals,
option_no_absolute_literals,
option_align_targets,
option_no_align_targets,
option_warn_unaligned_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,
option_rename_section_name,
option_prefer_l32r,
option_prefer_const16,
option_target_hardware,
option_trampolines,
option_no_trampolines,
option_auto_litpools,
option_no_auto_litpools,
option_auto_litpool_limit,
};
const char *md_shortopts = "";
struct option md_longopts[] =
{
{ "density", no_argument, NULL, option_density },
{ "no-density", no_argument, NULL, option_no_density },
{ "flix", no_argument, NULL, option_flix },
{ "no-generate-flix", no_argument, NULL, option_no_generate_flix },
{ "no-allow-flix", no_argument, NULL, option_no_flix },
/* Both "relax" and "generics" are deprecated and treated as equivalent
to the "transform" option. */
{ "relax", no_argument, NULL, option_relax },
{ "no-relax", no_argument, NULL, option_no_relax },
{ "generics", no_argument, NULL, option_generics },
{ "no-generics", no_argument, NULL, option_no_generics },
{ "transform", no_argument, NULL, option_transform },
{ "no-transform", no_argument, NULL, option_no_transform },
{ "text-section-literals", no_argument, NULL, option_text_section_literals },
{ "no-text-section-literals", no_argument, NULL,
option_no_text_section_literals },
{ "absolute-literals", no_argument, NULL, option_absolute_literals },
{ "no-absolute-literals", no_argument, NULL, option_no_absolute_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 },
{ "warn-unaligned-targets", no_argument, NULL,
option_warn_unaligned_targets },
{ "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 },
{ "prefer-l32r", no_argument, NULL, option_prefer_l32r },
{ "prefer-const16", no_argument, NULL, option_prefer_const16 },
{ "no-workarounds", no_argument, NULL, option_no_workarounds },
{ "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 },
{ "rename-section", required_argument, NULL, option_rename_section_name },
{ "link-relax", no_argument, NULL, option_link_relax },
{ "no-link-relax", no_argument, NULL, option_no_link_relax },
{ "target-hardware", required_argument, NULL, option_target_hardware },
{ "trampolines", no_argument, NULL, option_trampolines },
{ "no-trampolines", no_argument, NULL, option_no_trampolines },
{ "auto-litpools", no_argument, NULL, option_auto_litpools },
{ "no-auto-litpools", no_argument, NULL, option_no_auto_litpools },
{ "auto-litpool-limit", required_argument, NULL, option_auto_litpool_limit },
{ NULL, no_argument, NULL, 0 }
};
size_t md_longopts_size = sizeof md_longopts;
int
md_parse_option (int c, const char *arg)
{
switch (c)
{
case option_density:
as_warn (_("--density option is ignored"));
return 1;
case option_no_density:
as_warn (_("--no-density option is ignored"));
return 1;
case option_link_relax:
linkrelax = 1;
return 1;
case option_no_link_relax:
linkrelax = 0;
return 1;
case option_flix:
produce_flix = FLIX_ALL;
return 1;
case option_no_generate_flix:
produce_flix = FLIX_NO_GENERATE;
return 1;
case option_no_flix:
produce_flix = FLIX_NONE;
return 1;
case option_generics:
as_warn (_("--generics is deprecated; use --transform instead"));
return md_parse_option (option_transform, arg);
case option_no_generics:
as_warn (_("--no-generics is deprecated; use --no-transform instead"));
return md_parse_option (option_no_transform, arg);
case option_relax:
as_warn (_("--relax is deprecated; use --transform instead"));
return md_parse_option (option_transform, arg);
case option_no_relax:
as_warn (_("--no-relax is deprecated; use --no-transform instead"));
return md_parse_option (option_no_transform, arg);
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_absolute_literals:
if (!absolute_literals_supported)
{
as_fatal (_("--absolute-literals option not supported in this Xtensa configuration"));
return 0;
}
directive_state[directive_absolute_literals] = TRUE;
return 1;
case option_no_absolute_literals:
directive_state[directive_absolute_literals] = FALSE;
return 1;
case option_workaround_a0_b_retw:
workaround_a0_b_retw = TRUE;
return 1;
case option_no_workaround_a0_b_retw:
workaround_a0_b_retw = FALSE;
return 1;
case option_workaround_b_j_loop_end:
workaround_b_j_loop_end = TRUE;
return 1;
case option_no_workaround_b_j_loop_end:
workaround_b_j_loop_end = FALSE;
return 1;
case option_workaround_short_loop:
workaround_short_loop = TRUE;
return 1;
case option_no_workaround_short_loop:
workaround_short_loop = FALSE;
return 1;
case option_workaround_all_short_loops:
workaround_all_short_loops = TRUE;
return 1;
case option_no_workaround_all_short_loops:
workaround_all_short_loops = FALSE;
return 1;
case option_workaround_close_loop_end:
workaround_close_loop_end = TRUE;
return 1;
case option_no_workaround_close_loop_end:
workaround_close_loop_end = FALSE;
return 1;
case option_no_workarounds:
workaround_a0_b_retw = FALSE;
workaround_b_j_loop_end = FALSE;
workaround_short_loop = FALSE;
workaround_all_short_loops = FALSE;
workaround_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_warn_unaligned_targets:
warn_unaligned_branch_targets = TRUE;
return 1;
case option_rename_section_name:
build_section_rename (arg);
return 1;
case 'Q':
/* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
should be emitted or not. FIXME: Not implemented. */
return 1;
case option_prefer_l32r:
if (prefer_const16)
as_fatal (_("prefer-l32r conflicts with prefer-const16"));
prefer_l32r = 1;
return 1;
case option_prefer_const16:
if (prefer_l32r)
as_fatal (_("prefer-const16 conflicts with prefer-l32r"));
prefer_const16 = 1;
return 1;
case option_target_hardware:
{
int earliest, latest = 0;
char *end;
if (*arg == 0 || *arg == '-')
as_fatal (_("invalid target hardware version"));
earliest = strtol (arg, &end, 0);
if (*end == 0)
latest = earliest;
else if (*end == '-')
{
if (*++end == 0)
as_fatal (_("invalid target hardware version"));
latest = strtol (end, &end, 0);
}
if (*end != 0)
as_fatal (_("invalid target hardware version"));
xtensa_setup_hw_workarounds (earliest, latest);
return 1;
}
case option_transform:
/* This option has no affect other than to use the defaults,
which are already set. */
return 1;
case option_no_transform:
/* This option turns off all transformations of any kind.
However, because we want to preserve the state of other
directives, we only change its own field. Thus, before
you perform any transformation, always check if transform
is available. If you use the functions we provide for this
purpose, you will be ok. */
directive_state[directive_transform] = FALSE;
return 1;
case option_trampolines:
use_trampolines = TRUE;
return 1;
case option_no_trampolines:
use_trampolines = FALSE;
return 1;
case option_auto_litpools:
auto_litpools = TRUE;
use_literal_section = FALSE;
return 1;
case option_no_auto_litpools:
auto_litpools = FALSE;
auto_litpool_limit = -1;
return 1;
case option_auto_litpool_limit:
{
int value = 0;
char *end;
if (auto_litpool_limit < 0)
as_fatal (_("no-auto-litpools is incompatible with auto-litpool-limit"));
if (*arg == 0 || *arg == '-')
as_fatal (_("invalid auto-litpool-limit argument"));
value = strtol (arg, &end, 10);
if (*end != 0)
as_fatal (_("invalid auto-litpool-limit argument"));
if (value < 100 || value > 10000)
as_fatal (_("invalid auto-litpool-limit argument (range is 100-10000)"));
auto_litpool_limit = value;
auto_litpools = TRUE;
use_literal_section = FALSE;
return 1;
}
default:
return 0;
}
}
void
md_show_usage (FILE *stream)
{
fputs ("\n\
Xtensa options:\n\
--[no-]text-section-literals\n\
[Do not] put literals in the text section\n\
--[no-]absolute-literals\n\
[Do not] default to use non-PC-relative literals\n\
--[no-]target-align [Do not] try to align branch targets\n\
--[no-]longcalls [Do not] emit 32-bit call sequences\n\
--[no-]transform [Do not] transform instructions\n\
--flix both allow hand-written and generate flix bundles\n\
--no-generate-flix allow hand-written but do not generate\n\
flix bundles\n\
--no-allow-flix neither allow hand-written nor generate\n\
flix bundles\n\
--rename-section old=new Rename section 'old' to 'new'\n\
--[no-]trampolines [Do not] generate trampolines (jumps to jumps)\n\
when jumps do not reach their targets\n\
--[no-]auto-litpools [Do not] automatically create literal pools\n\
--auto-litpool-limit=<value>\n\
(range 100-10000) Maximum number of blocks of\n\
instructions to emit between literal pool\n\
locations; implies --auto-litpools flag\n", stream);
}
/* Functions related to the list of current label symbols. */
static void
xtensa_add_insn_label (symbolS *sym)
{
sym_list *l;
if (!free_insn_labels)
l = XNEW (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;
}
static void
xtensa_move_labels (fragS *new_frag, valueT new_offset)
{
sym_list *lit;
for (lit = insn_labels; lit; lit = lit->next)
{
symbolS *lit_sym = lit->sym;
S_SET_VALUE (lit_sym, new_offset);
symbol_set_frag (lit_sym, new_frag);
}
}
/* 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. */
{ "long", xtensa_elf_cons, 4 },
{ "word", xtensa_elf_cons, 4 },
{ "4byte", xtensa_elf_cons, 4 },
{ "short", xtensa_elf_cons, 2 },
{ "2byte", xtensa_elf_cons, 2 },
{ "sleb128", xtensa_leb128, 1},
{ "uleb128", xtensa_leb128, 0},
{ "begin", xtensa_begin_directive, 0 },
{ "end", xtensa_end_directive, 0 },
{ "literal", xtensa_literal_pseudo, 0 },
{ "frequency", xtensa_frequency_pseudo, 0 },
{ NULL, 0, 0 },
};
static bfd_boolean
use_transform (void)
{
/* After md_end, you should be checking frag by frag, rather
than state directives. */
gas_assert (!past_xtensa_end);
return directive_state[directive_transform];
}
static bfd_boolean
do_align_targets (void)
{
/* Do not use this function after md_end; just look at align_targets
instead. There is no target-align directive, so alignment is either
enabled for all frags or not done at all. */
gas_assert (!past_xtensa_end);
return align_targets && use_transform ();
}
static void
directive_push (directiveE directive, bfd_boolean negated, const void *datum)
{
const char *file;
unsigned int line;
state_stackS *stack = XNEW (state_stackS);
file = as_where (&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 (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 (void)
{
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 (directiveE dir)
{
state_stackS *top = directive_state_stack;
while (top && top->directive != dir)
top = top->prev;
return (top != NULL);
}
static void
get_directive (directiveE *directive, bfd_boolean *negated)
{
int len;
unsigned i;
const char *directive_string;
if (strncmp (input_line_pointer, "no-", 3) != 0)
*negated = FALSE;
else
{
*negated = TRUE;
input_line_pointer += 3;
}
len = strspn (input_line_pointer,
"abcdefghijklmnopqrstuvwxyz_-/0123456789.");
/* This code is a hack to make .begin [no-][generics|relax] exactly
equivalent to .begin [no-]transform. We should remove it when
we stop accepting those options. */
if (strncmp (input_line_pointer, "generics", strlen ("generics")) == 0)
{
as_warn (_("[no-]generics is deprecated; use [no-]transform instead"));
directive_string = "transform";
}
else if (strncmp (input_line_pointer, "relax", strlen ("relax")) == 0)
{
as_warn (_("[no-]relax is deprecated; use [no-]transform instead"));
directive_string = "transform";
}
else
directive_string = input_line_pointer;
for (i = 0; i < sizeof (directive_info) / sizeof (*directive_info); ++i)
{
if (strncmp (directive_string, 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 cannot be negated"),
directive_info[i].name);
return;
}
}
as_bad (_("unknown directive"));
*directive = (directiveE) XTENSA_UNDEFINED;
}
static void
xtensa_begin_directive (int ignore ATTRIBUTE_UNUSED)
{
directiveE directive;
bfd_boolean negated;
emit_state *state;
lit_state *ls;
get_directive (&directive, &negated);
if (directive == (directiveE) XTENSA_UNDEFINED)
{
discard_rest_of_line ();
return;
}
if (cur_vinsn.inside_bundle)
as_bad (_("directives are not valid inside bundles"));
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;
}
as_warn (_(".begin literal is deprecated; use .literal instead"));
state = XNEW (emit_state);
xtensa_switch_to_literal_fragment (state);
directive_push (directive_literal, negated, state);
break;
case directive_literal_prefix:
/* Have to flush pending output because a movi relaxed to an l32r
might produce a literal. */
md_flush_pending_output ();
/* Check to see if the current fragment is a literal
fragment. If it is, then this operation is not allowed. */
if (generating_literals)
{
as_bad (_("cannot set literal_prefix inside literal fragment"));
return;
}
/* Allocate the literal state for this section and push
onto the directive stack. */
ls = XNEW (lit_state);
gas_assert (ls);
*ls = default_lit_sections;
directive_push (directive_literal_prefix, negated, ls);
/* Process the new prefix. */
xtensa_literal_prefix ();
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_schedule:
md_flush_pending_output ();
frag_var (rs_fill, 0, 0, frag_now->fr_subtype,
frag_now->fr_symbol, frag_now->fr_offset, NULL);
directive_push (directive_schedule, negated, 0);
xtensa_set_frag_assembly_state (frag_now);
break;
case directive_density:
as_warn (_(".begin [no-]density is ignored"));
break;
case directive_absolute_literals:
md_flush_pending_output ();
if (!absolute_literals_supported && !negated)
{
as_warn (_("Xtensa absolute literals option not supported; ignored"));
break;
}
xtensa_set_frag_assembly_state (frag_now);
directive_push (directive, negated, 0);
break;
default:
md_flush_pending_output ();
xtensa_set_frag_assembly_state (frag_now);
directive_push (directive, negated, 0);
break;
}
demand_empty_rest_of_line ();
}
static void
xtensa_end_directive (int ignore ATTRIBUTE_UNUSED)
{
directiveE begin_directive, end_directive;
bfd_boolean begin_negated, end_negated;
const char *file;
unsigned int line;
emit_state *state;
emit_state **state_ptr;
lit_state *s;
if (cur_vinsn.inside_bundle)
as_bad (_("directives are not valid inside bundles"));
get_directive (&end_directive, &end_negated);
md_flush_pending_output ();
switch ((int) end_directive)
{
case XTENSA_UNDEFINED:
discard_rest_of_line ();
return;
case (int) directive_density:
as_warn (_(".end [no-]density is ignored"));
demand_empty_rest_of_line ();
break;
case (int) directive_absolute_literals:
if (!absolute_literals_supported && !end_negated)
{
as_warn (_("Xtensa absolute literals option not supported; ignored"));
demand_empty_rest_of_line ();
return;
}
break;
default:
break;
}
state_ptr = &state; /* use state_ptr to avoid type-punning warning */
directive_pop (&begin_directive, &begin_negated, &file, &line,
(const void **) state_ptr);
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);
xtensa_set_frag_assembly_state (frag_now);
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_literal_prefix:
/* Restore the default collection sections from saved state. */
s = (lit_state *) state;
gas_assert (s);
default_lit_sections = *s;
/* Free the state storage. */
free (s->lit_prefix);
free (s);
break;
case directive_schedule:
case directive_freeregs:
break;
default:
xtensa_set_frag_assembly_state (frag_now);
break;
}
}
}
demand_empty_rest_of_line ();
}
/* Place an aligned literal fragment at the current location. */
static void
xtensa_literal_position (int ignore ATTRIBUTE_UNUSED)
{
md_flush_pending_output ();
if (inside_directive (directive_literal))
as_warn (_(".literal_position inside literal directive; ignoring"));
xtensa_mark_literal_pool_location ();
demand_empty_rest_of_line ();
xtensa_clear_insn_labels ();
}
/* Support .literal label, expr, ... */
static void
xtensa_literal_pseudo (int ignored ATTRIBUTE_UNUSED)
{
emit_state state;
char *p, *base_name;
char c;
segT dest_seg;
if (inside_directive (directive_literal))
{
as_bad (_(".literal not allowed inside .begin literal region"));
ignore_rest_of_line ();
return;
}
md_flush_pending_output ();
/* 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 || directive_state[directive_absolute_literals])
dest_seg = now_seg;
/* FIXME, despite the previous comments, dest_seg is unused... */
(void) dest_seg;
/* All literals are aligned to four-byte boundaries. */
frag_align (2, 0, 0);
record_alignment (now_seg, 2);
c = get_symbol_name (&base_name);
/* Just after name is now '\0'. */
p = input_line_pointer;
*p = c;
SKIP_WHITESPACE_AFTER_NAME ();
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);
*p = c;
input_line_pointer++; /* skip ',' or ':' */
xtensa_elf_cons (4);
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 (void)
{
char *name;
int len;
/* Parse the new prefix from the input_line_pointer. */
SKIP_WHITESPACE ();
len = strspn (input_line_pointer,
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz_/0123456789.$");
/* Get a null-terminated copy of the name. */
name = xmemdup0 (input_line_pointer, len);
/* Skip the name in the input line. */
input_line_pointer += len;
default_lit_sections.lit_prefix = name;
/* Clear cached literal sections, since the prefix has changed. */
default_lit_sections.lit_seg = NULL;
default_lit_sections.lit4_seg = NULL;
}
/* Support ".frequency branch_target_frequency fall_through_frequency". */
static void
xtensa_frequency_pseudo (int ignored ATTRIBUTE_UNUSED)
{
float fall_through_f, target_f;
fall_through_f = (float) strtod (input_line_pointer, &input_line_pointer);
if (fall_through_f < 0)
{
as_bad (_("fall through frequency must be greater than 0"));
ignore_rest_of_line ();
return;
}
target_f = (float) strtod (input_line_pointer, &input_line_pointer);
if (target_f < 0)
{
as_bad (_("branch target frequency must be greater than 0"));
ignore_rest_of_line ();
return;
}
set_subseg_freq (now_seg, now_subseg, target_f + fall_through_f, target_f);
demand_empty_rest_of_line ();
}
/* Like normal .long/.short/.word, except support @plt, etc.
Clobbers input_line_pointer, checks end-of-line. */
static void
xtensa_elf_cons (int nbytes)
{
expressionS exp;
bfd_reloc_code_real_type reloc;
md_flush_pending_output ();
if (cur_vinsn.inside_bundle)
as_bad (_("directives are not valid inside bundles"));
if (is_it_end_of_statement ())
{
demand_empty_rest_of_line ();
return;
}
do
{
expression (&exp);
if (exp.X_op == O_symbol
&& *input_line_pointer == '@'
&& ((reloc = xtensa_elf_suffix (&input_line_pointer, &exp))
!= BFD_RELOC_NONE))
{
reloc_howto_type *reloc_howto =
bfd_reloc_type_lookup (stdoutput, reloc);
if (reloc == BFD_RELOC_UNUSED || !reloc_howto)
as_bad (_("unsupported relocation"));
else if ((reloc >= BFD_RELOC_XTENSA_SLOT0_OP
&& reloc <= BFD_RELOC_XTENSA_SLOT14_OP)
|| (reloc >= BFD_RELOC_XTENSA_SLOT0_ALT
&& reloc <= BFD_RELOC_XTENSA_SLOT14_ALT))
as_bad (_("opcode-specific %s relocation used outside "
"an instruction"), reloc_howto->name);
else if (nbytes != (int) bfd_get_reloc_size (reloc_howto))
as_bad (_("%s relocations do not fit in %d bytes"),
reloc_howto->name, nbytes);
else if (reloc == BFD_RELOC_XTENSA_TLS_FUNC
|| reloc == BFD_RELOC_XTENSA_TLS_ARG
|| reloc == BFD_RELOC_XTENSA_TLS_CALL)
as_bad (_("invalid use of %s relocation"), reloc_howto->name);
else
{
char *p = frag_more ((int) nbytes);
xtensa_set_frag_assembly_state (frag_now);
fix_new_exp (frag_now, p - frag_now->fr_literal,
nbytes, &exp, reloc_howto->pc_relative, reloc);
}
}
else
{
xtensa_set_frag_assembly_state (frag_now);
emit_expr (&exp, (unsigned int) nbytes);
}
}
while (*input_line_pointer++ == ',');
input_line_pointer--; /* Put terminator back into stream. */
demand_empty_rest_of_line ();
}
static bfd_boolean is_leb128_expr;
static void
xtensa_leb128 (int sign)
{
is_leb128_expr = TRUE;
s_leb128 (sign);
is_leb128_expr = FALSE;
}
/* Parsing and Idiom Translation. */
/* Parse @plt, etc. and return the desired relocation. */
static bfd_reloc_code_real_type
xtensa_elf_suffix (char **str_p, expressionS *exp_p)
{
char ident[20];
char *str = *str_p;
char *str2;
int ch;
int len;
unsigned int i;
if (*str++ != '@')
return BFD_RELOC_NONE;
for (ch = *str, str2 = ident;
(str2 < ident + sizeof (ident) - 1
&& (ISALNUM (ch) || ch == '@'));
ch = *++str)
{
*str2++ = (ISLOWER (ch)) ? ch : TOLOWER (ch);
}
*str2 = '\0';
len = str2 - ident;
ch = ident[0];
for (i = 0; i < ARRAY_SIZE (suffix_relocs); i++)
if (ch == suffix_relocs[i].suffix[0]
&& len == suffix_relocs[i].length
&& memcmp (ident, suffix_relocs[i].suffix, suffix_relocs[i].length) == 0)
{
/* Now check for "identifier@suffix+constant". */
if (*str == '-' || *str == '+')
{
char *orig_line = input_line_pointer;
expressionS new_exp;
input_line_pointer = str;
expression (&new_exp);
if (new_exp.X_op == O_constant)
{
exp_p->X_add_number += new_exp.X_add_number;
str = input_line_pointer;
}
if (&input_line_pointer != str_p)
input_line_pointer = orig_line;
}
*str_p = str;
return suffix_relocs[i].reloc;
}
return BFD_RELOC_UNUSED;
}
/* Find the matching operator type. */
static operatorT
map_suffix_reloc_to_operator (bfd_reloc_code_real_type reloc)
{
operatorT operator = O_illegal;
unsigned int i;
for (i = 0; i < ARRAY_SIZE (suffix_relocs); i++)
{
if (suffix_relocs[i].reloc == reloc)
{
operator = suffix_relocs[i].operator;
break;
}
}
gas_assert (operator != O_illegal);
return operator;
}
/* Find the matching reloc type. */
static bfd_reloc_code_real_type
map_operator_to_reloc (unsigned char operator, bfd_boolean is_literal)
{
unsigned int i;
bfd_reloc_code_real_type reloc = BFD_RELOC_UNUSED;
for (i = 0; i < ARRAY_SIZE (suffix_relocs); i++)
{
if (suffix_relocs[i].operator == operator)
{
reloc = suffix_relocs[i].reloc;
break;
}
}
if (is_literal)
{
if (reloc == BFD_RELOC_XTENSA_TLS_FUNC)
return BFD_RELOC_XTENSA_TLSDESC_FN;
else if (reloc == BFD_RELOC_XTENSA_TLS_ARG)
return BFD_RELOC_XTENSA_TLSDESC_ARG;
}
if (reloc == BFD_RELOC_UNUSED)
return BFD_RELOC_32;
return reloc;
}
static const char *
expression_end (const char *name)
{
while (1)
{
switch (*name)
{
case '}':
case ';':
case '\0':
case ',':
case ':':
return name;
case ' ':
case '\t':
++name;
continue;
default:
return 0;
}
}
}
#define ERROR_REG_NUM ((unsigned) -1)
static unsigned
tc_get_register (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;
}
static void
expression_maybe_register (xtensa_opcode opc, int opnd, expressionS *tok)
{
xtensa_isa isa = xtensa_default_isa;
/* Check if this is an immediate operand. */
if (xtensa_operand_is_register (isa, opc, opnd) == 0)
{
bfd_reloc_code_real_type reloc;
segT t = expression (tok);
if (t == absolute_section
&& xtensa_operand_is_PCrelative (isa, opc, opnd) == 1)
{
gas_assert (tok->X_op == O_constant);
tok->X_op = O_symbol;
tok->X_add_symbol = &abs_symbol;
}
if ((tok->X_op == O_constant || tok->X_op == O_symbol)
&& ((reloc = xtensa_elf_suffix (&input_line_pointer, tok))
!= BFD_RELOC_NONE))
{
switch (reloc)
{
case BFD_RELOC_LO16:
if (tok->X_op == O_constant)
{
tok->X_add_number &= 0xffff;
return;
}
break;
case BFD_RELOC_HI16:
if (tok->X_op == O_constant)
{
tok->X_add_number = ((unsigned) tok->X_add_number) >> 16;
return;
}
break;
case BFD_RELOC_UNUSED:
as_bad (_("unsupported relocation"));
return;
case BFD_RELOC_32_PCREL:
as_bad (_("pcrel relocation not allowed in an instruction"));
return;
default:
break;
}
tok->X_op = map_suffix_reloc_to_operator (reloc);
}
}
else
{
xtensa_regfile opnd_rf = xtensa_operand_regfile (isa, opc, opnd);
unsigned reg = tc_get_register (xtensa_regfile_shortname (isa, opnd_rf));
if (reg != ERROR_REG_NUM) /* Already errored */
{
uint32 buf = reg;
if (xtensa_operand_encode (isa, opc, 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 (char **args, char *str)
{
char *old_input_line_pointer;
bfd_boolean saw_comma = FALSE;
bfd_boolean saw_arg = FALSE;
bfd_boolean saw_colon = 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':
case '}':
goto fini;
case ':':
input_line_pointer++;
if (saw_comma || saw_colon || !saw_arg)
goto err;
saw_colon = TRUE;
break;
case ',':
input_line_pointer++;
if (saw_comma || saw_colon || !saw_arg)
goto err;
saw_comma = TRUE;
break;
default:
if (!saw_comma && !saw_colon && 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 = XNEWVEC (char, (saw_colon ? 1 : 0) + arg_len + 1);
args[num_args] = arg;
if (saw_colon)
*arg++ = ':';
strncpy (arg, input_line_pointer, arg_len);
arg[arg_len] = '\0';
input_line_pointer = arg_end;
num_args += 1;
saw_comma = FALSE;
saw_colon = FALSE;
saw_arg = TRUE;
break;
}
}
fini:
if (saw_comma || saw_colon)
goto err;
input_line_pointer = old_input_line_pointer;
return num_args;
err:
if (saw_comma)
as_bad (_("extra comma"));
else if (saw_colon)
as_bad (_("extra colon"));
else if (!saw_arg)
as_bad (_("missing argument"));
else
as_bad (_("missing comma or colon"));
input_line_pointer = old_input_line_pointer;
return -1;
}
/* Parse the arguments to an opcode. Return TRUE on error. */
static bfd_boolean
parse_arguments (TInsn *insn, int num_args, char **arg_strings)
{
expressionS *tok, *last_tok;
xtensa_opcode opcode = insn->opcode;
bfd_boolean had_error = TRUE;
xtensa_isa isa = xtensa_default_isa;
int n, num_regs = 0;
int opcode_operand_count;
int opnd_cnt, last_opnd_cnt;
unsigned int next_reg = 0;
char *old_input_line_pointer;
if (insn->insn_type == ITYPE_LITERAL)
opcode_operand_count = 1;
else
opcode_operand_count = xtensa_opcode_num_operands (isa, opcode);
tok = insn->tok;
memset (tok, 0, sizeof (*tok) * MAX_INSN_ARGS);
/* Save and restore input_line_pointer around this function. */
old_input_line_pointer = input_line_pointer;
last_tok = 0;
last_opnd_cnt = -1;
opnd_cnt = 0;
/* Skip invisible operands. */
while (xtensa_operand_is_visible (isa, opcode, opnd_cnt) == 0)
{
opnd_cnt += 1;
tok++;
}
for (n = 0; n < num_args; n++)
{
input_line_pointer = arg_strings[n];
if (*input_line_pointer == ':')
{
xtensa_regfile opnd_rf;
input_line_pointer++;
if (num_regs == 0)
goto err;
gas_assert (opnd_cnt > 0);
num_regs--;
opnd_rf = xtensa_operand_regfile (isa, opcode, last_opnd_cnt);
if (next_reg
!= tc_get_register (xtensa_regfile_shortname (isa, opnd_rf)))
as_warn (_("incorrect register number, ignoring"));
next_reg++;
}
else
{
if (opnd_cnt >= opcode_operand_count)
{
as_warn (_("too many arguments"));
goto err;
}
gas_assert (opnd_cnt < MAX_INSN_ARGS);
expression_maybe_register (opcode, opnd_cnt, tok);
next_reg = tok->X_add_number + 1;
if (tok->X_op == O_illegal || tok->X_op == O_absent)
goto err;
if (xtensa_operand_is_register (isa, opcode, opnd_cnt) == 1)
{
num_regs = xtensa_operand_num_regs (isa, opcode, opnd_cnt) - 1;
/* minus 1 because we are seeing one right now */
}
else
num_regs = 0;
last_tok = tok;
last_opnd_cnt = opnd_cnt;
demand_empty_rest_of_line ();
do
{
opnd_cnt += 1;
tok++;
}
while (xtensa_operand_is_visible (isa, opcode, opnd_cnt) == 0);
}
}
if (num_regs > 0 && ((int) next_reg != last_tok->X_add_number + 1))
goto err;
insn->ntok = tok - insn->tok;
had_error = FALSE;
err:
input_line_pointer = old_input_line_pointer;
return had_error;
}
static int
get_invisible_operands (TInsn *insn)
{
xtensa_isa isa = xtensa_default_isa;
static xtensa_insnbuf slotbuf = NULL;
xtensa_format fmt;
xtensa_opcode opc = insn->opcode;
int slot, opnd, fmt_found;
unsigned val;
if (!slotbuf)
slotbuf = xtensa_insnbuf_alloc (isa);
/* Find format/slot where this can be encoded. */
fmt_found = 0;
slot = 0;
for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
{
for (slot = 0; slot < xtensa_format_num_slots (isa, fmt); slot++)
{
if (xtensa_opcode_encode (isa, fmt, slot, slotbuf, opc) == 0)
{
fmt_found = 1;
break;
}
}
if (fmt_found) break;
}
if (!fmt_found)
{
as_bad (_("cannot encode opcode \"%s\""), xtensa_opcode_name (isa, opc));
return -1;
}
/* First encode all the visible operands
(to deal with shared field operands). */
for (opnd = 0; opnd < insn->ntok; opnd++)
{
if (xtensa_operand_is_visible (isa, opc, opnd) == 1
&& (insn->tok[opnd].X_op == O_register
|| insn->tok[opnd].X_op == O_constant))
{
val = insn->tok[opnd].X_add_number;
xtensa_operand_encode (isa, opc, opnd, &val);
xtensa_operand_set_field (isa, opc, opnd, fmt, slot, slotbuf, val);
}
}
/* Then pull out the values for the invisible ones. */
for (opnd = 0; opnd < insn->ntok; opnd++)
{
if (xtensa_operand_is_visible (isa, opc, opnd) == 0)
{
xtensa_operand_get_field (isa, opc, opnd, fmt, slot, slotbuf, &val);
xtensa_operand_decode (isa, opc, opnd, &val);
insn->tok[opnd].X_add_number = val;
if (xtensa_operand_is_register (isa, opc, opnd) == 1)
insn->tok[opnd].X_op = O_register;
else
insn->tok[opnd].X_op = O_constant;
}
}
return 0;
}
static void
xg_reverse_shift_count (char **cnt_argp)
{
char *cnt_arg, *new_arg;
cnt_arg = *cnt_argp;
/* replace the argument with "31-(argument)" */
new_arg = concat ("31-(", cnt_argp, ")", (char *) NULL);
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 (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 (char **popname, const char *newop)
{
free (*popname);
*popname = xstrdup (newop);
}
static int
xg_check_num_args (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;
}
/* If the register is not specified as part of the opcode,
then get it from the operand and move it to the opcode. */
static int
xg_translate_sysreg_op (char **popname, int *pnum_args, char **arg_strings)
{
xtensa_isa isa = xtensa_default_isa;
xtensa_sysreg sr;
char *opname, *new_opname;
const char *sr_name;
int is_user, is_write;
opname = *popname;
if (*opname == '_')
opname += 1;
is_user = (opname[1] == 'u');
is_write = (opname[0] == 'w');
/* Opname == [rw]ur or [rwx]sr... */
if (xg_check_num_args (pnum_args, 2, opname, arg_strings))
return -1;
/* Check if the argument is a symbolic register name. */
sr = xtensa_sysreg_lookup_name (isa, arg_strings[1]);
/* Handle WSR to "INTSET" as a special case. */
if (sr == XTENSA_UNDEFINED && is_write && !is_user
&& !strcasecmp (arg_strings[1], "intset"))
sr = xtensa_sysreg_lookup_name (isa, "interrupt");
if (sr == XTENSA_UNDEFINED
|| (xtensa_sysreg_is_user (isa, sr) == 1) != is_user)
{
/* Maybe it's a register number.... */
offsetT val;
if (!xg_arg_is_constant (arg_strings[1], &val))
{
as_bad (_("invalid register '%s' for '%s' instruction"),
arg_strings[1], opname);
return -1;
}
sr = xtensa_sysreg_lookup (isa, val, is_user);
if (sr == XTENSA_UNDEFINED)
{
as_bad (_("invalid register number (%ld) for '%s' instruction"),
(long) 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. */
sr_name = xtensa_sysreg_name (isa, sr);
/* Another special case for "WSR.INTSET".... */
if (is_write && !is_user && !strcasecmp ("interrupt", sr_name))
sr_name = "intset";
new_opname = concat (*popname, ".", sr_name, (char *) NULL);
free (*popname);
*popname = new_opname;
return 0;
}
static int
xtensa_translate_old_userreg_ops (char **popname)
{
xtensa_isa isa = xtensa_default_isa;
xtensa_sysreg sr;
char *opname, *new_opname;
const char *sr_name;
bfd_boolean has_underbar = FALSE;
opname = *popname;
if (opname[0] == '_')
{
has_underbar = TRUE;
opname += 1;
}
sr = xtensa_sysreg_lookup_name (isa, opname + 1);
if (sr != XTENSA_UNDEFINED)
{
/* The new default name ("nnn") is different from the old default
name ("URnnn"). The old default is handled below, and we don't
want to recognize [RW]nnn, so do nothing if the name is the (new)
default. */
static char namebuf[10];
sprintf (namebuf, "%d", xtensa_sysreg_number (isa, sr));
if (strcmp (namebuf, opname + 1) == 0)
return 0;
}
else
{
offsetT val;
char *end;
/* Only continue if the reg name is "URnnn". */
if (opname[1] != 'u' || opname[2] != 'r')
return 0;
val = strtoul (opname + 3, &end, 10);
if (*end != '\0')
return 0;
sr = xtensa_sysreg_lookup (isa, val, 1);
if (sr == XTENSA_UNDEFINED)
{
as_bad (_("invalid register number (%ld) for '%s'"),
(long) val, opname);
return -1;
}
}
/* Translate the opcode. */
sr_name = xtensa_sysreg_name (isa, sr);
new_opname = XNEWVEC (char, strlen (sr_name) + 6);
sprintf (new_opname, "%s%cur.%s", (has_underbar ? "_" : ""),
opname[0], sr_name);
free (*popname);
*popname = new_opname;
return 0;
}
static int
xtensa_translate_zero_immed (const char *old_op,
const char *new_op,
char **popname,
int *pnum_args,
char **arg_strings)
{
char *opname;
offsetT val;
opname = *popname;
gas_assert (opname[0] != '_');
if (strcmp (opname, old_op) != 0)
return 0;
if (xg_check_num_args (pnum_args, 3, opname, arg_strings))
return -1;
if (xg_arg_is_constant (arg_strings[1], &val) && val == 0)
{
xg_replace_opname (popname, new_op);
free (arg_strings[1]);
arg_strings[1] = arg_strings[2];
arg_strings[2] = 0;
*pnum_args = 2;
}
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 (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 (use_transform () && !has_underbar && density_supported)
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] = xstrdup (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;
}
/* Don't do anything special with NOPs inside FLIX instructions. They
are handled elsewhere. Real NOP instructions are always available
in configurations with FLIX, so this should never be an issue but
check for it anyway. */
if (!cur_vinsn.inside_bundle && xtensa_nop_opcode == XTENSA_UNDEFINED
&& strcmp (opname, "nop") == 0)
{
if (use_transform () && !has_underbar && density_supported)
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] = xstrdup ("a1");
arg_strings[1] = xstrdup ("a1");
arg_strings[2] = xstrdup ("a1");
*pnum_args = 3;
}
return 0;
}
/* Recognize [RW]UR and [RWX]SR. */
if ((((opname[0] == 'r' || opname[0] == 'w')
&& (opname[1] == 'u' || opname[1] == 's'))
|| (opname[0] == 'x' && opname[1] == 's'))
&& opname[2] == 'r'
&& opname[3] == '\0')
return xg_translate_sysreg_op (popname, pnum_args, arg_strings);
/* Backward compatibility for RUR and WUR: Recognize [RW]UR<nnn> and
[RW]<name> if <name> is the non-default name of a user register. */
if ((opname[0] == 'r' || opname[0] == 'w')
&& xtensa_opcode_lookup (xtensa_default_isa, opname) == XTENSA_UNDEFINED)
return xtensa_translate_old_userreg_ops (popname);
/* Relax branches that don't allow comparisons against an immediate value
of zero to the corresponding branches with implicit zero immediates. */
if (!has_underbar && use_transform ())
{
if (xtensa_translate_zero_immed ("bnei", "bnez", popname,
pnum_args, arg_strings))
return -1;
if (xtensa_translate_zero_immed ("beqi", "beqz", popname,
pnum_args, arg_strings))
return -1;
if (xtensa_translate_zero_immed ("bgei", "bgez", popname,
pnum_args, arg_strings))
return -1;
if (xtensa_translate_zero_immed ("blti", "bltz", popname,
pnum_args, arg_strings))
return -1;
}
return 0;
}
/* Functions for dealing with the Xtensa ISA. */
/* 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 a PC-relative operand,
the last one is chosen. Otherwise, the result is the number of the
last immediate operand, and if there are none of those, we fail and
return -1. */
static int
get_relaxable_immed (xtensa_opcode opcode)
{
int last_immed = -1;
int noperands, opi;
if (opcode == XTENSA_UNDEFINED)
return -1;
noperands = xtensa_opcode_num_operands (xtensa_default_isa, opcode);
for (opi = noperands - 1; opi >= 0; opi--)
{
if (xtensa_operand_is_visible (xtensa_default_isa, opcode, opi) == 0)
continue;
if (xtensa_operand_is_PCrelative (xtensa_default_isa, opcode, opi) == 1)
return opi;
if (last_immed == -1
&& xtensa_operand_is_register (xtensa_default_isa, opcode, opi) == 0)
last_immed = opi;
}
return last_immed;
}
static xtensa_opcode
get_opcode_from_buf (const char *buf, int slot)
{
static xtensa_insnbuf insnbuf = NULL;
static xtensa_insnbuf slotbuf = NULL;
xtensa_isa isa = xtensa_default_isa;
xtensa_format fmt;
if (!insnbuf)
{
insnbuf = xtensa_insnbuf_alloc (isa);
slotbuf = xtensa_insnbuf_alloc (isa);
}
xtensa_insnbuf_from_chars (isa, insnbuf, (const unsigned char *) buf, 0);
fmt = xtensa_format_decode (isa, insnbuf);
if (fmt == XTENSA_UNDEFINED)
return XTENSA_UNDEFINED;
if (slot >= xtensa_format_num_slots (isa, fmt))
return XTENSA_UNDEFINED;
xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
}
#ifdef TENSILICA_DEBUG
/* For debugging, print out the mapping of opcode numbers to opcodes. */
static void
xtensa_print_insn_table (void)
{
int num_opcodes, num_operands;
xtensa_opcode opcode;
xtensa_isa isa = xtensa_default_isa;
num_opcodes = xtensa_isa_num_opcodes (xtensa_default_isa);
for (opcode = 0; opcode < num_opcodes; opcode++)
{
int opn;
fprintf (stderr, "%d: %s: ", opcode, xtensa_opcode_name (isa, opcode));
num_operands = xtensa_opcode_num_operands (isa, opcode);
for (opn = 0; opn < num_operands; opn++)
{
if (xtensa_operand_is_visible (isa, opcode, opn) == 0)
continue;
if (xtensa_operand_is_register (isa, opcode, opn) == 1)
{
xtensa_regfile opnd_rf =
xtensa_operand_regfile (isa, opcode, opn);
fprintf (stderr, "%s ", xtensa_regfile_shortname (isa, opnd_rf));
}
else if (xtensa_operand_is_PCrelative (isa, opcode, opn) == 1)
fputs ("[lLr] ", stderr);
else
fputs ("i ", stderr);
}
fprintf (stderr, "\n");
}
}
static void
print_vliw_insn (xtensa_insnbuf vbuf)
{
xtensa_isa isa = xtensa_default_isa;
xtensa_format f = xtensa_format_decode (isa, vbuf);
xtensa_insnbuf sbuf = xtensa_insnbuf_alloc (isa);
int op;
fprintf (stderr, "format = %d\n", f);
for (op = 0; op < xtensa_format_num_slots (isa, f); op++)
{
xtensa_opcode opcode;
const char *opname;
int operands;
xtensa_format_get_slot (isa, f, op, vbuf, sbuf);
opcode = xtensa_opcode_decode (isa, f, op, sbuf);
opname = xtensa_opcode_name (isa, opcode);
fprintf (stderr, "op in slot %i is %s;\n", op, opname);
fprintf (stderr, " operands = ");
for (operands = 0;
operands < xtensa_opcode_num_operands (isa, opcode);
operands++)
{
unsigned int val;
if (xtensa_operand_is_visible (isa, opcode, operands) == 0)
continue;
xtensa_operand_get_field (isa, opcode, operands, f, op, sbuf, &val);
xtensa_operand_decode (isa, opcode, operands, &val);
fprintf (stderr, "%d ", val);
}
fprintf (stderr, "\n");
}
xtensa_insnbuf_free (isa, sbuf);
}
#endif /* TENSILICA_DEBUG */
static bfd_boolean
is_direct_call_opcode (xtensa_opcode opcode)
{
xtensa_isa isa = xtensa_default_isa;
int n, num_operands;
if (xtensa_opcode_is_call (isa, opcode) != 1)
return FALSE;
num_operands = xtensa_opcode_num_operands (isa, opcode);
for (n = 0; n < num_operands; n++)
{
if (xtensa_operand_is_register (isa, opcode, n) == 0
&& xtensa_operand_is_PCrelative (isa, opcode, n) == 1)
return TRUE;
}
return FALSE;
}
/* Convert from BFD relocation type code to slot and operand number.
Returns non-zero on failure. */
static int
decode_reloc (bfd_reloc_code_real_type reloc, int *slot, bfd_boolean *is_alt)
{
if (reloc >= BFD_RELOC_XTENSA_SLOT0_OP
&& reloc <= BFD_RELOC_XTENSA_SLOT14_OP)
{
*slot = reloc - BFD_RELOC_XTENSA_SLOT0_OP;
*is_alt = FALSE;
}
else if (reloc >= BFD_RELOC_XTENSA_SLOT0_ALT
&& reloc <= BFD_RELOC_XTENSA_SLOT14_ALT)
{
*slot = reloc - BFD_RELOC_XTENSA_SLOT0_ALT;
*is_alt = TRUE;
}
else
return -1;
return 0;
}
/* Convert from slot number to BFD relocation type code for the
standard PC-relative relocations. Return BFD_RELOC_NONE on
failure. */
static bfd_reloc_code_real_type
encode_reloc (int slot)
{
if (slot < 0 || slot > 14)
return BFD_RELOC_NONE;
return BFD_RELOC_XTENSA_SLOT0_OP + slot;
}
/* Convert from slot numbers to BFD relocation type code for the
"alternate" relocations. Return BFD_RELOC_NONE on failure. */
static bfd_reloc_code_real_type
encode_alt_reloc (int slot)
{
if (slot < 0 || slot > 14)
return BFD_RELOC_NONE;
return BFD_RELOC_XTENSA_SLOT0_ALT + slot;
}
static void
xtensa_insnbuf_set_operand (xtensa_insnbuf slotbuf,
xtensa_format fmt,
int slot,
xtensa_opcode opcode,
int operand,
uint32 value,
const char *file,
unsigned int line)
{
uint32 valbuf = value;
if (xtensa_operand_encode (xtensa_default_isa, opcode, operand, &valbuf))
{
if (xtensa_operand_is_PCrelative (xtensa_default_isa, opcode, operand)
== 1)
as_bad_where ((char *) file, line,
_("operand %d of '%s' has out of range value '%u'"),
operand + 1,
xtensa_opcode_name (xtensa_default_isa, opcode),
value);
else
as_bad_where ((char *) file, line,
_("operand %d of '%s' has invalid value '%u'"),
operand + 1,
xtensa_opcode_name (xtensa_default_isa, opcode),
value);
return;
}
xtensa_operand_set_field (xtensa_default_isa, opcode, operand, fmt, slot,
slotbuf, valbuf);
}
static uint32
xtensa_insnbuf_get_operand (xtensa_insnbuf slotbuf,
xtensa_format fmt,
int slot,
xtensa_opcode opcode,
int opnum)
{
uint32 val = 0;
(void) xtensa_operand_get_field (xtensa_default_isa, opcode, opnum,
fmt, slot, slotbuf, &val);
(void) xtensa_operand_decode (xtensa_default_isa, opcode, opnum, &val);
return val;
}
/* Checks for rules from xtensa-relax tables. */
/* The routine xg_instruction_matches_option_term must return TRUE
when a given option term is true. The meaning of all of the option
terms is given interpretation by this function. */
static bfd_boolean
xg_instruction_matches_option_term (TInsn *insn, const ReqOrOption *option)
{
if (strcmp (option->option_name, "realnop") == 0
|| strncmp (option->option_name, "IsaUse", 6) == 0)
{
/* These conditions were evaluated statically when building the
relaxation table. There's no need to reevaluate them now. */
return TRUE;
}
else if (strcmp (option->option_name, "FREEREG") == 0)
return insn->extra_arg.X_op == O_register;
else
{
as_fatal (_("internal error: unknown option name '%s'"),
option->option_name);
}
}
static bfd_boolean
xg_instruction_matches_or_options (TInsn *insn,
const ReqOrOptionList *or_option)
{
const ReqOrOption *option;
/* Must match each of the AND terms. */
for (option = or_option; option != NULL; option = option->next)
{
if (xg_instruction_matches_option_term (insn, option))
return TRUE;
}
return FALSE;
}
static bfd_boolean
xg_instruction_matches_options (TInsn *insn, const ReqOptionList *options)
{
const ReqOption *req_options;
/* Must match each of the AND terms. */
for (req_options = options;
req_options != NULL;
req_options = req_options->next)
{
/* Must match one of the OR clauses. */
if (!xg_instruction_matches_or_options (insn,
req_options->or_option_terms))
return FALSE;
}
return TRUE;
}
/* Return the transition rule that matches or NULL if none matches. */
static bfd_boolean
xg_instruction_matches_rule (TInsn *insn, TransitionRule *rule)
{
PreconditionList *condition_l;
if (rule->opcode != insn->opcode)
return FALSE;
for (condition_l = rule->conditions;
condition_l != NULL;
condition_l = condition_l->next