symbolS *symbolP = symbol_create (name, segment, valu, frag);
/* Link to end of symbol chain. */
-#ifdef BFD_ASSEMBLER
{
extern int symbol_table_frozen;
if (symbol_table_frozen)
abort ();
}
-#endif
symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
return symbolP;
/* symbol must be born in some fixed state. This seems as good as any. */
memset (symbolP, 0, sizeof (symbolS));
-#ifdef BFD_ASSEMBLER
symbolP->bsym = bfd_make_empty_symbol (stdoutput);
if (symbolP->bsym == NULL)
as_perror ("%s", "bfd_make_empty_symbol");
symbolP->bsym->udata.p = (PTR) symbolP;
-#endif
S_SET_NAME (symbolP, preserved_copy_of_name);
S_SET_SEGMENT (symbolP, segment);
symbol_clear_list_pointers (symbolP);
symbolP->sy_frag = frag;
-#ifndef BFD_ASSEMBLER
- symbolP->sy_number = ~0;
- symbolP->sy_name_offset = (unsigned int) ~0;
-#endif
obj_symbol_new_hook (symbolP);
return symbolP;
}
\f
-#ifdef BFD_ASSEMBLER
/* Local symbol support. If we can get away with it, we keep only a
small amount of information for local symbols. */
return ret;
}
-
-#else /* ! BFD_ASSEMBLER */
-
-#define LOCAL_SYMBOL_CHECK(s) 0
-#define local_symbol_convert(s) ((symbolS *) s)
-
-#endif /* ! BFD_ASSEMBLER */
\f
/* We have just seen "<name>:".
Creates a struct symbol unless it already exists.
/* Sun local labels go out of scope whenever a non-local symbol is
defined. */
- if (LOCAL_LABELS_DOLLAR)
- {
- int local;
-
-#ifdef BFD_ASSEMBLER
- local = bfd_is_local_label_name (stdoutput, sym_name);
-#else
- local = LOCAL_LABEL (sym_name);
-#endif
-
- if (! local)
- dollar_label_clear ();
- }
+ if (LOCAL_LABELS_DOLLAR
+ && !bfd_is_local_label_name (stdoutput, sym_name))
+ dollar_label_clear ();
#ifndef WORKING_DOT_WORD
if (new_broken_words)
/* Now check for undefined symbols. */
if (LOCAL_SYMBOL_CHECK (symbolP))
{
-#ifdef BFD_ASSEMBLER
struct local_symbol *locsym = (struct local_symbol *) symbolP;
if (locsym->lsy_section != undefined_section
locsym->lsy_section = now_seg;
local_symbol_set_frag (locsym, frag_now);
locsym->lsy_value = frag_now_fix ();
-#endif
}
else if (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
{
#else
char od_buf[100];
od_buf[0] = '\0';
-#ifdef BFD_ASSEMBLER
if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
-#endif
sprintf (od_buf, "%d.%d.",
S_GET_OTHER (symbolP),
S_GET_DESC (symbolP));
}
}
-#ifdef BFD_ASSEMBLER
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);
}
-#endif /* BFD_ASSEMBLER */
else
{
symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
if (symbolP == NULL)
{
-#ifdef BFD_ASSEMBLER
if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name))
{
symbolP = md_undefined_symbol ((char *) name);
&zero_address_frag);
return symbolP;
}
-#endif
symbolP = symbol_make (name);
symbolS *
symbol_find_exact (const char *name)
{
-#ifdef BFD_ASSEMBLER
- {
- struct local_symbol *locsym;
+ struct local_symbol *locsym;
- locsym = (struct local_symbol *) hash_find (local_hash, name);
- if (locsym != NULL)
- return (symbolS *) locsym;
- }
-#endif
+ locsym = (struct local_symbol *) hash_find (local_hash, name);
+ if (locsym != NULL)
+ return (symbolS *) locsym;
return ((symbolS *) hash_find (sy_hash, name));
}
know (*rootPP == NULL);
know (*lastPP == NULL);
addme->sy_next = NULL;
-#ifdef SYMBOLS_NEED_BACKPOINTERS
addme->sy_previous = NULL;
-#endif
*rootPP = addme;
*lastPP = addme;
return;
if (target->sy_next != NULL)
{
-#ifdef SYMBOLS_NEED_BACKPOINTERS
target->sy_next->sy_previous = addme;
-#endif /* SYMBOLS_NEED_BACKPOINTERS */
}
else
{
addme->sy_next = target->sy_next;
target->sy_next = addme;
-
-#ifdef SYMBOLS_NEED_BACKPOINTERS
addme->sy_previous = target;
-#endif /* SYMBOLS_NEED_BACKPOINTERS */
debug_verify_symchain (symbol_rootP, symbol_lastP);
}
if (LOCAL_SYMBOL_CHECK (symbolP))
abort ();
symbolP->sy_next = NULL;
-#ifdef SYMBOLS_NEED_BACKPOINTERS
symbolP->sy_previous = NULL;
-#endif
}
-#ifdef SYMBOLS_NEED_BACKPOINTERS
/* Remove SYMBOLP from the list. */
void
debug_verify_symchain (*rootPP, *lastPP);
}
-#endif /* SYMBOLS_NEED_BACKPOINTERS */
-
void
verify_symbol_chain (symbolS *rootP, symbolS *lastP)
{
for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
{
-#ifdef BFD_ASSEMBLER
assert (symbolP->bsym != NULL);
-#endif
-#ifdef SYMBOLS_NEED_BACKPOINTERS
assert (symbolP->sy_next->sy_previous == symbolP);
-#else
- /* Walk the list anyways, to make sure pointers are still good. */
- ;
-#endif /* SYMBOLS_NEED_BACKPOINTERS */
}
assert (lastP == symbolP);
valueT final_val = 0;
segT final_seg;
-#ifdef BFD_ASSEMBLER
if (LOCAL_SYMBOL_CHECK (symp))
{
struct local_symbol *locsym = (struct local_symbol *) symp;
return final_val;
}
-#endif
if (symp->sy_resolved)
{
offsetT left, right;
segT seg_left, seg_right;
operatorT op;
+ int move_seg_ok;
symp->sy_resolving = 1;
relocation to be against the symbol to which this symbol
is equated. */
if (! S_IS_DEFINED (add_symbol)
-#if defined (OBJ_COFF) && defined (TE_PE) && (defined(BFD_ASSEMBLER) || defined(S_IS_WEAK))
+#if defined (OBJ_COFF) && defined (TE_PE)
|| S_IS_WEAK (add_symbol)
#endif
|| S_IS_COMMON (add_symbol))
}
}
+ move_seg_ok = 1;
/* Equality and non-equality tests are permitted on anything.
Subtraction, and other comparison operators are permitted if
both operands are in the same section. Otherwise, both
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.
-
- Don't emit messages unless we're finalizing the symbol value,
- otherwise we may get the same message multiple times. */
- if (finalize_syms
- && !(seg_left == absolute_section
+ supports arbitrary expressions, such as IEEE-695. */
+ if (!(seg_left == absolute_section
&& seg_right == absolute_section)
&& !(op == O_eq || op == O_ne)
&& !((op == O_subtract
&& seg_left == seg_right
&& (seg_left != undefined_section
|| add_symbol == op_symbol)))
- report_op_error (symp, add_symbol, op_symbol);
+ {
+ /* Don't emit messages unless we're finalizing the symbol value,
+ otherwise we may get the same message multiple times. */
+ if (finalize_syms)
+ report_op_error (symp, add_symbol, op_symbol);
+ /* However do not move the symbol into the absolute section
+ if it cannot currently be resolved - this would confuse
+ other parts of the assembler into believing that the
+ expression had been evaluated to zero. */
+ else
+ move_seg_ok = 0;
+ }
- if (final_seg == expr_section || final_seg == undefined_section)
+ if (move_seg_ok
+ && (final_seg == expr_section || final_seg == undefined_section))
final_seg = absolute_section;
/* Check for division by zero. */
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. */
-#if defined (OBJ_AOUT) && ! defined (BFD_ASSEMBLER)
- /* The old a.out backend does not handle S_SET_SEGMENT correctly
- for a stab symbol, so we use this bad hack. */
- if (final_seg != S_GET_SEGMENT (symp))
-#endif
S_SET_SEGMENT (symp, final_seg);
/* Don't worry if we can't resolve an expr_section symbol. */
return final_val;
}
-#ifdef BFD_ASSEMBLER
-
static void resolve_local_symbol (const char *, PTR);
/* A static function passed to hash_traverse. */
resolve_symbol_value (value);
}
-#endif
-
/* Resolve all local symbols. */
void
resolve_local_symbol_values (void)
{
-#ifdef BFD_ASSEMBLER
hash_traverse (local_hash, resolve_local_symbol);
-#endif
}
/* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
valueT
S_GET_VALUE (symbolS *s)
{
-#ifdef BFD_ASSEMBLER
if (LOCAL_SYMBOL_CHECK (s))
return resolve_symbol_value (s);
-#endif
if (!s->sy_resolved)
{
void
S_SET_VALUE (symbolS *s, valueT val)
{
-#ifdef BFD_ASSEMBLER
if (LOCAL_SYMBOL_CHECK (s))
{
((struct local_symbol *) s)->lsy_value = val;
return;
}
-#endif
s->sy_value.X_op = O_constant;
s->sy_value.X_add_number = (offsetT) val;
if (LOCAL_SYMBOL_CHECK (src))
src = local_symbol_convert ((struct local_symbol *) src);
-#ifdef BFD_ASSEMBLER
/* In an expression, transfer the settings of these flags.
The user can override later, of course. */
#define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT)
dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
-#endif
#ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
#endif
}
-#ifdef BFD_ASSEMBLER
-
int
S_IS_FUNCTION (symbolS *s)
{
}
s->bsym->name = name;
}
-#endif /* BFD_ASSEMBLER */
-
-#ifdef SYMBOLS_NEED_BACKPOINTERS
/* Return the previous symbol in a chain. */
return s->sy_previous;
}
-#endif /* SYMBOLS_NEED_BACKPOINTERS */
-
/* Return the next symbol in a chain. */
symbolS *
offsetT *
symbol_X_add_number (symbolS *s)
{
-#ifdef BFD_ASSEMBLER
if (LOCAL_SYMBOL_CHECK (s))
return (offsetT *) &((struct local_symbol *) s)->lsy_value;
-#endif
return &s->sy_value.X_add_number;
}
void
symbol_set_frag (symbolS *s, fragS *f)
{
-#ifdef BFD_ASSEMBLER
if (LOCAL_SYMBOL_CHECK (s))
{
local_symbol_set_frag ((struct local_symbol *) s, f);
return;
}
-#endif
s->sy_frag = f;
}
fragS *
symbol_get_frag (symbolS *s)
{
-#ifdef BFD_ASSEMBLER
if (LOCAL_SYMBOL_CHECK (s))
return local_symbol_get_frag ((struct local_symbol *) s);
-#endif
return s->sy_frag;
}
void
symbol_mark_resolved (symbolS *s)
{
-#ifdef BFD_ASSEMBLER
if (LOCAL_SYMBOL_CHECK (s))
{
local_symbol_mark_resolved ((struct local_symbol *) s);
return;
}
-#endif
s->sy_resolved = 1;
}
int
symbol_resolved_p (symbolS *s)
{
-#ifdef BFD_ASSEMBLER
if (LOCAL_SYMBOL_CHECK (s))
return local_symbol_resolved_p ((struct local_symbol *) s);
-#endif
return s->sy_resolved;
}
{
if (LOCAL_SYMBOL_CHECK (s))
return 0;
-#ifdef BFD_ASSEMBLER
return (s->bsym->flags & BSF_SECTION_SYM) != 0;
-#else
- /* FIXME. */
- return 0;
-#endif
}
/* Return whether a symbol is equated to another symbol. */
resolve_symbol_value to flag expression syms that have been
equated. */
return (s->sy_value.X_op == O_symbol
-#if defined (OBJ_COFF) && defined (TE_PE) && (defined(BFD_ASSEMBLER) || defined(S_IS_WEAK))
+#if defined (OBJ_COFF) && defined (TE_PE)
&& ! S_IS_WEAK (s)
#endif
&& ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
return s->sy_value.X_op == O_constant;
}
-#ifdef BFD_ASSEMBLER
-
/* Return the BFD symbol for a symbol. */
asymbol *
/* else XXX - What do we do now ? */
}
-#endif /* BFD_ASSEMBLER */
-
#ifdef OBJ_SYMFIELD_TYPE
/* Get a pointer to the object format information for a symbol. */
symbol_lastP = NULL;
symbol_rootP = NULL; /* In case we have 0 symbols (!!) */
sy_hash = hash_new ();
-#ifdef BFD_ASSEMBLER
local_hash = hash_new ();
-#endif
memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
-#ifdef BFD_ASSEMBLER
#if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
abs_symbol.bsym = bfd_abs_section.symbol;
-#endif
-#else
- /* Can't initialise a union. Sigh. */
- S_SET_SEGMENT (&abs_symbol, absolute_section);
#endif
abs_symbol.sy_value.X_op = O_constant;
abs_symbol.sy_frag = &zero_address_frag;
if (LOCAL_SYMBOL_CHECK (sym))
{
-#ifdef BFD_ASSEMBLER
struct local_symbol *locsym = (struct local_symbol *) sym;
if (local_symbol_get_frag (locsym) != &zero_address_frag
&& local_symbol_get_frag (locsym) != NULL)
if (local_symbol_resolved_p (locsym))
fprintf (file, " resolved");
fprintf (file, " local");
-#endif
}
else
{
{
indent_level++;
fprintf (file, "\n%*s<", indent_level * 4, "");
-#ifdef BFD_ASSEMBLER
if (LOCAL_SYMBOL_CHECK (sym))
fprintf (file, "constant %lx",
(long) ((struct local_symbol *) sym)->lsy_value);
else
-#endif
print_expr_1 (file, &sym->sy_value);
fprintf (file, ">");
indent_level--;
symbol_print_statistics (FILE *file)
{
hash_print_statistics (file, "symbol table", sy_hash);
-#ifdef BFD_ASSEMBLER
hash_print_statistics (file, "mini local symbol table", local_hash);
fprintf (file, "%lu mini local symbols created, %lu converted\n",
local_symbol_count, local_symbol_conversion_count);
-#endif
}
projects / deliverable / binutils-gdb.git / blobdiff