/* tc-tic4x.c -- Assemble for the Texas Instruments TMS320C[34]x.
- Copyright (C) 1997,1998, 2002, 2003, 2005, 2006, 2007, 2008
- Free Software Foundation. Inc.
+ Copyright (C) 1997,1998, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010,
+ 2012 Free Software Foundation. Inc.
Contributed by Michael P. Hayes (m.hayes@elec.canterbury.ac.nz)
o .align cannot handle fill-data-width larger than 0xFF/8-bits. It
should be possible to define a 32-bits pattern.
- o .align fills all section with NOP's when used regardless if has
- been used in .text or .data. (However the .align is primarily
- intended used in .text sections. If you require something else,
- use .align <size>,0x00)
-
o .align: Implement a 'bu' insn if the number of nop's exceeds 4
within the align frag. if(fragsize>4words) insert bu fragend+1
first.
o Evaluation of constant floating point expressions (expr.c needs
work!)
- o Support 'abc' constants (that is 0x616263)
-*/
+ o Support 'abc' constants (that is 0x616263). */
-#include "safe-ctype.h"
#include "as.h"
+#include "safe-ctype.h"
#include "opcode/tic4x.h"
#include "subsegs.h"
#include "obstack.h"
|| flonum.sign == 0) /* = NaN */
{
if(flonum.sign == 0)
- as_bad ("Nan, using zero.");
+ as_bad (_("Nan, using zero."));
words[0] = 0x8000;
return return_value;
}
}
if (abs (exponent) >= (1 << (exponent_bits - 1)))
- as_bad ("Cannot represent exponent in %d bits", exponent_bits);
+ as_bad (_("Cannot represent exponent in %d bits"), exponent_bits);
/* Force exponent to fit in desired field width. */
exponent &= (1 << (exponent_bits)) - 1;
break;
default:
- as_bad ("Invalid floating point number");
+ as_bad (_("Invalid floating point number"));
return (NULL);
}
if (atof_generic (&return_value, ".", EXP_CHARS,
&generic_floating_point_number))
{
- as_bad ("Invalid floating point number");
+ as_bad (_("Invalid floating point number"));
return (NULL);
}
input_line_pointer++;
if (*input_line_pointer != ',')
{
- as_bad ("Comma expected\n");
+ as_bad (_("Comma expected\n"));
return;
}
*input_line_pointer++ = '\0';
c = get_symbol_end (); /* Get terminator. */
if (c != ',')
{
- as_bad (".bss size argument missing\n");
+ as_bad (_(".bss size argument missing\n"));
return;
}
tic4x_expression_abs (++input_line_pointer, &size);
if (size < 0)
{
- as_bad (".bss size %ld < 0!", (long) size);
+ as_bad (_(".bss size %ld < 0!"), (long) size);
return;
}
subseg_set (bss_section, 0);
input_line_pointer = tic4x_expression (input_line_pointer, &exp);
if (exp.X_op != O_constant)
{
- as_bad("Non-constant symbols not allowed\n");
+ as_bad (_("Non-constant symbols not allowed\n"));
return;
}
exp.X_add_number &= 255; /* Limit numeber to 8-bit */
tic4x_expression_abs (input_line_pointer, &value);
if (*input_line_pointer++ != ',')
{
- as_bad ("Symbol missing\n");
+ as_bad (_("Symbol missing\n"));
return;
}
name = input_line_pointer;
c = get_symbol_end (); /* Get terminator. */
- demand_empty_rest_of_line ();
tic4x_insert_sym (name, value);
+ *input_line_pointer++ = c;
+ demand_empty_rest_of_line ();
}
/* Reset local labels. */
{
char c;
char *section_name;
- char *subsection_name;
char *name;
segT seg;
offsetT num;
Volker Kuhlmann <v.kuhlmann@elec.canterbury.ac.nz>. */
if (c == ':')
{
- subsection_name = input_line_pointer;
c = get_symbol_end (); /* Get terminator. */
input_line_pointer++; /* Skip null symbol terminator. */
- as_warn (".sect: subsection name ignored");
+ as_warn (_(".sect: subsection name ignored"));
}
/* We might still have a '"' to discard, but the character after a
if (bfd_get_section_flags (stdoutput, seg) == SEC_NO_FLAGS)
{
if (!bfd_set_section_flags (stdoutput, seg, SEC_DATA))
- as_warn ("Error setting flags for \"%s\": %s", name,
+ as_warn (_("Error setting flags for \"%s\": %s"), name,
bfd_errmsg (bfd_get_error ()));
}
c = get_symbol_end (); /* Get terminator. */
if (c != ',')
{
- as_bad (".set syntax invalid\n");
+ as_bad (_(".set syntax invalid\n"));
ignore_rest_of_line ();
return;
}
else
alignment_flag = 0;
if (alignment_flag)
- as_warn (".usect: non-zero alignment flag ignored");
+ as_warn (_(".usect: non-zero alignment flag ignored"));
seg = subseg_new (name, 0);
if (line_label != NULL)
}
seg_info (seg)->bss = 1; /* Uninitialised data. */
if (!bfd_set_section_flags (stdoutput, seg, SEC_ALLOC))
- as_warn ("Error setting flags for \"%s\": %s", name,
+ as_warn (_("Error setting flags for \"%s\": %s"), name,
bfd_errmsg (bfd_get_error ()));
tic4x_seg_alloc (name, seg, size, line_label);
input_line_pointer =
tic4x_expression_abs (input_line_pointer, &temp);
if (!IS_CPU_TIC3X (temp) && !IS_CPU_TIC4X (temp))
- as_bad ("This assembler does not support processor generation %ld",
+ as_bad (_("This assembler does not support processor generation %ld"),
(long) temp);
if (tic4x_cpu && temp != (offsetT) tic4x_cpu)
- as_warn ("Changing processor generation on fly not supported...");
+ as_warn (_("Changing processor generation on fly not supported..."));
tic4x_cpu = temp;
demand_empty_rest_of_line ();
}
{
static tic4x_inst_t *insts = NULL;
static char *names = NULL;
- static int index = 0;
+ static int iindex = 0;
if (insts == NULL)
{
insts = (tic4x_inst_t *)
xmalloc (sizeof (tic4x_inst_t) * 1024);
}
- insts[index].name = names;
- insts[index].opcode = opcode;
- insts[index].opmask = 0xffffffff;
- insts[index].args = args;
- index++;
+ insts[iindex].name = names;
+ insts[iindex].opcode = opcode;
+ insts[iindex].opmask = 0xffffffff;
+ insts[iindex].args = args;
+ iindex++;
do
*names++ = *name++;
while (*name);
*names++ = '\0';
- return &insts[index - 1];
+ return &insts[iindex - 1];
}
/* Add instruction template, creating dynamic templates as required. */
d = name;
/* We do not care about INSNs that is not a part of our
- oplevel setting */
- if (!insts->oplevel & tic4x_oplevel)
+ oplevel setting. */
+ if ((insts->oplevel & tic4x_oplevel) == 0)
return ok;
while (1)
if (operand->aregno >= REG_AR0 && operand->aregno <= REG_AR7)
break;
- as_bad ("Auxiliary register AR0--AR7 required for indirect");
+ as_bad (_("Auxiliary register AR0--AR7 required for indirect"));
return -1;
case 'd': /* Need to match constant for disp. */
operand->disp = operand->expr.X_add_number;
if (operand->disp < 0 || operand->disp > 255)
{
- as_bad ("Bad displacement %d (require 0--255)\n",
+ as_bad (_("Bad displacement %d (require 0--255)\n"),
operand->disp);
return -1;
}
if (operand->expr.X_add_number != REG_IR0
&& operand->expr.X_add_number != REG_IR1)
{
- as_bad ("Index register IR0,IR1 required for displacement");
+ as_bad (_("Index register IR0,IR1 required for displacement"));
return -1;
}
expressionS *exp = &operand->expr;
char *save = input_line_pointer;
char *str;
- char *new;
+ char *new_pointer;
struct hash_entry *entry = NULL;
input_line_pointer = s;
str = input_line_pointer;
c = get_symbol_end (); /* Get terminator. */
- new = input_line_pointer;
+ new_pointer = input_line_pointer;
if (strlen (str) && (entry = hash_find (tic4x_asg_hash, str)) != NULL)
{
*input_line_pointer = c;
case '%':
input_line_pointer = tic4x_expression (++input_line_pointer, exp);
if (exp->X_op != O_register)
- as_bad ("Expecting a register name");
+ as_bad (_("Expecting a register name"));
operand->mode = M_REGISTER;
break;
else if (exp->X_op == O_big)
{
if (exp->X_add_number)
- as_bad ("Number too large"); /* bignum required */
+ as_bad (_("Number too large")); /* bignum required */
else
{
tic4x_gen_to_words (generic_floating_point_number,
else if (exp->X_op == O_big)
{
if (exp->X_add_number > 0)
- as_bad ("Number too large"); /* bignum required. */
+ as_bad (_("Number too large")); /* bignum required. */
else
{
tic4x_gen_to_words (generic_floating_point_number,
}
else
- as_bad ("Expecting a constant value");
+ as_bad (_("Expecting a constant value"));
break;
case '\\':
#endif
case '@':
input_line_pointer = tic4x_expression (++input_line_pointer, exp);
if (exp->X_op != O_constant && exp->X_op != O_symbol)
- as_bad ("Bad direct addressing construct %s", s);
+ as_bad (_("Bad direct addressing construct %s"), s);
if (exp->X_op == O_constant)
{
if (exp->X_add_number < 0)
- as_bad ("Direct value of %ld is not suitable",
+ as_bad (_("Direct value of %ld is not suitable"),
(long) exp->X_add_number);
}
operand->mode = M_DIRECT;
operand->expr.X_add_number = 0x18;
}
else
- as_bad ("Unknown indirect addressing mode");
+ as_bad (_("Unknown indirect addressing mode"));
break;
default:
else if (exp->X_op == O_big)
{
if (exp->X_add_number > 0)
- as_bad ("Number too large"); /* bignum required. */
+ as_bad (_("Number too large")); /* bignum required. */
else
{
tic4x_gen_to_words (generic_floating_point_number,
#endif
}
if (entry == NULL)
- new = input_line_pointer;
+ new_pointer = input_line_pointer;
input_line_pointer = save;
- return new;
+ return new_pointer;
}
static int
-tic4x_operands_match (tic4x_inst_t *inst, tic4x_insn_t *insn, int check)
+tic4x_operands_match (tic4x_inst_t *inst, tic4x_insn_t *tinsn, int check)
{
const char *args = inst->args;
unsigned long opcode = inst->opcode;
- int num_operands = insn->num_operands;
- tic4x_operand_t *operand = insn->operands;
+ int num_operands = tinsn->num_operands;
+ tic4x_operand_t *operand = tinsn->operands;
expressionS *exp = &operand->expr;
int ret = 1;
int reg;
If an operand matches, we modify insn or opcode appropriately,
and do a "continue". If an operand fails to match, we "break". */
- insn->nchars = 4; /* Instructions always 4 bytes. */
- insn->reloc = NO_RELOC;
- insn->pcrel = 0;
+ tinsn->nchars = 4; /* Instructions always 4 bytes. */
+ tinsn->reloc = NO_RELOC;
+ tinsn->pcrel = 0;
if (*args == '\0')
{
- insn->opcode = opcode;
+ tinsn->opcode = opcode;
return num_operands == 0;
}
case '\0': /* End of args. */
if (num_operands == 1)
{
- insn->opcode = opcode;
+ tinsn->opcode = opcode;
return ret;
}
break; /* Too many operands. */
else
{
if (!check)
- as_bad ("Immediate value of %ld is too large for ldf",
+ as_bad (_("Immediate value of %ld is too large for ldf"),
(long) exp->X_add_number);
ret = -1;
continue;
}
else if (exp->X_op == O_symbol)
{
- insn->reloc = BFD_RELOC_HI16;
- insn->exp = *exp;
+ tinsn->reloc = BFD_RELOC_HI16;
+ tinsn->exp = *exp;
continue;
}
break; /* Not direct (dp) addressing. */
}
else if (exp->X_op == O_symbol)
{
- insn->reloc = BFD_RELOC_LO16;
- insn->exp = *exp;
+ tinsn->reloc = BFD_RELOC_LO16;
+ tinsn->exp = *exp;
continue;
}
break; /* Not direct addressing. */
else
{
if (!check)
- as_bad ("Destination register must be ARn");
+ as_bad (_("Destination register must be ARn"));
ret = -1;
}
continue;
else
{
if (!check)
- as_bad ("Immediate value of %ld is too large",
+ as_bad (_("Immediate value of %ld is too large"),
(long) exp->X_add_number);
ret = -1;
continue;
}
if (IS_CPU_TIC4X (tic4x_cpu))
{
- insn->reloc = BFD_RELOC_24_PCREL;
- insn->pcrel = 1;
+ tinsn->reloc = BFD_RELOC_24_PCREL;
+ tinsn->pcrel = 1;
}
else
{
- insn->reloc = BFD_RELOC_24;
- insn->pcrel = 0;
+ tinsn->reloc = BFD_RELOC_24;
+ tinsn->pcrel = 0;
}
- insn->exp = *exp;
+ tinsn->exp = *exp;
continue;
case 'C':
&& operand->expr.X_add_number != 0x18)
{
if (!check)
- as_bad ("Invalid indirect addressing mode");
+ as_bad (_("Invalid indirect addressing mode"));
ret = -1;
continue;
}
else
{
if (!check)
- as_bad ("Register must be Rn");
+ as_bad (_("Register must be Rn"));
ret = -1;
}
continue;
else
{
if (!check)
- as_bad ("Register must be Rn");
+ as_bad (_("Register must be Rn"));
ret = -1;
}
continue;
else
{
if (!check)
- as_bad ("Register must be R0--R7");
+ as_bad (_("Register must be R0--R7"));
ret = -1;
}
continue;
if (IS_CPU_TIC4X (tic4x_cpu))
break;
if (!check)
- as_bad ("Invalid indirect addressing mode displacement %d",
+ as_bad (_("Invalid indirect addressing mode displacement %d"),
operand->disp);
ret = -1;
continue;
if (IS_CPU_TIC4X (tic4x_cpu))
break;
if (!check)
- as_bad ("Invalid indirect addressing mode displacement %d",
+ as_bad (_("Invalid indirect addressing mode displacement %d"),
operand->disp);
ret = -1;
continue;
else
{
if (!check)
- as_bad ("Register must be R0--R7");
+ as_bad (_("Register must be R0--R7"));
ret = -1;
}
continue;
else
{
if (!check)
- as_bad ("Register must be R0--R7");
+ as_bad (_("Register must be R0--R7"));
ret = -1;
}
continue;
else
{
if (!check)
- as_bad ("Destination register must be R2 or R3");
+ as_bad (_("Destination register must be R2 or R3"));
ret = -1;
}
continue;
else
{
if (!check)
- as_bad ("Destination register must be R0 or R1");
+ as_bad (_("Destination register must be R0 or R1"));
ret = -1;
}
continue;
&& operand->expr.X_add_number != 0x18)
{
if (!check)
- as_bad ("Invalid indirect addressing mode");
+ as_bad (_("Invalid indirect addressing mode"));
ret = -1;
continue;
}
else
{
if (!check)
- as_bad ("Displacement value of %ld is too large",
+ as_bad (_("Displacement value of %ld is too large"),
(long) exp->X_add_number);
ret = -1;
continue;
}
}
- insn->reloc = BFD_RELOC_16_PCREL;
- insn->pcrel = 1;
- insn->exp = *exp;
+ tinsn->reloc = BFD_RELOC_16_PCREL;
+ tinsn->pcrel = 1;
+ tinsn->exp = *exp;
continue;
case 'Q':
else
{
if (!check)
- as_bad ("Register must be Rn");
+ as_bad (_("Register must be Rn"));
ret = -1;
}
continue;
else
{
if (!check)
- as_bad ("Register must be Rn");
+ as_bad (_("Register must be Rn"));
ret = -1;
}
continue;
if (exp->X_op == O_big)
{
if (!check)
- as_bad ("Floating point number not valid in expression");
+ as_bad (_("Floating point number not valid in expression"));
ret = -1;
continue;
}
else
{
if (!check)
- as_bad ("Signed immediate value %ld too large",
+ as_bad (_("Signed immediate value %ld too large"),
(long) exp->X_add_number);
ret = -1;
continue;
{
if (operand->mode == M_HI)
{
- insn->reloc = BFD_RELOC_HI16;
+ tinsn->reloc = BFD_RELOC_HI16;
}
else
{
- insn->reloc = BFD_RELOC_LO16;
+ tinsn->reloc = BFD_RELOC_LO16;
}
- insn->exp = *exp;
+ tinsn->exp = *exp;
continue;
}
/* Handle cases like ldi foo - $, ar0 where foo
is a forward reference. Perhaps we should check
for X_op == O_symbol and disallow things like
ldi foo, ar0. */
- insn->reloc = BFD_RELOC_16;
- insn->exp = *exp;
+ tinsn->reloc = BFD_RELOC_16;
+ tinsn->exp = *exp;
continue;
case 'T': /* 5-bit immediate value for tic4x stik. */
else
{
if (!check)
- as_bad ("Immediate value of %ld is too large",
+ as_bad (_("Immediate value of %ld is too large"),
(long) exp->X_add_number);
ret = -1;
continue;
else
{
if (!check)
- as_bad ("Unsigned immediate value %ld too large",
+ as_bad (_("Unsigned immediate value %ld too large"),
(long) exp->X_add_number);
ret = -1;
continue;
else if (exp->X_op == O_symbol)
{
if (operand->mode == M_HI)
- insn->reloc = BFD_RELOC_HI16;
+ tinsn->reloc = BFD_RELOC_HI16;
else
- insn->reloc = BFD_RELOC_LO16;
+ tinsn->reloc = BFD_RELOC_LO16;
- insn->exp = *exp;
+ tinsn->exp = *exp;
continue;
}
- insn->reloc = BFD_RELOC_16;
- insn->exp = *exp;
+ tinsn->reloc = BFD_RELOC_16;
+ tinsn->exp = *exp;
continue;
case 'V': /* Trap numbers (immediate field). */
else
{
if (!check)
- as_bad ("Immediate value of %ld is too large",
+ as_bad (_("Immediate value of %ld is too large"),
(long) exp->X_add_number);
ret = -1;
continue;
if (exp->X_op == O_big)
{
if (!check)
- as_bad ("Floating point number not valid in expression");
+ as_bad (_("Floating point number not valid in expression"));
ret = -1;
continue;
}
else
{
if (!check)
- as_bad ("Immediate value %ld too large",
+ as_bad (_("Immediate value %ld too large"),
(long) exp->X_add_number);
ret = -1;
continue;
}
}
- insn->reloc = BFD_RELOC_16;
- insn->exp = *exp;
+ tinsn->reloc = BFD_RELOC_16;
+ tinsn->exp = *exp;
continue;
case 'X': /* Expansion register for tic4x. */
else
{
if (!check)
- as_bad ("Register must be ivtp or tvtp");
+ as_bad (_("Register must be ivtp or tvtp"));
ret = -1;
}
continue;
else
{
if (!check)
- as_bad ("Register must be address register");
+ as_bad (_("Register must be address register"));
ret = -1;
}
continue;
else
{
if (!check)
- as_bad ("Register must be ivtp or tvtp");
+ as_bad (_("Register must be ivtp or tvtp"));
ret = -1;
}
continue;
continue;
case '|': /* treat as `,' if have ldi_ldi form. */
- if (insn->parallel)
+ if (tinsn->parallel)
{
if (--num_operands < 0)
break; /* Too few operands. */
}
static void
-tic4x_insn_check (tic4x_insn_t *insn)
+tic4x_insn_check (tic4x_insn_t *tinsn)
{
- if (!strcmp(insn->name, "lda"))
+ if (!strcmp (tinsn->name, "lda"))
{
- if (insn->num_operands < 2 || insn->num_operands > 2)
+ if (tinsn->num_operands < 2 || tinsn->num_operands > 2)
as_fatal ("Illegal internal LDA insn definition");
- if ( insn->operands[0].mode == M_REGISTER
- && insn->operands[1].mode == M_REGISTER
- && insn->operands[0].expr.X_add_number == insn->operands[1].expr.X_add_number )
- as_bad ("Source and destination register should not be equal");
+ if (tinsn->operands[0].mode == M_REGISTER
+ && tinsn->operands[1].mode == M_REGISTER
+ && tinsn->operands[0].expr.X_add_number == tinsn->operands[1].expr.X_add_number )
+ as_bad (_("Source and destination register should not be equal"));
}
- else if( !strcmp(insn->name, "ldi_ldi")
- || !strcmp(insn->name, "ldi1_ldi2")
- || !strcmp(insn->name, "ldi2_ldi1")
- || !strcmp(insn->name, "ldf_ldf")
- || !strcmp(insn->name, "ldf1_ldf2")
- || !strcmp(insn->name, "ldf2_ldf1") )
+ else if (!strcmp (tinsn->name, "ldi_ldi")
+ || !strcmp (tinsn->name, "ldi1_ldi2")
+ || !strcmp (tinsn->name, "ldi2_ldi1")
+ || !strcmp (tinsn->name, "ldf_ldf")
+ || !strcmp (tinsn->name, "ldf1_ldf2")
+ || !strcmp (tinsn->name, "ldf2_ldf1") )
{
- if ( insn->num_operands < 4 && insn->num_operands > 5 )
- as_fatal ("Illegal internal %s insn definition", insn->name);
+ if (tinsn->num_operands < 4 && tinsn->num_operands > 5 )
+ as_fatal ("Illegal internal %s insn definition", tinsn->name);
- if ( insn->operands[1].mode == M_REGISTER
- && insn->operands[insn->num_operands-1].mode == M_REGISTER
- && insn->operands[1].expr.X_add_number == insn->operands[insn->num_operands-1].expr.X_add_number )
- as_warn ("Equal parallell destination registers, one result will be discarded");
+ if (tinsn->operands[1].mode == M_REGISTER
+ && tinsn->operands[tinsn->num_operands-1].mode == M_REGISTER
+ && tinsn->operands[1].expr.X_add_number == tinsn->operands[tinsn->num_operands-1].expr.X_add_number )
+ as_warn (_("Equal parallell destination registers, one result will be discarded"));
}
}
static void
-tic4x_insn_output (tic4x_insn_t *insn)
+tic4x_insn_output (tic4x_insn_t *tinsn)
{
char *dst;
/* Grab another fragment for opcode. */
- dst = frag_more (insn->nchars);
+ dst = frag_more (tinsn->nchars);
/* Put out opcode word as a series of bytes in little endian order. */
- md_number_to_chars (dst, insn->opcode, insn->nchars);
+ md_number_to_chars (dst, tinsn->opcode, tinsn->nchars);
/* Put out the symbol-dependent stuff. */
- if (insn->reloc != NO_RELOC)
+ if (tinsn->reloc != NO_RELOC)
{
/* Where is the offset into the fragment for this instruction. */
fix_new_exp (frag_now,
dst - frag_now->fr_literal, /* where */
- insn->nchars, /* size */
- &insn->exp,
- insn->pcrel,
- insn->reloc);
+ tinsn->nchars, /* size */
+ &tinsn->exp,
+ tinsn->pcrel,
+ tinsn->reloc);
}
}
if (num_operands > TIC4X_OPERANDS_MAX)
{
- as_bad ("Too many operands scanned");
+ as_bad (_("Too many operands scanned"));
return -1;
}
return num_operands;
{
if(insn->parallel)
{
- as_bad ("Parallel opcode cannot contain more than two instructions");
+ as_bad (_("Parallel opcode cannot contain more than two instructions"));
insn->parallel = 0;
insn->in_use = 0;
return;
if ((insn->inst = (struct tic4x_inst *)
hash_find (tic4x_op_hash, insn->name)) == NULL)
{
- as_bad ("Unknown opcode `%s'.", insn->name);
+ as_bad (_("Unknown opcode `%s'."), insn->name);
insn->parallel = 0;
insn->in_use = 0;
return;
{
if (first_inst)
tic4x_operands_match (first_inst, insn, 0);
- as_bad ("Invalid operands for %s", insn->name);
+ as_bad (_("Invalid operands for %s"), insn->name);
}
else
- as_bad ("Invalid instruction %s", insn->name);
+ as_bad (_("Invalid instruction %s"), insn->name);
}
if (str && !parsed)
case NO_RELOC:
default:
- as_bad ("Bad relocation type: 0x%02x", fixP->fx_r_type);
+ as_bad (_("Bad relocation type: 0x%02x"), fixP->fx_r_type);
break;
}
arg++;
tic4x_cpu = atoi (arg);
if (!IS_CPU_TIC3X (tic4x_cpu) && !IS_CPU_TIC4X (tic4x_cpu))
- as_warn ("Unsupported processor generation %d", tic4x_cpu);
+ as_warn (_("Unsupported processor generation %d"), tic4x_cpu);
break;
case OPTION_REV: /* cpu revision */
break;
case 'b':
- as_warn ("Option -b is depreciated, please use -mbig");
+ as_warn (_("Option -b is depreciated, please use -mbig"));
case OPTION_BIG: /* big model */
tic4x_big_model = 1;
break;
case 'p':
- as_warn ("Option -p is depreciated, please use -mmemparm");
+ as_warn (_("Option -p is depreciated, please use -mmemparm"));
case OPTION_MEMPARM: /* push args */
tic4x_reg_args = 0;
break;
case 'r':
- as_warn ("Option -r is depreciated, please use -mregparm");
+ as_warn (_("Option -r is depreciated, please use -mregparm"));
case OPTION_REGPARM: /* register args */
tic4x_reg_args = 1;
break;
case 's':
- as_warn ("Option -s is depreciated, please use -msmall");
+ as_warn (_("Option -s is depreciated, please use -msmall"));
case OPTION_SMALL: /* small model */
tic4x_big_model = 0;
break;
if (dollar_label_defined (lab))
{
- as_bad ("Label \"$%d\" redefined", lab);
+ as_bad (_("Label \"$%d\" redefined"), lab);
return 0;
}
/* Fill the alignment area with NOP's on .text, unless fill-data
was specified. */
int
-tic4x_do_align (int alignment ATTRIBUTE_UNUSED,
- const char *fill ATTRIBUTE_UNUSED,
- int len ATTRIBUTE_UNUSED,
- int max ATTRIBUTE_UNUSED)
+tic4x_do_align (int alignment,
+ const char *fill,
+ int len,
+ int max)
{
- unsigned long nop = TIC_NOP_OPCODE;
-
/* Because we are talking lwords, not bytes, adjust alignment to do words */
alignment += 2;
{
if (fill == NULL)
{
- /*if (subseg_text_p (now_seg))*/ /* FIXME: doesn't work for .text for some reason */
- frag_align_pattern( alignment, (const char *)&nop, sizeof(nop), max);
- return 1;
- /*else
- frag_align (alignment, 0, max);*/
+ if (subseg_text_p (now_seg))
+ {
+ char nop[4];
+
+ md_number_to_chars (nop, TIC_NOP_OPCODE, 4);
+ frag_align_pattern (alignment, nop, sizeof (nop), max);
+ }
+ else
+ frag_align (alignment, 0, max);
}
else if (len <= 1)
frag_align (alignment, *fill, max);
if (reloc->howto == (reloc_howto_type *) NULL)
{
as_bad_where (fixP->fx_file, fixP->fx_line,
- "Reloc %d not supported by object file format",
+ _("Reloc %d not supported by object file format"),
(int) fixP->fx_r_type);
return NULL;
}
projects / external / binutils.git / blobdiff