the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-/* Contributed by Steve Chamberlain of Transmeta, sac@pobox.com */
+/* Contributed by Steve Chamberlain of Transmeta <sac@pobox.com>. */
#include "as.h"
#include "opcode/pj.h"
-
extern const pj_opc_info_t pj_opc_info[512];
const char comment_chars[] = "!/";
static int pending_reloc;
static struct hash_control *opcode_hash_control;
-
static void
little (ignore)
target_big_endian = 1;
}
-
const pseudo_typeS md_pseudo_table[] = {
{"ml", little, 0},
{"mb", big, 0},
{0, 0, 0}
};
-
const char FLT_CHARS[] = "rRsSfFdDxXpP";
const char EXP_CHARS[] = "eE";
if (strncmp (input_line_pointer, "%hi16", 5) == 0)
{
if (pending_reloc)
- as_bad (_ ("confusing relocation expressions"));
+ as_bad (_("confusing relocation expressions"));
pending_reloc = BFD_RELOC_PJ_CODE_HI16;
input_line_pointer += 5;
expression (op);
if (strncmp (input_line_pointer, "%lo16", 5) == 0)
{
if (pending_reloc)
- as_bad (_ ("confusing relocation expressions"));
+ as_bad (_("confusing relocation expressions"));
pending_reloc = BFD_RELOC_PJ_CODE_LO16;
input_line_pointer += 5;
expression (op);
}
}
-/* Parse an expression and then restore the input line pointer. */
+/* Parse an expression and then restore the input line pointer. */
static char *
parse_exp_save_ilp (s, op)
int nbytes;
expressionS *exp;
{
- static int rv[5][2] =
+ static int rv[5][2] =
{ { 0, 0 },
{ BFD_RELOC_8, BFD_RELOC_8 },
{ BFD_RELOC_PJ_CODE_DIR16, BFD_RELOC_16 },
{ 0, 0 },
{ BFD_RELOC_PJ_CODE_DIR32, BFD_RELOC_32 }};
- fix_new_exp (frag, where, nbytes, exp, 0,
+ fix_new_exp (frag, where, nbytes, exp, 0,
pending_reloc ? pending_reloc
- : rv [nbytes][(now_seg->flags & SEC_CODE) ? 0 : 1]);
+ : rv[nbytes][(now_seg->flags & SEC_CODE) ? 0 : 1]);
pending_reloc = 0;
}
-
/* Turn a reloc description character from the pj-opc.h table into
- code which BFD can handle. */
+ code which BFD can handle. */
static int
c_to_r (x)
return 0;
}
-
-
-
/* Handler for the ipush fake opcode,
- turns ipush <foo> into sipush lo16<foo>, sethi hi16<foo>. */
+ turns ipush <foo> into sipush lo16<foo>, sethi hi16<foo>. */
static void
ipush_code (opcode, str)
- pj_opc_info_t *opcode ATTRIBUTE_UNUSED;
+ pj_opc_info_t *opcode ATTRIBUTE_UNUSED;
char *str;
{
int mod = 0;
char *b = frag_more (6);
expressionS arg;
+
b[0] = 0x11;
b[3] = 0xed;
parse_exp_save_ilp (str + 1, &arg, &mod);
if (mod)
- as_bad (_ ("can't have relocation for ipush"));
-
+ as_bad (_("can't have relocation for ipush"));
- fix_new_exp (frag_now, b - frag_now->fr_literal + 1, 2,
- &arg, 0, BFD_RELOC_PJ_CODE_DIR16);
+ fix_new_exp (frag_now, b - frag_now->fr_literal + 1, 2,
+ &arg, 0, BFD_RELOC_PJ_CODE_DIR16);
fix_new_exp (frag_now, b - frag_now->fr_literal + 4, 2,
- &arg, 0, BFD_RELOC_PJ_CODE_HI16);
+ &arg, 0, BFD_RELOC_PJ_CODE_HI16);
}
/* Insert names into the opcode table which are really mini macros,
- not opcodes. The fakeness is inidicated with an opcode of -1. */
+ not opcodes. The fakeness is inidicated with an opcode of -1. */
static void
- fake_opcode (name, func) const char *
- name;
+fake_opcode (name, func)
+ const char *name;
void (*func) ();
{
pj_opc_info_t *fake = (pj_opc_info_t *) xmalloc (sizeof (pj_opc_info_t));
hash_insert (opcode_hash_control, name, (char *) fake);
}
-
/* Enter another entry into the opcode hash table so the same opcode
- can have another name. */
+ can have another name. */
+
static void
- alias (new, old) const char *
- new;
+alias (new, old)
+ const char *new;
const char *old;
{
hash_insert (opcode_hash_control, new,
(char *) hash_find (opcode_hash_control, old));
}
-
/* This function is called once, at assembler startup time. It sets
up the hash table with all the opcodes in it, and also initializes
- some aliases for compatibility with other assemblers. */
+ some aliases for compatibility with other assemblers. */
void
md_begin ()
const pj_opc_info_t *opcode;
opcode_hash_control = hash_new ();
- /* Insert names into hash table */
+ /* Insert names into hash table. */
for (opcode = pj_opc_info; opcode->name; opcode++)
hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
- /* Insert the only fake opcode. */
+ /* Insert the only fake opcode. */
fake_opcode ("ipush", ipush_code);
- /* Add some aliases for opcode names. */
+ /* Add some aliases for opcode names. */
alias ("ifeq_s", "ifeq");
alias ("ifne_s", "ifne");
alias ("if_icmpge_s", "if_icmpge");
bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0);
}
-/* This is the guts of the machine-dependent assembler. STR points to a
- machine dependent instruction. This function is supposed to emit
- the frags/bytes it assembles to.
- */
+/* This is the guts of the machine-dependent assembler. STR points to
+ a machine dependent instruction. This function is supposed to emit
+ the frags/bytes it assembles to. */
void
md_assemble (str)
unsigned char *op_start;
unsigned char *op_end;
- // pj_operan_info operand[3];
+#if 0
+ pj_operan_info operand[3];
+#endif
pj_opc_info_t *opcode;
char *output;
int idx = 0;
int nlen = 0;
- /* Drop leading whitespace */
+ /* Drop leading whitespace. */
while (*str == ' ')
str++;
- /* find the op code end */
+ /* Find the op code end. */
for (op_start = op_end = (unsigned char *) (str);
*op_end && !is_end_of_line[*op_end] && *op_end != ' ';
- op_end++)
+ op_end++)
nlen++;
pend = *op_end;
*op_end = 0;
if (nlen == 0)
- {
- as_bad (_ ("can't find opcode "));
- }
+ as_bad (_("can't find opcode "));
opcode = (pj_opc_info_t *) hash_find (opcode_hash_control, op_start);
*op_end = pend;
if (opcode == NULL)
{
- as_bad (_ ("unknown opcode %s"), op_start);
+ as_bad (_("unknown opcode %s"), op_start);
return;
}
if (opcode->opcode == -1)
{
- /* It's a fake opcode.. dig out the args and pretend that was
- what we were passed */
+ /* It's a fake opcode. Dig out the args and pretend that was
+ what we were passed. */
((void (*)()) opcode->name) (opcode, op_end);
}
else
op_end = parse_exp_save_ilp (op_end, &arg);
- fix_new_exp (frag_now,
+ fix_new_exp (frag_now,
output - frag_now->fr_literal + idx,
ASIZE (opcode->arg[an]),
&arg,
- PCREL (opcode->arg[an]),
+ PCREL (opcode->arg[an]),
pending_reloc ? pending_reloc : c_to_r (opcode->arg[an]));
idx += ASIZE (opcode->arg[an]);
}
-/* Turn a string in input_line_pointer into a floating point constant of type
- type, and store the appropriate bytes in *litP. The number of LITTLENUMS
- emitted is stored in *sizeP . An error message is returned, or NULL on OK.
- */
+/* Turn a string in input_line_pointer into a floating point constant
+ of type type, and store the appropriate bytes in *LITP. The number
+ of LITTLENUMS emitted is stored in *SIZEP . An error message is
+ returned, or NULL on OK. */
+
char *
md_atof (type, litP, sizeP)
int type;
default:
*sizeP = 0;
- return _ ("bad call to md_atof");
+ return _("bad call to md_atof");
}
t = atof_ieee (input_line_pointer, type, words);
return NULL;
}
\f
-
CONST char *md_shortopts = "";
struct option md_longopts[] = {
int
md_parse_option (c, arg)
int c;
- char *arg ATTRIBUTE_UNUSED;
+ char *arg ATTRIBUTE_UNUSED;
{
switch (c)
{
md_show_usage (stream)
FILE *stream;
{
- fprintf (stream, _ ("\
+ fprintf (stream, _("\
PJ options:\n\
-little generate little endian code\n\
-big generate big endian code\n"));
}
-
-
/* Apply a fixup to the object file. */
-
int
md_apply_fix (fixP, valp)
fixS *fixP;
long max, min;
int shift;
-
/* adjust_reloc_syms won't convert a reloc against a weak symbol
into a reloc against a section, but bfd_install_relocation will
screw up if the symbol is defined, so we have to adjust val here
case BFD_RELOC_PJ_CODE_REL16:
if (val < -0x8000 || val >= 0x7fff)
- as_bad_where (fixP->fx_file, fixP->fx_line, _ ("pcrel too far"));
+ as_bad_where (fixP->fx_file, fixP->fx_line, _("pcrel too far"));
buf[0] |= (val >> 8) & 0xff;
buf[1] = val & 0xff;
break;
*buf++ = val >> 8;
*buf++ = val >> 0;
}
- else
+ else
{
*buf++ = val >> 0;
*buf++ = val >> 8;
}
break;
-
default:
abort ();
}
if (max != 0 && (val < min || val > max))
- as_bad_where (fixP->fx_file, fixP->fx_line, _ ("offset out of range"));
+ as_bad_where (fixP->fx_file, fixP->fx_line, _("offset out of range"));
return 0;
}
/* Put number into target byte order. Always put values in an
- executable section into big endian order. */
+ executable section into big endian order. */
void
md_number_to_chars (ptr, use, nbytes)
number_to_chars_littleendian (ptr, use, nbytes);
}
-
-
/* Translate internal representation of relocation info to BFD target
- format. */
+ format. */
arelent *
tc_gen_reloc (section, fixp)
if (rel->howto == NULL)
{
as_bad_where (fixp->fx_file, fixp->fx_line,
- _ ("Cannot represent relocation type %s"),
+ _("Cannot represent relocation type %s"),
bfd_get_reloc_code_name (r_type));
/* Set howto to a garbage value so that we can keep going. */
rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
#include "opcode/tic80.h"
#define internal_error(what) \
- as_fatal(_("internal error:%s:%d: %s\n"),__FILE__,__LINE__,what)
-#define internal_error_a(what,arg) \
- as_fatal(_("internal error:%s:%d: %s %d\n"),__FILE__,__LINE__,what,arg)
+ as_fatal(_("internal error:%s:%d: %s\n"), __FILE__, __LINE__, what)
+#define internal_error_a(what,arg) \
+ as_fatal(_("internal error:%s:%d: %s %d\n"), __FILE__, __LINE__, what, arg)
\f
-/* Generic assembler global variables which must be defined by all targets. */
+/* Generic assembler global variables which must be defined by all
+ targets. */
-/* Characters which always start a comment. */
+/* Characters which always start a comment. */
const char comment_chars[] = ";";
/* Characters which start a comment at the beginning of a line. */
/* Characters which may be used to separate multiple commands on a single
line. The semicolon is such a character by default and should not be
- explicitly listed. */
+ explicitly listed. */
const char line_separator_chars[] = "";
-/* Characters which are used to indicate an exponent in a floating
+/* Characters which are used to indicate an exponent in a floating
point number. */
const char EXP_CHARS[] = "eE";
-/* Characters which mean that a number is a floating point constant,
+/* Characters which mean that a number is a floating point constant,
as in 0f1.0. */
const char FLT_CHARS[] = "fF";
pseudo-op name without dot
function to call to execute this pseudo-op
- integer arg to pass to the function */
+ integer arg to pass to the function */
extern void obj_coff_section ();
const pseudo_typeS md_pseudo_table[] =
{
- { "align", s_align_bytes, 4 }, /* Do byte alignment, default is a 4 byte boundary */
- { "word", cons, 4 }, /* FIXME: Should this be machine independent? */
+ { "align", s_align_bytes, 4 }, /* Do byte alignment, default is a 4 byte boundary */
+ { "word", cons, 4 }, /* FIXME: Should this be machine independent? */
{ "bss", s_lcomm_bytes, 1 },
- { "sect", obj_coff_section, 0}, /* For compatibility with TI tools */
- { "section", obj_coff_section, 0}, /* Standard COFF .section pseudo-op */
+ { "sect", obj_coff_section, 0}, /* For compatibility with TI tools */
+ { "section", obj_coff_section, 0}, /* Standard COFF .section pseudo-op */
{ NULL, NULL, 0 }
};
static int get_operands PARAMS ((expressionS exp[]));
static int const_overflow PARAMS ((unsigned long num, int bits, int flags));
-/* Replace short PC relative instructions with long form when necessary. Currently
- this is off by default or when given the -no-relax option. Turning it on by using
- the -relax option forces all PC relative instructions to use the long form, which
- is why it is currently not the default. */
+/* Replace short PC relative instructions with long form when
+ necessary. Currently this is off by default or when given the
+ -no-relax option. Turning it on by using the -relax option forces
+ all PC relative instructions to use the long form, which is why it
+ is currently not the default. */
static int tic80_relax = 0;
-
\f
int
md_estimate_size_before_relax (fragP, segment_type)
/* We have no need to default values of symbols. */
-/* ARGSUSED */
symbolS *
md_undefined_symbol (name)
char *name;
return 0;
}
-/* Turn a string in input_line_pointer into a floating point constant of type
- type, and store the appropriate bytes in *litP. The number of LITTLENUMS
- emitted is stored in *sizeP . An error message is returned, or NULL on OK.
- */
+/* Turn a string in input_line_pointer into a floating point constant
+ of type TYPE, and store the appropriate bytes in *LITP. The number
+ of LITTLENUMS emitted is stored in *SIZEP. An error message is
+ returned, or NULL on OK. */
#define MAX_LITTLENUMS 4
LITTLENUM_TYPE *wordP;
char *t;
char *atof_ieee ();
-
+
switch (type)
{
case 'f':
{
input_line_pointer = t;
}
-
+
*sizeP = prec * sizeof (LITTLENUM_TYPE);
-
+
for (wordP = words; prec--;)
{
md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
}
/* Check to see if the constant value in NUM will fit in a field of
- width BITS if it has flags FLAGS. */
+ width BITS if it has flags FLAGS. */
static int
const_overflow (num, bits, flags)
long min, max;
int retval = 0;
- /* Only need to check fields less than 32 bits wide */
+ /* Only need to check fields less than 32 bits wide. */
if (bits < 32)
if (flags & TIC80_OPERAND_SIGNED)
{
- max = (1 << (bits - 1)) - 1;
- min = - (1 << (bits - 1));
+ max = (1 << (bits - 1)) - 1;
+ min = - (1 << (bits - 1));
retval = ((long) num > max) || ((long) num < min);
}
else
return (retval);
}
-/* get_operands() parses a string of operands and fills in a passed array of
- expressions in EXP.
+/* get_operands () parses a string of operands and fills in a passed
+ array of expressions in EXP.
Note that we use O_absent expressions to record additional information
about the previous non-O_absent expression, such as ":m" or ":s"
modifiers or register numbers enclosed in parens like "(r10)".
- Returns the number of expressions that were placed in EXP.
-
- */
+ Returns the number of expressions that were placed in EXP. */
static int
-get_operands (exp)
+get_operands (exp)
expressionS exp[];
{
char *p = input_line_pointer;
int sflag = 0;
int parens = 0;
- while (*p)
+ while (*p)
{
- /* Skip leading whitespace */
- while (*p == ' ' || *p == '\t' || *p == ',')
- {
- p++;
- }
+ /* Skip leading whitespace. */
+ while (*p == ' ' || *p == '\t' || *p == ',')
+ p++;
+
+ /* Check to see if we have any operands left to parse. */
+ if (*p == 0 || *p == '\n' || *p == '\r')
+ break;
- /* Check to see if we have any operands left to parse */
- if (*p == 0 || *p == '\n' || *p == '\r')
- {
- break;
- }
-
/* Notice scaling or direct memory operand modifiers and save them in
- an O_absent expression after the expression that they modify. */
+ an O_absent expression after the expression that they modify. */
- if (*p == ':')
+ if (*p == ':')
{
p++;
exp[numexp].X_op = O_absent;
- if (*p == 'm')
+ if (*p == 'm')
{
p++;
- /* This is a ":m" modifier */
+ /* This is a ":m" modifier. */
exp[numexp].X_add_number = TIC80_OPERAND_M_SI | TIC80_OPERAND_M_LI;
}
else if (*p == 's')
{
p++;
- /* This is a ":s" modifier */
+ /* This is a ":s" modifier. */
exp[numexp].X_add_number = TIC80_OPERAND_SCALED;
}
else
/* Handle leading '(' on operands that use them, by recording that we
have entered a paren nesting level and then continuing. We complain
- about multiple nesting. */
+ about multiple nesting. */
if (*p == '(')
{
if (++parens != 1)
- {
- as_bad (_("paren nesting"));
- }
+ as_bad (_("paren nesting"));
+
p++;
continue;
}
/* Handle trailing ')' on operands that use them, by reducing the
nesting level and then continuing. We complain if there were too
- many closures. */
+ many closures. */
- if (*p == ')')
+ if (*p == ')')
{
- /* Record that we have left a paren group and continue */
+ /* Record that we have left a paren group and continue. */
if (--parens < 0)
- {
- as_bad (_("mismatched parenthesis"));
- }
+ as_bad (_("mismatched parenthesis"));
+
p++;
continue;
}
- /* Begin operand parsing at the current scan point. */
+ /* Begin operand parsing at the current scan point. */
input_line_pointer = p;
expression (&exp[numexp]);
exp[numexp++].X_add_number = TIC80_OPERAND_PARENS;
}
- /* Mark the end of the valid operands with an illegal expression. */
+ /* Mark the end of the valid operands with an illegal expression. */
exp[numexp].X_op = O_illegal;
return (numexp);
const struct tic80_opcode *end; /* Pointer to end of opcode table */
/* First parse all the operands so we only have to do it once. There may
- be more expressions generated than there are operands. */
+ be more expressions generated than there are operands. */
numexp = get_operands (myops);
/* For each opcode with the same name, try to match it against the parsed
- operands. */
+ operands. */
end = tic80_opcodes + tic80_num_opcodes;
- while (!match && (opc < end) && (strcmp (opc -> name, opcode -> name) == 0))
+ while (!match && (opc < end) && (strcmp (opc->name, opcode->name) == 0))
{
/* Start off assuming a match. If we find a mismatch, then this is
reset and the operand/expr matching loop terminates with match
- equal to zero, which allows us to try the next opcode. */
+ equal to zero, which allows us to try the next opcode. */
match = 1;
/* The O_absent expressions apply to the same operand as the most
recent non O_absent expression. So only increment the operand
index when the current expression is not one of these special
- expressions. */
+ expressions. */
if (X_op != O_absent)
{
opi++;
}
- flags = tic80_operands[opc -> operands[opi]].flags;
- bits = tic80_operands[opc -> operands[opi]].bits;
+ flags = tic80_operands[opc->operands[opi]].flags;
+ bits = tic80_operands[opc->operands[opi]].bits;
switch (X_op)
{
case O_register:
- /* Also check that registers that are supposed to be even actually
- are even. */
+ /* Also check that registers that are supposed to be
+ even actually are even. */
if (((flags & TIC80_OPERAND_GPR) != (num & TIC80_OPERAND_GPR)) ||
((flags & TIC80_OPERAND_FPA) != (num & TIC80_OPERAND_FPA)) ||
((flags & TIC80_OPERAND_CR) != (num & TIC80_OPERAND_CR)) ||
case O_constant:
if ((flags & TIC80_OPERAND_ENDMASK) && (num == 32))
{
- /* Endmask values of 0 and 32 give identical results */
+ /* Endmask values of 0 and 32 give identical
+ results. */
num = 0;
}
if ((flags & (TIC80_OPERAND_FPA | TIC80_OPERAND_GPR)) ||
}
break;
case O_symbol:
- if ((bits < 32) && (flags & TIC80_OPERAND_PCREL) && !tic80_relax)
+ if ((bits < 32) && (flags & TIC80_OPERAND_PCREL)
+ && !tic80_relax)
{
- /* The default is to prefer the short form of PC relative relocations.
- This is the only form that the TI assembler supports.
- If the -relax option is given, we never use the short forms.
- FIXME: Should be able to choose "best-fit". */
+ /* The default is to prefer the short form of PC
+ relative relocations. This is the only form that
+ the TI assembler supports. If the -relax option
+ is given, we never use the short forms.
+ FIXME: Should be able to choose "best-fit". */
}
- else if ((bits == 32) /* && (flags & TIC80_OPERAND_BASEREL) */)
+ else if ((bits == 32)
+#if 0
+ && (flags & TIC80_OPERAND_BASEREL)
+#endif
+ )
{
- /* The default is to prefer the long form of base relative relocations.
- This is the only form that the TI assembler supports.
- If the -no-relax option is given, we always use the long form of
+ /* The default is to prefer the long form of base
+ relative relocations. This is the only form that
+ the TI assembler supports. If the -no-relax
+ option is given, we always use the long form of
PC relative relocations.
- FIXME: Should be able to choose "best-fit". */
+ FIXME: Should be able to choose "best-fit". */
}
else
{
/* Symbols that don't match one of the above cases are
- rejected as an operand. */
+ rejected as an operand. */
match = 0;
}
break;
case O_absent:
- /* If this is an O_absent expression, then it may be an expression that
- supplies additional information about the operand, such as ":m" or
- ":s" modifiers. Check to see that the operand matches this requirement. */
- if (!((num & TIC80_OPERAND_M_SI) && (flags & TIC80_OPERAND_M_SI) ||
- (num & TIC80_OPERAND_M_LI) && (flags & TIC80_OPERAND_M_LI) ||
- (num & TIC80_OPERAND_SCALED) && (flags & TIC80_OPERAND_SCALED)))
+ /* If this is an O_absent expression, then it may be an
+ expression that supplies additional information about
+ the operand, such as ":m" or ":s" modifiers. Check to
+ see that the operand matches this requirement. */
+ if (!((num & TIC80_OPERAND_M_SI) && (flags & TIC80_OPERAND_M_SI)
+ || (num & TIC80_OPERAND_M_LI) && (flags & TIC80_OPERAND_M_LI)
+ || (num & TIC80_OPERAND_SCALED) && (flags & TIC80_OPERAND_SCALED)))
{
match = 0;
}
}
}
if (!match)
- {
- opc++;
- }
- }
+ opc++;
+ }
return (match ? opc : NULL);
#if 0
-
/* Now search the opcode table table for one with operands that
- matches what we've got. */
+ matches what we've got. */
while (!match)
{
match = 1;
- for (i = 0; opcode -> operands[i]; i++)
+ for (i = 0; opcode->operands[i]; i++)
{
int flags = tic80_operands[opcode->operands[i]].flags;
int X_op = myops[i].X_op;
int num = myops[i].X_add_number;
- if (X_op == 0)
+ if (X_op == 0)
{
match = 0;
break;
}
-
- if (flags & (TIC80_OPERAND_GPR | TIC80_OPERAND_FPA | TIC80_OPERAND_CR))
+
+ if (flags
+ & (TIC80_OPERAND_GPR | TIC80_OPERAND_FPA | TIC80_OPERAND_CR))
{
if ((X_op != O_register) ||
((flags & TIC80_OPERAND_GPR) != (num & TIC80_OPERAND_GPR)) ||
((flags & TIC80_OPERAND_FPA) != (num & TIC80_OPERAND_FPA)) ||
((flags & TIC80_OPERAND_CR) != (num & TIC80_OPERAND_CR)))
{
- match=0;
+ match = 0;
break;
- }
+ }
}
-
+
if (((flags & TIC80_OPERAND_MINUS) && ((X_op != O_absent) || (num != TIC80_OPERAND_MINUS))) ||
((flags & TIC80_OPERAND_PLUS) && ((X_op != O_absent) || (num != TIC80_OPERAND_PLUS))) ||
((flags & TIC80_OPERAND_ATMINUS) && ((X_op != O_absent) || (num != TIC80_OPERAND_ATMINUS))) ||
((flags & TIC80_OPERAND_ATPAR) && ((X_op != O_absent) || (num != TIC80_OPERAND_ATPAR))) ||
- ((flags & TIC80_OPERAND_ATSIGN) && ((X_op != O_absent) || (num != TIC80_OPERAND_ATSIGN))))
+ ((flags & TIC80_OPERAND_ATSIGN) && ((X_op != O_absent) || (num != TIC80_OPERAND_ATSIGN))))
{
- match=0;
+ match = 0;
break;
- }
+ }
}
- /* we're only done if the operands matched so far AND there
- are no more to check */
- if (match && myops[i].X_op==0)
+ /* We're only done if the operands matched so far AND there
+ are no more to check. */
+ if (match && myops[i].X_op == 0)
break;
else
match = 0;
- next_opcode = opcode+1;
- if (next_opcode->opcode == 0)
+ next_opcode = opcode + 1;
+ if (next_opcode->opcode == 0)
break;
- if (strcmp(next_opcode->name, opcode->name))
+ if (strcmp (next_opcode->name, opcode->name))
break;
opcode = next_opcode;
}
- if (!match)
+ if (!match)
{
as_bad (_("bad opcode or operands"));
return (0);
}
- /* Check that all registers that are required to be even are. */
- /* Also, if any operands were marked as registers, but were really symbols */
- /* fix that here. */
- for (i=0; opcode->operands[i]; i++)
+ /* Check that all registers that are required to be even are.
+ Also, if any operands were marked as registers, but were really
+ symbols, fix that here. */
+ for (i = 0; opcode->operands[i]; i++)
{
- if ((tic80_operands[opcode->operands[i]].flags & TIC80_OPERAND_EVEN) &&
- (myops[i].X_add_number & 1))
+ if ((tic80_operands[opcode->operands[i]].flags & TIC80_OPERAND_EVEN)
+ && (myops[i].X_add_number & 1))
as_fatal (_("Register number must be EVEN"));
if (myops[i].X_op == O_register)
{
- if (!(tic80_operands[opcode->operands[i]].flags & TIC80_OPERAND_REG))
+ if (!(tic80_operands[opcode->operands[i]].flags & TIC80_OPERAND_REG))
{
myops[i].X_op = O_symbol;
- myops[i].X_add_symbol = symbol_find_or_make ((char *)myops[i].X_op_symbol);
+ myops[i].X_add_symbol =
+ symbol_find_or_make ((char *) myops[i].X_op_symbol);
myops[i].X_add_number = 0;
myops[i].X_op_symbol = NULL;
}
}
}
-
#endif
}
Note that the opcode word and extended word may be written to different
frags, with the opcode at the end of one frag and the extension at the
- beginning of the next. */
+ beginning of the next. */
static void
-build_insn (opcode, opers)
+build_insn (opcode, opers)
struct tic80_opcode *opcode;
expressionS *opers;
{
char *fx = NULL; /* Pointer to frag location for insn[1] */
fragS *fxfrag; /* Frag containing location fx */
- /* Start with the raw opcode bits from the opcode table. */
- insn[0] = opcode -> opcode;
+ /* Start with the raw opcode bits from the opcode table. */
+ insn[0] = opcode->opcode;
/* We are going to insert at least one 32 bit opcode so get the
- frag now. */
+ frag now. */
f = frag_more (4);
ffrag = frag_now;
/* For each operand expression, insert the appropriate bits into the
- instruction . */
+ instruction. */
for (expi = 0, opi = -1; opers[expi].X_op != O_illegal; expi++)
{
int bits, shift, flags, X_op, num;
/* The O_absent expressions apply to the same operand as the most
recent non O_absent expression. So only increment the operand
index when the current expression is not one of these special
- expressions. */
+ expressions. */
if (X_op != O_absent)
{
opi++;
}
- flags = tic80_operands[opcode -> operands[opi]].flags;
- bits = tic80_operands[opcode -> operands[opi]].bits;
- shift = tic80_operands[opcode -> operands[opi]].shift;
+ flags = tic80_operands[opcode->operands[opi]].flags;
+ bits = tic80_operands[opcode->operands[opi]].bits;
+ shift = tic80_operands[opcode->operands[opi]].shift;
switch (X_op)
{
case O_constant:
if ((flags & TIC80_OPERAND_ENDMASK) && (num == 32))
{
- /* Endmask values of 0 and 32 give identical results */
+ /* Endmask values of 0 and 32 give identical results. */
num = 0;
}
else if ((flags & TIC80_OPERAND_BITNUM))
{
- /* BITNUM values are stored in one's complement form */
+ /* BITNUM values are stored in one's complement form. */
num = (~num & 0x1F);
}
- /* Mask off upper bits, just it case it is signed and is negative */
+ /* Mask off upper bits, just it case it is signed and is
+ negative. */
if (bits < 32)
{
num &= (1 << bits) - 1;
if (flags & TIC80_OPERAND_PCREL)
{
fix_new_exp (fxfrag,
- fx - (fxfrag -> fr_literal),
+ fx - (fxfrag->fr_literal),
4,
- &opers[expi],
+ &opers[expi],
1,
R_MPPCR);
}
else
{
fix_new_exp (fxfrag,
- fx - (fxfrag -> fr_literal),
+ fx - (fxfrag->fr_literal),
4,
- &opers[expi],
+ &opers[expi],
0,
R_RELLONGX);
}
else if (flags & TIC80_OPERAND_PCREL)
{
fix_new_exp (ffrag,
- f - (ffrag -> fr_literal),
- 4, /* FIXME! how is this used? */
+ f - (ffrag->fr_literal),
+ 4, /* FIXME! how is this used? */
&opers[expi],
1,
R_MPPCR15W);
}
break;
case O_absent:
- /* Each O_absent expression can indicate exactly one possible modifier. */
- if ((num & TIC80_OPERAND_M_SI) && (flags & TIC80_OPERAND_M_SI))
+ /* Each O_absent expression can indicate exactly one
+ possible modifier. */
+ if ((num & TIC80_OPERAND_M_SI)
+ && (flags & TIC80_OPERAND_M_SI))
{
insn[0] = insn[0] | (1 << 17);
}
- else if ((num & TIC80_OPERAND_M_LI) && (flags & TIC80_OPERAND_M_LI))
+ else if ((num & TIC80_OPERAND_M_LI)
+ && (flags & TIC80_OPERAND_M_LI))
{
insn[0] = insn[0] | (1 << 15);
}
- else if ((num & TIC80_OPERAND_SCALED) && (flags & TIC80_OPERAND_SCALED))
+ else if ((num & TIC80_OPERAND_SCALED)
+ && (flags & TIC80_OPERAND_SCALED))
{
insn[0] = insn[0] | (1 << 11);
}
- else if ((num & TIC80_OPERAND_PARENS) && (flags & TIC80_OPERAND_PARENS))
+ else if ((num & TIC80_OPERAND_PARENS)
+ && (flags & TIC80_OPERAND_PARENS))
{
- /* No code to generate, just accept and discard this expression */
+ /* No code to generate, just accept and discard this
+ expression. */
}
else
{
- internal_error_a (_("unhandled operand modifier"), opers[expi].X_add_number);
+ internal_error_a (_("unhandled operand modifier"),
+ opers[expi].X_add_number);
}
break;
case O_big:
int precision = 2;
long exponent_bits = 8L;
LITTLENUM_TYPE words[2];
- /* Value is still in generic_floating_point_number */
+ /* Value is still in generic_floating_point_number. */
gen_to_words (words, precision, exponent_bits);
insn[1] = (words[0] << 16) | words[1];
}
expressionS myops[16];
unsigned long insn;
- /* Ensure there is something there to assemble. */
+ /* Ensure there is something there to assemble. */
assert (str);
- /* Drop any leading whitespace. */
+ /* Drop any leading whitespace. */
while (isspace (*str))
- {
- str++;
- }
+ str++;
/* Isolate the mnemonic from the rest of the string by finding the first
whitespace character and zapping it to a null byte. */
- for (scan = str; *scan != '\000' && !isspace (*scan); scan++) {;}
+ for (scan = str; *scan != '\000' && !isspace (*scan); scan++)
+ ;
+
if (*scan != '\000')
- {
- *scan++ = '\000';
- }
+ *scan++ = '\000';
- /* Try to find this mnemonic in the hash table */
+ /* Try to find this mnemonic in the hash table. */
if ((opcode = (struct tic80_opcode *) hash_find (tic80_hash, str)) == NULL)
{
as_bad (_("Invalid mnemonic: '%s'"), str);
str = scan;
while (isspace (*scan))
- {
- scan++;
- }
+ scan++;
input_line_save = input_line_pointer;
input_line_pointer = str;
opcode = find_opcode (opcode, myops);
if (opcode == NULL)
- {
- as_bad (_("Invalid operands: '%s'"), input_line_save);
- }
+ as_bad (_("Invalid operands: '%s'"), input_line_save);
input_line_pointer = input_line_save;
build_insn (opcode, myops);
register const struct tic80_opcode *op;
register const struct tic80_opcode *op_end;
const struct predefined_symbol *pdsp;
- extern int coff_flags; /* Defined in obj-coff.c */
+ extern int coff_flags; /* Defined in obj-coff.c */
/* Set F_AR32WR in coff_flags, which will end up in the file header
- f_flags field. */
+ f_flags field. */
- coff_flags |= F_AR32WR; /* TIc80 is 32 bit little endian */
+ coff_flags |= F_AR32WR; /* TIc80 is 32 bit little endian. */
/* Insert unique names into hash table. The TIc80 instruction set
has many identical opcode names that have different opcodes based
op_end = tic80_opcodes + tic80_num_opcodes;
for (op = tic80_opcodes; op < op_end; op++)
{
- if (strcmp (prev_name, op -> name) != 0)
+ if (strcmp (prev_name, op->name) != 0)
{
- prev_name = (char *) op -> name;
- hash_insert (tic80_hash, op -> name, (char *) op);
+ prev_name = (char *) op->name;
+ hash_insert (tic80_hash, op->name, (char *) op);
}
}
- /* Insert the predefined symbols into the symbol table. We use symbol_create
- rather than symbol_new so that these symbols don't end up in the object
- files' symbol table. Note that the values of the predefined symbols include
- some upper bits that distinguish the type of the symbol (register, bitnum,
- condition code, etc) and these bits must be masked away before actually
- inserting the values into the instruction stream. For registers we put
- these bits in the symbol table since we use them later and there is no
- question that they aren't part of the register number. For constants we
- can't do that since the constant can be any value, so they are masked off
- before putting them into the symbol table. */
+ /* Insert the predefined symbols into the symbol table. We use
+ symbol_create rather than symbol_new so that these symbols don't
+ end up in the object files' symbol table. Note that the values
+ of the predefined symbols include some upper bits that
+ distinguish the type of the symbol (register, bitnum, condition
+ code, etc) and these bits must be masked away before actually
+ inserting the values into the instruction stream. For registers
+ we put these bits in the symbol table since we use them later and
+ there is no question that they aren't part of the register
+ number. For constants we can't do that since the constant can be
+ any value, so they are masked off before putting them into the
+ symbol table. */
pdsp = NULL;
while ((pdsp = tic80_next_predefined_symbol (pdsp)) != NULL)
&zero_address_frag));
}
}
-
\f
-
-/* The assembler adds md_shortopts to the string passed to getopt. */
+/* The assembler adds md_shortopts to the string passed to getopt. */
CONST char *md_shortopts = "";
/* The assembler adds md_longopts to the machine independent long options
- that are passed to getopt. */
+ that are passed to getopt. */
struct option md_longopts[] = {
{NULL, no_argument, NULL, 0}
};
-size_t md_longopts_size = sizeof(md_longopts);
+size_t md_longopts_size = sizeof (md_longopts);
/* The md_parse_option function will be called whenever getopt returns an
unrecognized code, presumably indicating a special code value which
- appears in md_longopts for machine specific command line options. */
+ appears in md_longopts for machine specific command line options. */
int
md_parse_option (c, arg)
/* The md_show_usage function will be called whenever a usage message is
printed. It should print a description of the machine specific options
- found in md_longopts. */
+ found in md_longopts. */
void
md_show_usage (stream)
-relax alter PC relative branch instructions to use long form when needed\n\
-no-relax always use short PC relative branch instructions, error on overflow\n");
}
-
\f
/* Attempt to simplify or even eliminate a fixup. The return value is
ignored; perhaps it was once meaningful, but now it is historical.
- To indicate that a fixup has been eliminated, set fixP->fx_done.
- */
+ To indicate that a fixup has been eliminated, set fixP->fx_done. */
void
md_apply_fix (fixP, val)
fixS *fixP;
long val;
{
- char *dest = fixP -> fx_frag -> fr_literal + fixP -> fx_where;
+ char *dest = fixP->fx_frag->fr_literal + fixP->fx_where;
int overflow;
- switch (fixP -> fx_r_type)
+ switch (fixP->fx_r_type)
{
case R_RELLONGX:
md_number_to_chars (dest, (valueT) val, 4);
overflow = (val < -65536L) || (val > 65532L);
if (overflow)
{
- as_bad_where (fixP -> fx_file, fixP -> fx_line,
+ as_bad_where (fixP->fx_file, fixP->fx_line,
_("PC offset 0x%lx outside range 0x%lx-0x%lx"),
val, -65536L, 65532L);
}
}
break;
case R_ABS:
- md_number_to_chars (dest, (valueT) val, fixP -> fx_size);
+ md_number_to_chars (dest, (valueT) val, fixP->fx_size);
break;
default:
- internal_error_a (_("unhandled relocation type in fixup"), fixP -> fx_r_type);
+ internal_error_a (_("unhandled relocation type in fixup"),
+ fixP->fx_r_type);
break;
}
}
-
\f
/* Functions concerning relocs. */
given a PC relative reloc.
For the TIc80, this is the address of the 32 bit opcode containing
- the PC relative field. */
+ the PC relative field. */
long
md_pcrel_from (fixP)
fixS *fixP;
{
- return (fixP -> fx_frag -> fr_address + fixP -> fx_where) ;
+ return (fixP->fx_frag->fr_address + fixP->fx_where);
}
-/*
- * Called after relax() is finished.
+/* Called after relax() is finished.
* In: Address of frag.
* fr_type == rs_machine_dependent.
* fr_subtype is what the address relaxed to.
internal_error (_("md_convert_frag() not implemented yet"));
abort ();
}
-
\f
-/*ARGSUSED*/
void
tc_coff_symbol_emit_hook (ignore)
symbolS *ignore;
tc_coff_fix2rtype (fixP)
fixS *fixP;
{
- return (fixP -> fx_r_type);
+ return (fixP->fx_r_type);
}
-#endif /* OBJ_COFF */
-
-/* end of tc-tic80.c */
+#endif /* OBJ_COFF */
projects / binutils-gdb.git / commitdiff