1 /* ELF object file format
2 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 2,
10 or (at your option) any later version.
12 GAS is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 the GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 #define OBJ_HEADER "obj-elf.h"
24 #include "safe-ctype.h"
27 #include "struc-symbol.h"
29 #ifndef ECOFF_DEBUGGING
30 #define ECOFF_DEBUGGING 0
32 #define NEED_ECOFF_DEBUG
35 #ifdef NEED_ECOFF_DEBUG
40 #include "elf/alpha.h"
55 static bfd_vma elf_s_get_size PARAMS ((symbolS *));
56 static void elf_s_set_size PARAMS ((symbolS *, bfd_vma));
57 static bfd_vma elf_s_get_align PARAMS ((symbolS *));
58 static void elf_s_set_align PARAMS ((symbolS *, bfd_vma));
59 static void elf_s_set_other PARAMS ((symbolS *, int));
60 static int elf_sec_sym_ok_for_reloc PARAMS ((asection *));
61 static void adjust_stab_sections PARAMS ((bfd *, asection *, PTR));
62 static void build_group_lists PARAMS ((bfd *, asection *, PTR));
63 static int elf_separate_stab_sections PARAMS ((void));
64 static void elf_init_stab_section PARAMS ((segT));
65 static symbolS *elf_common PARAMS ((int));
67 #ifdef NEED_ECOFF_DEBUG
68 static boolean elf_get_extr PARAMS ((asymbol *, EXTR *));
69 static void elf_set_index PARAMS ((asymbol *, bfd_size_type));
72 static void obj_elf_line PARAMS ((int));
73 void obj_elf_version PARAMS ((int));
74 static void obj_elf_size PARAMS ((int));
75 static void obj_elf_type PARAMS ((int));
76 static void obj_elf_ident PARAMS ((int));
77 static void obj_elf_weak PARAMS ((int));
78 static void obj_elf_local PARAMS ((int));
79 static void obj_elf_visibility PARAMS ((int));
80 static void obj_elf_change_section
81 PARAMS ((const char *, int, int, int, const char *, int, int));
82 static int obj_elf_parse_section_letters PARAMS ((char *, size_t));
83 static int obj_elf_section_word PARAMS ((char *, size_t));
84 static char *obj_elf_section_name PARAMS ((void));
85 static int obj_elf_section_type PARAMS ((char *, size_t));
86 static void obj_elf_symver PARAMS ((int));
87 static void obj_elf_subsection PARAMS ((int));
88 static void obj_elf_popsection PARAMS ((int));
89 static void obj_elf_tls_common PARAMS ((int));
91 static const pseudo_typeS elf_pseudo_table[] =
93 {"comm", obj_elf_common, 0},
94 {"common", obj_elf_common, 1},
95 {"ident", obj_elf_ident, 0},
96 {"local", obj_elf_local, 0},
97 {"previous", obj_elf_previous, 0},
98 {"section", obj_elf_section, 0},
99 {"section.s", obj_elf_section, 0},
100 {"sect", obj_elf_section, 0},
101 {"sect.s", obj_elf_section, 0},
102 {"pushsection", obj_elf_section, 1},
103 {"popsection", obj_elf_popsection, 0},
104 {"size", obj_elf_size, 0},
105 {"type", obj_elf_type, 0},
106 {"version", obj_elf_version, 0},
107 {"weak", obj_elf_weak, 0},
109 /* These define symbol visibility. */
110 {"internal", obj_elf_visibility, STV_INTERNAL},
111 {"hidden", obj_elf_visibility, STV_HIDDEN},
112 {"protected", obj_elf_visibility, STV_PROTECTED},
114 /* These are used for stabs-in-elf configurations. */
115 {"line", obj_elf_line, 0},
117 /* This is a GNU extension to handle symbol versions. */
118 {"symver", obj_elf_symver, 0},
120 /* A GNU extension to change subsection only. */
121 {"subsection", obj_elf_subsection, 0},
123 /* These are GNU extensions to aid in garbage collecting C++ vtables. */
124 {"vtable_inherit", (void (*) PARAMS ((int))) &obj_elf_vtable_inherit, 0},
125 {"vtable_entry", (void (*) PARAMS ((int))) &obj_elf_vtable_entry, 0},
127 /* These are used for dwarf. */
132 /* We need to trap the section changing calls to handle .previous. */
133 {"data", obj_elf_data, 0},
134 {"text", obj_elf_text, 0},
136 {"tls_common", obj_elf_tls_common, 0},
142 static const pseudo_typeS ecoff_debug_pseudo_table[] =
144 #ifdef NEED_ECOFF_DEBUG
145 /* COFF style debugging information for ECOFF. .ln is not used; .loc
147 { "def", ecoff_directive_def, 0 },
148 { "dim", ecoff_directive_dim, 0 },
149 { "endef", ecoff_directive_endef, 0 },
150 { "file", ecoff_directive_file, 0 },
151 { "scl", ecoff_directive_scl, 0 },
152 { "tag", ecoff_directive_tag, 0 },
153 { "val", ecoff_directive_val, 0 },
155 /* COFF debugging requires pseudo-ops .size and .type, but ELF
156 already has meanings for those. We use .esize and .etype
157 instead. These are only generated by gcc anyhow. */
158 { "esize", ecoff_directive_size, 0 },
159 { "etype", ecoff_directive_type, 0 },
161 /* ECOFF specific debugging information. */
162 { "begin", ecoff_directive_begin, 0 },
163 { "bend", ecoff_directive_bend, 0 },
164 { "end", ecoff_directive_end, 0 },
165 { "ent", ecoff_directive_ent, 0 },
166 { "fmask", ecoff_directive_fmask, 0 },
167 { "frame", ecoff_directive_frame, 0 },
168 { "loc", ecoff_directive_loc, 0 },
169 { "mask", ecoff_directive_mask, 0 },
171 /* Other ECOFF directives. */
172 { "extern", ecoff_directive_extern, 0 },
174 /* These are used on Irix. I don't know how to implement them. */
175 { "alias", s_ignore, 0 },
176 { "bgnb", s_ignore, 0 },
177 { "endb", s_ignore, 0 },
178 { "lab", s_ignore, 0 },
179 { "noalias", s_ignore, 0 },
180 { "verstamp", s_ignore, 0 },
181 { "vreg", s_ignore, 0 },
184 {NULL, NULL, 0} /* end sentinel */
188 #include "aout/aout64.h"
190 /* This is called when the assembler starts. */
195 /* Add symbols for the known sections to the symbol table. */
196 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput,
197 TEXT_SECTION_NAME)));
198 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput,
199 DATA_SECTION_NAME)));
200 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput,
207 pop_insert (elf_pseudo_table);
209 pop_insert (ecoff_debug_pseudo_table);
216 return S_GET_SIZE (sym);
220 elf_s_set_size (sym, sz)
224 S_SET_SIZE (sym, sz);
228 elf_s_get_align (sym)
231 return S_GET_ALIGN (sym);
235 elf_s_set_align (sym, align)
239 S_SET_ALIGN (sym, align);
243 elf_s_get_other (sym)
246 return elf_symbol (symbol_get_bfdsym (sym))->internal_elf_sym.st_other;
250 elf_s_set_other (sym, other)
254 S_SET_OTHER (sym, other);
258 elf_sec_sym_ok_for_reloc (sec)
261 return obj_sec_sym_ok_for_reloc (sec);
270 sym = symbol_new (s, absolute_section, (valueT) 0, (struct frag *) 0);
271 symbol_set_frag (sym, &zero_address_frag);
272 symbol_get_bfdsym (sym)->flags |= BSF_FILE;
274 if (symbol_rootP != sym)
276 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
277 symbol_insert (sym, symbol_rootP, &symbol_rootP, &symbol_lastP);
279 verify_symbol_chain (symbol_rootP, symbol_lastP);
283 #ifdef NEED_ECOFF_DEBUG
289 elf_common (is_common)
299 if (flag_mri && is_common)
305 name = input_line_pointer;
306 c = get_symbol_end ();
307 /* just after name is now '\0' */
308 p = input_line_pointer;
311 if (*input_line_pointer != ',')
313 as_bad (_("expected comma after symbol-name"));
314 ignore_rest_of_line ();
317 input_line_pointer++; /* skip ',' */
318 if ((temp = get_absolute_expression ()) < 0)
320 as_bad (_(".COMMon length (%d.) <0! Ignored."), temp);
321 ignore_rest_of_line ();
326 symbolP = symbol_find_or_make (name);
328 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
330 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP));
331 ignore_rest_of_line ();
334 if (S_GET_VALUE (symbolP) != 0)
336 if (S_GET_VALUE (symbolP) != (valueT) size)
338 as_warn (_("length of .comm \"%s\" is already %ld; not changed to %d"),
339 S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), size);
342 know (symbolP->sy_frag == &zero_address_frag);
343 if (*input_line_pointer != ',')
348 input_line_pointer++;
351 if (! have_align || *input_line_pointer != '"')
357 temp = get_absolute_expression ();
361 as_warn (_("common alignment negative; 0 assumed"));
364 if (symbol_get_obj (symbolP)->local)
373 old_subsec = now_subseg;
376 /* convert to a power of 2 alignment */
377 for (align = 0; (temp & 1) == 0; temp >>= 1, ++align);
380 as_bad (_("common alignment not a power of 2"));
381 ignore_rest_of_line ();
387 record_alignment (bss_section, align);
388 subseg_set (bss_section, 0);
390 frag_align (align, 0, 0);
391 if (S_GET_SEGMENT (symbolP) == bss_section)
392 symbol_get_frag (symbolP)->fr_symbol = 0;
393 symbol_set_frag (symbolP, frag_now);
394 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
395 (offsetT) size, (char *) 0);
397 S_SET_SIZE (symbolP, size);
398 S_SET_SEGMENT (symbolP, bss_section);
399 S_CLEAR_EXTERNAL (symbolP);
400 subseg_set (old_sec, old_subsec);
405 S_SET_VALUE (symbolP, (valueT) size);
406 S_SET_ALIGN (symbolP, temp);
407 S_SET_EXTERNAL (symbolP);
408 S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
413 input_line_pointer++;
414 /* @@ Some use the dot, some don't. Can we get some consistency?? */
415 if (*input_line_pointer == '.')
416 input_line_pointer++;
417 /* @@ Some say data, some say bss. */
418 if (strncmp (input_line_pointer, "bss\"", 4)
419 && strncmp (input_line_pointer, "data\"", 5))
421 while (*--input_line_pointer != '"')
423 input_line_pointer--;
424 goto bad_common_segment;
426 while (*input_line_pointer++ != '"')
428 goto allocate_common;
431 symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
433 demand_empty_rest_of_line ();
438 p = input_line_pointer;
439 while (*p && *p != '\n')
443 as_bad (_("bad .common segment %s"), input_line_pointer + 1);
445 input_line_pointer = p;
446 ignore_rest_of_line ();
452 obj_elf_common (is_common)
455 elf_common (is_common);
459 obj_elf_tls_common (ignore)
460 int ignore ATTRIBUTE_UNUSED;
462 symbolS *symbolP = elf_common (0);
465 symbol_get_bfdsym (symbolP)->flags |= BSF_THREAD_LOCAL;
469 obj_elf_local (ignore)
470 int ignore ATTRIBUTE_UNUSED;
478 name = input_line_pointer;
479 c = get_symbol_end ();
480 symbolP = symbol_find_or_make (name);
481 *input_line_pointer = c;
483 S_CLEAR_EXTERNAL (symbolP);
484 symbol_get_obj (symbolP)->local = 1;
487 input_line_pointer++;
489 if (*input_line_pointer == '\n')
494 demand_empty_rest_of_line ();
498 obj_elf_weak (ignore)
499 int ignore ATTRIBUTE_UNUSED;
507 name = input_line_pointer;
508 c = get_symbol_end ();
509 symbolP = symbol_find_or_make (name);
510 *input_line_pointer = c;
512 S_SET_WEAK (symbolP);
513 symbol_get_obj (symbolP)->local = 1;
516 input_line_pointer++;
518 if (*input_line_pointer == '\n')
523 demand_empty_rest_of_line ();
527 obj_elf_visibility (visibility)
534 elf_symbol_type *elfsym;
538 name = input_line_pointer;
539 c = get_symbol_end ();
540 symbolP = symbol_find_or_make (name);
541 *input_line_pointer = c;
545 bfdsym = symbol_get_bfdsym (symbolP);
546 elfsym = elf_symbol_from (bfd_asymbol_bfd (bfdsym), bfdsym);
550 elfsym->internal_elf_sym.st_other &= ~3;
551 elfsym->internal_elf_sym.st_other |= visibility;
555 input_line_pointer ++;
559 if (*input_line_pointer == '\n')
565 demand_empty_rest_of_line ();
568 static segT previous_section;
569 static int previous_subsection;
573 struct section_stack *next;
575 int subseg, prev_subseg;
578 static struct section_stack *section_stack;
580 /* Handle the .section pseudo-op. This code supports two different
583 The first is found on Solaris, and looks like
584 .section ".sec1",#alloc,#execinstr,#write
585 Here the names after '#' are the SHF_* flags to turn on for the
586 section. I'm not sure how it determines the SHT_* type (BFD
587 doesn't really give us control over the type, anyhow).
589 The second format is found on UnixWare, and probably most SVR4
590 machines, and looks like
591 .section .sec1,"a",@progbits
592 The quoted string may contain any combination of a, w, x, and
593 represents the SHF_* flags to turn on for the section. The string
594 beginning with '@' can be progbits or nobits. There should be
595 other possibilities, but I don't know what they are. In any case,
596 BFD doesn't really let us set the section type. */
598 /* Certain named sections have particular defined types, listed on p.
600 struct special_section
607 static struct special_section const special_sections[] =
609 { ".bss", SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
610 { ".comment", SHT_PROGBITS, 0 },
611 { ".data", SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
612 { ".data1", SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
613 { ".debug", SHT_PROGBITS, 0 },
614 { ".fini", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
615 { ".init", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
616 { ".line", SHT_PROGBITS, 0 },
617 { ".note", SHT_NOTE, 0 },
618 { ".rodata", SHT_PROGBITS, SHF_ALLOC },
619 { ".rodata1", SHT_PROGBITS, SHF_ALLOC },
620 { ".tbss", SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
621 { ".tdata", SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
622 { ".text", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
624 /* FIXME: The current gcc, as of 2002-03-03, will emit
626 .section .init_array,"aw",@progbits
628 for __attribute__ ((section (".init_array"))). "@progbits" marks
629 the incorrect section type. For now, we make them with
630 SHT_PROGBITS. BFD will fix the section type. Gcc should be changed
636 { ".init_array",SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
637 { ".fini_array",SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
638 { ".preinit_array",SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
640 { ".init_array",SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
641 { ".fini_array",SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
642 { ".preinit_array",SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
645 #ifdef ELF_TC_SPECIAL_SECTIONS
646 ELF_TC_SPECIAL_SECTIONS
650 /* The following section names are special, but they can not
651 reasonably appear in assembler code. Some of the attributes are
652 processor dependent. */
653 { ".dynamic", SHT_DYNAMIC, SHF_ALLOC /* + SHF_WRITE */ },
654 { ".dynstr", SHT_STRTAB, SHF_ALLOC },
655 { ".dynsym", SHT_DYNSYM, SHF_ALLOC },
656 { ".got", SHT_PROGBITS, 0 },
657 { ".hash", SHT_HASH, SHF_ALLOC },
658 { ".interp", SHT_PROGBITS, /* SHF_ALLOC */ },
659 { ".plt", SHT_PROGBITS, 0 },
660 { ".shstrtab",SHT_STRTAB, 0 },
661 { ".strtab", SHT_STRTAB, /* SHF_ALLOC */ },
662 { ".symtab", SHT_SYMTAB, /* SHF_ALLOC */ },
669 obj_elf_change_section (name, type, attr, entsize, group_name, linkonce, push)
674 const char *group_name;
683 #ifdef md_flush_pending_output
684 md_flush_pending_output ();
687 /* Switch to the section, creating it if necessary. */
690 struct section_stack *elt;
691 elt = xmalloc (sizeof (struct section_stack));
692 elt->next = section_stack;
694 elt->prev_seg = previous_section;
695 elt->subseg = now_subseg;
696 elt->prev_subseg = previous_subsection;
699 previous_section = now_seg;
700 previous_subsection = now_subseg;
702 old_sec = bfd_get_section_by_name (stdoutput, name);
703 sec = subseg_new (name, 0);
705 /* See if this is one of the special sections. */
706 for (i = 0; special_sections[i].name != NULL; i++)
707 if (strcmp (name, special_sections[i].name) == 0)
709 if (type == SHT_NULL)
710 type = special_sections[i].type;
711 else if (type != special_sections[i].type)
715 as_warn (_("setting incorrect section type for %s"), name);
719 as_warn (_("ignoring incorrect section type for %s"), name);
720 type = special_sections[i].type;
723 if ((attr &~ special_sections[i].attributes) != 0
726 /* As a GNU extension, we permit a .note section to be
727 allocatable. If the linker sees an allocateable .note
728 section, it will create a PT_NOTE segment in the output
730 if (strcmp (name, ".note") != 0
731 || attr != SHF_ALLOC)
732 as_warn (_("setting incorrect section attributes for %s"),
735 attr |= special_sections[i].attributes;
739 /* Convert ELF type and flags to BFD flags. */
741 | ((attr & SHF_WRITE) ? 0 : SEC_READONLY)
742 | ((attr & SHF_ALLOC) ? SEC_ALLOC : 0)
743 | (((attr & SHF_ALLOC) && type != SHT_NOBITS) ? SEC_LOAD : 0)
744 | ((attr & SHF_EXECINSTR) ? SEC_CODE : 0)
745 | ((attr & SHF_MERGE) ? SEC_MERGE : 0)
746 | ((attr & SHF_STRINGS) ? SEC_STRINGS : 0)
747 | ((attr & SHF_TLS) ? SEC_THREAD_LOCAL : 0));
748 #ifdef md_elf_section_flags
749 flags = md_elf_section_flags (flags, attr, type);
756 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */
757 if (type == SHT_NOBITS)
758 seg_info (sec)->bss = 1;
760 bfd_set_section_flags (stdoutput, sec, flags);
761 if (flags & SEC_MERGE)
762 sec->entsize = entsize;
763 elf_group_name (sec) = group_name;
764 elf_linkonce_p (sec) = linkonce;
766 /* Add a symbol for this section to the symbol table. */
767 secsym = symbol_find (name);
769 symbol_set_bfdsym (secsym, sec->symbol);
771 symbol_table_insert (section_symbol (sec));
775 /* If section attributes are specified the second time we see a
776 particular section, then check that they are the same as we
777 saw the first time. */
778 if (((old_sec->flags ^ flags)
779 & (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
780 | SEC_EXCLUDE | SEC_SORT_ENTRIES | SEC_MERGE | SEC_STRINGS
782 || linkonce != elf_linkonce_p (sec))
783 as_warn (_("ignoring changed section attributes for %s"), name);
784 if ((flags & SEC_MERGE) && old_sec->entsize != (unsigned) entsize)
785 as_warn (_("ignoring changed section entity size for %s"), name);
786 if ((attr & SHF_GROUP) != 0
787 && strcmp (elf_group_name (old_sec), group_name) != 0)
788 as_warn (_("ignoring new section group for %s"), name);
791 #ifdef md_elf_section_change_hook
792 md_elf_section_change_hook ();
797 obj_elf_parse_section_letters (str, len)
814 attr |= SHF_EXECINSTR;
830 if (*(str - 1) == 'a')
833 if (len > 1 && str[1] == 's')
842 char *bad_msg = _("unrecognized .section attribute: want a,w,x,M,S,G,T");
843 #ifdef md_elf_section_letter
844 int md_attr = md_elf_section_letter (*str, &bad_msg);
850 as_warn ("%s", bad_msg);
863 obj_elf_section_word (str, len)
867 if (len == 5 && strncmp (str, "write", 5) == 0)
869 if (len == 5 && strncmp (str, "alloc", 5) == 0)
871 if (len == 9 && strncmp (str, "execinstr", 9) == 0)
872 return SHF_EXECINSTR;
874 #ifdef md_elf_section_word
876 int md_attr = md_elf_section_word (str, len);
882 as_warn (_("unrecognized section attribute"));
887 obj_elf_section_type (str, len)
891 if (len == 8 && strncmp (str, "progbits", 8) == 0)
893 if (len == 6 && strncmp (str, "nobits", 6) == 0)
896 #ifdef md_elf_section_type
898 int md_type = md_elf_section_type (str, len);
904 as_warn (_("unrecognized section type"));
908 /* Get name of section. */
910 obj_elf_section_name ()
915 if (*input_line_pointer == '"')
919 name = demand_copy_C_string (&dummy);
922 ignore_rest_of_line ();
928 char *end = input_line_pointer;
930 while (0 == strchr ("\n\t,; ", *end))
932 if (end == input_line_pointer)
934 as_warn (_("missing name"));
935 ignore_rest_of_line ();
939 name = xmalloc (end - input_line_pointer + 1);
940 memcpy (name, input_line_pointer, end - input_line_pointer);
941 name[end - input_line_pointer] = '\0';
942 input_line_pointer = end;
949 obj_elf_section (push)
952 char *name, *group_name, *beg;
953 int type, attr, dummy;
962 #ifdef md_flush_pending_output
963 md_flush_pending_output ();
966 previous_section = now_seg;
967 previous_subsection = now_subseg;
969 s_mri_sect (&mri_type);
971 #ifdef md_elf_section_change_hook
972 md_elf_section_change_hook ();
977 #endif /* ! defined (TC_I370) */
979 name = obj_elf_section_name ();
988 if (*input_line_pointer == ',')
990 /* Skip the comma. */
991 ++input_line_pointer;
994 if (*input_line_pointer == '"')
996 beg = demand_copy_C_string (&dummy);
999 ignore_rest_of_line ();
1002 attr |= obj_elf_parse_section_letters (beg, strlen (beg));
1005 if (*input_line_pointer == ',')
1008 char *save = input_line_pointer;
1010 ++input_line_pointer;
1012 c = *input_line_pointer;
1015 beg = demand_copy_C_string (&dummy);
1018 ignore_rest_of_line ();
1021 type = obj_elf_section_type (beg, strlen (beg));
1023 else if (c == '@' || c == '%')
1025 beg = ++input_line_pointer;
1026 c = get_symbol_end ();
1027 *input_line_pointer = c;
1028 type = obj_elf_section_type (beg, input_line_pointer - beg);
1031 input_line_pointer = save;
1035 if ((attr & SHF_MERGE) != 0 && *input_line_pointer == ',')
1037 ++input_line_pointer;
1039 entsize = get_absolute_expression ();
1043 as_warn (_("invalid merge entity size"));
1048 else if ((attr & SHF_MERGE) != 0)
1050 as_warn (_("entity size for SHF_MERGE not specified"));
1054 if ((attr & SHF_GROUP) != 0 && *input_line_pointer == ',')
1056 ++input_line_pointer;
1057 group_name = obj_elf_section_name ();
1058 if (group_name == NULL)
1060 else if (strncmp (input_line_pointer, ",comdat", 7) == 0)
1062 input_line_pointer += 7;
1065 else if (strncmp (name, ".gnu.linkonce", 13) == 0)
1068 else if ((attr & SHF_GROUP) != 0)
1070 as_warn (_("group name for SHF_GROUP not specified"));
1081 if (*input_line_pointer != '#')
1083 as_warn (_("character following name is not '#'"));
1084 ignore_rest_of_line ();
1087 beg = ++input_line_pointer;
1088 c = get_symbol_end ();
1089 *input_line_pointer = c;
1091 attr |= obj_elf_section_word (beg, input_line_pointer - beg);
1095 while (*input_line_pointer++ == ',');
1096 --input_line_pointer;
1100 demand_empty_rest_of_line ();
1102 obj_elf_change_section (name, type, attr, entsize, group_name, linkonce, push);
1105 /* Change to the .data section. */
1111 #ifdef md_flush_pending_output
1112 md_flush_pending_output ();
1115 previous_section = now_seg;
1116 previous_subsection = now_subseg;
1119 #ifdef md_elf_section_change_hook
1120 md_elf_section_change_hook ();
1124 /* Change to the .text section. */
1130 #ifdef md_flush_pending_output
1131 md_flush_pending_output ();
1134 previous_section = now_seg;
1135 previous_subsection = now_subseg;
1138 #ifdef md_elf_section_change_hook
1139 md_elf_section_change_hook ();
1144 obj_elf_subsection (ignore)
1145 int ignore ATTRIBUTE_UNUSED;
1149 #ifdef md_flush_pending_output
1150 md_flush_pending_output ();
1153 previous_section = now_seg;
1154 previous_subsection = now_subseg;
1156 temp = get_absolute_expression ();
1157 subseg_set (now_seg, (subsegT) temp);
1158 demand_empty_rest_of_line ();
1160 #ifdef md_elf_section_change_hook
1161 md_elf_section_change_hook ();
1165 /* This can be called from the processor backends if they change
1169 obj_elf_section_change_hook ()
1171 previous_section = now_seg;
1172 previous_subsection = now_subseg;
1176 obj_elf_previous (ignore)
1177 int ignore ATTRIBUTE_UNUSED;
1182 if (previous_section == 0)
1184 as_warn (_(".previous without corresponding .section; ignored"));
1188 #ifdef md_flush_pending_output
1189 md_flush_pending_output ();
1192 new_section = previous_section;
1193 new_subsection = previous_subsection;
1194 previous_section = now_seg;
1195 previous_subsection = now_subseg;
1196 subseg_set (new_section, new_subsection);
1198 #ifdef md_elf_section_change_hook
1199 md_elf_section_change_hook ();
1204 obj_elf_popsection (xxx)
1205 int xxx ATTRIBUTE_UNUSED;
1207 struct section_stack *top = section_stack;
1211 as_warn (_(".popsection without corresponding .pushsection; ignored"));
1215 #ifdef md_flush_pending_output
1216 md_flush_pending_output ();
1219 section_stack = top->next;
1220 previous_section = top->prev_seg;
1221 previous_subsection = top->prev_subseg;
1222 subseg_set (top->seg, top->subseg);
1225 #ifdef md_elf_section_change_hook
1226 md_elf_section_change_hook ();
1231 obj_elf_line (ignore)
1232 int ignore ATTRIBUTE_UNUSED;
1234 /* Assume delimiter is part of expression. BSD4.2 as fails with
1235 delightful bug, so we are not being incompatible here. */
1236 new_logical_line ((char *) NULL, (int) (get_absolute_expression ()));
1237 demand_empty_rest_of_line ();
1240 /* This handles the .symver pseudo-op, which is used to specify a
1241 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1242 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1243 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1244 with the same value as the symbol NAME. */
1247 obj_elf_symver (ignore)
1248 int ignore ATTRIBUTE_UNUSED;
1255 name = input_line_pointer;
1256 c = get_symbol_end ();
1258 sym = symbol_find_or_make (name);
1260 *input_line_pointer = c;
1263 if (*input_line_pointer != ',')
1265 as_bad (_("expected comma after name in .symver"));
1266 ignore_rest_of_line ();
1270 ++input_line_pointer;
1271 name = input_line_pointer;
1273 /* Temporarily include '@' in symbol names. */
1274 old_lexat = lex_type[(unsigned char) '@'];
1275 lex_type[(unsigned char) '@'] |= LEX_NAME;
1276 c = get_symbol_end ();
1277 lex_type[(unsigned char) '@'] = old_lexat;
1279 if (symbol_get_obj (sym)->versioned_name == NULL)
1281 symbol_get_obj (sym)->versioned_name = xstrdup (name);
1283 *input_line_pointer = c;
1285 if (strchr (symbol_get_obj (sym)->versioned_name,
1286 ELF_VER_CHR) == NULL)
1288 as_bad (_("missing version name in `%s' for symbol `%s'"),
1289 symbol_get_obj (sym)->versioned_name,
1291 ignore_rest_of_line ();
1297 if (strcmp (symbol_get_obj (sym)->versioned_name, name))
1299 as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1300 name, symbol_get_obj (sym)->versioned_name,
1302 ignore_rest_of_line ();
1306 *input_line_pointer = c;
1309 demand_empty_rest_of_line ();
1312 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1313 to the linker the hierarchy in which a particular table resides. The
1314 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1317 obj_elf_vtable_inherit (ignore)
1318 int ignore ATTRIBUTE_UNUSED;
1320 char *cname, *pname;
1321 symbolS *csym, *psym;
1324 if (*input_line_pointer == '#')
1325 ++input_line_pointer;
1327 cname = input_line_pointer;
1328 c = get_symbol_end ();
1329 csym = symbol_find (cname);
1331 /* GCFIXME: should check that we don't have two .vtable_inherits for
1332 the same child symbol. Also, we can currently only do this if the
1333 child symbol is already exists and is placed in a fragment. */
1335 if (csym == NULL || symbol_get_frag (csym) == NULL)
1337 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1342 *input_line_pointer = c;
1345 if (*input_line_pointer != ',')
1347 as_bad ("expected comma after name in .vtable_inherit");
1348 ignore_rest_of_line ();
1352 ++input_line_pointer;
1355 if (*input_line_pointer == '#')
1356 ++input_line_pointer;
1358 if (input_line_pointer[0] == '0'
1359 && (input_line_pointer[1] == '\0'
1360 || ISSPACE (input_line_pointer[1])))
1362 psym = section_symbol (absolute_section);
1363 ++input_line_pointer;
1367 pname = input_line_pointer;
1368 c = get_symbol_end ();
1369 psym = symbol_find_or_make (pname);
1370 *input_line_pointer = c;
1373 demand_empty_rest_of_line ();
1378 assert (symbol_get_value_expression (csym)->X_op == O_constant);
1379 return fix_new (symbol_get_frag (csym),
1380 symbol_get_value_expression (csym)->X_add_number,
1381 0, psym, 0, 0, BFD_RELOC_VTABLE_INHERIT);
1384 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1385 to the linker that a vtable slot was used. The syntax is
1386 ".vtable_entry tablename, offset". */
1389 obj_elf_vtable_entry (ignore)
1390 int ignore ATTRIBUTE_UNUSED;
1397 if (*input_line_pointer == '#')
1398 ++input_line_pointer;
1400 name = input_line_pointer;
1401 c = get_symbol_end ();
1402 sym = symbol_find_or_make (name);
1403 *input_line_pointer = c;
1406 if (*input_line_pointer != ',')
1408 as_bad ("expected comma after name in .vtable_entry");
1409 ignore_rest_of_line ();
1413 ++input_line_pointer;
1414 if (*input_line_pointer == '#')
1415 ++input_line_pointer;
1417 offset = get_absolute_expression ();
1419 demand_empty_rest_of_line ();
1421 return fix_new (frag_now, frag_now_fix (), 0, sym, offset, 0,
1422 BFD_RELOC_VTABLE_ENTRY);
1426 elf_obj_read_begin_hook ()
1428 #ifdef NEED_ECOFF_DEBUG
1429 if (ECOFF_DEBUGGING)
1430 ecoff_read_begin_hook ();
1435 elf_obj_symbol_new_hook (symbolP)
1438 struct elf_obj_sy *sy_obj;
1440 sy_obj = symbol_get_obj (symbolP);
1441 sy_obj->size = NULL;
1442 sy_obj->versioned_name = NULL;
1444 #ifdef NEED_ECOFF_DEBUG
1445 if (ECOFF_DEBUGGING)
1446 ecoff_symbol_new_hook (symbolP);
1450 /* When setting one symbol equal to another, by default we probably
1451 want them to have the same "size", whatever it means in the current
1455 elf_copy_symbol_attributes (dest, src)
1456 symbolS *dest, *src;
1458 struct elf_obj_sy *srcelf = symbol_get_obj (src);
1459 struct elf_obj_sy *destelf = symbol_get_obj (dest);
1462 if (destelf->size == NULL)
1464 (expressionS *) xmalloc (sizeof (expressionS));
1465 *destelf->size = *srcelf->size;
1469 if (destelf->size != NULL)
1470 free (destelf->size);
1471 destelf->size = NULL;
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))));
1480 obj_elf_version (ignore)
1481 int ignore ATTRIBUTE_UNUSED;
1486 asection *seg = now_seg;
1487 subsegT subseg = now_subseg;
1488 Elf_Internal_Note i_note;
1489 Elf_External_Note e_note;
1490 asection *note_secp = (asection *) NULL;
1494 if (*input_line_pointer == '\"')
1496 ++input_line_pointer; /* -> 1st char of string. */
1497 name = input_line_pointer;
1499 while (is_a_char (c = next_char_of_string ()))
1501 c = *input_line_pointer;
1502 *input_line_pointer = '\0';
1503 *(input_line_pointer - 1) = '\0';
1504 *input_line_pointer = c;
1506 /* create the .note section */
1508 note_secp = subseg_new (".note", 0);
1509 bfd_set_section_flags (stdoutput,
1511 SEC_HAS_CONTENTS | SEC_READONLY);
1513 /* process the version string */
1515 len = strlen (name);
1517 i_note.namesz = ((len + 1) + 3) & ~3; /* round this to word boundary */
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, (valueT) i_note.namesz, sizeof (e_note.namesz));
1522 p = frag_more (sizeof (e_note.descsz));
1523 md_number_to_chars (p, (valueT) i_note.descsz, sizeof (e_note.descsz));
1524 p = frag_more (sizeof (e_note.type));
1525 md_number_to_chars (p, (valueT) i_note.type, sizeof (e_note.type));
1526 p = frag_more (len + 1);
1529 frag_align (2, 0, 0);
1531 subseg_set (seg, subseg);
1535 as_bad (_("expected quoted string"));
1537 demand_empty_rest_of_line ();
1541 obj_elf_size (ignore)
1542 int ignore ATTRIBUTE_UNUSED;
1544 char *name = input_line_pointer;
1545 char c = get_symbol_end ();
1550 p = input_line_pointer;
1553 if (*input_line_pointer != ',')
1556 as_bad (_("expected comma after name `%s' in .size directive"), name);
1558 ignore_rest_of_line ();
1561 input_line_pointer++;
1563 if (exp.X_op == O_absent)
1565 as_bad (_("missing expression in .size directive"));
1566 exp.X_op = O_constant;
1567 exp.X_add_number = 0;
1570 sym = symbol_find_or_make (name);
1572 if (exp.X_op == O_constant)
1574 S_SET_SIZE (sym, exp.X_add_number);
1575 if (symbol_get_obj (sym)->size)
1577 xfree (symbol_get_obj (sym)->size);
1578 symbol_get_obj (sym)->size = NULL;
1583 symbol_get_obj (sym)->size =
1584 (expressionS *) xmalloc (sizeof (expressionS));
1585 *symbol_get_obj (sym)->size = exp;
1587 demand_empty_rest_of_line ();
1590 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1591 There are five syntaxes:
1593 The first (used on Solaris) is
1595 The second (used on UnixWare) is
1597 The third (reportedly to be used on Irix 6.0) is
1599 The fourth (used on NetBSD/Arm and Linux/ARM) is
1601 The fifth (used on SVR4/860) is
1602 .type SYM,"function"
1606 obj_elf_type (ignore)
1607 int ignore ATTRIBUTE_UNUSED;
1612 const char *typename;
1614 elf_symbol_type *elfsym;
1616 name = input_line_pointer;
1617 c = get_symbol_end ();
1618 sym = symbol_find_or_make (name);
1619 elfsym = (elf_symbol_type *) symbol_get_bfdsym (sym);
1620 *input_line_pointer = c;
1623 if (*input_line_pointer == ',')
1624 ++input_line_pointer;
1627 if ( *input_line_pointer == '#'
1628 || *input_line_pointer == '@'
1629 || *input_line_pointer == '"'
1630 || *input_line_pointer == '%')
1631 ++input_line_pointer;
1633 typename = input_line_pointer;
1634 c = get_symbol_end ();
1637 if (strcmp (typename, "function") == 0
1638 || strcmp (typename, "STT_FUNC") == 0)
1639 type = BSF_FUNCTION;
1640 else if (strcmp (typename, "object") == 0
1641 || strcmp (typename, "STT_OBJECT") == 0)
1643 #ifdef md_elf_symbol_type
1644 else if ((type = md_elf_symbol_type (typename, sym, elfsym)) != -1)
1648 as_bad (_("unrecognized symbol type \"%s\""), typename);
1650 *input_line_pointer = c;
1652 if (*input_line_pointer == '"')
1653 ++input_line_pointer;
1655 elfsym->symbol.flags |= type;
1657 demand_empty_rest_of_line ();
1661 obj_elf_ident (ignore)
1662 int ignore ATTRIBUTE_UNUSED;
1664 static segT comment_section;
1665 segT old_section = now_seg;
1666 int old_subsection = now_subseg;
1668 #ifdef md_flush_pending_output
1669 md_flush_pending_output ();
1672 if (!comment_section)
1675 comment_section = subseg_new (".comment", 0);
1676 bfd_set_section_flags (stdoutput, comment_section,
1677 SEC_READONLY | SEC_HAS_CONTENTS);
1682 subseg_set (comment_section, 0);
1684 subseg_set (old_section, old_subsection);
1687 #ifdef INIT_STAB_SECTION
1689 /* The first entry in a .stabs section is special. */
1692 obj_elf_init_stab_section (seg)
1698 unsigned int stroff;
1700 /* Force the section to align to a longword boundary. Without this,
1701 UnixWare ar crashes. */
1702 bfd_set_section_alignment (stdoutput, seg, 2);
1704 /* Make space for this first symbol. */
1708 as_where (&file, (unsigned int *) NULL);
1709 stabstr_name = (char *) xmalloc (strlen (segment_name (seg)) + 4);
1710 strcpy (stabstr_name, segment_name (seg));
1711 strcat (stabstr_name, "str");
1712 stroff = get_stab_string_offset (file, stabstr_name);
1714 md_number_to_chars (p, stroff, 4);
1715 seg_info (seg)->stabu.p = p;
1720 /* Fill in the counts in the first entry in a .stabs section. */
1723 adjust_stab_sections (abfd, sec, xxx)
1726 PTR xxx ATTRIBUTE_UNUSED;
1733 if (strncmp (".stab", sec->name, 5))
1735 if (!strcmp ("str", sec->name + strlen (sec->name) - 3))
1738 name = (char *) alloca (strlen (sec->name) + 4);
1739 strcpy (name, sec->name);
1740 strcat (name, "str");
1741 strsec = bfd_get_section_by_name (abfd, name);
1743 strsz = bfd_section_size (abfd, strsec);
1746 nsyms = bfd_section_size (abfd, sec) / 12 - 1;
1748 p = seg_info (sec)->stabu.p;
1751 bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
1752 bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
1755 #ifdef NEED_ECOFF_DEBUG
1757 /* This function is called by the ECOFF code. It is supposed to
1758 record the external symbol information so that the backend can
1759 write it out correctly. The ELF backend doesn't actually handle
1760 this at the moment, so we do it ourselves. We save the information
1764 elf_ecoff_set_ext (sym, ext)
1766 struct ecoff_extr *ext;
1768 symbol_get_bfdsym (sym)->udata.p = (PTR) ext;
1771 /* This function is called by bfd_ecoff_debug_externals. It is
1772 supposed to *EXT to the external symbol information, and return
1773 whether the symbol should be used at all. */
1776 elf_get_extr (sym, ext)
1780 if (sym->udata.p == NULL)
1782 *ext = *(EXTR *) sym->udata.p;
1786 /* This function is called by bfd_ecoff_debug_externals. It has
1787 nothing to do for ELF. */
1791 elf_set_index (sym, indx)
1792 asymbol *sym ATTRIBUTE_UNUSED;
1793 bfd_size_type indx ATTRIBUTE_UNUSED;
1797 #endif /* NEED_ECOFF_DEBUG */
1800 elf_frob_symbol (symp, puntp)
1804 struct elf_obj_sy *sy_obj;
1806 #ifdef NEED_ECOFF_DEBUG
1807 if (ECOFF_DEBUGGING)
1808 ecoff_frob_symbol (symp);
1811 sy_obj = symbol_get_obj (symp);
1813 if (sy_obj->size != NULL)
1815 switch (sy_obj->size->X_op)
1819 (S_GET_VALUE (sy_obj->size->X_add_symbol)
1820 + sy_obj->size->X_add_number
1821 - S_GET_VALUE (sy_obj->size->X_op_symbol)));
1825 (S_GET_VALUE (sy_obj->size->X_add_symbol)
1826 + sy_obj->size->X_add_number));
1829 as_bad (_(".size expression too complicated to fix up"));
1832 free (sy_obj->size);
1833 sy_obj->size = NULL;
1836 if (sy_obj->versioned_name != NULL)
1840 p = strchr (sy_obj->versioned_name, ELF_VER_CHR);
1843 /* This symbol was given a new name with the .symver directive.
1845 If this is an external reference, just rename the symbol to
1846 include the version string. This will make the relocs be
1847 against the correct versioned symbol.
1849 If this is a definition, add an alias. FIXME: Using an alias
1850 will permit the debugging information to refer to the right
1851 symbol. However, it's not clear whether it is the best
1854 if (! S_IS_DEFINED (symp))
1856 /* Verify that the name isn't using the @@ syntax--this is
1857 reserved for definitions of the default version to link
1859 if (p[1] == ELF_VER_CHR)
1861 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1862 sy_obj->versioned_name);
1865 S_SET_NAME (symp, sy_obj->versioned_name);
1869 if (p [1] == ELF_VER_CHR && p [2] == ELF_VER_CHR)
1873 /* The @@@ syntax is a special case. It renames the
1874 symbol name to versioned_name with one `@' removed. */
1875 l = strlen (&p[3]) + 1;
1876 memmove (&p [2], &p[3], l);
1877 S_SET_NAME (symp, sy_obj->versioned_name);
1883 /* FIXME: Creating a new symbol here is risky. We're
1884 in the final loop over the symbol table. We can
1885 get away with it only because the symbol goes to
1886 the end of the list, where the loop will still see
1887 it. It would probably be better to do this in
1888 obj_frob_file_before_adjust. */
1890 symp2 = symbol_find_or_make (sy_obj->versioned_name);
1892 /* Now we act as though we saw symp2 = sym. */
1894 S_SET_SEGMENT (symp2, S_GET_SEGMENT (symp));
1896 /* Subtracting out the frag address here is a hack
1897 because we are in the middle of the final loop. */
1900 - symbol_get_frag (symp)->fr_address));
1902 symbol_set_frag (symp2, symbol_get_frag (symp));
1904 /* This will copy over the size information. */
1905 copy_symbol_attributes (symp2, symp);
1907 S_SET_OTHER (symp2, S_GET_OTHER (symp));
1909 if (S_IS_WEAK (symp))
1912 if (S_IS_EXTERNAL (symp))
1913 S_SET_EXTERNAL (symp2);
1918 /* Double check weak symbols. */
1919 if (S_IS_WEAK (symp))
1921 if (S_IS_COMMON (symp))
1922 as_bad (_("symbol `%s' can not be both weak and common"),
1927 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1928 any undefined non-function symbol to STT_OBJECT. We try to be
1929 compatible, since newer Irix 5 and 6 linkers care. However, we
1930 only set undefined symbols to be STT_OBJECT if we are on Irix,
1931 because that is the only time gcc will generate the necessary
1932 .global directives to mark functions. */
1934 if (S_IS_COMMON (symp))
1935 symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
1937 if (strstr (TARGET_OS, "irix") != NULL
1938 && ! S_IS_DEFINED (symp)
1939 && (symbol_get_bfdsym (symp)->flags & BSF_FUNCTION) == 0)
1940 symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
1944 /* If TC_PPC is defined, we used to force the type of a symbol to be
1945 BSF_OBJECT if it was otherwise unset. This was required by some
1946 version of VxWorks. Thomas de Lellis <tdel@windriver.com> says
1947 that this is no longer needed, so it is now commented out. */
1948 if ((symbol_get_bfdsym (symp)->flags
1949 & (BSF_FUNCTION | BSF_FILE | BSF_SECTION_SYM)) == 0
1950 && S_IS_DEFINED (symp))
1951 symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
1957 asection **head; /* Section lists. */
1958 unsigned int *elt_count; /* Number of sections in each list. */
1959 unsigned int num_group; /* Number of lists. */
1962 /* Called via bfd_map_over_sections. If SEC is a member of a group,
1963 add it to a list of sections belonging to the group. INF is a
1964 pointer to a struct group_list, which is where we store the head of
1968 build_group_lists (abfd, sec, inf)
1969 bfd *abfd ATTRIBUTE_UNUSED;
1973 struct group_list *list = (struct group_list *) inf;
1974 const char *group_name = elf_group_name (sec);
1977 if (group_name == NULL)
1980 /* If this group already has a list, add the section to the head of
1982 for (i = 0; i < list->num_group; i++)
1984 if (strcmp (group_name, elf_group_name (list->head[i])) == 0)
1986 elf_next_in_group (sec) = list->head[i];
1987 list->head[i] = sec;
1988 list->elt_count[i] += 1;
1993 /* New group. Make the arrays bigger in chunks to minimize calls to
1995 i = list->num_group;
1998 unsigned int newsize = i + 128;
1999 list->head = xrealloc (list->head, newsize * sizeof (*list->head));
2000 list->elt_count = xrealloc (list->elt_count,
2001 newsize * sizeof (*list->elt_count));
2003 list->head[i] = sec;
2004 list->elt_count[i] = 1;
2005 list->num_group += 1;
2011 struct group_list list;
2014 bfd_map_over_sections (stdoutput, adjust_stab_sections, (PTR) 0);
2016 /* Go find section groups. */
2019 list.elt_count = NULL;
2020 bfd_map_over_sections (stdoutput, build_group_lists, (PTR) &list);
2022 /* Make the SHT_GROUP sections that describe each section group. We
2023 can't set up the section contents here yet, because elf section
2024 indices have yet to be calculated. elf.c:set_group_contents does
2025 the rest of the work. */
2026 for (i = 0; i < list.num_group; i++)
2028 const char *group_name = elf_group_name (list.head[i]);
2029 const char *sec_name;
2035 flags = SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_GROUP;
2036 for (s = list.head[i]; s != NULL; s = elf_next_in_group (s))
2037 if (elf_linkonce_p (s) != ((flags & SEC_LINK_ONCE) != 0))
2039 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2040 if (s != list.head[i])
2042 as_warn (_("assuming all members of group `%s' are COMDAT"),
2048 sec_name = group_name;
2049 sy = symbol_find_exact (group_name);
2052 && (sy == symbol_lastP
2053 || (sy->sy_next != NULL
2054 && sy->sy_next->sy_previous == sy)))
2057 sec_name = ".group";
2059 s = subseg_force_new (sec_name, 0);
2061 || !bfd_set_section_flags (stdoutput, s, flags)
2062 || !bfd_set_section_alignment (stdoutput, s, 2))
2064 as_fatal (_("can't create group: %s"),
2065 bfd_errmsg (bfd_get_error ()));
2068 /* Pass a pointer to the first section in this group. */
2069 elf_next_in_group (s) = list.head[i];
2071 elf_group_id (s) = sy->bsym;
2073 s->_raw_size = 4 * (list.elt_count[i] + 1);
2074 s->contents = frag_more (s->_raw_size);
2075 frag_now->fr_fix = frag_now_fix_octets ();
2078 #ifdef elf_tc_final_processing
2079 elf_tc_final_processing ();
2083 /* It removes any unneeded versioned symbols from the symbol table. */
2086 elf_frob_file_before_adjust ()
2092 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2093 if (!S_IS_DEFINED (symp))
2095 if (symbol_get_obj (symp)->versioned_name)
2099 /* The @@@ syntax is a special case. If the symbol is
2100 not defined, 2 `@'s will be removed from the
2103 p = strchr (symbol_get_obj (symp)->versioned_name,
2106 if (p [1] == ELF_VER_CHR && p [2] == ELF_VER_CHR)
2108 size_t l = strlen (&p[3]) + 1;
2109 memmove (&p [1], &p[3], l);
2111 if (symbol_used_p (symp) == 0
2112 && symbol_used_in_reloc_p (symp) == 0)
2113 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2116 /* If there was .weak foo, but foo was neither defined nor
2117 used anywhere, remove it. */
2119 else if (S_IS_WEAK (symp)
2120 && symbol_used_p (symp) == 0
2121 && symbol_used_in_reloc_p (symp) == 0)
2122 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2127 /* It is required that we let write_relocs have the opportunity to
2128 optimize away fixups before output has begun, since it is possible
2129 to eliminate all fixups for a section and thus we never should
2130 have generated the relocation section. */
2133 elf_frob_file_after_relocs ()
2135 #ifdef NEED_ECOFF_DEBUG
2136 if (ECOFF_DEBUGGING)
2137 /* Generate the ECOFF debugging information. */
2139 const struct ecoff_debug_swap *debug_swap;
2140 struct ecoff_debug_info debug;
2145 = get_elf_backend_data (stdoutput)->elf_backend_ecoff_debug_swap;
2146 know (debug_swap != (const struct ecoff_debug_swap *) NULL);
2147 ecoff_build_debug (&debug.symbolic_header, &buf, debug_swap);
2149 /* Set up the pointers in debug. */
2150 #define SET(ptr, offset, type) \
2151 debug.ptr = (type) (buf + debug.symbolic_header.offset)
2153 SET (line, cbLineOffset, unsigned char *);
2154 SET (external_dnr, cbDnOffset, PTR);
2155 SET (external_pdr, cbPdOffset, PTR);
2156 SET (external_sym, cbSymOffset, PTR);
2157 SET (external_opt, cbOptOffset, PTR);
2158 SET (external_aux, cbAuxOffset, union aux_ext *);
2159 SET (ss, cbSsOffset, char *);
2160 SET (external_fdr, cbFdOffset, PTR);
2161 SET (external_rfd, cbRfdOffset, PTR);
2162 /* ssext and external_ext are set up just below. */
2166 /* Set up the external symbols. */
2167 debug.ssext = debug.ssext_end = NULL;
2168 debug.external_ext = debug.external_ext_end = NULL;
2169 if (! bfd_ecoff_debug_externals (stdoutput, &debug, debug_swap, true,
2170 elf_get_extr, elf_set_index))
2171 as_fatal (_("failed to set up debugging information: %s"),
2172 bfd_errmsg (bfd_get_error ()));
2174 sec = bfd_get_section_by_name (stdoutput, ".mdebug");
2175 assert (sec != NULL);
2177 know (stdoutput->output_has_begun == false);
2179 /* We set the size of the section, call bfd_set_section_contents
2180 to force the ELF backend to allocate a file position, and then
2181 write out the data. FIXME: Is this really the best way to do
2183 sec->_raw_size = bfd_ecoff_debug_size (stdoutput, &debug, debug_swap);
2185 /* Pass BUF to bfd_set_section_contents because this will
2186 eventually become a call to fwrite, and ISO C prohibits
2187 passing a NULL pointer to a stdio function even if the
2188 pointer will not be used. */
2189 if (! bfd_set_section_contents (stdoutput, sec, (PTR) buf,
2190 (file_ptr) 0, (bfd_size_type) 0))
2191 as_fatal (_("can't start writing .mdebug section: %s"),
2192 bfd_errmsg (bfd_get_error ()));
2194 know (stdoutput->output_has_begun == true);
2195 know (sec->filepos != 0);
2197 if (! bfd_ecoff_write_debug (stdoutput, &debug, debug_swap,
2199 as_fatal (_("could not write .mdebug section: %s"),
2200 bfd_errmsg (bfd_get_error ()));
2202 #endif /* NEED_ECOFF_DEBUG */
2207 /* Heavily plagarized from obj_elf_version. The idea is to emit the
2208 SCO specific identifier in the .notes section to satisfy the SCO
2211 This looks more complicated than it really is. As opposed to the
2212 "obvious" solution, this should handle the cross dev cases
2213 correctly. (i.e, hosting on a 64 bit big endian processor, but
2214 generating SCO Elf code) Efficiency isn't a concern, as there
2215 should be exactly one of these sections per object module.
2217 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
2220 int_32 namesz = 4 ; Name size
2221 int_32 descsz = 12 ; Descriptive information
2223 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
2224 int_32 version = (major ver # << 16) | version of tools ;
2225 int_32 source = (tool_id << 16 ) | 1 ;
2226 int_32 info = 0 ; These are set by the SCO tools, but we
2227 don't know enough about the source
2228 environment to set them. SCO ld currently
2229 ignores them, and recommends we set them
2232 #define SCO_MAJOR_VERSION 0x1
2233 #define SCO_MINOR_VERSION 0x1
2243 asection *seg = now_seg;
2244 subsegT subseg = now_subseg;
2245 Elf_Internal_Note i_note;
2246 Elf_External_Note e_note;
2247 asection *note_secp = (asection *) NULL;
2250 /* create the .note section */
2252 note_secp = subseg_new (".note", 0);
2253 bfd_set_section_flags (stdoutput,
2255 SEC_HAS_CONTENTS | SEC_READONLY);
2257 /* process the version string */
2260 i_note.descsz = 12; /* 12 descriptive bytes */
2261 i_note.type = NT_VERSION; /* Contains a version string */
2263 p = frag_more (sizeof (i_note.namesz));
2264 md_number_to_chars (p, (valueT) i_note.namesz, 4);
2266 p = frag_more (sizeof (i_note.descsz));
2267 md_number_to_chars (p, (valueT) i_note.descsz, 4);
2269 p = frag_more (sizeof (i_note.type));
2270 md_number_to_chars (p, (valueT) i_note.type, 4);
2275 /* Note: this is the version number of the ELF we're representing */
2277 md_number_to_chars (p, (SCO_MAJOR_VERSION << 16) | (SCO_MINOR_VERSION), 4);
2279 /* Here, we pick a magic number for ourselves (yes, I "registered"
2280 it with SCO. The bottom bit shows that we are compat with the
2283 md_number_to_chars (p, 0x4c520000 | 0x0001, 4);
2285 /* If we knew (or cared) what the source language options were, we'd
2286 fill them in here. SCO has given us permission to ignore these
2287 and just set them to zero. */
2289 md_number_to_chars (p, 0x0000, 4);
2291 frag_align (2, 0, 0);
2293 /* We probably can't restore the current segment, for there likely
2296 subseg_set (seg, subseg);
2300 #endif /* SCO_ELF */
2303 elf_separate_stab_sections ()
2305 #ifdef NEED_ECOFF_DEBUG
2306 return (!ECOFF_DEBUGGING);
2313 elf_init_stab_section (seg)
2316 #ifdef NEED_ECOFF_DEBUG
2317 if (!ECOFF_DEBUGGING)
2319 obj_elf_init_stab_section (seg);
2322 const struct format_ops elf_format_ops =
2324 bfd_target_elf_flavour,
2325 0, /* dfl_leading_underscore */
2326 1, /* emit_section_symbols */
2331 elf_frob_file_before_adjust,
2332 elf_frob_file_after_relocs,
2333 elf_s_get_size, elf_s_set_size,
2334 elf_s_get_align, elf_s_set_align,
2341 elf_copy_symbol_attributes,
2342 #ifdef NEED_ECOFF_DEBUG
2343 ecoff_generate_asm_lineno,
2346 0, /* generate_asm_lineno */
2347 0, /* process_stab */
2349 elf_separate_stab_sections,
2350 elf_init_stab_section,
2351 elf_sec_sym_ok_for_reloc,
2353 #ifdef NEED_ECOFF_DEBUG
2356 0, /* ecoff_set_ext */
2358 elf_obj_read_begin_hook,
2359 elf_obj_symbol_new_hook