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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gas/] [config/] [obj-elf.c] - Blame information for rev 160

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

Line No. Rev Author Line
1 16 khays
/* ELF object file format
2
   Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3
   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
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
10
   published by the Free Software Foundation; either version 3,
11
   or (at your option) any later version.
12
 
13
   GAS is distributed in the hope that it will be useful, but
14
   WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
16
   the 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 OBJ_HEADER "obj-elf.h"
24
#include "as.h"
25
#include "safe-ctype.h"
26
#include "subsegs.h"
27
#include "obstack.h"
28
#include "struc-symbol.h"
29
#include "dwarf2dbg.h"
30
 
31
#ifndef ECOFF_DEBUGGING
32
#define ECOFF_DEBUGGING 0
33
#else
34
#define NEED_ECOFF_DEBUG
35
#endif
36
 
37
#ifdef NEED_ECOFF_DEBUG
38
#include "ecoff.h"
39
#endif
40
 
41
#ifdef TC_ALPHA
42
#include "elf/alpha.h"
43
#endif
44
 
45
#ifdef TC_MIPS
46
#include "elf/mips.h"
47
#endif
48
 
49
#ifdef TC_PPC
50
#include "elf/ppc.h"
51
#endif
52
 
53
#ifdef TC_I370
54
#include "elf/i370.h"
55
#endif
56
 
57
#ifdef TC_I386
58
#include "elf/x86-64.h"
59
#endif
60
 
61
#ifdef TC_MEP
62
#include "elf/mep.h"
63
#endif
64
 
65
static void obj_elf_line (int);
66
static void obj_elf_size (int);
67
static void obj_elf_type (int);
68
static void obj_elf_ident (int);
69
static void obj_elf_weak (int);
70
static void obj_elf_local (int);
71
static void obj_elf_visibility (int);
72
static void obj_elf_symver (int);
73
static void obj_elf_subsection (int);
74
static void obj_elf_popsection (int);
75
static void obj_elf_tls_common (int);
76
static void obj_elf_lcomm (int);
77
static void obj_elf_struct (int);
78
 
79
static const pseudo_typeS elf_pseudo_table[] =
80
{
81
  {"comm", obj_elf_common, 0},
82
  {"common", obj_elf_common, 1},
83
  {"ident", obj_elf_ident, 0},
84
  {"lcomm", obj_elf_lcomm, 0},
85
  {"local", obj_elf_local, 0},
86
  {"previous", obj_elf_previous, 0},
87
  {"section", obj_elf_section, 0},
88
  {"section.s", obj_elf_section, 0},
89
  {"sect", obj_elf_section, 0},
90
  {"sect.s", obj_elf_section, 0},
91
  {"pushsection", obj_elf_section, 1},
92
  {"popsection", obj_elf_popsection, 0},
93
  {"size", obj_elf_size, 0},
94
  {"type", obj_elf_type, 0},
95
  {"version", obj_elf_version, 0},
96
  {"weak", obj_elf_weak, 0},
97
 
98
  /* These define symbol visibility.  */
99
  {"internal", obj_elf_visibility, STV_INTERNAL},
100
  {"hidden", obj_elf_visibility, STV_HIDDEN},
101
  {"protected", obj_elf_visibility, STV_PROTECTED},
102
 
103
  /* These are used for stabs-in-elf configurations.  */
104
  {"line", obj_elf_line, 0},
105
 
106
  /* This is a GNU extension to handle symbol versions.  */
107
  {"symver", obj_elf_symver, 0},
108
 
109
  /* A GNU extension to change subsection only.  */
110
  {"subsection", obj_elf_subsection, 0},
111
 
112
  /* These are GNU extensions to aid in garbage collecting C++ vtables.  */
113
  {"vtable_inherit", (void (*) (int)) &obj_elf_vtable_inherit, 0},
114
  {"vtable_entry", (void (*) (int)) &obj_elf_vtable_entry, 0},
115
 
116
  /* These are used for dwarf.  */
117
  {"2byte", cons, 2},
118
  {"4byte", cons, 4},
119
  {"8byte", cons, 8},
120
  /* These are used for dwarf2.  */
121
  { "file", (void (*) (int)) dwarf2_directive_file, 0 },
122
  { "loc",  dwarf2_directive_loc,  0 },
123
  { "loc_mark_labels", dwarf2_directive_loc_mark_labels, 0 },
124
 
125
  /* We need to trap the section changing calls to handle .previous.  */
126
  {"data", obj_elf_data, 0},
127
  {"offset", obj_elf_struct, 0},
128
  {"struct", obj_elf_struct, 0},
129
  {"text", obj_elf_text, 0},
130
 
131
  {"tls_common", obj_elf_tls_common, 0},
132
 
133
  /* End sentinel.  */
134
  {NULL, NULL, 0},
135
};
136
 
137
static const pseudo_typeS ecoff_debug_pseudo_table[] =
138
{
139
#ifdef NEED_ECOFF_DEBUG
140
  /* COFF style debugging information for ECOFF. .ln is not used; .loc
141
     is used instead.  */
142
  { "def",      ecoff_directive_def,    0 },
143
  { "dim",      ecoff_directive_dim,    0 },
144
  { "endef",    ecoff_directive_endef,  0 },
145
  { "file",     ecoff_directive_file,   0 },
146
  { "scl",      ecoff_directive_scl,    0 },
147
  { "tag",      ecoff_directive_tag,    0 },
148
  { "val",      ecoff_directive_val,    0 },
149
 
150
  /* COFF debugging requires pseudo-ops .size and .type, but ELF
151
     already has meanings for those.  We use .esize and .etype
152
     instead.  These are only generated by gcc anyhow.  */
153
  { "esize",    ecoff_directive_size,   0 },
154
  { "etype",    ecoff_directive_type,   0 },
155
 
156
  /* ECOFF specific debugging information.  */
157
  { "begin",    ecoff_directive_begin,  0 },
158
  { "bend",     ecoff_directive_bend,   0 },
159
  { "end",      ecoff_directive_end,    0 },
160
  { "ent",      ecoff_directive_ent,    0 },
161
  { "fmask",    ecoff_directive_fmask,  0 },
162
  { "frame",    ecoff_directive_frame,  0 },
163
  { "loc",      ecoff_directive_loc,    0 },
164
  { "mask",     ecoff_directive_mask,   0 },
165
 
166
  /* Other ECOFF directives.  */
167
  { "extern",   ecoff_directive_extern, 0 },
168
 
169
  /* These are used on Irix.  I don't know how to implement them.  */
170
  { "alias",    s_ignore,               0 },
171
  { "bgnb",     s_ignore,               0 },
172
  { "endb",     s_ignore,               0 },
173
  { "lab",      s_ignore,               0 },
174
  { "noalias",  s_ignore,               0 },
175
  { "verstamp", s_ignore,               0 },
176
  { "vreg",     s_ignore,               0 },
177
#endif
178
 
179
  {NULL, NULL, 0}                        /* end sentinel */
180
};
181
 
182
#undef NO_RELOC
183
#include "aout/aout64.h"
184
 
185
/* This is called when the assembler starts.  */
186
 
187
asection *elf_com_section_ptr;
188
 
189
void
190
elf_begin (void)
191
{
192
  asection *s;
193
 
194
  /* Add symbols for the known sections to the symbol table.  */
195
  s = bfd_get_section_by_name (stdoutput, TEXT_SECTION_NAME);
196
  symbol_table_insert (section_symbol (s));
197
  s = bfd_get_section_by_name (stdoutput, DATA_SECTION_NAME);
198
  symbol_table_insert (section_symbol (s));
199
  s = bfd_get_section_by_name (stdoutput, BSS_SECTION_NAME);
200
  symbol_table_insert (section_symbol (s));
201
  elf_com_section_ptr = bfd_com_section_ptr;
202
}
203
 
204
void
205
elf_pop_insert (void)
206
{
207
  pop_insert (elf_pseudo_table);
208
  if (ECOFF_DEBUGGING)
209
    pop_insert (ecoff_debug_pseudo_table);
210
}
211
 
212
static bfd_vma
213
elf_s_get_size (symbolS *sym)
214
{
215
  return S_GET_SIZE (sym);
216
}
217
 
218
static void
219
elf_s_set_size (symbolS *sym, bfd_vma sz)
220
{
221
  S_SET_SIZE (sym, sz);
222
}
223
 
224
static bfd_vma
225
elf_s_get_align (symbolS *sym)
226
{
227
  return S_GET_ALIGN (sym);
228
}
229
 
230
static void
231
elf_s_set_align (symbolS *sym, bfd_vma align)
232
{
233
  S_SET_ALIGN (sym, align);
234
}
235
 
236
int
237
elf_s_get_other (symbolS *sym)
238
{
239
  return elf_symbol (symbol_get_bfdsym (sym))->internal_elf_sym.st_other;
240
}
241
 
242
static void
243
elf_s_set_other (symbolS *sym, int other)
244
{
245
  S_SET_OTHER (sym, other);
246
}
247
 
248
static int
249
elf_sec_sym_ok_for_reloc (asection *sec)
250
{
251
  return obj_sec_sym_ok_for_reloc (sec);
252
}
253
 
254
void
255
elf_file_symbol (const char *s, int appfile)
256
{
257
  if (!appfile
258
      || symbol_rootP == NULL
259
      || symbol_rootP->bsym == NULL
260
      || (symbol_rootP->bsym->flags & BSF_FILE) == 0)
261
    {
262
      symbolS *sym;
263
      unsigned int name_length;
264
 
265
      sym = symbol_new (s, absolute_section, 0, NULL);
266
      symbol_set_frag (sym, &zero_address_frag);
267
 
268
      name_length = strlen (s);
269
      if (name_length > strlen (S_GET_NAME (sym)))
270
        {
271
          obstack_grow (&notes, s, name_length + 1);
272
          S_SET_NAME (sym, (const char *) obstack_finish (&notes));
273
        }
274
      else
275
        strcpy ((char *) S_GET_NAME (sym), s);
276
 
277
      symbol_get_bfdsym (sym)->flags |= BSF_FILE;
278
 
279
      if (symbol_rootP != sym)
280
        {
281
          symbol_remove (sym, &symbol_rootP, &symbol_lastP);
282
          symbol_insert (sym, symbol_rootP, &symbol_rootP, &symbol_lastP);
283
#ifdef DEBUG
284
          verify_symbol_chain (symbol_rootP, symbol_lastP);
285
#endif
286
        }
287
    }
288
 
289
#ifdef NEED_ECOFF_DEBUG
290
  ecoff_new_file (s, appfile);
291
#endif
292
}
293
 
294
/* Called from read.c:s_comm after we've parsed .comm symbol, size.
295
   Parse a possible alignment value.  */
296
 
