1 /* ELF object file format
2 Copyright (C) 1992, 93-98, 1999 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as
8 published by the Free Software Foundation; either version 2,
9 or (at your option) any later version.
11 GAS is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
14 the GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21 #define OBJ_HEADER "obj-elf.h"
26 #ifndef ECOFF_DEBUGGING
27 #define ECOFF_DEBUGGING 0
29 #define NEED_ECOFF_DEBUG
32 #ifdef NEED_ECOFF_DEBUG
37 #include "elf/alpha.h"
48 static bfd_vma elf_s_get_size
PARAMS ((symbolS
*));
49 static void elf_s_set_size
PARAMS ((symbolS
*, bfd_vma
));
50 static bfd_vma elf_s_get_align
PARAMS ((symbolS
*));
51 static void elf_s_set_align
PARAMS ((symbolS
*, bfd_vma
));
52 static void elf_copy_symbol_attributes
PARAMS ((symbolS
*, symbolS
*));
53 static int elf_sec_sym_ok_for_reloc
PARAMS ((asection
*));
54 static void adjust_stab_sections
PARAMS ((bfd
*, asection
*, PTR
));
56 #ifdef NEED_ECOFF_DEBUG
57 static boolean elf_get_extr
PARAMS ((asymbol
*, EXTR
*));
58 static void elf_set_index
PARAMS ((asymbol
*, bfd_size_type
));
61 static void obj_elf_line
PARAMS ((int));
62 void obj_elf_version
PARAMS ((int));
63 static void obj_elf_size
PARAMS ((int));
64 static void obj_elf_type
PARAMS ((int));
65 static void obj_elf_ident
PARAMS ((int));
66 static void obj_elf_weak
PARAMS ((int));
67 static void obj_elf_local
PARAMS ((int));
68 static void obj_elf_symver
PARAMS ((int));
69 static void obj_elf_vtable_inherit
PARAMS ((int));
70 static void obj_elf_vtable_entry
PARAMS ((int));
71 static void obj_elf_subsection
PARAMS ((int));
72 static void obj_elf_popsection
PARAMS ((int));
74 static const pseudo_typeS elf_pseudo_table
[] =
76 {"comm", obj_elf_common
, 0},
77 {"common", obj_elf_common
, 1},
78 {"ident", obj_elf_ident
, 0},
79 {"local", obj_elf_local
, 0},
80 {"previous", obj_elf_previous
, 0},
81 {"section", obj_elf_section
, 0},
82 {"section.s", obj_elf_section
, 0},
83 {"sect", obj_elf_section
, 0},
84 {"sect.s", obj_elf_section
, 0},
85 {"pushsection", obj_elf_section
, 1},
86 {"popsection", obj_elf_popsection
, 0},
87 {"size", obj_elf_size
, 0},
88 {"type", obj_elf_type
, 0},
89 {"version", obj_elf_version
, 0},
90 {"weak", obj_elf_weak
, 0},
92 /* These are used for stabs-in-elf configurations. */
93 {"line", obj_elf_line
, 0},
95 /* This is a GNU extension to handle symbol versions. */
96 {"symver", obj_elf_symver
, 0},
98 /* A GNU extension to change subsection only. */
99 {"subsection", obj_elf_subsection
, 0},
101 /* These are GNU extensions to aid in garbage collecting C++ vtables. */
102 {"vtable_inherit", obj_elf_vtable_inherit
, 0},
103 {"vtable_entry", obj_elf_vtable_entry
, 0},
105 /* These are used for dwarf. */
110 /* We need to trap the section changing calls to handle .previous. */
111 {"data", obj_elf_data
, 0},
112 {"text", obj_elf_text
, 0},
118 static const pseudo_typeS ecoff_debug_pseudo_table
[] =
120 #ifdef NEED_ECOFF_DEBUG
121 /* COFF style debugging information for ECOFF. .ln is not used; .loc
123 { "def", ecoff_directive_def
, 0 },
124 { "dim", ecoff_directive_dim
, 0 },
125 { "endef", ecoff_directive_endef
, 0 },
126 { "file", ecoff_directive_file
, 0 },
127 { "scl", ecoff_directive_scl
, 0 },
128 { "tag", ecoff_directive_tag
, 0 },
129 { "val", ecoff_directive_val
, 0 },
131 /* COFF debugging requires pseudo-ops .size and .type, but ELF
132 already has meanings for those. We use .esize and .etype
133 instead. These are only generated by gcc anyhow. */
134 { "esize", ecoff_directive_size
, 0 },
135 { "etype", ecoff_directive_type
, 0 },
137 /* ECOFF specific debugging information. */
138 { "begin", ecoff_directive_begin
, 0 },
139 { "bend", ecoff_directive_bend
, 0 },
140 { "end", ecoff_directive_end
, 0 },
141 { "ent", ecoff_directive_ent
, 0 },
142 { "fmask", ecoff_directive_fmask
, 0 },
143 { "frame", ecoff_directive_frame
, 0 },
144 { "loc", ecoff_directive_loc
, 0 },
145 { "mask", ecoff_directive_mask
, 0 },
147 /* Other ECOFF directives. */
148 { "extern", ecoff_directive_extern
, 0 },
150 /* These are used on Irix. I don't know how to implement them. */
151 { "alias", s_ignore
, 0 },
152 { "bgnb", s_ignore
, 0 },
153 { "endb", s_ignore
, 0 },
154 { "lab", s_ignore
, 0 },
155 { "noalias", s_ignore
, 0 },
156 { "verstamp", s_ignore
, 0 },
157 { "vreg", s_ignore
, 0 },
160 {NULL
, NULL
, 0} /* end sentinel */
164 #include "aout/aout64.h"
166 /* This is called when the assembler starts. */
171 /* Add symbols for the known sections to the symbol table. */
172 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
173 TEXT_SECTION_NAME
)));
174 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
175 DATA_SECTION_NAME
)));
176 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
183 pop_insert (elf_pseudo_table
);
185 pop_insert (ecoff_debug_pseudo_table
);
192 return S_GET_SIZE (sym
);
196 elf_s_set_size (sym
, sz
)
200 S_SET_SIZE (sym
, sz
);
204 elf_s_get_align (sym
)
207 return S_GET_ALIGN (sym
);
211 elf_s_set_align (sym
, align
)
215 S_SET_ALIGN (sym
, align
);
219 elf_copy_symbol_attributes (dest
, src
)
222 OBJ_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
226 elf_sec_sym_ok_for_reloc (sec
)
229 return obj_sec_sym_ok_for_reloc (sec
);
238 sym
= symbol_new (s
, absolute_section
, (valueT
) 0, (struct frag
*) 0);
239 symbol_set_frag (sym
, &zero_address_frag
);
240 symbol_get_bfdsym (sym
)->flags
|= BSF_FILE
;
242 if (symbol_rootP
!= sym
)
244 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
245 symbol_insert (sym
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
247 verify_symbol_chain (symbol_rootP
, symbol_lastP
);
251 #ifdef NEED_ECOFF_DEBUG
257 obj_elf_common (is_common
)
267 if (flag_mri
&& is_common
)
273 name
= input_line_pointer
;
274 c
= get_symbol_end ();
275 /* just after name is now '\0' */
276 p
= input_line_pointer
;
279 if (*input_line_pointer
!= ',')
281 as_bad (_("Expected comma after symbol-name"));
282 ignore_rest_of_line ();
285 input_line_pointer
++; /* skip ',' */
286 if ((temp
= get_absolute_expression ()) < 0)
288 as_bad (_(".COMMon length (%d.) <0! Ignored."), temp
);
289 ignore_rest_of_line ();
294 symbolP
= symbol_find_or_make (name
);
296 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
298 as_bad (_("Ignoring attempt to re-define symbol"));
299 ignore_rest_of_line ();
302 if (S_GET_VALUE (symbolP
) != 0)
304 if (S_GET_VALUE (symbolP
) != (valueT
) size
)
306 as_warn (_("Length of .comm \"%s\" is already %ld. Not changed to %d."),
307 S_GET_NAME (symbolP
), (long) S_GET_VALUE (symbolP
), size
);
310 know (symbolP
->sy_frag
== &zero_address_frag
);
311 if (*input_line_pointer
!= ',')
316 input_line_pointer
++;
319 if (! have_align
|| *input_line_pointer
!= '"')
325 temp
= get_absolute_expression ();
329 as_warn (_("Common alignment negative; 0 assumed"));
332 if (symbol_get_obj (symbolP
)->local
)
341 old_subsec
= now_subseg
;
344 /* convert to a power of 2 alignment */
345 for (align
= 0; (temp
& 1) == 0; temp
>>= 1, ++align
);
348 as_bad (_("Common alignment not a power of 2"));
349 ignore_rest_of_line ();
355 record_alignment (bss_section
, align
);
356 subseg_set (bss_section
, 0);
358 frag_align (align
, 0, 0);
359 if (S_GET_SEGMENT (symbolP
) == bss_section
)
360 symbol_get_frag (symbolP
)->fr_symbol
= 0;
361 symbol_set_frag (symbolP
, frag_now
);
362 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
,
363 (offsetT
) size
, (char *) 0);
365 S_SET_SIZE (symbolP
, size
);
366 S_SET_SEGMENT (symbolP
, bss_section
);
367 S_CLEAR_EXTERNAL (symbolP
);
368 subseg_set (old_sec
, old_subsec
);
373 S_SET_VALUE (symbolP
, (valueT
) size
);
374 S_SET_ALIGN (symbolP
, temp
);
375 S_SET_EXTERNAL (symbolP
);
376 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
381 input_line_pointer
++;
382 /* @@ Some use the dot, some don't. Can we get some consistency?? */
383 if (*input_line_pointer
== '.')
384 input_line_pointer
++;
385 /* @@ Some say data, some say bss. */
386 if (strncmp (input_line_pointer
, "bss\"", 4)
387 && strncmp (input_line_pointer
, "data\"", 5))
389 while (*--input_line_pointer
!= '"')
391 input_line_pointer
--;
392 goto bad_common_segment
;
394 while (*input_line_pointer
++ != '"')
396 goto allocate_common
;
399 symbol_get_bfdsym (symbolP
)->flags
|= BSF_OBJECT
;
401 demand_empty_rest_of_line ();
406 p
= input_line_pointer
;
407 while (*p
&& *p
!= '\n')
411 as_bad (_("bad .common segment %s"), input_line_pointer
+ 1);
413 input_line_pointer
= p
;
414 ignore_rest_of_line ();
420 obj_elf_local (ignore
)
421 int ignore ATTRIBUTE_UNUSED
;
429 name
= input_line_pointer
;
430 c
= get_symbol_end ();
431 symbolP
= symbol_find_or_make (name
);
432 *input_line_pointer
= c
;
434 S_CLEAR_EXTERNAL (symbolP
);
435 symbol_get_obj (symbolP
)->local
= 1;
438 input_line_pointer
++;
440 if (*input_line_pointer
== '\n')
445 demand_empty_rest_of_line ();
449 obj_elf_weak (ignore
)
450 int ignore ATTRIBUTE_UNUSED
;
458 name
= input_line_pointer
;
459 c
= get_symbol_end ();
460 symbolP
= symbol_find_or_make (name
);
461 *input_line_pointer
= c
;
463 S_SET_WEAK (symbolP
);
464 symbol_get_obj (symbolP
)->local
= 1;
467 input_line_pointer
++;
469 if (*input_line_pointer
== '\n')
474 demand_empty_rest_of_line ();
477 static segT previous_section
;
478 static int previous_subsection
;
482 struct section_stack
*next
;
484 int subseg
, prev_subseg
;
487 static struct section_stack
*section_stack
;
490 /* Handle the .section pseudo-op. This code supports two different
493 The first is found on Solaris, and looks like
494 .section ".sec1",#alloc,#execinstr,#write
495 Here the names after '#' are the SHF_* flags to turn on for the
496 section. I'm not sure how it determines the SHT_* type (BFD
497 doesn't really give us control over the type, anyhow).
499 The second format is found on UnixWare, and probably most SVR4
500 machines, and looks like
501 .section .sec1,"a",@progbits
502 The quoted string may contain any combination of a, w, x, and
503 represents the SHF_* flags to turn on for the section. The string
504 beginning with '@' can be progbits or nobits. There should be
505 other possibilities, but I don't know what they are. In any case,
506 BFD doesn't really let us set the section type. */
508 /* Certain named sections have particular defined types, listed on p.
510 struct special_section
517 static struct special_section
const special_sections
[] =
519 { ".bss", SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
520 { ".comment", SHT_PROGBITS
, 0 },
521 { ".data", SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
522 { ".data1", SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
523 { ".debug", SHT_PROGBITS
, 0 },
524 { ".fini", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
525 { ".init", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
526 { ".line", SHT_PROGBITS
, 0 },
527 { ".note", SHT_NOTE
, 0 },
528 { ".rodata", SHT_PROGBITS
, SHF_ALLOC
},
529 { ".rodata1", SHT_PROGBITS
, SHF_ALLOC
},
530 { ".text", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
532 #ifdef ELF_TC_SPECIAL_SECTIONS
533 ELF_TC_SPECIAL_SECTIONS
537 /* The following section names are special, but they can not
538 reasonably appear in assembler code. Some of the attributes are
539 processor dependent. */
540 { ".dynamic", SHT_DYNAMIC
, SHF_ALLOC
/* + SHF_WRITE */ },
541 { ".dynstr", SHT_STRTAB
, SHF_ALLOC
},
542 { ".dynsym", SHT_DYNSYM
, SHF_ALLOC
},
543 { ".got", SHT_PROGBITS
, 0 },
544 { ".hash", SHT_HASH
, SHF_ALLOC
},
545 { ".interp", SHT_PROGBITS
, /* SHF_ALLOC */ },
546 { ".plt", SHT_PROGBITS
, 0 },
547 { ".shstrtab",SHT_STRTAB
, 0 },
548 { ".strtab", SHT_STRTAB
, /* SHF_ALLOC */ },
549 { ".symtab", SHT_SYMTAB
, /* SHF_ALLOC */ },
556 obj_elf_change_section (name
, type
, attr
, push
)
558 int type
, attr
, push
;
563 #ifdef md_flush_pending_output
564 md_flush_pending_output ();
567 /* Switch to the section, creating it if necessary. */
570 struct section_stack
*elt
;
571 elt
= xmalloc (sizeof (struct section_stack
));
572 elt
->next
= section_stack
;
574 elt
->prev_seg
= previous_section
;
575 elt
->subseg
= now_subseg
;
576 elt
->prev_subseg
= previous_subsection
;
579 previous_section
= now_seg
;
580 previous_subsection
= now_subseg
;
582 new_sec
= bfd_get_section_by_name (stdoutput
, name
) == NULL
;
583 sec
= subseg_new (name
, 0);
591 /* See if this is one of the special sections. */
592 for (i
= 0; special_sections
[i
].name
!= NULL
; i
++)
593 if (strcmp (name
, special_sections
[i
].name
) == 0)
595 if (type
== SHT_NULL
)
596 type
= special_sections
[i
].type
;
597 else if (type
!= special_sections
[i
].type
)
598 as_warn (_("Setting incorrect section type for %s"), name
);
600 if ((attr
&~ special_sections
[i
].attributes
) != 0)
602 /* As a GNU extension, we permit a .note section to be
603 allocatable. If the linker sees an allocateable .note
604 section, it will create a PT_NOTE segment in the output
606 if (strcmp (name
, ".note") != 0
607 || attr
!= SHF_ALLOC
)
608 as_warn (_("Setting incorrect section attributes for %s"),
611 attr
|= special_sections
[i
].attributes
;
615 /* Convert ELF type and flags to BFD flags. */
617 | ((attr
& SHF_WRITE
) ? 0 : SEC_READONLY
)
618 | ((attr
& SHF_ALLOC
) ? SEC_ALLOC
: 0)
619 | (((attr
& SHF_ALLOC
) && type
!= SHT_NOBITS
) ? SEC_LOAD
: 0)
620 | ((attr
& SHF_EXECINSTR
) ? SEC_CODE
: 0));
621 #ifdef md_elf_section_flags
622 flags
= md_elf_section_flags (flags
, attr
, type
);
625 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */
626 if (type
== SHT_NOBITS
)
627 seg_info (sec
)->bss
= 1;
629 bfd_set_section_flags (stdoutput
, sec
, flags
);
631 /* Add a symbol for this section to the symbol table. */
632 secsym
= symbol_find (name
);
634 symbol_set_bfdsym (secsym
, sec
->symbol
);
636 symbol_table_insert (section_symbol (sec
));
639 #ifdef md_elf_section_change_hook
640 md_elf_section_change_hook ();
645 obj_elf_parse_section_letters (str
, len
)
662 attr
|= SHF_EXECINSTR
;
666 char *bad_msg
= _("Unrecognized .section attribute: want a,w,x");
667 #ifdef md_elf_section_letter
668 int md_attr
= md_elf_section_letter (*str
, &bad_msg
);
687 obj_elf_section_word (str
, len
)
691 if (len
== 5 && strncmp (str
, "write", 5) == 0)
693 if (len
== 5 && strncmp (str
, "alloc", 5) == 0)
695 if (len
== 9 && strncmp (str
, "execinstr", 9) == 0)
696 return SHF_EXECINSTR
;
698 #ifdef md_elf_section_word
700 int md_attr
= md_elf_section_word (str
, len
);
706 as_warn (_("Unrecognized section attribute"));
711 obj_elf_section_type (str
, len
)
715 if (len
== 8 && strncmp (str
, "progbits", 8) == 0)
717 if (len
== 6 && strncmp (str
, "nobits", 6) == 0)
720 #ifdef md_elf_section_type
722 int md_type
= md_elf_section_type (str
, len
);
728 as_warn (_("Unrecognized section type"));
733 obj_elf_section (push
)
736 char *name
, *beg
, *end
;
737 int type
, attr
, dummy
;
743 #ifdef md_flush_pending_output
744 md_flush_pending_output ();
747 previous_section
= now_seg
;
748 previous_subsection
= now_subseg
;
750 s_mri_sect (&mri_type
);
752 #ifdef md_elf_section_change_hook
753 md_elf_section_change_hook ();
759 /* Get name of section. */
761 if (*input_line_pointer
== '"')
763 name
= demand_copy_C_string (&dummy
);
766 ignore_rest_of_line ();
772 end
= input_line_pointer
;
773 while (0 == strchr ("\n\t,; ", *end
))
775 if (end
== input_line_pointer
)
777 as_warn (_("Missing section name"));
778 ignore_rest_of_line ();
782 name
= xmalloc (end
- input_line_pointer
+ 1);
783 memcpy (name
, input_line_pointer
, end
- input_line_pointer
);
784 name
[end
- input_line_pointer
] = '\0';
785 input_line_pointer
= end
;
792 if (*input_line_pointer
== ',')
794 /* Skip the comma. */
795 ++input_line_pointer
;
798 if (*input_line_pointer
== '"')
800 beg
= demand_copy_C_string (&dummy
);
803 ignore_rest_of_line ();
806 attr
|= obj_elf_parse_section_letters (beg
, strlen (beg
));
809 if (*input_line_pointer
== ',')
812 ++input_line_pointer
;
814 c
= *input_line_pointer
;
817 beg
= demand_copy_C_string (&dummy
);
820 ignore_rest_of_line ();
823 type
= obj_elf_section_type (beg
, strlen (beg
));
825 else if (c
== '@' || c
== '%')
827 beg
= ++input_line_pointer
;
828 c
= get_symbol_end ();
829 *input_line_pointer
= c
;
830 type
= obj_elf_section_type (beg
, input_line_pointer
- beg
);
841 if (*input_line_pointer
!= '#')
843 as_warn (_("Bad .section directive - character following name is not '#'"));
844 ignore_rest_of_line ();
847 beg
= ++input_line_pointer
;
848 c
= get_symbol_end ();
849 *input_line_pointer
= c
;
851 attr
|= obj_elf_section_word (beg
, input_line_pointer
- beg
);
855 while (*input_line_pointer
++ == ',');
856 --input_line_pointer
;
860 demand_empty_rest_of_line ();
862 obj_elf_change_section (name
, type
, attr
, push
);
865 /* Change to the .data section. */
871 #ifdef md_flush_pending_output
872 md_flush_pending_output ();
875 previous_section
= now_seg
;
876 previous_subsection
= now_subseg
;
879 #ifdef md_elf_section_change_hook
880 md_elf_section_change_hook ();
884 /* Change to the .text section. */
890 #ifdef md_flush_pending_output
891 md_flush_pending_output ();
894 previous_section
= now_seg
;
895 previous_subsection
= now_subseg
;
898 #ifdef md_elf_section_change_hook
899 md_elf_section_change_hook ();
904 obj_elf_subsection (ignore
)
905 int ignore ATTRIBUTE_UNUSED
;
909 #ifdef md_flush_pending_output
910 md_flush_pending_output ();
913 previous_section
= now_seg
;
914 previous_subsection
= now_subseg
;
916 temp
= get_absolute_expression ();
917 subseg_set (now_seg
, (subsegT
) temp
);
918 demand_empty_rest_of_line ();
920 #ifdef md_elf_section_change_hook
921 md_elf_section_change_hook ();
925 /* This can be called from the processor backends if they change
929 obj_elf_section_change_hook ()
931 previous_section
= now_seg
;
932 previous_subsection
= now_subseg
;
936 obj_elf_previous (ignore
)
937 int ignore ATTRIBUTE_UNUSED
;
942 if (previous_section
== 0)
944 as_bad (_(".previous without corresponding .section; ignored"));
948 #ifdef md_flush_pending_output
949 md_flush_pending_output ();
952 new_section
= previous_section
;
953 new_subsection
= previous_subsection
;
954 previous_section
= now_seg
;
955 previous_subsection
= now_subseg
;
956 subseg_set (new_section
, new_subsection
);
958 #ifdef md_elf_section_change_hook
959 md_elf_section_change_hook ();
964 obj_elf_popsection (xxx
)
965 int xxx ATTRIBUTE_UNUSED
;
967 struct section_stack
*top
= section_stack
;
971 as_bad (_(".popsection without corresponding .pushsection; ignored"));
975 #ifdef md_flush_pending_output
976 md_flush_pending_output ();
979 section_stack
= top
->next
;
980 previous_section
= top
->prev_seg
;
981 previous_subsection
= top
->prev_subseg
;
982 subseg_set (top
->seg
, top
->subseg
);
985 #ifdef md_elf_section_change_hook
986 md_elf_section_change_hook ();
991 obj_elf_line (ignore
)
992 int ignore ATTRIBUTE_UNUSED
;
994 /* Assume delimiter is part of expression. BSD4.2 as fails with
995 delightful bug, so we are not being incompatible here. */
996 new_logical_line ((char *) NULL
, (int) (get_absolute_expression ()));
997 demand_empty_rest_of_line ();
1000 /* This handles the .symver pseudo-op, which is used to specify a
1001 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1002 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1003 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1004 with the same value as the symbol NAME. */
1007 obj_elf_symver (ignore
)
1008 int ignore ATTRIBUTE_UNUSED
;
1014 name
= input_line_pointer
;
1015 c
= get_symbol_end ();
1017 sym
= symbol_find_or_make (name
);
1019 *input_line_pointer
= c
;
1021 if (symbol_get_obj (sym
)->versioned_name
!= NULL
)
1023 as_bad (_("multiple .symver directives for symbol `%s'"),
1025 ignore_rest_of_line ();
1030 if (*input_line_pointer
!= ',')
1032 as_bad (_("expected comma after name in .symver"));
1033 ignore_rest_of_line ();
1037 ++input_line_pointer
;
1038 name
= input_line_pointer
;
1041 c
= get_symbol_end ();
1042 if (c
!= ELF_VER_CHR
)
1044 *input_line_pointer
++ = c
;
1047 symbol_get_obj (sym
)->versioned_name
= xstrdup (name
);
1049 *input_line_pointer
= c
;
1051 if (strchr (symbol_get_obj (sym
)->versioned_name
, ELF_VER_CHR
) == NULL
)
1053 as_bad (_("missing version name in `%s' for symbol `%s'"),
1054 symbol_get_obj (sym
)->versioned_name
, S_GET_NAME (sym
));
1055 ignore_rest_of_line ();
1059 demand_empty_rest_of_line ();
1062 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1063 to the linker the hierarchy in which a particular table resides. The
1064 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1067 obj_elf_vtable_inherit (ignore
)
1068 int ignore ATTRIBUTE_UNUSED
;
1070 char *cname
, *pname
;
1071 symbolS
*csym
, *psym
;
1074 if (*input_line_pointer
== '#')
1075 ++input_line_pointer
;
1077 cname
= input_line_pointer
;
1078 c
= get_symbol_end ();
1079 csym
= symbol_find (cname
);
1081 /* GCFIXME: should check that we don't have two .vtable_inherits for
1082 the same child symbol. Also, we can currently only do this if the
1083 child symbol is already exists and is placed in a fragment. */
1085 if (csym
== NULL
|| symbol_get_frag (csym
) == NULL
)
1087 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1092 *input_line_pointer
= c
;
1095 if (*input_line_pointer
!= ',')
1097 as_bad ("expected comma after name in .vtable_inherit");
1098 ignore_rest_of_line ();
1102 ++input_line_pointer
;
1105 if (*input_line_pointer
== '#')
1106 ++input_line_pointer
;
1108 if (input_line_pointer
[0] == '0'
1109 && (input_line_pointer
[1] == '\0'
1110 || isspace ((unsigned char) input_line_pointer
[1])))
1112 psym
= section_symbol (absolute_section
);
1113 ++input_line_pointer
;
1117 pname
= input_line_pointer
;
1118 c
= get_symbol_end ();
1119 psym
= symbol_find_or_make (pname
);
1120 *input_line_pointer
= c
;
1123 demand_empty_rest_of_line ();
1128 assert (symbol_get_value_expression (csym
)->X_op
== O_constant
);
1129 fix_new (symbol_get_frag (csym
),
1130 symbol_get_value_expression (csym
)->X_add_number
, 0, psym
, 0, 0,
1131 BFD_RELOC_VTABLE_INHERIT
);
1134 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1135 to the linker that a vtable slot was used. The syntax is
1136 ".vtable_entry tablename, offset". */
1139 obj_elf_vtable_entry (ignore
)
1140 int ignore ATTRIBUTE_UNUSED
;
1147 if (*input_line_pointer
== '#')
1148 ++input_line_pointer
;
1150 name
= input_line_pointer
;
1151 c
= get_symbol_end ();
1152 sym
= symbol_find_or_make (name
);
1153 *input_line_pointer
= c
;
1156 if (*input_line_pointer
!= ',')
1158 as_bad ("expected comma after name in .vtable_entry");
1159 ignore_rest_of_line ();
1163 ++input_line_pointer
;
1164 if (*input_line_pointer
== '#')
1165 ++input_line_pointer
;
1167 offset
= get_absolute_expression ();
1169 fix_new (frag_now
, frag_now_fix (), 0, sym
, offset
, 0,
1170 BFD_RELOC_VTABLE_ENTRY
);
1172 demand_empty_rest_of_line ();
1176 obj_read_begin_hook ()
1178 #ifdef NEED_ECOFF_DEBUG
1179 if (ECOFF_DEBUGGING
)
1180 ecoff_read_begin_hook ();
1185 obj_symbol_new_hook (symbolP
)
1188 struct elf_obj_sy
*sy_obj
;
1190 sy_obj
= symbol_get_obj (symbolP
);
1191 sy_obj
->size
= NULL
;
1192 sy_obj
->versioned_name
= NULL
;
1194 #ifdef NEED_ECOFF_DEBUG
1195 if (ECOFF_DEBUGGING
)
1196 ecoff_symbol_new_hook (symbolP
);
1201 obj_elf_version (ignore
)
1202 int ignore ATTRIBUTE_UNUSED
;
1208 asection
*seg
= now_seg
;
1209 subsegT subseg
= now_subseg
;
1210 Elf_Internal_Note i_note
;
1211 Elf_External_Note e_note
;
1212 asection
*note_secp
= (asection
*) NULL
;
1216 if (*input_line_pointer
== '\"')
1218 ++input_line_pointer
; /* -> 1st char of string. */
1219 name
= input_line_pointer
;
1221 while (is_a_char (c
= next_char_of_string ()))
1223 c
= *input_line_pointer
;
1224 *input_line_pointer
= '\0';
1225 *(input_line_pointer
- 1) = '\0';
1226 *input_line_pointer
= c
;
1228 /* create the .note section */
1230 note_secp
= subseg_new (".note", 0);
1231 bfd_set_section_flags (stdoutput
,
1233 SEC_HAS_CONTENTS
| SEC_READONLY
);
1235 /* process the version string */
1237 len
= strlen (name
);
1239 i_note
.namesz
= ((len
+ 1) + 3) & ~3; /* round this to word boundary */
1240 i_note
.descsz
= 0; /* no description */
1241 i_note
.type
= NT_VERSION
;
1242 p
= frag_more (sizeof (e_note
.namesz
));
1243 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
1244 p
= frag_more (sizeof (e_note
.descsz
));
1245 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
1246 p
= frag_more (sizeof (e_note
.type
));
1247 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
1249 for (i
= 0; i
< len
; i
++)
1253 FRAG_APPEND_1_CHAR (ch
);
1256 frag_align (2, 0, 0);
1258 subseg_set (seg
, subseg
);
1262 as_bad (_("Expected quoted string"));
1264 demand_empty_rest_of_line ();
1268 obj_elf_size (ignore
)
1269 int ignore ATTRIBUTE_UNUSED
;
1271 char *name
= input_line_pointer
;
1272 char c
= get_symbol_end ();
1277 p
= input_line_pointer
;
1280 if (*input_line_pointer
!= ',')
1283 as_bad (_("expected comma after name `%s' in .size directive"), name
);
1285 ignore_rest_of_line ();
1288 input_line_pointer
++;
1290 if (exp
.X_op
== O_absent
)
1292 as_bad (_("missing expression in .size directive"));
1293 exp
.X_op
= O_constant
;
1294 exp
.X_add_number
= 0;
1297 sym
= symbol_find_or_make (name
);
1299 if (exp
.X_op
== O_constant
)
1300 S_SET_SIZE (sym
, exp
.X_add_number
);
1303 symbol_get_obj (sym
)->size
=
1304 (expressionS
*) xmalloc (sizeof (expressionS
));
1305 *symbol_get_obj (sym
)->size
= exp
;
1307 demand_empty_rest_of_line ();
1310 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1311 There are four syntaxes:
1313 The first (used on Solaris) is
1315 The second (used on UnixWare) is
1317 The third (reportedly to be used on Irix 6.0) is
1319 The fourth (used on NetBSD/Arm and Linux/ARM) is
1324 obj_elf_type (ignore
)
1325 int ignore ATTRIBUTE_UNUSED
;
1330 const char *typename
;
1333 name
= input_line_pointer
;
1334 c
= get_symbol_end ();
1335 sym
= symbol_find_or_make (name
);
1336 *input_line_pointer
= c
;
1339 if (*input_line_pointer
== ',')
1340 ++input_line_pointer
;
1343 if ( *input_line_pointer
== '#'
1344 || *input_line_pointer
== '@'
1345 || *input_line_pointer
== '%')
1346 ++input_line_pointer
;
1348 typename
= input_line_pointer
;
1349 c
= get_symbol_end ();
1352 if (strcmp (typename
, "function") == 0
1353 || strcmp (typename
, "STT_FUNC") == 0)
1354 type
= BSF_FUNCTION
;
1355 else if (strcmp (typename
, "object") == 0
1356 || strcmp (typename
, "STT_OBJECT") == 0)
1359 as_bad (_("ignoring unrecognized symbol type \"%s\""), typename
);
1361 *input_line_pointer
= c
;
1363 symbol_get_bfdsym (sym
)->flags
|= type
;
1365 demand_empty_rest_of_line ();
1369 obj_elf_ident (ignore
)
1370 int ignore ATTRIBUTE_UNUSED
;
1372 static segT comment_section
;
1373 segT old_section
= now_seg
;
1374 int old_subsection
= now_subseg
;
1376 #ifdef md_flush_pending_output
1377 md_flush_pending_output ();
1380 if (!comment_section
)
1383 comment_section
= subseg_new (".comment", 0);
1384 bfd_set_section_flags (stdoutput
, comment_section
,
1385 SEC_READONLY
| SEC_HAS_CONTENTS
);
1390 subseg_set (comment_section
, 0);
1392 subseg_set (old_section
, old_subsection
);
1395 #ifdef INIT_STAB_SECTION
1397 /* The first entry in a .stabs section is special. */
1400 obj_elf_init_stab_section (seg
)
1406 unsigned int stroff
;
1408 /* Force the section to align to a longword boundary. Without this,
1409 UnixWare ar crashes. */
1410 bfd_set_section_alignment (stdoutput
, seg
, 2);
1412 /* Make space for this first symbol. */
1416 as_where (&file
, (unsigned int *) NULL
);
1417 stabstr_name
= (char *) alloca (strlen (segment_name (seg
)) + 4);
1418 strcpy (stabstr_name
, segment_name (seg
));
1419 strcat (stabstr_name
, "str");
1420 stroff
= get_stab_string_offset (file
, stabstr_name
);
1422 md_number_to_chars (p
, stroff
, 4);
1423 seg_info (seg
)->stabu
.p
= p
;
1428 /* Fill in the counts in the first entry in a .stabs section. */
1431 adjust_stab_sections (abfd
, sec
, xxx
)
1434 PTR xxx ATTRIBUTE_UNUSED
;
1441 if (strncmp (".stab", sec
->name
, 5))
1443 if (!strcmp ("str", sec
->name
+ strlen (sec
->name
) - 3))
1446 name
= (char *) alloca (strlen (sec
->name
) + 4);
1447 strcpy (name
, sec
->name
);
1448 strcat (name
, "str");
1449 strsec
= bfd_get_section_by_name (abfd
, name
);
1451 strsz
= bfd_section_size (abfd
, strsec
);
1454 nsyms
= bfd_section_size (abfd
, sec
) / 12 - 1;
1456 p
= seg_info (sec
)->stabu
.p
;
1459 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
1460 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
1463 #ifdef NEED_ECOFF_DEBUG
1465 /* This function is called by the ECOFF code. It is supposed to
1466 record the external symbol information so that the backend can
1467 write it out correctly. The ELF backend doesn't actually handle
1468 this at the moment, so we do it ourselves. We save the information
1472 elf_ecoff_set_ext (sym
, ext
)
1474 struct ecoff_extr
*ext
;
1476 symbol_get_bfdsym (sym
)->udata
.p
= (PTR
) ext
;
1479 /* This function is called by bfd_ecoff_debug_externals. It is
1480 supposed to *EXT to the external symbol information, and return
1481 whether the symbol should be used at all. */
1484 elf_get_extr (sym
, ext
)
1488 if (sym
->udata
.p
== NULL
)
1490 *ext
= *(EXTR
*) sym
->udata
.p
;
1494 /* This function is called by bfd_ecoff_debug_externals. It has
1495 nothing to do for ELF. */
1499 elf_set_index (sym
, indx
)
1500 asymbol
*sym ATTRIBUTE_UNUSED
;
1501 bfd_size_type indx ATTRIBUTE_UNUSED
;
1505 #endif /* NEED_ECOFF_DEBUG */
1508 elf_frob_symbol (symp
, puntp
)
1512 struct elf_obj_sy
*sy_obj
;
1514 #ifdef NEED_ECOFF_DEBUG
1515 if (ECOFF_DEBUGGING
)
1516 ecoff_frob_symbol (symp
);
1519 sy_obj
= symbol_get_obj (symp
);
1521 if (sy_obj
->size
!= NULL
)
1523 switch (sy_obj
->size
->X_op
)
1527 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1528 + sy_obj
->size
->X_add_number
1529 - S_GET_VALUE (sy_obj
->size
->X_op_symbol
)));
1533 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1534 + sy_obj
->size
->X_add_number
));
1537 as_bad (_(".size expression too complicated to fix up"));
1540 free (sy_obj
->size
);
1541 sy_obj
->size
= NULL
;
1544 if (sy_obj
->versioned_name
!= NULL
)
1546 /* This symbol was given a new name with the .symver directive.
1548 If this is an external reference, just rename the symbol to
1549 include the version string. This will make the relocs be
1550 against the correct versioned symbol.
1552 If this is a definition, add an alias. FIXME: Using an alias
1553 will permit the debugging information to refer to the right
1554 symbol. However, it's not clear whether it is the best
1557 if (! S_IS_DEFINED (symp
))
1561 /* Verify that the name isn't using the @@ syntax--this is
1562 reserved for definitions of the default version to link
1564 p
= strchr (sy_obj
->versioned_name
, ELF_VER_CHR
);
1566 if (p
[1] == ELF_VER_CHR
)
1568 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1569 sy_obj
->versioned_name
);
1572 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1578 /* FIXME: Creating a new symbol here is risky. We're in the
1579 final loop over the symbol table. We can get away with
1580 it only because the symbol goes to the end of the list,
1581 where the loop will still see it. It would probably be
1582 better to do this in obj_frob_file_before_adjust. */
1584 symp2
= symbol_find_or_make (sy_obj
->versioned_name
);
1586 /* Now we act as though we saw symp2 = sym. */
1588 S_SET_SEGMENT (symp2
, S_GET_SEGMENT (symp
));
1590 /* Subtracting out the frag address here is a hack because
1591 we are in the middle of the final loop. */
1594 - symbol_get_frag (symp
)->fr_address
));
1596 symbol_set_frag (symp2
, symbol_get_frag (symp
));
1598 /* This will copy over the size information. */
1599 copy_symbol_attributes (symp2
, symp
);
1601 if (S_IS_WEAK (symp
))
1604 if (S_IS_EXTERNAL (symp
))
1605 S_SET_EXTERNAL (symp2
);
1609 /* Double check weak symbols. */
1610 if (S_IS_WEAK (symp
))
1612 if (S_IS_COMMON (symp
))
1613 as_bad (_("Symbol `%s' can not be both weak and common"),
1618 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1619 any undefined non-function symbol to STT_OBJECT. We try to be
1620 compatible, since newer Irix 5 and 6 linkers care. However, we
1621 only set undefined symbols to be STT_OBJECT if we are on Irix,
1622 because that is the only time gcc will generate the necessary
1623 .global directives to mark functions. */
1625 if (S_IS_COMMON (symp
))
1626 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1628 if (strstr (TARGET_OS
, "irix") != NULL
1629 && ! S_IS_DEFINED (symp
)
1630 && (symbol_get_bfdsym (symp
)->flags
& BSF_FUNCTION
) == 0)
1631 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1635 /* Frob the PowerPC, so that the symbol always has object type
1636 if it is not some other type. VxWorks needs this. */
1637 if ((symbol_get_bfdsym (symp
)->flags
1638 & (BSF_FUNCTION
| BSF_FILE
| BSF_SECTION_SYM
)) == 0
1639 && S_IS_DEFINED (symp
))
1640 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1647 bfd_map_over_sections (stdoutput
, adjust_stab_sections
, (PTR
) 0);
1649 #ifdef elf_tc_final_processing
1650 elf_tc_final_processing ();
1654 /* It is required that we let write_relocs have the opportunity to
1655 optimize away fixups before output has begun, since it is possible
1656 to eliminate all fixups for a section and thus we never should
1657 have generated the relocation section. */
1660 elf_frob_file_after_relocs ()
1662 #ifdef NEED_ECOFF_DEBUG
1663 if (ECOFF_DEBUGGING
)
1664 /* Generate the ECOFF debugging information. */
1666 const struct ecoff_debug_swap
*debug_swap
;
1667 struct ecoff_debug_info debug
;
1672 = get_elf_backend_data (stdoutput
)->elf_backend_ecoff_debug_swap
;
1673 know (debug_swap
!= (const struct ecoff_debug_swap
*) NULL
);
1674 ecoff_build_debug (&debug
.symbolic_header
, &buf
, debug_swap
);
1676 /* Set up the pointers in debug. */
1677 #define SET(ptr, offset, type) \
1678 debug.ptr = (type) (buf + debug.symbolic_header.offset)
1680 SET (line
, cbLineOffset
, unsigned char *);
1681 SET (external_dnr
, cbDnOffset
, PTR
);
1682 SET (external_pdr
, cbPdOffset
, PTR
);
1683 SET (external_sym
, cbSymOffset
, PTR
);
1684 SET (external_opt
, cbOptOffset
, PTR
);
1685 SET (external_aux
, cbAuxOffset
, union aux_ext
*);
1686 SET (ss
, cbSsOffset
, char *);
1687 SET (external_fdr
, cbFdOffset
, PTR
);
1688 SET (external_rfd
, cbRfdOffset
, PTR
);
1689 /* ssext and external_ext are set up just below. */
1693 /* Set up the external symbols. */
1694 debug
.ssext
= debug
.ssext_end
= NULL
;
1695 debug
.external_ext
= debug
.external_ext_end
= NULL
;
1696 if (! bfd_ecoff_debug_externals (stdoutput
, &debug
, debug_swap
, true,
1697 elf_get_extr
, elf_set_index
))
1698 as_fatal (_("Failed to set up debugging information: %s"),
1699 bfd_errmsg (bfd_get_error ()));
1701 sec
= bfd_get_section_by_name (stdoutput
, ".mdebug");
1702 assert (sec
!= NULL
);
1704 know (stdoutput
->output_has_begun
== false);
1706 /* We set the size of the section, call bfd_set_section_contents
1707 to force the ELF backend to allocate a file position, and then
1708 write out the data. FIXME: Is this really the best way to do
1710 sec
->_raw_size
= bfd_ecoff_debug_size (stdoutput
, &debug
, debug_swap
);
1712 /* Pass BUF to bfd_set_section_contents because this will
1713 eventually become a call to fwrite, and ISO C prohibits
1714 passing a NULL pointer to a stdio function even if the
1715 pointer will not be used. */
1716 if (! bfd_set_section_contents (stdoutput
, sec
, (PTR
) buf
,
1717 (file_ptr
) 0, (bfd_size_type
) 0))
1718 as_fatal (_("Can't start writing .mdebug section: %s"),
1719 bfd_errmsg (bfd_get_error ()));
1721 know (stdoutput
->output_has_begun
== true);
1722 know (sec
->filepos
!= 0);
1724 if (! bfd_ecoff_write_debug (stdoutput
, &debug
, debug_swap
,
1726 as_fatal (_("Could not write .mdebug section: %s"),
1727 bfd_errmsg (bfd_get_error ()));
1729 #endif /* NEED_ECOFF_DEBUG */
1734 /* Heavily plagarized from obj_elf_version. The idea is to emit the
1735 SCO specific identifier in the .notes section to satisfy the SCO
1738 This looks more complicated than it really is. As opposed to the
1739 "obvious" solution, this should handle the cross dev cases
1740 correctly. (i.e, hosting on a 64 bit big endian processor, but
1741 generating SCO Elf code) Efficiency isn't a concern, as there
1742 should be exactly one of these sections per object module.
1744 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
1747 int_32 namesz = 4 ; Name size
1748 int_32 descsz = 12 ; Descriptive information
1750 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
1751 int_32 version = (major ver # << 16) | version of tools ;
1752 int_32 source = (tool_id << 16 ) | 1 ;
1753 int_32 info = 0 ; These are set by the SCO tools, but we
1754 don't know enough about the source
1755 environment to set them. SCO ld currently
1756 ignores them, and recommends we set them
1759 #define SCO_MAJOR_VERSION 0x1
1760 #define SCO_MINOR_VERSION 0x1
1770 asection
*seg
= now_seg
;
1771 subsegT subseg
= now_subseg
;
1772 Elf_Internal_Note i_note
;
1773 Elf_External_Note e_note
;
1774 asection
*note_secp
= (asection
*) NULL
;
1777 /* create the .note section */
1779 note_secp
= subseg_new (".note", 0);
1780 bfd_set_section_flags (stdoutput
,
1782 SEC_HAS_CONTENTS
| SEC_READONLY
);
1784 /* process the version string */
1787 i_note
.descsz
= 12; /* 12 descriptive bytes */
1788 i_note
.type
= NT_VERSION
; /* Contains a version string */
1790 p
= frag_more (sizeof (i_note
.namesz
));
1791 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
1793 p
= frag_more (sizeof (i_note
.descsz
));
1794 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
1796 p
= frag_more (sizeof (i_note
.type
));
1797 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
1802 /* Note: this is the version number of the ELF we're representing */
1804 md_number_to_chars (p
, (SCO_MAJOR_VERSION
<< 16) | (SCO_MINOR_VERSION
), 4);
1806 /* Here, we pick a magic number for ourselves (yes, I "registered"
1807 it with SCO. The bottom bit shows that we are compat with the
1810 md_number_to_chars (p
, 0x4c520000 | 0x0001, 4);
1812 /* If we knew (or cared) what the source language options were, we'd
1813 fill them in here. SCO has given us permission to ignore these
1814 and just set them to zero. */
1816 md_number_to_chars (p
, 0x0000, 4);
1818 frag_align (2, 0, 0);
1820 /* We probably can't restore the current segment, for there likely
1823 subseg_set (seg
, subseg
);
1827 #endif /* SCO_ELF */
1829 const struct format_ops elf_format_ops
=
1831 bfd_target_elf_flavour
,
1836 elf_frob_file_after_relocs
,
1837 elf_s_get_size
, elf_s_set_size
,
1838 elf_s_get_align
, elf_s_set_align
,
1839 elf_copy_symbol_attributes
,
1840 #ifdef NEED_ECOFF_DEBUG
1841 ecoff_generate_asm_lineno
,
1845 0, /* process_stab */
1847 elf_sec_sym_ok_for_reloc
,
1849 #ifdef NEED_ECOFF_DEBUG
1854 obj_read_begin_hook
,
1855 obj_symbol_new_hook
,