1 /* ELF object file format
2 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 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, 51 Franklin Street - Fifth Floor, Boston, MA
22 #define OBJ_HEADER "obj-elf.h"
24 #include "safe-ctype.h"
27 #include "struc-symbol.h"
28 #include "dwarf2dbg.h"
30 #ifndef ECOFF_DEBUGGING
31 #define ECOFF_DEBUGGING 0
33 #define NEED_ECOFF_DEBUG
36 #ifdef NEED_ECOFF_DEBUG
41 #include "elf/alpha.h"
57 #include "elf/x86-64.h"
60 static void obj_elf_line (int);
61 static void obj_elf_size (int);
62 static void obj_elf_type (int);
63 static void obj_elf_ident (int);
64 static void obj_elf_weak (int);
65 static void obj_elf_local (int);
66 static void obj_elf_visibility (int);
67 static void obj_elf_symver (int);
68 static void obj_elf_subsection (int);
69 static void obj_elf_popsection (int);
70 static void obj_elf_tls_common (int);
71 static void obj_elf_lcomm (int);
72 static void obj_elf_struct (int);
74 static const pseudo_typeS elf_pseudo_table
[] =
76 {"comm", obj_elf_common
, 0},
77 {"common", obj_elf_common
, 1},
78 {"ident", obj_elf_ident
, 0},
79 {"lcomm", obj_elf_lcomm
, 0},
80 {"local", obj_elf_local
, 0},
81 {"previous", obj_elf_previous
, 0},
82 {"section", obj_elf_section
, 0},
83 {"section.s", obj_elf_section
, 0},
84 {"sect", obj_elf_section
, 0},
85 {"sect.s", obj_elf_section
, 0},
86 {"pushsection", obj_elf_section
, 1},
87 {"popsection", obj_elf_popsection
, 0},
88 {"size", obj_elf_size
, 0},
89 {"type", obj_elf_type
, 0},
90 {"version", obj_elf_version
, 0},
91 {"weak", obj_elf_weak
, 0},
93 /* These define symbol visibility. */
94 {"internal", obj_elf_visibility
, STV_INTERNAL
},
95 {"hidden", obj_elf_visibility
, STV_HIDDEN
},
96 {"protected", obj_elf_visibility
, STV_PROTECTED
},
98 /* These are used for stabs-in-elf configurations. */
99 {"line", obj_elf_line
, 0},
101 /* This is a GNU extension to handle symbol versions. */
102 {"symver", obj_elf_symver
, 0},
104 /* A GNU extension to change subsection only. */
105 {"subsection", obj_elf_subsection
, 0},
107 /* These are GNU extensions to aid in garbage collecting C++ vtables. */
108 {"vtable_inherit", (void (*) (int)) &obj_elf_vtable_inherit
, 0},
109 {"vtable_entry", (void (*) (int)) &obj_elf_vtable_entry
, 0},
111 /* These are used for dwarf. */
115 /* These are used for dwarf2. */
116 { "file", (void (*) (int)) dwarf2_directive_file
, 0 },
117 { "loc", dwarf2_directive_loc
, 0 },
118 { "loc_mark_labels", dwarf2_directive_loc_mark_labels
, 0 },
120 /* We need to trap the section changing calls to handle .previous. */
121 {"data", obj_elf_data
, 0},
122 {"offset", obj_elf_struct
, 0},
123 {"struct", obj_elf_struct
, 0},
124 {"text", obj_elf_text
, 0},
126 {"tls_common", obj_elf_tls_common
, 0},
132 static const pseudo_typeS ecoff_debug_pseudo_table
[] =
134 #ifdef NEED_ECOFF_DEBUG
135 /* COFF style debugging information for ECOFF. .ln is not used; .loc
137 { "def", ecoff_directive_def
, 0 },
138 { "dim", ecoff_directive_dim
, 0 },
139 { "endef", ecoff_directive_endef
, 0 },
140 { "file", ecoff_directive_file
, 0 },
141 { "scl", ecoff_directive_scl
, 0 },
142 { "tag", ecoff_directive_tag
, 0 },
143 { "val", ecoff_directive_val
, 0 },
145 /* COFF debugging requires pseudo-ops .size and .type, but ELF
146 already has meanings for those. We use .esize and .etype
147 instead. These are only generated by gcc anyhow. */
148 { "esize", ecoff_directive_size
, 0 },
149 { "etype", ecoff_directive_type
, 0 },
151 /* ECOFF specific debugging information. */
152 { "begin", ecoff_directive_begin
, 0 },
153 { "bend", ecoff_directive_bend
, 0 },
154 { "end", ecoff_directive_end
, 0 },
155 { "ent", ecoff_directive_ent
, 0 },
156 { "fmask", ecoff_directive_fmask
, 0 },
157 { "frame", ecoff_directive_frame
, 0 },
158 { "loc", ecoff_directive_loc
, 0 },
159 { "mask", ecoff_directive_mask
, 0 },
161 /* Other ECOFF directives. */
162 { "extern", ecoff_directive_extern
, 0 },
164 /* These are used on Irix. I don't know how to implement them. */
165 { "alias", s_ignore
, 0 },
166 { "bgnb", s_ignore
, 0 },
167 { "endb", s_ignore
, 0 },
168 { "lab", s_ignore
, 0 },
169 { "noalias", s_ignore
, 0 },
170 { "verstamp", s_ignore
, 0 },
171 { "vreg", s_ignore
, 0 },
174 {NULL
, NULL
, 0} /* end sentinel */
178 #include "aout/aout64.h"
180 /* This is called when the assembler starts. */
182 asection
*elf_com_section_ptr
;
189 /* Add symbols for the known sections to the symbol table. */
190 s
= bfd_get_section_by_name (stdoutput
, TEXT_SECTION_NAME
);
191 symbol_table_insert (section_symbol (s
));
192 s
= bfd_get_section_by_name (stdoutput
, DATA_SECTION_NAME
);
193 symbol_table_insert (section_symbol (s
));
194 s
= bfd_get_section_by_name (stdoutput
, BSS_SECTION_NAME
);
195 symbol_table_insert (section_symbol (s
));
196 elf_com_section_ptr
= bfd_com_section_ptr
;
200 elf_pop_insert (void)
202 pop_insert (elf_pseudo_table
);
204 pop_insert (ecoff_debug_pseudo_table
);
208 elf_s_get_size (symbolS
*sym
)
210 return S_GET_SIZE (sym
);
214 elf_s_set_size (symbolS
*sym
, bfd_vma sz
)
216 S_SET_SIZE (sym
, sz
);
220 elf_s_get_align (symbolS
*sym
)
222 return S_GET_ALIGN (sym
);
226 elf_s_set_align (symbolS
*sym
, bfd_vma align
)
228 S_SET_ALIGN (sym
, align
);
232 elf_s_get_other (symbolS
*sym
)
234 return elf_symbol (symbol_get_bfdsym (sym
))->internal_elf_sym
.st_other
;
238 elf_s_set_other (symbolS
*sym
, int other
)
240 S_SET_OTHER (sym
, other
);
244 elf_sec_sym_ok_for_reloc (asection
*sec
)
246 return obj_sec_sym_ok_for_reloc (sec
);
250 elf_file_symbol (const char *s
, int appfile
)
253 || symbol_rootP
== NULL
254 || symbol_rootP
->bsym
== NULL
255 || (symbol_rootP
->bsym
->flags
& BSF_FILE
) == 0)
259 sym
= symbol_new (s
, absolute_section
, 0, NULL
);
260 symbol_set_frag (sym
, &zero_address_frag
);
261 symbol_get_bfdsym (sym
)->flags
|= BSF_FILE
;
263 if (symbol_rootP
!= sym
)
265 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
266 symbol_insert (sym
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
268 verify_symbol_chain (symbol_rootP
, symbol_lastP
);
273 #ifdef NEED_ECOFF_DEBUG
274 ecoff_new_file (s
, appfile
);
278 /* Called from read.c:s_comm after we've parsed .comm symbol, size.
279 Parse a possible alignment value. */
282 elf_common_parse (int ignore ATTRIBUTE_UNUSED
, symbolS
*symbolP
, addressT size
)
285 int is_local
= symbol_get_obj (symbolP
)->local
;
287 if (*input_line_pointer
== ',')
289 char *save
= input_line_pointer
;
291 input_line_pointer
++;
294 if (*input_line_pointer
== '"')
296 /* For sparc. Accept .common symbol, length, "bss" */
297 input_line_pointer
++;
298 /* Some use the dot, some don't. */
299 if (*input_line_pointer
== '.')
300 input_line_pointer
++;
301 /* Some say data, some say bss. */
302 if (strncmp (input_line_pointer
, "bss\"", 4) == 0)
303 input_line_pointer
+= 4;
304 else if (strncmp (input_line_pointer
, "data\"", 5) == 0)
305 input_line_pointer
+= 5;
308 char *p
= input_line_pointer
;
313 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
314 if (*input_line_pointer
++ == '"')
316 c
= *input_line_pointer
;
317 *input_line_pointer
= '\0';
318 as_bad (_("bad .common segment %s"), p
);
319 *input_line_pointer
= c
;
320 ignore_rest_of_line ();
323 /* ??? Don't ask me why these are always global. */
328 input_line_pointer
= save
;
329 align
= parse_align (is_local
);
330 if (align
== (addressT
) -1)
337 bss_alloc (symbolP
, size
, align
);
338 S_CLEAR_EXTERNAL (symbolP
);
342 S_SET_VALUE (symbolP
, size
);
343 S_SET_ALIGN (symbolP
, align
);
344 S_SET_EXTERNAL (symbolP
);
345 S_SET_SEGMENT (symbolP
, elf_com_section_ptr
);
348 symbol_get_bfdsym (symbolP
)->flags
|= BSF_OBJECT
;
354 obj_elf_common (int is_common
)
356 if (flag_mri
&& is_common
)
359 s_comm_internal (0, elf_common_parse
);
363 obj_elf_tls_common (int ignore ATTRIBUTE_UNUSED
)
365 symbolS
*symbolP
= s_comm_internal (0, elf_common_parse
);
368 symbol_get_bfdsym (symbolP
)->flags
|= BSF_THREAD_LOCAL
;
372 obj_elf_lcomm (int ignore ATTRIBUTE_UNUSED
)
374 symbolS
*symbolP
= s_comm_internal (0, s_lcomm_internal
);
377 symbol_get_bfdsym (symbolP
)->flags
|= BSF_OBJECT
;
381 obj_elf_local (int ignore ATTRIBUTE_UNUSED
)
389 name
= input_line_pointer
;
390 c
= get_symbol_end ();
391 symbolP
= symbol_find_or_make (name
);
392 *input_line_pointer
= c
;
394 S_CLEAR_EXTERNAL (symbolP
);
395 symbol_get_obj (symbolP
)->local
= 1;
398 input_line_pointer
++;
400 if (*input_line_pointer
== '\n')
405 demand_empty_rest_of_line ();
409 obj_elf_weak (int ignore ATTRIBUTE_UNUSED
)
417 name
= input_line_pointer
;
418 c
= get_symbol_end ();
419 symbolP
= symbol_find_or_make (name
);
420 *input_line_pointer
= c
;
422 S_SET_WEAK (symbolP
);
423 symbol_get_obj (symbolP
)->local
= 1;
426 input_line_pointer
++;
428 if (*input_line_pointer
== '\n')
433 demand_empty_rest_of_line ();
437 obj_elf_visibility (int visibility
)
443 elf_symbol_type
*elfsym
;
447 name
= input_line_pointer
;
448 c
= get_symbol_end ();
449 symbolP
= symbol_find_or_make (name
);
450 *input_line_pointer
= c
;
454 bfdsym
= symbol_get_bfdsym (symbolP
);
455 elfsym
= elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
459 elfsym
->internal_elf_sym
.st_other
&= ~3;
460 elfsym
->internal_elf_sym
.st_other
|= visibility
;
464 input_line_pointer
++;
468 if (*input_line_pointer
== '\n')
474 demand_empty_rest_of_line ();
477 static segT previous_section
;
478 static int previous_subsection
;
482 struct section_stack
*next
;
484 int subseg
, prev_subseg
;
487 static struct section_stack
*section_stack
;
490 get_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
492 const char *gname
= inf
;
493 const char *group_name
= elf_group_name (sec
);
495 return (group_name
== gname
496 || (group_name
!= NULL
498 && strcmp (group_name
, gname
) == 0));
501 /* Handle the .section pseudo-op. This code supports two different
504 The first is found on Solaris, and looks like
505 .section ".sec1",#alloc,#execinstr,#write
506 Here the names after '#' are the SHF_* flags to turn on for the
507 section. I'm not sure how it determines the SHT_* type (BFD
508 doesn't really give us control over the type, anyhow).
510 The second format is found on UnixWare, and probably most SVR4
511 machines, and looks like
512 .section .sec1,"a",@progbits
513 The quoted string may contain any combination of a, w, x, and
514 represents the SHF_* flags to turn on for the section. The string
515 beginning with '@' can be progbits or nobits. There should be
516 other possibilities, but I don't know what they are. In any case,
517 BFD doesn't really let us set the section type. */
520 obj_elf_change_section (const char *name
,
524 const char *group_name
,
531 const struct elf_backend_data
*bed
;
532 const struct bfd_elf_special_section
*ssect
;
534 #ifdef md_flush_pending_output
535 md_flush_pending_output ();
538 /* Switch to the section, creating it if necessary. */
541 struct section_stack
*elt
;
542 elt
= xmalloc (sizeof (struct section_stack
));
543 elt
->next
= section_stack
;
545 elt
->prev_seg
= previous_section
;
546 elt
->subseg
= now_subseg
;
547 elt
->prev_subseg
= previous_subsection
;
550 previous_section
= now_seg
;
551 previous_subsection
= now_subseg
;
553 old_sec
= bfd_get_section_by_name_if (stdoutput
, name
, get_section
,
554 (void *) group_name
);
561 sec
= subseg_force_new (name
, 0);
563 bed
= get_elf_backend_data (stdoutput
);
564 ssect
= (*bed
->get_sec_type_attr
) (stdoutput
, sec
);
568 bfd_boolean override
= FALSE
;
570 if (type
== SHT_NULL
)
572 else if (type
!= ssect
->type
)
575 /* FIXME: gcc, as of 2002-10-22, will emit
577 .section .init_array,"aw",@progbits
579 for __attribute__ ((section (".init_array"))).
580 "@progbits" is incorrect. Also for x86-64 large bss
581 sections, gcc, as of 2005-07-06, will emit
583 .section .lbss,"aw",@progbits
585 "@progbits" is incorrect. */
587 && (bed
->s
->arch_size
!= 64
588 || !(ssect
->attr
& SHF_X86_64_LARGE
))
590 && ssect
->type
!= SHT_INIT_ARRAY
591 && ssect
->type
!= SHT_FINI_ARRAY
592 && ssect
->type
!= SHT_PREINIT_ARRAY
)
594 /* We allow to specify any type for a .note section. */
595 if (ssect
->type
!= SHT_NOTE
)
596 as_warn (_("setting incorrect section type for %s"),
601 as_warn (_("ignoring incorrect section type for %s"),
607 if (old_sec
== NULL
&& (attr
& ~ssect
->attr
) != 0)
609 /* As a GNU extension, we permit a .note section to be
610 allocatable. If the linker sees an allocatable .note
611 section, it will create a PT_NOTE segment in the output
612 file. We also allow "x" for .note.GNU-stack. */
613 if (ssect
->type
== SHT_NOTE
614 && (attr
== SHF_ALLOC
|| attr
== SHF_EXECINSTR
))
616 /* Allow different SHF_MERGE and SHF_STRINGS if we have
617 something like .rodata.str. */
618 else if (ssect
->suffix_length
== -2
619 && name
[ssect
->prefix_length
] == '.'
623 & ~SHF_STRINGS
) == 0)
625 /* .interp, .strtab and .symtab can have SHF_ALLOC. */
626 else if (attr
== SHF_ALLOC
627 && (strcmp (name
, ".interp") == 0
628 || strcmp (name
, ".strtab") == 0
629 || strcmp (name
, ".symtab") == 0))
631 /* .note.GNU-stack can have SHF_EXECINSTR. */
632 else if (attr
== SHF_EXECINSTR
633 && strcmp (name
, ".note.GNU-stack") == 0)
636 /* A section on Alpha may have SHF_ALPHA_GPREL. */
637 else if ((attr
& ~ssect
->attr
) == SHF_ALPHA_GPREL
)
642 if (group_name
== NULL
)
643 as_warn (_("setting incorrect section attributes for %s"),
648 if (!override
&& old_sec
== NULL
)
652 /* Convert ELF type and flags to BFD flags. */
654 | ((attr
& SHF_WRITE
) ? 0 : SEC_READONLY
)
655 | ((attr
& SHF_ALLOC
) ? SEC_ALLOC
: 0)
656 | (((attr
& SHF_ALLOC
) && type
!= SHT_NOBITS
) ? SEC_LOAD
: 0)
657 | ((attr
& SHF_EXECINSTR
) ? SEC_CODE
: 0)
658 | ((attr
& SHF_MERGE
) ? SEC_MERGE
: 0)
659 | ((attr
& SHF_STRINGS
) ? SEC_STRINGS
: 0)
660 | ((attr
& SHF_TLS
) ? SEC_THREAD_LOCAL
: 0));
661 #ifdef md_elf_section_flags
662 flags
= md_elf_section_flags (flags
, attr
, type
);
666 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
672 elf_section_type (sec
) = type
;
673 elf_section_flags (sec
) = attr
;
675 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */
676 if (type
== SHT_NOBITS
)
677 seg_info (sec
)->bss
= 1;
679 bfd_set_section_flags (stdoutput
, sec
, flags
);
680 if (flags
& SEC_MERGE
)
681 sec
->entsize
= entsize
;
682 elf_group_name (sec
) = group_name
;
684 /* Add a symbol for this section to the symbol table. */
685 secsym
= symbol_find (name
);
687 symbol_set_bfdsym (secsym
, sec
->symbol
);
689 symbol_table_insert (section_symbol (sec
));
694 && (unsigned) type
!= elf_section_type (old_sec
))
695 as_warn (_("ignoring changed section type for %s"), name
);
699 /* If section attributes are specified the second time we see a
700 particular section, then check that they are the same as we
701 saw the first time. */
702 if (((old_sec
->flags
^ flags
)
703 & (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
704 | SEC_EXCLUDE
| SEC_SORT_ENTRIES
| SEC_MERGE
| SEC_STRINGS
705 | SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
706 | SEC_THREAD_LOCAL
)))
707 as_warn (_("ignoring changed section attributes for %s"), name
);
708 if ((flags
& SEC_MERGE
) && old_sec
->entsize
!= (unsigned) entsize
)
709 as_warn (_("ignoring changed section entity size for %s"), name
);
713 #ifdef md_elf_section_change_hook
714 md_elf_section_change_hook ();
719 obj_elf_parse_section_letters (char *str
, size_t len
)
734 attr
|= SHF_EXECINSTR
;
750 if (*(str
- 1) == 'a')
753 if (len
> 1 && str
[1] == 's')
762 char *bad_msg
= _("unrecognized .section attribute: want a,w,x,M,S,G,T");
763 #ifdef md_elf_section_letter
764 int md_attr
= md_elf_section_letter (*str
, &bad_msg
);
769 as_fatal ("%s", bad_msg
);
780 obj_elf_section_word (char *str
, size_t len
)
782 if (len
== 5 && strncmp (str
, "write", 5) == 0)
784 if (len
== 5 && strncmp (str
, "alloc", 5) == 0)
786 if (len
== 9 && strncmp (str
, "execinstr", 9) == 0)
787 return SHF_EXECINSTR
;
788 if (len
== 3 && strncmp (str
, "tls", 3) == 0)
791 #ifdef md_elf_section_word
793 int md_attr
= md_elf_section_word (str
, len
);
799 as_warn (_("unrecognized section attribute"));
804 obj_elf_section_type (char *str
, size_t len
)
806 if (len
== 8 && strncmp (str
, "progbits", 8) == 0)
808 if (len
== 6 && strncmp (str
, "nobits", 6) == 0)
810 if (len
== 4 && strncmp (str
, "note", 4) == 0)
812 if (len
== 10 && strncmp (str
, "init_array", 10) == 0)
813 return SHT_INIT_ARRAY
;
814 if (len
== 10 && strncmp (str
, "fini_array", 10) == 0)
815 return SHT_FINI_ARRAY
;
816 if (len
== 13 && strncmp (str
, "preinit_array", 13) == 0)
817 return SHT_PREINIT_ARRAY
;
819 #ifdef md_elf_section_type
821 int md_type
= md_elf_section_type (str
, len
);
827 as_warn (_("unrecognized section type"));
831 /* Get name of section. */
833 obj_elf_section_name (void)
838 if (*input_line_pointer
== '"')
842 name
= demand_copy_C_string (&dummy
);
845 ignore_rest_of_line ();
851 char *end
= input_line_pointer
;
853 while (0 == strchr ("\n\t,; ", *end
))
855 if (end
== input_line_pointer
)
857 as_bad (_("missing name"));
858 ignore_rest_of_line ();
862 name
= xmalloc (end
- input_line_pointer
+ 1);
863 memcpy (name
, input_line_pointer
, end
- input_line_pointer
);
864 name
[end
- input_line_pointer
] = '\0';
865 #ifdef tc_canonicalize_section_name
866 name
= tc_canonicalize_section_name (name
);
868 input_line_pointer
= end
;
875 obj_elf_section (int push
)
877 char *name
, *group_name
, *beg
;
878 int type
, attr
, dummy
;
887 #ifdef md_flush_pending_output
888 md_flush_pending_output ();
891 previous_section
= now_seg
;
892 previous_subsection
= now_subseg
;
894 s_mri_sect (&mri_type
);
896 #ifdef md_elf_section_change_hook
897 md_elf_section_change_hook ();
902 #endif /* ! defined (TC_I370) */
904 name
= obj_elf_section_name ();
913 if (*input_line_pointer
== ',')
915 /* Skip the comma. */
916 ++input_line_pointer
;
919 if (*input_line_pointer
== '"')
921 beg
= demand_copy_C_string (&dummy
);
924 ignore_rest_of_line ();
927 attr
|= obj_elf_parse_section_letters (beg
, strlen (beg
));
930 if (*input_line_pointer
== ',')
933 char *save
= input_line_pointer
;
935 ++input_line_pointer
;
937 c
= *input_line_pointer
;
940 beg
= demand_copy_C_string (&dummy
);
943 ignore_rest_of_line ();
946 type
= obj_elf_section_type (beg
, strlen (beg
));
948 else if (c
== '@' || c
== '%')
950 beg
= ++input_line_pointer
;
951 c
= get_symbol_end ();
952 *input_line_pointer
= c
;
953 type
= obj_elf_section_type (beg
, input_line_pointer
- beg
);
956 input_line_pointer
= save
;
960 if ((attr
& SHF_MERGE
) != 0 && *input_line_pointer
== ',')
962 ++input_line_pointer
;
964 entsize
= get_absolute_expression ();
968 as_warn (_("invalid merge entity size"));
973 else if ((attr
& SHF_MERGE
) != 0)
975 as_warn (_("entity size for SHF_MERGE not specified"));
979 if ((attr
& SHF_GROUP
) != 0 && *input_line_pointer
== ',')
981 ++input_line_pointer
;
982 group_name
= obj_elf_section_name ();
983 if (group_name
== NULL
)
985 else if (strncmp (input_line_pointer
, ",comdat", 7) == 0)
987 input_line_pointer
+= 7;
990 else if (strncmp (name
, ".gnu.linkonce", 13) == 0)
993 else if ((attr
& SHF_GROUP
) != 0)
995 as_warn (_("group name for SHF_GROUP not specified"));
1006 if (*input_line_pointer
!= '#')
1008 as_bad (_("character following name is not '#'"));
1009 ignore_rest_of_line ();
1012 beg
= ++input_line_pointer
;
1013 c
= get_symbol_end ();
1014 *input_line_pointer
= c
;
1016 attr
|= obj_elf_section_word (beg
, input_line_pointer
- beg
);
1020 while (*input_line_pointer
++ == ',');
1021 --input_line_pointer
;
1025 demand_empty_rest_of_line ();
1027 obj_elf_change_section (name
, type
, attr
, entsize
, group_name
, linkonce
, push
);
1030 /* Change to the .data section. */
1033 obj_elf_data (int i
)
1035 #ifdef md_flush_pending_output
1036 md_flush_pending_output ();
1039 previous_section
= now_seg
;
1040 previous_subsection
= now_subseg
;
1043 #ifdef md_elf_section_change_hook
1044 md_elf_section_change_hook ();
1048 /* Change to the .text section. */
1051 obj_elf_text (int i
)
1053 #ifdef md_flush_pending_output
1054 md_flush_pending_output ();
1057 previous_section
= now_seg
;
1058 previous_subsection
= now_subseg
;
1061 #ifdef md_elf_section_change_hook
1062 md_elf_section_change_hook ();
1066 /* Change to the *ABS* section. */
1069 obj_elf_struct (int i
)
1071 #ifdef md_flush_pending_output
1072 md_flush_pending_output ();
1075 previous_section
= now_seg
;
1076 previous_subsection
= now_subseg
;
1079 #ifdef md_elf_section_change_hook
1080 md_elf_section_change_hook ();
1085 obj_elf_subsection (int ignore ATTRIBUTE_UNUSED
)
1089 #ifdef md_flush_pending_output
1090 md_flush_pending_output ();
1093 previous_section
= now_seg
;
1094 previous_subsection
= now_subseg
;
1096 temp
= get_absolute_expression ();
1097 subseg_set (now_seg
, (subsegT
) temp
);
1098 demand_empty_rest_of_line ();
1100 #ifdef md_elf_section_change_hook
1101 md_elf_section_change_hook ();
1105 /* This can be called from the processor backends if they change
1109 obj_elf_section_change_hook (void)
1111 previous_section
= now_seg
;
1112 previous_subsection
= now_subseg
;
1116 obj_elf_previous (int ignore ATTRIBUTE_UNUSED
)
1121 if (previous_section
== 0)
1123 as_warn (_(".previous without corresponding .section; ignored"));
1127 #ifdef md_flush_pending_output
1128 md_flush_pending_output ();
1131 new_section
= previous_section
;
1132 new_subsection
= previous_subsection
;
1133 previous_section
= now_seg
;
1134 previous_subsection
= now_subseg
;
1135 subseg_set (new_section
, new_subsection
);
1137 #ifdef md_elf_section_change_hook
1138 md_elf_section_change_hook ();
1143 obj_elf_popsection (int xxx ATTRIBUTE_UNUSED
)
1145 struct section_stack
*top
= section_stack
;
1149 as_warn (_(".popsection without corresponding .pushsection; ignored"));
1153 #ifdef md_flush_pending_output
1154 md_flush_pending_output ();
1157 section_stack
= top
->next
;
1158 previous_section
= top
->prev_seg
;
1159 previous_subsection
= top
->prev_subseg
;
1160 subseg_set (top
->seg
, top
->subseg
);
1163 #ifdef md_elf_section_change_hook
1164 md_elf_section_change_hook ();
1169 obj_elf_line (int ignore ATTRIBUTE_UNUSED
)
1171 /* Assume delimiter is part of expression. BSD4.2 as fails with
1172 delightful bug, so we are not being incompatible here. */
1173 new_logical_line (NULL
, get_absolute_expression ());
1174 demand_empty_rest_of_line ();
1177 /* This handles the .symver pseudo-op, which is used to specify a
1178 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1179 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1180 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1181 with the same value as the symbol NAME. */
1184 obj_elf_symver (int ignore ATTRIBUTE_UNUSED
)
1191 name
= input_line_pointer
;
1192 c
= get_symbol_end ();
1194 sym
= symbol_find_or_make (name
);
1196 *input_line_pointer
= c
;
1199 if (*input_line_pointer
!= ',')
1201 as_bad (_("expected comma after name in .symver"));
1202 ignore_rest_of_line ();
1206 ++input_line_pointer
;
1208 name
= input_line_pointer
;
1210 /* Temporarily include '@' in symbol names. */
1211 old_lexat
= lex_type
[(unsigned char) '@'];
1212 lex_type
[(unsigned char) '@'] |= LEX_NAME
;
1213 c
= get_symbol_end ();
1214 lex_type
[(unsigned char) '@'] = old_lexat
;
1216 if (symbol_get_obj (sym
)->versioned_name
== NULL
)
1218 symbol_get_obj (sym
)->versioned_name
= xstrdup (name
);
1220 *input_line_pointer
= c
;
1222 if (strchr (symbol_get_obj (sym
)->versioned_name
,
1223 ELF_VER_CHR
) == NULL
)
1225 as_bad (_("missing version name in `%s' for symbol `%s'"),
1226 symbol_get_obj (sym
)->versioned_name
,
1228 ignore_rest_of_line ();
1234 if (strcmp (symbol_get_obj (sym
)->versioned_name
, name
))
1236 as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1237 name
, symbol_get_obj (sym
)->versioned_name
,
1239 ignore_rest_of_line ();
1243 *input_line_pointer
= c
;
1246 demand_empty_rest_of_line ();
1249 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1250 to the linker the hierarchy in which a particular table resides. The
1251 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1254 obj_elf_vtable_inherit (int ignore ATTRIBUTE_UNUSED
)
1256 char *cname
, *pname
;
1257 symbolS
*csym
, *psym
;
1260 if (*input_line_pointer
== '#')
1261 ++input_line_pointer
;
1263 cname
= input_line_pointer
;
1264 c
= get_symbol_end ();
1265 csym
= symbol_find (cname
);
1267 /* GCFIXME: should check that we don't have two .vtable_inherits for
1268 the same child symbol. Also, we can currently only do this if the
1269 child symbol is already exists and is placed in a fragment. */
1271 if (csym
== NULL
|| symbol_get_frag (csym
) == NULL
)
1273 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1278 *input_line_pointer
= c
;
1281 if (*input_line_pointer
!= ',')
1283 as_bad ("expected comma after name in .vtable_inherit");
1284 ignore_rest_of_line ();
1288 ++input_line_pointer
;
1291 if (*input_line_pointer
== '#')
1292 ++input_line_pointer
;
1294 if (input_line_pointer
[0] == '0'
1295 && (input_line_pointer
[1] == '\0'
1296 || ISSPACE (input_line_pointer
[1])))
1298 psym
= section_symbol (absolute_section
);
1299 ++input_line_pointer
;
1303 pname
= input_line_pointer
;
1304 c
= get_symbol_end ();
1305 psym
= symbol_find_or_make (pname
);
1306 *input_line_pointer
= c
;
1309 demand_empty_rest_of_line ();
1314 assert (symbol_get_value_expression (csym
)->X_op
== O_constant
);
1315 return fix_new (symbol_get_frag (csym
),
1316 symbol_get_value_expression (csym
)->X_add_number
,
1317 0, psym
, 0, 0, BFD_RELOC_VTABLE_INHERIT
);
1320 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1321 to the linker that a vtable slot was used. The syntax is
1322 ".vtable_entry tablename, offset". */
1325 obj_elf_vtable_entry (int ignore ATTRIBUTE_UNUSED
)
1332 if (*input_line_pointer
== '#')
1333 ++input_line_pointer
;
1335 name
= input_line_pointer
;
1336 c
= get_symbol_end ();
1337 sym
= symbol_find_or_make (name
);
1338 *input_line_pointer
= c
;
1341 if (*input_line_pointer
!= ',')
1343 as_bad ("expected comma after name in .vtable_entry");
1344 ignore_rest_of_line ();
1348 ++input_line_pointer
;
1349 if (*input_line_pointer
== '#')
1350 ++input_line_pointer
;
1352 offset
= get_absolute_expression ();
1354 demand_empty_rest_of_line ();
1356 return fix_new (frag_now
, frag_now_fix (), 0, sym
, offset
, 0,
1357 BFD_RELOC_VTABLE_ENTRY
);
1361 elf_obj_read_begin_hook (void)
1363 #ifdef NEED_ECOFF_DEBUG
1364 if (ECOFF_DEBUGGING
)
1365 ecoff_read_begin_hook ();
1370 elf_obj_symbol_new_hook (symbolS
*symbolP
)
1372 struct elf_obj_sy
*sy_obj
;
1374 sy_obj
= symbol_get_obj (symbolP
);
1375 sy_obj
->size
= NULL
;
1376 sy_obj
->versioned_name
= NULL
;
1378 #ifdef NEED_ECOFF_DEBUG
1379 if (ECOFF_DEBUGGING
)
1380 ecoff_symbol_new_hook (symbolP
);
1384 /* When setting one symbol equal to another, by default we probably
1385 want them to have the same "size", whatever it means in the current
1389 elf_copy_symbol_attributes (symbolS
*dest
, symbolS
*src
)
1391 struct elf_obj_sy
*srcelf
= symbol_get_obj (src
);
1392 struct elf_obj_sy
*destelf
= symbol_get_obj (dest
);
1395 if (destelf
->size
== NULL
)
1396 destelf
->size
= xmalloc (sizeof (expressionS
));
1397 *destelf
->size
= *srcelf
->size
;
1401 if (destelf
->size
!= NULL
)
1402 free (destelf
->size
);
1403 destelf
->size
= NULL
;
1405 S_SET_SIZE (dest
, S_GET_SIZE (src
));
1406 /* Don't copy visibility. */
1407 S_SET_OTHER (dest
, (ELF_ST_VISIBILITY (S_GET_OTHER (dest
))
1408 | (S_GET_OTHER (src
) & ~ELF_ST_VISIBILITY (-1))));
1412 obj_elf_version (int ignore ATTRIBUTE_UNUSED
)
1417 asection
*seg
= now_seg
;
1418 subsegT subseg
= now_subseg
;
1419 Elf_Internal_Note i_note
;
1420 Elf_External_Note e_note
;
1421 asection
*note_secp
= NULL
;
1425 if (*input_line_pointer
== '\"')
1427 ++input_line_pointer
; /* -> 1st char of string. */
1428 name
= input_line_pointer
;
1430 while (is_a_char (c
= next_char_of_string ()))
1432 c
= *input_line_pointer
;
1433 *input_line_pointer
= '\0';
1434 *(input_line_pointer
- 1) = '\0';
1435 *input_line_pointer
= c
;
1437 /* create the .note section */
1439 note_secp
= subseg_new (".note", 0);
1440 bfd_set_section_flags (stdoutput
,
1442 SEC_HAS_CONTENTS
| SEC_READONLY
);
1444 /* process the version string */
1446 len
= strlen (name
);
1448 i_note
.namesz
= ((len
+ 1) + 3) & ~3; /* round this to word boundary */
1449 i_note
.descsz
= 0; /* no description */
1450 i_note
.type
= NT_VERSION
;
1451 p
= frag_more (sizeof (e_note
.namesz
));
1452 md_number_to_chars (p
, i_note
.namesz
, sizeof (e_note
.namesz
));
1453 p
= frag_more (sizeof (e_note
.descsz
));
1454 md_number_to_chars (p
, i_note
.descsz
, sizeof (e_note
.descsz
));
1455 p
= frag_more (sizeof (e_note
.type
));
1456 md_number_to_chars (p
, i_note
.type
, sizeof (e_note
.type
));
1457 p
= frag_more (len
+ 1);
1460 frag_align (2, 0, 0);
1462 subseg_set (seg
, subseg
);
1466 as_bad (_("expected quoted string"));
1468 demand_empty_rest_of_line ();
1472 obj_elf_size (int ignore ATTRIBUTE_UNUSED
)
1474 char *name
= input_line_pointer
;
1475 char c
= get_symbol_end ();
1480 p
= input_line_pointer
;
1483 if (*input_line_pointer
!= ',')
1486 as_bad (_("expected comma after name `%s' in .size directive"), name
);
1488 ignore_rest_of_line ();
1491 input_line_pointer
++;
1493 if (exp
.X_op
== O_absent
)
1495 as_bad (_("missing expression in .size directive"));
1496 exp
.X_op
= O_constant
;
1497 exp
.X_add_number
= 0;
1500 sym
= symbol_find_or_make (name
);
1502 if (exp
.X_op
== O_constant
)
1504 S_SET_SIZE (sym
, exp
.X_add_number
);
1505 if (symbol_get_obj (sym
)->size
)
1507 xfree (symbol_get_obj (sym
)->size
);
1508 symbol_get_obj (sym
)->size
= NULL
;
1513 symbol_get_obj (sym
)->size
= xmalloc (sizeof (expressionS
));
1514 *symbol_get_obj (sym
)->size
= exp
;
1516 demand_empty_rest_of_line ();
1519 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1520 There are five syntaxes:
1522 The first (used on Solaris) is
1524 The second (used on UnixWare) is
1526 The third (reportedly to be used on Irix 6.0) is
1528 The fourth (used on NetBSD/Arm and Linux/ARM) is
1530 The fifth (used on SVR4/860) is
1531 .type SYM,"function"
1535 obj_elf_type (int ignore ATTRIBUTE_UNUSED
)
1540 const char *typename
;
1542 elf_symbol_type
*elfsym
;
1544 name
= input_line_pointer
;
1545 c
= get_symbol_end ();
1546 sym
= symbol_find_or_make (name
);
1547 elfsym
= (elf_symbol_type
*) symbol_get_bfdsym (sym
);
1548 *input_line_pointer
= c
;
1551 if (*input_line_pointer
== ',')
1552 ++input_line_pointer
;
1555 if ( *input_line_pointer
== '#'
1556 || *input_line_pointer
== '@'
1557 || *input_line_pointer
== '"'
1558 || *input_line_pointer
== '%')
1559 ++input_line_pointer
;
1561 typename
= input_line_pointer
;
1562 c
= get_symbol_end ();
1565 if (strcmp (typename
, "function") == 0
1566 || strcmp (typename
, "STT_FUNC") == 0)
1567 type
= BSF_FUNCTION
;
1568 else if (strcmp (typename
, "object") == 0
1569 || strcmp (typename
, "STT_OBJECT") == 0)
1571 else if (strcmp (typename
, "tls_object") == 0
1572 || strcmp (typename
, "STT_TLS") == 0)
1573 type
= BSF_OBJECT
| BSF_THREAD_LOCAL
;
1574 else if (strcmp (typename
, "notype") == 0
1575 || strcmp (typename
, "STT_NOTYPE") == 0)
1577 #ifdef md_elf_symbol_type
1578 else if ((type
= md_elf_symbol_type (typename
, sym
, elfsym
)) != -1)
1582 as_bad (_("unrecognized symbol type \"%s\""), typename
);
1584 *input_line_pointer
= c
;
1586 if (*input_line_pointer
== '"')
1587 ++input_line_pointer
;
1589 elfsym
->symbol
.flags
|= type
;
1591 demand_empty_rest_of_line ();
1595 obj_elf_ident (int ignore ATTRIBUTE_UNUSED
)
1597 static segT comment_section
;
1598 segT old_section
= now_seg
;
1599 int old_subsection
= now_subseg
;
1601 #ifdef md_flush_pending_output
1602 md_flush_pending_output ();
1605 if (!comment_section
)
1608 comment_section
= subseg_new (".comment", 0);
1609 bfd_set_section_flags (stdoutput
, comment_section
,
1610 SEC_READONLY
| SEC_HAS_CONTENTS
);
1615 subseg_set (comment_section
, 0);
1617 subseg_set (old_section
, old_subsection
);
1620 #ifdef INIT_STAB_SECTION
1622 /* The first entry in a .stabs section is special. */
1625 obj_elf_init_stab_section (segT seg
)
1630 unsigned int stroff
;
1632 /* Force the section to align to a longword boundary. Without this,
1633 UnixWare ar crashes. */
1634 bfd_set_section_alignment (stdoutput
, seg
, 2);
1636 /* Make space for this first symbol. */
1640 as_where (&file
, NULL
);
1641 stabstr_name
= xmalloc (strlen (segment_name (seg
)) + 4);
1642 strcpy (stabstr_name
, segment_name (seg
));
1643 strcat (stabstr_name
, "str");
1644 stroff
= get_stab_string_offset (file
, stabstr_name
);
1646 md_number_to_chars (p
, stroff
, 4);
1647 seg_info (seg
)->stabu
.p
= p
;
1652 /* Fill in the counts in the first entry in a .stabs section. */
1655 adjust_stab_sections (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1662 if (strncmp (".stab", sec
->name
, 5))
1664 if (!strcmp ("str", sec
->name
+ strlen (sec
->name
) - 3))
1667 name
= alloca (strlen (sec
->name
) + 4);
1668 strcpy (name
, sec
->name
);
1669 strcat (name
, "str");
1670 strsec
= bfd_get_section_by_name (abfd
, name
);
1672 strsz
= bfd_section_size (abfd
, strsec
);
1675 nsyms
= bfd_section_size (abfd
, sec
) / 12 - 1;
1677 p
= seg_info (sec
)->stabu
.p
;
1680 bfd_h_put_16 (abfd
, nsyms
, p
+ 6);
1681 bfd_h_put_32 (abfd
, strsz
, p
+ 8);
1684 #ifdef NEED_ECOFF_DEBUG
1686 /* This function is called by the ECOFF code. It is supposed to
1687 record the external symbol information so that the backend can
1688 write it out correctly. The ELF backend doesn't actually handle
1689 this at the moment, so we do it ourselves. We save the information
1693 elf_ecoff_set_ext (symbolS
*sym
, struct ecoff_extr
*ext
)
1695 symbol_get_bfdsym (sym
)->udata
.p
= ext
;
1698 /* This function is called by bfd_ecoff_debug_externals. It is
1699 supposed to *EXT to the external symbol information, and return
1700 whether the symbol should be used at all. */
1703 elf_get_extr (asymbol
*sym
, EXTR
*ext
)
1705 if (sym
->udata
.p
== NULL
)
1707 *ext
= *(EXTR
*) sym
->udata
.p
;
1711 /* This function is called by bfd_ecoff_debug_externals. It has
1712 nothing to do for ELF. */
1715 elf_set_index (asymbol
*sym ATTRIBUTE_UNUSED
,
1716 bfd_size_type indx ATTRIBUTE_UNUSED
)
1720 #endif /* NEED_ECOFF_DEBUG */
1723 elf_frob_symbol (symbolS
*symp
, int *puntp
)
1725 struct elf_obj_sy
*sy_obj
;
1727 #ifdef NEED_ECOFF_DEBUG
1728 if (ECOFF_DEBUGGING
)
1729 ecoff_frob_symbol (symp
);
1732 sy_obj
= symbol_get_obj (symp
);
1734 if (sy_obj
->size
!= NULL
)
1736 switch (sy_obj
->size
->X_op
)
1740 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1741 + sy_obj
->size
->X_add_number
1742 - S_GET_VALUE (sy_obj
->size
->X_op_symbol
)));
1746 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1747 + sy_obj
->size
->X_add_number
));
1750 as_bad (_(".size expression too complicated to fix up"));
1753 free (sy_obj
->size
);
1754 sy_obj
->size
= NULL
;
1757 if (sy_obj
->versioned_name
!= NULL
)
1761 p
= strchr (sy_obj
->versioned_name
, ELF_VER_CHR
);
1764 /* This symbol was given a new name with the .symver directive.
1766 If this is an external reference, just rename the symbol to
1767 include the version string. This will make the relocs be
1768 against the correct versioned symbol.
1770 If this is a definition, add an alias. FIXME: Using an alias
1771 will permit the debugging information to refer to the right
1772 symbol. However, it's not clear whether it is the best
1775 if (! S_IS_DEFINED (symp
))
1777 /* Verify that the name isn't using the @@ syntax--this is
1778 reserved for definitions of the default version to link
1780 if (p
[1] == ELF_VER_CHR
)
1782 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1783 sy_obj
->versioned_name
);
1786 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1790 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
1794 /* The @@@ syntax is a special case. It renames the
1795 symbol name to versioned_name with one `@' removed. */
1796 l
= strlen (&p
[3]) + 1;
1797 memmove (&p
[2], &p
[3], l
);
1798 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1804 /* FIXME: Creating a new symbol here is risky. We're
1805 in the final loop over the symbol table. We can
1806 get away with it only because the symbol goes to
1807 the end of the list, where the loop will still see
1808 it. It would probably be better to do this in
1809 obj_frob_file_before_adjust. */
1811 symp2
= symbol_find_or_make (sy_obj
->versioned_name
);
1813 /* Now we act as though we saw symp2 = sym. */
1815 S_SET_SEGMENT (symp2
, S_GET_SEGMENT (symp
));
1817 /* Subtracting out the frag address here is a hack
1818 because we are in the middle of the final loop. */
1821 - symbol_get_frag (symp
)->fr_address
));
1823 symbol_set_frag (symp2
, symbol_get_frag (symp
));
1825 /* This will copy over the size information. */
1826 copy_symbol_attributes (symp2
, symp
);
1828 S_SET_OTHER (symp2
, S_GET_OTHER (symp
));
1830 if (S_IS_WEAK (symp
))
1833 if (S_IS_EXTERNAL (symp
))
1834 S_SET_EXTERNAL (symp2
);
1839 /* Double check weak symbols. */
1840 if (S_IS_WEAK (symp
))
1842 if (S_IS_COMMON (symp
))
1843 as_bad (_("symbol `%s' can not be both weak and common"),
1848 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1849 any undefined non-function symbol to STT_OBJECT. We try to be
1850 compatible, since newer Irix 5 and 6 linkers care. However, we
1851 only set undefined symbols to be STT_OBJECT if we are on Irix,
1852 because that is the only time gcc will generate the necessary
1853 .global directives to mark functions. */
1855 if (S_IS_COMMON (symp
))
1856 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1858 if (strstr (TARGET_OS
, "irix") != NULL
1859 && ! S_IS_DEFINED (symp
)
1860 && (symbol_get_bfdsym (symp
)->flags
& BSF_FUNCTION
) == 0)
1861 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1867 asection
**head
; /* Section lists. */
1868 unsigned int *elt_count
; /* Number of sections in each list. */
1869 unsigned int num_group
; /* Number of lists. */
1872 /* Called via bfd_map_over_sections. If SEC is a member of a group,
1873 add it to a list of sections belonging to the group. INF is a
1874 pointer to a struct group_list, which is where we store the head of
1878 build_group_lists (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
1880 struct group_list
*list
= inf
;
1881 const char *group_name
= elf_group_name (sec
);
1884 if (group_name
== NULL
)
1887 /* If this group already has a list, add the section to the head of
1889 for (i
= 0; i
< list
->num_group
; i
++)
1891 if (strcmp (group_name
, elf_group_name (list
->head
[i
])) == 0)
1893 elf_next_in_group (sec
) = list
->head
[i
];
1894 list
->head
[i
] = sec
;
1895 list
->elt_count
[i
] += 1;
1900 /* New group. Make the arrays bigger in chunks to minimize calls to
1902 i
= list
->num_group
;
1905 unsigned int newsize
= i
+ 128;
1906 list
->head
= xrealloc (list
->head
, newsize
* sizeof (*list
->head
));
1907 list
->elt_count
= xrealloc (list
->elt_count
,
1908 newsize
* sizeof (*list
->elt_count
));
1910 list
->head
[i
] = sec
;
1911 list
->elt_count
[i
] = 1;
1912 list
->num_group
+= 1;
1916 elf_frob_file (void)
1918 struct group_list list
;
1921 bfd_map_over_sections (stdoutput
, adjust_stab_sections
, NULL
);
1923 /* Go find section groups. */
1926 list
.elt_count
= NULL
;
1927 bfd_map_over_sections (stdoutput
, build_group_lists
, &list
);
1929 /* Make the SHT_GROUP sections that describe each section group. We
1930 can't set up the section contents here yet, because elf section
1931 indices have yet to be calculated. elf.c:set_group_contents does
1932 the rest of the work. */
1933 for (i
= 0; i
< list
.num_group
; i
++)
1935 const char *group_name
= elf_group_name (list
.head
[i
]);
1936 const char *sec_name
;
1943 flags
= SEC_READONLY
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_GROUP
;
1944 for (s
= list
.head
[i
]; s
!= NULL
; s
= elf_next_in_group (s
))
1945 if ((s
->flags
^ flags
) & SEC_LINK_ONCE
)
1947 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1948 if (s
!= list
.head
[i
])
1950 as_warn (_("assuming all members of group `%s' are COMDAT"),
1956 sec_name
= group_name
;
1957 sy
= symbol_find_exact (group_name
);
1960 && (sy
== symbol_lastP
1961 || (sy
->sy_next
!= NULL
1962 && sy
->sy_next
->sy_previous
== sy
)))
1965 sec_name
= ".group";
1967 s
= subseg_force_new (sec_name
, 0);
1969 || !bfd_set_section_flags (stdoutput
, s
, flags
)
1970 || !bfd_set_section_alignment (stdoutput
, s
, 2))
1972 as_fatal (_("can't create group: %s"),
1973 bfd_errmsg (bfd_get_error ()));
1975 elf_section_type (s
) = SHT_GROUP
;
1977 /* Pass a pointer to the first section in this group. */
1978 elf_next_in_group (s
) = list
.head
[i
];
1980 elf_group_id (s
) = sy
->bsym
;
1982 size
= 4 * (list
.elt_count
[i
] + 1);
1983 bfd_set_section_size (stdoutput
, s
, size
);
1984 s
->contents
= (unsigned char *) frag_more (size
);
1985 frag_now
->fr_fix
= frag_now_fix_octets ();
1988 #ifdef elf_tc_final_processing
1989 elf_tc_final_processing ();
1993 /* It removes any unneeded versioned symbols from the symbol table. */
1996 elf_frob_file_before_adjust (void)
2002 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2003 if (!S_IS_DEFINED (symp
))
2005 if (symbol_get_obj (symp
)->versioned_name
)
2009 /* The @@@ syntax is a special case. If the symbol is
2010 not defined, 2 `@'s will be removed from the
2013 p
= strchr (symbol_get_obj (symp
)->versioned_name
,
2016 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
2018 size_t l
= strlen (&p
[3]) + 1;
2019 memmove (&p
[1], &p
[3], l
);
2021 if (symbol_used_p (symp
) == 0
2022 && symbol_used_in_reloc_p (symp
) == 0)
2023 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2026 /* If there was .weak foo, but foo was neither defined nor
2027 used anywhere, remove it. */
2029 else if (S_IS_WEAK (symp
)
2030 && symbol_used_p (symp
) == 0
2031 && symbol_used_in_reloc_p (symp
) == 0)
2032 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2037 /* It is required that we let write_relocs have the opportunity to
2038 optimize away fixups before output has begun, since it is possible
2039 to eliminate all fixups for a section and thus we never should
2040 have generated the relocation section. */
2043 elf_frob_file_after_relocs (void)
2045 #ifdef NEED_ECOFF_DEBUG
2046 if (ECOFF_DEBUGGING
)
2047 /* Generate the ECOFF debugging information. */
2049 const struct ecoff_debug_swap
*debug_swap
;
2050 struct ecoff_debug_info debug
;
2055 = get_elf_backend_data (stdoutput
)->elf_backend_ecoff_debug_swap
;
2056 know (debug_swap
!= NULL
);
2057 ecoff_build_debug (&debug
.symbolic_header
, &buf
, debug_swap
);
2059 /* Set up the pointers in debug. */
2060 #define SET(ptr, offset, type) \
2061 debug.ptr = (type) (buf + debug.symbolic_header.offset)
2063 SET (line
, cbLineOffset
, unsigned char *);
2064 SET (external_dnr
, cbDnOffset
, void *);
2065 SET (external_pdr
, cbPdOffset
, void *);
2066 SET (external_sym
, cbSymOffset
, void *);
2067 SET (external_opt
, cbOptOffset
, void *);
2068 SET (external_aux
, cbAuxOffset
, union aux_ext
*);
2069 SET (ss
, cbSsOffset
, char *);
2070 SET (external_fdr
, cbFdOffset
, void *);
2071 SET (external_rfd
, cbRfdOffset
, void *);
2072 /* ssext and external_ext are set up just below. */
2076 /* Set up the external symbols. */
2077 debug
.ssext
= debug
.ssext_end
= NULL
;
2078 debug
.external_ext
= debug
.external_ext_end
= NULL
;
2079 if (! bfd_ecoff_debug_externals (stdoutput
, &debug
, debug_swap
, TRUE
,
2080 elf_get_extr
, elf_set_index
))
2081 as_fatal (_("failed to set up debugging information: %s"),
2082 bfd_errmsg (bfd_get_error ()));
2084 sec
= bfd_get_section_by_name (stdoutput
, ".mdebug");
2085 assert (sec
!= NULL
);
2087 know (!stdoutput
->output_has_begun
);
2089 /* We set the size of the section, call bfd_set_section_contents
2090 to force the ELF backend to allocate a file position, and then
2091 write out the data. FIXME: Is this really the best way to do
2093 bfd_set_section_size
2094 (stdoutput
, sec
, bfd_ecoff_debug_size (stdoutput
, &debug
, debug_swap
));
2096 /* Pass BUF to bfd_set_section_contents because this will
2097 eventually become a call to fwrite, and ISO C prohibits
2098 passing a NULL pointer to a stdio function even if the
2099 pointer will not be used. */
2100 if (! bfd_set_section_contents (stdoutput
, sec
, buf
, 0, 0))
2101 as_fatal (_("can't start writing .mdebug section: %s"),
2102 bfd_errmsg (bfd_get_error ()));
2104 know (stdoutput
->output_has_begun
);
2105 know (sec
->filepos
!= 0);
2107 if (! bfd_ecoff_write_debug (stdoutput
, &debug
, debug_swap
,
2109 as_fatal (_("could not write .mdebug section: %s"),
2110 bfd_errmsg (bfd_get_error ()));
2112 #endif /* NEED_ECOFF_DEBUG */
2117 /* Heavily plagiarized from obj_elf_version. The idea is to emit the
2118 SCO specific identifier in the .notes section to satisfy the SCO
2121 This looks more complicated than it really is. As opposed to the
2122 "obvious" solution, this should handle the cross dev cases
2123 correctly. (i.e, hosting on a 64 bit big endian processor, but
2124 generating SCO Elf code) Efficiency isn't a concern, as there
2125 should be exactly one of these sections per object module.
2127 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
2130 int_32 namesz = 4 ; Name size
2131 int_32 descsz = 12 ; Descriptive information
2133 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
2134 int_32 version = (major ver # << 16) | version of tools ;
2135 int_32 source = (tool_id << 16 ) | 1 ;
2136 int_32 info = 0 ; These are set by the SCO tools, but we
2137 don't know enough about the source
2138 environment to set them. SCO ld currently
2139 ignores them, and recommends we set them
2142 #define SCO_MAJOR_VERSION 0x1
2143 #define SCO_MINOR_VERSION 0x1
2153 asection
*seg
= now_seg
;
2154 subsegT subseg
= now_subseg
;
2155 Elf_Internal_Note i_note
;
2156 Elf_External_Note e_note
;
2157 asection
*note_secp
= NULL
;
2160 /* create the .note section */
2162 note_secp
= subseg_new (".note", 0);
2163 bfd_set_section_flags (stdoutput
,
2165 SEC_HAS_CONTENTS
| SEC_READONLY
);
2167 /* process the version string */
2170 i_note
.descsz
= 12; /* 12 descriptive bytes */
2171 i_note
.type
= NT_VERSION
; /* Contains a version string */
2173 p
= frag_more (sizeof (i_note
.namesz
));
2174 md_number_to_chars (p
, i_note
.namesz
, 4);
2176 p
= frag_more (sizeof (i_note
.descsz
));
2177 md_number_to_chars (p
, i_note
.descsz
, 4);
2179 p
= frag_more (sizeof (i_note
.type
));
2180 md_number_to_chars (p
, i_note
.type
, 4);
2185 /* Note: this is the version number of the ELF we're representing */
2187 md_number_to_chars (p
, (SCO_MAJOR_VERSION
<< 16) | (SCO_MINOR_VERSION
), 4);
2189 /* Here, we pick a magic number for ourselves (yes, I "registered"
2190 it with SCO. The bottom bit shows that we are compat with the
2193 md_number_to_chars (p
, 0x4c520000 | 0x0001, 4);
2195 /* If we knew (or cared) what the source language options were, we'd
2196 fill them in here. SCO has given us permission to ignore these
2197 and just set them to zero. */
2199 md_number_to_chars (p
, 0x0000, 4);
2201 frag_align (2, 0, 0);
2203 /* We probably can't restore the current segment, for there likely
2206 subseg_set (seg
, subseg
);
2210 #endif /* SCO_ELF */
2213 elf_separate_stab_sections (void)
2215 #ifdef NEED_ECOFF_DEBUG
2216 return (!ECOFF_DEBUGGING
);
2223 elf_init_stab_section (segT seg
)
2225 #ifdef NEED_ECOFF_DEBUG
2226 if (!ECOFF_DEBUGGING
)
2228 obj_elf_init_stab_section (seg
);
2231 const struct format_ops elf_format_ops
=
2233 bfd_target_elf_flavour
,
2234 0, /* dfl_leading_underscore */
2235 1, /* emit_section_symbols */
2240 elf_frob_file_before_adjust
,
2241 0, /* obj_frob_file_before_fix */
2242 elf_frob_file_after_relocs
,
2243 elf_s_get_size
, elf_s_set_size
,
2244 elf_s_get_align
, elf_s_set_align
,
2251 elf_copy_symbol_attributes
,
2252 #ifdef NEED_ECOFF_DEBUG
2253 ecoff_generate_asm_lineno
,
2256 0, /* generate_asm_lineno */
2257 0, /* process_stab */
2259 elf_separate_stab_sections
,
2260 elf_init_stab_section
,
2261 elf_sec_sym_ok_for_reloc
,
2263 #ifdef NEED_ECOFF_DEBUG
2266 0, /* ecoff_set_ext */
2268 elf_obj_read_begin_hook
,
2269 elf_obj_symbol_new_hook