297
symbolS *
298
elf_common_parse (int ignore ATTRIBUTE_UNUSED, symbolS *symbolP, addressT size)
299
{
300
  addressT align = 0;
301
  int is_local = symbol_get_obj (symbolP)->local;
302
 
303
  if (*input_line_pointer == ',')
304
    {
305
      char *save = input_line_pointer;
306
 
307
      input_line_pointer++;
308
      SKIP_WHITESPACE ();
309
 
310
      if (*input_line_pointer == '"')
311
        {
312
          /* For sparc.  Accept .common symbol, length, "bss"  */
313
          input_line_pointer++;
314
          /* Some use the dot, some don't.  */
315
          if (*input_line_pointer == '.')
316
            input_line_pointer++;
317
          /* Some say data, some say bss.  */
318
          if (strncmp (input_line_pointer, "bss\"", 4) == 0)
319
            input_line_pointer += 4;
320
          else if (strncmp (input_line_pointer, "data\"", 5) == 0)
321
            input_line_pointer += 5;
322
          else
323
            {
324
              char *p = input_line_pointer;
325
              char c;
326
 
327
              while (*--p != '"')
328
                ;
329
              while (!is_end_of_line[(unsigned char) *input_line_pointer])
330
                if (*input_line_pointer++ == '"')
331
                  break;
332
              c = *input_line_pointer;
333
              *input_line_pointer = '\0';
334
              as_bad (_("bad .common segment %s"), p);
335
              *input_line_pointer = c;
336
              ignore_rest_of_line ();
337
              return NULL;
338
            }
339
          /* ??? Don't ask me why these are always global.  */
340
          is_local = 0;
341
        }
342
      else
343
        {
344
          input_line_pointer = save;
345
          align = parse_align (is_local);
346
          if (align == (addressT) -1)
347
            return NULL;
348
        }
349
    }
350
 
351
  if (is_local)
352
    {
353
      bss_alloc (symbolP, size, align);
354
      S_CLEAR_EXTERNAL (symbolP);
355
    }
356
  else
357
    {
358
      S_SET_VALUE (symbolP, size);
359
      S_SET_ALIGN (symbolP, align);
360
      S_SET_EXTERNAL (symbolP);
361
      S_SET_SEGMENT (symbolP, elf_com_section_ptr);
362
    }
363
 
364
  symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
365
 
366
  return symbolP;
367
}
368
 
369
void
370
obj_elf_common (int is_common)
371
{
372
  if (flag_mri && is_common)
373
    s_mri_common (0);
374
  else
375
    s_comm_internal (0, elf_common_parse);
376
}
377
 
378
static void
379
obj_elf_tls_common (int ignore ATTRIBUTE_UNUSED)
380
{
381
  symbolS *symbolP = s_comm_internal (0, elf_common_parse);
382
 
383
  if (symbolP)
384
    symbol_get_bfdsym (symbolP)->flags |= BSF_THREAD_LOCAL;
385
}
386
 
387
static void
388
obj_elf_lcomm (int ignore ATTRIBUTE_UNUSED)
389
{
390
  symbolS *symbolP = s_comm_internal (0, s_lcomm_internal);
391
 
392
  if (symbolP)
393
    symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
394
}
395
 
396
static symbolS *
397
get_sym_from_input_line_and_check (void)
398
{
399
  char *name;
400
  char c;
401
  symbolS *sym;
402
 
403
  name = input_line_pointer;
404
  c = get_symbol_end ();
405
  sym = symbol_find_or_make (name);
406
  *input_line_pointer = c;
407
  SKIP_WHITESPACE ();
408
 
409
  /* There is no symbol name if input_line_pointer has not moved.  */
410
  if (name == input_line_pointer)
411
    as_bad (_("Missing symbol name in directive"));
412
  return sym;
413
}
414
 
415
static void
416
obj_elf_local (int ignore ATTRIBUTE_UNUSED)
417
{
418
  int c;
419
  symbolS *symbolP;
420
 
421
  do
422
    {
423
      symbolP = get_sym_from_input_line_and_check ();
424
      c = *input_line_pointer;
425
      S_CLEAR_EXTERNAL (symbolP);
426
      symbol_get_obj (symbolP)->local = 1;
427
      if (c == ',')
428
        {
429
          input_line_pointer++;
430
          SKIP_WHITESPACE ();
431
          if (*input_line_pointer == '\n')
432
            c = '\n';
433
        }
434
    }
435
  while (c == ',');
436
  demand_empty_rest_of_line ();
437
}
438
 
439
static void
440
obj_elf_weak (int ignore ATTRIBUTE_UNUSED)
441
{
442
  int c;
443
  symbolS *symbolP;
444
 
445
  do
446
    {
447
      symbolP = get_sym_from_input_line_and_check ();
448
      c = *input_line_pointer;
449
      S_SET_WEAK (symbolP);
450
      symbol_get_obj (symbolP)->local = 1;
451
      if (c == ',')
452
        {
453
          input_line_pointer++;
454
          SKIP_WHITESPACE ();
455
          if (*input_line_pointer == '\n')
456
            c = '\n';
457
        }
458
    }
459
  while (c == ',');
460
  demand_empty_rest_of_line ();
461
}
462
 
463
static void
464
obj_elf_visibility (int visibility)
465
{
466
  int c;
467
  symbolS *symbolP;
468
  asymbol *bfdsym;
469
  elf_symbol_type *elfsym;
470
 
471
  do
472
    {
473
      symbolP = get_sym_from_input_line_and_check ();
474
 
475
      bfdsym = symbol_get_bfdsym (symbolP);
476
      elfsym = elf_symbol_from (bfd_asymbol_bfd (bfdsym), bfdsym);
477
 
478
      gas_assert (elfsym);
479
 
480
      elfsym->internal_elf_sym.st_other &= ~3;
481
      elfsym->internal_elf_sym.st_other |= visibility;
482
 
483
      c = *input_line_pointer;
484
      if (c == ',')
485
        {
486
          input_line_pointer ++;
487
 
488
          SKIP_WHITESPACE ();
489
 
490
          if (*input_line_pointer == '\n')
491
            c = '\n';
492
        }
493
    }
494
  while (c == ',');
495
 
496
  demand_empty_rest_of_line ();
497
}
498
 
499
static segT previous_section;
500
static int previous_subsection;
501
 
502
struct section_stack
503
{
504
  struct section_stack *next;
505
  segT seg, prev_seg;
506
  int subseg, prev_subseg;
507
};
508
 
509
static struct section_stack *section_stack;
510
 
511
static bfd_boolean
512
get_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
513
{
514
  const char *gname = (const char *) inf;
515
  const char *group_name = elf_group_name (sec);
516
 
517
  return (group_name == gname
518
          || (group_name != NULL
519
              && gname != NULL
520
              && strcmp (group_name, gname) == 0));
521
}
522
 
523
/* Handle the .section pseudo-op.  This code supports two different
524
   syntaxes.
525
 
526
   The first is found on Solaris, and looks like
527
       .section ".sec1",#alloc,#execinstr,#write
528
   Here the names after '#' are the SHF_* flags to turn on for the
529
   section.  I'm not sure how it determines the SHT_* type (BFD
530
   doesn't really give us control over the type, anyhow).
531
 
532
   The second format is found on UnixWare, and probably most SVR4
533
   machines, and looks like
534
       .section .sec1,"a",@progbits
535
   The quoted string may contain any combination of a, w, x, and
536
   represents the SHF_* flags to turn on for the section.  The string
537
   beginning with '@' can be progbits or nobits.  There should be
538
   other possibilities, but I don't know what they are.  In any case,
539
   BFD doesn't really let us set the section type.  */
540
 
541
void
542
obj_elf_change_section (const char *name,
543
                        int type,
544
                        bfd_vma attr,
545
                        int entsize,
546
                        const char *group_name,
547
                        int linkonce,
548
                        int push)
549
{
550
  asection *old_sec;
551
  segT sec;
552
  flagword flags;
553
  const struct elf_backend_data *bed;
554
  const struct bfd_elf_special_section *ssect;
555
 
556
#ifdef md_flush_pending_output
557
  md_flush_pending_output ();
558
#endif
559
 
560
  /* Switch to the section, creating it if necessary.  */
561
  if (push)
562
    {
563
      struct section_stack *elt;
564
      elt = (struct section_stack *) xmalloc (sizeof (struct section_stack));
565
      elt->next = section_stack;
566
      elt->seg = now_seg;
567
      elt->prev_seg = previous_section;
568
      elt->subseg = now_subseg;
569
      elt->prev_subseg = previous_subsection;
570
      section_stack = elt;
571
    }
572
  previous_section = now_seg;
573
  previous_subsection = now_subseg;
574
 
575
  old_sec = bfd_get_section_by_name_if (stdoutput, name, get_section,
576
                                        (void *) group_name);
577
  if (old_sec)
578
    {
579
      sec = old_sec;
580
      subseg_set (sec, 0);
581
    }
582
  else
583
    sec = subseg_force_new (name, 0);
584
 
585
  bed = get_elf_backend_data (stdoutput);
586
  ssect = (*bed->get_sec_type_attr) (stdoutput, sec);
587
 
588
  if (ssect != NULL)
589
    {
590
      bfd_boolean override = FALSE;
591
 
592
      if (type == SHT_NULL)
593
        type = ssect->type;
594
      else if (type != ssect->type)
595
        {
596
          if (old_sec == NULL
597
              /* Some older versions of gcc will emit
598
 
599
                 .section .init_array,"aw",@progbits
600
 
601
                 for __attribute__ ((section (".init_array"))).
602
                 "@progbits" is incorrect.  Also for x86-64 large bss
603
                 sections, some older versions of gcc will emit
604
 
605
                 .section .lbss,"aw",@progbits
606
 
607
                 "@progbits" is incorrect.  */
608
#ifdef TC_I386
609
              && (bed->s->arch_size != 64
610
                  || !(ssect->attr & SHF_X86_64_LARGE))
611
#endif
612
              && ssect->type != SHT_INIT_ARRAY
613
              && ssect->type != SHT_FINI_ARRAY
614
              && ssect->type != SHT_PREINIT_ARRAY)
615
            {
616
              /* We allow to specify any type for a .note section.  */
617
              if (ssect->type != SHT_NOTE)
618
                as_warn (_("setting incorrect section type for %s"),
619
                         name);
620
            }
621
          else
622
            {
623
              as_warn (_("ignoring incorrect section type for %s"),
624
                       name);
625
              type = ssect->type;
626
            }
627
        }
628
 
629
      if (old_sec == NULL && (attr & ~ssect->attr) != 0)
630
        {
631
          /* As a GNU extension, we permit a .note section to be
632
             allocatable.  If the linker sees an allocatable .note
633
             section, it will create a PT_NOTE segment in the output
634
             file.  We also allow "x" for .note.GNU-stack.  */
635
          if (ssect->type == SHT_NOTE
636
              && (attr == SHF_ALLOC || attr == SHF_EXECINSTR))
637
            ;
638
          /* Allow different SHF_MERGE and SHF_STRINGS if we have
639
             something like .rodata.str.  */
640
          else if (ssect->suffix_length == -2
641
                   && name[ssect->prefix_length] == '.'
642
                   && (attr
643
                       & ~ssect->attr
644
                       & ~SHF_MERGE
645
                       & ~SHF_STRINGS) == 0)
646
            ;
647
          /* .interp, .strtab and .symtab can have SHF_ALLOC.  */
648
          else if (attr == SHF_ALLOC
649
                   && (strcmp (name, ".interp") == 0
650
                       || strcmp (name, ".strtab") == 0
651
                       || strcmp (name, ".symtab") == 0))
652
            override = TRUE;
653
          /* .note.GNU-stack can have SHF_EXECINSTR.  */
654
          else if (attr == SHF_EXECINSTR
655
                   && strcmp (name, ".note.GNU-stack") == 0)
656
            override = TRUE;
657
#ifdef TC_ALPHA
658
          /* A section on Alpha may have SHF_ALPHA_GPREL.  */
659
          else if ((attr & ~ssect->attr) == SHF_ALPHA_GPREL)
660
            override = TRUE;
661
#endif
662
          else
663
            {
664
              if (group_name == NULL)
665
                as_warn (_("setting incorrect section attributes for %s"),
666
                         name);
667
              override = TRUE;
668
            }
669
        }
670
      if (!override && old_sec == NULL)
671
        attr |= ssect->attr;
672
    }
673
 
674
  /* Convert ELF type and flags to BFD flags.  */
675
  flags = (SEC_RELOC
676
           | ((attr & SHF_WRITE) ? 0 : SEC_READONLY)
677
           | ((attr & SHF_ALLOC) ? SEC_ALLOC : 0)
678
           | (((attr & SHF_ALLOC) && type != SHT_NOBITS) ? SEC_LOAD : 0)
679
           | ((attr & SHF_EXECINSTR) ? SEC_CODE : 0)
680
           | ((attr & SHF_MERGE) ? SEC_MERGE : 0)
681
           | ((attr & SHF_STRINGS) ? SEC_STRINGS : 0)
682
           | ((attr & SHF_EXCLUDE) ? SEC_EXCLUDE: 0)
683
           | ((attr & SHF_TLS) ? SEC_THREAD_LOCAL : 0));
684
#ifdef md_elf_section_flags
685
  flags = md_elf_section_flags (flags, attr, type);
686
#endif
687
 
688
  if (linkonce)
689
    flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
690
 
691
  if (old_sec == NULL)
692
    {
693
      symbolS *secsym;
694
 
695
      if (type == SHT_NULL)
696
        type = bfd_elf_get_default_section_type (flags);
697
      elf_section_type (sec) = type;
698
      elf_section_flags (sec) = attr;
699
 
700
      /* Prevent SEC_HAS_CONTENTS from being inadvertently set.  */
701
      if (type == SHT_NOBITS)
702
        seg_info (sec)->bss = 1;
703
 
704
      bfd_set_section_flags (stdoutput, sec, flags);
705
      if (flags & SEC_MERGE)
706
        sec->entsize = entsize;
707
      elf_group_name (sec) = group_name;
708
 
709
      /* Add a symbol for this section to the symbol table.  */
710
      secsym = symbol_find (name);
711
      if (secsym != NULL)
712
        symbol_set_bfdsym (secsym, sec->symbol);
713
      else
714
        symbol_table_insert (section_symbol (sec));
715
    }
716
  else
717
    {
718
      if (type != SHT_NULL
719
          && (unsigned) type != elf_section_type (old_sec))
720
        as_warn (_("ignoring changed section type for %s"), name);
721
 
722
      if (attr != 0)
723
        {
724
          /* If section attributes are specified the second time we see a
725
             particular section, then check that they are the same as we
726
             saw the first time.  */
727
          if (((old_sec->flags ^ flags)
728
               & (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
729
                  | SEC_EXCLUDE | SEC_SORT_ENTRIES | SEC_MERGE | SEC_STRINGS
730
                  | SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
731
                  | SEC_THREAD_LOCAL)))
732
            as_warn (_("ignoring changed section attributes for %s"), name);
733
          if ((flags & SEC_MERGE) && old_sec->entsize != (unsigned) entsize)
734
            as_warn (_("ignoring changed section entity size for %s"), name);
735
        }
736
    }
737
 
738
#ifdef md_elf_section_change_hook
739
  md_elf_section_change_hook ();
740
#endif
741
}
742
 
