1 /* ELF object file format
2 Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 99, 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
, push
)
625 int type
, attr
, 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 #ifdef md_elf_section_flags
695 flags
= md_elf_section_flags (flags
, attr
, type
);
702 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */
703 if (type
== SHT_NOBITS
)
704 seg_info (sec
)->bss
= 1;
706 bfd_set_section_flags (stdoutput
, sec
, flags
);
708 /* Add a symbol for this section to the symbol table. */
709 secsym
= symbol_find (name
);
711 symbol_set_bfdsym (secsym
, sec
->symbol
);
713 symbol_table_insert (section_symbol (sec
));
717 /* If section attributes are specified the second time we see a
718 particular section, then check that they are the same as we
719 saw the first time. */
720 if ((old_sec
->flags
^ flags
)
721 & (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
722 | SEC_EXCLUDE
| SEC_SORT_ENTRIES
))
723 as_warn (_("Ignoring changed section attributes for %s"), name
);
726 #ifdef md_elf_section_change_hook
727 md_elf_section_change_hook ();
732 obj_elf_parse_section_letters (str
, len
)
749 attr
|= SHF_EXECINSTR
;
753 char *bad_msg
= _("Unrecognized .section attribute: want a,w,x");
754 #ifdef md_elf_section_letter
755 int md_attr
= md_elf_section_letter (*str
, &bad_msg
);
761 as_warn ("%s", bad_msg
);
774 obj_elf_section_word (str
, len
)
778 if (len
== 5 && strncmp (str
, "write", 5) == 0)
780 if (len
== 5 && strncmp (str
, "alloc", 5) == 0)
782 if (len
== 9 && strncmp (str
, "execinstr", 9) == 0)
783 return SHF_EXECINSTR
;
785 #ifdef md_elf_section_word
787 int md_attr
= md_elf_section_word (str
, len
);
793 as_warn (_("Unrecognized section attribute"));
798 obj_elf_section_type (str
, len
)
802 if (len
== 8 && strncmp (str
, "progbits", 8) == 0)
804 if (len
== 6 && strncmp (str
, "nobits", 6) == 0)
807 #ifdef md_elf_section_type
809 int md_type
= md_elf_section_type (str
, len
);
815 as_warn (_("Unrecognized section type"));
820 obj_elf_section (push
)
823 char *name
, *beg
, *end
;
824 int type
, attr
, dummy
;
831 #ifdef md_flush_pending_output
832 md_flush_pending_output ();
835 previous_section
= now_seg
;
836 previous_subsection
= now_subseg
;
838 s_mri_sect (&mri_type
);
840 #ifdef md_elf_section_change_hook
841 md_elf_section_change_hook ();
846 #endif /* ! defined (TC_I370) */
848 /* Get name of section. */
850 if (*input_line_pointer
== '"')
852 name
= demand_copy_C_string (&dummy
);
855 ignore_rest_of_line ();
861 end
= input_line_pointer
;
862 while (0 == strchr ("\n\t,; ", *end
))
864 if (end
== input_line_pointer
)
866 as_warn (_("Missing section name"));
867 ignore_rest_of_line ();
871 name
= xmalloc (end
- input_line_pointer
+ 1);
872 memcpy (name
, input_line_pointer
, end
- input_line_pointer
);
873 name
[end
- input_line_pointer
] = '\0';
874 input_line_pointer
= end
;
881 if (*input_line_pointer
== ',')
883 /* Skip the comma. */
884 ++input_line_pointer
;
887 if (*input_line_pointer
== '"')
889 beg
= demand_copy_C_string (&dummy
);
892 ignore_rest_of_line ();
895 attr
|= obj_elf_parse_section_letters (beg
, strlen (beg
));
898 if (*input_line_pointer
== ',')
901 ++input_line_pointer
;
903 c
= *input_line_pointer
;
906 beg
= demand_copy_C_string (&dummy
);
909 ignore_rest_of_line ();
912 type
= obj_elf_section_type (beg
, strlen (beg
));
914 else if (c
== '@' || c
== '%')
916 beg
= ++input_line_pointer
;
917 c
= get_symbol_end ();
918 *input_line_pointer
= c
;
919 type
= obj_elf_section_type (beg
, input_line_pointer
- beg
);
930 if (*input_line_pointer
!= '#')
932 as_warn (_("Bad .section directive - character following name is not '#'"));
933 ignore_rest_of_line ();
936 beg
= ++input_line_pointer
;
937 c
= get_symbol_end ();
938 *input_line_pointer
= c
;
940 attr
|= obj_elf_section_word (beg
, input_line_pointer
- beg
);
944 while (*input_line_pointer
++ == ',');
945 --input_line_pointer
;
949 demand_empty_rest_of_line ();
951 obj_elf_change_section (name
, type
, attr
, push
);
954 /* Change to the .data section. */
960 #ifdef md_flush_pending_output
961 md_flush_pending_output ();
964 previous_section
= now_seg
;
965 previous_subsection
= now_subseg
;
968 #ifdef md_elf_section_change_hook
969 md_elf_section_change_hook ();
973 /* Change to the .text section. */
979 #ifdef md_flush_pending_output
980 md_flush_pending_output ();
983 previous_section
= now_seg
;
984 previous_subsection
= now_subseg
;
987 #ifdef md_elf_section_change_hook
988 md_elf_section_change_hook ();
993 obj_elf_subsection (ignore
)
994 int ignore ATTRIBUTE_UNUSED
;
998 #ifdef md_flush_pending_output
999 md_flush_pending_output ();
1002 previous_section
= now_seg
;
1003 previous_subsection
= now_subseg
;
1005 temp
= get_absolute_expression ();
1006 subseg_set (now_seg
, (subsegT
) temp
);
1007 demand_empty_rest_of_line ();
1009 #ifdef md_elf_section_change_hook
1010 md_elf_section_change_hook ();
1014 /* This can be called from the processor backends if they change
1018 obj_elf_section_change_hook ()
1020 previous_section
= now_seg
;
1021 previous_subsection
= now_subseg
;
1025 obj_elf_previous (ignore
)
1026 int ignore ATTRIBUTE_UNUSED
;
1031 if (previous_section
== 0)
1033 as_bad (_(".previous without corresponding .section; ignored"));
1037 #ifdef md_flush_pending_output
1038 md_flush_pending_output ();
1041 new_section
= previous_section
;
1042 new_subsection
= previous_subsection
;
1043 previous_section
= now_seg
;
1044 previous_subsection
= now_subseg
;
1045 subseg_set (new_section
, new_subsection
);
1047 #ifdef md_elf_section_change_hook
1048 md_elf_section_change_hook ();
1053 obj_elf_popsection (xxx
)
1054 int xxx ATTRIBUTE_UNUSED
;
1056 struct section_stack
*top
= section_stack
;
1060 as_bad (_(".popsection without corresponding .pushsection; ignored"));
1064 #ifdef md_flush_pending_output
1065 md_flush_pending_output ();
1068 section_stack
= top
->next
;
1069 previous_section
= top
->prev_seg
;
1070 previous_subsection
= top
->prev_subseg
;
1071 subseg_set (top
->seg
, top
->subseg
);
1074 #ifdef md_elf_section_change_hook
1075 md_elf_section_change_hook ();
1080 obj_elf_line (ignore
)
1081 int ignore ATTRIBUTE_UNUSED
;
1083 /* Assume delimiter is part of expression. BSD4.2 as fails with
1084 delightful bug, so we are not being incompatible here. */
1085 new_logical_line ((char *) NULL
, (int) (get_absolute_expression ()));
1086 demand_empty_rest_of_line ();
1089 /* This handles the .symver pseudo-op, which is used to specify a
1090 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1091 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1092 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1093 with the same value as the symbol NAME. */
1096 obj_elf_symver (ignore
)
1097 int ignore ATTRIBUTE_UNUSED
;
1103 name
= input_line_pointer
;
1104 c
= get_symbol_end ();
1106 sym
= symbol_find_or_make (name
);
1108 *input_line_pointer
= c
;
1110 if (symbol_get_obj (sym
)->versioned_name
!= NULL
)
1112 as_bad (_("multiple .symver directives for symbol `%s'"),
1114 ignore_rest_of_line ();
1119 if (*input_line_pointer
!= ',')
1121 as_bad (_("expected comma after name in .symver"));
1122 ignore_rest_of_line ();
1126 ++input_line_pointer
;
1127 name
= input_line_pointer
;
1130 c
= get_symbol_end ();
1131 if (c
!= ELF_VER_CHR
)
1133 *input_line_pointer
++ = c
;
1136 symbol_get_obj (sym
)->versioned_name
= xstrdup (name
);
1138 *input_line_pointer
= c
;
1140 if (strchr (symbol_get_obj (sym
)->versioned_name
, ELF_VER_CHR
) == NULL
)
1142 as_bad (_("missing version name in `%s' for symbol `%s'"),
1143 symbol_get_obj (sym
)->versioned_name
, S_GET_NAME (sym
));
1144 ignore_rest_of_line ();
1148 demand_empty_rest_of_line ();
1151 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1152 to the linker the hierarchy in which a particular table resides. The
1153 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1156 obj_elf_vtable_inherit (ignore
)
1157 int ignore ATTRIBUTE_UNUSED
;
1159 char *cname
, *pname
;
1160 symbolS
*csym
, *psym
;
1163 if (*input_line_pointer
== '#')
1164 ++input_line_pointer
;
1166 cname
= input_line_pointer
;
1167 c
= get_symbol_end ();
1168 csym
= symbol_find (cname
);
1170 /* GCFIXME: should check that we don't have two .vtable_inherits for
1171 the same child symbol. Also, we can currently only do this if the
1172 child symbol is already exists and is placed in a fragment. */
1174 if (csym
== NULL
|| symbol_get_frag (csym
) == NULL
)
1176 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1181 *input_line_pointer
= c
;
1184 if (*input_line_pointer
!= ',')
1186 as_bad ("expected comma after name in .vtable_inherit");
1187 ignore_rest_of_line ();
1191 ++input_line_pointer
;
1194 if (*input_line_pointer
== '#')
1195 ++input_line_pointer
;
1197 if (input_line_pointer
[0] == '0'
1198 && (input_line_pointer
[1] == '\0'
1199 || isspace ((unsigned char) input_line_pointer
[1])))
1201 psym
= section_symbol (absolute_section
);
1202 ++input_line_pointer
;
1206 pname
= input_line_pointer
;
1207 c
= get_symbol_end ();
1208 psym
= symbol_find_or_make (pname
);
1209 *input_line_pointer
= c
;
1212 demand_empty_rest_of_line ();
1217 assert (symbol_get_value_expression (csym
)->X_op
== O_constant
);
1218 return fix_new (symbol_get_frag (csym
),
1219 symbol_get_value_expression (csym
)->X_add_number
,
1220 0, psym
, 0, 0, BFD_RELOC_VTABLE_INHERIT
);
1223 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1224 to the linker that a vtable slot was used. The syntax is
1225 ".vtable_entry tablename, offset". */
1228 obj_elf_vtable_entry (ignore
)
1229 int ignore ATTRIBUTE_UNUSED
;
1236 if (*input_line_pointer
== '#')
1237 ++input_line_pointer
;
1239 name
= input_line_pointer
;
1240 c
= get_symbol_end ();
1241 sym
= symbol_find_or_make (name
);
1242 *input_line_pointer
= c
;
1245 if (*input_line_pointer
!= ',')
1247 as_bad ("expected comma after name in .vtable_entry");
1248 ignore_rest_of_line ();
1252 ++input_line_pointer
;
1253 if (*input_line_pointer
== '#')
1254 ++input_line_pointer
;
1256 offset
= get_absolute_expression ();
1258 demand_empty_rest_of_line ();
1260 return fix_new (frag_now
, frag_now_fix (), 0, sym
, offset
, 0,
1261 BFD_RELOC_VTABLE_ENTRY
);
1265 elf_obj_read_begin_hook ()
1267 #ifdef NEED_ECOFF_DEBUG
1268 if (ECOFF_DEBUGGING
)
1269 ecoff_read_begin_hook ();
1274 elf_obj_symbol_new_hook (symbolP
)
1277 struct elf_obj_sy
*sy_obj
;
1279 sy_obj
= symbol_get_obj (symbolP
);
1280 sy_obj
->size
= NULL
;
1281 sy_obj
->versioned_name
= NULL
;
1283 #ifdef NEED_ECOFF_DEBUG
1284 if (ECOFF_DEBUGGING
)
1285 ecoff_symbol_new_hook (symbolP
);
1290 obj_elf_version (ignore
)
1291 int ignore ATTRIBUTE_UNUSED
;
1297 asection
*seg
= now_seg
;
1298 subsegT subseg
= now_subseg
;
1299 Elf_Internal_Note i_note
;
1300 Elf_External_Note e_note
;
1301 asection
*note_secp
= (asection
*) NULL
;
1305 if (*input_line_pointer
== '\"')
1307 ++input_line_pointer
; /* -> 1st char of string. */
1308 name
= input_line_pointer
;
1310 while (is_a_char (c
= next_char_of_string ()))
1312 c
= *input_line_pointer
;
1313 *input_line_pointer
= '\0';
1314 *(input_line_pointer
- 1) = '\0';
1315 *input_line_pointer
= c
;
1317 /* create the .note section */
1319 note_secp
= subseg_new (".note", 0);
1320 bfd_set_section_flags (stdoutput
,
1322 SEC_HAS_CONTENTS
| SEC_READONLY
);
1324 /* process the version string */
1326 len
= strlen (name
);
1328 i_note
.namesz
= ((len
+ 1) + 3) & ~3; /* round this to word boundary */
1329 i_note
.descsz
= 0; /* no description */
1330 i_note
.type
= NT_VERSION
;
1331 p
= frag_more (sizeof (e_note
.namesz
));
1332 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
1333 p
= frag_more (sizeof (e_note
.descsz
));
1334 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
1335 p
= frag_more (sizeof (e_note
.type
));
1336 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
1338 for (i
= 0; i
< len
; i
++)
1342 FRAG_APPEND_1_CHAR (ch
);
1345 frag_align (2, 0, 0);
1347 subseg_set (seg
, subseg
);
1351 as_bad (_("Expected quoted string"));
1353 demand_empty_rest_of_line ();
1357 obj_elf_size (ignore
)
1358 int ignore ATTRIBUTE_UNUSED
;
1360 char *name
= input_line_pointer
;
1361 char c
= get_symbol_end ();
1366 p
= input_line_pointer
;
1369 if (*input_line_pointer
!= ',')
1372 as_bad (_("expected comma after name `%s' in .size directive"), name
);
1374 ignore_rest_of_line ();
1377 input_line_pointer
++;
1379 if (exp
.X_op
== O_absent
)
1381 as_bad (_("missing expression in .size directive"));
1382 exp
.X_op
= O_constant
;
1383 exp
.X_add_number
= 0;
1386 sym
= symbol_find_or_make (name
);
1388 if (exp
.X_op
== O_constant
)
1389 S_SET_SIZE (sym
, exp
.X_add_number
);
1392 symbol_get_obj (sym
)->size
=
1393 (expressionS
*) xmalloc (sizeof (expressionS
));
1394 *symbol_get_obj (sym
)->size
= exp
;
1396 demand_empty_rest_of_line ();
1399 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1400 There are five syntaxes:
1402 The first (used on Solaris) is
1404 The second (used on UnixWare) is
1406 The third (reportedly to be used on Irix 6.0) is
1408 The fourth (used on NetBSD/Arm and Linux/ARM) is
1410 The fifth (used on SVR4/860) is
1411 .type SYM,"function"
1415 obj_elf_type (ignore
)
1416 int ignore ATTRIBUTE_UNUSED
;
1421 const char *typename
;
1423 elf_symbol_type
*elfsym
;
1425 name
= input_line_pointer
;
1426 c
= get_symbol_end ();
1427 sym
= symbol_find_or_make (name
);
1428 elfsym
= (elf_symbol_type
*) symbol_get_bfdsym (sym
);
1429 *input_line_pointer
= c
;
1432 if (*input_line_pointer
== ',')
1433 ++input_line_pointer
;
1436 if ( *input_line_pointer
== '#'
1437 || *input_line_pointer
== '@'
1438 || *input_line_pointer
== '"'
1439 || *input_line_pointer
== '%')
1440 ++input_line_pointer
;
1442 typename
= input_line_pointer
;
1443 c
= get_symbol_end ();
1446 if (strcmp (typename
, "function") == 0
1447 || strcmp (typename
, "STT_FUNC") == 0)
1448 type
= BSF_FUNCTION
;
1449 else if (strcmp (typename
, "object") == 0
1450 || strcmp (typename
, "STT_OBJECT") == 0)
1452 #ifdef md_elf_symbol_type
1453 else if ((type
= md_elf_symbol_type (typename
, sym
, elfsym
)) != -1)
1457 as_bad (_("ignoring unrecognized symbol type \"%s\""), typename
);
1459 *input_line_pointer
= c
;
1461 if (*input_line_pointer
== '"')
1462 ++input_line_pointer
;
1464 elfsym
->symbol
.flags
|= type
;
1466 demand_empty_rest_of_line ();
1470 obj_elf_ident (ignore
)
1471 int ignore ATTRIBUTE_UNUSED
;
1473 static segT comment_section
;
1474 segT old_section
= now_seg
;
1475 int old_subsection
= now_subseg
;
1477 #ifdef md_flush_pending_output
1478 md_flush_pending_output ();
1481 if (!comment_section
)
1484 comment_section
= subseg_new (".comment", 0);
1485 bfd_set_section_flags (stdoutput
, comment_section
,
1486 SEC_READONLY
| SEC_HAS_CONTENTS
);
1491 subseg_set (comment_section
, 0);
1493 subseg_set (old_section
, old_subsection
);
1496 #ifdef INIT_STAB_SECTION
1498 /* The first entry in a .stabs section is special. */
1501 obj_elf_init_stab_section (seg
)
1507 unsigned int stroff
;
1509 /* Force the section to align to a longword boundary. Without this,
1510 UnixWare ar crashes. */
1511 bfd_set_section_alignment (stdoutput
, seg
, 2);
1513 /* Make space for this first symbol. */
1517 as_where (&file
, (unsigned int *) NULL
);
1518 stabstr_name
= (char *) alloca (strlen (segment_name (seg
)) + 4);
1519 strcpy (stabstr_name
, segment_name (seg
));
1520 strcat (stabstr_name
, "str");
1521 stroff
= get_stab_string_offset (file
, stabstr_name
);
1523 md_number_to_chars (p
, stroff
, 4);
1524 seg_info (seg
)->stabu
.p
= p
;
1529 /* Fill in the counts in the first entry in a .stabs section. */
1532 adjust_stab_sections (abfd
, sec
, xxx
)
1535 PTR xxx ATTRIBUTE_UNUSED
;
1542 if (strncmp (".stab", sec
->name
, 5))
1544 if (!strcmp ("str", sec
->name
+ strlen (sec
->name
) - 3))
1547 name
= (char *) alloca (strlen (sec
->name
) + 4);
1548 strcpy (name
, sec
->name
);
1549 strcat (name
, "str");
1550 strsec
= bfd_get_section_by_name (abfd
, name
);
1552 strsz
= bfd_section_size (abfd
, strsec
);
1555 nsyms
= bfd_section_size (abfd
, sec
) / 12 - 1;
1557 p
= seg_info (sec
)->stabu
.p
;
1560 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
1561 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
1564 #ifdef NEED_ECOFF_DEBUG
1566 /* This function is called by the ECOFF code. It is supposed to
1567 record the external symbol information so that the backend can
1568 write it out correctly. The ELF backend doesn't actually handle
1569 this at the moment, so we do it ourselves. We save the information
1573 elf_ecoff_set_ext (sym
, ext
)
1575 struct ecoff_extr
*ext
;
1577 symbol_get_bfdsym (sym
)->udata
.p
= (PTR
) ext
;
1580 /* This function is called by bfd_ecoff_debug_externals. It is
1581 supposed to *EXT to the external symbol information, and return
1582 whether the symbol should be used at all. */
1585 elf_get_extr (sym
, ext
)
1589 if (sym
->udata
.p
== NULL
)
1591 *ext
= *(EXTR
*) sym
->udata
.p
;
1595 /* This function is called by bfd_ecoff_debug_externals. It has
1596 nothing to do for ELF. */
1600 elf_set_index (sym
, indx
)
1601 asymbol
*sym ATTRIBUTE_UNUSED
;
1602 bfd_size_type indx ATTRIBUTE_UNUSED
;
1606 #endif /* NEED_ECOFF_DEBUG */
1609 elf_frob_symbol (symp
, puntp
)
1613 struct elf_obj_sy
*sy_obj
;
1615 #ifdef NEED_ECOFF_DEBUG
1616 if (ECOFF_DEBUGGING
)
1617 ecoff_frob_symbol (symp
);
1620 sy_obj
= symbol_get_obj (symp
);
1622 if (sy_obj
->size
!= NULL
)
1624 switch (sy_obj
->size
->X_op
)
1628 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1629 + sy_obj
->size
->X_add_number
1630 - S_GET_VALUE (sy_obj
->size
->X_op_symbol
)));
1634 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1635 + sy_obj
->size
->X_add_number
));
1638 as_bad (_(".size expression too complicated to fix up"));
1641 free (sy_obj
->size
);
1642 sy_obj
->size
= NULL
;
1645 if (sy_obj
->versioned_name
!= NULL
)
1647 /* This symbol was given a new name with the .symver directive.
1649 If this is an external reference, just rename the symbol to
1650 include the version string. This will make the relocs be
1651 against the correct versioned symbol.
1653 If this is a definition, add an alias. FIXME: Using an alias
1654 will permit the debugging information to refer to the right
1655 symbol. However, it's not clear whether it is the best
1658 if (! S_IS_DEFINED (symp
))
1662 /* Verify that the name isn't using the @@ syntax--this is
1663 reserved for definitions of the default version to link
1665 p
= strchr (sy_obj
->versioned_name
, ELF_VER_CHR
);
1667 if (p
[1] == ELF_VER_CHR
)
1669 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1670 sy_obj
->versioned_name
);
1673 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1679 /* FIXME: Creating a new symbol here is risky. We're in the
1680 final loop over the symbol table. We can get away with
1681 it only because the symbol goes to the end of the list,
1682 where the loop will still see it. It would probably be
1683 better to do this in obj_frob_file_before_adjust. */
1685 symp2
= symbol_find_or_make (sy_obj
->versioned_name
);
1687 /* Now we act as though we saw symp2 = sym. */
1689 S_SET_SEGMENT (symp2
, S_GET_SEGMENT (symp
));
1691 /* Subtracting out the frag address here is a hack because
1692 we are in the middle of the final loop. */
1695 - symbol_get_frag (symp
)->fr_address
));
1697 symbol_set_frag (symp2
, symbol_get_frag (symp
));
1699 /* This will copy over the size information. */
1700 copy_symbol_attributes (symp2
, symp
);
1702 if (S_IS_WEAK (symp
))
1705 if (S_IS_EXTERNAL (symp
))
1706 S_SET_EXTERNAL (symp2
);
1710 /* Double check weak symbols. */
1711 if (S_IS_WEAK (symp
))
1713 if (S_IS_COMMON (symp
))
1714 as_bad (_("Symbol `%s' can not be both weak and common"),
1719 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1720 any undefined non-function symbol to STT_OBJECT. We try to be
1721 compatible, since newer Irix 5 and 6 linkers care. However, we
1722 only set undefined symbols to be STT_OBJECT if we are on Irix,
1723 because that is the only time gcc will generate the necessary
1724 .global directives to mark functions. */
1726 if (S_IS_COMMON (symp
))
1727 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1729 if (strstr (TARGET_OS
, "irix") != NULL
1730 && ! S_IS_DEFINED (symp
)
1731 && (symbol_get_bfdsym (symp
)->flags
& BSF_FUNCTION
) == 0)
1732 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1736 /* If TC_PPC is defined, we used to force the type of a symbol to be
1737 BSF_OBJECT if it was otherwise unset. This was required by some
1738 version of VxWorks. Thomas de Lellis <tdel@windriver.com> says
1739 that this is no longer needed, so it is now commented out. */
1740 if ((symbol_get_bfdsym (symp
)->flags
1741 & (BSF_FUNCTION
| BSF_FILE
| BSF_SECTION_SYM
)) == 0
1742 && S_IS_DEFINED (symp
))
1743 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1750 bfd_map_over_sections (stdoutput
, adjust_stab_sections
, (PTR
) 0);
1752 #ifdef elf_tc_final_processing
1753 elf_tc_final_processing ();
1757 /* It is required that we let write_relocs have the opportunity to
1758 optimize away fixups before output has begun, since it is possible
1759 to eliminate all fixups for a section and thus we never should
1760 have generated the relocation section. */
1763 elf_frob_file_after_relocs ()
1765 #ifdef NEED_ECOFF_DEBUG
1766 if (ECOFF_DEBUGGING
)
1767 /* Generate the ECOFF debugging information. */
1769 const struct ecoff_debug_swap
*debug_swap
;
1770 struct ecoff_debug_info debug
;
1775 = get_elf_backend_data (stdoutput
)->elf_backend_ecoff_debug_swap
;
1776 know (debug_swap
!= (const struct ecoff_debug_swap
*) NULL
);
1777 ecoff_build_debug (&debug
.symbolic_header
, &buf
, debug_swap
);
1779 /* Set up the pointers in debug. */
1780 #define SET(ptr, offset, type) \
1781 debug.ptr = (type) (buf + debug.symbolic_header.offset)
1783 SET (line
, cbLineOffset
, unsigned char *);
1784 SET (external_dnr
, cbDnOffset
, PTR
);
1785 SET (external_pdr
, cbPdOffset
, PTR
);
1786 SET (external_sym
, cbSymOffset
, PTR
);
1787 SET (external_opt
, cbOptOffset
, PTR
);
1788 SET (external_aux
, cbAuxOffset
, union aux_ext
*);
1789 SET (ss
, cbSsOffset
, char *);
1790 SET (external_fdr
, cbFdOffset
, PTR
);
1791 SET (external_rfd
, cbRfdOffset
, PTR
);
1792 /* ssext and external_ext are set up just below. */
1796 /* Set up the external symbols. */
1797 debug
.ssext
= debug
.ssext_end
= NULL
;
1798 debug
.external_ext
= debug
.external_ext_end
= NULL
;
1799 if (! bfd_ecoff_debug_externals (stdoutput
, &debug
, debug_swap
, true,
1800 elf_get_extr
, elf_set_index
))
1801 as_fatal (_("Failed to set up debugging information: %s"),
1802 bfd_errmsg (bfd_get_error ()));
1804 sec
= bfd_get_section_by_name (stdoutput
, ".mdebug");
1805 assert (sec
!= NULL
);
1807 know (stdoutput
->output_has_begun
== false);
1809 /* We set the size of the section, call bfd_set_section_contents
1810 to force the ELF backend to allocate a file position, and then
1811 write out the data. FIXME: Is this really the best way to do
1813 sec
->_raw_size
= bfd_ecoff_debug_size (stdoutput
, &debug
, debug_swap
);
1815 /* Pass BUF to bfd_set_section_contents because this will
1816 eventually become a call to fwrite, and ISO C prohibits
1817 passing a NULL pointer to a stdio function even if the
1818 pointer will not be used. */
1819 if (! bfd_set_section_contents (stdoutput
, sec
, (PTR
) buf
,
1820 (file_ptr
) 0, (bfd_size_type
) 0))
1821 as_fatal (_("Can't start writing .mdebug section: %s"),
1822 bfd_errmsg (bfd_get_error ()));
1824 know (stdoutput
->output_has_begun
== true);
1825 know (sec
->filepos
!= 0);
1827 if (! bfd_ecoff_write_debug (stdoutput
, &debug
, debug_swap
,
1829 as_fatal (_("Could not write .mdebug section: %s"),
1830 bfd_errmsg (bfd_get_error ()));
1832 #endif /* NEED_ECOFF_DEBUG */
1837 /* Heavily plagarized from obj_elf_version. The idea is to emit the
1838 SCO specific identifier in the .notes section to satisfy the SCO
1841 This looks more complicated than it really is. As opposed to the
1842 "obvious" solution, this should handle the cross dev cases
1843 correctly. (i.e, hosting on a 64 bit big endian processor, but
1844 generating SCO Elf code) Efficiency isn't a concern, as there
1845 should be exactly one of these sections per object module.
1847 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
1850 int_32 namesz = 4 ; Name size
1851 int_32 descsz = 12 ; Descriptive information
1853 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
1854 int_32 version = (major ver # << 16) | version of tools ;
1855 int_32 source = (tool_id << 16 ) | 1 ;
1856 int_32 info = 0 ; These are set by the SCO tools, but we
1857 don't know enough about the source
1858 environment to set them. SCO ld currently
1859 ignores them, and recommends we set them
1862 #define SCO_MAJOR_VERSION 0x1
1863 #define SCO_MINOR_VERSION 0x1
1873 asection
*seg
= now_seg
;
1874 subsegT subseg
= now_subseg
;
1875 Elf_Internal_Note i_note
;
1876 Elf_External_Note e_note
;
1877 asection
*note_secp
= (asection
*) NULL
;
1880 /* create the .note section */
1882 note_secp
= subseg_new (".note", 0);
1883 bfd_set_section_flags (stdoutput
,
1885 SEC_HAS_CONTENTS
| SEC_READONLY
);
1887 /* process the version string */
1890 i_note
.descsz
= 12; /* 12 descriptive bytes */
1891 i_note
.type
= NT_VERSION
; /* Contains a version string */
1893 p
= frag_more (sizeof (i_note
.namesz
));
1894 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
1896 p
= frag_more (sizeof (i_note
.descsz
));
1897 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
1899 p
= frag_more (sizeof (i_note
.type
));
1900 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
1905 /* Note: this is the version number of the ELF we're representing */
1907 md_number_to_chars (p
, (SCO_MAJOR_VERSION
<< 16) | (SCO_MINOR_VERSION
), 4);
1909 /* Here, we pick a magic number for ourselves (yes, I "registered"
1910 it with SCO. The bottom bit shows that we are compat with the
1913 md_number_to_chars (p
, 0x4c520000 | 0x0001, 4);
1915 /* If we knew (or cared) what the source language options were, we'd
1916 fill them in here. SCO has given us permission to ignore these
1917 and just set them to zero. */
1919 md_number_to_chars (p
, 0x0000, 4);
1921 frag_align (2, 0, 0);
1923 /* We probably can't restore the current segment, for there likely
1926 subseg_set (seg
, subseg
);
1930 #endif /* SCO_ELF */
1933 elf_separate_stab_sections ()
1935 #ifdef NEED_ECOFF_DEBUG
1936 return (!ECOFF_DEBUGGING
);
1943 elf_init_stab_section (seg
)
1946 #ifdef NEED_ECOFF_DEBUG
1947 if (!ECOFF_DEBUGGING
)
1949 obj_elf_init_stab_section (seg
);
1952 const struct format_ops elf_format_ops
=
1954 bfd_target_elf_flavour
,
1955 0, /* dfl_leading_underscore */
1956 1, /* emit_section_symbols */
1961 elf_frob_file_after_relocs
,
1962 elf_s_get_size
, elf_s_set_size
,
1963 elf_s_get_align
, elf_s_set_align
,
1970 elf_copy_symbol_attributes
,
1971 #ifdef NEED_ECOFF_DEBUG
1972 ecoff_generate_asm_lineno
,
1975 0, /* generate_asm_lineno */
1976 0, /* process_stab */
1978 elf_separate_stab_sections
,
1979 elf_init_stab_section
,
1980 elf_sec_sym_ok_for_reloc
,
1982 #ifdef NEED_ECOFF_DEBUG
1985 0, /* ecoff_set_ext */
1987 elf_obj_read_begin_hook
,
1988 elf_obj_symbol_new_hook