OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gas/] [symbols.c] - Diff between revs 163 and 166

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 163 Rev 166
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 (&notes, sizeof *ret);
  ret = (struct local_symbol *) obstack_alloc (&notes, 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");

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.