743
static bfd_vma
744
obj_elf_parse_section_letters (char *str, size_t len, bfd_boolean *clone)
745
{
746
  bfd_vma attr = 0;
747
  *clone = FALSE;
748
 
749
  while (len > 0)
750
    {
751
      switch (*str)
752
        {
753
        case 'a':
754
          attr |= SHF_ALLOC;
755
          break;
756
        case 'e':
757
          attr |= SHF_EXCLUDE;
758
          break;
759
        case 'w':
760
          attr |= SHF_WRITE;
761
          break;
762
        case 'x':
763
          attr |= SHF_EXECINSTR;
764
          break;
765
        case 'M':
766
          attr |= SHF_MERGE;
767
          break;
768
        case 'S':
769
          attr |= SHF_STRINGS;
770
          break;
771
        case 'G':
772
          attr |= SHF_GROUP;
773
          break;
774
        case 'T':
775
          attr |= SHF_TLS;
776
          break;
777
        case '?':
778
          *clone = TRUE;
779
          break;
780
        /* Compatibility.  */
781
        case 'm':
782
          if (*(str - 1) == 'a')
783
            {
784
              attr |= SHF_MERGE;
785
              if (len > 1 && str[1] == 's')
786
                {
787
                  attr |= SHF_STRINGS;
788
                  str++, len--;
789
                }
790
              break;
791
            }
792
        default:
793
          {
794
            char *bad_msg = _("unrecognized .section attribute: want a,e,w,x,M,S,G,T");
795
#ifdef md_elf_section_letter
796
            bfd_vma md_attr = md_elf_section_letter (*str, &bad_msg);
797
            if (md_attr != (bfd_vma) -1)
798
              attr |= md_attr;
799
            else
800
#endif
801
              as_fatal ("%s", bad_msg);
802
          }
803
          break;
804
        }
805
      str++, len--;
806
    }
807
 
808
  return attr;
809
}
810
 
811
static int
812
obj_elf_section_type (char *str, size_t len, bfd_boolean warn)
813
{
814
  if (len == 8 && strncmp (str, "progbits", 8) == 0)
815
    return SHT_PROGBITS;
816
  if (len == 6 && strncmp (str, "nobits", 6) == 0)
817
    return SHT_NOBITS;
818
  if (len == 4 && strncmp (str, "note", 4) == 0)
819
    return SHT_NOTE;
820
  if (len == 10 && strncmp (str, "init_array", 10) == 0)
821
    return SHT_INIT_ARRAY;
822
  if (len == 10 && strncmp (str, "fini_array", 10) == 0)
823
    return SHT_FINI_ARRAY;
824
  if (len == 13 && strncmp (str, "preinit_array", 13) == 0)
825
    return SHT_PREINIT_ARRAY;
826
 
827
#ifdef md_elf_section_type
828
  {
829
    int md_type = md_elf_section_type (str, len);
830
    if (md_type >= 0)
831
      return md_type;
832
  }
833
#endif
834
 
835
  if (warn)
836
    as_warn (_("unrecognized section type"));
837
  return 0;
838
}
839
 
840
static bfd_vma
841
obj_elf_section_word (char *str, size_t len, int *type)
842
{
843
  int ret;
844
 
845
  if (len == 5 && strncmp (str, "write", 5) == 0)
846
    return SHF_WRITE;
847
  if (len == 5 && strncmp (str, "alloc", 5) == 0)
848
    return SHF_ALLOC;
849
  if (len == 9 && strncmp (str, "execinstr", 9) == 0)
850
    return SHF_EXECINSTR;
851
  if (len == 7 && strncmp (str, "exclude", 7) == 0)
852
    return SHF_EXCLUDE;
853
  if (len == 3 && strncmp (str, "tls", 3) == 0)
854
    return SHF_TLS;
855
 
856
#ifdef md_elf_section_word
857
  {
858
    bfd_vma md_attr = md_elf_section_word (str, len);
859
    if (md_attr > 0)
860
      return md_attr;
861
  }
862
#endif
863
 
864
  ret = obj_elf_section_type (str, len, FALSE);
865
  if (ret != 0)
866
    *type = ret;
867
  else
868
    as_warn (_("unrecognized section attribute"));
869
 
870
  return 0;
871
}
872
 
873
/* Get name of section.  */
874
char *
875
obj_elf_section_name (void)
876
{
877
  char *name;
878
 
879
  SKIP_WHITESPACE ();
880
  if (*input_line_pointer == '"')
881
    {
882
      int dummy;
883
 
884
      name = demand_copy_C_string (&dummy);
885
      if (name == NULL)
886
        {
887
          ignore_rest_of_line ();
888
          return NULL;
889
        }
890
    }
891
  else
892
    {
893
      char *end = input_line_pointer;
894
 
895
      while (0 == strchr ("\n\t,; ", *end))
896
        end++;
897
      if (end == input_line_pointer)
898
        {
899
          as_bad (_("missing name"));
900
          ignore_rest_of_line ();
901
          return NULL;
902
        }
903
 
904
      name = (char *) xmalloc (end - input_line_pointer + 1);
905
      memcpy (name, input_line_pointer, end - input_line_pointer);
906
      name[end - input_line_pointer] = '\0';
907
#ifdef tc_canonicalize_section_name
908
      name = tc_canonicalize_section_name (name);
909
#endif
910
      input_line_pointer = end;
911
    }
912
  SKIP_WHITESPACE ();
913
  return name;
914
}
915
 
