/* symbols.c -symbol table-
- Copyright (C) 1987-2014 Free Software Foundation, Inc.
+ Copyright (C) 1987-2022 Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
#include "safe-ctype.h"
#include "obstack.h" /* For "symbols.h" */
#include "subsegs.h"
-#include "struc-symbol.h"
+#include "write.h"
+
+#include <limits.h>
+#ifndef CHAR_BIT
+#define CHAR_BIT 8
+#endif
+
+struct symbol_flags
+{
+ /* Whether the symbol is a local_symbol. */
+ unsigned int local_symbol : 1;
+
+ /* Weather symbol has been written. */
+ unsigned int written : 1;
+
+ /* Whether symbol value has been completely resolved (used during
+ final pass over symbol table). */
+ unsigned int resolved : 1;
+
+ /* Whether the symbol value is currently being resolved (used to
+ detect loops in symbol dependencies). */
+ unsigned int resolving : 1;
+
+ /* Whether the symbol value is used in a reloc. This is used to
+ ensure that symbols used in relocs are written out, even if they
+ are local and would otherwise not be. */
+ unsigned int used_in_reloc : 1;
+
+ /* Whether the symbol is used as an operand or in an expression.
+ NOTE: Not all the backends keep this information accurate;
+ backends which use this bit are responsible for setting it when
+ a symbol is used in backend routines. */
+ unsigned int used : 1;
+
+ /* Whether the symbol can be re-defined. */
+ unsigned int volatil : 1;
+
+ /* Whether the symbol is a forward reference, and whether such has
+ been determined. */
+ unsigned int forward_ref : 1;
+ unsigned int forward_resolved : 1;
+
+ /* This is set if the symbol is defined in an MRI common section.
+ We handle such sections as single common symbols, so symbols
+ defined within them must be treated specially by the relocation
+ routines. */
+ unsigned int mri_common : 1;
+
+ /* This is set if the symbol is set with a .weakref directive. */
+ unsigned int weakrefr : 1;
+
+ /* This is set when the symbol is referenced as part of a .weakref
+ directive, but only if the symbol was not in the symbol table
+ before. It is cleared as soon as any direct reference to the
+ symbol is present. */
+ unsigned int weakrefd : 1;
+
+ /* Whether the symbol has been marked to be removed by a .symver
+ directive. */
+ unsigned int removed : 1;
+
+ /* Set when a warning about the symbol containing multibyte characters
+ is generated. */
+ unsigned int multibyte_warned : 1;
+};
+
+/* A pointer in the symbol may point to either a complete symbol
+ (struct symbol below) or to a local symbol (struct local_symbol
+ defined here). The symbol code can detect the case by examining
+ the first field which is present in both structs.
+
+ We do this because we ordinarily only need a small amount of
+ information for a local symbol. The symbol table takes up a lot of
+ space, and storing less information for a local symbol can make a
+ big difference in assembler memory usage when assembling a large
+ file. */
+
+struct local_symbol
+{
+ /* Symbol flags. Only local_symbol and resolved are relevant. */
+ struct symbol_flags flags;
+
+ /* Hash value calculated from name. */
+ hashval_t hash;
+
+ /* The symbol name. */
+ const char *name;
+
+ /* The symbol frag. */
+ fragS *frag;
+
+ /* The symbol section. */
+ asection *section;
+
+ /* The value of the symbol. */
+ valueT value;
+};
+
+/* The information we keep for a symbol. The symbol table holds
+ pointers both to this and to local_symbol structures. The first
+ three fields must be identical to struct local_symbol, and the size
+ should be the same as or smaller than struct local_symbol.
+ Fields that don't fit go to an extension structure. */
+
+struct symbol
+{
+ /* Symbol flags. */
+ struct symbol_flags flags;
+
+ /* Hash value calculated from name. */
+ hashval_t hash;
+
+ /* The symbol name. */
+ const char *name;
+
+ /* Pointer to the frag this symbol is attached to, if any.
+ Otherwise, NULL. */
+ fragS *frag;
+
+ /* BFD symbol */
+ asymbol *bsym;
+
+ /* Extra symbol fields that won't fit. */
+ struct xsymbol *x;
+};
+
+/* Extra fields to make up a full symbol. */
+
+struct xsymbol
+{
+ /* The value of the symbol. */
+ expressionS value;
+
+ /* Forwards and backwards chain pointers. */
+ struct symbol *next;
+ struct symbol *previous;
+
+#ifdef OBJ_SYMFIELD_TYPE
+ OBJ_SYMFIELD_TYPE obj;
+#endif
+
+#ifdef TC_SYMFIELD_TYPE
+ TC_SYMFIELD_TYPE tc;
+#endif
+};
+
+typedef union symbol_entry
+{
+ struct local_symbol lsy;
+ struct symbol sy;
+} symbol_entry_t;
+
+/* Hash function for a symbol_entry. */
+
+static hashval_t
+hash_symbol_entry (const void *e)
+{
+ symbol_entry_t *entry = (symbol_entry_t *) e;
+ if (entry->sy.hash == 0)
+ entry->sy.hash = htab_hash_string (entry->sy.name);
+
+ return entry->sy.hash;
+}
+
+/* Equality function for a symbol_entry. */
+
+static int
+eq_symbol_entry (const void *a, const void *b)
+{
+ const symbol_entry_t *ea = (const symbol_entry_t *) a;
+ const symbol_entry_t *eb = (const symbol_entry_t *) b;
+
+ return (ea->sy.hash == eb->sy.hash
+ && strcmp (ea->sy.name, eb->sy.name) == 0);
+}
+
+static void *
+symbol_entry_find (htab_t table, const char *name)
+{
+ hashval_t hash = htab_hash_string (name);
+ symbol_entry_t needle = { { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+ hash, name, 0, 0, 0 } };
+ return htab_find_with_hash (table, &needle, hash);
+}
+
/* This is non-zero if symbols are case sensitive, which is the
default. */
extern int new_broken_words;
#endif
-/* symbol-name => struct symbol pointer */
-static struct hash_control *sy_hash;
-
-/* Table of local symbols. */
-static struct hash_control *local_hash;
+static htab_t sy_hash;
/* Below are commented in "symbols.h". */
symbolS *symbol_rootP;
symbolS *symbol_lastP;
symbolS abs_symbol;
+struct xsymbol abs_symbol_x;
symbolS dot_symbol;
+struct xsymbol dot_symbol_x;
#ifdef DEBUG_SYMS
#define debug_verify_symchain verify_symbol_chain
const char * an_external_name;
#endif
-static char *save_symbol_name (const char *);
-static void fb_label_init (void);
-static long dollar_label_instance (long);
-static long fb_label_instance (long);
-
-static void print_binary (FILE *, const char *, expressionS *);
-
/* 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
chain.
output file, you can call symbol_create. */
symbolS *
-symbol_new (const char *name, segT segment, valueT valu, fragS *frag)
+symbol_new (const char *name, segT segment, fragS *frag, valueT valu)
{
- symbolS *symbolP = symbol_create (name, segment, valu, frag);
+ symbolS *symbolP = symbol_create (name, segment, frag, valu);
/* Link to end of symbol chain. */
- {
- extern int symbol_table_frozen;
- if (symbol_table_frozen)
- abort ();
- }
symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
return symbolP;
/* 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)
{
size_t name_length;
char *ret;
+ gas_assert (name != NULL);
name_length = strlen (name) + 1; /* +1 for \0. */
obstack_grow (¬es, name, name_length);
ret = (char *) obstack_finish (¬es);
return ret;
}
-symbolS *
-symbol_create (const char *name, /* It is copied, the caller can destroy/modify. */
- segT segment, /* Segment identifier (SEG_<something>). */
- valueT valu, /* Symbol value. */
- fragS *frag /* Associated fragment. */)
+static void
+symbol_init (symbolS *symbolP, const char *name, asection *sec,
+ fragS *frag, valueT valu)
{
- char *preserved_copy_of_name;
- symbolS *symbolP;
-
- preserved_copy_of_name = save_symbol_name (name);
-
- symbolP = (symbolS *) obstack_alloc (¬es, sizeof (symbolS));
-
- /* symbol must be born in some fixed state. This seems as good as any. */
- memset (symbolP, 0, sizeof (symbolS));
-
+ symbolP->frag = frag;
symbolP->bsym = bfd_make_empty_symbol (stdoutput);
if (symbolP->bsym == NULL)
as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
- S_SET_NAME (symbolP, preserved_copy_of_name);
+ symbolP->bsym->name = name;
+ symbolP->bsym->section = sec;
+
+ if (multibyte_handling == multibyte_warn_syms
+ && ! symbolP->flags.local_symbol
+ && sec != undefined_section
+ && ! symbolP->flags.multibyte_warned
+ && scan_for_multibyte_characters ((const unsigned char *) name,
+ (const unsigned char *) name + strlen (name),
+ false /* Do not warn. */))
+ {
+ as_warn (_("symbol '%s' contains multibyte characters"), name);
+ symbolP->flags.multibyte_warned = 1;
+ }
- S_SET_SEGMENT (symbolP, segment);
S_SET_VALUE (symbolP, valu);
- symbol_clear_list_pointers (symbolP);
- symbolP->sy_frag = frag;
+ symbol_clear_list_pointers (symbolP);
obj_symbol_new_hook (symbolP);
#ifdef tc_symbol_new_hook
tc_symbol_new_hook (symbolP);
#endif
+}
+
+/* Create a symbol. NAME is copied, the caller can destroy/modify. */
+
+symbolS *
+symbol_create (const char *name, segT segment, fragS *frag, valueT valu)
+{
+ const char *preserved_copy_of_name;
+ symbolS *symbolP;
+ size_t size;
+
+ preserved_copy_of_name = save_symbol_name (name);
+
+ size = sizeof (symbolS) + sizeof (struct xsymbol);
+ symbolP = (symbolS *) obstack_alloc (¬es, size);
+
+ /* symbol must be born in some fixed state. This seems as good as any. */
+ memset (symbolP, 0, size);
+ symbolP->name = preserved_copy_of_name;
+ symbolP->x = (struct xsymbol *) (symbolP + 1);
+
+ symbol_init (symbolP, preserved_copy_of_name, segment, frag, valu);
return symbolP;
}
/* Local symbol support. If we can get away with it, we keep only a
small amount of information for local symbols. */
-static symbolS *local_symbol_convert (struct local_symbol *);
-
/* Used for statistics. */
static unsigned long local_symbol_count;
static unsigned long local_symbol_conversion_count;
-/* This macro is called with a symbol argument passed by reference.
- It returns whether this is a local symbol. If necessary, it
- changes its argument to the real symbol. */
-
-#define LOCAL_SYMBOL_CHECK(s) \
- (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) \
- : 1) \
- : 0)
-
/* Create a local symbol and insert it into the local hash table. */
struct local_symbol *
-local_symbol_make (const char *name, segT section, valueT val, fragS *frag)
+local_symbol_make (const char *name, segT section, fragS *frag, valueT val)
{
- char *name_copy;
+ const char *name_copy;
struct local_symbol *ret;
+ struct symbol_flags flags = { .local_symbol = 1, .resolved = 0 };
++local_symbol_count;
name_copy = save_symbol_name (name);
ret = (struct local_symbol *) obstack_alloc (¬es, sizeof *ret);
- 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);
- ret->lsy_value = val;
+ ret->flags = flags;
+ ret->hash = 0;
+ ret->name = name_copy;
+ ret->frag = frag;
+ ret->section = section;
+ ret->value = val;
- hash_jam (local_hash, name_copy, (void *) ret);
+ htab_insert (sy_hash, ret, 1);
return ret;
}
-/* Convert a local symbol into a real symbol. Note that we do not
- reclaim the space used by the local symbol. */
+/* Convert a local symbol into a real symbol. */
static symbolS *
-local_symbol_convert (struct local_symbol *locsym)
+local_symbol_convert (void *sym)
{
- symbolS *ret;
+ symbol_entry_t *ent = (symbol_entry_t *) sym;
+ struct xsymbol *xtra;
+ valueT val;
- gas_assert (locsym->lsy_flags.sy_local_symbol);
- if (local_symbol_converted_p (locsym))
- return local_symbol_get_real_symbol (locsym);
+ gas_assert (ent->lsy.flags.local_symbol);
++local_symbol_conversion_count;
- ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value,
- local_symbol_get_frag (locsym));
-
- if (local_symbol_resolved_p (locsym))
- ret->sy_flags.sy_resolved = 1;
+ xtra = (struct xsymbol *) obstack_alloc (¬es, sizeof (*xtra));
+ memset (xtra, 0, sizeof (*xtra));
+ val = ent->lsy.value;
+ ent->sy.x = xtra;
/* Local symbols are always either defined or used. */
- ret->sy_flags.sy_used = 1;
-
-#ifdef TC_LOCAL_SYMFIELD_CONVERT
- TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
-#endif
-
- symbol_table_insert (ret);
+ ent->sy.flags.used = 1;
+ ent->sy.flags.local_symbol = 0;
- local_symbol_mark_converted (locsym);
- local_symbol_set_real_symbol (locsym, ret);
+ symbol_init (&ent->sy, ent->lsy.name, ent->lsy.section, ent->lsy.frag, val);
+ symbol_append (&ent->sy, symbol_lastP, &symbol_rootP, &symbol_lastP);
- hash_jam (local_hash, locsym->lsy_name, NULL);
-
- return ret;
+ return &ent->sy;
}
\f
static void
define_sym_at_dot (symbolS *symbolP)
{
- symbolP->sy_frag = frag_now;
+ symbolP->frag = frag_now;
S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
S_SET_SEGMENT (symbolP, now_seg);
}
symbolS *
colon (/* Just seen "x:" - rattle symbols & frags. */
- const char *sym_name /* Symbol name, as a cannonical string. */
+ const char *sym_name /* Symbol name, as a canonical 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. */
return symbolP;
#endif
/* Now check for undefined symbols. */
- if (LOCAL_SYMBOL_CHECK (symbolP))
+ if (symbolP->flags.local_symbol)
{
struct local_symbol *locsym = (struct local_symbol *) symbolP;
- if (locsym->lsy_section != undefined_section
- && (local_symbol_get_frag (locsym) != frag_now
- || locsym->lsy_section != now_seg
- || locsym->lsy_value != frag_now_fix ()))
+ if (locsym->section != undefined_section
+ && (locsym->frag != frag_now
+ || locsym->section != now_seg
+ || locsym->value != frag_now_fix ()))
{
as_bad (_("symbol `%s' is already defined"), sym_name);
return symbolP;
}
- locsym->lsy_section = now_seg;
- local_symbol_set_frag (locsym, frag_now);
- locsym->lsy_value = frag_now_fix ();
+ locsym->section = now_seg;
+ locsym->frag = frag_now;
+ locsym->value = frag_now_fix ();
}
else if (!(S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
|| S_IS_COMMON (symbolP)
}
else
{
-#if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
- && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
+#if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT))
static const char *od_buf = "";
#else
char od_buf[100];
else
{
/* Don't blow up if the definition is the same. */
- if (!(frag_now == symbolP->sy_frag
+ if (!(frag_now == symbolP->frag
&& S_GET_VALUE (symbolP) == frag_now_fix ()
&& S_GET_SEGMENT (symbolP) == now_seg))
{
}
else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name))
{
- symbolP = (symbolS *) local_symbol_make (sym_name, now_seg,
- (valueT) frag_now_fix (),
- frag_now);
+ symbolP = (symbolS *) local_symbol_make (sym_name, now_seg, frag_now,
+ frag_now_fix ());
}
else
{
- symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
- frag_now);
+ symbolP = symbol_new (sym_name, now_seg, frag_now, frag_now_fix ());
symbol_table_insert (symbolP);
}
{
/* This symbol is actually being defined within an MRI common
section. This requires special handling. */
- if (LOCAL_SYMBOL_CHECK (symbolP))
- symbolP = local_symbol_convert ((struct local_symbol *) symbolP);
- symbolP->sy_value.X_op = O_symbol;
- symbolP->sy_value.X_add_symbol = mri_common_symbol;
- symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
- symbolP->sy_frag = &zero_address_frag;
+ if (symbolP->flags.local_symbol)
+ symbolP = local_symbol_convert (symbolP);
+ symbolP->x->value.X_op = O_symbol;
+ symbolP->x->value.X_add_symbol = mri_common_symbol;
+ symbolP->x->value.X_add_number = S_GET_VALUE (mri_common_symbol);
+ symbolP->frag = &zero_address_frag;
S_SET_SEGMENT (symbolP, expr_section);
- symbolP->sy_flags.sy_mri_common = 1;
+ symbolP->flags.mri_common = 1;
}
#ifdef tc_frob_label
void
symbol_table_insert (symbolS *symbolP)
{
- register const char *error_string;
-
know (symbolP);
- know (S_GET_NAME (symbolP));
-
- if (LOCAL_SYMBOL_CHECK (symbolP))
- {
- error_string = hash_jam (local_hash, S_GET_NAME (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), (void *) symbolP)))
- {
- as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
- S_GET_NAME (symbolP), error_string);
- } /* on error */
+ htab_insert (sy_hash, symbolP, 1);
}
\f
/* If a symbol name does not exist, create it as undefined, and insert
symbolS *
symbol_find_or_make (const char *name)
{
- register symbolS *symbolP;
+ symbolS *symbolP;
symbolP = symbol_find (name);
return symbolP;
symbolP = (symbolS *) local_symbol_make (name, undefined_section,
- (valueT) 0,
- &zero_address_frag);
+ &zero_address_frag, 0);
return symbolP;
}
symbolP = md_undefined_symbol ((char *) name);
if (!symbolP)
- symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
+ symbolP = symbol_new (name, undefined_section, &zero_address_frag, 0);
return (symbolP);
}
/* 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
- depends on not encountering an unconverted symbol. */
- if (LOCAL_SYMBOL_CHECK (orgsymP))
- orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);
+ /* When cloning a local symbol it isn't absolutely necessary to
+ convert the original, but converting makes the code much
+ simpler to cover this unexpected case. As of 2020-08-21
+ symbol_clone won't be called on a local symbol. */
+ if (orgsymP->flags.local_symbol)
+ orgsymP = local_symbol_convert (orgsymP);
bsymorg = orgsymP->bsym;
- newsymP = (symbolS *) obstack_alloc (¬es, sizeof (*newsymP));
+ newsymP = (symbolS *) obstack_alloc (¬es, (sizeof (symbolS)
+ + sizeof (struct xsymbol)));
*newsymP = *orgsymP;
+ newsymP->x = (struct xsymbol *) (newsymP + 1);
+ *newsymP->x = *orgsymP->x;
bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg));
if (bsymnew == NULL)
as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
{
if (symbol_rootP == orgsymP)
symbol_rootP = newsymP;
- else if (orgsymP->sy_previous)
+ else if (orgsymP->x->previous)
{
- orgsymP->sy_previous->sy_next = newsymP;
- orgsymP->sy_previous = NULL;
+ orgsymP->x->previous->x->next = newsymP;
+ orgsymP->x->previous = NULL;
}
if (symbol_lastP == orgsymP)
symbol_lastP = newsymP;
- else if (orgsymP->sy_next)
- orgsymP->sy_next->sy_previous = newsymP;
+ else if (orgsymP->x->next)
+ orgsymP->x->next->x->previous = newsymP;
/* Symbols that won't be output can't be external. */
S_CLEAR_EXTERNAL (orgsymP);
- orgsymP->sy_previous = orgsymP->sy_next = orgsymP;
+ orgsymP->x->previous = orgsymP->x->next = orgsymP;
debug_verify_symchain (symbol_rootP, symbol_lastP);
symbol_table_insert (newsymP);
{
/* Symbols that won't be output can't be external. */
S_CLEAR_EXTERNAL (newsymP);
- newsymP->sy_previous = newsymP->sy_next = newsymP;
+ newsymP->x->previous = newsymP->x->next = newsymP;
}
return newsymP;
/* Referenced symbols, if they are forward references, need to be cloned
(without replacing the original) so that the value of the referenced
- symbols at the point of use . */
+ symbols at the point of use is saved by the clone. */
#undef symbol_clone_if_forward_ref
symbolS *
symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
{
- if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
+ if (symbolP
+ && !symbolP->flags.local_symbol
+ && !symbolP->flags.forward_resolved)
{
- symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
- symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
+ symbolS *orig_add_symbol = symbolP->x->value.X_add_symbol;
+ symbolS *orig_op_symbol = symbolP->x->value.X_op_symbol;
+ symbolS *add_symbol = orig_add_symbol;
+ symbolS *op_symbol = orig_op_symbol;
- if (symbolP->sy_flags.sy_forward_ref)
+ if (symbolP->flags.forward_ref)
is_forward = 1;
if (is_forward)
op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));
}
- /* Re-using sy_resolving here, as this routine cannot get called from
+ /* Re-using resolving here, as this routine cannot get called from
symbol resolution code. */
if ((symbolP->bsym->section == expr_section
- || symbolP->sy_flags.sy_forward_ref)
- && !symbolP->sy_flags.sy_resolving)
+ || symbolP->flags.forward_ref)
+ && !symbolP->flags.resolving)
{
- symbolP->sy_flags.sy_resolving = 1;
+ symbolP->flags.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_flags.sy_resolving = 0;
+ symbolP->flags.resolving = 0;
}
- 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->flags.forward_ref
+ || add_symbol != orig_add_symbol
+ || op_symbol != orig_op_symbol)
{
if (symbolP != &dot_symbol)
{
symbolP = symbol_clone (symbolP, 0);
- symbolP->sy_flags.sy_resolving = 0;
+ symbolP->flags.resolving = 0;
}
else
{
}
}
- symbolP->sy_value.X_add_symbol = add_symbol;
- symbolP->sy_value.X_op_symbol = op_symbol;
+ symbolP->x->value.X_add_symbol = add_symbol;
+ symbolP->x->value.X_op_symbol = op_symbol;
+ symbolP->flags.forward_resolved = 1;
}
return symbolP;
}
symbolS *
-symbol_temp_new (segT seg, valueT ofs, fragS *frag)
+symbol_temp_new (segT seg, fragS *frag, valueT ofs)
{
- return symbol_new (FAKE_LABEL_NAME, seg, ofs, frag);
+ return symbol_new (FAKE_LABEL_NAME, seg, frag, ofs);
}
symbolS *
symbol_temp_new_now (void)
{
- return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
+ return symbol_temp_new (now_seg, frag_now, frag_now_fix ());
+}
+
+symbolS *
+symbol_temp_new_now_octets (void)
+{
+ return symbol_temp_new (now_seg, frag_now, frag_now_fix_octets ());
}
symbolS *
symbolS *
symbol_find_exact_noref (const char *name, int noref)
{
- struct local_symbol *locsym;
- symbolS* sym;
-
- locsym = (struct local_symbol *) hash_find (local_hash, name);
- if (locsym != NULL)
- return (symbolS *) locsym;
-
- sym = ((symbolS *) hash_find (sy_hash, name));
+ symbolS *sym = symbol_entry_find (sy_hash, name);
/* Any references to the symbol, except for the reference in
.weakref, must clear this flag, such that the symbol does not
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';
+
+ free (copy2);
+ copy = (char *) name;
}
- return symbol_find_exact_noref (name, noref);
+ result = symbol_find_exact_noref (name, noref);
+ free (copy);
+ return result;
}
/* Once upon a time, symbols were kept in a singly linked list. At
symbol_append (symbolS *addme, symbolS *target,
symbolS **rootPP, symbolS **lastPP)
{
- if (LOCAL_SYMBOL_CHECK (addme))
+ extern int symbol_table_frozen;
+ if (symbol_table_frozen)
abort ();
- if (target != NULL && LOCAL_SYMBOL_CHECK (target))
+ if (addme->flags.local_symbol)
+ abort ();
+ if (target != NULL && target->flags.local_symbol)
abort ();
if (target == NULL)
{
know (*rootPP == NULL);
know (*lastPP == NULL);
- addme->sy_next = NULL;
- addme->sy_previous = NULL;
+ addme->x->next = NULL;
+ addme->x->previous = NULL;
*rootPP = addme;
*lastPP = addme;
return;
} /* if the list is empty */
- if (target->sy_next != NULL)
+ if (target->x->next != NULL)
{
- target->sy_next->sy_previous = addme;
+ target->x->next->x->previous = addme;
}
else
{
*lastPP = addme;
} /* if we have a next */
- addme->sy_next = target->sy_next;
- target->sy_next = addme;
- addme->sy_previous = target;
+ addme->x->next = target->x->next;
+ target->x->next = addme;
+ addme->x->previous = target;
debug_verify_symchain (symbol_rootP, symbol_lastP);
}
void
symbol_clear_list_pointers (symbolS *symbolP)
{
- if (LOCAL_SYMBOL_CHECK (symbolP))
+ if (symbolP->flags.local_symbol)
abort ();
- symbolP->sy_next = NULL;
- symbolP->sy_previous = NULL;
+ symbolP->x->next = NULL;
+ symbolP->x->previous = NULL;
}
/* Remove SYMBOLP from the list. */
void
symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP)
{
- if (LOCAL_SYMBOL_CHECK (symbolP))
+ if (symbolP->flags.local_symbol)
abort ();
if (symbolP == *rootPP)
{
- *rootPP = symbolP->sy_next;
+ *rootPP = symbolP->x->next;
} /* if it was the root */
if (symbolP == *lastPP)
{
- *lastPP = symbolP->sy_previous;
+ *lastPP = symbolP->x->previous;
} /* if it was the tail */
- if (symbolP->sy_next != NULL)
+ if (symbolP->x->next != NULL)
{
- symbolP->sy_next->sy_previous = symbolP->sy_previous;
+ symbolP->x->next->x->previous = symbolP->x->previous;
} /* if not last */
- if (symbolP->sy_previous != NULL)
+ if (symbolP->x->previous != NULL)
{
- symbolP->sy_previous->sy_next = symbolP->sy_next;
+ symbolP->x->previous->x->next = symbolP->x->next;
} /* if not first */
debug_verify_symchain (*rootPP, *lastPP);
symbol_insert (symbolS *addme, symbolS *target,
symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED)
{
- if (LOCAL_SYMBOL_CHECK (addme))
+ extern int symbol_table_frozen;
+ if (symbol_table_frozen)
+ abort ();
+ if (addme->flags.local_symbol)
abort ();
- if (LOCAL_SYMBOL_CHECK (target))
+ if (target->flags.local_symbol)
abort ();
- if (target->sy_previous != NULL)
+ if (target->x->previous != NULL)
{
- target->sy_previous->sy_next = addme;
+ target->x->previous->x->next = addme;
}
else
{
*rootPP = addme;
} /* if not first */
- addme->sy_previous = target->sy_previous;
- target->sy_previous = addme;
- addme->sy_next = target;
+ addme->x->previous = target->x->previous;
+ target->x->previous = addme;
+ addme->x->next = target;
debug_verify_symchain (*rootPP, *lastPP);
}
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);
+ gas_assert (symbolP->flags.local_symbol == 0);
+ gas_assert (symbolP->x->next->x->previous == symbolP);
}
gas_assert (lastP == symbolP);
}
+int
+symbol_on_chain (symbolS *s, symbolS *rootPP, symbolS *lastPP)
+{
+ return (!s->flags.local_symbol
+ && ((s->x->next != s
+ && s->x->next != NULL
+ && s->x->next->x->previous == s)
+ || s == lastPP)
+ && ((s->x->previous != s
+ && s->x->previous != NULL
+ && s->x->previous->x->next == s)
+ || s == rootPP));
+}
+
#ifdef OBJ_COMPLEX_RELC
static int
use_complex_relocs_for (symbolS * symp)
{
- switch (symp->sy_value.X_op)
+ switch (symp->x->value.X_op)
{
case O_constant:
return 0;
- case O_symbol:
- case O_symbol_rva:
- case O_uminus:
- case O_bit_not:
- case O_logical_not:
- if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
- || S_IS_LOCAL (symp->sy_value.X_add_symbol))
- &&
- (S_IS_DEFINED (symp->sy_value.X_add_symbol)
- && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section))
- return 0;
- break;
-
case O_multiply:
case O_divide:
case O_modulus:
case O_gt:
case O_logical_and:
case O_logical_or:
-
- 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_IS_DEFINED (symp->sy_value.X_add_symbol)
- && S_IS_DEFINED (symp->sy_value.X_op_symbol)
- && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section
- && S_GET_SEGMENT (symp->sy_value.X_op_symbol) != expr_section)
- return 0;
+ if ((S_IS_COMMON (symp->x->value.X_op_symbol)
+ || S_IS_LOCAL (symp->x->value.X_op_symbol))
+ && S_IS_DEFINED (symp->x->value.X_op_symbol)
+ && S_GET_SEGMENT (symp->x->value.X_op_symbol) != expr_section)
+ {
+ case O_symbol:
+ case O_symbol_rva:
+ case O_uminus:
+ case O_bit_not:
+ case O_logical_not:
+ if ((S_IS_COMMON (symp->x->value.X_add_symbol)
+ || S_IS_LOCAL (symp->x->value.X_add_symbol))
+ && S_IS_DEFINED (symp->x->value.X_add_symbol)
+ && S_GET_SEGMENT (symp->x->value.X_add_symbol) != expr_section)
+ return 0;
+ }
break;
default:
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);
resolve_symbol_value (symbolS *symp)
{
int resolved;
- valueT final_val = 0;
+ valueT final_val;
segT final_seg;
- if (LOCAL_SYMBOL_CHECK (symp))
+ if (symp->flags.local_symbol)
{
struct local_symbol *locsym = (struct local_symbol *) symp;
- final_val = locsym->lsy_value;
- if (local_symbol_resolved_p (locsym))
+ final_val = locsym->value;
+ if (locsym->flags.resolved)
return final_val;
- final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;
+ /* Symbols whose section has SEC_ELF_OCTETS set,
+ resolve to octets instead of target bytes. */
+ if (locsym->section->flags & SEC_OCTETS)
+ final_val += locsym->frag->fr_address;
+ else
+ final_val += locsym->frag->fr_address / OCTETS_PER_BYTE;
if (finalize_syms)
{
- locsym->lsy_value = final_val;
- local_symbol_mark_resolved (locsym);
+ locsym->value = final_val;
+ locsym->flags.resolved = 1;
}
return final_val;
}
- if (symp->sy_flags.sy_resolved)
+ if (symp->flags.resolved)
{
- if (symp->sy_value.X_op == O_constant)
- return (valueT) symp->sy_value.X_add_number;
+ final_val = 0;
+ while (symp->x->value.X_op == O_symbol)
+ {
+ final_val += symp->x->value.X_add_number;
+ symp = symp->x->value.X_add_symbol;
+ if (symp->flags.local_symbol)
+ {
+ struct local_symbol *locsym = (struct local_symbol *) symp;
+ final_val += locsym->value;
+ return final_val;
+ }
+ if (!symp->flags.resolved)
+ return 0;
+ }
+ if (symp->x->value.X_op == O_constant)
+ final_val += symp->x->value.X_add_number;
else
- return 0;
+ final_val = 0;
+ return final_val;
}
resolved = 0;
final_seg = S_GET_SEGMENT (symp);
- if (symp->sy_flags.sy_resolving)
+ if (symp->flags.resolving)
{
if (finalize_syms)
as_bad (_("symbol definition loop encountered at `%s'"),
symbolS * relc_symbol = NULL;
char * relc_symbol_name = NULL;
- relc_symbol_name = symbol_relc_make_expr (& symp->sy_value);
+ relc_symbol_name = symbol_relc_make_expr (& symp->x->value);
/* For debugging, print out conversion input & output. */
#ifdef DEBUG_SYMS
- print_expr (& symp->sy_value);
+ print_expr (& symp->x->value);
if (relc_symbol_name)
fprintf (stderr, "-> relc symbol: %s\n", relc_symbol_name);
#endif
if (relc_symbol_name != NULL)
relc_symbol = symbol_new (relc_symbol_name, undefined_section,
- 0, & zero_address_frag);
+ &zero_address_frag, 0);
if (relc_symbol == NULL)
{
{
symbol_table_insert (relc_symbol);
- /* S_CLEAR_EXTERNAL (relc_symbol); */
+ /* S_CLEAR_EXTERNAL (relc_symbol); */
if (symp->bsym->flags & BSF_SRELC)
relc_symbol->bsym->flags |= BSF_SRELC;
else
relc_symbol->bsym->flags |= BSF_RELC;
/* symp->bsym->flags |= BSF_RELC; */
copy_symbol_attributes (symp, relc_symbol);
- symp->sy_value.X_op = O_symbol;
- symp->sy_value.X_add_symbol = relc_symbol;
- symp->sy_value.X_add_number = 0;
+ symp->x->value.X_op = O_symbol;
+ symp->x->value.X_add_symbol = relc_symbol;
+ symp->x->value.X_add_number = 0;
resolved = 1;
}
+ final_val = 0;
final_seg = undefined_section;
goto exit_dont_set_value;
}
operatorT op;
int move_seg_ok;
- symp->sy_flags.sy_resolving = 1;
+ symp->flags.resolving = 1;
/* Help out with CSE. */
- add_symbol = symp->sy_value.X_add_symbol;
- op_symbol = symp->sy_value.X_op_symbol;
- final_val = symp->sy_value.X_add_number;
- op = symp->sy_value.X_op;
+ add_symbol = symp->x->value.X_add_symbol;
+ op_symbol = symp->x->value.X_op_symbol;
+ final_val = symp->x->value.X_add_number;
+ op = symp->x->value.X_op;
switch (op)
{
/* Fall through. */
case O_constant:
- final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
+ /* Symbols whose section has SEC_ELF_OCTETS set,
+ resolve to octets instead of target bytes. */
+ if (symp->bsym->section->flags & SEC_OCTETS)
+ final_val += symp->frag->fr_address;
+ else
+ final_val += symp->frag->fr_address / OCTETS_PER_BYTE;
if (final_seg == expr_section)
final_seg = absolute_section;
/* Fall through. */
case O_symbol:
case O_symbol_rva:
+ case O_secidx:
left = resolve_symbol_value (add_symbol);
seg_left = S_GET_SEGMENT (add_symbol);
if (finalize_syms)
- symp->sy_value.X_op_symbol = NULL;
+ symp->x->value.X_op_symbol = NULL;
do_symbol:
if (S_IS_WEAKREFR (symp))
gas_assert (final_val == 0);
if (S_IS_WEAKREFR (add_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;
+ gas_assert (add_symbol->x->value.X_op == O_symbol
+ && add_symbol->x->value.X_add_number == 0);
+ add_symbol = add_symbol->x->value.X_add_symbol;
gas_assert (! S_IS_WEAKREFR (add_symbol));
- symp->sy_value.X_add_symbol = add_symbol;
+ symp->x->value.X_add_symbol = add_symbol;
}
}
- if (symp->sy_flags.sy_mri_common)
+ if (symp->flags.mri_common)
{
/* This is a symbol inside an MRI common section. The
relocation routines are going to handle it specially.
break;
}
- if (finalize_syms && final_val == 0)
+ /* Don't leave symbol loops. */
+ if (finalize_syms
+ && !add_symbol->flags.local_symbol
+ && add_symbol->flags.resolving)
+ break;
+
+ if (finalize_syms && final_val == 0
+#ifdef OBJ_XCOFF
+ /* Avoid changing symp's "within" when dealing with
+ AIX debug symbols. For some storage classes, "within"
+ have a special meaning.
+ C_DWARF should behave like on Linux, thus this check
+ isn't done to be closer. */
+ && ((symbol_get_bfdsym (symp)->flags & BSF_DEBUGGING) == 0
+ || (S_GET_STORAGE_CLASS (symp) == C_DWARF))
+#endif
+ )
{
- if (LOCAL_SYMBOL_CHECK (add_symbol))
- add_symbol = local_symbol_convert ((struct local_symbol *)
- add_symbol);
+ if (add_symbol->flags.local_symbol)
+ add_symbol = local_symbol_convert (add_symbol);
copy_symbol_attributes (symp, add_symbol);
}
relocation to detect this case, and convert the
relocation to be against the symbol to which this symbol
is equated. */
- if (! S_IS_DEFINED (add_symbol)
+ if (seg_left == undefined_section
+ || bfd_is_com_section (seg_left)
#if defined (OBJ_COFF) && defined (TE_PE)
|| S_IS_WEAK (add_symbol)
#endif
- || S_IS_COMMON (add_symbol))
+ || (finalize_syms
+ && ((final_seg == expr_section
+ && seg_left != expr_section
+ && seg_left != absolute_section)
+ || symbol_shadow_p (symp))))
{
if (finalize_syms)
{
- symp->sy_value.X_op = O_symbol;
- symp->sy_value.X_add_symbol = add_symbol;
- symp->sy_value.X_add_number = final_val;
+ symp->x->value.X_op = O_symbol;
+ symp->x->value.X_add_symbol = add_symbol;
+ symp->x->value.X_add_number = final_val;
/* Use X_op_symbol as a flag. */
- symp->sy_value.X_op_symbol = add_symbol;
+ symp->x->value.X_op_symbol = add_symbol;
}
final_seg = seg_left;
- final_val = 0;
- resolved = symbol_resolved_p (add_symbol);
- symp->sy_flags.sy_resolving = 0;
- goto exit_dont_set_value;
- }
- else if (finalize_syms
- && ((final_seg == expr_section && seg_left != expr_section)
- || symbol_shadow_p (symp)))
- {
- /* If the symbol is an expression symbol, do similarly
- as for undefined and common syms above. Handles
- "sym +/- expr" where "expr" cannot be evaluated
- immediately, and we want relocations to be against
- "sym", eg. because it is weak. */
- symp->sy_value.X_op = O_symbol;
- symp->sy_value.X_add_symbol = add_symbol;
- symp->sy_value.X_add_number = final_val;
- symp->sy_value.X_op_symbol = add_symbol;
- final_seg = seg_left;
- final_val += symp->sy_frag->fr_address + left;
+ final_val += symp->frag->fr_address + left;
resolved = symbol_resolved_p (add_symbol);
- symp->sy_flags.sy_resolving = 0;
+ symp->flags.resolving = 0;
+
+ if (op == O_secidx && seg_left != undefined_section)
+ {
+ final_val = 0;
+ break;
+ }
+
goto exit_dont_set_value;
}
else
{
- final_val += symp->sy_frag->fr_address + left;
+ final_val += symp->frag->fr_address + left;
if (final_seg == expr_section || final_seg == undefined_section)
final_seg = seg_left;
}
resolved = symbol_resolved_p (add_symbol);
if (S_IS_WEAKREFR (symp))
- goto exit_dont_set_value;
+ {
+ symp->flags.resolving = 0;
+ goto exit_dont_set_value;
+ }
break;
case O_uminus:
seg_left = S_GET_SEGMENT (add_symbol);
/* By reducing these to the relevant dyadic operator, we get
- !S -> S == 0 permitted on anything,
- -S -> 0 - S only permitted on absolute
- ~S -> S ^ ~0 only permitted on absolute */
+ !S -> S == 0 permitted on anything,
+ -S -> 0 - S only permitted on absolute
+ ~S -> S ^ ~0 only permitted on absolute */
if (op != O_logical_not && seg_left != absolute_section
&& finalize_syms)
report_op_error (symp, NULL, op, add_symbol);
else
left = ~left;
- final_val += left + symp->sy_frag->fr_address;
+ final_val += left + symp->frag->fr_address;
resolved = symbol_resolved_p (add_symbol);
break;
operands must be absolute. We already handled the case of
addition or subtraction of a constant above. This will
probably need to be changed for an object file format which
- supports arbitrary expressions, such as IEEE-695. */
+ supports arbitrary expressions. */
if (!(seg_left == absolute_section
&& seg_right == absolute_section)
&& !(op == O_eq || op == O_ne)
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))
right = 1;
}
+ if ((op == O_left_shift || op == O_right_shift)
+ && (valueT) right >= sizeof (valueT) * CHAR_BIT)
+ {
+ as_warn_value_out_of_range (_("shift count"), right, 0,
+ sizeof (valueT) * CHAR_BIT - 1,
+ NULL, 0);
+ left = right = 0;
+ }
- switch (symp->sy_value.X_op)
+ switch (symp->x->value.X_op)
{
case O_multiply: left *= right; break;
case O_divide: left /= right; break;
case O_modulus: left %= right; break;
- case O_left_shift: left <<= right; break;
- case O_right_shift: left >>= right; break;
+ case O_left_shift:
+ left = (valueT) left << (valueT) right; break;
+ case O_right_shift:
+ left = (valueT) left >> (valueT) right; break;
case O_bit_inclusive_or: left |= right; break;
case O_bit_or_not: left |= ~right; break;
case O_bit_exclusive_or: left ^= right; break;
&& (seg_left != undefined_section
|| add_symbol == op_symbol)
? ~ (offsetT) 0 : 0);
- if (symp->sy_value.X_op == O_ne)
+ if (symp->x->value.X_op == O_ne)
left = ~left;
break;
case O_lt: left = left < right ? ~ (offsetT) 0 : 0; break;
case O_gt: left = left > right ? ~ (offsetT) 0 : 0; break;
case O_logical_and: left = left && right; break;
case O_logical_or: left = left || right; break;
- default: abort ();
+
+ case O_illegal:
+ case O_absent:
+ case O_constant:
+ /* See PR 20895 for a reproducer. */
+ as_bad (_("Invalid operation on symbol"));
+ goto exit_dont_set_value;
+
+ default:
+ abort ();
}
- final_val += symp->sy_frag->fr_address + left;
+ final_val += symp->frag->fr_address + left;
if (final_seg == expr_section || final_seg == undefined_section)
{
if (seg_left == undefined_section
break;
}
- symp->sy_flags.sy_resolving = 0;
+ symp->flags.resolving = 0;
}
if (finalize_syms)
S_SET_VALUE (symp, final_val);
-exit_dont_set_value:
+ exit_dont_set_value:
/* Always set the segment, even if not finalizing the value.
The segment is used to determine whether a symbol is defined. */
S_SET_SEGMENT (symp, final_seg);
if (finalize_syms)
{
if (resolved)
- symp->sy_flags.sy_resolved = 1;
+ symp->flags.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_flags.sy_resolved = 1;
+ symp->flags.resolved = 1;
}
}
return final_val;
}
-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, void *value)
+static int
+resolve_local_symbol (void **slot, void *arg ATTRIBUTE_UNUSED)
{
- if (value != NULL)
- resolve_symbol_value ((symbolS *) value);
+ symbol_entry_t *entry = *((symbol_entry_t **) slot);
+ if (entry->sy.flags.local_symbol)
+ resolve_symbol_value (&entry->sy);
+
+ return 1;
}
/* Resolve all local symbols. */
void
resolve_local_symbol_values (void)
{
- hash_traverse (local_hash, resolve_local_symbol);
+ htab_traverse (sy_hash, resolve_local_symbol, NULL);
}
/* Obtain the current value of a symbol without changing any
{
symbolS *symbolP = *symbolPP;
- if (LOCAL_SYMBOL_CHECK (symbolP))
+ if (symbolP->flags.local_symbol)
{
struct local_symbol *locsym = (struct local_symbol *) symbolP;
- *valueP = locsym->lsy_value;
- *segP = locsym->lsy_section;
- *fragPP = local_symbol_get_frag (locsym);
+ *valueP = locsym->value;
+ *segP = locsym->section;
+ *fragPP = locsym->frag;
}
else
{
- expressionS exp = symbolP->sy_value;
+ expressionS exp = symbolP->x->value;
- if (!symbolP->sy_flags.sy_resolved && exp.X_op != O_illegal)
+ if (!symbolP->flags.resolved && exp.X_op != O_illegal)
{
int resolved;
- if (symbolP->sy_flags.sy_resolving)
+ if (symbolP->flags.resolving)
return 0;
- symbolP->sy_flags.sy_resolving = 1;
+ symbolP->flags.resolving = 1;
resolved = resolve_expression (&exp);
- symbolP->sy_flags.sy_resolving = 0;
+ symbolP->flags.resolving = 0;
if (!resolved)
return 0;
case O_register:
if (!symbol_equated_p (symbolP))
break;
- /* Fall thru. */
+ /* Fallthru. */
case O_symbol:
case O_symbol_rva:
symbolP = exp.X_add_symbol;
}
*symbolPP = symbolP;
- *valueP = exp.X_add_number;
- *segP = symbolP->bsym->section;
- *fragPP = symbolP->sy_frag;
+
+ /* A bogus input file can result in resolve_expression()
+ generating a local symbol, so we have to check again. */
+ if (symbolP->flags.local_symbol)
+ {
+ struct local_symbol *locsym = (struct local_symbol *) symbolP;
+
+ *valueP = locsym->value;
+ *segP = locsym->section;
+ *fragPP = locsym->frag;
+ }
+ else
+ {
+ *valueP = exp.X_add_number;
+ *segP = symbolP->bsym->section;
+ *fragPP = symbolP->frag;
+ }
if (*segP == expr_section)
switch (exp.X_op)
the instance number, keep a list of defined symbols separate from the real
symbol table, and we treat these buggers as a sparse array. */
-static long *dollar_labels;
-static long *dollar_label_instances;
+typedef unsigned int dollar_ent;
+static dollar_ent *dollar_labels;
+static dollar_ent *dollar_label_instances;
static char *dollar_label_defines;
-static unsigned long dollar_label_count;
-static unsigned long dollar_label_max;
+static size_t dollar_label_count;
+static size_t dollar_label_max;
int
-dollar_label_defined (long label)
+dollar_label_defined (unsigned int label)
{
- long *i;
+ dollar_ent *i;
know ((dollar_labels != NULL) || (dollar_label_count == 0));
return 0;
}
-static long
-dollar_label_instance (long label)
+static unsigned int
+dollar_label_instance (unsigned int label)
{
- long *i;
+ dollar_ent *i;
know ((dollar_labels != NULL) || (dollar_label_count == 0));
void
dollar_label_clear (void)
{
- memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
+ if (dollar_label_count)
+ memset (dollar_label_defines, '\0', dollar_label_count);
}
#define DOLLAR_LABEL_BUMP_BY 10
void
-define_dollar_label (long label)
+define_dollar_label (unsigned int label)
{
- long *i;
+ dollar_ent *i;
for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
if (*i == label)
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 (dollar_ent, DOLLAR_LABEL_BUMP_BY);
+ dollar_label_instances = XNEWVEC (dollar_ent, 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 (dollar_ent, dollar_labels,
+ dollar_label_max);
+ dollar_label_instances = XRESIZEVEC (dollar_ent,
+ 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;
/* Caller must copy returned name: we re-use the area for the next name.
- The mth occurence of label n: is turned into the symbol "Ln^Am"
+ The mth occurrence of label n: is turned into the symbol "Ln^Am"
where n is the label number and m is the instance number. "L" makes
it a label discarded unless debugging and "^A"('\1') ensures no
ordinary symbol SHOULD get the same name as a local label
symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
fb labels get the same treatment, except that ^B is used in place
- of ^A. */
+ of ^A.
+
+ AUGEND is 0 for current instance, 1 for new instance. */
-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. */)
+char *
+dollar_label_name (unsigned int n, unsigned int augend)
{
- 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 symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
+ char *p = symbol_name_build;
- know (n >= 0);
- know (augend == 0 || augend == 1);
- p = symbol_name_build;
#ifdef LOCAL_LABEL_PREFIX
*p++ = LOCAL_LABEL_PREFIX;
#endif
- *p++ = 'L';
-
- /* Next code just does sprintf( {}, "%d", n); */
- /* Label number. */
- q = symbol_name_temporary;
- for (*q++ = 0, i = n; i; ++q)
- {
- *q = i % 10 + '0';
- i /= 10;
- }
- while ((*p = *--q) != '\0')
- ++p;
-
- *p++ = DOLLAR_LABEL_CHAR; /* ^A */
-
- /* Instance number. */
- q = symbol_name_temporary;
- for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
- {
- *q = i % 10 + '0';
- i /= 10;
- }
- while ((*p++ = *--q) != '\0');
-
- /* The label, as a '\0' ended string, starts at symbol_name_build. */
+ sprintf (p, "L%u%c%u",
+ n, DOLLAR_LABEL_CHAR, dollar_label_instance (n) + augend);
return symbol_name_build;
}
#define FB_LABEL_SPECIAL (10)
-static long fb_low_counter[FB_LABEL_SPECIAL];
-static long *fb_labels;
-static long *fb_label_instances;
-static long fb_label_count;
-static long fb_label_max;
+typedef unsigned int fb_ent;
+static fb_ent fb_low_counter[FB_LABEL_SPECIAL];
+static fb_ent *fb_labels;
+static fb_ent *fb_label_instances;
+static size_t fb_label_count;
+static size_t fb_label_max;
/* This must be more than FB_LABEL_SPECIAL. */
#define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
/* Add one to the instance number of this fb label. */
void
-fb_label_instance_inc (long label)
+fb_label_instance_inc (unsigned int label)
{
- long *i;
+ fb_ent *i;
- if ((unsigned long) label < FB_LABEL_SPECIAL)
+ if (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 (fb_ent, FB_LABEL_BUMP_BY);
+ fb_label_instances = XNEWVEC (fb_ent, 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 (fb_ent, fb_labels, fb_label_max);
+ fb_label_instances = XRESIZEVEC (fb_ent, fb_label_instances,
+ fb_label_max);
} /* if we needed to grow */
fb_labels[fb_label_count] = label;
++fb_label_count;
}
-static long
-fb_label_instance (long label)
+static unsigned int
+fb_label_instance (unsigned int label)
{
- long *i;
+ fb_ent *i;
- if ((unsigned long) label < FB_LABEL_SPECIAL)
- {
- return (fb_low_counter[label]);
- }
+ if (label < FB_LABEL_SPECIAL)
+ return (fb_low_counter[label]);
if (fb_labels != NULL)
{
i < fb_labels + fb_label_count; ++i)
{
if (*i == label)
- {
- return (fb_label_instances[i - fb_labels]);
- } /* if we find it */
- } /* for each existing label */
+ return (fb_label_instances[i - fb_labels]);
+ }
}
/* We didn't find the label, so this must be a reference to the
/* Caller must copy returned name: we re-use the area for the next name.
- The mth occurence of label n: is turned into the symbol "Ln^Bm"
+ The mth occurrence of label n: is turned into the symbol "Ln^Bm"
where n is the label number and m is the instance number. "L" makes
it a label discarded unless debugging and "^B"('\2') ensures no
ordinary symbol SHOULD get the same name as a local label
symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
dollar labels get the same treatment, except that ^A is used in
- place of ^B. */
+ place of ^B.
+
+ AUGEND is 0 for nb, 1 for n:, nf. */
-char * /* Return local label name. */
-fb_label_name (long n, /* We just saw "n:", "nf" or "nb" : n a number. */
- long augend /* 0 for nb, 1 for n:, nf. */)
+char *
+fb_label_name (unsigned int n, unsigned int augend)
{
- 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 symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
+ char *p = symbol_name_build;
- know (n >= 0);
#ifdef TC_MMIX
- know ((unsigned long) augend <= 2 /* See mmix_fb_label. */);
+ know (augend <= 2 /* See mmix_fb_label. */);
#else
- know ((unsigned long) augend <= 1);
+ know (augend <= 1);
#endif
- p = symbol_name_build;
+
#ifdef LOCAL_LABEL_PREFIX
*p++ = LOCAL_LABEL_PREFIX;
#endif
- *p++ = 'L';
-
- /* Next code just does sprintf( {}, "%d", n); */
- /* Label number. */
- q = symbol_name_temporary;
- for (*q++ = 0, i = n; i; ++q)
- {
- *q = i % 10 + '0';
- i /= 10;
- }
- while ((*p = *--q) != '\0')
- ++p;
-
- *p++ = LOCAL_LABEL_CHAR; /* ^B */
-
- /* Instance number. */
- q = symbol_name_temporary;
- for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
- {
- *q = i % 10 + '0';
- i /= 10;
- }
- while ((*p++ = *--q) != '\0');
-
- /* The label, as a '\0' ended string, starts at symbol_name_build. */
- return (symbol_name_build);
+ sprintf (p, "L%u%c%u",
+ n, LOCAL_LABEL_CHAR, fb_label_instance (n) + augend);
+ return symbol_name_build;
}
/* Decode name that may have been generated by foo_label_name() above.
char *symbol_decode;
int label_number;
int instance_number;
- char *type;
+ const char *type;
const char *message_format;
int lindex = 0;
valueT
S_GET_VALUE (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return resolve_symbol_value (s);
- if (!s->sy_flags.sy_resolved)
+ if (!s->flags.resolved)
{
valueT val = resolve_symbol_value (s);
if (!finalize_syms)
return val;
}
if (S_IS_WEAKREFR (s))
- return S_GET_VALUE (s->sy_value.X_add_symbol);
+ return S_GET_VALUE (s->x->value.X_add_symbol);
- if (s->sy_value.X_op != O_constant)
+ if (s->x->value.X_op != O_constant)
{
- if (! s->sy_flags.sy_resolved
- || s->sy_value.X_op != O_symbol
+ if (! s->flags.resolved
+ || s->x->value.X_op != O_symbol
|| (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
as_bad (_("attempt to get value of unresolved symbol `%s'"),
S_GET_NAME (s));
}
- return (valueT) s->sy_value.X_add_number;
+ return (valueT) s->x->value.X_add_number;
}
/* Set the value of a symbol. */
void
S_SET_VALUE (symbolS *s, valueT val)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
{
- ((struct local_symbol *) s)->lsy_value = val;
+ ((struct local_symbol *) s)->value = val;
return;
}
- s->sy_value.X_op = O_constant;
- s->sy_value.X_add_number = (offsetT) val;
- s->sy_value.X_unsigned = 0;
+ s->x->value.X_op = O_constant;
+ s->x->value.X_add_number = (offsetT) val;
+ s->x->value.X_unsigned = 0;
S_CLEAR_WEAKREFR (s);
}
void
copy_symbol_attributes (symbolS *dest, symbolS *src)
{
- if (LOCAL_SYMBOL_CHECK (dest))
- dest = local_symbol_convert ((struct local_symbol *) dest);
- if (LOCAL_SYMBOL_CHECK (src))
- src = local_symbol_convert ((struct local_symbol *) src);
+ if (dest->flags.local_symbol)
+ dest = local_symbol_convert (dest);
+ if (src->flags.local_symbol)
+ src = local_symbol_convert (src);
/* In an expression, transfer the settings of these flags.
The user can override later, of course. */
{
flagword flags;
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
flags = s->bsym->flags;
{
flagword flags;
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
flags = s->bsym->flags;
int
S_IS_WEAK (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
/* Conceptually, a weakrefr is weak if the referenced symbol is. We
could probably handle a WEAKREFR as always weak though. E.g., if
the referenced symbol has lost its weak status, there's no reason
to keep handling the weakrefr as if it was weak. */
if (S_IS_WEAKREFR (s))
- return S_IS_WEAK (s->sy_value.X_add_symbol);
+ return S_IS_WEAK (s->x->value.X_add_symbol);
return (s->bsym->flags & BSF_WEAK) != 0;
}
int
S_IS_WEAKREFR (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
- return s->sy_flags.sy_weakrefr != 0;
+ return s->flags.weakrefr != 0;
}
int
S_IS_WEAKREFD (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
- return s->sy_flags.sy_weakrefd != 0;
+ return s->flags.weakrefd != 0;
}
int
S_IS_COMMON (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
return bfd_is_com_section (s->bsym->section);
}
int
S_IS_DEFINED (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- return ((struct local_symbol *) s)->lsy_section != undefined_section;
+ if (s->flags.local_symbol)
+ return ((struct local_symbol *) s)->section != undefined_section;
return s->bsym->section != undefined_section;
}
int
S_FORCE_RELOC (symbolS *s, int strict)
{
- if (LOCAL_SYMBOL_CHECK (s))
- return ((struct local_symbol *) s)->lsy_section == undefined_section;
-
- return ((strict
+ segT sec;
+ if (s->flags.local_symbol)
+ sec = ((struct local_symbol *) s)->section;
+ else
+ {
+ if ((strict
&& ((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->bsym->flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
+ return true;
+ sec = s->bsym->section;
+ }
+ return bfd_is_und_section (sec) || bfd_is_com_section (sec);
}
int
S_IS_DEBUG (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
if (s->bsym->flags & BSF_DEBUGGING)
return 1;
flagword flags;
const char *name;
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 1;
flags = s->bsym->flags;
if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
abort ();
- if (bfd_get_section (s->bsym) == reg_section)
+ if (bfd_asymbol_section (s->bsym) == reg_section)
return 1;
if (flag_strip_local_absolute
/* Keep BSF_FILE symbols in order to allow debuggers to identify
the source file even when the object file is stripped. */
&& (flags & (BSF_GLOBAL | BSF_FILE)) == 0
- && bfd_get_section (s->bsym) == absolute_section)
+ && bfd_asymbol_section (s->bsym) == absolute_section)
return 1;
name = S_GET_NAME (s);
&& ! S_IS_DEBUG (s)
&& (strchr (name, DOLLAR_LABEL_CHAR)
|| strchr (name, LOCAL_LABEL_CHAR)
+#if FAKE_LABEL_CHAR != DOLLAR_LABEL_CHAR
+ || strchr (name, FAKE_LABEL_CHAR)
+#endif
|| TC_LABEL_IS_LOCAL (name)
|| (! flag_keep_locals
&& (bfd_is_local_label (stdoutput, s->bsym)
int
S_CAN_BE_REDEFINED (const symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- return (local_symbol_get_frag ((struct local_symbol *) s)
+ if (s->flags.local_symbol)
+ return (((struct local_symbol *) s)->frag
== &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))
+ if (s->flags.local_symbol)
return 0;
- return s->sy_flags.sy_volatile;
+ return s->flags.volatil;
}
int
S_IS_FORWARD_REF (const symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
- return s->sy_flags.sy_forward_ref;
+ return s->flags.forward_ref;
}
const char *
S_GET_NAME (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- return ((struct local_symbol *) s)->lsy_name;
- return s->bsym->name;
+ return s->name;
}
segT
S_GET_SEGMENT (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- return ((struct local_symbol *) s)->lsy_section;
+ if (s->flags.local_symbol)
+ return ((struct local_symbol *) s)->section;
return s->bsym->section;
}
void
S_SET_SEGMENT (symbolS *s, segT seg)
{
- /* Don't reassign section symbols. The direct reason is to prevent seg
- faults assigning back to const global symbols such as *ABS*, but it
- shouldn't happen anyway. */
-
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
{
- if (seg == reg_section)
- s = local_symbol_convert ((struct local_symbol *) s);
- else
- {
- ((struct local_symbol *) s)->lsy_section = seg;
- return;
- }
+ ((struct local_symbol *) s)->section = seg;
+ return;
}
+ /* Don't reassign section symbols. The direct reason is to prevent seg
+ faults assigning back to const global symbols such as *ABS*, but it
+ shouldn't happen anyway. */
if (s->bsym->flags & BSF_SECTION_SYM)
{
if (s->bsym->section != seg)
abort ();
}
else
- s->bsym->section = seg;
+ {
+ if (multibyte_handling == multibyte_warn_syms
+ && ! s->flags.local_symbol
+ && seg != undefined_section
+ && ! s->flags.multibyte_warned
+ && scan_for_multibyte_characters ((const unsigned char *) s->name,
+ (const unsigned char *) s->name + strlen (s->name),
+ false))
+ {
+ as_warn (_("symbol '%s' contains multibyte characters"), s->name);
+ s->flags.multibyte_warned = 1;
+ }
+
+ s->bsym->section = seg;
+ }
}
void
S_SET_EXTERNAL (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
if ((s->bsym->flags & BSF_WEAK) != 0)
{
/* Let .weak override .global. */
}
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 (_("can't make section symbol 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));
+ as_bad (_("can't make register symbol global"));
return;
}
#endif
void
S_CLEAR_EXTERNAL (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return;
if ((s->bsym->flags & BSF_WEAK) != 0)
{
void
S_SET_WEAK (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
#ifdef obj_set_weak_hook
obj_set_weak_hook (s);
#endif
void
S_SET_WEAKREFR (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_flags.sy_weakrefr = 1;
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
+ s->flags.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_flags.sy_used)
- symbol_mark_used (s->sy_value.X_add_symbol);
+ if (s->flags.used)
+ symbol_mark_used (s->x->value.X_add_symbol);
}
void
S_CLEAR_WEAKREFR (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return;
- s->sy_flags.sy_weakrefr = 0;
+ s->flags.weakrefr = 0;
}
void
S_SET_WEAKREFD (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_flags.sy_weakrefd = 1;
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
+ s->flags.weakrefd = 1;
S_SET_WEAK (s);
}
void
S_CLEAR_WEAKREFD (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return;
- if (s->sy_flags.sy_weakrefd)
+ if (s->flags.weakrefd)
{
- s->sy_flags.sy_weakrefd = 0;
+ s->flags.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
void
S_SET_THREAD_LOCAL (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
if (bfd_is_com_section (s->bsym->section)
&& (s->bsym->flags & BSF_THREAD_LOCAL) != 0)
return;
void
S_SET_NAME (symbolS *s, const char *name)
{
- if (LOCAL_SYMBOL_CHECK (s))
- {
- ((struct local_symbol *) s)->lsy_name = name;
- return;
- }
+ s->name = name;
+ if (s->flags.local_symbol)
+ return;
s->bsym->name = name;
}
void
S_SET_VOLATILE (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_flags.sy_volatile = 1;
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
+ s->flags.volatil = 1;
}
void
S_CLEAR_VOLATILE (symbolS *s)
{
- if (!LOCAL_SYMBOL_CHECK (s))
- s->sy_flags.sy_volatile = 0;
+ if (!s->flags.local_symbol)
+ s->flags.volatil = 0;
}
void
S_SET_FORWARD_REF (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_flags.sy_forward_ref = 1;
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
+ s->flags.forward_ref = 1;
}
/* Return the previous symbol in a chain. */
symbolS *
symbol_previous (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
abort ();
- return s->sy_previous;
+ return s->x->previous;
}
/* Return the next symbol in a chain. */
symbolS *
symbol_next (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
abort ();
- return s->sy_next;
+ return s->x->next;
}
/* Return a pointer to the value of a symbol as an expression. */
expressionS *
symbol_get_value_expression (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
- return &s->sy_value;
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
+ return &s->x->value;
}
/* Set the value of a symbol to an expression. */
void
symbol_set_value_expression (symbolS *s, const expressionS *exp)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_value = *exp;
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
+ s->x->value = *exp;
S_CLEAR_WEAKREFR (s);
}
int
symbol_same_p (symbolS *s1, symbolS *s2)
{
- 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->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;
}
offsetT *
symbol_X_add_number (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- return (offsetT *) &((struct local_symbol *) s)->lsy_value;
+ if (s->flags.local_symbol)
+ return (offsetT *) &((struct local_symbol *) s)->value;
- return &s->sy_value.X_add_number;
+ return &s->x->value.X_add_number;
}
/* Set the value of SYM to the current position in the current segment. */
void
symbol_set_frag (symbolS *s, fragS *f)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
{
- local_symbol_set_frag ((struct local_symbol *) s, f);
+ ((struct local_symbol *) s)->frag = f;
return;
}
- s->sy_frag = f;
+ s->frag = f;
S_CLEAR_WEAKREFR (s);
}
fragS *
symbol_get_frag (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- return local_symbol_get_frag ((struct local_symbol *) s);
- return s->sy_frag;
+ if (s->flags.local_symbol)
+ return ((struct local_symbol *) s)->frag;
+ return s->frag;
}
/* Mark a symbol as having been used. */
void
symbol_mark_used (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return;
- s->sy_flags.sy_used = 1;
+ s->flags.used = 1;
if (S_IS_WEAKREFR (s))
- symbol_mark_used (s->sy_value.X_add_symbol);
+ symbol_mark_used (s->x->value.X_add_symbol);
}
/* Clear the mark of whether a symbol has been used. */
void
symbol_clear_used (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_flags.sy_used = 0;
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
+ s->flags.used = 0;
}
/* Return whether a symbol has been used. */
int
symbol_used_p (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 1;
- return s->sy_flags.sy_used;
+ return s->flags.used;
}
/* Mark a symbol as having been used in a reloc. */
void
symbol_mark_used_in_reloc (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_flags.sy_used_in_reloc = 1;
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
+ s->flags.used_in_reloc = 1;
}
/* Clear the mark of whether a symbol has been used in a reloc. */
void
symbol_clear_used_in_reloc (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return;
- s->sy_flags.sy_used_in_reloc = 0;
+ s->flags.used_in_reloc = 0;
}
/* Return whether a symbol has been used in a reloc. */
int
symbol_used_in_reloc_p (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
- return s->sy_flags.sy_used_in_reloc;
+ return s->flags.used_in_reloc;
}
/* Mark a symbol as an MRI common symbol. */
void
symbol_mark_mri_common (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_flags.sy_mri_common = 1;
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
+ s->flags.mri_common = 1;
}
/* Clear the mark of whether a symbol is an MRI common symbol. */
void
symbol_clear_mri_common (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return;
- s->sy_flags.sy_mri_common = 0;
+ s->flags.mri_common = 0;
}
/* Return whether a symbol is an MRI common symbol. */
int
symbol_mri_common_p (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
- return s->sy_flags.sy_mri_common;
+ return s->flags.mri_common;
}
/* Mark a symbol as having been written. */
void
symbol_mark_written (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return;
- s->sy_flags.sy_written = 1;
+ s->flags.written = 1;
}
/* Clear the mark of whether a symbol has been written. */
void
symbol_clear_written (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return;
- s->sy_flags.sy_written = 0;
+ s->flags.written = 0;
}
/* Return whether a symbol has been written. */
int
symbol_written_p (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
+ return 0;
+ return s->flags.written;
+}
+
+/* Mark a symbol as to be removed. */
+
+void
+symbol_mark_removed (symbolS *s)
+{
+ if (s->flags.local_symbol)
+ return;
+ s->flags.removed = 1;
+}
+
+/* Return whether a symbol has been marked to be removed. */
+
+int
+symbol_removed_p (symbolS *s)
+{
+ if (s->flags.local_symbol)
return 0;
- return s->sy_flags.sy_written;
+ return s->flags.removed;
}
/* Mark a symbol has having been resolved. */
void
symbol_mark_resolved (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- {
- local_symbol_mark_resolved ((struct local_symbol *) s);
- return;
- }
- s->sy_flags.sy_resolved = 1;
+ s->flags.resolved = 1;
}
/* Return whether a symbol has been resolved. */
int
symbol_resolved_p (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- return local_symbol_resolved_p ((struct local_symbol *) s);
- return s->sy_flags.sy_resolved;
+ return s->flags.resolved;
}
/* Return whether a symbol is a section symbol. */
int
-symbol_section_p (symbolS *s ATTRIBUTE_UNUSED)
+symbol_section_p (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
return (s->bsym->flags & BSF_SECTION_SYM) != 0;
}
int
symbol_equated_p (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
- return s->sy_value.X_op == O_symbol;
+ return s->x->value.X_op == O_symbol;
}
/* Return whether a symbol is equated to another symbol, and should be
int
symbol_equated_reloc_p (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
/* X_op_symbol, normally not used for O_symbol, is set by
resolve_symbol_value to flag expression syms that have been
equated. */
- return (s->sy_value.X_op == O_symbol
+ return (s->x->value.X_op == O_symbol
#if defined (OBJ_COFF) && defined (TE_PE)
&& ! S_IS_WEAK (s)
#endif
- && ((s->sy_flags.sy_resolved && s->sy_value.X_op_symbol != NULL)
+ && ((s->flags.resolved && s->x->value.X_op_symbol != NULL)
|| ! S_IS_DEFINED (s)
|| S_IS_COMMON (s)));
}
int
symbol_constant_p (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 1;
- return s->sy_value.X_op == O_constant;
+ return s->x->value.X_op == O_constant;
}
/* Return whether a symbol was cloned and thus removed from the global
int
symbol_shadow_p (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return 0;
- return s->sy_next == s;
+ return s->x->next == s;
+}
+
+/* If S is a struct symbol return S, otherwise return NULL. */
+
+symbolS *
+symbol_symbolS (symbolS *s)
+{
+ if (s->flags.local_symbol)
+ return NULL;
+ return s;
}
/* Return the BFD symbol for a symbol. */
asymbol *
symbol_get_bfdsym (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
return s->bsym;
}
void
symbol_set_bfdsym (symbolS *s, asymbol *bsym)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
/* Usually, it is harmless to reset a symbol to a BFD section
symbol. For example, obj_elf_change_section sets the BFD symbol
of an old symbol with the newly created section symbol. But when
OBJ_SYMFIELD_TYPE *
symbol_get_obj (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
- return &s->sy_obj;
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
+ return &s->x->obj;
}
/* Set the object format information for a symbol. */
void
symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPE *o)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_obj = *o;
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
+ s->x->obj = *o;
}
#endif /* OBJ_SYMFIELD_TYPE */
TC_SYMFIELD_TYPE *
symbol_get_tc (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
- return &s->sy_tc;
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
+ return &s->x->tc;
}
/* Set the processor information for a symbol. */
void
symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)
{
- if (LOCAL_SYMBOL_CHECK (s))
- s = local_symbol_convert ((struct local_symbol *) s);
- s->sy_tc = *o;
+ if (s->flags.local_symbol)
+ s = local_symbol_convert (s);
+ s->x->tc = *o;
}
#endif /* TC_SYMFIELD_TYPE */
{
symbol_lastP = NULL;
symbol_rootP = NULL; /* In case we have 0 symbols (!!) */
- sy_hash = hash_new ();
- local_hash = hash_new ();
+ sy_hash = htab_create_alloc (16, hash_symbol_entry, eq_symbol_entry,
+ NULL, xcalloc, free);
- memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
#if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_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;
+ abs_symbol.x = &abs_symbol_x;
+ abs_symbol.x->value.X_op = O_constant;
+ abs_symbol.frag = &zero_address_frag;
if (LOCAL_LABELS_FB)
fb_label_init ();
void
dot_symbol_init (void)
{
+ dot_symbol.name = ".";
+ dot_symbol.flags.forward_ref = 1;
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_flags.sy_forward_ref = 1;
- dot_symbol.sy_value.X_op = O_constant;
+ dot_symbol.x = &dot_symbol_x;
+ dot_symbol.x->value.X_op = O_constant;
}
\f
int indent_level;
fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym));
fprintf (file, " %s", name);
- if (LOCAL_SYMBOL_CHECK (sym))
+ if (sym->flags.local_symbol)
{
struct local_symbol *locsym = (struct local_symbol *) sym;
- if (local_symbol_get_frag (locsym) != & zero_address_frag
- && local_symbol_get_frag (locsym) != NULL)
+ if (locsym->frag != &zero_address_frag
+ && locsym->frag != NULL)
{
fprintf (file, " frag ");
- fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) local_symbol_get_frag (locsym)));
- }
- if (local_symbol_resolved_p (locsym))
+ fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) locsym->frag));
+ }
+ if (locsym->flags.resolved)
fprintf (file, " resolved");
fprintf (file, " local");
}
else
{
- if (sym->sy_frag != &zero_address_frag)
+ if (sym->frag != &zero_address_frag)
{
fprintf (file, " frag ");
- fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym->sy_frag));
+ fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym->frag));
}
- if (sym->sy_flags.sy_written)
+ if (sym->flags.written)
fprintf (file, " written");
- if (sym->sy_flags.sy_resolved)
+ if (sym->flags.resolved)
fprintf (file, " resolved");
- else if (sym->sy_flags.sy_resolving)
+ else if (sym->flags.resolving)
fprintf (file, " resolving");
- if (sym->sy_flags.sy_used_in_reloc)
+ if (sym->flags.used_in_reloc)
fprintf (file, " used-in-reloc");
- if (sym->sy_flags.sy_used)
+ if (sym->flags.used)
fprintf (file, " used");
if (S_IS_LOCAL (sym))
fprintf (file, " local");
{
indent_level++;
fprintf (file, "\n%*s<", indent_level * 4, "");
- if (LOCAL_SYMBOL_CHECK (sym))
+ if (sym->flags.local_symbol)
fprintf (file, "constant %lx",
- (unsigned long) ((struct local_symbol *) sym)->lsy_value);
+ (unsigned long) ((struct local_symbol *) sym)->value);
else
- print_expr_1 (file, &sym->sy_value);
+ print_expr_1 (file, &sym->x->value);
fprintf (file, ">");
indent_level--;
}
void
symbol_print_statistics (FILE *file)
{
- hash_print_statistics (file, "symbol table", sy_hash);
- hash_print_statistics (file, "mini local symbol table", local_hash);
+ htab_print_statistics (file, "symbol table", sy_hash);
fprintf (file, "%lu mini local symbols created, %lu converted\n",
local_symbol_count, local_symbol_conversion_count);
}
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
- is marked with sy_used_in_reloc. */
+ is marked with used_in_reloc. */
char *
symbol_relc_make_sym (symbolS * sym)
is defined as an expression or a plain value. */
if ( S_GET_SEGMENT (sym) == expr_section
|| S_GET_SEGMENT (sym) == absolute_section)
- return symbol_relc_make_expr (& sym->sy_value);
+ return symbol_relc_make_expr (symbol_get_value_expression (sym));
- /* This may be a "fake symbol" L0\001, referring to ".".
+ /* This may be a "fake symbol", referring to ".".
Write out a special null symbol to refer to this position. */
if (! strcmp (S_GET_NAME (sym), FAKE_LABEL_NAME))
return xstrdup (".");
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;
/* Helper macros for nesting nodes. */
-#define HANDLE_XADD_OPT1(str_) \
+#define HANDLE_XADD_OPT1(str_) \
if (exp->X_add_number) \
- { \
- arity = 2; \
- opstr = "+:" str_; \
- operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
- operands[1] = symbol_relc_make_value (exp->X_add_number); \
- break; \
- } \
+ { \
+ arity = 2; \
+ opstr = "+:" str_; \
+ operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
+ operands[1] = symbol_relc_make_value (exp->X_add_number); \
+ break; \
+ } \
else \
- { \
- arity = 1; \
- opstr = str_; \
- operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
- } \
+ { \
+ arity = 1; \
+ opstr = str_; \
+ operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
+ } \
break
-#define HANDLE_XADD_OPT2(str_) \
+#define HANDLE_XADD_OPT2(str_) \
if (exp->X_add_number) \
- { \
- arity = 3; \
- opstr = "+:" str_; \
- operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
- operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
- operands[2] = symbol_relc_make_value (exp->X_add_number); \
- } \
+ { \
+ arity = 3; \
+ opstr = "+:" str_; \
+ operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
+ operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
+ operands[2] = symbol_relc_make_value (exp->X_add_number); \
+ } \
else \
- { \
- arity = 2; \
- opstr = str_; \
- operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
- operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
- } \
+ { \
+ arity = 2; \
+ opstr = str_; \
+ operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
+ operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
+ } \
break
/* Nesting nodes. */
- case O_uminus: HANDLE_XADD_OPT1 ("0-");
- case O_bit_not: HANDLE_XADD_OPT1 ("~");
- case O_logical_not: HANDLE_XADD_OPT1 ("!");
- case O_multiply: HANDLE_XADD_OPT2 ("*");
- case O_divide: HANDLE_XADD_OPT2 ("/");
- case O_modulus: HANDLE_XADD_OPT2 ("%");
- case O_left_shift: HANDLE_XADD_OPT2 ("<<");
- case O_right_shift: HANDLE_XADD_OPT2 (">>");
+ case O_uminus: HANDLE_XADD_OPT1 ("0-");
+ case O_bit_not: HANDLE_XADD_OPT1 ("~");
+ case O_logical_not: HANDLE_XADD_OPT1 ("!");
+ case O_multiply: HANDLE_XADD_OPT2 ("*");
+ case O_divide: HANDLE_XADD_OPT2 ("/");
+ case O_modulus: HANDLE_XADD_OPT2 ("%");
+ case O_left_shift: HANDLE_XADD_OPT2 ("<<");
+ case O_right_shift: HANDLE_XADD_OPT2 (">>");
case O_bit_inclusive_or: HANDLE_XADD_OPT2 ("|");
case O_bit_exclusive_or: HANDLE_XADD_OPT2 ("^");
- case O_bit_and: HANDLE_XADD_OPT2 ("&");
- case O_add: HANDLE_XADD_OPT2 ("+");
- case O_subtract: HANDLE_XADD_OPT2 ("-");
- case O_eq: HANDLE_XADD_OPT2 ("==");
- case O_ne: HANDLE_XADD_OPT2 ("!=");
- case O_lt: HANDLE_XADD_OPT2 ("<");
- case O_le: HANDLE_XADD_OPT2 ("<=");
- case O_ge: HANDLE_XADD_OPT2 (">=");
- case O_gt: HANDLE_XADD_OPT2 (">");
- case O_logical_and: HANDLE_XADD_OPT2 ("&&");
- case O_logical_or: HANDLE_XADD_OPT2 ("||");
+ case O_bit_and: HANDLE_XADD_OPT2 ("&");
+ case O_add: HANDLE_XADD_OPT2 ("+");
+ case O_subtract: HANDLE_XADD_OPT2 ("-");
+ case O_eq: HANDLE_XADD_OPT2 ("==");
+ case O_ne: HANDLE_XADD_OPT2 ("!=");
+ case O_lt: HANDLE_XADD_OPT2 ("<");
+ case O_le: HANDLE_XADD_OPT2 ("<=");
+ case O_ge: HANDLE_XADD_OPT2 (">=");
+ case O_gt: HANDLE_XADD_OPT2 (">");
+ case O_logical_and: HANDLE_XADD_OPT2 ("&&");
+ case O_logical_or: HANDLE_XADD_OPT2 ("||");
}
/* Validate & reject early. */
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 / binutils.git / blobdiff