2012-01-10 Tristan Gingold <gingold@adacore.com>

[deliverable/binutils-gdb.git] / gas / symbols.c

diff --git a/gas/symbols.c b/gas/symbols.c
index 086e01d6a5b6105268f546d33663bda717ee7222..12b2f8fe27ae89913547b5df8c38db8c8ca79e71 100644 (file)
--- a/gas/symbols.c
+++ b/gas/symbols.c
@@ -180,7 +180,7 @@ static unsigned long local_symbol_conversion_count;
    changes its argument to the real symbol.  */
 
 #define LOCAL_SYMBOL_CHECK(s)                                          \
    changes its argument to the real symbol.  */
 
 #define LOCAL_SYMBOL_CHECK(s)                                          \

-  (s->bsym == 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), \
         0)                                                             \
    ? (local_symbol_converted_p ((struct local_symbol *) s)             \
       ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
         0)                                                             \


@@ -200,7 +200,8 @@ local_symbol_make (const char *name, segT section, valueT val, fragS *frag)
   name_copy = save_symbol_name (name);
 
   ret = (struct local_symbol *) obstack_alloc (&notes, sizeof *ret);
   name_copy = save_symbol_name (name);
 
   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_section = section;
   local_symbol_set_frag (ret, frag);
   ret->lsy_name = name_copy;
   ret->lsy_section = section;
   local_symbol_set_frag (ret, frag);


@@ -219,7 +220,7 @@ 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))
     return local_symbol_get_real_symbol (locsym);
 
   if (local_symbol_converted_p (locsym))
     return local_symbol_get_real_symbol (locsym);
 


@@ -229,10 +230,10 @@ local_symbol_convert (struct local_symbol *locsym)
                    local_symbol_get_frag (locsym));
 
   if (local_symbol_resolved_p (locsym))
                    local_symbol_get_frag (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
   TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
 
 #ifdef TC_LOCAL_SYMFIELD_CONVERT
   TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);