916
void
917
obj_elf_section (int push)
918
{
919
  char *name, *group_name, *beg;
920
  int type, dummy;
921
  bfd_vma attr;
922
  int entsize;
923
  int linkonce;
924
  subsegT new_subsection = -1;
925
 
926
#ifndef TC_I370
927
  if (flag_mri)
928
    {
929
      char mri_type;
930
 
931
#ifdef md_flush_pending_output
932
      md_flush_pending_output ();
933
#endif
934
 
935
      previous_section = now_seg;
936
      previous_subsection = now_subseg;
937
 
938
      s_mri_sect (&mri_type);
939
 
940
#ifdef md_elf_section_change_hook
941
      md_elf_section_change_hook ();
942
#endif
943
 
944
      return;
945
    }
946
#endif /* ! defined (TC_I370) */
947
 
948
  name = obj_elf_section_name ();
949
  if (name == NULL)
950
    return;
951
  type = SHT_NULL;
952
  attr = 0;
953
  group_name = NULL;
954
  entsize = 0;
955
  linkonce = 0;
956
 
957
  if (*input_line_pointer == ',')
958
    {
959
      /* Skip the comma.  */
960
      ++input_line_pointer;
961
      SKIP_WHITESPACE ();
962
 
963
      if (push && ISDIGIT (*input_line_pointer))
964
        {
965
          /* .pushsection has an optional subsection.  */
966
          new_subsection = (subsegT) get_absolute_expression ();
967
 
968
          SKIP_WHITESPACE ();
969
 
970
          /* Stop if we don't see a comma.  */
971
          if (*input_line_pointer != ',')
972
            goto done;
973
 
974
          /* Skip the comma.  */
975
          ++input_line_pointer;
976
          SKIP_WHITESPACE ();
977
        }
978
 
979
      if (*input_line_pointer == '"')
980
        {
981
          bfd_boolean clone;
982
 
983
          beg = demand_copy_C_string (&dummy);
984
          if (beg == NULL)
985
            {
986
              ignore_rest_of_line ();
987
              return;
988
            }
989
          attr |= obj_elf_parse_section_letters (beg, strlen (beg), &clone);
990
 
991
          SKIP_WHITESPACE ();
992
          if (*input_line_pointer == ',')
993
            {
994
              char c;
995
              char *save = input_line_pointer;
996
 
997
              ++input_line_pointer;
998
              SKIP_WHITESPACE ();
999
              c = *input_line_pointer;
1000
              if (c == '"')
1001
                {
1002
                  beg = demand_copy_C_string (&dummy);
1003
                  if (beg == NULL)
1004
                    {
1005
                      ignore_rest_of_line ();
1006
                      return;
1007
                    }
1008
                  type = obj_elf_section_type (beg, strlen (beg), TRUE);
1009
                }
1010
              else if (c == '@' || c == '%')
1011
                {
1012
                  beg = ++input_line_pointer;
1013
                  c = get_symbol_end ();
1014
                  *input_line_pointer = c;
1015
                  type = obj_elf_section_type (beg, input_line_pointer - beg, TRUE);
1016
                }
1017
              else
1018
                input_line_pointer = save;
1019
            }
1020
 
1021
          SKIP_WHITESPACE ();
1022
          if ((attr & SHF_MERGE) != 0 && *input_line_pointer == ',')
1023
            {
1024
              ++input_line_pointer;
1025
              SKIP_WHITESPACE ();
1026
              entsize = get_absolute_expression ();
1027
              SKIP_WHITESPACE ();
1028
              if (entsize < 0)
1029
                {
1030
                  as_warn (_("invalid merge entity size"));
1031
                  attr &= ~SHF_MERGE;
1032
                  entsize = 0;
1033
                }
1034
            }
1035
          else if ((attr & SHF_MERGE) != 0)
1036
            {
1037
              as_warn (_("entity size for SHF_MERGE not specified"));
1038
              attr &= ~SHF_MERGE;
1039
            }
1040
 
1041
          if ((attr & SHF_GROUP) != 0 && clone)
1042
            {
1043
              as_warn (_("? section flag ignored with G present"));
1044
              clone = FALSE;
1045
            }
1046
          if ((attr & SHF_GROUP) != 0 && *input_line_pointer == ',')
1047
            {
1048
              ++input_line_pointer;
1049
              group_name = obj_elf_section_name ();
1050
              if (group_name == NULL)
1051
                attr &= ~SHF_GROUP;
1052
              else if (strncmp (input_line_pointer, ",comdat", 7) == 0)
1053
                {
1054
                  input_line_pointer += 7;
1055
                  linkonce = 1;
1056
                }
1057
              else if (strncmp (name, ".gnu.linkonce", 13) == 0)
1058
                linkonce = 1;
1059
            }
1060
          else if ((attr & SHF_GROUP) != 0)
1061
            {
1062
              as_warn (_("group name for SHF_GROUP not specified"));
1063
              attr &= ~SHF_GROUP;
1064
            }
1065
 
1066
          if (clone)
1067
            {
1068
              const char *now_group = elf_group_name (now_seg);
1069
              if (now_group != NULL)
1070
                {
1071
                  group_name = xstrdup (now_group);
1072
                  linkonce = (now_seg->flags & SEC_LINK_ONCE) != 0;
1073
                }
1074
            }
1075
        }
1076
      else
1077
        {
1078
          do
1079
            {
1080
              char c;
1081
 
1082
              SKIP_WHITESPACE ();
1083
              if (*input_line_pointer != '#')
1084
                {
1085
                  as_bad (_("character following name is not '#'"));
1086
                  ignore_rest_of_line ();
1087
                  return;
1088
                }
1089
              beg = ++input_line_pointer;
1090
              c = get_symbol_end ();
1091
              *input_line_pointer = c;
1092
 
1093
              attr |= obj_elf_section_word (beg, input_line_pointer - beg, & type);
1094
 
1095
              SKIP_WHITESPACE ();
1096
            }
1097
          while (*input_line_pointer++ == ',');
1098
          --input_line_pointer;
1099
        }
1100
    }
1101
 
1102
done:
1103
  demand_empty_rest_of_line ();
1104
 
1105
  obj_elf_change_section (name, type, attr, entsize, group_name, linkonce, push);
1106
 
1107
  if (push && new_subsection != -1)
1108
    subseg_set (now_seg, new_subsection);
1109
}
1110
 
1111
/* Change to the .data section.  */
1112
 
1113
void
1114
obj_elf_data (int i)
1115
{
1116
#ifdef md_flush_pending_output
1117
  md_flush_pending_output ();
1118
#endif
1119
 
1120
  previous_section = now_seg;
1121
  previous_subsection = now_subseg;
1122
  s_data (i);
1123
 
1124
#ifdef md_elf_section_change_hook
1125
  md_elf_section_change_hook ();
1126
#endif
1127
}
1128
 
1129
/* Change to the .text section.  */
1130
 
1131
void
1132
obj_elf_text (int i)
1133
{
1134
#ifdef md_flush_pending_output
1135
  md_flush_pending_output ();
1136
#endif
1137
 
1138
  previous_section = now_seg;
1139
  previous_subsection = now_subseg;
1140
  s_text (i);
1141
 
1142
#ifdef md_elf_section_change_hook
1143
  md_elf_section_change_hook ();
1144
#endif
1145
}
1146
 
1147
/* Change to the *ABS* section.  */
1148
 
1149
void
1150
obj_elf_struct (int i)
1151
{
1152
#ifdef md_flush_pending_output
1153
  md_flush_pending_output ();
1154
#endif
1155
 
1156
  previous_section = now_seg;
1157
  previous_subsection = now_subseg;
1158
  s_struct (i);
1159
 
1160
#ifdef md_elf_section_change_hook
1161
  md_elf_section_change_hook ();
1162
#endif
1163
}
1164
 
1165
static void
1166
obj_elf_subsection (int ignore ATTRIBUTE_UNUSED)
1167
{
1168
  int temp;
1169
 
1170
#ifdef md_flush_pending_output
1171
  md_flush_pending_output ();
1172
#endif
1173
 
1174
  previous_section = now_seg;
1175
  previous_subsection = now_subseg;
1176
 
1177
  temp = get_absolute_expression ();
1178
  subseg_set (now_seg, (subsegT) temp);
1179
  demand_empty_rest_of_line ();
1180
 
1181
#ifdef md_elf_section_change_hook
1182
  md_elf_section_change_hook ();
1183
#endif
1184
}
1185
 
1186
/* This can be called from the processor backends if they change
1187
   sections.  */
1188
 
1189
void
1190
obj_elf_section_change_hook (void)
1191
{
1192
  previous_section = now_seg;
1193
  previous_subsection = now_subseg;
1194
}
1195
 
1196
void
1197
obj_elf_previous (int ignore ATTRIBUTE_UNUSED)
1198
{
1199
  segT new_section;
1200
  int new_subsection;
1201
 
1202
  if (previous_section == 0)
1203
    {
1204
      as_warn (_(".previous without corresponding .section; ignored"));
1205
      return;
1206
    }
1207
 
1208
#ifdef md_flush_pending_output
1209
  md_flush_pending_output ();
1210
#endif
1211
 
1212
  new_section = previous_section;
1213
  new_subsection = previous_subsection;
1214
  previous_section = now_seg;
1215
  previous_subsection = now_subseg;
1216
  subseg_set (new_section, new_subsection);
1217
 
1218
#ifdef md_elf_section_change_hook
1219
  md_elf_section_change_hook ();
1220
#endif
1221
}
1222
 
1223
static void
1224
obj_elf_popsection (int xxx ATTRIBUTE_UNUSED)
1225
{
1226
  struct section_stack *top = section_stack;
1227
 
1228
  if (top == NULL)
1229
    {
1230
      as_warn (_(".popsection without corresponding .pushsection; ignored"));
1231
      return;
1232
    }
1233
 
1234
#ifdef md_flush_pending_output
1235
  md_flush_pending_output ();
1236
#endif
1237
 
1238
  section_stack = top->next;
1239
  previous_section = top->prev_seg;
1240
  previous_subsection = top->prev_subseg;
1241
  subseg_set (top->seg, top->subseg);
1242
  free (top);
1243
 
1244
#ifdef md_elf_section_change_hook
1245
  md_elf_section_change_hook ();
1246
#endif
1247
}
1248
 
1249
static void
1250
obj_elf_line (int ignore ATTRIBUTE_UNUSED)
1251
{
1252
  /* Assume delimiter is part of expression.  BSD4.2 as fails with
1253
     delightful bug, so we are not being incompatible here.  */
1254
  new_logical_line (NULL, get_absolute_expression ());
1255
  demand_empty_rest_of_line ();
1256
}
1257
 
1258
/* This handles the .symver pseudo-op, which is used to specify a
1259
   symbol version.  The syntax is ``.symver NAME,SYMVERNAME''.
1260
   SYMVERNAME may contain ELF_VER_CHR ('@') characters.  This
1261
   pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1262
   with the same value as the symbol NAME.  */
1263
 
1264
static void
1265
obj_elf_symver (int ignore ATTRIBUTE_UNUSED)
1266
{
1267
  char *name;
1268
  char c;
1269
  char old_lexat;
1270
  symbolS *sym;
1271
 
1272
  sym = get_sym_from_input_line_and_check ();
1273
 
1274
  if (*input_line_pointer != ',')
1275
    {
1276
      as_bad (_("expected comma after name in .symver"));
1277
      ignore_rest_of_line ();
1278
      return;
1279
    }
1280
 
1281
  ++input_line_pointer;
1282
  SKIP_WHITESPACE ();
1283
  name = input_line_pointer;
1284
 
1285
  /* Temporarily include '@' in symbol names.  */
1286
  old_lexat = lex_type[(unsigned char) '@'];
1287
  lex_type[(unsigned char) '@'] |= LEX_NAME;
1288
  c = get_symbol_end ();
1289
  lex_type[(unsigned char) '@'] = old_lexat;
1290
 
1291
  if (symbol_get_obj (sym)->versioned_name == NULL)
1292
    {
1293
      symbol_get_obj (sym)->versioned_name = xstrdup (name);
1294
 
1295
      *input_line_pointer = c;
1296
 
1297
      if (strchr (symbol_get_obj (sym)->versioned_name,
1298
                  ELF_VER_CHR) == NULL)
1299
        {
1300
          as_bad (_("missing version name in `%s' for symbol `%s'"),
1301
                  symbol_get_obj (sym)->versioned_name,
1302
                  S_GET_NAME (sym));
1303
          ignore_rest_of_line ();
1304
          return;
1305
        }
1306
    }
1307
  else
1308
    {
1309
      if (strcmp (symbol_get_obj (sym)->versioned_name, name))
1310
        {
1311
          as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1312
                  name, symbol_get_obj (sym)->versioned_name,
1313
                  S_GET_NAME (sym));
1314
          ignore_rest_of_line ();
1315
          return;
1316
        }
1317
 
1318
      *input_line_pointer = c;
1319
    }
1320
 
1321
  demand_empty_rest_of_line ();
1322
}
1323
 
1324
/* This handles the .vtable_inherit pseudo-op, which is used to indicate
1325
   to the linker the hierarchy in which a particular table resides.  The
1326
   syntax is ".vtable_inherit CHILDNAME, PARENTNAME".  */
1327
 
