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 299

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 166 khays
   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 16 khays
   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 166 khays
obj_elf_parse_section_letters (char *str, size_t len, bfd_boolean *is_clone)
745 16 khays
{
746
  bfd_vma attr = 0;
747 166 khays
  *is_clone = FALSE;
748 16 khays
 
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 166 khays
          *is_clone = TRUE;
779 16 khays
          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 166 khays
          bfd_boolean is_clone;
982 16 khays
 
983
          beg = demand_copy_C_string (&dummy);
984
          if (beg == NULL)
985
            {
986
              ignore_rest_of_line ();
987
              return;
988
            }
989 166 khays
          attr |= obj_elf_parse_section_letters (beg, strlen (beg), &is_clone);
990 16 khays
 
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 166 khays
          if ((attr & SHF_GROUP) != 0 && is_clone)
1042 16 khays
            {
1043
              as_warn (_("? section flag ignored with G present"));
1044 166 khays
              is_clone = FALSE;
1045 16 khays
            }
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 166 khays
          if (is_clone)
1067 16 khays
            {
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 166 khays
            || bed->elf_osabi == ELFOSABI_FREEBSD
1706 160 khays
            /* GNU is still using the default value 0.  */
1707 16 khays
            || bed->elf_osabi == ELFOSABI_NONE))
1708 166 khays
        as_bad (_("symbol type \"%s\" is supported only by GNU and FreeBSD targets"),
1709 16 khays
                type_name);
1710
      type = BSF_FUNCTION | BSF_GNU_INDIRECT_FUNCTION;
1711
    }
1712
  else if (strcmp (type_name, "gnu_unique_object") == 0)
1713
    {
1714
      struct elf_backend_data *bed;
1715
 
1716
      bed = (struct elf_backend_data *) get_elf_backend_data (stdoutput);
1717 160 khays
      if (!(bed->elf_osabi == ELFOSABI_GNU
1718
            /* GNU is still using the default value 0.  */
1719 16 khays
            || bed->elf_osabi == ELFOSABI_NONE))
1720
        as_bad (_("symbol type \"%s\" is supported only by GNU targets"),
1721
                type_name);
1722
      type = BSF_OBJECT | BSF_GNU_UNIQUE;
1723 160 khays
      /* PR 10549: Always set OSABI field to GNU for objects containing unique symbols.  */
1724
      bed->elf_osabi = ELFOSABI_GNU;
1725 16 khays
    }
1726
#ifdef md_elf_symbol_type
1727
  else if ((type = md_elf_symbol_type (type_name, sym, elfsym)) != -1)
1728
    ;
1729
#endif
1730
  else
1731
    as_bad (_("unrecognized symbol type \"%s\""), type_name);
1732
 
1733
  *input_line_pointer = c;
1734
 
1735
  if (*input_line_pointer == '"')
1736
    ++input_line_pointer;
1737
 
1738
  elfsym->symbol.flags |= type;
1739
 
1740
  demand_empty_rest_of_line ();
1741
}
1742
 
1743
static void
1744
obj_elf_ident (int ignore ATTRIBUTE_UNUSED)
1745
{
1746
  static segT comment_section;
1747
  segT old_section = now_seg;
1748
  int old_subsection = now_subseg;
1749
 
1750
#ifdef md_flush_pending_output
1751
  md_flush_pending_output ();
1752
#endif
1753
 
1754
  if (!comment_section)
1755
    {
1756
      char *p;
1757
      comment_section = subseg_new (".comment", 0);
1758
      bfd_set_section_flags (stdoutput, comment_section,
1759
                             SEC_READONLY | SEC_HAS_CONTENTS
1760
                             | SEC_MERGE | SEC_STRINGS);
1761
      comment_section->entsize = 1;
1762
#ifdef md_elf_section_change_hook
1763
      md_elf_section_change_hook ();
1764
#endif
1765
      p = frag_more (1);
1766
      *p = 0;
1767
    }
1768
  else
1769
    subseg_set (comment_section, 0);
1770
  stringer (8 + 1);
1771
  subseg_set (old_section, old_subsection);
1772
}
1773
 
