home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / binutils-2.7-src.tgz / tar.out / fsf / binutils / gas / symbols.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  42KB  |  1,651 lines
  1. /* symbols.c -symbol table-
  2.    Copyright (C) 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996
  3.    Free Software Foundation, Inc.
  4.  
  5.    This file is part of GAS, the GNU Assembler.
  6.  
  7.    GAS is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 2, or (at your option)
  10.    any later version.
  11.  
  12.    GAS is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License
  18.    along with GAS; see the file COPYING.  If not, write to
  19.    the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20.  
  21. /* #define DEBUG_SYMS / * to debug symbol list maintenance */
  22.  
  23. #include <ctype.h>
  24.  
  25. #include "as.h"
  26.  
  27. #include "obstack.h"        /* For "symbols.h" */
  28. #include "subsegs.h"
  29.  
  30. /* This is non-zero if symbols are case sensitive, which is the
  31.    default.  */
  32. int symbols_case_sensitive = 1;
  33.  
  34. #ifndef WORKING_DOT_WORD
  35. extern int new_broken_words;
  36. #endif
  37.  
  38. /* symbol-name => struct symbol pointer */
  39. static struct hash_control *sy_hash;
  40.  
  41. /* Below are commented in "symbols.h". */
  42. symbolS *symbol_rootP;
  43. symbolS *symbol_lastP;
  44. symbolS abs_symbol;
  45.  
  46. #ifdef DEBUG_SYMS
  47. #define debug_verify_symchain verify_symbol_chain
  48. #else
  49. #define debug_verify_symchain(root, last) ((void) 0)
  50. #endif
  51.  
  52. struct obstack notes;
  53.  
  54. static void fb_label_init PARAMS ((void));
  55.  
  56. /* symbol_new()
  57.   
  58.    Return a pointer to a new symbol.  Die if we can't make a new
  59.    symbol.  Fill in the symbol's values.  Add symbol to end of symbol
  60.    chain.
  61.  
  62.    This function should be called in the general case of creating a
  63.    symbol.  However, if the output file symbol table has already been
  64.    set, and you are certain that this symbol won't be wanted in the
  65.    output file, you can call symbol_create.  */
  66.  
  67. symbolS *
  68. symbol_new (name, segment, valu, frag)
  69.      const char *name;
  70.      segT segment;
  71.      valueT valu;
  72.      fragS *frag;
  73. {
  74.   symbolS *symbolP = symbol_create (name, segment, valu, frag);
  75.  
  76.   /*
  77.    * Link to end of symbol chain.
  78.    */
  79. #ifdef BFD_ASSEMBLER
  80.   {
  81.     extern int symbol_table_frozen;
  82.     if (symbol_table_frozen)
  83.       abort ();
  84.   }
  85. #endif
  86.   symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
  87.   debug_verify_symchain (symbol_rootP, symbol_lastP);
  88.  
  89.   return symbolP;
  90. }
  91.  
  92. symbolS *
  93. symbol_create (name, segment, valu, frag)
  94.      const char *name;        /* It is copied, the caller can destroy/modify */
  95.      segT segment;        /* Segment identifier (SEG_<something>) */
  96.      valueT valu;        /* Symbol value */
  97.      fragS *frag;        /* Associated fragment */
  98. {
  99.   unsigned int name_length;
  100.   char *preserved_copy_of_name;
  101.   symbolS *symbolP;
  102.  
  103.   name_length = strlen (name) + 1;    /* +1 for \0 */
  104.   obstack_grow (¬es, name, name_length);
  105.   preserved_copy_of_name = obstack_finish (¬es);
  106. #ifdef STRIP_UNDERSCORE
  107.   if (preserved_copy_of_name[0] == '_')
  108.     preserved_copy_of_name++;
  109. #endif
  110.  
  111. #ifdef tc_canonicalize_symbol_name
  112.   preserved_copy_of_name =
  113.     tc_canonicalize_symbol_name (preserved_copy_of_name);
  114. #endif
  115.  
  116.   if (! symbols_case_sensitive)
  117.     {
  118.       unsigned char *s;
  119.  
  120.       for (s = (unsigned char *) preserved_copy_of_name; *s != '\0'; s++)
  121.     if (islower (*s))
  122.       *s = toupper (*s);
  123.     }
  124.  
  125.   symbolP = (symbolS *) obstack_alloc (¬es, sizeof (symbolS));
  126.  
  127.   /* symbol must be born in some fixed state.  This seems as good as any. */
  128.   memset (symbolP, 0, sizeof (symbolS));
  129.  
  130. #ifdef BFD_ASSEMBLER
  131.   symbolP->bsym = bfd_make_empty_symbol (stdoutput);
  132.   if (symbolP->bsym == NULL)
  133.     as_perror ("%s", "bfd_make_empty_symbol");
  134.   symbolP->bsym->udata.p = (PTR) symbolP;
  135. #endif
  136.   S_SET_NAME (symbolP, preserved_copy_of_name);
  137.  
  138.   S_SET_SEGMENT (symbolP, segment);
  139.   S_SET_VALUE (symbolP, valu);
  140.   symbol_clear_list_pointers (symbolP);
  141.  
  142.   symbolP->sy_frag = frag;
  143. #ifndef BFD_ASSEMBLER
  144.   symbolP->sy_number = ~0;
  145.   symbolP->sy_name_offset = (unsigned int) ~0;
  146. #endif
  147.  
  148.   obj_symbol_new_hook (symbolP);
  149.  
  150. #ifdef tc_symbol_new_hook
  151.   tc_symbol_new_hook (symbolP);
  152. #endif
  153.  
  154.   return symbolP;
  155. }
  156.  
  157.  
  158. /*
  159.  *            colon()
  160.  *
  161.  * We have just seen "<name>:".
  162.  * Creates a struct symbol unless it already exists.
  163.  *
  164.  * Gripes if we are redefining a symbol incompatibly (and ignores it).
  165.  *
  166.  */
  167. symbolS *
  168. colon (sym_name)        /* just seen "x:" - rattle symbols & frags */
  169.      const char *sym_name;    /* symbol name, as a cannonical string */
  170.      /* We copy this string: OK to alter later. */
  171. {
  172.   register symbolS *symbolP;    /* symbol we are working with */
  173.  
  174.   /* Sun local labels go out of scope whenever a non-local symbol is
  175.      defined.  */
  176.   if (LOCAL_LABELS_DOLLAR && ! LOCAL_LABEL (sym_name))
  177.     dollar_label_clear ();
  178.  
  179. #ifndef WORKING_DOT_WORD
  180.   if (new_broken_words)
  181.     {
  182.       struct broken_word *a;
  183.       int possible_bytes;
  184.       fragS *frag_tmp;
  185.       char *frag_opcode;
  186.  
  187.       extern const int md_short_jump_size;
  188.       extern const int md_long_jump_size;
  189.       possible_bytes = (md_short_jump_size
  190.             + new_broken_words * md_long_jump_size);
  191.  
  192.       frag_tmp = frag_now;
  193.       frag_opcode = frag_var (rs_broken_word,
  194.                   possible_bytes,
  195.                   possible_bytes,
  196.                   (relax_substateT) 0,
  197.                   (symbolS *) broken_words,
  198.                   0L,
  199.                   NULL);
  200.  
  201.       /* We want to store the pointer to where to insert the jump table in the
  202.      fr_opcode of the rs_broken_word frag.  This requires a little
  203.      hackery.  */
  204.       while (frag_tmp
  205.          && (frag_tmp->fr_type != rs_broken_word
  206.          || frag_tmp->fr_opcode))
  207.     frag_tmp = frag_tmp->fr_next;
  208.       know (frag_tmp);
  209.       frag_tmp->fr_opcode = frag_opcode;
  210.       new_broken_words = 0;
  211.  
  212.       for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
  213.     a->dispfrag = frag_tmp;
  214.     }
  215. #endif /* WORKING_DOT_WORD */
  216.  
  217.   if ((symbolP = symbol_find (sym_name)) != 0)
  218.     {
  219. #ifdef RESOLVE_SYMBOL_REDEFINITION
  220.       if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
  221.     return symbolP;
  222. #endif
  223.       /*
  224.        *    Now check for undefined symbols
  225.        */
  226.       if (!S_IS_DEFINED (symbolP))
  227.     {
  228.       if (S_GET_VALUE (symbolP) == 0)
  229.         {
  230.           symbolP->sy_frag = frag_now;
  231. #ifdef OBJ_VMS
  232.           S_SET_OTHER(symbolP, const_flag);
  233. #endif
  234.           S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
  235.           S_SET_SEGMENT (symbolP, now_seg);
  236. #ifdef N_UNDF
  237.           know (N_UNDF == 0);
  238. #endif /* if we have one, it better be zero. */
  239.  
  240.         }
  241.       else
  242.         {
  243.           /*
  244.            *    There are still several cases to check:
  245.            *        A .comm/.lcomm symbol being redefined as
  246.            *            initialized data is OK
  247.            *        A .comm/.lcomm symbol being redefined with
  248.            *            a larger size is also OK
  249.            *
  250.            * This only used to be allowed on VMS gas, but Sun cc
  251.            * on the sparc also depends on it.
  252.            */
  253.  
  254.           if (((!S_IS_DEBUG (symbolP)
  255.             && !S_IS_DEFINED (symbolP)
  256.             && S_IS_EXTERNAL (symbolP))
  257.            || S_GET_SEGMENT (symbolP) == bss_section)
  258.           && (now_seg == data_section
  259.               || now_seg == S_GET_SEGMENT (symbolP)))
  260.         {
  261.           /*
  262.            *    Select which of the 2 cases this is
  263.            */
  264.           if (now_seg != data_section)
  265.             {
  266.               /*
  267.                *   New .comm for prev .comm symbol.
  268.                *    If the new size is larger we just
  269.                *    change its value.  If the new size
  270.                *    is smaller, we ignore this symbol
  271.                */
  272.               if (S_GET_VALUE (symbolP)
  273.               < ((unsigned) frag_now_fix ()))
  274.             {
  275.               S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
  276.             }
  277.             }
  278.           else
  279.             {
  280.               /* It is a .comm/.lcomm being converted to initialized
  281.              data.  */
  282.               symbolP->sy_frag = frag_now;
  283. #ifdef OBJ_VMS
  284.               S_SET_OTHER(symbolP, const_flag);
  285. #endif
  286.               S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
  287.               S_SET_SEGMENT (symbolP, now_seg);    /* keep N_EXT bit */
  288.             }
  289.         }
  290.           else
  291.         {
  292. #if defined (S_GET_OTHER) && defined (S_GET_DESC)
  293.           as_fatal ("Symbol \"%s\" is already defined as \"%s\"/%d.%d.%ld.",
  294.                 sym_name,
  295.                 segment_name (S_GET_SEGMENT (symbolP)),
  296.                 S_GET_OTHER (symbolP), S_GET_DESC (symbolP),
  297.                 (long) S_GET_VALUE (symbolP));
  298. #else
  299.           as_fatal ("Symbol \"%s\" is already defined as \"%s\"/%ld.",
  300.                 sym_name,
  301.                 segment_name (S_GET_SEGMENT (symbolP)),
  302.                 (long) S_GET_VALUE (symbolP));
  303. #endif
  304.         }
  305.         }            /* if the undefined symbol has no value */
  306.     }
  307.       else
  308.     {
  309.       /* Don't blow up if the definition is the same */
  310.       if (!(frag_now == symbolP->sy_frag
  311.         && S_GET_VALUE (symbolP) == frag_now_fix ()
  312.         && S_GET_SEGMENT (symbolP) == now_seg))
  313.         as_fatal ("Symbol %s already defined.", sym_name);
  314.     }            /* if this symbol is not yet defined */
  315.  
  316.     }
  317.   else
  318.     {
  319.       symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
  320.                 frag_now);
  321. #ifdef OBJ_VMS
  322.       S_SET_OTHER (symbolP, const_flag);
  323. #endif /* OBJ_VMS */
  324.  
  325.       symbol_table_insert (symbolP);
  326.     }                /* if we have seen this symbol before */
  327.  
  328.   if (mri_common_symbol != NULL)
  329.     {
  330.       /* This symbol is actually being defined within an MRI common
  331.          section.  This requires special handling.  */
  332.       symbolP->sy_value.X_op = O_symbol;
  333.       symbolP->sy_value.X_add_symbol = mri_common_symbol;
  334.       symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
  335.       symbolP->sy_frag = &zero_address_frag;
  336.       S_SET_SEGMENT (symbolP, expr_section);
  337.       symbolP->sy_mri_common = 1;
  338.     }
  339.  
  340. #ifdef tc_frob_label
  341.   tc_frob_label (symbolP);
  342. #endif
  343.  
  344.   return symbolP;
  345. }
  346.  
  347.  
  348. /*
  349.  *            symbol_table_insert()
  350.  *
  351.  * Die if we can't insert the symbol.
  352.  *
  353.  */
  354.  
  355. void 
  356. symbol_table_insert (symbolP)
  357.      symbolS *symbolP;
  358. {
  359.   register const char *error_string;
  360.  
  361.   know (symbolP);
  362.   know (S_GET_NAME (symbolP));
  363.  
  364.   if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTR) symbolP)))
  365.     {
  366.       as_fatal ("Inserting \"%s\" into symbol table failed: %s",
  367.         S_GET_NAME (symbolP), error_string);
  368.     }                /* on error */
  369. }                /* symbol_table_insert() */
  370.  
  371. /*
  372.  *            symbol_find_or_make()
  373.  *
  374.  * If a symbol name does not exist, create it as undefined, and insert
  375.  * it into the symbol table. Return a pointer to it.
  376.  */
  377. symbolS *
  378. symbol_find_or_make (name)
  379.      const char *name;
  380. {
  381.   register symbolS *symbolP;
  382.  
  383.   symbolP = symbol_find (name);
  384.  
  385.   if (symbolP == NULL)
  386.     {
  387.       symbolP = symbol_make (name);
  388.  
  389.       symbol_table_insert (symbolP);
  390.     }                /* if symbol wasn't found */
  391.  
  392.   return (symbolP);
  393. }                /* symbol_find_or_make() */
  394.  
  395. symbolS *
  396. symbol_make (name)
  397.      CONST char *name;
  398. {
  399.   symbolS *symbolP;
  400.  
  401.   /* Let the machine description default it, e.g. for register names. */
  402.   symbolP = md_undefined_symbol ((char *) name);
  403.  
  404.   if (!symbolP)
  405.     symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
  406.  
  407.   return (symbolP);
  408. }                /* symbol_make() */
  409.  
  410. /*
  411.  *            symbol_find()
  412.  *
  413.  * Implement symbol table lookup.
  414.  * In:    A symbol's name as a string: '\0' can't be part of a symbol name.
  415.  * Out:    NULL if the name was not in the symbol table, else the address
  416.  *    of a struct symbol associated with that name.
  417.  */
  418.  
  419. symbolS *
  420. symbol_find (name)
  421.      CONST char *name;
  422. {
  423. #ifdef STRIP_UNDERSCORE
  424.   return (symbol_find_base (name, 1));
  425. #else /* STRIP_UNDERSCORE */
  426.   return (symbol_find_base (name, 0));
  427. #endif /* STRIP_UNDERSCORE */
  428. }                /* symbol_find() */
  429.  
  430. symbolS *
  431. symbol_find_base (name, strip_underscore)
  432.      CONST char *name;
  433.      int strip_underscore;
  434. {
  435.   if (strip_underscore && *name == '_')
  436.     name++;
  437.  
  438. #ifdef tc_canonicalize_symbol_name
  439.   {
  440.     char *copy;
  441.  
  442.     copy = (char *) alloca (strlen (name) + 1);
  443.     strcpy (copy, name);
  444.     name = tc_canonicalize_symbol_name (copy);
  445.   }
  446. #endif
  447.  
  448.   if (! symbols_case_sensitive)
  449.     {
  450.       unsigned char *copy;
  451.  
  452.       copy = (unsigned char *) alloca (strlen (name) + 1);
  453.       name = (const char *) copy;
  454.       for (; *copy != '\0'; copy++)
  455.     if (islower (*copy))
  456.       *copy = toupper (*copy);
  457.     }
  458.  
  459.   return ((symbolS *) hash_find (sy_hash, name));
  460. }
  461.  
  462. /*
  463.  * Once upon a time, symbols were kept in a singly linked list.  At
  464.  * least coff needs to be able to rearrange them from time to time, for
  465.  * which a doubly linked list is much more convenient.  Loic did these
  466.  * as macros which seemed dangerous to me so they're now functions.
  467.  * xoxorich.
  468.  */
  469.  
  470. /* Link symbol ADDME after symbol TARGET in the chain. */
  471. void 
  472. symbol_append (addme, target, rootPP, lastPP)
  473.      symbolS *addme;
  474.      symbolS *target;
  475.      symbolS **rootPP;
  476.      symbolS **lastPP;
  477. {
  478.   if (target == NULL)
  479.     {
  480.       know (*rootPP == NULL);
  481.       know (*lastPP == NULL);
  482.       *rootPP = addme;
  483.       *lastPP = addme;
  484.       return;
  485.     }                /* if the list is empty */
  486.  
  487.   if (target->sy_next != NULL)
  488.     {
  489. #ifdef SYMBOLS_NEED_BACKPOINTERS
  490.       target->sy_next->sy_previous = addme;
  491. #endif /* SYMBOLS_NEED_BACKPOINTERS */
  492.     }
  493.   else
  494.     {
  495.       know (*lastPP == target);
  496.       *lastPP = addme;
  497.     }                /* if we have a next */
  498.  
  499.   addme->sy_next = target->sy_next;
  500.   target->sy_next = addme;
  501.  
  502. #ifdef SYMBOLS_NEED_BACKPOINTERS
  503.   addme->sy_previous = target;
  504. #endif /* SYMBOLS_NEED_BACKPOINTERS */
  505. }
  506.  
  507. /* Set the chain pointers of SYMBOL to null. */
  508. void 
  509. symbol_clear_list_pointers (symbolP)
  510.      symbolS *symbolP;
  511. {
  512.   symbolP->sy_next = NULL;
  513. #ifdef SYMBOLS_NEED_BACKPOINTERS
  514.   symbolP->sy_previous = NULL;
  515. #endif
  516. }
  517.  
  518. #ifdef SYMBOLS_NEED_BACKPOINTERS
  519. /* Remove SYMBOLP from the list. */
  520. void 
  521. symbol_remove (symbolP, rootPP, lastPP)
  522.      symbolS *symbolP;
  523.      symbolS **rootPP;
  524.      symbolS **lastPP;
  525. {
  526.   if (symbolP == *rootPP)
  527.     {
  528.       *rootPP = symbolP->sy_next;
  529.     }                /* if it was the root */
  530.  
  531.   if (symbolP == *lastPP)
  532.     {
  533.       *lastPP = symbolP->sy_previous;
  534.     }                /* if it was the tail */
  535.  
  536.   if (symbolP->sy_next != NULL)
  537.     {
  538.       symbolP->sy_next->sy_previous = symbolP->sy_previous;
  539.     }                /* if not last */
  540.  
  541.   if (symbolP->sy_previous != NULL)
  542.     {
  543.       symbolP->sy_previous->sy_next = symbolP->sy_next;
  544.     }                /* if not first */
  545.  
  546.   debug_verify_symchain (*rootPP, *lastPP);
  547. }
  548.  
  549. /* Link symbol ADDME before symbol TARGET in the chain. */
  550. void 
  551. symbol_insert (addme, target, rootPP, lastPP)
  552.      symbolS *addme;
  553.      symbolS *target;
  554.      symbolS **rootPP;
  555.      symbolS **lastPP;
  556. {
  557.   if (target->sy_previous != NULL)
  558.     {
  559.       target->sy_previous->sy_next = addme;
  560.     }
  561.   else
  562.     {
  563.       know (*rootPP == target);
  564.       *rootPP = addme;
  565.     }                /* if not first */
  566.  
  567.   addme->sy_previous = target->sy_previous;
  568.   target->sy_previous = addme;
  569.   addme->sy_next = target;
  570.  
  571.   debug_verify_symchain (*rootPP, *lastPP);
  572. }
  573.  
  574. #endif /* SYMBOLS_NEED_BACKPOINTERS */
  575.  
  576. void 
  577. verify_symbol_chain (rootP, lastP)
  578.      symbolS *rootP;
  579.      symbolS *lastP;
  580. {
  581.   symbolS *symbolP = rootP;
  582.  
  583.   if (symbolP == NULL)
  584.     return;
  585.  
  586.   for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
  587.     {
  588. #ifdef SYMBOLS_NEED_BACKPOINTERS
  589.       know (symbolP->sy_next->sy_previous == symbolP);
  590. #else
  591.       /* Walk the list anyways, to make sure pointers are still good.  */
  592.       ;
  593. #endif /* SYMBOLS_NEED_BACKPOINTERS */
  594.     }
  595.  
  596.   assert (lastP == symbolP);
  597. }
  598.  
  599. void
  600. verify_symbol_chain_2 (sym)
  601.      symbolS *sym;
  602. {
  603.   symbolS *p = sym, *n = sym;
  604. #ifdef SYMBOLS_NEED_BACKPOINTERS
  605.   while (symbol_previous (p))
  606.     p = symbol_previous (p);
  607. #endif
  608.   while (symbol_next (n))
  609.     n = symbol_next (n);
  610.   verify_symbol_chain (p, n);
  611. }
  612.  
  613. /* Resolve the value of a symbol.  This is called during the final
  614.    pass over the symbol table to resolve any symbols with complex
  615.    values.  */
  616.  
  617. void
  618. resolve_symbol_value (symp)
  619.      symbolS *symp;
  620. {
  621.   int resolved;
  622.  
  623.   if (symp->sy_resolved)
  624.     return;
  625.  
  626.   resolved = 0;
  627.  
  628.   if (symp->sy_resolving)
  629.     {
  630.       as_bad ("Symbol definition loop encountered at %s",
  631.           S_GET_NAME (symp));
  632.       S_SET_VALUE (symp, (valueT) 0);
  633.       resolved = 1;
  634.     }
  635.   else
  636.     {
  637.       offsetT left, right, val;
  638.       segT seg_left, seg_right;
  639.  
  640.       symp->sy_resolving = 1;
  641.  
  642.     reduce:
  643.       switch (symp->sy_value.X_op)
  644.     {
  645.     case O_absent:
  646.       S_SET_VALUE (symp, 0);
  647.       /* Fall through.  */
  648.     case O_constant:
  649.       S_SET_VALUE (symp, S_GET_VALUE (symp) + symp->sy_frag->fr_address);
  650.       if (S_GET_SEGMENT (symp) == expr_section)
  651.         S_SET_SEGMENT (symp, absolute_section);
  652.       resolved = 1;
  653.       break;
  654.  
  655.     case O_symbol:
  656.       resolve_symbol_value (symp->sy_value.X_add_symbol);
  657.  
  658.       if (symp->sy_mri_common)
  659.         {
  660.           /* This is a symbol inside an MRI common section.  The
  661.                  relocation routines are going to handle it specially.
  662.                  Don't change the value.  */
  663.           S_SET_VALUE (symp, symp->sy_value.X_add_number);
  664.           resolved = symp->sy_value.X_add_symbol->sy_resolved;
  665.           break;
  666.         }
  667.  
  668.       if (symp->sy_value.X_add_number == 0)
  669.         copy_symbol_attributes (symp, symp->sy_value.X_add_symbol);
  670.  
  671.       S_SET_VALUE (symp,
  672.                (symp->sy_value.X_add_number
  673.             + symp->sy_frag->fr_address
  674.             + S_GET_VALUE (symp->sy_value.X_add_symbol)));
  675.       if (S_GET_SEGMENT (symp) == expr_section
  676.           || S_GET_SEGMENT (symp) == undefined_section)
  677.         S_SET_SEGMENT (symp,
  678.                S_GET_SEGMENT (symp->sy_value.X_add_symbol));
  679.  
  680.       /* If we have equated this symbol to an undefined symbol, we
  681.              keep X_op set to O_symbol.  This permits the routine
  682.              which writes out relocation to detect this case, and
  683.              convert the relocation to be against the symbol to which
  684.              this symbol is equated.  */
  685.       if (! S_IS_DEFINED (symp) || S_IS_COMMON (symp))
  686.         symp->sy_value.X_op = O_symbol;
  687.  
  688.       resolved = symp->sy_value.X_add_symbol->sy_resolved;
  689.       break;
  690.  
  691.     case O_uminus:
  692.     case O_bit_not:
  693.     case O_logical_not:
  694.       resolve_symbol_value (symp->sy_value.X_add_symbol);
  695.       if (symp->sy_value.X_op == O_uminus)
  696.         val = - S_GET_VALUE (symp->sy_value.X_add_symbol);
  697.       else if (symp->sy_value.X_op == O_logical_not)
  698.         val = ! S_GET_VALUE (symp->sy_value.X_add_symbol);
  699.       else
  700.         val = ~ S_GET_VALUE (symp->sy_value.X_add_symbol);
  701.       S_SET_VALUE (symp,
  702.                (val
  703.             + symp->sy_value.X_add_number
  704.             + symp->sy_frag->fr_address));
  705.       if (S_GET_SEGMENT (symp) == expr_section
  706.           || S_GET_SEGMENT (symp) == undefined_section)
  707.         S_SET_SEGMENT (symp, absolute_section);
  708.       resolved = symp->sy_value.X_add_symbol->sy_resolved;
  709.       break;
  710.  
  711.     case O_add:
  712.       resolve_symbol_value (symp->sy_value.X_add_symbol);
  713.       resolve_symbol_value (symp->sy_value.X_op_symbol);
  714.       seg_left = S_GET_SEGMENT (symp->sy_value.X_add_symbol);
  715.       seg_right = S_GET_SEGMENT (symp->sy_value.X_op_symbol);
  716.       /* This case comes up with PIC support.  */
  717.       {
  718.         symbolS *s_left = symp->sy_value.X_add_symbol;
  719.         symbolS *s_right = symp->sy_value.X_op_symbol;
  720.  
  721.         if (seg_left == absolute_section)
  722.           {
  723.         symbolS *t;
  724.         segT ts;
  725.         t = s_left;
  726.         s_left = s_right;
  727.         s_right = t;
  728.         ts = seg_left;
  729.         seg_left = seg_right;
  730.         seg_right = ts;
  731.           }
  732.         if (seg_right == absolute_section
  733.         && s_right->sy_resolved)
  734.           {
  735.         symp->sy_value.X_add_number += S_GET_VALUE (s_right);
  736.         symp->sy_value.X_op_symbol = 0;
  737.         symp->sy_value.X_add_symbol = s_left;
  738.         symp->sy_value.X_op = O_symbol;
  739.         goto reduce;
  740.           }
  741.       }
  742.       /* fall through */
  743.  
  744.     case O_multiply:
  745.     case O_divide:
  746.     case O_modulus:
  747.     case O_left_shift:
  748.     case O_right_shift:
  749.     case O_bit_inclusive_or:
  750.     case O_bit_or_not:
  751.     case O_bit_exclusive_or:
  752.     case O_bit_and:
  753.     case O_subtract:
  754.     case O_eq:
  755.     case O_ne:
  756.     case O_lt:
  757.     case O_le:
  758.     case O_ge:
  759.     case O_gt:
  760.     case O_logical_and:
  761.     case O_logical_or:
  762.       resolve_symbol_value (symp->sy_value.X_add_symbol);
  763.       resolve_symbol_value (symp->sy_value.X_op_symbol);
  764.       seg_left = S_GET_SEGMENT (symp->sy_value.X_add_symbol);
  765.       seg_right = S_GET_SEGMENT (symp->sy_value.X_op_symbol);
  766.       if (seg_left != seg_right
  767.           && seg_left != undefined_section
  768.           && seg_right != undefined_section)
  769.         {
  770.           char *file;
  771.           unsigned int line;
  772.  
  773.           if (expr_symbol_where (symp, &file, &line))
  774.         as_bad_where
  775.           (file, line,
  776.            "illegal operation on symbols in different sections");
  777.           else
  778.         as_bad
  779.           ("%s set to illegal operation on symbols in different sections",
  780.            S_GET_NAME (symp));
  781.         }
  782.       if ((S_GET_SEGMENT (symp->sy_value.X_add_symbol)
  783.            != absolute_section)
  784.           && symp->sy_value.X_op != O_subtract)
  785.         {
  786.           char *file;
  787.           unsigned int line;
  788.  
  789.           if (expr_symbol_where (symp, &file, &line))
  790.         as_bad_where (file, line,
  791.                   "illegal operation on non-absolute symbols");
  792.           else
  793.         as_bad ("%s set to illegal operation on non-absolute symbols",
  794.             S_GET_NAME (symp));
  795.         }
  796.       left = S_GET_VALUE (symp->sy_value.X_add_symbol);
  797.       right = S_GET_VALUE (symp->sy_value.X_op_symbol);
  798.       switch (symp->sy_value.X_op)
  799.         {
  800.         case O_multiply:        val = left * right; break;
  801.         case O_divide:        val = left / right; break;
  802.         case O_modulus:        val = left % right; break;
  803.         case O_left_shift:        val = left << right; break;
  804.         case O_right_shift:        val = left >> right; break;
  805.         case O_bit_inclusive_or:    val = left | right; break;
  806.         case O_bit_or_not:        val = left |~ right; break;
  807.         case O_bit_exclusive_or:    val = left ^ right; break;
  808.         case O_bit_and:        val = left & right; break;
  809.         case O_add:            val = left + right; break;
  810.         case O_subtract:        val = left - right; break;
  811.         case O_eq:        val = left == right ? ~ (offsetT) 0 : 0;
  812.         case O_ne:        val = left != right ? ~ (offsetT) 0 : 0;
  813.         case O_lt:        val = left <  right ? ~ (offsetT) 0 : 0;
  814.         case O_le:        val = left <= right ? ~ (offsetT) 0 : 0;
  815.         case O_ge:        val = left >= right ? ~ (offsetT) 0 : 0;
  816.         case O_gt:        val = left >  right ? ~ (offsetT) 0 : 0;
  817.         case O_logical_and:    val = left && right; break;
  818.         case O_logical_or:    val = left || right; break;
  819.         default:            abort ();
  820.         }
  821.       S_SET_VALUE (symp,
  822.                (symp->sy_value.X_add_number
  823.             + symp->sy_frag->fr_address
  824.             + val));
  825.       if (S_GET_SEGMENT (symp) == expr_section
  826.           || S_GET_SEGMENT (symp) == undefined_section)
  827.         S_SET_SEGMENT (symp, absolute_section);
  828.       resolved = (symp->sy_value.X_add_symbol->sy_resolved
  829.               && symp->sy_value.X_op_symbol->sy_resolved);
  830.          break;
  831.  
  832.     case O_register:
  833.     case O_big:
  834.     case O_illegal:
  835.       /* Give an error (below) if not in expr_section.  We don't
  836.          want to worry about expr_section symbols, because they
  837.          are fictional (they are created as part of expression
  838.          resolution), and any problems may not actually mean
  839.          anything.  */
  840.       break;
  841.     }
  842.     }
  843.  
  844.   /* Don't worry if we can't resolve an expr_section symbol.  */
  845.   if (resolved)
  846.     symp->sy_resolved = 1;
  847.   else if (S_GET_SEGMENT (symp) != expr_section)
  848.     {
  849.       as_bad ("can't resolve value for symbol \"%s\"", S_GET_NAME (symp));
  850.       symp->sy_resolved = 1;
  851.     }
  852. }
  853.  
  854. /* Dollar labels look like a number followed by a dollar sign.  Eg, "42$".
  855.    They are *really* local.  That is, they go out of scope whenever we see a
  856.    label that isn't local.  Also, like fb labels, there can be multiple
  857.    instances of a dollar label.  Therefor, we name encode each instance with
  858.    the instance number, keep a list of defined symbols separate from the real
  859.    symbol table, and we treat these buggers as a sparse array.  */
  860.  
  861. static long *dollar_labels;
  862. static long *dollar_label_instances;
  863. static char *dollar_label_defines;
  864. static long dollar_label_count;
  865. static unsigned long dollar_label_max;
  866.  
  867. int 
  868. dollar_label_defined (label)
  869.      long label;
  870. {
  871.   long *i;
  872.  
  873.   know ((dollar_labels != NULL) || (dollar_label_count == 0));
  874.  
  875.   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
  876.     if (*i == label)
  877.       return dollar_label_defines[i - dollar_labels];
  878.  
  879.   /* if we get here, label isn't defined */
  880.   return 0;
  881. }                /* dollar_label_defined() */
  882.  
  883. static int 
  884. dollar_label_instance (label)
  885.      long label;
  886. {
  887.   long *i;
  888.  
  889.   know ((dollar_labels != NULL) || (dollar_label_count == 0));
  890.  
  891.   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
  892.     if (*i == label)
  893.       return (dollar_label_instances[i - dollar_labels]);
  894.  
  895.   /* If we get here, we haven't seen the label before, therefore its instance
  896.      count is zero.  */
  897.   return 0;
  898. }
  899.  
  900. void 
  901. dollar_label_clear ()
  902. {
  903.   memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
  904. }
  905.  
  906. #define DOLLAR_LABEL_BUMP_BY 10
  907.  
  908. void 
  909. define_dollar_label (label)
  910.      long label;
  911. {
  912.   long *i;
  913.  
  914.   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
  915.     if (*i == label)
  916.       {
  917.     ++dollar_label_instances[i - dollar_labels];
  918.     dollar_label_defines[i - dollar_labels] = 1;
  919.     return;
  920.       }
  921.  
  922.   /* if we get to here, we don't have label listed yet. */
  923.  
  924.   if (dollar_labels == NULL)
  925.     {
  926.       dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
  927.       dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
  928.       dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY);
  929.       dollar_label_max = DOLLAR_LABEL_BUMP_BY;
  930.       dollar_label_count = 0;
  931.     }
  932.   else if (dollar_label_count == dollar_label_max)
  933.     {
  934.       dollar_label_max += DOLLAR_LABEL_BUMP_BY;
  935.       dollar_labels = (long *) xrealloc ((char *) dollar_labels,
  936.                      dollar_label_max * sizeof (long));
  937.       dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
  938.                       dollar_label_max * sizeof (long));
  939.       dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);
  940.     }                /* if we needed to grow */
  941.  
  942.   dollar_labels[dollar_label_count] = label;
  943.   dollar_label_instances[dollar_label_count] = 1;
  944.   dollar_label_defines[dollar_label_count] = 1;
  945.   ++dollar_label_count;
  946. }
  947.  
  948. /*
  949.  *            dollar_label_name()
  950.  *
  951.  * Caller must copy returned name: we re-use the area for the next name.
  952.  *
  953.  * The mth occurence of label n: is turned into the symbol "Ln^Am"
  954.  * where n is the label number and m is the instance number. "L" makes
  955.  * it a label discarded unless debugging and "^A"('\1') ensures no
  956.  * ordinary symbol SHOULD get the same name as a local label
  957.  * symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
  958.  *
  959.  * fb labels get the same treatment, except that ^B is used in place of ^A.
  960.  */
  961.  
  962. char *                /* Return local label name. */
  963. dollar_label_name (n, augend)
  964.      register long n;        /* we just saw "n$:" : n a number */
  965.      register int augend;    /* 0 for current instance, 1 for new instance */
  966. {
  967.   long i;
  968.   /* Returned to caller, then copied.  used for created names ("4f") */
  969.   static char symbol_name_build[24];
  970.   register char *p;
  971.   register char *q;
  972.   char symbol_name_temporary[20];    /* build up a number, BACKWARDS */
  973.  
  974.   know (n >= 0);
  975.   know (augend == 0 || augend == 1);
  976.   p = symbol_name_build;
  977.   *p++ = 'L';
  978.  
  979.   /* Next code just does sprintf( {}, "%d", n); */
  980.   /* label number */
  981.   q = symbol_name_temporary;
  982.   for (*q++ = 0, i = n; i; ++q)
  983.     {
  984.       *q = i % 10 + '0';
  985.       i /= 10;
  986.     }
  987.   while ((*p = *--q) != '\0')
  988.     ++p;
  989.  
  990.   *p++ = 1;            /* ^A */
  991.  
  992.   /* instance number */
  993.   q = symbol_name_temporary;
  994.   for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
  995.     {
  996.       *q = i % 10 + '0';
  997.       i /= 10;
  998.     }
  999.   while ((*p++ = *--q) != '\0');;
  1000.  
  1001.   /* The label, as a '\0' ended string, starts at symbol_name_build. */
  1002.   return symbol_name_build;
  1003. }
  1004.  
  1005. /*
  1006.  * Sombody else's idea of local labels. They are made by "n:" where n
  1007.  * is any decimal digit. Refer to them with
  1008.  *  "nb" for previous (backward) n:
  1009.  *  or "nf" for next (forward) n:.
  1010.  *
  1011.  * We do a little better and let n be any number, not just a single digit, but
  1012.  * since the other guy's assembler only does ten, we treat the first ten
  1013.  * specially.
  1014.  *
  1015.  * Like someone else's assembler, we have one set of local label counters for
  1016.  * entire assembly, not one set per (sub)segment like in most assemblers. This
  1017.  * implies that one can refer to a label in another segment, and indeed some
  1018.  * crufty compilers have done just that.
  1019.  *
  1020.  * Since there could be a LOT of these things, treat them as a sparse array.
  1021.  */
  1022.  
  1023. #define FB_LABEL_SPECIAL (10)
  1024.  
  1025. static long fb_low_counter[FB_LABEL_SPECIAL];
  1026. static long *fb_labels;
  1027. static long *fb_label_instances;
  1028. static long fb_label_count;
  1029. static long fb_label_max;
  1030.  
  1031. /* this must be more than FB_LABEL_SPECIAL */
  1032. #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
  1033.  
  1034. static void 
  1035. fb_label_init ()
  1036. {
  1037.   memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
  1038. }                /* fb_label_init() */
  1039.  
  1040. /* add one to the instance number of this fb label */
  1041. void 
  1042. fb_label_instance_inc (label)
  1043.      long label;
  1044. {
  1045.   long *i;
  1046.  
  1047.   if (label < FB_LABEL_SPECIAL)
  1048.     {
  1049.       ++fb_low_counter[label];
  1050.       return;
  1051.     }
  1052.  
  1053.   if (fb_labels != NULL)
  1054.     {
  1055.       for (i = fb_labels + FB_LABEL_SPECIAL;
  1056.        i < fb_labels + fb_label_count; ++i)
  1057.     {
  1058.       if (*i == label)
  1059.         {
  1060.           ++fb_label_instances[i - fb_labels];
  1061.           return;
  1062.         }            /* if we find it */
  1063.     }            /* for each existing label */
  1064.     }
  1065.  
  1066.   /* if we get to here, we don't have label listed yet. */
  1067.  
  1068.   if (fb_labels == NULL)
  1069.     {
  1070.       fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
  1071.       fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
  1072.       fb_label_max = FB_LABEL_BUMP_BY;
  1073.       fb_label_count = FB_LABEL_SPECIAL;
  1074.  
  1075.     }
  1076.   else if (fb_label_count == fb_label_max)
  1077.     {
  1078.       fb_label_max += FB_LABEL_BUMP_BY;
  1079.       fb_labels = (long *) xrealloc ((char *) fb_labels,
  1080.                      fb_label_max * sizeof (long));
  1081.       fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
  1082.                           fb_label_max * sizeof (long));
  1083.     }                /* if we needed to grow */
  1084.  
  1085.   fb_labels[fb_label_count] = label;
  1086.   fb_label_instances[fb_label_count] = 1;
  1087.   ++fb_label_count;
  1088. }
  1089.  
  1090. static long 
  1091. fb_label_instance (label)
  1092.      long label;
  1093. {
  1094.   long *i;
  1095.  
  1096.   if (label < FB_LABEL_SPECIAL)
  1097.     {
  1098.       return (fb_low_counter[label]);
  1099.     }
  1100.  
  1101.   if (fb_labels != NULL)
  1102.     {
  1103.       for (i = fb_labels + FB_LABEL_SPECIAL;
  1104.        i < fb_labels + fb_label_count; ++i)
  1105.     {
  1106.       if (*i == label)
  1107.         {
  1108.           return (fb_label_instances[i - fb_labels]);
  1109.         }            /* if we find it */
  1110.     }            /* for each existing label */
  1111.     }
  1112.  
  1113.   /* We didn't find the label, so this must be a reference to the
  1114.      first instance.  */
  1115.   return 0;
  1116. }
  1117.  
  1118. /*
  1119.  *            fb_label_name()
  1120.  *
  1121.  * Caller must copy returned name: we re-use the area for the next name.
  1122.  *
  1123.  * The mth occurence of label n: is turned into the symbol "Ln^Bm"
  1124.  * where n is the label number and m is the instance number. "L" makes
  1125.  * it a label discarded unless debugging and "^B"('\2') ensures no
  1126.  * ordinary symbol SHOULD get the same name as a local label
  1127.  * symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
  1128.  *
  1129.  * dollar labels get the same treatment, except that ^A is used in place of ^B. */
  1130.  
  1131. char *                /* Return local label name. */
  1132. fb_label_name (n, augend)
  1133.      long n;            /* we just saw "n:", "nf" or "nb" : n a number */
  1134.      long augend;        /* 0 for nb, 1 for n:, nf */
  1135. {
  1136.   long i;
  1137.   /* Returned to caller, then copied.  used for created names ("4f") */
  1138.   static char symbol_name_build[24];
  1139.   register char *p;
  1140.   register char *q;
  1141.   char symbol_name_temporary[20];    /* build up a number, BACKWARDS */
  1142.  
  1143.   know (n >= 0);
  1144.   know (augend == 0 || augend == 1);
  1145.   p = symbol_name_build;
  1146.   *p++ = 'L';
  1147.  
  1148.   /* Next code just does sprintf( {}, "%d", n); */
  1149.   /* label number */
  1150.   q = symbol_name_temporary;
  1151.   for (*q++ = 0, i = n; i; ++q)
  1152.     {
  1153.       *q = i % 10 + '0';
  1154.       i /= 10;
  1155.     }
  1156.   while ((*p = *--q) != '\0')
  1157.     ++p;
  1158.  
  1159.   *p++ = 2;            /* ^B */
  1160.  
  1161.   /* instance number */
  1162.   q = symbol_name_temporary;
  1163.   for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
  1164.     {
  1165.       *q = i % 10 + '0';
  1166.       i /= 10;
  1167.     }
  1168.   while ((*p++ = *--q) != '\0');;
  1169.  
  1170.   /* The label, as a '\0' ended string, starts at symbol_name_build. */
  1171.   return (symbol_name_build);
  1172. }                /* fb_label_name() */
  1173.  
  1174. /*
  1175.  * decode name that may have been generated by foo_label_name() above.  If
  1176.  * the name wasn't generated by foo_label_name(), then return it unaltered.
  1177.  * This is used for error messages.
  1178.  */
  1179.  
  1180. char *
  1181. decode_local_label_name (s)
  1182.      char *s;
  1183. {
  1184.   char *p;
  1185.   char *symbol_decode;
  1186.   int label_number;
  1187.   int instance_number;
  1188.   char *type;
  1189.   const char *message_format = "\"%d\" (instance number %d of a %s label)";
  1190.  
  1191.   if (s[0] != 'L')
  1192.     return s;
  1193.  
  1194.   for (label_number = 0, p = s + 1; isdigit (*p); ++p)
  1195.     label_number = (10 * label_number) + *p - '0';
  1196.  
  1197.   if (*p == 1)
  1198.     type = "dollar";
  1199.   else if (*p == 2)
  1200.     type = "fb";
  1201.   else
  1202.     return s;
  1203.  
  1204.   for (instance_number = 0, p++; isdigit (*p); ++p)
  1205.     instance_number = (10 * instance_number) + *p - '0';
  1206.  
  1207.   symbol_decode = obstack_alloc (¬es, strlen (message_format) + 30);
  1208.   sprintf (symbol_decode, message_format, label_number, instance_number, type);
  1209.  
  1210.   return symbol_decode;
  1211. }
  1212.  
  1213. /* Get the value of a symbol.  */
  1214.  
  1215. valueT
  1216. S_GET_VALUE (s)
  1217.      symbolS *s;
  1218. {
  1219.   if (!s->sy_resolved && !s->sy_resolving && s->sy_value.X_op != O_constant)
  1220.     resolve_symbol_value (s);
  1221.   if (s->sy_value.X_op != O_constant)
  1222.     {
  1223.       static symbolS *recur;
  1224.  
  1225.       /* FIXME: In non BFD assemblers, S_IS_DEFINED and S_IS_COMMON
  1226.          may call S_GET_VALUE.  We use a static symbol to avoid the
  1227.          immediate recursion.  */
  1228.       if (recur == s)
  1229.     return (valueT) s->sy_value.X_add_number;
  1230.       recur = s;
  1231.       if (! s->sy_resolved
  1232.       || s->sy_value.X_op != O_symbol
  1233.       || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
  1234.     as_bad ("Attempt to get value of unresolved symbol %s",
  1235.         S_GET_NAME (s));
  1236.       recur = NULL;
  1237.     }
  1238.   return (valueT) s->sy_value.X_add_number;
  1239. }
  1240.  
  1241. /* Set the value of a symbol.  */
  1242.  
  1243. void
  1244. S_SET_VALUE (s, val)
  1245.      symbolS *s;
  1246.      valueT val;
  1247. {
  1248.   s->sy_value.X_op = O_constant;
  1249.   s->sy_value.X_add_number = (offsetT) val;
  1250.   s->sy_value.X_unsigned = 0;
  1251. }
  1252.  
  1253. void
  1254. copy_symbol_attributes (dest, src)
  1255.      symbolS *dest, *src;
  1256. {
  1257. #ifdef BFD_ASSEMBLER
  1258.   /* In an expression, transfer the settings of these flags.
  1259.      The user can override later, of course.  */
  1260. #define COPIED_SYMFLAGS    (BSF_FUNCTION)
  1261.   dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
  1262. #endif
  1263.  
  1264. #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
  1265.   OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
  1266. #endif
  1267. }
  1268.  
  1269. #ifdef BFD_ASSEMBLER
  1270.  
  1271. int
  1272. S_IS_EXTERNAL (s)
  1273.      symbolS *s;
  1274. {
  1275.   flagword flags = s->bsym->flags;
  1276.  
  1277.   /* sanity check */
  1278.   if (flags & BSF_LOCAL && flags & BSF_GLOBAL)
  1279.     abort ();
  1280.  
  1281.   return (flags & BSF_GLOBAL) != 0;
  1282. }
  1283.  
  1284. int
  1285. S_IS_WEAK (s)
  1286.      symbolS *s;
  1287. {
  1288.   return (s->bsym->flags & BSF_WEAK) != 0;
  1289. }
  1290.  
  1291. int
  1292. S_IS_COMMON (s)
  1293.      symbolS *s;
  1294. {
  1295.   return bfd_is_com_section (s->bsym->section);
  1296. }
  1297.  
  1298. int
  1299. S_IS_DEFINED (s)
  1300.      symbolS *s;
  1301. {
  1302.   return s->bsym->section != undefined_section;
  1303. }
  1304.  
  1305. int
  1306. S_IS_DEBUG (s)
  1307.      symbolS *s;
  1308. {
  1309.   if (s->bsym->flags & BSF_DEBUGGING)
  1310.     return 1;
  1311.   return 0;
  1312. }
  1313.  
  1314. int
  1315. S_IS_LOCAL (s)
  1316.      symbolS *s;
  1317. {
  1318.   flagword flags = s->bsym->flags;
  1319.   const char *name;
  1320.  
  1321.   /* sanity check */
  1322.   if (flags & BSF_LOCAL && flags & BSF_GLOBAL)
  1323.     abort ();
  1324.  
  1325.   if (bfd_get_section (s->bsym) == reg_section)
  1326.     return 1;
  1327.  
  1328.   name = S_GET_NAME (s);
  1329.   return (name != NULL
  1330.       && ! S_IS_DEBUG (s)
  1331.       && (strchr (name, '\001')
  1332.           || strchr (name, '\002')
  1333.           || (! flag_keep_locals
  1334.           && (LOCAL_LABEL (name)
  1335.               || (flag_mri
  1336.               && name[0] == '?'
  1337.               && name[1] == '?')))));
  1338. }
  1339.  
  1340. int
  1341. S_IS_EXTERN (s)
  1342.      symbolS *s;
  1343. {
  1344.   return S_IS_EXTERNAL (s);
  1345. }
  1346.  
  1347. int
  1348. S_IS_STABD (s)
  1349.      symbolS *s;
  1350. {
  1351.   return S_GET_NAME (s) == 0;
  1352. }
  1353.  
  1354. CONST char *
  1355. S_GET_NAME (s)
  1356.      symbolS *s;
  1357. {
  1358.   return s->bsym->name;
  1359. }
  1360.  
  1361. segT
  1362. S_GET_SEGMENT (s)
  1363.      symbolS *s;
  1364. {
  1365.   return s->bsym->section;
  1366. }
  1367.  
  1368. void
  1369. S_SET_SEGMENT (s, seg)
  1370.      symbolS *s;
  1371.      segT seg;
  1372. {
  1373.   s->bsym->section = seg;
  1374. }
  1375.  
  1376. void
  1377. S_SET_EXTERNAL (s)
  1378.      symbolS *s;
  1379. {
  1380.   if ((s->bsym->flags & BSF_WEAK) != 0)
  1381.     {
  1382.       as_bad ("%s already declared as weak", S_GET_NAME (s));
  1383.       return;
  1384.     }
  1385.   s->bsym->flags |= BSF_GLOBAL;
  1386.   s->bsym->flags &= ~(BSF_LOCAL|BSF_WEAK);
  1387. }
  1388.  
  1389. void
  1390. S_CLEAR_EXTERNAL (s)
  1391.      symbolS *s;
  1392. {
  1393.   if ((s->bsym->flags & BSF_WEAK) != 0)
  1394.     {
  1395.       as_bad ("%s already declared as weak", S_GET_NAME (s));
  1396.       return;
  1397.     }
  1398.   s->bsym->flags |= BSF_LOCAL;
  1399.   s->bsym->flags &= ~(BSF_GLOBAL|BSF_WEAK);
  1400. }
  1401.  
  1402. void
  1403. S_SET_WEAK (s)
  1404.      symbolS *s;
  1405. {
  1406.   if ((s->bsym->flags & BSF_GLOBAL) != 0)
  1407.     {
  1408.       as_bad ("%s already declared as global", S_GET_NAME (s));
  1409.       return;
  1410.     }
  1411.   s->bsym->flags |= BSF_WEAK;
  1412.   s->bsym->flags &= ~(BSF_GLOBAL|BSF_LOCAL);
  1413. }
  1414.  
  1415. void
  1416. S_SET_NAME (s, name)
  1417.      symbolS *s;
  1418.      char *name;
  1419. {
  1420.   s->bsym->name = name;
  1421. }
  1422. #endif /* BFD_ASSEMBLER */
  1423.  
  1424. void
  1425. symbol_begin ()
  1426. {
  1427.   symbol_lastP = NULL;
  1428.   symbol_rootP = NULL;        /* In case we have 0 symbols (!!) */
  1429.   sy_hash = hash_new ();
  1430.  
  1431.   memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
  1432. #ifdef BFD_ASSEMBLER
  1433. #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
  1434.   abs_symbol.bsym = bfd_abs_section.symbol;
  1435. #endif
  1436. #else
  1437.   /* Can't initialise a union. Sigh. */
  1438.   S_SET_SEGMENT (&abs_symbol, absolute_section);
  1439. #endif
  1440.   abs_symbol.sy_value.X_op = O_constant;
  1441.   abs_symbol.sy_frag = &zero_address_frag;
  1442.  
  1443.   if (LOCAL_LABELS_FB)
  1444.     fb_label_init ();
  1445. }
  1446.  
  1447.  
  1448. int indent_level;
  1449.  
  1450. #if 0
  1451.  
  1452. static void
  1453. indent ()
  1454. {
  1455.   printf ("%*s", indent_level * 4, "");
  1456. }
  1457.  
  1458. #endif
  1459.  
  1460. void print_expr_1 PARAMS ((FILE *, expressionS *));
  1461. void print_symbol_value_1 PARAMS ((FILE *, symbolS *));
  1462.  
  1463. void
  1464. print_symbol_value_1 (file, sym)
  1465.      FILE *file;
  1466.      symbolS *sym;
  1467. {
  1468.   const char *name = S_GET_NAME (sym);
  1469.   if (!name || !name[0])
  1470.     name = "(unnamed)";
  1471.   fprintf (file, "sym %lx %s", (unsigned long) sym, name);
  1472.   if (sym->sy_frag != &zero_address_frag)
  1473.     fprintf (file, " frag %lx", (long) sym->sy_frag);
  1474.   if (sym->written)
  1475.     fprintf (file, " written");
  1476.   if (sym->sy_resolved)
  1477.     fprintf (file, " resolved");
  1478.   else if (sym->sy_resolving)
  1479.     fprintf (file, " resolving");
  1480.   if (sym->sy_used_in_reloc)
  1481.     fprintf (file, " used-in-reloc");
  1482.   if (sym->sy_used)
  1483.     fprintf (file, " used");
  1484.   if (S_IS_LOCAL (sym))
  1485.     fprintf (file, " local");
  1486.   if (S_IS_EXTERN (sym))
  1487.     fprintf (file, " extern");
  1488.   if (S_IS_DEBUG (sym))
  1489.     fprintf (file, " debug");
  1490.   if (S_IS_DEFINED (sym))
  1491.     fprintf (file, " defined");
  1492.   fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
  1493.   if (sym->sy_resolved)
  1494.     {
  1495.       segT s = S_GET_SEGMENT (sym);
  1496.  
  1497.       if (s != undefined_section
  1498.           && s != expr_section)
  1499.     fprintf (file, " %lx", (long) S_GET_VALUE (sym));
  1500.     }
  1501.   else if (indent_level < 8 && S_GET_SEGMENT (sym) != undefined_section)
  1502.     {
  1503.       indent_level++;
  1504.       fprintf (file, "\n%*s<", indent_level * 4, "");
  1505.       print_expr_1 (file, &sym->sy_value);
  1506.       fprintf (file, ">");
  1507.       indent_level--;
  1508.     }
  1509.   fflush (file);
  1510. }
  1511.  
  1512. void
  1513. print_symbol_value (sym)
  1514.      symbolS *sym;
  1515. {
  1516.   indent_level = 0;
  1517.   print_symbol_value_1 (stderr, sym);
  1518.   fprintf (stderr, "\n");
  1519. }
  1520.  
  1521. void
  1522. print_expr_1 (file, exp)
  1523.      FILE *file;
  1524.      expressionS *exp;
  1525. {
  1526.   fprintf (file, "expr %lx ", (long) exp);
  1527.   switch (exp->X_op)
  1528.     {
  1529.     case O_illegal:
  1530.       fprintf (file, "illegal");
  1531.       break;
  1532.     case O_absent:
  1533.       fprintf (file, "absent");
  1534.       break;
  1535.     case O_constant:
  1536.       fprintf (file, "constant %lx", (long) exp->X_add_number);
  1537.       break;
  1538.     case O_symbol:
  1539.       indent_level++;
  1540.       fprintf (file, "symbol\n%*s<", indent_level * 4, "");
  1541.       print_symbol_value_1 (file, exp->X_add_symbol);
  1542.       fprintf (file, ">");
  1543.     maybe_print_addnum:
  1544.       if (exp->X_add_number)
  1545.     fprintf (file, "\n%*s%lx", indent_level * 4, "",
  1546.          (long) exp->X_add_number);
  1547.       indent_level--;
  1548.       break;
  1549.     case O_register:
  1550.       fprintf (file, "register #%d", (int) exp->X_add_number);
  1551.       break;
  1552.     case O_big:
  1553.       fprintf (file, "big");
  1554.       break;
  1555.     case O_uminus:
  1556.       fprintf (file, "uminus -<");
  1557.       indent_level++;
  1558.       print_symbol_value_1 (file, exp->X_add_symbol);
  1559.       fprintf (file, ">");
  1560.       goto maybe_print_addnum;
  1561.     case O_bit_not:
  1562.       fprintf (file, "bit_not");
  1563.       break;
  1564.     case O_multiply:
  1565.       fprintf (file, "multiply");
  1566.       break;
  1567.     case O_divide:
  1568.       fprintf (file, "divide");
  1569.       break;
  1570.     case O_modulus:
  1571.       fprintf (file, "modulus");
  1572.       break;
  1573.     case O_left_shift:
  1574.       fprintf (file, "lshift");
  1575.       break;
  1576.     case O_right_shift:
  1577.       fprintf (file, "rshift");
  1578.       break;
  1579.     case O_bit_inclusive_or:
  1580.       fprintf (file, "bit_ior");
  1581.       break;
  1582.     case O_bit_exclusive_or:
  1583.       fprintf (file, "bit_xor");
  1584.       break;
  1585.     case O_bit_and:
  1586.       fprintf (file, "bit_and");
  1587.       break;
  1588.     case O_eq:
  1589.       fprintf (file, "eq");
  1590.       break;
  1591.     case O_ne:
  1592.       fprintf (file, "ne");
  1593.       break;
  1594.     case O_lt:
  1595.       fprintf (file, "lt");
  1596.       break;
  1597.     case O_le:
  1598.       fprintf (file, "le");
  1599.       break;
  1600.     case O_ge:
  1601.       fprintf (file, "ge");
  1602.       break;
  1603.     case O_gt:
  1604.       fprintf (file, "gt");
  1605.       break;
  1606.     case O_logical_and:
  1607.       fprintf (file, "logical_and");
  1608.       break;
  1609.     case O_logical_or:
  1610.       fprintf (file, "logical_or");
  1611.       break;
  1612.     case O_add:
  1613.       indent_level++;
  1614.       fprintf (file, "add\n%*s<", indent_level * 4, "");
  1615.       print_symbol_value_1 (file, exp->X_add_symbol);
  1616.       fprintf (file, ">\n%*s<", indent_level * 4, "");
  1617.       print_symbol_value_1 (file, exp->X_op_symbol);
  1618.       fprintf (file, ">");
  1619.       goto maybe_print_addnum;
  1620.     case O_subtract:
  1621.       indent_level++;
  1622.       fprintf (file, "subtract\n%*s<", indent_level * 4, "");
  1623.       print_symbol_value_1 (file, exp->X_add_symbol);
  1624.       fprintf (file, ">\n%*s<", indent_level * 4, "");
  1625.       print_symbol_value_1 (file, exp->X_op_symbol);
  1626.       fprintf (file, ">");
  1627.       goto maybe_print_addnum;
  1628.     default:
  1629.       fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
  1630.       break;
  1631.     }
  1632.   fflush (stdout);
  1633. }
  1634.  
  1635. void
  1636. print_expr (exp)
  1637.      expressionS *exp;
  1638. {
  1639.   print_expr_1 (stderr, exp);
  1640.   fprintf (stderr, "\n");
  1641. }
  1642.  
  1643. void
  1644. symbol_print_statistics (file)
  1645.      FILE *file;
  1646. {
  1647.   hash_print_statistics (file, "symbol table", sy_hash);
  1648. }
  1649.  
  1650. /* end of symbols.c */
  1651.