1328
struct fix *
1329
obj_elf_vtable_inherit (int ignore ATTRIBUTE_UNUSED)
1330
{
1331
  char *cname, *pname;
1332
  symbolS *csym, *psym;
1333
  char c, bad = 0;
1334
 
1335
  if (*input_line_pointer == '#')
1336
    ++input_line_pointer;
1337
 
1338
  cname = input_line_pointer;
1339
  c = get_symbol_end ();
1340
  csym = symbol_find (cname);
1341
 
1342
  /* GCFIXME: should check that we don't have two .vtable_inherits for
1343
     the same child symbol.  Also, we can currently only do this if the
1344
     child symbol is already exists and is placed in a fragment.  */
1345
 
1346
  if (csym == NULL || symbol_get_frag (csym) == NULL)
1347
    {
1348
      as_bad (_("expected `%s' to have already been set for .vtable_inherit"),
1349
              cname);
1350
      bad = 1;
1351
    }
1352
 
1353
  *input_line_pointer = c;
1354
 
1355
  SKIP_WHITESPACE ();
1356
  if (*input_line_pointer != ',')
1357
    {
1358
      as_bad (_("expected comma after name in .vtable_inherit"));
1359
      ignore_rest_of_line ();
1360
      return NULL;
1361
    }
1362
 
1363
  ++input_line_pointer;
1364
  SKIP_WHITESPACE ();
1365
 
1366
  if (*input_line_pointer == '#')
1367
    ++input_line_pointer;
1368
 
1369
  if (input_line_pointer[0] == '0'
1370
      && (input_line_pointer[1] == '\0'
1371
          || ISSPACE (input_line_pointer[1])))
1372
    {
1373
      psym = section_symbol (absolute_section);
1374
      ++input_line_pointer;
1375
    }
1376
  else
1377
    {
1378
      pname = input_line_pointer;
1379
      c = get_symbol_end ();
1380
      psym = symbol_find_or_make (pname);
1381
      *input_line_pointer = c;
1382
    }
1383
 
1384
  demand_empty_rest_of_line ();
1385
 
1386
  if (bad)
1387
    return NULL;
1388
 
1389
  gas_assert (symbol_get_value_expression (csym)->X_op == O_constant);
1390
  return fix_new (symbol_get_frag (csym),
1391
                  symbol_get_value_expression (csym)->X_add_number,
1392
                  0, psym, 0, 0, BFD_RELOC_VTABLE_INHERIT);
1393
}
1394
 
1395
/* This handles the .vtable_entry pseudo-op, which is used to indicate
1396
   to the linker that a vtable slot was used.  The syntax is
1397
   ".vtable_entry tablename, offset".  */
1398
 
1399
struct fix *
1400
obj_elf_vtable_entry (int ignore ATTRIBUTE_UNUSED)
1401
{
1402
  symbolS *sym;
1403
  offsetT offset;
1404
 
1405
  if (*input_line_pointer == '#')
1406
    ++input_line_pointer;
1407
 
1408
  sym = get_sym_from_input_line_and_check ();
1409
  if (*input_line_pointer != ',')
1410
    {
1411
      as_bad (_("expected comma after name in .vtable_entry"));
1412
      ignore_rest_of_line ();
1413
      return NULL;
1414
    }
1415
 
1416
  ++input_line_pointer;
1417
  if (*input_line_pointer == '#')
1418
    ++input_line_pointer;
1419
 
1420
  offset = get_absolute_expression ();
1421
 
1422
  demand_empty_rest_of_line ();
1423
 
1424
  return fix_new (frag_now, frag_now_fix (), 0, sym, offset, 0,
1425
                  BFD_RELOC_VTABLE_ENTRY);
1426
}
1427
 
1428
void
1429
elf_obj_read_begin_hook (void)
1430
{
1431
#ifdef NEED_ECOFF_DEBUG
1432
  if (ECOFF_DEBUGGING)
1433
    ecoff_read_begin_hook ();
1434
#endif
1435
}
1436
 
1437
void
1438
elf_obj_symbol_new_hook (symbolS *symbolP)
1439
{
1440
  struct elf_obj_sy *sy_obj;
1441
 
1442
  sy_obj = symbol_get_obj (symbolP);
1443
  sy_obj->size = NULL;
1444
  sy_obj->versioned_name = NULL;
1445
 
1446
#ifdef NEED_ECOFF_DEBUG
1447
  if (ECOFF_DEBUGGING)
1448
    ecoff_symbol_new_hook (symbolP);
1449
#endif
1450
}
1451
 
1452
/* When setting one symbol equal to another, by default we probably
1453
   want them to have the same "size", whatever it means in the current
1454
   context.  */
1455
 
1456
void
1457
elf_copy_symbol_attributes (symbolS *dest, symbolS *src)
1458
{
1459
  struct elf_obj_sy *srcelf = symbol_get_obj (src);
1460
  struct elf_obj_sy *destelf = symbol_get_obj (dest);
1461
  if (srcelf->size)
1462
    {
1463
      if (destelf->size == NULL)
1464
        destelf->size = (expressionS *) xmalloc (sizeof (expressionS));
1465
      *destelf->size = *srcelf->size;
1466
    }
1467
  else
1468
    {
1469
      if (destelf->size != NULL)
1470
        free (destelf->size);
1471
      destelf->size = NULL;
1472
    }
1473
  S_SET_SIZE (dest, S_GET_SIZE (src));
1474
  /* Don't copy visibility.  */
1475
  S_SET_OTHER (dest, (ELF_ST_VISIBILITY (S_GET_OTHER (dest))
1476
                      | (S_GET_OTHER (src) & ~ELF_ST_VISIBILITY (-1))));
1477
}
1478
 
1479
void
1480
obj_elf_version (int ignore ATTRIBUTE_UNUSED)
1481
{
1482
  char *name;
1483
  unsigned int c;
1484
  char *p;
1485
  asection *seg = now_seg;
1486
  subsegT subseg = now_subseg;
1487
  Elf_Internal_Note i_note;
1488
  Elf_External_Note e_note;
1489
  asection *note_secp = NULL;
1490
 
1491
  SKIP_WHITESPACE ();
1492
  if (*input_line_pointer == '\"')
1493
    {
1494
      unsigned int len;
1495
 
1496
      ++input_line_pointer;     /* -> 1st char of string.  */
1497
      name = input_line_pointer;
1498
 
1499
      while (is_a_char (c = next_char_of_string ()))
1500
        ;
1501
      c = *input_line_pointer;
1502
      *input_line_pointer = '\0';
1503
      *(input_line_pointer - 1) = '\0';
1504
      *input_line_pointer = c;
1505
 
1506
      /* Create the .note section.  */
1507
      note_secp = subseg_new (".note", 0);
1508
      bfd_set_section_flags (stdoutput,
1509
                             note_secp,
1510
                             SEC_HAS_CONTENTS | SEC_READONLY);
1511
 
1512
      /* Process the version string.  */
1513
      len = strlen (name) + 1;
1514
 
1515
      /* PR 3456: Although the name field is padded out to an 4-byte
1516
         boundary, the namesz field should not be adjusted.  */
1517
      i_note.namesz = len;
1518
      i_note.descsz = 0; /* No description.  */
1519
      i_note.type = NT_VERSION;
1520
      p = frag_more (sizeof (e_note.namesz));
1521
      md_number_to_chars (p, i_note.namesz, sizeof (e_note.namesz));
1522
      p = frag_more (sizeof (e_note.descsz));
1523
      md_number_to_chars (p, i_note.descsz, sizeof (e_note.descsz));
1524
      p = frag_more (sizeof (e_note.type));
1525
      md_number_to_chars (p, i_note.type, sizeof (e_note.type));
1526
      p = frag_more (len);
1527
      memcpy (p, name, len);
1528
 
1529
      frag_align (2, 0, 0);
1530
 
1531
      subseg_set (seg, subseg);
1532
    }
1533
  else
1534
    as_bad (_("expected quoted string"));
1535
 
1536
  demand_empty_rest_of_line ();
1537
}
1538
 
1539
static void
1540
obj_elf_size (int ignore ATTRIBUTE_UNUSED)
1541
{
1542
  char *name = input_line_pointer;
1543
  char c = get_symbol_end ();
1544
  char *p;
1545
  expressionS exp;
1546
  symbolS *sym;
1547
 
1548
  p = input_line_pointer;
1549
  *p = c;
1550
  SKIP_WHITESPACE ();
1551
  if (*input_line_pointer != ',')
1552
    {
1553
      *p = 0;
1554
      as_bad (_("expected comma after name `%s' in .size directive"), name);
1555
      *p = c;
1556
      ignore_rest_of_line ();
1557
      return;
1558
    }
1559
  input_line_pointer++;
1560
  expression (&exp);
1561
  if (exp.X_op == O_absent)
1562
    {
1563
      as_bad (_("missing expression in .size directive"));
1564
      exp.X_op = O_constant;
1565
      exp.X_add_number = 0;
1566
    }
1567
  *p = 0;
1568
  sym = symbol_find_or_make (name);
1569
  *p = c;
1570
  if (exp.X_op == O_constant)
1571
    {
1572
      S_SET_SIZE (sym, exp.X_add_number);
1573
      if (symbol_get_obj (sym)->size)
1574
        {
1575
          xfree (symbol_get_obj (sym)->size);
1576
          symbol_get_obj (sym)->size = NULL;
1577
        }
1578
    }
1579
  else
1580
    {
1581
      symbol_get_obj (sym)->size =
1582
          (expressionS *) xmalloc (sizeof (expressionS));
1583
      *symbol_get_obj (sym)->size = exp;
1584
    }
1585
  demand_empty_rest_of_line ();
1586
}
1587
 
1588
/* Handle the ELF .type pseudo-op.  This sets the type of a symbol.
1589
   There are six syntaxes:
1590
 
1591
   The first (used on Solaris) is
1592
       .type SYM,#function
1593
   The second (used on UnixWare) is
1594
       .type SYM,@function
1595
   The third (reportedly to be used on Irix 6.0) is
1596
       .type SYM STT_FUNC
1597
   The fourth (used on NetBSD/Arm and Linux/ARM) is
1598
       .type SYM,%function
1599
   The fifth (used on SVR4/860) is
1600
       .type SYM,"function"
1601
   The sixth (emitted by recent SunPRO under Solaris) is
1602
       .type SYM,[0-9]
1603
   where the integer is the STT_* value.
1604
   */
1605
 
1606
static char *
1607
obj_elf_type_name (char *cp)
1608
{
1609
  char *p;
1610
 
1611
  p = input_line_pointer;
1612
  if (*input_line_pointer >= '0'
1613
      && *input_line_pointer <= '9')
1614
    {
1615
      while (*input_line_pointer >= '0'
1616
             && *input_line_pointer <= '9')
1617
        ++input_line_pointer;
1618
      *cp = *input_line_pointer;
1619
      *input_line_pointer = '\0';
1620
    }
1621
  else
1622
    *cp = get_symbol_end ();
1623
 
1624
  return p;
1625
}
1626
 
