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 obj_elf_change_section (name
, type
, attr
, entsize
, push
);
988 /* Change to the .data section. */
994 #ifdef md_flush_pending_output
995 md_flush_pending_output ();
998 previous_section
= now_seg
;
999 previous_subsection
= now_subseg
;
1002 #ifdef md_elf_section_change_hook
1003 md_elf_section_change_hook ();
1007 /* Change to the .text section. */
1013 #ifdef md_flush_pending_output
1014 md_flush_pending_output ();
1017 previous_section
= now_seg
;
1018 previous_subsection
= now_subseg
;
1021 #ifdef md_elf_section_change_hook
1022 md_elf_section_change_hook ();
1027 obj_elf_subsection (ignore
)
1028 int ignore ATTRIBUTE_UNUSED
;
1032 #ifdef md_flush_pending_output
1033 md_flush_pending_output ();
1036 previous_section
= now_seg
;
1037 previous_subsection
= now_subseg
;
1039 temp
= get_absolute_expression ();
1040 subseg_set (now_seg
, (subsegT
) temp
);
1041 demand_empty_rest_of_line ();
1043 #ifdef md_elf_section_change_hook
1044 md_elf_section_change_hook ();
1048 /* This can be called from the processor backends if they change
1052 obj_elf_section_change_hook ()
1054 previous_section
= now_seg
;
1055 previous_subsection
= now_subseg
;
1059 obj_elf_previous (ignore
)
1060 int ignore ATTRIBUTE_UNUSED
;
1065 if (previous_section
== 0)
1067 as_bad (_(".previous without corresponding .section; ignored"));
1071 #ifdef md_flush_pending_output
1072 md_flush_pending_output ();
1075 new_section
= previous_section
;
1076 new_subsection
= previous_subsection
;
1077 previous_section
= now_seg
;
1078 previous_subsection
= now_subseg
;
1079 subseg_set (new_section
, new_subsection
);
1081 #ifdef md_elf_section_change_hook
1082 md_elf_section_change_hook ();
1087 obj_elf_popsection (xxx
)
1088 int xxx ATTRIBUTE_UNUSED
;
1090 struct section_stack
*top
= section_stack
;
1094 as_bad (_(".popsection without corresponding .pushsection; ignored"));
1098 #ifdef md_flush_pending_output
1099 md_flush_pending_output ();
1102 section_stack
= top
->next
;
1103 previous_section
= top
->prev_seg
;
1104 previous_subsection
= top
->prev_subseg
;
1105 subseg_set (top
->seg
, top
->subseg
);
1108 #ifdef md_elf_section_change_hook
1109 md_elf_section_change_hook ();
1114 obj_elf_line (ignore
)
1115 int ignore ATTRIBUTE_UNUSED
;
1117 /* Assume delimiter is part of expression. BSD4.2 as fails with
1118 delightful bug, so we are not being incompatible here. */
1119 new_logical_line ((char *) NULL
, (int) (get_absolute_expression ()));
1120 demand_empty_rest_of_line ();
1123 /* This handles the .symver pseudo-op, which is used to specify a
1124 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1125 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1126 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1127 with the same value as the symbol NAME. */
1130 obj_elf_symver (ignore
)
1131 int ignore ATTRIBUTE_UNUSED
;
1137 name
= input_line_pointer
;
1138 c
= get_symbol_end ();
1140 sym
= symbol_find_or_make (name
);
1142 *input_line_pointer
= c
;
1145 if (*input_line_pointer
!= ',')
1147 as_bad (_("expected comma after name in .symver"));
1148 ignore_rest_of_line ();
1152 ++input_line_pointer
;
1153 name
= input_line_pointer
;
1156 c
= get_symbol_end ();
1157 if (c
!= ELF_VER_CHR
)
1159 *input_line_pointer
++ = c
;
1162 if (symbol_get_obj (sym
)->versioned_name
== NULL
)
1164 symbol_get_obj (sym
)->versioned_name
= xstrdup (name
);
1166 *input_line_pointer
= c
;
1168 if (strchr (symbol_get_obj (sym
)->versioned_name
,
1169 ELF_VER_CHR
) == NULL
)
1171 as_bad (_("missing version name in `%s' for symbol `%s'"),
1172 symbol_get_obj (sym
)->versioned_name
,
1174 ignore_rest_of_line ();
1180 if (strcmp (symbol_get_obj (sym
)->versioned_name
, name
))
1182 as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1183 name
, symbol_get_obj (sym
)->versioned_name
,
1185 ignore_rest_of_line ();
1189 *input_line_pointer
= c
;
1192 demand_empty_rest_of_line ();
1195 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1196 to the linker the hierarchy in which a particular table resides. The
1197 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1200 obj_elf_vtable_inherit (ignore
)
1201 int ignore ATTRIBUTE_UNUSED
;
1203 char *cname
, *pname
;
1204 symbolS
*csym
, *psym
;
1207 if (*input_line_pointer
== '#')
1208 ++input_line_pointer
;
1210 cname
= input_line_pointer
;
1211 c
= get_symbol_end ();
1212 csym
= symbol_find (cname
);
1214 /* GCFIXME: should check that we don't have two .vtable_inherits for
1215 the same child symbol. Also, we can currently only do this if the
1216 child symbol is already exists and is placed in a fragment. */
1218 if (csym
== NULL
|| symbol_get_frag (csym
) == NULL
)
1220 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1225 *input_line_pointer
= c
;
1228 if (*input_line_pointer
!= ',')
1230 as_bad ("expected comma after name in .vtable_inherit");
1231 ignore_rest_of_line ();
1235 ++input_line_pointer
;
1238 if (*input_line_pointer
== '#')
1239 ++input_line_pointer
;
1241 if (input_line_pointer
[0] == '0'
1242 && (input_line_pointer
[1] == '\0'
1243 || isspace ((unsigned char) input_line_pointer
[1])))
1245 psym
= section_symbol (absolute_section
);
1246 ++input_line_pointer
;
1250 pname
= input_line_pointer
;
1251 c
= get_symbol_end ();
1252 psym
= symbol_find_or_make (pname
);
1253 *input_line_pointer
= c
;
1256 demand_empty_rest_of_line ();
1261 assert (symbol_get_value_expression (csym
)->X_op
== O_constant
);
1262 return fix_new (symbol_get_frag (csym
),
1263 symbol_get_value_expression (csym
)->X_add_number
,
1264 0, psym
, 0, 0, BFD_RELOC_VTABLE_INHERIT
);
1267 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1268 to the linker that a vtable slot was used. The syntax is
1269 ".vtable_entry tablename, offset". */
1272 obj_elf_vtable_entry (ignore
)
1273 int ignore ATTRIBUTE_UNUSED
;
1280 if (*input_line_pointer
== '#')
1281 ++input_line_pointer
;
1283 name
= input_line_pointer
;
1284 c
= get_symbol_end ();
1285 sym
= symbol_find_or_make (name
);
1286 *input_line_pointer
= c
;
1289 if (*input_line_pointer
!= ',')
1291 as_bad ("expected comma after name in .vtable_entry");
1292 ignore_rest_of_line ();
1296 ++input_line_pointer
;
1297 if (*input_line_pointer
== '#')
1298 ++input_line_pointer
;
1300 offset
= get_absolute_expression ();
1302 demand_empty_rest_of_line ();
1304 return fix_new (frag_now
, frag_now_fix (), 0, sym
, offset
, 0,
1305 BFD_RELOC_VTABLE_ENTRY
);
1309 elf_obj_read_begin_hook ()
1311 #ifdef NEED_ECOFF_DEBUG
1312 if (ECOFF_DEBUGGING
)
1313 ecoff_read_begin_hook ();
1318 elf_obj_symbol_new_hook (symbolP
)
1321 struct elf_obj_sy
*sy_obj
;
1323 sy_obj
= symbol_get_obj (symbolP
);
1324 sy_obj
->size
= NULL
;
1325 sy_obj
->versioned_name
= NULL
;
1327 #ifdef NEED_ECOFF_DEBUG
1328 if (ECOFF_DEBUGGING
)
1329 ecoff_symbol_new_hook (symbolP
);
1334 obj_elf_version (ignore
)
1335 int ignore ATTRIBUTE_UNUSED
;
1341 asection
*seg
= now_seg
;
1342 subsegT subseg
= now_subseg
;
1343 Elf_Internal_Note i_note
;
1344 Elf_External_Note e_note
;
1345 asection
*note_secp
= (asection
*) NULL
;
1349 if (*input_line_pointer
== '\"')
1351 ++input_line_pointer
; /* -> 1st char of string. */
1352 name
= input_line_pointer
;
1354 while (is_a_char (c
= next_char_of_string ()))
1356 c
= *input_line_pointer
;
1357 *input_line_pointer
= '\0';
1358 *(input_line_pointer
- 1) = '\0';
1359 *input_line_pointer
= c
;
1361 /* create the .note section */
1363 note_secp
= subseg_new (".note", 0);
1364 bfd_set_section_flags (stdoutput
,
1366 SEC_HAS_CONTENTS
| SEC_READONLY
);
1368 /* process the version string */
1370 len
= strlen (name
);
1372 i_note
.namesz
= ((len
+ 1) + 3) & ~3; /* round this to word boundary */
1373 i_note
.descsz
= 0; /* no description */
1374 i_note
.type
= NT_VERSION
;
1375 p
= frag_more (sizeof (e_note
.namesz
));
1376 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
1377 p
= frag_more (sizeof (e_note
.descsz
));
1378 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
1379 p
= frag_more (sizeof (e_note
.type
));
1380 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
1382 for (i
= 0; i
< len
; i
++)
1386 FRAG_APPEND_1_CHAR (ch
);
1389 frag_align (2, 0, 0);
1391 subseg_set (seg
, subseg
);
1395 as_bad (_("Expected quoted string"));
1397 demand_empty_rest_of_line ();
1401 obj_elf_size (ignore
)
1402 int ignore ATTRIBUTE_UNUSED
;
1404 char *name
= input_line_pointer
;
1405 char c
= get_symbol_end ();
1410 p
= input_line_pointer
;
1413 if (*input_line_pointer
!= ',')
1416 as_bad (_("expected comma after name `%s' in .size directive"), name
);
1418 ignore_rest_of_line ();
1421 input_line_pointer
++;
1423 if (exp
.X_op
== O_absent
)
1425 as_bad (_("missing expression in .size directive"));
1426 exp
.X_op
= O_constant
;
1427 exp
.X_add_number
= 0;
1430 sym
= symbol_find_or_make (name
);
1432 if (exp
.X_op
== O_constant
)
1433 S_SET_SIZE (sym
, exp
.X_add_number
);
1436 symbol_get_obj (sym
)->size
=
1437 (expressionS
*) xmalloc (sizeof (expressionS
));
1438 *symbol_get_obj (sym
)->size
= exp
;
1440 demand_empty_rest_of_line ();
1443 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1444 There are five syntaxes:
1446 The first (used on Solaris) is
1448 The second (used on UnixWare) is
1450 The third (reportedly to be used on Irix 6.0) is
1452 The fourth (used on NetBSD/Arm and Linux/ARM) is
1454 The fifth (used on SVR4/860) is
1455 .type SYM,"function"
1459 obj_elf_type (ignore
)
1460 int ignore ATTRIBUTE_UNUSED
;
1465 const char *typename
;
1467 elf_symbol_type
*elfsym
;
1469 name
= input_line_pointer
;
1470 c
= get_symbol_end ();
1471 sym
= symbol_find_or_make (name
);
1472 elfsym
= (elf_symbol_type
*) symbol_get_bfdsym (sym
);
1473 *input_line_pointer
= c
;
1476 if (*input_line_pointer
== ',')
1477 ++input_line_pointer
;
1480 if ( *input_line_pointer
== '#'
1481 || *input_line_pointer
== '@'
1482 || *input_line_pointer
== '"'
1483 || *input_line_pointer
== '%')
1484 ++input_line_pointer
;
1486 typename
= input_line_pointer
;
1487 c
= get_symbol_end ();
1490 if (strcmp (typename
, "function") == 0
1491 || strcmp (typename
, "STT_FUNC") == 0)
1492 type
= BSF_FUNCTION
;
1493 else if (strcmp (typename
, "object") == 0
1494 || strcmp (typename
, "STT_OBJECT") == 0)
1496 #ifdef md_elf_symbol_type
1497 else if ((type
= md_elf_symbol_type (typename
, sym
, elfsym
)) != -1)
1501 as_bad (_("ignoring unrecognized symbol type \"%s\""), typename
);
1503 *input_line_pointer
= c
;
1505 if (*input_line_pointer
== '"')
1506 ++input_line_pointer
;
1508 elfsym
->symbol
.flags
|= type
;
1510 demand_empty_rest_of_line ();
1514 obj_elf_ident (ignore
)
1515 int ignore ATTRIBUTE_UNUSED
;
1517 static segT comment_section
;
1518 segT old_section
= now_seg
;
1519 int old_subsection
= now_subseg
;
1521 #ifdef md_flush_pending_output
1522 md_flush_pending_output ();
1525 if (!comment_section
)
1528 comment_section
= subseg_new (".comment", 0);
1529 bfd_set_section_flags (stdoutput
, comment_section
,
1530 SEC_READONLY
| SEC_HAS_CONTENTS
);
1535 subseg_set (comment_section
, 0);
1537 subseg_set (old_section
, old_subsection
);
1540 #ifdef INIT_STAB_SECTION
1542 /* The first entry in a .stabs section is special. */
1545 obj_elf_init_stab_section (seg
)
1551 unsigned int stroff
;
1553 /* Force the section to align to a longword boundary. Without this,
1554 UnixWare ar crashes. */
1555 bfd_set_section_alignment (stdoutput
, seg
, 2);
1557 /* Make space for this first symbol. */
1561 as_where (&file
, (unsigned int *) NULL
);
1562 stabstr_name
= (char *) alloca (strlen (segment_name (seg
)) + 4);
1563 strcpy (stabstr_name
, segment_name (seg
));
1564 strcat (stabstr_name
, "str");
1565 stroff
= get_stab_string_offset (file
, stabstr_name
);
1567 md_number_to_chars (p
, stroff
, 4);
1568 seg_info (seg
)->stabu
.p
= p
;
1573 /* Fill in the counts in the first entry in a .stabs section. */
1576 adjust_stab_sections (abfd
, sec
, xxx
)
1579 PTR xxx ATTRIBUTE_UNUSED
;
1586 if (strncmp (".stab", sec
->name
, 5))
1588 if (!strcmp ("str", sec
->name
+ strlen (sec
->name
) - 3))
1591 name
= (char *) alloca (strlen (sec
->name
) + 4);
1592 strcpy (name
, sec
->name
);
1593 strcat (name
, "str");
1594 strsec
= bfd_get_section_by_name (abfd
, name
);
1596 strsz
= bfd_section_size (abfd
, strsec
);
1599 nsyms
= bfd_section_size (abfd
, sec
) / 12 - 1;
1601 p
= seg_info (sec
)->stabu
.p
;
1604 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
1605 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
1608 #ifdef NEED_ECOFF_DEBUG
1610 /* This function is called by the ECOFF code. It is supposed to
1611 record the external symbol information so that the backend can
1612 write it out correctly. The ELF backend doesn't actually handle
1613 this at the moment, so we do it ourselves. We save the information
1617 elf_ecoff_set_ext (sym
, ext
)
1619 struct ecoff_extr
*ext
;
1621 symbol_get_bfdsym (sym
)->udata
.p
= (PTR
) ext
;
1624 /* This function is called by bfd_ecoff_debug_externals. It is
1625 supposed to *EXT to the external symbol information, and return
1626 whether the symbol should be used at all. */
1629 elf_get_extr (sym
, ext
)
1633 if (sym
->udata
.p
== NULL
)
1635 *ext
= *(EXTR
*) sym
->udata
.p
;
1639 /* This function is called by bfd_ecoff_debug_externals. It has
1640 nothing to do for ELF. */
1644 elf_set_index (sym
, indx
)
1645 asymbol
*sym ATTRIBUTE_UNUSED
;
1646 bfd_size_type indx ATTRIBUTE_UNUSED
;
1650 #endif /* NEED_ECOFF_DEBUG */
1653 elf_frob_symbol (symp
, puntp
)
1657 struct elf_obj_sy
*sy_obj
;
1659 #ifdef NEED_ECOFF_DEBUG
1660 if (ECOFF_DEBUGGING
)
1661 ecoff_frob_symbol (symp
);
1664 sy_obj
= symbol_get_obj (symp
);
1666 if (sy_obj
->size
!= NULL
)
1668 switch (sy_obj
->size
->X_op
)
1672 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1673 + sy_obj
->size
->X_add_number
1674 - S_GET_VALUE (sy_obj
->size
->X_op_symbol
)));
1678 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1679 + sy_obj
->size
->X_add_number
));
1682 as_bad (_(".size expression too complicated to fix up"));
1685 free (sy_obj
->size
);
1686 sy_obj
->size
= NULL
;
1689 if (sy_obj
->versioned_name
!= NULL
)
1693 p
= strchr (sy_obj
->versioned_name
, ELF_VER_CHR
);
1696 /* This symbol was given a new name with the .symver directive.
1698 If this is an external reference, just rename the symbol to
1699 include the version string. This will make the relocs be
1700 against the correct versioned symbol.
1702 If this is a definition, add an alias. FIXME: Using an alias
1703 will permit the debugging information to refer to the right
1704 symbol. However, it's not clear whether it is the best
1707 if (! S_IS_DEFINED (symp
))
1709 /* Verify that the name isn't using the @@ syntax--this is
1710 reserved for definitions of the default version to link
1712 if (p
[1] == ELF_VER_CHR
)
1714 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1715 sy_obj
->versioned_name
);
1718 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1722 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
1726 /* The @@@ syntax is a special case. It renames the
1727 symbol name to versioned_name with one `@' removed. */
1728 l
= strlen (&p
[3]) + 1;
1729 memmove (&p
[2], &p
[3], l
);
1730 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1736 /* FIXME: Creating a new symbol here is risky. We're
1737 in the final loop over the symbol table. We can
1738 get away with it only because the symbol goes to
1739 the end of the list, where the loop will still see
1740 it. It would probably be better to do this in
1741 obj_frob_file_before_adjust. */
1743 symp2
= symbol_find_or_make (sy_obj
->versioned_name
);
1745 /* Now we act as though we saw symp2 = sym. */
1747 S_SET_SEGMENT (symp2
, S_GET_SEGMENT (symp
));
1749 /* Subtracting out the frag address here is a hack
1750 because we are in the middle of the final loop. */
1753 - symbol_get_frag (symp
)->fr_address
));
1755 symbol_set_frag (symp2
, symbol_get_frag (symp
));
1757 /* This will copy over the size information. */
1758 copy_symbol_attributes (symp2
, symp
);
1760 if (S_IS_WEAK (symp
))
1763 if (S_IS_EXTERNAL (symp
))
1764 S_SET_EXTERNAL (symp2
);
1769 /* Double check weak symbols. */
1770 if (S_IS_WEAK (symp
))
1772 if (S_IS_COMMON (symp
))
1773 as_bad (_("Symbol `%s' can not be both weak and common"),
1778 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1779 any undefined non-function symbol to STT_OBJECT. We try to be
1780 compatible, since newer Irix 5 and 6 linkers care. However, we
1781 only set undefined symbols to be STT_OBJECT if we are on Irix,
1782 because that is the only time gcc will generate the necessary
1783 .global directives to mark functions. */
1785 if (S_IS_COMMON (symp
))
1786 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1788 if (strstr (TARGET_OS
, "irix") != NULL
1789 && ! S_IS_DEFINED (symp
)
1790 && (symbol_get_bfdsym (symp
)->flags
& BSF_FUNCTION
) == 0)
1791 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1795 /* If TC_PPC is defined, we used to force the type of a symbol to be
1796 BSF_OBJECT if it was otherwise unset. This was required by some
1797 version of VxWorks. Thomas de Lellis <tdel@windriver.com> says
1798 that this is no longer needed, so it is now commented out. */
1799 if ((symbol_get_bfdsym (symp
)->flags
1800 & (BSF_FUNCTION
| BSF_FILE
| BSF_SECTION_SYM
)) == 0
1801 && S_IS_DEFINED (symp
))
1802 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1809 bfd_map_over_sections (stdoutput
, adjust_stab_sections
, (PTR
) 0);
1811 #ifdef elf_tc_final_processing
1812 elf_tc_final_processing ();
1816 /* It removes any unneeded versioned symbols from the symbol table. */
1819 elf_frob_file_before_adjust ()
1825 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1826 if (symbol_get_obj (symp
)->versioned_name
)
1828 if (!S_IS_DEFINED (symp
))
1832 /* The @@@ syntax is a special case. If the symbol is
1833 not defined, 2 `@'s will be removed from the
1836 p
= strchr (symbol_get_obj (symp
)->versioned_name
,
1839 if (p
[1] == ELF_VER_CHR
&& p
[2] == ELF_VER_CHR
)
1841 size_t l
= strlen (&p
[3]) + 1;
1842 memmove (&p
[1], &p
[3], l
);
1844 if (symbol_used_p (symp
) == 0
1845 && symbol_used_in_reloc_p (symp
) == 0)
1846 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1852 /* It is required that we let write_relocs have the opportunity to
1853 optimize away fixups before output has begun, since it is possible
1854 to eliminate all fixups for a section and thus we never should
1855 have generated the relocation section. */
1858 elf_frob_file_after_relocs ()
1860 #ifdef NEED_ECOFF_DEBUG
1861 if (ECOFF_DEBUGGING
)
1862 /* Generate the ECOFF debugging information. */
1864 const struct ecoff_debug_swap
*debug_swap
;
1865 struct ecoff_debug_info debug
;
1870 = get_elf_backend_data (stdoutput
)->elf_backend_ecoff_debug_swap
;
1871 know (debug_swap
!= (const struct ecoff_debug_swap
*) NULL
);
1872 ecoff_build_debug (&debug
.symbolic_header
, &buf
, debug_swap
);
1874 /* Set up the pointers in debug. */
1875 #define SET(ptr, offset, type) \
1876 debug.ptr = (type) (buf + debug.symbolic_header.offset)
1878 SET (line
, cbLineOffset
, unsigned char *);
1879 SET (external_dnr
, cbDnOffset
, PTR
);
1880 SET (external_pdr
, cbPdOffset
, PTR
);
1881 SET (external_sym
, cbSymOffset
, PTR
);
1882 SET (external_opt
, cbOptOffset
, PTR
);
1883 SET (external_aux
, cbAuxOffset
, union aux_ext
*);
1884 SET (ss
, cbSsOffset
, char *);
1885 SET (external_fdr
, cbFdOffset
, PTR
);
1886 SET (external_rfd
, cbRfdOffset
, PTR
);
1887 /* ssext and external_ext are set up just below. */
1891 /* Set up the external symbols. */
1892 debug
.ssext
= debug
.ssext_end
= NULL
;
1893 debug
.external_ext
= debug
.external_ext_end
= NULL
;
1894 if (! bfd_ecoff_debug_externals (stdoutput
, &debug
, debug_swap
, true,
1895 elf_get_extr
, elf_set_index
))
1896 as_fatal (_("Failed to set up debugging information: %s"),
1897 bfd_errmsg (bfd_get_error ()));
1899 sec
= bfd_get_section_by_name (stdoutput
, ".mdebug");
1900 assert (sec
!= NULL
);
1902 know (stdoutput
->output_has_begun
== false);
1904 /* We set the size of the section, call bfd_set_section_contents
1905 to force the ELF backend to allocate a file position, and then
1906 write out the data. FIXME: Is this really the best way to do
1908 sec
->_raw_size
= bfd_ecoff_debug_size (stdoutput
, &debug
, debug_swap
);
1910 /* Pass BUF to bfd_set_section_contents because this will
1911 eventually become a call to fwrite, and ISO C prohibits
1912 passing a NULL pointer to a stdio function even if the
1913 pointer will not be used. */
1914 if (! bfd_set_section_contents (stdoutput
, sec
, (PTR
) buf
,
1915 (file_ptr
) 0, (bfd_size_type
) 0))
1916 as_fatal (_("Can't start writing .mdebug section: %s"),
1917 bfd_errmsg (bfd_get_error ()));
1919 know (stdoutput
->output_has_begun
== true);
1920 know (sec
->filepos
!= 0);
1922 if (! bfd_ecoff_write_debug (stdoutput
, &debug
, debug_swap
,
1924 as_fatal (_("Could not write .mdebug section: %s"),
1925 bfd_errmsg (bfd_get_error ()));
1927 #endif /* NEED_ECOFF_DEBUG */
1932 /* Heavily plagarized from obj_elf_version. The idea is to emit the
1933 SCO specific identifier in the .notes section to satisfy the SCO
1936 This looks more complicated than it really is. As opposed to the
1937 "obvious" solution, this should handle the cross dev cases
1938 correctly. (i.e, hosting on a 64 bit big endian processor, but
1939 generating SCO Elf code) Efficiency isn't a concern, as there
1940 should be exactly one of these sections per object module.
1942 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
1945 int_32 namesz = 4 ; Name size
1946 int_32 descsz = 12 ; Descriptive information
1948 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
1949 int_32 version = (major ver # << 16) | version of tools ;
1950 int_32 source = (tool_id << 16 ) | 1 ;
1951 int_32 info = 0 ; These are set by the SCO tools, but we
1952 don't know enough about the source
1953 environment to set them. SCO ld currently
1954 ignores them, and recommends we set them
1957 #define SCO_MAJOR_VERSION 0x1
1958 #define SCO_MINOR_VERSION 0x1
1968 asection
*seg
= now_seg
;
1969 subsegT subseg
= now_subseg
;
1970 Elf_Internal_Note i_note
;
1971 Elf_External_Note e_note
;
1972 asection
*note_secp
= (asection
*) NULL
;
1975 /* create the .note section */
1977 note_secp
= subseg_new (".note", 0);
1978 bfd_set_section_flags (stdoutput
,
1980 SEC_HAS_CONTENTS
| SEC_READONLY
);
1982 /* process the version string */
1985 i_note
.descsz
= 12; /* 12 descriptive bytes */
1986 i_note
.type
= NT_VERSION
; /* Contains a version string */
1988 p
= frag_more (sizeof (i_note
.namesz
));
1989 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
1991 p
= frag_more (sizeof (i_note
.descsz
));
1992 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
1994 p
= frag_more (sizeof (i_note
.type
));
1995 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
2000 /* Note: this is the version number of the ELF we're representing */
2002 md_number_to_chars (p
, (SCO_MAJOR_VERSION
<< 16) | (SCO_MINOR_VERSION
), 4);
2004 /* Here, we pick a magic number for ourselves (yes, I "registered"
2005 it with SCO. The bottom bit shows that we are compat with the
2008 md_number_to_chars (p
, 0x4c520000 | 0x0001, 4);
2010 /* If we knew (or cared) what the source language options were, we'd
2011 fill them in here. SCO has given us permission to ignore these
2012 and just set them to zero. */
2014 md_number_to_chars (p
, 0x0000, 4);
2016 frag_align (2, 0, 0);
2018 /* We probably can't restore the current segment, for there likely
2021 subseg_set (seg
, subseg
);
2025 #endif /* SCO_ELF */
2028 elf_separate_stab_sections ()
2030 #ifdef NEED_ECOFF_DEBUG
2031 return (!ECOFF_DEBUGGING
);
2038 elf_init_stab_section (seg
)
2041 #ifdef NEED_ECOFF_DEBUG
2042 if (!ECOFF_DEBUGGING
)
2044 obj_elf_init_stab_section (seg
);
2047 const struct format_ops elf_format_ops
=
2049 bfd_target_elf_flavour
,
2050 0, /* dfl_leading_underscore */
2051 1, /* emit_section_symbols */
2056 elf_frob_file_before_adjust
,
2057 elf_frob_file_after_relocs
,
2058 elf_s_get_size
, elf_s_set_size
,
2059 elf_s_get_align
, elf_s_set_align
,
2066 elf_copy_symbol_attributes
,
2067 #ifdef NEED_ECOFF_DEBUG
2068 ecoff_generate_asm_lineno
,
2071 0, /* generate_asm_lineno */
2072 0, /* process_stab */
2074 elf_separate_stab_sections
,
2075 elf_init_stab_section
,
2076 elf_sec_sym_ok_for_reloc
,
2078 #ifdef NEED_ECOFF_DEBUG
2081 0, /* ecoff_set_ext */
2083 elf_obj_read_begin_hook
,
2084 elf_obj_symbol_new_hook