/* symbols.c -symbol table-
- Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
- 2011 Free Software Foundation, Inc.
+ Copyright (C) 1987-2016 Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
const char * an_external_name;
#endif
-static char *save_symbol_name (const char *);
+static const char *save_symbol_name (const char *);
static void fb_label_init (void);
static long dollar_label_instance (long);
static long fb_label_instance (long);
/* Save a symbol name on a permanent obstack, and convert it according
to the object file format. */
-static char *
+static const char *
save_symbol_name (const char *name)
{
- unsigned int name_length;
+ size_t name_length;
char *ret;
name_length = strlen (name) + 1; /* +1 for \0. */
valueT valu, /* Symbol value. */
fragS *frag /* Associated fragment. */)
{
- char *preserved_copy_of_name;
+ const char *preserved_copy_of_name;
symbolS *symbolP;
preserved_copy_of_name = save_symbol_name (name);
changes its argument to the real symbol. */
#define LOCAL_SYMBOL_CHECK(s) \
- (s->bsym == NULL \
+ (s->sy_flags.sy_local_symbol \
? (local_symbol_converted_p ((struct local_symbol *) s) \
? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
0) \
struct local_symbol *
local_symbol_make (const char *name, segT section, valueT val, fragS *frag)
{
- char *name_copy;
+ const char *name_copy;
struct local_symbol *ret;
++local_symbol_count;
name_copy = save_symbol_name (name);
ret = (struct local_symbol *) obstack_alloc (¬es, sizeof *ret);
- ret->lsy_marker = NULL;
+ ret->lsy_flags.sy_local_symbol = 1;
+ ret->lsy_flags.sy_resolved = 0;
ret->lsy_name = name_copy;
ret->lsy_section = section;
local_symbol_set_frag (ret, frag);
{
symbolS *ret;
- gas_assert (locsym->lsy_marker == NULL);
+ gas_assert (locsym->lsy_flags.sy_local_symbol);
if (local_symbol_converted_p (locsym))
return local_symbol_get_real_symbol (locsym);
local_symbol_get_frag (locsym));
if (local_symbol_resolved_p (locsym))
- ret->sy_resolved = 1;
+ ret->sy_flags.sy_resolved = 1;
/* Local symbols are always either defined or used. */
- ret->sy_used = 1;
+ ret->sy_flags.sy_used = 1;
#ifdef TC_LOCAL_SYMFIELD_CONVERT
TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
const char *sym_name /* Symbol name, as a cannonical string. */
/* We copy this string: OK to alter later. */)
{
- register symbolS *symbolP; /* Symbol we are working with. */
+ symbolS *symbolP; /* Symbol we are working with. */
/* Sun local labels go out of scope whenever a non-local symbol is
defined. */
}
#endif /* WORKING_DOT_WORD */
+#ifdef obj_frob_colon
+ obj_frob_colon (sym_name);
+#endif
+
if ((symbolP = symbol_find (sym_name)) != 0)
{
S_CLEAR_WEAKREFR (symbolP);
symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
symbolP->sy_frag = &zero_address_frag;
S_SET_SEGMENT (symbolP, expr_section);
- symbolP->sy_mri_common = 1;
+ symbolP->sy_flags.sy_mri_common = 1;
}
#ifdef tc_frob_label
void
symbol_table_insert (symbolS *symbolP)
{
- register const char *error_string;
+ const char *error_string;
know (symbolP);
know (S_GET_NAME (symbolP));
symbolS *
symbol_find_or_make (const char *name)
{
- register symbolS *symbolP;
+ symbolS *symbolP;
symbolP = symbol_find (name);
symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
- if (symbolP->sy_forward_ref)
+ if (symbolP->sy_flags.sy_forward_ref)
is_forward = 1;
if (is_forward)
/* Re-using sy_resolving here, as this routine cannot get called from
symbol resolution code. */
- if ((symbolP->bsym->section == expr_section || symbolP->sy_forward_ref)
- && !symbolP->sy_resolving)
+ if ((symbolP->bsym->section == expr_section
+ || symbolP->sy_flags.sy_forward_ref)
+ && !symbolP->sy_flags.sy_resolving)
{
- symbolP->sy_resolving = 1;
+ symbolP->sy_flags.sy_resolving = 1;
add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);
- symbolP->sy_resolving = 0;
+ symbolP->sy_flags.sy_resolving = 0;
}
- if (symbolP->sy_forward_ref
+ if (symbolP->sy_flags.sy_forward_ref
|| add_symbol != symbolP->sy_value.X_add_symbol
|| op_symbol != symbolP->sy_value.X_op_symbol)
{
if (symbolP != &dot_symbol)
{
symbolP = symbol_clone (symbolP, 0);
- symbolP->sy_resolving = 0;
+ symbolP->sy_flags.sy_resolving = 0;
}
else
{
symbolS *
symbol_find_noref (const char *name, int noref)
{
+ symbolS * result;
+ char * copy = NULL;
+
#ifdef tc_canonicalize_symbol_name
{
- char *copy;
- size_t len = strlen (name) + 1;
-
- copy = (char *) alloca (len);
- memcpy (copy, name, len);
+ copy = xstrdup (name);
name = tc_canonicalize_symbol_name (copy);
}
#endif
if (! symbols_case_sensitive)
{
- char *copy;
const char *orig;
+ char *copy2 = NULL;
unsigned char c;
orig = name;
- name = copy = (char *) alloca (strlen (name) + 1);
+ if (copy != NULL)
+ copy2 = copy;
+ name = copy = XNEWVEC (char, strlen (name) + 1);
while ((c = *orig++) != '\0')
- {
- *copy++ = TOUPPER (c);
- }
+ *copy++ = TOUPPER (c);
*copy = '\0';
+
+ if (copy2 != NULL)
+ free (copy2);
+ copy = (char *) name;
}
- return symbol_find_exact_noref (name, noref);
+ result = symbol_find_exact_noref (name, noref);
+ if (copy != NULL)
+ free (copy);
+ return result;
}
/* Once upon a time, symbols were kept in a singly linked list. At
for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
{
gas_assert (symbolP->bsym != NULL);
+ gas_assert (symbolP->sy_flags.sy_local_symbol == 0);
gas_assert (symbolP->sy_next->sy_previous == symbolP);
}
if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
|| S_IS_LOCAL (symp->sy_value.X_add_symbol))
- &&
+ &&
(S_IS_COMMON (symp->sy_value.X_op_symbol)
|| S_IS_LOCAL (symp->sy_value.X_op_symbol))
&& S_GET_SEGMENT (symp->sy_value.X_op_symbol) != expr_section)
return 0;
break;
-
+
default:
break;
}
static void
report_op_error (symbolS *symp, symbolS *left, operatorT op, symbolS *right)
{
- char *file;
+ const char *file;
unsigned int line;
segT seg_left = left ? S_GET_SEGMENT (left) : 0;
segT seg_right = S_GET_SEGMENT (right);
return final_val;
}
- if (symp->sy_resolved)
+ if (symp->sy_flags.sy_resolved)
{
if (symp->sy_value.X_op == O_constant)
return (valueT) symp->sy_value.X_add_number;
resolved = 0;
final_seg = S_GET_SEGMENT (symp);
- if (symp->sy_resolving)
+ if (symp->sy_flags.sy_resolving)
{
if (finalize_syms)
as_bad (_("symbol definition loop encountered at `%s'"),
if (symp->bsym->flags & BSF_SRELC)
relc_symbol->bsym->flags |= BSF_SRELC;
else
- relc_symbol->bsym->flags |= BSF_RELC;
+ relc_symbol->bsym->flags |= BSF_RELC;
/* symp->bsym->flags |= BSF_RELC; */
copy_symbol_attributes (symp, relc_symbol);
symp->sy_value.X_op = O_symbol;
operatorT op;
int move_seg_ok;
- symp->sy_resolving = 1;
+ symp->sy_flags.sy_resolving = 1;
/* Help out with CSE. */
add_symbol = symp->sy_value.X_add_symbol;
}
}
- if (symp->sy_mri_common)
+ if (symp->sy_flags.sy_mri_common)
{
/* This is a symbol inside an MRI common section. The
relocation routines are going to handle it specially.
final_seg = seg_left;
final_val = 0;
resolved = symbol_resolved_p (add_symbol);
- symp->sy_resolving = 0;
+ symp->sy_flags.sy_resolving = 0;
goto exit_dont_set_value;
}
else if (finalize_syms
final_seg = seg_left;
final_val += symp->sy_frag->fr_address + left;
resolved = symbol_resolved_p (add_symbol);
- symp->sy_resolving = 0;
+ symp->sy_flags.sy_resolving = 0;
goto exit_dont_set_value;
}
else
resolved = symbol_resolved_p (add_symbol);
if (S_IS_WEAKREFR (symp))
- goto exit_dont_set_value;
+ {
+ symp->sy_flags.sy_resolving = 0;
+ goto exit_dont_set_value;
+ }
break;
case O_uminus:
already issued a warning about using a bad symbol. */
if (seg_right == absolute_section && finalize_syms)
{
- char *file;
+ const char *file;
unsigned int line;
if (expr_symbol_where (symp, &file, &line))
break;
}
- symp->sy_resolving = 0;
+ symp->sy_flags.sy_resolving = 0;
}
if (finalize_syms)
if (finalize_syms)
{
if (resolved)
- symp->sy_resolved = 1;
+ symp->sy_flags.sy_resolved = 1;
else if (S_GET_SEGMENT (symp) != expr_section)
{
as_bad (_("can't resolve value for symbol `%s'"),
S_GET_NAME (symp));
- symp->sy_resolved = 1;
+ symp->sy_flags.sy_resolved = 1;
}
}
{
expressionS exp = symbolP->sy_value;
- if (!symbolP->sy_resolved && exp.X_op != O_illegal)
+ if (!symbolP->sy_flags.sy_resolved && exp.X_op != O_illegal)
{
int resolved;
- if (symbolP->sy_resolving)
+ if (symbolP->sy_flags.sy_resolving)
return 0;
- symbolP->sy_resolving = 1;
+ symbolP->sy_flags.sy_resolving = 1;
resolved = resolve_expression (&exp);
- symbolP->sy_resolving = 0;
+ symbolP->sy_flags.sy_resolving = 0;
if (!resolved)
return 0;
if (dollar_labels == NULL)
{
- dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
- dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
- dollar_label_defines = (char *) xmalloc (DOLLAR_LABEL_BUMP_BY);
+ dollar_labels = XNEWVEC (long, DOLLAR_LABEL_BUMP_BY);
+ dollar_label_instances = XNEWVEC (long, DOLLAR_LABEL_BUMP_BY);
+ dollar_label_defines = XNEWVEC (char, DOLLAR_LABEL_BUMP_BY);
dollar_label_max = DOLLAR_LABEL_BUMP_BY;
dollar_label_count = 0;
}
else if (dollar_label_count == dollar_label_max)
{
dollar_label_max += DOLLAR_LABEL_BUMP_BY;
- dollar_labels = (long *) xrealloc ((char *) dollar_labels,
- dollar_label_max * sizeof (long));
- dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
- dollar_label_max * sizeof (long));
- dollar_label_defines = (char *) xrealloc (dollar_label_defines, dollar_label_max);
+ dollar_labels = XRESIZEVEC (long, dollar_labels, dollar_label_max);
+ dollar_label_instances = XRESIZEVEC (long, dollar_label_instances,
+ dollar_label_max);
+ dollar_label_defines = XRESIZEVEC (char, dollar_label_defines,
+ dollar_label_max);
} /* if we needed to grow */
dollar_labels[dollar_label_count] = label;
of ^A. */
char * /* Return local label name. */
-dollar_label_name (register long n, /* we just saw "n$:" : n a number. */
- register int augend /* 0 for current instance, 1 for new instance. */)
+dollar_label_name (long n, /* we just saw "n$:" : n a number. */
+ int augend /* 0 for current instance, 1 for new instance. */)
{
long i;
/* Returned to caller, then copied. Used for created names ("4f"). */
static char symbol_name_build[24];
- register char *p;
- register char *q;
+ char *p;
+ char *q;
char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
know (n >= 0);
*q = i % 10 + '0';
i /= 10;
}
- while ((*p++ = *--q) != '\0');;
+ while ((*p++ = *--q) != '\0');
/* The label, as a '\0' ended string, starts at symbol_name_build. */
return symbol_name_build;
{
long *i;
- if (label < FB_LABEL_SPECIAL)
+ if ((unsigned long) label < FB_LABEL_SPECIAL)
{
++fb_low_counter[label];
return;
if (fb_labels == NULL)
{
- fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
- fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
+ fb_labels = XNEWVEC (long, FB_LABEL_BUMP_BY);
+ fb_label_instances = XNEWVEC (long, FB_LABEL_BUMP_BY);
fb_label_max = FB_LABEL_BUMP_BY;
fb_label_count = FB_LABEL_SPECIAL;
else if (fb_label_count == fb_label_max)
{
fb_label_max += FB_LABEL_BUMP_BY;
- fb_labels = (long *) xrealloc ((char *) fb_labels,
- fb_label_max * sizeof (long));
- fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
- fb_label_max * sizeof (long));
+ fb_labels = XRESIZEVEC (long, fb_labels, fb_label_max);
+ fb_label_instances = XRESIZEVEC (long, fb_label_instances, fb_label_max);
} /* if we needed to grow */
fb_labels[fb_label_count] = label;
{
long *i;
- if (label < FB_LABEL_SPECIAL)
+ if ((unsigned long) label < FB_LABEL_SPECIAL)
{
return (fb_low_counter[label]);
}
long i;
/* Returned to caller, then copied. Used for created names ("4f"). */
static char symbol_name_build[24];
- register char *p;
- register char *q;
+ char *p;
+ char *q;
char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
know (n >= 0);
*q = i % 10 + '0';
i /= 10;
}
- while ((*p++ = *--q) != '\0');;
+ while ((*p++ = *--q) != '\0');
/* The label, as a '\0' ended string, starts at symbol_name_build. */
return (symbol_name_build);
char *symbol_decode;
int label_number;
int instance_number;
- char *type;
+ const char *type;
const char *message_format;
int lindex = 0;
if (LOCAL_SYMBOL_CHECK (s))
return resolve_symbol_value (s);
- if (!s->sy_resolved)
+ if (!s->sy_flags.sy_resolved)
{
valueT val = resolve_symbol_value (s);
if (!finalize_syms)
if (s->sy_value.X_op != O_constant)
{
- if (! s->sy_resolved
+ if (! s->sy_flags.sy_resolved
|| s->sy_value.X_op != O_symbol
|| (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
as_bad (_("attempt to get value of unresolved symbol `%s'"),
{
if (LOCAL_SYMBOL_CHECK (s))
return 0;
- return s->sy_weakrefr != 0;
+ return s->sy_flags.sy_weakrefr != 0;
}
int
{
if (LOCAL_SYMBOL_CHECK (s))
return 0;
- return s->sy_weakrefd != 0;
+ return s->sy_flags.sy_weakrefd != 0;
}
int
return S_GET_NAME (s) == 0;
}
+int
+S_CAN_BE_REDEFINED (const symbolS *s)
+{
+ if (LOCAL_SYMBOL_CHECK (s))
+ return (local_symbol_get_frag ((struct local_symbol *) s)
+ == &predefined_address_frag);
+ /* Permit register names to be redefined. */
+ return s->bsym->section == reg_section;
+}
+
int
S_IS_VOLATILE (const symbolS *s)
{
if (LOCAL_SYMBOL_CHECK (s))
return 0;
- return s->sy_volatile;
+ return s->sy_flags.sy_volatile;
}
int
{
if (LOCAL_SYMBOL_CHECK (s))
return 0;
- return s->sy_forward_ref;
+ return s->sy_flags.sy_forward_ref;
}
const char *
}
if (s->bsym->flags & BSF_SECTION_SYM)
{
- char * file;
- unsigned int line;
-
/* Do not reassign section symbols. */
- as_where (& file, & line);
- as_warn_where (file, line,
- _("section symbols are already global"));
+ as_warn (_("section symbols are already global"));
return;
}
#ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
{
if (LOCAL_SYMBOL_CHECK (s))
s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_weakrefr = 1;
+ s->sy_flags.sy_weakrefr = 1;
/* If the alias was already used, make sure we mark the target as
used as well, otherwise it might be dropped from the symbol
table. This may have unintended side effects if the alias is
later redirected to another symbol, such as keeping the unused
previous target in the symbol table. Since it will be weak, it's
not a big deal. */
- if (s->sy_used)
+ if (s->sy_flags.sy_used)
symbol_mark_used (s->sy_value.X_add_symbol);
}
{
if (LOCAL_SYMBOL_CHECK (s))
return;
- s->sy_weakrefr = 0;
+ s->sy_flags.sy_weakrefr = 0;
}
void
{
if (LOCAL_SYMBOL_CHECK (s))
s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_weakrefd = 1;
+ s->sy_flags.sy_weakrefd = 1;
S_SET_WEAK (s);
}
{
if (LOCAL_SYMBOL_CHECK (s))
return;
- if (s->sy_weakrefd)
+ if (s->sy_flags.sy_weakrefd)
{
- s->sy_weakrefd = 0;
+ s->sy_flags.sy_weakrefd = 0;
/* If a weakref target symbol is weak, then it was never
referenced directly before, not even in a .global directive,
so decay it to local. If it remains undefined, it will be
{
if (LOCAL_SYMBOL_CHECK (s))
s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_volatile = 1;
+ s->sy_flags.sy_volatile = 1;
}
void
S_CLEAR_VOLATILE (symbolS *s)
{
if (!LOCAL_SYMBOL_CHECK (s))
- s->sy_volatile = 0;
+ s->sy_flags.sy_volatile = 0;
}
void
{
if (LOCAL_SYMBOL_CHECK (s))
s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_forward_ref = 1;
+ s->sy_flags.sy_forward_ref = 1;
}
/* Return the previous symbol in a chain. */
int
symbol_same_p (symbolS *s1, symbolS *s2)
{
- if (s1->bsym == NULL
+ if (s1->sy_flags.sy_local_symbol
&& local_symbol_converted_p ((struct local_symbol *) s1))
s1 = local_symbol_get_real_symbol ((struct local_symbol *) s1);
- if (s2->bsym == NULL
+ if (s2->sy_flags.sy_local_symbol
&& local_symbol_converted_p ((struct local_symbol *) s2))
s2 = local_symbol_get_real_symbol ((struct local_symbol *) s2);
return s1 == s2;
{
if (LOCAL_SYMBOL_CHECK (s))
return;
- s->sy_used = 1;
+ s->sy_flags.sy_used = 1;
if (S_IS_WEAKREFR (s))
symbol_mark_used (s->sy_value.X_add_symbol);
}
{
if (LOCAL_SYMBOL_CHECK (s))
s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_used = 0;
+ s->sy_flags.sy_used = 0;
}
/* Return whether a symbol has been used. */
{
if (LOCAL_SYMBOL_CHECK (s))
return 1;
- return s->sy_used;
+ return s->sy_flags.sy_used;
}
/* Mark a symbol as having been used in a reloc. */
{
if (LOCAL_SYMBOL_CHECK (s))
s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_used_in_reloc = 1;
+ s->sy_flags.sy_used_in_reloc = 1;
}
/* Clear the mark of whether a symbol has been used in a reloc. */
{
if (LOCAL_SYMBOL_CHECK (s))
return;
- s->sy_used_in_reloc = 0;
+ s->sy_flags.sy_used_in_reloc = 0;
}
/* Return whether a symbol has been used in a reloc. */
{
if (LOCAL_SYMBOL_CHECK (s))
return 0;
- return s->sy_used_in_reloc;
+ return s->sy_flags.sy_used_in_reloc;
}
/* Mark a symbol as an MRI common symbol. */
{
if (LOCAL_SYMBOL_CHECK (s))
s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_mri_common = 1;
+ s->sy_flags.sy_mri_common = 1;
}
/* Clear the mark of whether a symbol is an MRI common symbol. */
{
if (LOCAL_SYMBOL_CHECK (s))
return;
- s->sy_mri_common = 0;
+ s->sy_flags.sy_mri_common = 0;
}
/* Return whether a symbol is an MRI common symbol. */
{
if (LOCAL_SYMBOL_CHECK (s))
return 0;
- return s->sy_mri_common;
+ return s->sy_flags.sy_mri_common;
}
/* Mark a symbol as having been written. */
{
if (LOCAL_SYMBOL_CHECK (s))
return;
- s->written = 1;
+ s->sy_flags.sy_written = 1;
}
/* Clear the mark of whether a symbol has been written. */
{
if (LOCAL_SYMBOL_CHECK (s))
return;
- s->written = 0;
+ s->sy_flags.sy_written = 0;
}
/* Return whether a symbol has been written. */
{
if (LOCAL_SYMBOL_CHECK (s))
return 0;
- return s->written;
+ return s->sy_flags.sy_written;
}
/* Mark a symbol has having been resolved. */
local_symbol_mark_resolved ((struct local_symbol *) s);
return;
}
- s->sy_resolved = 1;
+ s->sy_flags.sy_resolved = 1;
}
/* Return whether a symbol has been resolved. */
{
if (LOCAL_SYMBOL_CHECK (s))
return local_symbol_resolved_p ((struct local_symbol *) s);
- return s->sy_resolved;
+ return s->sy_flags.sy_resolved;
}
/* Return whether a symbol is a section symbol. */
#if defined (OBJ_COFF) && defined (TE_PE)
&& ! S_IS_WEAK (s)
#endif
- && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
+ && ((s->sy_flags.sy_resolved && s->sy_value.X_op_symbol != NULL)
|| ! S_IS_DEFINED (s)
|| S_IS_COMMON (s)));
}
memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
#if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
- abs_symbol.bsym = bfd_abs_section.symbol;
+ abs_symbol.bsym = bfd_abs_section_ptr->symbol;
#endif
abs_symbol.sy_value.X_op = O_constant;
abs_symbol.sy_frag = &zero_address_frag;
if (dot_symbol.bsym == NULL)
as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
dot_symbol.bsym->name = ".";
- dot_symbol.sy_forward_ref = 1;
+ dot_symbol.sy_flags.sy_forward_ref = 1;
dot_symbol.sy_value.X_op = O_constant;
}
\f
fprintf (file, " frag ");
fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym->sy_frag));
}
- if (sym->written)
+ if (sym->sy_flags.sy_written)
fprintf (file, " written");
- if (sym->sy_resolved)
+ if (sym->sy_flags.sy_resolved)
fprintf (file, " resolved");
- else if (sym->sy_resolving)
+ else if (sym->sy_flags.sy_resolving)
fprintf (file, " resolving");
- if (sym->sy_used_in_reloc)
+ if (sym->sy_flags.sy_used_in_reloc)
fprintf (file, " used-in-reloc");
- if (sym->sy_used)
+ if (sym->sy_flags.sy_used)
fprintf (file, " used");
if (S_IS_LOCAL (sym))
fprintf (file, " local");
sname_len = strlen (sname);
typetag = symbol_section_p (sym) ? 'S' : 's';
- terminal = xmalloc (1 /* S or s */
- + 8 /* sname_len in decimal */
- + 1 /* _ spacer */
- + sname_len /* name itself */
- + 1 /* \0 */ );
+ terminal = XNEWVEC (char, (1 /* S or s */
+ + 8 /* sname_len in decimal */
+ + 1 /* _ spacer */
+ + sname_len /* name itself */
+ + 1 /* \0 */ ));
sprintf (terminal, "%c%d:%s", typetag, sname_len, sname);
return terminal;
char *
symbol_relc_make_value (offsetT val)
{
- char * terminal = xmalloc (28); /* Enough for long long. */
+ char * terminal = XNEWVEC (char, 28); /* Enough for long long. */
terminal[0] = '#';
bfd_sprintf_vma (stdoutput, terminal + 1, val);
char *
symbol_relc_make_expr (expressionS * exp)
{
- char * opstr = NULL; /* Operator prefix string. */
+ const char * opstr = NULL; /* Operator prefix string. */
int arity = 0; /* Arity of this operator. */
char * operands[3]; /* Up to three operands. */
char * concat_string = NULL;
gas_assert (exp != NULL);
/* Match known operators -> fill in opstr, arity, operands[] and fall
- through to construct subexpression fragments; may instead return
+ through to construct subexpression fragments; may instead return
string directly for leaf nodes. */
- /* See expr.h for the meaning of all these enums. Many operators
+ /* See expr.h for the meaning of all these enums. Many operators
have an unnatural arity (X_add_number implicitly added). The
conversion logic expands them to explicit "+" subexpressions. */
return symbol_relc_make_value (exp->X_add_number);
case O_symbol:
- if (exp->X_add_number)
- {
- arity = 2;
- opstr = "+";
+ if (exp->X_add_number)
+ {
+ arity = 2;
+ opstr = "+";
operands[0] = symbol_relc_make_sym (exp->X_add_symbol);
operands[1] = symbol_relc_make_value (exp->X_add_number);
break;
operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
} \
break
-
+
#define HANDLE_XADD_OPT2(str_) \
if (exp->X_add_number) \
{ \
if (opstr == NULL)
concat_string = NULL;
+ else if (arity == 0)
+ concat_string = xstrdup (opstr);
+ else if (arity == 1)
+ concat_string = concat (opstr, ":", operands[0], (char *) NULL);
+ else if (arity == 2)
+ concat_string = concat (opstr, ":", operands[0], ":", operands[1],
+ (char *) NULL);
else
- {
- /* Allocate new string; include inter-operand padding gaps etc. */
- concat_string = xmalloc (strlen (opstr)
- + 1
- + (arity >= 1 ? (strlen (operands[0]) + 1 ) : 0)
- + (arity >= 2 ? (strlen (operands[1]) + 1 ) : 0)
- + (arity >= 3 ? (strlen (operands[2]) + 0 ) : 0)
- + 1);
- gas_assert (concat_string != NULL);
-
- /* Format the thing. */
- sprintf (concat_string,
- (arity == 0 ? "%s" :
- arity == 1 ? "%s:%s" :
- arity == 2 ? "%s:%s:%s" :
- /* arity == 3 */ "%s:%s:%s:%s"),
- opstr, operands[0], operands[1], operands[2]);
- }
+ concat_string = concat (opstr, ":", operands[0], ":", operands[1], ":",
+ operands[2], (char *) NULL);
/* Free operand strings (not opstr). */
if (arity >= 1) xfree (operands[0]);
projects / deliverable / binutils-gdb.git / blobdiff