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