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 { ".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
},
621 { ".init_array",SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
622 { ".fini_array",SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
623 { ".preinit_array",SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
625 #ifdef ELF_TC_SPECIAL_SECTIONS
626 ELF_TC_SPECIAL_SECTIONS
630 /* The following section names are special, but they can not
631 reasonably appear in assembler code. Some of the attributes are
632 processor dependent. */
633 { ".dynamic", SHT_DYNAMIC
, SHF_ALLOC
/* + SHF_WRITE */ },
634 { ".dynstr", SHT_STRTAB
, SHF_ALLOC
},
635 { ".dynsym", SHT_DYNSYM
, SHF_ALLOC
},
636 { ".got", SHT_PROGBITS
, 0 },
637 { ".hash", SHT_HASH
, SHF_ALLOC
},
638 { ".interp", SHT_PROGBITS
, /* SHF_ALLOC */ },
639 { ".plt", SHT_PROGBITS
, 0 },
640 { ".shstrtab",SHT_STRTAB
, 0 },
641 { ".strtab", SHT_STRTAB
, /* SHF_ALLOC */ },
642 { ".symtab", SHT_SYMTAB
, /* SHF_ALLOC */ },
649 obj_elf_change_section (name
, type
, attr
, entsize
, group_name
, linkonce
, push
)
654 const char *group_name
;
663 #ifdef md_flush_pending_output
664 md_flush_pending_output ();
667 /* Switch to the section, creating it if necessary. */
670 struct section_stack
*elt
;
671 elt
= xmalloc (sizeof (struct section_stack
));
672 elt
->next
= section_stack
;
674 elt
->prev_seg
= previous_section
;
675 elt
->subseg
= now_subseg
;
676 elt
->prev_subseg
= previous_subsection
;
679 previous_section
= now_seg
;
680 previous_subsection
= now_subseg
;
682 old_sec
= bfd_get_section_by_name (stdoutput
, name
);
683 sec
= subseg_new (name
, 0);
685 /* See if this is one of the special sections. */
686 for (i
= 0; special_sections
[i
].name
!= NULL
; i
++)
687 if (strcmp (name
, special_sections
[i
].name
) == 0)
689 if (type
== SHT_NULL
)
690 type
= special_sections
[i
].type
;
691 else if (type
!= special_sections
[i
].type
)
694 /* FIXME: gcc, as of 2002-10-22, will emit
696 .section .init_array,"aw",@progbits
698 for __attribute__ ((section (".init_array"))).
699 "@progbits" is incorrect. */
700 && special_sections
[i
].type
!= SHT_INIT_ARRAY
701 && special_sections
[i
].type
!= SHT_FINI_ARRAY
702 && special_sections
[i
].type
!= SHT_PREINIT_ARRAY
)
704 as_warn (_("setting incorrect section type for %s"), name
);
708 as_warn (_("ignoring incorrect section type for %s"), name
);
709 type
= special_sections
[i
].type
;
712 if ((attr
&~ special_sections
[i
].attributes
) != 0
715 /* As a GNU extension, we permit a .note section to be
716 allocatable. If the linker sees an allocateable .note
717 section, it will create a PT_NOTE segment in the output
719 if (strcmp (name
, ".note") != 0
720 || attr
!= SHF_ALLOC
)
721 as_warn (_("setting incorrect section attributes for %s"),
724 attr
|= special_sections
[i
].attributes
;
728 /* Convert ELF type and flags to BFD flags. */
730 | ((attr
& SHF_WRITE
) ? 0 : SEC_READONLY
)
731 | ((attr
& SHF_ALLOC
) ? SEC_ALLOC
: 0)
732 | (((attr
& SHF_ALLOC
) && type
!= SHT_NOBITS
) ? SEC_LOAD
: 0)
733 | ((attr
& SHF_EXECINSTR
) ? SEC_CODE
: 0)
734 | ((attr
& SHF_MERGE
) ? SEC_MERGE
: 0)
735 | ((attr
& SHF_STRINGS
) ? SEC_STRINGS
: 0)
736 | ((attr
& SHF_TLS
) ? SEC_THREAD_LOCAL
: 0));
737 #ifdef md_elf_section_flags
738 flags
= md_elf_section_flags (flags
, attr
, type
);
745 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */
746 if (type
== SHT_NOBITS
)
747 seg_info (sec
)->bss
= 1;
749 bfd_set_section_flags (stdoutput
, sec
, flags
);
750 if (flags
& SEC_MERGE
)
751 sec
->entsize
= entsize
;
752 elf_group_name (sec
) = group_name
;
753 elf_linkonce_p (sec
) = linkonce
;
755 /* Add a symbol for this section to the symbol table. */
756 secsym
= symbol_find (name
);
758 symbol_set_bfdsym (secsym
, sec
->symbol
);
760 symbol_table_insert (section_symbol (sec
));
764 /* If section attributes are specified the second time we see a
765 particular section, then check that they are the same as we
766 saw the first time. */
767 if (((old_sec
->flags
^ flags
)
768 & (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
769 | SEC_EXCLUDE
| SEC_SORT_ENTRIES
| SEC_MERGE
| SEC_STRINGS
771 || linkonce
!= elf_linkonce_p (sec
))
772 as_warn (_("ignoring changed section attributes for %s"), name
);
773 if ((flags
& SEC_MERGE
) && old_sec
->entsize
!= (unsigned) entsize
)
774 as_warn (_("ignoring changed section entity size for %s"), name
);
775 if ((attr
& SHF_GROUP
) != 0
776 && strcmp (elf_group_name (old_sec
), group_name
) != 0)
777 as_warn (_("ignoring new section group for %s"), name
);
780 #ifdef md_elf_section_change_hook
781 md_elf_section_change_hook ();
786 obj_elf_parse_section_letters (str
, len
)
803 attr
|= SHF_EXECINSTR
;
819 if (*(str
- 1) == 'a')
822 if (len
> 1 && str
[1] == 's')
831 char *bad_msg
= _("unrecognized .section attribute: want a,w,x,M,S,G,T");
832 #ifdef md_elf_section_letter
833 int md_attr
= md_elf_section_letter (*str
, &bad_msg
);
839 as_warn ("%s", bad_msg
);
852 obj_elf_section_word (str
, len
)
856 if (len
== 5 && strncmp (str
, "write", 5) == 0)
858 if (len
== 5 && strncmp (str
, "alloc", 5) == 0)
860 if (len
== 9 && strncmp (str
, "execinstr", 9) == 0)
861 return SHF_EXECINSTR
;
863 #ifdef md_elf_section_word
865 int md_attr
= md_elf_section_word (str
, len
);
871 as_warn (_("unrecognized section attribute"));
876 obj_elf_section_type (str
, len
)
880 if (len
== 8 && strncmp (str
, "progbits", 8) == 0)
882 if (len
== 6 && strncmp (str
, "nobits", 6) == 0)
885 #ifdef md_elf_section_type
887 int md_type
= md_elf_section_type (str
, len
);
893 as_warn (_("unrecognized section type"));
897 /* Get name of section. */
899 obj_elf_section_name ()
904 if (*input_line_pointer
== '"')
908 name
= demand_copy_C_string (&dummy
);
911 ignore_rest_of_line ();
917 char *end
= input_line_pointer
;
919 while (0 == strchr ("\n\t,; ", *end
))
921 if (end
== input_line_pointer
)
923 as_warn (_("missing name"));
924 ignore_rest_of_line ();
928 name
= xmalloc (end
- input_line_pointer
+ 1);
929 memcpy (name
, input_line_pointer
, end
- input_line_pointer
);
930 name
[end
- input_line_pointer
] = '\0';
931 input_line_pointer
= end
;
938 obj_elf_section (push
)
941 char *name
, *group_name
, *beg
;
942 int type
, attr
, dummy
;
951 #ifdef md_flush_pending_output
952 md_flush_pending_output ();
955 previous_section
= now_seg
;
956 previous_subsection
= now_subseg
;
958 s_mri_sect (&mri_type
);
960 #ifdef md_elf_section_change_hook
961 md_elf_section_change_hook ();
966 #endif /* ! defined (TC_I370) */
968 name
= obj_elf_section_name ();
977 if (*input_line_pointer
== ',')
979 /* Skip the comma. */
980 ++input_line_pointer
;
983 if (*input_line_pointer
== '"')
985 beg
= demand_copy_C_string (&dummy
);
988 ignore_rest_of_line ();
991 attr
|= obj_elf_parse_section_letters (beg
, strlen (beg
));
994 if (*input_line_pointer
== ',')
997 char *save
= input_line_pointer
;
999 ++input_line_pointer
;
1001 c
= *input_line_pointer
;
1004 beg
= demand_copy_C_string (&dummy
);
1007 ignore_rest_of_line ();
1010 type
= obj_elf_section_type (beg
, strlen (beg
));
1012 else if (c
== '@' || c
== '%')
1014 beg
= ++input_line_pointer
;
1015 c
= get_symbol_end ();
1016 *input_line_pointer
= c
;
1017 type
= obj_elf_section_type (beg
, input_line_pointer
- beg
);
1020 input_line_pointer
= save
;
1024 if ((attr
& SHF_MERGE
) != 0 && *input_line_pointer
== ',')
1026 ++input_line_pointer
;
1028 entsize
= get_absolute_expression ();
1032 as_warn (_("invalid merge entity size"));
1037 else if ((attr
& SHF_MERGE
) != 0)
1039 as_warn (_("entity size for SHF_MERGE not specified"));
1043 if ((attr
& SHF_GROUP
) != 0 && *input_line_pointer
== ',')
1045 ++input_line_pointer
;
1046 group_name
= obj_elf_section_name ();
1047 if (group_name
== NULL
)
1049 else if (strncmp (input_line_pointer
, ",comdat", 7) == 0)
1051 input_line_pointer
+= 7;
1054 else if (strncmp (name
, ".gnu.linkonce", 13) == 0)
1057 else if ((attr
& SHF_GROUP
) != 0)
1059 as_warn (_("group name for SHF_GROUP not specified"));
1070 if (*input_line_pointer
!= '#')
1072 as_warn (_("character following name is not '#'"));
1073 ignore_rest_of_line ();
1076 beg
= ++input_line_pointer
;
1077 c
= get_symbol_end ();
1078 *input_line_pointer
= c
;
1080 attr
|= obj_elf_section_word (beg
, input_line_pointer
- beg
);
1084 while (*input_line_pointer
++ == ',');
1085 --input_line_pointer
;
1089 demand_empty_rest_of_line ();
1091 obj_elf_change_section (name
, type
, attr
, entsize
, group_name
, linkonce
, push
);
1094 /* Change to the .data section. */
1100 #ifdef md_flush_pending_output
1101 md_flush_pending_output ();
1104 previous_section
= now_seg
;
1105 previous_subsection
= now_subseg
;
1108 #ifdef md_elf_section_change_hook
1109 md_elf_section_change_hook ();
1113 /* Change to the .text section. */
1119 #ifdef md_flush_pending_output
1120 md_flush_pending_output ();
1123 previous_section
= now_seg
;
1124 previous_subsection
= now_subseg
;
1127 #ifdef md_elf_section_change_hook
1128 md_elf_section_change_hook ();
1133 obj_elf_subsection (ignore
)
1134 int ignore ATTRIBUTE_UNUSED
;
1138 #ifdef md_flush_pending_output
1139 md_flush_pending_output ();
1142 previous_section
= now_seg
;
1143 previous_subsection
= now_subseg
;
1145 temp
= get_absolute_expression ();
1146 subseg_set (now_seg
, (subsegT
) temp
);
1147 demand_empty_rest_of_line ();
1149 #ifdef md_elf_section_change_hook
1150 md_elf_section_change_hook ();
1154 /* This can be called from the processor backends if they change
1158 obj_elf_section_change_hook ()
1160 previous_section
= now_seg
;
1161 previous_subsection
= now_subseg
;
1165 obj_elf_previous (ignore
)
1166 int ignore ATTRIBUTE_UNUSED
;
1171 if (previous_section
== 0)
1173 as_warn (_(".previous without corresponding .section; ignored"));
1177 #ifdef md_flush_pending_output
1178 md_flush_pending_output ();
1181 new_section
= previous_section
;
1182 new_subsection
= previous_subsection
;
1183 previous_section
= now_seg
;
1184 previous_subsection
= now_subseg
;
1185 subseg_set (new_section
, new_subsection
);
1187 #ifdef md_elf_section_change_hook
1188 md_elf_section_change_hook ();
1193 obj_elf_popsection (xxx
)
1194 int xxx ATTRIBUTE_UNUSED
;
1196 struct section_stack
*top
= section_stack
;
1200 as_warn (_(".popsection without corresponding .pushsection; ignored"));
1204 #ifdef md_flush_pending_output
1205 md_flush_pending_output ();
1208 section_stack
= top
->next
;
1209 previous_section
= top
->prev_seg
;
1210 previous_subsection
= top
->prev_subseg
;
1211 subseg_set (top
->seg
, top
->subseg
);
1214 #ifdef md_elf_section_change_hook
1215 md_elf_section_change_hook ();
1220 obj_elf_line (ignore
)
1221 int ignore ATTRIBUTE_UNUSED
;
1223 /* Assume delimiter is part of expression. BSD4.2 as fails with
1224 delightful bug, so we are not being incompatible here. */
1225 new_logical_line ((char *) NULL
, (int) (get_absolute_expression ()));
1226 demand_empty_rest_of_line ();
1229 /* This handles the .symver pseudo-op, which is used to specify a
1230 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1231 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1232 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1233 with the same value as the symbol NAME. */
1236 obj_elf_symver (ignore
)
1237 int ignore ATTRIBUTE_UNUSED
;
1244 name
= input_line_pointer
;
1245 c
= get_symbol_end ();
1247 sym
= symbol_find_or_make (name
);
1249 *input_line_pointer
= c
;
1252 if (*input_line_pointer
!= ',')
1254 as_bad (_("expected comma after name in .symver"));
1255 ignore_rest_of_line ();
1259 ++input_line_pointer
;
1260 name
= input_line_pointer
;
1262 /* Temporarily include '@' in symbol names. */
1263 old_lexat
= lex_type
[(unsigned char) '@'];
1264 lex_type
[(unsigned char) '@'] |= LEX_NAME
;
1265 c
= get_symbol_end ();
1266 lex_type
[(unsigned char) '@'] = old_lexat
;
1268 if (symbol_get_obj (sym
)->versioned_name
== NULL
)
1270 symbol_get_obj (sym
)->versioned_name
= xstrdup (name
);
1272 *input_line_pointer
= c
;
1274 if (strchr (symbol_get_obj (sym
)->versioned_name
,
1275 ELF_VER_CHR
) == NULL
)
1277 as_bad (_("missing version name in `%s' for symbol `%s'"),
1278 symbol_get_obj (sym
)->versioned_name
,
1280 ignore_rest_of_line ();
1286 if (strcmp (symbol_get_obj (sym
)->versioned_name
, name
))
1288 as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1289 name
, symbol_get_obj (sym
)->versioned_name
,
1291 ignore_rest_of_line ();
1295 *input_line_pointer
= c
;
1298 demand_empty_rest_of_line ();
1301 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1302 to the linker the hierarchy in which a particular table resides. The
1303 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1306 obj_elf_vtable_inherit (ignore
)
1307 int ignore ATTRIBUTE_UNUSED
;
1309 char *cname
, *pname
;
1310 symbolS
*csym
, *psym
;
1313 if (*input_line_pointer
== '#')
1314 ++input_line_pointer
;
1316 cname
= input_line_pointer
;
1317 c
= get_symbol_end ();
1318 csym
= symbol_find (cname
);
1320 /* GCFIXME: should check that we don't have two .vtable_inherits for
1321 the same child symbol. Also, we can currently only do this if the
1322 child symbol is already exists and is placed in a fragment. */
1324 if (csym
== NULL
|| symbol_get_frag (csym
) == NULL
)
1326 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1331 *input_line_pointer
= c
;
1334 if (*input_line_pointer
!= ',')
1336 as_bad ("expected comma after name in .vtable_inherit");
1337 ignore_rest_of_line ();
1341 ++input_line_pointer
;
1344 if (*input_line_pointer
== '#')
1345 ++input_line_pointer
;
1347 if (input_line_pointer
[0] == '0'
1348 && (input_line_pointer
[1] == '\0'
1349 || ISSPACE (input_line_pointer
[1])))
1351 psym
= section_symbol (absolute_section
);
1352 ++input_line_pointer
;
1356 pname
= input_line_pointer
;
1357 c
= get_symbol_end ();
1358 psym
= symbol_find_or_make (pname
);
1359 *input_line_pointer
= c
;
1362 demand_empty_rest_of_line ();
1367 assert (symbol_get_value_expression (csym
)->X_op
== O_constant
);
1368 return fix_new (symbol_get_frag (csym
),
1369 symbol_get_value_expression (csym
)->X_add_number
,
1370 0, psym
, 0, 0, BFD_RELOC_VTABLE_INHERIT
);
1373 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1374 to the linker that a vtable slot was used. The syntax is
1375 ".vtable_entry tablename, offset". */
1378 obj_elf_vtable_entry (ignore
)
1379 int ignore ATTRIBUTE_UNUSED
;
1386 if (*input_line_pointer
== '#')
1387 ++input_line_pointer
;
1389 name
= input_line_pointer
;
1390 c
= get_symbol_end ();
1391 sym
= symbol_find_or_make (name
);
1392 *input_line_pointer
= c
;
1395 if (*input_line_pointer
!= ',')
1397 as_bad ("expected comma after name in .vtable_entry");
1398 ignore_rest_of_line ();
1402 ++input_line_pointer
;
1403 if (*input_line_pointer
== '#')
1404 ++input_line_pointer
;
1406 offset
= get_absolute_expression ();
1408 demand_empty_rest_of_line ();
1410 return fix_new (frag_now
, frag_now_fix (), 0, sym
, offset
, 0,
1411 BFD_RELOC_VTABLE_ENTRY
);
1415 elf_obj_read_begin_hook ()
1417 #ifdef NEED_ECOFF_DEBUG
1418 if (ECOFF_DEBUGGING
)
1419 ecoff_read_begin_hook ();
1424 elf_obj_symbol_new_hook (symbolP
)
1427 struct elf_obj_sy
*sy_obj
;
1429 sy_obj
= symbol_get_obj (symbolP
);
1430 sy_obj
->size
= NULL
;
1431 sy_obj
->versioned_name
= NULL
;
1433 #ifdef NEED_ECOFF_DEBUG
1434 if (ECOFF_DEBUGGING
)
1435 ecoff_symbol_new_hook (symbolP
);
1439 /* When setting one symbol equal to another, by default we probably
1440 want them to have the same "size", whatever it means in the current
1444 elf_copy_symbol_attributes (dest
, src
)
1445 symbolS
*dest
, *src
;
1447 struct elf_obj_sy
*srcelf
= symbol_get_obj (src
);
1448 struct elf_obj_sy
*destelf
= symbol_get_obj (dest
);
1451 if (destelf
->size
== NULL
)
1453 (expressionS
*) xmalloc (sizeof (expressionS
));
1454 *destelf
->size
= *srcelf
->size
;
1458 if (destelf
->size
!= NULL
)
1459 free (destelf
->size
);
1460 destelf
->size
= NULL
;
1462 S_SET_SIZE (dest
, S_GET_SIZE (src
));
1463 /* Don't copy visibility. */
1464 S_SET_OTHER (dest
, (ELF_ST_VISIBILITY (S_GET_OTHER (dest
))
1465 | (S_GET_OTHER (src
) & ~ELF_ST_VISIBILITY (-1))));
1469 obj_elf_version (ignore
)
1470 int ignore ATTRIBUTE_UNUSED
;
1475 asection
*seg
= now_seg
;
1476 subsegT subseg
= now_subseg
;
1477 Elf_Internal_Note i_note
;
1478 Elf_External_Note e_note
;
1479 asection
*note_secp
= (asection
*) NULL
;
1483 if (*input_line_pointer
== '\"')
1485 ++input_line_pointer
; /* -> 1st char of string. */
1486 name
= input_line_pointer
;
1488 while (is_a_char (c
= next_char_of_string ()))
1490 c
= *input_line_pointer
;
1491 *input_line_pointer
= '\0';
1492 *(input_line_pointer
- 1) = '\0';
1493 *input_line_pointer
= c
;
1495 /* create the .note section */
1497 note_secp
= subseg_new (".note", 0);
1498 bfd_set_section_flags (stdoutput
,
1500 SEC_HAS_CONTENTS
| SEC_READONLY
);
1502 /* process the version string */
1504 len
= strlen (name
);
1506 i_note
.namesz
= ((len
+ 1) + 3) & ~3; /* round this to word boundary */
1507 i_note
.descsz
= 0; /* no description */
1508 i_note
.type
= NT_VERSION
;
1509 p
= frag_more (sizeof (e_note
.namesz
));
1510 md_number_to_chars (p
, (valueT
) i_note
.namesz
, sizeof (e_note
.namesz
));
1511 p
= frag_more (sizeof (e_note
.descsz
));
1512 md_number_to_chars (p
, (valueT
) i_note
.descsz
, sizeof (e_note
.descsz
));
1513 p
= frag_more (sizeof (e_note
.type
));
1514 md_number_to_chars (p
, (valueT
) i_note
.type
, sizeof (e_note
.type
));
1515 p
= frag_more (len
+ 1);
1518 frag_align (2, 0, 0);
1520 subseg_set (seg
, subseg
);
1524 as_bad (_("expected quoted string"));
1526 demand_empty_rest_of_line ();
1530 obj_elf_size (ignore
)
1531 int ignore ATTRIBUTE_UNUSED
;
1533 char *name
= input_line_pointer
;
1534 char c
= get_symbol_end ();
1539 p
= input_line_pointer
;
1542 if (*input_line_pointer
!= ',')
1545 as_bad (_("expected comma after name `%s' in .size directive"), name
);
1547 ignore_rest_of_line ();
1550 input_line_pointer
++;
1552 if (exp
.X_op
== O_absent
)
1554 as_bad (_("missing expression in .size directive"));
1555 exp
.X_op
= O_constant
;
1556 exp
.X_add_number
= 0;
1559 sym
= symbol_find_or_make (name
);
1561 if (exp
.X_op
== O_constant
)
1563 S_SET_SIZE (sym
, exp
.X_add_number
);
1564 if (symbol_get_obj (sym
)->size
)
1566 xfree (symbol_get_obj (sym
)->size
);
1567 symbol_get_obj (sym
)->size
= NULL
;
1572 symbol_get_obj (sym
)->size
=
1573 (expressionS
*) xmalloc (sizeof (expressionS
));
1574 *symbol_get_obj (sym
)->size
= exp
;
1576 demand_empty_rest_of_line ();
1579 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1580 There are five syntaxes:
1582 The first (used on Solaris) is
1584 The second (used on UnixWare) is
1586 The third (reportedly to be used on Irix 6.0) is
1588 The fourth (used on NetBSD/Arm and Linux/ARM) is
1590 The fifth (used on SVR4/860) is
1591 .type SYM,"function"
1595 obj_elf_type (ignore
)
1596 int ignore ATTRIBUTE_UNUSED
;
1601 const char *typename
;
1603 elf_symbol_type
*elfsym
;
1605 name
= input_line_pointer
;
1606 c
= get_symbol_end ();
1607 sym
= symbol_find_or_make (name
);
1608 elfsym
= (elf_symbol_type
*) symbol_get_bfdsym (sym
);
1609 *input_line_pointer
= c
;
1612 if (*input_line_pointer
== ',')
1613 ++input_line_pointer
;
1616 if ( *input_line_pointer
== '#'
1617 || *input_line_pointer
== '@'
1618 || *input_line_pointer
== '"'
1619 || *input_line_pointer
== '%')
1620 ++input_line_pointer
;
1622 typename
= input_line_pointer
;
1623 c
= get_symbol_end ();
1626 if (strcmp (typename
, "function") == 0
1627 || strcmp (typename
, "STT_FUNC") == 0)
1628 type
= BSF_FUNCTION
;
1629 else if (strcmp (typename
, "object") == 0
1630 || strcmp (typename
, "STT_OBJECT") == 0)
1632 #ifdef md_elf_symbol_type
1633 else if ((type
= md_elf_symbol_type (typename
, sym
, elfsym
)) != -1)
1637 as_bad (_("unrecognized symbol type \"%s\""), typename
);
1639 *input_line_pointer
= c
;
1641 if (*input_line_pointer
== '"')
1642 ++input_line_pointer
;
1644 elfsym
->symbol
.flags
|= type
;
1646 demand_empty_rest_of_line ();
1650 obj_elf_ident (ignore
)
1651 int ignore ATTRIBUTE_UNUSED
;
1653 static segT comment_section
;
1654 segT old_section
= now_seg
;
1655 int old_subsection
= now_subseg
;
1657 #ifdef md_flush_pending_output
1658 md_flush_pending_output ();
1661 if (!comment_section
)
1664 comment_section
= subseg_new (".comment", 0);
1665 bfd_set_section_flags (stdoutput
, comment_section
,
1666 SEC_READONLY
| SEC_HAS_CONTENTS
);
1671 subseg_set (comment_section
, 0);
1673 subseg_set (old_section
, old_subsection
);
1676 #ifdef INIT_STAB_SECTION
1678 /* The first entry in a .stabs section is special. */
1681 obj_elf_init_stab_section (seg
)
1687 unsigned int stroff
;
1689 /* Force the section to align to a longword boundary. Without this,
1690 UnixWare ar crashes. */
1691 bfd_set_section_alignment (stdoutput
, seg
, 2);
1693 /* Make space for this first symbol. */
1697 as_where (&file
, (unsigned int *) NULL
);
1698 stabstr_name
= (char *) xmalloc (strlen (segment_name (seg
)) + 4);
1699 strcpy (stabstr_name
, segment_name (seg
));
1700 strcat (stabstr_name
, "str");
1701 stroff
= get_stab_string_offset (file
, stabstr_name
);
1703 md_number_to_chars (p
, stroff
, 4);
1704 seg_info (seg
)->stabu
.p
= p
;
1709 /* Fill in the counts in the first entry in a .stabs section. */
1712 adjust_stab_sections (abfd
, sec
, xxx
)
1715 PTR xxx ATTRIBUTE_UNUSED
;
1722 if (strncmp (".stab", sec
->name
, 5))
1724 if (!strcmp ("str", sec
->name
+ strlen (sec
->name
) - 3))
1727 name
= (char *) alloca (strlen (sec
->name
) + 4);
1728 strcpy (name
, sec
->name
);
1729 strcat (name
, "str");
1730 strsec
= bfd_get_section_by_name (abfd
, name
);
1732 strsz
= bfd_section_size (abfd
, strsec
);
1735 nsyms
= bfd_section_size (abfd
, sec
) / 12 - 1;
1737 p
= seg_info (sec
)->stabu
.p
;
1740 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
1741 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
1744 #ifdef NEED_ECOFF_DEBUG
1746 /* This function is called by the ECOFF code. It is supposed to
1747 record the external symbol information so that the backend can
1748 write it out correctly. The ELF backend doesn't actually handle
1749 this at the moment, so we do it ourselves. We save the information
1753 elf_ecoff_set_ext (sym
, ext
)
1755 struct ecoff_extr
*ext
;
1757 symbol_get_bfdsym (sym
)->udata
.p
= (PTR
) ext
;
1760 /* This function is called by bfd_ecoff_debug_externals. It is
1761 supposed to *EXT to the external symbol information, and return
1762 whether the symbol should be used at all. */
1765 elf_get_extr (sym
, ext
)
1769 if (sym
->udata
.p
== NULL
)
1771 *ext
= *(EXTR
*) sym
->udata
.p
;
1775 /* This function is called by bfd_ecoff_debug_externals. It has
1776 nothing to do for ELF. */
1780 elf_set_index (sym
, indx
)
1781 asymbol
*sym ATTRIBUTE_UNUSED
;
1782 bfd_size_type indx ATTRIBUTE_UNUSED
;
1786 #endif /* NEED_ECOFF_DEBUG */
1789 elf_frob_symbol (symp
, puntp
)
1793 struct elf_obj_sy
*sy_obj
;
1795 #ifdef NEED_ECOFF_DEBUG
1796 if (ECOFF_DEBUGGING
)
1797 ecoff_frob_symbol (symp
);
1800 sy_obj
= symbol_get_obj (symp
);
1802 if (sy_obj
->size
!= NULL
)
1804 switch (sy_obj
->size
->X_op
)
1808 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1809 + sy_obj
->size
->X_add_number
1810 - S_GET_VALUE (sy_obj
->size
->X_op_symbol
)));
1814 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1815 + sy_obj
->size
->X_add_number
));
1818 as_bad (_(".size expression too complicated to fix up"));
1821 free (sy_obj
->size
);
1822 sy_obj
->size
= NULL
;
1825 if (sy_obj
->versioned_name
!= NULL
)
1829 p
= strchr (sy_obj
->versioned_name
, ELF_VER_CHR
);
1832 /* This symbol was given a new name with the .symver directive.
1834 If this is an external reference, just rename the symbol to
1835 include the version string. This will make the relocs be
1836 against the correct versioned symbol.
1838 If this is a definition, add an alias. FIXME: Using an alias
1839 will permit the debugging information to refer to the right
1840 symbol. However, it's not clear whether it is the best
1843 if (! S_IS_DEFINED (symp
))
1845 /* Verify that the name isn't using the @@ syntax--this is
1846 reserved for definitions of the default version to link
1848 if (p
[1] == ELF_VER_CHR
)
1850 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1851 sy_obj
->versioned_name
);
1854 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1858 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
1862 /* The @@@ syntax is a special case. It renames the
1863 symbol name to versioned_name with one `@' removed. */
1864 l
= strlen (&p
[3]) + 1;
1865 memmove (&p
[2], &p
[3], l
);
1866 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1872 /* FIXME: Creating a new symbol here is risky. We're
1873 in the final loop over the symbol table. We can
1874 get away with it only because the symbol goes to
1875 the end of the list, where the loop will still see
1876 it. It would probably be better to do this in
1877 obj_frob_file_before_adjust. */
1879 symp2
= symbol_find_or_make (sy_obj
->versioned_name
);
1881 /* Now we act as though we saw symp2 = sym. */
1883 S_SET_SEGMENT (symp2
, S_GET_SEGMENT (symp
));
1885 /* Subtracting out the frag address here is a hack
1886 because we are in the middle of the final loop. */
1889 - symbol_get_frag (symp
)->fr_address
));
1891 symbol_set_frag (symp2
, symbol_get_frag (symp
));
1893 /* This will copy over the size information. */
1894 copy_symbol_attributes (symp2
, symp
);
1896 S_SET_OTHER (symp2
, S_GET_OTHER (symp
));
1898 if (S_IS_WEAK (symp
))
1901 if (S_IS_EXTERNAL (symp
))
1902 S_SET_EXTERNAL (symp2
);
1907 /* Double check weak symbols. */
1908 if (S_IS_WEAK (symp
))
1910 if (S_IS_COMMON (symp
))
1911 as_bad (_("symbol `%s' can not be both weak and common"),
1916 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1917 any undefined non-function symbol to STT_OBJECT. We try to be
1918 compatible, since newer Irix 5 and 6 linkers care. However, we
1919 only set undefined symbols to be STT_OBJECT if we are on Irix,
1920 because that is the only time gcc will generate the necessary
1921 .global directives to mark functions. */
1923 if (S_IS_COMMON (symp
))
1924 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1926 if (strstr (TARGET_OS
, "irix") != NULL
1927 && ! S_IS_DEFINED (symp
)
1928 && (symbol_get_bfdsym (symp
)->flags
& BSF_FUNCTION
) == 0)
1929 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1933 /* If TC_PPC is defined, we used to force the type of a symbol to be
1934 BSF_OBJECT if it was otherwise unset. This was required by some
1935 version of VxWorks. Thomas de Lellis <tdel@windriver.com> says
1936 that this is no longer needed, so it is now commented out. */
1937 if ((symbol_get_bfdsym (symp
)->flags
1938 & (BSF_FUNCTION
| BSF_FILE
| BSF_SECTION_SYM
)) == 0
1939 && S_IS_DEFINED (symp
))
1940 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1946 asection
**head
; /* Section lists. */
1947 unsigned int *elt_count
; /* Number of sections in each list. */
1948 unsigned int num_group
; /* Number of lists. */
1951 /* Called via bfd_map_over_sections. If SEC is a member of a group,
1952 add it to a list of sections belonging to the group. INF is a
1953 pointer to a struct group_list, which is where we store the head of
1957 build_group_lists (abfd
, sec
, inf
)
1958 bfd
*abfd ATTRIBUTE_UNUSED
;
1962 struct group_list
*list
= (struct group_list
*) inf
;
1963 const char *group_name
= elf_group_name (sec
);
1966 if (group_name
== NULL
)
1969 /* If this group already has a list, add the section to the head of
1971 for (i
= 0; i
< list
->num_group
; i
++)
1973 if (strcmp (group_name
, elf_group_name (list
->head
[i
])) == 0)
1975 elf_next_in_group (sec
) = list
->head
[i
];
1976 list
->head
[i
] = sec
;
1977 list
->elt_count
[i
] += 1;
1982 /* New group. Make the arrays bigger in chunks to minimize calls to
1984 i
= list
->num_group
;
1987 unsigned int newsize
= i
+ 128;
1988 list
->head
= xrealloc (list
->head
, newsize
* sizeof (*list
->head
));
1989 list
->elt_count
= xrealloc (list
->elt_count
,
1990 newsize
* sizeof (*list
->elt_count
));
1992 list
->head
[i
] = sec
;
1993 list
->elt_count
[i
] = 1;
1994 list
->num_group
+= 1;
2000 struct group_list list
;
2003 bfd_map_over_sections (stdoutput
, adjust_stab_sections
, (PTR
) 0);
2005 /* Go find section groups. */
2008 list
.elt_count
= NULL
;
2009 bfd_map_over_sections (stdoutput
, build_group_lists
, (PTR
) &list
);
2011 /* Make the SHT_GROUP sections that describe each section group. We
2012 can't set up the section contents here yet, because elf section
2013 indices have yet to be calculated. elf.c:set_group_contents does
2014 the rest of the work. */
2015 for (i
= 0; i
< list
.num_group
; i
++)
2017 const char *group_name
= elf_group_name (list
.head
[i
]);
2018 const char *sec_name
;
2024 flags
= SEC_READONLY
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_GROUP
;
2025 for (s
= list
.head
[i
]; s
!= NULL
; s
= elf_next_in_group (s
))
2026 if (elf_linkonce_p (s
) != ((flags
& SEC_LINK_ONCE
) != 0))
2028 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
2029 if (s
!= list
.head
[i
])
2031 as_warn (_("assuming all members of group `%s' are COMDAT"),
2037 sec_name
= group_name
;
2038 sy
= symbol_find_exact (group_name
);
2041 && (sy
== symbol_lastP
2042 || (sy
->sy_next
!= NULL
2043 && sy
->sy_next
->sy_previous
== sy
)))
2046 sec_name
= ".group";
2048 s
= subseg_force_new (sec_name
, 0);
2050 || !bfd_set_section_flags (stdoutput
, s
, flags
)
2051 || !bfd_set_section_alignment (stdoutput
, s
, 2))
2053 as_fatal (_("can't create group: %s"),
2054 bfd_errmsg (bfd_get_error ()));
2057 /* Pass a pointer to the first section in this group. */
2058 elf_next_in_group (s
) = list
.head
[i
];
2060 elf_group_id (s
) = sy
->bsym
;
2062 s
->_raw_size
= 4 * (list
.elt_count
[i
] + 1);
2063 s
->contents
= frag_more (s
->_raw_size
);
2064 frag_now
->fr_fix
= frag_now_fix_octets ();
2067 #ifdef elf_tc_final_processing
2068 elf_tc_final_processing ();
2072 /* It removes any unneeded versioned symbols from the symbol table. */
2075 elf_frob_file_before_adjust ()
2081 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2082 if (!S_IS_DEFINED (symp
))
2084 if (symbol_get_obj (symp
)->versioned_name
)
2088 /* The @@@ syntax is a special case. If the symbol is
2089 not defined, 2 `@'s will be removed from the
2092 p
= strchr (symbol_get_obj (symp
)->versioned_name
,
2095 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
2097 size_t l
= strlen (&p
[3]) + 1;
2098 memmove (&p
[1], &p
[3], l
);
2100 if (symbol_used_p (symp
) == 0
2101 && symbol_used_in_reloc_p (symp
) == 0)
2102 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2105 /* If there was .weak foo, but foo was neither defined nor
2106 used anywhere, remove it. */
2108 else if (S_IS_WEAK (symp
)
2109 && symbol_used_p (symp
) == 0
2110 && symbol_used_in_reloc_p (symp
) == 0)
2111 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2116 /* It is required that we let write_relocs have the opportunity to
2117 optimize away fixups before output has begun, since it is possible
2118 to eliminate all fixups for a section and thus we never should
2119 have generated the relocation section. */
2122 elf_frob_file_after_relocs ()
2124 #ifdef NEED_ECOFF_DEBUG
2125 if (ECOFF_DEBUGGING
)
2126 /* Generate the ECOFF debugging information. */
2128 const struct ecoff_debug_swap
*debug_swap
;
2129 struct ecoff_debug_info debug
;
2134 = get_elf_backend_data (stdoutput
)->elf_backend_ecoff_debug_swap
;
2135 know (debug_swap
!= (const struct ecoff_debug_swap
*) NULL
);
2136 ecoff_build_debug (&debug
.symbolic_header
, &buf
, debug_swap
);
2138 /* Set up the pointers in debug. */
2139 #define SET(ptr, offset, type) \
2140 debug.ptr = (type) (buf + debug.symbolic_header.offset)
2142 SET (line
, cbLineOffset
, unsigned char *);
2143 SET (external_dnr
, cbDnOffset
, PTR
);
2144 SET (external_pdr
, cbPdOffset
, PTR
);
2145 SET (external_sym
, cbSymOffset
, PTR
);
2146 SET (external_opt
, cbOptOffset
, PTR
);
2147 SET (external_aux
, cbAuxOffset
, union aux_ext
*);
2148 SET (ss
, cbSsOffset
, char *);
2149 SET (external_fdr
, cbFdOffset
, PTR
);
2150 SET (external_rfd
, cbRfdOffset
, PTR
);
2151 /* ssext and external_ext are set up just below. */
2155 /* Set up the external symbols. */
2156 debug
.ssext
= debug
.ssext_end
= NULL
;
2157 debug
.external_ext
= debug
.external_ext_end
= NULL
;
2158 if (! bfd_ecoff_debug_externals (stdoutput
, &debug
, debug_swap
, TRUE
,
2159 elf_get_extr
, elf_set_index
))
2160 as_fatal (_("failed to set up debugging information: %s"),
2161 bfd_errmsg (bfd_get_error ()));
2163 sec
= bfd_get_section_by_name (stdoutput
, ".mdebug");
2164 assert (sec
!= NULL
);
2166 know (!stdoutput
->output_has_begun
);
2168 /* We set the size of the section, call bfd_set_section_contents
2169 to force the ELF backend to allocate a file position, and then
2170 write out the data. FIXME: Is this really the best way to do
2172 sec
->_raw_size
= bfd_ecoff_debug_size (stdoutput
, &debug
, debug_swap
);
2174 /* Pass BUF to bfd_set_section_contents because this will
2175 eventually become a call to fwrite, and ISO C prohibits
2176 passing a NULL pointer to a stdio function even if the
2177 pointer will not be used. */
2178 if (! bfd_set_section_contents (stdoutput
, sec
, (PTR
) buf
,
2179 (file_ptr
) 0, (bfd_size_type
) 0))
2180 as_fatal (_("can't start writing .mdebug section: %s"),
2181 bfd_errmsg (bfd_get_error ()));
2183 know (stdoutput
->output_has_begun
);
2184 know (sec
->filepos
!= 0);
2186 if (! bfd_ecoff_write_debug (stdoutput
, &debug
, debug_swap
,
2188 as_fatal (_("could not write .mdebug section: %s"),
2189 bfd_errmsg (bfd_get_error ()));
2191 #endif /* NEED_ECOFF_DEBUG */
2196 /* Heavily plagarized from obj_elf_version. The idea is to emit the
2197 SCO specific identifier in the .notes section to satisfy the SCO
2200 This looks more complicated than it really is. As opposed to the
2201 "obvious" solution, this should handle the cross dev cases
2202 correctly. (i.e, hosting on a 64 bit big endian processor, but
2203 generating SCO Elf code) Efficiency isn't a concern, as there
2204 should be exactly one of these sections per object module.
2206 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
2209 int_32 namesz = 4 ; Name size
2210 int_32 descsz = 12 ; Descriptive information
2212 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
2213 int_32 version = (major ver # << 16) | version of tools ;
2214 int_32 source = (tool_id << 16 ) | 1 ;
2215 int_32 info = 0 ; These are set by the SCO tools, but we
2216 don't know enough about the source
2217 environment to set them. SCO ld currently
2218 ignores them, and recommends we set them
2221 #define SCO_MAJOR_VERSION 0x1
2222 #define SCO_MINOR_VERSION 0x1
2232 asection
*seg
= now_seg
;
2233 subsegT subseg
= now_subseg
;
2234 Elf_Internal_Note i_note
;
2235 Elf_External_Note e_note
;
2236 asection
*note_secp
= (asection
*) NULL
;
2239 /* create the .note section */
2241 note_secp
= subseg_new (".note", 0);
2242 bfd_set_section_flags (stdoutput
,
2244 SEC_HAS_CONTENTS
| SEC_READONLY
);
2246 /* process the version string */
2249 i_note
.descsz
= 12; /* 12 descriptive bytes */
2250 i_note
.type
= NT_VERSION
; /* Contains a version string */
2252 p
= frag_more (sizeof (i_note
.namesz
));
2253 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
2255 p
= frag_more (sizeof (i_note
.descsz
));
2256 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
2258 p
= frag_more (sizeof (i_note
.type
));
2259 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
2264 /* Note: this is the version number of the ELF we're representing */
2266 md_number_to_chars (p
, (SCO_MAJOR_VERSION
<< 16) | (SCO_MINOR_VERSION
), 4);
2268 /* Here, we pick a magic number for ourselves (yes, I "registered"
2269 it with SCO. The bottom bit shows that we are compat with the
2272 md_number_to_chars (p
, 0x4c520000 | 0x0001, 4);
2274 /* If we knew (or cared) what the source language options were, we'd
2275 fill them in here. SCO has given us permission to ignore these
2276 and just set them to zero. */
2278 md_number_to_chars (p
, 0x0000, 4);
2280 frag_align (2, 0, 0);
2282 /* We probably can't restore the current segment, for there likely
2285 subseg_set (seg
, subseg
);
2289 #endif /* SCO_ELF */
2292 elf_separate_stab_sections ()
2294 #ifdef NEED_ECOFF_DEBUG
2295 return (!ECOFF_DEBUGGING
);
2302 elf_init_stab_section (seg
)
2305 #ifdef NEED_ECOFF_DEBUG
2306 if (!ECOFF_DEBUGGING
)
2308 obj_elf_init_stab_section (seg
);
2311 const struct format_ops elf_format_ops
=
2313 bfd_target_elf_flavour
,
2314 0, /* dfl_leading_underscore */
2315 1, /* emit_section_symbols */
2320 elf_frob_file_before_adjust
,
2321 0, /* obj_frob_file_before_fix */
2322 elf_frob_file_after_relocs
,
2323 elf_s_get_size
, elf_s_set_size
,
2324 elf_s_get_align
, elf_s_set_align
,
2331 elf_copy_symbol_attributes
,
2332 #ifdef NEED_ECOFF_DEBUG
2333 ecoff_generate_asm_lineno
,
2336 0, /* generate_asm_lineno */
2337 0, /* process_stab */
2339 elf_separate_stab_sections
,
2340 elf_init_stab_section
,
2341 elf_sec_sym_ok_for_reloc
,
2343 #ifdef NEED_ECOFF_DEBUG
2346 0, /* ecoff_set_ext */
2348 elf_obj_read_begin_hook
,
2349 elf_obj_symbol_new_hook