1 /* ELF object file format
2 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
3 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"
27 #ifndef ECOFF_DEBUGGING
28 #define ECOFF_DEBUGGING 0
30 #define NEED_ECOFF_DEBUG
33 #ifdef NEED_ECOFF_DEBUG
38 #include "elf/alpha.h"
53 static bfd_vma elf_s_get_size
PARAMS ((symbolS
*));
54 static void elf_s_set_size
PARAMS ((symbolS
*, bfd_vma
));
55 static bfd_vma elf_s_get_align
PARAMS ((symbolS
*));
56 static void elf_s_set_align
PARAMS ((symbolS
*, bfd_vma
));
57 static void elf_s_set_other
PARAMS ((symbolS
*, int));
58 static void elf_copy_symbol_attributes
PARAMS ((symbolS
*, symbolS
*));
59 static int elf_sec_sym_ok_for_reloc
PARAMS ((asection
*));
60 static void adjust_stab_sections
PARAMS ((bfd
*, asection
*, PTR
));
61 static int elf_separate_stab_sections
PARAMS ((void));
62 static void elf_init_stab_section
PARAMS ((segT
));
64 #ifdef NEED_ECOFF_DEBUG
65 static boolean elf_get_extr
PARAMS ((asymbol
*, EXTR
*));
66 static void elf_set_index
PARAMS ((asymbol
*, bfd_size_type
));
69 static void obj_elf_line
PARAMS ((int));
70 void obj_elf_version
PARAMS ((int));
71 static void obj_elf_size
PARAMS ((int));
72 static void obj_elf_type
PARAMS ((int));
73 static void obj_elf_ident
PARAMS ((int));
74 static void obj_elf_weak
PARAMS ((int));
75 static void obj_elf_local
PARAMS ((int));
76 static void obj_elf_visibility
PARAMS ((int));
77 static void obj_elf_symver
PARAMS ((int));
78 static void obj_elf_subsection
PARAMS ((int));
79 static void obj_elf_popsection
PARAMS ((int));
81 static const pseudo_typeS elf_pseudo_table
[] =
83 {"comm", obj_elf_common
, 0},
84 {"common", obj_elf_common
, 1},
85 {"ident", obj_elf_ident
, 0},
86 {"local", obj_elf_local
, 0},
87 {"previous", obj_elf_previous
, 0},
88 {"section", obj_elf_section
, 0},
89 {"section.s", obj_elf_section
, 0},
90 {"sect", obj_elf_section
, 0},
91 {"sect.s", obj_elf_section
, 0},
92 {"pushsection", obj_elf_section
, 1},
93 {"popsection", obj_elf_popsection
, 0},
94 {"size", obj_elf_size
, 0},
95 {"type", obj_elf_type
, 0},
96 {"version", obj_elf_version
, 0},
97 {"weak", obj_elf_weak
, 0},
99 /* These define symbol visibility. */
100 {"internal", obj_elf_visibility
, STV_INTERNAL
},
101 {"hidden", obj_elf_visibility
, STV_HIDDEN
},
102 {"protected", obj_elf_visibility
, STV_PROTECTED
},
104 /* These are used for stabs-in-elf configurations. */
105 {"line", obj_elf_line
, 0},
107 /* This is a GNU extension to handle symbol versions. */
108 {"symver", obj_elf_symver
, 0},
110 /* A GNU extension to change subsection only. */
111 {"subsection", obj_elf_subsection
, 0},
113 /* These are GNU extensions to aid in garbage collecting C++ vtables. */
114 {"vtable_inherit", (void (*) PARAMS ((int))) &obj_elf_vtable_inherit
, 0},
115 {"vtable_entry", (void (*) PARAMS ((int))) &obj_elf_vtable_entry
, 0},
117 /* These are used for dwarf. */
122 /* We need to trap the section changing calls to handle .previous. */
123 {"data", obj_elf_data
, 0},
124 {"text", obj_elf_text
, 0},
130 static const pseudo_typeS ecoff_debug_pseudo_table
[] =
132 #ifdef NEED_ECOFF_DEBUG
133 /* COFF style debugging information for ECOFF. .ln is not used; .loc
135 { "def", ecoff_directive_def
, 0 },
136 { "dim", ecoff_directive_dim
, 0 },
137 { "endef", ecoff_directive_endef
, 0 },
138 { "file", ecoff_directive_file
, 0 },
139 { "scl", ecoff_directive_scl
, 0 },
140 { "tag", ecoff_directive_tag
, 0 },
141 { "val", ecoff_directive_val
, 0 },
143 /* COFF debugging requires pseudo-ops .size and .type, but ELF
144 already has meanings for those. We use .esize and .etype
145 instead. These are only generated by gcc anyhow. */
146 { "esize", ecoff_directive_size
, 0 },
147 { "etype", ecoff_directive_type
, 0 },
149 /* ECOFF specific debugging information. */
150 { "begin", ecoff_directive_begin
, 0 },
151 { "bend", ecoff_directive_bend
, 0 },
152 { "end", ecoff_directive_end
, 0 },
153 { "ent", ecoff_directive_ent
, 0 },
154 { "fmask", ecoff_directive_fmask
, 0 },
155 { "frame", ecoff_directive_frame
, 0 },
156 { "loc", ecoff_directive_loc
, 0 },
157 { "mask", ecoff_directive_mask
, 0 },
159 /* Other ECOFF directives. */
160 { "extern", ecoff_directive_extern
, 0 },
162 /* These are used on Irix. I don't know how to implement them. */
163 { "alias", s_ignore
, 0 },
164 { "bgnb", s_ignore
, 0 },
165 { "endb", s_ignore
, 0 },
166 { "lab", s_ignore
, 0 },
167 { "noalias", s_ignore
, 0 },
168 { "verstamp", s_ignore
, 0 },
169 { "vreg", s_ignore
, 0 },
172 {NULL
, NULL
, 0} /* end sentinel */
176 #include "aout/aout64.h"
178 /* This is called when the assembler starts. */
183 /* Add symbols for the known sections to the symbol table. */
184 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
185 TEXT_SECTION_NAME
)));
186 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
187 DATA_SECTION_NAME
)));
188 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput
,
195 pop_insert (elf_pseudo_table
);
197 pop_insert (ecoff_debug_pseudo_table
);
204 return S_GET_SIZE (sym
);
208 elf_s_set_size (sym
, sz
)
212 S_SET_SIZE (sym
, sz
);
216 elf_s_get_align (sym
)
219 return S_GET_ALIGN (sym
);
223 elf_s_set_align (sym
, align
)
227 S_SET_ALIGN (sym
, align
);
231 elf_s_get_other (sym
)
234 return elf_symbol (symbol_get_bfdsym (sym
))->internal_elf_sym
.st_other
;
238 elf_s_set_other (sym
, other
)
242 S_SET_OTHER (sym
, other
);
246 elf_copy_symbol_attributes (dest
, src
)
249 OBJ_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
253 elf_sec_sym_ok_for_reloc (sec
)
256 return obj_sec_sym_ok_for_reloc (sec
);
265 sym
= symbol_new (s
, absolute_section
, (valueT
) 0, (struct frag
*) 0);
266 symbol_set_frag (sym
, &zero_address_frag
);
267 symbol_get_bfdsym (sym
)->flags
|= BSF_FILE
;
269 if (symbol_rootP
!= sym
)
271 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
272 symbol_insert (sym
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
274 verify_symbol_chain (symbol_rootP
, symbol_lastP
);
278 #ifdef NEED_ECOFF_DEBUG
284 obj_elf_common (is_common
)
294 if (flag_mri
&& is_common
)
300 name
= input_line_pointer
;
301 c
= get_symbol_end ();
302 /* just after name is now '\0' */
303 p
= input_line_pointer
;
306 if (*input_line_pointer
!= ',')
308 as_bad (_("Expected comma after symbol-name"));
309 ignore_rest_of_line ();
312 input_line_pointer
++; /* skip ',' */
313 if ((temp
= get_absolute_expression ()) < 0)
315 as_bad (_(".COMMon length (%d.) <0! Ignored."), temp
);
316 ignore_rest_of_line ();
321 symbolP
= symbol_find_or_make (name
);
323 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
325 as_bad (_("Ignoring attempt to re-define symbol"));
326 ignore_rest_of_line ();
329 if (S_GET_VALUE (symbolP
) != 0)
331 if (S_GET_VALUE (symbolP
) != (valueT
) size
)
333 as_warn (_("Length of .comm \"%s\" is already %ld. Not changed to %d."),
334 S_GET_NAME (symbolP
), (long) S_GET_VALUE (symbolP
), size
);
337 know (symbolP
->sy_frag
== &zero_address_frag
);
338 if (*input_line_pointer
!= ',')
343 input_line_pointer
++;
346 if (! have_align
|| *input_line_pointer
!= '"')
352 temp
= get_absolute_expression ();
356 as_warn (_("Common alignment negative; 0 assumed"));
359 if (symbol_get_obj (symbolP
)->local
)
368 old_subsec
= now_subseg
;
371 /* convert to a power of 2 alignment */
372 for (align
= 0; (temp
& 1) == 0; temp
>>= 1, ++align
);
375 as_bad (_("Common alignment not a power of 2"));
376 ignore_rest_of_line ();
382 record_alignment (bss_section
, align
);
383 subseg_set (bss_section
, 0);
385 frag_align (align
, 0, 0);
386 if (S_GET_SEGMENT (symbolP
) == bss_section
)
387 symbol_get_frag (symbolP
)->fr_symbol
= 0;
388 symbol_set_frag (symbolP
, frag_now
);
389 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
,
390 (offsetT
) size
, (char *) 0);
392 S_SET_SIZE (symbolP
, size
);
393 S_SET_SEGMENT (symbolP
, bss_section
);
394 S_CLEAR_EXTERNAL (symbolP
);
395 subseg_set (old_sec
, old_subsec
);
400 S_SET_VALUE (symbolP
, (valueT
) size
);
401 S_SET_ALIGN (symbolP
, temp
);
402 S_SET_EXTERNAL (symbolP
);
403 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
408 input_line_pointer
++;
409 /* @@ Some use the dot, some don't. Can we get some consistency?? */
410 if (*input_line_pointer
== '.')
411 input_line_pointer
++;
412 /* @@ Some say data, some say bss. */
413 if (strncmp (input_line_pointer
, "bss\"", 4)
414 && strncmp (input_line_pointer
, "data\"", 5))
416 while (*--input_line_pointer
!= '"')
418 input_line_pointer
--;
419 goto bad_common_segment
;
421 while (*input_line_pointer
++ != '"')
423 goto allocate_common
;
426 symbol_get_bfdsym (symbolP
)->flags
|= BSF_OBJECT
;
428 demand_empty_rest_of_line ();
433 p
= input_line_pointer
;
434 while (*p
&& *p
!= '\n')
438 as_bad (_("bad .common segment %s"), input_line_pointer
+ 1);
440 input_line_pointer
= p
;
441 ignore_rest_of_line ();
447 obj_elf_local (ignore
)
448 int ignore ATTRIBUTE_UNUSED
;
456 name
= input_line_pointer
;
457 c
= get_symbol_end ();
458 symbolP
= symbol_find_or_make (name
);
459 *input_line_pointer
= c
;
461 S_CLEAR_EXTERNAL (symbolP
);
462 symbol_get_obj (symbolP
)->local
= 1;
465 input_line_pointer
++;
467 if (*input_line_pointer
== '\n')
472 demand_empty_rest_of_line ();
476 obj_elf_weak (ignore
)
477 int ignore ATTRIBUTE_UNUSED
;
485 name
= input_line_pointer
;
486 c
= get_symbol_end ();
487 symbolP
= symbol_find_or_make (name
);
488 *input_line_pointer
= c
;
490 S_SET_WEAK (symbolP
);
491 symbol_get_obj (symbolP
)->local
= 1;
494 input_line_pointer
++;
496 if (*input_line_pointer
== '\n')
501 demand_empty_rest_of_line ();
505 obj_elf_visibility (visibility
)
512 elf_symbol_type
*elfsym
;
516 name
= input_line_pointer
;
517 c
= get_symbol_end ();
518 symbolP
= symbol_find_or_make (name
);
519 *input_line_pointer
= c
;
523 bfdsym
= symbol_get_bfdsym (symbolP
);
524 elfsym
= elf_symbol_from (bfd_asymbol_bfd (bfdsym
), bfdsym
);
528 elfsym
->internal_elf_sym
.st_other
= visibility
;
532 input_line_pointer
++;
536 if (*input_line_pointer
== '\n')
542 demand_empty_rest_of_line ();
545 static segT previous_section
;
546 static int previous_subsection
;
550 struct section_stack
*next
;
552 int subseg
, prev_subseg
;
555 static struct section_stack
*section_stack
;
557 /* Handle the .section pseudo-op. This code supports two different
560 The first is found on Solaris, and looks like
561 .section ".sec1",#alloc,#execinstr,#write
562 Here the names after '#' are the SHF_* flags to turn on for the
563 section. I'm not sure how it determines the SHT_* type (BFD
564 doesn't really give us control over the type, anyhow).
566 The second format is found on UnixWare, and probably most SVR4
567 machines, and looks like
568 .section .sec1,"a",@progbits
569 The quoted string may contain any combination of a, w, x, and
570 represents the SHF_* flags to turn on for the section. The string
571 beginning with '@' can be progbits or nobits. There should be
572 other possibilities, but I don't know what they are. In any case,
573 BFD doesn't really let us set the section type. */
575 /* Certain named sections have particular defined types, listed on p.
577 struct special_section
584 static struct special_section
const special_sections
[] =
586 { ".bss", SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
587 { ".comment", SHT_PROGBITS
, 0 },
588 { ".data", SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
589 { ".data1", SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
590 { ".debug", SHT_PROGBITS
, 0 },
591 { ".fini", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
592 { ".init", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
593 { ".line", SHT_PROGBITS
, 0 },
594 { ".note", SHT_NOTE
, 0 },
595 { ".rodata", SHT_PROGBITS
, SHF_ALLOC
},
596 { ".rodata1", SHT_PROGBITS
, SHF_ALLOC
},
597 { ".text", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
599 #ifdef ELF_TC_SPECIAL_SECTIONS
600 ELF_TC_SPECIAL_SECTIONS
604 /* The following section names are special, but they can not
605 reasonably appear in assembler code. Some of the attributes are
606 processor dependent. */
607 { ".dynamic", SHT_DYNAMIC
, SHF_ALLOC
/* + SHF_WRITE */ },
608 { ".dynstr", SHT_STRTAB
, SHF_ALLOC
},
609 { ".dynsym", SHT_DYNSYM
, SHF_ALLOC
},
610 { ".got", SHT_PROGBITS
, 0 },
611 { ".hash", SHT_HASH
, SHF_ALLOC
},
612 { ".interp", SHT_PROGBITS
, /* SHF_ALLOC */ },
613 { ".plt", SHT_PROGBITS
, 0 },
614 { ".shstrtab",SHT_STRTAB
, 0 },
615 { ".strtab", SHT_STRTAB
, /* SHF_ALLOC */ },
616 { ".symtab", SHT_SYMTAB
, /* SHF_ALLOC */ },
623 obj_elf_change_section (name
, type
, attr
, entsize
, push
)
625 int type
, attr
, entsize
, push
;
632 #ifdef md_flush_pending_output
633 md_flush_pending_output ();
636 /* Switch to the section, creating it if necessary. */
639 struct section_stack
*elt
;
640 elt
= xmalloc (sizeof (struct section_stack
));
641 elt
->next
= section_stack
;
643 elt
->prev_seg
= previous_section
;
644 elt
->subseg
= now_subseg
;
645 elt
->prev_subseg
= previous_subsection
;
648 previous_section
= now_seg
;
649 previous_subsection
= now_subseg
;
651 old_sec
= bfd_get_section_by_name (stdoutput
, name
);
652 sec
= subseg_new (name
, 0);
654 /* See if this is one of the special sections. */
655 for (i
= 0; special_sections
[i
].name
!= NULL
; i
++)
656 if (strcmp (name
, special_sections
[i
].name
) == 0)
658 if (type
== SHT_NULL
)
659 type
= special_sections
[i
].type
;
660 else if (type
!= special_sections
[i
].type
)
664 as_warn (_("Setting incorrect section type for %s"), name
);
668 as_warn (_("Ignoring incorrect section type for %s"), name
);
669 type
= special_sections
[i
].type
;
672 if ((attr
&~ special_sections
[i
].attributes
) != 0
675 /* As a GNU extension, we permit a .note section to be
676 allocatable. If the linker sees an allocateable .note
677 section, it will create a PT_NOTE segment in the output
679 if (strcmp (name
, ".note") != 0
680 || attr
!= SHF_ALLOC
)
681 as_warn (_("Setting incorrect section attributes for %s"),
684 attr
|= special_sections
[i
].attributes
;
688 /* Convert ELF type and flags to BFD flags. */
690 | ((attr
& SHF_WRITE
) ? 0 : SEC_READONLY
)
691 | ((attr
& SHF_ALLOC
) ? SEC_ALLOC
: 0)
692 | (((attr
& SHF_ALLOC
) && type
!= SHT_NOBITS
) ? SEC_LOAD
: 0)
693 | ((attr
& SHF_EXECINSTR
) ? SEC_CODE
: 0)
694 | ((attr
& SHF_MERGE
) ? SEC_MERGE
: 0)
695 | ((attr
& SHF_STRINGS
) ? SEC_STRINGS
: 0));
696 #ifdef md_elf_section_flags
697 flags
= md_elf_section_flags (flags
, attr
, type
);
704 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */
705 if (type
== SHT_NOBITS
)
706 seg_info (sec
)->bss
= 1;
708 bfd_set_section_flags (stdoutput
, sec
, flags
);
709 if (flags
& SEC_MERGE
)
710 sec
->entsize
= entsize
;
712 /* Add a symbol for this section to the symbol table. */
713 secsym
= symbol_find (name
);
715 symbol_set_bfdsym (secsym
, sec
->symbol
);
717 symbol_table_insert (section_symbol (sec
));
721 /* If section attributes are specified the second time we see a
722 particular section, then check that they are the same as we
723 saw the first time. */
724 if ((old_sec
->flags
^ flags
)
725 & (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
726 | SEC_EXCLUDE
| SEC_SORT_ENTRIES
| SEC_MERGE
| SEC_STRINGS
))
727 as_warn (_("Ignoring changed section attributes for %s"), name
);
728 else if ((flags
& SEC_MERGE
) && old_sec
->entsize
!= entsize
)
729 as_warn (_("Ignoring changed section entity size for %s"), name
);
732 #ifdef md_elf_section_change_hook
733 md_elf_section_change_hook ();
738 obj_elf_parse_section_letters (str
, len
)
755 attr
|= SHF_EXECINSTR
;
765 char *bad_msg
= _("Unrecognized .section attribute: want a,m,s,w,x");
766 #ifdef md_elf_section_letter
767 int md_attr
= md_elf_section_letter (*str
, &bad_msg
);
773 as_warn ("%s", bad_msg
);
786 obj_elf_section_word (str
, len
)
790 if (len
== 5 && strncmp (str
, "write", 5) == 0)
792 if (len
== 5 && strncmp (str
, "alloc", 5) == 0)
794 if (len
== 9 && strncmp (str
, "execinstr", 9) == 0)
795 return SHF_EXECINSTR
;
797 #ifdef md_elf_section_word
799 int md_attr
= md_elf_section_word (str
, len
);
805 as_warn (_("Unrecognized section attribute"));
810 obj_elf_section_type (str
, len
)
814 if (len
== 8 && strncmp (str
, "progbits", 8) == 0)
816 if (len
== 6 && strncmp (str
, "nobits", 6) == 0)
819 #ifdef md_elf_section_type
821 int md_type
= md_elf_section_type (str
, len
);
827 as_warn (_("Unrecognized section type"));
832 obj_elf_section (push
)
835 char *name
, *beg
, *end
;
836 int type
, attr
, dummy
;
844 #ifdef md_flush_pending_output
845 md_flush_pending_output ();
848 previous_section
= now_seg
;
849 previous_subsection
= now_subseg
;
851 s_mri_sect (&mri_type
);
853 #ifdef md_elf_section_change_hook
854 md_elf_section_change_hook ();
859 #endif /* ! defined (TC_I370) */
861 /* Get name of section. */
863 if (*input_line_pointer
== '"')
865 name
= demand_copy_C_string (&dummy
);
868 ignore_rest_of_line ();
874 end
= input_line_pointer
;
875 while (0 == strchr ("\n\t,; ", *end
))
877 if (end
== input_line_pointer
)
879 as_warn (_("Missing section name"));
880 ignore_rest_of_line ();
884 name
= xmalloc (end
- input_line_pointer
+ 1);
885 memcpy (name
, input_line_pointer
, end
- input_line_pointer
);
886 name
[end
- input_line_pointer
] = '\0';
887 input_line_pointer
= end
;
895 if (*input_line_pointer
== ',')
897 /* Skip the comma. */
898 ++input_line_pointer
;
901 if (*input_line_pointer
== '"')
903 beg
= demand_copy_C_string (&dummy
);
906 ignore_rest_of_line ();
909 attr
|= obj_elf_parse_section_letters (beg
, strlen (beg
));
912 if (*input_line_pointer
== ',')
915 ++input_line_pointer
;
917 c
= *input_line_pointer
;
920 beg
= demand_copy_C_string (&dummy
);
923 ignore_rest_of_line ();
926 type
= obj_elf_section_type (beg
, strlen (beg
));
928 else if (c
== '@' || c
== '%')
930 beg
= ++input_line_pointer
;
931 c
= get_symbol_end ();
932 *input_line_pointer
= c
;
933 type
= obj_elf_section_type (beg
, input_line_pointer
- beg
);
938 if ((attr
& SHF_MERGE
) && *input_line_pointer
== ',')
940 ++input_line_pointer
;
942 entsize
= get_absolute_expression ();
945 as_warn (_("Bad .section directive - invalid merge entity size"));
958 if (*input_line_pointer
!= '#')
960 as_warn (_("Bad .section directive - character following name is not '#'"));
961 ignore_rest_of_line ();
964 beg
= ++input_line_pointer
;
965 c
= get_symbol_end ();
966 *input_line_pointer
= c
;
968 attr
|= obj_elf_section_word (beg
, input_line_pointer
- beg
);
972 while (*input_line_pointer
++ == ',');
973 --input_line_pointer
;
977 demand_empty_rest_of_line ();
979 if ((attr
& SHF_MERGE
) && entsize
== 0)
981 as_warn (_("Entity size for SHF_MERGE not specified.\nSpecify entity size as 4th argument"));
985 #ifdef md_elf_section_change_data_hook
986 md_elf_section_change_data_hook (name
, type
, attr
, entsize
, push
);
989 obj_elf_change_section (name
, type
, attr
, entsize
, push
);
992 /* Change to the .data section. */
998 #ifdef md_flush_pending_output
999 md_flush_pending_output ();
1002 previous_section
= now_seg
;
1003 previous_subsection
= now_subseg
;
1006 #ifdef md_elf_section_change_hook
1007 md_elf_section_change_hook ();
1011 /* Change to the .text section. */
1017 #ifdef md_flush_pending_output
1018 md_flush_pending_output ();
1021 previous_section
= now_seg
;
1022 previous_subsection
= now_subseg
;
1025 #ifdef md_elf_section_change_hook
1026 md_elf_section_change_hook ();
1031 obj_elf_subsection (ignore
)
1032 int ignore ATTRIBUTE_UNUSED
;
1036 #ifdef md_flush_pending_output
1037 md_flush_pending_output ();
1040 previous_section
= now_seg
;
1041 previous_subsection
= now_subseg
;
1043 temp
= get_absolute_expression ();
1044 subseg_set (now_seg
, (subsegT
) temp
);
1045 demand_empty_rest_of_line ();
1047 #ifdef md_elf_section_change_hook
1048 md_elf_section_change_hook ();
1052 /* This can be called from the processor backends if they change
1056 obj_elf_section_change_hook ()
1058 previous_section
= now_seg
;
1059 previous_subsection
= now_subseg
;
1063 obj_elf_previous (ignore
)
1064 int ignore ATTRIBUTE_UNUSED
;
1069 if (previous_section
== 0)
1071 as_bad (_(".previous without corresponding .section; ignored"));
1075 #ifdef md_flush_pending_output
1076 md_flush_pending_output ();
1079 new_section
= previous_section
;
1080 new_subsection
= previous_subsection
;
1081 previous_section
= now_seg
;
1082 previous_subsection
= now_subseg
;
1083 subseg_set (new_section
, new_subsection
);
1085 #ifdef md_elf_section_change_hook
1086 md_elf_section_change_hook ();
1091 obj_elf_popsection (xxx
)
1092 int xxx ATTRIBUTE_UNUSED
;
1094 struct section_stack
*top
= section_stack
;
1098 as_bad (_(".popsection without corresponding .pushsection; ignored"));
1102 #ifdef md_flush_pending_output
1103 md_flush_pending_output ();
1106 section_stack
= top
->next
;
1107 previous_section
= top
->prev_seg
;
1108 previous_subsection
= top
->prev_subseg
;
1109 subseg_set (top
->seg
, top
->subseg
);
1112 #ifdef md_elf_section_change_hook
1113 md_elf_section_change_hook ();
1118 obj_elf_line (ignore
)
1119 int ignore ATTRIBUTE_UNUSED
;
1121 /* Assume delimiter is part of expression. BSD4.2 as fails with
1122 delightful bug, so we are not being incompatible here. */
1123 new_logical_line ((char *) NULL
, (int) (get_absolute_expression ()));
1124 demand_empty_rest_of_line ();
1127 /* This handles the .symver pseudo-op, which is used to specify a
1128 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1129 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1130 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1131 with the same value as the symbol NAME. */
1134 obj_elf_symver (ignore
)
1135 int ignore ATTRIBUTE_UNUSED
;
1141 name
= input_line_pointer
;
1142 c
= get_symbol_end ();
1144 sym
= symbol_find_or_make (name
);
1146 *input_line_pointer
= c
;
1149 if (*input_line_pointer
!= ',')
1151 as_bad (_("expected comma after name in .symver"));
1152 ignore_rest_of_line ();
1156 ++input_line_pointer
;
1157 name
= input_line_pointer
;
1160 c
= get_symbol_end ();
1161 if (c
!= ELF_VER_CHR
)
1163 *input_line_pointer
++ = c
;
1166 if (symbol_get_obj (sym
)->versioned_name
== NULL
)
1168 symbol_get_obj (sym
)->versioned_name
= xstrdup (name
);
1170 *input_line_pointer
= c
;
1172 if (strchr (symbol_get_obj (sym
)->versioned_name
,
1173 ELF_VER_CHR
) == NULL
)
1175 as_bad (_("missing version name in `%s' for symbol `%s'"),
1176 symbol_get_obj (sym
)->versioned_name
,
1178 ignore_rest_of_line ();
1184 if (strcmp (symbol_get_obj (sym
)->versioned_name
, name
))
1186 as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1187 name
, symbol_get_obj (sym
)->versioned_name
,
1189 ignore_rest_of_line ();
1193 *input_line_pointer
= c
;
1196 demand_empty_rest_of_line ();
1199 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1200 to the linker the hierarchy in which a particular table resides. The
1201 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1204 obj_elf_vtable_inherit (ignore
)
1205 int ignore ATTRIBUTE_UNUSED
;
1207 char *cname
, *pname
;
1208 symbolS
*csym
, *psym
;
1211 if (*input_line_pointer
== '#')
1212 ++input_line_pointer
;
1214 cname
= input_line_pointer
;
1215 c
= get_symbol_end ();
1216 csym
= symbol_find (cname
);
1218 /* GCFIXME: should check that we don't have two .vtable_inherits for
1219 the same child symbol. Also, we can currently only do this if the
1220 child symbol is already exists and is placed in a fragment. */
1222 if (csym
== NULL
|| symbol_get_frag (csym
) == NULL
)
1224 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1229 *input_line_pointer
= c
;
1232 if (*input_line_pointer
!= ',')
1234 as_bad ("expected comma after name in .vtable_inherit");
1235 ignore_rest_of_line ();
1239 ++input_line_pointer
;
1242 if (*input_line_pointer
== '#')
1243 ++input_line_pointer
;
1245 if (input_line_pointer
[0] == '0'
1246 && (input_line_pointer
[1] == '\0'
1247 || isspace ((unsigned char) input_line_pointer
[1])))
1249 psym
= section_symbol (absolute_section
);
1250 ++input_line_pointer
;
1254 pname
= input_line_pointer
;
1255 c
= get_symbol_end ();
1256 psym
= symbol_find_or_make (pname
);
1257 *input_line_pointer
= c
;
1260 demand_empty_rest_of_line ();
1265 assert (symbol_get_value_expression (csym
)->X_op
== O_constant
);
1266 return fix_new (symbol_get_frag (csym
),
1267 symbol_get_value_expression (csym
)->X_add_number
,
1268 0, psym
, 0, 0, BFD_RELOC_VTABLE_INHERIT
);
1271 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1272 to the linker that a vtable slot was used. The syntax is
1273 ".vtable_entry tablename, offset". */
1276 obj_elf_vtable_entry (ignore
)
1277 int ignore ATTRIBUTE_UNUSED
;
1284 if (*input_line_pointer
== '#')
1285 ++input_line_pointer
;
1287 name
= input_line_pointer
;
1288 c
= get_symbol_end ();
1289 sym
= symbol_find_or_make (name
);
1290 *input_line_pointer
= c
;
1293 if (*input_line_pointer
!= ',')
1295 as_bad ("expected comma after name in .vtable_entry");
1296 ignore_rest_of_line ();
1300 ++input_line_pointer
;
1301 if (*input_line_pointer
== '#')
1302 ++input_line_pointer
;
1304 offset
= get_absolute_expression ();
1306 demand_empty_rest_of_line ();
1308 return fix_new (frag_now
, frag_now_fix (), 0, sym
, offset
, 0,
1309 BFD_RELOC_VTABLE_ENTRY
);
1313 elf_obj_read_begin_hook ()
1315 #ifdef NEED_ECOFF_DEBUG
1316 if (ECOFF_DEBUGGING
)
1317 ecoff_read_begin_hook ();
1322 elf_obj_symbol_new_hook (symbolP
)
1325 struct elf_obj_sy
*sy_obj
;
1327 sy_obj
= symbol_get_obj (symbolP
);
1328 sy_obj
->size
= NULL
;
1329 sy_obj
->versioned_name
= NULL
;
1331 #ifdef NEED_ECOFF_DEBUG
1332 if (ECOFF_DEBUGGING
)
1333 ecoff_symbol_new_hook (symbolP
);
1338 obj_elf_version (ignore
)
1339 int ignore ATTRIBUTE_UNUSED
;
1345 asection
*seg
= now_seg
;
1346 subsegT subseg
= now_subseg
;
1347 Elf_Internal_Note i_note
;
1348 Elf_External_Note e_note
;
1349 asection
*note_secp
= (asection
*) NULL
;
1353 if (*input_line_pointer
== '\"')
1355 ++input_line_pointer
; /* -> 1st char of string. */
1356 name
= input_line_pointer
;
1358 while (is_a_char (c
= next_char_of_string ()))
1360 c
= *input_line_pointer
;
1361 *input_line_pointer
= '\0';
1362 *(input_line_pointer
- 1) = '\0';
1363 *input_line_pointer
= c
;
1365 /* create the .note section */
1367 note_secp
= subseg_new (".note", 0);
1368 bfd_set_section_flags (stdoutput
,
1370 SEC_HAS_CONTENTS
| SEC_READONLY
);
1372 /* process the version string */
1374 len
= strlen (name
);
1376 i_note
.namesz
= ((len
+ 1) + 3) & ~3; /* round this to word boundary */
1377 i_note
.descsz
= 0; /* no description */
1378 i_note
.type
= NT_VERSION
;
1379 p
= frag_more (sizeof (e_note
.namesz
));
1380 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
1381 p
= frag_more (sizeof (e_note
.descsz
));
1382 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
1383 p
= frag_more (sizeof (e_note
.type
));
1384 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
1386 for (i
= 0; i
< len
; i
++)
1390 FRAG_APPEND_1_CHAR (ch
);
1393 frag_align (2, 0, 0);
1395 subseg_set (seg
, subseg
);
1399 as_bad (_("Expected quoted string"));
1401 demand_empty_rest_of_line ();
1405 obj_elf_size (ignore
)
1406 int ignore ATTRIBUTE_UNUSED
;
1408 char *name
= input_line_pointer
;
1409 char c
= get_symbol_end ();
1414 p
= input_line_pointer
;
1417 if (*input_line_pointer
!= ',')
1420 as_bad (_("expected comma after name `%s' in .size directive"), name
);
1422 ignore_rest_of_line ();
1425 input_line_pointer
++;
1427 if (exp
.X_op
== O_absent
)
1429 as_bad (_("missing expression in .size directive"));
1430 exp
.X_op
= O_constant
;
1431 exp
.X_add_number
= 0;
1434 sym
= symbol_find_or_make (name
);
1436 if (exp
.X_op
== O_constant
)
1437 S_SET_SIZE (sym
, exp
.X_add_number
);
1440 symbol_get_obj (sym
)->size
=
1441 (expressionS
*) xmalloc (sizeof (expressionS
));
1442 *symbol_get_obj (sym
)->size
= exp
;
1444 demand_empty_rest_of_line ();
1447 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1448 There are five syntaxes:
1450 The first (used on Solaris) is
1452 The second (used on UnixWare) is
1454 The third (reportedly to be used on Irix 6.0) is
1456 The fourth (used on NetBSD/Arm and Linux/ARM) is
1458 The fifth (used on SVR4/860) is
1459 .type SYM,"function"
1463 obj_elf_type (ignore
)
1464 int ignore ATTRIBUTE_UNUSED
;
1469 const char *typename
;
1471 elf_symbol_type
*elfsym
;
1473 name
= input_line_pointer
;
1474 c
= get_symbol_end ();
1475 sym
= symbol_find_or_make (name
);
1476 elfsym
= (elf_symbol_type
*) symbol_get_bfdsym (sym
);
1477 *input_line_pointer
= c
;
1480 if (*input_line_pointer
== ',')
1481 ++input_line_pointer
;
1484 if ( *input_line_pointer
== '#'
1485 || *input_line_pointer
== '@'
1486 || *input_line_pointer
== '"'
1487 || *input_line_pointer
== '%')
1488 ++input_line_pointer
;
1490 typename
= input_line_pointer
;
1491 c
= get_symbol_end ();
1494 if (strcmp (typename
, "function") == 0
1495 || strcmp (typename
, "STT_FUNC") == 0)
1496 type
= BSF_FUNCTION
;
1497 else if (strcmp (typename
, "object") == 0
1498 || strcmp (typename
, "STT_OBJECT") == 0)
1500 #ifdef md_elf_symbol_type
1501 else if ((type
= md_elf_symbol_type (typename
, sym
, elfsym
)) != -1)
1505 as_bad (_("ignoring unrecognized symbol type \"%s\""), typename
);
1507 *input_line_pointer
= c
;
1509 if (*input_line_pointer
== '"')
1510 ++input_line_pointer
;
1512 elfsym
->symbol
.flags
|= type
;
1514 demand_empty_rest_of_line ();
1518 obj_elf_ident (ignore
)
1519 int ignore ATTRIBUTE_UNUSED
;
1521 static segT comment_section
;
1522 segT old_section
= now_seg
;
1523 int old_subsection
= now_subseg
;
1525 #ifdef md_flush_pending_output
1526 md_flush_pending_output ();
1529 if (!comment_section
)
1532 comment_section
= subseg_new (".comment", 0);
1533 bfd_set_section_flags (stdoutput
, comment_section
,
1534 SEC_READONLY
| SEC_HAS_CONTENTS
);
1539 subseg_set (comment_section
, 0);
1541 subseg_set (old_section
, old_subsection
);
1544 #ifdef INIT_STAB_SECTION
1546 /* The first entry in a .stabs section is special. */
1549 obj_elf_init_stab_section (seg
)
1555 unsigned int stroff
;
1557 /* Force the section to align to a longword boundary. Without this,
1558 UnixWare ar crashes. */
1559 bfd_set_section_alignment (stdoutput
, seg
, 2);
1561 /* Make space for this first symbol. */
1565 as_where (&file
, (unsigned int *) NULL
);
1566 stabstr_name
= (char *) alloca (strlen (segment_name (seg
)) + 4);
1567 strcpy (stabstr_name
, segment_name (seg
));
1568 strcat (stabstr_name
, "str");
1569 stroff
= get_stab_string_offset (file
, stabstr_name
);
1571 md_number_to_chars (p
, stroff
, 4);
1572 seg_info (seg
)->stabu
.p
= p
;
1577 /* Fill in the counts in the first entry in a .stabs section. */
1580 adjust_stab_sections (abfd
, sec
, xxx
)
1583 PTR xxx ATTRIBUTE_UNUSED
;
1590 if (strncmp (".stab", sec
->name
, 5))
1592 if (!strcmp ("str", sec
->name
+ strlen (sec
->name
) - 3))
1595 name
= (char *) alloca (strlen (sec
->name
) + 4);
1596 strcpy (name
, sec
->name
);
1597 strcat (name
, "str");
1598 strsec
= bfd_get_section_by_name (abfd
, name
);
1600 strsz
= bfd_section_size (abfd
, strsec
);
1603 nsyms
= bfd_section_size (abfd
, sec
) / 12 - 1;
1605 p
= seg_info (sec
)->stabu
.p
;
1608 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
1609 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
1612 #ifdef NEED_ECOFF_DEBUG
1614 /* This function is called by the ECOFF code. It is supposed to
1615 record the external symbol information so that the backend can
1616 write it out correctly. The ELF backend doesn't actually handle
1617 this at the moment, so we do it ourselves. We save the information
1621 elf_ecoff_set_ext (sym
, ext
)
1623 struct ecoff_extr
*ext
;
1625 symbol_get_bfdsym (sym
)->udata
.p
= (PTR
) ext
;
1628 /* This function is called by bfd_ecoff_debug_externals. It is
1629 supposed to *EXT to the external symbol information, and return
1630 whether the symbol should be used at all. */
1633 elf_get_extr (sym
, ext
)
1637 if (sym
->udata
.p
== NULL
)
1639 *ext
= *(EXTR
*) sym
->udata
.p
;
1643 /* This function is called by bfd_ecoff_debug_externals. It has
1644 nothing to do for ELF. */
1648 elf_set_index (sym
, indx
)
1649 asymbol
*sym ATTRIBUTE_UNUSED
;
1650 bfd_size_type indx ATTRIBUTE_UNUSED
;
1654 #endif /* NEED_ECOFF_DEBUG */
1657 elf_frob_symbol (symp
, puntp
)
1661 struct elf_obj_sy
*sy_obj
;
1663 #ifdef NEED_ECOFF_DEBUG
1664 if (ECOFF_DEBUGGING
)
1665 ecoff_frob_symbol (symp
);
1668 sy_obj
= symbol_get_obj (symp
);
1670 if (sy_obj
->size
!= NULL
)
1672 switch (sy_obj
->size
->X_op
)
1676 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1677 + sy_obj
->size
->X_add_number
1678 - S_GET_VALUE (sy_obj
->size
->X_op_symbol
)));
1682 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1683 + sy_obj
->size
->X_add_number
));
1686 as_bad (_(".size expression too complicated to fix up"));
1689 free (sy_obj
->size
);
1690 sy_obj
->size
= NULL
;
1693 if (sy_obj
->versioned_name
!= NULL
)
1697 p
= strchr (sy_obj
->versioned_name
, ELF_VER_CHR
);
1700 /* This symbol was given a new name with the .symver directive.
1702 If this is an external reference, just rename the symbol to
1703 include the version string. This will make the relocs be
1704 against the correct versioned symbol.
1706 If this is a definition, add an alias. FIXME: Using an alias
1707 will permit the debugging information to refer to the right
1708 symbol. However, it's not clear whether it is the best
1711 if (! S_IS_DEFINED (symp
))
1713 /* Verify that the name isn't using the @@ syntax--this is
1714 reserved for definitions of the default version to link
1716 if (p
[1] == ELF_VER_CHR
)
1718 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1719 sy_obj
->versioned_name
);
1722 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1726 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
1730 /* The @@@ syntax is a special case. It renames the
1731 symbol name to versioned_name with one `@' removed. */
1732 l
= strlen (&p
[3]) + 1;
1733 memmove (&p
[2], &p
[3], l
);
1734 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1740 /* FIXME: Creating a new symbol here is risky. We're
1741 in the final loop over the symbol table. We can
1742 get away with it only because the symbol goes to
1743 the end of the list, where the loop will still see
1744 it. It would probably be better to do this in
1745 obj_frob_file_before_adjust. */
1747 symp2
= symbol_find_or_make (sy_obj
->versioned_name
);
1749 /* Now we act as though we saw symp2 = sym. */
1751 S_SET_SEGMENT (symp2
, S_GET_SEGMENT (symp
));
1753 /* Subtracting out the frag address here is a hack
1754 because we are in the middle of the final loop. */
1757 - symbol_get_frag (symp
)->fr_address
));
1759 symbol_set_frag (symp2
, symbol_get_frag (symp
));
1761 /* This will copy over the size information. */
1762 copy_symbol_attributes (symp2
, symp
);
1764 if (S_IS_WEAK (symp
))
1767 if (S_IS_EXTERNAL (symp
))
1768 S_SET_EXTERNAL (symp2
);
1773 /* Double check weak symbols. */
1774 if (S_IS_WEAK (symp
))
1776 if (S_IS_COMMON (symp
))
1777 as_bad (_("Symbol `%s' can not be both weak and common"),
1782 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1783 any undefined non-function symbol to STT_OBJECT. We try to be
1784 compatible, since newer Irix 5 and 6 linkers care. However, we
1785 only set undefined symbols to be STT_OBJECT if we are on Irix,
1786 because that is the only time gcc will generate the necessary
1787 .global directives to mark functions. */
1789 if (S_IS_COMMON (symp
))
1790 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1792 if (strstr (TARGET_OS
, "irix") != NULL
1793 && ! S_IS_DEFINED (symp
)
1794 && (symbol_get_bfdsym (symp
)->flags
& BSF_FUNCTION
) == 0)
1795 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1799 /* If TC_PPC is defined, we used to force the type of a symbol to be
1800 BSF_OBJECT if it was otherwise unset. This was required by some
1801 version of VxWorks. Thomas de Lellis <tdel@windriver.com> says
1802 that this is no longer needed, so it is now commented out. */
1803 if ((symbol_get_bfdsym (symp
)->flags
1804 & (BSF_FUNCTION
| BSF_FILE
| BSF_SECTION_SYM
)) == 0
1805 && S_IS_DEFINED (symp
))
1806 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1813 bfd_map_over_sections (stdoutput
, adjust_stab_sections
, (PTR
) 0);
1815 #ifdef elf_tc_final_processing
1816 elf_tc_final_processing ();
1820 /* It removes any unneeded versioned symbols from the symbol table. */
1823 elf_frob_file_before_adjust ()
1829 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1830 if (symbol_get_obj (symp
)->versioned_name
)
1832 if (!S_IS_DEFINED (symp
))
1836 /* The @@@ syntax is a special case. If the symbol is
1837 not defined, 2 `@'s will be removed from the
1840 p
= strchr (symbol_get_obj (symp
)->versioned_name
,
1843 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
1845 size_t l
= strlen (&p
[3]) + 1;
1846 memmove (&p
[1], &p
[3], l
);
1848 if (symbol_used_p (symp
) == 0
1849 && symbol_used_in_reloc_p (symp
) == 0)
1850 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1856 /* It is required that we let write_relocs have the opportunity to
1857 optimize away fixups before output has begun, since it is possible
1858 to eliminate all fixups for a section and thus we never should
1859 have generated the relocation section. */
1862 elf_frob_file_after_relocs ()
1864 #ifdef NEED_ECOFF_DEBUG
1865 if (ECOFF_DEBUGGING
)
1866 /* Generate the ECOFF debugging information. */
1868 const struct ecoff_debug_swap
*debug_swap
;
1869 struct ecoff_debug_info debug
;
1874 = get_elf_backend_data (stdoutput
)->elf_backend_ecoff_debug_swap
;
1875 know (debug_swap
!= (const struct ecoff_debug_swap
*) NULL
);
1876 ecoff_build_debug (&debug
.symbolic_header
, &buf
, debug_swap
);
1878 /* Set up the pointers in debug. */
1879 #define SET(ptr, offset, type) \
1880 debug.ptr = (type) (buf + debug.symbolic_header.offset)
1882 SET (line
, cbLineOffset
, unsigned char *);
1883 SET (external_dnr
, cbDnOffset
, PTR
);
1884 SET (external_pdr
, cbPdOffset
, PTR
);
1885 SET (external_sym
, cbSymOffset
, PTR
);
1886 SET (external_opt
, cbOptOffset
, PTR
);
1887 SET (external_aux
, cbAuxOffset
, union aux_ext
*);
1888 SET (ss
, cbSsOffset
, char *);
1889 SET (external_fdr
, cbFdOffset
, PTR
);
1890 SET (external_rfd
, cbRfdOffset
, PTR
);
1891 /* ssext and external_ext are set up just below. */
1895 /* Set up the external symbols. */
1896 debug
.ssext
= debug
.ssext_end
= NULL
;
1897 debug
.external_ext
= debug
.external_ext_end
= NULL
;
1898 if (! bfd_ecoff_debug_externals (stdoutput
, &debug
, debug_swap
, true,
1899 elf_get_extr
, elf_set_index
))
1900 as_fatal (_("Failed to set up debugging information: %s"),
1901 bfd_errmsg (bfd_get_error ()));
1903 sec
= bfd_get_section_by_name (stdoutput
, ".mdebug");
1904 assert (sec
!= NULL
);
1906 know (stdoutput
->output_has_begun
== false);
1908 /* We set the size of the section, call bfd_set_section_contents
1909 to force the ELF backend to allocate a file position, and then
1910 write out the data. FIXME: Is this really the best way to do
1912 sec
->_raw_size
= bfd_ecoff_debug_size (stdoutput
, &debug
, debug_swap
);
1914 /* Pass BUF to bfd_set_section_contents because this will
1915 eventually become a call to fwrite, and ISO C prohibits
1916 passing a NULL pointer to a stdio function even if the
1917 pointer will not be used. */
1918 if (! bfd_set_section_contents (stdoutput
, sec
, (PTR
) buf
,
1919 (file_ptr
) 0, (bfd_size_type
) 0))
1920 as_fatal (_("Can't start writing .mdebug section: %s"),
1921 bfd_errmsg (bfd_get_error ()));
1923 know (stdoutput
->output_has_begun
== true);
1924 know (sec
->filepos
!= 0);
1926 if (! bfd_ecoff_write_debug (stdoutput
, &debug
, debug_swap
,
1928 as_fatal (_("Could not write .mdebug section: %s"),
1929 bfd_errmsg (bfd_get_error ()));
1931 #endif /* NEED_ECOFF_DEBUG */
1936 /* Heavily plagarized from obj_elf_version. The idea is to emit the
1937 SCO specific identifier in the .notes section to satisfy the SCO
1940 This looks more complicated than it really is. As opposed to the
1941 "obvious" solution, this should handle the cross dev cases
1942 correctly. (i.e, hosting on a 64 bit big endian processor, but
1943 generating SCO Elf code) Efficiency isn't a concern, as there
1944 should be exactly one of these sections per object module.
1946 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
1949 int_32 namesz = 4 ; Name size
1950 int_32 descsz = 12 ; Descriptive information
1952 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
1953 int_32 version = (major ver # << 16) | version of tools ;
1954 int_32 source = (tool_id << 16 ) | 1 ;
1955 int_32 info = 0 ; These are set by the SCO tools, but we
1956 don't know enough about the source
1957 environment to set them. SCO ld currently
1958 ignores them, and recommends we set them
1961 #define SCO_MAJOR_VERSION 0x1
1962 #define SCO_MINOR_VERSION 0x1
1972 asection
*seg
= now_seg
;
1973 subsegT subseg
= now_subseg
;
1974 Elf_Internal_Note i_note
;
1975 Elf_External_Note e_note
;
1976 asection
*note_secp
= (asection
*) NULL
;
1979 /* create the .note section */
1981 note_secp
= subseg_new (".note", 0);
1982 bfd_set_section_flags (stdoutput
,
1984 SEC_HAS_CONTENTS
| SEC_READONLY
);
1986 /* process the version string */
1989 i_note
.descsz
= 12; /* 12 descriptive bytes */
1990 i_note
.type
= NT_VERSION
; /* Contains a version string */
1992 p
= frag_more (sizeof (i_note
.namesz
));
1993 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
1995 p
= frag_more (sizeof (i_note
.descsz
));
1996 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
1998 p
= frag_more (sizeof (i_note
.type
));
1999 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
2004 /* Note: this is the version number of the ELF we're representing */
2006 md_number_to_chars (p
, (SCO_MAJOR_VERSION
<< 16) | (SCO_MINOR_VERSION
), 4);
2008 /* Here, we pick a magic number for ourselves (yes, I "registered"
2009 it with SCO. The bottom bit shows that we are compat with the
2012 md_number_to_chars (p
, 0x4c520000 | 0x0001, 4);
2014 /* If we knew (or cared) what the source language options were, we'd
2015 fill them in here. SCO has given us permission to ignore these
2016 and just set them to zero. */
2018 md_number_to_chars (p
, 0x0000, 4);
2020 frag_align (2, 0, 0);
2022 /* We probably can't restore the current segment, for there likely
2025 subseg_set (seg
, subseg
);
2029 #endif /* SCO_ELF */
2032 elf_separate_stab_sections ()
2034 #ifdef NEED_ECOFF_DEBUG
2035 return (!ECOFF_DEBUGGING
);
2042 elf_init_stab_section (seg
)
2045 #ifdef NEED_ECOFF_DEBUG
2046 if (!ECOFF_DEBUGGING
)
2048 obj_elf_init_stab_section (seg
);
2051 const struct format_ops elf_format_ops
=
2053 bfd_target_elf_flavour
,
2054 0, /* dfl_leading_underscore */
2055 1, /* emit_section_symbols */
2060 elf_frob_file_before_adjust
,
2061 elf_frob_file_after_relocs
,
2062 elf_s_get_size
, elf_s_set_size
,
2063 elf_s_get_align
, elf_s_set_align
,
2070 elf_copy_symbol_attributes
,
2071 #ifdef NEED_ECOFF_DEBUG
2072 ecoff_generate_asm_lineno
,
2075 0, /* generate_asm_lineno */
2076 0, /* process_stab */
2078 elf_separate_stab_sections
,
2079 elf_init_stab_section
,
2080 elf_sec_sym_ok_for_reloc
,
2082 #ifdef NEED_ECOFF_DEBUG
2085 0, /* ecoff_set_ext */
2087 elf_obj_read_begin_hook
,
2088 elf_obj_symbol_new_hook