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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [gas/] [symbols.c] - Blame information for rev 304

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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