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 bfd_vma elf_s_get_size
PARAMS ((symbolS
*));
57 static void elf_s_set_size
PARAMS ((symbolS
*, bfd_vma
));
58 static bfd_vma elf_s_get_align
PARAMS ((symbolS
*));
59 static void elf_s_set_align
PARAMS ((symbolS
*, bfd_vma
));
60 static void elf_s_set_other
PARAMS ((symbolS
*, int));
61 static int elf_sec_sym_ok_for_reloc
PARAMS ((asection
*));
62 static void adjust_stab_sections
PARAMS ((bfd
*, asection
*, PTR
));
63 static void build_group_lists
PARAMS ((bfd
*, asection
*, PTR
));
64 static int elf_separate_stab_sections
PARAMS ((void));
65 static void elf_init_stab_section
PARAMS ((segT
));
66 static symbolS
*elf_common
PARAMS ((int));
68 #ifdef NEED_ECOFF_DEBUG
69 static bfd_boolean elf_get_extr
PARAMS ((asymbol
*, EXTR
*));
70 static void elf_set_index
PARAMS ((asymbol
*, bfd_size_type
));
73 static void obj_elf_line
PARAMS ((int));
74 void obj_elf_version
PARAMS ((int));
75 static void obj_elf_size
PARAMS ((int));
76 static void obj_elf_type
PARAMS ((int));
77 static void obj_elf_ident
PARAMS ((int));
78 static void obj_elf_weak
PARAMS ((int));
79 static void obj_elf_local
PARAMS ((int));
80 static void obj_elf_visibility
PARAMS ((int));
81 static int obj_elf_parse_section_letters
PARAMS ((char *, size_t));
82 static int obj_elf_section_word
PARAMS ((char *, size_t));
83 static char *obj_elf_section_name
PARAMS ((void));
84 static int obj_elf_section_type
PARAMS ((char *, size_t));
85 static void obj_elf_symver
PARAMS ((int));
86 static void obj_elf_subsection
PARAMS ((int));
87 static void obj_elf_popsection
PARAMS ((int));
88 static void obj_elf_tls_common
PARAMS ((int));
90 static const pseudo_typeS elf_pseudo_table
[] =
92 {"comm", obj_elf_common
, 0},
93 {"common", obj_elf_common
, 1},
94 {"ident", obj_elf_ident
, 0},
95 {"local", obj_elf_local
, 0},
96 {"previous", obj_elf_previous
, 0},
97 {"section", obj_elf_section
, 0},
98 {"section.s", obj_elf_section
, 0},
99 {"sect", obj_elf_section
, 0},
100 {"sect.s", obj_elf_section
, 0},
101 {"pushsection", obj_elf_section
, 1},
102 {"popsection", obj_elf_popsection
, 0},
103 {"size", obj_elf_size
, 0},
104 {"type", obj_elf_type
, 0},
105 {"version", obj_elf_version
, 0},
106 {"weak", obj_elf_weak
, 0},
108 /* These define symbol visibility. */
109 {"internal", obj_elf_visibility
, STV_INTERNAL
},
110 {"hidden", obj_elf_visibility
, STV_HIDDEN
},
111 {"protected", obj_elf_visibility
, STV_PROTECTED
},
113 /* These are used for stabs-in-elf configurations. */
114 {"line", obj_elf_line
, 0},
116 /* This is a GNU extension to handle symbol versions. */
117 {"symver", obj_elf_symver
, 0},
119 /* A GNU extension to change subsection only. */
120 {"subsection", obj_elf_subsection
, 0},
122 /* These are GNU extensions to aid in garbage collecting C++ vtables. */
123 {"vtable_inherit", (void (*) PARAMS ((int))) &obj_elf_vtable_inherit
, 0},
124 {"vtable_entry", (void (*) PARAMS ((int))) &obj_elf_vtable_entry
, 0},
126 /* These are used for dwarf. */
130 /* These are used for dwarf2. */
131 { "file", (void (*) PARAMS ((int))) dwarf2_directive_file
, 0 },
132 { "loc", dwarf2_directive_loc
, 0 },
134 /* We need to trap the section changing calls to handle .previous. */
135 {"data", obj_elf_data
, 0},
136 {"text", obj_elf_text
, 0},
138 {"tls_common", obj_elf_tls_common
, 0},
144 static const pseudo_typeS ecoff_debug_pseudo_table
[] =
146 #ifdef NEED_ECOFF_DEBUG
147 /* COFF style debugging information for ECOFF. .ln is not used; .loc
149 { "def", ecoff_directive_def
, 0 },
150 { "dim", ecoff_directive_dim
, 0 },
151 { "endef", ecoff_directive_endef
, 0 },
152 { "file", ecoff_directive_file
, 0 },
153 { "scl", ecoff_directive_scl
, 0 },
154 { "tag", ecoff_directive_tag
, 0 },
155 { "val", ecoff_directive_val
, 0 },
157 /* COFF debugging requires pseudo-ops .size and .type, but ELF
158 already has meanings for those. We use .esize and .etype
159 instead. These are only generated by gcc anyhow. */
160 { "esize", ecoff_directive_size
, 0 },
161 { "etype", ecoff_directive_type
, 0 },
163 /* ECOFF specific debugging information. */
164 { "begin", ecoff_directive_begin
, 0 },
165 { "bend", ecoff_directive_bend
, 0 },
166 { "end", ecoff_directive_end
, 0 },
167 { "ent", ecoff_directive_ent
, 0 },
168 { "fmask", ecoff_directive_fmask
, 0 },
169 { "frame", ecoff_directive_frame
, 0 },
170 { "loc", ecoff_directive_loc
, 0 },
171 { "mask", ecoff_directive_mask
, 0 },
173 /* Other ECOFF directives. */
174 { "extern", ecoff_directive_extern
, 0 },
176 /* These are used on Irix. I don't know how to implement them. */
177 { "alias", s_ignore
, 0 },
178 { "bgnb", s_ignore
, 0 },
179 { "endb", s_ignore
, 0 },
180 { "lab", s_ignore
, 0 },
181 { "noalias", s_ignore
, 0 },
182 { "verstamp", s_ignore
, 0 },
183 { "vreg", s_ignore
, 0 },
186 {NULL
, NULL
, 0} /* end sentinel */
190 #include "aout/aout64.h"
192 /* This is called when the assembler starts. */
197 /* Add symbols for the known sections to the symbol table. */
198 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
199 TEXT_SECTION_NAME
)));
200 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
201 DATA_SECTION_NAME
)));
202 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
209 pop_insert (elf_pseudo_table
);
211 pop_insert (ecoff_debug_pseudo_table
);
218 return S_GET_SIZE (sym
);
222 elf_s_set_size (sym
, sz
)
226 S_SET_SIZE (sym
, sz
);
230 elf_s_get_align (sym
)
233 return S_GET_ALIGN (sym
);
237 elf_s_set_align (sym
, align
)
241 S_SET_ALIGN (sym
, align
);
245 elf_s_get_other (sym
)
248 return elf_symbol (symbol_get_bfdsym (sym
))->internal_elf_sym
.st_other
;
252 elf_s_set_other (sym
, other
)
256 S_SET_OTHER (sym
, other
);
260 elf_sec_sym_ok_for_reloc (sec
)
263 return obj_sec_sym_ok_for_reloc (sec
);
272 sym
= symbol_new (s
, absolute_section
, (valueT
) 0, (struct frag
*) 0);
273 symbol_set_frag (sym
, &zero_address_frag
);
274 symbol_get_bfdsym (sym
)->flags
|= BSF_FILE
;
276 if (symbol_rootP
!= sym
)
278 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
279 symbol_insert (sym
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
281 verify_symbol_chain (symbol_rootP
, symbol_lastP
);
285 #ifdef NEED_ECOFF_DEBUG
291 elf_common (is_common
)
297 offsetT temp
, size
, sign
;
302 if (flag_mri
&& is_common
)
308 name
= input_line_pointer
;
309 c
= get_symbol_end ();
310 /* just after name is now '\0' */
311 p
= input_line_pointer
;
314 if (*input_line_pointer
!= ',')
316 as_bad (_("expected comma after symbol-name"));
317 ignore_rest_of_line ();
320 input_line_pointer
++; /* skip ',' */
321 temp
= get_absolute_expr (&exp
);
322 sign
= (offsetT
) 1 << (stdoutput
->arch_info
->bits_per_address
- 1);
323 size
= temp
& ((sign
<< 1) - 1);
324 if (temp
!= size
|| !exp
.X_unsigned
)
326 as_bad (_(".COMMon length (%ld) out of range, ignored."), (long) temp
);
327 ignore_rest_of_line ();
331 symbolP
= symbol_find_or_make (name
);
333 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
335 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP
));
336 ignore_rest_of_line ();
339 if (S_GET_VALUE (symbolP
) != 0)
341 if (S_GET_VALUE (symbolP
) != (valueT
) size
)
343 as_warn (_("length of .comm \"%s\" is already %ld; not changed to %ld"),
344 S_GET_NAME (symbolP
), (long) S_GET_VALUE (symbolP
),
348 know (symbolP
->sy_frag
== &zero_address_frag
);
349 if (*input_line_pointer
!= ',')
354 input_line_pointer
++;
357 if (! have_align
|| *input_line_pointer
!= '"')
363 temp
= get_absolute_expr (&exp
);
367 as_warn (_("common alignment negative; 0 assumed"));
370 if (symbol_get_obj (symbolP
)->local
)
379 old_subsec
= now_subseg
;
382 /* convert to a power of 2 alignment */
383 for (align
= 0; (temp
& 1) == 0; temp
>>= 1, ++align
);
386 as_bad (_("common alignment not a power of 2"));
387 ignore_rest_of_line ();
393 record_alignment (bss_section
, align
);
394 subseg_set (bss_section
, 0);
396 frag_align (align
, 0, 0);
397 if (S_GET_SEGMENT (symbolP
) == bss_section
)
398 symbol_get_frag (symbolP
)->fr_symbol
= 0;
399 symbol_set_frag (symbolP
, frag_now
);
400 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
,
401 (offsetT
) size
, (char *) 0);
403 S_SET_SIZE (symbolP
, size
);
404 S_SET_SEGMENT (symbolP
, bss_section
);
405 S_CLEAR_EXTERNAL (symbolP
);
406 subseg_set (old_sec
, old_subsec
);
411 S_SET_VALUE (symbolP
, (valueT
) size
);
412 S_SET_ALIGN (symbolP
, temp
);
413 S_SET_EXTERNAL (symbolP
);
414 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
419 input_line_pointer
++;
420 /* @@ Some use the dot, some don't. Can we get some consistency?? */
421 if (*input_line_pointer
== '.')
422 input_line_pointer
++;
423 /* @@ Some say data, some say bss. */
424 if (strncmp (input_line_pointer
, "bss\"", 4)
425 && strncmp (input_line_pointer
, "data\"", 5))
427 while (*--input_line_pointer
!= '"')
429 input_line_pointer
--;
430 goto bad_common_segment
;
432 while (*input_line_pointer
++ != '"')
434 goto allocate_common
;
437 symbol_get_bfdsym (symbolP
)->flags
|= BSF_OBJECT
;
439 demand_empty_rest_of_line ();
444 p
= input_line_pointer
;
445 while (*p
&& *p
!= '\n')
449 as_bad (_("bad .common segment %s"), input_line_pointer
+ 1);
451 input_line_pointer
= p
;
452 ignore_rest_of_line ();
458 obj_elf_common (is_common
)
461 elf_common (is_common
);
465 obj_elf_tls_common (ignore
)
466 int ignore ATTRIBUTE_UNUSED
;
468 symbolS
*symbolP
= elf_common (0);
471 symbol_get_bfdsym (symbolP
)->flags
|= BSF_THREAD_LOCAL
;
475 obj_elf_local (ignore
)
476 int ignore ATTRIBUTE_UNUSED
;
484 name
= input_line_pointer
;
485 c
= get_symbol_end ();
486 symbolP
= symbol_find_or_make (name
);
487 *input_line_pointer
= c
;
489 S_CLEAR_EXTERNAL (symbolP
);
490 symbol_get_obj (symbolP
)->local
= 1;
493 input_line_pointer
++;
495 if (*input_line_pointer
== '\n')
500 demand_empty_rest_of_line ();
504 obj_elf_weak (ignore
)
505 int ignore ATTRIBUTE_UNUSED
;
513 name
= input_line_pointer
;
514 c
= get_symbol_end ();
515 symbolP
= symbol_find_or_make (name
);
516 *input_line_pointer
= c
;
518 S_SET_WEAK (symbolP
);
519 symbol_get_obj (symbolP
)->local
= 1;
522 input_line_pointer
++;
524 if (*input_line_pointer
== '\n')
529 demand_empty_rest_of_line ();
533 obj_elf_visibility (visibility
)
540 elf_symbol_type
*elfsym
;
544 name
= input_line_pointer
;
545 c
= get_symbol_end ();
546 symbolP
= symbol_find_or_make (name
);
547 *input_line_pointer
= c
;
551 bfdsym
= symbol_get_bfdsym (symbolP
);
552 elfsym
= elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
556 elfsym
->internal_elf_sym
.st_other
&= ~3;
557 elfsym
->internal_elf_sym
.st_other
|= visibility
;
561 input_line_pointer
++;
565 if (*input_line_pointer
== '\n')
571 demand_empty_rest_of_line ();
574 static segT previous_section
;
575 static int previous_subsection
;
579 struct section_stack
*next
;
581 int subseg
, prev_subseg
;
584 static struct section_stack
*section_stack
;
586 /* Handle the .section pseudo-op. This code supports two different
589 The first is found on Solaris, and looks like
590 .section ".sec1",#alloc,#execinstr,#write
591 Here the names after '#' are the SHF_* flags to turn on for the
592 section. I'm not sure how it determines the SHT_* type (BFD
593 doesn't really give us control over the type, anyhow).
595 The second format is found on UnixWare, and probably most SVR4
596 machines, and looks like
597 .section .sec1,"a",@progbits
598 The quoted string may contain any combination of a, w, x, and
599 represents the SHF_* flags to turn on for the section. The string
600 beginning with '@' can be progbits or nobits. There should be
601 other possibilities, but I don't know what they are. In any case,
602 BFD doesn't really let us set the section type. */
605 obj_elf_change_section (name
, type
, attr
, entsize
, group_name
, linkonce
, push
)
610 const char *group_name
;
620 #ifdef md_flush_pending_output
621 md_flush_pending_output ();
624 /* Switch to the section, creating it if necessary. */
627 struct section_stack
*elt
;
628 elt
= xmalloc (sizeof (struct section_stack
));
629 elt
->next
= section_stack
;
631 elt
->prev_seg
= previous_section
;
632 elt
->subseg
= now_subseg
;
633 elt
->prev_subseg
= previous_subsection
;
636 previous_section
= now_seg
;
637 previous_subsection
= now_subseg
;
639 old_sec
= bfd_get_section_by_name (stdoutput
, name
);
640 sec
= subseg_new (name
, 0);
642 if (_bfd_elf_get_sec_type_attr (stdoutput
, name
, &def_type
,
645 if (type
== SHT_NULL
)
647 else if (type
!= def_type
)
650 /* FIXME: gcc, as of 2002-10-22, will emit
652 .section .init_array,"aw",@progbits
654 for __attribute__ ((section (".init_array"))).
655 "@progbits" is incorrect. */
656 && def_type
!= SHT_INIT_ARRAY
657 && def_type
!= SHT_FINI_ARRAY
658 && def_type
!= SHT_PREINIT_ARRAY
)
660 /* We allow to specify any type for a .note section. */
661 if (def_type
!= SHT_NOTE
)
662 as_warn (_("setting incorrect section type for %s"),
667 as_warn (_("ignoring incorrect section type for %s"),
673 if (old_sec
== NULL
&& (attr
&~ def_attr
) != 0)
675 /* As a GNU extension, we permit a .note section to be
676 allocatable. If the linker sees an allocateable .note
677 section, it will create a PT_NOTE segment in the output
678 file. We also allow "x" for .note.GNU-stack. */
679 if (!(def_type
== SHT_NOTE
680 && (attr
== SHF_ALLOC
|| attr
== SHF_EXECINSTR
)))
681 as_warn (_("setting incorrect section attributes for %s"),
687 if (type
!= SHT_NULL
)
688 elf_section_type (sec
) = type
;
690 elf_section_flags (sec
) = attr
;
692 /* Convert ELF type and flags to BFD flags. */
694 | ((attr
& SHF_WRITE
) ? 0 : SEC_READONLY
)
695 | ((attr
& SHF_ALLOC
) ? SEC_ALLOC
: 0)
696 | (((attr
& SHF_ALLOC
) && type
!= SHT_NOBITS
) ? SEC_LOAD
: 0)
697 | ((attr
& SHF_EXECINSTR
) ? SEC_CODE
: 0)
698 | ((attr
& SHF_MERGE
) ? SEC_MERGE
: 0)
699 | ((attr
& SHF_STRINGS
) ? SEC_STRINGS
: 0)
700 | ((attr
& SHF_TLS
) ? SEC_THREAD_LOCAL
: 0));
701 #ifdef md_elf_section_flags
702 flags
= md_elf_section_flags (flags
, attr
, type
);
709 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */
710 if (type
== SHT_NOBITS
)
711 seg_info (sec
)->bss
= 1;
714 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
715 bfd_set_section_flags (stdoutput
, sec
, flags
);
716 if (flags
& SEC_MERGE
)
717 sec
->entsize
= entsize
;
718 elf_group_name (sec
) = group_name
;
720 /* Add a symbol for this section to the symbol table. */
721 secsym
= symbol_find (name
);
723 symbol_set_bfdsym (secsym
, sec
->symbol
);
725 symbol_table_insert (section_symbol (sec
));
729 /* If section attributes are specified the second time we see a
730 particular section, then check that they are the same as we
731 saw the first time. */
732 if (((old_sec
->flags
^ flags
)
733 & (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
734 | SEC_EXCLUDE
| SEC_SORT_ENTRIES
| SEC_MERGE
| SEC_STRINGS
735 | SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
736 | SEC_THREAD_LOCAL
)))
737 as_warn (_("ignoring changed section attributes for %s"), name
);
738 if ((flags
& SEC_MERGE
) && old_sec
->entsize
!= (unsigned) entsize
)
739 as_warn (_("ignoring changed section entity size for %s"), name
);
740 if ((attr
& SHF_GROUP
) != 0
741 && strcmp (elf_group_name (old_sec
), group_name
) != 0)
742 as_warn (_("ignoring new section group for %s"), name
);
745 #ifdef md_elf_section_change_hook
746 md_elf_section_change_hook ();
751 obj_elf_parse_section_letters (str
, len
)
768 attr
|= SHF_EXECINSTR
;
784 if (*(str
- 1) == 'a')
787 if (len
> 1 && str
[1] == 's')
796 char *bad_msg
= _("unrecognized .section attribute: want a,w,x,M,S,G,T");
797 #ifdef md_elf_section_letter
798 int md_attr
= md_elf_section_letter (*str
, &bad_msg
);
803 as_fatal ("%s", bad_msg
);
814 obj_elf_section_word (str
, len
)
818 if (len
== 5 && strncmp (str
, "write", 5) == 0)
820 if (len
== 5 && strncmp (str
, "alloc", 5) == 0)
822 if (len
== 9 && strncmp (str
, "execinstr", 9) == 0)
823 return SHF_EXECINSTR
;
824 if (len
== 3 && strncmp (str
, "tls", 3) == 0)
827 #ifdef md_elf_section_word
829 int md_attr
= md_elf_section_word (str
, len
);
835 as_warn (_("unrecognized section attribute"));
840 obj_elf_section_type (str
, len
)
844 if (len
== 8 && strncmp (str
, "progbits", 8) == 0)
846 if (len
== 6 && strncmp (str
, "nobits", 6) == 0)
848 if (len
== 4 && strncmp (str
, "note", 4) == 0)
851 #ifdef md_elf_section_type
853 int md_type
= md_elf_section_type (str
, len
);
859 as_warn (_("unrecognized section type"));
863 /* Get name of section. */
865 obj_elf_section_name ()
870 if (*input_line_pointer
== '"')
874 name
= demand_copy_C_string (&dummy
);
877 ignore_rest_of_line ();
883 char *end
= input_line_pointer
;
885 while (0 == strchr ("\n\t,; ", *end
))
887 if (end
== input_line_pointer
)
889 as_warn (_("missing name"));
890 ignore_rest_of_line ();
894 name
= xmalloc (end
- input_line_pointer
+ 1);
895 memcpy (name
, input_line_pointer
, end
- input_line_pointer
);
896 name
[end
- input_line_pointer
] = '\0';
897 #ifdef tc_canonicalize_section_name
898 name
= tc_canonicalize_section_name (name
);
900 input_line_pointer
= end
;
907 obj_elf_section (push
)
910 char *name
, *group_name
, *beg
;
911 int type
, attr
, dummy
;
920 #ifdef md_flush_pending_output
921 md_flush_pending_output ();
924 previous_section
= now_seg
;
925 previous_subsection
= now_subseg
;
927 s_mri_sect (&mri_type
);
929 #ifdef md_elf_section_change_hook
930 md_elf_section_change_hook ();
935 #endif /* ! defined (TC_I370) */
937 name
= obj_elf_section_name ();
946 if (*input_line_pointer
== ',')
948 /* Skip the comma. */
949 ++input_line_pointer
;
952 if (*input_line_pointer
== '"')
954 beg
= demand_copy_C_string (&dummy
);
957 ignore_rest_of_line ();
960 attr
|= obj_elf_parse_section_letters (beg
, strlen (beg
));
963 if (*input_line_pointer
== ',')
966 char *save
= input_line_pointer
;
968 ++input_line_pointer
;
970 c
= *input_line_pointer
;
973 beg
= demand_copy_C_string (&dummy
);
976 ignore_rest_of_line ();
979 type
= obj_elf_section_type (beg
, strlen (beg
));
981 else if (c
== '@' || c
== '%')
983 beg
= ++input_line_pointer
;
984 c
= get_symbol_end ();
985 *input_line_pointer
= c
;
986 type
= obj_elf_section_type (beg
, input_line_pointer
- beg
);
989 input_line_pointer
= save
;
993 if ((attr
& SHF_MERGE
) != 0 && *input_line_pointer
== ',')
995 ++input_line_pointer
;
997 entsize
= get_absolute_expression ();
1001 as_warn (_("invalid merge entity size"));
1006 else if ((attr
& SHF_MERGE
) != 0)
1008 as_warn (_("entity size for SHF_MERGE not specified"));
1012 if ((attr
& SHF_GROUP
) != 0 && *input_line_pointer
== ',')
1014 ++input_line_pointer
;
1015 group_name
= obj_elf_section_name ();
1016 if (group_name
== NULL
)
1018 else if (strncmp (input_line_pointer
, ",comdat", 7) == 0)
1020 input_line_pointer
+= 7;
1023 else if (strncmp (name
, ".gnu.linkonce", 13) == 0)
1026 else if ((attr
& SHF_GROUP
) != 0)
1028 as_warn (_("group name for SHF_GROUP not specified"));
1039 if (*input_line_pointer
!= '#')
1041 as_warn (_("character following name is not '#'"));
1042 ignore_rest_of_line ();
1045 beg
= ++input_line_pointer
;
1046 c
= get_symbol_end ();
1047 *input_line_pointer
= c
;
1049 attr
|= obj_elf_section_word (beg
, input_line_pointer
- beg
);
1053 while (*input_line_pointer
++ == ',');
1054 --input_line_pointer
;
1058 demand_empty_rest_of_line ();
1060 obj_elf_change_section (name
, type
, attr
, entsize
, group_name
, linkonce
, push
);
1063 /* Change to the .data section. */
1069 #ifdef md_flush_pending_output
1070 md_flush_pending_output ();
1073 previous_section
= now_seg
;
1074 previous_subsection
= now_subseg
;
1077 #ifdef md_elf_section_change_hook
1078 md_elf_section_change_hook ();
1082 /* Change to the .text section. */
1088 #ifdef md_flush_pending_output
1089 md_flush_pending_output ();
1092 previous_section
= now_seg
;
1093 previous_subsection
= now_subseg
;
1096 #ifdef md_elf_section_change_hook
1097 md_elf_section_change_hook ();
1102 obj_elf_subsection (ignore
)
1103 int ignore ATTRIBUTE_UNUSED
;
1107 #ifdef md_flush_pending_output
1108 md_flush_pending_output ();
1111 previous_section
= now_seg
;
1112 previous_subsection
= now_subseg
;
1114 temp
= get_absolute_expression ();
1115 subseg_set (now_seg
, (subsegT
) temp
);
1116 demand_empty_rest_of_line ();
1118 #ifdef md_elf_section_change_hook
1119 md_elf_section_change_hook ();
1123 /* This can be called from the processor backends if they change
1127 obj_elf_section_change_hook ()
1129 previous_section
= now_seg
;
1130 previous_subsection
= now_subseg
;
1134 obj_elf_previous (ignore
)
1135 int ignore ATTRIBUTE_UNUSED
;
1140 if (previous_section
== 0)
1142 as_warn (_(".previous without corresponding .section; ignored"));
1146 #ifdef md_flush_pending_output
1147 md_flush_pending_output ();
1150 new_section
= previous_section
;
1151 new_subsection
= previous_subsection
;
1152 previous_section
= now_seg
;
1153 previous_subsection
= now_subseg
;
1154 subseg_set (new_section
, new_subsection
);
1156 #ifdef md_elf_section_change_hook
1157 md_elf_section_change_hook ();
1162 obj_elf_popsection (xxx
)
1163 int xxx ATTRIBUTE_UNUSED
;
1165 struct section_stack
*top
= section_stack
;
1169 as_warn (_(".popsection without corresponding .pushsection; ignored"));
1173 #ifdef md_flush_pending_output
1174 md_flush_pending_output ();
1177 section_stack
= top
->next
;
1178 previous_section
= top
->prev_seg
;
1179 previous_subsection
= top
->prev_subseg
;
1180 subseg_set (top
->seg
, top
->subseg
);
1183 #ifdef md_elf_section_change_hook
1184 md_elf_section_change_hook ();
1189 obj_elf_line (ignore
)
1190 int ignore ATTRIBUTE_UNUSED
;
1192 /* Assume delimiter is part of expression. BSD4.2 as fails with
1193 delightful bug, so we are not being incompatible here. */
1194 new_logical_line ((char *) NULL
, (int) (get_absolute_expression ()));
1195 demand_empty_rest_of_line ();
1198 /* This handles the .symver pseudo-op, which is used to specify a
1199 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1200 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1201 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1202 with the same value as the symbol NAME. */
1205 obj_elf_symver (ignore
)
1206 int ignore ATTRIBUTE_UNUSED
;
1213 name
= input_line_pointer
;
1214 c
= get_symbol_end ();
1216 sym
= symbol_find_or_make (name
);
1218 *input_line_pointer
= c
;
1221 if (*input_line_pointer
!= ',')
1223 as_bad (_("expected comma after name in .symver"));
1224 ignore_rest_of_line ();
1228 ++input_line_pointer
;
1230 name
= input_line_pointer
;
1232 /* Temporarily include '@' in symbol names. */
1233 old_lexat
= lex_type
[(unsigned char) '@'];
1234 lex_type
[(unsigned char) '@'] |= LEX_NAME
;
1235 c
= get_symbol_end ();
1236 lex_type
[(unsigned char) '@'] = old_lexat
;
1238 if (symbol_get_obj (sym
)->versioned_name
== NULL
)
1240 symbol_get_obj (sym
)->versioned_name
= xstrdup (name
);
1242 *input_line_pointer
= c
;
1244 if (strchr (symbol_get_obj (sym
)->versioned_name
,
1245 ELF_VER_CHR
) == NULL
)
1247 as_bad (_("missing version name in `%s' for symbol `%s'"),
1248 symbol_get_obj (sym
)->versioned_name
,
1250 ignore_rest_of_line ();
1256 if (strcmp (symbol_get_obj (sym
)->versioned_name
, name
))
1258 as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1259 name
, symbol_get_obj (sym
)->versioned_name
,
1261 ignore_rest_of_line ();
1265 *input_line_pointer
= c
;
1268 demand_empty_rest_of_line ();
1271 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1272 to the linker the hierarchy in which a particular table resides. The
1273 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1276 obj_elf_vtable_inherit (ignore
)
1277 int ignore ATTRIBUTE_UNUSED
;
1279 char *cname
, *pname
;
1280 symbolS
*csym
, *psym
;
1283 if (*input_line_pointer
== '#')
1284 ++input_line_pointer
;
1286 cname
= input_line_pointer
;
1287 c
= get_symbol_end ();
1288 csym
= symbol_find (cname
);
1290 /* GCFIXME: should check that we don't have two .vtable_inherits for
1291 the same child symbol. Also, we can currently only do this if the
1292 child symbol is already exists and is placed in a fragment. */
1294 if (csym
== NULL
|| symbol_get_frag (csym
) == NULL
)
1296 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1301 *input_line_pointer
= c
;
1304 if (*input_line_pointer
!= ',')
1306 as_bad ("expected comma after name in .vtable_inherit");
1307 ignore_rest_of_line ();
1311 ++input_line_pointer
;
1314 if (*input_line_pointer
== '#')
1315 ++input_line_pointer
;
1317 if (input_line_pointer
[0] == '0'
1318 && (input_line_pointer
[1] == '\0'
1319 || ISSPACE (input_line_pointer
[1])))
1321 psym
= section_symbol (absolute_section
);
1322 ++input_line_pointer
;
1326 pname
= input_line_pointer
;
1327 c
= get_symbol_end ();
1328 psym
= symbol_find_or_make (pname
);
1329 *input_line_pointer
= c
;
1332 demand_empty_rest_of_line ();
1337 assert (symbol_get_value_expression (csym
)->X_op
== O_constant
);
1338 return fix_new (symbol_get_frag (csym
),
1339 symbol_get_value_expression (csym
)->X_add_number
,
1340 0, psym
, 0, 0, BFD_RELOC_VTABLE_INHERIT
);
1343 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1344 to the linker that a vtable slot was used. The syntax is
1345 ".vtable_entry tablename, offset". */
1348 obj_elf_vtable_entry (ignore
)
1349 int ignore ATTRIBUTE_UNUSED
;
1356 if (*input_line_pointer
== '#')
1357 ++input_line_pointer
;
1359 name
= input_line_pointer
;
1360 c
= get_symbol_end ();
1361 sym
= symbol_find_or_make (name
);
1362 *input_line_pointer
= c
;
1365 if (*input_line_pointer
!= ',')
1367 as_bad ("expected comma after name in .vtable_entry");
1368 ignore_rest_of_line ();
1372 ++input_line_pointer
;
1373 if (*input_line_pointer
== '#')
1374 ++input_line_pointer
;
1376 offset
= get_absolute_expression ();
1378 demand_empty_rest_of_line ();
1380 return fix_new (frag_now
, frag_now_fix (), 0, sym
, offset
, 0,
1381 BFD_RELOC_VTABLE_ENTRY
);
1385 elf_obj_read_begin_hook ()
1387 #ifdef NEED_ECOFF_DEBUG
1388 if (ECOFF_DEBUGGING
)
1389 ecoff_read_begin_hook ();
1394 elf_obj_symbol_new_hook (symbolP
)
1397 struct elf_obj_sy
*sy_obj
;
1399 sy_obj
= symbol_get_obj (symbolP
);
1400 sy_obj
->size
= NULL
;
1401 sy_obj
->versioned_name
= NULL
;
1403 #ifdef NEED_ECOFF_DEBUG
1404 if (ECOFF_DEBUGGING
)
1405 ecoff_symbol_new_hook (symbolP
);
1409 /* When setting one symbol equal to another, by default we probably
1410 want them to have the same "size", whatever it means in the current
1414 elf_copy_symbol_attributes (dest
, src
)
1415 symbolS
*dest
, *src
;
1417 struct elf_obj_sy
*srcelf
= symbol_get_obj (src
);
1418 struct elf_obj_sy
*destelf
= symbol_get_obj (dest
);
1421 if (destelf
->size
== NULL
)
1423 (expressionS
*) xmalloc (sizeof (expressionS
));
1424 *destelf
->size
= *srcelf
->size
;
1428 if (destelf
->size
!= NULL
)
1429 free (destelf
->size
);
1430 destelf
->size
= NULL
;
1432 S_SET_SIZE (dest
, S_GET_SIZE (src
));
1433 /* Don't copy visibility. */
1434 S_SET_OTHER (dest
, (ELF_ST_VISIBILITY (S_GET_OTHER (dest
))
1435 | (S_GET_OTHER (src
) & ~ELF_ST_VISIBILITY (-1))));
1439 obj_elf_version (ignore
)
1440 int ignore ATTRIBUTE_UNUSED
;
1445 asection
*seg
= now_seg
;
1446 subsegT subseg
= now_subseg
;
1447 Elf_Internal_Note i_note
;
1448 Elf_External_Note e_note
;
1449 asection
*note_secp
= (asection
*) NULL
;
1453 if (*input_line_pointer
== '\"')
1455 ++input_line_pointer
; /* -> 1st char of string. */
1456 name
= input_line_pointer
;
1458 while (is_a_char (c
= next_char_of_string ()))
1460 c
= *input_line_pointer
;
1461 *input_line_pointer
= '\0';
1462 *(input_line_pointer
- 1) = '\0';
1463 *input_line_pointer
= c
;
1465 /* create the .note section */
1467 note_secp
= subseg_new (".note", 0);
1468 bfd_set_section_flags (stdoutput
,
1470 SEC_HAS_CONTENTS
| SEC_READONLY
);
1472 /* process the version string */
1474 len
= strlen (name
);
1476 i_note
.namesz
= ((len
+ 1) + 3) & ~3; /* round this to word boundary */
1477 i_note
.descsz
= 0; /* no description */
1478 i_note
.type
= NT_VERSION
;
1479 p
= frag_more (sizeof (e_note
.namesz
));
1480 md_number_to_chars (p
, (valueT
) i_note
.namesz
, sizeof (e_note
.namesz
));
1481 p
= frag_more (sizeof (e_note
.descsz
));
1482 md_number_to_chars (p
, (valueT
) i_note
.descsz
, sizeof (e_note
.descsz
));
1483 p
= frag_more (sizeof (e_note
.type
));
1484 md_number_to_chars (p
, (valueT
) i_note
.type
, sizeof (e_note
.type
));
1485 p
= frag_more (len
+ 1);
1488 frag_align (2, 0, 0);
1490 subseg_set (seg
, subseg
);
1494 as_bad (_("expected quoted string"));
1496 demand_empty_rest_of_line ();
1500 obj_elf_size (ignore
)
1501 int ignore ATTRIBUTE_UNUSED
;
1503 char *name
= input_line_pointer
;
1504 char c
= get_symbol_end ();
1509 p
= input_line_pointer
;
1512 if (*input_line_pointer
!= ',')
1515 as_bad (_("expected comma after name `%s' in .size directive"), name
);
1517 ignore_rest_of_line ();
1520 input_line_pointer
++;
1522 if (exp
.X_op
== O_absent
)
1524 as_bad (_("missing expression in .size directive"));
1525 exp
.X_op
= O_constant
;
1526 exp
.X_add_number
= 0;
1529 sym
= symbol_find_or_make (name
);
1531 if (exp
.X_op
== O_constant
)
1533 S_SET_SIZE (sym
, exp
.X_add_number
);
1534 if (symbol_get_obj (sym
)->size
)
1536 xfree (symbol_get_obj (sym
)->size
);
1537 symbol_get_obj (sym
)->size
= NULL
;
1542 symbol_get_obj (sym
)->size
=
1543 (expressionS
*) xmalloc (sizeof (expressionS
));
1544 *symbol_get_obj (sym
)->size
= exp
;
1546 demand_empty_rest_of_line ();
1549 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1550 There are five syntaxes:
1552 The first (used on Solaris) is
1554 The second (used on UnixWare) is
1556 The third (reportedly to be used on Irix 6.0) is
1558 The fourth (used on NetBSD/Arm and Linux/ARM) is
1560 The fifth (used on SVR4/860) is
1561 .type SYM,"function"
1565 obj_elf_type (ignore
)
1566 int ignore ATTRIBUTE_UNUSED
;
1571 const char *typename
;
1573 elf_symbol_type
*elfsym
;
1575 name
= input_line_pointer
;
1576 c
= get_symbol_end ();
1577 sym
= symbol_find_or_make (name
);
1578 elfsym
= (elf_symbol_type
*) symbol_get_bfdsym (sym
);
1579 *input_line_pointer
= c
;
1582 if (*input_line_pointer
== ',')
1583 ++input_line_pointer
;
1586 if ( *input_line_pointer
== '#'
1587 || *input_line_pointer
== '@'
1588 || *input_line_pointer
== '"'
1589 || *input_line_pointer
== '%')
1590 ++input_line_pointer
;
1592 typename
= input_line_pointer
;
1593 c
= get_symbol_end ();
1596 if (strcmp (typename
, "function") == 0
1597 || strcmp (typename
, "STT_FUNC") == 0)
1598 type
= BSF_FUNCTION
;
1599 else if (strcmp (typename
, "object") == 0
1600 || strcmp (typename
, "STT_OBJECT") == 0)
1602 else if (strcmp (typename
, "tls_object") == 0
1603 || strcmp (typename
, "STT_TLS") == 0)
1604 type
= BSF_OBJECT
| BSF_THREAD_LOCAL
;
1605 else if (strcmp (typename
, "notype") == 0
1606 || strcmp (typename
, "STT_NOTYPE") == 0)
1608 #ifdef md_elf_symbol_type
1609 else if ((type
= md_elf_symbol_type (typename
, sym
, elfsym
)) != -1)
1613 as_bad (_("unrecognized symbol type \"%s\""), typename
);
1615 *input_line_pointer
= c
;
1617 if (*input_line_pointer
== '"')
1618 ++input_line_pointer
;
1620 elfsym
->symbol
.flags
|= type
;
1622 demand_empty_rest_of_line ();
1626 obj_elf_ident (ignore
)
1627 int ignore ATTRIBUTE_UNUSED
;
1629 static segT comment_section
;
1630 segT old_section
= now_seg
;
1631 int old_subsection
= now_subseg
;
1633 #ifdef md_flush_pending_output
1634 md_flush_pending_output ();
1637 if (!comment_section
)
1640 comment_section
= subseg_new (".comment", 0);
1641 bfd_set_section_flags (stdoutput
, comment_section
,
1642 SEC_READONLY
| SEC_HAS_CONTENTS
);
1647 subseg_set (comment_section
, 0);
1649 subseg_set (old_section
, old_subsection
);
1652 #ifdef INIT_STAB_SECTION
1654 /* The first entry in a .stabs section is special. */
1657 obj_elf_init_stab_section (seg
)
1663 unsigned int stroff
;
1665 /* Force the section to align to a longword boundary. Without this,
1666 UnixWare ar crashes. */
1667 bfd_set_section_alignment (stdoutput
, seg
, 2);
1669 /* Make space for this first symbol. */
1673 as_where (&file
, (unsigned int *) NULL
);
1674 stabstr_name
= (char *) xmalloc (strlen (segment_name (seg
)) + 4);
1675 strcpy (stabstr_name
, segment_name (seg
));
1676 strcat (stabstr_name
, "str");
1677 stroff
= get_stab_string_offset (file
, stabstr_name
);
1679 md_number_to_chars (p
, stroff
, 4);
1680 seg_info (seg
)->stabu
.p
= p
;
1685 /* Fill in the counts in the first entry in a .stabs section. */
1688 adjust_stab_sections (abfd
, sec
, xxx
)
1691 PTR xxx ATTRIBUTE_UNUSED
;
1698 if (strncmp (".stab", sec
->name
, 5))
1700 if (!strcmp ("str", sec
->name
+ strlen (sec
->name
) - 3))
1703 name
= (char *) alloca (strlen (sec
->name
) + 4);
1704 strcpy (name
, sec
->name
);
1705 strcat (name
, "str");
1706 strsec
= bfd_get_section_by_name (abfd
, name
);
1708 strsz
= bfd_section_size (abfd
, strsec
);
1711 nsyms
= bfd_section_size (abfd
, sec
) / 12 - 1;
1713 p
= seg_info (sec
)->stabu
.p
;
1716 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
1717 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
1720 #ifdef NEED_ECOFF_DEBUG
1722 /* This function is called by the ECOFF code. It is supposed to
1723 record the external symbol information so that the backend can
1724 write it out correctly. The ELF backend doesn't actually handle
1725 this at the moment, so we do it ourselves. We save the information
1729 elf_ecoff_set_ext (sym
, ext
)
1731 struct ecoff_extr
*ext
;
1733 symbol_get_bfdsym (sym
)->udata
.p
= (PTR
) ext
;
1736 /* This function is called by bfd_ecoff_debug_externals. It is
1737 supposed to *EXT to the external symbol information, and return
1738 whether the symbol should be used at all. */
1741 elf_get_extr (sym
, ext
)
1745 if (sym
->udata
.p
== NULL
)
1747 *ext
= *(EXTR
*) sym
->udata
.p
;
1751 /* This function is called by bfd_ecoff_debug_externals. It has
1752 nothing to do for ELF. */
1756 elf_set_index (sym
, indx
)
1757 asymbol
*sym ATTRIBUTE_UNUSED
;
1758 bfd_size_type indx ATTRIBUTE_UNUSED
;
1762 #endif /* NEED_ECOFF_DEBUG */
1765 elf_frob_symbol (symp
, puntp
)
1769 struct elf_obj_sy
*sy_obj
;
1771 #ifdef NEED_ECOFF_DEBUG
1772 if (ECOFF_DEBUGGING
)
1773 ecoff_frob_symbol (symp
);
1776 sy_obj
= symbol_get_obj (symp
);
1778 if (sy_obj
->size
!= NULL
)
1780 switch (sy_obj
->size
->X_op
)
1784 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1785 + sy_obj
->size
->X_add_number
1786 - S_GET_VALUE (sy_obj
->size
->X_op_symbol
)));
1790 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1791 + sy_obj
->size
->X_add_number
));
1794 as_bad (_(".size expression too complicated to fix up"));
1797 free (sy_obj
->size
);
1798 sy_obj
->size
= NULL
;
1801 if (sy_obj
->versioned_name
!= NULL
)
1805 p
= strchr (sy_obj
->versioned_name
, ELF_VER_CHR
);
1808 /* This symbol was given a new name with the .symver directive.
1810 If this is an external reference, just rename the symbol to
1811 include the version string. This will make the relocs be
1812 against the correct versioned symbol.
1814 If this is a definition, add an alias. FIXME: Using an alias
1815 will permit the debugging information to refer to the right
1816 symbol. However, it's not clear whether it is the best
1819 if (! S_IS_DEFINED (symp
))
1821 /* Verify that the name isn't using the @@ syntax--this is
1822 reserved for definitions of the default version to link
1824 if (p
[1] == ELF_VER_CHR
)
1826 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1827 sy_obj
->versioned_name
);
1830 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1834 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
1838 /* The @@@ syntax is a special case. It renames the
1839 symbol name to versioned_name with one `@' removed. */
1840 l
= strlen (&p
[3]) + 1;
1841 memmove (&p
[2], &p
[3], l
);
1842 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1848 /* FIXME: Creating a new symbol here is risky. We're
1849 in the final loop over the symbol table. We can
1850 get away with it only because the symbol goes to
1851 the end of the list, where the loop will still see
1852 it. It would probably be better to do this in
1853 obj_frob_file_before_adjust. */
1855 symp2
= symbol_find_or_make (sy_obj
->versioned_name
);
1857 /* Now we act as though we saw symp2 = sym. */
1859 S_SET_SEGMENT (symp2
, S_GET_SEGMENT (symp
));
1861 /* Subtracting out the frag address here is a hack
1862 because we are in the middle of the final loop. */
1865 - symbol_get_frag (symp
)->fr_address
));
1867 symbol_set_frag (symp2
, symbol_get_frag (symp
));
1869 /* This will copy over the size information. */
1870 copy_symbol_attributes (symp2
, symp
);
1872 S_SET_OTHER (symp2
, S_GET_OTHER (symp
));
1874 if (S_IS_WEAK (symp
))
1877 if (S_IS_EXTERNAL (symp
))
1878 S_SET_EXTERNAL (symp2
);
1883 /* Double check weak symbols. */
1884 if (S_IS_WEAK (symp
))
1886 if (S_IS_COMMON (symp
))
1887 as_bad (_("symbol `%s' can not be both weak and common"),
1892 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1893 any undefined non-function symbol to STT_OBJECT. We try to be
1894 compatible, since newer Irix 5 and 6 linkers care. However, we
1895 only set undefined symbols to be STT_OBJECT if we are on Irix,
1896 because that is the only time gcc will generate the necessary
1897 .global directives to mark functions. */
1899 if (S_IS_COMMON (symp
))
1900 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1902 if (strstr (TARGET_OS
, "irix") != NULL
1903 && ! S_IS_DEFINED (symp
)
1904 && (symbol_get_bfdsym (symp
)->flags
& BSF_FUNCTION
) == 0)
1905 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1909 /* If TC_PPC is defined, we used to force the type of a symbol to be
1910 BSF_OBJECT if it was otherwise unset. This was required by some
1911 version of VxWorks. Thomas de Lellis <tdel@windriver.com> says
1912 that this is no longer needed, so it is now commented out. */
1913 if ((symbol_get_bfdsym (symp
)->flags
1914 & (BSF_FUNCTION
| BSF_FILE
| BSF_SECTION_SYM
)) == 0
1915 && S_IS_DEFINED (symp
))
1916 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1922 asection
**head
; /* Section lists. */
1923 unsigned int *elt_count
; /* Number of sections in each list. */
1924 unsigned int num_group
; /* Number of lists. */
1927 /* Called via bfd_map_over_sections. If SEC is a member of a group,
1928 add it to a list of sections belonging to the group. INF is a
1929 pointer to a struct group_list, which is where we store the head of
1933 build_group_lists (abfd
, sec
, inf
)
1934 bfd
*abfd ATTRIBUTE_UNUSED
;
1938 struct group_list
*list
= (struct group_list
*) inf
;
1939 const char *group_name
= elf_group_name (sec
);
1942 if (group_name
== NULL
)
1945 /* If this group already has a list, add the section to the head of
1947 for (i
= 0; i
< list
->num_group
; i
++)
1949 if (strcmp (group_name
, elf_group_name (list
->head
[i
])) == 0)
1951 elf_next_in_group (sec
) = list
->head
[i
];
1952 list
->head
[i
] = sec
;
1953 list
->elt_count
[i
] += 1;
1958 /* New group. Make the arrays bigger in chunks to minimize calls to
1960 i
= list
->num_group
;
1963 unsigned int newsize
= i
+ 128;
1964 list
->head
= xrealloc (list
->head
, newsize
* sizeof (*list
->head
));
1965 list
->elt_count
= xrealloc (list
->elt_count
,
1966 newsize
* sizeof (*list
->elt_count
));
1968 list
->head
[i
] = sec
;
1969 list
->elt_count
[i
] = 1;
1970 list
->num_group
+= 1;
1976 struct group_list list
;
1979 bfd_map_over_sections (stdoutput
, adjust_stab_sections
, (PTR
) 0);
1981 /* Go find section groups. */
1984 list
.elt_count
= NULL
;
1985 bfd_map_over_sections (stdoutput
, build_group_lists
, (PTR
) &list
);
1987 /* Make the SHT_GROUP sections that describe each section group. We
1988 can't set up the section contents here yet, because elf section
1989 indices have yet to be calculated. elf.c:set_group_contents does
1990 the rest of the work. */
1991 for (i
= 0; i
< list
.num_group
; i
++)
1993 const char *group_name
= elf_group_name (list
.head
[i
]);
1994 const char *sec_name
;
2000 flags
= SEC_READONLY
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_GROUP
;
2001 for (s
= list
.head
[i
]; s
!= NULL
; s
= elf_next_in_group (s
))
2002 if ((s
->flags
^ flags
) & SEC_LINK_ONCE
)
2004 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
2005 if (s
!= list
.head
[i
])
2007 as_warn (_("assuming all members of group `%s' are COMDAT"),
2013 sec_name
= group_name
;
2014 sy
= symbol_find_exact (group_name
);
2017 && (sy
== symbol_lastP
2018 || (sy
->sy_next
!= NULL
2019 && sy
->sy_next
->sy_previous
== sy
)))
2022 sec_name
= ".group";
2024 s
= subseg_force_new (sec_name
, 0);
2026 || !bfd_set_section_flags (stdoutput
, s
, flags
)
2027 || !bfd_set_section_alignment (stdoutput
, s
, 2))
2029 as_fatal (_("can't create group: %s"),
2030 bfd_errmsg (bfd_get_error ()));
2032 elf_section_type (s
) = SHT_GROUP
;
2034 /* Pass a pointer to the first section in this group. */
2035 elf_next_in_group (s
) = list
.head
[i
];
2037 elf_group_id (s
) = sy
->bsym
;
2039 s
->_raw_size
= 4 * (list
.elt_count
[i
] + 1);
2040 s
->contents
= frag_more (s
->_raw_size
);
2041 frag_now
->fr_fix
= frag_now_fix_octets ();
2044 #ifdef elf_tc_final_processing
2045 elf_tc_final_processing ();
2049 /* It removes any unneeded versioned symbols from the symbol table. */
2052 elf_frob_file_before_adjust ()
2058 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2059 if (!S_IS_DEFINED (symp
))
2061 if (symbol_get_obj (symp
)->versioned_name
)
2065 /* The @@@ syntax is a special case. If the symbol is
2066 not defined, 2 `@'s will be removed from the
2069 p
= strchr (symbol_get_obj (symp
)->versioned_name
,
2072 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
2074 size_t l
= strlen (&p
[3]) + 1;
2075 memmove (&p
[1], &p
[3], l
);
2077 if (symbol_used_p (symp
) == 0
2078 && symbol_used_in_reloc_p (symp
) == 0)
2079 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2082 /* If there was .weak foo, but foo was neither defined nor
2083 used anywhere, remove it. */
2085 else if (S_IS_WEAK (symp
)
2086 && symbol_used_p (symp
) == 0
2087 && symbol_used_in_reloc_p (symp
) == 0)
2088 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2093 /* It is required that we let write_relocs have the opportunity to
2094 optimize away fixups before output has begun, since it is possible
2095 to eliminate all fixups for a section and thus we never should
2096 have generated the relocation section. */
2099 elf_frob_file_after_relocs ()
2101 #ifdef NEED_ECOFF_DEBUG
2102 if (ECOFF_DEBUGGING
)
2103 /* Generate the ECOFF debugging information. */
2105 const struct ecoff_debug_swap
*debug_swap
;
2106 struct ecoff_debug_info debug
;
2111 = get_elf_backend_data (stdoutput
)->elf_backend_ecoff_debug_swap
;
2112 know (debug_swap
!= (const struct ecoff_debug_swap
*) NULL
);
2113 ecoff_build_debug (&debug
.symbolic_header
, &buf
, debug_swap
);
2115 /* Set up the pointers in debug. */
2116 #define SET(ptr, offset, type) \
2117 debug.ptr = (type) (buf + debug.symbolic_header.offset)
2119 SET (line
, cbLineOffset
, unsigned char *);
2120 SET (external_dnr
, cbDnOffset
, PTR
);
2121 SET (external_pdr
, cbPdOffset
, PTR
);
2122 SET (external_sym
, cbSymOffset
, PTR
);
2123 SET (external_opt
, cbOptOffset
, PTR
);
2124 SET (external_aux
, cbAuxOffset
, union aux_ext
*);
2125 SET (ss
, cbSsOffset
, char *);
2126 SET (external_fdr
, cbFdOffset
, PTR
);
2127 SET (external_rfd
, cbRfdOffset
, PTR
);
2128 /* ssext and external_ext are set up just below. */
2132 /* Set up the external symbols. */
2133 debug
.ssext
= debug
.ssext_end
= NULL
;
2134 debug
.external_ext
= debug
.external_ext_end
= NULL
;
2135 if (! bfd_ecoff_debug_externals (stdoutput
, &debug
, debug_swap
, TRUE
,
2136 elf_get_extr
, elf_set_index
))
2137 as_fatal (_("failed to set up debugging information: %s"),
2138 bfd_errmsg (bfd_get_error ()));
2140 sec
= bfd_get_section_by_name (stdoutput
, ".mdebug");
2141 assert (sec
!= NULL
);
2143 know (!stdoutput
->output_has_begun
);
2145 /* We set the size of the section, call bfd_set_section_contents
2146 to force the ELF backend to allocate a file position, and then
2147 write out the data. FIXME: Is this really the best way to do
2149 sec
->_raw_size
= bfd_ecoff_debug_size (stdoutput
, &debug
, debug_swap
);
2151 /* Pass BUF to bfd_set_section_contents because this will
2152 eventually become a call to fwrite, and ISO C prohibits
2153 passing a NULL pointer to a stdio function even if the
2154 pointer will not be used. */
2155 if (! bfd_set_section_contents (stdoutput
, sec
, (PTR
) buf
,
2156 (file_ptr
) 0, (bfd_size_type
) 0))
2157 as_fatal (_("can't start writing .mdebug section: %s"),
2158 bfd_errmsg (bfd_get_error ()));
2160 know (stdoutput
->output_has_begun
);
2161 know (sec
->filepos
!= 0);
2163 if (! bfd_ecoff_write_debug (stdoutput
, &debug
, debug_swap
,
2165 as_fatal (_("could not write .mdebug section: %s"),
2166 bfd_errmsg (bfd_get_error ()));
2168 #endif /* NEED_ECOFF_DEBUG */
2173 /* Heavily plagarized from obj_elf_version. The idea is to emit the
2174 SCO specific identifier in the .notes section to satisfy the SCO
2177 This looks more complicated than it really is. As opposed to the
2178 "obvious" solution, this should handle the cross dev cases
2179 correctly. (i.e, hosting on a 64 bit big endian processor, but
2180 generating SCO Elf code) Efficiency isn't a concern, as there
2181 should be exactly one of these sections per object module.
2183 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
2186 int_32 namesz = 4 ; Name size
2187 int_32 descsz = 12 ; Descriptive information
2189 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
2190 int_32 version = (major ver # << 16) | version of tools ;
2191 int_32 source = (tool_id << 16 ) | 1 ;
2192 int_32 info = 0 ; These are set by the SCO tools, but we
2193 don't know enough about the source
2194 environment to set them. SCO ld currently
2195 ignores them, and recommends we set them
2198 #define SCO_MAJOR_VERSION 0x1
2199 #define SCO_MINOR_VERSION 0x1
2209 asection
*seg
= now_seg
;
2210 subsegT subseg
= now_subseg
;
2211 Elf_Internal_Note i_note
;
2212 Elf_External_Note e_note
;
2213 asection
*note_secp
= (asection
*) NULL
;
2216 /* create the .note section */
2218 note_secp
= subseg_new (".note", 0);
2219 bfd_set_section_flags (stdoutput
,
2221 SEC_HAS_CONTENTS
| SEC_READONLY
);
2223 /* process the version string */
2226 i_note
.descsz
= 12; /* 12 descriptive bytes */
2227 i_note
.type
= NT_VERSION
; /* Contains a version string */
2229 p
= frag_more (sizeof (i_note
.namesz
));
2230 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
2232 p
= frag_more (sizeof (i_note
.descsz
));
2233 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
2235 p
= frag_more (sizeof (i_note
.type
));
2236 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
2241 /* Note: this is the version number of the ELF we're representing */
2243 md_number_to_chars (p
, (SCO_MAJOR_VERSION
<< 16) | (SCO_MINOR_VERSION
), 4);
2245 /* Here, we pick a magic number for ourselves (yes, I "registered"
2246 it with SCO. The bottom bit shows that we are compat with the
2249 md_number_to_chars (p
, 0x4c520000 | 0x0001, 4);
2251 /* If we knew (or cared) what the source language options were, we'd
2252 fill them in here. SCO has given us permission to ignore these
2253 and just set them to zero. */
2255 md_number_to_chars (p
, 0x0000, 4);
2257 frag_align (2, 0, 0);
2259 /* We probably can't restore the current segment, for there likely
2262 subseg_set (seg
, subseg
);
2266 #endif /* SCO_ELF */
2269 elf_separate_stab_sections ()
2271 #ifdef NEED_ECOFF_DEBUG
2272 return (!ECOFF_DEBUGGING
);
2279 elf_init_stab_section (seg
)
2282 #ifdef NEED_ECOFF_DEBUG
2283 if (!ECOFF_DEBUGGING
)
2285 obj_elf_init_stab_section (seg
);
2288 const struct format_ops elf_format_ops
=
2290 bfd_target_elf_flavour
,
2291 0, /* dfl_leading_underscore */
2292 1, /* emit_section_symbols */
2297 elf_frob_file_before_adjust
,
2298 0, /* obj_frob_file_before_fix */
2299 elf_frob_file_after_relocs
,
2300 elf_s_get_size
, elf_s_set_size
,
2301 elf_s_get_align
, elf_s_set_align
,
2308 elf_copy_symbol_attributes
,
2309 #ifdef NEED_ECOFF_DEBUG
2310 ecoff_generate_asm_lineno
,
2313 0, /* generate_asm_lineno */
2314 0, /* process_stab */
2316 elf_separate_stab_sections
,
2317 elf_init_stab_section
,
2318 elf_sec_sym_ok_for_reloc
,
2320 #ifdef NEED_ECOFF_DEBUG
2323 0, /* ecoff_set_ext */
2325 elf_obj_read_begin_hook
,
2326 elf_obj_symbol_new_hook