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 158

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
              xfree (name);
988
              return;
989
            }
990
          attr |= obj_elf_parse_section_letters (beg, strlen (beg), &clone);
991
 
992
          SKIP_WHITESPACE ();
993
          if (*input_line_pointer == ',')
994
            {
995
              char c;
996
              char *save = input_line_pointer;
997
 
998
              ++input_line_pointer;
999
              SKIP_WHITESPACE ();
1000
              c = *input_line_pointer;
1001
              if (c == '"')
1002
                {
1003
                  beg = demand_copy_C_string (&dummy);
1004
                  if (beg == NULL)
1005
                    {
1006
                      ignore_rest_of_line ();
1007
                      xfree (name);
1008
                      return;
1009
                    }
1010
                  type = obj_elf_section_type (beg, strlen (beg), TRUE);
1011
                }
1012
              else if (c == '@' || c == '%')
1013
                {
1014
                  beg = ++input_line_pointer;
1015
                  c = get_symbol_end ();
1016
                  *input_line_pointer = c;
1017
                  type = obj_elf_section_type (beg, input_line_pointer - beg, TRUE);
1018
                }
1019
              else
1020
                input_line_pointer = save;
1021
            }
1022
 
1023
          SKIP_WHITESPACE ();
1024
          if ((attr & SHF_MERGE) != 0 && *input_line_pointer == ',')
1025
            {
1026
              ++input_line_pointer;
1027
              SKIP_WHITESPACE ();
1028
              entsize = get_absolute_expression ();
1029
              SKIP_WHITESPACE ();
1030
              if (entsize < 0)
1031
                {
1032
                  as_warn (_("invalid merge entity size"));
1033
                  attr &= ~SHF_MERGE;
1034
                  entsize = 0;
1035
                }
1036
            }
1037
          else if ((attr & SHF_MERGE) != 0)
1038
            {
1039
              as_warn (_("entity size for SHF_MERGE not specified"));
1040
              attr &= ~SHF_MERGE;
1041
            }
1042
 
1043
          if ((attr & SHF_GROUP) != 0 && clone)
1044
            {
1045
              as_warn (_("? section flag ignored with G present"));
1046
              clone = FALSE;
1047
            }
1048
          if ((attr & SHF_GROUP) != 0 && *input_line_pointer == ',')
1049
            {
1050
              ++input_line_pointer;
1051
              group_name = obj_elf_section_name ();
1052
              if (group_name == NULL)
1053
                attr &= ~SHF_GROUP;
1054
              else if (strncmp (input_line_pointer, ",comdat", 7) == 0)
1055
                {
1056
                  input_line_pointer += 7;
1057
                  linkonce = 1;
1058
                }
1059
              else if (strncmp (name, ".gnu.linkonce", 13) == 0)
1060
                linkonce = 1;
1061
            }
1062
          else if ((attr & SHF_GROUP) != 0)
1063
            {
1064
              as_warn (_("group name for SHF_GROUP not specified"));
1065
              attr &= ~SHF_GROUP;
1066
            }
1067
 
1068
          if (clone)
1069
            {
1070
              const char *now_group = elf_group_name (now_seg);
1071
              if (now_group != NULL)
1072
                {
1073
                  group_name = xstrdup (now_group);
1074
                  linkonce = (now_seg->flags & SEC_LINK_ONCE) != 0;
1075
                }
1076
            }
1077
        }
1078
      else
1079
        {
1080
          do
1081
            {
1082
              char c;
1083
 
1084
              SKIP_WHITESPACE ();
1085
              if (*input_line_pointer != '#')
1086
                {
1087
                  as_bad (_("character following name is not '#'"));
1088
                  ignore_rest_of_line ();
1089
                  xfree (name);
1090
                  return;
1091
                }
1092
              beg = ++input_line_pointer;
1093
              c = get_symbol_end ();
1094
              *input_line_pointer = c;
1095
 
1096
              attr |= obj_elf_section_word (beg, input_line_pointer - beg, & type);
1097
 
1098
              SKIP_WHITESPACE ();
1099
            }
1100
          while (*input_line_pointer++ == ',');
1101
          --input_line_pointer;
1102
        }
1103
    }
1104
 
1105
done:
1106
  demand_empty_rest_of_line ();
1107
 
1108
  obj_elf_change_section (name, type, attr, entsize, group_name, linkonce, push);
1109
 
1110
  if (push && new_subsection != -1)
1111
    subseg_set (now_seg, new_subsection);
1112
}
1113
 
1114
/* Change to the .data section.  */
1115
 
1116
void
1117
obj_elf_data (int i)
1118
{
1119
#ifdef md_flush_pending_output
1120
  md_flush_pending_output ();
1121
#endif
1122
 
1123
  previous_section = now_seg;
1124
  previous_subsection = now_subseg;
1125
  s_data (i);
1126
 
1127
#ifdef md_elf_section_change_hook
1128
  md_elf_section_change_hook ();
1129
#endif
1130
}
1131
 
1132
/* Change to the .text section.  */
1133
 
1134
void
1135
obj_elf_text (int i)
1136
{
1137
#ifdef md_flush_pending_output
1138
  md_flush_pending_output ();
1139
#endif
1140
 
1141
  previous_section = now_seg;
1142
  previous_subsection = now_subseg;
1143
  s_text (i);
1144
 
1145
#ifdef md_elf_section_change_hook
1146
  md_elf_section_change_hook ();
1147
#endif
1148
}
1149
 
1150
/* Change to the *ABS* section.  */
1151
 
1152
void
1153
obj_elf_struct (int i)
1154
{
1155
#ifdef md_flush_pending_output
1156
  md_flush_pending_output ();
1157
#endif
1158
 
1159
  previous_section = now_seg;
1160
  previous_subsection = now_subseg;
1161
  s_struct (i);
1162
 
1163
#ifdef md_elf_section_change_hook
1164
  md_elf_section_change_hook ();
1165
#endif
1166
}
1167
 
1168
static void
1169
obj_elf_subsection (int ignore ATTRIBUTE_UNUSED)
1170
{
1171
  int temp;
1172
 
1173
#ifdef md_flush_pending_output
1174
  md_flush_pending_output ();
1175
#endif
1176
 
1177
  previous_section = now_seg;
1178
  previous_subsection = now_subseg;
1179
 
1180
  temp = get_absolute_expression ();
1181
  subseg_set (now_seg, (subsegT) temp);
1182
  demand_empty_rest_of_line ();
1183
 
1184
#ifdef md_elf_section_change_hook
1185
  md_elf_section_change_hook ();
1186
#endif
1187
}
1188
 
1189
/* This can be called from the processor backends if they change
1190
   sections.  */
1191
 
1192
void
1193
obj_elf_section_change_hook (void)
1194
{
1195
  previous_section = now_seg;
1196
  previous_subsection = now_subseg;
1197
}
1198
 
