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"
27 #include "struc-symbol.h"
29 #ifndef ECOFF_DEBUGGING
30 #define ECOFF_DEBUGGING 0
32 #define NEED_ECOFF_DEBUG
35 #ifdef NEED_ECOFF_DEBUG
40 #include "elf/alpha.h"
55 static bfd_vma elf_s_get_size
PARAMS ((symbolS
*));
56 static void elf_s_set_size
PARAMS ((symbolS
*, bfd_vma
));
57 static bfd_vma elf_s_get_align
PARAMS ((symbolS
*));
58 static void elf_s_set_align
PARAMS ((symbolS
*, bfd_vma
));
59 static void elf_s_set_other
PARAMS ((symbolS
*, int));
60 static int elf_sec_sym_ok_for_reloc
PARAMS ((asection
*));
61 static void adjust_stab_sections
PARAMS ((bfd
*, asection
*, PTR
));
62 static void build_group_lists
PARAMS ((bfd
*, asection
*, PTR
));
63 static int elf_separate_stab_sections
PARAMS ((void));
64 static void elf_init_stab_section
PARAMS ((segT
));
65 static symbolS
*elf_common
PARAMS ((int));
67 #ifdef NEED_ECOFF_DEBUG
68 static bfd_boolean elf_get_extr
PARAMS ((asymbol
*, EXTR
*));
69 static void elf_set_index
PARAMS ((asymbol
*, bfd_size_type
));
72 static void obj_elf_line
PARAMS ((int));
73 void obj_elf_version
PARAMS ((int));
74 static void obj_elf_size
PARAMS ((int));
75 static void obj_elf_type
PARAMS ((int));
76 static void obj_elf_ident
PARAMS ((int));
77 static void obj_elf_weak
PARAMS ((int));
78 static void obj_elf_local
PARAMS ((int));
79 static void obj_elf_visibility
PARAMS ((int));
80 static int obj_elf_parse_section_letters
PARAMS ((char *, size_t));
81 static int obj_elf_section_word
PARAMS ((char *, size_t));
82 static char *obj_elf_section_name
PARAMS ((void));
83 static int obj_elf_section_type
PARAMS ((char *, size_t));
84 static void obj_elf_symver
PARAMS ((int));
85 static void obj_elf_subsection
PARAMS ((int));
86 static void obj_elf_popsection
PARAMS ((int));
87 static void obj_elf_tls_common
PARAMS ((int));
89 static const pseudo_typeS elf_pseudo_table
[] =
91 {"comm", obj_elf_common
, 0},
92 {"common", obj_elf_common
, 1},
93 {"ident", obj_elf_ident
, 0},
94 {"local", obj_elf_local
, 0},
95 {"previous", obj_elf_previous
, 0},
96 {"section", obj_elf_section
, 0},
97 {"section.s", obj_elf_section
, 0},
98 {"sect", obj_elf_section
, 0},
99 {"sect.s", obj_elf_section
, 0},
100 {"pushsection", obj_elf_section
, 1},
101 {"popsection", obj_elf_popsection
, 0},
102 {"size", obj_elf_size
, 0},
103 {"type", obj_elf_type
, 0},
104 {"version", obj_elf_version
, 0},
105 {"weak", obj_elf_weak
, 0},
107 /* These define symbol visibility. */
108 {"internal", obj_elf_visibility
, STV_INTERNAL
},
109 {"hidden", obj_elf_visibility
, STV_HIDDEN
},
110 {"protected", obj_elf_visibility
, STV_PROTECTED
},
112 /* These are used for stabs-in-elf configurations. */
113 {"line", obj_elf_line
, 0},
115 /* This is a GNU extension to handle symbol versions. */
116 {"symver", obj_elf_symver
, 0},
118 /* A GNU extension to change subsection only. */
119 {"subsection", obj_elf_subsection
, 0},
121 /* These are GNU extensions to aid in garbage collecting C++ vtables. */
122 {"vtable_inherit", (void (*) PARAMS ((int))) &obj_elf_vtable_inherit
, 0},
123 {"vtable_entry", (void (*) PARAMS ((int))) &obj_elf_vtable_entry
, 0},
125 /* These are used for dwarf. */
130 /* We need to trap the section changing calls to handle .previous. */
131 {"data", obj_elf_data
, 0},
132 {"text", obj_elf_text
, 0},
134 {"tls_common", obj_elf_tls_common
, 0},
140 static const pseudo_typeS ecoff_debug_pseudo_table
[] =
142 #ifdef NEED_ECOFF_DEBUG
143 /* COFF style debugging information for ECOFF. .ln is not used; .loc
145 { "def", ecoff_directive_def
, 0 },
146 { "dim", ecoff_directive_dim
, 0 },
147 { "endef", ecoff_directive_endef
, 0 },
148 { "file", ecoff_directive_file
, 0 },
149 { "scl", ecoff_directive_scl
, 0 },
150 { "tag", ecoff_directive_tag
, 0 },
151 { "val", ecoff_directive_val
, 0 },
153 /* COFF debugging requires pseudo-ops .size and .type, but ELF
154 already has meanings for those. We use .esize and .etype
155 instead. These are only generated by gcc anyhow. */
156 { "esize", ecoff_directive_size
, 0 },
157 { "etype", ecoff_directive_type
, 0 },
159 /* ECOFF specific debugging information. */
160 { "begin", ecoff_directive_begin
, 0 },
161 { "bend", ecoff_directive_bend
, 0 },
162 { "end", ecoff_directive_end
, 0 },
163 { "ent", ecoff_directive_ent
, 0 },
164 { "fmask", ecoff_directive_fmask
, 0 },
165 { "frame", ecoff_directive_frame
, 0 },
166 { "loc", ecoff_directive_loc
, 0 },
167 { "mask", ecoff_directive_mask
, 0 },
169 /* Other ECOFF directives. */
170 { "extern", ecoff_directive_extern
, 0 },
172 /* These are used on Irix. I don't know how to implement them. */
173 { "alias", s_ignore
, 0 },
174 { "bgnb", s_ignore
, 0 },
175 { "endb", s_ignore
, 0 },
176 { "lab", s_ignore
, 0 },
177 { "noalias", s_ignore
, 0 },
178 { "verstamp", s_ignore
, 0 },
179 { "vreg", s_ignore
, 0 },
182 {NULL
, NULL
, 0} /* end sentinel */
186 #include "aout/aout64.h"
188 /* This is called when the assembler starts. */
193 /* Add symbols for the known sections to the symbol table. */
194 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
195 TEXT_SECTION_NAME
)));
196 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
197 DATA_SECTION_NAME
)));
198 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
205 pop_insert (elf_pseudo_table
);
207 pop_insert (ecoff_debug_pseudo_table
);
214 return S_GET_SIZE (sym
);
218 elf_s_set_size (sym
, sz
)
222 S_SET_SIZE (sym
, sz
);
226 elf_s_get_align (sym
)
229 return S_GET_ALIGN (sym
);
233 elf_s_set_align (sym
, align
)
237 S_SET_ALIGN (sym
, align
);
241 elf_s_get_other (sym
)
244 return elf_symbol (symbol_get_bfdsym (sym
))->internal_elf_sym
.st_other
;
248 elf_s_set_other (sym
, other
)
252 S_SET_OTHER (sym
, other
);
256 elf_sec_sym_ok_for_reloc (sec
)
259 return obj_sec_sym_ok_for_reloc (sec
);
268 sym
= symbol_new (s
, absolute_section
, (valueT
) 0, (struct frag
*) 0);
269 symbol_set_frag (sym
, &zero_address_frag
);
270 symbol_get_bfdsym (sym
)->flags
|= BSF_FILE
;
272 if (symbol_rootP
!= sym
)
274 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
275 symbol_insert (sym
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
277 verify_symbol_chain (symbol_rootP
, symbol_lastP
);
281 #ifdef NEED_ECOFF_DEBUG
287 elf_common (is_common
)
297 if (flag_mri
&& is_common
)
303 name
= input_line_pointer
;
304 c
= get_symbol_end ();
305 /* just after name is now '\0' */
306 p
= input_line_pointer
;
309 if (*input_line_pointer
!= ',')
311 as_bad (_("expected comma after symbol-name"));
312 ignore_rest_of_line ();
315 input_line_pointer
++; /* skip ',' */
316 if ((temp
= get_absolute_expression ()) < 0)
318 as_bad (_(".COMMon length (%d.) <0! Ignored."), temp
);
319 ignore_rest_of_line ();
324 symbolP
= symbol_find_or_make (name
);
326 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
328 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP
));
329 ignore_rest_of_line ();
332 if (S_GET_VALUE (symbolP
) != 0)
334 if (S_GET_VALUE (symbolP
) != (valueT
) size
)
336 as_warn (_("length of .comm \"%s\" is already %ld; not changed to %d"),
337 S_GET_NAME (symbolP
), (long) S_GET_VALUE (symbolP
), size
);
340 know (symbolP
->sy_frag
== &zero_address_frag
);
341 if (*input_line_pointer
!= ',')
346 input_line_pointer
++;
349 if (! have_align
|| *input_line_pointer
!= '"')
355 temp
= get_absolute_expression ();
359 as_warn (_("common alignment negative; 0 assumed"));
362 if (symbol_get_obj (symbolP
)->local
)
371 old_subsec
= now_subseg
;
374 /* convert to a power of 2 alignment */
375 for (align
= 0; (temp
& 1) == 0; temp
>>= 1, ++align
);
378 as_bad (_("common alignment not a power of 2"));
379 ignore_rest_of_line ();
385 record_alignment (bss_section
, align
);
386 subseg_set (bss_section
, 0);
388 frag_align (align
, 0, 0);
389 if (S_GET_SEGMENT (symbolP
) == bss_section
)
390 symbol_get_frag (symbolP
)->fr_symbol
= 0;
391 symbol_set_frag (symbolP
, frag_now
);
392 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
,
393 (offsetT
) size
, (char *) 0);
395 S_SET_SIZE (symbolP
, size
);
396 S_SET_SEGMENT (symbolP
, bss_section
);
397 S_CLEAR_EXTERNAL (symbolP
);
398 subseg_set (old_sec
, old_subsec
);
403 S_SET_VALUE (symbolP
, (valueT
) size
);
404 S_SET_ALIGN (symbolP
, temp
);
405 S_SET_EXTERNAL (symbolP
);
406 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
411 input_line_pointer
++;
412 /* @@ Some use the dot, some don't. Can we get some consistency?? */
413 if (*input_line_pointer
== '.')
414 input_line_pointer
++;
415 /* @@ Some say data, some say bss. */
416 if (strncmp (input_line_pointer
, "bss\"", 4)
417 && strncmp (input_line_pointer
, "data\"", 5))
419 while (*--input_line_pointer
!= '"')
421 input_line_pointer
--;
422 goto bad_common_segment
;
424 while (*input_line_pointer
++ != '"')
426 goto allocate_common
;
429 symbol_get_bfdsym (symbolP
)->flags
|= BSF_OBJECT
;
431 demand_empty_rest_of_line ();
436 p
= input_line_pointer
;
437 while (*p
&& *p
!= '\n')
441 as_bad (_("bad .common segment %s"), input_line_pointer
+ 1);
443 input_line_pointer
= p
;
444 ignore_rest_of_line ();
450 obj_elf_common (is_common
)
453 elf_common (is_common
);
457 obj_elf_tls_common (ignore
)
458 int ignore ATTRIBUTE_UNUSED
;
460 symbolS
*symbolP
= elf_common (0);
463 symbol_get_bfdsym (symbolP
)->flags
|= BSF_THREAD_LOCAL
;
467 obj_elf_local (ignore
)
468 int ignore ATTRIBUTE_UNUSED
;
476 name
= input_line_pointer
;
477 c
= get_symbol_end ();
478 symbolP
= symbol_find_or_make (name
);
479 *input_line_pointer
= c
;
481 S_CLEAR_EXTERNAL (symbolP
);
482 symbol_get_obj (symbolP
)->local
= 1;
485 input_line_pointer
++;
487 if (*input_line_pointer
== '\n')
492 demand_empty_rest_of_line ();
496 obj_elf_weak (ignore
)
497 int ignore ATTRIBUTE_UNUSED
;
505 name
= input_line_pointer
;
506 c
= get_symbol_end ();
507 symbolP
= symbol_find_or_make (name
);
508 *input_line_pointer
= c
;
510 S_SET_WEAK (symbolP
);
511 symbol_get_obj (symbolP
)->local
= 1;
514 input_line_pointer
++;
516 if (*input_line_pointer
== '\n')
521 demand_empty_rest_of_line ();
525 obj_elf_visibility (visibility
)
532 elf_symbol_type
*elfsym
;
536 name
= input_line_pointer
;
537 c
= get_symbol_end ();
538 symbolP
= symbol_find_or_make (name
);
539 *input_line_pointer
= c
;
543 bfdsym
= symbol_get_bfdsym (symbolP
);
544 elfsym
= elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
548 elfsym
->internal_elf_sym
.st_other
&= ~3;
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 #if defined (TC_HPPA) && !defined (TE_LINUX) && TARGET_ARCH_SIZE == 64
613 { ".fini", SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
614 { ".init", SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
616 { ".fini", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
617 { ".init", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
619 { ".line", SHT_PROGBITS
, 0 },
620 { ".note", SHT_NOTE
, 0 },
621 { ".rodata", SHT_PROGBITS
, SHF_ALLOC
},
622 { ".rodata1", SHT_PROGBITS
, SHF_ALLOC
},
623 { ".tbss", SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
624 { ".tdata", SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
625 { ".text", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
626 { ".init_array",SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
627 { ".fini_array",SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
628 { ".preinit_array",SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
630 #ifdef ELF_TC_SPECIAL_SECTIONS
631 ELF_TC_SPECIAL_SECTIONS
635 /* The following section names are special, but they can not
636 reasonably appear in assembler code. Some of the attributes are
637 processor dependent. */
638 { ".dynamic", SHT_DYNAMIC
, SHF_ALLOC
/* + SHF_WRITE */ },
639 { ".dynstr", SHT_STRTAB
, SHF_ALLOC
},
640 { ".dynsym", SHT_DYNSYM
, SHF_ALLOC
},
641 { ".got", SHT_PROGBITS
, 0 },
642 { ".hash", SHT_HASH
, SHF_ALLOC
},
643 { ".interp", SHT_PROGBITS
, /* SHF_ALLOC */ },
644 { ".plt", SHT_PROGBITS
, 0 },
645 { ".shstrtab",SHT_STRTAB
, 0 },
646 { ".strtab", SHT_STRTAB
, /* SHF_ALLOC */ },
647 { ".symtab", SHT_SYMTAB
, /* SHF_ALLOC */ },
654 obj_elf_change_section (name
, type
, attr
, entsize
, group_name
, linkonce
, push
)
659 const char *group_name
;
668 #ifdef md_flush_pending_output
669 md_flush_pending_output ();
672 /* Switch to the section, creating it if necessary. */
675 struct section_stack
*elt
;
676 elt
= xmalloc (sizeof (struct section_stack
));
677 elt
->next
= section_stack
;
679 elt
->prev_seg
= previous_section
;
680 elt
->subseg
= now_subseg
;
681 elt
->prev_subseg
= previous_subsection
;
684 previous_section
= now_seg
;
685 previous_subsection
= now_subseg
;
687 old_sec
= bfd_get_section_by_name (stdoutput
, name
);
688 sec
= subseg_new (name
, 0);
690 /* See if this is one of the special sections. */
691 for (i
= 0; special_sections
[i
].name
!= NULL
; i
++)
692 if (strcmp (name
, special_sections
[i
].name
) == 0)
694 if (type
== SHT_NULL
)
695 type
= special_sections
[i
].type
;
696 else if (type
!= special_sections
[i
].type
)
699 /* FIXME: gcc, as of 2002-10-22, will emit
701 .section .init_array,"aw",@progbits
703 for __attribute__ ((section (".init_array"))).
704 "@progbits" is incorrect. */
705 && special_sections
[i
].type
!= SHT_INIT_ARRAY
706 && special_sections
[i
].type
!= SHT_FINI_ARRAY
707 && special_sections
[i
].type
!= SHT_PREINIT_ARRAY
)
709 as_warn (_("setting incorrect section type for %s"), name
);
713 as_warn (_("ignoring incorrect section type for %s"), name
);
714 type
= special_sections
[i
].type
;
717 if ((attr
&~ special_sections
[i
].attributes
) != 0
720 /* As a GNU extension, we permit a .note section to be
721 allocatable. If the linker sees an allocateable .note
722 section, it will create a PT_NOTE segment in the output
724 if (strcmp (name
, ".note") != 0
725 || attr
!= SHF_ALLOC
)
726 as_warn (_("setting incorrect section attributes for %s"),
729 attr
|= special_sections
[i
].attributes
;
733 /* Convert ELF type and flags to BFD flags. */
735 | ((attr
& SHF_WRITE
) ? 0 : SEC_READONLY
)
736 | ((attr
& SHF_ALLOC
) ? SEC_ALLOC
: 0)
737 | (((attr
& SHF_ALLOC
) && type
!= SHT_NOBITS
) ? SEC_LOAD
: 0)
738 | ((attr
& SHF_EXECINSTR
) ? SEC_CODE
: 0)
739 | ((attr
& SHF_MERGE
) ? SEC_MERGE
: 0)
740 | ((attr
& SHF_STRINGS
) ? SEC_STRINGS
: 0)
741 | ((attr
& SHF_TLS
) ? SEC_THREAD_LOCAL
: 0));
742 #ifdef md_elf_section_flags
743 flags
= md_elf_section_flags (flags
, attr
, type
);
750 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */
751 if (type
== SHT_NOBITS
)
752 seg_info (sec
)->bss
= 1;
754 bfd_set_section_flags (stdoutput
, sec
, flags
);
755 if (flags
& SEC_MERGE
)
756 sec
->entsize
= entsize
;
757 elf_group_name (sec
) = group_name
;
758 elf_linkonce_p (sec
) = linkonce
;
760 /* Add a symbol for this section to the symbol table. */
761 secsym
= symbol_find (name
);
763 symbol_set_bfdsym (secsym
, sec
->symbol
);
765 symbol_table_insert (section_symbol (sec
));
769 /* If section attributes are specified the second time we see a
770 particular section, then check that they are the same as we
771 saw the first time. */
772 if (((old_sec
->flags
^ flags
)
773 & (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
774 | SEC_EXCLUDE
| SEC_SORT_ENTRIES
| SEC_MERGE
| SEC_STRINGS
776 || linkonce
!= elf_linkonce_p (sec
))
777 as_warn (_("ignoring changed section attributes for %s"), name
);
778 if ((flags
& SEC_MERGE
) && old_sec
->entsize
!= (unsigned) entsize
)
779 as_warn (_("ignoring changed section entity size for %s"), name
);
780 if ((attr
& SHF_GROUP
) != 0
781 && strcmp (elf_group_name (old_sec
), group_name
) != 0)
782 as_warn (_("ignoring new section group for %s"), name
);
785 #ifdef md_elf_section_change_hook
786 md_elf_section_change_hook ();
791 obj_elf_parse_section_letters (str
, len
)
808 attr
|= SHF_EXECINSTR
;
824 if (*(str
- 1) == 'a')
827 if (len
> 1 && str
[1] == 's')
836 char *bad_msg
= _("unrecognized .section attribute: want a,w,x,M,S,G,T");
837 #ifdef md_elf_section_letter
838 int md_attr
= md_elf_section_letter (*str
, &bad_msg
);
844 as_warn ("%s", bad_msg
);
857 obj_elf_section_word (str
, len
)
861 if (len
== 5 && strncmp (str
, "write", 5) == 0)
863 if (len
== 5 && strncmp (str
, "alloc", 5) == 0)
865 if (len
== 9 && strncmp (str
, "execinstr", 9) == 0)
866 return SHF_EXECINSTR
;
868 #ifdef md_elf_section_word
870 int md_attr
= md_elf_section_word (str
, len
);
876 as_warn (_("unrecognized section attribute"));
881 obj_elf_section_type (str
, len
)
885 if (len
== 8 && strncmp (str
, "progbits", 8) == 0)
887 if (len
== 6 && strncmp (str
, "nobits", 6) == 0)
890 #ifdef md_elf_section_type
892 int md_type
= md_elf_section_type (str
, len
);
898 as_warn (_("unrecognized section type"));
902 /* Get name of section. */
904 obj_elf_section_name ()
909 if (*input_line_pointer
== '"')
913 name
= demand_copy_C_string (&dummy
);
916 ignore_rest_of_line ();
922 char *end
= input_line_pointer
;
924 while (0 == strchr ("\n\t,; ", *end
))
926 if (end
== input_line_pointer
)
928 as_warn (_("missing name"));
929 ignore_rest_of_line ();
933 name
= xmalloc (end
- input_line_pointer
+ 1);
934 memcpy (name
, input_line_pointer
, end
- input_line_pointer
);
935 name
[end
- input_line_pointer
] = '\0';
936 input_line_pointer
= end
;
943 obj_elf_section (push
)
946 char *name
, *group_name
, *beg
;
947 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 ();
982 if (*input_line_pointer
== ',')
984 /* Skip the comma. */
985 ++input_line_pointer
;
988 if (*input_line_pointer
== '"')
990 beg
= demand_copy_C_string (&dummy
);
993 ignore_rest_of_line ();
996 attr
|= obj_elf_parse_section_letters (beg
, strlen (beg
));
999 if (*input_line_pointer
== ',')
1002 char *save
= input_line_pointer
;
1004 ++input_line_pointer
;
1006 c
= *input_line_pointer
;
1009 beg
= demand_copy_C_string (&dummy
);
1012 ignore_rest_of_line ();
1015 type
= obj_elf_section_type (beg
, strlen (beg
));
1017 else if (c
== '@' || c
== '%')
1019 beg
= ++input_line_pointer
;
1020 c
= get_symbol_end ();
1021 *input_line_pointer
= c
;
1022 type
= obj_elf_section_type (beg
, input_line_pointer
- beg
);
1025 input_line_pointer
= save
;
1029 if ((attr
& SHF_MERGE
) != 0 && *input_line_pointer
== ',')
1031 ++input_line_pointer
;
1033 entsize
= get_absolute_expression ();
1037 as_warn (_("invalid merge entity size"));
1042 else if ((attr
& SHF_MERGE
) != 0)
1044 as_warn (_("entity size for SHF_MERGE not specified"));
1048 if ((attr
& SHF_GROUP
) != 0 && *input_line_pointer
== ',')
1050 ++input_line_pointer
;
1051 group_name
= obj_elf_section_name ();
1052 if (group_name
== NULL
)
1054 else if (strncmp (input_line_pointer
, ",comdat", 7) == 0)
1056 input_line_pointer
+= 7;
1059 else if (strncmp (name
, ".gnu.linkonce", 13) == 0)
1062 else if ((attr
& SHF_GROUP
) != 0)
1064 as_warn (_("group name for SHF_GROUP not specified"));
1075 if (*input_line_pointer
!= '#')
1077 as_warn (_("character following name is not '#'"));
1078 ignore_rest_of_line ();
1081 beg
= ++input_line_pointer
;
1082 c
= get_symbol_end ();
1083 *input_line_pointer
= c
;
1085 attr
|= obj_elf_section_word (beg
, input_line_pointer
- beg
);
1089 while (*input_line_pointer
++ == ',');
1090 --input_line_pointer
;
1094 demand_empty_rest_of_line ();
1096 obj_elf_change_section (name
, type
, attr
, entsize
, group_name
, linkonce
, push
);
1099 /* Change to the .data section. */
1105 #ifdef md_flush_pending_output
1106 md_flush_pending_output ();
1109 previous_section
= now_seg
;
1110 previous_subsection
= now_subseg
;
1113 #ifdef md_elf_section_change_hook
1114 md_elf_section_change_hook ();
1118 /* Change to the .text section. */
1124 #ifdef md_flush_pending_output
1125 md_flush_pending_output ();
1128 previous_section
= now_seg
;
1129 previous_subsection
= now_subseg
;
1132 #ifdef md_elf_section_change_hook
1133 md_elf_section_change_hook ();
1138 obj_elf_subsection (ignore
)
1139 int ignore ATTRIBUTE_UNUSED
;
1143 #ifdef md_flush_pending_output
1144 md_flush_pending_output ();
1147 previous_section
= now_seg
;
1148 previous_subsection
= now_subseg
;
1150 temp
= get_absolute_expression ();
1151 subseg_set (now_seg
, (subsegT
) temp
);
1152 demand_empty_rest_of_line ();
1154 #ifdef md_elf_section_change_hook
1155 md_elf_section_change_hook ();
1159 /* This can be called from the processor backends if they change
1163 obj_elf_section_change_hook ()
1165 previous_section
= now_seg
;
1166 previous_subsection
= now_subseg
;
1170 obj_elf_previous (ignore
)
1171 int ignore ATTRIBUTE_UNUSED
;
1176 if (previous_section
== 0)
1178 as_warn (_(".previous without corresponding .section; ignored"));
1182 #ifdef md_flush_pending_output
1183 md_flush_pending_output ();
1186 new_section
= previous_section
;
1187 new_subsection
= previous_subsection
;
1188 previous_section
= now_seg
;
1189 previous_subsection
= now_subseg
;
1190 subseg_set (new_section
, new_subsection
);
1192 #ifdef md_elf_section_change_hook
1193 md_elf_section_change_hook ();
1198 obj_elf_popsection (xxx
)
1199 int xxx ATTRIBUTE_UNUSED
;
1201 struct section_stack
*top
= section_stack
;
1205 as_warn (_(".popsection without corresponding .pushsection; ignored"));
1209 #ifdef md_flush_pending_output
1210 md_flush_pending_output ();
1213 section_stack
= top
->next
;
1214 previous_section
= top
->prev_seg
;
1215 previous_subsection
= top
->prev_subseg
;
1216 subseg_set (top
->seg
, top
->subseg
);
1219 #ifdef md_elf_section_change_hook
1220 md_elf_section_change_hook ();
1225 obj_elf_line (ignore
)
1226 int ignore ATTRIBUTE_UNUSED
;
1228 /* Assume delimiter is part of expression. BSD4.2 as fails with
1229 delightful bug, so we are not being incompatible here. */
1230 new_logical_line ((char *) NULL
, (int) (get_absolute_expression ()));
1231 demand_empty_rest_of_line ();
1234 /* This handles the .symver pseudo-op, which is used to specify a
1235 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1236 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1237 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1238 with the same value as the symbol NAME. */
1241 obj_elf_symver (ignore
)
1242 int ignore ATTRIBUTE_UNUSED
;
1249 name
= input_line_pointer
;
1250 c
= get_symbol_end ();
1252 sym
= symbol_find_or_make (name
);
1254 *input_line_pointer
= c
;
1257 if (*input_line_pointer
!= ',')
1259 as_bad (_("expected comma after name in .symver"));
1260 ignore_rest_of_line ();
1264 ++input_line_pointer
;
1265 name
= input_line_pointer
;
1267 /* Temporarily include '@' in symbol names. */
1268 old_lexat
= lex_type
[(unsigned char) '@'];
1269 lex_type
[(unsigned char) '@'] |= LEX_NAME
;
1270 c
= get_symbol_end ();
1271 lex_type
[(unsigned char) '@'] = old_lexat
;
1273 if (symbol_get_obj (sym
)->versioned_name
== NULL
)
1275 symbol_get_obj (sym
)->versioned_name
= xstrdup (name
);
1277 *input_line_pointer
= c
;
1279 if (strchr (symbol_get_obj (sym
)->versioned_name
,
1280 ELF_VER_CHR
) == NULL
)
1282 as_bad (_("missing version name in `%s' for symbol `%s'"),
1283 symbol_get_obj (sym
)->versioned_name
,
1285 ignore_rest_of_line ();
1291 if (strcmp (symbol_get_obj (sym
)->versioned_name
, name
))
1293 as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1294 name
, symbol_get_obj (sym
)->versioned_name
,
1296 ignore_rest_of_line ();
1300 *input_line_pointer
= c
;
1303 demand_empty_rest_of_line ();
1306 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1307 to the linker the hierarchy in which a particular table resides. The
1308 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1311 obj_elf_vtable_inherit (ignore
)
1312 int ignore ATTRIBUTE_UNUSED
;
1314 char *cname
, *pname
;
1315 symbolS
*csym
, *psym
;
1318 if (*input_line_pointer
== '#')
1319 ++input_line_pointer
;
1321 cname
= input_line_pointer
;
1322 c
= get_symbol_end ();
1323 csym
= symbol_find (cname
);
1325 /* GCFIXME: should check that we don't have two .vtable_inherits for
1326 the same child symbol. Also, we can currently only do this if the
1327 child symbol is already exists and is placed in a fragment. */
1329 if (csym
== NULL
|| symbol_get_frag (csym
) == NULL
)
1331 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1336 *input_line_pointer
= c
;
1339 if (*input_line_pointer
!= ',')
1341 as_bad ("expected comma after name in .vtable_inherit");
1342 ignore_rest_of_line ();
1346 ++input_line_pointer
;
1349 if (*input_line_pointer
== '#')
1350 ++input_line_pointer
;
1352 if (input_line_pointer
[0] == '0'
1353 && (input_line_pointer
[1] == '\0'
1354 || ISSPACE (input_line_pointer
[1])))
1356 psym
= section_symbol (absolute_section
);
1357 ++input_line_pointer
;
1361 pname
= input_line_pointer
;
1362 c
= get_symbol_end ();
1363 psym
= symbol_find_or_make (pname
);
1364 *input_line_pointer
= c
;
1367 demand_empty_rest_of_line ();
1372 assert (symbol_get_value_expression (csym
)->X_op
== O_constant
);
1373 return fix_new (symbol_get_frag (csym
),
1374 symbol_get_value_expression (csym
)->X_add_number
,
1375 0, psym
, 0, 0, BFD_RELOC_VTABLE_INHERIT
);
1378 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1379 to the linker that a vtable slot was used. The syntax is
1380 ".vtable_entry tablename, offset". */
1383 obj_elf_vtable_entry (ignore
)
1384 int ignore ATTRIBUTE_UNUSED
;
1391 if (*input_line_pointer
== '#')
1392 ++input_line_pointer
;
1394 name
= input_line_pointer
;
1395 c
= get_symbol_end ();
1396 sym
= symbol_find_or_make (name
);
1397 *input_line_pointer
= c
;
1400 if (*input_line_pointer
!= ',')
1402 as_bad ("expected comma after name in .vtable_entry");
1403 ignore_rest_of_line ();
1407 ++input_line_pointer
;
1408 if (*input_line_pointer
== '#')
1409 ++input_line_pointer
;
1411 offset
= get_absolute_expression ();
1413 demand_empty_rest_of_line ();
1415 return fix_new (frag_now
, frag_now_fix (), 0, sym
, offset
, 0,
1416 BFD_RELOC_VTABLE_ENTRY
);
1420 elf_obj_read_begin_hook ()
1422 #ifdef NEED_ECOFF_DEBUG
1423 if (ECOFF_DEBUGGING
)
1424 ecoff_read_begin_hook ();
1429 elf_obj_symbol_new_hook (symbolP
)
1432 struct elf_obj_sy
*sy_obj
;
1434 sy_obj
= symbol_get_obj (symbolP
);
1435 sy_obj
->size
= NULL
;
1436 sy_obj
->versioned_name
= NULL
;
1438 #ifdef NEED_ECOFF_DEBUG
1439 if (ECOFF_DEBUGGING
)
1440 ecoff_symbol_new_hook (symbolP
);
1444 /* When setting one symbol equal to another, by default we probably
1445 want them to have the same "size", whatever it means in the current
1449 elf_copy_symbol_attributes (dest
, src
)
1450 symbolS
*dest
, *src
;
1452 struct elf_obj_sy
*srcelf
= symbol_get_obj (src
);
1453 struct elf_obj_sy
*destelf
= symbol_get_obj (dest
);
1456 if (destelf
->size
== NULL
)
1458 (expressionS
*) xmalloc (sizeof (expressionS
));
1459 *destelf
->size
= *srcelf
->size
;
1463 if (destelf
->size
!= NULL
)
1464 free (destelf
->size
);
1465 destelf
->size
= NULL
;
1467 S_SET_SIZE (dest
, S_GET_SIZE (src
));
1468 /* Don't copy visibility. */
1469 S_SET_OTHER (dest
, (ELF_ST_VISIBILITY (S_GET_OTHER (dest
))
1470 | (S_GET_OTHER (src
) & ~ELF_ST_VISIBILITY (-1))));
1474 obj_elf_version (ignore
)
1475 int ignore ATTRIBUTE_UNUSED
;
1480 asection
*seg
= now_seg
;
1481 subsegT subseg
= now_subseg
;
1482 Elf_Internal_Note i_note
;
1483 Elf_External_Note e_note
;
1484 asection
*note_secp
= (asection
*) NULL
;
1488 if (*input_line_pointer
== '\"')
1490 ++input_line_pointer
; /* -> 1st char of string. */
1491 name
= input_line_pointer
;
1493 while (is_a_char (c
= next_char_of_string ()))
1495 c
= *input_line_pointer
;
1496 *input_line_pointer
= '\0';
1497 *(input_line_pointer
- 1) = '\0';
1498 *input_line_pointer
= c
;
1500 /* create the .note section */
1502 note_secp
= subseg_new (".note", 0);
1503 bfd_set_section_flags (stdoutput
,
1505 SEC_HAS_CONTENTS
| SEC_READONLY
);
1507 /* process the version string */
1509 len
= strlen (name
);
1511 i_note
.namesz
= ((len
+ 1) + 3) & ~3; /* round this to word boundary */
1512 i_note
.descsz
= 0; /* no description */
1513 i_note
.type
= NT_VERSION
;
1514 p
= frag_more (sizeof (e_note
.namesz
));
1515 md_number_to_chars (p
, (valueT
) i_note
.namesz
, sizeof (e_note
.namesz
));
1516 p
= frag_more (sizeof (e_note
.descsz
));
1517 md_number_to_chars (p
, (valueT
) i_note
.descsz
, sizeof (e_note
.descsz
));
1518 p
= frag_more (sizeof (e_note
.type
));
1519 md_number_to_chars (p
, (valueT
) i_note
.type
, sizeof (e_note
.type
));
1520 p
= frag_more (len
+ 1);
1523 frag_align (2, 0, 0);
1525 subseg_set (seg
, subseg
);
1529 as_bad (_("expected quoted string"));
1531 demand_empty_rest_of_line ();
1535 obj_elf_size (ignore
)
1536 int ignore ATTRIBUTE_UNUSED
;
1538 char *name
= input_line_pointer
;
1539 char c
= get_symbol_end ();
1544 p
= input_line_pointer
;
1547 if (*input_line_pointer
!= ',')
1550 as_bad (_("expected comma after name `%s' in .size directive"), name
);
1552 ignore_rest_of_line ();
1555 input_line_pointer
++;
1557 if (exp
.X_op
== O_absent
)
1559 as_bad (_("missing expression in .size directive"));
1560 exp
.X_op
= O_constant
;
1561 exp
.X_add_number
= 0;
1564 sym
= symbol_find_or_make (name
);
1566 if (exp
.X_op
== O_constant
)
1568 S_SET_SIZE (sym
, exp
.X_add_number
);
1569 if (symbol_get_obj (sym
)->size
)
1571 xfree (symbol_get_obj (sym
)->size
);
1572 symbol_get_obj (sym
)->size
= NULL
;
1577 symbol_get_obj (sym
)->size
=
1578 (expressionS
*) xmalloc (sizeof (expressionS
));
1579 *symbol_get_obj (sym
)->size
= exp
;
1581 demand_empty_rest_of_line ();
1584 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1585 There are five syntaxes:
1587 The first (used on Solaris) is
1589 The second (used on UnixWare) is
1591 The third (reportedly to be used on Irix 6.0) is
1593 The fourth (used on NetBSD/Arm and Linux/ARM) is
1595 The fifth (used on SVR4/860) is
1596 .type SYM,"function"
1600 obj_elf_type (ignore
)
1601 int ignore ATTRIBUTE_UNUSED
;
1606 const char *typename
;
1608 elf_symbol_type
*elfsym
;
1610 name
= input_line_pointer
;
1611 c
= get_symbol_end ();
1612 sym
= symbol_find_or_make (name
);
1613 elfsym
= (elf_symbol_type
*) symbol_get_bfdsym (sym
);
1614 *input_line_pointer
= c
;
1617 if (*input_line_pointer
== ',')
1618 ++input_line_pointer
;
1621 if ( *input_line_pointer
== '#'
1622 || *input_line_pointer
== '@'
1623 || *input_line_pointer
== '"'
1624 || *input_line_pointer
== '%')
1625 ++input_line_pointer
;
1627 typename
= input_line_pointer
;
1628 c
= get_symbol_end ();
1631 if (strcmp (typename
, "function") == 0
1632 || strcmp (typename
, "STT_FUNC") == 0)
1633 type
= BSF_FUNCTION
;
1634 else if (strcmp (typename
, "object") == 0
1635 || strcmp (typename
, "STT_OBJECT") == 0)
1637 #ifdef md_elf_symbol_type
1638 else if ((type
= md_elf_symbol_type (typename
, sym
, elfsym
)) != -1)
1642 as_bad (_("unrecognized symbol type \"%s\""), typename
);
1644 *input_line_pointer
= c
;
1646 if (*input_line_pointer
== '"')
1647 ++input_line_pointer
;
1649 elfsym
->symbol
.flags
|= type
;
1651 demand_empty_rest_of_line ();
1655 obj_elf_ident (ignore
)
1656 int ignore ATTRIBUTE_UNUSED
;
1658 static segT comment_section
;
1659 segT old_section
= now_seg
;
1660 int old_subsection
= now_subseg
;
1662 #ifdef md_flush_pending_output
1663 md_flush_pending_output ();
1666 if (!comment_section
)
1669 comment_section
= subseg_new (".comment", 0);
1670 bfd_set_section_flags (stdoutput
, comment_section
,
1671 SEC_READONLY
| SEC_HAS_CONTENTS
);
1676 subseg_set (comment_section
, 0);
1678 subseg_set (old_section
, old_subsection
);
1681 #ifdef INIT_STAB_SECTION
1683 /* The first entry in a .stabs section is special. */
1686 obj_elf_init_stab_section (seg
)
1692 unsigned int stroff
;
1694 /* Force the section to align to a longword boundary. Without this,
1695 UnixWare ar crashes. */
1696 bfd_set_section_alignment (stdoutput
, seg
, 2);
1698 /* Make space for this first symbol. */
1702 as_where (&file
, (unsigned int *) NULL
);
1703 stabstr_name
= (char *) xmalloc (strlen (segment_name (seg
)) + 4);
1704 strcpy (stabstr_name
, segment_name (seg
));
1705 strcat (stabstr_name
, "str");
1706 stroff
= get_stab_string_offset (file
, stabstr_name
);
1708 md_number_to_chars (p
, stroff
, 4);
1709 seg_info (seg
)->stabu
.p
= p
;
1714 /* Fill in the counts in the first entry in a .stabs section. */
1717 adjust_stab_sections (abfd
, sec
, xxx
)
1720 PTR xxx ATTRIBUTE_UNUSED
;
1727 if (strncmp (".stab", sec
->name
, 5))
1729 if (!strcmp ("str", sec
->name
+ strlen (sec
->name
) - 3))
1732 name
= (char *) alloca (strlen (sec
->name
) + 4);
1733 strcpy (name
, sec
->name
);
1734 strcat (name
, "str");
1735 strsec
= bfd_get_section_by_name (abfd
, name
);
1737 strsz
= bfd_section_size (abfd
, strsec
);
1740 nsyms
= bfd_section_size (abfd
, sec
) / 12 - 1;
1742 p
= seg_info (sec
)->stabu
.p
;
1745 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
1746 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
1749 #ifdef NEED_ECOFF_DEBUG
1751 /* This function is called by the ECOFF code. It is supposed to
1752 record the external symbol information so that the backend can
1753 write it out correctly. The ELF backend doesn't actually handle
1754 this at the moment, so we do it ourselves. We save the information
1758 elf_ecoff_set_ext (sym
, ext
)
1760 struct ecoff_extr
*ext
;
1762 symbol_get_bfdsym (sym
)->udata
.p
= (PTR
) ext
;
1765 /* This function is called by bfd_ecoff_debug_externals. It is
1766 supposed to *EXT to the external symbol information, and return
1767 whether the symbol should be used at all. */
1770 elf_get_extr (sym
, ext
)
1774 if (sym
->udata
.p
== NULL
)
1776 *ext
= *(EXTR
*) sym
->udata
.p
;
1780 /* This function is called by bfd_ecoff_debug_externals. It has
1781 nothing to do for ELF. */
1785 elf_set_index (sym
, indx
)
1786 asymbol
*sym ATTRIBUTE_UNUSED
;
1787 bfd_size_type indx ATTRIBUTE_UNUSED
;
1791 #endif /* NEED_ECOFF_DEBUG */
1794 elf_frob_symbol (symp
, puntp
)
1798 struct elf_obj_sy
*sy_obj
;
1800 #ifdef NEED_ECOFF_DEBUG
1801 if (ECOFF_DEBUGGING
)
1802 ecoff_frob_symbol (symp
);
1805 sy_obj
= symbol_get_obj (symp
);
1807 if (sy_obj
->size
!= NULL
)
1809 switch (sy_obj
->size
->X_op
)
1813 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1814 + sy_obj
->size
->X_add_number
1815 - S_GET_VALUE (sy_obj
->size
->X_op_symbol
)));
1819 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1820 + sy_obj
->size
->X_add_number
));
1823 as_bad (_(".size expression too complicated to fix up"));
1826 free (sy_obj
->size
);
1827 sy_obj
->size
= NULL
;
1830 if (sy_obj
->versioned_name
!= NULL
)
1834 p
= strchr (sy_obj
->versioned_name
, ELF_VER_CHR
);
1837 /* This symbol was given a new name with the .symver directive.
1839 If this is an external reference, just rename the symbol to
1840 include the version string. This will make the relocs be
1841 against the correct versioned symbol.
1843 If this is a definition, add an alias. FIXME: Using an alias
1844 will permit the debugging information to refer to the right
1845 symbol. However, it's not clear whether it is the best
1848 if (! S_IS_DEFINED (symp
))
1850 /* Verify that the name isn't using the @@ syntax--this is
1851 reserved for definitions of the default version to link
1853 if (p
[1] == ELF_VER_CHR
)
1855 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1856 sy_obj
->versioned_name
);
1859 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1863 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
1867 /* The @@@ syntax is a special case. It renames the
1868 symbol name to versioned_name with one `@' removed. */
1869 l
= strlen (&p
[3]) + 1;
1870 memmove (&p
[2], &p
[3], l
);
1871 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1877 /* FIXME: Creating a new symbol here is risky. We're
1878 in the final loop over the symbol table. We can
1879 get away with it only because the symbol goes to
1880 the end of the list, where the loop will still see
1881 it. It would probably be better to do this in
1882 obj_frob_file_before_adjust. */
1884 symp2
= symbol_find_or_make (sy_obj
->versioned_name
);
1886 /* Now we act as though we saw symp2 = sym. */
1888 S_SET_SEGMENT (symp2
, S_GET_SEGMENT (symp
));
1890 /* Subtracting out the frag address here is a hack
1891 because we are in the middle of the final loop. */
1894 - symbol_get_frag (symp
)->fr_address
));
1896 symbol_set_frag (symp2
, symbol_get_frag (symp
));
1898 /* This will copy over the size information. */
1899 copy_symbol_attributes (symp2
, symp
);
1901 S_SET_OTHER (symp2
, S_GET_OTHER (symp
));
1903 if (S_IS_WEAK (symp
))
1906 if (S_IS_EXTERNAL (symp
))
1907 S_SET_EXTERNAL (symp2
);
1912 /* Double check weak symbols. */
1913 if (S_IS_WEAK (symp
))
1915 if (S_IS_COMMON (symp
))
1916 as_bad (_("symbol `%s' can not be both weak and common"),
1921 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1922 any undefined non-function symbol to STT_OBJECT. We try to be
1923 compatible, since newer Irix 5 and 6 linkers care. However, we
1924 only set undefined symbols to be STT_OBJECT if we are on Irix,
1925 because that is the only time gcc will generate the necessary
1926 .global directives to mark functions. */
1928 if (S_IS_COMMON (symp
))
1929 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1931 if (strstr (TARGET_OS
, "irix") != NULL
1932 && ! S_IS_DEFINED (symp
)
1933 && (symbol_get_bfdsym (symp
)->flags
& BSF_FUNCTION
) == 0)
1934 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1938 /* If TC_PPC is defined, we used to force the type of a symbol to be
1939 BSF_OBJECT if it was otherwise unset. This was required by some
1940 version of VxWorks. Thomas de Lellis <tdel@windriver.com> says
1941 that this is no longer needed, so it is now commented out. */
1942 if ((symbol_get_bfdsym (symp
)->flags
1943 & (BSF_FUNCTION
| BSF_FILE
| BSF_SECTION_SYM
)) == 0
1944 && S_IS_DEFINED (symp
))
1945 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1951 asection
**head
; /* Section lists. */
1952 unsigned int *elt_count
; /* Number of sections in each list. */
1953 unsigned int num_group
; /* Number of lists. */
1956 /* Called via bfd_map_over_sections. If SEC is a member of a group,
1957 add it to a list of sections belonging to the group. INF is a
1958 pointer to a struct group_list, which is where we store the head of
1962 build_group_lists (abfd
, sec
, inf
)
1963 bfd
*abfd ATTRIBUTE_UNUSED
;
1967 struct group_list
*list
= (struct group_list
*) inf
;
1968 const char *group_name
= elf_group_name (sec
);
1971 if (group_name
== NULL
)
1974 /* If this group already has a list, add the section to the head of
1976 for (i
= 0; i
< list
->num_group
; i
++)
1978 if (strcmp (group_name
, elf_group_name (list
->head
[i
])) == 0)
1980 elf_next_in_group (sec
) = list
->head
[i
];
1981 list
->head
[i
] = sec
;
1982 list
->elt_count
[i
] += 1;
1987 /* New group. Make the arrays bigger in chunks to minimize calls to
1989 i
= list
->num_group
;
1992 unsigned int newsize
= i
+ 128;
1993 list
->head
= xrealloc (list
->head
, newsize
* sizeof (*list
->head
));
1994 list
->elt_count
= xrealloc (list
->elt_count
,
1995 newsize
* sizeof (*list
->elt_count
));
1997 list
->head
[i
] = sec
;
1998 list
->elt_count
[i
] = 1;
1999 list
->num_group
+= 1;
2005 struct group_list list
;
2008 bfd_map_over_sections (stdoutput
, adjust_stab_sections
, (PTR
) 0);
2010 /* Go find section groups. */
2013 list
.elt_count
= NULL
;
2014 bfd_map_over_sections (stdoutput
, build_group_lists
, (PTR
) &list
);
2016 /* Make the SHT_GROUP sections that describe each section group. We
2017 can't set up the section contents here yet, because elf section
2018 indices have yet to be calculated. elf.c:set_group_contents does
2019 the rest of the work. */
2020 for (i
= 0; i
< list
.num_group
; i
++)
2022 const char *group_name
= elf_group_name (list
.head
[i
]);
2023 const char *sec_name
;
2029 flags
= SEC_READONLY
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_GROUP
;
2030 for (s
= list
.head
[i
]; s
!= NULL
; s
= elf_next_in_group (s
))
2031 if (elf_linkonce_p (s
) != ((flags
& SEC_LINK_ONCE
) != 0))
2033 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
2034 if (s
!= list
.head
[i
])
2036 as_warn (_("assuming all members of group `%s' are COMDAT"),
2042 sec_name
= group_name
;
2043 sy
= symbol_find_exact (group_name
);
2046 && (sy
== symbol_lastP
2047 || (sy
->sy_next
!= NULL
2048 && sy
->sy_next
->sy_previous
== sy
)))
2051 sec_name
= ".group";
2053 s
= subseg_force_new (sec_name
, 0);
2055 || !bfd_set_section_flags (stdoutput
, s
, flags
)
2056 || !bfd_set_section_alignment (stdoutput
, s
, 2))
2058 as_fatal (_("can't create group: %s"),
2059 bfd_errmsg (bfd_get_error ()));
2062 /* Pass a pointer to the first section in this group. */
2063 elf_next_in_group (s
) = list
.head
[i
];
2065 elf_group_id (s
) = sy
->bsym
;
2067 s
->_raw_size
= 4 * (list
.elt_count
[i
] + 1);
2068 s
->contents
= frag_more (s
->_raw_size
);
2069 frag_now
->fr_fix
= frag_now_fix_octets ();
2072 #ifdef elf_tc_final_processing
2073 elf_tc_final_processing ();
2077 /* It removes any unneeded versioned symbols from the symbol table. */
2080 elf_frob_file_before_adjust ()
2086 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2087 if (!S_IS_DEFINED (symp
))
2089 if (symbol_get_obj (symp
)->versioned_name
)
2093 /* The @@@ syntax is a special case. If the symbol is
2094 not defined, 2 `@'s will be removed from the
2097 p
= strchr (symbol_get_obj (symp
)->versioned_name
,
2100 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
2102 size_t l
= strlen (&p
[3]) + 1;
2103 memmove (&p
[1], &p
[3], l
);
2105 if (symbol_used_p (symp
) == 0
2106 && symbol_used_in_reloc_p (symp
) == 0)
2107 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2110 /* If there was .weak foo, but foo was neither defined nor
2111 used anywhere, remove it. */
2113 else if (S_IS_WEAK (symp
)
2114 && symbol_used_p (symp
) == 0
2115 && symbol_used_in_reloc_p (symp
) == 0)
2116 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2121 /* It is required that we let write_relocs have the opportunity to
2122 optimize away fixups before output has begun, since it is possible
2123 to eliminate all fixups for a section and thus we never should
2124 have generated the relocation section. */
2127 elf_frob_file_after_relocs ()
2129 #ifdef NEED_ECOFF_DEBUG
2130 if (ECOFF_DEBUGGING
)
2131 /* Generate the ECOFF debugging information. */
2133 const struct ecoff_debug_swap
*debug_swap
;
2134 struct ecoff_debug_info debug
;
2139 = get_elf_backend_data (stdoutput
)->elf_backend_ecoff_debug_swap
;
2140 know (debug_swap
!= (const struct ecoff_debug_swap
*) NULL
);
2141 ecoff_build_debug (&debug
.symbolic_header
, &buf
, debug_swap
);
2143 /* Set up the pointers in debug. */
2144 #define SET(ptr, offset, type) \
2145 debug.ptr = (type) (buf + debug.symbolic_header.offset)
2147 SET (line
, cbLineOffset
, unsigned char *);
2148 SET (external_dnr
, cbDnOffset
, PTR
);
2149 SET (external_pdr
, cbPdOffset
, PTR
);
2150 SET (external_sym
, cbSymOffset
, PTR
);
2151 SET (external_opt
, cbOptOffset
, PTR
);
2152 SET (external_aux
, cbAuxOffset
, union aux_ext
*);
2153 SET (ss
, cbSsOffset
, char *);
2154 SET (external_fdr
, cbFdOffset
, PTR
);
2155 SET (external_rfd
, cbRfdOffset
, PTR
);
2156 /* ssext and external_ext are set up just below. */
2160 /* Set up the external symbols. */
2161 debug
.ssext
= debug
.ssext_end
= NULL
;
2162 debug
.external_ext
= debug
.external_ext_end
= NULL
;
2163 if (! bfd_ecoff_debug_externals (stdoutput
, &debug
, debug_swap
, TRUE
,
2164 elf_get_extr
, elf_set_index
))
2165 as_fatal (_("failed to set up debugging information: %s"),
2166 bfd_errmsg (bfd_get_error ()));
2168 sec
= bfd_get_section_by_name (stdoutput
, ".mdebug");
2169 assert (sec
!= NULL
);
2171 know (!stdoutput
->output_has_begun
);
2173 /* We set the size of the section, call bfd_set_section_contents
2174 to force the ELF backend to allocate a file position, and then
2175 write out the data. FIXME: Is this really the best way to do
2177 sec
->_raw_size
= bfd_ecoff_debug_size (stdoutput
, &debug
, debug_swap
);
2179 /* Pass BUF to bfd_set_section_contents because this will
2180 eventually become a call to fwrite, and ISO C prohibits
2181 passing a NULL pointer to a stdio function even if the
2182 pointer will not be used. */
2183 if (! bfd_set_section_contents (stdoutput
, sec
, (PTR
) buf
,
2184 (file_ptr
) 0, (bfd_size_type
) 0))
2185 as_fatal (_("can't start writing .mdebug section: %s"),
2186 bfd_errmsg (bfd_get_error ()));
2188 know (stdoutput
->output_has_begun
);
2189 know (sec
->filepos
!= 0);
2191 if (! bfd_ecoff_write_debug (stdoutput
, &debug
, debug_swap
,
2193 as_fatal (_("could not write .mdebug section: %s"),
2194 bfd_errmsg (bfd_get_error ()));
2196 #endif /* NEED_ECOFF_DEBUG */
2201 /* Heavily plagarized from obj_elf_version. The idea is to emit the
2202 SCO specific identifier in the .notes section to satisfy the SCO
2205 This looks more complicated than it really is. As opposed to the
2206 "obvious" solution, this should handle the cross dev cases
2207 correctly. (i.e, hosting on a 64 bit big endian processor, but
2208 generating SCO Elf code) Efficiency isn't a concern, as there
2209 should be exactly one of these sections per object module.
2211 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
2214 int_32 namesz = 4 ; Name size
2215 int_32 descsz = 12 ; Descriptive information
2217 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
2218 int_32 version = (major ver # << 16) | version of tools ;
2219 int_32 source = (tool_id << 16 ) | 1 ;
2220 int_32 info = 0 ; These are set by the SCO tools, but we
2221 don't know enough about the source
2222 environment to set them. SCO ld currently
2223 ignores them, and recommends we set them
2226 #define SCO_MAJOR_VERSION 0x1
2227 #define SCO_MINOR_VERSION 0x1
2237 asection
*seg
= now_seg
;
2238 subsegT subseg
= now_subseg
;
2239 Elf_Internal_Note i_note
;
2240 Elf_External_Note e_note
;
2241 asection
*note_secp
= (asection
*) NULL
;
2244 /* create the .note section */
2246 note_secp
= subseg_new (".note", 0);
2247 bfd_set_section_flags (stdoutput
,
2249 SEC_HAS_CONTENTS
| SEC_READONLY
);
2251 /* process the version string */
2254 i_note
.descsz
= 12; /* 12 descriptive bytes */
2255 i_note
.type
= NT_VERSION
; /* Contains a version string */
2257 p
= frag_more (sizeof (i_note
.namesz
));
2258 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
2260 p
= frag_more (sizeof (i_note
.descsz
));
2261 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
2263 p
= frag_more (sizeof (i_note
.type
));
2264 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
2269 /* Note: this is the version number of the ELF we're representing */
2271 md_number_to_chars (p
, (SCO_MAJOR_VERSION
<< 16) | (SCO_MINOR_VERSION
), 4);
2273 /* Here, we pick a magic number for ourselves (yes, I "registered"
2274 it with SCO. The bottom bit shows that we are compat with the
2277 md_number_to_chars (p
, 0x4c520000 | 0x0001, 4);
2279 /* If we knew (or cared) what the source language options were, we'd
2280 fill them in here. SCO has given us permission to ignore these
2281 and just set them to zero. */
2283 md_number_to_chars (p
, 0x0000, 4);
2285 frag_align (2, 0, 0);
2287 /* We probably can't restore the current segment, for there likely
2290 subseg_set (seg
, subseg
);
2294 #endif /* SCO_ELF */
2297 elf_separate_stab_sections ()
2299 #ifdef NEED_ECOFF_DEBUG
2300 return (!ECOFF_DEBUGGING
);
2307 elf_init_stab_section (seg
)
2310 #ifdef NEED_ECOFF_DEBUG
2311 if (!ECOFF_DEBUGGING
)
2313 obj_elf_init_stab_section (seg
);
2316 const struct format_ops elf_format_ops
=
2318 bfd_target_elf_flavour
,
2319 0, /* dfl_leading_underscore */
2320 1, /* emit_section_symbols */
2325 elf_frob_file_before_adjust
,
2326 0, /* obj_frob_file_before_fix */
2327 elf_frob_file_after_relocs
,
2328 elf_s_get_size
, elf_s_set_size
,
2329 elf_s_get_align
, elf_s_set_align
,
2336 elf_copy_symbol_attributes
,
2337 #ifdef NEED_ECOFF_DEBUG
2338 ecoff_generate_asm_lineno
,
2341 0, /* generate_asm_lineno */
2342 0, /* process_stab */
2344 elf_separate_stab_sections
,
2345 elf_init_stab_section
,
2346 elf_sec_sym_ok_for_reloc
,
2348 #ifdef NEED_ECOFF_DEBUG
2351 0, /* ecoff_set_ext */
2353 elf_obj_read_begin_hook
,
2354 elf_obj_symbol_new_hook