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
} /* 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
) != 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
)
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
)
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
)
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
)
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
)
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
)
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
)
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
)
1069 char *cname
, *pname
;
1070 symbolS
*csym
, *psym
;
1073 if (*input_line_pointer
== '#')
1074 ++input_line_pointer
;
1076 cname
= input_line_pointer
;
1077 c
= get_symbol_end ();
1078 csym
= symbol_find (cname
);
1080 /* GCFIXME: should check that we don't have two .vtable_inherits for
1081 the same child symbol. Also, we can currently only do this if the
1082 child symbol is already exists and is placed in a fragment. */
1084 if (csym
== NULL
|| symbol_get_frag (csym
) == NULL
)
1086 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1091 *input_line_pointer
= c
;
1094 if (*input_line_pointer
!= ',')
1096 as_bad ("expected comma after name in .vtable_inherit");
1097 ignore_rest_of_line ();
1101 ++input_line_pointer
;
1104 if (*input_line_pointer
== '#')
1105 ++input_line_pointer
;
1107 if (input_line_pointer
[0] == '0'
1108 && (input_line_pointer
[1] == '\0'
1109 || isspace ((unsigned char) input_line_pointer
[1])))
1111 psym
= section_symbol (absolute_section
);
1112 ++input_line_pointer
;
1116 pname
= input_line_pointer
;
1117 c
= get_symbol_end ();
1118 psym
= symbol_find_or_make (pname
);
1119 *input_line_pointer
= c
;
1122 demand_empty_rest_of_line ();
1127 assert (symbol_get_value_expression (csym
)->X_op
== O_constant
);
1128 fix_new (symbol_get_frag (csym
),
1129 symbol_get_value_expression (csym
)->X_add_number
, 0, psym
, 0, 0,
1130 BFD_RELOC_VTABLE_INHERIT
);
1133 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1134 to the linker that a vtable slot was used. The syntax is
1135 ".vtable_entry tablename, offset". */
1138 obj_elf_vtable_entry (ignore
)
1145 if (*input_line_pointer
== '#')
1146 ++input_line_pointer
;
1148 name
= input_line_pointer
;
1149 c
= get_symbol_end ();
1150 sym
= symbol_find_or_make (name
);
1151 *input_line_pointer
= c
;
1154 if (*input_line_pointer
!= ',')
1156 as_bad ("expected comma after name in .vtable_entry");
1157 ignore_rest_of_line ();
1161 ++input_line_pointer
;
1162 if (*input_line_pointer
== '#')
1163 ++input_line_pointer
;
1165 offset
= get_absolute_expression ();
1167 fix_new (frag_now
, frag_now_fix (), 0, sym
, offset
, 0,
1168 BFD_RELOC_VTABLE_ENTRY
);
1170 demand_empty_rest_of_line ();
1174 obj_read_begin_hook ()
1176 #ifdef NEED_ECOFF_DEBUG
1177 if (ECOFF_DEBUGGING
)
1178 ecoff_read_begin_hook ();
1183 obj_symbol_new_hook (symbolP
)
1186 struct elf_obj_sy
*sy_obj
;
1188 sy_obj
= symbol_get_obj (symbolP
);
1189 sy_obj
->size
= NULL
;
1190 sy_obj
->versioned_name
= NULL
;
1192 #ifdef NEED_ECOFF_DEBUG
1193 if (ECOFF_DEBUGGING
)
1194 ecoff_symbol_new_hook (symbolP
);
1199 obj_elf_version (ignore
)
1206 asection
*seg
= now_seg
;
1207 subsegT subseg
= now_subseg
;
1208 Elf_Internal_Note i_note
;
1209 Elf_External_Note e_note
;
1210 asection
*note_secp
= (asection
*) NULL
;
1214 if (*input_line_pointer
== '\"')
1216 ++input_line_pointer
; /* -> 1st char of string. */
1217 name
= input_line_pointer
;
1219 while (is_a_char (c
= next_char_of_string ()))
1221 c
= *input_line_pointer
;
1222 *input_line_pointer
= '\0';
1223 *(input_line_pointer
- 1) = '\0';
1224 *input_line_pointer
= c
;
1226 /* create the .note section */
1228 note_secp
= subseg_new (".note", 0);
1229 bfd_set_section_flags (stdoutput
,
1231 SEC_HAS_CONTENTS
| SEC_READONLY
);
1233 /* process the version string */
1235 len
= strlen (name
);
1237 i_note
.namesz
= ((len
+ 1) + 3) & ~3; /* round this to word boundary */
1238 i_note
.descsz
= 0; /* no description */
1239 i_note
.type
= NT_VERSION
;
1240 p
= frag_more (sizeof (e_note
.namesz
));
1241 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
1242 p
= frag_more (sizeof (e_note
.descsz
));
1243 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
1244 p
= frag_more (sizeof (e_note
.type
));
1245 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
1247 for (i
= 0; i
< len
; i
++)
1251 FRAG_APPEND_1_CHAR (ch
);
1254 frag_align (2, 0, 0);
1256 subseg_set (seg
, subseg
);
1260 as_bad (_("Expected quoted string"));
1262 demand_empty_rest_of_line ();
1266 obj_elf_size (ignore
)
1269 char *name
= input_line_pointer
;
1270 char c
= get_symbol_end ();
1275 p
= input_line_pointer
;
1278 if (*input_line_pointer
!= ',')
1281 as_bad (_("expected comma after name `%s' in .size directive"), name
);
1283 ignore_rest_of_line ();
1286 input_line_pointer
++;
1288 if (exp
.X_op
== O_absent
)
1290 as_bad (_("missing expression in .size directive"));
1291 exp
.X_op
= O_constant
;
1292 exp
.X_add_number
= 0;
1295 sym
= symbol_find_or_make (name
);
1297 if (exp
.X_op
== O_constant
)
1298 S_SET_SIZE (sym
, exp
.X_add_number
);
1301 symbol_get_obj (sym
)->size
=
1302 (expressionS
*) xmalloc (sizeof (expressionS
));
1303 *symbol_get_obj (sym
)->size
= exp
;
1305 demand_empty_rest_of_line ();
1308 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1309 There are four syntaxes:
1311 The first (used on Solaris) is
1313 The second (used on UnixWare) is
1315 The third (reportedly to be used on Irix 6.0) is
1317 The fourth (used on NetBSD/Arm and Linux/ARM) is
1322 obj_elf_type (ignore
)
1328 const char *typename
;
1331 name
= input_line_pointer
;
1332 c
= get_symbol_end ();
1333 sym
= symbol_find_or_make (name
);
1334 *input_line_pointer
= c
;
1337 if (*input_line_pointer
== ',')
1338 ++input_line_pointer
;
1341 if ( *input_line_pointer
== '#'
1342 || *input_line_pointer
== '@'
1343 || *input_line_pointer
== '%')
1344 ++input_line_pointer
;
1346 typename
= input_line_pointer
;
1347 c
= get_symbol_end ();
1350 if (strcmp (typename
, "function") == 0
1351 || strcmp (typename
, "STT_FUNC") == 0)
1352 type
= BSF_FUNCTION
;
1353 else if (strcmp (typename
, "object") == 0
1354 || strcmp (typename
, "STT_OBJECT") == 0)
1357 as_bad (_("ignoring unrecognized symbol type \"%s\""), typename
);
1359 *input_line_pointer
= c
;
1361 symbol_get_bfdsym (sym
)->flags
|= type
;
1363 demand_empty_rest_of_line ();
1367 obj_elf_ident (ignore
)
1370 static segT comment_section
;
1371 segT old_section
= now_seg
;
1372 int old_subsection
= now_subseg
;
1374 if (!comment_section
)
1377 comment_section
= subseg_new (".comment", 0);
1378 bfd_set_section_flags (stdoutput
, comment_section
,
1379 SEC_READONLY
| SEC_HAS_CONTENTS
);
1384 subseg_set (comment_section
, 0);
1386 subseg_set (old_section
, old_subsection
);
1389 #ifdef INIT_STAB_SECTION
1391 /* The first entry in a .stabs section is special. */
1394 obj_elf_init_stab_section (seg
)
1400 unsigned int stroff
;
1402 /* Force the section to align to a longword boundary. Without this,
1403 UnixWare ar crashes. */
1404 bfd_set_section_alignment (stdoutput
, seg
, 2);
1406 /* Make space for this first symbol. */
1410 as_where (&file
, (unsigned int *) NULL
);
1411 stabstr_name
= (char *) alloca (strlen (segment_name (seg
)) + 4);
1412 strcpy (stabstr_name
, segment_name (seg
));
1413 strcat (stabstr_name
, "str");
1414 stroff
= get_stab_string_offset (file
, stabstr_name
);
1416 md_number_to_chars (p
, stroff
, 4);
1417 seg_info (seg
)->stabu
.p
= p
;
1422 /* Fill in the counts in the first entry in a .stabs section. */
1425 adjust_stab_sections (abfd
, sec
, xxx
)
1435 if (strncmp (".stab", sec
->name
, 5))
1437 if (!strcmp ("str", sec
->name
+ strlen (sec
->name
) - 3))
1440 name
= (char *) alloca (strlen (sec
->name
) + 4);
1441 strcpy (name
, sec
->name
);
1442 strcat (name
, "str");
1443 strsec
= bfd_get_section_by_name (abfd
, name
);
1445 strsz
= bfd_section_size (abfd
, strsec
);
1448 nsyms
= bfd_section_size (abfd
, sec
) / 12 - 1;
1450 p
= seg_info (sec
)->stabu
.p
;
1453 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
1454 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
1457 #ifdef NEED_ECOFF_DEBUG
1459 /* This function is called by the ECOFF code. It is supposed to
1460 record the external symbol information so that the backend can
1461 write it out correctly. The ELF backend doesn't actually handle
1462 this at the moment, so we do it ourselves. We save the information
1466 elf_ecoff_set_ext (sym
, ext
)
1468 struct ecoff_extr
*ext
;
1470 symbol_get_bfdsym (sym
)->udata
.p
= (PTR
) ext
;
1473 /* This function is called by bfd_ecoff_debug_externals. It is
1474 supposed to *EXT to the external symbol information, and return
1475 whether the symbol should be used at all. */
1478 elf_get_extr (sym
, ext
)
1482 if (sym
->udata
.p
== NULL
)
1484 *ext
= *(EXTR
*) sym
->udata
.p
;
1488 /* This function is called by bfd_ecoff_debug_externals. It has
1489 nothing to do for ELF. */
1493 elf_set_index (sym
, indx
)
1499 #endif /* NEED_ECOFF_DEBUG */
1502 elf_frob_symbol (symp
, puntp
)
1506 struct elf_obj_sy
*sy_obj
;
1508 #ifdef NEED_ECOFF_DEBUG
1509 if (ECOFF_DEBUGGING
)
1510 ecoff_frob_symbol (symp
);
1513 sy_obj
= symbol_get_obj (symp
);
1515 if (sy_obj
->size
!= NULL
)
1517 switch (sy_obj
->size
->X_op
)
1521 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1522 + sy_obj
->size
->X_add_number
1523 - S_GET_VALUE (sy_obj
->size
->X_op_symbol
)));
1527 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1528 + sy_obj
->size
->X_add_number
));
1531 as_bad (_(".size expression too complicated to fix up"));
1534 free (sy_obj
->size
);
1535 sy_obj
->size
= NULL
;
1538 if (sy_obj
->versioned_name
!= NULL
)
1540 /* This symbol was given a new name with the .symver directive.
1542 If this is an external reference, just rename the symbol to
1543 include the version string. This will make the relocs be
1544 against the correct versioned symbol.
1546 If this is a definition, add an alias. FIXME: Using an alias
1547 will permit the debugging information to refer to the right
1548 symbol. However, it's not clear whether it is the best
1551 if (! S_IS_DEFINED (symp
))
1555 /* Verify that the name isn't using the @@ syntax--this is
1556 reserved for definitions of the default version to link
1558 p
= strchr (sy_obj
->versioned_name
, ELF_VER_CHR
);
1560 if (p
[1] == ELF_VER_CHR
)
1562 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1563 sy_obj
->versioned_name
);
1566 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1572 /* FIXME: Creating a new symbol here is risky. We're in the
1573 final loop over the symbol table. We can get away with
1574 it only because the symbol goes to the end of the list,
1575 where the loop will still see it. It would probably be
1576 better to do this in obj_frob_file_before_adjust. */
1578 symp2
= symbol_find_or_make (sy_obj
->versioned_name
);
1580 /* Now we act as though we saw symp2 = sym. */
1582 S_SET_SEGMENT (symp2
, S_GET_SEGMENT (symp
));
1584 /* Subtracting out the frag address here is a hack because
1585 we are in the middle of the final loop. */
1588 - symbol_get_frag (symp
)->fr_address
));
1590 symbol_set_frag (symp2
, symbol_get_frag (symp
));
1592 /* This will copy over the size information. */
1593 copy_symbol_attributes (symp2
, symp
);
1595 if (S_IS_WEAK (symp
))
1598 if (S_IS_EXTERNAL (symp
))
1599 S_SET_EXTERNAL (symp2
);
1603 /* Double check weak symbols. */
1604 if (S_IS_WEAK (symp
))
1606 if (S_IS_COMMON (symp
))
1607 as_bad (_("Symbol `%s' can not be both weak and common"),
1612 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1613 any undefined non-function symbol to STT_OBJECT. We try to be
1614 compatible, since newer Irix 5 and 6 linkers care. However, we
1615 only set undefined symbols to be STT_OBJECT if we are on Irix,
1616 because that is the only time gcc will generate the necessary
1617 .global directives to mark functions. */
1619 if (S_IS_COMMON (symp
))
1620 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1622 if (strstr (TARGET_OS
, "irix") != NULL
1623 && ! S_IS_DEFINED (symp
)
1624 && (symbol_get_bfdsym (symp
)->flags
& BSF_FUNCTION
) == 0)
1625 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1629 /* Frob the PowerPC, so that the symbol always has object type
1630 if it is not some other type. VxWorks needs this. */
1631 if ((symbol_get_bfdsym (symp
)->flags
1632 & (BSF_FUNCTION
| BSF_FILE
| BSF_SECTION_SYM
)) == 0
1633 && S_IS_DEFINED (symp
))
1634 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1641 bfd_map_over_sections (stdoutput
, adjust_stab_sections
, (PTR
) 0);
1643 #ifdef elf_tc_final_processing
1644 elf_tc_final_processing ();
1648 /* It is required that we let write_relocs have the opportunity to
1649 optimize away fixups before output has begun, since it is possible
1650 to eliminate all fixups for a section and thus we never should
1651 have generated the relocation section. */
1654 elf_frob_file_after_relocs ()
1656 #ifdef NEED_ECOFF_DEBUG
1657 if (ECOFF_DEBUGGING
)
1658 /* Generate the ECOFF debugging information. */
1660 const struct ecoff_debug_swap
*debug_swap
;
1661 struct ecoff_debug_info debug
;
1666 = get_elf_backend_data (stdoutput
)->elf_backend_ecoff_debug_swap
;
1667 know (debug_swap
!= (const struct ecoff_debug_swap
*) NULL
);
1668 ecoff_build_debug (&debug
.symbolic_header
, &buf
, debug_swap
);
1670 /* Set up the pointers in debug. */
1671 #define SET(ptr, offset, type) \
1672 debug.ptr = (type) (buf + debug.symbolic_header.offset)
1674 SET (line
, cbLineOffset
, unsigned char *);
1675 SET (external_dnr
, cbDnOffset
, PTR
);
1676 SET (external_pdr
, cbPdOffset
, PTR
);
1677 SET (external_sym
, cbSymOffset
, PTR
);
1678 SET (external_opt
, cbOptOffset
, PTR
);
1679 SET (external_aux
, cbAuxOffset
, union aux_ext
*);
1680 SET (ss
, cbSsOffset
, char *);
1681 SET (external_fdr
, cbFdOffset
, PTR
);
1682 SET (external_rfd
, cbRfdOffset
, PTR
);
1683 /* ssext and external_ext are set up just below. */
1687 /* Set up the external symbols. */
1688 debug
.ssext
= debug
.ssext_end
= NULL
;
1689 debug
.external_ext
= debug
.external_ext_end
= NULL
;
1690 if (! bfd_ecoff_debug_externals (stdoutput
, &debug
, debug_swap
, true,
1691 elf_get_extr
, elf_set_index
))
1692 as_fatal (_("Failed to set up debugging information: %s"),
1693 bfd_errmsg (bfd_get_error ()));
1695 sec
= bfd_get_section_by_name (stdoutput
, ".mdebug");
1696 assert (sec
!= NULL
);
1698 know (stdoutput
->output_has_begun
== false);
1700 /* We set the size of the section, call bfd_set_section_contents
1701 to force the ELF backend to allocate a file position, and then
1702 write out the data. FIXME: Is this really the best way to do
1704 sec
->_raw_size
= bfd_ecoff_debug_size (stdoutput
, &debug
, debug_swap
);
1706 if (! bfd_set_section_contents (stdoutput
, sec
, (PTR
) NULL
,
1707 (file_ptr
) 0, (bfd_size_type
) 0))
1708 as_fatal (_("Can't start writing .mdebug section: %s"),
1709 bfd_errmsg (bfd_get_error ()));
1711 know (stdoutput
->output_has_begun
== true);
1712 know (sec
->filepos
!= 0);
1714 if (! bfd_ecoff_write_debug (stdoutput
, &debug
, debug_swap
,
1716 as_fatal (_("Could not write .mdebug section: %s"),
1717 bfd_errmsg (bfd_get_error ()));
1719 #endif /* NEED_ECOFF_DEBUG */
1724 /* Heavily plagarized from obj_elf_version. The idea is to emit the
1725 SCO specific identifier in the .notes section to satisfy the SCO
1728 This looks more complicated than it really is. As opposed to the
1729 "obvious" solution, this should handle the cross dev cases
1730 correctly. (i.e, hosting on a 64 bit big endian processor, but
1731 generating SCO Elf code) Efficiency isn't a concern, as there
1732 should be exactly one of these sections per object module.
1734 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
1737 int_32 namesz = 4 ; Name size
1738 int_32 descsz = 12 ; Descriptive information
1740 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
1741 int_32 version = (major ver # << 16) | version of tools ;
1742 int_32 source = (tool_id << 16 ) | 1 ;
1743 int_32 info = 0 ; These are set by the SCO tools, but we
1744 don't know enough about the source
1745 environment to set them. SCO ld currently
1746 ignores them, and recommends we set them
1749 #define SCO_MAJOR_VERSION 0x1
1750 #define SCO_MINOR_VERSION 0x1
1760 asection
*seg
= now_seg
;
1761 subsegT subseg
= now_subseg
;
1762 Elf_Internal_Note i_note
;
1763 Elf_External_Note e_note
;
1764 asection
*note_secp
= (asection
*) NULL
;
1767 /* create the .note section */
1769 note_secp
= subseg_new (".note", 0);
1770 bfd_set_section_flags (stdoutput
,
1772 SEC_HAS_CONTENTS
| SEC_READONLY
);
1774 /* process the version string */
1777 i_note
.descsz
= 12; /* 12 descriptive bytes */
1778 i_note
.type
= NT_VERSION
; /* Contains a version string */
1780 p
= frag_more (sizeof (i_note
.namesz
));
1781 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
1783 p
= frag_more (sizeof (i_note
.descsz
));
1784 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
1786 p
= frag_more (sizeof (i_note
.type
));
1787 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
1792 /* Note: this is the version number of the ELF we're representing */
1794 md_number_to_chars (p
, (SCO_MAJOR_VERSION
<< 16) | (SCO_MINOR_VERSION
), 4);
1796 /* Here, we pick a magic number for ourselves (yes, I "registered"
1797 it with SCO. The bottom bit shows that we are compat with the
1800 md_number_to_chars (p
, 0x4c520000 | 0x0001, 4);
1802 /* If we knew (or cared) what the source language options were, we'd
1803 fill them in here. SCO has given us permission to ignore these
1804 and just set them to zero. */
1806 md_number_to_chars (p
, 0x0000, 4);
1808 frag_align (2, 0, 0);
1810 /* We probably can't restore the current segment, for there likely
1813 subseg_set (seg
, subseg
);
1817 #endif /* SCO_ELF */
1819 const struct format_ops elf_format_ops
=
1821 bfd_target_elf_flavour
,
1826 elf_frob_file_after_relocs
,
1827 elf_s_get_size
, elf_s_set_size
,
1828 elf_s_get_align
, elf_s_set_align
,
1829 elf_copy_symbol_attributes
,
1830 #ifdef NEED_ECOFF_DEBUG
1831 ecoff_generate_asm_lineno
,
1835 0, /* process_stab */
1837 elf_sec_sym_ok_for_reloc
,
1839 #ifdef NEED_ECOFF_DEBUG
1844 obj_read_begin_hook
,
1845 obj_symbol_new_hook
,