1199
void
1200
obj_elf_previous (int ignore ATTRIBUTE_UNUSED)
1201
{
1202
  segT new_section;
1203
  int new_subsection;
1204
 
1205
  if (previous_section == 0)
1206
    {
1207
      as_warn (_(".previous without corresponding .section; ignored"));
1208
      return;
1209
    }
1210
 
1211
#ifdef md_flush_pending_output
1212
  md_flush_pending_output ();
1213
#endif
1214
 
1215
  new_section = previous_section;
1216
  new_subsection = previous_subsection;
1217
  previous_section = now_seg;
1218
  previous_subsection = now_subseg;
1219
  subseg_set (new_section, new_subsection);
1220
 
1221
#ifdef md_elf_section_change_hook
1222
  md_elf_section_change_hook ();
1223
#endif
1224
}
1225
 
1226
static void
1227
obj_elf_popsection (int xxx ATTRIBUTE_UNUSED)
1228
{
1229
  struct section_stack *top = section_stack;
1230
 
1231
  if (top == NULL)
1232
    {
1233
      as_warn (_(".popsection without corresponding .pushsection; ignored"));
1234
      return;
1235
    }
1236
 
1237
#ifdef md_flush_pending_output
1238
  md_flush_pending_output ();
1239
#endif
1240
 
1241
  section_stack = top->next;
1242
  previous_section = top->prev_seg;
1243
  previous_subsection = top->prev_subseg;
1244
  subseg_set (top->seg, top->subseg);
1245
  free (top);
1246
 
1247
#ifdef md_elf_section_change_hook
1248
  md_elf_section_change_hook ();
1249
#endif
1250
}
1251
 
1252
static void
1253
obj_elf_line (int ignore ATTRIBUTE_UNUSED)
1254
{
1255
  /* Assume delimiter is part of expression.  BSD4.2 as fails with
1256
     delightful bug, so we are not being incompatible here.  */
1257
  new_logical_line (NULL, get_absolute_expression ());
1258
  demand_empty_rest_of_line ();
1259
}
1260
 
1261
/* This handles the .symver pseudo-op, which is used to specify a
1262
   symbol version.  The syntax is ``.symver NAME,SYMVERNAME''.
1263
   SYMVERNAME may contain ELF_VER_CHR ('@') characters.  This
1264
   pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1265
   with the same value as the symbol NAME.  */
1266
 
1267
static void
1268
obj_elf_symver (int ignore ATTRIBUTE_UNUSED)
1269
{
1270
  char *name;
1271
  char c;
1272
  char old_lexat;
1273
  symbolS *sym;
1274
 
1275
  sym = get_sym_from_input_line_and_check ();
1276
 
1277
  if (*input_line_pointer != ',')
1278
    {
1279
      as_bad (_("expected comma after name in .symver"));
1280
      ignore_rest_of_line ();
1281
      return;
1282
    }
1283
 
1284
  ++input_line_pointer;
1285
  SKIP_WHITESPACE ();
1286
  name = input_line_pointer;
1287
 
1288
  /* Temporarily include '@' in symbol names.  */
1289
  old_lexat = lex_type[(unsigned char) '@'];
1290
  lex_type[(unsigned char) '@'] |= LEX_NAME;
1291
  c = get_symbol_end ();
1292
  lex_type[(unsigned char) '@'] = old_lexat;
1293
 
1294
  if (symbol_get_obj (sym)->versioned_name == NULL)
1295
    {
1296
      symbol_get_obj (sym)->versioned_name = xstrdup (name);
1297
 
1298
      *input_line_pointer = c;
1299
 
1300
      if (strchr (symbol_get_obj (sym)->versioned_name,
1301
                  ELF_VER_CHR) == NULL)
1302
        {
1303
          as_bad (_("missing version name in `%s' for symbol `%s'"),
1304
                  symbol_get_obj (sym)->versioned_name,
1305
                  S_GET_NAME (sym));
1306
          ignore_rest_of_line ();
1307
          return;
1308
        }
1309
    }
1310
  else
1311
    {
1312
      if (strcmp (symbol_get_obj (sym)->versioned_name, name))
1313
        {
1314
          as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1315
                  name, symbol_get_obj (sym)->versioned_name,
1316
                  S_GET_NAME (sym));
1317
          ignore_rest_of_line ();
1318
          return;
1319
        }
1320
 
1321
      *input_line_pointer = c;
1322
    }
1323
 
1324
  demand_empty_rest_of_line ();
1325
}
1326
 
1327
/* This handles the .vtable_inherit pseudo-op, which is used to indicate
1328
   to the linker the hierarchy in which a particular table resides.  The
1329
   syntax is ".vtable_inherit CHILDNAME, PARENTNAME".  */
1330
 
1331
struct fix *
1332
obj_elf_vtable_inherit (int ignore ATTRIBUTE_UNUSED)
1333
{
1334
  char *cname, *pname;
1335
  symbolS *csym, *psym;
1336
  char c, bad = 0;
1337
 
1338
  if (*input_line_pointer == '#')
1339
    ++input_line_pointer;
1340
 
1341
  cname = input_line_pointer;
1342
  c = get_symbol_end ();
1343
  csym = symbol_find (cname);
1344
 
1345
  /* GCFIXME: should check that we don't have two .vtable_inherits for
1346
     the same child symbol.  Also, we can currently only do this if the
1347
     child symbol is already exists and is placed in a fragment.  */
1348
 
1349
  if (csym == NULL || symbol_get_frag (csym) == NULL)
1350
    {
1351
      as_bad (_("expected `%s' to have already been set for .vtable_inherit"),
1352
              cname);
1353
      bad = 1;
1354
    }
1355
 
1356
  *input_line_pointer = c;
1357
 
1358
  SKIP_WHITESPACE ();
1359
  if (*input_line_pointer != ',')
1360
    {
1361
      as_bad (_("expected comma after name in .vtable_inherit"));
1362
      ignore_rest_of_line ();
1363
      return NULL;
1364
    }
1365
 
1366
  ++input_line_pointer;
1367
  SKIP_WHITESPACE ();
1368
 
1369
  if (*input_line_pointer == '#')
1370
    ++input_line_pointer;
1371
 
1372
  if (input_line_pointer[0] == '0'
1373
      && (input_line_pointer[1] == '\0'
1374
          || ISSPACE (input_line_pointer[1])))
1375
    {
1376
      psym = section_symbol (absolute_section);
1377
      ++input_line_pointer;
1378
    }
1379
  else
1380
    {
1381
      pname = input_line_pointer;
1382
      c = get_symbol_end ();
1383
      psym = symbol_find_or_make (pname);
1384
      *input_line_pointer = c;
1385
    }
1386
 
1387
  demand_empty_rest_of_line ();
1388
 
1389
  if (bad)
1390
    return NULL;
1391
 
1392
  gas_assert (symbol_get_value_expression (csym)->X_op == O_constant);
1393
  return fix_new (symbol_get_frag (csym),
1394
                  symbol_get_value_expression (csym)->X_add_number,
1395
                  0, psym, 0, 0, BFD_RELOC_VTABLE_INHERIT);
1396
}
1397
 
1398
/* This handles the .vtable_entry pseudo-op, which is used to indicate
1399
   to the linker that a vtable slot was used.  The syntax is
1400
   ".vtable_entry tablename, offset".  */
1401
 
