1 /* symbols.c -symbol table-
2    Copyright (C) 1987-2016 Free Software Foundation, Inc.
3 
4    This file is part of GAS, the GNU Assembler.
5 
6    GAS is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3, or (at your option)
9    any later version.
10 
11    GAS is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15 
16    You should have received a copy of the GNU General Public License
17    along with GAS; see the file COPYING.  If not, write to the Free
18    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
19    02110-1301, USA.  */
20 
21 /* #define DEBUG_SYMS / * to debug symbol list maintenance.  */
22 
23 #include "as.h"
24 #include "safe-ctype.h"
25 #include "obstack.h"		/* For "symbols.h" */
26 #include "subsegs.h"
27 #include "struc-symbol.h"
28 
29 /* This is non-zero if symbols are case sensitive, which is the
30    default.  */
31 int symbols_case_sensitive = 1;
32 
33 #ifndef WORKING_DOT_WORD
34 extern int new_broken_words;
35 #endif
36 
37 /* symbol-name => struct symbol pointer */
38 static struct hash_control *sy_hash;
39 
40 /* Table of local symbols.  */
41 static struct hash_control *local_hash;
42 
43 /* Below are commented in "symbols.h".  */
44 symbolS *symbol_rootP;
45 symbolS *symbol_lastP;
46 symbolS abs_symbol;
47 symbolS dot_symbol;
48 
49 #ifdef DEBUG_SYMS
50 #define debug_verify_symchain verify_symbol_chain
51 #else
52 #define debug_verify_symchain(root, last) ((void) 0)
53 #endif
54 
55 #define DOLLAR_LABEL_CHAR	'\001'
56 #define LOCAL_LABEL_CHAR	'\002'
57 
58 #ifndef TC_LABEL_IS_LOCAL
59 #define TC_LABEL_IS_LOCAL(name)	0
60 #endif
61 
62 struct obstack notes;
63 #ifdef TE_PE
64 /* The name of an external symbol which is
65    used to make weak PE symbol names unique.  */
66 const char * an_external_name;
67 #endif
68 
69 static const char *save_symbol_name (const char *);
70 static void fb_label_init (void);
71 static long dollar_label_instance (long);
72 static long fb_label_instance (long);
73 
74 static void print_binary (FILE *, const char *, expressionS *);
75 
76 /* Return a pointer to a new symbol.  Die if we can't make a new
77    symbol.  Fill in the symbol's values.  Add symbol to end of symbol
78    chain.
79 
80    This function should be called in the general case of creating a
81    symbol.  However, if the output file symbol table has already been
82    set, and you are certain that this symbol won't be wanted in the
83    output file, you can call symbol_create.  */
84 
85 symbolS *
symbol_new(const char * name,segT segment,valueT valu,fragS * frag)86 symbol_new (const char *name, segT segment, valueT valu, fragS *frag)
87 {
88   symbolS *symbolP = symbol_create (name, segment, valu, frag);
89 
90   /* Link to end of symbol chain.  */
91   {
92     extern int symbol_table_frozen;
93     if (symbol_table_frozen)
94       abort ();
95   }
96   symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
97 
98   return symbolP;
99 }
100 
101 /* Save a symbol name on a permanent obstack, and convert it according
102    to the object file format.  */
103 
104 static const char *
save_symbol_name(const char * name)105 save_symbol_name (const char *name)
106 {
107   size_t name_length;
108   char *ret;
109 
110   name_length = strlen (name) + 1;	/* +1 for \0.  */
111   obstack_grow (&notes, name, name_length);
112   ret = (char *) obstack_finish (&notes);
113 
114 #ifdef tc_canonicalize_symbol_name
115   ret = tc_canonicalize_symbol_name (ret);
116 #endif
117 
118   if (! symbols_case_sensitive)
119     {
120       char *s;
121 
122       for (s = ret; *s != '\0'; s++)
123 	*s = TOUPPER (*s);
124     }
125 
126   return ret;
127 }
128 
129 symbolS *
symbol_create(const char * name,segT segment,valueT valu,fragS * frag)130 symbol_create (const char *name, /* It is copied, the caller can destroy/modify.  */
131 	       segT segment,	/* Segment identifier (SEG_<something>).  */
132 	       valueT valu,	/* Symbol value.  */
133 	       fragS *frag	/* Associated fragment.  */)
134 {
135   const char *preserved_copy_of_name;
136   symbolS *symbolP;
137 
138   preserved_copy_of_name = save_symbol_name (name);
139 
140   symbolP = (symbolS *) obstack_alloc (&notes, sizeof (symbolS));
141 
142   /* symbol must be born in some fixed state.  This seems as good as any.  */
143   memset (symbolP, 0, sizeof (symbolS));
144 
145   symbolP->bsym = bfd_make_empty_symbol (stdoutput);
146   if (symbolP->bsym == NULL)
147     as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
148   S_SET_NAME (symbolP, preserved_copy_of_name);
149 
150   S_SET_SEGMENT (symbolP, segment);
151   S_SET_VALUE (symbolP, valu);
152   symbol_clear_list_pointers (symbolP);
153 
154   symbolP->sy_frag = frag;
155 
156   obj_symbol_new_hook (symbolP);
157 
158 #ifdef tc_symbol_new_hook
159   tc_symbol_new_hook (symbolP);
160 #endif
161 
162   return symbolP;
163 }
164 
165 
166 /* Local symbol support.  If we can get away with it, we keep only a
167    small amount of information for local symbols.  */
168 
169 static symbolS *local_symbol_convert (struct local_symbol *);
170 
171 /* Used for statistics.  */
172 
173 static unsigned long local_symbol_count;
174 static unsigned long local_symbol_conversion_count;
175 
176 /* This macro is called with a symbol argument passed by reference.
177    It returns whether this is a local symbol.  If necessary, it
178    changes its argument to the real symbol.  */
179 
180 #define LOCAL_SYMBOL_CHECK(s)						\
181   (s->sy_flags.sy_local_symbol 						\
182    ? (local_symbol_converted_p ((struct local_symbol *) s)		\
183       ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s),	\
184 	 0)								\
185       : 1)								\
186    : 0)
187 
188 /* Create a local symbol and insert it into the local hash table.  */
189 
190 struct local_symbol *
local_symbol_make(const char * name,segT section,valueT val,fragS * frag)191 local_symbol_make (const char *name, segT section, valueT val, fragS *frag)
192 {
193   const char *name_copy;
194   struct local_symbol *ret;
195 
196   ++local_symbol_count;
197 
198   name_copy = save_symbol_name (name);
199 
200   ret = (struct local_symbol *) obstack_alloc (&notes, sizeof *ret);
201   ret->lsy_flags.sy_local_symbol = 1;
202   ret->lsy_flags.sy_resolved = 0;
203   ret->lsy_name = name_copy;
204   ret->lsy_section = section;
205   local_symbol_set_frag (ret, frag);
206   ret->lsy_value = val;
207 
208   hash_jam (local_hash, name_copy, (void *) ret);
209 
210   return ret;
211 }
212 
213 /* Convert a local symbol into a real symbol.  Note that we do not
214    reclaim the space used by the local symbol.  */
215 
216 static symbolS *
local_symbol_convert(struct local_symbol * locsym)217 local_symbol_convert (struct local_symbol *locsym)
218 {
219   symbolS *ret;
220 
221   gas_assert (locsym->lsy_flags.sy_local_symbol);
222   if (local_symbol_converted_p (locsym))
223     return local_symbol_get_real_symbol (locsym);
224 
225   ++local_symbol_conversion_count;
226 
227   ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value,
228 		    local_symbol_get_frag (locsym));
229 
230   if (local_symbol_resolved_p (locsym))
231     ret->sy_flags.sy_resolved = 1;
232 
233   /* Local symbols are always either defined or used.  */
234   ret->sy_flags.sy_used = 1;
235 
236 #ifdef TC_LOCAL_SYMFIELD_CONVERT
237   TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
238 #endif
239 
240   symbol_table_insert (ret);
241 
242   local_symbol_mark_converted (locsym);
243   local_symbol_set_real_symbol (locsym, ret);
244 
245   hash_jam (local_hash, locsym->lsy_name, NULL);
246 
247   return ret;
248 }
249 
250 static void
define_sym_at_dot(symbolS * symbolP)251 define_sym_at_dot (symbolS *symbolP)
252 {
253   symbolP->sy_frag = frag_now;
254   S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
255   S_SET_SEGMENT (symbolP, now_seg);
256 }
257 
258 /* We have just seen "<name>:".
259    Creates a struct symbol unless it already exists.
260 
261    Gripes if we are redefining a symbol incompatibly (and ignores it).  */
262 
263 symbolS *
colon(const char * sym_name)264 colon (/* Just seen "x:" - rattle symbols & frags.  */
265        const char *sym_name	/* Symbol name, as a cannonical string.  */
266        /* We copy this string: OK to alter later.  */)
267 {
268   symbolS *symbolP;	/* Symbol we are working with.  */
269 
270   /* Sun local labels go out of scope whenever a non-local symbol is
271      defined.  */
272   if (LOCAL_LABELS_DOLLAR
273       && !bfd_is_local_label_name (stdoutput, sym_name))
274     dollar_label_clear ();
275 
276 #ifndef WORKING_DOT_WORD
277   if (new_broken_words)
278     {
279       struct broken_word *a;
280       int possible_bytes;
281       fragS *frag_tmp;
282       char *frag_opcode;
283 
284       if (now_seg == absolute_section)
285 	{
286 	  as_bad (_("cannot define symbol `%s' in absolute section"), sym_name);
287 	  return NULL;
288 	}
289 
290       possible_bytes = (md_short_jump_size
291 			+ new_broken_words * md_long_jump_size);
292 
293       frag_tmp = frag_now;
294       frag_opcode = frag_var (rs_broken_word,
295 			      possible_bytes,
296 			      possible_bytes,
297 			      (relax_substateT) 0,
298 			      (symbolS *) broken_words,
299 			      (offsetT) 0,
300 			      NULL);
301 
302       /* We want to store the pointer to where to insert the jump
303 	 table in the fr_opcode of the rs_broken_word frag.  This
304 	 requires a little hackery.  */
305       while (frag_tmp
306 	     && (frag_tmp->fr_type != rs_broken_word
307 		 || frag_tmp->fr_opcode))
308 	frag_tmp = frag_tmp->fr_next;
309       know (frag_tmp);
310       frag_tmp->fr_opcode = frag_opcode;
311       new_broken_words = 0;
312 
313       for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
314 	a->dispfrag = frag_tmp;
315     }
316 #endif /* WORKING_DOT_WORD */
317 
318 #ifdef obj_frob_colon
319   obj_frob_colon (sym_name);
320 #endif
321 
322   if ((symbolP = symbol_find (sym_name)) != 0)
323     {
324       S_CLEAR_WEAKREFR (symbolP);
325 #ifdef RESOLVE_SYMBOL_REDEFINITION
326       if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
327 	return symbolP;
328 #endif
329       /* Now check for undefined symbols.  */
330       if (LOCAL_SYMBOL_CHECK (symbolP))
331 	{
332 	  struct local_symbol *locsym = (struct local_symbol *) symbolP;
333 
334 	  if (locsym->lsy_section != undefined_section
335 	      && (local_symbol_get_frag (locsym) != frag_now
336 		  || locsym->lsy_section != now_seg
337 		  || locsym->lsy_value != frag_now_fix ()))
338 	    {
339 	      as_bad (_("symbol `%s' is already defined"), sym_name);
340 	      return symbolP;
341 	    }
342 
343 	  locsym->lsy_section = now_seg;
344 	  local_symbol_set_frag (locsym, frag_now);
345 	  locsym->lsy_value = frag_now_fix ();
346 	}
347       else if (!(S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
348 	       || S_IS_COMMON (symbolP)
349 	       || S_IS_VOLATILE (symbolP))
350 	{
351 	  if (S_IS_VOLATILE (symbolP))
352 	    {
353 	      symbolP = symbol_clone (symbolP, 1);
354 	      S_SET_VALUE (symbolP, 0);
355 	      S_CLEAR_VOLATILE (symbolP);
356 	    }
357 	  if (S_GET_VALUE (symbolP) == 0)
358 	    {
359 	      define_sym_at_dot (symbolP);
360 #ifdef N_UNDF
361 	      know (N_UNDF == 0);
362 #endif /* if we have one, it better be zero.  */
363 
364 	    }
365 	  else
366 	    {
367 	      /* There are still several cases to check:
368 
369 		 A .comm/.lcomm symbol being redefined as initialized
370 		 data is OK
371 
372 		 A .comm/.lcomm symbol being redefined with a larger
373 		 size is also OK
374 
375 		 This only used to be allowed on VMS gas, but Sun cc
376 		 on the sparc also depends on it.  */
377 
378 	      if (((!S_IS_DEBUG (symbolP)
379 		    && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
380 		    && S_IS_EXTERNAL (symbolP))
381 		   || S_GET_SEGMENT (symbolP) == bss_section)
382 		  && (now_seg == data_section
383 		      || now_seg == bss_section
384 		      || now_seg == S_GET_SEGMENT (symbolP)))
385 		{
386 		  /* Select which of the 2 cases this is.  */
387 		  if (now_seg != data_section)
388 		    {
389 		      /* New .comm for prev .comm symbol.
390 
391 			 If the new size is larger we just change its
392 			 value.  If the new size is smaller, we ignore
393 			 this symbol.  */
394 		      if (S_GET_VALUE (symbolP)
395 			  < ((unsigned) frag_now_fix ()))
396 			{
397 			  S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
398 			}
399 		    }
400 		  else
401 		    {
402 		      /* It is a .comm/.lcomm being converted to initialized
403 			 data.  */
404 		      define_sym_at_dot (symbolP);
405 		    }
406 		}
407 	      else
408 		{
409 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
410      && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
411 		  static const char *od_buf = "";
412 #else
413 		  char od_buf[100];
414 		  od_buf[0] = '\0';
415 		  if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
416 		    sprintf (od_buf, "%d.%d.",
417 			     S_GET_OTHER (symbolP),
418 			     S_GET_DESC (symbolP));
419 #endif
420 		  as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
421 			    sym_name,
422 			    segment_name (S_GET_SEGMENT (symbolP)),
423 			    od_buf,
424 			    (long) S_GET_VALUE (symbolP));
425 		}
426 	    }			/* if the undefined symbol has no value  */
427 	}
428       else
429 	{
430 	  /* Don't blow up if the definition is the same.  */
431 	  if (!(frag_now == symbolP->sy_frag
432 		&& S_GET_VALUE (symbolP) == frag_now_fix ()
433 		&& S_GET_SEGMENT (symbolP) == now_seg))
434 	    {
435 	      as_bad (_("symbol `%s' is already defined"), sym_name);
436 	      symbolP = symbol_clone (symbolP, 0);
437 	      define_sym_at_dot (symbolP);
438 	    }
439 	}
440 
441     }
442   else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name))
443     {
444       symbolP = (symbolS *) local_symbol_make (sym_name, now_seg,
445 					       (valueT) frag_now_fix (),
446 					       frag_now);
447     }
448   else
449     {
450       symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
451 			    frag_now);
452 
453       symbol_table_insert (symbolP);
454     }
455 
456   if (mri_common_symbol != NULL)
457     {
458       /* This symbol is actually being defined within an MRI common
459 	 section.  This requires special handling.  */
460       if (LOCAL_SYMBOL_CHECK (symbolP))
461 	symbolP = local_symbol_convert ((struct local_symbol *) symbolP);
462       symbolP->sy_value.X_op = O_symbol;
463       symbolP->sy_value.X_add_symbol = mri_common_symbol;
464       symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
465       symbolP->sy_frag = &zero_address_frag;
466       S_SET_SEGMENT (symbolP, expr_section);
467       symbolP->sy_flags.sy_mri_common = 1;
468     }
469 
470 #ifdef tc_frob_label
471   tc_frob_label (symbolP);
472 #endif
473 #ifdef obj_frob_label
474   obj_frob_label (symbolP);
475 #endif
476 
477   return symbolP;
478 }
479 
480 /* Die if we can't insert the symbol.  */
481 
482 void
symbol_table_insert(symbolS * symbolP)483 symbol_table_insert (symbolS *symbolP)
484 {
485   const char *error_string;
486 
487   know (symbolP);
488   know (S_GET_NAME (symbolP));
489 
490   if (LOCAL_SYMBOL_CHECK (symbolP))
491     {
492       error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
493 			       (void *) symbolP);
494       if (error_string != NULL)
495 	as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
496 		  S_GET_NAME (symbolP), error_string);
497       return;
498     }
499 
500   if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (void *) symbolP)))
501     {
502       as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
503 		S_GET_NAME (symbolP), error_string);
504     }				/* on error  */
505 }
506 
507 /* If a symbol name does not exist, create it as undefined, and insert
508    it into the symbol table.  Return a pointer to it.  */
509 
510 symbolS *
symbol_find_or_make(const char * name)511 symbol_find_or_make (const char *name)
512 {
513   symbolS *symbolP;
514 
515   symbolP = symbol_find (name);
516 
517   if (symbolP == NULL)
518     {
519       if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name))
520 	{
521 	  symbolP = md_undefined_symbol ((char *) name);
522 	  if (symbolP != NULL)
523 	    return symbolP;
524 
525 	  symbolP = (symbolS *) local_symbol_make (name, undefined_section,
526 						   (valueT) 0,
527 						   &zero_address_frag);
528 	  return symbolP;
529 	}
530 
531       symbolP = symbol_make (name);
532 
533       symbol_table_insert (symbolP);
534     }				/* if symbol wasn't found */
535 
536   return (symbolP);
537 }
538 
539 symbolS *
symbol_make(const char * name)540 symbol_make (const char *name)
541 {
542   symbolS *symbolP;
543 
544   /* Let the machine description default it, e.g. for register names.  */
545   symbolP = md_undefined_symbol ((char *) name);
546 
547   if (!symbolP)
548     symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
549 
550   return (symbolP);
551 }
552 
553 symbolS *
symbol_clone(symbolS * orgsymP,int replace)554 symbol_clone (symbolS *orgsymP, int replace)
555 {
556   symbolS *newsymP;
557   asymbol *bsymorg, *bsymnew;
558 
559   /* Make sure we never clone the dot special symbol.  */
560   gas_assert (orgsymP != &dot_symbol);
561 
562   /* Running local_symbol_convert on a clone that's not the one currently
563      in local_hash would incorrectly replace the hash entry.  Thus the
564      symbol must be converted here.  Note that the rest of the function
565      depends on not encountering an unconverted symbol.  */
566   if (LOCAL_SYMBOL_CHECK (orgsymP))
567     orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);
568   bsymorg = orgsymP->bsym;
569 
570   newsymP = (symbolS *) obstack_alloc (&notes, sizeof (*newsymP));
571   *newsymP = *orgsymP;
572   bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg));
573   if (bsymnew == NULL)
574     as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
575   newsymP->bsym = bsymnew;
576   bsymnew->name = bsymorg->name;
577   bsymnew->flags = bsymorg->flags & ~BSF_SECTION_SYM;
578   bsymnew->section = bsymorg->section;
579   bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg), bsymorg,
580 				bfd_asymbol_bfd (bsymnew), bsymnew);
581 
582 #ifdef obj_symbol_clone_hook
583   obj_symbol_clone_hook (newsymP, orgsymP);
584 #endif
585 
586 #ifdef tc_symbol_clone_hook
587   tc_symbol_clone_hook (newsymP, orgsymP);
588 #endif
589 
590   if (replace)
591     {
592       if (symbol_rootP == orgsymP)
593 	symbol_rootP = newsymP;
594       else if (orgsymP->sy_previous)
595 	{
596 	  orgsymP->sy_previous->sy_next = newsymP;
597 	  orgsymP->sy_previous = NULL;
598 	}
599       if (symbol_lastP == orgsymP)
600 	symbol_lastP = newsymP;
601       else if (orgsymP->sy_next)
602 	orgsymP->sy_next->sy_previous = newsymP;
603 
604       /* Symbols that won't be output can't be external.  */
605       S_CLEAR_EXTERNAL (orgsymP);
606       orgsymP->sy_previous = orgsymP->sy_next = orgsymP;
607       debug_verify_symchain (symbol_rootP, symbol_lastP);
608 
609       symbol_table_insert (newsymP);
610     }
611   else
612     {
613       /* Symbols that won't be output can't be external.  */
614       S_CLEAR_EXTERNAL (newsymP);
615       newsymP->sy_previous = newsymP->sy_next = newsymP;
616     }
617 
618   return newsymP;
619 }
620 
621 /* Referenced symbols, if they are forward references, need to be cloned
622    (without replacing the original) so that the value of the referenced
623    symbols at the point of use .  */
624 
625 #undef symbol_clone_if_forward_ref
626 symbolS *
symbol_clone_if_forward_ref(symbolS * symbolP,int is_forward)627 symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
628 {
629   if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
630     {
631       symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
632       symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
633 
634       if (symbolP->sy_flags.sy_forward_ref)
635 	is_forward = 1;
636 
637       if (is_forward)
638 	{
639 	  /* assign_symbol() clones volatile symbols; pre-existing expressions
640 	     hold references to the original instance, but want the current
641 	     value.  Just repeat the lookup.  */
642 	  if (add_symbol && S_IS_VOLATILE (add_symbol))
643 	    add_symbol = symbol_find_exact (S_GET_NAME (add_symbol));
644 	  if (op_symbol && S_IS_VOLATILE (op_symbol))
645 	    op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));
646 	}
647 
648       /* Re-using sy_resolving here, as this routine cannot get called from
649 	 symbol resolution code.  */
650       if ((symbolP->bsym->section == expr_section
651            || symbolP->sy_flags.sy_forward_ref)
652 	  && !symbolP->sy_flags.sy_resolving)
653 	{
654 	  symbolP->sy_flags.sy_resolving = 1;
655 	  add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
656 	  op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);
657 	  symbolP->sy_flags.sy_resolving = 0;
658 	}
659 
660       if (symbolP->sy_flags.sy_forward_ref
661 	  || add_symbol != symbolP->sy_value.X_add_symbol
662 	  || op_symbol != symbolP->sy_value.X_op_symbol)
663 	{
664 	  if (symbolP != &dot_symbol)
665 	    {
666 	      symbolP = symbol_clone (symbolP, 0);
667 	      symbolP->sy_flags.sy_resolving = 0;
668 	    }
669 	  else
670 	    {
671 	      symbolP = symbol_temp_new_now ();
672 #ifdef tc_new_dot_label
673 	      tc_new_dot_label (symbolP);
674 #endif
675 	    }
676 	}
677 
678       symbolP->sy_value.X_add_symbol = add_symbol;
679       symbolP->sy_value.X_op_symbol = op_symbol;
680     }
681 
682   return symbolP;
683 }
684 
685 symbolS *
symbol_temp_new(segT seg,valueT ofs,fragS * frag)686 symbol_temp_new (segT seg, valueT ofs, fragS *frag)
687 {
688   return symbol_new (FAKE_LABEL_NAME, seg, ofs, frag);
689 }
690 
691 symbolS *
symbol_temp_new_now(void)692 symbol_temp_new_now (void)
693 {
694   return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
695 }
696 
697 symbolS *
symbol_temp_make(void)698 symbol_temp_make (void)
699 {
700   return symbol_make (FAKE_LABEL_NAME);
701 }
702 
703 /* Implement symbol table lookup.
704    In:	A symbol's name as a string: '\0' can't be part of a symbol name.
705    Out:	NULL if the name was not in the symbol table, else the address
706    of a struct symbol associated with that name.  */
707 
708 symbolS *
symbol_find_exact(const char * name)709 symbol_find_exact (const char *name)
710 {
711   return symbol_find_exact_noref (name, 0);
712 }
713 
714 symbolS *
symbol_find_exact_noref(const char * name,int noref)715 symbol_find_exact_noref (const char *name, int noref)
716 {
717   struct local_symbol *locsym;
718   symbolS* sym;
719 
720   locsym = (struct local_symbol *) hash_find (local_hash, name);
721   if (locsym != NULL)
722     return (symbolS *) locsym;
723 
724   sym = ((symbolS *) hash_find (sy_hash, name));
725 
726   /* Any references to the symbol, except for the reference in
727      .weakref, must clear this flag, such that the symbol does not
728      turn into a weak symbol.  Note that we don't have to handle the
729      local_symbol case, since a weakrefd is always promoted out of the
730      local_symbol table when it is turned into a weak symbol.  */
731   if (sym && ! noref)
732     S_CLEAR_WEAKREFD (sym);
733 
734   return sym;
735 }
736 
737 symbolS *
symbol_find(const char * name)738 symbol_find (const char *name)
739 {
740   return symbol_find_noref (name, 0);
741 }
742 
743 symbolS *
symbol_find_noref(const char * name,int noref)744 symbol_find_noref (const char *name, int noref)
745 {
746   symbolS * result;
747   char * copy = NULL;
748 
749 #ifdef tc_canonicalize_symbol_name
750   {
751     copy = xstrdup (name);
752     name = tc_canonicalize_symbol_name (copy);
753   }
754 #endif
755 
756   if (! symbols_case_sensitive)
757     {
758       const char *orig;
759       char *copy2 = NULL;
760       unsigned char c;
761 
762       orig = name;
763       if (copy != NULL)
764 	copy2 = copy;
765       name = copy = XNEWVEC (char, strlen (name) + 1);
766 
767       while ((c = *orig++) != '\0')
768 	*copy++ = TOUPPER (c);
769       *copy = '\0';
770 
771       if (copy2 != NULL)
772 	free (copy2);
773       copy = (char *) name;
774     }
775 
776   result = symbol_find_exact_noref (name, noref);
777   if (copy != NULL)
778     free (copy);
779   return result;
780 }
781 
782 /* Once upon a time, symbols were kept in a singly linked list.  At
783    least coff needs to be able to rearrange them from time to time, for
784    which a doubly linked list is much more convenient.  Loic did these
785    as macros which seemed dangerous to me so they're now functions.
786    xoxorich.  */
787 
788 /* Link symbol ADDME after symbol TARGET in the chain.  */
789 
790 void
symbol_append(symbolS * addme,symbolS * target,symbolS ** rootPP,symbolS ** lastPP)791 symbol_append (symbolS *addme, symbolS *target,
792 	       symbolS **rootPP, symbolS **lastPP)
793 {
794   if (LOCAL_SYMBOL_CHECK (addme))
795     abort ();
796   if (target != NULL && LOCAL_SYMBOL_CHECK (target))
797     abort ();
798 
799   if (target == NULL)
800     {
801       know (*rootPP == NULL);
802       know (*lastPP == NULL);
803       addme->sy_next = NULL;
804       addme->sy_previous = NULL;
805       *rootPP = addme;
806       *lastPP = addme;
807       return;
808     }				/* if the list is empty  */
809 
810   if (target->sy_next != NULL)
811     {
812       target->sy_next->sy_previous = addme;
813     }
814   else
815     {
816       know (*lastPP == target);
817       *lastPP = addme;
818     }				/* if we have a next  */
819 
820   addme->sy_next = target->sy_next;
821   target->sy_next = addme;
822   addme->sy_previous = target;
823 
824   debug_verify_symchain (symbol_rootP, symbol_lastP);
825 }
826 
827 /* Set the chain pointers of SYMBOL to null.  */
828 
829 void
symbol_clear_list_pointers(symbolS * symbolP)830 symbol_clear_list_pointers (symbolS *symbolP)
831 {
832   if (LOCAL_SYMBOL_CHECK (symbolP))
833     abort ();
834   symbolP->sy_next = NULL;
835   symbolP->sy_previous = NULL;
836 }
837 
838 /* Remove SYMBOLP from the list.  */
839 
840 void
symbol_remove(symbolS * symbolP,symbolS ** rootPP,symbolS ** lastPP)841 symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP)
842 {
843   if (LOCAL_SYMBOL_CHECK (symbolP))
844     abort ();
845 
846   if (symbolP == *rootPP)
847     {
848       *rootPP = symbolP->sy_next;
849     }				/* if it was the root  */
850 
851   if (symbolP == *lastPP)
852     {
853       *lastPP = symbolP->sy_previous;
854     }				/* if it was the tail  */
855 
856   if (symbolP->sy_next != NULL)
857     {
858       symbolP->sy_next->sy_previous = symbolP->sy_previous;
859     }				/* if not last  */
860 
861   if (symbolP->sy_previous != NULL)
862     {
863       symbolP->sy_previous->sy_next = symbolP->sy_next;
864     }				/* if not first  */
865 
866   debug_verify_symchain (*rootPP, *lastPP);
867 }
868 
869 /* Link symbol ADDME before symbol TARGET in the chain.  */
870 
871 void
symbol_insert(symbolS * addme,symbolS * target,symbolS ** rootPP,symbolS ** lastPP ATTRIBUTE_UNUSED)872 symbol_insert (symbolS *addme, symbolS *target,
873 	       symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED)
874 {
875   if (LOCAL_SYMBOL_CHECK (addme))
876     abort ();
877   if (LOCAL_SYMBOL_CHECK (target))
878     abort ();
879 
880   if (target->sy_previous != NULL)
881     {
882       target->sy_previous->sy_next = addme;
883     }
884   else
885     {
886       know (*rootPP == target);
887       *rootPP = addme;
888     }				/* if not first  */
889 
890   addme->sy_previous = target->sy_previous;
891   target->sy_previous = addme;
892   addme->sy_next = target;
893 
894   debug_verify_symchain (*rootPP, *lastPP);
895 }
896 
897 void
verify_symbol_chain(symbolS * rootP,symbolS * lastP)898 verify_symbol_chain (symbolS *rootP, symbolS *lastP)
899 {
900   symbolS *symbolP = rootP;
901 
902   if (symbolP == NULL)
903     return;
904 
905   for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
906     {
907       gas_assert (symbolP->bsym != NULL);
908       gas_assert (symbolP->sy_flags.sy_local_symbol == 0);
909       gas_assert (symbolP->sy_next->sy_previous == symbolP);
910     }
911 
912   gas_assert (lastP == symbolP);
913 }
914 
915 #ifdef OBJ_COMPLEX_RELC
916 
917 static int
use_complex_relocs_for(symbolS * symp)918 use_complex_relocs_for (symbolS * symp)
919 {
920   switch (symp->sy_value.X_op)
921     {
922     case O_constant:
923       return 0;
924 
925     case O_symbol:
926     case O_symbol_rva:
927     case O_uminus:
928     case O_bit_not:
929     case O_logical_not:
930       if (  (S_IS_COMMON (symp->sy_value.X_add_symbol)
931 	   || S_IS_LOCAL (symp->sy_value.X_add_symbol))
932 	  &&
933 	      (S_IS_DEFINED (symp->sy_value.X_add_symbol)
934 	   && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section))
935 	return 0;
936       break;
937 
938     case O_multiply:
939     case O_divide:
940     case O_modulus:
941     case O_left_shift:
942     case O_right_shift:
943     case O_bit_inclusive_or:
944     case O_bit_or_not:
945     case O_bit_exclusive_or:
946     case O_bit_and:
947     case O_add:
948     case O_subtract:
949     case O_eq:
950     case O_ne:
951     case O_lt:
952     case O_le:
953     case O_ge:
954     case O_gt:
955     case O_logical_and:
956     case O_logical_or:
957 
958       if (  (S_IS_COMMON (symp->sy_value.X_add_symbol)
959 	   || S_IS_LOCAL (symp->sy_value.X_add_symbol))
960 	  &&
961 	    (S_IS_COMMON (symp->sy_value.X_op_symbol)
962 	   || S_IS_LOCAL (symp->sy_value.X_op_symbol))
963 
964 	  && S_IS_DEFINED (symp->sy_value.X_add_symbol)
965 	  && S_IS_DEFINED (symp->sy_value.X_op_symbol)
966 	  && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section
967 	  && S_GET_SEGMENT (symp->sy_value.X_op_symbol) != expr_section)
968 	return 0;
969       break;
970 
971     default:
972       break;
973     }
974   return 1;
975 }
976 #endif
977 
978 static void
report_op_error(symbolS * symp,symbolS * left,operatorT op,symbolS * right)979 report_op_error (symbolS *symp, symbolS *left, operatorT op, symbolS *right)
980 {
981   const char *file;
982   unsigned int line;
983   segT seg_left = left ? S_GET_SEGMENT (left) : 0;
984   segT seg_right = S_GET_SEGMENT (right);
985   const char *opname;
986 
987   switch (op)
988     {
989     default:
990       abort ();
991       return;
992 
993     case O_uminus:		opname = "-"; break;
994     case O_bit_not:		opname = "~"; break;
995     case O_logical_not:		opname = "!"; break;
996     case O_multiply:		opname = "*"; break;
997     case O_divide:		opname = "/"; break;
998     case O_modulus:		opname = "%"; break;
999     case O_left_shift:		opname = "<<"; break;
1000     case O_right_shift:		opname = ">>"; break;
1001     case O_bit_inclusive_or:	opname = "|"; break;
1002     case O_bit_or_not:		opname = "|~"; break;
1003     case O_bit_exclusive_or:	opname = "^"; break;
1004     case O_bit_and:		opname = "&"; break;
1005     case O_add:			opname = "+"; break;
1006     case O_subtract:		opname = "-"; break;
1007     case O_eq:			opname = "=="; break;
1008     case O_ne:			opname = "!="; break;
1009     case O_lt:			opname = "<"; break;
1010     case O_le:			opname = "<="; break;
1011     case O_ge:			opname = ">="; break;
1012     case O_gt:			opname = ">"; break;
1013     case O_logical_and:		opname = "&&"; break;
1014     case O_logical_or:		opname = "||"; break;
1015     }
1016 
1017   if (expr_symbol_where (symp, &file, &line))
1018     {
1019       if (left)
1020 	as_bad_where (file, line,
1021 		      _("invalid operands (%s and %s sections) for `%s'"),
1022 		      seg_left->name, seg_right->name, opname);
1023       else
1024 	as_bad_where (file, line,
1025 		      _("invalid operand (%s section) for `%s'"),
1026 		      seg_right->name, opname);
1027     }
1028   else
1029     {
1030       const char *sname = S_GET_NAME (symp);
1031 
1032       if (left)
1033 	as_bad (_("invalid operands (%s and %s sections) for `%s' when setting `%s'"),
1034 		seg_left->name, seg_right->name, opname, sname);
1035       else
1036 	as_bad (_("invalid operand (%s section) for `%s' when setting `%s'"),
1037 		seg_right->name, opname, sname);
1038     }
1039 }
1040 
1041 /* Resolve the value of a symbol.  This is called during the final
1042    pass over the symbol table to resolve any symbols with complex
1043    values.  */
1044 
1045 valueT
resolve_symbol_value(symbolS * symp)1046 resolve_symbol_value (symbolS *symp)
1047 {
1048   int resolved;
1049   valueT final_val = 0;
1050   segT final_seg;
1051 
1052   if (LOCAL_SYMBOL_CHECK (symp))
1053     {
1054       struct local_symbol *locsym = (struct local_symbol *) symp;
1055 
1056       final_val = locsym->lsy_value;
1057       if (local_symbol_resolved_p (locsym))
1058 	return final_val;
1059 
1060       final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;
1061 
1062       if (finalize_syms)
1063 	{
1064 	  locsym->lsy_value = final_val;
1065 	  local_symbol_mark_resolved (locsym);
1066 	}
1067 
1068       return final_val;
1069     }
1070 
1071   if (symp->sy_flags.sy_resolved)
1072     {
1073       if (symp->sy_value.X_op == O_constant)
1074 	return (valueT) symp->sy_value.X_add_number;
1075       else
1076 	return 0;
1077     }
1078 
1079   resolved = 0;
1080   final_seg = S_GET_SEGMENT (symp);
1081 
1082   if (symp->sy_flags.sy_resolving)
1083     {
1084       if (finalize_syms)
1085 	as_bad (_("symbol definition loop encountered at `%s'"),
1086 		S_GET_NAME (symp));
1087       final_val = 0;
1088       resolved = 1;
1089     }
1090 #ifdef OBJ_COMPLEX_RELC
1091   else if (final_seg == expr_section
1092 	   && use_complex_relocs_for (symp))
1093     {
1094       symbolS * relc_symbol = NULL;
1095       char * relc_symbol_name = NULL;
1096 
1097       relc_symbol_name = symbol_relc_make_expr (& symp->sy_value);
1098 
1099       /* For debugging, print out conversion input & output.  */
1100 #ifdef DEBUG_SYMS
1101       print_expr (& symp->sy_value);
1102       if (relc_symbol_name)
1103 	fprintf (stderr, "-> relc symbol: %s\n", relc_symbol_name);
1104 #endif
1105 
1106       if (relc_symbol_name != NULL)
1107 	relc_symbol = symbol_new (relc_symbol_name, undefined_section,
1108 				  0, & zero_address_frag);
1109 
1110       if (relc_symbol == NULL)
1111 	{
1112 	  as_bad (_("cannot convert expression symbol %s to complex relocation"),
1113 		  S_GET_NAME (symp));
1114 	  resolved = 0;
1115 	}
1116       else
1117 	{
1118 	  symbol_table_insert (relc_symbol);
1119 
1120  	  /* S_CLEAR_EXTERNAL (relc_symbol); */
1121 	  if (symp->bsym->flags & BSF_SRELC)
1122 	    relc_symbol->bsym->flags |= BSF_SRELC;
1123 	  else
1124 	    relc_symbol->bsym->flags |= BSF_RELC;
1125 	  /* symp->bsym->flags |= BSF_RELC; */
1126 	  copy_symbol_attributes (symp, relc_symbol);
1127 	  symp->sy_value.X_op = O_symbol;
1128 	  symp->sy_value.X_add_symbol = relc_symbol;
1129 	  symp->sy_value.X_add_number = 0;
1130 	  resolved = 1;
1131 	}
1132 
1133       final_seg = undefined_section;
1134       goto exit_dont_set_value;
1135     }
1136 #endif
1137   else
1138     {
1139       symbolS *add_symbol, *op_symbol;
1140       offsetT left, right;
1141       segT seg_left, seg_right;
1142       operatorT op;
1143       int move_seg_ok;
1144 
1145       symp->sy_flags.sy_resolving = 1;
1146 
1147       /* Help out with CSE.  */
1148       add_symbol = symp->sy_value.X_add_symbol;
1149       op_symbol = symp->sy_value.X_op_symbol;
1150       final_val = symp->sy_value.X_add_number;
1151       op = symp->sy_value.X_op;
1152 
1153       switch (op)
1154 	{
1155 	default:
1156 	  BAD_CASE (op);
1157 	  break;
1158 
1159 	case O_absent:
1160 	  final_val = 0;
1161 	  /* Fall through.  */
1162 
1163 	case O_constant:
1164 	  final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
1165 	  if (final_seg == expr_section)
1166 	    final_seg = absolute_section;
1167 	  /* Fall through.  */
1168 
1169 	case O_register:
1170 	  resolved = 1;
1171 	  break;
1172 
1173 	case O_symbol:
1174 	case O_symbol_rva:
1175 	  left = resolve_symbol_value (add_symbol);
1176 	  seg_left = S_GET_SEGMENT (add_symbol);
1177 	  if (finalize_syms)
1178 	    symp->sy_value.X_op_symbol = NULL;
1179 
1180 	do_symbol:
1181 	  if (S_IS_WEAKREFR (symp))
1182 	    {
1183 	      gas_assert (final_val == 0);
1184 	      if (S_IS_WEAKREFR (add_symbol))
1185 		{
1186 		  gas_assert (add_symbol->sy_value.X_op == O_symbol
1187 			  && add_symbol->sy_value.X_add_number == 0);
1188 		  add_symbol = add_symbol->sy_value.X_add_symbol;
1189 		  gas_assert (! S_IS_WEAKREFR (add_symbol));
1190 		  symp->sy_value.X_add_symbol = add_symbol;
1191 		}
1192 	    }
1193 
1194 	  if (symp->sy_flags.sy_mri_common)
1195 	    {
1196 	      /* This is a symbol inside an MRI common section.  The
1197 		 relocation routines are going to handle it specially.
1198 		 Don't change the value.  */
1199 	      resolved = symbol_resolved_p (add_symbol);
1200 	      break;
1201 	    }
1202 
1203 	  if (finalize_syms && final_val == 0)
1204 	    {
1205 	      if (LOCAL_SYMBOL_CHECK (add_symbol))
1206 		add_symbol = local_symbol_convert ((struct local_symbol *)
1207 						   add_symbol);
1208 	      copy_symbol_attributes (symp, add_symbol);
1209 	    }
1210 
1211 	  /* If we have equated this symbol to an undefined or common
1212 	     symbol, keep X_op set to O_symbol, and don't change
1213 	     X_add_number.  This permits the routine which writes out
1214 	     relocation to detect this case, and convert the
1215 	     relocation to be against the symbol to which this symbol
1216 	     is equated.  */
1217 	  if (! S_IS_DEFINED (add_symbol)
1218 #if defined (OBJ_COFF) && defined (TE_PE)
1219 	      || S_IS_WEAK (add_symbol)
1220 #endif
1221 	      || S_IS_COMMON (add_symbol))
1222 	    {
1223 	      if (finalize_syms)
1224 		{
1225 		  symp->sy_value.X_op = O_symbol;
1226 		  symp->sy_value.X_add_symbol = add_symbol;
1227 		  symp->sy_value.X_add_number = final_val;
1228 		  /* Use X_op_symbol as a flag.  */
1229 		  symp->sy_value.X_op_symbol = add_symbol;
1230 		}
1231 	      final_seg = seg_left;
1232 	      final_val = 0;
1233 	      resolved = symbol_resolved_p (add_symbol);
1234 	      symp->sy_flags.sy_resolving = 0;
1235 	      goto exit_dont_set_value;
1236 	    }
1237 	  else if (finalize_syms
1238 		   && ((final_seg == expr_section && seg_left != expr_section)
1239 		       || symbol_shadow_p (symp)))
1240 	    {
1241 	      /* If the symbol is an expression symbol, do similarly
1242 		 as for undefined and common syms above.  Handles
1243 		 "sym +/- expr" where "expr" cannot be evaluated
1244 		 immediately, and we want relocations to be against
1245 		 "sym", eg. because it is weak.  */
1246 	      symp->sy_value.X_op = O_symbol;
1247 	      symp->sy_value.X_add_symbol = add_symbol;
1248 	      symp->sy_value.X_add_number = final_val;
1249 	      symp->sy_value.X_op_symbol = add_symbol;
1250 	      final_seg = seg_left;
1251 	      final_val += symp->sy_frag->fr_address + left;
1252 	      resolved = symbol_resolved_p (add_symbol);
1253 	      symp->sy_flags.sy_resolving = 0;
1254 	      goto exit_dont_set_value;
1255 	    }
1256 	  else
1257 	    {
1258 	      final_val += symp->sy_frag->fr_address + left;
1259 	      if (final_seg == expr_section || final_seg == undefined_section)
1260 		final_seg = seg_left;
1261 	    }
1262 
1263 	  resolved = symbol_resolved_p (add_symbol);
1264 	  if (S_IS_WEAKREFR (symp))
1265 	    {
1266 	      symp->sy_flags.sy_resolving = 0;
1267 	      goto exit_dont_set_value;
1268 	    }
1269 	  break;
1270 
1271 	case O_uminus:
1272 	case O_bit_not:
1273 	case O_logical_not:
1274 	  left = resolve_symbol_value (add_symbol);
1275 	  seg_left = S_GET_SEGMENT (add_symbol);
1276 
1277 	  /* By reducing these to the relevant dyadic operator, we get
1278 	     	!S -> S == 0 	permitted on anything,
1279 		-S -> 0 - S 	only permitted on absolute
1280 		~S -> S ^ ~0 	only permitted on absolute  */
1281 	  if (op != O_logical_not && seg_left != absolute_section
1282 	      && finalize_syms)
1283 	    report_op_error (symp, NULL, op, add_symbol);
1284 
1285 	  if (final_seg == expr_section || final_seg == undefined_section)
1286 	    final_seg = absolute_section;
1287 
1288 	  if (op == O_uminus)
1289 	    left = -left;
1290 	  else if (op == O_logical_not)
1291 	    left = !left;
1292 	  else
1293 	    left = ~left;
1294 
1295 	  final_val += left + symp->sy_frag->fr_address;
1296 
1297 	  resolved = symbol_resolved_p (add_symbol);
1298 	  break;
1299 
1300 	case O_multiply:
1301 	case O_divide:
1302 	case O_modulus:
1303 	case O_left_shift:
1304 	case O_right_shift:
1305 	case O_bit_inclusive_or:
1306 	case O_bit_or_not:
1307 	case O_bit_exclusive_or:
1308 	case O_bit_and:
1309 	case O_add:
1310 	case O_subtract:
1311 	case O_eq:
1312 	case O_ne:
1313 	case O_lt:
1314 	case O_le:
1315 	case O_ge:
1316 	case O_gt:
1317 	case O_logical_and:
1318 	case O_logical_or:
1319 	  left = resolve_symbol_value (add_symbol);
1320 	  right = resolve_symbol_value (op_symbol);
1321 	  seg_left = S_GET_SEGMENT (add_symbol);
1322 	  seg_right = S_GET_SEGMENT (op_symbol);
1323 
1324 	  /* Simplify addition or subtraction of a constant by folding the
1325 	     constant into X_add_number.  */
1326 	  if (op == O_add)
1327 	    {
1328 	      if (seg_right == absolute_section)
1329 		{
1330 		  final_val += right;
1331 		  goto do_symbol;
1332 		}
1333 	      else if (seg_left == absolute_section)
1334 		{
1335 		  final_val += left;
1336 		  add_symbol = op_symbol;
1337 		  left = right;
1338 		  seg_left = seg_right;
1339 		  goto do_symbol;
1340 		}
1341 	    }
1342 	  else if (op == O_subtract)
1343 	    {
1344 	      if (seg_right == absolute_section)
1345 		{
1346 		  final_val -= right;
1347 		  goto do_symbol;
1348 		}
1349 	    }
1350 
1351 	  move_seg_ok = 1;
1352 	  /* Equality and non-equality tests are permitted on anything.
1353 	     Subtraction, and other comparison operators are permitted if
1354 	     both operands are in the same section.  Otherwise, both
1355 	     operands must be absolute.  We already handled the case of
1356 	     addition or subtraction of a constant above.  This will
1357 	     probably need to be changed for an object file format which
1358 	     supports arbitrary expressions, such as IEEE-695.  */
1359 	  if (!(seg_left == absolute_section
1360 		&& seg_right == absolute_section)
1361 	      && !(op == O_eq || op == O_ne)
1362 	      && !((op == O_subtract
1363 		    || op == O_lt || op == O_le || op == O_ge || op == O_gt)
1364 		   && seg_left == seg_right
1365 		   && (seg_left != undefined_section
1366 		       || add_symbol == op_symbol)))
1367 	    {
1368 	      /* Don't emit messages unless we're finalizing the symbol value,
1369 		 otherwise we may get the same message multiple times.  */
1370 	      if (finalize_syms)
1371 		report_op_error (symp, add_symbol, op, op_symbol);
1372 	      /* However do not move the symbol into the absolute section
1373 		 if it cannot currently be resolved - this would confuse
1374 		 other parts of the assembler into believing that the
1375 		 expression had been evaluated to zero.  */
1376 	      else
1377 		move_seg_ok = 0;
1378 	    }
1379 
1380 	  if (move_seg_ok
1381 	      && (final_seg == expr_section || final_seg == undefined_section))
1382 	    final_seg = absolute_section;
1383 
1384 	  /* Check for division by zero.  */
1385 	  if ((op == O_divide || op == O_modulus) && right == 0)
1386 	    {
1387 	      /* If seg_right is not absolute_section, then we've
1388 		 already issued a warning about using a bad symbol.  */
1389 	      if (seg_right == absolute_section && finalize_syms)
1390 		{
1391 		  const char *file;
1392 		  unsigned int line;
1393 
1394 		  if (expr_symbol_where (symp, &file, &line))
1395 		    as_bad_where (file, line, _("division by zero"));
1396 		  else
1397 		    as_bad (_("division by zero when setting `%s'"),
1398 			    S_GET_NAME (symp));
1399 		}
1400 
1401 	      right = 1;
1402 	    }
1403 
1404 	  switch (symp->sy_value.X_op)
1405 	    {
1406 	    case O_multiply:		left *= right; break;
1407 	    case O_divide:		left /= right; break;
1408 	    case O_modulus:		left %= right; break;
1409 	    case O_left_shift:		left <<= right; break;
1410 	    case O_right_shift:		left >>= right; break;
1411 	    case O_bit_inclusive_or:	left |= right; break;
1412 	    case O_bit_or_not:		left |= ~right; break;
1413 	    case O_bit_exclusive_or:	left ^= right; break;
1414 	    case O_bit_and:		left &= right; break;
1415 	    case O_add:			left += right; break;
1416 	    case O_subtract:		left -= right; break;
1417 	    case O_eq:
1418 	    case O_ne:
1419 	      left = (left == right && seg_left == seg_right
1420 		      && (seg_left != undefined_section
1421 			  || add_symbol == op_symbol)
1422 		      ? ~ (offsetT) 0 : 0);
1423 	      if (symp->sy_value.X_op == O_ne)
1424 		left = ~left;
1425 	      break;
1426 	    case O_lt:	left = left <  right ? ~ (offsetT) 0 : 0; break;
1427 	    case O_le:	left = left <= right ? ~ (offsetT) 0 : 0; break;
1428 	    case O_ge:	left = left >= right ? ~ (offsetT) 0 : 0; break;
1429 	    case O_gt:	left = left >  right ? ~ (offsetT) 0 : 0; break;
1430 	    case O_logical_and:	left = left && right; break;
1431 	    case O_logical_or:	left = left || right; break;
1432 	    default:		abort ();
1433 	    }
1434 
1435 	  final_val += symp->sy_frag->fr_address + left;
1436 	  if (final_seg == expr_section || final_seg == undefined_section)
1437 	    {
1438 	      if (seg_left == undefined_section
1439 		  || seg_right == undefined_section)
1440 		final_seg = undefined_section;
1441 	      else if (seg_left == absolute_section)
1442 		final_seg = seg_right;
1443 	      else
1444 		final_seg = seg_left;
1445 	    }
1446 	  resolved = (symbol_resolved_p (add_symbol)
1447 		      && symbol_resolved_p (op_symbol));
1448 	  break;
1449 
1450 	case O_big:
1451 	case O_illegal:
1452 	  /* Give an error (below) if not in expr_section.  We don't
1453 	     want to worry about expr_section symbols, because they
1454 	     are fictional (they are created as part of expression
1455 	     resolution), and any problems may not actually mean
1456 	     anything.  */
1457 	  break;
1458 	}
1459 
1460       symp->sy_flags.sy_resolving = 0;
1461     }
1462 
1463   if (finalize_syms)
1464     S_SET_VALUE (symp, final_val);
1465 
1466 exit_dont_set_value:
1467   /* Always set the segment, even if not finalizing the value.
1468      The segment is used to determine whether a symbol is defined.  */
1469     S_SET_SEGMENT (symp, final_seg);
1470 
1471   /* Don't worry if we can't resolve an expr_section symbol.  */
1472   if (finalize_syms)
1473     {
1474       if (resolved)
1475 	symp->sy_flags.sy_resolved = 1;
1476       else if (S_GET_SEGMENT (symp) != expr_section)
1477 	{
1478 	  as_bad (_("can't resolve value for symbol `%s'"),
1479 		  S_GET_NAME (symp));
1480 	  symp->sy_flags.sy_resolved = 1;
1481 	}
1482     }
1483 
1484   return final_val;
1485 }
1486 
1487 static void resolve_local_symbol (const char *, void *);
1488 
1489 /* A static function passed to hash_traverse.  */
1490 
1491 static void
resolve_local_symbol(const char * key ATTRIBUTE_UNUSED,void * value)1492 resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, void *value)
1493 {
1494   if (value != NULL)
1495     resolve_symbol_value ((symbolS *) value);
1496 }
1497 
1498 /* Resolve all local symbols.  */
1499 
1500 void
resolve_local_symbol_values(void)1501 resolve_local_symbol_values (void)
1502 {
1503   hash_traverse (local_hash, resolve_local_symbol);
1504 }
1505 
1506 /* Obtain the current value of a symbol without changing any
1507    sub-expressions used.  */
1508 
1509 int
snapshot_symbol(symbolS ** symbolPP,valueT * valueP,segT * segP,fragS ** fragPP)1510 snapshot_symbol (symbolS **symbolPP, valueT *valueP, segT *segP, fragS **fragPP)
1511 {
1512   symbolS *symbolP = *symbolPP;
1513 
1514   if (LOCAL_SYMBOL_CHECK (symbolP))
1515     {
1516       struct local_symbol *locsym = (struct local_symbol *) symbolP;
1517 
1518       *valueP = locsym->lsy_value;
1519       *segP = locsym->lsy_section;
1520       *fragPP = local_symbol_get_frag (locsym);
1521     }
1522   else
1523     {
1524       expressionS exp = symbolP->sy_value;
1525 
1526       if (!symbolP->sy_flags.sy_resolved && exp.X_op != O_illegal)
1527 	{
1528 	  int resolved;
1529 
1530 	  if (symbolP->sy_flags.sy_resolving)
1531 	    return 0;
1532 	  symbolP->sy_flags.sy_resolving = 1;
1533 	  resolved = resolve_expression (&exp);
1534 	  symbolP->sy_flags.sy_resolving = 0;
1535 	  if (!resolved)
1536 	    return 0;
1537 
1538 	  switch (exp.X_op)
1539 	    {
1540 	    case O_constant:
1541 	    case O_register:
1542 	      if (!symbol_equated_p (symbolP))
1543 		break;
1544 	      /* Fall thru.  */
1545 	    case O_symbol:
1546 	    case O_symbol_rva:
1547 	      symbolP = exp.X_add_symbol;
1548 	      break;
1549 	    default:
1550 	      return 0;
1551 	    }
1552 	}
1553 
1554       *symbolPP = symbolP;
1555       *valueP = exp.X_add_number;
1556       *segP = symbolP->bsym->section;
1557       *fragPP = symbolP->sy_frag;
1558 
1559       if (*segP == expr_section)
1560 	switch (exp.X_op)
1561 	  {
1562 	  case O_constant: *segP = absolute_section; break;
1563 	  case O_register: *segP = reg_section; break;
1564 	  default: break;
1565 	  }
1566     }
1567 
1568   return 1;
1569 }
1570 
1571 /* Dollar labels look like a number followed by a dollar sign.  Eg, "42$".
1572    They are *really* local.  That is, they go out of scope whenever we see a
1573    label that isn't local.  Also, like fb labels, there can be multiple
1574    instances of a dollar label.  Therefor, we name encode each instance with
1575    the instance number, keep a list of defined symbols separate from the real
1576    symbol table, and we treat these buggers as a sparse array.  */
1577 
1578 static long *dollar_labels;
1579 static long *dollar_label_instances;
1580 static char *dollar_label_defines;
1581 static unsigned long dollar_label_count;
1582 static unsigned long dollar_label_max;
1583 
1584 int
dollar_label_defined(long label)1585 dollar_label_defined (long label)
1586 {
1587   long *i;
1588 
1589   know ((dollar_labels != NULL) || (dollar_label_count == 0));
1590 
1591   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1592     if (*i == label)
1593       return dollar_label_defines[i - dollar_labels];
1594 
1595   /* If we get here, label isn't defined.  */
1596   return 0;
1597 }
1598 
1599 static long
dollar_label_instance(long label)1600 dollar_label_instance (long label)
1601 {
1602   long *i;
1603 
1604   know ((dollar_labels != NULL) || (dollar_label_count == 0));
1605 
1606   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1607     if (*i == label)
1608       return (dollar_label_instances[i - dollar_labels]);
1609 
1610   /* If we get here, we haven't seen the label before.
1611      Therefore its instance count is zero.  */
1612   return 0;
1613 }
1614 
1615 void
dollar_label_clear(void)1616 dollar_label_clear (void)
1617 {
1618   memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
1619 }
1620 
1621 #define DOLLAR_LABEL_BUMP_BY 10
1622 
1623 void
define_dollar_label(long label)1624 define_dollar_label (long label)
1625 {
1626   long *i;
1627 
1628   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1629     if (*i == label)
1630       {
1631 	++dollar_label_instances[i - dollar_labels];
1632 	dollar_label_defines[i - dollar_labels] = 1;
1633 	return;
1634       }
1635 
1636   /* If we get to here, we don't have label listed yet.  */
1637 
1638   if (dollar_labels == NULL)
1639     {
1640       dollar_labels = XNEWVEC (long, DOLLAR_LABEL_BUMP_BY);
1641       dollar_label_instances = XNEWVEC (long, DOLLAR_LABEL_BUMP_BY);
1642       dollar_label_defines = XNEWVEC (char, DOLLAR_LABEL_BUMP_BY);
1643       dollar_label_max = DOLLAR_LABEL_BUMP_BY;
1644       dollar_label_count = 0;
1645     }
1646   else if (dollar_label_count == dollar_label_max)
1647     {
1648       dollar_label_max += DOLLAR_LABEL_BUMP_BY;
1649       dollar_labels = XRESIZEVEC (long, dollar_labels, dollar_label_max);
1650       dollar_label_instances = XRESIZEVEC (long, dollar_label_instances,
1651 					  dollar_label_max);
1652       dollar_label_defines = XRESIZEVEC (char, dollar_label_defines,
1653 					 dollar_label_max);
1654     }				/* if we needed to grow  */
1655 
1656   dollar_labels[dollar_label_count] = label;
1657   dollar_label_instances[dollar_label_count] = 1;
1658   dollar_label_defines[dollar_label_count] = 1;
1659   ++dollar_label_count;
1660 }
1661 
1662 /* Caller must copy returned name: we re-use the area for the next name.
1663 
1664    The mth occurence of label n: is turned into the symbol "Ln^Am"
1665    where n is the label number and m is the instance number. "L" makes
1666    it a label discarded unless debugging and "^A"('\1') ensures no
1667    ordinary symbol SHOULD get the same name as a local label
1668    symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1669 
1670    fb labels get the same treatment, except that ^B is used in place
1671    of ^A.  */
1672 
1673 char *				/* Return local label name.  */
dollar_label_name(long n,int augend)1674 dollar_label_name (long n,	/* we just saw "n$:" : n a number.  */
1675 		   int augend	/* 0 for current instance, 1 for new instance.  */)
1676 {
1677   long i;
1678   /* Returned to caller, then copied.  Used for created names ("4f").  */
1679   static char symbol_name_build[24];
1680   char *p;
1681   char *q;
1682   char symbol_name_temporary[20];	/* Build up a number, BACKWARDS.  */
1683 
1684   know (n >= 0);
1685   know (augend == 0 || augend == 1);
1686   p = symbol_name_build;
1687 #ifdef LOCAL_LABEL_PREFIX
1688   *p++ = LOCAL_LABEL_PREFIX;
1689 #endif
1690   *p++ = 'L';
1691 
1692   /* Next code just does sprintf( {}, "%d", n);  */
1693   /* Label number.  */
1694   q = symbol_name_temporary;
1695   for (*q++ = 0, i = n; i; ++q)
1696     {
1697       *q = i % 10 + '0';
1698       i /= 10;
1699     }
1700   while ((*p = *--q) != '\0')
1701     ++p;
1702 
1703   *p++ = DOLLAR_LABEL_CHAR;		/* ^A  */
1704 
1705   /* Instance number.  */
1706   q = symbol_name_temporary;
1707   for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
1708     {
1709       *q = i % 10 + '0';
1710       i /= 10;
1711     }
1712   while ((*p++ = *--q) != '\0');
1713 
1714   /* The label, as a '\0' ended string, starts at symbol_name_build.  */
1715   return symbol_name_build;
1716 }
1717 
1718 /* Somebody else's idea of local labels. They are made by "n:" where n
1719    is any decimal digit. Refer to them with
1720     "nb" for previous (backward) n:
1721    or "nf" for next (forward) n:.
1722 
1723    We do a little better and let n be any number, not just a single digit, but
1724    since the other guy's assembler only does ten, we treat the first ten
1725    specially.
1726 
1727    Like someone else's assembler, we have one set of local label counters for
1728    entire assembly, not one set per (sub)segment like in most assemblers. This
1729    implies that one can refer to a label in another segment, and indeed some
1730    crufty compilers have done just that.
1731 
1732    Since there could be a LOT of these things, treat them as a sparse
1733    array.  */
1734 
1735 #define FB_LABEL_SPECIAL (10)
1736 
1737 static long fb_low_counter[FB_LABEL_SPECIAL];
1738 static long *fb_labels;
1739 static long *fb_label_instances;
1740 static long fb_label_count;
1741 static long fb_label_max;
1742 
1743 /* This must be more than FB_LABEL_SPECIAL.  */
1744 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1745 
1746 static void
fb_label_init(void)1747 fb_label_init (void)
1748 {
1749   memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
1750 }
1751 
1752 /* Add one to the instance number of this fb label.  */
1753 
1754 void
fb_label_instance_inc(long label)1755 fb_label_instance_inc (long label)
1756 {
1757   long *i;
1758 
1759   if ((unsigned long) label < FB_LABEL_SPECIAL)
1760     {
1761       ++fb_low_counter[label];
1762       return;
1763     }
1764 
1765   if (fb_labels != NULL)
1766     {
1767       for (i = fb_labels + FB_LABEL_SPECIAL;
1768 	   i < fb_labels + fb_label_count; ++i)
1769 	{
1770 	  if (*i == label)
1771 	    {
1772 	      ++fb_label_instances[i - fb_labels];
1773 	      return;
1774 	    }			/* if we find it  */
1775 	}			/* for each existing label  */
1776     }
1777 
1778   /* If we get to here, we don't have label listed yet.  */
1779 
1780   if (fb_labels == NULL)
1781     {
1782       fb_labels = XNEWVEC (long, FB_LABEL_BUMP_BY);
1783       fb_label_instances = XNEWVEC (long, FB_LABEL_BUMP_BY);
1784       fb_label_max = FB_LABEL_BUMP_BY;
1785       fb_label_count = FB_LABEL_SPECIAL;
1786 
1787     }
1788   else if (fb_label_count == fb_label_max)
1789     {
1790       fb_label_max += FB_LABEL_BUMP_BY;
1791       fb_labels = XRESIZEVEC (long, fb_labels, fb_label_max);
1792       fb_label_instances = XRESIZEVEC (long, fb_label_instances, fb_label_max);
1793     }				/* if we needed to grow  */
1794 
1795   fb_labels[fb_label_count] = label;
1796   fb_label_instances[fb_label_count] = 1;
1797   ++fb_label_count;
1798 }
1799 
1800 static long
fb_label_instance(long label)1801 fb_label_instance (long label)
1802 {
1803   long *i;
1804 
1805   if ((unsigned long) label < FB_LABEL_SPECIAL)
1806     {
1807       return (fb_low_counter[label]);
1808     }
1809 
1810   if (fb_labels != NULL)
1811     {
1812       for (i = fb_labels + FB_LABEL_SPECIAL;
1813 	   i < fb_labels + fb_label_count; ++i)
1814 	{
1815 	  if (*i == label)
1816 	    {
1817 	      return (fb_label_instances[i - fb_labels]);
1818 	    }			/* if we find it  */
1819 	}			/* for each existing label  */
1820     }
1821 
1822   /* We didn't find the label, so this must be a reference to the
1823      first instance.  */
1824   return 0;
1825 }
1826 
1827 /* Caller must copy returned name: we re-use the area for the next name.
1828 
1829    The mth occurence of label n: is turned into the symbol "Ln^Bm"
1830    where n is the label number and m is the instance number. "L" makes
1831    it a label discarded unless debugging and "^B"('\2') ensures no
1832    ordinary symbol SHOULD get the same name as a local label
1833    symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1834 
1835    dollar labels get the same treatment, except that ^A is used in
1836    place of ^B.  */
1837 
1838 char *				/* Return local label name.  */
fb_label_name(long n,long augend)1839 fb_label_name (long n,	/* We just saw "n:", "nf" or "nb" : n a number.  */
1840 	       long augend	/* 0 for nb, 1 for n:, nf.  */)
1841 {
1842   long i;
1843   /* Returned to caller, then copied.  Used for created names ("4f").  */
1844   static char symbol_name_build[24];
1845   char *p;
1846   char *q;
1847   char symbol_name_temporary[20];	/* Build up a number, BACKWARDS.  */
1848 
1849   know (n >= 0);
1850 #ifdef TC_MMIX
1851   know ((unsigned long) augend <= 2 /* See mmix_fb_label.  */);
1852 #else
1853   know ((unsigned long) augend <= 1);
1854 #endif
1855   p = symbol_name_build;
1856 #ifdef LOCAL_LABEL_PREFIX
1857   *p++ = LOCAL_LABEL_PREFIX;
1858 #endif
1859   *p++ = 'L';
1860 
1861   /* Next code just does sprintf( {}, "%d", n);  */
1862   /* Label number.  */
1863   q = symbol_name_temporary;
1864   for (*q++ = 0, i = n; i; ++q)
1865     {
1866       *q = i % 10 + '0';
1867       i /= 10;
1868     }
1869   while ((*p = *--q) != '\0')
1870     ++p;
1871 
1872   *p++ = LOCAL_LABEL_CHAR;		/* ^B  */
1873 
1874   /* Instance number.  */
1875   q = symbol_name_temporary;
1876   for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
1877     {
1878       *q = i % 10 + '0';
1879       i /= 10;
1880     }
1881   while ((*p++ = *--q) != '\0');
1882 
1883   /* The label, as a '\0' ended string, starts at symbol_name_build.  */
1884   return (symbol_name_build);
1885 }
1886 
1887 /* Decode name that may have been generated by foo_label_name() above.
1888    If the name wasn't generated by foo_label_name(), then return it
1889    unaltered.  This is used for error messages.  */
1890 
1891 char *
decode_local_label_name(char * s)1892 decode_local_label_name (char *s)
1893 {
1894   char *p;
1895   char *symbol_decode;
1896   int label_number;
1897   int instance_number;
1898   const char *type;
1899   const char *message_format;
1900   int lindex = 0;
1901 
1902 #ifdef LOCAL_LABEL_PREFIX
1903   if (s[lindex] == LOCAL_LABEL_PREFIX)
1904     ++lindex;
1905 #endif
1906 
1907   if (s[lindex] != 'L')
1908     return s;
1909 
1910   for (label_number = 0, p = s + lindex + 1; ISDIGIT (*p); ++p)
1911     label_number = (10 * label_number) + *p - '0';
1912 
1913   if (*p == DOLLAR_LABEL_CHAR)
1914     type = "dollar";
1915   else if (*p == LOCAL_LABEL_CHAR)
1916     type = "fb";
1917   else
1918     return s;
1919 
1920   for (instance_number = 0, p++; ISDIGIT (*p); ++p)
1921     instance_number = (10 * instance_number) + *p - '0';
1922 
1923   message_format = _("\"%d\" (instance number %d of a %s label)");
1924   symbol_decode = (char *) obstack_alloc (&notes, strlen (message_format) + 30);
1925   sprintf (symbol_decode, message_format, label_number, instance_number, type);
1926 
1927   return symbol_decode;
1928 }
1929 
1930 /* Get the value of a symbol.  */
1931 
1932 valueT
S_GET_VALUE(symbolS * s)1933 S_GET_VALUE (symbolS *s)
1934 {
1935   if (LOCAL_SYMBOL_CHECK (s))
1936     return resolve_symbol_value (s);
1937 
1938   if (!s->sy_flags.sy_resolved)
1939     {
1940       valueT val = resolve_symbol_value (s);
1941       if (!finalize_syms)
1942 	return val;
1943     }
1944   if (S_IS_WEAKREFR (s))
1945     return S_GET_VALUE (s->sy_value.X_add_symbol);
1946 
1947   if (s->sy_value.X_op != O_constant)
1948     {
1949       if (! s->sy_flags.sy_resolved
1950 	  || s->sy_value.X_op != O_symbol
1951 	  || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
1952 	as_bad (_("attempt to get value of unresolved symbol `%s'"),
1953 		S_GET_NAME (s));
1954     }
1955   return (valueT) s->sy_value.X_add_number;
1956 }
1957 
1958 /* Set the value of a symbol.  */
1959 
1960 void
S_SET_VALUE(symbolS * s,valueT val)1961 S_SET_VALUE (symbolS *s, valueT val)
1962 {
1963   if (LOCAL_SYMBOL_CHECK (s))
1964     {
1965       ((struct local_symbol *) s)->lsy_value = val;
1966       return;
1967     }
1968 
1969   s->sy_value.X_op = O_constant;
1970   s->sy_value.X_add_number = (offsetT) val;
1971   s->sy_value.X_unsigned = 0;
1972   S_CLEAR_WEAKREFR (s);
1973 }
1974 
1975 void
copy_symbol_attributes(symbolS * dest,symbolS * src)1976 copy_symbol_attributes (symbolS *dest, symbolS *src)
1977 {
1978   if (LOCAL_SYMBOL_CHECK (dest))
1979     dest = local_symbol_convert ((struct local_symbol *) dest);
1980   if (LOCAL_SYMBOL_CHECK (src))
1981     src = local_symbol_convert ((struct local_symbol *) src);
1982 
1983   /* In an expression, transfer the settings of these flags.
1984      The user can override later, of course.  */
1985 #define COPIED_SYMFLAGS	(BSF_FUNCTION | BSF_OBJECT \
1986 			 | BSF_GNU_INDIRECT_FUNCTION)
1987   dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
1988 
1989 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1990   OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
1991 #endif
1992 
1993 #ifdef TC_COPY_SYMBOL_ATTRIBUTES
1994   TC_COPY_SYMBOL_ATTRIBUTES (dest, src);
1995 #endif
1996 }
1997 
1998 int
S_IS_FUNCTION(symbolS * s)1999 S_IS_FUNCTION (symbolS *s)
2000 {
2001   flagword flags;
2002 
2003   if (LOCAL_SYMBOL_CHECK (s))
2004     return 0;
2005 
2006   flags = s->bsym->flags;
2007 
2008   return (flags & BSF_FUNCTION) != 0;
2009 }
2010 
2011 int
S_IS_EXTERNAL(symbolS * s)2012 S_IS_EXTERNAL (symbolS *s)
2013 {
2014   flagword flags;
2015 
2016   if (LOCAL_SYMBOL_CHECK (s))
2017     return 0;
2018 
2019   flags = s->bsym->flags;
2020 
2021   /* Sanity check.  */
2022   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
2023     abort ();
2024 
2025   return (flags & BSF_GLOBAL) != 0;
2026 }
2027 
2028 int
S_IS_WEAK(symbolS * s)2029 S_IS_WEAK (symbolS *s)
2030 {
2031   if (LOCAL_SYMBOL_CHECK (s))
2032     return 0;
2033   /* Conceptually, a weakrefr is weak if the referenced symbol is.  We
2034      could probably handle a WEAKREFR as always weak though.  E.g., if
2035      the referenced symbol has lost its weak status, there's no reason
2036      to keep handling the weakrefr as if it was weak.  */
2037   if (S_IS_WEAKREFR (s))
2038     return S_IS_WEAK (s->sy_value.X_add_symbol);
2039   return (s->bsym->flags & BSF_WEAK) != 0;
2040 }
2041 
2042 int
S_IS_WEAKREFR(symbolS * s)2043 S_IS_WEAKREFR (symbolS *s)
2044 {
2045   if (LOCAL_SYMBOL_CHECK (s))
2046     return 0;
2047   return s->sy_flags.sy_weakrefr != 0;
2048 }
2049 
2050 int
S_IS_WEAKREFD(symbolS * s)2051 S_IS_WEAKREFD (symbolS *s)
2052 {
2053   if (LOCAL_SYMBOL_CHECK (s))
2054     return 0;
2055   return s->sy_flags.sy_weakrefd != 0;
2056 }
2057 
2058 int
S_IS_COMMON(symbolS * s)2059 S_IS_COMMON (symbolS *s)
2060 {
2061   if (LOCAL_SYMBOL_CHECK (s))
2062     return 0;
2063   return bfd_is_com_section (s->bsym->section);
2064 }
2065 
2066 int
S_IS_DEFINED(symbolS * s)2067 S_IS_DEFINED (symbolS *s)
2068 {
2069   if (LOCAL_SYMBOL_CHECK (s))
2070     return ((struct local_symbol *) s)->lsy_section != undefined_section;
2071   return s->bsym->section != undefined_section;
2072 }
2073 
2074 
2075 #ifndef EXTERN_FORCE_RELOC
2076 #define EXTERN_FORCE_RELOC IS_ELF
2077 #endif
2078 
2079 /* Return true for symbols that should not be reduced to section
2080    symbols or eliminated from expressions, because they may be
2081    overridden by the linker.  */
2082 int
S_FORCE_RELOC(symbolS * s,int strict)2083 S_FORCE_RELOC (symbolS *s, int strict)
2084 {
2085   if (LOCAL_SYMBOL_CHECK (s))
2086     return ((struct local_symbol *) s)->lsy_section == undefined_section;
2087 
2088   return ((strict
2089 	   && ((s->bsym->flags & BSF_WEAK) != 0
2090 	       || (EXTERN_FORCE_RELOC
2091 		   && (s->bsym->flags & BSF_GLOBAL) != 0)))
2092 	  || (s->bsym->flags & BSF_GNU_INDIRECT_FUNCTION) != 0
2093 	  || s->bsym->section == undefined_section
2094 	  || bfd_is_com_section (s->bsym->section));
2095 }
2096 
2097 int
S_IS_DEBUG(symbolS * s)2098 S_IS_DEBUG (symbolS *s)
2099 {
2100   if (LOCAL_SYMBOL_CHECK (s))
2101     return 0;
2102   if (s->bsym->flags & BSF_DEBUGGING)
2103     return 1;
2104   return 0;
2105 }
2106 
2107 int
S_IS_LOCAL(symbolS * s)2108 S_IS_LOCAL (symbolS *s)
2109 {
2110   flagword flags;
2111   const char *name;
2112 
2113   if (LOCAL_SYMBOL_CHECK (s))
2114     return 1;
2115 
2116   flags = s->bsym->flags;
2117 
2118   /* Sanity check.  */
2119   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
2120     abort ();
2121 
2122   if (bfd_get_section (s->bsym) == reg_section)
2123     return 1;
2124 
2125   if (flag_strip_local_absolute
2126       /* Keep BSF_FILE symbols in order to allow debuggers to identify
2127 	 the source file even when the object file is stripped.  */
2128       && (flags & (BSF_GLOBAL | BSF_FILE)) == 0
2129       && bfd_get_section (s->bsym) == absolute_section)
2130     return 1;
2131 
2132   name = S_GET_NAME (s);
2133   return (name != NULL
2134 	  && ! S_IS_DEBUG (s)
2135 	  && (strchr (name, DOLLAR_LABEL_CHAR)
2136 	      || strchr (name, LOCAL_LABEL_CHAR)
2137 	      || TC_LABEL_IS_LOCAL (name)
2138 	      || (! flag_keep_locals
2139 		  && (bfd_is_local_label (stdoutput, s->bsym)
2140 		      || (flag_mri
2141 			  && name[0] == '?'
2142 			  && name[1] == '?')))));
2143 }
2144 
2145 int
S_IS_STABD(symbolS * s)2146 S_IS_STABD (symbolS *s)
2147 {
2148   return S_GET_NAME (s) == 0;
2149 }
2150 
2151 int
S_CAN_BE_REDEFINED(const symbolS * s)2152 S_CAN_BE_REDEFINED (const symbolS *s)
2153 {
2154   if (LOCAL_SYMBOL_CHECK (s))
2155     return (local_symbol_get_frag ((struct local_symbol *) s)
2156 	    == &predefined_address_frag);
2157   /* Permit register names to be redefined.  */
2158   return s->bsym->section == reg_section;
2159 }
2160 
2161 int
S_IS_VOLATILE(const symbolS * s)2162 S_IS_VOLATILE (const symbolS *s)
2163 {
2164   if (LOCAL_SYMBOL_CHECK (s))
2165     return 0;
2166   return s->sy_flags.sy_volatile;
2167 }
2168 
2169 int
S_IS_FORWARD_REF(const symbolS * s)2170 S_IS_FORWARD_REF (const symbolS *s)
2171 {
2172   if (LOCAL_SYMBOL_CHECK (s))
2173     return 0;
2174   return s->sy_flags.sy_forward_ref;
2175 }
2176 
2177 const char *
S_GET_NAME(symbolS * s)2178 S_GET_NAME (symbolS *s)
2179 {
2180   if (LOCAL_SYMBOL_CHECK (s))
2181     return ((struct local_symbol *) s)->lsy_name;
2182   return s->bsym->name;
2183 }
2184 
2185 segT
S_GET_SEGMENT(symbolS * s)2186 S_GET_SEGMENT (symbolS *s)
2187 {
2188   if (LOCAL_SYMBOL_CHECK (s))
2189     return ((struct local_symbol *) s)->lsy_section;
2190   return s->bsym->section;
2191 }
2192 
2193 void
S_SET_SEGMENT(symbolS * s,segT seg)2194 S_SET_SEGMENT (symbolS *s, segT seg)
2195 {
2196   /* Don't reassign section symbols.  The direct reason is to prevent seg
2197      faults assigning back to const global symbols such as *ABS*, but it
2198      shouldn't happen anyway.  */
2199 
2200   if (LOCAL_SYMBOL_CHECK (s))
2201     {
2202       if (seg == reg_section)
2203 	s = local_symbol_convert ((struct local_symbol *) s);
2204       else
2205 	{
2206 	  ((struct local_symbol *) s)->lsy_section = seg;
2207 	  return;
2208 	}
2209     }
2210 
2211   if (s->bsym->flags & BSF_SECTION_SYM)
2212     {
2213       if (s->bsym->section != seg)
2214 	abort ();
2215     }
2216   else
2217     s->bsym->section = seg;
2218 }
2219 
2220 void
S_SET_EXTERNAL(symbolS * s)2221 S_SET_EXTERNAL (symbolS *s)
2222 {
2223   if (LOCAL_SYMBOL_CHECK (s))
2224     s = local_symbol_convert ((struct local_symbol *) s);
2225   if ((s->bsym->flags & BSF_WEAK) != 0)
2226     {
2227       /* Let .weak override .global.  */
2228       return;
2229     }
2230   if (s->bsym->flags & BSF_SECTION_SYM)
2231     {
2232       /* Do not reassign section symbols.  */
2233       as_warn (_("section symbols are already global"));
2234       return;
2235     }
2236 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
2237   if (S_GET_SEGMENT (s) == reg_section)
2238     {
2239       as_bad ("can't make register symbol `%s' global",
2240 	      S_GET_NAME (s));
2241       return;
2242     }
2243 #endif
2244   s->bsym->flags |= BSF_GLOBAL;
2245   s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
2246 
2247 #ifdef TE_PE
2248   if (! an_external_name && S_GET_NAME(s)[0] != '.')
2249     an_external_name = S_GET_NAME (s);
2250 #endif
2251 }
2252 
2253 void
S_CLEAR_EXTERNAL(symbolS * s)2254 S_CLEAR_EXTERNAL (symbolS *s)
2255 {
2256   if (LOCAL_SYMBOL_CHECK (s))
2257     return;
2258   if ((s->bsym->flags & BSF_WEAK) != 0)
2259     {
2260       /* Let .weak override.  */
2261       return;
2262     }
2263   s->bsym->flags |= BSF_LOCAL;
2264   s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
2265 }
2266 
2267 void
S_SET_WEAK(symbolS * s)2268 S_SET_WEAK (symbolS *s)
2269 {
2270   if (LOCAL_SYMBOL_CHECK (s))
2271     s = local_symbol_convert ((struct local_symbol *) s);
2272 #ifdef obj_set_weak_hook
2273   obj_set_weak_hook (s);
2274 #endif
2275   s->bsym->flags |= BSF_WEAK;
2276   s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
2277 }
2278 
2279 void
S_SET_WEAKREFR(symbolS * s)2280 S_SET_WEAKREFR (symbolS *s)
2281 {
2282   if (LOCAL_SYMBOL_CHECK (s))
2283     s = local_symbol_convert ((struct local_symbol *) s);
2284   s->sy_flags.sy_weakrefr = 1;
2285   /* If the alias was already used, make sure we mark the target as
2286      used as well, otherwise it might be dropped from the symbol
2287      table.  This may have unintended side effects if the alias is
2288      later redirected to another symbol, such as keeping the unused
2289      previous target in the symbol table.  Since it will be weak, it's
2290      not a big deal.  */
2291   if (s->sy_flags.sy_used)
2292     symbol_mark_used (s->sy_value.X_add_symbol);
2293 }
2294 
2295 void
S_CLEAR_WEAKREFR(symbolS * s)2296 S_CLEAR_WEAKREFR (symbolS *s)
2297 {
2298   if (LOCAL_SYMBOL_CHECK (s))
2299     return;
2300   s->sy_flags.sy_weakrefr = 0;
2301 }
2302 
2303 void
S_SET_WEAKREFD(symbolS * s)2304 S_SET_WEAKREFD (symbolS *s)
2305 {
2306   if (LOCAL_SYMBOL_CHECK (s))
2307     s = local_symbol_convert ((struct local_symbol *) s);
2308   s->sy_flags.sy_weakrefd = 1;
2309   S_SET_WEAK (s);
2310 }
2311 
2312 void
S_CLEAR_WEAKREFD(symbolS * s)2313 S_CLEAR_WEAKREFD (symbolS *s)
2314 {
2315   if (LOCAL_SYMBOL_CHECK (s))
2316     return;
2317   if (s->sy_flags.sy_weakrefd)
2318     {
2319       s->sy_flags.sy_weakrefd = 0;
2320       /* If a weakref target symbol is weak, then it was never
2321 	 referenced directly before, not even in a .global directive,
2322 	 so decay it to local.  If it remains undefined, it will be
2323 	 later turned into a global, like any other undefined
2324 	 symbol.  */
2325       if (s->bsym->flags & BSF_WEAK)
2326 	{
2327 #ifdef obj_clear_weak_hook
2328 	  obj_clear_weak_hook (s);
2329 #endif
2330 	  s->bsym->flags &= ~BSF_WEAK;
2331 	  s->bsym->flags |= BSF_LOCAL;
2332 	}
2333     }
2334 }
2335 
2336 void
S_SET_THREAD_LOCAL(symbolS * s)2337 S_SET_THREAD_LOCAL (symbolS *s)
2338 {
2339   if (LOCAL_SYMBOL_CHECK (s))
2340     s = local_symbol_convert ((struct local_symbol *) s);
2341   if (bfd_is_com_section (s->bsym->section)
2342       && (s->bsym->flags & BSF_THREAD_LOCAL) != 0)
2343     return;
2344   s->bsym->flags |= BSF_THREAD_LOCAL;
2345   if ((s->bsym->flags & BSF_FUNCTION) != 0)
2346     as_bad (_("Accessing function `%s' as thread-local object"),
2347 	    S_GET_NAME (s));
2348   else if (! bfd_is_und_section (s->bsym->section)
2349 	   && (s->bsym->section->flags & SEC_THREAD_LOCAL) == 0)
2350     as_bad (_("Accessing `%s' as thread-local object"),
2351 	    S_GET_NAME (s));
2352 }
2353 
2354 void
S_SET_NAME(symbolS * s,const char * name)2355 S_SET_NAME (symbolS *s, const char *name)
2356 {
2357   if (LOCAL_SYMBOL_CHECK (s))
2358     {
2359       ((struct local_symbol *) s)->lsy_name = name;
2360       return;
2361     }
2362   s->bsym->name = name;
2363 }
2364 
2365 void
S_SET_VOLATILE(symbolS * s)2366 S_SET_VOLATILE (symbolS *s)
2367 {
2368   if (LOCAL_SYMBOL_CHECK (s))
2369     s = local_symbol_convert ((struct local_symbol *) s);
2370   s->sy_flags.sy_volatile = 1;
2371 }
2372 
2373 void
S_CLEAR_VOLATILE(symbolS * s)2374 S_CLEAR_VOLATILE (symbolS *s)
2375 {
2376   if (!LOCAL_SYMBOL_CHECK (s))
2377     s->sy_flags.sy_volatile = 0;
2378 }
2379 
2380 void
S_SET_FORWARD_REF(symbolS * s)2381 S_SET_FORWARD_REF (symbolS *s)
2382 {
2383   if (LOCAL_SYMBOL_CHECK (s))
2384     s = local_symbol_convert ((struct local_symbol *) s);
2385   s->sy_flags.sy_forward_ref = 1;
2386 }
2387 
2388 /* Return the previous symbol in a chain.  */
2389 
2390 symbolS *
symbol_previous(symbolS * s)2391 symbol_previous (symbolS *s)
2392 {
2393   if (LOCAL_SYMBOL_CHECK (s))
2394     abort ();
2395   return s->sy_previous;
2396 }
2397 
2398 /* Return the next symbol in a chain.  */
2399 
2400 symbolS *
symbol_next(symbolS * s)2401 symbol_next (symbolS *s)
2402 {
2403   if (LOCAL_SYMBOL_CHECK (s))
2404     abort ();
2405   return s->sy_next;
2406 }
2407 
2408 /* Return a pointer to the value of a symbol as an expression.  */
2409 
2410 expressionS *
symbol_get_value_expression(symbolS * s)2411 symbol_get_value_expression (symbolS *s)
2412 {
2413   if (LOCAL_SYMBOL_CHECK (s))
2414     s = local_symbol_convert ((struct local_symbol *) s);
2415   return &s->sy_value;
2416 }
2417 
2418 /* Set the value of a symbol to an expression.  */
2419 
2420 void
symbol_set_value_expression(symbolS * s,const expressionS * exp)2421 symbol_set_value_expression (symbolS *s, const expressionS *exp)
2422 {
2423   if (LOCAL_SYMBOL_CHECK (s))
2424     s = local_symbol_convert ((struct local_symbol *) s);
2425   s->sy_value = *exp;
2426   S_CLEAR_WEAKREFR (s);
2427 }
2428 
2429 /* Return whether 2 symbols are the same.  */
2430 
2431 int
symbol_same_p(symbolS * s1,symbolS * s2)2432 symbol_same_p (symbolS *s1, symbolS *s2)
2433 {
2434   if (s1->sy_flags.sy_local_symbol
2435       && local_symbol_converted_p ((struct local_symbol *) s1))
2436     s1 = local_symbol_get_real_symbol ((struct local_symbol *) s1);
2437   if (s2->sy_flags.sy_local_symbol
2438       && local_symbol_converted_p ((struct local_symbol *) s2))
2439     s2 = local_symbol_get_real_symbol ((struct local_symbol *) s2);
2440   return s1 == s2;
2441 }
2442 
2443 /* Return a pointer to the X_add_number component of a symbol.  */
2444 
2445 offsetT *
symbol_X_add_number(symbolS * s)2446 symbol_X_add_number (symbolS *s)
2447 {
2448   if (LOCAL_SYMBOL_CHECK (s))
2449     return (offsetT *) &((struct local_symbol *) s)->lsy_value;
2450 
2451   return &s->sy_value.X_add_number;
2452 }
2453 
2454 /* Set the value of SYM to the current position in the current segment.  */
2455 
2456 void
symbol_set_value_now(symbolS * sym)2457 symbol_set_value_now (symbolS *sym)
2458 {
2459   S_SET_SEGMENT (sym, now_seg);
2460   S_SET_VALUE (sym, frag_now_fix ());
2461   symbol_set_frag (sym, frag_now);
2462 }
2463 
2464 /* Set the frag of a symbol.  */
2465 
2466 void
symbol_set_frag(symbolS * s,fragS * f)2467 symbol_set_frag (symbolS *s, fragS *f)
2468 {
2469   if (LOCAL_SYMBOL_CHECK (s))
2470     {
2471       local_symbol_set_frag ((struct local_symbol *) s, f);
2472       return;
2473     }
2474   s->sy_frag = f;
2475   S_CLEAR_WEAKREFR (s);
2476 }
2477 
2478 /* Return the frag of a symbol.  */
2479 
2480 fragS *
symbol_get_frag(symbolS * s)2481 symbol_get_frag (symbolS *s)
2482 {
2483   if (LOCAL_SYMBOL_CHECK (s))
2484     return local_symbol_get_frag ((struct local_symbol *) s);
2485   return s->sy_frag;
2486 }
2487 
2488 /* Mark a symbol as having been used.  */
2489 
2490 void
symbol_mark_used(symbolS * s)2491 symbol_mark_used (symbolS *s)
2492 {
2493   if (LOCAL_SYMBOL_CHECK (s))
2494     return;
2495   s->sy_flags.sy_used = 1;
2496   if (S_IS_WEAKREFR (s))
2497     symbol_mark_used (s->sy_value.X_add_symbol);
2498 }
2499 
2500 /* Clear the mark of whether a symbol has been used.  */
2501 
2502 void
symbol_clear_used(symbolS * s)2503 symbol_clear_used (symbolS *s)
2504 {
2505   if (LOCAL_SYMBOL_CHECK (s))
2506     s = local_symbol_convert ((struct local_symbol *) s);
2507   s->sy_flags.sy_used = 0;
2508 }
2509 
2510 /* Return whether a symbol has been used.  */
2511 
2512 int
symbol_used_p(symbolS * s)2513 symbol_used_p (symbolS *s)
2514 {
2515   if (LOCAL_SYMBOL_CHECK (s))
2516     return 1;
2517   return s->sy_flags.sy_used;
2518 }
2519 
2520 /* Mark a symbol as having been used in a reloc.  */
2521 
2522 void
symbol_mark_used_in_reloc(symbolS * s)2523 symbol_mark_used_in_reloc (symbolS *s)
2524 {
2525   if (LOCAL_SYMBOL_CHECK (s))
2526     s = local_symbol_convert ((struct local_symbol *) s);
2527   s->sy_flags.sy_used_in_reloc = 1;
2528 }
2529 
2530 /* Clear the mark of whether a symbol has been used in a reloc.  */
2531 
2532 void
symbol_clear_used_in_reloc(symbolS * s)2533 symbol_clear_used_in_reloc (symbolS *s)
2534 {
2535   if (LOCAL_SYMBOL_CHECK (s))
2536     return;
2537   s->sy_flags.sy_used_in_reloc = 0;
2538 }
2539 
2540 /* Return whether a symbol has been used in a reloc.  */
2541 
2542 int
symbol_used_in_reloc_p(symbolS * s)2543 symbol_used_in_reloc_p (symbolS *s)
2544 {
2545   if (LOCAL_SYMBOL_CHECK (s))
2546     return 0;
2547   return s->sy_flags.sy_used_in_reloc;
2548 }
2549 
2550 /* Mark a symbol as an MRI common symbol.  */
2551 
2552 void
symbol_mark_mri_common(symbolS * s)2553 symbol_mark_mri_common (symbolS *s)
2554 {
2555   if (LOCAL_SYMBOL_CHECK (s))
2556     s = local_symbol_convert ((struct local_symbol *) s);
2557   s->sy_flags.sy_mri_common = 1;
2558 }
2559 
2560 /* Clear the mark of whether a symbol is an MRI common symbol.  */
2561 
2562 void
symbol_clear_mri_common(symbolS * s)2563 symbol_clear_mri_common (symbolS *s)
2564 {
2565   if (LOCAL_SYMBOL_CHECK (s))
2566     return;
2567   s->sy_flags.sy_mri_common = 0;
2568 }
2569 
2570 /* Return whether a symbol is an MRI common symbol.  */
2571 
2572 int
symbol_mri_common_p(symbolS * s)2573 symbol_mri_common_p (symbolS *s)
2574 {
2575   if (LOCAL_SYMBOL_CHECK (s))
2576     return 0;
2577   return s->sy_flags.sy_mri_common;
2578 }
2579 
2580 /* Mark a symbol as having been written.  */
2581 
2582 void
symbol_mark_written(symbolS * s)2583 symbol_mark_written (symbolS *s)
2584 {
2585   if (LOCAL_SYMBOL_CHECK (s))
2586     return;
2587   s->sy_flags.sy_written = 1;
2588 }
2589 
2590 /* Clear the mark of whether a symbol has been written.  */
2591 
2592 void
symbol_clear_written(symbolS * s)2593 symbol_clear_written (symbolS *s)
2594 {
2595   if (LOCAL_SYMBOL_CHECK (s))
2596     return;
2597   s->sy_flags.sy_written = 0;
2598 }
2599 
2600 /* Return whether a symbol has been written.  */
2601 
2602 int
symbol_written_p(symbolS * s)2603 symbol_written_p (symbolS *s)
2604 {
2605   if (LOCAL_SYMBOL_CHECK (s))
2606     return 0;
2607   return s->sy_flags.sy_written;
2608 }
2609 
2610 /* Mark a symbol has having been resolved.  */
2611 
2612 void
symbol_mark_resolved(symbolS * s)2613 symbol_mark_resolved (symbolS *s)
2614 {
2615   if (LOCAL_SYMBOL_CHECK (s))
2616     {
2617       local_symbol_mark_resolved ((struct local_symbol *) s);
2618       return;
2619     }
2620   s->sy_flags.sy_resolved = 1;
2621 }
2622 
2623 /* Return whether a symbol has been resolved.  */
2624 
2625 int
symbol_resolved_p(symbolS * s)2626 symbol_resolved_p (symbolS *s)
2627 {
2628   if (LOCAL_SYMBOL_CHECK (s))
2629     return local_symbol_resolved_p ((struct local_symbol *) s);
2630   return s->sy_flags.sy_resolved;
2631 }
2632 
2633 /* Return whether a symbol is a section symbol.  */
2634 
2635 int
symbol_section_p(symbolS * s ATTRIBUTE_UNUSED)2636 symbol_section_p (symbolS *s ATTRIBUTE_UNUSED)
2637 {
2638   if (LOCAL_SYMBOL_CHECK (s))
2639     return 0;
2640   return (s->bsym->flags & BSF_SECTION_SYM) != 0;
2641 }
2642 
2643 /* Return whether a symbol is equated to another symbol.  */
2644 
2645 int
symbol_equated_p(symbolS * s)2646 symbol_equated_p (symbolS *s)
2647 {
2648   if (LOCAL_SYMBOL_CHECK (s))
2649     return 0;
2650   return s->sy_value.X_op == O_symbol;
2651 }
2652 
2653 /* Return whether a symbol is equated to another symbol, and should be
2654    treated specially when writing out relocs.  */
2655 
2656 int
symbol_equated_reloc_p(symbolS * s)2657 symbol_equated_reloc_p (symbolS *s)
2658 {
2659   if (LOCAL_SYMBOL_CHECK (s))
2660     return 0;
2661   /* X_op_symbol, normally not used for O_symbol, is set by
2662      resolve_symbol_value to flag expression syms that have been
2663      equated.  */
2664   return (s->sy_value.X_op == O_symbol
2665 #if defined (OBJ_COFF) && defined (TE_PE)
2666 	  && ! S_IS_WEAK (s)
2667 #endif
2668 	  && ((s->sy_flags.sy_resolved && s->sy_value.X_op_symbol != NULL)
2669 	      || ! S_IS_DEFINED (s)
2670 	      || S_IS_COMMON (s)));
2671 }
2672 
2673 /* Return whether a symbol has a constant value.  */
2674 
2675 int
symbol_constant_p(symbolS * s)2676 symbol_constant_p (symbolS *s)
2677 {
2678   if (LOCAL_SYMBOL_CHECK (s))
2679     return 1;
2680   return s->sy_value.X_op == O_constant;
2681 }
2682 
2683 /* Return whether a symbol was cloned and thus removed from the global
2684    symbol list.  */
2685 
2686 int
symbol_shadow_p(symbolS * s)2687 symbol_shadow_p (symbolS *s)
2688 {
2689   if (LOCAL_SYMBOL_CHECK (s))
2690     return 0;
2691   return s->sy_next == s;
2692 }
2693 
2694 /* Return the BFD symbol for a symbol.  */
2695 
2696 asymbol *
symbol_get_bfdsym(symbolS * s)2697 symbol_get_bfdsym (symbolS *s)
2698 {
2699   if (LOCAL_SYMBOL_CHECK (s))
2700     s = local_symbol_convert ((struct local_symbol *) s);
2701   return s->bsym;
2702 }
2703 
2704 /* Set the BFD symbol for a symbol.  */
2705 
2706 void
symbol_set_bfdsym(symbolS * s,asymbol * bsym)2707 symbol_set_bfdsym (symbolS *s, asymbol *bsym)
2708 {
2709   if (LOCAL_SYMBOL_CHECK (s))
2710     s = local_symbol_convert ((struct local_symbol *) s);
2711   /* Usually, it is harmless to reset a symbol to a BFD section
2712      symbol. For example, obj_elf_change_section sets the BFD symbol
2713      of an old symbol with the newly created section symbol. But when
2714      we have multiple sections with the same name, the newly created
2715      section may have the same name as an old section. We check if the
2716      old symbol has been already marked as a section symbol before
2717      resetting it.  */
2718   if ((s->bsym->flags & BSF_SECTION_SYM) == 0)
2719     s->bsym = bsym;
2720   /* else XXX - What do we do now ?  */
2721 }
2722 
2723 #ifdef OBJ_SYMFIELD_TYPE
2724 
2725 /* Get a pointer to the object format information for a symbol.  */
2726 
2727 OBJ_SYMFIELD_TYPE *
symbol_get_obj(symbolS * s)2728 symbol_get_obj (symbolS *s)
2729 {
2730   if (LOCAL_SYMBOL_CHECK (s))
2731     s = local_symbol_convert ((struct local_symbol *) s);
2732   return &s->sy_obj;
2733 }
2734 
2735 /* Set the object format information for a symbol.  */
2736 
2737 void
symbol_set_obj(symbolS * s,OBJ_SYMFIELD_TYPE * o)2738 symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPE *o)
2739 {
2740   if (LOCAL_SYMBOL_CHECK (s))
2741     s = local_symbol_convert ((struct local_symbol *) s);
2742   s->sy_obj = *o;
2743 }
2744 
2745 #endif /* OBJ_SYMFIELD_TYPE */
2746 
2747 #ifdef TC_SYMFIELD_TYPE
2748 
2749 /* Get a pointer to the processor information for a symbol.  */
2750 
2751 TC_SYMFIELD_TYPE *
symbol_get_tc(symbolS * s)2752 symbol_get_tc (symbolS *s)
2753 {
2754   if (LOCAL_SYMBOL_CHECK (s))
2755     s = local_symbol_convert ((struct local_symbol *) s);
2756   return &s->sy_tc;
2757 }
2758 
2759 /* Set the processor information for a symbol.  */
2760 
2761 void
symbol_set_tc(symbolS * s,TC_SYMFIELD_TYPE * o)2762 symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)
2763 {
2764   if (LOCAL_SYMBOL_CHECK (s))
2765     s = local_symbol_convert ((struct local_symbol *) s);
2766   s->sy_tc = *o;
2767 }
2768 
2769 #endif /* TC_SYMFIELD_TYPE */
2770 
2771 void
symbol_begin(void)2772 symbol_begin (void)
2773 {
2774   symbol_lastP = NULL;
2775   symbol_rootP = NULL;		/* In case we have 0 symbols (!!)  */
2776   sy_hash = hash_new ();
2777   local_hash = hash_new ();
2778 
2779   memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
2780 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2781   abs_symbol.bsym = bfd_abs_section_ptr->symbol;
2782 #endif
2783   abs_symbol.sy_value.X_op = O_constant;
2784   abs_symbol.sy_frag = &zero_address_frag;
2785 
2786   if (LOCAL_LABELS_FB)
2787     fb_label_init ();
2788 }
2789 
2790 void
dot_symbol_init(void)2791 dot_symbol_init (void)
2792 {
2793   dot_symbol.bsym = bfd_make_empty_symbol (stdoutput);
2794   if (dot_symbol.bsym == NULL)
2795     as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
2796   dot_symbol.bsym->name = ".";
2797   dot_symbol.sy_flags.sy_forward_ref = 1;
2798   dot_symbol.sy_value.X_op = O_constant;
2799 }
2800 
2801 int indent_level;
2802 
2803 /* Maximum indent level.
2804    Available for modification inside a gdb session.  */
2805 static int max_indent_level = 8;
2806 
2807 void
print_symbol_value_1(FILE * file,symbolS * sym)2808 print_symbol_value_1 (FILE *file, symbolS *sym)
2809 {
2810   const char *name = S_GET_NAME (sym);
2811   if (!name || !name[0])
2812     name = "(unnamed)";
2813   fprintf (file, "sym ");
2814   fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym));
2815   fprintf (file, " %s", name);
2816 
2817   if (LOCAL_SYMBOL_CHECK (sym))
2818     {
2819       struct local_symbol *locsym = (struct local_symbol *) sym;
2820 
2821       if (local_symbol_get_frag (locsym) != & zero_address_frag
2822 	  && local_symbol_get_frag (locsym) != NULL)
2823 	{
2824 	  fprintf (file, " frag ");
2825 	  fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) local_symbol_get_frag (locsym)));
2826         }
2827       if (local_symbol_resolved_p (locsym))
2828 	fprintf (file, " resolved");
2829       fprintf (file, " local");
2830     }
2831   else
2832     {
2833       if (sym->sy_frag != &zero_address_frag)
2834 	{
2835 	  fprintf (file, " frag ");
2836 	  fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym->sy_frag));
2837 	}
2838       if (sym->sy_flags.sy_written)
2839 	fprintf (file, " written");
2840       if (sym->sy_flags.sy_resolved)
2841 	fprintf (file, " resolved");
2842       else if (sym->sy_flags.sy_resolving)
2843 	fprintf (file, " resolving");
2844       if (sym->sy_flags.sy_used_in_reloc)
2845 	fprintf (file, " used-in-reloc");
2846       if (sym->sy_flags.sy_used)
2847 	fprintf (file, " used");
2848       if (S_IS_LOCAL (sym))
2849 	fprintf (file, " local");
2850       if (S_IS_EXTERNAL (sym))
2851 	fprintf (file, " extern");
2852       if (S_IS_WEAK (sym))
2853 	fprintf (file, " weak");
2854       if (S_IS_DEBUG (sym))
2855 	fprintf (file, " debug");
2856       if (S_IS_DEFINED (sym))
2857 	fprintf (file, " defined");
2858     }
2859   if (S_IS_WEAKREFR (sym))
2860     fprintf (file, " weakrefr");
2861   if (S_IS_WEAKREFD (sym))
2862     fprintf (file, " weakrefd");
2863   fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
2864   if (symbol_resolved_p (sym))
2865     {
2866       segT s = S_GET_SEGMENT (sym);
2867 
2868       if (s != undefined_section
2869 	  && s != expr_section)
2870 	fprintf (file, " %lx", (unsigned long) S_GET_VALUE (sym));
2871     }
2872   else if (indent_level < max_indent_level
2873 	   && S_GET_SEGMENT (sym) != undefined_section)
2874     {
2875       indent_level++;
2876       fprintf (file, "\n%*s<", indent_level * 4, "");
2877       if (LOCAL_SYMBOL_CHECK (sym))
2878 	fprintf (file, "constant %lx",
2879 		 (unsigned long) ((struct local_symbol *) sym)->lsy_value);
2880       else
2881 	print_expr_1 (file, &sym->sy_value);
2882       fprintf (file, ">");
2883       indent_level--;
2884     }
2885   fflush (file);
2886 }
2887 
2888 void
print_symbol_value(symbolS * sym)2889 print_symbol_value (symbolS *sym)
2890 {
2891   indent_level = 0;
2892   print_symbol_value_1 (stderr, sym);
2893   fprintf (stderr, "\n");
2894 }
2895 
2896 static void
print_binary(FILE * file,const char * name,expressionS * exp)2897 print_binary (FILE *file, const char *name, expressionS *exp)
2898 {
2899   indent_level++;
2900   fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
2901   print_symbol_value_1 (file, exp->X_add_symbol);
2902   fprintf (file, ">\n%*s<", indent_level * 4, "");
2903   print_symbol_value_1 (file, exp->X_op_symbol);
2904   fprintf (file, ">");
2905   indent_level--;
2906 }
2907 
2908 void
print_expr_1(FILE * file,expressionS * exp)2909 print_expr_1 (FILE *file, expressionS *exp)
2910 {
2911   fprintf (file, "expr ");
2912   fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) exp));
2913   fprintf (file, " ");
2914   switch (exp->X_op)
2915     {
2916     case O_illegal:
2917       fprintf (file, "illegal");
2918       break;
2919     case O_absent:
2920       fprintf (file, "absent");
2921       break;
2922     case O_constant:
2923       fprintf (file, "constant %lx", (unsigned long) exp->X_add_number);
2924       break;
2925     case O_symbol:
2926       indent_level++;
2927       fprintf (file, "symbol\n%*s<", indent_level * 4, "");
2928       print_symbol_value_1 (file, exp->X_add_symbol);
2929       fprintf (file, ">");
2930     maybe_print_addnum:
2931       if (exp->X_add_number)
2932 	fprintf (file, "\n%*s%lx", indent_level * 4, "",
2933 		 (unsigned long) exp->X_add_number);
2934       indent_level--;
2935       break;
2936     case O_register:
2937       fprintf (file, "register #%d", (int) exp->X_add_number);
2938       break;
2939     case O_big:
2940       fprintf (file, "big");
2941       break;
2942     case O_uminus:
2943       fprintf (file, "uminus -<");
2944       indent_level++;
2945       print_symbol_value_1 (file, exp->X_add_symbol);
2946       fprintf (file, ">");
2947       goto maybe_print_addnum;
2948     case O_bit_not:
2949       fprintf (file, "bit_not");
2950       break;
2951     case O_multiply:
2952       print_binary (file, "multiply", exp);
2953       break;
2954     case O_divide:
2955       print_binary (file, "divide", exp);
2956       break;
2957     case O_modulus:
2958       print_binary (file, "modulus", exp);
2959       break;
2960     case O_left_shift:
2961       print_binary (file, "lshift", exp);
2962       break;
2963     case O_right_shift:
2964       print_binary (file, "rshift", exp);
2965       break;
2966     case O_bit_inclusive_or:
2967       print_binary (file, "bit_ior", exp);
2968       break;
2969     case O_bit_exclusive_or:
2970       print_binary (file, "bit_xor", exp);
2971       break;
2972     case O_bit_and:
2973       print_binary (file, "bit_and", exp);
2974       break;
2975     case O_eq:
2976       print_binary (file, "eq", exp);
2977       break;
2978     case O_ne:
2979       print_binary (file, "ne", exp);
2980       break;
2981     case O_lt:
2982       print_binary (file, "lt", exp);
2983       break;
2984     case O_le:
2985       print_binary (file, "le", exp);
2986       break;
2987     case O_ge:
2988       print_binary (file, "ge", exp);
2989       break;
2990     case O_gt:
2991       print_binary (file, "gt", exp);
2992       break;
2993     case O_logical_and:
2994       print_binary (file, "logical_and", exp);
2995       break;
2996     case O_logical_or:
2997       print_binary (file, "logical_or", exp);
2998       break;
2999     case O_add:
3000       indent_level++;
3001       fprintf (file, "add\n%*s<", indent_level * 4, "");
3002       print_symbol_value_1 (file, exp->X_add_symbol);
3003       fprintf (file, ">\n%*s<", indent_level * 4, "");
3004       print_symbol_value_1 (file, exp->X_op_symbol);
3005       fprintf (file, ">");
3006       goto maybe_print_addnum;
3007     case O_subtract:
3008       indent_level++;
3009       fprintf (file, "subtract\n%*s<", indent_level * 4, "");
3010       print_symbol_value_1 (file, exp->X_add_symbol);
3011       fprintf (file, ">\n%*s<", indent_level * 4, "");
3012       print_symbol_value_1 (file, exp->X_op_symbol);
3013       fprintf (file, ">");
3014       goto maybe_print_addnum;
3015     default:
3016       fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
3017       break;
3018     }
3019   fflush (stdout);
3020 }
3021 
3022 void
print_expr(expressionS * exp)3023 print_expr (expressionS *exp)
3024 {
3025   print_expr_1 (stderr, exp);
3026   fprintf (stderr, "\n");
3027 }
3028 
3029 void
symbol_print_statistics(FILE * file)3030 symbol_print_statistics (FILE *file)
3031 {
3032   hash_print_statistics (file, "symbol table", sy_hash);
3033   hash_print_statistics (file, "mini local symbol table", local_hash);
3034   fprintf (file, "%lu mini local symbols created, %lu converted\n",
3035 	   local_symbol_count, local_symbol_conversion_count);
3036 }
3037 
3038 #ifdef OBJ_COMPLEX_RELC
3039 
3040 /* Convert given symbol to a new complex-relocation symbol name.  This
3041    may be a recursive function, since it might be called for non-leaf
3042    nodes (plain symbols) in the expression tree.  The caller owns the
3043    returning string, so should free it eventually.  Errors are
3044    indicated via as_bad and a NULL return value.  The given symbol
3045    is marked with sy_used_in_reloc.  */
3046 
3047 char *
symbol_relc_make_sym(symbolS * sym)3048 symbol_relc_make_sym (symbolS * sym)
3049 {
3050   char * terminal = NULL;
3051   const char * sname;
3052   char typetag;
3053   int sname_len;
3054 
3055   gas_assert (sym != NULL);
3056 
3057   /* Recurse to symbol_relc_make_expr if this symbol
3058      is defined as an expression or a plain value.  */
3059   if (   S_GET_SEGMENT (sym) == expr_section
3060       || S_GET_SEGMENT (sym) == absolute_section)
3061     return symbol_relc_make_expr (& sym->sy_value);
3062 
3063   /* This may be a "fake symbol" L0\001, referring to ".".
3064      Write out a special null symbol to refer to this position.  */
3065   if (! strcmp (S_GET_NAME (sym), FAKE_LABEL_NAME))
3066     return xstrdup (".");
3067 
3068   /* We hope this is a plain leaf symbol.  Construct the encoding
3069      as {S,s}II...:CCCCCCC....
3070      where 'S'/'s' means section symbol / plain symbol
3071      III is decimal for the symbol name length
3072      CCC is the symbol name itself.  */
3073   symbol_mark_used_in_reloc (sym);
3074 
3075   sname = S_GET_NAME (sym);
3076   sname_len = strlen (sname);
3077   typetag = symbol_section_p (sym) ? 'S' : 's';
3078 
3079   terminal = XNEWVEC (char, (1 /* S or s */
3080 			     + 8 /* sname_len in decimal */
3081 			     + 1 /* _ spacer */
3082 			     + sname_len /* name itself */
3083 			     + 1 /* \0 */ ));
3084 
3085   sprintf (terminal, "%c%d:%s", typetag, sname_len, sname);
3086   return terminal;
3087 }
3088 
3089 /* Convert given value to a new complex-relocation symbol name.  This
3090    is a non-recursive function, since it is be called for leaf nodes
3091    (plain values) in the expression tree.  The caller owns the
3092    returning string, so should free() it eventually.  No errors.  */
3093 
3094 char *
symbol_relc_make_value(offsetT val)3095 symbol_relc_make_value (offsetT val)
3096 {
3097   char * terminal = XNEWVEC (char, 28);  /* Enough for long long.  */
3098 
3099   terminal[0] = '#';
3100   bfd_sprintf_vma (stdoutput, terminal + 1, val);
3101   return terminal;
3102 }
3103 
3104 /* Convert given expression to a new complex-relocation symbol name.
3105    This is a recursive function, since it traverses the entire given
3106    expression tree.  The caller owns the returning string, so should
3107    free() it eventually.  Errors are indicated via as_bad() and a NULL
3108    return value.  */
3109 
3110 char *
symbol_relc_make_expr(expressionS * exp)3111 symbol_relc_make_expr (expressionS * exp)
3112 {
3113   const char * opstr = NULL; /* Operator prefix string.  */
3114   int    arity = 0;    /* Arity of this operator.  */
3115   char * operands[3];  /* Up to three operands.  */
3116   char * concat_string = NULL;
3117 
3118   operands[0] = operands[1] = operands[2] = NULL;
3119 
3120   gas_assert (exp != NULL);
3121 
3122   /* Match known operators -> fill in opstr, arity, operands[] and fall
3123      through to construct subexpression fragments; may instead return
3124      string directly for leaf nodes.  */
3125 
3126   /* See expr.h for the meaning of all these enums.  Many operators
3127      have an unnatural arity (X_add_number implicitly added).  The
3128      conversion logic expands them to explicit "+" subexpressions.   */
3129 
3130   switch (exp->X_op)
3131     {
3132     default:
3133       as_bad ("Unknown expression operator (enum %d)", exp->X_op);
3134       break;
3135 
3136       /* Leaf nodes.  */
3137     case O_constant:
3138       return symbol_relc_make_value (exp->X_add_number);
3139 
3140     case O_symbol:
3141       if (exp->X_add_number)
3142 	{
3143 	  arity = 2;
3144 	  opstr = "+";
3145 	  operands[0] = symbol_relc_make_sym (exp->X_add_symbol);
3146 	  operands[1] = symbol_relc_make_value (exp->X_add_number);
3147 	  break;
3148 	}
3149       else
3150 	return symbol_relc_make_sym (exp->X_add_symbol);
3151 
3152       /* Helper macros for nesting nodes.  */
3153 
3154 #define HANDLE_XADD_OPT1(str_) 						\
3155       if (exp->X_add_number)						\
3156         {								\
3157           arity = 2;							\
3158           opstr = "+:" str_;						\
3159           operands[0] = symbol_relc_make_sym (exp->X_add_symbol);	\
3160           operands[1] = symbol_relc_make_value (exp->X_add_number);	\
3161           break;							\
3162         }								\
3163       else								\
3164         {								\
3165           arity = 1;							\
3166           opstr = str_;							\
3167           operands[0] = symbol_relc_make_sym (exp->X_add_symbol);	\
3168         }								\
3169       break
3170 
3171 #define HANDLE_XADD_OPT2(str_) 						\
3172       if (exp->X_add_number)						\
3173         {								\
3174           arity = 3;							\
3175           opstr = "+:" str_;						\
3176           operands[0] = symbol_relc_make_sym (exp->X_add_symbol);	\
3177           operands[1] = symbol_relc_make_sym (exp->X_op_symbol);	\
3178           operands[2] = symbol_relc_make_value (exp->X_add_number);	\
3179         }								\
3180       else								\
3181         {								\
3182           arity = 2;							\
3183           opstr = str_;							\
3184           operands[0] = symbol_relc_make_sym (exp->X_add_symbol);	\
3185           operands[1] = symbol_relc_make_sym (exp->X_op_symbol);	\
3186         } 								\
3187       break
3188 
3189       /* Nesting nodes.  */
3190 
3191     case O_uminus:       	HANDLE_XADD_OPT1 ("0-");
3192     case O_bit_not:      	HANDLE_XADD_OPT1 ("~");
3193     case O_logical_not:  	HANDLE_XADD_OPT1 ("!");
3194     case O_multiply:     	HANDLE_XADD_OPT2 ("*");
3195     case O_divide:       	HANDLE_XADD_OPT2 ("/");
3196     case O_modulus:      	HANDLE_XADD_OPT2 ("%");
3197     case O_left_shift:   	HANDLE_XADD_OPT2 ("<<");
3198     case O_right_shift:  	HANDLE_XADD_OPT2 (">>");
3199     case O_bit_inclusive_or:	HANDLE_XADD_OPT2 ("|");
3200     case O_bit_exclusive_or:	HANDLE_XADD_OPT2 ("^");
3201     case O_bit_and:      	HANDLE_XADD_OPT2 ("&");
3202     case O_add:          	HANDLE_XADD_OPT2 ("+");
3203     case O_subtract:     	HANDLE_XADD_OPT2 ("-");
3204     case O_eq:           	HANDLE_XADD_OPT2 ("==");
3205     case O_ne:           	HANDLE_XADD_OPT2 ("!=");
3206     case O_lt:           	HANDLE_XADD_OPT2 ("<");
3207     case O_le:           	HANDLE_XADD_OPT2 ("<=");
3208     case O_ge:           	HANDLE_XADD_OPT2 (">=");
3209     case O_gt:           	HANDLE_XADD_OPT2 (">");
3210     case O_logical_and:  	HANDLE_XADD_OPT2 ("&&");
3211     case O_logical_or:   	HANDLE_XADD_OPT2 ("||");
3212     }
3213 
3214   /* Validate & reject early.  */
3215   if (arity >= 1 && ((operands[0] == NULL) || (strlen (operands[0]) == 0)))
3216     opstr = NULL;
3217   if (arity >= 2 && ((operands[1] == NULL) || (strlen (operands[1]) == 0)))
3218     opstr = NULL;
3219   if (arity >= 3 && ((operands[2] == NULL) || (strlen (operands[2]) == 0)))
3220     opstr = NULL;
3221 
3222   if (opstr == NULL)
3223     concat_string = NULL;
3224   else if (arity == 0)
3225     concat_string = xstrdup (opstr);
3226   else if (arity == 1)
3227     concat_string = concat (opstr, ":", operands[0], (char *) NULL);
3228   else if (arity == 2)
3229     concat_string = concat (opstr, ":", operands[0], ":", operands[1],
3230 			    (char *) NULL);
3231   else
3232     concat_string = concat (opstr, ":", operands[0], ":", operands[1], ":",
3233 			    operands[2], (char *) NULL);
3234 
3235   /* Free operand strings (not opstr).  */
3236   if (arity >= 1) xfree (operands[0]);
3237   if (arity >= 2) xfree (operands[1]);
3238   if (arity >= 3) xfree (operands[2]);
3239 
3240   return concat_string;
3241 }
3242 
3243 #endif
3244