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"
28 #ifndef ECOFF_DEBUGGING
29 #define ECOFF_DEBUGGING 0
31 #define NEED_ECOFF_DEBUG
34 #ifdef NEED_ECOFF_DEBUG
39 #include "elf/alpha.h"
54 static bfd_vma elf_s_get_size PARAMS ((symbolS *));
55 static void elf_s_set_size PARAMS ((symbolS *, bfd_vma));
56 static bfd_vma elf_s_get_align PARAMS ((symbolS *));
57 static void elf_s_set_align PARAMS ((symbolS *, bfd_vma));
58 static void elf_s_set_other PARAMS ((symbolS *, int));
59 static int elf_sec_sym_ok_for_reloc PARAMS ((asection *));
60 static void adjust_stab_sections PARAMS ((bfd *, asection *, PTR));
61 static void build_group_lists PARAMS ((bfd *, asection *, PTR));
62 static int elf_separate_stab_sections PARAMS ((void));
63 static void elf_init_stab_section PARAMS ((segT));
65 #ifdef NEED_ECOFF_DEBUG
66 static boolean elf_get_extr PARAMS ((asymbol *, EXTR *));
67 static void elf_set_index PARAMS ((asymbol *, bfd_size_type));
70 static void obj_elf_line PARAMS ((int));
71 void obj_elf_version PARAMS ((int));
72 static void obj_elf_size PARAMS ((int));
73 static void obj_elf_type PARAMS ((int));
74 static void obj_elf_ident PARAMS ((int));
75 static void obj_elf_weak PARAMS ((int));
76 static void obj_elf_local PARAMS ((int));
77 static void obj_elf_visibility PARAMS ((int));
78 static void obj_elf_change_section
79 PARAMS ((const char *, int, int, int, const char *, int));
80 static int obj_elf_parse_section_letters PARAMS ((char *, size_t));
81 static int obj_elf_section_word PARAMS ((char *, size_t));
82 static char *obj_elf_section_name PARAMS ((void));
83 static int obj_elf_section_type PARAMS ((char *, size_t));
84 static void obj_elf_symver PARAMS ((int));
85 static void obj_elf_subsection PARAMS ((int));
86 static void obj_elf_popsection PARAMS ((int));
88 static const pseudo_typeS elf_pseudo_table[] =
90 {"comm", obj_elf_common, 0},
91 {"common", obj_elf_common, 1},
92 {"ident", obj_elf_ident, 0},
93 {"local", obj_elf_local, 0},
94 {"previous", obj_elf_previous, 0},
95 {"section", obj_elf_section, 0},
96 {"section.s", obj_elf_section, 0},
97 {"sect", obj_elf_section, 0},
98 {"sect.s", obj_elf_section, 0},
99 {"pushsection", obj_elf_section, 1},
100 {"popsection", obj_elf_popsection, 0},
101 {"size", obj_elf_size, 0},
102 {"type", obj_elf_type, 0},
103 {"version", obj_elf_version, 0},
104 {"weak", obj_elf_weak, 0},
106 /* These define symbol visibility. */
107 {"internal", obj_elf_visibility, STV_INTERNAL},
108 {"hidden", obj_elf_visibility, STV_HIDDEN},
109 {"protected", obj_elf_visibility, STV_PROTECTED},
111 /* These are used for stabs-in-elf configurations. */
112 {"line", obj_elf_line, 0},
114 /* This is a GNU extension to handle symbol versions. */
115 {"symver", obj_elf_symver, 0},
117 /* A GNU extension to change subsection only. */
118 {"subsection", obj_elf_subsection, 0},
120 /* These are GNU extensions to aid in garbage collecting C++ vtables. */
121 {"vtable_inherit", (void (*) PARAMS ((int))) &obj_elf_vtable_inherit, 0},
122 {"vtable_entry", (void (*) PARAMS ((int))) &obj_elf_vtable_entry, 0},
124 /* These are used for dwarf. */
129 /* We need to trap the section changing calls to handle .previous. */
130 {"data", obj_elf_data, 0},
131 {"text", obj_elf_text, 0},
137 static const pseudo_typeS ecoff_debug_pseudo_table[] =
139 #ifdef NEED_ECOFF_DEBUG
140 /* COFF style debugging information for ECOFF. .ln is not used; .loc
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 },
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 },
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 },
166 /* Other ECOFF directives. */
167 { "extern", ecoff_directive_extern, 0 },
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 },
179 {NULL, NULL, 0} /* end sentinel */
183 #include "aout/aout64.h"
185 /* This is called when the assembler starts. */
190 /* Add symbols for the known sections to the symbol table. */
191 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput,
192 TEXT_SECTION_NAME)));
193 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput,
194 DATA_SECTION_NAME)));
195 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput,
202 pop_insert (elf_pseudo_table);
204 pop_insert (ecoff_debug_pseudo_table);
211 return S_GET_SIZE (sym);
215 elf_s_set_size (sym, sz)
219 S_SET_SIZE (sym, sz);
223 elf_s_get_align (sym)
226 return S_GET_ALIGN (sym);
230 elf_s_set_align (sym, align)
234 S_SET_ALIGN (sym, align);
238 elf_s_get_other (sym)
241 return elf_symbol (symbol_get_bfdsym (sym))->internal_elf_sym.st_other;
245 elf_s_set_other (sym, other)
249 S_SET_OTHER (sym, other);
253 elf_sec_sym_ok_for_reloc (sec)
256 return obj_sec_sym_ok_for_reloc (sec);
265 sym = symbol_new (s, absolute_section, (valueT) 0, (struct frag *) 0);
266 symbol_set_frag (sym, &zero_address_frag);
267 symbol_get_bfdsym (sym)->flags |= BSF_FILE;
269 if (symbol_rootP != sym)
271 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
272 symbol_insert (sym, symbol_rootP, &symbol_rootP, &symbol_lastP);
274 verify_symbol_chain (symbol_rootP, symbol_lastP);
278 #ifdef NEED_ECOFF_DEBUG
284 obj_elf_common (is_common)
294 if (flag_mri && is_common)
300 name = input_line_pointer;
301 c = get_symbol_end ();
302 /* just after name is now '\0' */
303 p = input_line_pointer;
306 if (*input_line_pointer != ',')
308 as_bad (_("expected comma after symbol-name"));
309 ignore_rest_of_line ();
312 input_line_pointer++; /* skip ',' */
313 if ((temp = get_absolute_expression ()) < 0)
315 as_bad (_(".COMMon length (%d.) <0! Ignored."), temp);
316 ignore_rest_of_line ();
321 symbolP = symbol_find_or_make (name);
323 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
325 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP));
326 ignore_rest_of_line ();
329 if (S_GET_VALUE (symbolP) != 0)
331 if (S_GET_VALUE (symbolP) != (valueT) size)
333 as_warn (_("length of .comm \"%s\" is already %ld; not changed to %d"),
334 S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), size);
337 know (symbolP->sy_frag == &zero_address_frag);
338 if (*input_line_pointer != ',')
343 input_line_pointer++;
346 if (! have_align || *input_line_pointer != '"')
352 temp = get_absolute_expression ();
356 as_warn (_("common alignment negative; 0 assumed"));
359 if (symbol_get_obj (symbolP)->local)
368 old_subsec = now_subseg;
371 /* convert to a power of 2 alignment */
372 for (align = 0; (temp & 1) == 0; temp >>= 1, ++align);
375 as_bad (_("common alignment not a power of 2"));
376 ignore_rest_of_line ();
382 record_alignment (bss_section, align);
383 subseg_set (bss_section, 0);
385 frag_align (align, 0, 0);
386 if (S_GET_SEGMENT (symbolP) == bss_section)
387 symbol_get_frag (symbolP)->fr_symbol = 0;
388 symbol_set_frag (symbolP, frag_now);
389 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
390 (offsetT) size, (char *) 0);
392 S_SET_SIZE (symbolP, size);
393 S_SET_SEGMENT (symbolP, bss_section);
394 S_CLEAR_EXTERNAL (symbolP);
395 subseg_set (old_sec, old_subsec);
400 S_SET_VALUE (symbolP, (valueT) size);
401 S_SET_ALIGN (symbolP, temp);
402 S_SET_EXTERNAL (symbolP);
403 S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
408 input_line_pointer++;
409 /* @@ Some use the dot, some don't. Can we get some consistency?? */
410 if (*input_line_pointer == '.')
411 input_line_pointer++;
412 /* @@ Some say data, some say bss. */
413 if (strncmp (input_line_pointer, "bss\"", 4)
414 && strncmp (input_line_pointer, "data\"", 5))
416 while (*--input_line_pointer != '"')
418 input_line_pointer--;
419 goto bad_common_segment;
421 while (*input_line_pointer++ != '"')
423 goto allocate_common;
426 symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
428 demand_empty_rest_of_line ();
433 p = input_line_pointer;
434 while (*p && *p != '\n')
438 as_bad (_("bad .common segment %s"), input_line_pointer + 1);
440 input_line_pointer = p;
441 ignore_rest_of_line ();
447 obj_elf_local (ignore)
448 int ignore ATTRIBUTE_UNUSED;
456 name = input_line_pointer;
457 c = get_symbol_end ();
458 symbolP = symbol_find_or_make (name);
459 *input_line_pointer = c;
461 S_CLEAR_EXTERNAL (symbolP);
462 symbol_get_obj (symbolP)->local = 1;
465 input_line_pointer++;
467 if (*input_line_pointer == '\n')
472 demand_empty_rest_of_line ();
476 obj_elf_weak (ignore)
477 int ignore ATTRIBUTE_UNUSED;
485 name = input_line_pointer;
486 c = get_symbol_end ();
487 symbolP = symbol_find_or_make (name);
488 *input_line_pointer = c;
490 S_SET_WEAK (symbolP);
491 symbol_get_obj (symbolP)->local = 1;
494 input_line_pointer++;
496 if (*input_line_pointer == '\n')
501 demand_empty_rest_of_line ();
505 obj_elf_visibility (visibility)
512 elf_symbol_type *elfsym;
516 name = input_line_pointer;
517 c = get_symbol_end ();
518 symbolP = symbol_find_or_make (name);
519 *input_line_pointer = c;
523 bfdsym = symbol_get_bfdsym (symbolP);
524 elfsym = elf_symbol_from (bfd_asymbol_bfd (bfdsym), bfdsym);
528 elfsym->internal_elf_sym.st_other = visibility;
532 input_line_pointer ++;
536 if (*input_line_pointer == '\n')
542 demand_empty_rest_of_line ();
545 static segT previous_section;
546 static int previous_subsection;
550 struct section_stack *next;
552 int subseg, prev_subseg;
555 static struct section_stack *section_stack;
557 /* Handle the .section pseudo-op. This code supports two different
560 The first is found on Solaris, and looks like
561 .section ".sec1",#alloc,#execinstr,#write
562 Here the names after '#' are the SHF_* flags to turn on for the
563 section. I'm not sure how it determines the SHT_* type (BFD
564 doesn't really give us control over the type, anyhow).
566 The second format is found on UnixWare, and probably most SVR4
567 machines, and looks like
568 .section .sec1,"a",@progbits
569 The quoted string may contain any combination of a, w, x, and
570 represents the SHF_* flags to turn on for the section. The string
571 beginning with '@' can be progbits or nobits. There should be
572 other possibilities, but I don't know what they are. In any case,
573 BFD doesn't really let us set the section type. */
575 /* Certain named sections have particular defined types, listed on p.
577 struct special_section
584 static struct special_section const special_sections[] =
586 { ".bss", SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
587 { ".comment", SHT_PROGBITS, 0 },
588 { ".data", SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
589 { ".data1", SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
590 { ".debug", SHT_PROGBITS, 0 },
591 { ".fini", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
592 { ".init", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
593 { ".line", SHT_PROGBITS, 0 },
594 { ".note", SHT_NOTE, 0 },
595 { ".rodata", SHT_PROGBITS, SHF_ALLOC },
596 { ".rodata1", SHT_PROGBITS, SHF_ALLOC },
597 { ".text", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
599 /* FIXME: The current gcc, as of 2002-03-03, will emit
601 .section .init_array,"aw",@progbits
603 for __attribute__ ((section (".init_array"))). "@progbits" marks
604 the incorrect section type. For now, we make them with
605 SHT_PROGBITS. BFD will fix the section type. Gcc should be changed
611 { ".init_array",SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
612 { ".fini_array",SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
613 { ".preinit_array",SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
615 { ".init_array",SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
616 { ".fini_array",SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
617 { ".preinit_array",SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
620 #ifdef ELF_TC_SPECIAL_SECTIONS
621 ELF_TC_SPECIAL_SECTIONS
625 /* The following section names are special, but they can not
626 reasonably appear in assembler code. Some of the attributes are
627 processor dependent. */
628 { ".dynamic", SHT_DYNAMIC, SHF_ALLOC /* + SHF_WRITE */ },
629 { ".dynstr", SHT_STRTAB, SHF_ALLOC },
630 { ".dynsym", SHT_DYNSYM, SHF_ALLOC },
631 { ".got", SHT_PROGBITS, 0 },
632 { ".hash", SHT_HASH, SHF_ALLOC },
633 { ".interp", SHT_PROGBITS, /* SHF_ALLOC */ },
634 { ".plt", SHT_PROGBITS, 0 },
635 { ".shstrtab",SHT_STRTAB, 0 },
636 { ".strtab", SHT_STRTAB, /* SHF_ALLOC */ },
637 { ".symtab", SHT_SYMTAB, /* SHF_ALLOC */ },
644 obj_elf_change_section (name, type, attr, entsize, group_name, push)
649 const char *group_name;
657 #ifdef md_flush_pending_output
658 md_flush_pending_output ();
661 /* Switch to the section, creating it if necessary. */
664 struct section_stack *elt;
665 elt = xmalloc (sizeof (struct section_stack));
666 elt->next = section_stack;
668 elt->prev_seg = previous_section;
669 elt->subseg = now_subseg;
670 elt->prev_subseg = previous_subsection;
673 previous_section = now_seg;
674 previous_subsection = now_subseg;
676 old_sec = bfd_get_section_by_name (stdoutput, name);
677 sec = subseg_new (name, 0);
679 /* See if this is one of the special sections. */
680 for (i = 0; special_sections[i].name != NULL; i++)
681 if (strcmp (name, special_sections[i].name) == 0)
683 if (type == SHT_NULL)
684 type = special_sections[i].type;
685 else if (type != special_sections[i].type)
689 as_warn (_("setting incorrect section type for %s"), name);
693 as_warn (_("ignoring incorrect section type for %s"), name);
694 type = special_sections[i].type;
697 if ((attr &~ special_sections[i].attributes) != 0
700 /* As a GNU extension, we permit a .note section to be
701 allocatable. If the linker sees an allocateable .note
702 section, it will create a PT_NOTE segment in the output
704 if (strcmp (name, ".note") != 0
705 || attr != SHF_ALLOC)
706 as_warn (_("setting incorrect section attributes for %s"),
709 attr |= special_sections[i].attributes;
713 /* Convert ELF type and flags to BFD flags. */
715 | ((attr & SHF_WRITE) ? 0 : SEC_READONLY)
716 | ((attr & SHF_ALLOC) ? SEC_ALLOC : 0)
717 | (((attr & SHF_ALLOC) && type != SHT_NOBITS) ? SEC_LOAD : 0)
718 | ((attr & SHF_EXECINSTR) ? SEC_CODE : 0)
719 | ((attr & SHF_MERGE) ? SEC_MERGE : 0)
720 | ((attr & SHF_STRINGS) ? SEC_STRINGS : 0));
721 #ifdef md_elf_section_flags
722 flags = md_elf_section_flags (flags, attr, type);
729 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */
730 if (type == SHT_NOBITS)
731 seg_info (sec)->bss = 1;
733 bfd_set_section_flags (stdoutput, sec, flags);
734 if (flags & SEC_MERGE)
735 sec->entsize = entsize;
736 elf_group_name (sec) = group_name;
738 /* Add a symbol for this section to the symbol table. */
739 secsym = symbol_find (name);
741 symbol_set_bfdsym (secsym, sec->symbol);
743 symbol_table_insert (section_symbol (sec));
747 /* If section attributes are specified the second time we see a
748 particular section, then check that they are the same as we
749 saw the first time. */
750 if ((old_sec->flags ^ flags)
751 & (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
752 | SEC_EXCLUDE | SEC_SORT_ENTRIES | SEC_MERGE | SEC_STRINGS))
753 as_warn (_("ignoring changed section attributes for %s"), name);
754 else if ((flags & SEC_MERGE) && old_sec->entsize != (unsigned) entsize)
755 as_warn (_("ignoring changed section entity size for %s"), name);
756 else if ((attr & SHF_GROUP) != 0
757 && strcmp (elf_group_name (old_sec), group_name) != 0)
758 as_warn (_("ignoring new section group for %s"), name);
761 #ifdef md_elf_section_change_hook
762 md_elf_section_change_hook ();
767 obj_elf_parse_section_letters (str, len)
784 attr |= SHF_EXECINSTR;
797 if (*(str - 1) == 'a')
800 if (len > 1 && str[1] == 's')
809 char *bad_msg = _("unrecognized .section attribute: want a,w,x,M,S,G");
810 #ifdef md_elf_section_letter
811 int md_attr = md_elf_section_letter (*str, &bad_msg);
817 as_warn ("%s", bad_msg);
830 obj_elf_section_word (str, len)
834 if (len == 5 && strncmp (str, "write", 5) == 0)
836 if (len == 5 && strncmp (str, "alloc", 5) == 0)
838 if (len == 9 && strncmp (str, "execinstr", 9) == 0)
839 return SHF_EXECINSTR;
841 #ifdef md_elf_section_word
843 int md_attr = md_elf_section_word (str, len);
849 as_warn (_("unrecognized section attribute"));
854 obj_elf_section_type (str, len)
858 if (len == 8 && strncmp (str, "progbits", 8) == 0)
860 if (len == 6 && strncmp (str, "nobits", 6) == 0)
863 #ifdef md_elf_section_type
865 int md_type = md_elf_section_type (str, len);
871 as_warn (_("unrecognized section type"));
875 /* Get name of section. */
877 obj_elf_section_name ()
882 if (*input_line_pointer == '"')
886 name = demand_copy_C_string (&dummy);
889 ignore_rest_of_line ();
895 char *end = input_line_pointer;
897 while (0 == strchr ("\n\t,; ", *end))
899 if (end == input_line_pointer)
901 as_warn (_("missing name"));
902 ignore_rest_of_line ();
906 name = xmalloc (end - input_line_pointer + 1);
907 memcpy (name, input_line_pointer, end - input_line_pointer);
908 name[end - input_line_pointer] = '\0';
909 input_line_pointer = end;
916 obj_elf_section (push)
919 char *name, *group_name, *beg;
920 int type, attr, dummy;
928 #ifdef md_flush_pending_output
929 md_flush_pending_output ();
932 previous_section = now_seg;
933 previous_subsection = now_subseg;
935 s_mri_sect (&mri_type);
937 #ifdef md_elf_section_change_hook
938 md_elf_section_change_hook ();
943 #endif /* ! defined (TC_I370) */
945 name = obj_elf_section_name ();
953 if (*input_line_pointer == ',')
955 /* Skip the comma. */
956 ++input_line_pointer;
959 if (*input_line_pointer == '"')
961 beg = demand_copy_C_string (&dummy);
964 ignore_rest_of_line ();
967 attr |= obj_elf_parse_section_letters (beg, strlen (beg));
970 if (*input_line_pointer == ',')
973 char *save = input_line_pointer;
975 ++input_line_pointer;
977 c = *input_line_pointer;
980 beg = demand_copy_C_string (&dummy);
983 ignore_rest_of_line ();
986 type = obj_elf_section_type (beg, strlen (beg));
988 else if (c == '@' || c == '%')
990 beg = ++input_line_pointer;
991 c = get_symbol_end ();
992 *input_line_pointer = c;
993 type = obj_elf_section_type (beg, input_line_pointer - beg);
996 input_line_pointer = save;
1000 if ((attr & SHF_MERGE) != 0 && *input_line_pointer == ',')
1002 ++input_line_pointer;
1004 entsize = get_absolute_expression ();
1008 as_warn (_("invalid merge entity size"));
1013 else if ((attr & SHF_MERGE) != 0)
1015 as_warn (_("entity size for SHF_MERGE not specified"));
1019 if ((attr & SHF_GROUP) != 0 && *input_line_pointer == ',')
1021 ++input_line_pointer;
1022 group_name = obj_elf_section_name ();
1023 if (group_name == NULL)
1026 else if ((attr & SHF_GROUP) != 0)
1028 as_warn (_("group name for SHF_GROUP not specified"));
1039 if (*input_line_pointer != '#')
1041 as_warn (_("character following name is not '#'"));
1042 ignore_rest_of_line ();
1045 beg = ++input_line_pointer;
1046 c = get_symbol_end ();
1047 *input_line_pointer = c;
1049 attr |= obj_elf_section_word (beg, input_line_pointer - beg);
1053 while (*input_line_pointer++ == ',');
1054 --input_line_pointer;
1058 demand_empty_rest_of_line ();
1060 obj_elf_change_section (name, type, attr, entsize, group_name, push);
1063 /* Change to the .data section. */
1069 #ifdef md_flush_pending_output
1070 md_flush_pending_output ();
1073 previous_section = now_seg;
1074 previous_subsection = now_subseg;
1077 #ifdef md_elf_section_change_hook
1078 md_elf_section_change_hook ();
1082 /* Change to the .text section. */
1088 #ifdef md_flush_pending_output
1089 md_flush_pending_output ();
1092 previous_section = now_seg;
1093 previous_subsection = now_subseg;
1096 #ifdef md_elf_section_change_hook
1097 md_elf_section_change_hook ();
1102 obj_elf_subsection (ignore)
1103 int ignore ATTRIBUTE_UNUSED;
1107 #ifdef md_flush_pending_output
1108 md_flush_pending_output ();
1111 previous_section = now_seg;
1112 previous_subsection = now_subseg;
1114 temp = get_absolute_expression ();
1115 subseg_set (now_seg, (subsegT) temp);
1116 demand_empty_rest_of_line ();
1118 #ifdef md_elf_section_change_hook
1119 md_elf_section_change_hook ();
1123 /* This can be called from the processor backends if they change
1127 obj_elf_section_change_hook ()
1129 previous_section = now_seg;
1130 previous_subsection = now_subseg;
1134 obj_elf_previous (ignore)
1135 int ignore ATTRIBUTE_UNUSED;
1140 if (previous_section == 0)
1142 as_warn (_(".previous without corresponding .section; ignored"));
1146 #ifdef md_flush_pending_output
1147 md_flush_pending_output ();
1150 new_section = previous_section;
1151 new_subsection = previous_subsection;
1152 previous_section = now_seg;
1153 previous_subsection = now_subseg;
1154 subseg_set (new_section, new_subsection);
1156 #ifdef md_elf_section_change_hook
1157 md_elf_section_change_hook ();
1162 obj_elf_popsection (xxx)
1163 int xxx ATTRIBUTE_UNUSED;
1165 struct section_stack *top = section_stack;
1169 as_warn (_(".popsection without corresponding .pushsection; ignored"));
1173 #ifdef md_flush_pending_output
1174 md_flush_pending_output ();
1177 section_stack = top->next;
1178 previous_section = top->prev_seg;
1179 previous_subsection = top->prev_subseg;
1180 subseg_set (top->seg, top->subseg);
1183 #ifdef md_elf_section_change_hook
1184 md_elf_section_change_hook ();
1189 obj_elf_line (ignore)
1190 int ignore ATTRIBUTE_UNUSED;
1192 /* Assume delimiter is part of expression. BSD4.2 as fails with
1193 delightful bug, so we are not being incompatible here. */
1194 new_logical_line ((char *) NULL, (int) (get_absolute_expression ()));
1195 demand_empty_rest_of_line ();
1198 /* This handles the .symver pseudo-op, which is used to specify a
1199 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1200 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1201 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1202 with the same value as the symbol NAME. */
1205 obj_elf_symver (ignore)
1206 int ignore ATTRIBUTE_UNUSED;
1213 name = input_line_pointer;
1214 c = get_symbol_end ();
1216 sym = symbol_find_or_make (name);
1218 *input_line_pointer = c;
1221 if (*input_line_pointer != ',')
1223 as_bad (_("expected comma after name in .symver"));
1224 ignore_rest_of_line ();
1228 ++input_line_pointer;
1229 name = input_line_pointer;
1231 /* Temporarily include '@' in symbol names. */
1232 old_lexat = lex_type[(unsigned char) '@'];
1233 lex_type[(unsigned char) '@'] |= LEX_NAME;
1234 c = get_symbol_end ();
1235 lex_type[(unsigned char) '@'] = old_lexat;
1237 if (symbol_get_obj (sym)->versioned_name == NULL)
1239 symbol_get_obj (sym)->versioned_name = xstrdup (name);
1241 *input_line_pointer = c;
1243 if (strchr (symbol_get_obj (sym)->versioned_name,
1244 ELF_VER_CHR) == NULL)
1246 as_bad (_("missing version name in `%s' for symbol `%s'"),
1247 symbol_get_obj (sym)->versioned_name,
1249 ignore_rest_of_line ();
1255 if (strcmp (symbol_get_obj (sym)->versioned_name, name))
1257 as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1258 name, symbol_get_obj (sym)->versioned_name,
1260 ignore_rest_of_line ();
1264 *input_line_pointer = c;
1267 demand_empty_rest_of_line ();
1270 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1271 to the linker the hierarchy in which a particular table resides. The
1272 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1275 obj_elf_vtable_inherit (ignore)
1276 int ignore ATTRIBUTE_UNUSED;
1278 char *cname, *pname;
1279 symbolS *csym, *psym;
1282 if (*input_line_pointer == '#')
1283 ++input_line_pointer;
1285 cname = input_line_pointer;
1286 c = get_symbol_end ();
1287 csym = symbol_find (cname);
1289 /* GCFIXME: should check that we don't have two .vtable_inherits for
1290 the same child symbol. Also, we can currently only do this if the
1291 child symbol is already exists and is placed in a fragment. */
1293 if (csym == NULL || symbol_get_frag (csym) == NULL)
1295 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1300 *input_line_pointer = c;
1303 if (*input_line_pointer != ',')
1305 as_bad ("expected comma after name in .vtable_inherit");
1306 ignore_rest_of_line ();
1310 ++input_line_pointer;
1313 if (*input_line_pointer == '#')
1314 ++input_line_pointer;
1316 if (input_line_pointer[0] == '0'
1317 && (input_line_pointer[1] == '\0'
1318 || ISSPACE (input_line_pointer[1])))
1320 psym = section_symbol (absolute_section);
1321 ++input_line_pointer;
1325 pname = input_line_pointer;
1326 c = get_symbol_end ();
1327 psym = symbol_find_or_make (pname);
1328 *input_line_pointer = c;
1331 demand_empty_rest_of_line ();
1336 assert (symbol_get_value_expression (csym)->X_op == O_constant);
1337 return fix_new (symbol_get_frag (csym),
1338 symbol_get_value_expression (csym)->X_add_number,
1339 0, psym, 0, 0, BFD_RELOC_VTABLE_INHERIT);
1342 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1343 to the linker that a vtable slot was used. The syntax is
1344 ".vtable_entry tablename, offset". */
1347 obj_elf_vtable_entry (ignore)
1348 int ignore ATTRIBUTE_UNUSED;
1355 if (*input_line_pointer == '#')
1356 ++input_line_pointer;
1358 name = input_line_pointer;
1359 c = get_symbol_end ();
1360 sym = symbol_find_or_make (name);
1361 *input_line_pointer = c;
1364 if (*input_line_pointer != ',')
1366 as_bad ("expected comma after name in .vtable_entry");
1367 ignore_rest_of_line ();
1371 ++input_line_pointer;
1372 if (*input_line_pointer == '#')
1373 ++input_line_pointer;
1375 offset = get_absolute_expression ();
1377 demand_empty_rest_of_line ();
1379 return fix_new (frag_now, frag_now_fix (), 0, sym, offset, 0,
1380 BFD_RELOC_VTABLE_ENTRY);
1384 elf_obj_read_begin_hook ()
1386 #ifdef NEED_ECOFF_DEBUG
1387 if (ECOFF_DEBUGGING)
1388 ecoff_read_begin_hook ();
1393 elf_obj_symbol_new_hook (symbolP)
1396 struct elf_obj_sy *sy_obj;
1398 sy_obj = symbol_get_obj (symbolP);
1399 sy_obj->size = NULL;
1400 sy_obj->versioned_name = NULL;
1402 #ifdef NEED_ECOFF_DEBUG
1403 if (ECOFF_DEBUGGING)
1404 ecoff_symbol_new_hook (symbolP);
1408 /* When setting one symbol equal to another, by default we probably
1409 want them to have the same "size", whatever it means in the current
1413 elf_copy_symbol_attributes (dest, src)
1414 symbolS *dest, *src;
1416 struct elf_obj_sy *srcelf = symbol_get_obj (src);
1417 struct elf_obj_sy *destelf = symbol_get_obj (dest);
1420 if (destelf->size == NULL)
1422 (expressionS *) xmalloc (sizeof (expressionS));
1423 *destelf->size = *srcelf->size;
1427 if (destelf->size != NULL)
1428 free (destelf->size);
1429 destelf->size = NULL;
1431 S_SET_SIZE (dest, S_GET_SIZE (src));
1432 /* Don't copy visibility. */
1433 S_SET_OTHER (dest, (ELF_ST_VISIBILITY (S_GET_OTHER (dest))
1434 | (S_GET_OTHER (src) & ~ELF_ST_VISIBILITY (-1))));
1438 obj_elf_version (ignore)
1439 int ignore ATTRIBUTE_UNUSED;
1444 asection *seg = now_seg;
1445 subsegT subseg = now_subseg;
1446 Elf_Internal_Note i_note;
1447 Elf_External_Note e_note;
1448 asection *note_secp = (asection *) NULL;
1452 if (*input_line_pointer == '\"')
1454 ++input_line_pointer; /* -> 1st char of string. */
1455 name = input_line_pointer;
1457 while (is_a_char (c = next_char_of_string ()))
1459 c = *input_line_pointer;
1460 *input_line_pointer = '\0';
1461 *(input_line_pointer - 1) = '\0';
1462 *input_line_pointer = c;
1464 /* create the .note section */
1466 note_secp = subseg_new (".note", 0);
1467 bfd_set_section_flags (stdoutput,
1469 SEC_HAS_CONTENTS | SEC_READONLY);
1471 /* process the version string */
1473 len = strlen (name);
1475 i_note.namesz = ((len + 1) + 3) & ~3; /* round this to word boundary */
1476 i_note.descsz = 0; /* no description */
1477 i_note.type = NT_VERSION;
1478 p = frag_more (sizeof (e_note.namesz));
1479 md_number_to_chars (p, (valueT) i_note.namesz, sizeof (e_note.namesz));
1480 p = frag_more (sizeof (e_note.descsz));
1481 md_number_to_chars (p, (valueT) i_note.descsz, sizeof (e_note.descsz));
1482 p = frag_more (sizeof (e_note.type));
1483 md_number_to_chars (p, (valueT) i_note.type, sizeof (e_note.type));
1484 p = frag_more (len + 1);
1487 frag_align (2, 0, 0);
1489 subseg_set (seg, subseg);
1493 as_bad (_("expected quoted string"));
1495 demand_empty_rest_of_line ();
1499 obj_elf_size (ignore)
1500 int ignore ATTRIBUTE_UNUSED;
1502 char *name = input_line_pointer;
1503 char c = get_symbol_end ();
1508 p = input_line_pointer;
1511 if (*input_line_pointer != ',')
1514 as_bad (_("expected comma after name `%s' in .size directive"), name);
1516 ignore_rest_of_line ();
1519 input_line_pointer++;
1521 if (exp.X_op == O_absent)
1523 as_bad (_("missing expression in .size directive"));
1524 exp.X_op = O_constant;
1525 exp.X_add_number = 0;
1528 sym = symbol_find_or_make (name);
1530 if (exp.X_op == O_constant)
1532 S_SET_SIZE (sym, exp.X_add_number);
1533 if (symbol_get_obj (sym)->size)
1535 xfree (symbol_get_obj (sym)->size);
1536 symbol_get_obj (sym)->size = NULL;
1541 symbol_get_obj (sym)->size =
1542 (expressionS *) xmalloc (sizeof (expressionS));
1543 *symbol_get_obj (sym)->size = exp;
1545 demand_empty_rest_of_line ();
1548 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1549 There are five syntaxes:
1551 The first (used on Solaris) is
1553 The second (used on UnixWare) is
1555 The third (reportedly to be used on Irix 6.0) is
1557 The fourth (used on NetBSD/Arm and Linux/ARM) is
1559 The fifth (used on SVR4/860) is
1560 .type SYM,"function"
1564 obj_elf_type (ignore)
1565 int ignore ATTRIBUTE_UNUSED;
1570 const char *typename;
1572 elf_symbol_type *elfsym;
1574 name = input_line_pointer;
1575 c = get_symbol_end ();
1576 sym = symbol_find_or_make (name);
1577 elfsym = (elf_symbol_type *) symbol_get_bfdsym (sym);
1578 *input_line_pointer = c;
1581 if (*input_line_pointer == ',')
1582 ++input_line_pointer;
1585 if ( *input_line_pointer == '#'
1586 || *input_line_pointer == '@'
1587 || *input_line_pointer == '"'
1588 || *input_line_pointer == '%')
1589 ++input_line_pointer;
1591 typename = input_line_pointer;
1592 c = get_symbol_end ();
1595 if (strcmp (typename, "function") == 0
1596 || strcmp (typename, "STT_FUNC") == 0)
1597 type = BSF_FUNCTION;
1598 else if (strcmp (typename, "object") == 0
1599 || strcmp (typename, "STT_OBJECT") == 0)
1601 #ifdef md_elf_symbol_type
1602 else if ((type = md_elf_symbol_type (typename, sym, elfsym)) != -1)
1606 as_bad (_("unrecognized symbol type \"%s\""), typename);
1608 *input_line_pointer = c;
1610 if (*input_line_pointer == '"')
1611 ++input_line_pointer;
1613 elfsym->symbol.flags |= type;
1615 demand_empty_rest_of_line ();
1619 obj_elf_ident (ignore)
1620 int ignore ATTRIBUTE_UNUSED;
1622 static segT comment_section;
1623 segT old_section = now_seg;
1624 int old_subsection = now_subseg;
1626 #ifdef md_flush_pending_output
1627 md_flush_pending_output ();
1630 if (!comment_section)
1633 comment_section = subseg_new (".comment", 0);
1634 bfd_set_section_flags (stdoutput, comment_section,
1635 SEC_READONLY | SEC_HAS_CONTENTS);
1640 subseg_set (comment_section, 0);
1642 subseg_set (old_section, old_subsection);
1645 #ifdef INIT_STAB_SECTION
1647 /* The first entry in a .stabs section is special. */
1650 obj_elf_init_stab_section (seg)
1656 unsigned int stroff;
1658 /* Force the section to align to a longword boundary. Without this,
1659 UnixWare ar crashes. */
1660 bfd_set_section_alignment (stdoutput, seg, 2);
1662 /* Make space for this first symbol. */
1666 as_where (&file, (unsigned int *) NULL);
1667 stabstr_name = (char *) xmalloc (strlen (segment_name (seg)) + 4);
1668 strcpy (stabstr_name, segment_name (seg));
1669 strcat (stabstr_name, "str");
1670 stroff = get_stab_string_offset (file, stabstr_name);
1672 md_number_to_chars (p, stroff, 4);
1673 seg_info (seg)->stabu.p = p;
1678 /* Fill in the counts in the first entry in a .stabs section. */
1681 adjust_stab_sections (abfd, sec, xxx)
1684 PTR xxx ATTRIBUTE_UNUSED;
1691 if (strncmp (".stab", sec->name, 5))
1693 if (!strcmp ("str", sec->name + strlen (sec->name) - 3))
1696 name = (char *) alloca (strlen (sec->name) + 4);
1697 strcpy (name, sec->name);
1698 strcat (name, "str");
1699 strsec = bfd_get_section_by_name (abfd, name);
1701 strsz = bfd_section_size (abfd, strsec);
1704 nsyms = bfd_section_size (abfd, sec) / 12 - 1;
1706 p = seg_info (sec)->stabu.p;
1709 bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
1710 bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
1713 #ifdef NEED_ECOFF_DEBUG
1715 /* This function is called by the ECOFF code. It is supposed to
1716 record the external symbol information so that the backend can
1717 write it out correctly. The ELF backend doesn't actually handle
1718 this at the moment, so we do it ourselves. We save the information
1722 elf_ecoff_set_ext (sym, ext)
1724 struct ecoff_extr *ext;
1726 symbol_get_bfdsym (sym)->udata.p = (PTR) ext;
1729 /* This function is called by bfd_ecoff_debug_externals. It is
1730 supposed to *EXT to the external symbol information, and return
1731 whether the symbol should be used at all. */
1734 elf_get_extr (sym, ext)
1738 if (sym->udata.p == NULL)
1740 *ext = *(EXTR *) sym->udata.p;
1744 /* This function is called by bfd_ecoff_debug_externals. It has
1745 nothing to do for ELF. */
1749 elf_set_index (sym, indx)
1750 asymbol *sym ATTRIBUTE_UNUSED;
1751 bfd_size_type indx ATTRIBUTE_UNUSED;
1755 #endif /* NEED_ECOFF_DEBUG */
1758 elf_frob_symbol (symp, puntp)
1762 struct elf_obj_sy *sy_obj;
1764 #ifdef NEED_ECOFF_DEBUG
1765 if (ECOFF_DEBUGGING)
1766 ecoff_frob_symbol (symp);
1769 sy_obj = symbol_get_obj (symp);
1771 if (sy_obj->size != NULL)
1773 switch (sy_obj->size->X_op)
1777 (S_GET_VALUE (sy_obj->size->X_add_symbol)
1778 + sy_obj->size->X_add_number
1779 - S_GET_VALUE (sy_obj->size->X_op_symbol)));
1783 (S_GET_VALUE (sy_obj->size->X_add_symbol)
1784 + sy_obj->size->X_add_number));
1787 as_bad (_(".size expression too complicated to fix up"));
1790 free (sy_obj->size);
1791 sy_obj->size = NULL;
1794 if (sy_obj->versioned_name != NULL)
1798 p = strchr (sy_obj->versioned_name, ELF_VER_CHR);
1801 /* This symbol was given a new name with the .symver directive.
1803 If this is an external reference, just rename the symbol to
1804 include the version string. This will make the relocs be
1805 against the correct versioned symbol.
1807 If this is a definition, add an alias. FIXME: Using an alias
1808 will permit the debugging information to refer to the right
1809 symbol. However, it's not clear whether it is the best
1812 if (! S_IS_DEFINED (symp))
1814 /* Verify that the name isn't using the @@ syntax--this is
1815 reserved for definitions of the default version to link
1817 if (p[1] == ELF_VER_CHR)
1819 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1820 sy_obj->versioned_name);
1823 S_SET_NAME (symp, sy_obj->versioned_name);
1827 if (p [1] == ELF_VER_CHR && p [2] == ELF_VER_CHR)
1831 /* The @@@ syntax is a special case. It renames the
1832 symbol name to versioned_name with one `@' removed. */
1833 l = strlen (&p[3]) + 1;
1834 memmove (&p [2], &p[3], l);
1835 S_SET_NAME (symp, sy_obj->versioned_name);
1841 /* FIXME: Creating a new symbol here is risky. We're
1842 in the final loop over the symbol table. We can
1843 get away with it only because the symbol goes to
1844 the end of the list, where the loop will still see
1845 it. It would probably be better to do this in
1846 obj_frob_file_before_adjust. */
1848 symp2 = symbol_find_or_make (sy_obj->versioned_name);
1850 /* Now we act as though we saw symp2 = sym. */
1852 S_SET_SEGMENT (symp2, S_GET_SEGMENT (symp));
1854 /* Subtracting out the frag address here is a hack
1855 because we are in the middle of the final loop. */
1858 - symbol_get_frag (symp)->fr_address));
1860 symbol_set_frag (symp2, symbol_get_frag (symp));
1862 /* This will copy over the size information. */
1863 copy_symbol_attributes (symp2, symp);
1865 S_SET_OTHER (symp2, S_GET_OTHER (symp));
1867 if (S_IS_WEAK (symp))
1870 if (S_IS_EXTERNAL (symp))
1871 S_SET_EXTERNAL (symp2);
1876 /* Double check weak symbols. */
1877 if (S_IS_WEAK (symp))
1879 if (S_IS_COMMON (symp))
1880 as_bad (_("symbol `%s' can not be both weak and common"),
1885 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1886 any undefined non-function symbol to STT_OBJECT. We try to be
1887 compatible, since newer Irix 5 and 6 linkers care. However, we
1888 only set undefined symbols to be STT_OBJECT if we are on Irix,
1889 because that is the only time gcc will generate the necessary
1890 .global directives to mark functions. */
1892 if (S_IS_COMMON (symp))
1893 symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
1895 if (strstr (TARGET_OS, "irix") != NULL
1896 && ! S_IS_DEFINED (symp)
1897 && (symbol_get_bfdsym (symp)->flags & BSF_FUNCTION) == 0)
1898 symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
1902 /* If TC_PPC is defined, we used to force the type of a symbol to be
1903 BSF_OBJECT if it was otherwise unset. This was required by some
1904 version of VxWorks. Thomas de Lellis <tdel@windriver.com> says
1905 that this is no longer needed, so it is now commented out. */
1906 if ((symbol_get_bfdsym (symp)->flags
1907 & (BSF_FUNCTION | BSF_FILE | BSF_SECTION_SYM)) == 0
1908 && S_IS_DEFINED (symp))
1909 symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
1915 asection **head; /* Section lists. */
1916 unsigned int *elt_count; /* Number of sections in each list. */
1917 unsigned int num_group; /* Number of lists. */
1920 /* Called via bfd_map_over_sections. If SEC is a member of a group,
1921 add it to a list of sections belonging to the group. INF is a
1922 pointer to a struct group_list, which is where we store the head of
1926 build_group_lists (abfd, sec, inf)
1927 bfd *abfd ATTRIBUTE_UNUSED;
1931 struct group_list *list = (struct group_list *) inf;
1932 const char *group_name = elf_group_name (sec);
1935 if (group_name == NULL)
1938 /* If this group already has a list, add the section to the head of
1940 for (i = 0; i < list->num_group; i++)
1942 if (strcmp (group_name, elf_group_name (list->head[i])) == 0)
1944 elf_next_in_group (sec) = list->head[i];
1945 list->head[i] = sec;
1946 list->elt_count[i] += 1;
1951 /* New group. Make the arrays bigger in chunks to minimize calls to
1953 i = list->num_group;
1956 unsigned int newsize = i + 128;
1957 list->head = xrealloc (list->head, newsize * sizeof (*list->head));
1958 list->elt_count = xrealloc (list->elt_count,
1959 newsize * sizeof (*list->elt_count));
1961 list->head[i] = sec;
1962 list->elt_count[i] = 1;
1963 list->num_group += 1;
1969 struct group_list list;
1972 bfd_map_over_sections (stdoutput, adjust_stab_sections, (PTR) 0);
1974 /* Go find section groups. */
1977 list.elt_count = NULL;
1978 bfd_map_over_sections (stdoutput, build_group_lists, (PTR) &list);
1980 /* Make the SHT_GROUP sections that describe each section group. We
1981 can't set up the section contents here yet, because elf section
1982 indices have yet to be calculated. elf.c:set_group_contents does
1983 the rest of the work. */
1984 for (i = 0; i < list.num_group; i++)
1986 const char *group_name = elf_group_name (list.head[i]);
1990 s = subseg_force_new (group_name, 0);
1991 flags = SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_GROUP;
1993 || !bfd_set_section_flags (stdoutput, s, flags)
1994 || !bfd_set_section_alignment (stdoutput, s, 2))
1996 as_fatal (_("can't create group: %s"),
1997 bfd_errmsg (bfd_get_error ()));
2000 /* Pass a pointer to the first section in this group. */
2001 elf_next_in_group (s) = list.head[i];
2003 s->_raw_size = 4 * (list.elt_count[i] + 1);
2004 s->contents = frag_more (s->_raw_size);
2005 frag_now->fr_fix = frag_now_fix_octets ();
2008 #ifdef elf_tc_final_processing
2009 elf_tc_final_processing ();
2013 /* It removes any unneeded versioned symbols from the symbol table. */
2016 elf_frob_file_before_adjust ()
2022 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2023 if (!S_IS_DEFINED (symp))
2025 if (symbol_get_obj (symp)->versioned_name)
2029 /* The @@@ syntax is a special case. If the symbol is
2030 not defined, 2 `@'s will be removed from the
2033 p = strchr (symbol_get_obj (symp)->versioned_name,
2036 if (p [1] == ELF_VER_CHR && p [2] == ELF_VER_CHR)
2038 size_t l = strlen (&p[3]) + 1;
2039 memmove (&p [1], &p[3], l);
2041 if (symbol_used_p (symp) == 0
2042 && symbol_used_in_reloc_p (symp) == 0)
2043 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2046 /* If there was .weak foo, but foo was neither defined nor
2047 used anywhere, remove it. */
2049 else if (S_IS_WEAK (symp)
2050 && symbol_used_p (symp) == 0
2051 && symbol_used_in_reloc_p (symp) == 0)
2052 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2057 /* It is required that we let write_relocs have the opportunity to
2058 optimize away fixups before output has begun, since it is possible
2059 to eliminate all fixups for a section and thus we never should
2060 have generated the relocation section. */
2063 elf_frob_file_after_relocs ()
2065 #ifdef NEED_ECOFF_DEBUG
2066 if (ECOFF_DEBUGGING)
2067 /* Generate the ECOFF debugging information. */
2069 const struct ecoff_debug_swap *debug_swap;
2070 struct ecoff_debug_info debug;
2075 = get_elf_backend_data (stdoutput)->elf_backend_ecoff_debug_swap;
2076 know (debug_swap != (const struct ecoff_debug_swap *) NULL);
2077 ecoff_build_debug (&debug.symbolic_header, &buf, debug_swap);
2079 /* Set up the pointers in debug. */
2080 #define SET(ptr, offset, type) \
2081 debug.ptr = (type) (buf + debug.symbolic_header.offset)
2083 SET (line, cbLineOffset, unsigned char *);
2084 SET (external_dnr, cbDnOffset, PTR);
2085 SET (external_pdr, cbPdOffset, PTR);
2086 SET (external_sym, cbSymOffset, PTR);
2087 SET (external_opt, cbOptOffset, PTR);
2088 SET (external_aux, cbAuxOffset, union aux_ext *);
2089 SET (ss, cbSsOffset, char *);
2090 SET (external_fdr, cbFdOffset, PTR);
2091 SET (external_rfd, cbRfdOffset, PTR);
2092 /* ssext and external_ext are set up just below. */
2096 /* Set up the external symbols. */
2097 debug.ssext = debug.ssext_end = NULL;
2098 debug.external_ext = debug.external_ext_end = NULL;
2099 if (! bfd_ecoff_debug_externals (stdoutput, &debug, debug_swap, true,
2100 elf_get_extr, elf_set_index))
2101 as_fatal (_("failed to set up debugging information: %s"),
2102 bfd_errmsg (bfd_get_error ()));
2104 sec = bfd_get_section_by_name (stdoutput, ".mdebug");
2105 assert (sec != NULL);
2107 know (stdoutput->output_has_begun == false);
2109 /* We set the size of the section, call bfd_set_section_contents
2110 to force the ELF backend to allocate a file position, and then
2111 write out the data. FIXME: Is this really the best way to do
2113 sec->_raw_size = bfd_ecoff_debug_size (stdoutput, &debug, debug_swap);
2115 /* Pass BUF to bfd_set_section_contents because this will
2116 eventually become a call to fwrite, and ISO C prohibits
2117 passing a NULL pointer to a stdio function even if the
2118 pointer will not be used. */
2119 if (! bfd_set_section_contents (stdoutput, sec, (PTR) buf,
2120 (file_ptr) 0, (bfd_size_type) 0))
2121 as_fatal (_("can't start writing .mdebug section: %s"),
2122 bfd_errmsg (bfd_get_error ()));
2124 know (stdoutput->output_has_begun == true);
2125 know (sec->filepos != 0);
2127 if (! bfd_ecoff_write_debug (stdoutput, &debug, debug_swap,
2129 as_fatal (_("could not write .mdebug section: %s"),
2130 bfd_errmsg (bfd_get_error ()));
2132 #endif /* NEED_ECOFF_DEBUG */
2137 /* Heavily plagarized from obj_elf_version. The idea is to emit the
2138 SCO specific identifier in the .notes section to satisfy the SCO
2141 This looks more complicated than it really is. As opposed to the
2142 "obvious" solution, this should handle the cross dev cases
2143 correctly. (i.e, hosting on a 64 bit big endian processor, but
2144 generating SCO Elf code) Efficiency isn't a concern, as there
2145 should be exactly one of these sections per object module.
2147 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
2150 int_32 namesz = 4 ; Name size
2151 int_32 descsz = 12 ; Descriptive information
2153 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
2154 int_32 version = (major ver # << 16) | version of tools ;
2155 int_32 source = (tool_id << 16 ) | 1 ;
2156 int_32 info = 0 ; These are set by the SCO tools, but we
2157 don't know enough about the source
2158 environment to set them. SCO ld currently
2159 ignores them, and recommends we set them
2162 #define SCO_MAJOR_VERSION 0x1
2163 #define SCO_MINOR_VERSION 0x1
2173 asection *seg = now_seg;
2174 subsegT subseg = now_subseg;
2175 Elf_Internal_Note i_note;
2176 Elf_External_Note e_note;
2177 asection *note_secp = (asection *) NULL;
2180 /* create the .note section */
2182 note_secp = subseg_new (".note", 0);
2183 bfd_set_section_flags (stdoutput,
2185 SEC_HAS_CONTENTS | SEC_READONLY);
2187 /* process the version string */
2190 i_note.descsz = 12; /* 12 descriptive bytes */
2191 i_note.type = NT_VERSION; /* Contains a version string */
2193 p = frag_more (sizeof (i_note.namesz));
2194 md_number_to_chars (p, (valueT) i_note.namesz, 4);
2196 p = frag_more (sizeof (i_note.descsz));
2197 md_number_to_chars (p, (valueT) i_note.descsz, 4);
2199 p = frag_more (sizeof (i_note.type));
2200 md_number_to_chars (p, (valueT) i_note.type, 4);
2205 /* Note: this is the version number of the ELF we're representing */
2207 md_number_to_chars (p, (SCO_MAJOR_VERSION << 16) | (SCO_MINOR_VERSION), 4);
2209 /* Here, we pick a magic number for ourselves (yes, I "registered"
2210 it with SCO. The bottom bit shows that we are compat with the
2213 md_number_to_chars (p, 0x4c520000 | 0x0001, 4);
2215 /* If we knew (or cared) what the source language options were, we'd
2216 fill them in here. SCO has given us permission to ignore these
2217 and just set them to zero. */
2219 md_number_to_chars (p, 0x0000, 4);
2221 frag_align (2, 0, 0);
2223 /* We probably can't restore the current segment, for there likely
2226 subseg_set (seg, subseg);
2230 #endif /* SCO_ELF */
2233 elf_separate_stab_sections ()
2235 #ifdef NEED_ECOFF_DEBUG
2236 return (!ECOFF_DEBUGGING);
2243 elf_init_stab_section (seg)
2246 #ifdef NEED_ECOFF_DEBUG
2247 if (!ECOFF_DEBUGGING)
2249 obj_elf_init_stab_section (seg);
2252 const struct format_ops elf_format_ops =
2254 bfd_target_elf_flavour,
2255 0, /* dfl_leading_underscore */
2256 1, /* emit_section_symbols */
2261 elf_frob_file_before_adjust,
2262 elf_frob_file_after_relocs,
2263 elf_s_get_size, elf_s_set_size,
2264 elf_s_get_align, elf_s_set_align,
2271 elf_copy_symbol_attributes,
2272 #ifdef NEED_ECOFF_DEBUG
2273 ecoff_generate_asm_lineno,
2276 0, /* generate_asm_lineno */
2277 0, /* process_stab */
2279 elf_separate_stab_sections,
2280 elf_init_stab_section,
2281 elf_sec_sym_ok_for_reloc,
2283 #ifdef NEED_ECOFF_DEBUG
2286 0, /* ecoff_set_ext */
2288 elf_obj_read_begin_hook,
2289 elf_obj_symbol_new_hook