function to call to execute this pseudo-op
integer arg to pass to the function */
-const pseudo_typeS md_pseudo_table[] = {
- { "align", s_align_bytes, 4 }, /* Do byte alignment, default is a 4 byte boundary */
+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? */
{ "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 }
};
/* Opcode hash table. */
static struct hash_control *tic80_hash;
-static struct tic80_opcode * find_opcode PARAMS ((struct tic80_opcode *, expressionS []));
-static void build_insn PARAMS ((struct tic80_opcode *, expressionS *));
-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
static int tic80_relax = 0;
\f
int
-md_estimate_size_before_relax (fragP, segment_type)
- fragS *fragP ATTRIBUTE_UNUSED;
- segT segment_type ATTRIBUTE_UNUSED;
+md_estimate_size_before_relax (fragS *fragP ATTRIBUTE_UNUSED,
+ segT segment_type ATTRIBUTE_UNUSED)
{
internal_error (_("Relaxation is a luxury we can't afford"));
- return (-1);
+ return -1;
}
/* We have no need to default values of symbols. */
symbolS *
-md_undefined_symbol (name)
- char *name ATTRIBUTE_UNUSED;
+md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
{
- return 0;
+ return NULL;
}
/* Turn a string in input_line_pointer into a floating point constant
#define MAX_LITTLENUMS 4
char *
-md_atof (type, litP, sizeP)
- int type;
- char *litP;
- int *sizeP;
+md_atof (int type, char *litP, int *sizeP)
{
int prec;
LITTLENUM_TYPE words[MAX_LITTLENUMS];
t = atof_ieee (input_line_pointer, type, words);
if (t)
- {
- input_line_pointer = t;
- }
+ input_line_pointer = t;
*sizeP = prec * sizeof (LITTLENUM_TYPE);
md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
litP += sizeof (LITTLENUM_TYPE);
}
- return (NULL);
+
+ return NULL;
}
/* Check to see if the constant value in NUM will fit in a field of
width BITS if it has flags FLAGS. */
static int
-const_overflow (num, bits, flags)
- unsigned long num;
- int bits;
- int flags;
+const_overflow (unsigned long num, int bits, int flags)
{
long min, max;
int retval = 0;
Returns the number of expressions that were placed in EXP. */
static int
-get_operands (exp)
- expressionS exp[];
+get_operands (expressionS exp[])
{
char *p = input_line_pointer;
int numexp = 0;
exp[numexp].X_add_number = TIC80_OPERAND_SCALED;
}
else
- {
- as_bad (_("':' not followed by 'm' or 's'"));
- }
+ as_bad (_("':' not followed by 'm' or 's'"));
+
numexp++;
continue;
}
}
/* Begin operand parsing at the current scan point. */
-
input_line_pointer = p;
expression (&exp[numexp]);
if (exp[numexp].X_op == O_illegal)
- {
- as_bad (_("illegal operand"));
- }
+ as_bad (_("illegal operand"));
else if (exp[numexp].X_op == O_absent)
- {
- as_bad (_("missing operand"));
- }
+ as_bad (_("missing operand"));
numexp++;
p = input_line_pointer;
/* Mark the end of the valid operands with an illegal expression. */
exp[numexp].X_op = O_illegal;
- return (numexp);
+ return numexp;
}
/* find_opcode() gets a pointer to the entry in the opcode table that
choose the correct opcode. */
static struct tic80_opcode *
-find_opcode (opcode, myops)
- struct tic80_opcode *opcode;
- expressionS myops[];
+find_opcode (struct tic80_opcode *opcode, expressionS myops[])
{
- int numexp; /* Number of expressions from parsing operands */
- int expi; /* Index of current expression to match */
- int opi; /* Index of current operand to match */
- int match = 0; /* Set to 1 when an operand match is found */
- struct tic80_opcode *opc = opcode; /* Pointer to current opcode table entry */
- const struct tic80_opcode *end; /* Pointer to end of opcode table */
+ int numexp; /* Number of expressions from parsing operands. */
+ int expi; /* Index of current expression to match. */
+ int opi; /* Index of current operand to match. */
+ int match = 0; /* Set to 1 when an operand match is found. */
+ struct tic80_opcode *opc = opcode; /* Pointer to current opcode table entry. */
+ 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. */
-
numexp = get_operands (myops);
/* For each opcode with the same name, try to match it against the parsed
operands. */
-
end = tic80_opcodes + tic80_num_opcodes;
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. */
-
match = 1;
/* For each expression, try to match it against the current operand
for the current opcode. Upon any mismatch, we abandon further
matching for the current opcode table entry. */
-
for (expi = 0, opi = -1; (expi < numexp) && match; expi++)
{
int bits, flags, X_op, num;
recent non O_absent expression. So only increment the operand
index when the current expression is not one of these special
expressions. */
-
if (X_op != O_absent)
- {
- opi++;
- }
+ opi++;
flags = tic80_operands[opc->operands[opi]].flags;
bits = tic80_operands[opc->operands[opi]].bits;
((flags & TIC80_OPERAND_CR) != (num & TIC80_OPERAND_CR)) ||
((flags & TIC80_OPERAND_EVEN) && (num & 1)) ||
const_overflow (num & ~TIC80_OPERAND_MASK, bits, flags))
- {
- match = 0;
- }
+ match = 0;
break;
+
case O_constant:
if ((flags & TIC80_OPERAND_ENDMASK) && (num == 32))
- {
- /* Endmask values of 0 and 32 give identical
- results. */
- num = 0;
- }
+ /* Endmask values of 0 and 32 give identical
+ results. */
+ num = 0;
+
if ((flags & (TIC80_OPERAND_FPA | TIC80_OPERAND_GPR)) ||
const_overflow (num, bits, flags))
- {
- match = 0;
- }
+ match = 0;
break;
+
case O_symbol:
if ((bits < 32) && (flags & TIC80_OPERAND_PCREL)
&& !tic80_relax)
match = 0;
}
break;
+
case O_absent:
/* If this is an O_absent expression, then it may be an
expression that supplies additional information about
if (!((num & flags & TIC80_OPERAND_M_SI)
|| (num & flags & TIC80_OPERAND_M_LI)
|| (num & flags & TIC80_OPERAND_SCALED)))
- {
- match = 0;
- }
+ match = 0;
break;
+
case O_big:
if ((num > 0) || !(flags & TIC80_OPERAND_FLOAT))
- {
- match = 0;
- }
+ match = 0;
break;
+
case O_illegal:
case O_symbol_rva:
case O_uminus:
opc++;
}
- return (match ? opc : NULL);
+ return match ? opc : NULL;
}
beginning of the next. */
static void
-build_insn (opcode, opers)
- struct tic80_opcode *opcode;
- expressionS *opers;
+build_insn (struct tic80_opcode *opcode, expressionS *opers)
{
- int expi; /* Index of current expression to match */
- int opi; /* Index of current operand to match */
- unsigned long insn[2]; /* Instruction and long immediate (if any) */
- char *f; /* Pointer to frag location for insn[0] */
- fragS *ffrag; /* Frag containing location f */
- char *fx = NULL; /* Pointer to frag location for insn[1] */
- fragS *fxfrag; /* Frag containing location fx */
+ int expi; /* Index of current expression to match. */
+ int opi; /* Index of current operand to match. */
+ unsigned long insn[2]; /* Instruction and long immediate (if any). */
+ char *f; /* Pointer to frag location for insn[0]. */
+ fragS *ffrag; /* Frag containing location f. */
+ 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;
/* We are going to insert at least one 32 bit opcode so get the
frag now. */
-
f = frag_more (4);
ffrag = frag_now;
recent non O_absent expression. So only increment the operand
index when the current expression is not one of these special
expressions. */
-
if (X_op != O_absent)
- {
- opi++;
- }
+ opi++;
flags = tic80_operands[opcode->operands[opi]].flags;
bits = tic80_operands[opcode->operands[opi]].bits;
num &= ~TIC80_OPERAND_MASK;
insn[0] = insn[0] | (num << shift);
break;
+
case O_constant:
if ((flags & TIC80_OPERAND_ENDMASK) && (num == 32))
- {
- /* Endmask values of 0 and 32 give identical results. */
- num = 0;
- }
+ /* 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. */
- num = (~num & 0x1F);
- }
+ /* 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. */
if (bits < 32)
insn[1] = num;
}
break;
+
case O_symbol:
if (bits == 32)
{
fx = frag_more (4);
fxfrag = frag_now;
insn[1] = 0;
+
if (flags & TIC80_OPERAND_PCREL)
- {
- fix_new_exp (fxfrag,
- fx - (fxfrag->fr_literal),
- 4,
- &opers[expi],
- 1,
- R_MPPCR);
- }
+ fix_new_exp (fxfrag, fx - (fxfrag->fr_literal),
+ 4, &opers[expi], 1, R_MPPCR);
else
- {
- fix_new_exp (fxfrag,
- fx - (fxfrag->fr_literal),
- 4,
- &opers[expi],
- 0,
- R_RELLONGX);
- }
+ fix_new_exp (fxfrag, fx - (fxfrag->fr_literal),
+ 4, &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? */
- &opers[expi],
- 1,
- R_MPPCR15W);
- }
- else
- {
- internal_error (_("symbol reloc that is not PC relative or 32 bits"));
- }
+ fix_new_exp (ffrag, f - (ffrag->fr_literal),
+ 4, /* FIXME! how is this used? */
+ &opers[expi], 1, R_MPPCR15W);
+ else
+ internal_error (_("symbol reloc that is not PC relative or 32 bits"));
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))
- {
- insn[0] = insn[0] | (1 << 17);
- }
+ insn[0] = insn[0] | (1 << 17);
else if ((num & TIC80_OPERAND_M_LI)
&& (flags & TIC80_OPERAND_M_LI))
- {
- insn[0] = insn[0] | (1 << 15);
- }
+ insn[0] = insn[0] | (1 << 15);
else if ((num & TIC80_OPERAND_SCALED)
&& (flags & TIC80_OPERAND_SCALED))
- {
- insn[0] = insn[0] | (1 << 11);
- }
+ insn[0] = insn[0] | (1 << 11);
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"),
- (long) opers[expi].X_add_number);
- }
+ internal_error_a (_("unhandled operand modifier"),
+ (long) opers[expi].X_add_number);
break;
+
case O_big:
fx = frag_more (4);
fxfrag = frag_now;
+
{
int precision = 2;
long exponent_bits = 8L;
LITTLENUM_TYPE words[2];
+
/* Value is still in generic_floating_point_number. */
gen_to_words (words, precision, exponent_bits);
insn[1] = (words[0] << 16) | words[1];
}
break;
+
case O_illegal:
case O_symbol_rva:
case O_uminus:
md_number_to_chars (f, insn[0], 4);
if (fx != NULL)
- {
- md_number_to_chars (fx, insn[1], 4);
- }
+ md_number_to_chars (fx, insn[1], 4);
}
/* This is the main entry point for the machine-dependent assembler. Gas
function is supposed to emit the frags/bytes it assembles to. */
void
-md_assemble (str)
- char *str;
+md_assemble (char *str)
{
char *scan;
char *input_line_save;
the assembler will need. */
void
-md_begin ()
+md_begin (void)
{
char *prev_name = "";
register const struct tic80_opcode *op;
/* The assembler adds md_longopts to the machine independent long options
that are passed to getopt. */
-struct option md_longopts[] = {
-
+struct option md_longopts[] =
+{
#define OPTION_RELAX (OPTION_MD_BASE)
{"relax", no_argument, NULL, OPTION_RELAX},
appears in md_longopts for machine specific command line options. */
int
-md_parse_option (c, arg)
- int c;
- char *arg ATTRIBUTE_UNUSED;
+md_parse_option (int c, char *arg ATTRIBUTE_UNUSED)
{
switch (c)
{
tic80_relax = 0;
break;
default:
- return (0);
+ return 0;
}
- return (1);
+ return 1;
}
/* The md_show_usage function will be called whenever a usage message is
found in md_longopts. */
void
-md_show_usage (stream)
- FILE *stream;
+md_show_usage (FILE *stream)
{
fprintf (stream, "\
TIc80 options:\n\
To indicate that a fixup has been eliminated, set fixP->fx_done. */
void
-md_apply_fix3 (fixP, valP, seg)
- fixS *fixP;
- valueT * valP;
- segT seg ATTRIBUTE_UNUSED;
+md_apply_fix3 (fixS *fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED)
{
long val = * (long *) valP;
char *dest = fixP->fx_frag->fr_literal + fixP->fx_where;
break;
case R_MPPCR:
val >>= 2;
- val += 1; /* Target address computed from inst start */
+ val += 1; /* Target address computed from inst start. */
md_number_to_chars (dest, (valueT) val, 4);
break;
case R_MPPCR15W:
overflow = (val < -65536L) || (val > 65532L);
if (overflow)
- {
- as_bad_where (fixP->fx_file, fixP->fx_line,
- _("PC offset 0x%lx outside range 0x%lx-0x%lx"),
- val, -65536L, 65532L);
- }
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ _("PC offset 0x%lx outside range 0x%lx-0x%lx"),
+ val, -65536L, 65532L);
else
{
val >>= 2;
*dest = (*dest & 0x80) | (val & 0x7F);
}
break;
+
case R_ABS:
md_number_to_chars (dest, (valueT) val, fixP->fx_size);
break;
+
default:
internal_error_a (_("unhandled relocation type in fixup"),
(long) fixP->fx_r_type);
the PC relative field. */
long
-md_pcrel_from (fixP)
- fixS *fixP;
+md_pcrel_from (fixS *fixP)
{
return (fixP->fx_frag->fr_address + fixP->fx_where);
}
/* Called after relax() is finished.
- * In: Address of frag.
- * fr_type == rs_machine_dependent.
- * fr_subtype is what the address relaxed to.
- *
- * Out: Any fixSs and constants are set up.
- * Caller will turn frag into a ".space 0".
- */
+ In: Address of frag.
+ fr_type == rs_machine_dependent.
+ fr_subtype is what the address relaxed to.
+
+ Out: Any fixSs and constants are set up.
+ Caller will turn frag into a ".space 0". */
void
-md_convert_frag (headers, seg, fragP)
- object_headers *headers ATTRIBUTE_UNUSED;
- segT seg ATTRIBUTE_UNUSED;
- fragS *fragP ATTRIBUTE_UNUSED;
+md_convert_frag (object_headers *headers ATTRIBUTE_UNUSED,
+ segT seg ATTRIBUTE_UNUSED,
+ fragS *fragP ATTRIBUTE_UNUSED)
{
internal_error (_("md_convert_frag() not implemented yet"));
abort ();
}
\f
void
-tc_coff_symbol_emit_hook (ignore)
- symbolS *ignore ATTRIBUTE_UNUSED;
+tc_coff_symbol_emit_hook (symbolS *ignore ATTRIBUTE_UNUSED)
{
}
#if defined OBJ_COFF
short
-tc_coff_fix2rtype (fixP)
- fixS *fixP;
+tc_coff_fix2rtype (fixS *fixP)
{
return (fixP->fx_r_type);
}
projects / platform / upstream / binutils.git / blobdiff