/* tc-mmix.c -- Assembler for Don Knuth's MMIX.
- Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+ Free Software Foundation.
This file is part of GAS, the GNU Assembler.
GAS is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
+ 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,
You should have received a copy of the GNU General Public License
along with GAS; see the file COPYING. If not, write to
- the Free Software Foundation, 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ the Free Software Foundation, 51 Franklin Street - Fifth Floor,
+ Boston, MA 02110-1301, USA. */
/* Knuth's assembler mmixal does not provide a relocatable format; mmo is
to be considered a final link-format. In the final link, we make mmo,
compatible syntax, but the main purpose is to serve GCC. */
-#include <stdio.h>
#include <limits.h>
#include "as.h"
#include "subsegs.h"
-#include "bfd.h"
#include "elf/mmix.h"
#include "opcode/mmix.h"
#include "safe-ctype.h"
pass expressions as symbols and use fix_new, not fix_new_exp. */
sym = make_expr_symbol (exp + 1);
+ /* Mark the symbol as being OK for a reloc. */
+ symbol_get_bfdsym (sym)->flags |= BSF_KEEP;
+
/* Now we know it can be a "base address plus offset". Add
proper fixup types so we can handle this later, when we've
parsed everything. */
break;
case mmix_operands_xyz_opt:
- /* SWYM, TRIP, TRAP: zero, one, two or three operands. */
+ /* SWYM, TRIP, TRAP: zero, one, two or three operands. It's
+ unspecified whether operands are registers or constants, but
+ when we find register syntax, we require operands to be literal and
+ within 0..255. */
if (n_operands == 0 && ! mmix_gnu_syntax)
/* Zeros are in place - nothing needs to be done for zero
operands. We don't allow this in GNU syntax mode, because it
{
if (exp[0].X_op == O_constant)
{
- if (exp[0].X_add_number > 255*255*255
+ if (exp[0].X_add_number > 255*256*256
|| exp[0].X_add_number < 0)
{
as_bad (_("invalid operands to opcode %s: `%s'"),
if (exp[1].X_op == O_constant)
{
- if (exp[1].X_add_number > 255*255
+ if (exp[1].X_add_number > 255*256
|| exp[1].X_add_number < 0)
{
as_bad (_("invalid operands to opcode %s: `%s'"),
fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3,
1, exp + 2, 0, BFD_RELOC_8);
}
- else if (n_operands <= 3
- && (strcmp (instruction->name, "trip") == 0
- || strcmp (instruction->name, "trap") == 0))
+ else
{
- /* The meaning of operands to TRIP and TRAP are not defined, so
- we add combinations not handled above here as we find them. */
+ /* We can't get here for other cases. */
+ gas_assert (n_operands <= 3);
+
+ /* The meaning of operands to TRIP and TRAP is not defined (and
+ SWYM operands aren't enforced in mmixal, so let's avoid
+ that). We add combinations not handled above here as we find
+ them and as they're reported. */
if (n_operands == 3)
{
/* Don't require non-register operands. Always generate
maintenance problems. TRIP is supposed to be a rare
instruction, so the overhead should not matter. We
aren't allowed to fix_new_exp for an expression which is
- an O_register at this point, however. */
+ an O_register at this point, however.
+
+ Don't use BFD_RELOC_MMIX_REG_OR_BYTE as that modifies
+ the insn for a register in the Z field and we want
+ consistency. */
if (exp[0].X_op == O_register)
opcodep[1] = exp[0].X_add_number;
else
fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1,
- 1, exp, 0, BFD_RELOC_MMIX_REG_OR_BYTE);
+ 1, exp, 0, BFD_RELOC_8);
if (exp[1].X_op == O_register)
opcodep[2] = exp[1].X_add_number;
else
fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2,
- 1, exp + 1, 0, BFD_RELOC_MMIX_REG_OR_BYTE);
+ 1, exp + 1, 0, BFD_RELOC_8);
if (exp[2].X_op == O_register)
opcodep[3] = exp[2].X_add_number;
else
fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3,
- 1, exp + 2, 0, BFD_RELOC_MMIX_REG_OR_BYTE);
+ 1, exp + 2, 0, BFD_RELOC_8);
}
else if (n_operands == 2)
{
if (exp[0].X_op == O_register)
- opcodep[2] = exp[0].X_add_number;
+ opcodep[1] = exp[0].X_add_number;
else
- fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2,
- 1, exp, 0, BFD_RELOC_MMIX_REG_OR_BYTE);
+ fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1,
+ 1, exp, 0, BFD_RELOC_8);
if (exp[1].X_op == O_register)
opcodep[3] = exp[1].X_add_number;
else
- fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3,
- 1, exp + 1, 0, BFD_RELOC_MMIX_REG_OR_BYTE);
+ fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2,
+ 2, exp + 1, 0, BFD_RELOC_16);
}
else
{
- as_bad (_("unsupported operands to %s: `%s'"),
- instruction->name, operands);
- return;
+ /* We can't get here for other cases. */
+ gas_assert (n_operands == 1 && exp[0].X_op == O_register);
+
+ opcodep[3] = exp[0].X_add_number;
}
}
- else
- {
- as_bad (_("invalid operands to opcode %s: `%s'"),
- instruction->name, operands);
- return;
- }
break;
case mmix_operands_resume:
char *
md_atof (int type, char *litP, int *sizeP)
{
- int prec;
- LITTLENUM_TYPE words[4];
- char *t;
- int i;
-
- switch (type)
- {
- /* FIXME: Having 'f' in mmix_flt_chars (and here) makes it
- problematic to also have a forward reference in an expression.
- The testsuite wants it, and it's customary.
- We'll deal with the real problems when they come; we share the
- problem with most other ports. */
- case 'f':
- case 'r':
- prec = 2;
- break;
- case 'd':
- prec = 4;
- break;
- default:
- *sizeP = 0;
- return _("bad call to md_atof");
- }
-
- t = atof_ieee (input_line_pointer, type, words);
- if (t)
- input_line_pointer = t;
-
- *sizeP = prec * 2;
-
- for (i = 0; i < prec; i++)
- {
- md_number_to_chars (litP, (valueT) words[i], 2);
- litP += 2;
- }
- return NULL;
+ if (type == 'r')
+ type = 'f';
+ /* FIXME: Having 'f' in mmix_flt_chars (and here) makes it
+ problematic to also have a forward reference in an expression.
+ The testsuite wants it, and it's customary.
+ We'll deal with the real problems when they come; we share the
+ problem with most other ports. */
+ return ieee_md_atof (type, litP, sizeP, TRUE);
}
/* Convert variable-sized frags into one or more fixups. */
if (fragP->tc_frag_data == NULL)
{
/* We must initialize data that's supposed to be "fixed up" to
- avoid emitting garbage, because md_apply_fix3 won't do
+ avoid emitting garbage, because md_apply_fix won't do
anything for undefined symbols. */
md_number_to_chars (var_partp, 0, 8);
tmpfixP
Note that this function isn't called when linkrelax != 0. */
void
-md_apply_fix3 (fixS *fixP, valueT *valP, segT segment)
+md_apply_fix (fixS *fixP, valueT *valP, segT segment)
{
char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
/* Note: use offsetT because it is signed, valueT is unsigned. */
if (addsy == NULL || bfd_is_abs_section (addsec))
{
- /* Resolve this reloc now, as md_apply_fix3 would have done (not
+ /* Resolve this reloc now, as md_apply_fix would have done (not
called if -linkrelax). There is no point in keeping a reloc
to an absolute symbol. No reloc that is subject to
relaxation must be to an absolute symbol; difference
}
/* FALLTHROUGH. */
- /* The others are supposed to be handled by md_apply_fix3.
+ /* The others are supposed to be handled by md_apply_fix.
FIXME: ... which isn't called when -linkrelax. Move over
- md_apply_fix3 code here for everything reasonable. */
+ md_apply_fix code here for everything reasonable. */
badop:
default:
as_bad_where
}
relP = (arelent *) xmalloc (sizeof (arelent));
- assert (relP != 0);
+ gas_assert (relP != 0);
relP->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
*relP->sym_ptr_ptr = baddsy;
relP->address = fixP->fx_frag->fr_address + fixP->fx_where;
void
mmix_handle_mmixal (void)
{
- char *s0 = input_line_pointer;
- char *s;
+ char *insn;
+ char *s = input_line_pointer;
char *label = NULL;
char c;
if (mmix_gnu_syntax)
return;
- /* If the first character is a '.', then it's a pseudodirective, not a
- label. Make GAS not handle label-without-colon on this line. We
- also don't do mmixal-specific stuff on this line. */
- if (input_line_pointer[0] == '.')
- {
- label_without_colon_this_line = 0;
- return;
- }
-
- /* Don't handle empty lines here. */
- while (1)
- {
- if (*s0 == 0 || is_end_of_line[(unsigned int) *s0])
- return;
-
- if (! ISSPACE (*s0))
- break;
-
- s0++;
- }
-
/* If we're on a line with a label, check if it's a mmixal fb-label.
Save an indicator and skip the label; it must be set only after all
fb-labels of expressions are evaluated. */
- if (ISDIGIT (input_line_pointer[0])
- && input_line_pointer[1] == 'H'
- && ISSPACE (input_line_pointer[2]))
+ if (ISDIGIT (s[0]) && s[1] == 'H' && ISSPACE (s[2]))
{
- char *s;
- current_fb_label = input_line_pointer[0] - '0';
+ current_fb_label = s[0] - '0';
/* We have to skip the label, but also preserve the newlineness of
the previous character, since the caller checks that. It's a
mess we blame on the caller. */
- input_line_pointer[1] = input_line_pointer[-1];
- input_line_pointer += 2;
+ s[1] = s[-1];
+ s += 2;
+ input_line_pointer = s;
- s = input_line_pointer;
while (*s && ISSPACE (*s) && ! is_end_of_line[(unsigned int) *s])
s++;
_("[0-9]H labels do not mix with dot-pseudos"));
current_fb_label = -1;
}
+
+ /* Back off to the last space before the opcode so we don't handle
+ the opcode as a label. */
+ s--;
}
else
+ current_fb_label = -1;
+
+ if (*s == '.')
{
- current_fb_label = -1;
- if (is_name_beginner (input_line_pointer[0]))
- label = input_line_pointer;
+ /* If the first character is a '.', then it's a pseudodirective, not a
+ label. Make GAS not handle label-without-colon on this line. We
+ also don't do mmixal-specific stuff on this line. */
+ label_without_colon_this_line = 0;
+ return;
}
- s0 = input_line_pointer;
- /* Skip over label. */
- while (*s0 && is_part_of_name (*s0))
- s0++;
-
- /* Remove trailing ":" off labels, as they'd otherwise be considered
- part of the name. But don't do it for local labels. */
- if (s0 != input_line_pointer && s0[-1] == ':'
- && (s0 - 2 != input_line_pointer
- || ! ISDIGIT (s0[-2])))
- s0[-1] = ' ';
- else if (label != NULL)
+ if (*s == 0 || is_end_of_line[(unsigned int) *s])
+ /* We avoid handling empty lines here. */
+ return;
+
+ if (is_name_beginner (*s))
+ label = s;
+
+ /* If there is a label, skip over it. */
+ while (*s && is_part_of_name (*s))
+ s++;
+
+ /* Find the start of the instruction or pseudo following the label,
+ if there is one. */
+ for (insn = s;
+ *insn && ISSPACE (*insn) && ! is_end_of_line[(unsigned int) *insn];
+ insn++)
+ /* Empty */
+ ;
+
+ /* Remove a trailing ":" off labels, as they'd otherwise be considered
+ part of the name. But don't do this for local labels. */
+ if (s != input_line_pointer && s[-1] == ':'
+ && (s - 2 != input_line_pointer
+ || ! ISDIGIT (s[-2])))
+ s[-1] = ' ';
+ else if (label != NULL
+ /* For a lone label on a line, we don't attach it to the next
+ instruction or MMIXAL-pseudo (getting its alignment). Thus
+ is acts like a "normal" :-ended label. Ditto if it's
+ followed by a non-MMIXAL pseudo. */
+ && !is_end_of_line[(unsigned int) *insn]
+ && *insn != '.')
{
/* For labels that don't end in ":", we save it so we can later give
it the same alignment and address as the associated instruction. */
/* Make room for the label including the ending nul. */
- int len_0 = s0 - label + 1;
+ int len_0 = s - label + 1;
/* Save this label on the MMIX symbol obstack. Saving it on an
obstack is needless for "IS"-pseudos, but it's harmless and we
pending_label[len_0 - 1] = 0;
}
- while (*s0 && ISSPACE (*s0) && ! is_end_of_line[(unsigned int) *s0])
- s0++;
-
- if (pending_label != NULL && is_end_of_line[(unsigned int) *s0])
- /* Whoops, this was actually a lone label on a line. Like :-ended
- labels, we don't attach such labels to the next instruction or
- pseudo. */
- pending_label = NULL;
+ /* If we have a non-MMIXAL pseudo, we have not business with the rest of
+ the line. */
+ if (*insn == '.')
+ return;
/* Find local labels of operands. Look for "[0-9][FB]" where the
characters before and after are not part of words. Break if a single
/* First make sure we don't have any of the magic characters on the line
appearing as input. */
- s = s0;
while (*s)
{
c = *s++;
}
/* Scan again, this time looking for ';' after operands. */
- s = s0;
+ s = insn;
/* Skip the insn. */
while (*s
{
if ((s[1] != 'B' && s[1] != 'F')
|| is_part_of_name (s[-1])
- || is_part_of_name (s[2]))
+ || is_part_of_name (s[2])
+ /* Don't treat e.g. #1F as a local-label reference. */
+ || (s != input_line_pointer && s[-1] == '#'))
s++;
else
{
/* Make IS into an EQU by replacing it with "= ". Only match upper-case
though; let lower-case be a syntax error. */
- s = s0;
+ s = insn;
if (s[0] == 'I' && s[1] == 'S' && ISSPACE (s[2]))
{
*s = '=';
if (linkrelax)
return 1;
- /* All our pcrel relocations are must-keep. Note that md_apply_fix3 is
+ /* All our pcrel relocations are must-keep. Note that md_apply_fix is
called *after* this, and will handle getting rid of the presumed
reloc; a relocation isn't *forced* other than to be handled by
- md_apply_fix3 (or tc_gen_reloc if linkrelax). */
+ md_apply_fix (or tc_gen_reloc if linkrelax). */
if (fixP->fx_pcrel)
return 1;
{
if (sym == regsec)
{
- if (S_IS_EXTERN (sym) || symbol_used_in_reloc_p (sym))
+ if (S_IS_EXTERNAL (sym) || symbol_used_in_reloc_p (sym))
abort ();
symbol_remove (sym, &symbol_rootP, &symbol_lastP);
}
{
fragS *fragP;
symbolS *mainsym;
+ asection *regsec;
int i;
/* The first frag of GREG:s going into the register contents section. */
and the same allocation order (within a file) as mmixal. */
segT this_segment = now_seg;
subsegT this_subsegment = now_subseg;
- asection *regsec
- = bfd_make_section_old_way (stdoutput,
- MMIX_REG_CONTENTS_SECTION_NAME);
+
+ regsec = bfd_make_section_old_way (stdoutput,
+ MMIX_REG_CONTENTS_SECTION_NAME);
subseg_set (regsec, 0);
/* Finally emit the initialization-value. Emit a variable frag, which
subseg_set (this_segment, this_subsegment);
}
+ regsec = bfd_get_section_by_name (stdoutput, MMIX_REG_CONTENTS_SECTION_NAME);
+ /* Mark the section symbol as being OK for a reloc. */
+ if (regsec != NULL)
+ regsec->symbol->flags |= BSF_KEEP;
+
/* Iterate over frags resulting from GREGs and move those that evidently
have the same value together and point one to another.
if (real_reg_section != NULL)
{
- asection **secpp;
-
/* FIXME: Pass error state gracefully. */
if (bfd_get_section_flags (stdoutput, real_reg_section) & SEC_HAS_CONTENTS)
as_fatal (_("register section has contents\n"));
- /* Really remove the section. */
- for (secpp = &stdoutput->sections;
- *secpp != real_reg_section;
- secpp = &(*secpp)->next)
- ;
- bfd_section_list_remove (stdoutput, secpp);
+ bfd_section_list_remove (stdoutput, real_reg_section);
--stdoutput->section_count;
}
if (exp.X_add_number < ((offsetT) 0x20 << 56))
{
- /* Lower than Data_Segment - assume it's .text. */
+ /* Lower than Data_Segment or in the reserved area (the
+ segment number is >= 0x80, appearing negative) - assume
+ it's .text. */
section = text_section;
/* Save the lowest seen location, so we can pass on this
this one), we org at (this - lower). There's an implicit
"LOC 0" before any entered code. FIXME: handled by spurious
settings of text_has_contents. */
- if (exp.X_add_number < 0
- || exp.X_add_number < (offsetT) lowest_text_loc)
+ if (lowest_text_loc != (bfd_vma) -1
+ && (bfd_vma) exp.X_add_number < lowest_text_loc)
{
as_bad (_("LOC expression stepping backwards is not supported"));
exp.X_op = O_absent;
}
else
{
- /* Do the same for the .data section. */
+ /* Do the same for the .data section, except we don't have
+ to worry about exp.X_add_number carrying a sign. */
section = data_section;
if (exp.X_add_number < (offsetT) lowest_data_loc)
projects / external / binutils.git / blobdiff