1 /* ELF object file format
2 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 2,
10 or (at your option) any later version.
12 GAS is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 the GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 #define OBJ_HEADER "obj-elf.h"
24 #include "safe-ctype.h"
27 #include "struc-symbol.h"
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"
56 static void obj_elf_line (int);
57 static void obj_elf_size (int);
58 static void obj_elf_type (int);
59 static void obj_elf_ident (int);
60 static void obj_elf_weak (int);
61 static void obj_elf_local (int);
62 static void obj_elf_visibility (int);
63 static void obj_elf_symver (int);
64 static void obj_elf_subsection (int);
65 static void obj_elf_popsection (int);
66 static void obj_elf_tls_common (int);
67 static void obj_elf_lcomm (int);
69 static const pseudo_typeS elf_pseudo_table
[] =
71 {"comm", obj_elf_common
, 0},
72 {"common", obj_elf_common
, 1},
73 {"ident", obj_elf_ident
, 0},
74 {"lcomm", obj_elf_lcomm
, 0},
75 {"local", obj_elf_local
, 0},
76 {"previous", obj_elf_previous
, 0},
77 {"section", obj_elf_section
, 0},
78 {"section.s", obj_elf_section
, 0},
79 {"sect", obj_elf_section
, 0},
80 {"sect.s", obj_elf_section
, 0},
81 {"pushsection", obj_elf_section
, 1},
82 {"popsection", obj_elf_popsection
, 0},
83 {"size", obj_elf_size
, 0},
84 {"type", obj_elf_type
, 0},
85 {"version", obj_elf_version
, 0},
86 {"weak", obj_elf_weak
, 0},
88 /* These define symbol visibility. */
89 {"internal", obj_elf_visibility
, STV_INTERNAL
},
90 {"hidden", obj_elf_visibility
, STV_HIDDEN
},
91 {"protected", obj_elf_visibility
, STV_PROTECTED
},
93 /* These are used for stabs-in-elf configurations. */
94 {"line", obj_elf_line
, 0},
96 /* This is a GNU extension to handle symbol versions. */
97 {"symver", obj_elf_symver
, 0},
99 /* A GNU extension to change subsection only. */
100 {"subsection", obj_elf_subsection
, 0},
102 /* These are GNU extensions to aid in garbage collecting C++ vtables. */
103 {"vtable_inherit", (void (*) (int)) &obj_elf_vtable_inherit
, 0},
104 {"vtable_entry", (void (*) (int)) &obj_elf_vtable_entry
, 0},
106 /* These are used for dwarf. */
110 /* These are used for dwarf2. */
111 { "file", (void (*) (int)) dwarf2_directive_file
, 0 },
112 { "loc", dwarf2_directive_loc
, 0 },
114 /* We need to trap the section changing calls to handle .previous. */
115 {"data", obj_elf_data
, 0},
116 {"text", obj_elf_text
, 0},
118 {"tls_common", obj_elf_tls_common
, 0},
124 static const pseudo_typeS ecoff_debug_pseudo_table
[] =
126 #ifdef NEED_ECOFF_DEBUG
127 /* COFF style debugging information for ECOFF. .ln is not used; .loc
129 { "def", ecoff_directive_def
, 0 },
130 { "dim", ecoff_directive_dim
, 0 },
131 { "endef", ecoff_directive_endef
, 0 },
132 { "file", ecoff_directive_file
, 0 },
133 { "scl", ecoff_directive_scl
, 0 },
134 { "tag", ecoff_directive_tag
, 0 },
135 { "val", ecoff_directive_val
, 0 },
137 /* COFF debugging requires pseudo-ops .size and .type, but ELF
138 already has meanings for those. We use .esize and .etype
139 instead. These are only generated by gcc anyhow. */
140 { "esize", ecoff_directive_size
, 0 },
141 { "etype", ecoff_directive_type
, 0 },
143 /* ECOFF specific debugging information. */
144 { "begin", ecoff_directive_begin
, 0 },
145 { "bend", ecoff_directive_bend
, 0 },
146 { "end", ecoff_directive_end
, 0 },
147 { "ent", ecoff_directive_ent
, 0 },
148 { "fmask", ecoff_directive_fmask
, 0 },
149 { "frame", ecoff_directive_frame
, 0 },
150 { "loc", ecoff_directive_loc
, 0 },
151 { "mask", ecoff_directive_mask
, 0 },
153 /* Other ECOFF directives. */
154 { "extern", ecoff_directive_extern
, 0 },
156 /* These are used on Irix. I don't know how to implement them. */
157 { "alias", s_ignore
, 0 },
158 { "bgnb", s_ignore
, 0 },
159 { "endb", s_ignore
, 0 },
160 { "lab", s_ignore
, 0 },
161 { "noalias", s_ignore
, 0 },
162 { "verstamp", s_ignore
, 0 },
163 { "vreg", s_ignore
, 0 },
166 {NULL
, NULL
, 0} /* end sentinel */
170 #include "aout/aout64.h"
172 /* This is called when the assembler starts. */
179 /* Add symbols for the known sections to the symbol table. */
180 s
= bfd_get_section_by_name (stdoutput
, TEXT_SECTION_NAME
);
181 symbol_table_insert (section_symbol (s
));
182 s
= bfd_get_section_by_name (stdoutput
, DATA_SECTION_NAME
);
183 symbol_table_insert (section_symbol (s
));
184 s
= bfd_get_section_by_name (stdoutput
, BSS_SECTION_NAME
);
185 symbol_table_insert (section_symbol (s
));
189 elf_pop_insert (void)
191 pop_insert (elf_pseudo_table
);
193 pop_insert (ecoff_debug_pseudo_table
);
197 elf_s_get_size (symbolS
*sym
)
199 return S_GET_SIZE (sym
);
203 elf_s_set_size (symbolS
*sym
, bfd_vma sz
)
205 S_SET_SIZE (sym
, sz
);
209 elf_s_get_align (symbolS
*sym
)
211 return S_GET_ALIGN (sym
);
215 elf_s_set_align (symbolS
*sym
, bfd_vma align
)
217 S_SET_ALIGN (sym
, align
);
221 elf_s_get_other (symbolS
*sym
)
223 return elf_symbol (symbol_get_bfdsym (sym
))->internal_elf_sym
.st_other
;
227 elf_s_set_other (symbolS
*sym
, int other
)
229 S_SET_OTHER (sym
, other
);
233 elf_sec_sym_ok_for_reloc (asection
*sec
)
235 return obj_sec_sym_ok_for_reloc (sec
);
239 elf_file_symbol (const char *s
)
243 sym
= symbol_new (s
, absolute_section
, 0, NULL
);
244 symbol_set_frag (sym
, &zero_address_frag
);
245 symbol_get_bfdsym (sym
)->flags
|= BSF_FILE
;
247 if (symbol_rootP
!= sym
)
249 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
250 symbol_insert (sym
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
252 verify_symbol_chain (symbol_rootP
, symbol_lastP
);
256 #ifdef NEED_ECOFF_DEBUG
261 /* Called from read.c:s_comm after we've parsed .comm symbol, size.
262 Parse a possible alignment value. */
265 elf_common_parse (int ignore ATTRIBUTE_UNUSED
, symbolS
*symbolP
, addressT size
)
268 int is_local
= symbol_get_obj (symbolP
)->local
;
270 if (*input_line_pointer
== ',')
272 char *save
= input_line_pointer
;
274 input_line_pointer
++;
277 if (*input_line_pointer
== '"')
279 /* For sparc. Accept .common symbol, length, "bss" */
280 input_line_pointer
++;
281 /* Some use the dot, some don't. */
282 if (*input_line_pointer
== '.')
283 input_line_pointer
++;
284 /* Some say data, some say bss. */
285 if (strncmp (input_line_pointer
, "bss\"", 4) == 0)
286 input_line_pointer
+= 4;
287 else if (strncmp (input_line_pointer
, "data\"", 5) == 0)
288 input_line_pointer
+= 5;
291 char *p
= input_line_pointer
;
296 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
297 if (*input_line_pointer
++ == '"')
299 c
= *input_line_pointer
;
300 *input_line_pointer
= '\0';
301 as_bad (_("bad .common segment %s"), p
);
302 *input_line_pointer
= c
;
303 ignore_rest_of_line ();
306 /* ??? Don't ask me why these are always global. */
311 input_line_pointer
= save
;
312 align
= parse_align (is_local
);
313 if (align
== (addressT
) -1)
320 bss_alloc (symbolP
, size
, align
);
321 S_CLEAR_EXTERNAL (symbolP
);
325 S_SET_VALUE (symbolP
, size
);
326 S_SET_ALIGN (symbolP
, align
);
327 S_SET_EXTERNAL (symbolP
);
328 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
331 symbol_get_bfdsym (symbolP
)->flags
|= BSF_OBJECT
;
337 obj_elf_common (int is_common
)
339 if (flag_mri
&& is_common
)
342 s_comm_internal (0, elf_common_parse
);
346 obj_elf_tls_common (int ignore ATTRIBUTE_UNUSED
)
348 symbolS
*symbolP
= s_comm_internal (0, elf_common_parse
);
351 symbol_get_bfdsym (symbolP
)->flags
|= BSF_THREAD_LOCAL
;
355 obj_elf_lcomm (int ignore ATTRIBUTE_UNUSED
)
357 symbolS
*symbolP
= s_comm_internal (0, s_lcomm_internal
);
360 symbol_get_bfdsym (symbolP
)->flags
|= BSF_OBJECT
;
364 obj_elf_local (int ignore ATTRIBUTE_UNUSED
)
372 name
= input_line_pointer
;
373 c
= get_symbol_end ();
374 symbolP
= symbol_find_or_make (name
);
375 *input_line_pointer
= c
;
377 S_CLEAR_EXTERNAL (symbolP
);
378 symbol_get_obj (symbolP
)->local
= 1;
381 input_line_pointer
++;
383 if (*input_line_pointer
== '\n')
388 demand_empty_rest_of_line ();
392 obj_elf_weak (int ignore ATTRIBUTE_UNUSED
)
400 name
= input_line_pointer
;
401 c
= get_symbol_end ();
402 symbolP
= symbol_find_or_make (name
);
403 *input_line_pointer
= c
;
405 S_SET_WEAK (symbolP
);
406 symbol_get_obj (symbolP
)->local
= 1;
409 input_line_pointer
++;
411 if (*input_line_pointer
== '\n')
416 demand_empty_rest_of_line ();
420 obj_elf_visibility (int visibility
)
426 elf_symbol_type
*elfsym
;
430 name
= input_line_pointer
;
431 c
= get_symbol_end ();
432 symbolP
= symbol_find_or_make (name
);
433 *input_line_pointer
= c
;
437 bfdsym
= symbol_get_bfdsym (symbolP
);
438 elfsym
= elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
442 elfsym
->internal_elf_sym
.st_other
&= ~3;
443 elfsym
->internal_elf_sym
.st_other
|= visibility
;
447 input_line_pointer
++;
451 if (*input_line_pointer
== '\n')
457 demand_empty_rest_of_line ();
460 static segT previous_section
;
461 static int previous_subsection
;
465 struct section_stack
*next
;
467 int subseg
, prev_subseg
;
470 static struct section_stack
*section_stack
;
473 get_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
475 const char *gname
= inf
;
476 const char *group_name
= elf_group_name (sec
);
478 return (group_name
== gname
479 || (group_name
!= NULL
481 && strcmp (group_name
, gname
) == 0));
484 /* Handle the .section pseudo-op. This code supports two different
487 The first is found on Solaris, and looks like
488 .section ".sec1",#alloc,#execinstr,#write
489 Here the names after '#' are the SHF_* flags to turn on for the
490 section. I'm not sure how it determines the SHT_* type (BFD
491 doesn't really give us control over the type, anyhow).
493 The second format is found on UnixWare, and probably most SVR4
494 machines, and looks like
495 .section .sec1,"a",@progbits
496 The quoted string may contain any combination of a, w, x, and
497 represents the SHF_* flags to turn on for the section. The string
498 beginning with '@' can be progbits or nobits. There should be
499 other possibilities, but I don't know what they are. In any case,
500 BFD doesn't really let us set the section type. */
503 obj_elf_change_section (const char *name
,
507 const char *group_name
,
514 const struct bfd_elf_special_section
*ssect
;
516 #ifdef md_flush_pending_output
517 md_flush_pending_output ();
520 /* Switch to the section, creating it if necessary. */
523 struct section_stack
*elt
;
524 elt
= xmalloc (sizeof (struct section_stack
));
525 elt
->next
= section_stack
;
527 elt
->prev_seg
= previous_section
;
528 elt
->subseg
= now_subseg
;
529 elt
->prev_subseg
= previous_subsection
;
532 previous_section
= now_seg
;
533 previous_subsection
= now_subseg
;
535 old_sec
= bfd_get_section_by_name_if (stdoutput
, name
, get_section
,
536 (void *) group_name
);
543 sec
= subseg_force_new (name
, 0);
545 ssect
= _bfd_elf_get_sec_type_attr (stdoutput
, name
);
549 bfd_boolean override
= FALSE
;
551 if (type
== SHT_NULL
)
553 else if (type
!= ssect
->type
)
556 /* FIXME: gcc, as of 2002-10-22, will emit
558 .section .init_array,"aw",@progbits
560 for __attribute__ ((section (".init_array"))).
561 "@progbits" is incorrect. */
562 && ssect
->type
!= SHT_INIT_ARRAY
563 && ssect
->type
!= SHT_FINI_ARRAY
564 && ssect
->type
!= SHT_PREINIT_ARRAY
)
566 /* We allow to specify any type for a .note section. */
567 if (ssect
->type
!= SHT_NOTE
)
568 as_warn (_("setting incorrect section type for %s"),
573 as_warn (_("ignoring incorrect section type for %s"),
579 if (old_sec
== NULL
&& (attr
& ~ssect
->attr
) != 0)
581 /* As a GNU extension, we permit a .note section to be
582 allocatable. If the linker sees an allocatable .note
583 section, it will create a PT_NOTE segment in the output
584 file. We also allow "x" for .note.GNU-stack. */
585 if (ssect
->type
== SHT_NOTE
586 && (attr
== SHF_ALLOC
|| attr
== SHF_EXECINSTR
))
588 /* Allow different SHF_MERGE and SHF_STRINGS if we have
589 something like .rodata.str. */
590 else if (ssect
->suffix_length
== -2
591 && name
[ssect
->prefix_length
] == '.'
595 & ~SHF_STRINGS
) == 0)
597 /* .interp, .strtab and .symtab can have SHF_ALLOC. */
598 else if (attr
== SHF_ALLOC
599 && (strcmp (name
, ".interp") == 0
600 || strcmp (name
, ".strtab") == 0
601 || strcmp (name
, ".symtab") == 0))
605 if (group_name
== NULL
)
606 as_warn (_("setting incorrect section attributes for %s"),
611 if (!override
&& old_sec
== NULL
)
615 if (type
!= SHT_NULL
)
616 elf_section_type (sec
) = type
;
618 elf_section_flags (sec
) = attr
;
620 /* Convert ELF type and flags to BFD flags. */
622 | ((attr
& SHF_WRITE
) ? 0 : SEC_READONLY
)
623 | ((attr
& SHF_ALLOC
) ? SEC_ALLOC
: 0)
624 | (((attr
& SHF_ALLOC
) && type
!= SHT_NOBITS
) ? SEC_LOAD
: 0)
625 | ((attr
& SHF_EXECINSTR
) ? SEC_CODE
: 0)
626 | ((attr
& SHF_MERGE
) ? SEC_MERGE
: 0)
627 | ((attr
& SHF_STRINGS
) ? SEC_STRINGS
: 0)
628 | ((attr
& SHF_TLS
) ? SEC_THREAD_LOCAL
: 0));
629 #ifdef md_elf_section_flags
630 flags
= md_elf_section_flags (flags
, attr
, type
);
634 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
640 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */
641 if (type
== SHT_NOBITS
)
642 seg_info (sec
)->bss
= 1;
644 bfd_set_section_flags (stdoutput
, sec
, flags
);
645 if (flags
& SEC_MERGE
)
646 sec
->entsize
= entsize
;
647 elf_group_name (sec
) = group_name
;
649 /* Add a symbol for this section to the symbol table. */
650 secsym
= symbol_find (name
);
652 symbol_set_bfdsym (secsym
, sec
->symbol
);
654 symbol_table_insert (section_symbol (sec
));
658 /* If section attributes are specified the second time we see a
659 particular section, then check that they are the same as we
660 saw the first time. */
661 if (((old_sec
->flags
^ flags
)
662 & (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
663 | SEC_EXCLUDE
| SEC_SORT_ENTRIES
| SEC_MERGE
| SEC_STRINGS
664 | SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
665 | SEC_THREAD_LOCAL
)))
666 as_warn (_("ignoring changed section attributes for %s"), name
);
667 if ((flags
& SEC_MERGE
) && old_sec
->entsize
!= (unsigned) entsize
)
668 as_warn (_("ignoring changed section entity size for %s"), name
);
671 #ifdef md_elf_section_change_hook
672 md_elf_section_change_hook ();
677 obj_elf_parse_section_letters (char *str
, size_t len
)
692 attr
|= SHF_EXECINSTR
;
708 if (*(str
- 1) == 'a')
711 if (len
> 1 && str
[1] == 's')
720 char *bad_msg
= _("unrecognized .section attribute: want a,w,x,M,S,G,T");
721 #ifdef md_elf_section_letter
722 int md_attr
= md_elf_section_letter (*str
, &bad_msg
);
727 as_fatal ("%s", bad_msg
);
738 obj_elf_section_word (char *str
, size_t len
)
740 if (len
== 5 && strncmp (str
, "write", 5) == 0)
742 if (len
== 5 && strncmp (str
, "alloc", 5) == 0)
744 if (len
== 9 && strncmp (str
, "execinstr", 9) == 0)
745 return SHF_EXECINSTR
;
746 if (len
== 3 && strncmp (str
, "tls", 3) == 0)
749 #ifdef md_elf_section_word
751 int md_attr
= md_elf_section_word (str
, len
);
757 as_warn (_("unrecognized section attribute"));
762 obj_elf_section_type (char *str
, size_t len
)
764 if (len
== 8 && strncmp (str
, "progbits", 8) == 0)
766 if (len
== 6 && strncmp (str
, "nobits", 6) == 0)
768 if (len
== 4 && strncmp (str
, "note", 4) == 0)
771 #ifdef md_elf_section_type
773 int md_type
= md_elf_section_type (str
, len
);
779 as_warn (_("unrecognized section type"));
783 /* Get name of section. */
785 obj_elf_section_name (void)
790 if (*input_line_pointer
== '"')
794 name
= demand_copy_C_string (&dummy
);
797 ignore_rest_of_line ();
803 char *end
= input_line_pointer
;
805 while (0 == strchr ("\n\t,; ", *end
))
807 if (end
== input_line_pointer
)
809 as_bad (_("missing name"));
810 ignore_rest_of_line ();
814 name
= xmalloc (end
- input_line_pointer
+ 1);
815 memcpy (name
, input_line_pointer
, end
- input_line_pointer
);
816 name
[end
- input_line_pointer
] = '\0';
817 #ifdef tc_canonicalize_section_name
818 name
= tc_canonicalize_section_name (name
);
820 input_line_pointer
= end
;
827 obj_elf_section (int push
)
829 char *name
, *group_name
, *beg
;
830 int type
, attr
, dummy
;
839 #ifdef md_flush_pending_output
840 md_flush_pending_output ();
843 previous_section
= now_seg
;
844 previous_subsection
= now_subseg
;
846 s_mri_sect (&mri_type
);
848 #ifdef md_elf_section_change_hook
849 md_elf_section_change_hook ();
854 #endif /* ! defined (TC_I370) */
856 name
= obj_elf_section_name ();
865 if (*input_line_pointer
== ',')
867 /* Skip the comma. */
868 ++input_line_pointer
;
871 if (*input_line_pointer
== '"')
873 beg
= demand_copy_C_string (&dummy
);
876 ignore_rest_of_line ();
879 attr
|= obj_elf_parse_section_letters (beg
, strlen (beg
));
882 if (*input_line_pointer
== ',')
885 char *save
= input_line_pointer
;
887 ++input_line_pointer
;
889 c
= *input_line_pointer
;
892 beg
= demand_copy_C_string (&dummy
);
895 ignore_rest_of_line ();
898 type
= obj_elf_section_type (beg
, strlen (beg
));
900 else if (c
== '@' || c
== '%')
902 beg
= ++input_line_pointer
;
903 c
= get_symbol_end ();
904 *input_line_pointer
= c
;
905 type
= obj_elf_section_type (beg
, input_line_pointer
- beg
);
908 input_line_pointer
= save
;
912 if ((attr
& SHF_MERGE
) != 0 && *input_line_pointer
== ',')
914 ++input_line_pointer
;
916 entsize
= get_absolute_expression ();
920 as_warn (_("invalid merge entity size"));
925 else if ((attr
& SHF_MERGE
) != 0)
927 as_warn (_("entity size for SHF_MERGE not specified"));
931 if ((attr
& SHF_GROUP
) != 0 && *input_line_pointer
== ',')
933 ++input_line_pointer
;
934 group_name
= obj_elf_section_name ();
935 if (group_name
== NULL
)
937 else if (strncmp (input_line_pointer
, ",comdat", 7) == 0)
939 input_line_pointer
+= 7;
942 else if (strncmp (name
, ".gnu.linkonce", 13) == 0)
945 else if ((attr
& SHF_GROUP
) != 0)
947 as_warn (_("group name for SHF_GROUP not specified"));
958 if (*input_line_pointer
!= '#')
960 as_bad (_("character following name is not '#'"));
961 ignore_rest_of_line ();
964 beg
= ++input_line_pointer
;
965 c
= get_symbol_end ();
966 *input_line_pointer
= c
;
968 attr
|= obj_elf_section_word (beg
, input_line_pointer
- beg
);
972 while (*input_line_pointer
++ == ',');
973 --input_line_pointer
;
977 demand_empty_rest_of_line ();
979 obj_elf_change_section (name
, type
, attr
, entsize
, group_name
, linkonce
, push
);
982 /* Change to the .data section. */
987 #ifdef md_flush_pending_output
988 md_flush_pending_output ();
991 previous_section
= now_seg
;
992 previous_subsection
= now_subseg
;
995 #ifdef md_elf_section_change_hook
996 md_elf_section_change_hook ();
1000 /* Change to the .text section. */
1003 obj_elf_text (int i
)
1005 #ifdef md_flush_pending_output
1006 md_flush_pending_output ();
1009 previous_section
= now_seg
;
1010 previous_subsection
= now_subseg
;
1013 #ifdef md_elf_section_change_hook
1014 md_elf_section_change_hook ();
1019 obj_elf_subsection (int ignore ATTRIBUTE_UNUSED
)
1023 #ifdef md_flush_pending_output
1024 md_flush_pending_output ();
1027 previous_section
= now_seg
;
1028 previous_subsection
= now_subseg
;
1030 temp
= get_absolute_expression ();
1031 subseg_set (now_seg
, (subsegT
) temp
);
1032 demand_empty_rest_of_line ();
1034 #ifdef md_elf_section_change_hook
1035 md_elf_section_change_hook ();
1039 /* This can be called from the processor backends if they change
1043 obj_elf_section_change_hook (void)
1045 previous_section
= now_seg
;
1046 previous_subsection
= now_subseg
;
1050 obj_elf_previous (int ignore ATTRIBUTE_UNUSED
)
1055 if (previous_section
== 0)
1057 as_warn (_(".previous without corresponding .section; ignored"));
1061 #ifdef md_flush_pending_output
1062 md_flush_pending_output ();
1065 new_section
= previous_section
;
1066 new_subsection
= previous_subsection
;
1067 previous_section
= now_seg
;
1068 previous_subsection
= now_subseg
;
1069 subseg_set (new_section
, new_subsection
);
1071 #ifdef md_elf_section_change_hook
1072 md_elf_section_change_hook ();
1077 obj_elf_popsection (int xxx ATTRIBUTE_UNUSED
)
1079 struct section_stack
*top
= section_stack
;
1083 as_warn (_(".popsection without corresponding .pushsection; ignored"));
1087 #ifdef md_flush_pending_output
1088 md_flush_pending_output ();
1091 section_stack
= top
->next
;
1092 previous_section
= top
->prev_seg
;
1093 previous_subsection
= top
->prev_subseg
;
1094 subseg_set (top
->seg
, top
->subseg
);
1097 #ifdef md_elf_section_change_hook
1098 md_elf_section_change_hook ();
1103 obj_elf_line (int ignore ATTRIBUTE_UNUSED
)
1105 /* Assume delimiter is part of expression. BSD4.2 as fails with
1106 delightful bug, so we are not being incompatible here. */
1107 new_logical_line (NULL
, get_absolute_expression ());
1108 demand_empty_rest_of_line ();
1111 /* This handles the .symver pseudo-op, which is used to specify a
1112 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1113 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1114 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1115 with the same value as the symbol NAME. */
1118 obj_elf_symver (int ignore ATTRIBUTE_UNUSED
)
1125 name
= input_line_pointer
;
1126 c
= get_symbol_end ();
1128 sym
= symbol_find_or_make (name
);
1130 *input_line_pointer
= c
;
1133 if (*input_line_pointer
!= ',')
1135 as_bad (_("expected comma after name in .symver"));
1136 ignore_rest_of_line ();
1140 ++input_line_pointer
;
1142 name
= input_line_pointer
;
1144 /* Temporarily include '@' in symbol names. */
1145 old_lexat
= lex_type
[(unsigned char) '@'];
1146 lex_type
[(unsigned char) '@'] |= LEX_NAME
;
1147 c
= get_symbol_end ();
1148 lex_type
[(unsigned char) '@'] = old_lexat
;
1150 if (symbol_get_obj (sym
)->versioned_name
== NULL
)
1152 symbol_get_obj (sym
)->versioned_name
= xstrdup (name
);
1154 *input_line_pointer
= c
;
1156 if (strchr (symbol_get_obj (sym
)->versioned_name
,
1157 ELF_VER_CHR
) == NULL
)
1159 as_bad (_("missing version name in `%s' for symbol `%s'"),
1160 symbol_get_obj (sym
)->versioned_name
,
1162 ignore_rest_of_line ();
1168 if (strcmp (symbol_get_obj (sym
)->versioned_name
, name
))
1170 as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1171 name
, symbol_get_obj (sym
)->versioned_name
,
1173 ignore_rest_of_line ();
1177 *input_line_pointer
= c
;
1180 demand_empty_rest_of_line ();
1183 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1184 to the linker the hierarchy in which a particular table resides. The
1185 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1188 obj_elf_vtable_inherit (int ignore ATTRIBUTE_UNUSED
)
1190 char *cname
, *pname
;
1191 symbolS
*csym
, *psym
;
1194 if (*input_line_pointer
== '#')
1195 ++input_line_pointer
;
1197 cname
= input_line_pointer
;
1198 c
= get_symbol_end ();
1199 csym
= symbol_find (cname
);
1201 /* GCFIXME: should check that we don't have two .vtable_inherits for
1202 the same child symbol. Also, we can currently only do this if the
1203 child symbol is already exists and is placed in a fragment. */
1205 if (csym
== NULL
|| symbol_get_frag (csym
) == NULL
)
1207 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1212 *input_line_pointer
= c
;
1215 if (*input_line_pointer
!= ',')
1217 as_bad ("expected comma after name in .vtable_inherit");
1218 ignore_rest_of_line ();
1222 ++input_line_pointer
;
1225 if (*input_line_pointer
== '#')
1226 ++input_line_pointer
;
1228 if (input_line_pointer
[0] == '0'
1229 && (input_line_pointer
[1] == '\0'
1230 || ISSPACE (input_line_pointer
[1])))
1232 psym
= section_symbol (absolute_section
);
1233 ++input_line_pointer
;
1237 pname
= input_line_pointer
;
1238 c
= get_symbol_end ();
1239 psym
= symbol_find_or_make (pname
);
1240 *input_line_pointer
= c
;
1243 demand_empty_rest_of_line ();
1248 assert (symbol_get_value_expression (csym
)->X_op
== O_constant
);
1249 return fix_new (symbol_get_frag (csym
),
1250 symbol_get_value_expression (csym
)->X_add_number
,
1251 0, psym
, 0, 0, BFD_RELOC_VTABLE_INHERIT
);
1254 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1255 to the linker that a vtable slot was used. The syntax is
1256 ".vtable_entry tablename, offset". */
1259 obj_elf_vtable_entry (int ignore ATTRIBUTE_UNUSED
)
1266 if (*input_line_pointer
== '#')
1267 ++input_line_pointer
;
1269 name
= input_line_pointer
;
1270 c
= get_symbol_end ();
1271 sym
= symbol_find_or_make (name
);
1272 *input_line_pointer
= c
;
1275 if (*input_line_pointer
!= ',')
1277 as_bad ("expected comma after name in .vtable_entry");
1278 ignore_rest_of_line ();
1282 ++input_line_pointer
;
1283 if (*input_line_pointer
== '#')
1284 ++input_line_pointer
;
1286 offset
= get_absolute_expression ();
1288 demand_empty_rest_of_line ();
1290 return fix_new (frag_now
, frag_now_fix (), 0, sym
, offset
, 0,
1291 BFD_RELOC_VTABLE_ENTRY
);
1295 elf_obj_read_begin_hook (void)
1297 #ifdef NEED_ECOFF_DEBUG
1298 if (ECOFF_DEBUGGING
)
1299 ecoff_read_begin_hook ();
1304 elf_obj_symbol_new_hook (symbolS
*symbolP
)
1306 struct elf_obj_sy
*sy_obj
;
1308 sy_obj
= symbol_get_obj (symbolP
);
1309 sy_obj
->size
= NULL
;
1310 sy_obj
->versioned_name
= NULL
;
1312 #ifdef NEED_ECOFF_DEBUG
1313 if (ECOFF_DEBUGGING
)
1314 ecoff_symbol_new_hook (symbolP
);
1318 /* When setting one symbol equal to another, by default we probably
1319 want them to have the same "size", whatever it means in the current
1323 elf_copy_symbol_attributes (symbolS
*dest
, symbolS
*src
)
1325 struct elf_obj_sy
*srcelf
= symbol_get_obj (src
);
1326 struct elf_obj_sy
*destelf
= symbol_get_obj (dest
);
1329 if (destelf
->size
== NULL
)
1330 destelf
->size
= xmalloc (sizeof (expressionS
));
1331 *destelf
->size
= *srcelf
->size
;
1335 if (destelf
->size
!= NULL
)
1336 free (destelf
->size
);
1337 destelf
->size
= NULL
;
1339 S_SET_SIZE (dest
, S_GET_SIZE (src
));
1340 /* Don't copy visibility. */
1341 S_SET_OTHER (dest
, (ELF_ST_VISIBILITY (S_GET_OTHER (dest
))
1342 | (S_GET_OTHER (src
) & ~ELF_ST_VISIBILITY (-1))));
1346 obj_elf_version (int ignore ATTRIBUTE_UNUSED
)
1351 asection
*seg
= now_seg
;
1352 subsegT subseg
= now_subseg
;
1353 Elf_Internal_Note i_note
;
1354 Elf_External_Note e_note
;
1355 asection
*note_secp
= NULL
;
1359 if (*input_line_pointer
== '\"')
1361 ++input_line_pointer
; /* -> 1st char of string. */
1362 name
= input_line_pointer
;
1364 while (is_a_char (c
= next_char_of_string ()))
1366 c
= *input_line_pointer
;
1367 *input_line_pointer
= '\0';
1368 *(input_line_pointer
- 1) = '\0';
1369 *input_line_pointer
= c
;
1371 /* create the .note section */
1373 note_secp
= subseg_new (".note", 0);
1374 bfd_set_section_flags (stdoutput
,
1376 SEC_HAS_CONTENTS
| SEC_READONLY
);
1378 /* process the version string */
1380 len
= strlen (name
);
1382 i_note
.namesz
= ((len
+ 1) + 3) & ~3; /* round this to word boundary */
1383 i_note
.descsz
= 0; /* no description */
1384 i_note
.type
= NT_VERSION
;
1385 p
= frag_more (sizeof (e_note
.namesz
));
1386 md_number_to_chars (p
, i_note
.namesz
, sizeof (e_note
.namesz
));
1387 p
= frag_more (sizeof (e_note
.descsz
));
1388 md_number_to_chars (p
, i_note
.descsz
, sizeof (e_note
.descsz
));
1389 p
= frag_more (sizeof (e_note
.type
));
1390 md_number_to_chars (p
, i_note
.type
, sizeof (e_note
.type
));
1391 p
= frag_more (len
+ 1);
1394 frag_align (2, 0, 0);
1396 subseg_set (seg
, subseg
);
1400 as_bad (_("expected quoted string"));
1402 demand_empty_rest_of_line ();
1406 obj_elf_size (int ignore ATTRIBUTE_UNUSED
)
1408 char *name
= input_line_pointer
;
1409 char c
= get_symbol_end ();
1414 p
= input_line_pointer
;
1417 if (*input_line_pointer
!= ',')
1420 as_bad (_("expected comma after name `%s' in .size directive"), name
);
1422 ignore_rest_of_line ();
1425 input_line_pointer
++;
1427 if (exp
.X_op
== O_absent
)
1429 as_bad (_("missing expression in .size directive"));
1430 exp
.X_op
= O_constant
;
1431 exp
.X_add_number
= 0;
1434 sym
= symbol_find_or_make (name
);
1436 if (exp
.X_op
== O_constant
)
1438 S_SET_SIZE (sym
, exp
.X_add_number
);
1439 if (symbol_get_obj (sym
)->size
)
1441 xfree (symbol_get_obj (sym
)->size
);
1442 symbol_get_obj (sym
)->size
= NULL
;
1447 symbol_get_obj (sym
)->size
= xmalloc (sizeof (expressionS
));
1448 *symbol_get_obj (sym
)->size
= exp
;
1450 demand_empty_rest_of_line ();
1453 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1454 There are five syntaxes:
1456 The first (used on Solaris) is
1458 The second (used on UnixWare) is
1460 The third (reportedly to be used on Irix 6.0) is
1462 The fourth (used on NetBSD/Arm and Linux/ARM) is
1464 The fifth (used on SVR4/860) is
1465 .type SYM,"function"
1469 obj_elf_type (int ignore ATTRIBUTE_UNUSED
)
1474 const char *typename
;
1476 elf_symbol_type
*elfsym
;
1478 name
= input_line_pointer
;
1479 c
= get_symbol_end ();
1480 sym
= symbol_find_or_make (name
);
1481 elfsym
= (elf_symbol_type
*) symbol_get_bfdsym (sym
);
1482 *input_line_pointer
= c
;
1485 if (*input_line_pointer
== ',')
1486 ++input_line_pointer
;
1489 if ( *input_line_pointer
== '#'
1490 || *input_line_pointer
== '@'
1491 || *input_line_pointer
== '"'
1492 || *input_line_pointer
== '%')
1493 ++input_line_pointer
;
1495 typename
= input_line_pointer
;
1496 c
= get_symbol_end ();
1499 if (strcmp (typename
, "function") == 0
1500 || strcmp (typename
, "STT_FUNC") == 0)
1501 type
= BSF_FUNCTION
;
1502 else if (strcmp (typename
, "object") == 0
1503 || strcmp (typename
, "STT_OBJECT") == 0)
1505 else if (strcmp (typename
, "tls_object") == 0
1506 || strcmp (typename
, "STT_TLS") == 0)
1507 type
= BSF_OBJECT
| BSF_THREAD_LOCAL
;
1508 else if (strcmp (typename
, "notype") == 0
1509 || strcmp (typename
, "STT_NOTYPE") == 0)
1511 #ifdef md_elf_symbol_type
1512 else if ((type
= md_elf_symbol_type (typename
, sym
, elfsym
)) != -1)
1516 as_bad (_("unrecognized symbol type \"%s\""), typename
);
1518 *input_line_pointer
= c
;
1520 if (*input_line_pointer
== '"')
1521 ++input_line_pointer
;
1523 elfsym
->symbol
.flags
|= type
;
1525 demand_empty_rest_of_line ();
1529 obj_elf_ident (int ignore ATTRIBUTE_UNUSED
)
1531 static segT comment_section
;
1532 segT old_section
= now_seg
;
1533 int old_subsection
= now_subseg
;
1535 #ifdef md_flush_pending_output
1536 md_flush_pending_output ();
1539 if (!comment_section
)
1542 comment_section
= subseg_new (".comment", 0);
1543 bfd_set_section_flags (stdoutput
, comment_section
,
1544 SEC_READONLY
| SEC_HAS_CONTENTS
);
1549 subseg_set (comment_section
, 0);
1551 subseg_set (old_section
, old_subsection
);
1554 #ifdef INIT_STAB_SECTION
1556 /* The first entry in a .stabs section is special. */
1559 obj_elf_init_stab_section (segT seg
)
1564 unsigned int stroff
;
1566 /* Force the section to align to a longword boundary. Without this,
1567 UnixWare ar crashes. */
1568 bfd_set_section_alignment (stdoutput
, seg
, 2);
1570 /* Make space for this first symbol. */
1574 as_where (&file
, NULL
);
1575 stabstr_name
= xmalloc (strlen (segment_name (seg
)) + 4);
1576 strcpy (stabstr_name
, segment_name (seg
));
1577 strcat (stabstr_name
, "str");
1578 stroff
= get_stab_string_offset (file
, stabstr_name
);
1580 md_number_to_chars (p
, stroff
, 4);
1581 seg_info (seg
)->stabu
.p
= p
;
1586 /* Fill in the counts in the first entry in a .stabs section. */
1589 adjust_stab_sections (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1596 if (strncmp (".stab", sec
->name
, 5))
1598 if (!strcmp ("str", sec
->name
+ strlen (sec
->name
) - 3))
1601 name
= alloca (strlen (sec
->name
) + 4);
1602 strcpy (name
, sec
->name
);
1603 strcat (name
, "str");
1604 strsec
= bfd_get_section_by_name (abfd
, name
);
1606 strsz
= bfd_section_size (abfd
, strsec
);
1609 nsyms
= bfd_section_size (abfd
, sec
) / 12 - 1;
1611 p
= seg_info (sec
)->stabu
.p
;
1614 bfd_h_put_16 (abfd
, nsyms
, p
+ 6);
1615 bfd_h_put_32 (abfd
, strsz
, p
+ 8);
1618 #ifdef NEED_ECOFF_DEBUG
1620 /* This function is called by the ECOFF code. It is supposed to
1621 record the external symbol information so that the backend can
1622 write it out correctly. The ELF backend doesn't actually handle
1623 this at the moment, so we do it ourselves. We save the information
1627 elf_ecoff_set_ext (symbolS
*sym
, struct ecoff_extr
*ext
)
1629 symbol_get_bfdsym (sym
)->udata
.p
= ext
;
1632 /* This function is called by bfd_ecoff_debug_externals. It is
1633 supposed to *EXT to the external symbol information, and return
1634 whether the symbol should be used at all. */
1637 elf_get_extr (asymbol
*sym
, EXTR
*ext
)
1639 if (sym
->udata
.p
== NULL
)
1641 *ext
= *(EXTR
*) sym
->udata
.p
;
1645 /* This function is called by bfd_ecoff_debug_externals. It has
1646 nothing to do for ELF. */
1649 elf_set_index (asymbol
*sym ATTRIBUTE_UNUSED
,
1650 bfd_size_type indx ATTRIBUTE_UNUSED
)
1654 #endif /* NEED_ECOFF_DEBUG */
1657 elf_frob_symbol (symbolS
*symp
, int *puntp
)
1659 struct elf_obj_sy
*sy_obj
;
1661 #ifdef NEED_ECOFF_DEBUG
1662 if (ECOFF_DEBUGGING
)
1663 ecoff_frob_symbol (symp
);
1666 sy_obj
= symbol_get_obj (symp
);
1668 if (sy_obj
->size
!= NULL
)
1670 switch (sy_obj
->size
->X_op
)
1674 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1675 + sy_obj
->size
->X_add_number
1676 - S_GET_VALUE (sy_obj
->size
->X_op_symbol
)));
1680 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1681 + sy_obj
->size
->X_add_number
));
1684 as_bad (_(".size expression too complicated to fix up"));
1687 free (sy_obj
->size
);
1688 sy_obj
->size
= NULL
;
1691 if (sy_obj
->versioned_name
!= NULL
)
1695 p
= strchr (sy_obj
->versioned_name
, ELF_VER_CHR
);
1698 /* This symbol was given a new name with the .symver directive.
1700 If this is an external reference, just rename the symbol to
1701 include the version string. This will make the relocs be
1702 against the correct versioned symbol.
1704 If this is a definition, add an alias. FIXME: Using an alias
1705 will permit the debugging information to refer to the right
1706 symbol. However, it's not clear whether it is the best
1709 if (! S_IS_DEFINED (symp
))
1711 /* Verify that the name isn't using the @@ syntax--this is
1712 reserved for definitions of the default version to link
1714 if (p
[1] == ELF_VER_CHR
)
1716 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1717 sy_obj
->versioned_name
);
1720 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1724 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
1728 /* The @@@ syntax is a special case. It renames the
1729 symbol name to versioned_name with one `@' removed. */
1730 l
= strlen (&p
[3]) + 1;
1731 memmove (&p
[2], &p
[3], l
);
1732 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1738 /* FIXME: Creating a new symbol here is risky. We're
1739 in the final loop over the symbol table. We can
1740 get away with it only because the symbol goes to
1741 the end of the list, where the loop will still see
1742 it. It would probably be better to do this in
1743 obj_frob_file_before_adjust. */
1745 symp2
= symbol_find_or_make (sy_obj
->versioned_name
);
1747 /* Now we act as though we saw symp2 = sym. */
1749 S_SET_SEGMENT (symp2
, S_GET_SEGMENT (symp
));
1751 /* Subtracting out the frag address here is a hack
1752 because we are in the middle of the final loop. */
1755 - symbol_get_frag (symp
)->fr_address
));
1757 symbol_set_frag (symp2
, symbol_get_frag (symp
));
1759 /* This will copy over the size information. */
1760 copy_symbol_attributes (symp2
, symp
);
1762 S_SET_OTHER (symp2
, S_GET_OTHER (symp
));
1764 if (S_IS_WEAK (symp
))
1767 if (S_IS_EXTERNAL (symp
))
1768 S_SET_EXTERNAL (symp2
);
1773 /* Double check weak symbols. */
1774 if (S_IS_WEAK (symp
))
1776 if (S_IS_COMMON (symp
))
1777 as_bad (_("symbol `%s' can not be both weak and common"),
1782 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1783 any undefined non-function symbol to STT_OBJECT. We try to be
1784 compatible, since newer Irix 5 and 6 linkers care. However, we
1785 only set undefined symbols to be STT_OBJECT if we are on Irix,
1786 because that is the only time gcc will generate the necessary
1787 .global directives to mark functions. */
1789 if (S_IS_COMMON (symp
))
1790 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1792 if (strstr (TARGET_OS
, "irix") != NULL
1793 && ! S_IS_DEFINED (symp
)
1794 && (symbol_get_bfdsym (symp
)->flags
& BSF_FUNCTION
) == 0)
1795 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1799 /* If TC_PPC is defined, we used to force the type of a symbol to be
1800 BSF_OBJECT if it was otherwise unset. This was required by some
1801 version of VxWorks. Thomas de Lellis <tdel@windriver.com> says
1802 that this is no longer needed, so it is now commented out. */
1803 if ((symbol_get_bfdsym (symp
)->flags
1804 & (BSF_FUNCTION
| BSF_FILE
| BSF_SECTION_SYM
)) == 0
1805 && S_IS_DEFINED (symp
))
1806 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1812 asection
**head
; /* Section lists. */
1813 unsigned int *elt_count
; /* Number of sections in each list. */
1814 unsigned int num_group
; /* Number of lists. */
1817 /* Called via bfd_map_over_sections. If SEC is a member of a group,
1818 add it to a list of sections belonging to the group. INF is a
1819 pointer to a struct group_list, which is where we store the head of
1823 build_group_lists (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
1825 struct group_list
*list
= inf
;
1826 const char *group_name
= elf_group_name (sec
);
1829 if (group_name
== NULL
)
1832 /* If this group already has a list, add the section to the head of
1834 for (i
= 0; i
< list
->num_group
; i
++)
1836 if (strcmp (group_name
, elf_group_name (list
->head
[i
])) == 0)
1838 elf_next_in_group (sec
) = list
->head
[i
];
1839 list
->head
[i
] = sec
;
1840 list
->elt_count
[i
] += 1;
1845 /* New group. Make the arrays bigger in chunks to minimize calls to
1847 i
= list
->num_group
;
1850 unsigned int newsize
= i
+ 128;
1851 list
->head
= xrealloc (list
->head
, newsize
* sizeof (*list
->head
));
1852 list
->elt_count
= xrealloc (list
->elt_count
,
1853 newsize
* sizeof (*list
->elt_count
));
1855 list
->head
[i
] = sec
;
1856 list
->elt_count
[i
] = 1;
1857 list
->num_group
+= 1;
1861 elf_frob_file (void)
1863 struct group_list list
;
1866 bfd_map_over_sections (stdoutput
, adjust_stab_sections
, NULL
);
1868 /* Go find section groups. */
1871 list
.elt_count
= NULL
;
1872 bfd_map_over_sections (stdoutput
, build_group_lists
, &list
);
1874 /* Make the SHT_GROUP sections that describe each section group. We
1875 can't set up the section contents here yet, because elf section
1876 indices have yet to be calculated. elf.c:set_group_contents does
1877 the rest of the work. */
1878 for (i
= 0; i
< list
.num_group
; i
++)
1880 const char *group_name
= elf_group_name (list
.head
[i
]);
1881 const char *sec_name
;
1887 flags
= SEC_READONLY
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_GROUP
;
1888 for (s
= list
.head
[i
]; s
!= NULL
; s
= elf_next_in_group (s
))
1889 if ((s
->flags
^ flags
) & SEC_LINK_ONCE
)
1891 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1892 if (s
!= list
.head
[i
])
1894 as_warn (_("assuming all members of group `%s' are COMDAT"),
1900 sec_name
= group_name
;
1901 sy
= symbol_find_exact (group_name
);
1904 && (sy
== symbol_lastP
1905 || (sy
->sy_next
!= NULL
1906 && sy
->sy_next
->sy_previous
== sy
)))
1909 sec_name
= ".group";
1911 s
= subseg_force_new (sec_name
, 0);
1913 || !bfd_set_section_flags (stdoutput
, s
, flags
)
1914 || !bfd_set_section_alignment (stdoutput
, s
, 2))
1916 as_fatal (_("can't create group: %s"),
1917 bfd_errmsg (bfd_get_error ()));
1919 elf_section_type (s
) = SHT_GROUP
;
1921 /* Pass a pointer to the first section in this group. */
1922 elf_next_in_group (s
) = list
.head
[i
];
1924 elf_group_id (s
) = sy
->bsym
;
1926 s
->_raw_size
= 4 * (list
.elt_count
[i
] + 1);
1927 s
->contents
= frag_more (s
->_raw_size
);
1928 frag_now
->fr_fix
= frag_now_fix_octets ();
1931 #ifdef elf_tc_final_processing
1932 elf_tc_final_processing ();
1936 /* It removes any unneeded versioned symbols from the symbol table. */
1939 elf_frob_file_before_adjust (void)
1945 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1946 if (!S_IS_DEFINED (symp
))
1948 if (symbol_get_obj (symp
)->versioned_name
)
1952 /* The @@@ syntax is a special case. If the symbol is
1953 not defined, 2 `@'s will be removed from the
1956 p
= strchr (symbol_get_obj (symp
)->versioned_name
,
1959 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
1961 size_t l
= strlen (&p
[3]) + 1;
1962 memmove (&p
[1], &p
[3], l
);
1964 if (symbol_used_p (symp
) == 0
1965 && symbol_used_in_reloc_p (symp
) == 0)
1966 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1969 /* If there was .weak foo, but foo was neither defined nor
1970 used anywhere, remove it. */
1972 else if (S_IS_WEAK (symp
)
1973 && symbol_used_p (symp
) == 0
1974 && symbol_used_in_reloc_p (symp
) == 0)
1975 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1980 /* It is required that we let write_relocs have the opportunity to
1981 optimize away fixups before output has begun, since it is possible
1982 to eliminate all fixups for a section and thus we never should
1983 have generated the relocation section. */
1986 elf_frob_file_after_relocs (void)
1988 #ifdef NEED_ECOFF_DEBUG
1989 if (ECOFF_DEBUGGING
)
1990 /* Generate the ECOFF debugging information. */
1992 const struct ecoff_debug_swap
*debug_swap
;
1993 struct ecoff_debug_info debug
;
1998 = get_elf_backend_data (stdoutput
)->elf_backend_ecoff_debug_swap
;
1999 know (debug_swap
!= NULL
);
2000 ecoff_build_debug (&debug
.symbolic_header
, &buf
, debug_swap
);
2002 /* Set up the pointers in debug. */
2003 #define SET(ptr, offset, type) \
2004 debug.ptr = (type) (buf + debug.symbolic_header.offset)
2006 SET (line
, cbLineOffset
, unsigned char *);
2007 SET (external_dnr
, cbDnOffset
, void *);
2008 SET (external_pdr
, cbPdOffset
, void *);
2009 SET (external_sym
, cbSymOffset
, void *);
2010 SET (external_opt
, cbOptOffset
, void *);
2011 SET (external_aux
, cbAuxOffset
, union aux_ext
*);
2012 SET (ss
, cbSsOffset
, char *);
2013 SET (external_fdr
, cbFdOffset
, void *);
2014 SET (external_rfd
, cbRfdOffset
, void *);
2015 /* ssext and external_ext are set up just below. */
2019 /* Set up the external symbols. */
2020 debug
.ssext
= debug
.ssext_end
= NULL
;
2021 debug
.external_ext
= debug
.external_ext_end
= NULL
;
2022 if (! bfd_ecoff_debug_externals (stdoutput
, &debug
, debug_swap
, TRUE
,
2023 elf_get_extr
, elf_set_index
))
2024 as_fatal (_("failed to set up debugging information: %s"),
2025 bfd_errmsg (bfd_get_error ()));
2027 sec
= bfd_get_section_by_name (stdoutput
, ".mdebug");
2028 assert (sec
!= NULL
);
2030 know (!stdoutput
->output_has_begun
);
2032 /* We set the size of the section, call bfd_set_section_contents
2033 to force the ELF backend to allocate a file position, and then
2034 write out the data. FIXME: Is this really the best way to do
2036 sec
->_raw_size
= bfd_ecoff_debug_size (stdoutput
, &debug
, debug_swap
);
2038 /* Pass BUF to bfd_set_section_contents because this will
2039 eventually become a call to fwrite, and ISO C prohibits
2040 passing a NULL pointer to a stdio function even if the
2041 pointer will not be used. */
2042 if (! bfd_set_section_contents (stdoutput
, sec
, buf
, 0, 0))
2043 as_fatal (_("can't start writing .mdebug section: %s"),
2044 bfd_errmsg (bfd_get_error ()));
2046 know (stdoutput
->output_has_begun
);
2047 know (sec
->filepos
!= 0);
2049 if (! bfd_ecoff_write_debug (stdoutput
, &debug
, debug_swap
,
2051 as_fatal (_("could not write .mdebug section: %s"),
2052 bfd_errmsg (bfd_get_error ()));
2054 #endif /* NEED_ECOFF_DEBUG */
2059 /* Heavily plagiarized from obj_elf_version. The idea is to emit the
2060 SCO specific identifier in the .notes section to satisfy the SCO
2063 This looks more complicated than it really is. As opposed to the
2064 "obvious" solution, this should handle the cross dev cases
2065 correctly. (i.e, hosting on a 64 bit big endian processor, but
2066 generating SCO Elf code) Efficiency isn't a concern, as there
2067 should be exactly one of these sections per object module.
2069 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
2072 int_32 namesz = 4 ; Name size
2073 int_32 descsz = 12 ; Descriptive information
2075 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
2076 int_32 version = (major ver # << 16) | version of tools ;
2077 int_32 source = (tool_id << 16 ) | 1 ;
2078 int_32 info = 0 ; These are set by the SCO tools, but we
2079 don't know enough about the source
2080 environment to set them. SCO ld currently
2081 ignores them, and recommends we set them
2084 #define SCO_MAJOR_VERSION 0x1
2085 #define SCO_MINOR_VERSION 0x1
2095 asection
*seg
= now_seg
;
2096 subsegT subseg
= now_subseg
;
2097 Elf_Internal_Note i_note
;
2098 Elf_External_Note e_note
;
2099 asection
*note_secp
= NULL
;
2102 /* create the .note section */
2104 note_secp
= subseg_new (".note", 0);
2105 bfd_set_section_flags (stdoutput
,
2107 SEC_HAS_CONTENTS
| SEC_READONLY
);
2109 /* process the version string */
2112 i_note
.descsz
= 12; /* 12 descriptive bytes */
2113 i_note
.type
= NT_VERSION
; /* Contains a version string */
2115 p
= frag_more (sizeof (i_note
.namesz
));
2116 md_number_to_chars (p
, i_note
.namesz
, 4);
2118 p
= frag_more (sizeof (i_note
.descsz
));
2119 md_number_to_chars (p
, i_note
.descsz
, 4);
2121 p
= frag_more (sizeof (i_note
.type
));
2122 md_number_to_chars (p
, i_note
.type
, 4);
2127 /* Note: this is the version number of the ELF we're representing */
2129 md_number_to_chars (p
, (SCO_MAJOR_VERSION
<< 16) | (SCO_MINOR_VERSION
), 4);
2131 /* Here, we pick a magic number for ourselves (yes, I "registered"
2132 it with SCO. The bottom bit shows that we are compat with the
2135 md_number_to_chars (p
, 0x4c520000 | 0x0001, 4);
2137 /* If we knew (or cared) what the source language options were, we'd
2138 fill them in here. SCO has given us permission to ignore these
2139 and just set them to zero. */
2141 md_number_to_chars (p
, 0x0000, 4);
2143 frag_align (2, 0, 0);
2145 /* We probably can't restore the current segment, for there likely
2148 subseg_set (seg
, subseg
);
2152 #endif /* SCO_ELF */
2155 elf_separate_stab_sections (void)
2157 #ifdef NEED_ECOFF_DEBUG
2158 return (!ECOFF_DEBUGGING
);
2165 elf_init_stab_section (segT seg
)
2167 #ifdef NEED_ECOFF_DEBUG
2168 if (!ECOFF_DEBUGGING
)
2170 obj_elf_init_stab_section (seg
);
2173 const struct format_ops elf_format_ops
=
2175 bfd_target_elf_flavour
,
2176 0, /* dfl_leading_underscore */
2177 1, /* emit_section_symbols */
2182 elf_frob_file_before_adjust
,
2183 0, /* obj_frob_file_before_fix */
2184 elf_frob_file_after_relocs
,
2185 elf_s_get_size
, elf_s_set_size
,
2186 elf_s_get_align
, elf_s_set_align
,
2193 elf_copy_symbol_attributes
,
2194 #ifdef NEED_ECOFF_DEBUG
2195 ecoff_generate_asm_lineno
,
2198 0, /* generate_asm_lineno */
2199 0, /* process_stab */
2201 elf_separate_stab_sections
,
2202 elf_init_stab_section
,
2203 elf_sec_sym_ok_for_reloc
,
2205 #ifdef NEED_ECOFF_DEBUG
2208 0, /* ecoff_set_ext */
2210 elf_obj_read_begin_hook
,
2211 elf_obj_symbol_new_hook