1627
static void
1628
obj_elf_type (int ignore ATTRIBUTE_UNUSED)
1629
{
1630
  char c;
1631
  int type;
1632
  const char *type_name;
1633
  symbolS *sym;
1634
  elf_symbol_type *elfsym;
1635
 
1636
  sym = get_sym_from_input_line_and_check ();
1637
  c = *input_line_pointer;
1638
  elfsym = (elf_symbol_type *) symbol_get_bfdsym (sym);
1639
 
1640
  if (*input_line_pointer == ',')
1641
    ++input_line_pointer;
1642
 
1643
  SKIP_WHITESPACE ();
1644
  if (   *input_line_pointer == '#'
1645
      || *input_line_pointer == '@'
1646
      || *input_line_pointer == '"'
1647
      || *input_line_pointer == '%')
1648
    ++input_line_pointer;
1649
 
1650
  type_name = obj_elf_type_name (& c);
1651
 
1652
  type = 0;
1653
  if (strcmp (type_name, "function") == 0
1654
      || strcmp (type_name, "2") == 0
1655
      || strcmp (type_name, "STT_FUNC") == 0)
1656
    type = BSF_FUNCTION;
1657
  else if (strcmp (type_name, "object") == 0
1658
           || strcmp (type_name, "1") == 0
1659
           || strcmp (type_name, "STT_OBJECT") == 0)
1660
    type = BSF_OBJECT;
1661
  else if (strcmp (type_name, "tls_object") == 0
1662
           || strcmp (type_name, "6") == 0
1663
           || strcmp (type_name, "STT_TLS") == 0)
1664
    type = BSF_OBJECT | BSF_THREAD_LOCAL;
1665
  else if (strcmp (type_name, "notype") == 0
1666
           || strcmp (type_name, "0") == 0
1667
           || strcmp (type_name, "STT_NOTYPE") == 0)
1668
    ;
1669
  else if (strcmp (type_name, "common") == 0
1670
           || strcmp (type_name, "5") == 0
1671
           || strcmp (type_name, "STT_COMMON") == 0)
1672
    {
1673
      type = BSF_OBJECT;
1674
 
1675
      if (! S_IS_COMMON (sym))
1676
        {
1677
          if (S_IS_VOLATILE (sym))
1678
            {
1679
              sym = symbol_clone (sym, 1);
1680
              S_SET_SEGMENT (sym, bfd_com_section_ptr);
1681
              S_SET_VALUE (sym, 0);
1682
              S_SET_EXTERNAL (sym);
1683
              symbol_set_frag (sym, &zero_address_frag);
1684
              S_CLEAR_VOLATILE (sym);
1685
            }
1686
          else if (S_IS_DEFINED (sym) || symbol_equated_p (sym))
1687
            as_bad (_("symbol '%s' is already defined"), S_GET_NAME (sym));
1688
          else
1689
            {
1690
              /* FIXME: Is it safe to just change the section ?  */
1691
              S_SET_SEGMENT (sym, bfd_com_section_ptr);
1692
              S_SET_VALUE (sym, 0);
1693
              S_SET_EXTERNAL (sym);
1694
            }
1695
        }
1696
    }
1697
  else if (strcmp (type_name, "gnu_indirect_function") == 0
1698
           || strcmp (type_name, "10") == 0
1699
           || strcmp (type_name, "STT_GNU_IFUNC") == 0)
1700
    {
1701
      const struct elf_backend_data *bed;
1702
 
1703
      bed = get_elf_backend_data (stdoutput);
1704 160 khays
      if (!(bed->elf_osabi == ELFOSABI_GNU
1705
            /* GNU is still using the default value 0.  */
1706 16 khays
            || bed->elf_osabi == ELFOSABI_NONE))
1707
        as_bad (_("symbol type \"%s\" is supported only by GNU targets"),
1708
                type_name);
1709
      type = BSF_FUNCTION | BSF_GNU_INDIRECT_FUNCTION;
1710
    }
1711
  else if (strcmp (type_name, "gnu_unique_object") == 0)
1712
    {
1713
      struct elf_backend_data *bed;
1714
 
1715
      bed = (struct elf_backend_data *) get_elf_backend_data (stdoutput);
1716 160 khays
      if (!(bed->elf_osabi == ELFOSABI_GNU
1717
            /* GNU is still using the default value 0.  */
1718 16 khays
            || bed->elf_osabi == ELFOSABI_NONE))
1719
        as_bad (_("symbol type \"%s\" is supported only by GNU targets"),
1720
                type_name);
1721
      type = BSF_OBJECT | BSF_GNU_UNIQUE;
1722 160 khays
      /* PR 10549: Always set OSABI field to GNU for objects containing unique symbols.  */
1723
      bed->elf_osabi = ELFOSABI_GNU;
1724 16 khays
    }
1725
#ifdef md_elf_symbol_type
1726
  else if ((type = md_elf_symbol_type (type_name, sym, elfsym)) != -1)
1727
    ;
1728
#endif
1729
  else
1730
    as_bad (_("unrecognized symbol type \"%s\""), type_name);
1731
 
1732
  *input_line_pointer = c;
1733
 
1734
  if (*input_line_pointer == '"')
1735
    ++input_line_pointer;
1736
 
1737
  elfsym->symbol.flags |= type;
1738
 
1739
  demand_empty_rest_of_line ();
1740
}
1741
 
1742
static void
1743
obj_elf_ident (int ignore ATTRIBUTE_UNUSED)
1744
{
1745
  static segT comment_section;
1746
  segT old_section = now_seg;
1747
  int old_subsection = now_subseg;
1748
 
1749
#ifdef md_flush_pending_output
1750
  md_flush_pending_output ();
1751
#endif
1752
 
1753
  if (!comment_section)
1754
    {
1755
      char *p;
1756
      comment_section = subseg_new (".comment", 0);
1757
      bfd_set_section_flags (stdoutput, comment_section,
1758
                             SEC_READONLY | SEC_HAS_CONTENTS
1759
                             | SEC_MERGE | SEC_STRINGS);
1760
      comment_section->entsize = 1;
1761
#ifdef md_elf_section_change_hook
1762
      md_elf_section_change_hook ();
1763
#endif
1764
      p = frag_more (1);
1765
      *p = 0;
1766
    }
1767
  else
1768
    subseg_set (comment_section, 0);
1769
  stringer (8 + 1);
1770
  subseg_set (old_section, old_subsection);
1771
}
1772
 
1773
#ifdef INIT_STAB_SECTION
1774
 
1775
/* The first entry in a .stabs section is special.  */
1776
 
1777
void
1778
obj_elf_init_stab_section (segT seg)
1779
{
1780
  char *file;
1781
  char *p;
1782
  char *stabstr_name;
1783
  unsigned int stroff;
1784
 
1785
  /* Force the section to align to a longword boundary.  Without this,
1786
     UnixWare ar crashes.  */
1787
  bfd_set_section_alignment (stdoutput, seg, 2);
1788
 
1789
  /* Make space for this first symbol.  */
1790
  p = frag_more (12);
1791
  /* Zero it out.  */
1792
  memset (p, 0, 12);
1793
  as_where (&file, NULL);
1794
  stabstr_name = (char *) xmalloc (strlen (segment_name (seg)) + 4);
1795
  strcpy (stabstr_name, segment_name (seg));
1796
  strcat (stabstr_name, "str");
1797
  stroff = get_stab_string_offset (file, stabstr_name);
1798
  know (stroff == 1 || (stroff == 0 && file[0] == '\0'));
1799
  md_number_to_chars (p, stroff, 4);
1800
  seg_info (seg)->stabu.p = p;
1801
}
1802
 
1803
#endif
1804
 
1805
/* Fill in the counts in the first entry in a .stabs section.  */
1806
 