1774
#ifdef INIT_STAB_SECTION
1775
 
1776
/* The first entry in a .stabs section is special.  */
1777
 
1778
void
1779
obj_elf_init_stab_section (segT seg)
1780
{
1781
  char *file;
1782
  char *p;
1783
  char *stabstr_name;
1784
  unsigned int stroff;
1785
 
1786
  /* Force the section to align to a longword boundary.  Without this,
1787
     UnixWare ar crashes.  */
1788
  bfd_set_section_alignment (stdoutput, seg, 2);
1789
 
1790
  /* Make space for this first symbol.  */
1791
  p = frag_more (12);
1792
  /* Zero it out.  */
1793
  memset (p, 0, 12);
1794
  as_where (&file, NULL);
1795
  stabstr_name = (char *) xmalloc (strlen (segment_name (seg)) + 4);
1796
  strcpy (stabstr_name, segment_name (seg));
1797
  strcat (stabstr_name, "str");
1798
  stroff = get_stab_string_offset (file, stabstr_name);
1799
  know (stroff == 1 || (stroff == 0 && file[0] == '\0'));
1800
  md_number_to_chars (p, stroff, 4);
1801
  seg_info (seg)->stabu.p = p;
1802
}
1803
 
1804
#endif
1805
 
1806
/* Fill in the counts in the first entry in a .stabs section.  */
1807
 
