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