1807
static void
1808
adjust_stab_sections (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1809
{
1810
  char *name;
1811
  asection *strsec;
1812
  char *p;
1813
  int strsz, nsyms;
1814
 
1815
  if (strncmp (".stab", sec->name, 5))
1816
    return;
1817
  if (!strcmp ("str", sec->name + strlen (sec->name) - 3))
1818
    return;
1819
 
1820
  name = (char *) alloca (strlen (sec->name) + 4);
1821
  strcpy (name, sec->name);
1822
  strcat (name, "str");
1823
  strsec = bfd_get_section_by_name (abfd, name);
1824
  if (strsec)
1825
    strsz = bfd_section_size (abfd, strsec);
1826
  else
1827
    strsz = 0;
1828
  nsyms = bfd_section_size (abfd, sec) / 12 - 1;
1829
 
1830
  p = seg_info (sec)->stabu.p;
1831
  gas_assert (p != 0);
1832
 
1833
  bfd_h_put_16 (abfd, nsyms, p + 6);
1834
  bfd_h_put_32 (abfd, strsz, p + 8);
1835
}
1836
 
1837
#ifdef NEED_ECOFF_DEBUG
1838
 
1839
/* This function is called by the ECOFF code.  It is supposed to
1840
   record the external symbol information so that the backend can
1841
   write it out correctly.  The ELF backend doesn't actually handle
1842
   this at the moment, so we do it ourselves.  We save the information
1843
   in the symbol.  */
1844
 
1845
#ifdef OBJ_MAYBE_ELF
1846
static
1847
#endif
1848
void
1849
elf_ecoff_set_ext (symbolS *sym, struct ecoff_extr *ext)
1850
{
1851
  symbol_get_bfdsym (sym)->udata.p = ext;
1852
}
1853
 
1854
/* This function is called by bfd_ecoff_debug_externals.  It is
1855
   supposed to *EXT to the external symbol information, and return
1856
   whether the symbol should be used at all.  */
1857
 
1858
static bfd_boolean
1859
elf_get_extr (asymbol *sym, EXTR *ext)
1860
{
1861
  if (sym->udata.p == NULL)
1862
    return FALSE;
1863
  *ext = *(EXTR *) sym->udata.p;
1864
  return TRUE;
1865
}
1866
 
1867
/* This function is called by bfd_ecoff_debug_externals.  It has
1868
   nothing to do for ELF.  */
1869
 
1870
static void
1871
elf_set_index (asymbol *sym ATTRIBUTE_UNUSED,
1872
               bfd_size_type indx ATTRIBUTE_UNUSED)
1873
{
1874
}
1875
 
1876
#endif /* NEED_ECOFF_DEBUG */
1877
 
1878
void
1879
elf_frob_symbol (symbolS *symp, int *puntp)
1880
{
1881
  struct elf_obj_sy *sy_obj;
1882
  expressionS *size;
1883
 
1884
#ifdef NEED_ECOFF_DEBUG
1885
  if (ECOFF_DEBUGGING)
1886
    ecoff_frob_symbol (symp);
1887
#endif
1888
 
1889
  sy_obj = symbol_get_obj (symp);
1890
 
1891
  size = sy_obj->size;
1892
  if (size != NULL)
1893
    {
1894
      if (resolve_expression (size)
1895
          && size->X_op == O_constant)
1896
        S_SET_SIZE (symp, size->X_add_number);
1897
      else
1898
        {
1899
          if (flag_size_check == size_check_error)
1900
            as_bad (_(".size expression for %s "
1901
                      "does not evaluate to a constant"), S_GET_NAME (symp));
1902
          else
1903
            as_warn (_(".size expression for %s "
1904
                       "does not evaluate to a constant"), S_GET_NAME (symp));
1905
        }
1906
      free (sy_obj->size);
1907
      sy_obj->size = NULL;
1908
    }
1909
 
1910
  if (sy_obj->versioned_name != NULL)
1911
    {
1912
      char *p;
1913
 
1914
      p = strchr (sy_obj->versioned_name, ELF_VER_CHR);
1915
      know (p != NULL);
1916
 
1917
      /* This symbol was given a new name with the .symver directive.
1918
 
1919
         If this is an external reference, just rename the symbol to
1920
         include the version string.  This will make the relocs be
1921
         against the correct versioned symbol.
1922
 
1923
         If this is a definition, add an alias.  FIXME: Using an alias
1924
         will permit the debugging information to refer to the right
1925
         symbol.  However, it's not clear whether it is the best
1926
         approach.  */
1927
 
1928
      if (! S_IS_DEFINED (symp))
1929
        {
1930
          /* Verify that the name isn't using the @@ syntax--this is
1931
             reserved for definitions of the default version to link
1932
             against.  */
1933
          if (p[1] == ELF_VER_CHR)
1934
            {
1935
              as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1936
                      sy_obj->versioned_name);
1937
              *puntp = TRUE;
1938
            }
1939
          S_SET_NAME (symp, sy_obj->versioned_name);
1940
        }
1941
      else
1942
        {
1943
          if (p[1] == ELF_VER_CHR && p[2] == ELF_VER_CHR)
1944
            {
1945
              size_t l;
1946
 
1947
              /* The @@@ syntax is a special case. It renames the
1948
                 symbol name to versioned_name with one `@' removed.  */
1949
              l = strlen (&p[3]) + 1;
1950
              memmove (&p[2], &p[3], l);
1951
              S_SET_NAME (symp, sy_obj->versioned_name);
1952
            }
1953
          else
1954
            {
1955
              symbolS *symp2;
1956
 
1957
              /* FIXME: Creating a new symbol here is risky.  We're
1958
                 in the final loop over the symbol table.  We can
1959
                 get away with it only because the symbol goes to
1960
                 the end of the list, where the loop will still see
1961
                 it.  It would probably be better to do this in
1962
                 obj_frob_file_before_adjust.  */
1963
 
1964
              symp2 = symbol_find_or_make (sy_obj->versioned_name);
1965
 
1966
              /* Now we act as though we saw symp2 = sym.  */
1967
 
1968
              S_SET_SEGMENT (symp2, S_GET_SEGMENT (symp));
1969
 
1970
              /* Subtracting out the frag address here is a hack
1971
                 because we are in the middle of the final loop.  */
1972
              S_SET_VALUE (symp2,
1973
                           (S_GET_VALUE (symp)
1974
                            - symbol_get_frag (symp)->fr_address));
1975
 
1976
              symbol_set_frag (symp2, symbol_get_frag (symp));
1977
 
1978
              /* This will copy over the size information.  */
1979
              copy_symbol_attributes (symp2, symp);
1980
 
1981
              S_SET_OTHER (symp2, S_GET_OTHER (symp));
1982
 
1983
              if (S_IS_WEAK (symp))
1984
                S_SET_WEAK (symp2);
1985
 
1986
              if (S_IS_EXTERNAL (symp))
1987
                S_SET_EXTERNAL (symp2);
1988
            }
1989
        }
1990
    }
1991
 
1992
  /* Double check weak symbols.  */
1993
  if (S_IS_WEAK (symp))
1994
    {
1995
      if (S_IS_COMMON (symp))
1996
        as_bad (_("symbol `%s' can not be both weak and common"),
1997
                S_GET_NAME (symp));
1998
    }
1999
 
2000
#ifdef TC_MIPS
2001
  /* The Irix 5 and 6 assemblers set the type of any common symbol and
2002
     any undefined non-function symbol to STT_OBJECT.  We try to be
2003
     compatible, since newer Irix 5 and 6 linkers care.  However, we
2004
     only set undefined symbols to be STT_OBJECT if we are on Irix,
2005
     because that is the only time gcc will generate the necessary
2006
     .global directives to mark functions.  */
2007
 
2008
  if (S_IS_COMMON (symp))
2009
    symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
2010
 
2011
  if (strstr (TARGET_OS, "irix") != NULL
2012
      && ! S_IS_DEFINED (symp)
2013
      && (symbol_get_bfdsym (symp)->flags & BSF_FUNCTION) == 0)
2014
    symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
2015
#endif
2016
}
2017
 
2018
struct group_list
2019
{
2020
  asection **head;              /* Section lists.  */
2021
  unsigned int *elt_count;      /* Number of sections in each list.  */
2022
  unsigned int num_group;       /* Number of lists.  */
2023
  struct hash_control *indexes; /* Maps group name to index in head array.  */
2024
};
2025
 
2026
/* Called via bfd_map_over_sections.  If SEC is a member of a group,
2027
   add it to a list of sections belonging to the group.  INF is a
2028
   pointer to a struct group_list, which is where we store the head of
2029
   each list.  */
2030
 