1402
struct fix *
1403
obj_elf_vtable_entry (int ignore ATTRIBUTE_UNUSED)
1404
{
1405
  symbolS *sym;
1406
  offsetT offset;
1407
 
1408
  if (*input_line_pointer == '#')
1409
    ++input_line_pointer;
1410
 
1411
  sym = get_sym_from_input_line_and_check ();
1412
  if (*input_line_pointer != ',')
1413
    {
1414
      as_bad (_("expected comma after name in .vtable_entry"));
1415
      ignore_rest_of_line ();
1416
      return NULL;
1417
    }
1418
 
1419
  ++input_line_pointer;
1420
  if (*input_line_pointer == '#')
1421
    ++input_line_pointer;
1422
 
1423
  offset = get_absolute_expression ();
1424
 
1425
  demand_empty_rest_of_line ();
1426
 
1427
  return fix_new (frag_now, frag_now_fix (), 0, sym, offset, 0,
1428
                  BFD_RELOC_VTABLE_ENTRY);
1429
}
1430
 
1431
void
1432
elf_obj_read_begin_hook (void)
1433
{
1434
#ifdef NEED_ECOFF_DEBUG
1435
  if (ECOFF_DEBUGGING)
1436
    ecoff_read_begin_hook ();
1437
#endif
1438
}
1439
 
1440
void
1441
elf_obj_symbol_new_hook (symbolS *symbolP)
1442
{
1443
  struct elf_obj_sy *sy_obj;
1444
 
1445
  sy_obj = symbol_get_obj (symbolP);
1446
  sy_obj->size = NULL;
1447
  sy_obj->versioned_name = NULL;
1448
 
1449
#ifdef NEED_ECOFF_DEBUG
1450
  if (ECOFF_DEBUGGING)
1451
    ecoff_symbol_new_hook (symbolP);
1452
#endif
1453
}
1454
 
1455
/* When setting one symbol equal to another, by default we probably
1456
   want them to have the same "size", whatever it means in the current
1457
   context.  */
1458
 
1459
void
1460
elf_copy_symbol_attributes (symbolS *dest, symbolS *src)
1461
{
1462
  struct elf_obj_sy *srcelf = symbol_get_obj (src);
1463
  struct elf_obj_sy *destelf = symbol_get_obj (dest);
1464
  if (srcelf->size)
1465
    {
1466
      if (destelf->size == NULL)
1467
        destelf->size = (expressionS *) xmalloc (sizeof (expressionS));
1468
      *destelf->size = *srcelf->size;
1469
    }
1470
  else
1471
    {
1472
      if (destelf->size != NULL)
1473
        free (destelf->size);
1474
      destelf->size = NULL;
1475
    }
1476
  S_SET_SIZE (dest, S_GET_SIZE (src));
1477
  /* Don't copy visibility.  */
1478
  S_SET_OTHER (dest, (ELF_ST_VISIBILITY (S_GET_OTHER (dest))
1479
                      | (S_GET_OTHER (src) & ~ELF_ST_VISIBILITY (-1))));
1480
}
1481
 
1482
void
1483
obj_elf_version (int ignore ATTRIBUTE_UNUSED)
1484
{
1485
  char *name;
1486
  unsigned int c;
1487
  char *p;
1488
  asection *seg = now_seg;
1489
  subsegT subseg = now_subseg;
1490
  Elf_Internal_Note i_note;
1491
  Elf_External_Note e_note;
1492
  asection *note_secp = NULL;
1493
 
1494
  SKIP_WHITESPACE ();
1495
  if (*input_line_pointer == '\"')
1496
    {
1497
      unsigned int len;
1498
 
1499
      ++input_line_pointer;     /* -> 1st char of string.  */
1500
      name = input_line_pointer;
1501
 
1502
      while (is_a_char (c = next_char_of_string ()))
1503
        ;
1504
      c = *input_line_pointer;
1505
      *input_line_pointer = '\0';
1506
      *(input_line_pointer - 1) = '\0';
1507
      *input_line_pointer = c;
1508
 
1509
      /* Create the .note section.  */
1510
      note_secp = subseg_new (".note", 0);
1511
      bfd_set_section_flags (stdoutput,
1512
                             note_secp,
1513
                             SEC_HAS_CONTENTS | SEC_READONLY);
1514
 
1515
      /* Process the version string.  */
1516
      len = strlen (name) + 1;
1517
 
1518
      /* PR 3456: Although the name field is padded out to an 4-byte
1519
         boundary, the namesz field should not be adjusted.  */
1520
      i_note.namesz = len;
1521
      i_note.descsz = 0; /* No description.  */
1522
      i_note.type = NT_VERSION;
1523
      p = frag_more (sizeof (e_note.namesz));
1524
      md_number_to_chars (p, i_note.namesz, sizeof (e_note.namesz));
1525
      p = frag_more (sizeof (e_note.descsz));
1526
      md_number_to_chars (p, i_note.descsz, sizeof (e_note.descsz));
1527
      p = frag_more (sizeof (e_note.type));
1528
      md_number_to_chars (p, i_note.type, sizeof (e_note.type));
1529
      p = frag_more (len);
1530
      memcpy (p, name, len);
1531
 
1532
      frag_align (2, 0, 0);
1533
 
1534
      subseg_set (seg, subseg);
1535
    }
1536
  else
1537
    as_bad (_("expected quoted string"));
1538
 
1539
  demand_empty_rest_of_line ();
1540
}
1541
 
1542
static void
1543
obj_elf_size (int ignore ATTRIBUTE_UNUSED)
1544
{
1545
  char *name = input_line_pointer;
1546
  char c = get_symbol_end ();
1547
  char *p;
1548
  expressionS exp;
1549
  symbolS *sym;
1550
 
1551
  p = input_line_pointer;
1552
  *p = c;
1553
  SKIP_WHITESPACE ();
1554
  if (*input_line_pointer != ',')
1555
    {
1556
      *p = 0;
1557
      as_bad (_("expected comma after name `%s' in .size directive"), name);
1558
      *p = c;
1559
      ignore_rest_of_line ();
1560
      return;
1561
    }
1562
  input_line_pointer++;
1563
  expression (&exp);
1564
  if (exp.X_op == O_absent)
1565
    {
1566
      as_bad (_("missing expression in .size directive"));
1567
      exp.X_op = O_constant;
1568
      exp.X_add_number = 0;
1569
    }
1570
  *p = 0;
1571
  sym = symbol_find_or_make (name);
1572
  *p = c;
1573
  if (exp.X_op == O_constant)
1574
    {
1575
      S_SET_SIZE (sym, exp.X_add_number);
1576
      if (symbol_get_obj (sym)->size)
1577
        {
1578
          xfree (symbol_get_obj (sym)->size);
1579
          symbol_get_obj (sym)->size = NULL;
1580
        }
1581
    }
1582
  else
1583
    {
1584
      symbol_get_obj (sym)->size =
1585
          (expressionS *) xmalloc (sizeof (expressionS));
1586
      *symbol_get_obj (sym)->size = exp;
1587
    }
1588
  demand_empty_rest_of_line ();
1589
}
1590
 