@@ -461,7 +462,7 @@ colon (/* Just seen "x:" - rattle symbols & frags.  */
       symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
       symbolP->sy_frag = &zero_address_frag;
       S_SET_SEGMENT (symbolP, expr_section);
       symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
       symbolP->sy_frag = &zero_address_frag;
       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


@@ -628,7 +629,7 @@ symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
       symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
       symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
 
       symbolS *add_symbol = symbolP->sy_value.X_add_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;
 
       if (is_forward)
        is_forward = 1;
 
       if (is_forward)


@@ -644,23 +645,24 @@ symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
 
       /* Re-using sy_resolving here, as this routine cannot get called from
         symbol resolution code.  */
 
       /* Re-using sy_resolving here, as this routine cannot get called from
         symbol resolution code.  */

-      if ((symbolP->bsym->section == expr_section || symbolP->sy_forward_ref)
-         && !symbolP->sy_resolving)
+      if ((symbolP->bsym->section == expr_section
+           || 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);
          op_symbol = symbol_clone_if_forward_ref (op_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);

-         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
          || op_symbol != symbolP->sy_value.X_op_symbol)
        {
          if (symbolP != &dot_symbol)
            {
              symbolP = symbol_clone (symbolP, 0);
          || add_symbol != symbolP->sy_value.X_add_symbol
          || op_symbol != symbolP->sy_value.X_op_symbol)
        {
          if (symbolP != &dot_symbol)
            {
              symbolP = symbol_clone (symbolP, 0);

-             symbolP->sy_resolving = 0;
+             symbolP->sy_flags.sy_resolving = 0;

            }
          else
            {
            }
          else
            {


@@ -895,6 +897,7 @@ verify_symbol_chain (symbolS *rootP, symbolS *lastP)
   for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
     {
       gas_assert (symbolP->bsym != NULL);
   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->sy_next->sy_previous == symbolP);
     }
 


@@ -1057,7 +1060,7 @@ resolve_symbol_value (symbolS *symp)
       return final_val;
     }
 
       return final_val;
     }
 

-  if (symp->sy_resolved)
+  if (symp->sy_flags.sy_resolved)

     {
       if (symp->sy_value.X_op == O_constant)
        return (valueT) symp->sy_value.X_add_number;
     {
       if (symp->sy_value.X_op == O_constant)
        return (valueT) symp->sy_value.X_add_number;


@@ -1068,7 +1071,7 @@ resolve_symbol_value (symbolS *symp)
   resolved = 0;
   final_seg = S_GET_SEGMENT (symp);
 
   resolved = 0;
   final_seg = S_GET_SEGMENT (symp);
 

-  if (symp->sy_resolving)
+  if (symp->sy_flags.sy_resolving)

     {
       if (finalize_syms)
        as_bad (_("symbol definition loop encountered at `%s'"),
     {
       if (finalize_syms)
        as_bad (_("symbol definition loop encountered at `%s'"),


@@ -1131,7 +1134,7 @@ resolve_symbol_value (symbolS *symp)
       operatorT op;
       int move_seg_ok;
 
       operatorT op;
       int move_seg_ok;
 

-      symp->sy_resolving = 1;
+      symp->sy_flags.sy_resolving = 1;

 
       /* Help out with CSE.  */
       add_symbol = symp->sy_value.X_add_symbol;
 
       /* Help out with CSE.  */
       add_symbol = symp->sy_value.X_add_symbol;


@@ -1180,7 +1183,7 @@ resolve_symbol_value (symbolS *symp)
                }
            }
 
                }
            }
 

-         if (symp->sy_mri_common)
+         if (symp->sy_flags.sy_mri_common)

            {
              /* This is a symbol inside an MRI common section.  The
                 relocation routines are going to handle it specially.
            {
              /* This is a symbol inside an MRI common section.  The
                 relocation routines are going to handle it specially.


@@ -1220,7 +1223,7 @@ resolve_symbol_value (symbolS *symp)
              final_seg = seg_left;
              final_val = 0;
              resolved = symbol_resolved_p (add_symbol);
              final_seg = seg_left;
              final_val = 0;
              resolved = symbol_resolved_p (add_symbol);

-             symp->sy_resolving = 0;
+             symp->sy_flags.sy_resolving = 0;

              goto exit_dont_set_value;
            }
          else if (finalize_syms
              goto exit_dont_set_value;
            }
          else if (finalize_syms


@@ -1239,7 +1242,7 @@ resolve_symbol_value (symbolS *symp)
              final_seg = seg_left;
              final_val += symp->sy_frag->fr_address + left;
              resolved = symbol_resolved_p (add_symbol);
              final_seg = seg_left;
              final_val += symp->sy_frag->fr_address + left;
              resolved = symbol_resolved_p (add_symbol);

-             symp->sy_resolving = 0;
+             symp->sy_flags.sy_resolving = 0;

              goto exit_dont_set_value;
            }
          else
              goto exit_dont_set_value;
            }
          else


@@ -1443,7 +1446,7 @@ resolve_symbol_value (symbolS *symp)
          break;
        }
 
          break;
        }
 

-      symp->sy_resolving = 0;
+      symp->sy_flags.sy_resolving = 0;

     }
 
   if (finalize_syms)
     }
 
   if (finalize_syms)


@@ -1458,12 +1461,12 @@ exit_dont_set_value:
   if (finalize_syms)
     {
       if (resolved)
   if (finalize_syms)
     {
       if (resolved)

-       symp->sy_resolved = 1;
+       symp->sy_flags.sy_resolved = 1;

       else if (S_GET_SEGMENT (symp) != expr_section)
        {
          as_bad (_("can't resolve value for symbol `%s'"),
                  S_GET_NAME (symp));
       else if (S_GET_SEGMENT (symp) != expr_section)
        {
          as_bad (_("can't resolve value for symbol `%s'"),
                  S_GET_NAME (symp));

-         symp->sy_resolved = 1;
+         symp->sy_flags.sy_resolved = 1;

        }
     }
 
        }
     }
 


@@ -1509,15 +1512,15 @@ snapshot_symbol (symbolS **symbolPP, valueT *valueP, segT *segP, fragS **fragPP)
     {
       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)
            return 0;
 
          if (!resolved)
            return 0;
 


@@ -1923,7 +1926,7 @@ S_GET_VALUE (symbolS *s)
   if (LOCAL_SYMBOL_CHECK (s))
     return resolve_symbol_value (s);
 
   if (LOCAL_SYMBOL_CHECK (s))
     return resolve_symbol_value (s);
 

-  if (!s->sy_resolved)
+  if (!s->sy_flags.sy_resolved)

     {
       valueT val = resolve_symbol_value (s);
       if (!finalize_syms)
     {
       valueT val = resolve_symbol_value (s);
       if (!finalize_syms)


@@ -1934,7 +1937,7 @@ S_GET_VALUE (symbolS *s)
 
   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_IS_DEFINED (s) && ! S_IS_COMMON (s)))
        as_bad (_("attempt to get value of unresolved symbol `%s'"),
          || s->sy_value.X_op != O_symbol
          || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
        as_bad (_("attempt to get value of unresolved symbol `%s'"),


@@ -2032,7 +2035,7 @@ S_IS_WEAKREFR (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;

-  return s->sy_weakrefr != 0;
+  return s->sy_flags.sy_weakrefr != 0;

 }
 
 int
 }
 
 int


@@ -2040,7 +2043,7 @@ S_IS_WEAKREFD (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;

-  return s->sy_weakrefd != 0;
+  return s->sy_flags.sy_weakrefd != 0;

 }
 
 int
 }
 
 int


@@ -2151,7 +2154,7 @@ S_IS_VOLATILE (const symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;

-  return s->sy_volatile;
+  return s->sy_flags.sy_volatile;

 }
 
 int
 }
 
 int


@@ -2159,7 +2162,7 @@ S_IS_FORWARD_REF (const symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;

-  return s->sy_forward_ref;
+  return s->sy_flags.sy_forward_ref;

 }
 
 const char *
 }
 
 const char *


@@ -2274,14 +2277,14 @@ S_SET_WEAKREFR (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (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
      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 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_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);
 }
 


@@ -2290,7 +2293,7 @@ S_CLEAR_WEAKREFR (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;

-  s->sy_weakrefr = 0;
+  s->sy_flags.sy_weakrefr = 0;

 }
 
 void
 }
 
 void


@@ -2298,7 +2301,7 @@ S_SET_WEAKREFD (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (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);
 }
 


@@ -2307,9 +2310,9 @@ S_CLEAR_WEAKREFD (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     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
         referenced directly before, not even in a .global directive,
         so decay it to local.  If it remains undefined, it will be
       /* 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


@@ -2360,14 +2363,14 @@ S_SET_VOLATILE (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);

-  s->sy_volatile = 1;
+  s->sy_flags.sy_volatile = 1;

 }
 
 void
 S_CLEAR_VOLATILE (symbolS *s)
 {
   if (!LOCAL_SYMBOL_CHECK (s))
 }
 
 void
 S_CLEAR_VOLATILE (symbolS *s)
 {
   if (!LOCAL_SYMBOL_CHECK (s))

-    s->sy_volatile = 0;
+    s->sy_flags.sy_volatile = 0;

 }
 
 void
 }
 
 void


@@ -2375,7 +2378,7 @@ S_SET_FORWARD_REF (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (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.  */


@@ -2424,10 +2427,10 @@ symbol_set_value_expression (symbolS *s, const expressionS *exp)
 int
 symbol_same_p (symbolS *s1, symbolS *s2)
 {
 int
 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))
     s1 = local_symbol_get_real_symbol ((struct local_symbol *) s1);
       && local_symbol_converted_p ((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))
     s2 = local_symbol_get_real_symbol ((struct local_symbol *) s2);
   return s1 == s2;
       && local_symbol_converted_p ((struct local_symbol *) s2))
     s2 = local_symbol_get_real_symbol ((struct local_symbol *) s2);
   return s1 == s2;


@@ -2485,7 +2488,7 @@ symbol_mark_used (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;

-  s->sy_used = 1;
+  s->sy_flags.sy_used = 1;

   if (S_IS_WEAKREFR (s))
     symbol_mark_used (s->sy_value.X_add_symbol);
 }
   if (S_IS_WEAKREFR (s))
     symbol_mark_used (s->sy_value.X_add_symbol);
 }


@@ -2497,7 +2500,7 @@ symbol_clear_used (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (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.  */


@@ -2507,7 +2510,7 @@ symbol_used_p (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 1;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     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.  */


@@ -2517,7 +2520,7 @@ symbol_mark_used_in_reloc (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (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.  */


@@ -2527,7 +2530,7 @@ symbol_clear_used_in_reloc (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     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.  */


@@ -2537,7 +2540,7 @@ symbol_used_in_reloc_p (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     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.  */


@@ -2547,7 +2550,7 @@ symbol_mark_mri_common (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (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.  */


@@ -2557,7 +2560,7 @@ symbol_clear_mri_common (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     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.  */


@@ -2567,7 +2570,7 @@ symbol_mri_common_p (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     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.  */


@@ -2577,7 +2580,7 @@ symbol_mark_written (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     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.  */


@@ -2587,7 +2590,7 @@ symbol_clear_written (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;

-  s->written = 0;
+  s->sy_flags.sy_written = 0;

 }
 
 /* Return whether a symbol has been written.  */
 }
 
 /* Return whether a symbol has been written.  */


@@ -2597,7 +2600,7 @@ symbol_written_p (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     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.  */


@@ -2610,7 +2613,7 @@ symbol_mark_resolved (symbolS *s)
       local_symbol_mark_resolved ((struct local_symbol *) s);
       return;
     }
       local_symbol_mark_resolved ((struct local_symbol *) s);
       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.  */


@@ -2620,7 +2623,7 @@ symbol_resolved_p (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return local_symbol_resolved_p ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (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.  */


@@ -2658,7 +2661,7 @@ symbol_equated_reloc_p (symbolS *s)
 #if defined (OBJ_COFF) && defined (TE_PE)
          && ! S_IS_WEAK (s)
 #endif
 #if defined (OBJ_COFF) && defined (TE_PE)
          && ! S_IS_WEAK (s)
 #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_COMMON (s)));
 }
              || ! S_IS_DEFINED (s)
              || S_IS_COMMON (s)));
 }


@@ -2787,7 +2790,7 @@ dot_symbol_init (void)
   if (dot_symbol.bsym == NULL)
     as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
   dot_symbol.bsym->name = ".";
   if (dot_symbol.bsym == NULL)
     as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
   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;
 }
 \f
   dot_symbol.sy_value.X_op = O_constant;
 }
 \f


@@ -2828,15 +2831,15 @@ print_symbol_value_1 (FILE *file, symbolS *sym)
          fprintf (file, " frag ");
          fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym->sy_frag));
        }
          fprintf (file, " 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");
       if (S_IS_LOCAL (sym))
        fprintf (file, " local");
        fprintf (file, " used");
       if (S_IS_LOCAL (sym))
        fprintf (file, " local");