2031
static void
2032
build_group_lists (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
2033
{
2034
  struct group_list *list = (struct group_list *) inf;
2035
  const char *group_name = elf_group_name (sec);
2036
  unsigned int i;
2037
  unsigned int *elem_idx;
2038
  unsigned int *idx_ptr;
2039
 
2040
  if (group_name == NULL)
2041
    return;
2042
 
2043
  /* If this group already has a list, add the section to the head of
2044
     the list.  */
2045
  elem_idx = (unsigned int *) hash_find (list->indexes, group_name);
2046
  if (elem_idx != NULL)
2047
    {
2048
      elf_next_in_group (sec) = list->head[*elem_idx];
2049
      list->head[*elem_idx] = sec;
2050
      list->elt_count[*elem_idx] += 1;
2051
      return;
2052
    }
2053
 
2054
  /* New group.  Make the arrays bigger in chunks to minimize calls to
2055
     realloc.  */
2056
  i = list->num_group;
2057
  if ((i & 127) == 0)
2058
    {
2059
      unsigned int newsize = i + 128;
2060
      list->head = (asection **) xrealloc (list->head,
2061
                                           newsize * sizeof (*list->head));
2062
      list->elt_count = (unsigned int *)
2063
          xrealloc (list->elt_count, newsize * sizeof (*list->elt_count));
2064
    }
2065
  list->head[i] = sec;
2066
  list->elt_count[i] = 1;
2067
  list->num_group += 1;
2068
 
2069
  /* Add index to hash.  */
2070
  idx_ptr = (unsigned int *) xmalloc (sizeof (unsigned int));
2071
  *idx_ptr = i;
2072
  hash_insert (list->indexes, group_name, idx_ptr);
2073
}
2074
 
2075
static void free_section_idx (const char *key ATTRIBUTE_UNUSED, void *val)
2076
{
2077
  free ((unsigned int *) val);
2078
}
2079
 
2080
void
2081
elf_adjust_symtab (void)
2082
{
2083
  struct group_list list;
2084
  unsigned int i;
2085
 
2086
  /* Go find section groups.  */
2087
  list.num_group = 0;
2088
  list.head = NULL;
2089
  list.elt_count = NULL;
2090
  list.indexes = hash_new ();
2091
  bfd_map_over_sections (stdoutput, build_group_lists, &list);
2092
 
2093
  /* Make the SHT_GROUP sections that describe each section group.  We
2094
     can't set up the section contents here yet, because elf section
2095
     indices have yet to be calculated.  elf.c:set_group_contents does
2096
     the rest of the work.  */
2097
 for (i = 0; i < list.num_group; i++)
2098
    {
2099
      const char *group_name = elf_group_name (list.head[i]);
2100
      const char *sec_name;
2101
      asection *s;
2102
      flagword flags;
2103
      struct symbol *sy;
2104
      bfd_size_type size;
2105
 
2106
      flags = SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_GROUP;
2107
      for (s = list.head[i]; s != NULL; s = elf_next_in_group (s))
2108
        if ((s->flags ^ flags) & SEC_LINK_ONCE)
2109
          {
2110
            flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2111
            if (s != list.head[i])
2112
              {
2113
                as_warn (_("assuming all members of group `%s' are COMDAT"),
2114
                         group_name);
2115
                break;
2116
              }
2117
          }
2118
 
2119
      sec_name = ".group";
2120
      s = subseg_force_new (sec_name, 0);
2121
      if (s == NULL
2122
          || !bfd_set_section_flags (stdoutput, s, flags)
2123
          || !bfd_set_section_alignment (stdoutput, s, 2))
2124
        {
2125
          as_fatal (_("can't create group: %s"),
2126
                    bfd_errmsg (bfd_get_error ()));
2127
        }
2128
      elf_section_type (s) = SHT_GROUP;
2129
 
2130
      /* Pass a pointer to the first section in this group.  */
2131
      elf_next_in_group (s) = list.head[i];
2132
      /* Make sure that the signature symbol for the group has the
2133
         name of the group.  */
2134
      sy = symbol_find_exact (group_name);
2135
      if (!sy
2136
          || (sy != symbol_lastP
2137
              && (sy->sy_next == NULL
2138
                  || sy->sy_next->sy_previous != sy)))
2139
        {
2140
          /* Create the symbol now.  */
2141
          sy = symbol_new (group_name, now_seg, (valueT) 0, frag_now);
2142
#ifdef TE_SOLARIS
2143
          /* Before Solaris 11 build 154, Sun ld rejects local group
2144
             signature symbols, so make them weak hidden instead.  */
2145
          symbol_get_bfdsym (sy)->flags |= BSF_WEAK;
2146
          S_SET_OTHER (sy, STV_HIDDEN);
2147
#else
2148
          symbol_get_obj (sy)->local = 1;
2149
#endif
2150
          symbol_table_insert (sy);
2151
        }
2152
      elf_group_id (s) = symbol_get_bfdsym (sy);
2153
 
2154
      size = 4 * (list.elt_count[i] + 1);
2155
      bfd_set_section_size (stdoutput, s, size);
2156
      s->contents = (unsigned char *) frag_more (size);
2157
      frag_now->fr_fix = frag_now_fix_octets ();
2158
      frag_wane (frag_now);
2159
    }
2160
 
2161
  /* Cleanup hash.  */
2162
  hash_traverse (list.indexes, free_section_idx);
2163
  hash_die (list.indexes);
2164
}
2165
 
2166
void
2167
elf_frob_file (void)
2168
{
2169
  bfd_map_over_sections (stdoutput, adjust_stab_sections, NULL);
2170
 
2171
#ifdef elf_tc_final_processing
2172
  elf_tc_final_processing ();
2173
#endif
2174
}
2175
 
2176
/* It removes any unneeded versioned symbols from the symbol table.  */
2177
 
2178
void
2179
elf_frob_file_before_adjust (void)
2180
{
2181
  if (symbol_rootP)
2182
    {
2183
      symbolS *symp;
2184
 
2185
      for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2186
        if (!S_IS_DEFINED (symp))
2187
          {
2188
            if (symbol_get_obj (symp)->versioned_name)
2189
              {
2190
                char *p;
2191
 
2192
                /* The @@@ syntax is a special case. If the symbol is
2193
                   not defined, 2 `@'s will be removed from the
2194
                   versioned_name.  */
2195
 
2196
                p = strchr (symbol_get_obj (symp)->versioned_name,
2197
                            ELF_VER_CHR);
2198
                know (p != NULL);
2199
                if (p[1] == ELF_VER_CHR && p[2] == ELF_VER_CHR)
2200
                  {
2201
                    size_t l = strlen (&p[3]) + 1;
2202
                    memmove (&p[1], &p[3], l);
2203
                  }
2204
                if (symbol_used_p (symp) == 0
2205
                    && symbol_used_in_reloc_p (symp) == 0)
2206
                  symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2207
              }
2208
 
2209
            /* If there was .weak foo, but foo was neither defined nor
2210
               used anywhere, remove it.  */
2211
 
2212
            else if (S_IS_WEAK (symp)
2213
                     && symbol_used_p (symp) == 0
2214
                     && symbol_used_in_reloc_p (symp) == 0)
2215
              symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2216
          }
2217
    }
2218
}
2219
 
2220
/* It is required that we let write_relocs have the opportunity to
2221
   optimize away fixups before output has begun, since it is possible
2222
   to eliminate all fixups for a section and thus we never should
2223
   have generated the relocation section.  */
2224
 
2225
void
2226
elf_frob_file_after_relocs (void)
2227
{
2228
#ifdef NEED_ECOFF_DEBUG
2229
  if (ECOFF_DEBUGGING)
2230
    /* Generate the ECOFF debugging information.  */
2231
    {
2232
      const struct ecoff_debug_swap *debug_swap;
2233
      struct ecoff_debug_info debug;
2234
      char *buf;
2235
      asection *sec;
2236
 
2237
      debug_swap
2238
        = get_elf_backend_data (stdoutput)->elf_backend_ecoff_debug_swap;
2239
      know (debug_swap != NULL);
2240
      ecoff_build_debug (&debug.symbolic_header, &buf, debug_swap);
2241
 
2242
      /* Set up the pointers in debug.  */
2243
#define SET(ptr, offset, type) \
2244
    debug.ptr = (type) (buf + debug.symbolic_header.offset)
2245
 
2246
      SET (line, cbLineOffset, unsigned char *);
2247
      SET (external_dnr, cbDnOffset, void *);
2248
      SET (external_pdr, cbPdOffset, void *);
2249
      SET (external_sym, cbSymOffset, void *);
2250
      SET (external_opt, cbOptOffset, void *);
2251
      SET (external_aux, cbAuxOffset, union aux_ext *);
2252
      SET (ss, cbSsOffset, char *);
2253
      SET (external_fdr, cbFdOffset, void *);
2254
      SET (external_rfd, cbRfdOffset, void *);
2255
      /* ssext and external_ext are set up just below.  */
2256
 
2257
#undef SET
2258
 
2259
      /* Set up the external symbols.  */
2260
      debug.ssext = debug.ssext_end = NULL;
2261
      debug.external_ext = debug.external_ext_end = NULL;
2262
      if (! bfd_ecoff_debug_externals (stdoutput, &debug, debug_swap, TRUE,
2263
                                       elf_get_extr, elf_set_index))
2264
        as_fatal (_("failed to set up debugging information: %s"),
2265
                  bfd_errmsg (bfd_get_error ()));
2266
 
2267
      sec = bfd_get_section_by_name (stdoutput, ".mdebug");
2268
      gas_assert (sec != NULL);
2269
 
2270
      know (!stdoutput->output_has_begun);
2271
 
2272
      /* We set the size of the section, call bfd_set_section_contents
2273
         to force the ELF backend to allocate a file position, and then
2274
         write out the data.  FIXME: Is this really the best way to do
2275
         this?  */
2276
      bfd_set_section_size
2277
        (stdoutput, sec, bfd_ecoff_debug_size (stdoutput, &debug, debug_swap));
2278
 
2279
      /* Pass BUF to bfd_set_section_contents because this will
2280
         eventually become a call to fwrite, and ISO C prohibits
2281
         passing a NULL pointer to a stdio function even if the
2282
         pointer will not be used.  */
2283
      if (! bfd_set_section_contents (stdoutput, sec, buf, 0, 0))
2284
        as_fatal (_("can't start writing .mdebug section: %s"),
2285
                  bfd_errmsg (bfd_get_error ()));
2286
 
2287
      know (stdoutput->output_has_begun);
2288
      know (sec->filepos != 0);
2289
 
2290
      if (! bfd_ecoff_write_debug (stdoutput, &debug, debug_swap,
2291
                                   sec->filepos))
2292
        as_fatal (_("could not write .mdebug section: %s"),
2293
                  bfd_errmsg (bfd_get_error ()));
2294
    }
2295
#endif /* NEED_ECOFF_DEBUG */
2296
}
2297
 
2298
#ifdef SCO_ELF
2299
 
2300
/* Heavily plagiarized from obj_elf_version.  The idea is to emit the
2301
   SCO specific identifier in the .notes section to satisfy the SCO
2302
   linker.
2303
 
2304
   This looks more complicated than it really is.  As opposed to the
2305
   "obvious" solution, this should handle the cross dev cases
2306
   correctly.  (i.e, hosting on a 64 bit big endian processor, but
2307
   generating SCO Elf code) Efficiency isn't a concern, as there
2308
   should be exactly one of these sections per object module.
2309
 
2310
   SCO OpenServer 5 identifies it's ELF modules with a standard ELF
2311
   .note section.
2312
 
2313
   int_32 namesz  = 4 ;  Name size
2314
   int_32 descsz  = 12 ; Descriptive information
2315
   int_32 type    = 1 ;
2316
   char   name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
2317
   int_32 version = (major ver # << 16)  | version of tools ;
2318
   int_32 source  = (tool_id << 16 ) | 1 ;
2319
   int_32 info    = 0 ;    These are set by the SCO tools, but we
2320
                           don't know enough about the source
2321
                           environment to set them.  SCO ld currently
2322
                           ignores them, and recommends we set them
2323
                           to zero.  */
2324
 
2325
#define SCO_MAJOR_VERSION 0x1
2326
#define SCO_MINOR_VERSION 0x1
2327
 
2328
void
2329
sco_id (void)
2330
{
2331
 
2332
  char *name;
2333
  unsigned int c;
2334
  char ch;
2335
  char *p;
2336
  asection *seg = now_seg;
2337
  subsegT subseg = now_subseg;
2338
  Elf_Internal_Note i_note;
2339
  Elf_External_Note e_note;
2340
  asection *note_secp = NULL;
2341
  int i, len;
2342
 
2343
  /* create the .note section */
2344
 
2345
  note_secp = subseg_new (".note", 0);
2346
  bfd_set_section_flags (stdoutput,
2347
                         note_secp,
2348
                         SEC_HAS_CONTENTS | SEC_READONLY);
2349
 
2350
  /* process the version string */
2351
 
2352
  i_note.namesz = 4;
2353
  i_note.descsz = 12;           /* 12 descriptive bytes */
2354
  i_note.type = NT_VERSION;     /* Contains a version string */
2355
 
2356
  p = frag_more (sizeof (i_note.namesz));
2357
  md_number_to_chars (p, i_note.namesz, 4);
2358
 
2359
  p = frag_more (sizeof (i_note.descsz));
2360
  md_number_to_chars (p, i_note.descsz, 4);
2361
 
2362
  p = frag_more (sizeof (i_note.type));
2363
  md_number_to_chars (p, i_note.type, 4);
2364
 
2365
  p = frag_more (4);
2366
  strcpy (p, "SCO");
2367
 
2368
  /* Note: this is the version number of the ELF we're representing */
2369
  p = frag_more (4);
2370
  md_number_to_chars (p, (SCO_MAJOR_VERSION << 16) | (SCO_MINOR_VERSION), 4);
2371
 
2372
  /* Here, we pick a magic number for ourselves (yes, I "registered"
2373
     it with SCO.  The bottom bit shows that we are compat with the
2374
     SCO ABI.  */
2375
  p = frag_more (4);
2376
  md_number_to_chars (p, 0x4c520000 | 0x0001, 4);
2377
 
2378
  /* If we knew (or cared) what the source language options were, we'd
2379
     fill them in here.  SCO has given us permission to ignore these
2380
     and just set them to zero.  */
2381
  p = frag_more (4);
2382
  md_number_to_chars (p, 0x0000, 4);
2383
 
2384
  frag_align (2, 0, 0);
2385
 
2386
  /* We probably can't restore the current segment, for there likely
2387
     isn't one yet...  */
2388
  if (seg && subseg)
2389
    subseg_set (seg, subseg);
2390
 
2391
}
2392
 
2393
#endif /* SCO_ELF */
2394
 
2395
static void
2396
elf_generate_asm_lineno (void)
2397
{
2398
#ifdef NEED_ECOFF_DEBUG
2399
  if (ECOFF_DEBUGGING)
2400
    ecoff_generate_asm_lineno ();
2401
#endif
2402
}
2403
 
2404
static void
2405
elf_process_stab (segT sec ATTRIBUTE_UNUSED,
2406
                  int what ATTRIBUTE_UNUSED,
2407
                  const char *string ATTRIBUTE_UNUSED,
2408
                  int type ATTRIBUTE_UNUSED,
2409
                  int other ATTRIBUTE_UNUSED,
2410
                  int desc ATTRIBUTE_UNUSED)
2411
{
2412
#ifdef NEED_ECOFF_DEBUG
2413
  if (ECOFF_DEBUGGING)
2414
    ecoff_stab (sec, what, string, type, other, desc);
2415
#endif
2416
}
2417
 
2418
static int
2419
elf_separate_stab_sections (void)
2420
{
2421
#ifdef NEED_ECOFF_DEBUG
2422
  return (!ECOFF_DEBUGGING);
2423
#else
2424
  return 1;
2425
#endif
2426
}
2427
 
2428
static void
2429
elf_init_stab_section (segT seg)
2430
{
2431
#ifdef NEED_ECOFF_DEBUG
2432
  if (!ECOFF_DEBUGGING)
2433
#endif
2434
    obj_elf_init_stab_section (seg);
2435
}
2436
 
2437
const struct format_ops elf_format_ops =
2438
{
2439
  bfd_target_elf_flavour,
2440
  0,     /* dfl_leading_underscore */
2441
  1,    /* emit_section_symbols */
2442
  elf_begin,
2443
  elf_file_symbol,
2444
  elf_frob_symbol,
2445
  elf_frob_file,
2446
  elf_frob_file_before_adjust,
2447
  0,     /* obj_frob_file_before_fix */
2448
  elf_frob_file_after_relocs,
2449
  elf_s_get_size, elf_s_set_size,
2450
  elf_s_get_align, elf_s_set_align,
2451
  elf_s_get_other,
2452
  elf_s_set_other,
2453
  0,     /* s_get_desc */
2454
  0,     /* s_set_desc */
2455
  0,     /* s_get_type */
2456
  0,     /* s_set_type */
2457
  elf_copy_symbol_attributes,
2458
  elf_generate_asm_lineno,
2459
  elf_process_stab,
2460
  elf_separate_stab_sections,
2461
  elf_init_stab_section,
2462
  elf_sec_sym_ok_for_reloc,
2463
  elf_pop_insert,
2464
#ifdef NEED_ECOFF_DEBUG
2465
  elf_ecoff_set_ext,
2466
#else
2467
  0,     /* ecoff_set_ext */
2468
#endif
2469
  elf_obj_read_begin_hook,
2470
  elf_obj_symbol_new_hook,
2471
  0,
2472
  elf_adjust_symtab
2473
};

powered by: WebSVN 2.1.0

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