1808
static void
1809
adjust_stab_sections (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1810
{
1811
  char *name;
1812
  asection *strsec;
1813
  char *p;
1814
  int strsz, nsyms;
1815
 
1816
  if (strncmp (".stab", sec->name, 5))
1817
    return;
1818
  if (!strcmp ("str", sec->name + strlen (sec->name) - 3))
1819
    return;
1820
 
1821
  name = (char *) alloca (strlen (sec->name) + 4);
1822
  strcpy (name, sec->name);
1823
  strcat (name, "str");
1824
  strsec = bfd_get_section_by_name (abfd, name);
1825
  if (strsec)
1826
    strsz = bfd_section_size (abfd, strsec);
1827
  else
1828
    strsz = 0;
1829
  nsyms = bfd_section_size (abfd, sec) / 12 - 1;
1830
 
1831
  p = seg_info (sec)->stabu.p;
1832
  gas_assert (p != 0);
1833
 
1834
  bfd_h_put_16 (abfd, nsyms, p + 6);
1835
  bfd_h_put_32 (abfd, strsz, p + 8);
1836
}
1837
 
1838
#ifdef NEED_ECOFF_DEBUG
1839
 
1840
/* This function is called by the ECOFF code.  It is supposed to
1841
   record the external symbol information so that the backend can
1842
   write it out correctly.  The ELF backend doesn't actually handle
1843
   this at the moment, so we do it ourselves.  We save the information
1844
   in the symbol.  */
1845
 
1846
#ifdef OBJ_MAYBE_ELF
1847
static
1848
#endif
1849
void
1850
elf_ecoff_set_ext (symbolS *sym, struct ecoff_extr *ext)
1851
{
1852
  symbol_get_bfdsym (sym)->udata.p = ext;
1853
}
1854
 
1855
/* This function is called by bfd_ecoff_debug_externals.  It is
1856
   supposed to *EXT to the external symbol information, and return
1857
   whether the symbol should be used at all.  */
1858
 
1859
static bfd_boolean
1860
elf_get_extr (asymbol *sym, EXTR *ext)
1861
{
1862
  if (sym->udata.p == NULL)
1863
    return FALSE;
1864
  *ext = *(EXTR *) sym->udata.p;
1865
  return TRUE;
1866
}
1867
 
1868
/* This function is called by bfd_ecoff_debug_externals.  It has
1869
   nothing to do for ELF.  */
1870
 
1871
static void
1872
elf_set_index (asymbol *sym ATTRIBUTE_UNUSED,
1873
               bfd_size_type indx ATTRIBUTE_UNUSED)
1874
{
1875
}
1876
 
1877
#endif /* NEED_ECOFF_DEBUG */
1878
 
1879
void
1880
elf_frob_symbol (symbolS *symp, int *puntp)
1881
{
1882
  struct elf_obj_sy *sy_obj;
1883
  expressionS *size;
1884
 
1885
#ifdef NEED_ECOFF_DEBUG
1886
  if (ECOFF_DEBUGGING)
1887
    ecoff_frob_symbol (symp);
1888
#endif
1889
 
1890
  sy_obj = symbol_get_obj (symp);
1891
 
1892
  size = sy_obj->size;
1893
  if (size != NULL)
1894
    {
1895
      if (resolve_expression (size)
1896
          && size->X_op == O_constant)
1897
        S_SET_SIZE (symp, size->X_add_number);
1898
      else
1899
        {
1900
          if (flag_size_check == size_check_error)
1901
            as_bad (_(".size expression for %s "
1902
                      "does not evaluate to a constant"), S_GET_NAME (symp));
1903
          else
1904
            as_warn (_(".size expression for %s "
1905
                       "does not evaluate to a constant"), S_GET_NAME (symp));
1906
        }
1907
      free (sy_obj->size);
1908
      sy_obj->size = NULL;
1909
    }
1910
 
1911
  if (sy_obj->versioned_name != NULL)
1912
    {
1913
      char *p;
1914
 
1915
      p = strchr (sy_obj->versioned_name, ELF_VER_CHR);
1916
      know (p != NULL);
1917
 
1918
      /* This symbol was given a new name with the .symver directive.
1919
 
1920
         If this is an external reference, just rename the symbol to
1921
         include the version string.  This will make the relocs be
1922
         against the correct versioned symbol.
1923
 
1924
         If this is a definition, add an alias.  FIXME: Using an alias
1925
         will permit the debugging information to refer to the right
1926
         symbol.  However, it's not clear whether it is the best
1927
         approach.  */
1928
 
1929
      if (! S_IS_DEFINED (symp))
1930
        {
1931
          /* Verify that the name isn't using the @@ syntax--this is
1932
             reserved for definitions of the default version to link
1933
             against.  */
1934
          if (p[1] == ELF_VER_CHR)
1935
            {
1936
              as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1937
                      sy_obj->versioned_name);
1938
              *puntp = TRUE;
1939
            }
1940
          S_SET_NAME (symp, sy_obj->versioned_name);
1941
        }
1942
      else
1943
        {
1944
          if (p[1] == ELF_VER_CHR && p[2] == ELF_VER_CHR)
1945
            {
1946
              size_t l;
1947
 
1948
              /* The @@@ syntax is a special case. It renames the
1949
                 symbol name to versioned_name with one `@' removed.  */
1950
              l = strlen (&p[3]) + 1;
1951
              memmove (&p[2], &p[3], l);
1952
              S_SET_NAME (symp, sy_obj->versioned_name);
1953
            }
1954
          else
1955
            {
1956
              symbolS *symp2;
1957
 
1958
              /* FIXME: Creating a new symbol here is risky.  We're
1959
                 in the final loop over the symbol table.  We can
1960
                 get away with it only because the symbol goes to
1961
                 the end of the list, where the loop will still see
1962
                 it.  It would probably be better to do this in
1963
                 obj_frob_file_before_adjust.  */
1964
 
1965
              symp2 = symbol_find_or_make (sy_obj->versioned_name);
1966
 
1967
              /* Now we act as though we saw symp2 = sym.  */
1968
 
1969
              S_SET_SEGMENT (symp2, S_GET_SEGMENT (symp));
1970
 
1971
              /* Subtracting out the frag address here is a hack
1972
                 because we are in the middle of the final loop.  */
1973
              S_SET_VALUE (symp2,
1974
                           (S_GET_VALUE (symp)
1975
                            - symbol_get_frag (symp)->fr_address));
1976
 
1977
              symbol_set_frag (symp2, symbol_get_frag (symp));
1978
 
1979
              /* This will copy over the size information.  */
1980
              copy_symbol_attributes (symp2, symp);
1981
 
1982
              S_SET_OTHER (symp2, S_GET_OTHER (symp));
1983
 
1984
              if (S_IS_WEAK (symp))
1985
                S_SET_WEAK (symp2);
1986
 
1987
              if (S_IS_EXTERNAL (symp))
1988
                S_SET_EXTERNAL (symp2);
1989
            }
1990
        }
1991
    }
1992
 
1993
  /* Double check weak symbols.  */
1994
  if (S_IS_WEAK (symp))
1995
    {
1996
      if (S_IS_COMMON (symp))
1997
        as_bad (_("symbol `%s' can not be both weak and common"),
1998
                S_GET_NAME (symp));
1999
    }
2000
 
2001
#ifdef TC_MIPS
2002
  /* The Irix 5 and 6 assemblers set the type of any common symbol and
2003
     any undefined non-function symbol to STT_OBJECT.  We try to be
2004
     compatible, since newer Irix 5 and 6 linkers care.  However, we
2005
     only set undefined symbols to be STT_OBJECT if we are on Irix,
2006
     because that is the only time gcc will generate the necessary
2007
     .global directives to mark functions.  */
2008
 
2009
  if (S_IS_COMMON (symp))
2010
    symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
2011
 
2012
  if (strstr (TARGET_OS, "irix") != NULL
2013
      && ! S_IS_DEFINED (symp)
2014
      && (symbol_get_bfdsym (symp)->flags & BSF_FUNCTION) == 0)
2015
    symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
2016
#endif
2017
}
2018
 
