1 /* ELF object file format
2 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 2,
10 or (at your option) any later version.
12 GAS is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 the GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 #define OBJ_HEADER "obj-elf.h"
24 #include "safe-ctype.h"
28 #ifndef ECOFF_DEBUGGING
29 #define ECOFF_DEBUGGING 0
31 #define NEED_ECOFF_DEBUG
34 #ifdef NEED_ECOFF_DEBUG
39 #include "elf/alpha.h"
54 static bfd_vma elf_s_get_size
PARAMS ((symbolS
*));
55 static void elf_s_set_size
PARAMS ((symbolS
*, bfd_vma
));
56 static bfd_vma elf_s_get_align
PARAMS ((symbolS
*));
57 static void elf_s_set_align
PARAMS ((symbolS
*, bfd_vma
));
58 static void elf_s_set_other
PARAMS ((symbolS
*, int));
59 static int elf_sec_sym_ok_for_reloc
PARAMS ((asection
*));
60 static void adjust_stab_sections
PARAMS ((bfd
*, asection
*, PTR
));
61 static void build_group_lists
PARAMS ((bfd
*, asection
*, PTR
));
62 static int elf_separate_stab_sections
PARAMS ((void));
63 static void elf_init_stab_section
PARAMS ((segT
));
64 static symbolS
*elf_common
PARAMS ((int));
66 #ifdef NEED_ECOFF_DEBUG
67 static boolean elf_get_extr
PARAMS ((asymbol
*, EXTR
*));
68 static void elf_set_index
PARAMS ((asymbol
*, bfd_size_type
));
71 static void obj_elf_line
PARAMS ((int));
72 void obj_elf_version
PARAMS ((int));
73 static void obj_elf_size
PARAMS ((int));
74 static void obj_elf_type
PARAMS ((int));
75 static void obj_elf_ident
PARAMS ((int));
76 static void obj_elf_weak
PARAMS ((int));
77 static void obj_elf_local
PARAMS ((int));
78 static void obj_elf_visibility
PARAMS ((int));
79 static void obj_elf_change_section
80 PARAMS ((const char *, int, int, int, const char *, 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. */
131 /* We need to trap the section changing calls to handle .previous. */
132 {"data", obj_elf_data
, 0},
133 {"text", obj_elf_text
, 0},
135 {"tls_common", obj_elf_tls_common
, 0},
141 static const pseudo_typeS ecoff_debug_pseudo_table
[] =
143 #ifdef NEED_ECOFF_DEBUG
144 /* COFF style debugging information for ECOFF. .ln is not used; .loc
146 { "def", ecoff_directive_def
, 0 },
147 { "dim", ecoff_directive_dim
, 0 },
148 { "endef", ecoff_directive_endef
, 0 },
149 { "file", ecoff_directive_file
, 0 },
150 { "scl", ecoff_directive_scl
, 0 },
151 { "tag", ecoff_directive_tag
, 0 },
152 { "val", ecoff_directive_val
, 0 },
154 /* COFF debugging requires pseudo-ops .size and .type, but ELF
155 already has meanings for those. We use .esize and .etype
156 instead. These are only generated by gcc anyhow. */
157 { "esize", ecoff_directive_size
, 0 },
158 { "etype", ecoff_directive_type
, 0 },
160 /* ECOFF specific debugging information. */
161 { "begin", ecoff_directive_begin
, 0 },
162 { "bend", ecoff_directive_bend
, 0 },
163 { "end", ecoff_directive_end
, 0 },
164 { "ent", ecoff_directive_ent
, 0 },
165 { "fmask", ecoff_directive_fmask
, 0 },
166 { "frame", ecoff_directive_frame
, 0 },
167 { "loc", ecoff_directive_loc
, 0 },
168 { "mask", ecoff_directive_mask
, 0 },
170 /* Other ECOFF directives. */
171 { "extern", ecoff_directive_extern
, 0 },
173 /* These are used on Irix. I don't know how to implement them. */
174 { "alias", s_ignore
, 0 },
175 { "bgnb", s_ignore
, 0 },
176 { "endb", s_ignore
, 0 },
177 { "lab", s_ignore
, 0 },
178 { "noalias", s_ignore
, 0 },
179 { "verstamp", s_ignore
, 0 },
180 { "vreg", s_ignore
, 0 },
183 {NULL
, NULL
, 0} /* end sentinel */
187 #include "aout/aout64.h"
189 /* This is called when the assembler starts. */
194 /* Add symbols for the known sections to the symbol table. */
195 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
196 TEXT_SECTION_NAME
)));
197 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
198 DATA_SECTION_NAME
)));
199 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
206 pop_insert (elf_pseudo_table
);
208 pop_insert (ecoff_debug_pseudo_table
);
215 return S_GET_SIZE (sym
);
219 elf_s_set_size (sym
, sz
)
223 S_SET_SIZE (sym
, sz
);
227 elf_s_get_align (sym
)
230 return S_GET_ALIGN (sym
);
234 elf_s_set_align (sym
, align
)
238 S_SET_ALIGN (sym
, align
);
242 elf_s_get_other (sym
)
245 return elf_symbol (symbol_get_bfdsym (sym
))->internal_elf_sym
.st_other
;
249 elf_s_set_other (sym
, other
)
253 S_SET_OTHER (sym
, other
);
257 elf_sec_sym_ok_for_reloc (sec
)
260 return obj_sec_sym_ok_for_reloc (sec
);
269 sym
= symbol_new (s
, absolute_section
, (valueT
) 0, (struct frag
*) 0);
270 symbol_set_frag (sym
, &zero_address_frag
);
271 symbol_get_bfdsym (sym
)->flags
|= BSF_FILE
;
273 if (symbol_rootP
!= sym
)
275 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
276 symbol_insert (sym
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
278 verify_symbol_chain (symbol_rootP
, symbol_lastP
);
282 #ifdef NEED_ECOFF_DEBUG
288 elf_common (is_common
)
298 if (flag_mri
&& is_common
)
304 name
= input_line_pointer
;
305 c
= get_symbol_end ();
306 /* just after name is now '\0' */
307 p
= input_line_pointer
;
310 if (*input_line_pointer
!= ',')
312 as_bad (_("expected comma after symbol-name"));
313 ignore_rest_of_line ();
316 input_line_pointer
++; /* skip ',' */
317 if ((temp
= get_absolute_expression ()) < 0)
319 as_bad (_(".COMMon length (%d.) <0! Ignored."), temp
);
320 ignore_rest_of_line ();
325 symbolP
= symbol_find_or_make (name
);
327 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
329 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP
));
330 ignore_rest_of_line ();
333 if (S_GET_VALUE (symbolP
) != 0)
335 if (S_GET_VALUE (symbolP
) != (valueT
) size
)
337 as_warn (_("length of .comm \"%s\" is already %ld; not changed to %d"),
338 S_GET_NAME (symbolP
), (long) S_GET_VALUE (symbolP
), size
);
341 know (symbolP
->sy_frag
== &zero_address_frag
);
342 if (*input_line_pointer
!= ',')
347 input_line_pointer
++;
350 if (! have_align
|| *input_line_pointer
!= '"')
356 temp
= get_absolute_expression ();
360 as_warn (_("common alignment negative; 0 assumed"));
363 if (symbol_get_obj (symbolP
)->local
)
372 old_subsec
= now_subseg
;
375 /* convert to a power of 2 alignment */
376 for (align
= 0; (temp
& 1) == 0; temp
>>= 1, ++align
);
379 as_bad (_("common alignment not a power of 2"));
380 ignore_rest_of_line ();
386 record_alignment (bss_section
, align
);
387 subseg_set (bss_section
, 0);
389 frag_align (align
, 0, 0);
390 if (S_GET_SEGMENT (symbolP
) == bss_section
)
391 symbol_get_frag (symbolP
)->fr_symbol
= 0;
392 symbol_set_frag (symbolP
, frag_now
);
393 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
,
394 (offsetT
) size
, (char *) 0);
396 S_SET_SIZE (symbolP
, size
);
397 S_SET_SEGMENT (symbolP
, bss_section
);
398 S_CLEAR_EXTERNAL (symbolP
);
399 subseg_set (old_sec
, old_subsec
);
404 S_SET_VALUE (symbolP
, (valueT
) size
);
405 S_SET_ALIGN (symbolP
, temp
);
406 S_SET_EXTERNAL (symbolP
);
407 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
412 input_line_pointer
++;
413 /* @@ Some use the dot, some don't. Can we get some consistency?? */
414 if (*input_line_pointer
== '.')
415 input_line_pointer
++;
416 /* @@ Some say data, some say bss. */
417 if (strncmp (input_line_pointer
, "bss\"", 4)
418 && strncmp (input_line_pointer
, "data\"", 5))
420 while (*--input_line_pointer
!= '"')
422 input_line_pointer
--;
423 goto bad_common_segment
;
425 while (*input_line_pointer
++ != '"')
427 goto allocate_common
;
430 symbol_get_bfdsym (symbolP
)->flags
|= BSF_OBJECT
;
432 demand_empty_rest_of_line ();
437 p
= input_line_pointer
;
438 while (*p
&& *p
!= '\n')
442 as_bad (_("bad .common segment %s"), input_line_pointer
+ 1);
444 input_line_pointer
= p
;
445 ignore_rest_of_line ();
451 obj_elf_common (is_common
)
454 elf_common (is_common
);
458 obj_elf_tls_common (ignore
)
459 int ignore ATTRIBUTE_UNUSED
;
461 symbolS
*symbolP
= elf_common (0);
464 symbol_get_bfdsym (symbolP
)->flags
|= BSF_THREAD_LOCAL
;
468 obj_elf_local (ignore
)
469 int ignore ATTRIBUTE_UNUSED
;
477 name
= input_line_pointer
;
478 c
= get_symbol_end ();
479 symbolP
= symbol_find_or_make (name
);
480 *input_line_pointer
= c
;
482 S_CLEAR_EXTERNAL (symbolP
);
483 symbol_get_obj (symbolP
)->local
= 1;
486 input_line_pointer
++;
488 if (*input_line_pointer
== '\n')
493 demand_empty_rest_of_line ();
497 obj_elf_weak (ignore
)
498 int ignore ATTRIBUTE_UNUSED
;
506 name
= input_line_pointer
;
507 c
= get_symbol_end ();
508 symbolP
= symbol_find_or_make (name
);
509 *input_line_pointer
= c
;
511 S_SET_WEAK (symbolP
);
512 symbol_get_obj (symbolP
)->local
= 1;
515 input_line_pointer
++;
517 if (*input_line_pointer
== '\n')
522 demand_empty_rest_of_line ();
526 obj_elf_visibility (visibility
)
533 elf_symbol_type
*elfsym
;
537 name
= input_line_pointer
;
538 c
= get_symbol_end ();
539 symbolP
= symbol_find_or_make (name
);
540 *input_line_pointer
= c
;
544 bfdsym
= symbol_get_bfdsym (symbolP
);
545 elfsym
= elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
549 elfsym
->internal_elf_sym
.st_other
= visibility
;
553 input_line_pointer
++;
557 if (*input_line_pointer
== '\n')
563 demand_empty_rest_of_line ();
566 static segT previous_section
;
567 static int previous_subsection
;
571 struct section_stack
*next
;
573 int subseg
, prev_subseg
;
576 static struct section_stack
*section_stack
;
578 /* Handle the .section pseudo-op. This code supports two different
581 The first is found on Solaris, and looks like
582 .section ".sec1",#alloc,#execinstr,#write
583 Here the names after '#' are the SHF_* flags to turn on for the
584 section. I'm not sure how it determines the SHT_* type (BFD
585 doesn't really give us control over the type, anyhow).
587 The second format is found on UnixWare, and probably most SVR4
588 machines, and looks like
589 .section .sec1,"a",@progbits
590 The quoted string may contain any combination of a, w, x, and
591 represents the SHF_* flags to turn on for the section. The string
592 beginning with '@' can be progbits or nobits. There should be
593 other possibilities, but I don't know what they are. In any case,
594 BFD doesn't really let us set the section type. */
596 /* Certain named sections have particular defined types, listed on p.
598 struct special_section
605 static struct special_section
const special_sections
[] =
607 { ".bss", SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
608 { ".comment", SHT_PROGBITS
, 0 },
609 { ".data", SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
610 { ".data1", SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
611 { ".debug", SHT_PROGBITS
, 0 },
612 { ".fini", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
613 { ".init", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
614 { ".line", SHT_PROGBITS
, 0 },
615 { ".note", SHT_NOTE
, 0 },
616 { ".rodata", SHT_PROGBITS
, SHF_ALLOC
},
617 { ".rodata1", SHT_PROGBITS
, SHF_ALLOC
},
618 { ".tbss", SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
619 { ".tdata", SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
620 { ".text", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
622 /* FIXME: The current gcc, as of 2002-03-03, will emit
624 .section .init_array,"aw",@progbits
626 for __attribute__ ((section (".init_array"))). "@progbits" marks
627 the incorrect section type. For now, we make them with
628 SHT_PROGBITS. BFD will fix the section type. Gcc should be changed
634 { ".init_array",SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
635 { ".fini_array",SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
636 { ".preinit_array",SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
638 { ".init_array",SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
639 { ".fini_array",SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
640 { ".preinit_array",SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
643 #ifdef ELF_TC_SPECIAL_SECTIONS
644 ELF_TC_SPECIAL_SECTIONS
648 /* The following section names are special, but they can not
649 reasonably appear in assembler code. Some of the attributes are
650 processor dependent. */
651 { ".dynamic", SHT_DYNAMIC
, SHF_ALLOC
/* + SHF_WRITE */ },
652 { ".dynstr", SHT_STRTAB
, SHF_ALLOC
},
653 { ".dynsym", SHT_DYNSYM
, SHF_ALLOC
},
654 { ".got", SHT_PROGBITS
, 0 },
655 { ".hash", SHT_HASH
, SHF_ALLOC
},
656 { ".interp", SHT_PROGBITS
, /* SHF_ALLOC */ },
657 { ".plt", SHT_PROGBITS
, 0 },
658 { ".shstrtab",SHT_STRTAB
, 0 },
659 { ".strtab", SHT_STRTAB
, /* SHF_ALLOC */ },
660 { ".symtab", SHT_SYMTAB
, /* SHF_ALLOC */ },
667 obj_elf_change_section (name
, type
, attr
, entsize
, group_name
, push
)
672 const char *group_name
;
680 #ifdef md_flush_pending_output
681 md_flush_pending_output ();
684 /* Switch to the section, creating it if necessary. */
687 struct section_stack
*elt
;
688 elt
= xmalloc (sizeof (struct section_stack
));
689 elt
->next
= section_stack
;
691 elt
->prev_seg
= previous_section
;
692 elt
->subseg
= now_subseg
;
693 elt
->prev_subseg
= previous_subsection
;
696 previous_section
= now_seg
;
697 previous_subsection
= now_subseg
;
699 old_sec
= bfd_get_section_by_name (stdoutput
, name
);
700 sec
= subseg_new (name
, 0);
702 /* See if this is one of the special sections. */
703 for (i
= 0; special_sections
[i
].name
!= NULL
; i
++)
704 if (strcmp (name
, special_sections
[i
].name
) == 0)
706 if (type
== SHT_NULL
)
707 type
= special_sections
[i
].type
;
708 else if (type
!= special_sections
[i
].type
)
712 as_warn (_("setting incorrect section type for %s"), name
);
716 as_warn (_("ignoring incorrect section type for %s"), name
);
717 type
= special_sections
[i
].type
;
720 if ((attr
&~ special_sections
[i
].attributes
) != 0
723 /* As a GNU extension, we permit a .note section to be
724 allocatable. If the linker sees an allocateable .note
725 section, it will create a PT_NOTE segment in the output
727 if (strcmp (name
, ".note") != 0
728 || attr
!= SHF_ALLOC
)
729 as_warn (_("setting incorrect section attributes for %s"),
732 attr
|= special_sections
[i
].attributes
;
736 /* Convert ELF type and flags to BFD flags. */
738 | ((attr
& SHF_WRITE
) ? 0 : SEC_READONLY
)
739 | ((attr
& SHF_ALLOC
) ? SEC_ALLOC
: 0)
740 | (((attr
& SHF_ALLOC
) && type
!= SHT_NOBITS
) ? SEC_LOAD
: 0)
741 | ((attr
& SHF_EXECINSTR
) ? SEC_CODE
: 0)
742 | ((attr
& SHF_MERGE
) ? SEC_MERGE
: 0)
743 | ((attr
& SHF_STRINGS
) ? SEC_STRINGS
: 0)
744 | ((attr
& SHF_TLS
) ? SEC_THREAD_LOCAL
: 0));
745 #ifdef md_elf_section_flags
746 flags
= md_elf_section_flags (flags
, attr
, type
);
753 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */
754 if (type
== SHT_NOBITS
)
755 seg_info (sec
)->bss
= 1;
757 bfd_set_section_flags (stdoutput
, sec
, flags
);
758 if (flags
& SEC_MERGE
)
759 sec
->entsize
= entsize
;
760 elf_group_name (sec
) = group_name
;
762 /* Add a symbol for this section to the symbol table. */
763 secsym
= symbol_find (name
);
765 symbol_set_bfdsym (secsym
, sec
->symbol
);
767 symbol_table_insert (section_symbol (sec
));
771 /* If section attributes are specified the second time we see a
772 particular section, then check that they are the same as we
773 saw the first time. */
774 if ((old_sec
->flags
^ flags
)
775 & (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
776 | SEC_EXCLUDE
| SEC_SORT_ENTRIES
| SEC_MERGE
| SEC_STRINGS
778 as_warn (_("ignoring changed section attributes for %s"), name
);
779 else if ((flags
& SEC_MERGE
) && old_sec
->entsize
!= (unsigned) entsize
)
780 as_warn (_("ignoring changed section entity size for %s"), name
);
781 else if ((attr
& SHF_GROUP
) != 0
782 && strcmp (elf_group_name (old_sec
), group_name
) != 0)
783 as_warn (_("ignoring new section group for %s"), name
);
786 #ifdef md_elf_section_change_hook
787 md_elf_section_change_hook ();
792 obj_elf_parse_section_letters (str
, len
)
809 attr
|= SHF_EXECINSTR
;
825 if (*(str
- 1) == 'a')
828 if (len
> 1 && str
[1] == 's')
837 char *bad_msg
= _("unrecognized .section attribute: want a,w,x,M,S,G,T");
838 #ifdef md_elf_section_letter
839 int md_attr
= md_elf_section_letter (*str
, &bad_msg
);
845 as_warn ("%s", bad_msg
);
858 obj_elf_section_word (str
, len
)
862 if (len
== 5 && strncmp (str
, "write", 5) == 0)
864 if (len
== 5 && strncmp (str
, "alloc", 5) == 0)
866 if (len
== 9 && strncmp (str
, "execinstr", 9) == 0)
867 return SHF_EXECINSTR
;
869 #ifdef md_elf_section_word
871 int md_attr
= md_elf_section_word (str
, len
);
877 as_warn (_("unrecognized section attribute"));
882 obj_elf_section_type (str
, len
)
886 if (len
== 8 && strncmp (str
, "progbits", 8) == 0)
888 if (len
== 6 && strncmp (str
, "nobits", 6) == 0)
891 #ifdef md_elf_section_type
893 int md_type
= md_elf_section_type (str
, len
);
899 as_warn (_("unrecognized section type"));
903 /* Get name of section. */
905 obj_elf_section_name ()
910 if (*input_line_pointer
== '"')
914 name
= demand_copy_C_string (&dummy
);
917 ignore_rest_of_line ();
923 char *end
= input_line_pointer
;
925 while (0 == strchr ("\n\t,; ", *end
))
927 if (end
== input_line_pointer
)
929 as_warn (_("missing name"));
930 ignore_rest_of_line ();
934 name
= xmalloc (end
- input_line_pointer
+ 1);
935 memcpy (name
, input_line_pointer
, end
- input_line_pointer
);
936 name
[end
- input_line_pointer
] = '\0';
937 input_line_pointer
= end
;
944 obj_elf_section (push
)
947 char *name
, *group_name
, *beg
;
948 int type
, attr
, dummy
;
956 #ifdef md_flush_pending_output
957 md_flush_pending_output ();
960 previous_section
= now_seg
;
961 previous_subsection
= now_subseg
;
963 s_mri_sect (&mri_type
);
965 #ifdef md_elf_section_change_hook
966 md_elf_section_change_hook ();
971 #endif /* ! defined (TC_I370) */
973 name
= obj_elf_section_name ();
981 if (*input_line_pointer
== ',')
983 /* Skip the comma. */
984 ++input_line_pointer
;
987 if (*input_line_pointer
== '"')
989 beg
= demand_copy_C_string (&dummy
);
992 ignore_rest_of_line ();
995 attr
|= obj_elf_parse_section_letters (beg
, strlen (beg
));
998 if (*input_line_pointer
== ',')
1001 char *save
= input_line_pointer
;
1003 ++input_line_pointer
;
1005 c
= *input_line_pointer
;
1008 beg
= demand_copy_C_string (&dummy
);
1011 ignore_rest_of_line ();
1014 type
= obj_elf_section_type (beg
, strlen (beg
));
1016 else if (c
== '@' || c
== '%')
1018 beg
= ++input_line_pointer
;
1019 c
= get_symbol_end ();
1020 *input_line_pointer
= c
;
1021 type
= obj_elf_section_type (beg
, input_line_pointer
- beg
);
1024 input_line_pointer
= save
;
1028 if ((attr
& SHF_MERGE
) != 0 && *input_line_pointer
== ',')
1030 ++input_line_pointer
;
1032 entsize
= get_absolute_expression ();
1036 as_warn (_("invalid merge entity size"));
1041 else if ((attr
& SHF_MERGE
) != 0)
1043 as_warn (_("entity size for SHF_MERGE not specified"));
1047 if ((attr
& SHF_GROUP
) != 0 && *input_line_pointer
== ',')
1049 ++input_line_pointer
;
1050 group_name
= obj_elf_section_name ();
1051 if (group_name
== NULL
)
1054 else if ((attr
& SHF_GROUP
) != 0)
1056 as_warn (_("group name for SHF_GROUP not specified"));
1067 if (*input_line_pointer
!= '#')
1069 as_warn (_("character following name is not '#'"));
1070 ignore_rest_of_line ();
1073 beg
= ++input_line_pointer
;
1074 c
= get_symbol_end ();
1075 *input_line_pointer
= c
;
1077 attr
|= obj_elf_section_word (beg
, input_line_pointer
- beg
);
1081 while (*input_line_pointer
++ == ',');
1082 --input_line_pointer
;
1086 demand_empty_rest_of_line ();
1088 obj_elf_change_section (name
, type
, attr
, entsize
, group_name
, push
);
1091 /* Change to the .data section. */
1097 #ifdef md_flush_pending_output
1098 md_flush_pending_output ();
1101 previous_section
= now_seg
;
1102 previous_subsection
= now_subseg
;
1105 #ifdef md_elf_section_change_hook
1106 md_elf_section_change_hook ();
1110 /* Change to the .text section. */
1116 #ifdef md_flush_pending_output
1117 md_flush_pending_output ();
1120 previous_section
= now_seg
;
1121 previous_subsection
= now_subseg
;
1124 #ifdef md_elf_section_change_hook
1125 md_elf_section_change_hook ();
1130 obj_elf_subsection (ignore
)
1131 int ignore ATTRIBUTE_UNUSED
;
1135 #ifdef md_flush_pending_output
1136 md_flush_pending_output ();
1139 previous_section
= now_seg
;
1140 previous_subsection
= now_subseg
;
1142 temp
= get_absolute_expression ();
1143 subseg_set (now_seg
, (subsegT
) temp
);
1144 demand_empty_rest_of_line ();
1146 #ifdef md_elf_section_change_hook
1147 md_elf_section_change_hook ();
1151 /* This can be called from the processor backends if they change
1155 obj_elf_section_change_hook ()
1157 previous_section
= now_seg
;
1158 previous_subsection
= now_subseg
;
1162 obj_elf_previous (ignore
)
1163 int ignore ATTRIBUTE_UNUSED
;
1168 if (previous_section
== 0)
1170 as_warn (_(".previous without corresponding .section; ignored"));
1174 #ifdef md_flush_pending_output
1175 md_flush_pending_output ();
1178 new_section
= previous_section
;
1179 new_subsection
= previous_subsection
;
1180 previous_section
= now_seg
;
1181 previous_subsection
= now_subseg
;
1182 subseg_set (new_section
, new_subsection
);
1184 #ifdef md_elf_section_change_hook
1185 md_elf_section_change_hook ();
1190 obj_elf_popsection (xxx
)
1191 int xxx ATTRIBUTE_UNUSED
;
1193 struct section_stack
*top
= section_stack
;
1197 as_warn (_(".popsection without corresponding .pushsection; ignored"));
1201 #ifdef md_flush_pending_output
1202 md_flush_pending_output ();
1205 section_stack
= top
->next
;
1206 previous_section
= top
->prev_seg
;
1207 previous_subsection
= top
->prev_subseg
;
1208 subseg_set (top
->seg
, top
->subseg
);
1211 #ifdef md_elf_section_change_hook
1212 md_elf_section_change_hook ();
1217 obj_elf_line (ignore
)
1218 int ignore ATTRIBUTE_UNUSED
;
1220 /* Assume delimiter is part of expression. BSD4.2 as fails with
1221 delightful bug, so we are not being incompatible here. */
1222 new_logical_line ((char *) NULL
, (int) (get_absolute_expression ()));
1223 demand_empty_rest_of_line ();
1226 /* This handles the .symver pseudo-op, which is used to specify a
1227 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1228 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1229 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1230 with the same value as the symbol NAME. */
1233 obj_elf_symver (ignore
)
1234 int ignore ATTRIBUTE_UNUSED
;
1241 name
= input_line_pointer
;
1242 c
= get_symbol_end ();
1244 sym
= symbol_find_or_make (name
);
1246 *input_line_pointer
= c
;
1249 if (*input_line_pointer
!= ',')
1251 as_bad (_("expected comma after name in .symver"));
1252 ignore_rest_of_line ();
1256 ++input_line_pointer
;
1257 name
= input_line_pointer
;
1259 /* Temporarily include '@' in symbol names. */
1260 old_lexat
= lex_type
[(unsigned char) '@'];
1261 lex_type
[(unsigned char) '@'] |= LEX_NAME
;
1262 c
= get_symbol_end ();
1263 lex_type
[(unsigned char) '@'] = old_lexat
;
1265 if (symbol_get_obj (sym
)->versioned_name
== NULL
)
1267 symbol_get_obj (sym
)->versioned_name
= xstrdup (name
);
1269 *input_line_pointer
= c
;
1271 if (strchr (symbol_get_obj (sym
)->versioned_name
,
1272 ELF_VER_CHR
) == NULL
)
1274 as_bad (_("missing version name in `%s' for symbol `%s'"),
1275 symbol_get_obj (sym
)->versioned_name
,
1277 ignore_rest_of_line ();
1283 if (strcmp (symbol_get_obj (sym
)->versioned_name
, name
))
1285 as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1286 name
, symbol_get_obj (sym
)->versioned_name
,
1288 ignore_rest_of_line ();
1292 *input_line_pointer
= c
;
1295 demand_empty_rest_of_line ();
1298 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1299 to the linker the hierarchy in which a particular table resides. The
1300 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1303 obj_elf_vtable_inherit (ignore
)
1304 int ignore ATTRIBUTE_UNUSED
;
1306 char *cname
, *pname
;
1307 symbolS
*csym
, *psym
;
1310 if (*input_line_pointer
== '#')
1311 ++input_line_pointer
;
1313 cname
= input_line_pointer
;
1314 c
= get_symbol_end ();
1315 csym
= symbol_find (cname
);
1317 /* GCFIXME: should check that we don't have two .vtable_inherits for
1318 the same child symbol. Also, we can currently only do this if the
1319 child symbol is already exists and is placed in a fragment. */
1321 if (csym
== NULL
|| symbol_get_frag (csym
) == NULL
)
1323 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1328 *input_line_pointer
= c
;
1331 if (*input_line_pointer
!= ',')
1333 as_bad ("expected comma after name in .vtable_inherit");
1334 ignore_rest_of_line ();
1338 ++input_line_pointer
;
1341 if (*input_line_pointer
== '#')
1342 ++input_line_pointer
;
1344 if (input_line_pointer
[0] == '0'
1345 && (input_line_pointer
[1] == '\0'
1346 || ISSPACE (input_line_pointer
[1])))
1348 psym
= section_symbol (absolute_section
);
1349 ++input_line_pointer
;
1353 pname
= input_line_pointer
;
1354 c
= get_symbol_end ();
1355 psym
= symbol_find_or_make (pname
);
1356 *input_line_pointer
= c
;
1359 demand_empty_rest_of_line ();
1364 assert (symbol_get_value_expression (csym
)->X_op
== O_constant
);
1365 return fix_new (symbol_get_frag (csym
),
1366 symbol_get_value_expression (csym
)->X_add_number
,
1367 0, psym
, 0, 0, BFD_RELOC_VTABLE_INHERIT
);
1370 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1371 to the linker that a vtable slot was used. The syntax is
1372 ".vtable_entry tablename, offset". */
1375 obj_elf_vtable_entry (ignore
)
1376 int ignore ATTRIBUTE_UNUSED
;
1383 if (*input_line_pointer
== '#')
1384 ++input_line_pointer
;
1386 name
= input_line_pointer
;
1387 c
= get_symbol_end ();
1388 sym
= symbol_find_or_make (name
);
1389 *input_line_pointer
= c
;
1392 if (*input_line_pointer
!= ',')
1394 as_bad ("expected comma after name in .vtable_entry");
1395 ignore_rest_of_line ();
1399 ++input_line_pointer
;
1400 if (*input_line_pointer
== '#')
1401 ++input_line_pointer
;
1403 offset
= get_absolute_expression ();
1405 demand_empty_rest_of_line ();
1407 return fix_new (frag_now
, frag_now_fix (), 0, sym
, offset
, 0,
1408 BFD_RELOC_VTABLE_ENTRY
);
1412 elf_obj_read_begin_hook ()
1414 #ifdef NEED_ECOFF_DEBUG
1415 if (ECOFF_DEBUGGING
)
1416 ecoff_read_begin_hook ();
1421 elf_obj_symbol_new_hook (symbolP
)
1424 struct elf_obj_sy
*sy_obj
;
1426 sy_obj
= symbol_get_obj (symbolP
);
1427 sy_obj
->size
= NULL
;
1428 sy_obj
->versioned_name
= NULL
;
1430 #ifdef NEED_ECOFF_DEBUG
1431 if (ECOFF_DEBUGGING
)
1432 ecoff_symbol_new_hook (symbolP
);
1436 /* When setting one symbol equal to another, by default we probably
1437 want them to have the same "size", whatever it means in the current
1441 elf_copy_symbol_attributes (dest
, src
)
1442 symbolS
*dest
, *src
;
1444 struct elf_obj_sy
*srcelf
= symbol_get_obj (src
);
1445 struct elf_obj_sy
*destelf
= symbol_get_obj (dest
);
1448 if (destelf
->size
== NULL
)
1450 (expressionS
*) xmalloc (sizeof (expressionS
));
1451 *destelf
->size
= *srcelf
->size
;
1455 if (destelf
->size
!= NULL
)
1456 free (destelf
->size
);
1457 destelf
->size
= NULL
;
1459 S_SET_SIZE (dest
, S_GET_SIZE (src
));
1460 /* Don't copy visibility. */
1461 S_SET_OTHER (dest
, (ELF_ST_VISIBILITY (S_GET_OTHER (dest
))
1462 | (S_GET_OTHER (src
) & ~ELF_ST_VISIBILITY (-1))));
1466 obj_elf_version (ignore
)
1467 int ignore ATTRIBUTE_UNUSED
;
1472 asection
*seg
= now_seg
;
1473 subsegT subseg
= now_subseg
;
1474 Elf_Internal_Note i_note
;
1475 Elf_External_Note e_note
;
1476 asection
*note_secp
= (asection
*) NULL
;
1480 if (*input_line_pointer
== '\"')
1482 ++input_line_pointer
; /* -> 1st char of string. */
1483 name
= input_line_pointer
;
1485 while (is_a_char (c
= next_char_of_string ()))
1487 c
= *input_line_pointer
;
1488 *input_line_pointer
= '\0';
1489 *(input_line_pointer
- 1) = '\0';
1490 *input_line_pointer
= c
;
1492 /* create the .note section */
1494 note_secp
= subseg_new (".note", 0);
1495 bfd_set_section_flags (stdoutput
,
1497 SEC_HAS_CONTENTS
| SEC_READONLY
);
1499 /* process the version string */
1501 len
= strlen (name
);
1503 i_note
.namesz
= ((len
+ 1) + 3) & ~3; /* round this to word boundary */
1504 i_note
.descsz
= 0; /* no description */
1505 i_note
.type
= NT_VERSION
;
1506 p
= frag_more (sizeof (e_note
.namesz
));
1507 md_number_to_chars (p
, (valueT
) i_note
.namesz
, sizeof (e_note
.namesz
));
1508 p
= frag_more (sizeof (e_note
.descsz
));
1509 md_number_to_chars (p
, (valueT
) i_note
.descsz
, sizeof (e_note
.descsz
));
1510 p
= frag_more (sizeof (e_note
.type
));
1511 md_number_to_chars (p
, (valueT
) i_note
.type
, sizeof (e_note
.type
));
1512 p
= frag_more (len
+ 1);
1515 frag_align (2, 0, 0);
1517 subseg_set (seg
, subseg
);
1521 as_bad (_("expected quoted string"));
1523 demand_empty_rest_of_line ();
1527 obj_elf_size (ignore
)
1528 int ignore ATTRIBUTE_UNUSED
;
1530 char *name
= input_line_pointer
;
1531 char c
= get_symbol_end ();
1536 p
= input_line_pointer
;
1539 if (*input_line_pointer
!= ',')
1542 as_bad (_("expected comma after name `%s' in .size directive"), name
);
1544 ignore_rest_of_line ();
1547 input_line_pointer
++;
1549 if (exp
.X_op
== O_absent
)
1551 as_bad (_("missing expression in .size directive"));
1552 exp
.X_op
= O_constant
;
1553 exp
.X_add_number
= 0;
1556 sym
= symbol_find_or_make (name
);
1558 if (exp
.X_op
== O_constant
)
1560 S_SET_SIZE (sym
, exp
.X_add_number
);
1561 if (symbol_get_obj (sym
)->size
)
1563 xfree (symbol_get_obj (sym
)->size
);
1564 symbol_get_obj (sym
)->size
= NULL
;
1569 symbol_get_obj (sym
)->size
=
1570 (expressionS
*) xmalloc (sizeof (expressionS
));
1571 *symbol_get_obj (sym
)->size
= exp
;
1573 demand_empty_rest_of_line ();
1576 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1577 There are five syntaxes:
1579 The first (used on Solaris) is
1581 The second (used on UnixWare) is
1583 The third (reportedly to be used on Irix 6.0) is
1585 The fourth (used on NetBSD/Arm and Linux/ARM) is
1587 The fifth (used on SVR4/860) is
1588 .type SYM,"function"
1592 obj_elf_type (ignore
)
1593 int ignore ATTRIBUTE_UNUSED
;
1598 const char *typename
;
1600 elf_symbol_type
*elfsym
;
1602 name
= input_line_pointer
;
1603 c
= get_symbol_end ();
1604 sym
= symbol_find_or_make (name
);
1605 elfsym
= (elf_symbol_type
*) symbol_get_bfdsym (sym
);
1606 *input_line_pointer
= c
;
1609 if (*input_line_pointer
== ',')
1610 ++input_line_pointer
;
1613 if ( *input_line_pointer
== '#'
1614 || *input_line_pointer
== '@'
1615 || *input_line_pointer
== '"'
1616 || *input_line_pointer
== '%')
1617 ++input_line_pointer
;
1619 typename
= input_line_pointer
;
1620 c
= get_symbol_end ();
1623 if (strcmp (typename
, "function") == 0
1624 || strcmp (typename
, "STT_FUNC") == 0)
1625 type
= BSF_FUNCTION
;
1626 else if (strcmp (typename
, "object") == 0
1627 || strcmp (typename
, "STT_OBJECT") == 0)
1629 #ifdef md_elf_symbol_type
1630 else if ((type
= md_elf_symbol_type (typename
, sym
, elfsym
)) != -1)
1634 as_bad (_("unrecognized symbol type \"%s\""), typename
);
1636 *input_line_pointer
= c
;
1638 if (*input_line_pointer
== '"')
1639 ++input_line_pointer
;
1641 elfsym
->symbol
.flags
|= type
;
1643 demand_empty_rest_of_line ();
1647 obj_elf_ident (ignore
)
1648 int ignore ATTRIBUTE_UNUSED
;
1650 static segT comment_section
;
1651 segT old_section
= now_seg
;
1652 int old_subsection
= now_subseg
;
1654 #ifdef md_flush_pending_output
1655 md_flush_pending_output ();
1658 if (!comment_section
)
1661 comment_section
= subseg_new (".comment", 0);
1662 bfd_set_section_flags (stdoutput
, comment_section
,
1663 SEC_READONLY
| SEC_HAS_CONTENTS
);
1668 subseg_set (comment_section
, 0);
1670 subseg_set (old_section
, old_subsection
);
1673 #ifdef INIT_STAB_SECTION
1675 /* The first entry in a .stabs section is special. */
1678 obj_elf_init_stab_section (seg
)
1684 unsigned int stroff
;
1686 /* Force the section to align to a longword boundary. Without this,
1687 UnixWare ar crashes. */
1688 bfd_set_section_alignment (stdoutput
, seg
, 2);
1690 /* Make space for this first symbol. */
1694 as_where (&file
, (unsigned int *) NULL
);
1695 stabstr_name
= (char *) xmalloc (strlen (segment_name (seg
)) + 4);
1696 strcpy (stabstr_name
, segment_name (seg
));
1697 strcat (stabstr_name
, "str");
1698 stroff
= get_stab_string_offset (file
, stabstr_name
);
1700 md_number_to_chars (p
, stroff
, 4);
1701 seg_info (seg
)->stabu
.p
= p
;
1706 /* Fill in the counts in the first entry in a .stabs section. */
1709 adjust_stab_sections (abfd
, sec
, xxx
)
1712 PTR xxx ATTRIBUTE_UNUSED
;
1719 if (strncmp (".stab", sec
->name
, 5))
1721 if (!strcmp ("str", sec
->name
+ strlen (sec
->name
) - 3))
1724 name
= (char *) alloca (strlen (sec
->name
) + 4);
1725 strcpy (name
, sec
->name
);
1726 strcat (name
, "str");
1727 strsec
= bfd_get_section_by_name (abfd
, name
);
1729 strsz
= bfd_section_size (abfd
, strsec
);
1732 nsyms
= bfd_section_size (abfd
, sec
) / 12 - 1;
1734 p
= seg_info (sec
)->stabu
.p
;
1737 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
1738 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
1741 #ifdef NEED_ECOFF_DEBUG
1743 /* This function is called by the ECOFF code. It is supposed to
1744 record the external symbol information so that the backend can
1745 write it out correctly. The ELF backend doesn't actually handle
1746 this at the moment, so we do it ourselves. We save the information
1750 elf_ecoff_set_ext (sym
, ext
)
1752 struct ecoff_extr
*ext
;
1754 symbol_get_bfdsym (sym
)->udata
.p
= (PTR
) ext
;
1757 /* This function is called by bfd_ecoff_debug_externals. It is
1758 supposed to *EXT to the external symbol information, and return
1759 whether the symbol should be used at all. */
1762 elf_get_extr (sym
, ext
)
1766 if (sym
->udata
.p
== NULL
)
1768 *ext
= *(EXTR
*) sym
->udata
.p
;
1772 /* This function is called by bfd_ecoff_debug_externals. It has
1773 nothing to do for ELF. */
1777 elf_set_index (sym
, indx
)
1778 asymbol
*sym ATTRIBUTE_UNUSED
;
1779 bfd_size_type indx ATTRIBUTE_UNUSED
;
1783 #endif /* NEED_ECOFF_DEBUG */
1786 elf_frob_symbol (symp
, puntp
)
1790 struct elf_obj_sy
*sy_obj
;
1792 #ifdef NEED_ECOFF_DEBUG
1793 if (ECOFF_DEBUGGING
)
1794 ecoff_frob_symbol (symp
);
1797 sy_obj
= symbol_get_obj (symp
);
1799 if (sy_obj
->size
!= NULL
)
1801 switch (sy_obj
->size
->X_op
)
1805 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1806 + sy_obj
->size
->X_add_number
1807 - S_GET_VALUE (sy_obj
->size
->X_op_symbol
)));
1811 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1812 + sy_obj
->size
->X_add_number
));
1815 as_bad (_(".size expression too complicated to fix up"));
1818 free (sy_obj
->size
);
1819 sy_obj
->size
= NULL
;
1822 if (sy_obj
->versioned_name
!= NULL
)
1826 p
= strchr (sy_obj
->versioned_name
, ELF_VER_CHR
);
1829 /* This symbol was given a new name with the .symver directive.
1831 If this is an external reference, just rename the symbol to
1832 include the version string. This will make the relocs be
1833 against the correct versioned symbol.
1835 If this is a definition, add an alias. FIXME: Using an alias
1836 will permit the debugging information to refer to the right
1837 symbol. However, it's not clear whether it is the best
1840 if (! S_IS_DEFINED (symp
))
1842 /* Verify that the name isn't using the @@ syntax--this is
1843 reserved for definitions of the default version to link
1845 if (p
[1] == ELF_VER_CHR
)
1847 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1848 sy_obj
->versioned_name
);
1851 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1855 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
1859 /* The @@@ syntax is a special case. It renames the
1860 symbol name to versioned_name with one `@' removed. */
1861 l
= strlen (&p
[3]) + 1;
1862 memmove (&p
[2], &p
[3], l
);
1863 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1869 /* FIXME: Creating a new symbol here is risky. We're
1870 in the final loop over the symbol table. We can
1871 get away with it only because the symbol goes to
1872 the end of the list, where the loop will still see
1873 it. It would probably be better to do this in
1874 obj_frob_file_before_adjust. */
1876 symp2
= symbol_find_or_make (sy_obj
->versioned_name
);
1878 /* Now we act as though we saw symp2 = sym. */
1880 S_SET_SEGMENT (symp2
, S_GET_SEGMENT (symp
));
1882 /* Subtracting out the frag address here is a hack
1883 because we are in the middle of the final loop. */
1886 - symbol_get_frag (symp
)->fr_address
));
1888 symbol_set_frag (symp2
, symbol_get_frag (symp
));
1890 /* This will copy over the size information. */
1891 copy_symbol_attributes (symp2
, symp
);
1893 S_SET_OTHER (symp2
, S_GET_OTHER (symp
));
1895 if (S_IS_WEAK (symp
))
1898 if (S_IS_EXTERNAL (symp
))
1899 S_SET_EXTERNAL (symp2
);
1904 /* Double check weak symbols. */
1905 if (S_IS_WEAK (symp
))
1907 if (S_IS_COMMON (symp
))
1908 as_bad (_("symbol `%s' can not be both weak and common"),
1913 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1914 any undefined non-function symbol to STT_OBJECT. We try to be
1915 compatible, since newer Irix 5 and 6 linkers care. However, we
1916 only set undefined symbols to be STT_OBJECT if we are on Irix,
1917 because that is the only time gcc will generate the necessary
1918 .global directives to mark functions. */
1920 if (S_IS_COMMON (symp
))
1921 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1923 if (strstr (TARGET_OS
, "irix") != NULL
1924 && ! S_IS_DEFINED (symp
)
1925 && (symbol_get_bfdsym (symp
)->flags
& BSF_FUNCTION
) == 0)
1926 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1930 /* If TC_PPC is defined, we used to force the type of a symbol to be
1931 BSF_OBJECT if it was otherwise unset. This was required by some
1932 version of VxWorks. Thomas de Lellis <tdel@windriver.com> says
1933 that this is no longer needed, so it is now commented out. */
1934 if ((symbol_get_bfdsym (symp
)->flags
1935 & (BSF_FUNCTION
| BSF_FILE
| BSF_SECTION_SYM
)) == 0
1936 && S_IS_DEFINED (symp
))
1937 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1943 asection
**head
; /* Section lists. */
1944 unsigned int *elt_count
; /* Number of sections in each list. */
1945 unsigned int num_group
; /* Number of lists. */
1948 /* Called via bfd_map_over_sections. If SEC is a member of a group,
1949 add it to a list of sections belonging to the group. INF is a
1950 pointer to a struct group_list, which is where we store the head of
1954 build_group_lists (abfd
, sec
, inf
)
1955 bfd
*abfd ATTRIBUTE_UNUSED
;
1959 struct group_list
*list
= (struct group_list
*) inf
;
1960 const char *group_name
= elf_group_name (sec
);
1963 if (group_name
== NULL
)
1966 /* If this group already has a list, add the section to the head of
1968 for (i
= 0; i
< list
->num_group
; i
++)
1970 if (strcmp (group_name
, elf_group_name (list
->head
[i
])) == 0)
1972 elf_next_in_group (sec
) = list
->head
[i
];
1973 list
->head
[i
] = sec
;
1974 list
->elt_count
[i
] += 1;
1979 /* New group. Make the arrays bigger in chunks to minimize calls to
1981 i
= list
->num_group
;
1984 unsigned int newsize
= i
+ 128;
1985 list
->head
= xrealloc (list
->head
, newsize
* sizeof (*list
->head
));
1986 list
->elt_count
= xrealloc (list
->elt_count
,
1987 newsize
* sizeof (*list
->elt_count
));
1989 list
->head
[i
] = sec
;
1990 list
->elt_count
[i
] = 1;
1991 list
->num_group
+= 1;
1997 struct group_list list
;
2000 bfd_map_over_sections (stdoutput
, adjust_stab_sections
, (PTR
) 0);
2002 /* Go find section groups. */
2005 list
.elt_count
= NULL
;
2006 bfd_map_over_sections (stdoutput
, build_group_lists
, (PTR
) &list
);
2008 /* Make the SHT_GROUP sections that describe each section group. We
2009 can't set up the section contents here yet, because elf section
2010 indices have yet to be calculated. elf.c:set_group_contents does
2011 the rest of the work. */
2012 for (i
= 0; i
< list
.num_group
; i
++)
2014 const char *group_name
= elf_group_name (list
.head
[i
]);
2018 s
= subseg_force_new (group_name
, 0);
2019 flags
= SEC_READONLY
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_GROUP
;
2021 || !bfd_set_section_flags (stdoutput
, s
, flags
)
2022 || !bfd_set_section_alignment (stdoutput
, s
, 2))
2024 as_fatal (_("can't create group: %s"),
2025 bfd_errmsg (bfd_get_error ()));
2028 /* Pass a pointer to the first section in this group. */
2029 elf_next_in_group (s
) = list
.head
[i
];
2031 s
->_raw_size
= 4 * (list
.elt_count
[i
] + 1);
2032 s
->contents
= frag_more (s
->_raw_size
);
2033 frag_now
->fr_fix
= frag_now_fix_octets ();
2036 #ifdef elf_tc_final_processing
2037 elf_tc_final_processing ();
2041 /* It removes any unneeded versioned symbols from the symbol table. */
2044 elf_frob_file_before_adjust ()
2050 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2051 if (!S_IS_DEFINED (symp
))
2053 if (symbol_get_obj (symp
)->versioned_name
)
2057 /* The @@@ syntax is a special case. If the symbol is
2058 not defined, 2 `@'s will be removed from the
2061 p
= strchr (symbol_get_obj (symp
)->versioned_name
,
2064 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
2066 size_t l
= strlen (&p
[3]) + 1;
2067 memmove (&p
[1], &p
[3], l
);
2069 if (symbol_used_p (symp
) == 0
2070 && symbol_used_in_reloc_p (symp
) == 0)
2071 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2074 /* If there was .weak foo, but foo was neither defined nor
2075 used anywhere, remove it. */
2077 else if (S_IS_WEAK (symp
)
2078 && symbol_used_p (symp
) == 0
2079 && symbol_used_in_reloc_p (symp
) == 0)
2080 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2085 /* It is required that we let write_relocs have the opportunity to
2086 optimize away fixups before output has begun, since it is possible
2087 to eliminate all fixups for a section and thus we never should
2088 have generated the relocation section. */
2091 elf_frob_file_after_relocs ()
2093 #ifdef NEED_ECOFF_DEBUG
2094 if (ECOFF_DEBUGGING
)
2095 /* Generate the ECOFF debugging information. */
2097 const struct ecoff_debug_swap
*debug_swap
;
2098 struct ecoff_debug_info debug
;
2103 = get_elf_backend_data (stdoutput
)->elf_backend_ecoff_debug_swap
;
2104 know (debug_swap
!= (const struct ecoff_debug_swap
*) NULL
);
2105 ecoff_build_debug (&debug
.symbolic_header
, &buf
, debug_swap
);
2107 /* Set up the pointers in debug. */
2108 #define SET(ptr, offset, type) \
2109 debug.ptr = (type) (buf + debug.symbolic_header.offset)
2111 SET (line
, cbLineOffset
, unsigned char *);
2112 SET (external_dnr
, cbDnOffset
, PTR
);
2113 SET (external_pdr
, cbPdOffset
, PTR
);
2114 SET (external_sym
, cbSymOffset
, PTR
);
2115 SET (external_opt
, cbOptOffset
, PTR
);
2116 SET (external_aux
, cbAuxOffset
, union aux_ext
*);
2117 SET (ss
, cbSsOffset
, char *);
2118 SET (external_fdr
, cbFdOffset
, PTR
);
2119 SET (external_rfd
, cbRfdOffset
, PTR
);
2120 /* ssext and external_ext are set up just below. */
2124 /* Set up the external symbols. */
2125 debug
.ssext
= debug
.ssext_end
= NULL
;
2126 debug
.external_ext
= debug
.external_ext_end
= NULL
;
2127 if (! bfd_ecoff_debug_externals (stdoutput
, &debug
, debug_swap
, true,
2128 elf_get_extr
, elf_set_index
))
2129 as_fatal (_("failed to set up debugging information: %s"),
2130 bfd_errmsg (bfd_get_error ()));
2132 sec
= bfd_get_section_by_name (stdoutput
, ".mdebug");
2133 assert (sec
!= NULL
);
2135 know (stdoutput
->output_has_begun
== false);
2137 /* We set the size of the section, call bfd_set_section_contents
2138 to force the ELF backend to allocate a file position, and then
2139 write out the data. FIXME: Is this really the best way to do
2141 sec
->_raw_size
= bfd_ecoff_debug_size (stdoutput
, &debug
, debug_swap
);
2143 /* Pass BUF to bfd_set_section_contents because this will
2144 eventually become a call to fwrite, and ISO C prohibits
2145 passing a NULL pointer to a stdio function even if the
2146 pointer will not be used. */
2147 if (! bfd_set_section_contents (stdoutput
, sec
, (PTR
) buf
,
2148 (file_ptr
) 0, (bfd_size_type
) 0))
2149 as_fatal (_("can't start writing .mdebug section: %s"),
2150 bfd_errmsg (bfd_get_error ()));
2152 know (stdoutput
->output_has_begun
== true);
2153 know (sec
->filepos
!= 0);
2155 if (! bfd_ecoff_write_debug (stdoutput
, &debug
, debug_swap
,
2157 as_fatal (_("could not write .mdebug section: %s"),
2158 bfd_errmsg (bfd_get_error ()));
2160 #endif /* NEED_ECOFF_DEBUG */
2165 /* Heavily plagarized from obj_elf_version. The idea is to emit the
2166 SCO specific identifier in the .notes section to satisfy the SCO
2169 This looks more complicated than it really is. As opposed to the
2170 "obvious" solution, this should handle the cross dev cases
2171 correctly. (i.e, hosting on a 64 bit big endian processor, but
2172 generating SCO Elf code) Efficiency isn't a concern, as there
2173 should be exactly one of these sections per object module.
2175 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
2178 int_32 namesz = 4 ; Name size
2179 int_32 descsz = 12 ; Descriptive information
2181 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
2182 int_32 version = (major ver # << 16) | version of tools ;
2183 int_32 source = (tool_id << 16 ) | 1 ;
2184 int_32 info = 0 ; These are set by the SCO tools, but we
2185 don't know enough about the source
2186 environment to set them. SCO ld currently
2187 ignores them, and recommends we set them
2190 #define SCO_MAJOR_VERSION 0x1
2191 #define SCO_MINOR_VERSION 0x1
2201 asection
*seg
= now_seg
;
2202 subsegT subseg
= now_subseg
;
2203 Elf_Internal_Note i_note
;
2204 Elf_External_Note e_note
;
2205 asection
*note_secp
= (asection
*) NULL
;
2208 /* create the .note section */
2210 note_secp
= subseg_new (".note", 0);
2211 bfd_set_section_flags (stdoutput
,
2213 SEC_HAS_CONTENTS
| SEC_READONLY
);
2215 /* process the version string */
2218 i_note
.descsz
= 12; /* 12 descriptive bytes */
2219 i_note
.type
= NT_VERSION
; /* Contains a version string */
2221 p
= frag_more (sizeof (i_note
.namesz
));
2222 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
2224 p
= frag_more (sizeof (i_note
.descsz
));
2225 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
2227 p
= frag_more (sizeof (i_note
.type
));
2228 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
2233 /* Note: this is the version number of the ELF we're representing */
2235 md_number_to_chars (p
, (SCO_MAJOR_VERSION
<< 16) | (SCO_MINOR_VERSION
), 4);
2237 /* Here, we pick a magic number for ourselves (yes, I "registered"
2238 it with SCO. The bottom bit shows that we are compat with the
2241 md_number_to_chars (p
, 0x4c520000 | 0x0001, 4);
2243 /* If we knew (or cared) what the source language options were, we'd
2244 fill them in here. SCO has given us permission to ignore these
2245 and just set them to zero. */
2247 md_number_to_chars (p
, 0x0000, 4);
2249 frag_align (2, 0, 0);
2251 /* We probably can't restore the current segment, for there likely
2254 subseg_set (seg
, subseg
);
2258 #endif /* SCO_ELF */
2261 elf_separate_stab_sections ()
2263 #ifdef NEED_ECOFF_DEBUG
2264 return (!ECOFF_DEBUGGING
);
2271 elf_init_stab_section (seg
)
2274 #ifdef NEED_ECOFF_DEBUG
2275 if (!ECOFF_DEBUGGING
)
2277 obj_elf_init_stab_section (seg
);
2280 const struct format_ops elf_format_ops
=
2282 bfd_target_elf_flavour
,
2283 0, /* dfl_leading_underscore */
2284 1, /* emit_section_symbols */
2289 elf_frob_file_before_adjust
,
2290 elf_frob_file_after_relocs
,
2291 elf_s_get_size
, elf_s_set_size
,
2292 elf_s_get_align
, elf_s_set_align
,
2299 elf_copy_symbol_attributes
,
2300 #ifdef NEED_ECOFF_DEBUG
2301 ecoff_generate_asm_lineno
,
2304 0, /* generate_asm_lineno */
2305 0, /* process_stab */
2307 elf_separate_stab_sections
,
2308 elf_init_stab_section
,
2309 elf_sec_sym_ok_for_reloc
,
2311 #ifdef NEED_ECOFF_DEBUG
2314 0, /* ecoff_set_ext */
2316 elf_obj_read_begin_hook
,
2317 elf_obj_symbol_new_hook