1591
/* Handle the ELF .type pseudo-op.  This sets the type of a symbol.
1592
   There are six syntaxes:
1593
 
1594
   The first (used on Solaris) is
1595
       .type SYM,#function
1596
   The second (used on UnixWare) is
1597
       .type SYM,@function
1598
   The third (reportedly to be used on Irix 6.0) is
1599
       .type SYM STT_FUNC
1600
   The fourth (used on NetBSD/Arm and Linux/ARM) is
1601
       .type SYM,%function
1602
   The fifth (used on SVR4/860) is
1603
       .type SYM,"function"
1604
   The sixth (emitted by recent SunPRO under Solaris) is
1605
       .type SYM,[0-9]
1606
   where the integer is the STT_* value.
1607
   */
1608
 
1609
static char *
1610
obj_elf_type_name (char *cp)
1611
{
1612
  char *p;
1613
 
1614
  p = input_line_pointer;
1615
  if (*input_line_pointer >= '0'
1616
      && *input_line_pointer <= '9')
1617
    {
1618
      while (*input_line_pointer >= '0'
1619
             && *input_line_pointer <= '9')
1620
        ++input_line_pointer;
1621
      *cp = *input_line_pointer;
1622
      *input_line_pointer = '\0';
1623
    }
1624
  else
1625
    *cp = get_symbol_end ();
1626
 
1627
  return p;
1628
}
1629
 
1630
static void
1631
obj_elf_type (int ignore ATTRIBUTE_UNUSED)
1632
{
1633
  char c;
1634
  int type;
1635
  const char *type_name;
1636
  symbolS *sym;
1637
  elf_symbol_type *elfsym;
1638
 
1639
  sym = get_sym_from_input_line_and_check ();
1640
  c = *input_line_pointer;
1641
  elfsym = (elf_symbol_type *) symbol_get_bfdsym (sym);
1642
 
1643
  if (*input_line_pointer == ',')
1644
    ++input_line_pointer;
1645
 
1646
  SKIP_WHITESPACE ();
1647
  if (   *input_line_pointer == '#'
1648
      || *input_line_pointer == '@'
1649
      || *input_line_pointer == '"'
1650
      || *input_line_pointer == '%')
1651
    ++input_line_pointer;
1652
 
1653
  type_name = obj_elf_type_name (& c);
1654
 
1655
  type = 0;
1656
  if (strcmp (type_name, "function") == 0
1657
      || strcmp (type_name, "2") == 0
1658
      || strcmp (type_name, "STT_FUNC") == 0)
1659
    type = BSF_FUNCTION;
1660
  else if (strcmp (type_name, "object") == 0
1661
           || strcmp (type_name, "1") == 0
1662
           || strcmp (type_name, "STT_OBJECT") == 0)
1663
    type = BSF_OBJECT;
1664
  else if (strcmp (type_name, "tls_object") == 0
1665
           || strcmp (type_name, "6") == 0
1666
           || strcmp (type_name, "STT_TLS") == 0)
1667
    type = BSF_OBJECT | BSF_THREAD_LOCAL;
1668
  else if (strcmp (type_name, "notype") == 0
1669
           || strcmp (type_name, "0") == 0
1670
           || strcmp (type_name, "STT_NOTYPE") == 0)
1671
    ;
1672
  else if (strcmp (type_name, "common") == 0
1673
           || strcmp (type_name, "5") == 0
1674
           || strcmp (type_name, "STT_COMMON") == 0)
1675
    {
1676
      type = BSF_OBJECT;
1677
 
1678
      if (! S_IS_COMMON (sym))
1679
        {
1680
          if (S_IS_VOLATILE (sym))
1681
            {
1682
              sym = symbol_clone (sym, 1);
1683
              S_SET_SEGMENT (sym, bfd_com_section_ptr);
1684
              S_SET_VALUE (sym, 0);
1685
              S_SET_EXTERNAL (sym);
1686
              symbol_set_frag (sym, &zero_address_frag);
1687
              S_CLEAR_VOLATILE (sym);
1688
            }
1689
          else if (S_IS_DEFINED (sym) || symbol_equated_p (sym))
1690
            as_bad (_("symbol '%s' is already defined"), S_GET_NAME (sym));
1691
          else
1692
            {
1693
              /* FIXME: Is it safe to just change the section ?  */
1694
              S_SET_SEGMENT (sym, bfd_com_section_ptr);
1695
              S_SET_VALUE (sym, 0);
1696
              S_SET_EXTERNAL (sym);
1697
            }
1698
        }
1699
    }
1700
  else if (strcmp (type_name, "gnu_indirect_function") == 0
1701
           || strcmp (type_name, "10") == 0
1702
           || strcmp (type_name, "STT_GNU_IFUNC") == 0)
1703
    {
1704
      const struct elf_backend_data *bed;
1705
 
1706
      bed = get_elf_backend_data (stdoutput);
1707
      if (!(bed->elf_osabi == ELFOSABI_LINUX
1708
            /* GNU/Linux is still using the default value 0.  */
1709
            || bed->elf_osabi == ELFOSABI_NONE))
1710
        as_bad (_("symbol type \"%s\" is supported only by GNU targets"),
1711
                type_name);
1712
      type = BSF_FUNCTION | BSF_GNU_INDIRECT_FUNCTION;
1713
    }
1714
  else if (strcmp (type_name, "gnu_unique_object") == 0)
1715
    {
1716
      struct elf_backend_data *bed;
1717
 
1718
      bed = (struct elf_backend_data *) get_elf_backend_data (stdoutput);
1719
      if (!(bed->elf_osabi == ELFOSABI_LINUX
1720
            /* GNU/Linux is still using the default value 0.  */
1721
            || bed->elf_osabi == ELFOSABI_NONE))
1722
        as_bad (_("symbol type \"%s\" is supported only by GNU targets"),
1723
                type_name);
1724
      type = BSF_OBJECT | BSF_GNU_UNIQUE;
1725
      /* PR 10549: Always set OSABI field to LINUX for objects containing unique symbols.  */
1726
      bed->elf_osabi = ELFOSABI_LINUX;
1727
    }
1728
#ifdef md_elf_symbol_type
1729
  else if ((type = md_elf_symbol_type (type_name, sym, elfsym)) != -1)
1730
    ;
1731
#endif
1732
  else
1733
    as_bad (_("unrecognized symbol type \"%s\""), type_name);
1734
 
1735
  *input_line_pointer = c;
1736
 
1737
  if (*input_line_pointer == '"')
1738
    ++input_line_pointer;
1739
 
1740
  elfsym->symbol.flags |= type;
1741
 
1742
  demand_empty_rest_of_line ();
1743
}
1744
 
1745
static void
1746
obj_elf_ident (int ignore ATTRIBUTE_UNUSED)
1747
{
1748
  static segT comment_section;
1749
  segT old_section = now_seg;
1750
  int old_subsection = now_subseg;
1751
 
1752
#ifdef md_flush_pending_output
1753
  md_flush_pending_output ();
1754
#endif
1755
 
1756
  if (!comment_section)
1757
    {
1758
      char *p;
1759
      comment_section = subseg_new (".comment", 0);
1760
      bfd_set_section_flags (stdoutput, comment_section,
1761
                             SEC_READONLY | SEC_HAS_CONTENTS
1762
                             | SEC_MERGE | SEC_STRINGS);
1763
      comment_section->entsize = 1;
1764
#ifdef md_elf_section_change_hook
1765
      md_elf_section_change_hook ();
1766
#endif
1767
      p = frag_more (1);
1768
      *p = 0;
1769
    }
1770
  else
1771
    subseg_set (comment_section, 0);
1772
  stringer (8 + 1);
1773
  subseg_set (old_section, old_subsection);
1774
}
1775
 
