]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gas/config/obj-elf.c
Revert "2.41 Release sources"
[thirdparty/binutils-gdb.git] / gas / config / obj-elf.c
1 /* ELF object file format
2 Copyright (C) 1992-2023 Free Software Foundation, Inc.
3
4 This file is part of GAS, the GNU Assembler.
5
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as
8 published by the Free Software Foundation; either version 3,
9 or (at your option) any later version.
10
11 GAS is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
14 the GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
19 02110-1301, USA. */
20
21 #define OBJ_HEADER "obj-elf.h"
22 #include "as.h"
23 #include "safe-ctype.h"
24 #include "subsegs.h"
25 #include "obstack.h"
26 #include "dwarf2dbg.h"
27
28 #ifndef ECOFF_DEBUGGING
29 #define ECOFF_DEBUGGING 0
30 #else
31 #define NEED_ECOFF_DEBUG
32 #endif
33
34 #ifdef NEED_ECOFF_DEBUG
35 #include "ecoff.h"
36 #include "bfd/ecoff-bfd.h"
37 #endif
38
39 #ifdef TC_ALPHA
40 #include "elf/alpha.h"
41 #endif
42
43 #ifdef TC_MIPS
44 #include "elf/mips.h"
45 #endif
46
47 #ifdef TC_PPC
48 #include "elf/ppc.h"
49 #endif
50
51 #ifdef TC_I386
52 #include "elf/x86-64.h"
53 #endif
54
55 #ifdef TC_MEP
56 #include "elf/mep.h"
57 #endif
58
59 #ifdef TC_NIOS2
60 #include "elf/nios2.h"
61 #endif
62
63 #ifdef TC_PRU
64 #include "elf/pru.h"
65 #endif
66
67 static void obj_elf_line (int);
68 static void obj_elf_size (int);
69 static void obj_elf_type (int);
70 static void obj_elf_ident (int);
71 static void obj_elf_weak (int);
72 static void obj_elf_local (int);
73 static void obj_elf_visibility (int);
74 static void obj_elf_symver (int);
75 static void obj_elf_subsection (int);
76 static void obj_elf_popsection (int);
77 static void obj_elf_gnu_attribute (int);
78 static void obj_elf_tls_common (int);
79 static void obj_elf_lcomm (int);
80 static void obj_elf_struct (int);
81 static void obj_elf_attach_to_group (int);
82
83 static const pseudo_typeS elf_pseudo_table[] =
84 {
85 {"attach_to_group", obj_elf_attach_to_group, 0},
86 {"comm", obj_elf_common, 0},
87 {"common", obj_elf_common, 1},
88 {"ident", obj_elf_ident, 0},
89 {"lcomm", obj_elf_lcomm, 0},
90 {"local", obj_elf_local, 0},
91 {"previous", obj_elf_previous, 0},
92 {"section", obj_elf_section, 0},
93 {"section.s", obj_elf_section, 0},
94 {"sect", obj_elf_section, 0},
95 {"sect.s", obj_elf_section, 0},
96 {"pushsection", obj_elf_section, 1},
97 {"popsection", obj_elf_popsection, 0},
98 {"size", obj_elf_size, 0},
99 {"type", obj_elf_type, 0},
100 {"version", obj_elf_version, 0},
101 {"weak", obj_elf_weak, 0},
102
103 /* These define symbol visibility. */
104 {"internal", obj_elf_visibility, STV_INTERNAL},
105 {"hidden", obj_elf_visibility, STV_HIDDEN},
106 {"protected", obj_elf_visibility, STV_PROTECTED},
107
108 /* These are used for stabs-in-elf configurations. */
109 {"line", obj_elf_line, 0},
110
111 /* This is a GNU extension to handle symbol versions. */
112 {"symver", obj_elf_symver, 0},
113
114 /* A GNU extension to change subsection only. */
115 {"subsection", obj_elf_subsection, 0},
116
117 /* These are GNU extensions to aid in garbage collecting C++ vtables. */
118 {"vtable_inherit", obj_elf_vtable_inherit, 0},
119 {"vtable_entry", obj_elf_vtable_entry, 0},
120
121 /* A GNU extension for object attributes. */
122 {"gnu_attribute", obj_elf_gnu_attribute, 0},
123
124 /* These are used for dwarf2. */
125 { "file", dwarf2_directive_file, 0 },
126 { "loc", dwarf2_directive_loc, 0 },
127 { "loc_mark_labels", dwarf2_directive_loc_mark_labels, 0 },
128
129 /* We need to trap the section changing calls to handle .previous. */
130 {"data", obj_elf_data, 0},
131 {"offset", obj_elf_struct, 0},
132 {"struct", obj_elf_struct, 0},
133 {"text", obj_elf_text, 0},
134 {"bss", obj_elf_bss, 0},
135
136 {"tls_common", obj_elf_tls_common, 0},
137
138 /* End sentinel. */
139 {NULL, NULL, 0},
140 };
141
142 static const pseudo_typeS ecoff_debug_pseudo_table[] =
143 {
144 #ifdef NEED_ECOFF_DEBUG
145 /* COFF style debugging information for ECOFF. .ln is not used; .loc
146 is used instead. */
147 { "def", ecoff_directive_def, 0 },
148 { "dim", ecoff_directive_dim, 0 },
149 { "endef", ecoff_directive_endef, 0 },
150 { "file", ecoff_directive_file, 0 },
151 { "scl", ecoff_directive_scl, 0 },
152 { "tag", ecoff_directive_tag, 0 },
153 { "val", ecoff_directive_val, 0 },
154
155 /* COFF debugging requires pseudo-ops .size and .type, but ELF
156 already has meanings for those. We use .esize and .etype
157 instead. These are only generated by gcc anyhow. */
158 { "esize", ecoff_directive_size, 0 },
159 { "etype", ecoff_directive_type, 0 },
160
161 /* ECOFF specific debugging information. */
162 { "aent", ecoff_directive_ent, 1 },
163 { "begin", ecoff_directive_begin, 0 },
164 { "bend", ecoff_directive_bend, 0 },
165 { "end", ecoff_directive_end, 0 },
166 { "ent", ecoff_directive_ent, 0 },
167 { "fmask", ecoff_directive_fmask, 0 },
168 { "frame", ecoff_directive_frame, 0 },
169 { "loc", ecoff_directive_loc, 0 },
170 { "mask", ecoff_directive_mask, 0 },
171
172 /* Other ECOFF directives. */
173 { "extern", ecoff_directive_extern, 0 },
174
175 /* These are used on Irix. I don't know how to implement them. */
176 { "alias", s_ignore, 0 },
177 { "bgnb", s_ignore, 0 },
178 { "endb", s_ignore, 0 },
179 { "lab", s_ignore, 0 },
180 { "noalias", s_ignore, 0 },
181 { "verstamp", s_ignore, 0 },
182 { "vreg", s_ignore, 0 },
183 #endif
184
185 {NULL, NULL, 0} /* end sentinel */
186 };
187
188 #undef NO_RELOC
189 #include "aout/aout64.h"
190
191 asection *elf_com_section_ptr;
192
193 void
194 elf_pop_insert (void)
195 {
196 pop_insert (elf_pseudo_table);
197 if (ECOFF_DEBUGGING)
198 pop_insert (ecoff_debug_pseudo_table);
199 }
200
201 static bfd_vma
202 elf_s_get_size (symbolS *sym)
203 {
204 return S_GET_SIZE (sym);
205 }
206
207 static void
208 elf_s_set_size (symbolS *sym, bfd_vma sz)
209 {
210 S_SET_SIZE (sym, sz);
211 }
212
213 static bfd_vma
214 elf_s_get_align (symbolS *sym)
215 {
216 return S_GET_ALIGN (sym);
217 }
218
219 static void
220 elf_s_set_align (symbolS *sym, bfd_vma align)
221 {
222 S_SET_ALIGN (sym, align);
223 }
224
225 int
226 elf_s_get_other (symbolS *sym)
227 {
228 return elf_symbol (symbol_get_bfdsym (sym))->internal_elf_sym.st_other;
229 }
230
231 static void
232 elf_s_set_other (symbolS *sym, int other)
233 {
234 S_SET_OTHER (sym, other);
235 }
236
237 static int
238 elf_sec_sym_ok_for_reloc (asection *sec)
239 {
240 return obj_sec_sym_ok_for_reloc (sec);
241 }
242
243 void
244 elf_file_symbol (const char *s)
245 {
246 asymbol *bsym;
247 symbolS *sym = symbol_new (s, absolute_section, &zero_address_frag, 0);
248 size_t name_length = strlen (s);
249
250 if (name_length > strlen (S_GET_NAME (sym)))
251 {
252 obstack_grow (&notes, s, name_length + 1);
253 S_SET_NAME (sym, (const char *) obstack_finish (&notes));
254 }
255 else
256 strcpy ((char *) S_GET_NAME (sym), s);
257
258 symbol_get_bfdsym (sym)->flags |= BSF_FILE;
259
260 if (symbol_rootP != sym
261 && ((bsym = symbol_get_bfdsym (symbol_rootP)) == NULL
262 || (bsym->flags & BSF_FILE) == 0))
263 {
264 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
265 symbol_insert (sym, symbol_rootP, &symbol_rootP, &symbol_lastP);
266 }
267
268 #ifdef DEBUG
269 verify_symbol_chain (symbol_rootP, symbol_lastP);
270 #endif
271
272 #ifdef NEED_ECOFF_DEBUG
273 ecoff_new_file (s);
274 #endif
275 }
276
277 /* Called from read.c:s_comm after we've parsed .comm symbol, size.
278 Parse a possible alignment value. */
279
280 symbolS *
281 elf_common_parse (int ignore ATTRIBUTE_UNUSED, symbolS *symbolP, addressT size)
282 {
283 addressT align = 0;
284 int is_local = symbol_get_obj (symbolP)->local;
285
286 if (*input_line_pointer == ',')
287 {
288 char *save = input_line_pointer;
289
290 input_line_pointer++;
291 SKIP_WHITESPACE ();
292
293 if (*input_line_pointer == '"')
294 {
295 /* For sparc. Accept .common symbol, length, "bss" */
296 input_line_pointer++;
297 /* Some use the dot, some don't. */
298 if (*input_line_pointer == '.')
299 input_line_pointer++;
300 /* Some say data, some say bss. */
301 if (startswith (input_line_pointer, "bss\""))
302 input_line_pointer += 4;
303 else if (startswith (input_line_pointer, "data\""))
304 input_line_pointer += 5;
305 else
306 {
307 char *p = input_line_pointer;
308 char c;
309
310 while (*--p != '"')
311 ;
312 while (!is_end_of_line[(unsigned char) *input_line_pointer])
313 if (*input_line_pointer++ == '"')
314 break;
315 c = *input_line_pointer;
316 *input_line_pointer = '\0';
317 as_bad (_("bad .common segment %s"), p);
318 *input_line_pointer = c;
319 ignore_rest_of_line ();
320 return NULL;
321 }
322 /* ??? Don't ask me why these are always global. */
323 is_local = 0;
324 }
325 else
326 {
327 input_line_pointer = save;
328 align = parse_align (is_local);
329 if (align == (addressT) -1)
330 return NULL;
331 }
332 }
333
334 if (is_local)
335 {
336 bss_alloc (symbolP, size, align);
337 S_CLEAR_EXTERNAL (symbolP);
338 }
339 else
340 {
341 S_SET_VALUE (symbolP, size);
342 S_SET_ALIGN (symbolP, align);
343 S_SET_EXTERNAL (symbolP);
344 S_SET_SEGMENT (symbolP, elf_com_section_ptr);
345 }
346
347 symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
348
349 return symbolP;
350 }
351
352 void
353 obj_elf_common (int is_common)
354 {
355 if (flag_mri && is_common)
356 s_mri_common (0);
357 else
358 s_comm_internal (0, elf_common_parse);
359 }
360
361 static void
362 obj_elf_tls_common (int ignore ATTRIBUTE_UNUSED)
363 {
364 symbolS *symbolP = s_comm_internal (0, elf_common_parse);
365
366 if (symbolP)
367 symbol_get_bfdsym (symbolP)->flags |= BSF_THREAD_LOCAL;
368 }
369
370 static void
371 obj_elf_lcomm (int ignore ATTRIBUTE_UNUSED)
372 {
373 symbolS *symbolP = s_comm_internal (0, s_lcomm_internal);
374
375 if (symbolP)
376 symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
377 }
378
379 static symbolS *
380 get_sym_from_input_line_and_check (void)
381 {
382 char *name;
383 char c;
384 symbolS *sym;
385
386 c = get_symbol_name (& name);
387 sym = symbol_find_or_make (name);
388 *input_line_pointer = c;
389 SKIP_WHITESPACE_AFTER_NAME ();
390
391 /* There is no symbol name if input_line_pointer has not moved. */
392 if (name == input_line_pointer)
393 as_bad (_("Missing symbol name in directive"));
394 return sym;
395 }
396
397 static void
398 obj_elf_local (int ignore ATTRIBUTE_UNUSED)
399 {
400 int c;
401 symbolS *symbolP;
402
403 do
404 {
405 symbolP = get_sym_from_input_line_and_check ();
406 c = *input_line_pointer;
407 S_CLEAR_EXTERNAL (symbolP);
408 symbol_get_obj (symbolP)->local = 1;
409 if (c == ',')
410 {
411 input_line_pointer++;
412 SKIP_WHITESPACE ();
413 if (*input_line_pointer == '\n')
414 c = '\n';
415 }
416 }
417 while (c == ',');
418 demand_empty_rest_of_line ();
419 }
420
421 static void
422 obj_elf_weak (int ignore ATTRIBUTE_UNUSED)
423 {
424 int c;
425 symbolS *symbolP;
426
427 do
428 {
429 symbolP = get_sym_from_input_line_and_check ();
430 c = *input_line_pointer;
431 S_SET_WEAK (symbolP);
432 if (c == ',')
433 {
434 input_line_pointer++;
435 SKIP_WHITESPACE ();
436 if (*input_line_pointer == '\n')
437 c = '\n';
438 }
439 }
440 while (c == ',');
441 demand_empty_rest_of_line ();
442 }
443
444 static void
445 obj_elf_visibility (int visibility)
446 {
447 int c;
448 symbolS *symbolP;
449 asymbol *bfdsym;
450 elf_symbol_type *elfsym;
451
452 do
453 {
454 symbolP = get_sym_from_input_line_and_check ();
455
456 bfdsym = symbol_get_bfdsym (symbolP);
457 elfsym = elf_symbol_from (bfdsym);
458
459 gas_assert (elfsym);
460
461 elfsym->internal_elf_sym.st_other &= ~3;
462 elfsym->internal_elf_sym.st_other |= visibility;
463
464 c = *input_line_pointer;
465 if (c == ',')
466 {
467 input_line_pointer ++;
468
469 SKIP_WHITESPACE ();
470
471 if (*input_line_pointer == '\n')
472 c = '\n';
473 }
474 }
475 while (c == ',');
476
477 demand_empty_rest_of_line ();
478 }
479
480 static segT previous_section;
481 static int previous_subsection;
482
483 struct section_stack
484 {
485 struct section_stack *next;
486 segT seg, prev_seg;
487 int subseg, prev_subseg;
488 };
489
490 static struct section_stack *section_stack;
491
492 /* ELF section flags for unique sections. */
493 #define SEC_ASSEMBLER_SHF_MASK SHF_GNU_RETAIN
494
495 /* Return TRUE iff SEC matches the section info INF. */
496
497 static bool
498 get_section_by_match (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
499 {
500 struct elf_section_match *match = (struct elf_section_match *) inf;
501 const char *gname = match->group_name;
502 const char *group_name = elf_group_name (sec);
503 const char *linked_to_symbol_name
504 = sec->map_head.linked_to_symbol_name;
505 unsigned int sh_info = elf_section_data (sec)->this_hdr.sh_info;
506 bfd_vma sh_flags = (elf_section_data (sec)->this_hdr.sh_flags
507 & SEC_ASSEMBLER_SHF_MASK);
508
509 return (sh_info == match->sh_info
510 && sh_flags == match->sh_flags
511 && ((bfd_section_flags (sec) & SEC_ASSEMBLER_SECTION_ID)
512 == (match->flags & SEC_ASSEMBLER_SECTION_ID))
513 && sec->section_id == match->section_id
514 && (group_name == gname
515 || (group_name != NULL
516 && gname != NULL
517 && strcmp (group_name, gname) == 0))
518 && (linked_to_symbol_name == match->linked_to_symbol_name
519 || (linked_to_symbol_name != NULL
520 && match->linked_to_symbol_name != NULL
521 && strcmp (linked_to_symbol_name,
522 match->linked_to_symbol_name) == 0)));
523 }
524
525 /* Handle the .section pseudo-op. This code supports two different
526 syntaxes.
527
528 The first is found on Solaris, and looks like
529 .section ".sec1",#alloc,#execinstr,#write
530 Here the names after '#' are the SHF_* flags to turn on for the
531 section. I'm not sure how it determines the SHT_* type (BFD
532 doesn't really give us control over the type, anyhow).
533
534 The second format is found on UnixWare, and probably most SVR4
535 machines, and looks like
536 .section .sec1,"a",@progbits
537 The quoted string may contain any combination of a, w, x, and
538 represents the SHF_* flags to turn on for the section. The string
539 beginning with '@' can be progbits or nobits. There should be
540 other possibilities, but I don't know what they are. In any case,
541 BFD doesn't really let us set the section type. */
542
543 void
544 obj_elf_change_section (const char *name,
545 unsigned int type,
546 bfd_vma attr,
547 int entsize,
548 struct elf_section_match *match_p,
549 int linkonce,
550 int push)
551 {
552 asection *old_sec;
553 segT sec;
554 flagword flags;
555 const struct elf_backend_data *bed;
556 const struct bfd_elf_special_section *ssect;
557
558 if (match_p == NULL)
559 {
560 static struct elf_section_match unused_match;
561 match_p = &unused_match;
562 }
563
564 #ifdef md_flush_pending_output
565 md_flush_pending_output ();
566 #endif
567
568 /* Switch to the section, creating it if necessary. */
569 if (push)
570 {
571 struct section_stack *elt;
572 elt = XNEW (struct section_stack);
573 elt->next = section_stack;
574 elt->seg = now_seg;
575 elt->prev_seg = previous_section;
576 elt->subseg = now_subseg;
577 elt->prev_subseg = previous_subsection;
578 section_stack = elt;
579 }
580
581 obj_elf_section_change_hook ();
582
583 old_sec = bfd_get_section_by_name_if (stdoutput, name, get_section_by_match,
584 (void *) match_p);
585 if (old_sec)
586 {
587 sec = old_sec;
588 subseg_set (sec, 0);
589 }
590 else
591 sec = subseg_force_new (name, 0);
592
593 bed = get_elf_backend_data (stdoutput);
594 ssect = (*bed->get_sec_type_attr) (stdoutput, sec);
595
596 if (ssect != NULL)
597 {
598 bool override = false;
599
600 if (type == SHT_NULL)
601 type = ssect->type;
602 else if (type != ssect->type)
603 {
604 if (old_sec == NULL
605 /* Some older versions of gcc will emit
606
607 .section .init_array,"aw",@progbits
608
609 for __attribute__ ((section (".init_array"))).
610 "@progbits" is incorrect. Also for x86-64 large bss
611 sections, some older versions of gcc will emit
612
613 .section .lbss,"aw",@progbits
614
615 "@progbits" is incorrect. */
616 #ifdef TC_I386
617 && (bed->s->arch_size != 64
618 || !(ssect->attr & SHF_X86_64_LARGE))
619 #endif
620 && ssect->type != SHT_INIT_ARRAY
621 && ssect->type != SHT_FINI_ARRAY
622 && ssect->type != SHT_PREINIT_ARRAY)
623 {
624 /* We allow to specify any type for a .note section. */
625 if (ssect->type != SHT_NOTE
626 /* Processor and application defined types are allowed too. */
627 && type < SHT_LOPROC)
628 as_warn (_("setting incorrect section type for %s"),
629 name);
630 }
631 else
632 {
633 as_warn (_("ignoring incorrect section type for %s"),
634 name);
635 type = ssect->type;
636 }
637 }
638
639 if (old_sec == NULL && ((attr & ~(SHF_LINK_ORDER
640 | SHF_MASKOS
641 | SHF_MASKPROC))
642 & ~ssect->attr) != 0)
643 {
644 /* Strip SHF_GNU_RETAIN. */
645 bfd_vma generic_attr = attr;
646 if (elf_tdata (stdoutput)->has_gnu_osabi)
647 generic_attr &= ~SHF_GNU_RETAIN;
648
649 /* As a GNU extension, we permit a .note section to be
650 allocatable. If the linker sees an allocatable .note
651 section, it will create a PT_NOTE segment in the output
652 file. We also allow "x" for .note.GNU-stack. */
653 if (ssect->type == SHT_NOTE
654 && (generic_attr == SHF_ALLOC
655 || generic_attr == SHF_EXECINSTR))
656 ;
657 /* Allow different SHF_MERGE and SHF_STRINGS if we have
658 something like .rodata.str. */
659 else if (ssect->suffix_length == -2
660 && name[ssect->prefix_length] == '.'
661 && (generic_attr
662 & ~ssect->attr
663 & ~SHF_MERGE
664 & ~SHF_STRINGS) == 0)
665 ;
666 /* .interp, .strtab and .symtab can have SHF_ALLOC. */
667 else if (generic_attr == SHF_ALLOC
668 && (strcmp (name, ".interp") == 0
669 || strcmp (name, ".strtab") == 0
670 || strcmp (name, ".symtab") == 0))
671 override = true;
672 /* .note.GNU-stack can have SHF_EXECINSTR. */
673 else if (generic_attr == SHF_EXECINSTR
674 && strcmp (name, ".note.GNU-stack") == 0)
675 override = true;
676 #ifdef TC_ALPHA
677 /* A section on Alpha may have SHF_ALPHA_GPREL. */
678 else if ((generic_attr & ~ssect->attr) == SHF_ALPHA_GPREL)
679 override = true;
680 #endif
681 #ifdef TC_RX
682 else if (generic_attr == (SHF_EXECINSTR | SHF_WRITE | SHF_ALLOC)
683 && (ssect->type == SHT_INIT_ARRAY
684 || ssect->type == SHT_FINI_ARRAY
685 || ssect->type == SHT_PREINIT_ARRAY))
686 /* RX init/fini arrays can and should have the "awx" attributes set. */
687 ;
688 #endif
689 else
690 {
691 if (match_p->group_name == NULL)
692 as_warn (_("setting incorrect section attributes for %s"),
693 name);
694 override = true;
695 }
696 }
697
698 if (!override && old_sec == NULL)
699 attr |= ssect->attr;
700 }
701
702 /* Convert ELF type and flags to BFD flags. */
703 flags = (SEC_RELOC
704 | ((attr & SHF_WRITE) ? 0 : SEC_READONLY)
705 | ((attr & SHF_ALLOC) ? SEC_ALLOC : 0)
706 | (((attr & SHF_ALLOC) && type != SHT_NOBITS) ? SEC_LOAD : 0)
707 | ((attr & SHF_EXECINSTR) ? SEC_CODE : 0)
708 | ((attr & SHF_MERGE) ? SEC_MERGE : 0)
709 | ((attr & SHF_STRINGS) ? SEC_STRINGS : 0)
710 | ((attr & SHF_EXCLUDE) ? SEC_EXCLUDE: 0)
711 | ((attr & SHF_TLS) ? SEC_THREAD_LOCAL : 0));
712 #ifdef md_elf_section_flags
713 flags = md_elf_section_flags (flags, attr, type);
714 #endif
715
716 if (linkonce)
717 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
718
719 /* PR 28054: Set the SEC_ELF_OCTETS flag for debugging sections.
720 Based on the code in bfd/elf.c:_bfd_elf_make_section_from_shdr().
721
722 FIXME: We do not set the SEC_DEBUGGING flag because that causes
723 problems for the FT32 and MSP430 targets. Investigate and fix. */
724 if ((flags & SEC_ALLOC) == 0 && name [0] == '.')
725 {
726 if ( startswith (name, ".debug")
727 || startswith (name, ".zdebug")
728 || startswith (name, ".gnu.debuglto_.debug_")
729 || startswith (name, ".gnu.linkonce.wi.")
730 || startswith (name, GNU_BUILD_ATTRS_SECTION_NAME)
731 || startswith (name, ".note.gnu"))
732 flags |= SEC_ELF_OCTETS;
733 }
734
735 if (old_sec == NULL)
736 {
737 symbolS *secsym;
738
739 if (type == SHT_NULL)
740 type = bfd_elf_get_default_section_type (flags);
741 elf_section_type (sec) = type;
742 elf_section_flags (sec) = attr;
743 elf_section_data (sec)->this_hdr.sh_info = match_p->sh_info;
744
745 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */
746 if (type == SHT_NOBITS)
747 seg_info (sec)->bss = 1;
748
749 /* Set the section ID and flags. */
750 sec->section_id = match_p->section_id;
751 flags |= match_p->flags;
752
753 /* Set the linked-to symbol name. */
754 sec->map_head.linked_to_symbol_name
755 = match_p->linked_to_symbol_name;
756
757 bfd_set_section_flags (sec, flags);
758 if (flags & SEC_MERGE)
759 sec->entsize = entsize;
760 elf_group_name (sec) = match_p->group_name;
761
762 /* Add a symbol for this section to the symbol table. */
763 secsym = symbol_find (name);
764 if (secsym != NULL)
765 {
766 /* We could be repurposing an undefined symbol here: make sure we
767 reset sy_value to look like other section symbols in order to avoid
768 trying to incorrectly resolve this section symbol later on. */
769 static const expressionS exp = { .X_op = O_constant };
770 symbol_set_value_expression (secsym, &exp);
771 symbol_set_bfdsym (secsym, sec->symbol);
772 }
773 else
774 symbol_table_insert (section_symbol (sec));
775 }
776 else
777 {
778 if (type != SHT_NULL
779 && (unsigned) type != elf_section_type (old_sec))
780 {
781 if (ssect != NULL)
782 /* This is a special section with known type. User
783 assembly might get the section type wrong; Even high
784 profile projects like glibc have done so in the past.
785 So don't error in this case. */
786 as_warn (_("ignoring changed section type for %s"), name);
787 else
788 /* Do error when assembly isn't self-consistent. */
789 as_bad (_("changed section type for %s"), name);
790 }
791
792 if (attr != 0)
793 {
794 /* If section attributes are specified the second time we see a
795 particular section, then check that they are the same as we
796 saw the first time. */
797 if (((old_sec->flags ^ flags)
798 & (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
799 | SEC_EXCLUDE | SEC_SORT_ENTRIES | SEC_MERGE | SEC_STRINGS
800 | SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
801 | SEC_THREAD_LOCAL)))
802 {
803 if (ssect != NULL)
804 as_warn (_("ignoring changed section attributes for %s"), name);
805 else
806 as_bad (_("changed section attributes for %s"), name);
807 }
808 else
809 /* FIXME: Maybe we should consider removing a previously set
810 processor or application specific attribute as suspicious? */
811 elf_section_flags (sec) = attr;
812
813 if ((flags & SEC_MERGE) && old_sec->entsize != (unsigned) entsize)
814 as_bad (_("changed section entity size for %s"), name);
815 }
816 }
817
818 #ifdef md_elf_section_change_hook
819 md_elf_section_change_hook ();
820 #endif
821 }
822
823 static bfd_vma
824 obj_elf_parse_section_letters (char *str, size_t len,
825 bool *is_clone, bfd_vma *gnu_attr)
826 {
827 bfd_vma attr = 0;
828 *is_clone = false;
829
830 while (len > 0)
831 {
832 switch (*str)
833 {
834 case 'a':
835 attr |= SHF_ALLOC;
836 /* Compatibility. */
837 if (len > 1 && str[1] == 'm')
838 {
839 attr |= SHF_MERGE;
840 str++, len--;
841 if (len > 1 && str[1] == 's')
842 {
843 attr |= SHF_STRINGS;
844 str++, len--;
845 }
846 }
847 break;
848 case 'e':
849 attr |= SHF_EXCLUDE;
850 break;
851 case 'o':
852 attr |= SHF_LINK_ORDER;
853 break;
854 case 'w':
855 attr |= SHF_WRITE;
856 break;
857 case 'x':
858 attr |= SHF_EXECINSTR;
859 break;
860 case 'M':
861 attr |= SHF_MERGE;
862 break;
863 case 'S':
864 attr |= SHF_STRINGS;
865 break;
866 case 'G':
867 attr |= SHF_GROUP;
868 break;
869 case 'T':
870 attr |= SHF_TLS;
871 break;
872 case 'd':
873 *gnu_attr |= SHF_GNU_MBIND;
874 break;
875 case 'R':
876 *gnu_attr |= SHF_GNU_RETAIN;
877 break;
878 case '?':
879 *is_clone = true;
880 break;
881 default:
882 {
883 const char *bad_msg = _("unrecognized .section attribute:"
884 " want a,e,o,w,x,M,S,G,T or number");
885 #ifdef md_elf_section_letter
886 bfd_vma md_attr = md_elf_section_letter (*str, &bad_msg);
887 if (md_attr != (bfd_vma) -1)
888 attr |= md_attr;
889 else
890 #endif
891 if (ISDIGIT (*str))
892 {
893 char * end;
894 struct elf_backend_data *bed;
895 bfd_vma numeric_flags = strtoul (str, &end, 0);
896
897 attr |= numeric_flags;
898
899 bed = (struct elf_backend_data *)
900 get_elf_backend_data (stdoutput);
901
902 if (bed->elf_osabi == ELFOSABI_NONE
903 || bed->elf_osabi == ELFOSABI_STANDALONE
904 || bed->elf_osabi == ELFOSABI_GNU
905 || bed->elf_osabi == ELFOSABI_FREEBSD)
906 {
907 /* Add flags in the SHF_MASKOS range to gnu_attr for
908 OSABIs that support those flags.
909 Also adding the flags for ELFOSABI_{NONE,STANDALONE}
910 allows them to be validated later in obj_elf_section.
911 We can't just always set these bits in gnu_attr for
912 all OSABIs, since Binutils does not recognize all
913 SHF_MASKOS bits for non-GNU OSABIs. It's therefore
914 possible that numeric flags are being used to set bits
915 in the SHF_MASKOS range for those targets, and we
916 don't want assembly to fail in those situations. */
917 *gnu_attr |= (numeric_flags & SHF_MASKOS);
918 }
919
920 /* Update str and len, allowing for the fact that
921 we will execute str++ and len-- below. */
922 end --;
923 len -= (end - str);
924 str = end;
925 }
926 else
927 as_fatal ("%s", bad_msg);
928 }
929 break;
930 }
931 str++, len--;
932 }
933
934 return attr;
935 }
936
937 static int
938 obj_elf_section_type (char *str, size_t len, bool warn)
939 {
940 if (len == 8 && startswith (str, "progbits"))
941 return SHT_PROGBITS;
942 if (len == 6 && startswith (str, "nobits"))
943 return SHT_NOBITS;
944 if (len == 4 && startswith (str, "note"))
945 return SHT_NOTE;
946 if (len == 10 && startswith (str, "init_array"))
947 return SHT_INIT_ARRAY;
948 if (len == 10 && startswith (str, "fini_array"))
949 return SHT_FINI_ARRAY;
950 if (len == 13 && startswith (str, "preinit_array"))
951 return SHT_PREINIT_ARRAY;
952
953 #ifdef md_elf_section_type
954 {
955 int md_type = md_elf_section_type (str, len);
956 if (md_type >= 0)
957 return md_type;
958 }
959 #endif
960
961 if (ISDIGIT (*str))
962 {
963 char * end;
964 int type = strtoul (str, & end, 0);
965
966 if (warn && (size_t) (end - str) != len)
967 as_warn (_("extraneous characters at end of numeric section type"));
968
969 return type;
970 }
971
972 if (warn)
973 as_warn (_("unrecognized section type"));
974 return 0;
975 }
976
977 #ifdef TC_SPARC
978 static bfd_vma
979 obj_elf_section_word (char *str, size_t len, int *type)
980 {
981 int ret;
982
983 if (len == 5 && startswith (str, "write"))
984 return SHF_WRITE;
985 if (len == 5 && startswith (str, "alloc"))
986 return SHF_ALLOC;
987 if (len == 9 && startswith (str, "execinstr"))
988 return SHF_EXECINSTR;
989 if (len == 7 && startswith (str, "exclude"))
990 return SHF_EXCLUDE;
991 if (len == 3 && startswith (str, "tls"))
992 return SHF_TLS;
993
994 #ifdef md_elf_section_word
995 {
996 bfd_vma md_attr = md_elf_section_word (str, len);
997 if (md_attr > 0)
998 return md_attr;
999 }
1000 #endif
1001
1002 ret = obj_elf_section_type (str, len, false);
1003 if (ret != 0)
1004 *type = ret;
1005 else
1006 as_warn (_("unrecognized section attribute"));
1007
1008 return 0;
1009 }
1010 #endif
1011
1012 /* Get name of section. */
1013 const char *
1014 obj_elf_section_name (void)
1015 {
1016 char *name;
1017
1018 SKIP_WHITESPACE ();
1019 if (*input_line_pointer == '"')
1020 {
1021 int dummy;
1022
1023 name = demand_copy_C_string (&dummy);
1024 if (name == NULL)
1025 {
1026 ignore_rest_of_line ();
1027 return NULL;
1028 }
1029 }
1030 else
1031 {
1032 char *end = input_line_pointer;
1033
1034 while (0 == strchr ("\n\t,; ", *end))
1035 end++;
1036 if (end == input_line_pointer)
1037 {
1038 as_bad (_("missing name"));
1039 ignore_rest_of_line ();
1040 return NULL;
1041 }
1042
1043 obstack_grow0 (&notes, input_line_pointer, end - input_line_pointer);
1044 name = obstack_base (&notes);
1045
1046 while (flag_sectname_subst)
1047 {
1048 char *subst = strchr (name, '%');
1049 if (subst && subst[1] == 'S')
1050 {
1051 size_t head = subst - name;
1052 size_t tail = strlen (subst + 2) + 1;
1053 size_t slen = strlen (now_seg->name);
1054
1055 if (slen > 2)
1056 {
1057 obstack_blank (&notes, slen - 2);
1058 name = obstack_base (&notes);
1059 }
1060 memmove (name + head + slen, name + head + 2, tail);
1061 memcpy (name + head, now_seg->name, slen);
1062 }
1063 else
1064 break;
1065 }
1066
1067 obstack_finish (&notes);
1068
1069 #ifdef tc_canonicalize_section_name
1070 name = tc_canonicalize_section_name (name);
1071 #endif
1072 input_line_pointer = end;
1073 }
1074 SKIP_WHITESPACE ();
1075 return name;
1076 }
1077
1078 static void
1079 obj_elf_attach_to_group (int dummy ATTRIBUTE_UNUSED)
1080 {
1081 const char * gname = obj_elf_section_name ();
1082
1083 if (gname == NULL)
1084 {
1085 as_warn (_("group name not parseable"));
1086 return;
1087 }
1088
1089 if (elf_group_name (now_seg))
1090 {
1091 if (strcmp (elf_group_name (now_seg), gname) != 0)
1092 as_warn (_("section %s already has a group (%s)"),
1093 bfd_section_name (now_seg), elf_group_name (now_seg));
1094 return;
1095 }
1096
1097 elf_group_name (now_seg) = gname;
1098 elf_section_flags (now_seg) |= SHF_GROUP;
1099 }
1100
1101 void
1102 obj_elf_section (int push)
1103 {
1104 const char *name;
1105 char *beg;
1106 int type, dummy;
1107 bfd_vma attr;
1108 bfd_vma gnu_attr;
1109 int entsize;
1110 int linkonce;
1111 subsegT new_subsection = -1;
1112 struct elf_section_match match;
1113 unsigned long linked_to_section_index = -1UL;
1114
1115 if (flag_mri)
1116 {
1117 char mri_type;
1118
1119 #ifdef md_flush_pending_output
1120 md_flush_pending_output ();
1121 #endif
1122
1123 obj_elf_section_change_hook ();
1124
1125 s_mri_sect (&mri_type);
1126
1127 #ifdef md_elf_section_change_hook
1128 md_elf_section_change_hook ();
1129 #endif
1130
1131 return;
1132 }
1133
1134 name = obj_elf_section_name ();
1135 if (name == NULL)
1136 return;
1137
1138 memset (&match, 0, sizeof (match));
1139
1140 symbolS * sym;
1141 if ((sym = symbol_find (name)) != NULL
1142 && ! symbol_section_p (sym)
1143 && S_IS_DEFINED (sym)
1144 && ! S_IS_VOLATILE (sym)
1145 && ! S_CAN_BE_REDEFINED (sym))
1146 {
1147 as_bad (_("section name '%s' already defined as another symbol"), name);
1148 ignore_rest_of_line ();
1149 return;
1150 }
1151 type = SHT_NULL;
1152 attr = 0;
1153 gnu_attr = 0;
1154 entsize = 0;
1155 linkonce = 0;
1156
1157 if (*input_line_pointer == ',')
1158 {
1159 /* Skip the comma. */
1160 ++input_line_pointer;
1161 SKIP_WHITESPACE ();
1162
1163 if (push && ISDIGIT (*input_line_pointer))
1164 {
1165 /* .pushsection has an optional subsection. */
1166 new_subsection = (subsegT) get_absolute_expression ();
1167
1168 SKIP_WHITESPACE ();
1169
1170 /* Stop if we don't see a comma. */
1171 if (*input_line_pointer != ',')
1172 goto done;
1173
1174 /* Skip the comma. */
1175 ++input_line_pointer;
1176 SKIP_WHITESPACE ();
1177 }
1178
1179 if (*input_line_pointer == '"')
1180 {
1181 bool is_clone;
1182
1183 beg = demand_copy_C_string (&dummy);
1184 if (beg == NULL)
1185 {
1186 ignore_rest_of_line ();
1187 return;
1188 }
1189 attr |= obj_elf_parse_section_letters (beg, strlen (beg),
1190 &is_clone, &gnu_attr);
1191
1192 SKIP_WHITESPACE ();
1193 if (*input_line_pointer == ',')
1194 {
1195 char c;
1196 char *save = input_line_pointer;
1197
1198 ++input_line_pointer;
1199 SKIP_WHITESPACE ();
1200 c = *input_line_pointer;
1201 if (c == '"')
1202 {
1203 beg = demand_copy_C_string (&dummy);
1204 if (beg == NULL)
1205 {
1206 ignore_rest_of_line ();
1207 return;
1208 }
1209 type = obj_elf_section_type (beg, strlen (beg), true);
1210 }
1211 else if (c == '@' || c == '%')
1212 {
1213 ++input_line_pointer;
1214
1215 if (ISDIGIT (* input_line_pointer))
1216 type = strtoul (input_line_pointer, &input_line_pointer, 0);
1217 else
1218 {
1219 c = get_symbol_name (& beg);
1220 (void) restore_line_pointer (c);
1221 type = obj_elf_section_type (beg,
1222 input_line_pointer - beg,
1223 true);
1224 }
1225 }
1226 else
1227 input_line_pointer = save;
1228 }
1229
1230 SKIP_WHITESPACE ();
1231 if ((attr & SHF_MERGE) != 0 && *input_line_pointer == ',')
1232 {
1233 ++input_line_pointer;
1234 SKIP_WHITESPACE ();
1235 entsize = get_absolute_expression ();
1236 SKIP_WHITESPACE ();
1237 if (entsize < 0)
1238 {
1239 as_warn (_("invalid merge entity size"));
1240 attr &= ~SHF_MERGE;
1241 entsize = 0;
1242 }
1243 }
1244 else if ((attr & SHF_MERGE) != 0)
1245 {
1246 as_warn (_("entity size for SHF_MERGE not specified"));
1247 attr &= ~SHF_MERGE;
1248 }
1249
1250 if ((attr & SHF_LINK_ORDER) != 0 && *input_line_pointer == ',')
1251 {
1252 ++input_line_pointer;
1253 SKIP_WHITESPACE ();
1254 /* Check for a numeric section index, rather than a symbol name. */
1255 if (ISDIGIT (* input_line_pointer))
1256 {
1257 linked_to_section_index = strtoul (input_line_pointer, & input_line_pointer, 0);
1258 }
1259 else
1260 {
1261 char c;
1262 unsigned int length;
1263
1264 c = get_symbol_name (& beg);
1265 (void) restore_line_pointer (c);
1266 length = input_line_pointer - beg;
1267 if (length)
1268 match.linked_to_symbol_name = xmemdup0 (beg, length);
1269 }
1270 }
1271
1272 if ((attr & SHF_GROUP) != 0 && is_clone)
1273 {
1274 as_warn (_("? section flag ignored with G present"));
1275 is_clone = false;
1276 }
1277
1278 if ((attr & SHF_GROUP) != 0 && *input_line_pointer == ',')
1279 {
1280 ++input_line_pointer;
1281 match.group_name = obj_elf_section_name ();
1282 if (match.group_name == NULL)
1283 attr &= ~SHF_GROUP;
1284 else if (*input_line_pointer == ',')
1285 {
1286 ++input_line_pointer;
1287 SKIP_WHITESPACE ();
1288 if (startswith (input_line_pointer, "comdat"))
1289 {
1290 input_line_pointer += 6;
1291 linkonce = 1;
1292 }
1293 }
1294 else if (startswith (name, ".gnu.linkonce"))
1295 linkonce = 1;
1296 }
1297 else if ((attr & SHF_GROUP) != 0)
1298 {
1299 as_warn (_("group name for SHF_GROUP not specified"));
1300 attr &= ~SHF_GROUP;
1301 }
1302
1303 if (is_clone)
1304 {
1305 const char *now_group = elf_group_name (now_seg);
1306 if (now_group != NULL)
1307 {
1308 match.group_name = now_group;
1309 linkonce = (now_seg->flags & SEC_LINK_ONCE) != 0;
1310 }
1311 }
1312
1313 if ((gnu_attr & SHF_GNU_MBIND) != 0 && *input_line_pointer == ',')
1314 {
1315 char *save = input_line_pointer;
1316 ++input_line_pointer;
1317 SKIP_WHITESPACE ();
1318 if (ISDIGIT (* input_line_pointer))
1319 {
1320 char *t = input_line_pointer;
1321 match.sh_info = strtoul (input_line_pointer,
1322 &input_line_pointer, 0);
1323 if (match.sh_info == (unsigned int) -1)
1324 {
1325 as_warn (_("unsupported mbind section info: %s"), t);
1326 match.sh_info = 0;
1327 }
1328 }
1329 else
1330 input_line_pointer = save;
1331 }
1332
1333 if ((gnu_attr & SHF_GNU_RETAIN) != 0)
1334 match.sh_flags |= SHF_GNU_RETAIN;
1335
1336 if (*input_line_pointer == ',')
1337 {
1338 char *save = input_line_pointer;
1339
1340 ++input_line_pointer;
1341 SKIP_WHITESPACE ();
1342 if (startswith (input_line_pointer, "unique"))
1343 {
1344 input_line_pointer += 6;
1345 SKIP_WHITESPACE ();
1346 if (*input_line_pointer == ',')
1347 {
1348 ++input_line_pointer;
1349 SKIP_WHITESPACE ();
1350 if (ISDIGIT (* input_line_pointer))
1351 {
1352 bfd_vma id;
1353 bool overflow;
1354 char *t = input_line_pointer;
1355 if (sizeof (bfd_vma) <= sizeof (unsigned long))
1356 {
1357 errno = 0;
1358 id = strtoul (input_line_pointer,
1359 &input_line_pointer, 0);
1360 overflow = (id == (unsigned long) -1
1361 && errno == ERANGE);
1362 }
1363 else
1364 {
1365 id = bfd_scan_vma
1366 (input_line_pointer,
1367 (const char **) &input_line_pointer, 0);
1368 overflow = id == ~(bfd_vma) 0;
1369 }
1370 if (overflow || id > (unsigned int) -1)
1371 {
1372 char *linefeed, saved_char = 0;
1373 if ((linefeed = strchr (t, '\n')) != NULL)
1374 {
1375 saved_char = *linefeed;
1376 *linefeed = '\0';
1377 }
1378 as_bad (_("unsupported section id: %s"), t);
1379 if (saved_char)
1380 *linefeed = saved_char;
1381 }
1382 else
1383 {
1384 match.section_id = id;
1385 match.flags |= SEC_ASSEMBLER_SECTION_ID;
1386 }
1387 }
1388 }
1389 }
1390 else
1391 input_line_pointer = save;
1392 }
1393 }
1394 #ifdef TC_SPARC
1395 else
1396 {
1397 do
1398 {
1399 char c;
1400
1401 SKIP_WHITESPACE ();
1402 if (*input_line_pointer != '#')
1403 {
1404 as_bad (_("character following name is not '#'"));
1405 ignore_rest_of_line ();
1406 return;
1407 }
1408 ++input_line_pointer;
1409 c = get_symbol_name (& beg);
1410 (void) restore_line_pointer (c);
1411
1412 attr |= obj_elf_section_word (beg, input_line_pointer - beg,
1413 &type);
1414
1415 SKIP_WHITESPACE ();
1416 }
1417 while (*input_line_pointer++ == ',');
1418 --input_line_pointer;
1419 }
1420 #endif
1421 }
1422
1423 done:
1424 demand_empty_rest_of_line ();
1425
1426 if ((gnu_attr & (SHF_GNU_MBIND | SHF_GNU_RETAIN)) != 0)
1427 {
1428 const struct elf_backend_data *bed;
1429 bool mbind_p = (gnu_attr & SHF_GNU_MBIND) != 0;
1430
1431 if (mbind_p && (attr & SHF_ALLOC) == 0)
1432 as_bad (_("SHF_ALLOC isn't set for GNU_MBIND section: %s"), name);
1433
1434 bed = get_elf_backend_data (stdoutput);
1435
1436 if (bed->elf_osabi != ELFOSABI_GNU
1437 && bed->elf_osabi != ELFOSABI_FREEBSD
1438 && bed->elf_osabi != ELFOSABI_NONE)
1439 as_bad (_("%s section is supported only by GNU and FreeBSD targets"),
1440 mbind_p ? "GNU_MBIND" : "GNU_RETAIN");
1441 else
1442 {
1443 if (mbind_p)
1444 elf_tdata (stdoutput)->has_gnu_osabi |= elf_gnu_osabi_mbind;
1445 if ((gnu_attr & SHF_GNU_RETAIN) != 0)
1446 elf_tdata (stdoutput)->has_gnu_osabi |= elf_gnu_osabi_retain;
1447
1448 attr |= gnu_attr;
1449 }
1450 }
1451
1452 obj_elf_change_section (name, type, attr, entsize, &match, linkonce,
1453 push);
1454
1455 if (linked_to_section_index != -1UL)
1456 {
1457 elf_section_flags (now_seg) |= SHF_LINK_ORDER;
1458 elf_section_data (now_seg)->this_hdr.sh_link = linked_to_section_index;
1459 /* FIXME: Should we perform some sanity checking on the section index ? */
1460 }
1461
1462 if (push && new_subsection != -1)
1463 subseg_set (now_seg, new_subsection);
1464 }
1465
1466 /* Change to the .bss section. */
1467
1468 void
1469 obj_elf_bss (int i ATTRIBUTE_UNUSED)
1470 {
1471 int temp;
1472
1473 #ifdef md_flush_pending_output
1474 md_flush_pending_output ();
1475 #endif
1476
1477 obj_elf_section_change_hook ();
1478
1479 temp = get_absolute_expression ();
1480 subseg_set (bss_section, (subsegT) temp);
1481 demand_empty_rest_of_line ();
1482
1483 #ifdef md_elf_section_change_hook
1484 md_elf_section_change_hook ();
1485 #endif
1486 }
1487
1488 /* Change to the .data section. */
1489
1490 void
1491 obj_elf_data (int i)
1492 {
1493 #ifdef md_flush_pending_output
1494 md_flush_pending_output ();
1495 #endif
1496
1497 obj_elf_section_change_hook ();
1498
1499 s_data (i);
1500
1501 #ifdef md_elf_section_change_hook
1502 md_elf_section_change_hook ();
1503 #endif
1504 }
1505
1506 /* Change to the .text section. */
1507
1508 void
1509 obj_elf_text (int i)
1510 {
1511 #ifdef md_flush_pending_output
1512 md_flush_pending_output ();
1513 #endif
1514
1515 obj_elf_section_change_hook ();
1516
1517 s_text (i);
1518
1519 #ifdef md_elf_section_change_hook
1520 md_elf_section_change_hook ();
1521 #endif
1522 }
1523
1524 /* Change to the *ABS* section. */
1525
1526 void
1527 obj_elf_struct (int i)
1528 {
1529 #ifdef md_flush_pending_output
1530 md_flush_pending_output ();
1531 #endif
1532
1533 obj_elf_section_change_hook ();
1534
1535 s_struct (i);
1536
1537 #ifdef md_elf_section_change_hook
1538 md_elf_section_change_hook ();
1539 #endif
1540 }
1541
1542 static void
1543 obj_elf_subsection (int ignore ATTRIBUTE_UNUSED)
1544 {
1545 int temp;
1546
1547 #ifdef md_flush_pending_output
1548 md_flush_pending_output ();
1549 #endif
1550
1551 obj_elf_section_change_hook ();
1552
1553 temp = get_absolute_expression ();
1554 subseg_set (now_seg, (subsegT) temp);
1555 demand_empty_rest_of_line ();
1556
1557 #ifdef md_elf_section_change_hook
1558 md_elf_section_change_hook ();
1559 #endif
1560 }
1561
1562 /* This can be called from the processor backends if they change
1563 sections. */
1564
1565 void
1566 obj_elf_section_change_hook (void)
1567 {
1568 previous_section = now_seg;
1569 previous_subsection = now_subseg;
1570 }
1571
1572 void
1573 obj_elf_previous (int ignore ATTRIBUTE_UNUSED)
1574 {
1575 segT new_section;
1576 int new_subsection;
1577
1578 if (previous_section == 0)
1579 {
1580 as_warn (_(".previous without corresponding .section; ignored"));
1581 return;
1582 }
1583
1584 #ifdef md_flush_pending_output
1585 md_flush_pending_output ();
1586 #endif
1587
1588 new_section = previous_section;
1589 new_subsection = previous_subsection;
1590 obj_elf_section_change_hook ();
1591
1592 subseg_set (new_section, new_subsection);
1593
1594 #ifdef md_elf_section_change_hook
1595 md_elf_section_change_hook ();
1596 #endif
1597 }
1598
1599 static void
1600 obj_elf_popsection (int xxx ATTRIBUTE_UNUSED)
1601 {
1602 struct section_stack *top = section_stack;
1603
1604 if (top == NULL)
1605 {
1606 as_warn (_(".popsection without corresponding .pushsection; ignored"));
1607 return;
1608 }
1609
1610 #ifdef md_flush_pending_output
1611 md_flush_pending_output ();
1612 #endif
1613
1614 section_stack = top->next;
1615 previous_section = top->prev_seg;
1616 previous_subsection = top->prev_subseg;
1617 subseg_set (top->seg, top->subseg);
1618 free (top);
1619
1620 #ifdef md_elf_section_change_hook
1621 md_elf_section_change_hook ();
1622 #endif
1623 }
1624
1625 static void
1626 obj_elf_line (int ignore ATTRIBUTE_UNUSED)
1627 {
1628 /* Assume delimiter is part of expression. BSD4.2 as fails with
1629 delightful bug, so we are not being incompatible here. */
1630 new_logical_line (NULL, get_absolute_expression ());
1631 demand_empty_rest_of_line ();
1632 }
1633
1634 static struct elf_versioned_name_list *
1635 obj_elf_find_and_add_versioned_name (const char *version_name,
1636 const char *sym_name,
1637 const char *ver,
1638 struct elf_obj_sy *sy_obj)
1639 {
1640 struct elf_versioned_name_list *versioned_name;
1641 const char *p;
1642
1643 for (p = ver + 1; *p == ELF_VER_CHR; p++)
1644 ;
1645
1646 /* NB: Since some tests in ld/testsuite/ld-elfvers have no version
1647 names, we have to disable this. */
1648 if (0 && *p == '\0')
1649 {
1650 as_bad (_("missing version name in `%s' for symbol `%s'"),
1651 version_name, sym_name);
1652 return NULL;
1653 }
1654
1655 versioned_name = sy_obj->versioned_name;
1656
1657 switch (p - ver)
1658 {
1659 case 1:
1660 case 2:
1661 break;
1662 case 3:
1663 if (sy_obj->rename)
1664 {
1665 if (strcmp (versioned_name->name, version_name) == 0)
1666 return versioned_name;
1667 else
1668 {
1669 as_bad (_("only one version name with `@@@' is allowed "
1670 "for symbol `%s'"), sym_name);
1671 return NULL;
1672 }
1673 }
1674 sy_obj->rename = true;
1675 break;
1676 default:
1677 as_bad (_("invalid version name '%s' for symbol `%s'"),
1678 version_name, sym_name);
1679 return NULL;
1680 }
1681
1682 for (;
1683 versioned_name != NULL;
1684 versioned_name = versioned_name->next)
1685 if (strcmp (versioned_name->name, version_name) == 0)
1686 return versioned_name;
1687
1688 /* Add this versioned name to the head of the list, */
1689 versioned_name = (struct elf_versioned_name_list *)
1690 xmalloc (sizeof (*versioned_name));
1691 versioned_name->name = xstrdup (version_name);
1692 versioned_name->next = sy_obj->versioned_name;
1693 sy_obj->versioned_name = versioned_name;
1694
1695 return versioned_name;
1696 }
1697
1698 /* This handles the .symver pseudo-op, which is used to specify a
1699 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1700 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1701 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1702 with the same value as the symbol NAME. */
1703
1704 static void
1705 obj_elf_symver (int ignore ATTRIBUTE_UNUSED)
1706 {
1707 char *name;
1708 const char *sym_name;
1709 char c;
1710 char old_lexat;
1711 symbolS *sym;
1712 struct elf_obj_sy *sy_obj;
1713 char *p;
1714
1715 sym = get_sym_from_input_line_and_check ();
1716
1717 if (*input_line_pointer != ',')
1718 {
1719 as_bad (_("expected comma after name in .symver"));
1720 ignore_rest_of_line ();
1721 return;
1722 }
1723
1724 ++input_line_pointer;
1725 SKIP_WHITESPACE ();
1726
1727 /* Temporarily include '@' in symbol names. */
1728 old_lexat = lex_type[(unsigned char) '@'];
1729 lex_type[(unsigned char) '@'] |= LEX_NAME;
1730 c = get_symbol_name (& name);
1731 lex_type[(unsigned char) '@'] = old_lexat;
1732 sym_name = S_GET_NAME (sym);
1733
1734 if (S_IS_COMMON (sym))
1735 {
1736 as_bad (_("`%s' can't be versioned to common symbol '%s'"),
1737 name, sym_name);
1738 ignore_rest_of_line ();
1739 return;
1740 }
1741
1742 p = strchr (name, ELF_VER_CHR);
1743 if (p == NULL)
1744 {
1745 as_bad (_("missing version name in `%s' for symbol `%s'"),
1746 name, sym_name);
1747 ignore_rest_of_line ();
1748 return;
1749 }
1750
1751 sy_obj = symbol_get_obj (sym);
1752 if (obj_elf_find_and_add_versioned_name (name, sym_name,
1753 p, sy_obj) == NULL)
1754 {
1755 sy_obj->bad_version = true;
1756 ignore_rest_of_line ();
1757 return;
1758 }
1759
1760 (void) restore_line_pointer (c);
1761
1762 if (*input_line_pointer == ',')
1763 {
1764 char *save = input_line_pointer;
1765
1766 ++input_line_pointer;
1767 SKIP_WHITESPACE ();
1768 if (startswith (input_line_pointer, "local"))
1769 {
1770 input_line_pointer += 5;
1771 sy_obj->visibility = visibility_local;
1772 }
1773 else if (startswith (input_line_pointer, "hidden"))
1774 {
1775 input_line_pointer += 6;
1776 sy_obj->visibility = visibility_hidden;
1777 }
1778 else if (startswith (input_line_pointer, "remove"))
1779 {
1780 input_line_pointer += 6;
1781 sy_obj->visibility = visibility_remove;
1782 }
1783 else
1784 input_line_pointer = save;
1785 }
1786
1787 demand_empty_rest_of_line ();
1788 }
1789
1790 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1791 to the linker the hierarchy in which a particular table resides. The
1792 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1793
1794 struct fix *
1795 obj_elf_get_vtable_inherit (void)
1796 {
1797 char *cname, *pname;
1798 symbolS *csym, *psym;
1799 char c, bad = 0;
1800
1801 if (*input_line_pointer == '#')
1802 ++input_line_pointer;
1803
1804 c = get_symbol_name (& cname);
1805 csym = symbol_find (cname);
1806
1807 /* GCFIXME: should check that we don't have two .vtable_inherits for
1808 the same child symbol. Also, we can currently only do this if the
1809 child symbol is already exists and is placed in a fragment. */
1810
1811 if (csym == NULL || symbol_get_frag (csym) == NULL)
1812 {
1813 as_bad (_("expected `%s' to have already been set for .vtable_inherit"),
1814 cname);
1815 bad = 1;
1816 }
1817
1818 *input_line_pointer = c;
1819
1820 SKIP_WHITESPACE_AFTER_NAME ();
1821 if (*input_line_pointer != ',')
1822 {
1823 as_bad (_("expected comma after name in .vtable_inherit"));
1824 ignore_rest_of_line ();
1825 return NULL;
1826 }
1827
1828 ++input_line_pointer;
1829 SKIP_WHITESPACE ();
1830
1831 if (*input_line_pointer == '#')
1832 ++input_line_pointer;
1833
1834 if (input_line_pointer[0] == '0'
1835 && (input_line_pointer[1] == '\0'
1836 || ISSPACE (input_line_pointer[1])))
1837 {
1838 psym = section_symbol (absolute_section);
1839 ++input_line_pointer;
1840 }
1841 else
1842 {
1843 c = get_symbol_name (& pname);
1844 psym = symbol_find_or_make (pname);
1845 restore_line_pointer (c);
1846 }
1847
1848 demand_empty_rest_of_line ();
1849
1850 if (bad)
1851 return NULL;
1852
1853 gas_assert (symbol_get_value_expression (csym)->X_op == O_constant);
1854 return fix_new (symbol_get_frag (csym),
1855 symbol_get_value_expression (csym)->X_add_number,
1856 0, psym, 0, 0, BFD_RELOC_VTABLE_INHERIT);
1857 }
1858
1859 /* This is a version of obj_elf_get_vtable_inherit() that is
1860 suitable for use in struct _pseudo_type tables. */
1861
1862 void
1863 obj_elf_vtable_inherit (int ignore ATTRIBUTE_UNUSED)
1864 {
1865 (void) obj_elf_get_vtable_inherit ();
1866 }
1867
1868 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1869 to the linker that a vtable slot was used. The syntax is
1870 ".vtable_entry tablename, offset". */
1871
1872 struct fix *
1873 obj_elf_get_vtable_entry (void)
1874 {
1875 symbolS *sym;
1876 offsetT offset;
1877
1878 if (*input_line_pointer == '#')
1879 ++input_line_pointer;
1880
1881 sym = get_sym_from_input_line_and_check ();
1882 if (*input_line_pointer != ',')
1883 {
1884 as_bad (_("expected comma after name in .vtable_entry"));
1885 ignore_rest_of_line ();
1886 return NULL;
1887 }
1888
1889 ++input_line_pointer;
1890 if (*input_line_pointer == '#')
1891 ++input_line_pointer;
1892
1893 offset = get_absolute_expression ();
1894
1895 demand_empty_rest_of_line ();
1896
1897 return fix_new (frag_now, frag_now_fix (), 0, sym, offset, 0,
1898 BFD_RELOC_VTABLE_ENTRY);
1899 }
1900
1901 /* This is a version of obj_elf_get_vtable_entry() that is
1902 suitable for use in struct _pseudo_type tables. */
1903
1904 void
1905 obj_elf_vtable_entry (int ignore ATTRIBUTE_UNUSED)
1906 {
1907 (void) obj_elf_get_vtable_entry ();
1908 }
1909
1910 #define skip_whitespace(str) do { if (*(str) == ' ') ++(str); } while (0)
1911
1912 static inline int
1913 skip_past_char (char ** str, char c)
1914 {
1915 if (**str == c)
1916 {
1917 (*str)++;
1918 return 0;
1919 }
1920 else
1921 return -1;
1922 }
1923 #define skip_past_comma(str) skip_past_char (str, ',')
1924
1925 /* A list of attributes that have been explicitly set by the assembly code.
1926 VENDOR is the vendor id, BASE is the tag shifted right by the number
1927 of bits in MASK, and bit N of MASK is set if tag BASE+N has been set. */
1928 struct recorded_attribute_info {
1929 struct recorded_attribute_info *next;
1930 int vendor;
1931 unsigned int base;
1932 unsigned long mask;
1933 };
1934 static struct recorded_attribute_info *recorded_attributes;
1935
1936 /* Record that we have seen an explicit specification of attribute TAG
1937 for vendor VENDOR. */
1938
1939 static void
1940 record_attribute (int vendor, unsigned int tag)
1941 {
1942 unsigned int base;
1943 unsigned long mask;
1944 struct recorded_attribute_info *rai;
1945
1946 base = tag / (8 * sizeof (rai->mask));
1947 mask = 1UL << (tag % (8 * sizeof (rai->mask)));
1948 for (rai = recorded_attributes; rai; rai = rai->next)
1949 if (rai->vendor == vendor && rai->base == base)
1950 {
1951 rai->mask |= mask;
1952 return;
1953 }
1954
1955 rai = XNEW (struct recorded_attribute_info);
1956 rai->next = recorded_attributes;
1957 rai->vendor = vendor;
1958 rai->base = base;
1959 rai->mask = mask;
1960 recorded_attributes = rai;
1961 }
1962
1963 /* Return true if we have seen an explicit specification of attribute TAG
1964 for vendor VENDOR. */
1965
1966 bool
1967 obj_elf_seen_attribute (int vendor, unsigned int tag)
1968 {
1969 unsigned int base;
1970 unsigned long mask;
1971 struct recorded_attribute_info *rai;
1972
1973 base = tag / (8 * sizeof (rai->mask));
1974 mask = 1UL << (tag % (8 * sizeof (rai->mask)));
1975 for (rai = recorded_attributes; rai; rai = rai->next)
1976 if (rai->vendor == vendor && rai->base == base)
1977 return (rai->mask & mask) != 0;
1978 return false;
1979 }
1980
1981 /* Parse an attribute directive for VENDOR.
1982 Returns the attribute number read, or zero on error. */
1983
1984 int
1985 obj_elf_vendor_attribute (int vendor)
1986 {
1987 expressionS exp;
1988 int type;
1989 int tag;
1990 unsigned int i = 0;
1991 char *s = NULL;
1992
1993 /* Read the first number or name. */
1994 skip_whitespace (input_line_pointer);
1995 s = input_line_pointer;
1996 if (ISDIGIT (*input_line_pointer))
1997 {
1998 expression (& exp);
1999 if (exp.X_op != O_constant)
2000 goto bad;
2001 tag = exp.X_add_number;
2002 }
2003 else
2004 {
2005 char *name;
2006
2007 /* A name may contain '_', but no other punctuation. */
2008 for (; ISALNUM (*input_line_pointer) || *input_line_pointer == '_';
2009 ++input_line_pointer)
2010 i++;
2011 if (i == 0)
2012 goto bad;
2013
2014 name = xmemdup0 (s, i);
2015
2016 #ifndef CONVERT_SYMBOLIC_ATTRIBUTE
2017 #define CONVERT_SYMBOLIC_ATTRIBUTE(a) -1
2018 #endif
2019
2020 tag = CONVERT_SYMBOLIC_ATTRIBUTE (name);
2021 if (tag == -1)
2022 {
2023 as_bad (_("Attribute name not recognised: %s"), name);
2024 ignore_rest_of_line ();
2025 free (name);
2026 return 0;
2027 }
2028 free (name);
2029 }
2030
2031 type = _bfd_elf_obj_attrs_arg_type (stdoutput, vendor, tag);
2032
2033 if (skip_past_comma (&input_line_pointer) == -1)
2034 goto bad;
2035 if (type & 1)
2036 {
2037 expression (& exp);
2038 if (exp.X_op != O_constant)
2039 {
2040 as_bad (_("expected numeric constant"));
2041 ignore_rest_of_line ();
2042 return 0;
2043 }
2044 i = exp.X_add_number;
2045 }
2046 if ((type & 3) == 3
2047 && skip_past_comma (&input_line_pointer) == -1)
2048 {
2049 as_bad (_("expected comma"));
2050 ignore_rest_of_line ();
2051 return 0;
2052 }
2053 if (type & 2)
2054 {
2055 int len;
2056
2057 skip_whitespace (input_line_pointer);
2058 if (*input_line_pointer != '"')
2059 goto bad_string;
2060 s = demand_copy_C_string (&len);
2061 }
2062
2063 record_attribute (vendor, tag);
2064 switch (type & 3)
2065 {
2066 case 3:
2067 bfd_elf_add_obj_attr_int_string (stdoutput, vendor, tag, i, s);
2068 break;
2069 case 2:
2070 bfd_elf_add_obj_attr_string (stdoutput, vendor, tag, s);
2071 break;
2072 case 1:
2073 bfd_elf_add_obj_attr_int (stdoutput, vendor, tag, i);
2074 break;
2075 default:
2076 abort ();
2077 }
2078
2079 demand_empty_rest_of_line ();
2080 return tag;
2081 bad_string:
2082 as_bad (_("bad string constant"));
2083 ignore_rest_of_line ();
2084 return 0;
2085 bad:
2086 as_bad (_("expected <tag> , <value>"));
2087 ignore_rest_of_line ();
2088 return 0;
2089 }
2090
2091 /* Parse a .gnu_attribute directive. */
2092
2093 static void
2094 obj_elf_gnu_attribute (int ignored ATTRIBUTE_UNUSED)
2095 {
2096 obj_elf_vendor_attribute (OBJ_ATTR_GNU);
2097 }
2098
2099 void
2100 elf_obj_read_begin_hook (void)
2101 {
2102 #ifdef NEED_ECOFF_DEBUG
2103 if (ECOFF_DEBUGGING)
2104 ecoff_read_begin_hook ();
2105 #endif
2106 }
2107
2108 void
2109 elf_obj_symbol_new_hook (symbolS *symbolP)
2110 {
2111 struct elf_obj_sy *sy_obj;
2112
2113 sy_obj = symbol_get_obj (symbolP);
2114 sy_obj->size = NULL;
2115 sy_obj->versioned_name = NULL;
2116
2117 #ifdef NEED_ECOFF_DEBUG
2118 if (ECOFF_DEBUGGING)
2119 ecoff_symbol_new_hook (symbolP);
2120 #endif
2121 }
2122
2123 /* Deduplicate size expressions. We might get into trouble with
2124 multiple freeing or use after free if we leave them pointing to the
2125 same expressionS. */
2126
2127 void
2128 elf_obj_symbol_clone_hook (symbolS *newsym, symbolS *orgsym ATTRIBUTE_UNUSED)
2129 {
2130 struct elf_obj_sy *newelf = symbol_get_obj (newsym);
2131 if (newelf->size)
2132 {
2133 expressionS *exp = XNEW (expressionS);
2134 *exp = *newelf->size;
2135 newelf->size = exp;
2136 }
2137 }
2138
2139 void
2140 elf_copy_symbol_attributes (symbolS *dest, symbolS *src)
2141 {
2142 struct elf_obj_sy *srcelf = symbol_get_obj (src);
2143 struct elf_obj_sy *destelf = symbol_get_obj (dest);
2144 /* If size is unset, copy size from src. Because we don't track whether
2145 .size has been used, we can't differentiate .size dest, 0 from the case
2146 where dest's size is unset. */
2147 if (!destelf->size && S_GET_SIZE (dest) == 0)
2148 {
2149 if (srcelf->size)
2150 {
2151 destelf->size = XNEW (expressionS);
2152 *destelf->size = *srcelf->size;
2153 }
2154 S_SET_SIZE (dest, S_GET_SIZE (src));
2155 }
2156 /* Don't copy visibility. */
2157 S_SET_OTHER (dest, (ELF_ST_VISIBILITY (S_GET_OTHER (dest))
2158 | (S_GET_OTHER (src) & ~ELF_ST_VISIBILITY (-1))));
2159 }
2160
2161 void
2162 obj_elf_version (int ignore ATTRIBUTE_UNUSED)
2163 {
2164 char *name;
2165 unsigned int c;
2166 char *p;
2167 asection *seg = now_seg;
2168 subsegT subseg = now_subseg;
2169 Elf_Internal_Note i_note;
2170 Elf_External_Note e_note;
2171 asection *note_secp = NULL;
2172
2173 SKIP_WHITESPACE ();
2174 if (*input_line_pointer == '\"')
2175 {
2176 unsigned int len;
2177
2178 ++input_line_pointer; /* -> 1st char of string. */
2179 name = input_line_pointer;
2180
2181 while (is_a_char (c = next_char_of_string ()))
2182 ;
2183 c = *input_line_pointer;
2184 *input_line_pointer = '\0';
2185 *(input_line_pointer - 1) = '\0';
2186 *input_line_pointer = c;
2187
2188 /* Create the .note section. */
2189 note_secp = subseg_new (".note", 0);
2190 bfd_set_section_flags (note_secp, SEC_HAS_CONTENTS | SEC_READONLY);
2191 record_alignment (note_secp, 2);
2192
2193 /* Process the version string. */
2194 len = strlen (name) + 1;
2195
2196 /* PR 3456: Although the name field is padded out to an 4-byte
2197 boundary, the namesz field should not be adjusted. */
2198 i_note.namesz = len;
2199 i_note.descsz = 0; /* No description. */
2200 i_note.type = NT_VERSION;
2201 p = frag_more (sizeof (e_note.namesz));
2202 md_number_to_chars (p, i_note.namesz, sizeof (e_note.namesz));
2203 p = frag_more (sizeof (e_note.descsz));
2204 md_number_to_chars (p, i_note.descsz, sizeof (e_note.descsz));
2205 p = frag_more (sizeof (e_note.type));
2206 md_number_to_chars (p, i_note.type, sizeof (e_note.type));
2207 p = frag_more (len);
2208 memcpy (p, name, len);
2209
2210 frag_align (2, 0, 0);
2211
2212 subseg_set (seg, subseg);
2213 }
2214 else
2215 as_bad (_("expected quoted string"));
2216
2217 demand_empty_rest_of_line ();
2218 }
2219
2220 static void
2221 obj_elf_size (int ignore ATTRIBUTE_UNUSED)
2222 {
2223 char *name;
2224 char c = get_symbol_name (&name);
2225 char *p;
2226 expressionS exp;
2227 symbolS *sym;
2228
2229 p = input_line_pointer;
2230 *p = c;
2231 SKIP_WHITESPACE_AFTER_NAME ();
2232 if (*input_line_pointer != ',')
2233 {
2234 *p = 0;
2235 as_bad (_("expected comma after name `%s' in .size directive"), name);
2236 *p = c;
2237 ignore_rest_of_line ();
2238 return;
2239 }
2240 input_line_pointer++;
2241 expression (&exp);
2242 if (exp.X_op == O_absent)
2243 {
2244 as_bad (_("missing expression in .size directive"));
2245 exp.X_op = O_constant;
2246 exp.X_add_number = 0;
2247 }
2248 *p = 0;
2249 sym = symbol_find_or_make (name);
2250 *p = c;
2251 if (exp.X_op == O_constant)
2252 {
2253 S_SET_SIZE (sym, exp.X_add_number);
2254 xfree (symbol_get_obj (sym)->size);
2255 symbol_get_obj (sym)->size = NULL;
2256 }
2257 else
2258 {
2259 symbol_get_obj (sym)->size = XNEW (expressionS);
2260 *symbol_get_obj (sym)->size = exp;
2261 }
2262 demand_empty_rest_of_line ();
2263 }
2264
2265 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
2266 There are six syntaxes:
2267
2268 The first (used on Solaris) is
2269 .type SYM,#function
2270 The second (used on UnixWare) is
2271 .type SYM,@function
2272 The third (reportedly to be used on Irix 6.0) is
2273 .type SYM STT_FUNC
2274 The fourth (used on NetBSD/Arm and Linux/ARM) is
2275 .type SYM,%function
2276 The fifth (used on SVR4/860) is
2277 .type SYM,"function"
2278 The sixth (emitted by recent SunPRO under Solaris) is
2279 .type SYM,[0-9]
2280 where the integer is the STT_* value.
2281 */
2282
2283 static char *
2284 obj_elf_type_name (char *cp)
2285 {
2286 char *p;
2287
2288 p = input_line_pointer;
2289 if (*input_line_pointer >= '0'
2290 && *input_line_pointer <= '9')
2291 {
2292 while (*input_line_pointer >= '0'
2293 && *input_line_pointer <= '9')
2294 ++input_line_pointer;
2295 *cp = *input_line_pointer;
2296 *input_line_pointer = '\0';
2297 }
2298 else
2299 *cp = get_symbol_name (&p);
2300
2301 return p;
2302 }
2303
2304 static void
2305 obj_elf_type (int ignore ATTRIBUTE_UNUSED)
2306 {
2307 char c;
2308 int type;
2309 const char *type_name;
2310 symbolS *sym;
2311 elf_symbol_type *elfsym;
2312
2313 sym = get_sym_from_input_line_and_check ();
2314 c = *input_line_pointer;
2315 elfsym = (elf_symbol_type *) symbol_get_bfdsym (sym);
2316
2317 if (*input_line_pointer == ',')
2318 ++input_line_pointer;
2319
2320 SKIP_WHITESPACE ();
2321 if ( *input_line_pointer == '#'
2322 || *input_line_pointer == '@'
2323 || *input_line_pointer == '"'
2324 || *input_line_pointer == '%')
2325 ++input_line_pointer;
2326
2327 type_name = obj_elf_type_name (& c);
2328
2329 type = 0;
2330 if (strcmp (type_name, "function") == 0
2331 || strcmp (type_name, "2") == 0
2332 || strcmp (type_name, "STT_FUNC") == 0)
2333 type = BSF_FUNCTION;
2334 else if (strcmp (type_name, "object") == 0
2335 || strcmp (type_name, "1") == 0
2336 || strcmp (type_name, "STT_OBJECT") == 0)
2337 type = BSF_OBJECT;
2338 else if (strcmp (type_name, "tls_object") == 0
2339 || strcmp (type_name, "6") == 0
2340 || strcmp (type_name, "STT_TLS") == 0)
2341 type = BSF_OBJECT | BSF_THREAD_LOCAL;
2342 else if (strcmp (type_name, "notype") == 0
2343 || strcmp (type_name, "0") == 0
2344 || strcmp (type_name, "STT_NOTYPE") == 0)
2345 ;
2346 else if (strcmp (type_name, "common") == 0
2347 || strcmp (type_name, "5") == 0
2348 || strcmp (type_name, "STT_COMMON") == 0)
2349 {
2350 type = BSF_OBJECT;
2351
2352 if (! S_IS_COMMON (sym))
2353 {
2354 if (S_IS_VOLATILE (sym))
2355 {
2356 sym = symbol_clone (sym, 1);
2357 S_SET_SEGMENT (sym, bfd_com_section_ptr);
2358 S_SET_VALUE (sym, 0);
2359 S_SET_EXTERNAL (sym);
2360 symbol_set_frag (sym, &zero_address_frag);
2361 S_CLEAR_VOLATILE (sym);
2362 }
2363 else if (S_IS_DEFINED (sym) || symbol_equated_p (sym))
2364 as_bad (_("symbol '%s' is already defined"), S_GET_NAME (sym));
2365 else
2366 {
2367 /* FIXME: Is it safe to just change the section ? */
2368 S_SET_SEGMENT (sym, bfd_com_section_ptr);
2369 S_SET_VALUE (sym, 0);
2370 S_SET_EXTERNAL (sym);
2371 }
2372 }
2373 }
2374 else if (strcmp (type_name, "gnu_indirect_function") == 0
2375 || strcmp (type_name, "10") == 0
2376 || strcmp (type_name, "STT_GNU_IFUNC") == 0)
2377 {
2378 const struct elf_backend_data *bed;
2379
2380 bed = get_elf_backend_data (stdoutput);
2381 if (bed->elf_osabi != ELFOSABI_NONE
2382 && bed->elf_osabi != ELFOSABI_GNU
2383 && bed->elf_osabi != ELFOSABI_FREEBSD)
2384 as_bad (_("symbol type \"%s\" is supported only by GNU "
2385 "and FreeBSD targets"), type_name);
2386 /* MIPS targets do not support IFUNCS. */
2387 else if (bed->target_id == MIPS_ELF_DATA)
2388 as_bad (_("symbol type \"%s\" is not supported by "
2389 "MIPS targets"), type_name);
2390 elf_tdata (stdoutput)->has_gnu_osabi |= elf_gnu_osabi_ifunc;
2391 type = BSF_FUNCTION | BSF_GNU_INDIRECT_FUNCTION;
2392 }
2393 else if (strcmp (type_name, "gnu_unique_object") == 0)
2394 {
2395 const struct elf_backend_data *bed;
2396
2397 bed = get_elf_backend_data (stdoutput);
2398 if (bed->elf_osabi != ELFOSABI_NONE
2399 && bed->elf_osabi != ELFOSABI_GNU)
2400 as_bad (_("symbol type \"%s\" is supported only by GNU targets"),
2401 type_name);
2402 elf_tdata (stdoutput)->has_gnu_osabi |= elf_gnu_osabi_unique;
2403 type = BSF_OBJECT | BSF_GNU_UNIQUE;
2404 }
2405 #ifdef md_elf_symbol_type
2406 else if ((type = md_elf_symbol_type (type_name, sym, elfsym)) != -1)
2407 ;
2408 #endif
2409 else
2410 as_bad (_("unrecognized symbol type \"%s\""), type_name);
2411
2412 *input_line_pointer = c;
2413
2414 if (*input_line_pointer == '"')
2415 ++input_line_pointer;
2416
2417 #ifdef md_elf_symbol_type_change
2418 if (!md_elf_symbol_type_change (sym, elfsym, type))
2419 #endif
2420 {
2421 flagword mask = BSF_FUNCTION | BSF_OBJECT;
2422
2423 if (type != BSF_FUNCTION)
2424 mask |= BSF_GNU_INDIRECT_FUNCTION;
2425 if (type != BSF_OBJECT)
2426 {
2427 mask |= BSF_GNU_UNIQUE | BSF_THREAD_LOCAL;
2428
2429 if (S_IS_COMMON (sym))
2430 {
2431 as_bad (_("cannot change type of common symbol '%s'"),
2432 S_GET_NAME (sym));
2433 mask = type = 0;
2434 }
2435 }
2436
2437 /* Don't warn when changing to STT_NOTYPE. */
2438 if (type)
2439 {
2440 flagword new = (elfsym->symbol.flags & ~mask) | type;
2441
2442 if (new != (elfsym->symbol.flags | type))
2443 as_warn (_("symbol '%s' already has its type set"), S_GET_NAME (sym));
2444 elfsym->symbol.flags = new;
2445 }
2446 else
2447 elfsym->symbol.flags &= ~mask;
2448 }
2449
2450 demand_empty_rest_of_line ();
2451 }
2452
2453 static segT comment_section;
2454
2455 static void
2456 obj_elf_ident (int ignore ATTRIBUTE_UNUSED)
2457 {
2458 segT old_section = now_seg;
2459 int old_subsection = now_subseg;
2460
2461 #ifdef md_flush_pending_output
2462 md_flush_pending_output ();
2463 #endif
2464
2465 if (!comment_section)
2466 {
2467 char *p;
2468 comment_section = subseg_new (".comment", 0);
2469 bfd_set_section_flags (comment_section, (SEC_READONLY | SEC_HAS_CONTENTS
2470 | SEC_MERGE | SEC_STRINGS));
2471 comment_section->entsize = 1;
2472 #ifdef md_elf_section_change_hook
2473 md_elf_section_change_hook ();
2474 #endif
2475 p = frag_more (1);
2476 *p = 0;
2477 }
2478 else
2479 subseg_set (comment_section, 0);
2480 stringer (8 + 1);
2481 subseg_set (old_section, old_subsection);
2482 }
2483
2484 #ifdef INIT_STAB_SECTION
2485
2486 /* The first entry in a .stabs section is special. */
2487
2488 void
2489 obj_elf_init_stab_section (segT seg)
2490 {
2491 char *file;
2492 char *p;
2493 char *stabstr_name;
2494 unsigned int stroff;
2495
2496 /* Force the section to align to a longword boundary. Without this,
2497 UnixWare ar crashes. */
2498 bfd_set_section_alignment (seg, 2);
2499
2500 /* Make space for this first symbol. */
2501 p = frag_more (12);
2502 /* Zero it out. */
2503 memset (p, 0, 12);
2504 file = remap_debug_filename (as_where (NULL));
2505 stabstr_name = concat (segment_name (seg), "str", (char *) NULL);
2506 stroff = get_stab_string_offset (file, stabstr_name, true);
2507 know (stroff == 1 || (stroff == 0 && file[0] == '\0'));
2508 md_number_to_chars (p, stroff, 4);
2509 seg_info (seg)->stabu.p = p;
2510 free (file);
2511 }
2512
2513 #endif
2514
2515 /* Fill in the counts in the first entry in a .stabs section. */
2516
2517 static void
2518 adjust_stab_sections (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
2519 {
2520 char *name;
2521 asection *strsec;
2522 char *p;
2523 int strsz, nsyms;
2524
2525 if (!startswith (sec->name, ".stab"))
2526 return;
2527 if (!strcmp ("str", sec->name + strlen (sec->name) - 3))
2528 return;
2529
2530 name = concat (sec->name, "str", NULL);
2531 strsec = bfd_get_section_by_name (abfd, name);
2532 if (strsec)
2533 strsz = bfd_section_size (strsec);
2534 else
2535 strsz = 0;
2536 nsyms = bfd_section_size (sec) / 12 - 1;
2537
2538 p = seg_info (sec)->stabu.p;
2539 gas_assert (p != 0);
2540
2541 bfd_h_put_16 (abfd, nsyms, p + 6);
2542 bfd_h_put_32 (abfd, strsz, p + 8);
2543 free (name);
2544 }
2545
2546 #ifdef NEED_ECOFF_DEBUG
2547
2548 /* This function is called by the ECOFF code. It is supposed to
2549 record the external symbol information so that the backend can
2550 write it out correctly. The ELF backend doesn't actually handle
2551 this at the moment, so we do it ourselves. We save the information
2552 in the symbol. */
2553
2554 #ifdef OBJ_MAYBE_ELF
2555 static
2556 #endif
2557 void
2558 elf_ecoff_set_ext (symbolS *sym, struct ecoff_extr *ext)
2559 {
2560 symbol_get_bfdsym (sym)->udata.p = ext;
2561 }
2562
2563 /* This function is called by bfd_ecoff_debug_externals. It is
2564 supposed to *EXT to the external symbol information, and return
2565 whether the symbol should be used at all. */
2566
2567 static bool
2568 elf_get_extr (asymbol *sym, EXTR *ext)
2569 {
2570 if (sym->udata.p == NULL)
2571 return false;
2572 *ext = *(EXTR *) sym->udata.p;
2573 return true;
2574 }
2575
2576 /* This function is called by bfd_ecoff_debug_externals. It has
2577 nothing to do for ELF. */
2578
2579 static void
2580 elf_set_index (asymbol *sym ATTRIBUTE_UNUSED,
2581 bfd_size_type indx ATTRIBUTE_UNUSED)
2582 {
2583 }
2584
2585 #endif /* NEED_ECOFF_DEBUG */
2586
2587 void
2588 elf_frob_symbol (symbolS *symp, int *puntp)
2589 {
2590 struct elf_obj_sy *sy_obj;
2591 expressionS *size;
2592 struct elf_versioned_name_list *versioned_name;
2593
2594 #ifdef NEED_ECOFF_DEBUG
2595 if (ECOFF_DEBUGGING)
2596 ecoff_frob_symbol (symp);
2597 #endif
2598
2599 sy_obj = symbol_get_obj (symp);
2600
2601 size = sy_obj->size;
2602 if (size != NULL)
2603 {
2604 if (resolve_expression (size)
2605 && size->X_op == O_constant)
2606 S_SET_SIZE (symp, size->X_add_number);
2607 else
2608 {
2609 if (!flag_allow_nonconst_size)
2610 as_bad (_(".size expression for %s "
2611 "does not evaluate to a constant"), S_GET_NAME (symp));
2612 else
2613 as_warn (_(".size expression for %s "
2614 "does not evaluate to a constant"), S_GET_NAME (symp));
2615 }
2616 free (sy_obj->size);
2617 sy_obj->size = NULL;
2618 }
2619
2620 versioned_name = sy_obj->versioned_name;
2621 if (versioned_name)
2622 {
2623 /* This symbol was given a new name with the .symver directive.
2624 If this is an external reference, just rename the symbol to
2625 include the version string. This will make the relocs be
2626 against the correct versioned symbol. */
2627
2628 /* We will have already reported an version error. */
2629 if (sy_obj->bad_version)
2630 *puntp = true;
2631 /* elf_frob_file_before_adjust only allows one version symbol for
2632 renamed symbol. */
2633 else if (sy_obj->rename)
2634 S_SET_NAME (symp, versioned_name->name);
2635 else if (S_IS_COMMON (symp))
2636 {
2637 as_bad (_("`%s' can't be versioned to common symbol '%s'"),
2638 versioned_name->name, S_GET_NAME (symp));
2639 *puntp = true;
2640 }
2641 else
2642 {
2643 asymbol *bfdsym;
2644 elf_symbol_type *elfsym;
2645
2646 /* This is a definition. Add an alias for each version.
2647 FIXME: Using an alias will permit the debugging information
2648 to refer to the right symbol. However, it's not clear
2649 whether it is the best approach. */
2650
2651 /* FIXME: Creating a new symbol here is risky. We're
2652 in the final loop over the symbol table. We can
2653 get away with it only because the symbol goes to
2654 the end of the list, where the loop will still see
2655 it. It would probably be better to do this in
2656 obj_frob_file_before_adjust. */
2657 for (; versioned_name != NULL;
2658 versioned_name = versioned_name->next)
2659 {
2660 symbolS *symp2 = symbol_find_or_make (versioned_name->name);
2661
2662 S_SET_SEGMENT (symp2, S_GET_SEGMENT (symp));
2663
2664 /* Subtracting out the frag address here is a hack
2665 because we are in the middle of the final loop. */
2666 S_SET_VALUE (symp2,
2667 (S_GET_VALUE (symp)
2668 - (symbol_get_frag (symp)->fr_address
2669 / OCTETS_PER_BYTE)));
2670
2671 symbol_set_frag (symp2, symbol_get_frag (symp));
2672
2673 /* This will copy over the size information. */
2674 copy_symbol_attributes (symp2, symp);
2675
2676 S_SET_OTHER (symp2, S_GET_OTHER (symp));
2677
2678 if (S_IS_WEAK (symp))
2679 S_SET_WEAK (symp2);
2680
2681 if (S_IS_EXTERNAL (symp))
2682 S_SET_EXTERNAL (symp2);
2683 }
2684
2685 switch (sy_obj->visibility)
2686 {
2687 case visibility_unchanged:
2688 break;
2689 case visibility_hidden:
2690 bfdsym = symbol_get_bfdsym (symp);
2691 elfsym = elf_symbol_from (bfdsym);
2692 elfsym->internal_elf_sym.st_other &= ~3;
2693 elfsym->internal_elf_sym.st_other |= STV_HIDDEN;
2694 break;
2695 case visibility_remove:
2696 /* Don't remove the symbol if it is used in relocation.
2697 Instead, mark it as to be removed and issue an error
2698 if the symbol has more than one versioned name. */
2699 if (symbol_used_in_reloc_p (symp))
2700 {
2701 if (sy_obj->versioned_name->next != NULL)
2702 as_bad (_("symbol '%s' with multiple versions cannot be used in relocation"),
2703 S_GET_NAME (symp));
2704 symbol_mark_removed (symp);
2705 }
2706 else
2707 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2708 break;
2709 case visibility_local:
2710 S_CLEAR_EXTERNAL (symp);
2711 break;
2712 }
2713 }
2714 }
2715
2716 /* Double check weak symbols. */
2717 if (S_IS_WEAK (symp))
2718 {
2719 if (S_IS_COMMON (symp))
2720 as_bad (_("symbol `%s' can not be both weak and common"),
2721 S_GET_NAME (symp));
2722 }
2723 }
2724
2725 /* Fix up SYMPP which has been marked to be removed by .symver. */
2726
2727 void
2728 elf_fixup_removed_symbol (symbolS **sympp)
2729 {
2730 symbolS *symp = *sympp;
2731 struct elf_obj_sy *sy_obj = symbol_get_obj (symp);
2732
2733 /* Replace the removed symbol with the versioned symbol. */
2734 symp = symbol_find (sy_obj->versioned_name->name);
2735 *sympp = symp;
2736 }
2737
2738 struct group_list
2739 {
2740 asection **head; /* Section lists. */
2741 unsigned int num_group; /* Number of lists. */
2742 htab_t indexes; /* Maps group name to index in head array. */
2743 };
2744
2745 static struct group_list groups;
2746
2747 /* Called via bfd_map_over_sections. If SEC is a member of a group,
2748 add it to a list of sections belonging to the group. INF is a
2749 pointer to a struct group_list, which is where we store the head of
2750 each list. If its link_to_symbol_name isn't NULL, set up its
2751 linked-to section. */
2752
2753 static void
2754 build_additional_section_info (bfd *abfd ATTRIBUTE_UNUSED,
2755 asection *sec, void *inf)
2756 {
2757 struct group_list *list = (struct group_list *) inf;
2758 const char *group_name = elf_group_name (sec);
2759 unsigned int i;
2760 unsigned int *elem_idx;
2761 unsigned int *idx_ptr;
2762
2763 if (sec->map_head.linked_to_symbol_name)
2764 {
2765 symbolS *linked_to_sym;
2766 linked_to_sym = symbol_find (sec->map_head.linked_to_symbol_name);
2767 if (!linked_to_sym || !S_IS_DEFINED (linked_to_sym))
2768 as_bad (_("undefined linked-to symbol `%s' on section `%s'"),
2769 sec->map_head.linked_to_symbol_name,
2770 bfd_section_name (sec));
2771 else
2772 elf_linked_to_section (sec) = S_GET_SEGMENT (linked_to_sym);
2773 }
2774
2775 if (group_name == NULL)
2776 return;
2777
2778 /* If this group already has a list, add the section to the head of
2779 the list. */
2780 elem_idx = (unsigned int *) str_hash_find (list->indexes, group_name);
2781 if (elem_idx != NULL)
2782 {
2783 elf_next_in_group (sec) = list->head[*elem_idx];
2784 list->head[*elem_idx] = sec;
2785 return;
2786 }
2787
2788 /* New group. Make the arrays bigger in chunks to minimize calls to
2789 realloc. */
2790 i = list->num_group;
2791 if ((i & 127) == 0)
2792 {
2793 unsigned int newsize = i + 128;
2794 list->head = XRESIZEVEC (asection *, list->head, newsize);
2795 }
2796 list->head[i] = sec;
2797 list->num_group += 1;
2798
2799 /* Add index to hash. */
2800 idx_ptr = XNEW (unsigned int);
2801 *idx_ptr = i;
2802 str_hash_insert (list->indexes, group_name, idx_ptr, 0);
2803 }
2804
2805 static void
2806 free_section_idx (void *ent)
2807 {
2808 string_tuple_t *tuple = ent;
2809 free ((char *) tuple->value);
2810 }
2811
2812 /* Create symbols for group signature. */
2813
2814 void
2815 elf_adjust_symtab (void)
2816 {
2817 unsigned int i;
2818
2819 /* Go find section groups. */
2820 groups.num_group = 0;
2821 groups.head = NULL;
2822 groups.indexes = htab_create_alloc (16, hash_string_tuple, eq_string_tuple,
2823 free_section_idx, notes_calloc, NULL);
2824 bfd_map_over_sections (stdoutput, build_additional_section_info,
2825 &groups);
2826
2827 /* Make the SHT_GROUP sections that describe each section group. We
2828 can't set up the section contents here yet, because elf section
2829 indices have yet to be calculated. elf.c:set_group_contents does
2830 the rest of the work. */
2831 for (i = 0; i < groups.num_group; i++)
2832 {
2833 const char *group_name = elf_group_name (groups.head[i]);
2834 const char *sec_name;
2835 asection *s;
2836 flagword flags;
2837 struct symbol *sy;
2838
2839 flags = SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_GROUP;
2840 for (s = groups.head[i]; s != NULL; s = elf_next_in_group (s))
2841 if ((s->flags ^ flags) & SEC_LINK_ONCE)
2842 {
2843 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2844 if (s != groups.head[i])
2845 {
2846 as_warn (_("assuming all members of group `%s' are COMDAT"),
2847 group_name);
2848 break;
2849 }
2850 }
2851
2852 sec_name = ".group";
2853 s = subseg_force_new (sec_name, 0);
2854 if (s == NULL
2855 || !bfd_set_section_flags (s, flags)
2856 || !bfd_set_section_alignment (s, 2))
2857 {
2858 as_fatal (_("can't create group: %s"),
2859 bfd_errmsg (bfd_get_error ()));
2860 }
2861 elf_section_type (s) = SHT_GROUP;
2862
2863 /* Pass a pointer to the first section in this group. */
2864 elf_next_in_group (s) = groups.head[i];
2865 elf_sec_group (groups.head[i]) = s;
2866 /* Make sure that the signature symbol for the group has the
2867 name of the group. */
2868 sy = symbol_find_exact (group_name);
2869 if (!sy || !symbol_on_chain (sy, symbol_rootP, symbol_lastP))
2870 {
2871 /* Create the symbol now. */
2872 sy = symbol_new (group_name, now_seg, frag_now, 0);
2873 #ifdef TE_SOLARIS
2874 /* Before Solaris 11 build 154, Sun ld rejects local group
2875 signature symbols, so make them weak hidden instead. */
2876 symbol_get_bfdsym (sy)->flags |= BSF_WEAK;
2877 S_SET_OTHER (sy, STV_HIDDEN);
2878 #else
2879 symbol_get_obj (sy)->local = 1;
2880 #endif
2881 symbol_table_insert (sy);
2882 }
2883 elf_group_id (s) = symbol_get_bfdsym (sy);
2884 /* Mark the group signature symbol as used so that it will be
2885 included in the symbol table. */
2886 symbol_mark_used_in_reloc (sy);
2887 }
2888 }
2889
2890 void
2891 elf_frob_file (void)
2892 {
2893 bfd_map_over_sections (stdoutput, adjust_stab_sections, NULL);
2894
2895 #ifdef elf_tc_final_processing
2896 elf_tc_final_processing ();
2897 #endif
2898 }
2899
2900 /* It removes any unneeded versioned symbols from the symbol table. */
2901
2902 void
2903 elf_frob_file_before_adjust (void)
2904 {
2905 if (symbol_rootP)
2906 {
2907 symbolS *symp;
2908
2909 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2910 {
2911 struct elf_obj_sy *sy_obj = symbol_get_obj (symp);
2912 int is_defined = !!S_IS_DEFINED (symp);
2913
2914 if (sy_obj->versioned_name)
2915 {
2916 char *p = strchr (sy_obj->versioned_name->name,
2917 ELF_VER_CHR);
2918
2919 if (sy_obj->rename)
2920 {
2921 /* The @@@ syntax is a special case. If the symbol is
2922 not defined, 2 `@'s will be removed from the
2923 versioned_name. Otherwise, 1 `@' will be removed. */
2924 size_t l = strlen (&p[3]) + 1;
2925 memmove (&p[1 + is_defined], &p[3], l);
2926 }
2927
2928 if (!is_defined)
2929 {
2930 /* Verify that the name isn't using the @@ syntax--this
2931 is reserved for definitions of the default version
2932 to link against. */
2933 if (!sy_obj->rename && p[1] == ELF_VER_CHR)
2934 {
2935 as_bad (_("invalid attempt to declare external "
2936 "version name as default in symbol `%s'"),
2937 sy_obj->versioned_name->name);
2938 return;
2939 }
2940
2941 /* Only one version symbol is allowed for undefined
2942 symbol. */
2943 if (sy_obj->versioned_name->next)
2944 {
2945 as_bad (_("multiple versions [`%s'|`%s'] for "
2946 "symbol `%s'"),
2947 sy_obj->versioned_name->name,
2948 sy_obj->versioned_name->next->name,
2949 S_GET_NAME (symp));
2950 return;
2951 }
2952
2953 sy_obj->rename = true;
2954 }
2955 }
2956
2957 /* If there was .symver or .weak, but symbol was neither
2958 defined nor used anywhere, remove it. */
2959 if (!is_defined
2960 && (sy_obj->versioned_name || S_IS_WEAK (symp))
2961 && symbol_used_p (symp) == 0
2962 && symbol_used_in_reloc_p (symp) == 0)
2963 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2964 }
2965 }
2966 }
2967
2968 /* It is required that we let write_relocs have the opportunity to
2969 optimize away fixups before output has begun, since it is possible
2970 to eliminate all fixups for a section and thus we never should
2971 have generated the relocation section. */
2972
2973 void
2974 elf_frob_file_after_relocs (void)
2975 {
2976 unsigned int i;
2977
2978 /* Set SHT_GROUP section size. */
2979 for (i = 0; i < groups.num_group; i++)
2980 {
2981 asection *s, *head, *group;
2982 bfd_size_type size;
2983
2984 head = groups.head[i];
2985 size = 4;
2986 for (s = head; s != NULL; s = elf_next_in_group (s))
2987 size += (s->flags & SEC_RELOC) != 0 ? 8 : 4;
2988
2989 group = elf_sec_group (head);
2990 subseg_set (group, 0);
2991 bfd_set_section_size (group, size);
2992 group->contents = (unsigned char *) frag_more (size);
2993 frag_now->fr_fix = frag_now_fix_octets ();
2994 frag_wane (frag_now);
2995 }
2996
2997 #ifdef NEED_ECOFF_DEBUG
2998 if (ECOFF_DEBUGGING)
2999 /* Generate the ECOFF debugging information. */
3000 {
3001 const struct ecoff_debug_swap *debug_swap;
3002 struct ecoff_debug_info debug;
3003 char *buf;
3004 asection *sec;
3005
3006 debug_swap
3007 = get_elf_backend_data (stdoutput)->elf_backend_ecoff_debug_swap;
3008 know (debug_swap != NULL);
3009 ecoff_build_debug (&debug.symbolic_header, &buf, debug_swap);
3010
3011 /* Set up the pointers in debug. */
3012 debug.alloc_syments = true;
3013 #define SET(ptr, offset, type) \
3014 debug.ptr = (type) (buf + debug.symbolic_header.offset)
3015
3016 SET (line, cbLineOffset, unsigned char *);
3017 SET (external_dnr, cbDnOffset, void *);
3018 SET (external_pdr, cbPdOffset, void *);
3019 SET (external_sym, cbSymOffset, void *);
3020 SET (external_opt, cbOptOffset, void *);
3021 SET (external_aux, cbAuxOffset, union aux_ext *);
3022 SET (ss, cbSsOffset, char *);
3023 SET (external_fdr, cbFdOffset, void *);
3024 SET (external_rfd, cbRfdOffset, void *);
3025 /* ssext and external_ext are set up just below. */
3026
3027 #undef SET
3028
3029 /* Set up the external symbols. */
3030 debug.ssext = debug.ssext_end = NULL;
3031 debug.external_ext = debug.external_ext_end = NULL;
3032 if (! bfd_ecoff_debug_externals (stdoutput, &debug, debug_swap, true,
3033 elf_get_extr, elf_set_index))
3034 as_fatal (_("failed to set up debugging information: %s"),
3035 bfd_errmsg (bfd_get_error ()));
3036
3037 sec = bfd_get_section_by_name (stdoutput, ".mdebug");
3038 gas_assert (sec != NULL);
3039
3040 know (!stdoutput->output_has_begun);
3041
3042 /* We set the size of the section, call bfd_set_section_contents
3043 to force the ELF backend to allocate a file position, and then
3044 write out the data. FIXME: Is this really the best way to do
3045 this? */
3046 bfd_set_section_size (sec, bfd_ecoff_debug_size (stdoutput, &debug,
3047 debug_swap));
3048
3049 /* Pass BUF to bfd_set_section_contents because this will
3050 eventually become a call to fwrite, and ISO C prohibits
3051 passing a NULL pointer to a stdio function even if the
3052 pointer will not be used. */
3053 if (! bfd_set_section_contents (stdoutput, sec, buf, 0, 0))
3054 as_fatal (_("can't start writing .mdebug section: %s"),
3055 bfd_errmsg (bfd_get_error ()));
3056
3057 know (stdoutput->output_has_begun);
3058 know (sec->filepos != 0);
3059
3060 if (! bfd_ecoff_write_debug (stdoutput, &debug, debug_swap,
3061 sec->filepos))
3062 as_fatal (_("could not write .mdebug section: %s"),
3063 bfd_errmsg (bfd_get_error ()));
3064 }
3065 #endif /* NEED_ECOFF_DEBUG */
3066 }
3067
3068 static void
3069 elf_generate_asm_lineno (void)
3070 {
3071 #ifdef NEED_ECOFF_DEBUG
3072 if (ECOFF_DEBUGGING)
3073 ecoff_generate_asm_lineno ();
3074 #endif
3075 }
3076
3077 static void
3078 elf_process_stab (segT sec ATTRIBUTE_UNUSED,
3079 int what ATTRIBUTE_UNUSED,
3080 const char *string ATTRIBUTE_UNUSED,
3081 int type ATTRIBUTE_UNUSED,
3082 int other ATTRIBUTE_UNUSED,
3083 int desc ATTRIBUTE_UNUSED)
3084 {
3085 #ifdef NEED_ECOFF_DEBUG
3086 if (ECOFF_DEBUGGING)
3087 ecoff_stab (sec, what, string, type, other, desc);
3088 #endif
3089 }
3090
3091 static int
3092 elf_separate_stab_sections (void)
3093 {
3094 #ifdef NEED_ECOFF_DEBUG
3095 return (!ECOFF_DEBUGGING);
3096 #else
3097 return 1;
3098 #endif
3099 }
3100
3101 static void
3102 elf_init_stab_section (segT seg)
3103 {
3104 #ifdef NEED_ECOFF_DEBUG
3105 if (!ECOFF_DEBUGGING)
3106 #endif
3107 obj_elf_init_stab_section (seg);
3108 }
3109
3110 /* This is called when the assembler starts. */
3111
3112 void
3113 elf_begin (void)
3114 {
3115 asection *s;
3116
3117 /* Add symbols for the known sections to the symbol table. */
3118 s = bfd_get_section_by_name (stdoutput, TEXT_SECTION_NAME);
3119 symbol_table_insert (section_symbol (s));
3120 s = bfd_get_section_by_name (stdoutput, DATA_SECTION_NAME);
3121 symbol_table_insert (section_symbol (s));
3122 s = bfd_get_section_by_name (stdoutput, BSS_SECTION_NAME);
3123 symbol_table_insert (section_symbol (s));
3124 elf_com_section_ptr = bfd_com_section_ptr;
3125 previous_section = NULL;
3126 previous_subsection = 0;
3127 comment_section = NULL;
3128 memset (&groups, 0, sizeof (groups));
3129 }
3130
3131 void
3132 elf_end (void)
3133 {
3134 while (section_stack)
3135 {
3136 struct section_stack *top = section_stack;
3137 section_stack = top->next;
3138 free (top);
3139 }
3140 while (recorded_attributes)
3141 {
3142 struct recorded_attribute_info *rai = recorded_attributes;
3143 recorded_attributes = rai->next;
3144 free (rai);
3145 }
3146 if (groups.indexes)
3147 {
3148 htab_delete (groups.indexes);
3149 free (groups.head);
3150 }
3151 }
3152
3153 const struct format_ops elf_format_ops =
3154 {
3155 bfd_target_elf_flavour,
3156 0, /* dfl_leading_underscore */
3157 1, /* emit_section_symbols */
3158 elf_begin,
3159 elf_end,
3160 elf_file_symbol,
3161 elf_frob_symbol,
3162 elf_frob_file,
3163 elf_frob_file_before_adjust,
3164 0, /* obj_frob_file_before_fix */
3165 elf_frob_file_after_relocs,
3166 elf_s_get_size, elf_s_set_size,
3167 elf_s_get_align, elf_s_set_align,
3168 elf_s_get_other,
3169 elf_s_set_other,
3170 0, /* s_get_desc */
3171 0, /* s_set_desc */
3172 0, /* s_get_type */
3173 0, /* s_set_type */
3174 elf_copy_symbol_attributes,
3175 elf_generate_asm_lineno,
3176 elf_process_stab,
3177 elf_separate_stab_sections,
3178 elf_init_stab_section,
3179 elf_sec_sym_ok_for_reloc,
3180 elf_pop_insert,
3181 #ifdef NEED_ECOFF_DEBUG
3182 elf_ecoff_set_ext,
3183 #else
3184 0, /* ecoff_set_ext */
3185 #endif
3186 elf_obj_read_begin_hook,
3187 elf_obj_symbol_new_hook,
3188 elf_obj_symbol_clone_hook,
3189 elf_adjust_symtab
3190 };