/* symbols.c -symbol table-
Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
- Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+ 2011 Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
GAS is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
+ the Free Software Foundation; either version 3, or (at your option)
any later version.
GAS is distributed in the hope that it will be useful,
symbolS *symbol_rootP;
symbolS *symbol_lastP;
symbolS abs_symbol;
+symbolS dot_symbol;
#ifdef DEBUG_SYMS
#define debug_verify_symchain verify_symbol_chain
#define DOLLAR_LABEL_CHAR '\001'
#define LOCAL_LABEL_CHAR '\002'
+#ifndef TC_LABEL_IS_LOCAL
+#define TC_LABEL_IS_LOCAL(name) 0
+#endif
+
struct obstack notes;
-#ifdef USE_UNIQUE
+#ifdef TE_PE
/* The name of an external symbol which is
used to make weak PE symbol names unique. */
const char * an_external_name;
static long fb_label_instance (long);
static void print_binary (FILE *, const char *, expressionS *);
-static void report_op_error (symbolS *, symbolS *, symbolS *);
/* Return a pointer to a new symbol. Die if we can't make a new
symbol. Fill in the symbol's values. Add symbol to end of symbol
name_length = strlen (name) + 1; /* +1 for \0. */
obstack_grow (¬es, name, name_length);
- ret = obstack_finish (¬es);
+ ret = (char *) obstack_finish (¬es);
#ifdef tc_canonicalize_symbol_name
ret = tc_canonicalize_symbol_name (ret);
/* Create a local symbol and insert it into the local hash table. */
static struct local_symbol *
-local_symbol_make (const char *name, segT section, valueT value, fragS *frag)
+local_symbol_make (const char *name, segT section, valueT val, fragS *frag)
{
char *name_copy;
struct local_symbol *ret;
ret->lsy_name = name_copy;
ret->lsy_section = section;
local_symbol_set_frag (ret, frag);
- ret->lsy_value = value;
+ ret->lsy_value = val;
- hash_jam (local_hash, name_copy, (PTR) ret);
+ hash_jam (local_hash, name_copy, (void *) ret);
return ret;
}
{
symbolS *ret;
- assert (locsym->lsy_marker == NULL);
+ gas_assert (locsym->lsy_marker == NULL);
if (local_symbol_converted_p (locsym))
return local_symbol_get_real_symbol (locsym);
return ret;
}
\f
+static void
+define_sym_at_dot (symbolS *symbolP)
+{
+ symbolP->sy_frag = frag_now;
+ S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
+ S_SET_SEGMENT (symbolP, now_seg);
+}
+
/* We have just seen "<name>:".
Creates a struct symbol unless it already exists.
}
if (S_GET_VALUE (symbolP) == 0)
{
- symbolP->sy_frag = frag_now;
-#ifdef OBJ_VMS
- S_SET_OTHER (symbolP, const_flag);
-#endif
- S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
- S_SET_SEGMENT (symbolP, now_seg);
+ define_sym_at_dot (symbolP);
#ifdef N_UNDF
know (N_UNDF == 0);
#endif /* if we have one, it better be zero. */
{
/* It is a .comm/.lcomm being converted to initialized
data. */
- symbolP->sy_frag = frag_now;
-#ifdef OBJ_VMS
- S_SET_OTHER (symbolP, const_flag);
-#endif
- S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
- S_SET_SEGMENT (symbolP, now_seg); /* Keep N_EXT bit. */
+ define_sym_at_dot (symbolP);
}
}
else
{
as_bad (_("symbol `%s' is already defined"), sym_name);
symbolP = symbol_clone (symbolP, 0);
+ define_sym_at_dot (symbolP);
}
}
{
symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
frag_now);
-#ifdef OBJ_VMS
- S_SET_OTHER (symbolP, const_flag);
-#endif /* OBJ_VMS */
symbol_table_insert (symbolP);
}
if (LOCAL_SYMBOL_CHECK (symbolP))
{
error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
- (PTR) symbolP);
+ (void *) symbolP);
if (error_string != NULL)
as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
S_GET_NAME (symbolP), error_string);
return;
}
- if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTR) symbolP)))
+ if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (void *) symbolP)))
{
as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
S_GET_NAME (symbolP), error_string);
symbolS *newsymP;
asymbol *bsymorg, *bsymnew;
+ /* Make sure we never clone the dot special symbol. */
+ gas_assert (orgsymP != &dot_symbol);
+
/* Running local_symbol_convert on a clone that's not the one currently
in local_hash would incorrectly replace the hash entry. Thus the
symbol must be converted here. Note that the rest of the function
orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);
bsymorg = orgsymP->bsym;
- know (S_IS_DEFINED (orgsymP));
-
- newsymP = obstack_alloc (¬es, sizeof (*newsymP));
+ newsymP = (symbolS *) obstack_alloc (¬es, sizeof (*newsymP));
*newsymP = *orgsymP;
bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg));
if (bsymnew == NULL)
as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
newsymP->bsym = bsymnew;
bsymnew->name = bsymorg->name;
- bsymnew->flags = bsymorg->flags;
- bsymnew->section = bsymorg->section;
+ bsymnew->flags = bsymorg->flags & ~BSF_SECTION_SYM;
+ bsymnew->section = bsymorg->section;
bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg), bsymorg,
bfd_asymbol_bfd (bsymnew), bsymnew);
symbol_lastP = newsymP;
else if (orgsymP->sy_next)
orgsymP->sy_next->sy_previous = newsymP;
+
+ /* Symbols that won't be output can't be external. */
+ S_CLEAR_EXTERNAL (orgsymP);
orgsymP->sy_previous = orgsymP->sy_next = orgsymP;
debug_verify_symchain (symbol_rootP, symbol_lastP);
symbol_table_insert (newsymP);
}
else
- newsymP->sy_previous = newsymP->sy_next = newsymP;
+ {
+ /* Symbols that won't be output can't be external. */
+ S_CLEAR_EXTERNAL (newsymP);
+ newsymP->sy_previous = newsymP->sy_next = newsymP;
+ }
return newsymP;
}
/* Re-using sy_resolving here, as this routine cannot get called from
symbol resolution code. */
- if (symbolP->bsym->section == expr_section && !symbolP->sy_resolving)
+ if ((symbolP->bsym->section == expr_section || symbolP->sy_forward_ref)
+ && !symbolP->sy_resolving)
{
symbolP->sy_resolving = 1;
add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
if (symbolP->sy_forward_ref
|| add_symbol != symbolP->sy_value.X_add_symbol
|| op_symbol != symbolP->sy_value.X_op_symbol)
- symbolP = symbol_clone (symbolP, 0);
+ {
+ if (symbolP != &dot_symbol)
+ {
+ symbolP = symbol_clone (symbolP, 0);
+ symbolP->sy_resolving = 0;
+ }
+ else
+ {
+ symbolP = symbol_temp_new_now ();
+#ifdef tc_new_dot_label
+ tc_new_dot_label (symbolP);
+#endif
+ }
+ }
symbolP->sy_value.X_add_symbol = add_symbol;
symbolP->sy_value.X_op_symbol = op_symbol;
for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
{
- assert (symbolP->bsym != NULL);
- assert (symbolP->sy_next->sy_previous == symbolP);
+ gas_assert (symbolP->bsym != NULL);
+ gas_assert (symbolP->sy_next->sy_previous == symbolP);
}
- assert (lastP == symbolP);
+ gas_assert (lastP == symbolP);
}
#ifdef OBJ_COMPLEX_RELC
#endif
static void
-report_op_error (symbolS *symp, symbolS *left, symbolS *right)
+report_op_error (symbolS *symp, symbolS *left, operatorT op, symbolS *right)
{
char *file;
unsigned int line;
- segT seg_left = S_GET_SEGMENT (left);
- segT seg_right = right ? S_GET_SEGMENT (right) : 0;
+ segT seg_left = left ? S_GET_SEGMENT (left) : 0;
+ segT seg_right = S_GET_SEGMENT (right);
+ const char *opname;
+
+ switch (op)
+ {
+ default:
+ abort ();
+ return;
+
+ case O_uminus: opname = "-"; break;
+ case O_bit_not: opname = "~"; break;
+ case O_logical_not: opname = "!"; break;
+ case O_multiply: opname = "*"; break;
+ case O_divide: opname = "/"; break;
+ case O_modulus: opname = "%"; break;
+ case O_left_shift: opname = "<<"; break;
+ case O_right_shift: opname = ">>"; break;
+ case O_bit_inclusive_or: opname = "|"; break;
+ case O_bit_or_not: opname = "|~"; break;
+ case O_bit_exclusive_or: opname = "^"; break;
+ case O_bit_and: opname = "&"; break;
+ case O_add: opname = "+"; break;
+ case O_subtract: opname = "-"; break;
+ case O_eq: opname = "=="; break;
+ case O_ne: opname = "!="; break;
+ case O_lt: opname = "<"; break;
+ case O_le: opname = "<="; break;
+ case O_ge: opname = ">="; break;
+ case O_gt: opname = ">"; break;
+ case O_logical_and: opname = "&&"; break;
+ case O_logical_or: opname = "||"; break;
+ }
if (expr_symbol_where (symp, &file, &line))
{
- if (seg_left == undefined_section)
+ if (left)
as_bad_where (file, line,
- _("undefined symbol `%s' in operation"),
- S_GET_NAME (left));
- if (seg_right == undefined_section)
+ _("invalid operands (%s and %s sections) for `%s'"),
+ seg_left->name, seg_right->name, opname);
+ else
as_bad_where (file, line,
- _("undefined symbol `%s' in operation"),
- S_GET_NAME (right));
- if (seg_left != undefined_section
- && seg_right != undefined_section)
- {
- if (right)
- as_bad_where (file, line,
- _("invalid sections for operation on `%s' and `%s'"),
- S_GET_NAME (left), S_GET_NAME (right));
- else
- as_bad_where (file, line,
- _("invalid section for operation on `%s'"),
- S_GET_NAME (left));
- }
-
+ _("invalid operand (%s section) for `%s'"),
+ seg_right->name, opname);
}
else
{
- if (seg_left == undefined_section)
- as_bad (_("undefined symbol `%s' in operation setting `%s'"),
- S_GET_NAME (left), S_GET_NAME (symp));
- if (seg_right == undefined_section)
- as_bad (_("undefined symbol `%s' in operation setting `%s'"),
- S_GET_NAME (right), S_GET_NAME (symp));
- if (seg_left != undefined_section
- && seg_right != undefined_section)
- {
- if (right)
- as_bad (_("invalid sections for operation on `%s' and `%s' setting `%s'"),
- S_GET_NAME (left), S_GET_NAME (right), S_GET_NAME (symp));
- else
- as_bad (_("invalid section for operation on `%s' setting `%s'"),
- S_GET_NAME (left), S_GET_NAME (symp));
- }
+ const char *sname = S_GET_NAME (symp);
+
+ if (left)
+ as_bad (_("invalid operands (%s and %s sections) for `%s' when setting `%s'"),
+ seg_left->name, seg_right->name, opname, sname);
+ else
+ as_bad (_("invalid operand (%s section) for `%s' when setting `%s'"),
+ seg_right->name, opname, sname);
}
}
final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
if (final_seg == expr_section)
final_seg = absolute_section;
+ /* Fall through. */
+
+ case O_register:
resolved = 1;
break;
do_symbol:
if (S_IS_WEAKREFR (symp))
{
- assert (final_val == 0);
+ gas_assert (final_val == 0);
if (S_IS_WEAKREFR (add_symbol))
{
- assert (add_symbol->sy_value.X_op == O_symbol
+ gas_assert (add_symbol->sy_value.X_op == O_symbol
&& add_symbol->sy_value.X_add_number == 0);
add_symbol = add_symbol->sy_value.X_add_symbol;
- assert (! S_IS_WEAKREFR (add_symbol));
+ gas_assert (! S_IS_WEAKREFR (add_symbol));
symp->sy_value.X_add_symbol = add_symbol;
}
}
symp->sy_value.X_add_number = final_val;
/* Use X_op_symbol as a flag. */
symp->sy_value.X_op_symbol = add_symbol;
- final_seg = seg_left;
}
+ final_seg = seg_left;
final_val = 0;
resolved = symbol_resolved_p (add_symbol);
symp->sy_resolving = 0;
~S -> S ^ ~0 only permitted on absolute */
if (op != O_logical_not && seg_left != absolute_section
&& finalize_syms)
- report_op_error (symp, add_symbol, NULL);
+ report_op_error (symp, NULL, op, add_symbol);
if (final_seg == expr_section || final_seg == undefined_section)
final_seg = absolute_section;
probably need to be changed for an object file format which
supports arbitrary expressions, such as IEEE-695. */
if (!(seg_left == absolute_section
- && seg_right == absolute_section)
+ && seg_right == absolute_section)
&& !(op == O_eq || op == O_ne)
&& !((op == O_subtract
|| op == O_lt || op == O_le || op == O_ge || op == O_gt)
/* Don't emit messages unless we're finalizing the symbol value,
otherwise we may get the same message multiple times. */
if (finalize_syms)
- report_op_error (symp, add_symbol, op_symbol);
+ report_op_error (symp, add_symbol, op, op_symbol);
/* However do not move the symbol into the absolute section
if it cannot currently be resolved - this would confuse
other parts of the assembler into believing that the
&& symbol_resolved_p (op_symbol));
break;
- case O_register:
case O_big:
case O_illegal:
/* Give an error (below) if not in expr_section. We don't
return final_val;
}
-static void resolve_local_symbol (const char *, PTR);
+static void resolve_local_symbol (const char *, void *);
/* A static function passed to hash_traverse. */
static void
-resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, PTR value)
+resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, void *value)
{
if (value != NULL)
- resolve_symbol_value (value);
+ resolve_symbol_value ((symbolS *) value);
}
/* Resolve all local symbols. */
}
else
{
- expressionS expr = symbolP->sy_value;
+ expressionS exp = symbolP->sy_value;
- if (!symbolP->sy_resolved && expr.X_op != O_illegal)
+ if (!symbolP->sy_resolved && exp.X_op != O_illegal)
{
int resolved;
if (symbolP->sy_resolving)
return 0;
symbolP->sy_resolving = 1;
- resolved = resolve_expression (&expr);
+ resolved = resolve_expression (&exp);
symbolP->sy_resolving = 0;
if (!resolved)
return 0;
- switch (expr.X_op)
+ switch (exp.X_op)
{
case O_constant:
case O_register:
/* Fall thru. */
case O_symbol:
case O_symbol_rva:
- symbolP = expr.X_add_symbol;
+ symbolP = exp.X_add_symbol;
break;
default:
return 0;
}
}
- /* Never change a defined symbol. */
- if (symbolP->bsym->section == undefined_section
- || symbolP->bsym->section == expr_section)
- *symbolPP = symbolP;
- *valueP = expr.X_add_number;
+ *symbolPP = symbolP;
+ *valueP = exp.X_add_number;
*segP = symbolP->bsym->section;
*fragPP = symbolP->sy_frag;
if (*segP == expr_section)
- switch (expr.X_op)
+ switch (exp.X_op)
{
case O_constant: *segP = absolute_section; break;
case O_register: *segP = reg_section; break;
{
dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
- dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY);
+ dollar_label_defines = (char *) xmalloc (DOLLAR_LABEL_BUMP_BY);
dollar_label_max = DOLLAR_LABEL_BUMP_BY;
dollar_label_count = 0;
}
dollar_label_max * sizeof (long));
dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
dollar_label_max * sizeof (long));
- dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);
+ dollar_label_defines = (char *) xrealloc (dollar_label_defines, dollar_label_max);
} /* if we needed to grow */
dollar_labels[dollar_label_count] = label;
int instance_number;
char *type;
const char *message_format;
- int index = 0;
+ int lindex = 0;
#ifdef LOCAL_LABEL_PREFIX
- if (s[index] == LOCAL_LABEL_PREFIX)
- ++index;
+ if (s[lindex] == LOCAL_LABEL_PREFIX)
+ ++lindex;
#endif
- if (s[index] != 'L')
+ if (s[lindex] != 'L')
return s;
- for (label_number = 0, p = s + index + 1; ISDIGIT (*p); ++p)
+ for (label_number = 0, p = s + lindex + 1; ISDIGIT (*p); ++p)
label_number = (10 * label_number) + *p - '0';
if (*p == DOLLAR_LABEL_CHAR)
instance_number = (10 * instance_number) + *p - '0';
message_format = _("\"%d\" (instance number %d of a %s label)");
- symbol_decode = obstack_alloc (¬es, strlen (message_format) + 30);
+ symbol_decode = (char *) obstack_alloc (¬es, strlen (message_format) + 30);
sprintf (symbol_decode, message_format, label_number, instance_number, type);
return symbol_decode;
/* In an expression, transfer the settings of these flags.
The user can override later, of course. */
-#define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT)
+#define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT \
+ | BSF_GNU_INDIRECT_FUNCTION)
dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
#ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
#endif
+
+#ifdef TC_COPY_SYMBOL_ATTRIBUTES
+ TC_COPY_SYMBOL_ATTRIBUTES (dest, src);
+#endif
}
int
&& ((s->bsym->flags & BSF_WEAK) != 0
|| (EXTERN_FORCE_RELOC
&& (s->bsym->flags & BSF_GLOBAL) != 0)))
+ || (s->bsym->flags & BSF_GNU_INDIRECT_FUNCTION) != 0
|| s->bsym->section == undefined_section
|| bfd_is_com_section (s->bsym->section));
}
&& ! S_IS_DEBUG (s)
&& (strchr (name, DOLLAR_LABEL_CHAR)
|| strchr (name, LOCAL_LABEL_CHAR)
+ || TC_LABEL_IS_LOCAL (name)
|| (! flag_keep_locals
&& (bfd_is_local_label (stdoutput, s->bsym)
|| (flag_mri
_("section symbols are already global"));
return;
}
+#ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
+ if (S_GET_SEGMENT (s) == reg_section)
+ {
+ as_bad ("can't make register symbol `%s' global",
+ S_GET_NAME (s));
+ return;
+ }
+#endif
s->bsym->flags |= BSF_GLOBAL;
s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
-#ifdef USE_UNIQUE
+#ifdef TE_PE
if (! an_external_name && S_GET_NAME(s)[0] != '.')
an_external_name = S_GET_NAME (s);
#endif
S_CLEAR_WEAKREFR (s);
}
+/* Return whether 2 symbols are the same. */
+
+int
+symbol_same_p (symbolS *s1, symbolS *s2)
+{
+ if (s1->bsym == NULL
+ && local_symbol_converted_p ((struct local_symbol *) s1))
+ s1 = local_symbol_get_real_symbol ((struct local_symbol *) s1);
+ if (s2->bsym == NULL
+ && local_symbol_converted_p ((struct local_symbol *) s2))
+ s2 = local_symbol_get_real_symbol ((struct local_symbol *) s2);
+ return s1 == s2;
+}
+
/* Return a pointer to the X_add_number component of a symbol. */
offsetT *
if (LOCAL_LABELS_FB)
fb_label_init ();
}
+
+void
+dot_symbol_init (void)
+{
+ dot_symbol.bsym = bfd_make_empty_symbol (stdoutput);
+ 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_value.X_op = O_constant;
+}
\f
int indent_level;
const char *name = S_GET_NAME (sym);
if (!name || !name[0])
name = "(unnamed)";
- fprintf (file, "sym %lx %s", (unsigned long) sym, name);
+ fprintf (file, "sym ");
+ fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym));
+ fprintf (file, " %s", name);
if (LOCAL_SYMBOL_CHECK (sym))
{
struct local_symbol *locsym = (struct local_symbol *) sym;
- if (local_symbol_get_frag (locsym) != &zero_address_frag
+
+ if (local_symbol_get_frag (locsym) != & zero_address_frag
&& local_symbol_get_frag (locsym) != NULL)
- fprintf (file, " frag %lx", (long) local_symbol_get_frag (locsym));
+ {
+ fprintf (file, " frag ");
+ fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) local_symbol_get_frag (locsym)));
+ }
if (local_symbol_resolved_p (locsym))
fprintf (file, " resolved");
fprintf (file, " local");
else
{
if (sym->sy_frag != &zero_address_frag)
- fprintf (file, " frag %lx", (long) sym->sy_frag);
+ {
+ fprintf (file, " frag ");
+ fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym->sy_frag));
+ }
if (sym->written)
fprintf (file, " written");
if (sym->sy_resolved)
if (s != undefined_section
&& s != expr_section)
- fprintf (file, " %lx", (long) S_GET_VALUE (sym));
+ fprintf (file, " %lx", (unsigned long) S_GET_VALUE (sym));
}
else if (indent_level < max_indent_level
&& S_GET_SEGMENT (sym) != undefined_section)
fprintf (file, "\n%*s<", indent_level * 4, "");
if (LOCAL_SYMBOL_CHECK (sym))
fprintf (file, "constant %lx",
- (long) ((struct local_symbol *) sym)->lsy_value);
+ (unsigned long) ((struct local_symbol *) sym)->lsy_value);
else
print_expr_1 (file, &sym->sy_value);
fprintf (file, ">");
void
print_expr_1 (FILE *file, expressionS *exp)
{
- fprintf (file, "expr %lx ", (long) exp);
+ fprintf (file, "expr ");
+ fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) exp));
+ fprintf (file, " ");
switch (exp->X_op)
{
case O_illegal:
fprintf (file, "absent");
break;
case O_constant:
- fprintf (file, "constant %lx", (long) exp->X_add_number);
+ fprintf (file, "constant %lx", (unsigned long) exp->X_add_number);
break;
case O_symbol:
indent_level++;
maybe_print_addnum:
if (exp->X_add_number)
fprintf (file, "\n%*s%lx", indent_level * 4, "",
- (long) exp->X_add_number);
+ (unsigned long) exp->X_add_number);
indent_level--;
break;
case O_register:
#ifdef OBJ_COMPLEX_RELC
/* Convert given symbol to a new complex-relocation symbol name. This
- may bee a recursive function, since it might be called for non-leaf
+ may be a recursive function, since it might be called for non-leaf
nodes (plain symbols) in the expression tree. The caller owns the
- returning string, so should free() it eventually. Errors are
- indicated via as_bad() and a NULL return value. The given symbol
+ returning string, so should free it eventually. Errors are
+ indicated via as_bad and a NULL return value. The given symbol
is marked with sy_used_in_reloc. */
char *
char typetag;
int sname_len;
- assert (sym != NULL);
+ gas_assert (sym != NULL);
/* Recurse to symbol_relc_make_expr if this symbol
is defined as an expression or a plain value. */
char * terminal = xmalloc (28); /* Enough for long long. */
terminal[0] = '#';
- sprintf_vma (& terminal[1], val);
+ bfd_sprintf_vma (stdoutput, terminal + 1, val);
return terminal;
}
operands[0] = operands[1] = operands[2] = NULL;
- assert (exp != NULL);
+ gas_assert (exp != NULL);
/* Match known operators -> fill in opstr, arity, operands[] and fall
through to construct subexpression fragments; may instead return
+ (arity >= 2 ? (strlen (operands[1]) + 1 ) : 0)
+ (arity >= 3 ? (strlen (operands[2]) + 0 ) : 0)
+ 1);
- assert (concat_string != NULL);
+ gas_assert (concat_string != NULL);
/* Format the thing. */
sprintf (concat_string,