| Line 178... |
Line 178... |
/* This macro is called with a symbol argument passed by reference.
|
/* This macro is called with a symbol argument passed by reference.
|
It returns whether this is a local symbol. If necessary, it
|
It returns whether this is a local symbol. If necessary, it
|
changes its argument to the real symbol. */
|
changes its argument to the real symbol. */
|
|
|
#define LOCAL_SYMBOL_CHECK(s) \
|
#define LOCAL_SYMBOL_CHECK(s) \
|
(s->bsym == NULL \
|
(s->sy_flags.sy_local_symbol \
|
? (local_symbol_converted_p ((struct local_symbol *) s) \
|
? (local_symbol_converted_p ((struct local_symbol *) s) \
|
? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
|
? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
|
0) \
|
0) \
|
: 1) \
|
: 1) \
|
: 0)
|
: 0)
|
| Line 198... |
Line 198... |
++local_symbol_count;
|
++local_symbol_count;
|
|
|
name_copy = save_symbol_name (name);
|
name_copy = save_symbol_name (name);
|
|
|
ret = (struct local_symbol *) obstack_alloc (¬es, sizeof *ret);
|
ret = (struct local_symbol *) obstack_alloc (¬es, sizeof *ret);
|
ret->lsy_marker = NULL;
|
ret->lsy_flags.sy_local_symbol = 1;
|
|
ret->lsy_flags.sy_resolved = 0;
|
ret->lsy_name = name_copy;
|
ret->lsy_name = name_copy;
|
ret->lsy_section = section;
|
ret->lsy_section = section;
|
local_symbol_set_frag (ret, frag);
|
local_symbol_set_frag (ret, frag);
|
ret->lsy_value = val;
|
ret->lsy_value = val;
|
|
|
| Line 217... |
Line 218... |
static symbolS *
|
static symbolS *
|
local_symbol_convert (struct local_symbol *locsym)
|
local_symbol_convert (struct local_symbol *locsym)
|
{
|
{
|
symbolS *ret;
|
symbolS *ret;
|
|
|
gas_assert (locsym->lsy_marker == NULL);
|
gas_assert (locsym->lsy_flags.sy_local_symbol);
|
if (local_symbol_converted_p (locsym))
|
if (local_symbol_converted_p (locsym))
|
return local_symbol_get_real_symbol (locsym);
|
return local_symbol_get_real_symbol (locsym);
|
|
|
++local_symbol_conversion_count;
|
++local_symbol_conversion_count;
|
|
|
ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value,
|
ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value,
|
local_symbol_get_frag (locsym));
|
local_symbol_get_frag (locsym));
|
|
|
if (local_symbol_resolved_p (locsym))
|
if (local_symbol_resolved_p (locsym))
|
ret->sy_resolved = 1;
|
ret->sy_flags.sy_resolved = 1;
|
|
|
/* Local symbols are always either defined or used. */
|
/* Local symbols are always either defined or used. */
|
ret->sy_used = 1;
|
ret->sy_flags.sy_used = 1;
|
|
|
#ifdef TC_LOCAL_SYMFIELD_CONVERT
|
#ifdef TC_LOCAL_SYMFIELD_CONVERT
|
TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
|
TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
|
#endif
|
#endif
|
|
|
| Line 314... |
Line 315... |
for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
|
for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
|
a->dispfrag = frag_tmp;
|
a->dispfrag = frag_tmp;
|
}
|
}
|
#endif /* WORKING_DOT_WORD */
|
#endif /* WORKING_DOT_WORD */
|
|
|
|
#ifdef obj_frob_colon
|
|
obj_frob_colon (sym_name);
|
|
#endif
|
|
|
if ((symbolP = symbol_find (sym_name)) != 0)
|
if ((symbolP = symbol_find (sym_name)) != 0)
|
{
|
{
|
S_CLEAR_WEAKREFR (symbolP);
|
S_CLEAR_WEAKREFR (symbolP);
|
#ifdef RESOLVE_SYMBOL_REDEFINITION
|
#ifdef RESOLVE_SYMBOL_REDEFINITION
|
if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
|
if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
|
| Line 459... |
Line 464... |
symbolP->sy_value.X_op = O_symbol;
|
symbolP->sy_value.X_op = O_symbol;
|
symbolP->sy_value.X_add_symbol = mri_common_symbol;
|
symbolP->sy_value.X_add_symbol = mri_common_symbol;
|
symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
|
symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
|
symbolP->sy_frag = &zero_address_frag;
|
symbolP->sy_frag = &zero_address_frag;
|
S_SET_SEGMENT (symbolP, expr_section);
|
S_SET_SEGMENT (symbolP, expr_section);
|
symbolP->sy_mri_common = 1;
|
symbolP->sy_flags.sy_mri_common = 1;
|
}
|
}
|
|
|
#ifdef tc_frob_label
|
#ifdef tc_frob_label
|
tc_frob_label (symbolP);
|
tc_frob_label (symbolP);
|
#endif
|
#endif
|
| Line 626... |
Line 631... |
if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
|
if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
|
{
|
{
|
symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
|
symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
|
symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
|
symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
|
|
|
if (symbolP->sy_forward_ref)
|
if (symbolP->sy_flags.sy_forward_ref)
|
is_forward = 1;
|
is_forward = 1;
|
|
|
if (is_forward)
|
if (is_forward)
|
{
|
{
|
/* assign_symbol() clones volatile symbols; pre-existing expressions
|
/* assign_symbol() clones volatile symbols; pre-existing expressions
|
| Line 642... |
Line 647... |
op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));
|
op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));
|
}
|
}
|
|
|
/* Re-using sy_resolving here, as this routine cannot get called from
|
/* Re-using sy_resolving here, as this routine cannot get called from
|
symbol resolution code. */
|
symbol resolution code. */
|
if ((symbolP->bsym->section == expr_section || symbolP->sy_forward_ref)
|
if ((symbolP->bsym->section == expr_section
|
&& !symbolP->sy_resolving)
|
|| symbolP->sy_flags.sy_forward_ref)
|
|
&& !symbolP->sy_flags.sy_resolving)
|
{
|
{
|
symbolP->sy_resolving = 1;
|
symbolP->sy_flags.sy_resolving = 1;
|
add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
|
add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
|
op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);
|
op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);
|
symbolP->sy_resolving = 0;
|
symbolP->sy_flags.sy_resolving = 0;
|
}
|
}
|
|
|
if (symbolP->sy_forward_ref
|
if (symbolP->sy_flags.sy_forward_ref
|
|| add_symbol != symbolP->sy_value.X_add_symbol
|
|| add_symbol != symbolP->sy_value.X_add_symbol
|
|| op_symbol != symbolP->sy_value.X_op_symbol)
|
|| op_symbol != symbolP->sy_value.X_op_symbol)
|
{
|
{
|
if (symbolP != &dot_symbol)
|
if (symbolP != &dot_symbol)
|
{
|
{
|
symbolP = symbol_clone (symbolP, 0);
|
symbolP = symbol_clone (symbolP, 0);
|
symbolP->sy_resolving = 0;
|
symbolP->sy_flags.sy_resolving = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
symbolP = symbol_temp_new_now ();
|
symbolP = symbol_temp_new_now ();
|
#ifdef tc_new_dot_label
|
#ifdef tc_new_dot_label
|
| Line 893... |
Line 899... |
return;
|
return;
|
|
|
for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
|
for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
|
{
|
{
|
gas_assert (symbolP->bsym != NULL);
|
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->sy_next->sy_previous == symbolP);
|
}
|
}
|
|
|
gas_assert (lastP == symbolP);
|
gas_assert (lastP == symbolP);
|
}
|
}
|
| Line 1055... |
Line 1062... |
}
|
}
|
|
|
return final_val;
|
return final_val;
|
}
|
}
|
|
|
if (symp->sy_resolved)
|
if (symp->sy_flags.sy_resolved)
|
{
|
{
|
if (symp->sy_value.X_op == O_constant)
|
if (symp->sy_value.X_op == O_constant)
|
return (valueT) symp->sy_value.X_add_number;
|
return (valueT) symp->sy_value.X_add_number;
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
|
|
resolved = 0;
|
resolved = 0;
|
final_seg = S_GET_SEGMENT (symp);
|
final_seg = S_GET_SEGMENT (symp);
|
|
|
if (symp->sy_resolving)
|
if (symp->sy_flags.sy_resolving)
|
{
|
{
|
if (finalize_syms)
|
if (finalize_syms)
|
as_bad (_("symbol definition loop encountered at `%s'"),
|
as_bad (_("symbol definition loop encountered at `%s'"),
|
S_GET_NAME (symp));
|
S_GET_NAME (symp));
|
final_val = 0;
|
final_val = 0;
|
| Line 1129... |
Line 1136... |
offsetT left, right;
|
offsetT left, right;
|
segT seg_left, seg_right;
|
segT seg_left, seg_right;
|
operatorT op;
|
operatorT op;
|
int move_seg_ok;
|
int move_seg_ok;
|
|
|
symp->sy_resolving = 1;
|
symp->sy_flags.sy_resolving = 1;
|
|
|
/* Help out with CSE. */
|
/* Help out with CSE. */
|
add_symbol = symp->sy_value.X_add_symbol;
|
add_symbol = symp->sy_value.X_add_symbol;
|
op_symbol = symp->sy_value.X_op_symbol;
|
op_symbol = symp->sy_value.X_op_symbol;
|
final_val = symp->sy_value.X_add_number;
|
final_val = symp->sy_value.X_add_number;
|
| Line 1178... |
Line 1185... |
gas_assert (! S_IS_WEAKREFR (add_symbol));
|
gas_assert (! S_IS_WEAKREFR (add_symbol));
|
symp->sy_value.X_add_symbol = add_symbol;
|
symp->sy_value.X_add_symbol = add_symbol;
|
}
|
}
|
}
|
}
|
|
|
if (symp->sy_mri_common)
|
if (symp->sy_flags.sy_mri_common)
|
{
|
{
|
/* This is a symbol inside an MRI common section. The
|
/* This is a symbol inside an MRI common section. The
|
relocation routines are going to handle it specially.
|
relocation routines are going to handle it specially.
|
Don't change the value. */
|
Don't change the value. */
|
resolved = symbol_resolved_p (add_symbol);
|
resolved = symbol_resolved_p (add_symbol);
|
| Line 1218... |
Line 1225... |
symp->sy_value.X_op_symbol = add_symbol;
|
symp->sy_value.X_op_symbol = add_symbol;
|
}
|
}
|
final_seg = seg_left;
|
final_seg = seg_left;
|
final_val = 0;
|
final_val = 0;
|
resolved = symbol_resolved_p (add_symbol);
|
resolved = symbol_resolved_p (add_symbol);
|
symp->sy_resolving = 0;
|
symp->sy_flags.sy_resolving = 0;
|
goto exit_dont_set_value;
|
goto exit_dont_set_value;
|
}
|
}
|
else if (finalize_syms
|
else if (finalize_syms
|
&& ((final_seg == expr_section && seg_left != expr_section)
|
&& ((final_seg == expr_section && seg_left != expr_section)
|
|| symbol_shadow_p (symp)))
|
|| symbol_shadow_p (symp)))
|
| Line 1237... |
Line 1244... |
symp->sy_value.X_add_number = final_val;
|
symp->sy_value.X_add_number = final_val;
|
symp->sy_value.X_op_symbol = add_symbol;
|
symp->sy_value.X_op_symbol = add_symbol;
|
final_seg = seg_left;
|
final_seg = seg_left;
|
final_val += symp->sy_frag->fr_address + left;
|
final_val += symp->sy_frag->fr_address + left;
|
resolved = symbol_resolved_p (add_symbol);
|
resolved = symbol_resolved_p (add_symbol);
|
symp->sy_resolving = 0;
|
symp->sy_flags.sy_resolving = 0;
|
goto exit_dont_set_value;
|
goto exit_dont_set_value;
|
}
|
}
|
else
|
else
|
{
|
{
|
final_val += symp->sy_frag->fr_address + left;
|
final_val += symp->sy_frag->fr_address + left;
|
| Line 1441... |
Line 1448... |
resolution), and any problems may not actually mean
|
resolution), and any problems may not actually mean
|
anything. */
|
anything. */
|
break;
|
break;
|
}
|
}
|
|
|
symp->sy_resolving = 0;
|
symp->sy_flags.sy_resolving = 0;
|
}
|
}
|
|
|
if (finalize_syms)
|
if (finalize_syms)
|
S_SET_VALUE (symp, final_val);
|
S_SET_VALUE (symp, final_val);
|
|
|
| Line 1456... |
Line 1463... |
|
|
/* Don't worry if we can't resolve an expr_section symbol. */
|
/* Don't worry if we can't resolve an expr_section symbol. */
|
if (finalize_syms)
|
if (finalize_syms)
|
{
|
{
|
if (resolved)
|
if (resolved)
|
symp->sy_resolved = 1;
|
symp->sy_flags.sy_resolved = 1;
|
else if (S_GET_SEGMENT (symp) != expr_section)
|
else if (S_GET_SEGMENT (symp) != expr_section)
|
{
|
{
|
as_bad (_("can't resolve value for symbol `%s'"),
|
as_bad (_("can't resolve value for symbol `%s'"),
|
S_GET_NAME (symp));
|
S_GET_NAME (symp));
|
symp->sy_resolved = 1;
|
symp->sy_flags.sy_resolved = 1;
|
}
|
}
|
}
|
}
|
|
|
return final_val;
|
return final_val;
|
}
|
}
|
| Line 1507... |
Line 1514... |
}
|
}
|
else
|
else
|
{
|
{
|
expressionS exp = symbolP->sy_value;
|
expressionS exp = symbolP->sy_value;
|
|
|
if (!symbolP->sy_resolved && exp.X_op != O_illegal)
|
if (!symbolP->sy_flags.sy_resolved && exp.X_op != O_illegal)
|
{
|
{
|
int resolved;
|
int resolved;
|
|
|
if (symbolP->sy_resolving)
|
if (symbolP->sy_flags.sy_resolving)
|
return 0;
|
return 0;
|
symbolP->sy_resolving = 1;
|
symbolP->sy_flags.sy_resolving = 1;
|
resolved = resolve_expression (&exp);
|
resolved = resolve_expression (&exp);
|
symbolP->sy_resolving = 0;
|
symbolP->sy_flags.sy_resolving = 0;
|
if (!resolved)
|
if (!resolved)
|
return 0;
|
return 0;
|
|
|
switch (exp.X_op)
|
switch (exp.X_op)
|
{
|
{
|
| Line 1921... |
Line 1928... |
S_GET_VALUE (symbolS *s)
|
S_GET_VALUE (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return resolve_symbol_value (s);
|
return resolve_symbol_value (s);
|
|
|
if (!s->sy_resolved)
|
if (!s->sy_flags.sy_resolved)
|
{
|
{
|
valueT val = resolve_symbol_value (s);
|
valueT val = resolve_symbol_value (s);
|
if (!finalize_syms)
|
if (!finalize_syms)
|
return val;
|
return val;
|
}
|
}
|
if (S_IS_WEAKREFR (s))
|
if (S_IS_WEAKREFR (s))
|
return S_GET_VALUE (s->sy_value.X_add_symbol);
|
return S_GET_VALUE (s->sy_value.X_add_symbol);
|
|
|
if (s->sy_value.X_op != O_constant)
|
if (s->sy_value.X_op != O_constant)
|
{
|
{
|
if (! s->sy_resolved
|
if (! s->sy_flags.sy_resolved
|
|| s->sy_value.X_op != O_symbol
|
|| s->sy_value.X_op != O_symbol
|
|| (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
|
|| (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
|
as_bad (_("attempt to get value of unresolved symbol `%s'"),
|
as_bad (_("attempt to get value of unresolved symbol `%s'"),
|
S_GET_NAME (s));
|
S_GET_NAME (s));
|
}
|
}
|
| Line 2030... |
Line 2037... |
int
|
int
|
S_IS_WEAKREFR (symbolS *s)
|
S_IS_WEAKREFR (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return 0;
|
return 0;
|
return s->sy_weakrefr != 0;
|
return s->sy_flags.sy_weakrefr != 0;
|
}
|
}
|
|
|
int
|
int
|
S_IS_WEAKREFD (symbolS *s)
|
S_IS_WEAKREFD (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return 0;
|
return 0;
|
return s->sy_weakrefd != 0;
|
return s->sy_flags.sy_weakrefd != 0;
|
}
|
}
|
|
|
int
|
int
|
S_IS_COMMON (symbolS *s)
|
S_IS_COMMON (symbolS *s)
|
{
|
{
|
| Line 2149... |
Line 2156... |
int
|
int
|
S_IS_VOLATILE (const symbolS *s)
|
S_IS_VOLATILE (const symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return 0;
|
return 0;
|
return s->sy_volatile;
|
return s->sy_flags.sy_volatile;
|
}
|
}
|
|
|
int
|
int
|
S_IS_FORWARD_REF (const symbolS *s)
|
S_IS_FORWARD_REF (const symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return 0;
|
return 0;
|
return s->sy_forward_ref;
|
return s->sy_flags.sy_forward_ref;
|
}
|
}
|
|
|
const char *
|
const char *
|
S_GET_NAME (symbolS *s)
|
S_GET_NAME (symbolS *s)
|
{
|
{
|
| Line 2272... |
Line 2279... |
void
|
void
|
S_SET_WEAKREFR (symbolS *s)
|
S_SET_WEAKREFR (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s->sy_weakrefr = 1;
|
s->sy_flags.sy_weakrefr = 1;
|
/* If the alias was already used, make sure we mark the target as
|
/* If the alias was already used, make sure we mark the target as
|
used as well, otherwise it might be dropped from the symbol
|
used as well, otherwise it might be dropped from the symbol
|
table. This may have unintended side effects if the alias is
|
table. This may have unintended side effects if the alias is
|
later redirected to another symbol, such as keeping the unused
|
later redirected to another symbol, such as keeping the unused
|
previous target in the symbol table. Since it will be weak, it's
|
previous target in the symbol table. Since it will be weak, it's
|
not a big deal. */
|
not a big deal. */
|
if (s->sy_used)
|
if (s->sy_flags.sy_used)
|
symbol_mark_used (s->sy_value.X_add_symbol);
|
symbol_mark_used (s->sy_value.X_add_symbol);
|
}
|
}
|
|
|
void
|
void
|
S_CLEAR_WEAKREFR (symbolS *s)
|
S_CLEAR_WEAKREFR (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return;
|
return;
|
s->sy_weakrefr = 0;
|
s->sy_flags.sy_weakrefr = 0;
|
}
|
}
|
|
|
void
|
void
|
S_SET_WEAKREFD (symbolS *s)
|
S_SET_WEAKREFD (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s->sy_weakrefd = 1;
|
s->sy_flags.sy_weakrefd = 1;
|
S_SET_WEAK (s);
|
S_SET_WEAK (s);
|
}
|
}
|
|
|
void
|
void
|
S_CLEAR_WEAKREFD (symbolS *s)
|
S_CLEAR_WEAKREFD (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return;
|
return;
|
if (s->sy_weakrefd)
|
if (s->sy_flags.sy_weakrefd)
|
{
|
{
|
s->sy_weakrefd = 0;
|
s->sy_flags.sy_weakrefd = 0;
|
/* If a weakref target symbol is weak, then it was never
|
/* If a weakref target symbol is weak, then it was never
|
referenced directly before, not even in a .global directive,
|
referenced directly before, not even in a .global directive,
|
so decay it to local. If it remains undefined, it will be
|
so decay it to local. If it remains undefined, it will be
|
later turned into a global, like any other undefined
|
later turned into a global, like any other undefined
|
symbol. */
|
symbol. */
|
| Line 2358... |
Line 2365... |
void
|
void
|
S_SET_VOLATILE (symbolS *s)
|
S_SET_VOLATILE (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s->sy_volatile = 1;
|
s->sy_flags.sy_volatile = 1;
|
}
|
}
|
|
|
void
|
void
|
S_CLEAR_VOLATILE (symbolS *s)
|
S_CLEAR_VOLATILE (symbolS *s)
|
{
|
{
|
if (!LOCAL_SYMBOL_CHECK (s))
|
if (!LOCAL_SYMBOL_CHECK (s))
|
s->sy_volatile = 0;
|
s->sy_flags.sy_volatile = 0;
|
}
|
}
|
|
|
void
|
void
|
S_SET_FORWARD_REF (symbolS *s)
|
S_SET_FORWARD_REF (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s->sy_forward_ref = 1;
|
s->sy_flags.sy_forward_ref = 1;
|
}
|
}
|
|
|
/* Return the previous symbol in a chain. */
|
/* Return the previous symbol in a chain. */
|
|
|
symbolS *
|
symbolS *
|
| Line 2422... |
Line 2429... |
/* Return whether 2 symbols are the same. */
|
/* Return whether 2 symbols are the same. */
|
|
|
int
|
int
|
symbol_same_p (symbolS *s1, symbolS *s2)
|
symbol_same_p (symbolS *s1, symbolS *s2)
|
{
|
{
|
if (s1->bsym == NULL
|
if (s1->sy_flags.sy_local_symbol
|
&& local_symbol_converted_p ((struct local_symbol *) s1))
|
&& local_symbol_converted_p ((struct local_symbol *) s1))
|
s1 = local_symbol_get_real_symbol ((struct local_symbol *) s1);
|
s1 = local_symbol_get_real_symbol ((struct local_symbol *) s1);
|
if (s2->bsym == NULL
|
if (s2->sy_flags.sy_local_symbol
|
&& local_symbol_converted_p ((struct local_symbol *) s2))
|
&& local_symbol_converted_p ((struct local_symbol *) s2))
|
s2 = local_symbol_get_real_symbol ((struct local_symbol *) s2);
|
s2 = local_symbol_get_real_symbol ((struct local_symbol *) s2);
|
return s1 == s2;
|
return s1 == s2;
|
}
|
}
|
|
|
| Line 2483... |
Line 2490... |
void
|
void
|
symbol_mark_used (symbolS *s)
|
symbol_mark_used (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return;
|
return;
|
s->sy_used = 1;
|
s->sy_flags.sy_used = 1;
|
if (S_IS_WEAKREFR (s))
|
if (S_IS_WEAKREFR (s))
|
symbol_mark_used (s->sy_value.X_add_symbol);
|
symbol_mark_used (s->sy_value.X_add_symbol);
|
}
|
}
|
|
|
/* Clear the mark of whether a symbol has been used. */
|
/* Clear the mark of whether a symbol has been used. */
|
| Line 2495... |
Line 2502... |
void
|
void
|
symbol_clear_used (symbolS *s)
|
symbol_clear_used (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s->sy_used = 0;
|
s->sy_flags.sy_used = 0;
|
}
|
}
|
|
|
/* Return whether a symbol has been used. */
|
/* Return whether a symbol has been used. */
|
|
|
int
|
int
|
symbol_used_p (symbolS *s)
|
symbol_used_p (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return 1;
|
return 1;
|
return s->sy_used;
|
return s->sy_flags.sy_used;
|
}
|
}
|
|
|
/* Mark a symbol as having been used in a reloc. */
|
/* Mark a symbol as having been used in a reloc. */
|
|
|
void
|
void
|
symbol_mark_used_in_reloc (symbolS *s)
|
symbol_mark_used_in_reloc (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s->sy_used_in_reloc = 1;
|
s->sy_flags.sy_used_in_reloc = 1;
|
}
|
}
|
|
|
/* Clear the mark of whether a symbol has been used in a reloc. */
|
/* Clear the mark of whether a symbol has been used in a reloc. */
|
|
|
void
|
void
|
symbol_clear_used_in_reloc (symbolS *s)
|
symbol_clear_used_in_reloc (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return;
|
return;
|
s->sy_used_in_reloc = 0;
|
s->sy_flags.sy_used_in_reloc = 0;
|
}
|
}
|
|
|
/* Return whether a symbol has been used in a reloc. */
|
/* Return whether a symbol has been used in a reloc. */
|
|
|
int
|
int
|
symbol_used_in_reloc_p (symbolS *s)
|
symbol_used_in_reloc_p (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return 0;
|
return 0;
|
return s->sy_used_in_reloc;
|
return s->sy_flags.sy_used_in_reloc;
|
}
|
}
|
|
|
/* Mark a symbol as an MRI common symbol. */
|
/* Mark a symbol as an MRI common symbol. */
|
|
|
void
|
void
|
symbol_mark_mri_common (symbolS *s)
|
symbol_mark_mri_common (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s = local_symbol_convert ((struct local_symbol *) s);
|
s->sy_mri_common = 1;
|
s->sy_flags.sy_mri_common = 1;
|
}
|
}
|
|
|
/* Clear the mark of whether a symbol is an MRI common symbol. */
|
/* Clear the mark of whether a symbol is an MRI common symbol. */
|
|
|
void
|
void
|
symbol_clear_mri_common (symbolS *s)
|
symbol_clear_mri_common (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return;
|
return;
|
s->sy_mri_common = 0;
|
s->sy_flags.sy_mri_common = 0;
|
}
|
}
|
|
|
/* Return whether a symbol is an MRI common symbol. */
|
/* Return whether a symbol is an MRI common symbol. */
|
|
|
int
|
int
|
symbol_mri_common_p (symbolS *s)
|
symbol_mri_common_p (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return 0;
|
return 0;
|
return s->sy_mri_common;
|
return s->sy_flags.sy_mri_common;
|
}
|
}
|
|
|
/* Mark a symbol as having been written. */
|
/* Mark a symbol as having been written. */
|
|
|
void
|
void
|
symbol_mark_written (symbolS *s)
|
symbol_mark_written (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return;
|
return;
|
s->written = 1;
|
s->sy_flags.sy_written = 1;
|
}
|
}
|
|
|
/* Clear the mark of whether a symbol has been written. */
|
/* Clear the mark of whether a symbol has been written. */
|
|
|
void
|
void
|
symbol_clear_written (symbolS *s)
|
symbol_clear_written (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return;
|
return;
|
s->written = 0;
|
s->sy_flags.sy_written = 0;
|
}
|
}
|
|
|
/* Return whether a symbol has been written. */
|
/* Return whether a symbol has been written. */
|
|
|
int
|
int
|
symbol_written_p (symbolS *s)
|
symbol_written_p (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return 0;
|
return 0;
|
return s->written;
|
return s->sy_flags.sy_written;
|
}
|
}
|
|
|
/* Mark a symbol has having been resolved. */
|
/* Mark a symbol has having been resolved. */
|
|
|
void
|
void
|
| Line 2608... |
Line 2615... |
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
{
|
{
|
local_symbol_mark_resolved ((struct local_symbol *) s);
|
local_symbol_mark_resolved ((struct local_symbol *) s);
|
return;
|
return;
|
}
|
}
|
s->sy_resolved = 1;
|
s->sy_flags.sy_resolved = 1;
|
}
|
}
|
|
|
/* Return whether a symbol has been resolved. */
|
/* Return whether a symbol has been resolved. */
|
|
|
int
|
int
|
symbol_resolved_p (symbolS *s)
|
symbol_resolved_p (symbolS *s)
|
{
|
{
|
if (LOCAL_SYMBOL_CHECK (s))
|
if (LOCAL_SYMBOL_CHECK (s))
|
return local_symbol_resolved_p ((struct local_symbol *) s);
|
return local_symbol_resolved_p ((struct local_symbol *) s);
|
return s->sy_resolved;
|
return s->sy_flags.sy_resolved;
|
}
|
}
|
|
|
/* Return whether a symbol is a section symbol. */
|
/* Return whether a symbol is a section symbol. */
|
|
|
int
|
int
|
| Line 2656... |
Line 2663... |
equated. */
|
equated. */
|
return (s->sy_value.X_op == O_symbol
|
return (s->sy_value.X_op == O_symbol
|
#if defined (OBJ_COFF) && defined (TE_PE)
|
#if defined (OBJ_COFF) && defined (TE_PE)
|
&& ! S_IS_WEAK (s)
|
&& ! S_IS_WEAK (s)
|
#endif
|
#endif
|
&& ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
|
&& ((s->sy_flags.sy_resolved && s->sy_value.X_op_symbol != NULL)
|
|| ! S_IS_DEFINED (s)
|
|| ! S_IS_DEFINED (s)
|
|| S_IS_COMMON (s)));
|
|| S_IS_COMMON (s)));
|
}
|
}
|
|
|
/* Return whether a symbol has a constant value. */
|
/* Return whether a symbol has a constant value. */
|
| Line 2785... |
Line 2792... |
{
|
{
|
dot_symbol.bsym = bfd_make_empty_symbol (stdoutput);
|
dot_symbol.bsym = bfd_make_empty_symbol (stdoutput);
|
if (dot_symbol.bsym == NULL)
|
if (dot_symbol.bsym == NULL)
|
as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
|
as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
|
dot_symbol.bsym->name = ".";
|
dot_symbol.bsym->name = ".";
|
dot_symbol.sy_forward_ref = 1;
|
dot_symbol.sy_flags.sy_forward_ref = 1;
|
dot_symbol.sy_value.X_op = O_constant;
|
dot_symbol.sy_value.X_op = O_constant;
|
}
|
}
|
|
|
int indent_level;
|
int indent_level;
|
|
|
| Line 2826... |
Line 2833... |
if (sym->sy_frag != &zero_address_frag)
|
if (sym->sy_frag != &zero_address_frag)
|
{
|
{
|
fprintf (file, " frag ");
|
fprintf (file, " frag ");
|
fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym->sy_frag));
|
fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym->sy_frag));
|
}
|
}
|
if (sym->written)
|
if (sym->sy_flags.sy_written)
|
fprintf (file, " written");
|
fprintf (file, " written");
|
if (sym->sy_resolved)
|
if (sym->sy_flags.sy_resolved)
|
fprintf (file, " resolved");
|
fprintf (file, " resolved");
|
else if (sym->sy_resolving)
|
else if (sym->sy_flags.sy_resolving)
|
fprintf (file, " resolving");
|
fprintf (file, " resolving");
|
if (sym->sy_used_in_reloc)
|
if (sym->sy_flags.sy_used_in_reloc)
|
fprintf (file, " used-in-reloc");
|
fprintf (file, " used-in-reloc");
|
if (sym->sy_used)
|
if (sym->sy_flags.sy_used)
|
fprintf (file, " used");
|
fprintf (file, " used");
|
if (S_IS_LOCAL (sym))
|
if (S_IS_LOCAL (sym))
|
fprintf (file, " local");
|
fprintf (file, " local");
|
if (S_IS_EXTERNAL (sym))
|
if (S_IS_EXTERNAL (sym))
|
fprintf (file, " extern");
|
fprintf (file, " extern");
|