1776
#ifdef INIT_STAB_SECTION
1777
 
1778
/* The first entry in a .stabs section is special.  */
1779
 
1780
void
1781
obj_elf_init_stab_section (segT seg)
1782
{
1783
  char *file;
1784
  char *p;
1785
  char *stabstr_name;
1786
  unsigned int stroff;
1787
 
1788
  /* Force the section to align to a longword boundary.  Without this,
1789
     UnixWare ar crashes.  */
1790
  bfd_set_section_alignment (stdoutput, seg, 2);
1791
 
1792
  /* Make space for this first symbol.  */
1793
  p = frag_more (12);
1794
  /* Zero it out.  */
1795
  memset (p, 0, 12);
1796
  as_where (&file, NULL);
1797
  stabstr_name = (char *) xmalloc (strlen (segment_name (seg)) + 4);
1798
  strcpy (stabstr_name, segment_name (seg));
1799
  strcat (stabstr_name, "str");
1800
  stroff = get_stab_string_offset (file, stabstr_name);
1801
  know (stroff == 1 || (stroff == 0 && file[0] == '\0'));
1802
  md_number_to_chars (p, stroff, 4);
1803
  seg_info (seg)->stabu.p = p;
1804
}
1805
 
1806
#endif
1807
 
1808
/* Fill in the counts in the first entry in a .stabs section.  */
1809
 
1810
static void
1811
adjust_stab_sections (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1812
{
1813
  char *name;
1814
  asection *strsec;
1815
  char *p;
1816
  int strsz, nsyms;
1817
 
1818
  if (strncmp (".stab", sec->name, 5))
1819
    return;
1820
  if (!strcmp ("str", sec->name + strlen (sec->name) - 3))
1821
    return;
1822
 
1823
  name = (char *) alloca (strlen (sec->name) + 4);
1824
  strcpy (name, sec->name);
1825
  strcat (name, "str");
1826
  strsec = bfd_get_section_by_name (abfd, name);
1827
  if (strsec)
1828
    strsz = bfd_section_size (abfd, strsec);
1829
  else
1830
    strsz = 0;
1831
  nsyms = bfd_section_size (abfd, sec) / 12 - 1;
1832
 
1833
  p = seg_info (sec)->stabu.p;
1834
  gas_assert (p != 0);
1835
 
1836
  bfd_h_put_16 (abfd, nsyms, p + 6);
1837
  bfd_h_put_32 (abfd, strsz, p + 8);
1838
}
1839
 
1840
#ifdef NEED_ECOFF_DEBUG
1841
 
1842
/* This function is called by the ECOFF code.  It is supposed to
1843
   record the external symbol information so that the backend can
1844
   write it out correctly.  The ELF backend doesn't actually handle
1845
   this at the moment, so we do it ourselves.  We save the information
1846
   in the symbol.  */
1847
 
1848
#ifdef OBJ_MAYBE_ELF
1849
static
1850
#endif
1851
void
1852
elf_ecoff_set_ext (symbolS *sym, struct ecoff_extr *ext)
1853
{
1854
  symbol_get_bfdsym (sym)->udata.p = ext;
1855
}
1856
 
1857
/* This function is called by bfd_ecoff_debug_externals.  It is
1858
   supposed to *EXT to the external symbol information, and return
1859
   whether the symbol should be used at all.  */
1860
 
1861
static bfd_boolean
1862
elf_get_extr (asymbol *sym, EXTR *ext)
1863
{
1864
  if (sym->udata.p == NULL)
1865
    return FALSE;
1866
  *ext = *(EXTR *) sym->udata.p;
1867
  return TRUE;
1868
}
1869
 
1870
/* This function is called by bfd_ecoff_debug_externals.  It has
1871
   nothing to do for ELF.  */
1872
 
1873
static void
1874
elf_set_index (asymbol *sym ATTRIBUTE_UNUSED,
1875
               bfd_size_type indx ATTRIBUTE_UNUSED)
1876
{
1877
}
1878
 
1879
#endif /* NEED_ECOFF_DEBUG */
1880
 
1881
void
1882
elf_frob_symbol (symbolS *symp, int *puntp)
1883
{
1884
  struct elf_obj_sy *sy_obj;
1885
  expressionS *size;
1886
 
1887
#ifdef NEED_ECOFF_DEBUG
1888
  if (ECOFF_DEBUGGING)
1889
    ecoff_frob_symbol (symp);
1890
#endif
1891
 
1892
  sy_obj = symbol_get_obj (symp);
1893
 
1894
  size = sy_obj->size;
1895
  if (size != NULL)
1896
    {
1897
      if (resolve_expression (size)
1898
          && size->X_op == O_constant)
1899
        S_SET_SIZE (symp, size->X_add_number);
1900
      else
1901
        {
1902
          if (flag_size_check == size_check_error)
1903
            as_bad (_(".size expression for %s "
1904
                      "does not evaluate to a constant"), S_GET_NAME (symp));
1905
          else
1906
            as_warn (_(".size expression for %s "
1907
                       "does not evaluate to a constant"), S_GET_NAME (symp));
1908
        }
1909
      free (sy_obj->size);
1910
      sy_obj->size = NULL;
1911
    }
1912
 
1913
  if (sy_obj->versioned_name != NULL)
1914
    {
1915
      char *p;
1916
 
1917
      p = strchr (sy_obj->versioned_name, ELF_VER_CHR);
1918
      know (p != NULL);
1919
 
1920
      /* This symbol was given a new name with the .symver directive.
1921
 
1922
         If this is an external reference, just rename the symbol to
1923
         include the version string.  This will make the relocs be
1924
         against the correct versioned symbol.
1925
 
1926
         If this is a definition, add an alias.  FIXME: Using an alias
1927
         will permit the debugging information to refer to the right
1928
         symbol.  However, it's not clear whether it is the best
1929
         approach.  */
1930
 
1931
      if (! S_IS_DEFINED (symp))
1932
        {
1933
          /* Verify that the name isn't using the @@ syntax--this is
1934
             reserved for definitions of the default version to link
1935
             against.  */
1936
          if (p[1] == ELF_VER_CHR)
1937
            {
1938
              as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1939
                      sy_obj->versioned_name);
1940
              *puntp = TRUE;
1941
            }
1942
          S_SET_NAME (symp, sy_obj->versioned_name);
1943
        }
1944
      else
1945
        {
1946
          if (p[1] == ELF_VER_CHR && p[2] == ELF_VER_CHR)
1947
            {
1948
              size_t l;
1949
 
1950
              /* The @@@ syntax is a special case. It renames the
1951
                 symbol name to versioned_name with one `@' removed.  */
1952
              l = strlen (&p[3]) + 1;
1953
              memmove (&p[2], &p[3], l);
1954
              S_SET_NAME (symp, sy_obj->versioned_name);
1955
            }
1956
          else
1957
            {
1958
              symbolS *symp2;
1959
 
1960
              /* FIXME: Creating a new symbol here is risky.  We're
1961
                 in the final loop over the symbol table.  We can
1962
                 get away with it only because the symbol goes to
1963
                 the end of the list, where the loop will still see
1964
                 it.  It would probably be better to do this in
1965
                 obj_frob_file_before_adjust.  */
1966
 
1967
              symp2 = symbol_find_or_make (sy_obj->versioned_name);
1968
 
1969
              /* Now we act as though we saw symp2 = sym.  */
1970
 
1971
              S_SET_SEGMENT (symp2, S_GET_SEGMENT (symp));
1972
 
1973
              /* Subtracting out the frag address here is a hack
1974
                 because we are in the middle of the final loop.  */
1975
              S_SET_VALUE (symp2,
1976
                           (S_GET_VALUE (symp)
1977
                            - symbol_get_frag (symp)->fr_address));
1978
 
1979
              symbol_set_frag (symp2, symbol_get_frag (symp));
1980
 
1981
              /* This will copy over the size information.  */
1982
              copy_symbol_attributes (symp2, symp);
1983
 
1984
              S_SET_OTHER (symp2, S_GET_OTHER (symp));
1985
 
1986
              if (S_IS_WEAK (symp))
1987
                S_SET_WEAK (symp2);
1988
 
1989
              if (S_IS_EXTERNAL (symp))
1990
                S_SET_EXTERNAL (symp2);
1991
            }
1992
        }
1993
    }
1994
 
1995
  /* Double check weak symbols.  */
1996
  if (S_IS_WEAK (symp))
1997
    {
1998
      if (S_IS_COMMON (symp))
1999
        as_bad (_("symbol `%s' can not be both weak and common"),
2000
                S_GET_NAME (symp));
2001
    }
2002
 
2003
#ifdef TC_MIPS
2004
  /* The Irix 5 and 6 assemblers set the type of any common symbol and
2005
     any undefined non-function symbol to STT_OBJECT.  We try to be
2006
     compatible, since newer Irix 5 and 6 linkers care.  However, we
2007
     only set undefined symbols to be STT_OBJECT if we are on Irix,
2008
     because that is the only time gcc will generate the necessary
2009
     .global directives to mark functions.  */
2010
 
2011
  if (S_IS_COMMON (symp))
2012
    symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
2013
 
2014
  if (strstr (TARGET_OS, "irix") != NULL
2015
      && ! S_IS_DEFINED (symp)
2016
      && (symbol_get_bfdsym (symp)->flags & BSF_FUNCTION) == 0)
2017
    symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
2018
#endif
2019
}
2020
 
