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 ();
546 static segT previous_section
;
547 static int previous_subsection
;
551 struct section_stack
*next
;
553 int subseg
, prev_subseg
;
556 static struct section_stack
*section_stack
;
559 /* Handle the .section pseudo-op. This code supports two different
562 The first is found on Solaris, and looks like
563 .section ".sec1",#alloc,#execinstr,#write
564 Here the names after '#' are the SHF_* flags to turn on for the
565 section. I'm not sure how it determines the SHT_* type (BFD
566 doesn't really give us control over the type, anyhow).
568 The second format is found on UnixWare, and probably most SVR4
569 machines, and looks like
570 .section .sec1,"a",@progbits
571 The quoted string may contain any combination of a, w, x, and
572 represents the SHF_* flags to turn on for the section. The string
573 beginning with '@' can be progbits or nobits. There should be
574 other possibilities, but I don't know what they are. In any case,
575 BFD doesn't really let us set the section type. */
577 /* Certain named sections have particular defined types, listed on p.
579 struct special_section
586 static struct special_section
const special_sections
[] =
588 { ".bss", SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
589 { ".comment", SHT_PROGBITS
, 0 },
590 { ".data", SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
591 { ".data1", SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
592 { ".debug", SHT_PROGBITS
, 0 },
593 { ".fini", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
594 { ".init", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
595 { ".line", SHT_PROGBITS
, 0 },
596 { ".note", SHT_NOTE
, 0 },
597 { ".rodata", SHT_PROGBITS
, SHF_ALLOC
},
598 { ".rodata1", SHT_PROGBITS
, SHF_ALLOC
},
599 { ".text", SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
601 #ifdef ELF_TC_SPECIAL_SECTIONS
602 ELF_TC_SPECIAL_SECTIONS
606 /* The following section names are special, but they can not
607 reasonably appear in assembler code. Some of the attributes are
608 processor dependent. */
609 { ".dynamic", SHT_DYNAMIC
, SHF_ALLOC
/* + SHF_WRITE */ },
610 { ".dynstr", SHT_STRTAB
, SHF_ALLOC
},
611 { ".dynsym", SHT_DYNSYM
, SHF_ALLOC
},
612 { ".got", SHT_PROGBITS
, 0 },
613 { ".hash", SHT_HASH
, SHF_ALLOC
},
614 { ".interp", SHT_PROGBITS
, /* SHF_ALLOC */ },
615 { ".plt", SHT_PROGBITS
, 0 },
616 { ".shstrtab",SHT_STRTAB
, 0 },
617 { ".strtab", SHT_STRTAB
, /* SHF_ALLOC */ },
618 { ".symtab", SHT_SYMTAB
, /* SHF_ALLOC */ },
625 obj_elf_change_section (name
, type
, attr
, push
)
627 int type
, attr
, push
;
634 #ifdef md_flush_pending_output
635 md_flush_pending_output ();
638 /* Switch to the section, creating it if necessary. */
641 struct section_stack
*elt
;
642 elt
= xmalloc (sizeof (struct section_stack
));
643 elt
->next
= section_stack
;
645 elt
->prev_seg
= previous_section
;
646 elt
->subseg
= now_subseg
;
647 elt
->prev_subseg
= previous_subsection
;
650 previous_section
= now_seg
;
651 previous_subsection
= now_subseg
;
653 old_sec
= bfd_get_section_by_name (stdoutput
, name
);
654 sec
= subseg_new (name
, 0);
656 /* See if this is one of the special sections. */
657 for (i
= 0; special_sections
[i
].name
!= NULL
; i
++)
658 if (strcmp (name
, special_sections
[i
].name
) == 0)
660 if (type
== SHT_NULL
)
661 type
= special_sections
[i
].type
;
662 else if (type
!= special_sections
[i
].type
)
666 as_warn (_("Setting incorrect section type for %s"), name
);
670 as_warn (_("Ignoring incorrect section type for %s"), name
);
671 type
= special_sections
[i
].type
;
674 if ((attr
&~ special_sections
[i
].attributes
) != 0
677 /* As a GNU extension, we permit a .note section to be
678 allocatable. If the linker sees an allocateable .note
679 section, it will create a PT_NOTE segment in the output
681 if (strcmp (name
, ".note") != 0
682 || attr
!= SHF_ALLOC
)
683 as_warn (_("Setting incorrect section attributes for %s"),
686 attr
|= special_sections
[i
].attributes
;
690 /* Convert ELF type and flags to BFD flags. */
692 | ((attr
& SHF_WRITE
) ? 0 : SEC_READONLY
)
693 | ((attr
& SHF_ALLOC
) ? SEC_ALLOC
: 0)
694 | (((attr
& SHF_ALLOC
) && type
!= SHT_NOBITS
) ? SEC_LOAD
: 0)
695 | ((attr
& SHF_EXECINSTR
) ? SEC_CODE
: 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
);
710 /* Add a symbol for this section to the symbol table. */
711 secsym
= symbol_find (name
);
713 symbol_set_bfdsym (secsym
, sec
->symbol
);
715 symbol_table_insert (section_symbol (sec
));
719 /* If section attributes are specified the second time we see a
720 particular section, then check that they are the same as we
721 saw the first time. */
722 if ((old_sec
->flags
^ flags
)
723 & (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
724 | SEC_EXCLUDE
| SEC_SORT_ENTRIES
))
725 as_warn (_("Ignoring changed section attributes for %s"), name
);
728 #ifdef md_elf_section_change_hook
729 md_elf_section_change_hook ();
734 obj_elf_parse_section_letters (str
, len
)
751 attr
|= SHF_EXECINSTR
;
755 char *bad_msg
= _("Unrecognized .section attribute: want a,w,x");
756 #ifdef md_elf_section_letter
757 int md_attr
= md_elf_section_letter (*str
, &bad_msg
);
763 as_warn ("%s", bad_msg
);
776 obj_elf_section_word (str
, len
)
780 if (len
== 5 && strncmp (str
, "write", 5) == 0)
782 if (len
== 5 && strncmp (str
, "alloc", 5) == 0)
784 if (len
== 9 && strncmp (str
, "execinstr", 9) == 0)
785 return SHF_EXECINSTR
;
787 #ifdef md_elf_section_word
789 int md_attr
= md_elf_section_word (str
, len
);
795 as_warn (_("Unrecognized section attribute"));
800 obj_elf_section_type (str
, len
)
804 if (len
== 8 && strncmp (str
, "progbits", 8) == 0)
806 if (len
== 6 && strncmp (str
, "nobits", 6) == 0)
809 #ifdef md_elf_section_type
811 int md_type
= md_elf_section_type (str
, len
);
817 as_warn (_("Unrecognized section type"));
822 obj_elf_section (push
)
825 char *name
, *beg
, *end
;
826 int type
, attr
, dummy
;
833 #ifdef md_flush_pending_output
834 md_flush_pending_output ();
837 previous_section
= now_seg
;
838 previous_subsection
= now_subseg
;
840 s_mri_sect (&mri_type
);
842 #ifdef md_elf_section_change_hook
843 md_elf_section_change_hook ();
848 #endif /* ! defined (TC_I370) */
850 /* Get name of section. */
852 if (*input_line_pointer
== '"')
854 name
= demand_copy_C_string (&dummy
);
857 ignore_rest_of_line ();
863 end
= input_line_pointer
;
864 while (0 == strchr ("\n\t,; ", *end
))
866 if (end
== input_line_pointer
)
868 as_warn (_("Missing section name"));
869 ignore_rest_of_line ();
873 name
= xmalloc (end
- input_line_pointer
+ 1);
874 memcpy (name
, input_line_pointer
, end
- input_line_pointer
);
875 name
[end
- input_line_pointer
] = '\0';
876 input_line_pointer
= end
;
883 if (*input_line_pointer
== ',')
885 /* Skip the comma. */
886 ++input_line_pointer
;
889 if (*input_line_pointer
== '"')
891 beg
= demand_copy_C_string (&dummy
);
894 ignore_rest_of_line ();
897 attr
|= obj_elf_parse_section_letters (beg
, strlen (beg
));
900 if (*input_line_pointer
== ',')
903 ++input_line_pointer
;
905 c
= *input_line_pointer
;
908 beg
= demand_copy_C_string (&dummy
);
911 ignore_rest_of_line ();
914 type
= obj_elf_section_type (beg
, strlen (beg
));
916 else if (c
== '@' || c
== '%')
918 beg
= ++input_line_pointer
;
919 c
= get_symbol_end ();
920 *input_line_pointer
= c
;
921 type
= obj_elf_section_type (beg
, input_line_pointer
- beg
);
932 if (*input_line_pointer
!= '#')
934 as_warn (_("Bad .section directive - character following name is not '#'"));
935 ignore_rest_of_line ();
938 beg
= ++input_line_pointer
;
939 c
= get_symbol_end ();
940 *input_line_pointer
= c
;
942 attr
|= obj_elf_section_word (beg
, input_line_pointer
- beg
);
946 while (*input_line_pointer
++ == ',');
947 --input_line_pointer
;
951 demand_empty_rest_of_line ();
953 obj_elf_change_section (name
, type
, attr
, push
);
956 /* Change to the .data section. */
962 #ifdef md_flush_pending_output
963 md_flush_pending_output ();
966 previous_section
= now_seg
;
967 previous_subsection
= now_subseg
;
970 #ifdef md_elf_section_change_hook
971 md_elf_section_change_hook ();
975 /* Change to the .text section. */
981 #ifdef md_flush_pending_output
982 md_flush_pending_output ();
985 previous_section
= now_seg
;
986 previous_subsection
= now_subseg
;
989 #ifdef md_elf_section_change_hook
990 md_elf_section_change_hook ();
995 obj_elf_subsection (ignore
)
996 int ignore ATTRIBUTE_UNUSED
;
1000 #ifdef md_flush_pending_output
1001 md_flush_pending_output ();
1004 previous_section
= now_seg
;
1005 previous_subsection
= now_subseg
;
1007 temp
= get_absolute_expression ();
1008 subseg_set (now_seg
, (subsegT
) temp
);
1009 demand_empty_rest_of_line ();
1011 #ifdef md_elf_section_change_hook
1012 md_elf_section_change_hook ();
1016 /* This can be called from the processor backends if they change
1020 obj_elf_section_change_hook ()
1022 previous_section
= now_seg
;
1023 previous_subsection
= now_subseg
;
1027 obj_elf_previous (ignore
)
1028 int ignore ATTRIBUTE_UNUSED
;
1033 if (previous_section
== 0)
1035 as_bad (_(".previous without corresponding .section; ignored"));
1039 #ifdef md_flush_pending_output
1040 md_flush_pending_output ();
1043 new_section
= previous_section
;
1044 new_subsection
= previous_subsection
;
1045 previous_section
= now_seg
;
1046 previous_subsection
= now_subseg
;
1047 subseg_set (new_section
, new_subsection
);
1049 #ifdef md_elf_section_change_hook
1050 md_elf_section_change_hook ();
1055 obj_elf_popsection (xxx
)
1056 int xxx ATTRIBUTE_UNUSED
;
1058 struct section_stack
*top
= section_stack
;
1062 as_bad (_(".popsection without corresponding .pushsection; ignored"));
1066 #ifdef md_flush_pending_output
1067 md_flush_pending_output ();
1070 section_stack
= top
->next
;
1071 previous_section
= top
->prev_seg
;
1072 previous_subsection
= top
->prev_subseg
;
1073 subseg_set (top
->seg
, top
->subseg
);
1076 #ifdef md_elf_section_change_hook
1077 md_elf_section_change_hook ();
1082 obj_elf_line (ignore
)
1083 int ignore ATTRIBUTE_UNUSED
;
1085 /* Assume delimiter is part of expression. BSD4.2 as fails with
1086 delightful bug, so we are not being incompatible here. */
1087 new_logical_line ((char *) NULL
, (int) (get_absolute_expression ()));
1088 demand_empty_rest_of_line ();
1091 /* This handles the .symver pseudo-op, which is used to specify a
1092 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1093 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1094 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1095 with the same value as the symbol NAME. */
1098 obj_elf_symver (ignore
)
1099 int ignore ATTRIBUTE_UNUSED
;
1105 name
= input_line_pointer
;
1106 c
= get_symbol_end ();
1108 sym
= symbol_find_or_make (name
);
1110 *input_line_pointer
= c
;
1112 if (symbol_get_obj (sym
)->versioned_name
!= NULL
)
1114 as_bad (_("multiple .symver directives for symbol `%s'"),
1116 ignore_rest_of_line ();
1121 if (*input_line_pointer
!= ',')
1123 as_bad (_("expected comma after name in .symver"));
1124 ignore_rest_of_line ();
1128 ++input_line_pointer
;
1129 name
= input_line_pointer
;
1132 c
= get_symbol_end ();
1133 if (c
!= ELF_VER_CHR
)
1135 *input_line_pointer
++ = c
;
1138 symbol_get_obj (sym
)->versioned_name
= xstrdup (name
);
1140 *input_line_pointer
= c
;
1142 if (strchr (symbol_get_obj (sym
)->versioned_name
, ELF_VER_CHR
) == NULL
)
1144 as_bad (_("missing version name in `%s' for symbol `%s'"),
1145 symbol_get_obj (sym
)->versioned_name
, S_GET_NAME (sym
));
1146 ignore_rest_of_line ();
1150 demand_empty_rest_of_line ();
1153 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1154 to the linker the hierarchy in which a particular table resides. The
1155 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1158 obj_elf_vtable_inherit (ignore
)
1159 int ignore ATTRIBUTE_UNUSED
;
1161 char *cname
, *pname
;
1162 symbolS
*csym
, *psym
;
1165 if (*input_line_pointer
== '#')
1166 ++input_line_pointer
;
1168 cname
= input_line_pointer
;
1169 c
= get_symbol_end ();
1170 csym
= symbol_find (cname
);
1172 /* GCFIXME: should check that we don't have two .vtable_inherits for
1173 the same child symbol. Also, we can currently only do this if the
1174 child symbol is already exists and is placed in a fragment. */
1176 if (csym
== NULL
|| symbol_get_frag (csym
) == NULL
)
1178 as_bad ("expected `%s' to have already been set for .vtable_inherit",
1183 *input_line_pointer
= c
;
1186 if (*input_line_pointer
!= ',')
1188 as_bad ("expected comma after name in .vtable_inherit");
1189 ignore_rest_of_line ();
1193 ++input_line_pointer
;
1196 if (*input_line_pointer
== '#')
1197 ++input_line_pointer
;
1199 if (input_line_pointer
[0] == '0'
1200 && (input_line_pointer
[1] == '\0'
1201 || isspace ((unsigned char) input_line_pointer
[1])))
1203 psym
= section_symbol (absolute_section
);
1204 ++input_line_pointer
;
1208 pname
= input_line_pointer
;
1209 c
= get_symbol_end ();
1210 psym
= symbol_find_or_make (pname
);
1211 *input_line_pointer
= c
;
1214 demand_empty_rest_of_line ();
1219 assert (symbol_get_value_expression (csym
)->X_op
== O_constant
);
1220 return fix_new (symbol_get_frag (csym
),
1221 symbol_get_value_expression (csym
)->X_add_number
,
1222 0, psym
, 0, 0, BFD_RELOC_VTABLE_INHERIT
);
1225 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1226 to the linker that a vtable slot was used. The syntax is
1227 ".vtable_entry tablename, offset". */
1230 obj_elf_vtable_entry (ignore
)
1231 int ignore ATTRIBUTE_UNUSED
;
1238 if (*input_line_pointer
== '#')
1239 ++input_line_pointer
;
1241 name
= input_line_pointer
;
1242 c
= get_symbol_end ();
1243 sym
= symbol_find_or_make (name
);
1244 *input_line_pointer
= c
;
1247 if (*input_line_pointer
!= ',')
1249 as_bad ("expected comma after name in .vtable_entry");
1250 ignore_rest_of_line ();
1254 ++input_line_pointer
;
1255 if (*input_line_pointer
== '#')
1256 ++input_line_pointer
;
1258 offset
= get_absolute_expression ();
1260 demand_empty_rest_of_line ();
1262 return fix_new (frag_now
, frag_now_fix (), 0, sym
, offset
, 0,
1263 BFD_RELOC_VTABLE_ENTRY
);
1267 elf_obj_read_begin_hook ()
1269 #ifdef NEED_ECOFF_DEBUG
1270 if (ECOFF_DEBUGGING
)
1271 ecoff_read_begin_hook ();
1276 elf_obj_symbol_new_hook (symbolP
)
1279 struct elf_obj_sy
*sy_obj
;
1281 sy_obj
= symbol_get_obj (symbolP
);
1282 sy_obj
->size
= NULL
;
1283 sy_obj
->versioned_name
= NULL
;
1285 #ifdef NEED_ECOFF_DEBUG
1286 if (ECOFF_DEBUGGING
)
1287 ecoff_symbol_new_hook (symbolP
);
1292 obj_elf_version (ignore
)
1293 int ignore ATTRIBUTE_UNUSED
;
1299 asection
*seg
= now_seg
;
1300 subsegT subseg
= now_subseg
;
1301 Elf_Internal_Note i_note
;
1302 Elf_External_Note e_note
;
1303 asection
*note_secp
= (asection
*) NULL
;
1307 if (*input_line_pointer
== '\"')
1309 ++input_line_pointer
; /* -> 1st char of string. */
1310 name
= input_line_pointer
;
1312 while (is_a_char (c
= next_char_of_string ()))
1314 c
= *input_line_pointer
;
1315 *input_line_pointer
= '\0';
1316 *(input_line_pointer
- 1) = '\0';
1317 *input_line_pointer
= c
;
1319 /* create the .note section */
1321 note_secp
= subseg_new (".note", 0);
1322 bfd_set_section_flags (stdoutput
,
1324 SEC_HAS_CONTENTS
| SEC_READONLY
);
1326 /* process the version string */
1328 len
= strlen (name
);
1330 i_note
.namesz
= ((len
+ 1) + 3) & ~3; /* round this to word boundary */
1331 i_note
.descsz
= 0; /* no description */
1332 i_note
.type
= NT_VERSION
;
1333 p
= frag_more (sizeof (e_note
.namesz
));
1334 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
1335 p
= frag_more (sizeof (e_note
.descsz
));
1336 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
1337 p
= frag_more (sizeof (e_note
.type
));
1338 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
1340 for (i
= 0; i
< len
; i
++)
1344 FRAG_APPEND_1_CHAR (ch
);
1347 frag_align (2, 0, 0);
1349 subseg_set (seg
, subseg
);
1353 as_bad (_("Expected quoted string"));
1355 demand_empty_rest_of_line ();
1359 obj_elf_size (ignore
)
1360 int ignore ATTRIBUTE_UNUSED
;
1362 char *name
= input_line_pointer
;
1363 char c
= get_symbol_end ();
1368 p
= input_line_pointer
;
1371 if (*input_line_pointer
!= ',')
1374 as_bad (_("expected comma after name `%s' in .size directive"), name
);
1376 ignore_rest_of_line ();
1379 input_line_pointer
++;
1381 if (exp
.X_op
== O_absent
)
1383 as_bad (_("missing expression in .size directive"));
1384 exp
.X_op
= O_constant
;
1385 exp
.X_add_number
= 0;
1388 sym
= symbol_find_or_make (name
);
1390 if (exp
.X_op
== O_constant
)
1391 S_SET_SIZE (sym
, exp
.X_add_number
);
1394 symbol_get_obj (sym
)->size
=
1395 (expressionS
*) xmalloc (sizeof (expressionS
));
1396 *symbol_get_obj (sym
)->size
= exp
;
1398 demand_empty_rest_of_line ();
1401 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1402 There are five syntaxes:
1404 The first (used on Solaris) is
1406 The second (used on UnixWare) is
1408 The third (reportedly to be used on Irix 6.0) is
1410 The fourth (used on NetBSD/Arm and Linux/ARM) is
1412 The fifth (used on SVR4/860) is
1413 .type SYM,"function"
1417 obj_elf_type (ignore
)
1418 int ignore ATTRIBUTE_UNUSED
;
1423 const char *typename
;
1425 elf_symbol_type
*elfsym
;
1427 name
= input_line_pointer
;
1428 c
= get_symbol_end ();
1429 sym
= symbol_find_or_make (name
);
1430 elfsym
= (elf_symbol_type
*) symbol_get_bfdsym (sym
);
1431 *input_line_pointer
= c
;
1434 if (*input_line_pointer
== ',')
1435 ++input_line_pointer
;
1438 if ( *input_line_pointer
== '#'
1439 || *input_line_pointer
== '@'
1440 || *input_line_pointer
== '"'
1441 || *input_line_pointer
== '%')
1442 ++input_line_pointer
;
1444 typename
= input_line_pointer
;
1445 c
= get_symbol_end ();
1448 if (strcmp (typename
, "function") == 0
1449 || strcmp (typename
, "STT_FUNC") == 0)
1450 type
= BSF_FUNCTION
;
1451 else if (strcmp (typename
, "object") == 0
1452 || strcmp (typename
, "STT_OBJECT") == 0)
1454 #ifdef md_elf_symbol_type
1455 else if ((type
= md_elf_symbol_type (typename
, sym
, elfsym
)) != -1)
1459 as_bad (_("ignoring unrecognized symbol type \"%s\""), typename
);
1461 *input_line_pointer
= c
;
1463 if (*input_line_pointer
== '"')
1464 ++input_line_pointer
;
1466 elfsym
->symbol
.flags
|= type
;
1468 demand_empty_rest_of_line ();
1472 obj_elf_ident (ignore
)
1473 int ignore ATTRIBUTE_UNUSED
;
1475 static segT comment_section
;
1476 segT old_section
= now_seg
;
1477 int old_subsection
= now_subseg
;
1479 #ifdef md_flush_pending_output
1480 md_flush_pending_output ();
1483 if (!comment_section
)
1486 comment_section
= subseg_new (".comment", 0);
1487 bfd_set_section_flags (stdoutput
, comment_section
,
1488 SEC_READONLY
| SEC_HAS_CONTENTS
);
1493 subseg_set (comment_section
, 0);
1495 subseg_set (old_section
, old_subsection
);
1498 #ifdef INIT_STAB_SECTION
1500 /* The first entry in a .stabs section is special. */
1503 obj_elf_init_stab_section (seg
)
1509 unsigned int stroff
;
1511 /* Force the section to align to a longword boundary. Without this,
1512 UnixWare ar crashes. */
1513 bfd_set_section_alignment (stdoutput
, seg
, 2);
1515 /* Make space for this first symbol. */
1519 as_where (&file
, (unsigned int *) NULL
);
1520 stabstr_name
= (char *) alloca (strlen (segment_name (seg
)) + 4);
1521 strcpy (stabstr_name
, segment_name (seg
));
1522 strcat (stabstr_name
, "str");
1523 stroff
= get_stab_string_offset (file
, stabstr_name
);
1525 md_number_to_chars (p
, stroff
, 4);
1526 seg_info (seg
)->stabu
.p
= p
;
1531 /* Fill in the counts in the first entry in a .stabs section. */
1534 adjust_stab_sections (abfd
, sec
, xxx
)
1537 PTR xxx ATTRIBUTE_UNUSED
;
1544 if (strncmp (".stab", sec
->name
, 5))
1546 if (!strcmp ("str", sec
->name
+ strlen (sec
->name
) - 3))
1549 name
= (char *) alloca (strlen (sec
->name
) + 4);
1550 strcpy (name
, sec
->name
);
1551 strcat (name
, "str");
1552 strsec
= bfd_get_section_by_name (abfd
, name
);
1554 strsz
= bfd_section_size (abfd
, strsec
);
1557 nsyms
= bfd_section_size (abfd
, sec
) / 12 - 1;
1559 p
= seg_info (sec
)->stabu
.p
;
1562 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
1563 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
1566 #ifdef NEED_ECOFF_DEBUG
1568 /* This function is called by the ECOFF code. It is supposed to
1569 record the external symbol information so that the backend can
1570 write it out correctly. The ELF backend doesn't actually handle
1571 this at the moment, so we do it ourselves. We save the information
1575 elf_ecoff_set_ext (sym
, ext
)
1577 struct ecoff_extr
*ext
;
1579 symbol_get_bfdsym (sym
)->udata
.p
= (PTR
) ext
;
1582 /* This function is called by bfd_ecoff_debug_externals. It is
1583 supposed to *EXT to the external symbol information, and return
1584 whether the symbol should be used at all. */
1587 elf_get_extr (sym
, ext
)
1591 if (sym
->udata
.p
== NULL
)
1593 *ext
= *(EXTR
*) sym
->udata
.p
;
1597 /* This function is called by bfd_ecoff_debug_externals. It has
1598 nothing to do for ELF. */
1602 elf_set_index (sym
, indx
)
1603 asymbol
*sym ATTRIBUTE_UNUSED
;
1604 bfd_size_type indx ATTRIBUTE_UNUSED
;
1608 #endif /* NEED_ECOFF_DEBUG */
1611 elf_frob_symbol (symp
, puntp
)
1615 struct elf_obj_sy
*sy_obj
;
1617 #ifdef NEED_ECOFF_DEBUG
1618 if (ECOFF_DEBUGGING
)
1619 ecoff_frob_symbol (symp
);
1622 sy_obj
= symbol_get_obj (symp
);
1624 if (sy_obj
->size
!= NULL
)
1626 switch (sy_obj
->size
->X_op
)
1630 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1631 + sy_obj
->size
->X_add_number
1632 - S_GET_VALUE (sy_obj
->size
->X_op_symbol
)));
1636 (S_GET_VALUE (sy_obj
->size
->X_add_symbol
)
1637 + sy_obj
->size
->X_add_number
));
1640 as_bad (_(".size expression too complicated to fix up"));
1643 free (sy_obj
->size
);
1644 sy_obj
->size
= NULL
;
1647 if (sy_obj
->versioned_name
!= NULL
)
1649 /* This symbol was given a new name with the .symver directive.
1651 If this is an external reference, just rename the symbol to
1652 include the version string. This will make the relocs be
1653 against the correct versioned symbol.
1655 If this is a definition, add an alias. FIXME: Using an alias
1656 will permit the debugging information to refer to the right
1657 symbol. However, it's not clear whether it is the best
1660 if (! S_IS_DEFINED (symp
))
1664 /* Verify that the name isn't using the @@ syntax--this is
1665 reserved for definitions of the default version to link
1667 p
= strchr (sy_obj
->versioned_name
, ELF_VER_CHR
);
1669 if (p
[1] == ELF_VER_CHR
)
1671 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1672 sy_obj
->versioned_name
);
1675 S_SET_NAME (symp
, sy_obj
->versioned_name
);
1681 /* FIXME: Creating a new symbol here is risky. We're in the
1682 final loop over the symbol table. We can get away with
1683 it only because the symbol goes to the end of the list,
1684 where the loop will still see it. It would probably be
1685 better to do this in obj_frob_file_before_adjust. */
1687 symp2
= symbol_find_or_make (sy_obj
->versioned_name
);
1689 /* Now we act as though we saw symp2 = sym. */
1691 S_SET_SEGMENT (symp2
, S_GET_SEGMENT (symp
));
1693 /* Subtracting out the frag address here is a hack because
1694 we are in the middle of the final loop. */
1697 - symbol_get_frag (symp
)->fr_address
));
1699 symbol_set_frag (symp2
, symbol_get_frag (symp
));
1701 /* This will copy over the size information. */
1702 copy_symbol_attributes (symp2
, symp
);
1704 if (S_IS_WEAK (symp
))
1707 if (S_IS_EXTERNAL (symp
))
1708 S_SET_EXTERNAL (symp2
);
1712 /* Double check weak symbols. */
1713 if (S_IS_WEAK (symp
))
1715 if (S_IS_COMMON (symp
))
1716 as_bad (_("Symbol `%s' can not be both weak and common"),
1721 /* The Irix 5 and 6 assemblers set the type of any common symbol and
1722 any undefined non-function symbol to STT_OBJECT. We try to be
1723 compatible, since newer Irix 5 and 6 linkers care. However, we
1724 only set undefined symbols to be STT_OBJECT if we are on Irix,
1725 because that is the only time gcc will generate the necessary
1726 .global directives to mark functions. */
1728 if (S_IS_COMMON (symp
))
1729 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1731 if (strstr (TARGET_OS
, "irix") != NULL
1732 && ! S_IS_DEFINED (symp
)
1733 && (symbol_get_bfdsym (symp
)->flags
& BSF_FUNCTION
) == 0)
1734 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1738 /* If TC_PPC is defined, we used to force the type of a symbol to be
1739 BSF_OBJECT if it was otherwise unset. This was required by some
1740 version of VxWorks. Thomas de Lellis <tdel@windriver.com> says
1741 that this is no longer needed, so it is now commented out. */
1742 if ((symbol_get_bfdsym (symp
)->flags
1743 & (BSF_FUNCTION
| BSF_FILE
| BSF_SECTION_SYM
)) == 0
1744 && S_IS_DEFINED (symp
))
1745 symbol_get_bfdsym (symp
)->flags
|= BSF_OBJECT
;
1752 bfd_map_over_sections (stdoutput
, adjust_stab_sections
, (PTR
) 0);
1754 #ifdef elf_tc_final_processing
1755 elf_tc_final_processing ();
1759 /* It is required that we let write_relocs have the opportunity to
1760 optimize away fixups before output has begun, since it is possible
1761 to eliminate all fixups for a section and thus we never should
1762 have generated the relocation section. */
1765 elf_frob_file_after_relocs ()
1767 #ifdef NEED_ECOFF_DEBUG
1768 if (ECOFF_DEBUGGING
)
1769 /* Generate the ECOFF debugging information. */
1771 const struct ecoff_debug_swap
*debug_swap
;
1772 struct ecoff_debug_info debug
;
1777 = get_elf_backend_data (stdoutput
)->elf_backend_ecoff_debug_swap
;
1778 know (debug_swap
!= (const struct ecoff_debug_swap
*) NULL
);
1779 ecoff_build_debug (&debug
.symbolic_header
, &buf
, debug_swap
);
1781 /* Set up the pointers in debug. */
1782 #define SET(ptr, offset, type) \
1783 debug.ptr = (type) (buf + debug.symbolic_header.offset)
1785 SET (line
, cbLineOffset
, unsigned char *);
1786 SET (external_dnr
, cbDnOffset
, PTR
);
1787 SET (external_pdr
, cbPdOffset
, PTR
);
1788 SET (external_sym
, cbSymOffset
, PTR
);
1789 SET (external_opt
, cbOptOffset
, PTR
);
1790 SET (external_aux
, cbAuxOffset
, union aux_ext
*);
1791 SET (ss
, cbSsOffset
, char *);
1792 SET (external_fdr
, cbFdOffset
, PTR
);
1793 SET (external_rfd
, cbRfdOffset
, PTR
);
1794 /* ssext and external_ext are set up just below. */
1798 /* Set up the external symbols. */
1799 debug
.ssext
= debug
.ssext_end
= NULL
;
1800 debug
.external_ext
= debug
.external_ext_end
= NULL
;
1801 if (! bfd_ecoff_debug_externals (stdoutput
, &debug
, debug_swap
, true,
1802 elf_get_extr
, elf_set_index
))
1803 as_fatal (_("Failed to set up debugging information: %s"),
1804 bfd_errmsg (bfd_get_error ()));
1806 sec
= bfd_get_section_by_name (stdoutput
, ".mdebug");
1807 assert (sec
!= NULL
);
1809 know (stdoutput
->output_has_begun
== false);
1811 /* We set the size of the section, call bfd_set_section_contents
1812 to force the ELF backend to allocate a file position, and then
1813 write out the data. FIXME: Is this really the best way to do
1815 sec
->_raw_size
= bfd_ecoff_debug_size (stdoutput
, &debug
, debug_swap
);
1817 /* Pass BUF to bfd_set_section_contents because this will
1818 eventually become a call to fwrite, and ISO C prohibits
1819 passing a NULL pointer to a stdio function even if the
1820 pointer will not be used. */
1821 if (! bfd_set_section_contents (stdoutput
, sec
, (PTR
) buf
,
1822 (file_ptr
) 0, (bfd_size_type
) 0))
1823 as_fatal (_("Can't start writing .mdebug section: %s"),
1824 bfd_errmsg (bfd_get_error ()));
1826 know (stdoutput
->output_has_begun
== true);
1827 know (sec
->filepos
!= 0);
1829 if (! bfd_ecoff_write_debug (stdoutput
, &debug
, debug_swap
,
1831 as_fatal (_("Could not write .mdebug section: %s"),
1832 bfd_errmsg (bfd_get_error ()));
1834 #endif /* NEED_ECOFF_DEBUG */
1839 /* Heavily plagarized from obj_elf_version. The idea is to emit the
1840 SCO specific identifier in the .notes section to satisfy the SCO
1843 This looks more complicated than it really is. As opposed to the
1844 "obvious" solution, this should handle the cross dev cases
1845 correctly. (i.e, hosting on a 64 bit big endian processor, but
1846 generating SCO Elf code) Efficiency isn't a concern, as there
1847 should be exactly one of these sections per object module.
1849 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
1852 int_32 namesz = 4 ; Name size
1853 int_32 descsz = 12 ; Descriptive information
1855 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
1856 int_32 version = (major ver # << 16) | version of tools ;
1857 int_32 source = (tool_id << 16 ) | 1 ;
1858 int_32 info = 0 ; These are set by the SCO tools, but we
1859 don't know enough about the source
1860 environment to set them. SCO ld currently
1861 ignores them, and recommends we set them
1864 #define SCO_MAJOR_VERSION 0x1
1865 #define SCO_MINOR_VERSION 0x1
1875 asection
*seg
= now_seg
;
1876 subsegT subseg
= now_subseg
;
1877 Elf_Internal_Note i_note
;
1878 Elf_External_Note e_note
;
1879 asection
*note_secp
= (asection
*) NULL
;
1882 /* create the .note section */
1884 note_secp
= subseg_new (".note", 0);
1885 bfd_set_section_flags (stdoutput
,
1887 SEC_HAS_CONTENTS
| SEC_READONLY
);
1889 /* process the version string */
1892 i_note
.descsz
= 12; /* 12 descriptive bytes */
1893 i_note
.type
= NT_VERSION
; /* Contains a version string */
1895 p
= frag_more (sizeof (i_note
.namesz
));
1896 md_number_to_chars (p
, (valueT
) i_note
.namesz
, 4);
1898 p
= frag_more (sizeof (i_note
.descsz
));
1899 md_number_to_chars (p
, (valueT
) i_note
.descsz
, 4);
1901 p
= frag_more (sizeof (i_note
.type
));
1902 md_number_to_chars (p
, (valueT
) i_note
.type
, 4);
1907 /* Note: this is the version number of the ELF we're representing */
1909 md_number_to_chars (p
, (SCO_MAJOR_VERSION
<< 16) | (SCO_MINOR_VERSION
), 4);
1911 /* Here, we pick a magic number for ourselves (yes, I "registered"
1912 it with SCO. The bottom bit shows that we are compat with the
1915 md_number_to_chars (p
, 0x4c520000 | 0x0001, 4);
1917 /* If we knew (or cared) what the source language options were, we'd
1918 fill them in here. SCO has given us permission to ignore these
1919 and just set them to zero. */
1921 md_number_to_chars (p
, 0x0000, 4);
1923 frag_align (2, 0, 0);
1925 /* We probably can't restore the current segment, for there likely
1928 subseg_set (seg
, subseg
);
1932 #endif /* SCO_ELF */
1935 elf_separate_stab_sections ()
1937 #ifdef NEED_ECOFF_DEBUG
1938 return (!ECOFF_DEBUGGING
);
1945 elf_init_stab_section (seg
)
1948 #ifdef NEED_ECOFF_DEBUG
1949 if (!ECOFF_DEBUGGING
)
1951 obj_elf_init_stab_section (seg
);
1954 const struct format_ops elf_format_ops
=
1956 bfd_target_elf_flavour
,
1957 0, /* dfl_leading_underscore */
1958 1, /* emit_section_symbols */
1963 elf_frob_file_after_relocs
,
1964 elf_s_get_size
, elf_s_set_size
,
1965 elf_s_get_align
, elf_s_set_align
,
1972 elf_copy_symbol_attributes
,
1973 #ifdef NEED_ECOFF_DEBUG
1974 ecoff_generate_asm_lineno
,
1977 0, /* generate_asm_lineno */
1978 0, /* process_stab */
1980 elf_separate_stab_sections
,
1981 elf_init_stab_section
,
1982 elf_sec_sym_ok_for_reloc
,
1984 #ifdef NEED_ECOFF_DEBUG
1987 0, /* ecoff_set_ext */
1989 elf_obj_read_begin_hook
,
1990 elf_obj_symbol_new_hook