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