OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* config/tc-xtensa.c: Remove excess whitespace. 

* config/tc-xtensa.h: Likewise.
	* config/xtensa-istack.h: Likewise.
	* config/xtensa-relax.c: Likewise.
	* config/xtensa-relax.h: Likewise.
This commit is contained in:
Bob Wilson 2005-05-06 21:27:47 +00:00
parent aa7eb06d97
commit c138bc3888
6 changed files with 152 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gas/ChangeLog
View File

@ -1,3 +1,11 @@
2005-05-06 Bob Wilson <bob.wilson@acm.org>
* config/tc-xtensa.c: Remove excess whitespace.
* config/tc-xtensa.h: Likewise.
* config/xtensa-istack.h: Likewise.
* config/xtensa-relax.c: Likewise.
* config/xtensa-relax.h: Likewise.
2005-05-06 Nick Clifton <nickc@redhat.com> 2005-05-06 Nick Clifton <nickc@redhat.com>
* sb.h: Fix formatting of comments. * sb.h: Fix formatting of comments.

226
gas/config/tc-xtensa.c
View File

@ -81,7 +81,7 @@ unsigned xtensa_fetch_width = XCHAL_INST_FETCH_WIDTH;
static enum debug_info_type xt_saved_debug_type = DEBUG_NONE; static enum debug_info_type xt_saved_debug_type = DEBUG_NONE;
/* Some functions are only valid in the front end. This variable /* Some functions are only valid in the front end. This variable
allows us to assert that we haven't crossed over into the allows us to assert that we haven't crossed over into the
back end. */ back end. */
static bfd_boolean past_xtensa_end = FALSE; static bfd_boolean past_xtensa_end = FALSE;
@ -322,13 +322,13 @@ typedef struct op_placement_info_struct
int num_formats; int num_formats;
/* A number describing how restrictive the issue is for this /* A number describing how restrictive the issue is for this
opcode. For example, an opcode that fits lots of different opcode. For example, an opcode that fits lots of different
formats has a high freedom, as does an opcode that fits formats has a high freedom, as does an opcode that fits
only one format but many slots in that format. The most only one format but many slots in that format. The most
restrictive is the opcode that fits only one slot in one restrictive is the opcode that fits only one slot in one
format. */ format. */
int issuef; int issuef;
/* The single format (i.e., if the op can live in a bundle by itself), /* The single format (i.e., if the op can live in a bundle by itself),
narrowest format, and widest format the op can be bundled in narrowest format, and widest format the op can be bundled in
and their sizes: */ and their sizes: */
xtensa_format single; xtensa_format single;
xtensa_format narrowest; xtensa_format narrowest;
@ -844,7 +844,7 @@ md_parse_option (int c, char *arg)
/* -Qy, -Qn: SVR4 arguments controlling whether a .comment section /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
should be emitted or not. FIXME: Not implemented. */ should be emitted or not. FIXME: Not implemented. */
return 1; return 1;
case option_prefer_l32r: case option_prefer_l32r:
if (prefer_const16) if (prefer_const16)
as_fatal (_("prefer-l32r conflicts with prefer-const16")); as_fatal (_("prefer-l32r conflicts with prefer-const16"));
@ -857,7 +857,7 @@ md_parse_option (int c, char *arg)
prefer_const16 = 1; prefer_const16 = 1;
return 1; return 1;
case option_target_hardware: case option_target_hardware:
{ {
int earliest, latest = 0; int earliest, latest = 0;
if (*arg == 0 || *arg == '-') if (*arg == 0 || *arg == '-')
@ -950,8 +950,8 @@ xtensa_clear_insn_labels (void)
} }
/* The "loops_ok" argument is provided to allow ignoring labels that /* The "loops_ok" argument is provided to allow ignoring labels that
define loop ends. This fixes a bug where the NOPs to align a define loop ends. This fixes a bug where the NOPs to align a
loop opcode were included in a previous zero-cost loop: loop opcode were included in a previous zero-cost loop:
loop a0, loopend loop a0, loopend
@ -1144,7 +1144,7 @@ get_directive (directiveE *directive, bfd_boolean *negated)
/* This code is a hack to make .begin [no-][generics|relax] exactly /* This code is a hack to make .begin [no-][generics|relax] exactly
equivalent to .begin [no-]transform. We should remove it when equivalent to .begin [no-]transform. We should remove it when
we stop accepting those options. */ we stop accepting those options. */
if (strncmp (input_line_pointer, "generics", strlen ("generics")) == 0) if (strncmp (input_line_pointer, "generics", strlen ("generics")) == 0)
{ {
as_warn (_("[no-]generics is deprecated; use [no-]transform instead")); as_warn (_("[no-]generics is deprecated; use [no-]transform instead"));
@ -1154,7 +1154,7 @@ get_directive (directiveE *directive, bfd_boolean *negated)
{ {
as_warn (_("[no-]relax is deprecated; use [no-]transform instead")); as_warn (_("[no-]relax is deprecated; use [no-]transform instead"));
directive_string = "transform"; directive_string = "transform";
} }
else else
directive_string = input_line_pointer; directive_string = input_line_pointer;
@ -1212,7 +1212,7 @@ xtensa_begin_directive (int ignore ATTRIBUTE_UNUSED)
break; break;
case directive_literal_prefix: case directive_literal_prefix:
/* Have to flush pending output because a movi relaxed to an l32r /* Have to flush pending output because a movi relaxed to an l32r
might produce a literal. */ might produce a literal. */
md_flush_pending_output (); md_flush_pending_output ();
/* Check to see if the current fragment is a literal /* Check to see if the current fragment is a literal
@ -1927,9 +1927,9 @@ tokenize_arguments (char **args, char *str)
input_line_pointer = arg_end; input_line_pointer = arg_end;
num_args += 1; num_args += 1;
saw_comma = FALSE; saw_comma = FALSE;
saw_colon = FALSE; saw_colon = FALSE;
saw_arg = TRUE; saw_arg = TRUE;
break; break;
} }
} }
@ -1946,7 +1946,7 @@ err:
else if (saw_colon) else if (saw_colon)
as_bad (_("extra colon")); as_bad (_("extra colon"));
else if (!saw_arg) else if (!saw_arg)
as_bad (_("missing argument")); as_bad (_("missing argument"));
else else
as_bad (_("missing comma or colon")); as_bad (_("missing comma or colon"));
input_line_pointer = old_input_line_pointer; input_line_pointer = old_input_line_pointer;
@ -2046,7 +2046,7 @@ parse_arguments (TInsn *insn, int num_args, char **arg_strings)
goto err; goto err;
insn->ntok = tok - insn->tok; insn->ntok = tok - insn->tok;
had_error = FALSE; had_error = FALSE;
err: err:
input_line_pointer = old_input_line_pointer; input_line_pointer = old_input_line_pointer;
@ -2992,7 +2992,7 @@ is_unique_insn_expansion (TransitionRule *r)
NARROW_ONLY is true, then only consider relaxations that widen a narrow NARROW_ONLY is true, then only consider relaxations that widen a narrow
instruction, i.e., ignore relaxations that convert to an instruction of instruction, i.e., ignore relaxations that convert to an instruction of
equal size. In some contexts where this function is used, only equal size. In some contexts where this function is used, only
a single widening is allowed and the NARROW_ONLY argument is used to a single widening is allowed and the NARROW_ONLY argument is used to
exclude cases like ADDI being "widened" to an ADDMI, which may exclude cases like ADDI being "widened" to an ADDMI, which may
later be relaxed to an ADDMI/ADDI pair. */ later be relaxed to an ADDMI/ADDI pair. */
@ -3318,7 +3318,7 @@ xg_symbolic_immeds_fit (const TInsn *insn,
{ {
target += stretch; target += stretch;
} }
new_offset = target; new_offset = target;
xtensa_operand_do_reloc (isa, insn->opcode, i, &new_offset, pc); xtensa_operand_do_reloc (isa, insn->opcode, i, &new_offset, pc);
if (xg_check_operand (new_offset, insn->opcode, i)) if (xg_check_operand (new_offset, insn->opcode, i))
@ -3743,7 +3743,7 @@ is_branch_jmp_to_next (TInsn *insn, fragS *fragP)
if (target_frag == NULL) if (target_frag == NULL)
return FALSE; return FALSE;
if (is_next_frag_target (fragP->fr_next, target_frag) if (is_next_frag_target (fragP->fr_next, target_frag)
&& S_GET_VALUE (sym) == target_frag->fr_address) && S_GET_VALUE (sym) == target_frag->fr_address)
return TRUE; return TRUE;
@ -4046,7 +4046,7 @@ xg_assemble_literal (/* const */ TInsn *insn)
if (size > litsize) if (size > litsize)
{ {
/* This happens when someone writes a "movi a2, big_number". */ /* This happens when someone writes a "movi a2, big_number". */
as_bad_where (frag_now->fr_file, frag_now->fr_line, as_bad_where (frag_now->fr_file, frag_now->fr_line,
_("invalid immediate")); _("invalid immediate"));
xtensa_restore_emit_state (&state); xtensa_restore_emit_state (&state);
return NULL; return NULL;
@ -4203,7 +4203,7 @@ xg_add_opcode_fix (TInsn *tinsn,
the_fix->tc_fix_data.X_add_symbol = expr->X_add_symbol; the_fix->tc_fix_data.X_add_symbol = expr->X_add_symbol;
the_fix->tc_fix_data.X_add_number = expr->X_add_number; the_fix->tc_fix_data.X_add_number = expr->X_add_number;
the_fix->tc_fix_data.slot = slot; the_fix->tc_fix_data.slot = slot;
return TRUE; return TRUE;
} }
@ -4324,7 +4324,7 @@ is_bad_loopend_opcode (const TInsn *tinsn)
|| opcode == xtensa_waiti_opcode || opcode == xtensa_waiti_opcode
|| opcode == xtensa_rsr_lcount_opcode) || opcode == xtensa_rsr_lcount_opcode)
return TRUE; return TRUE;
return FALSE; return FALSE;
} }
@ -4366,7 +4366,7 @@ next_non_empty_frag (const fragS *fragP)
{ {
fragS *next_fragP = fragP->fr_next; fragS *next_fragP = fragP->fr_next;
/* Sometimes an empty will end up here due storage allocation issues. /* Sometimes an empty will end up here due storage allocation issues.
So we have to skip until we find something legit. */ So we have to skip until we find something legit. */
while (next_fragP && next_fragP->fr_fix == 0) while (next_fragP && next_fragP->fr_fix == 0)
next_fragP = next_fragP->fr_next; next_fragP = next_fragP->fr_next;
@ -4403,7 +4403,7 @@ frag_format_size (const fragS *fragP)
static xtensa_insnbuf insnbuf = NULL; static xtensa_insnbuf insnbuf = NULL;
xtensa_isa isa = xtensa_default_isa; xtensa_isa isa = xtensa_default_isa;
xtensa_format fmt; xtensa_format fmt;
int fmt_size; int fmt_size;
if (!insnbuf) if (!insnbuf)
insnbuf = xtensa_insnbuf_alloc (isa); insnbuf = xtensa_insnbuf_alloc (isa);
@ -4424,7 +4424,7 @@ frag_format_size (const fragS *fragP)
if (fragP->fr_opcode != fragP->fr_literal) if (fragP->fr_opcode != fragP->fr_literal)
return fmt_size; return fmt_size;
/* If during relaxation we have to pull an instruction out of a /* If during relaxation we have to pull an instruction out of a
multi-slot instruction, we will return the more conservative multi-slot instruction, we will return the more conservative
number. This works because alignment on bigger instructions number. This works because alignment on bigger instructions
is more restrictive than alignment on smaller instructions. is more restrictive than alignment on smaller instructions.
@ -4445,7 +4445,7 @@ frag_format_size (const fragS *fragP)
if (fragP->tc_frag_data.slot_subtypes[0] == RELAX_IMMED_STEP1 if (fragP->tc_frag_data.slot_subtypes[0] == RELAX_IMMED_STEP1
|| fragP->tc_frag_data.slot_subtypes[0] == RELAX_IMMED_STEP2) || fragP->tc_frag_data.slot_subtypes[0] == RELAX_IMMED_STEP2)
return 3; return 3;
if (fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW) if (fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW)
return 2 + fragP->tc_frag_data.text_expansion[0]; return 2 + fragP->tc_frag_data.text_expansion[0];
@ -4527,7 +4527,7 @@ next_frag_is_branch_target (const fragS *fragP)
static bfd_boolean static bfd_boolean
next_frag_is_loop_target (const fragS *fragP) next_frag_is_loop_target (const fragS *fragP)
{ {
/* Sometimes an empty will end up here due storage allocation issues. /* Sometimes an empty will end up here due storage allocation issues.
So we have to skip until we find something legit. */ So we have to skip until we find something legit. */
for (fragP = fragP->fr_next; fragP; fragP = fragP->fr_next) for (fragP = fragP->fr_next; fragP; fragP = fragP->fr_next)
{ {
@ -4715,7 +4715,7 @@ xtensa_set_frag_assembly_state (fragS *fragP)
fragP->tc_frag_data.is_no_density = TRUE; fragP->tc_frag_data.is_no_density = TRUE;
/* This function is called from subsegs_finish, which is called /* This function is called from subsegs_finish, which is called
after xtensa_end, so we can't use "use_transform" or after xtensa_end, so we can't use "use_transform" or
"use_schedule" here. */ "use_schedule" here. */
if (!directive_state[directive_transform]) if (!directive_state[directive_transform])
fragP->tc_frag_data.is_no_transform = TRUE; fragP->tc_frag_data.is_no_transform = TRUE;
@ -4801,9 +4801,9 @@ xtensa_find_unaligned_branch_targets (bfd *abfd ATTRIBUTE_UNUSED,
flagword flags = bfd_get_section_flags (abfd, sec); flagword flags = bfd_get_section_flags (abfd, sec);
segment_info_type *seginfo = seg_info (sec); segment_info_type *seginfo = seg_info (sec);
fragS *frag = seginfo->frchainP->frch_root; fragS *frag = seginfo->frchainP->frch_root;
if (flags & SEC_CODE) if (flags & SEC_CODE)
{ {
xtensa_isa isa = xtensa_default_isa; xtensa_isa isa = xtensa_default_isa;
xtensa_insnbuf insnbuf = xtensa_insnbuf_alloc (isa); xtensa_insnbuf insnbuf = xtensa_insnbuf_alloc (isa);
while (frag != NULL) while (frag != NULL)
@ -4841,9 +4841,9 @@ xtensa_find_unaligned_loops (bfd *abfd ATTRIBUTE_UNUSED,
segment_info_type *seginfo = seg_info (sec); segment_info_type *seginfo = seg_info (sec);
fragS *frag = seginfo->frchainP->frch_root; fragS *frag = seginfo->frchainP->frch_root;
xtensa_isa isa = xtensa_default_isa; xtensa_isa isa = xtensa_default_isa;
if (flags & SEC_CODE) if (flags & SEC_CODE)
{ {
xtensa_insnbuf insnbuf = xtensa_insnbuf_alloc (isa); xtensa_insnbuf insnbuf = xtensa_insnbuf_alloc (isa);
while (frag != NULL) while (frag != NULL)
{ {
@ -5261,7 +5261,7 @@ md_assemble (char *str)
} }
dwarf2_where (&orig_insn.loc); dwarf2_where (&orig_insn.loc);
xg_add_branch_and_loop_targets (&orig_insn); xg_add_branch_and_loop_targets (&orig_insn);
/* Special-case for "entry" instruction. */ /* Special-case for "entry" instruction. */
@ -5333,7 +5333,7 @@ xtensa_handle_align (fragS *fragP)
int count; int count;
count = fragP->fr_next->fr_address - fragP->fr_address - fragP->fr_fix; count = fragP->fr_next->fr_address - fragP->fr_address - fragP->fr_fix;
if (count != 0) if (count != 0)
as_bad_where (fragP->fr_file, fragP->fr_line, as_bad_where (fragP->fr_file, fragP->fr_line,
_("unaligned entry instruction")); _("unaligned entry instruction"));
} }
} }
@ -5760,11 +5760,11 @@ tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
/* Checks for resource conflicts between instructions. */ /* Checks for resource conflicts between instructions. */
/* The func unit stuff could be implemented as bit-vectors rather /* The func unit stuff could be implemented as bit-vectors rather
than the iterative approach here. If it ends up being too than the iterative approach here. If it ends up being too
slow, we will switch it. */ slow, we will switch it. */
resource_table * resource_table *
new_resource_table (void *data, new_resource_table (void *data,
int cycles, int cycles,
int nu, int nu,
@ -5792,7 +5792,7 @@ new_resource_table (void *data,
} }
void void
clear_resource_table (resource_table *rt) clear_resource_table (resource_table *rt)
{ {
int i, j; int i, j;
@ -5804,7 +5804,7 @@ clear_resource_table (resource_table *rt)
/* We never shrink it, just fake it into thinking so. */ /* We never shrink it, just fake it into thinking so. */
void void
resize_resource_table (resource_table *rt, int cycles) resize_resource_table (resource_table *rt, int cycles)
{ {
int i, old_cycles; int i, old_cycles;
@ -5824,13 +5824,13 @@ resize_resource_table (resource_table *rt, int cycles)
} }
bfd_boolean bfd_boolean
resources_available (resource_table *rt, xtensa_opcode opcode, int cycle) resources_available (resource_table *rt, xtensa_opcode opcode, int cycle)
{ {
int i; int i;
int uses = (rt->opcode_num_units) (rt->data, opcode); int uses = (rt->opcode_num_units) (rt->data, opcode);
for (i = 0; i < uses; i++) for (i = 0; i < uses; i++)
{ {
xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i); xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i);
int stage = (rt->opcode_unit_stage) (rt->data, opcode, i); int stage = (rt->opcode_unit_stage) (rt->data, opcode, i);
@ -5841,20 +5841,20 @@ resources_available (resource_table *rt, xtensa_opcode opcode, int cycle)
} }
return TRUE; return TRUE;
} }
void
void
reserve_resources (resource_table *rt, xtensa_opcode opcode, int cycle) reserve_resources (resource_table *rt, xtensa_opcode opcode, int cycle)
{ {
int i; int i;
int uses = (rt->opcode_num_units) (rt->data, opcode); int uses = (rt->opcode_num_units) (rt->data, opcode);
for (i = 0; i < uses; i++) for (i = 0; i < uses; i++)
{ {
xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i); xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i);
int stage = (rt->opcode_unit_stage) (rt->data, opcode, i); int stage = (rt->opcode_unit_stage) (rt->data, opcode, i);
/* Note that this allows resources to be oversubscribed. That's /* Note that this allows resources to be oversubscribed. That's
essential to the way the optional scheduler works. essential to the way the optional scheduler works.
resources_available reports when a resource is over-subscribed, resources_available reports when a resource is over-subscribed,
so it's easy to tell. */ so it's easy to tell. */
rt->units[stage + cycle][unit]++; rt->units[stage + cycle][unit]++;
@ -5862,13 +5862,13 @@ reserve_resources (resource_table *rt, xtensa_opcode opcode, int cycle)
} }
void void
release_resources (resource_table *rt, xtensa_opcode opcode, int cycle) release_resources (resource_table *rt, xtensa_opcode opcode, int cycle)
{ {
int i; int i;
int uses = (rt->opcode_num_units) (rt->data, opcode); int uses = (rt->opcode_num_units) (rt->data, opcode);
for (i = 0; i < uses; i++) for (i = 0; i < uses; i++)
{ {
xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i); xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i);
int stage = (rt->opcode_unit_stage) (rt->data, opcode, i); int stage = (rt->opcode_unit_stage) (rt->data, opcode, i);
@ -5876,20 +5876,20 @@ release_resources (resource_table *rt, xtensa_opcode opcode, int cycle)
assert (rt->units[stage + cycle][unit] >= 0); assert (rt->units[stage + cycle][unit] >= 0);
} }
} }
/* Wrapper functions make parameterized resource reservation /* Wrapper functions make parameterized resource reservation
more convenient. */ more convenient. */
int int
opcode_funcUnit_use_unit (void *data, xtensa_opcode opcode, int idx) opcode_funcUnit_use_unit (void *data, xtensa_opcode opcode, int idx)
{ {
xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx); xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx);
return use->unit; return use->unit;
} }
int int
opcode_funcUnit_use_stage (void *data, xtensa_opcode opcode, int idx) opcode_funcUnit_use_stage (void *data, xtensa_opcode opcode, int idx)
{ {
xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx); xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx);
@ -5899,7 +5899,7 @@ opcode_funcUnit_use_stage (void *data, xtensa_opcode opcode, int idx)
/* Note that this function does not check issue constraints, but /* Note that this function does not check issue constraints, but
solely whether the hardware is available to execute the given solely whether the hardware is available to execute the given
instructions together. It also doesn't check if the tinsns instructions together. It also doesn't check if the tinsns
write the same state, or access the same tieports. That is write the same state, or access the same tieports. That is
checked by check_t1_t2_reads_and_writes. */ checked by check_t1_t2_reads_and_writes. */
@ -5913,7 +5913,7 @@ resources_conflict (vliw_insn *vinsn)
if (vinsn->num_slots == 1) if (vinsn->num_slots == 1)
return FALSE; return FALSE;
if (rt == NULL) if (rt == NULL)
{ {
xtensa_isa isa = xtensa_default_isa; xtensa_isa isa = xtensa_default_isa;
rt = new_resource_table rt = new_resource_table
@ -5992,7 +5992,7 @@ finish_vinsn (vliw_insn *vinsn)
return; return;
} }
if (resources_conflict (vinsn)) if (resources_conflict (vinsn))
{ {
as_where (&file_name, &line); as_where (&file_name, &line);
as_bad_where (file_name, line, _("illegal resource usage in bundle")); as_bad_where (file_name, line, _("illegal resource usage in bundle"));
@ -6074,7 +6074,7 @@ finish_vinsn (vliw_insn *vinsn)
if (vinsn->format == XTENSA_UNDEFINED) if (vinsn->format == XTENSA_UNDEFINED)
vinsn->slots[i].opcode = xtensa_nop_opcode; vinsn->slots[i].opcode = xtensa_nop_opcode;
else else
vinsn->slots[i].opcode vinsn->slots[i].opcode
= xtensa_format_slot_nop_opcode (xtensa_default_isa, = xtensa_format_slot_nop_opcode (xtensa_default_isa,
vinsn->format, i); vinsn->format, i);
@ -6090,7 +6090,7 @@ finish_vinsn (vliw_insn *vinsn)
} }
/* Now check resource conflicts on the modified bundle. */ /* Now check resource conflicts on the modified bundle. */
if (resources_conflict (vinsn)) if (resources_conflict (vinsn))
{ {
as_where (&file_name, &line); as_where (&file_name, &line);
as_bad_where (file_name, line, _("illegal resource usage in bundle")); as_bad_where (file_name, line, _("illegal resource usage in bundle"));
@ -6225,7 +6225,7 @@ find_vinsn_conflicts (vliw_insn *vinsn)
case A: t1 reads a register t2 writes (an antidependency within a bundle) case A: t1 reads a register t2 writes (an antidependency within a bundle)
case B: no relationship between what is read and written (both could case B: no relationship between what is read and written (both could
read the same reg though) read the same reg though)
case C: t1 writes a register t2 writes (a register conflict within a case C: t1 writes a register t2 writes (a register conflict within a
bundle) bundle)
case D: t1 writes a state that t2 also writes case D: t1 writes a state that t2 also writes
case E: t1 writes a tie queue that t2 also writes case E: t1 writes a tie queue that t2 also writes
@ -6325,7 +6325,7 @@ check_t1_t2_reads_and_writes (TInsn *t1, TInsn *t2)
{ {
xtensa_state t1_so = xtensa_stateOperand_state (isa, t1->opcode, i); xtensa_state t1_so = xtensa_stateOperand_state (isa, t1->opcode, i);
t1_inout = xtensa_stateOperand_inout (isa, t1->opcode, i); t1_inout = xtensa_stateOperand_inout (isa, t1->opcode, i);
if (t1_so != t2_so) if (t1_so != t2_so)
continue; continue;
if (t2_inout == 'i' && (t1_inout == 'm' || t1_inout == 'o')) if (t2_inout == 'i' && (t1_inout == 'm' || t1_inout == 'o'))
@ -6333,22 +6333,22 @@ check_t1_t2_reads_and_writes (TInsn *t1, TInsn *t2)
conflict = 'a'; conflict = 'a';
continue; continue;
} }
if (t1_inout == 'i' && (t2_inout == 'm' || t2_inout == 'o')) if (t1_inout == 'i' && (t2_inout == 'm' || t2_inout == 'o'))
{ {
conflict = 'a'; conflict = 'a';
continue; continue;
} }
if (t1_inout != 'i' && t2_inout != 'i') if (t1_inout != 'i' && t2_inout != 'i')
return 'd'; return 'd';
} }
} }
/* Check tieports. */ /* Check tieports. */
t1_interfaces = xtensa_opcode_num_interfaceOperands (isa, t1->opcode); t1_interfaces = xtensa_opcode_num_interfaceOperands (isa, t1->opcode);
t2_interfaces = xtensa_opcode_num_interfaceOperands (isa, t2->opcode); t2_interfaces = xtensa_opcode_num_interfaceOperands (isa, t2->opcode);
for (j = 0; j < t2_interfaces; j++) for (j = 0; j < t2_interfaces; j++)
{ {
xtensa_interface t2_int xtensa_interface t2_int
= xtensa_interfaceOperand_interface (isa, t2->opcode, j); = xtensa_interfaceOperand_interface (isa, t2->opcode, j);
@ -6370,27 +6370,27 @@ check_t1_t2_reads_and_writes (TInsn *t1, TInsn *t2)
if (t1_volatile && t2_volatile && (t1_class == t2_class)) if (t1_volatile && t2_volatile && (t1_class == t2_class))
return 'f'; return 'f';
if (t1_int != t2_int) if (t1_int != t2_int)
continue; continue;
if (t2_inout == 'i' && t1_inout == 'o') if (t2_inout == 'i' && t1_inout == 'o')
{ {
conflict = 'a'; conflict = 'a';
continue; continue;
} }
if (t1_inout == 'i' && t2_inout == 'o') if (t1_inout == 'i' && t2_inout == 'o')
{ {
conflict = 'a'; conflict = 'a';
continue; continue;
} }
if (t1_inout != 'i' && t2_inout != 'i') if (t1_inout != 'i' && t2_inout != 'i')
return 'e'; return 'e';
} }
} }
return conflict; return conflict;
} }
@ -6504,7 +6504,7 @@ relaxation_requirements (vliw_insn *vinsn)
extra_space += 3; /* for the nop size */ extra_space += 3; /* for the nop size */
tinsn->subtype = RELAX_ADD_NOP_IF_PRE_LOOP_END; tinsn->subtype = RELAX_ADD_NOP_IF_PRE_LOOP_END;
} }
/* Need to assemble it with space for the relocation. */ /* Need to assemble it with space for the relocation. */
if (xg_is_relaxable_insn (tinsn, 0) if (xg_is_relaxable_insn (tinsn, 0)
&& !tinsn->is_specific_opcode) && !tinsn->is_specific_opcode)
@ -6512,9 +6512,9 @@ relaxation_requirements (vliw_insn *vinsn)
int max_size = xg_get_max_insn_widen_size (tinsn->opcode); int max_size = xg_get_max_insn_widen_size (tinsn->opcode);
int max_literal_size = int max_literal_size =
xg_get_max_insn_widen_literal_size (tinsn->opcode); xg_get_max_insn_widen_literal_size (tinsn->opcode);
tinsn->literal_space = max_literal_size; tinsn->literal_space = max_literal_size;
tinsn->subtype = RELAX_IMMED; tinsn->subtype = RELAX_IMMED;
tinsn->record_fix = FALSE; tinsn->record_fix = FALSE;
extra_space += max_size; extra_space += max_size;
@ -6579,10 +6579,10 @@ emit_single_op (TInsn *orig_insn)
istack_init (&istack); istack_init (&istack);
/* Special-case for "movi aX, foo" which is guaranteed to need relaxing. /* Special-case for "movi aX, foo" which is guaranteed to need relaxing.
Because the scheduling and bundling characteristics of movi and Because the scheduling and bundling characteristics of movi and
l32r or const16 are so different, we can do much better if we relax l32r or const16 are so different, we can do much better if we relax
it prior to scheduling and bundling, rather than after. */ it prior to scheduling and bundling, rather than after. */
if ((orig_insn->opcode == xtensa_movi_opcode if ((orig_insn->opcode == xtensa_movi_opcode
|| orig_insn->opcode == xtensa_movi_n_opcode) || orig_insn->opcode == xtensa_movi_n_opcode)
&& !cur_vinsn.inside_bundle && !cur_vinsn.inside_bundle
&& (orig_insn->tok[1].X_op == O_symbol && (orig_insn->tok[1].X_op == O_symbol
@ -6595,7 +6595,7 @@ emit_single_op (TInsn *orig_insn)
for (i = 0; i < istack.ninsn; i++) for (i = 0; i < istack.ninsn; i++)
{ {
TInsn *insn = &istack.insn[i]; TInsn *insn = &istack.insn[i];
switch (insn->insn_type) switch (insn->insn_type)
{ {
case ITYPE_LITERAL: case ITYPE_LITERAL:
assert (lit_sym == NULL); assert (lit_sym == NULL);
@ -6718,9 +6718,9 @@ xg_assemble_vliw_tokens (vliw_insn *vinsn)
/* See if the instruction implies an aligned section. */ /* See if the instruction implies an aligned section. */
if (xtensa_opcode_is_loop (isa, vinsn->slots[i].opcode) == 1) if (xtensa_opcode_is_loop (isa, vinsn->slots[i].opcode) == 1)
record_alignment (now_seg, 2); record_alignment (now_seg, 2);
/* Also determine the best line number for debug info. */ /* Also determine the best line number for debug info. */
best_loc = vinsn->slots[i].loc.line < best_loc.line best_loc = vinsn->slots[i].loc.line < best_loc.line
? vinsn->slots[i].loc : best_loc; ? vinsn->slots[i].loc : best_loc;
} }
@ -6729,10 +6729,10 @@ xg_assemble_vliw_tokens (vliw_insn *vinsn)
if (xtensa_opcode_is_loop (isa, vinsn->slots[0].opcode) == 1) if (xtensa_opcode_is_loop (isa, vinsn->slots[0].opcode) == 1)
{ {
int max_fill; int max_fill;
xtensa_set_frag_assembly_state (frag_now); xtensa_set_frag_assembly_state (frag_now);
frag_now->tc_frag_data.is_insn = TRUE; frag_now->tc_frag_data.is_insn = TRUE;
max_fill = get_text_align_max_fill_size max_fill = get_text_align_max_fill_size
(get_text_align_power (xtensa_fetch_width), (get_text_align_power (xtensa_fetch_width),
TRUE, frag_now->tc_frag_data.is_no_density); TRUE, frag_now->tc_frag_data.is_no_density);
@ -6744,10 +6744,10 @@ xg_assemble_vliw_tokens (vliw_insn *vinsn)
frag_now->fr_offset, frag_now->fr_offset,
NULL); NULL);
else else
frag_var (rs_machine_dependent, 0, 0, frag_var (rs_machine_dependent, 0, 0,
RELAX_CHECK_ALIGN_NEXT_OPCODE, 0, 0, NULL); RELAX_CHECK_ALIGN_NEXT_OPCODE, 0, 0, NULL);
xtensa_set_frag_assembly_state (frag_now); xtensa_set_frag_assembly_state (frag_now);
xtensa_move_labels (frag_now, 0, FALSE); xtensa_move_labels (frag_now, 0, FALSE);
} }
@ -6788,7 +6788,7 @@ xg_assemble_vliw_tokens (vliw_insn *vinsn)
return; return;
xtensa_insnbuf_to_chars (isa, vinsn->insnbuf, (unsigned char *) f, 0); xtensa_insnbuf_to_chars (isa, vinsn->insnbuf, (unsigned char *) f, 0);
xtensa_dwarf2_emit_insn (insn_size - extra_space, &best_loc); xtensa_dwarf2_emit_insn (insn_size - extra_space, &best_loc);
for (slot = 0; slot < vinsn->num_slots; slot++) for (slot = 0; slot < vinsn->num_slots; slot++)
@ -6809,7 +6809,7 @@ xg_assemble_vliw_tokens (vliw_insn *vinsn)
if (xtensa_opcode_is_branch (isa, tinsn->opcode) == 1) if (xtensa_opcode_is_branch (isa, tinsn->opcode) == 1)
is_branch = TRUE; is_branch = TRUE;
if (tinsn->subtype || tinsn->symbol || tinsn->record_fix if (tinsn->subtype || tinsn->symbol || tinsn->record_fix
|| tinsn->offset || tinsn->literal_frag || is_jump || is_branch) || tinsn->offset || tinsn->literal_frag || is_jump || is_branch)
finish_frag = TRUE; finish_frag = TRUE;
} }
@ -6986,7 +6986,7 @@ xtensa_cleanup_align_frags (void)
&& fragP->fr_subtype == RELAX_SLOTS && fragP->fr_subtype == RELAX_SLOTS
&& fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW) && fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW)
frag_wane (fragP); frag_wane (fragP);
if (fragP->fr_type == rs_machine_dependent if (fragP->fr_type == rs_machine_dependent
&& fragP->fr_subtype == RELAX_UNREACHABLE) && fragP->fr_subtype == RELAX_UNREACHABLE)
fragP->tc_frag_data.is_unreachable = TRUE; fragP->tc_frag_data.is_unreachable = TRUE;
} }
@ -7134,7 +7134,7 @@ xtensa_mark_zcl_first_insns (void)
/* Of course, sometimes (mostly for toy test cases) a /* Of course, sometimes (mostly for toy test cases) a
zero-cost loop instruction is the last in a section. */ zero-cost loop instruction is the last in a section. */
if (targ_frag) if (targ_frag)
{ {
targ_frag->tc_frag_data.is_first_loop_insn = TRUE; targ_frag->tc_frag_data.is_first_loop_insn = TRUE;
if (fragP->fr_subtype == RELAX_CHECK_ALIGN_NEXT_OPCODE) if (fragP->fr_subtype == RELAX_CHECK_ALIGN_NEXT_OPCODE)
@ -7389,7 +7389,7 @@ xtensa_fix_close_loop_end_frags (void)
< REQUIRED_LOOP_DIVIDING_BYTES) < REQUIRED_LOOP_DIVIDING_BYTES)
{ {
int length = 3; int length = 3;
if (fragP->fr_var < length) if (fragP->fr_var < length)
as_fatal (_("fr_var %lu < length %d"), as_fatal (_("fr_var %lu < length %d"),
(long) fragP->fr_var, length); (long) fragP->fr_var, length);
@ -7461,7 +7461,7 @@ unrelaxed_frag_max_size (fragS *fragP)
switch (fragP->fr_type) switch (fragP->fr_type)
{ {
case 0: case 0:
/* Empty frags created by the obstack allocation scheme /* Empty frags created by the obstack allocation scheme
end up with type 0. */ end up with type 0. */
break; break;
case rs_fill: case rs_fill:
@ -7904,7 +7904,7 @@ get_text_align_fill_size (addressT address,
alignment = (1 << align_pow); alignment = (1 << align_pow);
assert (target_size > 0 && alignment >= (addressT) target_size); assert (target_size > 0 && alignment >= (addressT) target_size);
if (!use_nops) if (!use_nops)
{ {
fill_limit = alignment; fill_limit = alignment;
@ -8024,16 +8024,16 @@ get_noop_aligned_address (fragS *fragP, addressT address)
the smallest number of bytes that need to be added to the smallest number of bytes that need to be added to
ensure that the next fragment's FIRST instruction will fit ensure that the next fragment's FIRST instruction will fit
in a single word. in a single word.
E.G., 2 bytes : 0, 1, 2 mod 4 E.G., 2 bytes : 0, 1, 2 mod 4
3 bytes: 0, 1 mod 4 3 bytes: 0, 1 mod 4
If the FIRST instruction MIGHT be relaxed, If the FIRST instruction MIGHT be relaxed,
assume that it will become a 3-byte instruction. assume that it will become a 3-byte instruction.
Note again here that LOOP instructions are not bundleable, Note again here that LOOP instructions are not bundleable,
and this relaxation only applies to LOOP opcodes. */ and this relaxation only applies to LOOP opcodes. */
int fill_size = 0; int fill_size = 0;
int first_insn_size; int first_insn_size;
int loop_insn_size; int loop_insn_size;
@ -8074,7 +8074,7 @@ get_noop_aligned_address (fragS *fragP, addressT address)
/* If it was 8, then we'll need a larger alignment for the section. */ /* If it was 8, then we'll need a larger alignment for the section. */
align_power = get_text_align_power (first_insn_size); align_power = get_text_align_power (first_insn_size);
record_alignment (now_seg, align_power); record_alignment (now_seg, align_power);
fill_size = get_text_align_fill_size fill_size = get_text_align_fill_size
(address + pre_opcode_bytes, align_power, first_insn_size, TRUE, (address + pre_opcode_bytes, align_power, first_insn_size, TRUE,
fragP->tc_frag_data.is_no_density); fragP->tc_frag_data.is_no_density);
@ -8289,7 +8289,7 @@ xtensa_relax_frag (fragS *fragP, long stretch, int *stretched_p)
} }
/* Tell gas we need another relaxation pass. */ /* Tell gas we need another relaxation pass. */
if (! fragP->tc_frag_data.relax_seen) if (! fragP->tc_frag_data.relax_seen)
{ {
fragP->tc_frag_data.relax_seen = TRUE; fragP->tc_frag_data.relax_seen = TRUE;
*stretched_p = 1; *stretched_p = 1;
@ -8476,7 +8476,7 @@ find_address_of_next_align_frag (fragS **fragPP,
return 0; return 0;
} }
} }
else else
{ {
/* Just punt if we don't know the type. */ /* Just punt if we don't know the type. */
*fragPP = fragP; *fragPP = fragP;
@ -8517,7 +8517,7 @@ future_alignment_required (fragS *fragP, long stretch ATTRIBUTE_UNUSED)
opt_diff = local_opt_diff; opt_diff = local_opt_diff;
assert (opt_diff >= 0); assert (opt_diff >= 0);
assert (max_diff >= opt_diff); assert (max_diff >= opt_diff);
if (max_diff == 0) if (max_diff == 0)
return 0; return 0;
if (fragP) if (fragP)
@ -8526,7 +8526,7 @@ future_alignment_required (fragS *fragP, long stretch ATTRIBUTE_UNUSED)
while (fragP && opt_diff < max_diff && address) while (fragP && opt_diff < max_diff && address)
{ {
/* We only use these to determine if we can exit early /* We only use these to determine if we can exit early
because there will be plenty of ways to align future because there will be plenty of ways to align future
align frags. */ align frags. */
int glob_widens = 0; int glob_widens = 0;
int dnn = 0; int dnn = 0;
@ -8538,7 +8538,7 @@ future_alignment_required (fragS *fragP, long stretch ATTRIBUTE_UNUSED)
if (glob_pad || glob_widens >= (1 << branch_align_power (now_seg))) if (glob_pad || glob_widens >= (1 << branch_align_power (now_seg)))
break; break;
if (address) if (address)
{ {
offsetT next_m_diff; offsetT next_m_diff;
offsetT next_o_diff; offsetT next_o_diff;
@ -8579,15 +8579,15 @@ future_alignment_required (fragS *fragP, long stretch ATTRIBUTE_UNUSED)
} }
return 0; return 0;
} }
local_stretch_amount local_stretch_amount
= bytes_to_stretch (this_frag, wide_nops, narrow_nops, = bytes_to_stretch (this_frag, wide_nops, narrow_nops,
num_widens, local_opt_diff); num_widens, local_opt_diff);
global_stretch_amount global_stretch_amount
= bytes_to_stretch (this_frag, wide_nops, narrow_nops, = bytes_to_stretch (this_frag, wide_nops, narrow_nops,
num_widens, opt_diff); num_widens, opt_diff);
/* If the condition below is true, then the frag couldn't /* If the condition below is true, then the frag couldn't
stretch the correct amount for the global case, so we just stretch the correct amount for the global case, so we just
optimize locally. We'll rely on the subsequent frags to get optimize locally. We'll rely on the subsequent frags to get
the correct alignment in the global case. */ the correct alignment in the global case. */
if (global_stretch_amount < local_stretch_amount) if (global_stretch_amount < local_stretch_amount)
stretch_amount = local_stretch_amount; stretch_amount = local_stretch_amount;
@ -8659,7 +8659,7 @@ bytes_to_stretch (fragS *this_frag,
assert (desired_diff >= 0 && desired_diff < 8); assert (desired_diff >= 0 && desired_diff < 8);
if (desired_diff == 0) if (desired_diff == 0)
return 0; return 0;
assert (wide_nops > 0 || num_widens > 0); assert (wide_nops > 0 || num_widens > 0);
/* Always prefer widening to NOP-filling. */ /* Always prefer widening to NOP-filling. */
@ -8669,7 +8669,7 @@ bytes_to_stretch (fragS *this_frag,
to align the target without widening this frag in any way. */ to align the target without widening this frag in any way. */
return 0; return 0;
} }
if (bytes_short == 0) if (bytes_short == 0)
{ {
/* Widen every narrow between here and the align target /* Widen every narrow between here and the align target
@ -8679,7 +8679,7 @@ bytes_to_stretch (fragS *this_frag,
else else
return 1; return 1;
} }
/* From here we will need at least one NOP to get an alignment. /* From here we will need at least one NOP to get an alignment.
However, we may not be able to align at all, in which case, However, we may not be able to align at all, in which case,
don't widen. */ don't widen. */
@ -8693,7 +8693,7 @@ bytes_to_stretch (fragS *this_frag,
if (!this_frag->tc_frag_data.is_no_density && narrow_nops == 1) if (!this_frag->tc_frag_data.is_no_density && narrow_nops == 1)
return 2; /* case 2 */ return 2; /* case 2 */
return 0; return 0;
case 3: case 3:
if (wide_nops > 1) if (wide_nops > 1)
return 0; return 0;
else else
@ -8707,7 +8707,7 @@ bytes_to_stretch (fragS *this_frag,
case 5: case 5:
if (num_widens >= 2 && wide_nops == 1) if (num_widens >= 2 && wide_nops == 1)
return 3; /* case 5a */ return 3; /* case 5a */
/* We will need two nops. Are there enough nops /* We will need two nops. Are there enough nops
between here and the align target? */ between here and the align target? */
if (wide_nops < 2 || narrow_nops == 0) if (wide_nops < 2 || narrow_nops == 0)
return 0; return 0;
@ -8739,7 +8739,7 @@ bytes_to_stretch (fragS *this_frag,
} }
else else
{ {
/* We will need a NOP no matter what, but should we widen /* We will need a NOP no matter what, but should we widen
this instruction to help? this instruction to help?
This is a RELAX_FRAG_NARROW frag. */ This is a RELAX_FRAG_NARROW frag. */
@ -9837,7 +9837,7 @@ mark_literal_frags (seg_list *segment)
{ {
frchain_from = seg_info (segment->seg)->frchainP; frchain_from = seg_info (segment->seg)->frchainP;
search_frag = frchain_from->frch_root; search_frag = frchain_from->frch_root;
while (search_frag) while (search_frag)
{ {
search_frag->tc_frag_data.is_literal = TRUE; search_frag->tc_frag_data.is_literal = TRUE;
search_frag = search_frag->fr_next; search_frag = search_frag->fr_next;
@ -9934,10 +9934,10 @@ xtensa_switch_to_non_abs_literal_fragment (emit_state *result)
static bfd_boolean recursive = FALSE; static bfd_boolean recursive = FALSE;
fragS *pool_location = get_literal_pool_location (now_seg); fragS *pool_location = get_literal_pool_location (now_seg);
bfd_boolean is_init = bfd_boolean is_init =
(now_seg && !strcmp (segment_name (now_seg), INIT_SECTION_NAME)); (now_seg && !strcmp (segment_name (now_seg), INIT_SECTION_NAME));
bfd_boolean is_fini = bfd_boolean is_fini =
(now_seg && !strcmp (segment_name (now_seg), FINI_SECTION_NAME)); (now_seg && !strcmp (segment_name (now_seg), FINI_SECTION_NAME));
if (pool_location == NULL if (pool_location == NULL
@ -11450,7 +11450,7 @@ static bfd_boolean
vinsn_has_specific_opcodes (vliw_insn *v) vinsn_has_specific_opcodes (vliw_insn *v)
{ {
int i; int i;
for (i = 0; i < v->num_slots; i++) for (i = 0; i < v->num_slots; i++)
{ {
if (v->slots[i].is_specific_opcode) if (v->slots[i].is_specific_opcode)

24
gas/config/tc-xtensa.h
View File

@ -141,7 +141,7 @@ enum xtensa_relax_statesE
does not fit, use the specified expansion. This is similar to does not fit, use the specified expansion. This is similar to
"NARROW", except that these may not be expanded in order to align "NARROW", except that these may not be expanded in order to align
code. */ code. */
RELAX_IMMED_STEP1, RELAX_IMMED_STEP1,
/* The last instruction in this fragment (at->fr_opcode) contains a /* The last instruction in this fragment (at->fr_opcode) contains a
literal. It has already been expanded at least 1 step. */ literal. It has already been expanded at least 1 step. */
@ -170,7 +170,7 @@ enum xtensa_relax_statesE
RELAX_MAYBE_UNREACHABLE, RELAX_MAYBE_UNREACHABLE,
/* This marks the location as possibly unreachable. These are placed /* This marks the location as possibly unreachable. These are placed
after a branch that may be relaxed into a branch and jump. If the after a branch that may be relaxed into a branch and jump. If the
branch is relaxed, then this frag will be converted to a branch is relaxed, then this frag will be converted to a
RELAX_UNREACHABLE frag. */ RELAX_UNREACHABLE frag. */
RELAX_NONE RELAX_NONE
@ -382,27 +382,27 @@ typedef int (*unit_num_copies_func) (void *, xtensa_funcUnit);
/* Returns the number of units the opcode uses. */ /* Returns the number of units the opcode uses. */
typedef int (*opcode_num_units_func) (void *, xtensa_opcode); typedef int (*opcode_num_units_func) (void *, xtensa_opcode);
/* Given an opcode and an index into the opcode's funcUnit list, /* Given an opcode and an index into the opcode's funcUnit list,
returns the unit used for the index. */ returns the unit used for the index. */
typedef int (*opcode_funcUnit_use_unit_func) (void *, xtensa_opcode, int); typedef int (*opcode_funcUnit_use_unit_func) (void *, xtensa_opcode, int);
/* Given an opcode and an index into the opcode's funcUnit list, /* Given an opcode and an index into the opcode's funcUnit list,
returns the cycle during which the unit is used. */ returns the cycle during which the unit is used. */
typedef int (*opcode_funcUnit_use_stage_func) (void *, xtensa_opcode, int); typedef int (*opcode_funcUnit_use_stage_func) (void *, xtensa_opcode, int);
/* The above typedefs parameterize the resource_table so that the /* The above typedefs parameterize the resource_table so that the
optional scheduler doesn't need its own resource reservation system. optional scheduler doesn't need its own resource reservation system.
For simple resource checking, which is all that happens normally, For simple resource checking, which is all that happens normally,
the functions will be as follows (with some wrapping to make the the functions will be as follows (with some wrapping to make the
interface more convenient): interface more convenient):
unit_num_copies_func = xtensa_funcUnit_num_copies unit_num_copies_func = xtensa_funcUnit_num_copies
opcode_num_units_func = xtensa_opcode_num_funcUnit_uses opcode_num_units_func = xtensa_opcode_num_funcUnit_uses
opcode_funcUnit_use_unit_func = xtensa_opcode_funcUnit_use->unit opcode_funcUnit_use_unit_func = xtensa_opcode_funcUnit_use->unit
opcode_funcUnit_use_stage_func = xtensa_opcode_funcUnit_use->stage opcode_funcUnit_use_stage_func = xtensa_opcode_funcUnit_use->stage
Of course the optional scheduler has its own reservation table Of course the optional scheduler has its own reservation table
and functions. */ and functions. */
int opcode_funcUnit_use_unit (void *, xtensa_opcode, int); int opcode_funcUnit_use_unit (void *, xtensa_opcode, int);
@ -421,8 +421,8 @@ typedef struct
char **units; char **units;
} resource_table; } resource_table;
resource_table *new_resource_table resource_table *new_resource_table
(void *, int, int, unit_num_copies_func, opcode_num_units_func, (void *, int, int, unit_num_copies_func, opcode_num_units_func,
opcode_funcUnit_use_unit_func, opcode_funcUnit_use_stage_func); opcode_funcUnit_use_unit_func, opcode_funcUnit_use_stage_func);
void resize_resource_table (resource_table *, int); void resize_resource_table (resource_table *, int);
void clear_resource_table (resource_table *); void clear_resource_table (resource_table *);

6
gas/config/xtensa-istack.h
View File

@ -43,8 +43,8 @@ typedef struct tinsn_struct
enum itype_enum insn_type; enum itype_enum insn_type;
xtensa_opcode opcode; /* Literals have an invalid opcode. */ xtensa_opcode opcode; /* Literals have an invalid opcode. */
bfd_boolean is_specific_opcode; bfd_boolean is_specific_opcode;
bfd_boolean keep_wide; bfd_boolean keep_wide;
int ntok; int ntok;
expressionS tok[MAX_INSN_ARGS]; expressionS tok[MAX_INSN_ARGS];
struct dwarf2_line_info loc; struct dwarf2_line_info loc;
@ -77,7 +77,7 @@ bfd_boolean istack_empty (IStack *);
bfd_boolean istack_full (IStack *); bfd_boolean istack_full (IStack *);
TInsn *istack_top (IStack *); TInsn *istack_top (IStack *);
void istack_push (IStack *, TInsn *); void istack_push (IStack *, TInsn *);
TInsn *istack_push_space (IStack *); TInsn *istack_push_space (IStack *);
void istack_pop (IStack *); void istack_pop (IStack *);
/* TInsn utilities. */ /* TInsn utilities. */

30
gas/config/xtensa-relax.c
View File

@ -15,7 +15,7 @@
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with GAS; see the file COPYING. If not, write to along with GAS; see the file COPYING. If not, write to
the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,
MA 02110-1301, USA. */ MA 02110-1301, USA. */
/* This file contains the code for generating runtime data structures /* This file contains the code for generating runtime data structures
@ -25,7 +25,7 @@
matches. The preconditions can specify that two operands are the matches. The preconditions can specify that two operands are the
same or an operand is a specific constant or register. The expansion same or an operand is a specific constant or register. The expansion
uses the bound variables from the pattern to specify that specific uses the bound variables from the pattern to specify that specific
operands from the pattern should be used in the result. operands from the pattern should be used in the result.
The code determines whether the condition applies to a constant or The code determines whether the condition applies to a constant or
a register depending on the type of the operand. You may get a register depending on the type of the operand. You may get
@ -46,10 +46,10 @@
OPTIONPRED ::= OPTIONNAME ('+' OPTIONNAME) OPTIONPRED ::= OPTIONNAME ('+' OPTIONNAME)
OPTIONNAME ::= '"' id '"' OPTIONNAME ::= '"' id '"'
The replacement language The replacement language
INSN_REPL ::= INSN_LABEL_LIT ( ';' INSN_LABEL_LIT )* INSN_REPL ::= INSN_LABEL_LIT ( ';' INSN_LABEL_LIT )*
INSN_LABEL_LIT ::= INSN_TEMPL INSN_LABEL_LIT ::= INSN_TEMPL
| 'LABEL' num | 'LABEL' num
| 'LITERAL' num ' ' VARIABLE | 'LITERAL' num ' ' VARIABLE
The operands in a PRECOND must be constants or variables bound by The operands in a PRECOND must be constants or variables bound by
@ -75,7 +75,7 @@
{"beqz %as,%label", "bnez %as,%LABEL0;j %label;LABEL0"} {"beqz %as,%label", "bnez %as,%LABEL0;j %label;LABEL0"}
would convert a branch to a negated branch to the following instruction would convert a branch to a negated branch to the following instruction
with a jump to the original label. with a jump to the original label.
An Xtensa-specific example that generates a literal: An Xtensa-specific example that generates a literal:
{"movi %at,%imm", "LITERAL0 %imm; l32r %at,%LITERAL0"} {"movi %at,%imm", "LITERAL0 %imm; l32r %at,%LITERAL0"}
will convert a movi instruction to an l32r of a literal will convert a movi instruction to an l32r of a literal
@ -263,9 +263,9 @@ static string_pattern_pair widen_spec_list[] =
{"slli %ar,%as,0", "or %ar,%as,%as"}, {"slli %ar,%as,0", "or %ar,%as,%as"},
/* Widening with literals or const16. */ /* Widening with literals or const16. */
{"movi %at,%imm ? IsaUseL32R ", {"movi %at,%imm ? IsaUseL32R ",
"LITERAL0 %imm; l32r %at,%LITERAL0"}, "LITERAL0 %imm; l32r %at,%LITERAL0"},
{"movi %at,%imm ? IsaUseConst16", {"movi %at,%imm ? IsaUseConst16",
"const16 %at,HI16U(%imm); const16 %at,LOW16U(%imm)"}, "const16 %at,HI16U(%imm); const16 %at,LOW16U(%imm)"},
{"addi %ar,%as,%imm", "addmi %ar,%as,%imm"}, {"addi %ar,%as,%imm", "addmi %ar,%as,%imm"},
@ -1278,7 +1278,7 @@ clone_req_option_list (ReqOption *req_option)
new_req_option = (ReqOption *) xmalloc (sizeof (ReqOption)); new_req_option = (ReqOption *) xmalloc (sizeof (ReqOption));
new_req_option->or_option_terms = NULL; new_req_option->or_option_terms = NULL;
new_req_option->next = NULL; new_req_option->next = NULL;
new_req_option->or_option_terms = new_req_option->or_option_terms =
clone_req_or_option_list (req_option->or_option_terms); clone_req_or_option_list (req_option->or_option_terms);
new_req_option->next = clone_req_option_list (req_option->next); new_req_option->next = clone_req_option_list (req_option->next);
return new_req_option; return new_req_option;
@ -1325,7 +1325,7 @@ parse_option_cond (const char *s, ReqOption *option)
req->next = NULL; req->next = NULL;
/* Append to list. */ /* Append to list. */
for (r_p = &option->or_option_terms; (*r_p) != NULL; for (r_p = &option->or_option_terms; (*r_p) != NULL;
r_p = &(*r_p)->next) r_p = &(*r_p)->next)
; ;
(*r_p) = req; (*r_p) = req;
@ -1366,7 +1366,7 @@ parse_insn_pattern (const char *in, insn_pattern *insn)
clear_split_rec (&optionrec); clear_split_rec (&optionrec);
return FALSE; return FALSE;
} }
init_split_rec (&rec); init_split_rec (&rec);
split_string (&rec, optionrec.vec[0], '|', TRUE); split_string (&rec, optionrec.vec[0], '|', TRUE);
@ -1409,7 +1409,7 @@ parse_insn_pattern (const char *in, insn_pattern *insn)
ReqOption *req_option = (ReqOption *) xmalloc (sizeof (ReqOption)); ReqOption *req_option = (ReqOption *) xmalloc (sizeof (ReqOption));
req_option->or_option_terms = NULL; req_option->or_option_terms = NULL;
req_option->next = NULL; req_option->next = NULL;
if (!parse_option_cond (optionrec.vec[i], req_option)) if (!parse_option_cond (optionrec.vec[i], req_option))
{ {
clear_split_rec (&rec); clear_split_rec (&rec);
@ -1477,7 +1477,7 @@ transition_applies (insn_pattern *initial_insn,
|| req_or_option->next != NULL) || req_or_option->next != NULL)
continue; continue;
if (strncmp (req_or_option->option_name, "IsaUse", 6) == 0) if (strncmp (req_or_option->option_name, "IsaUse", 6) == 0)
{ {
bfd_boolean option_available = FALSE; bfd_boolean option_available = FALSE;
char *option_name = req_or_option->option_name + 6; char *option_name = req_or_option->option_name + 6;
@ -1501,7 +1501,7 @@ transition_applies (insn_pattern *initial_insn,
} }
else if (strcmp (req_or_option->option_name, "realnop") == 0) else if (strcmp (req_or_option->option_name, "realnop") == 0)
{ {
bfd_boolean nop_available = bfd_boolean nop_available =
(xtensa_opcode_lookup (xtensa_default_isa, "nop") (xtensa_opcode_lookup (xtensa_default_isa, "nop")
!= XTENSA_UNDEFINED); != XTENSA_UNDEFINED);
if ((nop_available ^ req_or_option->is_true) != 0) if ((nop_available ^ req_or_option->is_true) != 0)
@ -1697,7 +1697,7 @@ build_transition (insn_pattern *initial_insn,
return NULL; return NULL;
} }
/* Check for the right number of ops. */ /* Check for the right number of ops. */
if (xtensa_opcode_num_operands (isa, bi->opcode) if (xtensa_opcode_num_operands (isa, bi->opcode)
!= (int) operand_count) != (int) operand_count)
as_fatal (_("opcode '%s': replacement does not have %d ops"), as_fatal (_("opcode '%s': replacement does not have %d ops"),
opcode_name, opcode_name,

2
gas/config/xtensa-relax.h
View File

@ -15,7 +15,7 @@
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with GAS; see the file COPYING. If not, write to along with GAS; see the file COPYING. If not, write to
the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,
MA 02110-1301, USA. */ MA 02110-1301, USA. */
#ifndef XTENSA_RELAX_H #ifndef XTENSA_RELAX_H