2019
struct group_list
2020
{
2021
  asection **head;              /* Section lists.  */
2022
  unsigned int *elt_count;      /* Number of sections in each list.  */
2023
  unsigned int num_group;       /* Number of lists.  */
2024
  struct hash_control *indexes; /* Maps group name to index in head array.  */
2025
};
2026
 
2027
/* Called via bfd_map_over_sections.  If SEC is a member of a group,
2028
   add it to a list of sections belonging to the group.  INF is a
2029
   pointer to a struct group_list, which is where we store the head of
2030
   each list.  */
2031
 
2032
static void
2033
build_group_lists (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
2034
{
2035
  struct group_list *list = (struct group_list *) inf;
2036
  const char *group_name = elf_group_name (sec);
2037
  unsigned int i;
2038
  unsigned int *elem_idx;
2039
  unsigned int *idx_ptr;
2040
 
2041
  if (group_name == NULL)
2042
    return;
2043
 
2044
  /* If this group already has a list, add the section to the head of
2045
     the list.  */
2046
  elem_idx = (unsigned int *) hash_find (list->indexes, group_name);
2047
  if (elem_idx != NULL)
2048
    {
2049
      elf_next_in_group (sec) = list->head[*elem_idx];
2050
      list->head[*elem_idx] = sec;
2051
      list->elt_count[*elem_idx] += 1;
2052
      return;
2053
    }
2054
 
2055
  /* New group.  Make the arrays bigger in chunks to minimize calls to
2056
     realloc.  */
2057
  i = list->num_group;
2058
  if ((i & 127) == 0)
2059
    {
2060
      unsigned int newsize = i + 128;
2061
      list->head = (asection **) xrealloc (list->head,
2062
                                           newsize * sizeof (*list->head));
2063
      list->elt_count = (unsigned int *)
2064
          xrealloc (list->elt_count, newsize * sizeof (*list->elt_count));
2065
    }
2066
  list->head[i] = sec;
2067
  list->elt_count[i] = 1;
2068
  list->num_group += 1;
2069
 
2070
  /* Add index to hash.  */
2071
  idx_ptr = (unsigned int *) xmalloc (sizeof (unsigned int));
2072
  *idx_ptr = i;
2073
  hash_insert (list->indexes, group_name, idx_ptr);
2074
}
2075
 
2076
static void free_section_idx (const char *key ATTRIBUTE_UNUSED, void *val)
2077
{
2078
  free ((unsigned int *) val);
2079
}
2080
 
2081
void
2082
elf_adjust_symtab (void)
2083
{
2084
  struct group_list list;
2085
  unsigned int i;
2086
 
2087
  /* Go find section groups.  */
2088
  list.num_group = 0;
2089
  list.head = NULL;
2090
  list.elt_count = NULL;
2091
  list.indexes = hash_new ();
2092
  bfd_map_over_sections (stdoutput, build_group_lists, &list);
2093
 
2094
  /* Make the SHT_GROUP sections that describe each section group.  We
2095
     can't set up the section contents here yet, because elf section
2096
     indices have yet to be calculated.  elf.c:set_group_contents does
2097
     the rest of the work.  */
2098
 for (i = 0; i < list.num_group; i++)
2099
    {
2100
      const char *group_name = elf_group_name (list.head[i]);
2101
      const char *sec_name;
2102
      asection *s;
2103
      flagword flags;
2104
      struct symbol *sy;
2105
      bfd_size_type size;
2106
 
2107
      flags = SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_GROUP;
2108
      for (s = list.head[i]; s != NULL; s = elf_next_in_group (s))
2109
        if ((s->flags ^ flags) & SEC_LINK_ONCE)
2110
          {
2111
            flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2112
            if (s != list.head[i])
2113
              {
2114
                as_warn (_("assuming all members of group `%s' are COMDAT"),
2115
                         group_name);
2116
                break;
2117
              }
2118
          }
2119
 
2120
      sec_name = ".group";
2121
      s = subseg_force_new (sec_name, 0);
2122
      if (s == NULL
2123
          || !bfd_set_section_flags (stdoutput, s, flags)
2124
          || !bfd_set_section_alignment (stdoutput, s, 2))
2125
        {
2126
          as_fatal (_("can't create group: %s"),
2127
                    bfd_errmsg (bfd_get_error ()));
2128
        }
2129
      elf_section_type (s) = SHT_GROUP;
2130
 
2131
      /* Pass a pointer to the first section in this group.  */
2132
      elf_next_in_group (s) = list.head[i];
2133
      /* Make sure that the signature symbol for the group has the
2134
         name of the group.  */
2135
      sy = symbol_find_exact (group_name);
2136
      if (!sy
2137
          || (sy != symbol_lastP
2138
              && (sy->sy_next == NULL
2139
                  || sy->sy_next->sy_previous != sy)))
2140
        {
2141
          /* Create the symbol now.  */
2142
          sy = symbol_new (group_name, now_seg, (valueT) 0, frag_now);
2143
#ifdef TE_SOLARIS
2144
          /* Before Solaris 11 build 154, Sun ld rejects local group
2145
             signature symbols, so make them weak hidden instead.  */
2146
          symbol_get_bfdsym (sy)->flags |= BSF_WEAK;
2147
          S_SET_OTHER (sy, STV_HIDDEN);
2148
#else
2149
          symbol_get_obj (sy)->local = 1;
2150
#endif
2151
          symbol_table_insert (sy);
2152
        }
2153
      elf_group_id (s) = symbol_get_bfdsym (sy);
2154
 
2155
      size = 4 * (list.elt_count[i] + 1);
2156
      bfd_set_section_size (stdoutput, s, size);
2157
      s->contents = (unsigned char *) frag_more (size);
2158
      frag_now->fr_fix = frag_now_fix_octets ();
2159
      frag_wane (frag_now);
2160
    }
2161
 
2162
  /* Cleanup hash.  */
2163
  hash_traverse (list.indexes, free_section_idx);
2164
  hash_die (list.indexes);
2165
}
2166
 
2167
void
2168
elf_frob_file (void)
2169
{
2170
  bfd_map_over_sections (stdoutput, adjust_stab_sections, NULL);
2171
 
2172
#ifdef elf_tc_final_processing
2173
  elf_tc_final_processing ();
2174
#endif
2175
}
2176
 
2177
/* It removes any unneeded versioned symbols from the symbol table.  */
2178
 
2179
void
2180
elf_frob_file_before_adjust (void)
2181
{
2182
  if (symbol_rootP)
2183
    {
2184
      symbolS *symp;
2185
 
2186
      for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2187
        if (!S_IS_DEFINED (symp))
2188
          {
2189
            if (symbol_get_obj (symp)->versioned_name)
2190
              {
2191
                char *p;
2192
 
2193
                /* The @@@ syntax is a special case. If the symbol is
2194
                   not defined, 2 `@'s will be removed from the
2195
                   versioned_name.  */
2196
 
2197
                p = strchr (symbol_get_obj (symp)->versioned_name,
2198
                            ELF_VER_CHR);
2199
                know (p != NULL);
2200
                if (p[1] == ELF_VER_CHR && p[2] == ELF_VER_CHR)
2201
                  {
2202
                    size_t l = strlen (&p[3]) + 1;
2203
                    memmove (&p[1], &p[3], l);
2204
                  }
2205
                if (symbol_used_p (symp) == 0
2206
                    && symbol_used_in_reloc_p (symp) == 0)
2207
                  symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2208
              }
2209
 
2210
            /* If there was .weak foo, but foo was neither defined nor
2211
               used anywhere, remove it.  */
2212
 
2213
            else if (S_IS_WEAK (symp)
2214
                     && symbol_used_p (symp) == 0
2215
                     && symbol_used_in_reloc_p (symp) == 0)
2216
              symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2217
          }
2218
    }
2219
}
2220
 
2221
/* It is required that we let write_relocs have the opportunity to
2222
   optimize away fixups before output has begun, since it is possible
2223
   to eliminate all fixups for a section and thus we never should
2224
   have generated the relocation section.  */
2225
 
2226
void
2227
elf_frob_file_after_relocs (void)
2228
{
2229
#ifdef NEED_ECOFF_DEBUG
2230
  if (ECOFF_DEBUGGING)
2231
    /* Generate the ECOFF debugging information.  */
2232
    {
2233
      const struct ecoff_debug_swap *debug_swap;
2234
      struct ecoff_debug_info debug;
2235
      char *buf;
2236
      asection *sec;
2237
 
2238
      debug_swap
2239
        = get_elf_backend_data (stdoutput)->elf_backend_ecoff_debug_swap;
2240
      know (debug_swap != NULL);
2241
      ecoff_build_debug (&debug.symbolic_header, &buf, debug_swap);
2242
 
2243
      /* Set up the pointers in debug.  */
2244
#define SET(ptr, offset, type) \
2245
    debug.ptr = (type) (buf + debug.symbolic_header.offset)
2246
 
2247
      SET (line, cbLineOffset, unsigned char *);
2248
      SET (external_dnr, cbDnOffset, void *);
2249
      SET (external_pdr, cbPdOffset, void *);
2250
      SET (external_sym, cbSymOffset, void *);
2251
      SET (external_opt, cbOptOffset, void *);
2252
      SET (external_aux, cbAuxOffset, union aux_ext *);
2253
      SET (ss, cbSsOffset, char *);
2254
      SET (external_fdr, cbFdOffset, void *);
2255
      SET (external_rfd, cbRfdOffset, void *);
2256
      /* ssext and external_ext are set up just below.  */
2257
 
2258
#undef SET
2259
 
2260
      /* Set up the external symbols.  */
2261
      debug.ssext = debug.ssext_end = NULL;
2262
      debug.external_ext = debug.external_ext_end = NULL;
2263
      if (! bfd_ecoff_debug_externals (stdoutput, &debug, debug_swap, TRUE,
2264
                                       elf_get_extr, elf_set_index))
2265
        as_fatal (_("failed to set up debugging information: %s"),
2266
                  bfd_errmsg (bfd_get_error ()));
2267
 
2268
      sec = bfd_get_section_by_name (stdoutput, ".mdebug");
2269
      gas_assert (sec != NULL);
2270
 
2271
      know (!stdoutput->output_has_begun);
2272
 
2273
      /* We set the size of the section, call bfd_set_section_contents
2274
         to force the ELF backend to allocate a file position, and then
2275
         write out the data.  FIXME: Is this really the best way to do
2276
         this?  */
2277
      bfd_set_section_size
2278
        (stdoutput, sec, bfd_ecoff_debug_size (stdoutput, &debug, debug_swap));
2279
 
2280
      /* Pass BUF to bfd_set_section_contents because this will
2281
         eventually become a call to fwrite, and ISO C prohibits
2282
         passing a NULL pointer to a stdio function even if the
2283
         pointer will not be used.  */
2284
      if (! bfd_set_section_contents (stdoutput, sec, buf, 0, 0))
2285
        as_fatal (_("can't start writing .mdebug section: %s"),
2286
                  bfd_errmsg (bfd_get_error ()));
2287
 
2288
      know (stdoutput->output_has_begun);
2289
      know (sec->filepos != 0);
2290
 
2291
      if (! bfd_ecoff_write_debug (stdoutput, &debug, debug_swap,
2292
                                   sec->filepos))
2293
        as_fatal (_("could not write .mdebug section: %s"),
2294
                  bfd_errmsg (bfd_get_error ()));
2295
    }
2296
#endif /* NEED_ECOFF_DEBUG */
2297
}
2298
 
2299
#ifdef SCO_ELF
2300
 
2301
/* Heavily plagiarized from obj_elf_version.  The idea is to emit the
2302
   SCO specific identifier in the .notes section to satisfy the SCO
2303
   linker.
2304
 
2305
   This looks more complicated than it really is.  As opposed to the
2306
   "obvious" solution, this should handle the cross dev cases
2307
   correctly.  (i.e, hosting on a 64 bit big endian processor, but
2308
   generating SCO Elf code) Efficiency isn't a concern, as there
2309
   should be exactly one of these sections per object module.
2310
 
2311
   SCO OpenServer 5 identifies it's ELF modules with a standard ELF
2312
   .note section.
2313
 
2314
   int_32 namesz  = 4 ;  Name size
2315
   int_32 descsz  = 12 ; Descriptive information
2316
   int_32 type    = 1 ;
2317
   char   name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
2318
   int_32 version = (major ver # << 16)  | version of tools ;
2319
   int_32 source  = (tool_id << 16 ) | 1 ;
2320
   int_32 info    = 0 ;    These are set by the SCO tools, but we
2321
                           don't know enough about the source
2322
                           environment to set them.  SCO ld currently
2323
                           ignores them, and recommends we set them
2324
                           to zero.  */
2325
 
2326
#define SCO_MAJOR_VERSION 0x1
2327
#define SCO_MINOR_VERSION 0x1
2328
 
2329
void
2330
sco_id (void)
2331
{
2332
 
2333
  char *name;
2334
  unsigned int c;
2335
  char ch;
2336
  char *p;
2337
  asection *seg = now_seg;
2338
  subsegT subseg = now_subseg;
2339
  Elf_Internal_Note i_note;
2340
  Elf_External_Note e_note;
2341
  asection *note_secp = NULL;
2342
  int i, len;
2343
 
2344
  /* create the .note section */
2345
 
2346
  note_secp = subseg_new (".note", 0);
2347
  bfd_set_section_flags (stdoutput,
2348
                         note_secp,
2349
                         SEC_HAS_CONTENTS | SEC_READONLY);
2350
 
2351
  /* process the version string */
2352
 
2353
  i_note.namesz = 4;
2354
  i_note.descsz = 12;           /* 12 descriptive bytes */
2355
  i_note.type = NT_VERSION;     /* Contains a version string */
2356
 
2357
  p = frag_more (sizeof (i_note.namesz));
2358
  md_number_to_chars (p, i_note.namesz, 4);
2359
 
2360
  p = frag_more (sizeof (i_note.descsz));
2361
  md_number_to_chars (p, i_note.descsz, 4);
2362
 
2363
  p = frag_more (sizeof (i_note.type));
2364
  md_number_to_chars (p, i_note.type, 4);
2365
 
2366
  p = frag_more (4);
2367
  strcpy (p, "SCO");
2368
 
2369
  /* Note: this is the version number of the ELF we're representing */
2370
  p = frag_more (4);
2371
  md_number_to_chars (p, (SCO_MAJOR_VERSION << 16) | (SCO_MINOR_VERSION), 4);
2372
 
2373
  /* Here, we pick a magic number for ourselves (yes, I "registered"
2374
     it with SCO.  The bottom bit shows that we are compat with the
2375
     SCO ABI.  */
2376
  p = frag_more (4);
2377
  md_number_to_chars (p, 0x4c520000 | 0x0001, 4);
2378
 
2379
  /* If we knew (or cared) what the source language options were, we'd
2380
     fill them in here.  SCO has given us permission to ignore these
2381
     and just set them to zero.  */
2382
  p = frag_more (4);
2383
  md_number_to_chars (p, 0x0000, 4);
2384
 
2385
  frag_align (2, 0, 0);
2386
 
2387
  /* We probably can't restore the current segment, for there likely
2388
     isn't one yet...  */
2389
  if (seg && subseg)
2390
    subseg_set (seg, subseg);
2391
 
2392
}
2393
 
2394
#endif /* SCO_ELF */
2395
 
2396
static void
2397
elf_generate_asm_lineno (void)
2398
{
2399
#ifdef NEED_ECOFF_DEBUG
2400
  if (ECOFF_DEBUGGING)
2401
    ecoff_generate_asm_lineno ();
2402
#endif
2403
}
2404
 
2405
static void
2406
elf_process_stab (segT sec ATTRIBUTE_UNUSED,
2407
                  int what ATTRIBUTE_UNUSED,
2408
                  const char *string ATTRIBUTE_UNUSED,
2409
                  int type ATTRIBUTE_UNUSED,
2410
                  int other ATTRIBUTE_UNUSED,
2411
                  int desc ATTRIBUTE_UNUSED)
2412
{
2413
#ifdef NEED_ECOFF_DEBUG
2414
  if (ECOFF_DEBUGGING)
2415
    ecoff_stab (sec, what, string, type, other, desc);
2416
#endif
2417
}
2418
 
2419
static int
2420
elf_separate_stab_sections (void)
2421
{
2422
#ifdef NEED_ECOFF_DEBUG
2423
  return (!ECOFF_DEBUGGING);
2424
#else
2425
  return 1;
2426
#endif
2427
}
2428
 
2429
static void
2430
elf_init_stab_section (segT seg)
2431
{
2432
#ifdef NEED_ECOFF_DEBUG
2433
  if (!ECOFF_DEBUGGING)
2434
#endif
2435
    obj_elf_init_stab_section (seg);
2436
}
2437
 
2438
const struct format_ops elf_format_ops =
2439
{
2440
  bfd_target_elf_flavour,
2441
  0,     /* dfl_leading_underscore */
2442
  1,    /* emit_section_symbols */
2443
  elf_begin,
2444
  elf_file_symbol,
2445
  elf_frob_symbol,
2446
  elf_frob_file,
2447
  elf_frob_file_before_adjust,
2448
  0,     /* obj_frob_file_before_fix */
2449
  elf_frob_file_after_relocs,
2450
  elf_s_get_size, elf_s_set_size,
2451
  elf_s_get_align, elf_s_set_align,
2452
  elf_s_get_other,
2453
  elf_s_set_other,
2454
  0,     /* s_get_desc */
2455
  0,     /* s_set_desc */
2456
  0,     /* s_get_type */
2457
  0,     /* s_set_type */
2458
  elf_copy_symbol_attributes,
2459
  elf_generate_asm_lineno,
2460
  elf_process_stab,
2461
  elf_separate_stab_sections,
2462
  elf_init_stab_section,
2463
  elf_sec_sym_ok_for_reloc,
2464
  elf_pop_insert,
2465
#ifdef NEED_ECOFF_DEBUG
2466
  elf_ecoff_set_ext,
2467
#else
2468
  0,     /* ecoff_set_ext */
2469
#endif
2470
  elf_obj_read_begin_hook,
2471
  elf_obj_symbol_new_hook,
2472
  0,
2473
  elf_adjust_symtab
2474
};

powered by: WebSVN 2.1.0

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