/* tc-tic54x.c -- Assembly code for the Texas Instruments TMS320C54X
- Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
- Free Software Foundation, Inc.
+ Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+ 2009, 2010 Free Software Foundation, Inc.
Contributed by Timothy Wall (twall@cygnus.com)
This file is part of GAS, the GNU Assembler.
typedef struct _tic54x_insn
{
- const template *tm; /* Opcode template. */
+ const insn_template *tm; /* Opcode template. */
char mnemonic[MAX_LINE]; /* Opcode name/mnemonic. */
char parmnemonic[MAX_LINE]; /* 2nd mnemonic of parallel insn. */
} \
while (0)
-static void tic54x_emit_char PARAMS ((char));
-static fragS * frag_prev PARAMS ((fragS *, segT));
-static fragS * bit_offset_frag PARAMS ((fragS *, segT));
-static int frag_bit_offset PARAMS ((fragS *, segT));
-static char * parse_expression PARAMS ((char *, expressionS *));
-static void tic54x_asg PARAMS ((int));
-static void tic54x_eval PARAMS ((int));
-static void tic54x_bss PARAMS ((int));
-static void stag_add_field_symbols PARAMS ((struct stag *, const char *, bfd_vma, symbolS *, const char *));
-static void stag_add_field PARAMS ((struct stag *, const char *, bfd_vma, struct stag *));
-static void tic54x_struct PARAMS ((int));
-static void tic54x_endstruct PARAMS ((int));
-static void tic54x_tag PARAMS ((int));
-static void tic54x_struct_field PARAMS ((int));
-static void tic54x_cons PARAMS ((int));
-static void tic54x_remove_local_label PARAMS ((const char *, PTR));
-static void tic54x_clear_local_labels PARAMS ((int));
-static void tic54x_sect PARAMS ((int));
-static void tic54x_space PARAMS ((int));
-static void tic54x_usect PARAMS ((int));
-static enum cpu_version lookup_version PARAMS ((const char *));
-static void set_cpu PARAMS ((enum cpu_version));
-static void tic54x_version PARAMS ((int));
-static void tic54x_float_cons PARAMS ((int));
-static void tic54x_stringer PARAMS ((int));
-static void tic54x_p2align PARAMS ((int));
-static void tic54x_align_words PARAMS ((int));
-static void tic54x_field PARAMS ((int));
-static int tic54x_initialized_section PARAMS ((segT));
-static void tic54x_clink PARAMS ((int));
-static void tic54x_set_default_include PARAMS ((int));
-static void tic54x_include PARAMS ((int));
-static void tic54x_message PARAMS ((int));
-static void tic54x_label PARAMS ((int));
-static void tic54x_mmregs PARAMS ((int));
-static void tic54x_loop PARAMS ((int));
-static void tic54x_endloop PARAMS ((int));
-static void tic54x_break PARAMS ((int));
-static void set_address_mode PARAMS ((int));
-static void tic54x_address_mode PARAMS ((int));
-static void tic54x_sblock PARAMS ((int));
-static void tic54x_set PARAMS ((int));
-static void tic54x_fclist PARAMS ((int));
-static void tic54x_sslist PARAMS ((int));
-static void tic54x_var PARAMS ((int));
-static void tic54x_mlib PARAMS ((int));
-static int subsym_symlen PARAMS ((char *, char *));
-static int subsym_symcmp PARAMS ((char *, char *));
-static int subsym_firstch PARAMS ((char *, char *));
-static int subsym_lastch PARAMS ((char *, char *));
-static int subsym_isdefed PARAMS ((char *, char *));
-static int subsym_ismember PARAMS ((char *, char *));
-static int subsym_iscons PARAMS ((char *, char *));
-static int subsym_isname PARAMS ((char *, char *));
-static int subsym_isreg PARAMS ((char *, char *));
-static int subsym_structsz PARAMS ((char *, char *));
-static int subsym_structacc PARAMS ((char *, char *));
-static float math_ceil PARAMS ((float, float));
-static float math_cvi PARAMS ((float, float));
-static float math_floor PARAMS ((float, float));
-static float math_fmod PARAMS ((float, float));
-static float math_int PARAMS ((float, float));
-static float math_round PARAMS ((float, float));
-static float math_sgn PARAMS ((float, float));
-static float math_trunc PARAMS ((float, float));
-static float math_acos PARAMS ((float, float));
-static float math_asin PARAMS ((float, float));
-static float math_atan PARAMS ((float, float));
-static float math_atan2 PARAMS ((float, float));
-static float math_cosh PARAMS ((float, float));
-static float math_cos PARAMS ((float, float));
-static float math_cvf PARAMS ((float, float));
-static float math_exp PARAMS ((float, float));
-static float math_fabs PARAMS ((float, float));
-static float math_ldexp PARAMS ((float, float));
-static float math_log10 PARAMS ((float, float));
-static float math_log PARAMS ((float, float));
-static float math_max PARAMS ((float, float));
-static float math_min PARAMS ((float, float));
-static float math_pow PARAMS ((float, float));
-static float math_sin PARAMS ((float, float));
-static float math_sinh PARAMS ((float, float));
-static float math_sqrt PARAMS ((float, float));
-static float math_tan PARAMS ((float, float));
-static float math_tanh PARAMS ((float, float));
-static int is_accumulator PARAMS ((struct opstruct *));
-static int get_operands PARAMS ((struct opstruct operands[], char *));
-static int is_immediate PARAMS ((struct opstruct *));
-static int is_absolute PARAMS ((struct opstruct *));
-static int is_indirect PARAMS ((struct opstruct *));
-static int is_dual PARAMS ((struct opstruct *));
-static int is_mmreg PARAMS ((struct opstruct *));
-static int is_type PARAMS ((struct opstruct *, enum optype));
-static int operands_match PARAMS ((tic54x_insn *, struct opstruct *, int, const enum optype *, int, int));
-static int encode_dmad PARAMS ((tic54x_insn *, struct opstruct *, int));
-static int encode_address PARAMS ((tic54x_insn *, struct opstruct *));
-static int encode_indirect PARAMS ((tic54x_insn *, struct opstruct *));
-static int encode_integer PARAMS ((tic54x_insn *, struct opstruct *, int, int, int, unsigned short));
-static int encode_condition PARAMS ((tic54x_insn *, struct opstruct *));
-static int encode_cc3 PARAMS ((tic54x_insn *, struct opstruct *));
-static int encode_arx PARAMS ((tic54x_insn *, struct opstruct *));
-static int encode_cc2 PARAMS ((tic54x_insn *, struct opstruct *));
-static int encode_operand PARAMS ((tic54x_insn *, enum optype, struct opstruct *));
-static void emit_insn PARAMS ((tic54x_insn *));
-static int build_insn PARAMS ((tic54x_insn *));
-static int optimize_insn PARAMS ((tic54x_insn *));
-static int tic54x_parse_insn PARAMS ((tic54x_insn *, char *));
-static int next_line_shows_parallel PARAMS ((char *));
-static int tic54x_parse_parallel_insn_firstline PARAMS ((tic54x_insn *, char *));
-static int tic54x_parse_parallel_insn_lastline PARAMS ((tic54x_insn *, char *));
-static char * subsym_get_arg PARAMS ((char *, char *, char **, int));
-static void subsym_create_or_replace PARAMS ((char *, char *));
-static char * subsym_lookup PARAMS ((char *, int));
-static char * subsym_substitute PARAMS ((char *, int));
+
+static void subsym_create_or_replace (char *, char *);
+static char *subsym_lookup (char *, int);
+static char *subsym_substitute (char *, int);
void
-md_show_usage (stream)
- FILE *stream;
+md_show_usage (FILE *stream)
{
fprintf (stream, _("C54x-specific command line options:\n"));
fprintf (stream, _("-mfar-mode | -mf Use extended addressing\n"));
/* Output a single character (upper octect is zero). */
static void
-tic54x_emit_char (c)
- char c;
+tic54x_emit_char (char c)
{
- expressionS exp;
+ expressionS expn;
- exp.X_op = O_constant;
- exp.X_add_number = c;
- emit_expr (&exp, 2);
+ expn.X_op = O_constant;
+ expn.X_add_number = c;
+ emit_expr (&expn, 2);
}
/* Walk backwards in the frag chain. */
static fragS *
-frag_prev (frag, seg)
- fragS *frag;
- segT seg;
+frag_prev (fragS *frag, segT seg)
{
segment_info_type *seginfo = seg_info (seg);
fragS *fragp;
}
static fragS *
-bit_offset_frag (frag, seg)
- fragS *frag;
- segT seg;
+bit_offset_frag (fragS *frag, segT seg)
{
while (frag != NULL)
{
none. .field/.space/.bes may leave words partially allocated. */
static int
-frag_bit_offset (frag, seg)
- fragS *frag;
- segT seg;
+frag_bit_offset (fragS *frag, segT seg)
{
frag = bit_offset_frag (frag, seg);
expression. */
static char *
-parse_expression (str, exp)
- char *str;
- expressionS * exp;
+parse_expression (char *str, expressionS *expn)
{
char *s;
char *tmp;
tmp = input_line_pointer; /* Save line pointer. */
input_line_pointer = str;
- expression (exp);
+ expression (expn);
s = input_line_pointer;
input_line_pointer = tmp; /* Restore line pointer. */
return s; /* Return pointer to where parsing stopped. */
unsupported. */
static void
-tic54x_asg (x)
- int x ATTRIBUTE_UNUSED;
+tic54x_asg (int x ATTRIBUTE_UNUSED)
{
int c;
char *name;
c = get_symbol_end (); /* Get terminator. */
if (!ISALPHA (*name))
{
- as_bad ("symbols assigned with .asg must begin with a letter");
+ as_bad (_("symbols assigned with .asg must begin with a letter"));
ignore_rest_of_line ();
return;
}
table, since that's what works best. */
static void
-tic54x_eval (x)
- int x ATTRIBUTE_UNUSED;
+tic54x_eval (int x ATTRIBUTE_UNUSED)
{
char c;
int value;
(not yet implemented). */
static void
-tic54x_bss (x)
- int x ATTRIBUTE_UNUSED;
+tic54x_bss (int x ATTRIBUTE_UNUSED)
{
char c;
char *name;
c = get_symbol_end (); /* Get terminator. */
if (c != ',')
{
- as_bad (".bss size argument missing\n");
+ as_bad (_(".bss size argument missing\n"));
ignore_rest_of_line ();
return;
}
words = get_absolute_expression ();
if (words < 0)
{
- as_bad (".bss size %d < 0!", words);
+ as_bad (_(".bss size %d < 0!"), words);
ignore_rest_of_line ();
return;
}
}
static void
-stag_add_field_symbols (stag, path, base_offset, rootsym, root_stag_name)
- struct stag *stag;
- const char *path;
- bfd_vma base_offset;
- symbolS *rootsym;
- const char *root_stag_name;
+stag_add_field_symbols (struct stag *stag,
+ const char *path,
+ bfd_vma base_offset,
+ symbolS *rootsym,
+ const char *root_stag_name)
{
char prefix[strlen (path) + 2];
struct stag_field *field = stag->field;
complete dereferencing symbols to the symbol table. */
static void
-stag_add_field (parent, name, offset, stag)
- struct stag *parent;
- const char *name;
- bfd_vma offset;
- struct stag *stag;
+stag_add_field (struct stag *parent,
+ const char *name,
+ bfd_vma offset,
+ struct stag *stag)
{
struct stag_field *sfield = xmalloc (sizeof (struct stag_field));
Start defining structure offsets (symbols in absolute section). */
static void
-tic54x_struct (arg)
- int arg;
+tic54x_struct (int arg)
{
int start_offset = 0;
int is_union = arg;
of the structure. */
static void
-tic54x_endstruct (is_union)
- int is_union;
+tic54x_endstruct (int is_union)
{
int size;
const char *path =
format on the existing allocated space. */
static void
-tic54x_tag (ignore)
- int ignore ATTRIBUTE_UNUSED;
+tic54x_tag (int ignore ATTRIBUTE_UNUSED)
{
char *name = input_line_pointer;
int c = get_symbol_end ();
and .word. */
static void
-tic54x_struct_field (type)
- int type;
+tic54x_struct_field (int type)
{
int size;
int count = 1;
/* Handle .byte, .word. .int, .long and all variants. */
static void
-tic54x_cons (type)
- int type;
+tic54x_cons (int type)
{
unsigned int c;
int octets;
}
else
{
- expressionS exp;
+ expressionS expn;
- input_line_pointer = parse_expression (input_line_pointer, &exp);
- if (exp.X_op == O_constant)
+ input_line_pointer = parse_expression (input_line_pointer, &expn);
+ if (expn.X_op == O_constant)
{
- offsetT value = exp.X_add_number;
+ offsetT value = expn.X_add_number;
/* Truncate overflows. */
switch (octets)
{
case 1:
if ((value > 0 && value > 0xFF)
|| (value < 0 && value < - 0x100))
- as_warn ("Overflow in expression, truncated to 8 bits");
+ as_warn (_("Overflow in expression, truncated to 8 bits"));
break;
case 2:
if ((value > 0 && value > 0xFFFF)
|| (value < 0 && value < - 0x10000))
- as_warn ("Overflow in expression, truncated to 16 bits");
+ as_warn (_("Overflow in expression, truncated to 16 bits"));
break;
}
}
- if (exp.X_op != O_constant && octets < 2)
+ if (expn.X_op != O_constant && octets < 2)
{
/* Disallow .byte with a non constant expression that will
require relocation. */
return;
}
- if (exp.X_op != O_constant
+ if (expn.X_op != O_constant
&& amode == c_mode
&& octets == 4)
{
totally ignored in the latest tools). */
amode = far_mode;
emitting_long = 1;
- emit_expr (&exp, 4);
+ emit_expr (&expn, 4);
emitting_long = 0;
amode = c_mode;
}
else
{
emitting_long = octets == 4;
- emit_expr (&exp, (octets == 1) ? 2 : octets);
+ emit_expr (&expn, (octets == 1) ? 2 : octets);
emitting_long = 0;
}
}
these, so we ignore the type here. */
void
-tic54x_global (type)
- int type;
+tic54x_global (int type)
{
char *name;
int c;
/* Remove the symbol from the local label hash lookup. */
static void
-tic54x_remove_local_label (key, value)
- const char *key;
- PTR value ATTRIBUTE_UNUSED;
+tic54x_remove_local_label (const char *key, void *value ATTRIBUTE_UNUSED)
{
- PTR *elem = hash_delete (local_label_hash[macro_level], key);
+ void *elem = hash_delete (local_label_hash[macro_level], key, FALSE);
free (elem);
}
/* Reset all local labels. */
static void
-tic54x_clear_local_labels (ignored)
- int ignored ATTRIBUTE_UNUSED;
+tic54x_clear_local_labels (int ignored ATTRIBUTE_UNUSED)
{
hash_traverse (local_label_hash[macro_level], tic54x_remove_local_label);
}
*/
static void
-tic54x_sect (arg)
- int arg;
+tic54x_sect (int arg)
{
ILLEGAL_WITHIN_STRUCT ();
cribbed from s_space. */
static void
-tic54x_space (arg)
- int arg;
+tic54x_space (int arg)
{
- expressionS exp;
+ expressionS expn;
char *p = 0;
int octets = 0;
long words;
#endif
/* Read the bit count. */
- expression (&exp);
+ expression (&expn);
/* Some expressions are unresolvable until later in the assembly pass;
postpone until relaxation/fixup. we also have to postpone if a previous
partial allocation has not been completed yet. */
- if (exp.X_op != O_constant || frag_bit_offset (frag_now, now_seg) == -1)
+ if (expn.X_op != O_constant || frag_bit_offset (frag_now, now_seg) == -1)
{
struct bit_info *bi = xmalloc (sizeof (struct bit_info));
- char *p;
bi->seg = now_seg;
bi->type = bes;
bi->sym = label;
p = frag_var (rs_machine_dependent,
65536 * 2, 1, (relax_substateT) 0,
- make_expr_symbol (&exp), (offsetT) 0,
+ make_expr_symbol (&expn), (offsetT) 0,
(char *) bi);
if (p)
*p = 0;
{
int spare_bits = bits_per_byte - bit_offset;
- if (spare_bits >= exp.X_add_number)
+ if (spare_bits >= expn.X_add_number)
{
/* Don't have to do anything; sufficient bits have already been
allocated; just point the label to the right place. */
S_SET_VALUE (label, frag_now_fix () - 1);
label = NULL;
}
- frag_now->tc_frag_data += exp.X_add_number;
+ frag_now->tc_frag_data += expn.X_add_number;
goto getout;
}
- exp.X_add_number -= spare_bits;
+ expn.X_add_number -= spare_bits;
/* Set the label to point to the first word allocated, which in this
case is the previous word, which was only partially filled. */
if (!bes && label != NULL)
}
}
/* Convert bits to bytes/words and octets, rounding up. */
- words = ((exp.X_add_number + bits_per_byte - 1) / bits_per_byte);
+ words = ((expn.X_add_number + bits_per_byte - 1) / bits_per_byte);
/* How many do we have left over? */
- bit_offset = exp.X_add_number % bits_per_byte;
+ bit_offset = expn.X_add_number % bits_per_byte;
octets = words * OCTETS_PER_BYTE;
if (octets < 0)
{
Has no effect on the current section. */
static void
-tic54x_usect (x)
- int x ATTRIBUTE_UNUSED;
+tic54x_usect (int x ATTRIBUTE_UNUSED)
{
char c;
char *name;
flags |= SEC_TIC54X_BLOCK;
if (!bfd_set_section_flags (stdoutput, seg, flags))
- as_warn ("Error setting flags for \"%s\": %s", name,
+ as_warn (_("Error setting flags for \"%s\": %s"), name,
bfd_errmsg (bfd_get_error ()));
subseg_set (current_seg, current_subseg); /* Restore current seg. */
}
static enum cpu_version
-lookup_version (ver)
- const char *ver;
+lookup_version (const char *ver)
{
enum cpu_version version = VNONE;
}
static void
-set_cpu (version)
- enum cpu_version version;
+set_cpu (enum cpu_version version)
{
cpu = version;
if (version == V545LP || version == V546LP)
static int cpu_needs_set = 1;
static void
-tic54x_version (x)
- int x ATTRIBUTE_UNUSED;
+tic54x_version (int x ATTRIBUTE_UNUSED)
{
enum cpu_version version = VNONE;
enum cpu_version old_version = cpu;
/* 'f' = float, 'x' = xfloat, 'd' = double, 'l' = ldouble. */
static void
-tic54x_float_cons (type)
- int type;
+tic54x_float_cons (int type)
{
if (current_stag != 0)
tic54x_struct_field ('f');
and encoded into the correct octets. */
static void
-tic54x_stringer (type)
- int type;
+tic54x_stringer (int type)
{
unsigned int c;
- char *start;
int append_zero = type == 'S' || type == 'P';
int packed = type == 'p' || type == 'P';
int last_char = -1; /* Packed strings need two bytes at a time to encode. */
}
case '\"':
++input_line_pointer; /* -> 1st char of string. */
- start = input_line_pointer;
while (is_a_char (c = next_char_of_string ()))
{
if (!packed)
}
static void
-tic54x_p2align (arg)
- int arg ATTRIBUTE_UNUSED;
+tic54x_p2align (int arg ATTRIBUTE_UNUSED)
{
as_bad (_("p2align not supported on this target"));
}
static void
-tic54x_align_words (arg)
- int arg;
+tic54x_align_words (int arg)
{
/* Only ".align" with no argument is allowed within .struct/.union. */
int count = arg;
/* Initialize multiple-bit fields withing a single word of memory. */
static void
-tic54x_field (ignore)
- int ignore ATTRIBUTE_UNUSED;
+tic54x_field (int ignore ATTRIBUTE_UNUSED)
{
- expressionS exp;
+ expressionS expn;
int size = 16;
char *p;
valueT value;
return;
}
- input_line_pointer = parse_expression (input_line_pointer, &exp);
+ input_line_pointer = parse_expression (input_line_pointer, &expn);
if (*input_line_pointer == ',')
{
}
/* Truncate values to the field width. */
- if (exp.X_op != O_constant)
+ if (expn.X_op != O_constant)
{
/* If the expression value is relocatable, the field size *must*
be 16. */
}
frag_now->tc_frag_data = 0;
- emit_expr (&exp, 2);
+ emit_expr (&expn, 2);
}
else
{
unsigned long fmask = (size == 32) ? 0xFFFFFFFF : (1ul << size) - 1;
- value = exp.X_add_number;
- exp.X_add_number &= fmask;
- if (value != (valueT) exp.X_add_number)
+ value = expn.X_add_number;
+ expn.X_add_number &= fmask;
+ if (value != (valueT) expn.X_add_number)
as_warn (_("field value truncated"));
- value = exp.X_add_number;
+ value = expn.X_add_number;
/* Bits are stored MS first. */
while (size >= 16)
{
available yet. seg_info ()->bss is the next best thing. */
static int
-tic54x_initialized_section (seg)
- segT seg;
+tic54x_initialized_section (segT seg)
{
return !seg_info (seg)->bss;
}
Name is required for uninitialized sections. */
static void
-tic54x_clink (ignored)
- int ignored ATTRIBUTE_UNUSED;
+tic54x_clink (int ignored ATTRIBUTE_UNUSED)
{
segT seg = now_seg;
set to "." instead. */
static void
-tic54x_set_default_include (dot)
- int dot;
+tic54x_set_default_include (int dot)
{
char *dir = ".";
char *tmp = NULL;
Entering/exiting included/copied file clears all local labels. */
static void
-tic54x_include (ignored)
- int ignored ATTRIBUTE_UNUSED;
+tic54x_include (int ignored ATTRIBUTE_UNUSED)
{
char newblock[] = " .newblock\n";
char *filename;
}
static void
-tic54x_message (type)
- int type;
+tic54x_message (int type)
{
char *msg;
char c;
run address (vma). */
static void
-tic54x_label (ignored)
- int ignored ATTRIBUTE_UNUSED;
+tic54x_label (int ignored ATTRIBUTE_UNUSED)
{
char *name = input_line_pointer;
symbolS *symbolP;
absolute local symbols. */
static void
-tic54x_mmregs (ignored)
- int ignored ATTRIBUTE_UNUSED;
+tic54x_mmregs (int ignored ATTRIBUTE_UNUSED)
{
symbol *sym;
Count defaults to 1024. */
static void
-tic54x_loop (count)
- int count;
+tic54x_loop (int count)
{
ILLEGAL_WITHIN_STRUCT ();
/* Normally, endloop gets eaten by the preceding loop. */
static void
-tic54x_endloop (ignore)
- int ignore ATTRIBUTE_UNUSED;
+tic54x_endloop (int ignore ATTRIBUTE_UNUSED)
{
as_bad (_("ENDLOOP without corresponding LOOP"));
ignore_rest_of_line ();
/* .break [condition]. */
static void
-tic54x_break (ignore)
- int ignore ATTRIBUTE_UNUSED;
+tic54x_break (int ignore ATTRIBUTE_UNUSED)
{
int cond = 1;
}
static void
-set_address_mode (mode)
- int mode;
+set_address_mode (int mode)
{
amode = mode;
if (mode == far_mode)
static int address_mode_needs_set = 1;
static void
-tic54x_address_mode (mode)
- int mode;
+tic54x_address_mode (int mode)
{
if (assembly_begun && amode != (unsigned) mode)
{
Designate initialized sections for blocking. */
static void
-tic54x_sblock (ignore)
- int ignore ATTRIBUTE_UNUSED;
+tic54x_sblock (int ignore ATTRIBUTE_UNUSED)
{
int c = ',';
symbols assigned with .set/.equ may not be redefined. */
static void
-tic54x_set (ignore)
- int ignore ATTRIBUTE_UNUSED;
+tic54x_set (int ignore ATTRIBUTE_UNUSED)
{
symbolS *symbolP;
char *name;
List false conditional blocks. */
static void
-tic54x_fclist (show)
- int show;
+tic54x_fclist (int show)
{
if (show)
listing &= ~LISTING_NOCOND;
}
static void
-tic54x_sslist (show)
- int show;
+tic54x_sslist (int show)
{
ILLEGAL_WITHIN_STRUCT ();
Define a substitution string to be local to a macro. */
static void
-tic54x_var (ignore)
- int ignore ATTRIBUTE_UNUSED;
+tic54x_var (int ignore ATTRIBUTE_UNUSED)
{
static char empty[] = "";
char *name;
FIXME need to try the source file directory as well. */
static void
-tic54x_mlib (ignore)
- int ignore ATTRIBUTE_UNUSED;
+tic54x_mlib (int ignore ATTRIBUTE_UNUSED)
{
char *filename;
char *path;
};
int
-md_parse_option (c, arg)
- int c;
- char *arg;
+md_parse_option (int c, char *arg)
{
switch (c)
{
deleting the local label hash between macro invocations. */
void
-tic54x_macro_start ()
+tic54x_macro_start (void)
{
++macro_level;
subsym_hash[macro_level] = hash_new ();
}
void
-tic54x_macro_info (macro)
- const macro_entry *macro;
+tic54x_macro_info (const macro_entry *macro)
{
const formal_entry *entry;
/* Get rid of this macro's .var's, arguments, and local labels. */
void
-tic54x_macro_end ()
+tic54x_macro_end (void)
{
hash_die (subsym_hash[macro_level]);
subsym_hash[macro_level] = NULL;
}
static int
-subsym_symlen (a, ignore)
- char *a;
- char *ignore ATTRIBUTE_UNUSED;
+subsym_symlen (char *a, char *ignore ATTRIBUTE_UNUSED)
{
return strlen (a);
}
/* Compare symbol A to string B. */
static int
-subsym_symcmp (a, b)
- char *a;
- char *b;
+subsym_symcmp (char *a, char *b)
{
return strcmp (a, b);
}
assumes b is an integer char value as a string. Index is one-based. */
static int
-subsym_firstch (a, b)
- char *a;
- char *b;
+subsym_firstch (char *a, char *b)
{
int val = atoi (b);
char *tmp = strchr (a, val);
/* Similar to firstch, but returns index of last occurrence of B in A. */
static int
-subsym_lastch (a, b)
- char *a;
- char *b;
+subsym_lastch (char *a, char *b)
{
int val = atoi (b);
char *tmp = strrchr (a, val);
symbol table). */
static int
-subsym_isdefed (a, ignore)
- char *a;
- char *ignore ATTRIBUTE_UNUSED;
+subsym_isdefed (char *a, char *ignore ATTRIBUTE_UNUSED)
{
symbolS *symbolP = symbol_find (a);
symbols, unsubstituted. */
static int
-subsym_ismember (sym, list)
- char *sym;
- char *list;
+subsym_ismember (char *sym, char *list)
{
char *elem, *ptr, *listv;
5 if decimal. */
static int
-subsym_iscons (a, ignore)
- char *a;
- char *ignore ATTRIBUTE_UNUSED;
+subsym_iscons (char *a, char *ignore ATTRIBUTE_UNUSED)
{
- expressionS exp;
+ expressionS expn;
- parse_expression (a, &exp);
+ parse_expression (a, &expn);
- if (exp.X_op == O_constant)
+ if (expn.X_op == O_constant)
{
int len = strlen (a);
/* Return 1 if A is a valid symbol name. Expects string input. */
static int
-subsym_isname (a, ignore)
- char *a;
- char *ignore ATTRIBUTE_UNUSED;
+subsym_isname (char *a, char *ignore ATTRIBUTE_UNUSED)
{
if (!is_name_beginner (*a))
return 0;
Note this does not recognize "A" or "B" accumulators. */
static int
-subsym_isreg (a, ignore)
- char *a;
- char *ignore ATTRIBUTE_UNUSED;
+subsym_isreg (char *a, char *ignore ATTRIBUTE_UNUSED)
{
if (hash_find (reg_hash, a))
return 1;
/* Return the structure size, given the stag. */
static int
-subsym_structsz (name, ignore)
- char *name;
- char *ignore ATTRIBUTE_UNUSED;
+subsym_structsz (char *name, char *ignore ATTRIBUTE_UNUSED)
{
struct stag *stag = (struct stag *) hash_find (stag_hash, name);
return zero, we punt and return zero. */
static int
-subsym_structacc (stag_name, ignore)
- char *stag_name ATTRIBUTE_UNUSED;
- char *ignore ATTRIBUTE_UNUSED;
+subsym_structacc (char *stag_name ATTRIBUTE_UNUSED,
+ char *ignore ATTRIBUTE_UNUSED)
{
return 0;
}
static float
-math_ceil (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_ceil (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) ceil (arg1);
}
static float
-math_cvi (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_cvi (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (int) arg1;
}
static float
-math_floor (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_floor (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) floor (arg1);
}
static float
-math_fmod (arg1, arg2)
- float arg1;
- float arg2;
+math_fmod (float arg1, float arg2)
{
return (int) arg1 % (int) arg2;
}
static float
-math_int (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_int (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return ((float) ((int) arg1)) == arg1;
}
static float
-math_round (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_round (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return arg1 > 0 ? (int) (arg1 + 0.5) : (int) (arg1 - 0.5);
}
static float
-math_sgn (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_sgn (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (arg1 < 0) ? -1 : (arg1 ? 1 : 0);
}
static float
-math_trunc (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_trunc (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (int) arg1;
}
static float
-math_acos (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_acos (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) acos (arg1);
}
static float
-math_asin (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_asin (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) asin (arg1);
}
static float
-math_atan (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_atan (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) atan (arg1);
}
static float
-math_atan2 (arg1, arg2)
- float arg1;
- float arg2;
+math_atan2 (float arg1, float arg2)
{
return (float) atan2 (arg1, arg2);
}
static float
-math_cosh (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_cosh (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) cosh (arg1);
}
static float
-math_cos (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_cos (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) cos (arg1);
}
static float
-math_cvf (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_cvf (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) arg1;
}
static float
-math_exp (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_exp (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) exp (arg1);
}
static float
-math_fabs (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_fabs (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) fabs (arg1);
}
/* expr1 * 2^expr2. */
static float
-math_ldexp (arg1, arg2)
- float arg1;
- float arg2;
+math_ldexp (float arg1, float arg2)
{
return arg1 * (float) pow (2.0, arg2);
}
static float
-math_log10 (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_log10 (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) log10 (arg1);
}
static float
-math_log (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_log (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) log (arg1);
}
static float
-math_max (arg1, arg2)
- float arg1;
- float arg2;
+math_max (float arg1, float arg2)
{
return (arg1 > arg2) ? arg1 : arg2;
}
static float
-math_min (arg1, arg2)
- float arg1;
- float arg2;
+math_min (float arg1, float arg2)
{
return (arg1 < arg2) ? arg1 : arg2;
}
static float
-math_pow (arg1, arg2)
- float arg1;
- float arg2;
+math_pow (float arg1, float arg2)
{
return (float) pow (arg1, arg2);
}
static float
-math_sin (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_sin (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) sin (arg1);
}
static float
-math_sinh (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_sinh (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) sinh (arg1);
}
static float
-math_sqrt (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_sqrt (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) sqrt (arg1);
}
static float
-math_tan (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_tan (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) tan (arg1);
}
static float
-math_tanh (arg1, ignore)
- float arg1;
- float ignore ATTRIBUTE_UNUSED;
+math_tanh (float arg1, float ignore ATTRIBUTE_UNUSED)
{
return (float) tanh (arg1);
}
typedef struct
{
char *name;
- int (*proc) PARAMS ((char *, char *));
+ int (*proc) (char *, char *);
int nargs;
} subsym_proc_entry;
typedef struct
{
char *name;
- float (*proc) PARAMS ((float, float));
+ float (*proc) (float, float);
int nargs;
int int_return;
} math_proc_entry;
};
void
-md_begin ()
+md_begin (void)
{
- template *tm;
+ insn_template *tm;
symbol *sym;
const subsym_proc_entry *subsym_proc;
const math_proc_entry *math_proc;
}
op_hash = hash_new ();
- for (tm = (template *) tic54x_optab; tm->name; tm++)
+ for (tm = (insn_template *) tic54x_optab; tm->name; tm++)
{
if (hash_find (op_hash, tm->name))
continue;
tm->name, hash_err);
}
parop_hash = hash_new ();
- for (tm = (template *) tic54x_paroptab; tm->name; tm++)
+ for (tm = (insn_template *) tic54x_paroptab; tm->name; tm++)
{
if (hash_find (parop_hash, tm->name))
continue;
}
static int
-is_accumulator (operand)
- struct opstruct *operand;
+is_accumulator (struct opstruct *operand)
{
return strcasecmp (operand->buf, "a") == 0
|| strcasecmp (operand->buf, "b") == 0;
the next array. */
static int
-get_operands (operands, line)
- struct opstruct operands[];
- char *line;
+get_operands (struct opstruct operands[], char *line)
{
char *lptr = line;
int numexp = 0;
{
if (paren_not_balanced)
{
- as_bad ("Unbalanced parenthesis in operand %d", numexp);
+ as_bad (_("Unbalanced parenthesis in operand %d"), numexp);
return -1;
}
else
{
if (expecting_operand || *lptr == ',')
{
- as_bad ("Expecting operand after ','");
+ as_bad (_("Expecting operand after ','"));
return -1;
}
}
{
if (*++lptr == '\0')
{
- as_bad ("Expecting operand after ','");
+ as_bad (_("Expecting operand after ','"));
return -1;
}
expecting_operand = 1;
;
if (!is_end_of_line[(int) *lptr])
{
- as_bad ("Extra junk on line");
+ as_bad (_("Extra junk on line"));
return -1;
}
/* Predicates for different operand types. */
static int
-is_immediate (operand)
- struct opstruct *operand;
+is_immediate (struct opstruct *operand)
{
return *operand->buf == '#';
}
and must *not* have the '#' prefix. */
static int
-is_absolute (operand)
- struct opstruct *operand;
+is_absolute (struct opstruct *operand)
{
return operand->exp.X_op == O_constant && !is_immediate (operand);
}
/* Is this an indirect operand? */
static int
-is_indirect (operand)
- struct opstruct *operand;
+is_indirect (struct opstruct *operand)
{
return operand->buf[0] == '*';
}
/* Is this a valid dual-memory operand? */
static int
-is_dual (operand)
- struct opstruct *operand;
+is_dual (struct opstruct *operand)
{
if (is_indirect (operand) && strncasecmp (operand->buf, "*ar", 3) == 0)
{
}
static int
-is_mmreg (operand)
- struct opstruct *operand;
+is_mmreg (struct opstruct *operand)
{
return (is_absolute (operand)
|| is_immediate (operand)
}
static int
-is_type (operand, type)
- struct opstruct *operand;
- enum optype type;
+is_type (struct opstruct *operand, enum optype type)
{
switch (type)
{
}
static int
-operands_match (insn, operands, opcount, refoptype, minops, maxops)
- tic54x_insn *insn;
- struct opstruct *operands;
- int opcount;
- const enum optype *refoptype;
- int minops;
- int maxops;
+operands_match (tic54x_insn *insn,
+ struct opstruct *operands,
+ int opcount,
+ const enum optype *refoptype,
+ int minops,
+ int maxops)
{
int op = 0, refop = 0;
2 for the upper 7 bits of a 23-bit address (LDX). */
static int
-encode_dmad (insn, operand, xpc_code)
- tic54x_insn *insn;
- struct opstruct *operand;
- int xpc_code;
+encode_dmad (tic54x_insn *insn, struct opstruct *operand, int xpc_code)
{
int op = 1 + insn->is_lkaddr;
/* 7-bit direct address encoding. */
static int
-encode_address (insn, operand)
- tic54x_insn *insn;
- struct opstruct *operand;
+encode_address (tic54x_insn *insn, struct opstruct *operand)
{
/* Assumes that dma addresses are *always* in word 0 of the opcode. */
insn->opcode[0].addr_expr = operand->exp;
}
static int
-encode_indirect (insn, operand)
- tic54x_insn *insn;
- struct opstruct *operand;
+encode_indirect (tic54x_insn *insn, struct opstruct *operand)
{
int arf;
int mod;
}
static int
-encode_integer (insn, operand, which, min, max, mask)
- tic54x_insn *insn;
- struct opstruct *operand;
- int which;
- int min;
- int max;
- unsigned short mask;
+encode_integer (tic54x_insn *insn,
+ struct opstruct *operand,
+ int which,
+ int min,
+ int max,
+ unsigned short mask)
{
long parse, integer;
}
static int
-encode_condition (insn, operand)
- tic54x_insn *insn;
- struct opstruct *operand;
+encode_condition (tic54x_insn *insn, struct opstruct *operand)
{
symbol *cc = (symbol *) hash_find (cc_hash, operand->buf);
if (!cc)
}
static int
-encode_cc3 (insn, operand)
- tic54x_insn *insn;
- struct opstruct *operand;
+encode_cc3 (tic54x_insn *insn, struct opstruct *operand)
{
symbol *cc3 = (symbol *) hash_find (cc3_hash, operand->buf);
int value = cc3 ? cc3->value : operand->exp.X_add_number << 8;
}
static int
-encode_arx (insn, operand)
- tic54x_insn *insn;
- struct opstruct *operand;
+encode_arx (tic54x_insn *insn, struct opstruct *operand)
{
int arf = strlen (operand->buf) >= 3 ? operand->buf[2] - '0' : -1;
}
static int
-encode_cc2 (insn, operand)
- tic54x_insn *insn;
- struct opstruct *operand;
+encode_cc2 (tic54x_insn *insn, struct opstruct *operand)
{
symbol *cc2 = (symbol *) hash_find (cc2_hash, operand->buf);
}
static int
-encode_operand (insn, type, operand)
- tic54x_insn *insn;
- enum optype type;
- struct opstruct *operand;
+encode_operand (tic54x_insn *insn, enum optype type, struct opstruct *operand)
{
int ext = (insn->tm->flags & FL_EXT) != 0;
}
static void
-emit_insn (insn)
- tic54x_insn *insn;
+emit_insn (tic54x_insn *insn)
{
int i;
flagword oldflags = bfd_get_section_flags (stdoutput, now_seg);
return the total number of words used by the instruction. */
static int
-build_insn (insn)
- tic54x_insn *insn;
+build_insn (tic54x_insn *insn)
{
int i;
}
static int
-optimize_insn (insn)
- tic54x_insn *insn;
+optimize_insn (tic54x_insn *insn)
{
/* Optimize some instructions, helping out the brain-dead programmer. */
#define is_zero(op) ((op).exp.X_op == O_constant && (op).exp.X_add_number == 0)
/* Find a matching template if possible, and get the operand strings. */
static int
-tic54x_parse_insn (insn, line)
- tic54x_insn *insn;
- char *line;
+tic54x_parse_insn (tic54x_insn *insn, char *line)
{
- insn->tm = (template *) hash_find (op_hash, insn->mnemonic);
+ insn->tm = (insn_template *) hash_find (op_hash, insn->mnemonic);
if (!insn->tm)
{
as_bad (_("Unrecognized instruction \"%s\""), insn->mnemonic);
/* SUCCESS! now try some optimizations. */
if (optimize_insn (insn))
{
- insn->tm = (template *) hash_find (op_hash,
- insn->mnemonic);
+ insn->tm = (insn_template *) hash_find (op_hash,
+ insn->mnemonic);
continue;
}
Look for a subsequent line starting with "||". */
static int
-next_line_shows_parallel (next_line)
- char *next_line;
+next_line_shows_parallel (char *next_line)
{
/* Look for the second half. */
while (ISSPACE (*next_line))
}
static int
-tic54x_parse_parallel_insn_firstline (insn, line)
- tic54x_insn *insn;
- char *line;
+tic54x_parse_parallel_insn_firstline (tic54x_insn *insn, char *line)
{
- insn->tm = (template *) hash_find (parop_hash, insn->mnemonic);
+ insn->tm = (insn_template *) hash_find (parop_hash, insn->mnemonic);
if (!insn->tm)
{
as_bad (_("Unrecognized parallel instruction \"%s\""),
/* Parse the second line of a two-line parallel instruction. */
static int
-tic54x_parse_parallel_insn_lastline (insn, line)
- tic54x_insn *insn;
- char *line;
+tic54x_parse_parallel_insn_lastline (tic54x_insn *insn, char *line)
{
int valid_mnemonic = 0;
replacement on the value. */
static char *
-subsym_get_arg (line, terminators, str, nosub)
- char *line;
- char *terminators;
- char **str;
- int nosub;
+subsym_get_arg (char *line, char *terminators, char **str, int nosub)
{
char *ptr = line;
char *endp;
that's compatible w/TI's assembler. */
static void
-subsym_create_or_replace (name, value)
- char *name;
- char *value;
+subsym_create_or_replace (char *name, char *value)
{
int i;
outwards. */
static char *
-subsym_lookup (name, nest_level)
- char *name;
- int nest_level;
+subsym_lookup (char *name, int nest_level)
{
char *value = hash_find (subsym_hash[nest_level], name);
If FORCED is set, look for forced substitutions of the form ':SYMBOL:'. */
static char *
-subsym_substitute (line, forced)
- char * line;
- int forced;
+subsym_substitute (char *line, int forced)
{
/* For each apparent symbol, see if it's a substitution symbol, and if so,
replace it in the input. */
++ptr;
if (math_entry != NULL)
{
- float arg1, arg2 = 0;
+ float farg1, farg2 = 0;
volatile float fresult;
- arg1 = (float) strtod (ptr, &ptr);
+ farg1 = (float) strtod (ptr, &ptr);
if (math_entry->nargs == 2)
{
if (*ptr++ != ',')
as_bad (_("Expecting second argument"));
break;
}
- arg2 = (float) strtod (ptr, &ptr);
+ farg2 = (float) strtod (ptr, &ptr);
}
- fresult = (*math_entry->proc) (arg1, arg2);
+ fresult = (*math_entry->proc) (farg1, farg2);
value = xmalloc (128);
if (math_entry->int_return)
sprintf (value, "%d", (int) fresult);
{
hash_insert (subsym_recurse_hash, name, name);
value = subsym_substitute (value, macro_level > 0);
- hash_delete (subsym_recurse_hash, name);
+ hash_delete (subsym_recurse_hash, name, FALSE);
}
/* Temporarily zero-terminate where the symbol started. */
returns the new buffer limit. */
void
-tic54x_start_line_hook ()
+tic54x_start_line_hook (void)
{
char *line, *endp;
char *replacement = NULL;
machine dependent instruction. This function is supposed to emit
the frags/bytes it assembles to. */
void
-md_assemble (line)
- char *line;
+md_assemble (char *line)
{
static int repeat_slot = 0;
static int delay_slots = 0; /* How many delay slots left to fill? */
a ".file" symbol. */
void
-tic54x_adjust_symtab ()
+tic54x_adjust_symtab (void)
{
if (symbol_rootP == NULL
|| S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
FIXME -- obviously this isn't done yet. These locals still show up in the
symbol table. */
void
-tic54x_define_label (sym)
- symbolS *sym;
+tic54x_define_label (symbolS *sym)
{
/* Just in case we need this later; note that this is not necessarily the
same thing as line_label...
/* Try to parse something that normal parsing failed at. */
symbolS *
-tic54x_undefined_symbol (name)
- char *name;
+tic54x_undefined_symbol (char *name)
{
symbol *sym;
it. */
int
-tic54x_parse_name (name, exp)
- char *name ATTRIBUTE_UNUSED;
- expressionS *exp ATTRIBUTE_UNUSED;
+tic54x_parse_name (char *name ATTRIBUTE_UNUSED,
+ expressionS *expn ATTRIBUTE_UNUSED)
{
return 0;
}
}
arelent *
-tc_gen_reloc (section, fixP)
- asection *section;
- fixS *fixP;
+tc_gen_reloc (asection *section, fixS *fixP)
{
arelent *rel;
bfd_reloc_code_real_type code = fixP->fx_r_type;
/* Handle cons expressions. */
void
-tic54x_cons_fix_new (frag, where, octets, exp)
- fragS *frag;
- int where;
- int octets;
- expressionS *exp;
+tic54x_cons_fix_new (fragS *frag, int where, int octets, expressionS *expn)
{
bfd_reloc_code_real_type r;
r = BFD_RELOC_32;
break;
}
- fix_new_exp (frag, where, octets, exp, 0, r);
+ fix_new_exp (frag, where, octets, expn, 0, r);
}
/* Attempt to simplify or even eliminate a fixup.
If fixp->fx_addsy is non-NULL, we'll have to generate a reloc entry. */
void
-md_apply_fix (fixP, valP, seg)
- fixS *fixP;
- valueT * valP;
- segT seg ATTRIBUTE_UNUSED;
+md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
{
char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
valueT val = * valP;
don't need to do anything here, since BFD does the proper encoding. */
valueT
-md_section_align (segment, section_size)
- segT segment ATTRIBUTE_UNUSED;
- valueT section_size;
+md_section_align (segT segment ATTRIBUTE_UNUSED, valueT section_size)
{
return section_size;
}
long
-md_pcrel_from (fixP)
- fixS *fixP ATTRIBUTE_UNUSED;
+md_pcrel_from (fixS *fixP ATTRIBUTE_UNUSED)
{
return 0;
}
first. */
void
-tic54x_number_to_chars (buf, val, n)
- char *buf;
- valueT val;
- int n;
+tic54x_number_to_chars (char *buf, valueT val, int n)
{
if (n != 4)
number_to_chars_littleendian (buf, val, n);
}
int
-tic54x_estimate_size_before_relax (frag, seg)
- fragS *frag ATTRIBUTE_UNUSED;
- segT seg ATTRIBUTE_UNUSED;
+tic54x_estimate_size_before_relax (fragS *frag ATTRIBUTE_UNUSED,
+ segT seg ATTRIBUTE_UNUSED)
{
return 0;
}
to symbols being in different frags. return number of octets added. */
int
-tic54x_relax_frag (frag, stretch)
- fragS *frag;
- long stretch ATTRIBUTE_UNUSED;
+tic54x_relax_frag (fragS *frag, long stretch ATTRIBUTE_UNUSED)
{
symbolS *sym = frag->fr_symbol;
int growth = 0;
}
void
-tic54x_convert_frag (abfd, seg, frag)
- bfd *abfd ATTRIBUTE_UNUSED;
- segT seg ATTRIBUTE_UNUSED;
- fragS *frag;
+tic54x_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
+ segT seg ATTRIBUTE_UNUSED,
+ fragS *frag)
{
/* Offset is in bytes. */
frag->fr_offset = (frag->fr_next->fr_address
Don't allow labels to start with '.' */
int
-tic54x_start_label (c, rest)
- int c;
- char *rest;
+tic54x_start_label (int c, char *rest)
{
/* If within .struct/.union, no auto line labels, please. */
if (current_stag != NULL)
projects / deliverable / binutils-gdb.git / blobdiff