2021
struct group_list
2022
{
2023
  asection **head;              /* Section lists.  */
2024
  unsigned int *elt_count;      /* Number of sections in each list.  */
2025
  unsigned int num_group;       /* Number of lists.  */
2026
  struct hash_control *indexes; /* Maps group name to index in head array.  */
2027
};
2028
 
2029
/* Called via bfd_map_over_sections.  If SEC is a member of a group,
2030
   add it to a list of sections belonging to the group.  INF is a
2031
   pointer to a struct group_list, which is where we store the head of
2032
   each list.  */
2033
 
2034
static void
2035
build_group_lists (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
2036
{
2037
  struct group_list *list = (struct group_list *) inf;
2038
  const char *group_name = elf_group_name (sec);
2039
  unsigned int i;
2040
  unsigned int *elem_idx;
2041
  unsigned int *idx_ptr;
2042
 
2043
  if (group_name == NULL)
2044
    return;
2045
 
2046
  /* If this group already has a list, add the section to the head of
2047
     the list.  */
2048
  elem_idx = (unsigned int *) hash_find (list->indexes, group_name);
2049
  if (elem_idx != NULL)
2050
    {
2051
      elf_next_in_group (sec) = list->head[*elem_idx];
2052
      list->head[*elem_idx] = sec;
2053
      list->elt_count[*elem_idx] += 1;
2054
      return;
2055
    }
2056
 
2057
  /* New group.  Make the arrays bigger in chunks to minimize calls to
2058
     realloc.  */
2059
  i = list->num_group;
2060
  if ((i & 127) == 0)
2061
    {
2062
      unsigned int newsize = i + 128;
2063
      list->head = (asection **) xrealloc (list->head,
2064
                                           newsize * sizeof (*list->head));
2065
      list->elt_count = (unsigned int *)
2066
          xrealloc (list->elt_count, newsize * sizeof (*list->elt_count));
2067
    }
2068
  list->head[i] = sec;
2069
  list->elt_count[i] = 1;
2070
  list->num_group += 1;
2071
 
2072
  /* Add index to hash.  */
2073
  idx_ptr = (unsigned int *) xmalloc (sizeof (unsigned int));
2074
  *idx_ptr = i;
2075
  hash_insert (list->indexes, group_name, idx_ptr);
2076
}
2077
 
2078
static void free_section_idx (const char *key ATTRIBUTE_UNUSED, void *val)
2079
{
2080
  free ((unsigned int *) val);
2081
}
2082
 
2083
void
2084
elf_adjust_symtab (void)
2085
{
2086
  struct group_list list;
2087
  unsigned int i;
2088
 
2089
  /* Go find section groups.  */
2090
  list.num_group = 0;
2091
  list.head = NULL;
2092
  list.elt_count = NULL;
2093
  list.indexes = hash_new ();
2094
  bfd_map_over_sections (stdoutput, build_group_lists, &list);
2095
 
2096
  /* Make the SHT_GROUP sections that describe each section group.  We
2097
     can't set up the section contents here yet, because elf section
2098
     indices have yet to be calculated.  elf.c:set_group_contents does
2099
     the rest of the work.  */
2100
 for (i = 0; i < list.num_group; i++)
2101
    {
2102
      const char *group_name = elf_group_name (list.head[i]);
2103
      const char *sec_name;
2104
      asection *s;
2105
      flagword flags;
2106
      struct symbol *sy;
2107
      bfd_size_type size;
2108
 
2109
      flags = SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_GROUP;
2110
      for (s = list.head[i]; s != NULL; s = elf_next_in_group (s))
2111
        if ((s->flags ^ flags) & SEC_LINK_ONCE)
2112
          {
2113
            flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2114
            if (s != list.head[i])
2115
              {
2116
                as_warn (_("assuming all members of group `%s' are COMDAT"),
2117
                         group_name);
2118
                break;
2119
              }
2120
          }
2121
 
2122
      sec_name = ".group";
2123
      s = subseg_force_new (sec_name, 0);
2124
      if (s == NULL
2125
          || !bfd_set_section_flags (stdoutput, s, flags)
2126
          || !bfd_set_section_alignment (stdoutput, s, 2))
2127
        {
2128
          as_fatal (_("can't create group: %s"),
2129
                    bfd_errmsg (bfd_get_error ()));
2130
        }
2131
      elf_section_type (s) = SHT_GROUP;
2132
 
2133
      /* Pass a pointer to the first section in this group.  */
2134
      elf_next_in_group (s) = list.head[i];
2135
      /* Make sure that the signature symbol for the group has the
2136
         name of the group.  */
2137
      sy = symbol_find_exact (group_name);
2138
      if (!sy
2139
          || (sy != symbol_lastP
2140
              && (sy->sy_next == NULL
2141
                  || sy->sy_next->sy_previous != sy)))
2142
        {
2143
          /* Create the symbol now.  */
2144
          sy = symbol_new (group_name, now_seg, (valueT) 0, frag_now);
2145
#ifdef TE_SOLARIS
2146
          /* Before Solaris 11 build 154, Sun ld rejects local group
2147
             signature symbols, so make them weak hidden instead.  */
2148
          symbol_get_bfdsym (sy)->flags |= BSF_WEAK;
2149
          S_SET_OTHER (sy, STV_HIDDEN);
2150
#else
2151
          symbol_get_obj (sy)->local = 1;
2152
#endif
2153
          symbol_table_insert (sy);
2154
        }
2155
      elf_group_id (s) = symbol_get_bfdsym (sy);
2156
 
2157
      size = 4 * (list.elt_count[i] + 1);
2158
      bfd_set_section_size (stdoutput, s, size);
2159
      s->contents = (unsigned char *) frag_more (size);
2160
      frag_now->fr_fix = frag_now_fix_octets ();
2161
      frag_wane (frag_now);
2162
    }
2163
 
2164
  /* Cleanup hash.  */
2165
  hash_traverse (list.indexes, free_section_idx);
2166
  hash_die (list.indexes);
2167
}
2168
 
2169
void
2170
elf_frob_file (void)
2171
{
2172
  bfd_map_over_sections (stdoutput, adjust_stab_sections, NULL);
2173
 
2174
#ifdef elf_tc_final_processing
2175
  elf_tc_final_processing ();
2176
#endif
2177
}
2178
 
2179
/* It removes any unneeded versioned symbols from the symbol table.  */
2180
 
2181
void
2182
elf_frob_file_before_adjust (void)
2183
{
2184
  if (symbol_rootP)
2185
    {
2186
      symbolS *symp;
2187
 
2188
      for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2189
        if (!S_IS_DEFINED (symp))
2190
          {
2191
            if (symbol_get_obj (symp)->versioned_name)
2192
              {
2193
                char *p;
2194
 
2195
                /* The @@@ syntax is a special case. If the symbol is
2196
                   not defined, 2 `@'s will be removed from the
2197
                   versioned_name.  */
2198
 
2199
                p = strchr (symbol_get_obj (symp)->versioned_name,
2200
                            ELF_VER_CHR);
2201
                know (p != NULL);
2202
                if (p[1] == ELF_VER_CHR && p[2] == ELF_VER_CHR)
2203
                  {
2204
                    size_t l = strlen (&p[3]) + 1;
2205
                    memmove (&p[1], &p[3], l);
2206
                  }
2207
                if (symbol_used_p (symp) == 0
2208
                    && symbol_used_in_reloc_p (symp) == 0)
2209
                  symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2210
              }
2211
 
2212
            /* If there was .weak foo, but foo was neither defined nor
2213
               used anywhere, remove it.  */
2214
 
2215
            else if (S_IS_WEAK (symp)
2216
                     && symbol_used_p (symp) == 0
2217
                     && symbol_used_in_reloc_p (symp) == 0)
2218
              symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2219
          }
2220
    }
2221
}
2222
 
2223
/* It is required that we let write_relocs have the opportunity to
2224
   optimize away fixups before output has begun, since it is possible
2225
   to eliminate all fixups for a section and thus we never should
2226
   have generated the relocation section.  */
2227
 
2228
void
2229
elf_frob_file_after_relocs (void)
2230
{
2231
#ifdef NEED_ECOFF_DEBUG
2232
  if (ECOFF_DEBUGGING)
2233
    /* Generate the ECOFF debugging information.  */
2234
    {
2235
      const struct ecoff_debug_swap *debug_swap;
2236
      struct ecoff_debug_info debug;
2237
      char *buf;
2238
      asection *sec;
2239
 
2240
      debug_swap
2241
        = get_elf_backend_data (stdoutput)->elf_backend_ecoff_debug_swap;
2242
      know (debug_swap != NULL);
2243
      ecoff_build_debug (&debug.symbolic_header, &buf, debug_swap);
2244
 
2245
      /* Set up the pointers in debug.  */
2246
#define SET(ptr, offset, type) \
2247
    debug.ptr = (type) (buf + debug.symbolic_header.offset)
2248
 
2249
      SET (line, cbLineOffset, unsigned char *);
2250
      SET (external_dnr, cbDnOffset, void *);
2251
      SET (external_pdr, cbPdOffset, void *);
2252
      SET (external_sym, cbSymOffset, void *);
2253
      SET (external_opt, cbOptOffset, void *);
2254
      SET (external_aux, cbAuxOffset, union aux_ext *);
2255
      SET (ss, cbSsOffset, char *);
2256
      SET (external_fdr, cbFdOffset, void *);
2257
      SET (external_rfd, cbRfdOffset, void *);
2258
      /* ssext and external_ext are set up just below.  */
2259
 
2260
#undef SET
2261
 
2262
      /* Set up the external symbols.  */
2263
      debug.ssext = debug.ssext_end = NULL;
2264
      debug.external_ext = debug.external_ext_end = NULL;
2265
      if (! bfd_ecoff_debug_externals (stdoutput, &debug, debug_swap, TRUE,
2266
                                       elf_get_extr, elf_set_index))
2267
        as_fatal (_("failed to set up debugging information: %s"),
2268
                  bfd_errmsg (bfd_get_error ()));
2269
 
2270
      sec = bfd_get_section_by_name (stdoutput, ".mdebug");
2271
      gas_assert (sec != NULL);
2272
 
2273
      know (!stdoutput->output_has_begun);
2274
 
2275
      /* We set the size of the section, call bfd_set_section_contents
2276
         to force the ELF backend to allocate a file position, and then
2277
         write out the data.  FIXME: Is this really the best way to do
2278
         this?  */
2279
      bfd_set_section_size
2280
        (stdoutput, sec, bfd_ecoff_debug_size (stdoutput, &debug, debug_swap));
2281
 
2282
      /* Pass BUF to bfd_set_section_contents because this will
2283
         eventually become a call to fwrite, and ISO C prohibits
2284
         passing a NULL pointer to a stdio function even if the
2285
         pointer will not be used.  */
2286
      if (! bfd_set_section_contents (stdoutput, sec, buf, 0, 0))
2287
        as_fatal (_("can't start writing .mdebug section: %s"),
2288
                  bfd_errmsg (bfd_get_error ()));
2289
 
2290
      know (stdoutput->output_has_begun);
2291
      know (sec->filepos != 0);
2292
 
2293
      if (! bfd_ecoff_write_debug (stdoutput, &debug, debug_swap,
2294
                                   sec->filepos))
2295
        as_fatal (_("could not write .mdebug section: %s"),
2296
                  bfd_errmsg (bfd_get_error ()));
2297
    }
2298
#endif /* NEED_ECOFF_DEBUG */
2299
}
2300
 
2301
#ifdef SCO_ELF
2302
 
2303
/* Heavily plagiarized from obj_elf_version.  The idea is to emit the
2304
   SCO specific identifier in the .notes section to satisfy the SCO
2305
   linker.
2306
 
2307
   This looks more complicated than it really is.  As opposed to the
2308
   "obvious" solution, this should handle the cross dev cases
2309
   correctly.  (i.e, hosting on a 64 bit big endian processor, but
2310
   generating SCO Elf code) Efficiency isn't a concern, as there
2311
   should be exactly one of these sections per object module.
2312
 
2313
   SCO OpenServer 5 identifies it's ELF modules with a standard ELF
2314
   .note section.
2315
 
2316
   int_32 namesz  = 4 ;  Name size
2317
   int_32 descsz  = 12 ; Descriptive information
2318
   int_32 type    = 1 ;
2319
   char   name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
2320
   int_32 version = (major ver # << 16)  | version of tools ;
2321
   int_32 source  = (tool_id << 16 ) | 1 ;
2322
   int_32 info    = 0 ;    These are set by the SCO tools, but we
2323
                           don't know enough about the source
2324
                           environment to set them.  SCO ld currently
2325
                           ignores them, and recommends we set them
2326
                           to zero.  */
2327
 
2328
#define SCO_MAJOR_VERSION 0x1
2329
#define SCO_MINOR_VERSION 0x1
2330
 
2331
void
2332
sco_id (void)
2333
{
2334
 
2335
  char *name;
2336
  unsigned int c;
2337
  char ch;
2338
  char *p;
2339
  asection *seg = now_seg;
2340
  subsegT subseg = now_subseg;
2341
  Elf_Internal_Note i_note;
2342
  Elf_External_Note e_note;
2343
  asection *note_secp = NULL;
2344
  int i, len;
2345
 
2346
  /* create the .note section */
2347
 
2348
  note_secp = subseg_new (".note", 0);
2349
  bfd_set_section_flags (stdoutput,
2350
                         note_secp,
2351
                         SEC_HAS_CONTENTS | SEC_READONLY);
2352
 
2353
  /* process the version string */
2354
 
2355
  i_note.namesz = 4;
2356
  i_note.descsz = 12;           /* 12 descriptive bytes */
2357
  i_note.type = NT_VERSION;     /* Contains a version string */
2358
 
2359
  p = frag_more (sizeof (i_note.namesz));
2360
  md_number_to_chars (p, i_note.namesz, 4);
2361
 
2362
  p = frag_more (sizeof (i_note.descsz));
2363
  md_number_to_chars (p, i_note.descsz, 4);
2364
 
2365
  p = frag_more (sizeof (i_note.type));
2366
  md_number_to_chars (p, i_note.type, 4);
2367
 
2368
  p = frag_more (4);
2369
  strcpy (p, "SCO");
2370
 
2371
  /* Note: this is the version number of the ELF we're representing */
2372
  p = frag_more (4);
2373
  md_number_to_chars (p, (SCO_MAJOR_VERSION << 16) | (SCO_MINOR_VERSION), 4);
2374
 
2375
  /* Here, we pick a magic number for ourselves (yes, I "registered"
2376
     it with SCO.  The bottom bit shows that we are compat with the
2377
     SCO ABI.  */
2378
  p = frag_more (4);
2379
  md_number_to_chars (p, 0x4c520000 | 0x0001, 4);
2380
 
2381
  /* If we knew (or cared) what the source language options were, we'd
2382
     fill them in here.  SCO has given us permission to ignore these
2383
     and just set them to zero.  */
2384
  p = frag_more (4);
2385
  md_number_to_chars (p, 0x0000, 4);
2386
 
2387
  frag_align (2, 0, 0);
2388
 
2389
  /* We probably can't restore the current segment, for there likely
2390
     isn't one yet...  */
2391
  if (seg && subseg)
2392
    subseg_set (seg, subseg);
2393
 
2394
}
2395
 
2396
#endif /* SCO_ELF */
2397
 
2398
static void
2399
elf_generate_asm_lineno (void)
2400
{
2401
#ifdef NEED_ECOFF_DEBUG
2402
  if (ECOFF_DEBUGGING)
2403
    ecoff_generate_asm_lineno ();
2404
#endif
2405
}
2406
 
2407
static void
2408
elf_process_stab (segT sec ATTRIBUTE_UNUSED,
2409
                  int what ATTRIBUTE_UNUSED,
2410
                  const char *string ATTRIBUTE_UNUSED,
2411
                  int type ATTRIBUTE_UNUSED,
2412
                  int other ATTRIBUTE_UNUSED,
2413
                  int desc ATTRIBUTE_UNUSED)
2414
{
2415
#ifdef NEED_ECOFF_DEBUG
2416
  if (ECOFF_DEBUGGING)
2417
    ecoff_stab (sec, what, string, type, other, desc);
2418
#endif
2419
}
2420
 
2421
static int
2422
elf_separate_stab_sections (void)
2423
{
2424
#ifdef NEED_ECOFF_DEBUG
2425
  return (!ECOFF_DEBUGGING);
2426
#else
2427
  return 1;
2428
#endif
2429
}
2430
 
2431
static void
2432
elf_init_stab_section (segT seg)
2433
{
2434
#ifdef NEED_ECOFF_DEBUG
2435
  if (!ECOFF_DEBUGGING)
2436
#endif
2437
    obj_elf_init_stab_section (seg);
2438
}
2439
 
2440
const struct format_ops elf_format_ops =
2441
{
2442
  bfd_target_elf_flavour,
2443
  0,     /* dfl_leading_underscore */
2444
  1,    /* emit_section_symbols */
2445
  elf_begin,
2446
  elf_file_symbol,
2447
  elf_frob_symbol,
2448
  elf_frob_file,
2449
  elf_frob_file_before_adjust,
2450
  0,     /* obj_frob_file_before_fix */
2451
  elf_frob_file_after_relocs,
2452
  elf_s_get_size, elf_s_set_size,
2453
  elf_s_get_align, elf_s_set_align,
2454
  elf_s_get_other,
2455
  elf_s_set_other,
2456
  0,     /* s_get_desc */
2457
  0,     /* s_set_desc */
2458
  0,     /* s_get_type */
2459
  0,     /* s_set_type */
2460
  elf_copy_symbol_attributes,
2461
  elf_generate_asm_lineno,
2462
  elf_process_stab,
2463
  elf_separate_stab_sections,
2464
  elf_init_stab_section,
2465
  elf_sec_sym_ok_for_reloc,
2466
  elf_pop_insert,
2467
#ifdef NEED_ECOFF_DEBUG
2468
  elf_ecoff_set_ext,
2469
#else
2470
  0,     /* ecoff_set_ext */
2471
#endif
2472
  elf_obj_read_begin_hook,
2473
  elf_obj_symbol_new_hook,
2474
  0,
2475
  elf_adjust_symtab
2476
};

powered by: WebSVN 2.1.0

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