#include "subsegs.h"
#include "write.h"
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+#ifndef CHAR_BIT
+#define CHAR_BIT 8
+#endif
+
struct symbol_flags
{
/* Whether the symbol is a local_symbol. */
- unsigned int sy_local_symbol : 1;
+ unsigned int local_symbol : 1;
/* Weather symbol has been written. */
- unsigned int sy_written : 1;
+ unsigned int written : 1;
/* Whether symbol value has been completely resolved (used during
final pass over symbol table). */
- unsigned int sy_resolved : 1;
+ unsigned int resolved : 1;
/* Whether the symbol value is currently being resolved (used to
detect loops in symbol dependencies). */
- unsigned int sy_resolving : 1;
+ 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 sy_used_in_reloc : 1;
+ 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 sy_used : 1;
+ unsigned int used : 1;
/* Whether the symbol can be re-defined. */
- unsigned int sy_volatile : 1;
+ unsigned int volatil : 1;
/* Whether the symbol is a forward reference. */
- unsigned int sy_forward_ref : 1;
+ unsigned int forward_ref : 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 sy_mri_common : 1;
+ unsigned int mri_common : 1;
/* This is set if the symbol is set with a .weakref directive. */
- unsigned int sy_weakrefr : 1;
+ 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 sy_weakrefd : 1;
+ unsigned int weakrefd : 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. Note that the symbol table
- holds pointers both to this and to local_symbol structures. See
- below. */
+/* 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 sy_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;
- /* The value of the symbol. */
- expressionS sy_value;
+ /* Extra symbol fields that won't fit. */
+ struct xsymbol *x;
+};
- /* Forwards and (optionally) backwards chain pointers. */
- struct symbol *sy_next;
- struct symbol *sy_previous;
+/* Extra fields to make up a full symbol. */
- /* Pointer to the frag this symbol is attached to, if any.
- Otherwise, NULL. */
- struct frag *sy_frag;
+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 sy_obj;
+ OBJ_SYMFIELD_TYPE obj;
#endif
#ifdef TC_SYMFIELD_TYPE
- TC_SYMFIELD_TYPE sy_tc;
-#endif
-
-#ifdef TARGET_SYMBOL_FIELDS
- TARGET_SYMBOL_FIELDS
+ TC_SYMFIELD_TYPE tc;
#endif
};
-/* A pointer in the symbol may point to either a complete symbol
- (struct symbol above) 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.
+typedef union symbol_entry
+{
+ struct local_symbol lsy;
+ struct symbol sy;
+} symbol_entry_t;
- 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. */
+/* Hash function for a symbol_entry. */
-struct local_symbol
+static hashval_t
+hash_symbol_entry (const void *e)
{
- /* Symbol flags. Only sy_local_symbol and sy_resolved are relevant. */
- struct symbol_flags lsy_flags;
+ symbol_entry_t *entry = (symbol_entry_t *) e;
+ if (entry->sy.hash == 0)
+ entry->sy.hash = htab_hash_string (entry->sy.name);
- /* The symbol section. This also serves as a flag. If this is
- reg_section, then this symbol has been converted into a regular
- symbol, and lsy_sym points to it. */
- segT lsy_section;
+ return entry->sy.hash;
+}
- /* The symbol name. */
- const char *lsy_name;
+/* Equality function for a symbol_entry. */
- /* The symbol frag or the real symbol, depending upon the value in
- lsy_section. */
- union
- {
- fragS *lsy_frag;
- symbolS *lsy_sym;
- } u;
+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;
- /* The value of the symbol. */
- valueT lsy_value;
+ return (ea->sy.hash == eb->sy.hash
+ && strcmp (ea->sy.name, eb->sy.name) == 0);
+}
-#ifdef TC_LOCAL_SYMFIELD_TYPE
- TC_LOCAL_SYMFIELD_TYPE lsy_tc;
-#endif
-};
+static void *
+symbol_entry_find (htab_t table, const char *name)
+{
+ hashval_t hash = htab_hash_string (name);
+ symbol_entry_t needle = { { { 0 }, hash, name, 0, 0, 0 } };
+ return htab_find_with_hash (table, &needle, hash);
+}
-#define local_symbol_converted_p(l) ((l)->lsy_section == reg_section)
-#define local_symbol_mark_converted(l) ((l)->lsy_section = reg_section)
-#define local_symbol_resolved_p(l) ((l)->lsy_flags.sy_resolved)
-#define local_symbol_mark_resolved(l) ((l)->lsy_flags.sy_resolved = 1)
-#define local_symbol_get_frag(l) ((l)->u.lsy_frag)
-#define local_symbol_set_frag(l, f) ((l)->u.lsy_frag = (f))
-#define local_symbol_get_real_symbol(l) ((l)->u.lsy_sym)
-#define local_symbol_set_real_symbol(l, s) ((l)->u.lsy_sym = (s))
/* 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
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;
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)
{
- const 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;
- 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)
{
const char *name_copy;
struct local_symbol *ret;
- struct symbol_flags flags = { .sy_local_symbol = 1, .sy_resolved = 0 };
+ 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 = flags;
- 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);
}
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
{
/* 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)
{
- 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
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;
}
-/* If S is a local symbol that has been converted, return the
- converted symbol. Otherwise return S. */
-
-static inline symbolS *
-get_real_sym (symbolS *s)
-{
- if (s != NULL
- && s->sy_flags.sy_local_symbol
- && local_symbol_converted_p ((struct local_symbol *) s))
- s = local_symbol_get_real_symbol ((struct local_symbol *) s);
- return s;
-}
-
/* 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 is saved by the clone. */
symbolS *
symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
{
- if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
+ if (symbolP && !symbolP->flags.local_symbol)
{
- symbolS *orig_add_symbol = get_real_sym (symbolP->sy_value.X_add_symbol);
- symbolS *orig_op_symbol = get_real_sym (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
+ 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;
}
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_fix_octets (), frag_now);
+ 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
*copy++ = TOUPPER (c);
*copy = '\0';
- if (copy2 != NULL)
- free (copy2);
+ free (copy2);
copy = (char *) name;
}
result = symbol_find_exact_noref (name, noref);
- if (copy != NULL)
- free (copy);
+ free (copy);
return result;
}
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 (!LOCAL_SYMBOL_CHECK (s)
- && ((s->sy_next != s
- && s->sy_next != NULL
- && s->sy_next->sy_previous == s)
+ return (!s->flags.local_symbol
+ && ((s->x->next != s
+ && s->x->next != NULL
+ && s->x->next->x->previous == s)
|| s == lastPP)
- && ((s->sy_previous != s
- && s->sy_previous != NULL
- && s->sy_previous->sy_next == s)
+ && ((s->x->previous != s
+ && s->x->previous != NULL
+ && s->x->previous->x->next == s)
|| s == rootPP));
}
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_gt:
case O_logical_and:
case O_logical_or:
- if ((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_op_symbol)
- && S_GET_SEGMENT (symp->sy_value.X_op_symbol) != expr_section)
+ 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->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)
+ 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;
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;
/* Symbols whose section has SEC_ELF_OCTETS set,
resolve to octets instead of target bytes. */
- if (locsym->lsy_section->flags & SEC_OCTETS)
- final_val += local_symbol_get_frag (locsym)->fr_address;
+ if (locsym->section->flags & SEC_OCTETS)
+ final_val += locsym->frag->fr_address;
else
- final_val += (local_symbol_get_frag (locsym)->fr_address
- / OCTETS_PER_BYTE);
+ 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)
{
final_val = 0;
- while (symp->sy_value.X_op == O_symbol)
+ while (symp->x->value.X_op == O_symbol)
{
- final_val += symp->sy_value.X_add_number;
- symp = symp->sy_value.X_add_symbol;
- if (LOCAL_SYMBOL_CHECK (symp))
+ 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->lsy_value;
+ final_val += locsym->value;
return final_val;
}
- if (!symp->sy_flags.sy_resolved)
+ if (!symp->flags.resolved)
return 0;
}
- if (symp->sy_value.X_op == O_constant)
- final_val += symp->sy_value.X_add_number;
+ if (symp->x->value.X_op == O_constant)
+ final_val += symp->x->value.X_add_number;
else
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;
}
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)
{
/* 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->sy_frag->fr_address;
+ final_val += symp->frag->fr_address;
else
- final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
+ final_val += symp->frag->fr_address / OCTETS_PER_BYTE;
if (final_seg == expr_section)
final_seg = absolute_section;
/* Fall through. */
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.
/* Don't leave symbol loops. */
if (finalize_syms
- && !LOCAL_SYMBOL_CHECK (add_symbol)
- && add_symbol->sy_flags.sy_resolving)
+ && !add_symbol->flags.local_symbol
+ && add_symbol->flags.resolving)
break;
if (finalize_syms && final_val == 0)
{
- 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);
}
{
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 += 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;
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))
{
- symp->sy_flags.sy_resolving = 0;
+ symp->flags.resolving = 0;
goto exit_dont_set_value;
}
break;
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;
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;
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)
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;
/* A bogus input file can result in resolve_expression()
generating a local symbol, so we have to check again. */
- 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
{
*valueP = exp.X_add_number;
*segP = symbolP->bsym->section;
- *fragPP = symbolP->sy_frag;
+ *fragPP = symbolP->frag;
}
if (*segP == expr_section)
static long *dollar_labels;
static long *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)
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
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;
}
S_FORCE_RELOC (symbolS *s, int strict)
{
segT sec;
- if (LOCAL_SYMBOL_CHECK (s))
- sec = ((struct local_symbol *) s)->lsy_section;
+ if (s->flags.local_symbol)
+ sec = ((struct local_symbol *) s)->section;
else
{
if ((strict
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;
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)
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. */
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)
{
- s1 = get_real_sym (s1);
- s2 = get_real_sym (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->sy_flags.sy_written;
+ return s->flags.written;
}
/* 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 was created as a struct symbol, return S, otherwise if S is a
- converted local_symbol return the converted symbol, otherwise
- return NULL. */
+/* If S is a struct symbol return S, otherwise return NULL. */
symbolS *
symbol_symbolS (symbolS *s)
{
- if (LOCAL_SYMBOL_CHECK (s))
+ if (s->flags.local_symbol)
return NULL;
return s;
}
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)
/* 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. */
projects / deliverable / binutils-gdb.git / blobdiff