1 /* ELF object file format
2 Copyright (C) 1992-2014 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 "struc-symbol.h"
27 #include "dwarf2dbg.h"
28
29 #ifndef ECOFF_DEBUGGING
30 #define ECOFF_DEBUGGING 0
31 #else
32 #define NEED_ECOFF_DEBUG
33 #endif
34
35 #ifdef NEED_ECOFF_DEBUG
36 #include "ecoff.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_I370
52 #include "elf/i370.h"
53 #endif
54
55 #ifdef TC_I386
56 #include "elf/x86-64.h"
57 #endif
58
59 #ifdef TC_MEP
60 #include "elf/mep.h"
61 #endif
62
63 #ifdef TC_NIOS2
64 #include "elf/nios2.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
82 static const pseudo_typeS elf_pseudo_table[] =
83 {
84 {"comm", obj_elf_common, 0},
85 {"common", obj_elf_common, 1},
86 {"ident", obj_elf_ident, 0},
87 {"lcomm", obj_elf_lcomm, 0},
88 {"local", obj_elf_local, 0},
89 {"previous", obj_elf_previous, 0},
90 {"section", obj_elf_section, 0},
91 {"section.s", obj_elf_section, 0},
92 {"sect", obj_elf_section, 0},
93 {"sect.s", obj_elf_section, 0},
94 {"pushsection", obj_elf_section, 1},
95 {"popsection", obj_elf_popsection, 0},
96 {"size", obj_elf_size, 0},
97 {"type", obj_elf_type, 0},
98 {"version", obj_elf_version, 0},
99 {"weak", obj_elf_weak, 0},
100
101 /* These define symbol visibility. */
102 {"internal", obj_elf_visibility, STV_INTERNAL},
103 {"hidden", obj_elf_visibility, STV_HIDDEN},
104 {"protected", obj_elf_visibility, STV_PROTECTED},
105
106 /* These are used for stabs-in-elf configurations. */
107 {"line", obj_elf_line, 0},
108
109 /* This is a GNU extension to handle symbol versions. */
110 {"symver", obj_elf_symver, 0},
111
112 /* A GNU extension to change subsection only. */
113 {"subsection", obj_elf_subsection, 0},
114
115 /* These are GNU extensions to aid in garbage collecting C++ vtables. */
116 {"vtable_inherit", (void (*) (int)) &obj_elf_vtable_inherit, 0},
117 {"vtable_entry", (void (*) (int)) &obj_elf_vtable_entry, 0},
118
119 /* A GNU extension for object attributes. */
120 {"gnu_attribute", obj_elf_gnu_attribute, 0},
121
122 /* These are used for dwarf. */
123 {"2byte", cons, 2},
124 {"4byte", cons, 4},
125 {"8byte", cons, 8},
126 /* These are used for dwarf2. */
127 { "file", (void (*) (int)) dwarf2_directive_file, 0 },
128 { "loc", dwarf2_directive_loc, 0 },
129 { "loc_mark_labels", dwarf2_directive_loc_mark_labels, 0 },
130 { "lloc", dwarf2_directive_loc, 1 },
131 { "subprog", dwarf2_directive_subprog, 0 },
132
133 /* We need to trap the section changing calls to handle .previous. */
134 {"data", obj_elf_data, 0},
135 {"offset", obj_elf_struct, 0},
136 {"struct", obj_elf_struct, 0},
137 {"text", obj_elf_text, 0},
138
139 {"tls_common", obj_elf_tls_common, 0},
140
141 /* End sentinel. */
142 {NULL, NULL, 0},
143 };
144
145 static const pseudo_typeS ecoff_debug_pseudo_table[] =
146 {
147 #ifdef NEED_ECOFF_DEBUG
148 /* COFF style debugging information for ECOFF. .ln is not used; .loc
149 is used instead. */
150 { "def", ecoff_directive_def, 0 },
151 { "dim", ecoff_directive_dim, 0 },
152 { "endef", ecoff_directive_endef, 0 },
153 { "file", ecoff_directive_file, 0 },
154 { "scl", ecoff_directive_scl, 0 },
155 { "tag", ecoff_directive_tag, 0 },
156 { "val", ecoff_directive_val, 0 },
157
158 /* COFF debugging requires pseudo-ops .size and .type, but ELF
159 already has meanings for those. We use .esize and .etype
160 instead. These are only generated by gcc anyhow. */
161 { "esize", ecoff_directive_size, 0 },
162 { "etype", ecoff_directive_type, 0 },
163
164 /* ECOFF specific debugging information. */
165 { "begin", ecoff_directive_begin, 0 },
166 { "bend", ecoff_directive_bend, 0 },
167 { "end", ecoff_directive_end, 0 },
168 { "ent", ecoff_directive_ent, 0 },
169 { "fmask", ecoff_directive_fmask, 0 },
170 { "frame", ecoff_directive_frame, 0 },
171 { "loc", ecoff_directive_loc, 0 },
172 { "mask", ecoff_directive_mask, 0 },
173
174 /* Other ECOFF directives. */
175 { "extern", ecoff_directive_extern, 0 },
176
177 /* These are used on Irix. I don't know how to implement them. */
178 { "alias", s_ignore, 0 },
179 { "bgnb", s_ignore, 0 },
180 { "endb", s_ignore, 0 },
181 { "lab", s_ignore, 0 },
182 { "noalias", s_ignore, 0 },
183 { "verstamp", s_ignore, 0 },
184 { "vreg", s_ignore, 0 },
185 #endif
186
187 {NULL, NULL, 0} /* end sentinel */
188 };
189
190 #undef NO_RELOC
191 #include "aout/aout64.h"
192
193 /* This is called when the assembler starts. */
194
195 asection *elf_com_section_ptr;
196
197 void
elf_begin(void)198 elf_begin (void)
199 {
200 asection *s;
201
202 /* Add symbols for the known sections to the symbol table. */
203 s = bfd_get_section_by_name (stdoutput, TEXT_SECTION_NAME);
204 symbol_table_insert (section_symbol (s));
205 s = bfd_get_section_by_name (stdoutput, DATA_SECTION_NAME);
206 symbol_table_insert (section_symbol (s));
207 s = bfd_get_section_by_name (stdoutput, BSS_SECTION_NAME);
208 symbol_table_insert (section_symbol (s));
209 elf_com_section_ptr = bfd_com_section_ptr;
210 }
211
212 void
elf_pop_insert(void)213 elf_pop_insert (void)
214 {
215 pop_insert (elf_pseudo_table);
216 if (ECOFF_DEBUGGING)
217 pop_insert (ecoff_debug_pseudo_table);
218 }
219
220 static bfd_vma
elf_s_get_size(symbolS * sym)221 elf_s_get_size (symbolS *sym)
222 {
223 return S_GET_SIZE (sym);
224 }
225
226 static void
elf_s_set_size(symbolS * sym,bfd_vma sz)227 elf_s_set_size (symbolS *sym, bfd_vma sz)
228 {
229 S_SET_SIZE (sym, sz);
230 }
231
232 static bfd_vma
elf_s_get_align(symbolS * sym)233 elf_s_get_align (symbolS *sym)
234 {
235 return S_GET_ALIGN (sym);
236 }
237
238 static void
elf_s_set_align(symbolS * sym,bfd_vma align)239 elf_s_set_align (symbolS *sym, bfd_vma align)
240 {
241 S_SET_ALIGN (sym, align);
242 }
243
244 int
elf_s_get_other(symbolS * sym)245 elf_s_get_other (symbolS *sym)
246 {
247 return elf_symbol (symbol_get_bfdsym (sym))->internal_elf_sym.st_other;
248 }
249
250 static void
elf_s_set_other(symbolS * sym,int other)251 elf_s_set_other (symbolS *sym, int other)
252 {
253 S_SET_OTHER (sym, other);
254 }
255
256 static int
elf_sec_sym_ok_for_reloc(asection * sec)257 elf_sec_sym_ok_for_reloc (asection *sec)
258 {
259 return obj_sec_sym_ok_for_reloc (sec);
260 }
261
262 void
elf_file_symbol(const char * s,int appfile)263 elf_file_symbol (const char *s, int appfile)
264 {
265 if (!appfile
266 || symbol_rootP == NULL
267 || symbol_rootP->bsym == NULL
268 || (symbol_rootP->bsym->flags & BSF_FILE) == 0)
269 {
270 symbolS *sym;
271 size_t name_length;
272
273 sym = symbol_new (s, absolute_section, 0, NULL);
274 symbol_set_frag (sym, &zero_address_frag);
275
276 name_length = strlen (s);
277 if (name_length > strlen (S_GET_NAME (sym)))
278 {
279 obstack_grow (¬es, s, name_length + 1);
280 S_SET_NAME (sym, (const char *) obstack_finish (¬es));
281 }
282 else
283 strcpy ((char *) S_GET_NAME (sym), s);
284
285 symbol_get_bfdsym (sym)->flags |= BSF_FILE;
286
287 if (symbol_rootP != sym)
288 {
289 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
290 symbol_insert (sym, symbol_rootP, &symbol_rootP, &symbol_lastP);
291 #ifdef DEBUG
292 verify_symbol_chain (symbol_rootP, symbol_lastP);
293 #endif
294 }
295 }
296
297 #ifdef NEED_ECOFF_DEBUG
298 ecoff_new_file (s, appfile);
299 #endif
300 }
301
302 /* Called from read.c:s_comm after we've parsed .comm symbol, size.
303 Parse a possible alignment value. */
304
305 symbolS *
elf_common_parse(int ignore ATTRIBUTE_UNUSED,symbolS * symbolP,addressT size)306 elf_common_parse (int ignore ATTRIBUTE_UNUSED, symbolS *symbolP, addressT size)
307 {
308 addressT align = 0;
309 int is_local = symbol_get_obj (symbolP)->local;
310
311 if (*input_line_pointer == ',')
312 {
313 char *save = input_line_pointer;
314
315 input_line_pointer++;
316 SKIP_WHITESPACE ();
317
318 if (*input_line_pointer == '"')
319 {
320 /* For sparc. Accept .common symbol, length, "bss" */
321 input_line_pointer++;
322 /* Some use the dot, some don't. */
323 if (*input_line_pointer == '.')
324 input_line_pointer++;
325 /* Some say data, some say bss. */
326 if (strncmp (input_line_pointer, "bss\"", 4) == 0)
327 input_line_pointer += 4;
328 else if (strncmp (input_line_pointer, "data\"", 5) == 0)
329 input_line_pointer += 5;
330 else
331 {
332 char *p = input_line_pointer;
333 char c;
334
335 while (*--p != '"')
336 ;
337 while (!is_end_of_line[(unsigned char) *input_line_pointer])
338 if (*input_line_pointer++ == '"')
339 break;
340 c = *input_line_pointer;
341 *input_line_pointer = '\0';
342 as_bad (_("bad .common segment %s"), p);
343 *input_line_pointer = c;
344 ignore_rest_of_line ();
345 return NULL;
346 }
347 /* ??? Don't ask me why these are always global. */
348 is_local = 0;
349 }
350 else
351 {
352 input_line_pointer = save;
353 align = parse_align (is_local);
354 if (align == (addressT) -1)
355 return NULL;
356 }
357 }
358
359 if (is_local)
360 {
361 bss_alloc (symbolP, size, align);
362 S_CLEAR_EXTERNAL (symbolP);
363 }
364 else
365 {
366 S_SET_VALUE (symbolP, size);
367 S_SET_ALIGN (symbolP, align);
368 S_SET_EXTERNAL (symbolP);
369 S_SET_SEGMENT (symbolP, elf_com_section_ptr);
370 }
371
372 symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
373
374 return symbolP;
375 }
376
377 void
obj_elf_common(int is_common)378 obj_elf_common (int is_common)
379 {
380 if (flag_mri && is_common)
381 s_mri_common (0);
382 else
383 s_comm_internal (0, elf_common_parse);
384 }
385
386 static void
obj_elf_tls_common(int ignore ATTRIBUTE_UNUSED)387 obj_elf_tls_common (int ignore ATTRIBUTE_UNUSED)
388 {
389 symbolS *symbolP = s_comm_internal (0, elf_common_parse);
390
391 if (symbolP)
392 symbol_get_bfdsym (symbolP)->flags |= BSF_THREAD_LOCAL;
393 }
394
395 static void
obj_elf_lcomm(int ignore ATTRIBUTE_UNUSED)396 obj_elf_lcomm (int ignore ATTRIBUTE_UNUSED)
397 {
398 symbolS *symbolP = s_comm_internal (0, s_lcomm_internal);
399
400 if (symbolP)
401 symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
402 }
403
404 static symbolS *
get_sym_from_input_line_and_check(void)405 get_sym_from_input_line_and_check (void)
406 {
407 char *name;
408 char c;
409 symbolS *sym;
410
411 name = input_line_pointer;
412 c = get_symbol_end ();
413 sym = symbol_find_or_make (name);
414 *input_line_pointer = c;
415 SKIP_WHITESPACE ();
416
417 /* There is no symbol name if input_line_pointer has not moved. */
418 if (name == input_line_pointer)
419 as_bad (_("Missing symbol name in directive"));
420 return sym;
421 }
422
423 static void
obj_elf_local(int ignore ATTRIBUTE_UNUSED)424 obj_elf_local (int ignore ATTRIBUTE_UNUSED)
425 {
426 int c;
427 symbolS *symbolP;
428
429 do
430 {
431 symbolP = get_sym_from_input_line_and_check ();
432 c = *input_line_pointer;
433 S_CLEAR_EXTERNAL (symbolP);
434 symbol_get_obj (symbolP)->local = 1;
435 if (c == ',')
436 {
437 input_line_pointer++;
438 SKIP_WHITESPACE ();
439 if (*input_line_pointer == '\n')
440 c = '\n';
441 }
442 }
443 while (c == ',');
444 demand_empty_rest_of_line ();
445 }
446
447 static void
obj_elf_weak(int ignore ATTRIBUTE_UNUSED)448 obj_elf_weak (int ignore ATTRIBUTE_UNUSED)
449 {
450 int c;
451 symbolS *symbolP;
452
453 do
454 {
455 symbolP = get_sym_from_input_line_and_check ();
456 c = *input_line_pointer;
457 S_SET_WEAK (symbolP);
458 if (c == ',')
459 {
460 input_line_pointer++;
461 SKIP_WHITESPACE ();
462 if (*input_line_pointer == '\n')
463 c = '\n';
464 }
465 }
466 while (c == ',');
467 demand_empty_rest_of_line ();
468 }
469
470 static void
obj_elf_visibility(int visibility)471 obj_elf_visibility (int visibility)
472 {
473 int c;
474 symbolS *symbolP;
475 asymbol *bfdsym;
476 elf_symbol_type *elfsym;
477
478 do
479 {
480 symbolP = get_sym_from_input_line_and_check ();
481
482 bfdsym = symbol_get_bfdsym (symbolP);
483 elfsym = elf_symbol_from (bfd_asymbol_bfd (bfdsym), bfdsym);
484
485 gas_assert (elfsym);
486
487 elfsym->internal_elf_sym.st_other &= ~3;
488 elfsym->internal_elf_sym.st_other |= visibility;
489
490 c = *input_line_pointer;
491 if (c == ',')
492 {
493 input_line_pointer ++;
494
495 SKIP_WHITESPACE ();
496
497 if (*input_line_pointer == '\n')
498 c = '\n';
499 }
500 }
501 while (c == ',');
502
503 demand_empty_rest_of_line ();
504 }
505
506 static segT previous_section;
507 static int previous_subsection;
508
509 struct section_stack
510 {
511 struct section_stack *next;
512 segT seg, prev_seg;
513 int subseg, prev_subseg;
514 };
515
516 static struct section_stack *section_stack;
517
518 static bfd_boolean
get_section(bfd * abfd ATTRIBUTE_UNUSED,asection * sec,void * inf)519 get_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
520 {
521 const char *gname = (const char *) inf;
522 const char *group_name = elf_group_name (sec);
523
524 return (group_name == gname
525 || (group_name != NULL
526 && gname != NULL
527 && strcmp (group_name, gname) == 0));
528 }
529
530 /* Handle the .section pseudo-op. This code supports two different
531 syntaxes.
532
533 The first is found on Solaris, and looks like
534 .section ".sec1",#alloc,#execinstr,#write
535 Here the names after '#' are the SHF_* flags to turn on for the
536 section. I'm not sure how it determines the SHT_* type (BFD
537 doesn't really give us control over the type, anyhow).
538
539 The second format is found on UnixWare, and probably most SVR4
540 machines, and looks like
541 .section .sec1,"a",@progbits
542 The quoted string may contain any combination of a, w, x, and
543 represents the SHF_* flags to turn on for the section. The string
544 beginning with '@' can be progbits or nobits. There should be
545 other possibilities, but I don't know what they are. In any case,
546 BFD doesn't really let us set the section type. */
547
548 void
obj_elf_change_section(const char * name,int type,bfd_vma attr,int entsize,const char * group_name,int linkonce,int push)549 obj_elf_change_section (const char *name,
550 int type,
551 bfd_vma attr,
552 int entsize,
553 const char *group_name,
554 int linkonce,
555 int push)
556 {
557 asection *old_sec;
558 segT sec;
559 flagword flags;
560 const struct elf_backend_data *bed;
561 const struct bfd_elf_special_section *ssect;
562
563 #ifdef md_flush_pending_output
564 md_flush_pending_output ();
565 #endif
566
567 /* Switch to the section, creating it if necessary. */
568 if (push)
569 {
570 struct section_stack *elt;
571 elt = (struct section_stack *) xmalloc (sizeof (struct section_stack));
572 elt->next = section_stack;
573 elt->seg = now_seg;
574 elt->prev_seg = previous_section;
575 elt->subseg = now_subseg;
576 elt->prev_subseg = previous_subsection;
577 section_stack = elt;
578 }
579 previous_section = now_seg;
580 previous_subsection = now_subseg;
581
582 old_sec = bfd_get_section_by_name_if (stdoutput, name, get_section,
583 (void *) group_name);
584 if (old_sec)
585 {
586 sec = old_sec;
587 subseg_set (sec, 0);
588 }
589 else
590 sec = subseg_force_new (name, 0);
591
592 bed = get_elf_backend_data (stdoutput);
593 ssect = (*bed->get_sec_type_attr) (stdoutput, sec);
594
595 if (ssect != NULL)
596 {
597 bfd_boolean override = FALSE;
598
599 if (type == SHT_NULL)
600 type = ssect->type;
601 else if (type != ssect->type)
602 {
603 if (old_sec == NULL
604 /* Some older versions of gcc will emit
605
606 .section .init_array,"aw",@progbits
607
608 for __attribute__ ((section (".init_array"))).
609 "@progbits" is incorrect. Also for x86-64 large bss
610 sections, some older versions of gcc will emit
611
612 .section .lbss,"aw",@progbits
613
614 "@progbits" is incorrect. */
615 #ifdef TC_I386
616 && (bed->s->arch_size != 64
617 || !(ssect->attr & SHF_X86_64_LARGE))
618 #endif
619 && ssect->type != SHT_INIT_ARRAY
620 && ssect->type != SHT_FINI_ARRAY
621 && ssect->type != SHT_PREINIT_ARRAY)
622 {
623 /* We allow to specify any type for a .note section. */
624 if (ssect->type != SHT_NOTE)
625 as_warn (_("setting incorrect section type for %s"),
626 name);
627 }
628 else
629 {
630 as_warn (_("ignoring incorrect section type for %s"),
631 name);
632 type = ssect->type;
633 }
634 }
635
636 if (old_sec == NULL && (attr & ~ssect->attr) != 0)
637 {
638 /* As a GNU extension, we permit a .note section to be
639 allocatable. If the linker sees an allocatable .note
640 section, it will create a PT_NOTE segment in the output
641 file. We also allow "x" for .note.GNU-stack. */
642 if (ssect->type == SHT_NOTE
643 && (attr == SHF_ALLOC || attr == SHF_EXECINSTR))
644 ;
645 /* Allow different SHF_MERGE and SHF_STRINGS if we have
646 something like .rodata.str. */
647 else if (ssect->suffix_length == -2
648 && name[ssect->prefix_length] == '.'
649 && (attr
650 & ~ssect->attr
651 & ~SHF_MERGE
652 & ~SHF_STRINGS) == 0)
653 ;
654 /* .interp, .strtab and .symtab can have SHF_ALLOC. */
655 else if (attr == SHF_ALLOC
656 && (strcmp (name, ".interp") == 0
657 || strcmp (name, ".strtab") == 0
658 || strcmp (name, ".symtab") == 0))
659 override = TRUE;
660 /* .note.GNU-stack can have SHF_EXECINSTR. */
661 else if (attr == SHF_EXECINSTR
662 && strcmp (name, ".note.GNU-stack") == 0)
663 override = TRUE;
664 #ifdef TC_ALPHA
665 /* A section on Alpha may have SHF_ALPHA_GPREL. */
666 else if ((attr & ~ssect->attr) == SHF_ALPHA_GPREL)
667 override = TRUE;
668 #endif
669 #ifdef TC_RX
670 else if (attr == (SHF_EXECINSTR | SHF_WRITE | SHF_ALLOC)
671 && (ssect->type == SHT_INIT_ARRAY
672 || ssect->type == SHT_FINI_ARRAY
673 || ssect->type == SHT_PREINIT_ARRAY))
674 /* RX init/fini arrays can and should have the "awx" attributes set. */
675 ;
676 #endif
677 else
678 {
679 if (group_name == NULL)
680 as_warn (_("setting incorrect section attributes for %s"),
681 name);
682 override = TRUE;
683 }
684 }
685 if (!override && old_sec == NULL)
686 attr |= ssect->attr;
687 }
688
689 /* Convert ELF type and flags to BFD flags. */
690 flags = (SEC_RELOC
691 | ((attr & SHF_WRITE) ? 0 : SEC_READONLY)
692 | ((attr & SHF_ALLOC) ? SEC_ALLOC : 0)
693 | (((attr & SHF_ALLOC) && type != SHT_NOBITS) ? SEC_LOAD : 0)
694 | ((attr & SHF_EXECINSTR) ? SEC_CODE : 0)
695 | ((attr & SHF_MERGE) ? SEC_MERGE : 0)
696 | ((attr & SHF_STRINGS) ? SEC_STRINGS : 0)
697 | ((attr & SHF_EXCLUDE) ? SEC_EXCLUDE: 0)
698 | ((attr & SHF_TLS) ? SEC_THREAD_LOCAL : 0));
699 #ifdef md_elf_section_flags
700 flags = md_elf_section_flags (flags, attr, type);
701 #endif
702
703 if (linkonce)
704 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
705
706 if (old_sec == NULL)
707 {
708 symbolS *secsym;
709
710 if (type == SHT_NULL)
711 type = bfd_elf_get_default_section_type (flags);
712 elf_section_type (sec) = type;
713 elf_section_flags (sec) = attr;
714
715 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */
716 if (type == SHT_NOBITS)
717 seg_info (sec)->bss = 1;
718
719 bfd_set_section_flags (stdoutput, sec, flags);
720 if (flags & SEC_MERGE)
721 sec->entsize = entsize;
722 elf_group_name (sec) = group_name;
723
724 /* Add a symbol for this section to the symbol table. */
725 secsym = symbol_find (name);
726 if (secsym != NULL)
727 symbol_set_bfdsym (secsym, sec->symbol);
728 else
729 symbol_table_insert (section_symbol (sec));
730 }
731 else
732 {
733 if (type != SHT_NULL
734 && (unsigned) type != elf_section_type (old_sec))
735 as_warn (_("ignoring changed section type for %s"), name);
736
737 if (attr != 0)
738 {
739 /* If section attributes are specified the second time we see a
740 particular section, then check that they are the same as we
741 saw the first time. */
742 if (((old_sec->flags ^ flags)
743 & (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
744 | SEC_EXCLUDE | SEC_SORT_ENTRIES | SEC_MERGE | SEC_STRINGS
745 | SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
746 | SEC_THREAD_LOCAL)))
747 as_warn (_("ignoring changed section attributes for %s"), name);
748 if ((flags & SEC_MERGE) && old_sec->entsize != (unsigned) entsize)
749 as_warn (_("ignoring changed section entity size for %s"), name);
750 }
751 }
752
753 #ifdef md_elf_section_change_hook
754 md_elf_section_change_hook ();
755 #endif
756 }
757
758 static bfd_vma
obj_elf_parse_section_letters(char * str,size_t len,bfd_boolean * is_clone)759 obj_elf_parse_section_letters (char *str, size_t len, bfd_boolean *is_clone)
760 {
761 bfd_vma attr = 0;
762 *is_clone = FALSE;
763
764 while (len > 0)
765 {
766 switch (*str)
767 {
768 case 'a':
769 attr |= SHF_ALLOC;
770 break;
771 case 'e':
772 attr |= SHF_EXCLUDE;
773 break;
774 case 'w':
775 attr |= SHF_WRITE;
776 break;
777 case 'x':
778 attr |= SHF_EXECINSTR;
779 break;
780 case 'M':
781 attr |= SHF_MERGE;
782 break;
783 case 'S':
784 attr |= SHF_STRINGS;
785 break;
786 case 'G':
787 attr |= SHF_GROUP;
788 break;
789 case 'T':
790 attr |= SHF_TLS;
791 break;
792 case '?':
793 *is_clone = TRUE;
794 break;
795 /* Compatibility. */
796 case 'm':
797 if (*(str - 1) == 'a')
798 {
799 attr |= SHF_MERGE;
800 if (len > 1 && str[1] == 's')
801 {
802 attr |= SHF_STRINGS;
803 str++, len--;
804 }
805 break;
806 }
807 default:
808 {
809 char *bad_msg = _("unrecognized .section attribute: want a,e,w,x,M,S,G,T");
810 #ifdef md_elf_section_letter
811 bfd_vma md_attr = md_elf_section_letter (*str, &bad_msg);
812 if (md_attr != (bfd_vma) -1)
813 attr |= md_attr;
814 else
815 #endif
816 as_fatal ("%s", bad_msg);
817 }
818 break;
819 }
820 str++, len--;
821 }
822
823 return attr;
824 }
825
826 static int
obj_elf_section_type(char * str,size_t len,bfd_boolean warn)827 obj_elf_section_type (char *str, size_t len, bfd_boolean warn)
828 {
829 if (len == 8 && strncmp (str, "progbits", 8) == 0)
830 return SHT_PROGBITS;
831 if (len == 6 && strncmp (str, "nobits", 6) == 0)
832 return SHT_NOBITS;
833 if (len == 4 && strncmp (str, "note", 4) == 0)
834 return SHT_NOTE;
835 if (len == 10 && strncmp (str, "init_array", 10) == 0)
836 return SHT_INIT_ARRAY;
837 if (len == 10 && strncmp (str, "fini_array", 10) == 0)
838 return SHT_FINI_ARRAY;
839 if (len == 13 && strncmp (str, "preinit_array", 13) == 0)
840 return SHT_PREINIT_ARRAY;
841
842 #ifdef md_elf_section_type
843 {
844 int md_type = md_elf_section_type (str, len);
845 if (md_type >= 0)
846 return md_type;
847 }
848 #endif
849
850 if (warn)
851 as_warn (_("unrecognized section type"));
852 return 0;
853 }
854
855 static bfd_vma
obj_elf_section_word(char * str,size_t len,int * type)856 obj_elf_section_word (char *str, size_t len, int *type)
857 {
858 int ret;
859
860 if (len == 5 && strncmp (str, "write", 5) == 0)
861 return SHF_WRITE;
862 if (len == 5 && strncmp (str, "alloc", 5) == 0)
863 return SHF_ALLOC;
864 if (len == 9 && strncmp (str, "execinstr", 9) == 0)
865 return SHF_EXECINSTR;
866 if (len == 7 && strncmp (str, "exclude", 7) == 0)
867 return SHF_EXCLUDE;
868 if (len == 3 && strncmp (str, "tls", 3) == 0)
869 return SHF_TLS;
870
871 #ifdef md_elf_section_word
872 {
873 bfd_vma md_attr = md_elf_section_word (str, len);
874 if (md_attr > 0)
875 return md_attr;
876 }
877 #endif
878
879 ret = obj_elf_section_type (str, len, FALSE);
880 if (ret != 0)
881 *type = ret;
882 else
883 as_warn (_("unrecognized section attribute"));
884
885 return 0;
886 }
887
888 /* Get name of section. */
889 char *
obj_elf_section_name(void)890 obj_elf_section_name (void)
891 {
892 char *name;
893
894 SKIP_WHITESPACE ();
895 if (*input_line_pointer == '"')
896 {
897 int dummy;
898
899 name = demand_copy_C_string (&dummy);
900 if (name == NULL)
901 {
902 ignore_rest_of_line ();
903 return NULL;
904 }
905 }
906 else
907 {
908 char *end = input_line_pointer;
909
910 while (0 == strchr ("\n\t,; ", *end))
911 end++;
912 if (end == input_line_pointer)
913 {
914 as_bad (_("missing name"));
915 ignore_rest_of_line ();
916 return NULL;
917 }
918
919 name = (char *) xmalloc (end - input_line_pointer + 1);
920 memcpy (name, input_line_pointer, end - input_line_pointer);
921 name[end - input_line_pointer] = '\0';
922 #ifdef tc_canonicalize_section_name
923 name = tc_canonicalize_section_name (name);
924 #endif
925 input_line_pointer = end;
926 }
927 SKIP_WHITESPACE ();
928 return name;
929 }
930
931 void
obj_elf_section(int push)932 obj_elf_section (int push)
933 {
934 char *name, *group_name, *beg;
935 int type, dummy;
936 bfd_vma attr;
937 int entsize;
938 int linkonce;
939 subsegT new_subsection = -1;
940
941 #ifndef TC_I370
942 if (flag_mri)
943 {
944 char mri_type;
945
946 #ifdef md_flush_pending_output
947 md_flush_pending_output ();
948 #endif
949
950 previous_section = now_seg;
951 previous_subsection = now_subseg;
952
953 s_mri_sect (&mri_type);
954
955 #ifdef md_elf_section_change_hook
956 md_elf_section_change_hook ();
957 #endif
958
959 return;
960 }
961 #endif /* ! defined (TC_I370) */
962
963 name = obj_elf_section_name ();
964 if (name == NULL)
965 return;
966 type = SHT_NULL;
967 attr = 0;
968 group_name = NULL;
969 entsize = 0;
970 linkonce = 0;
971
972 if (*input_line_pointer == ',')
973 {
974 /* Skip the comma. */
975 ++input_line_pointer;
976 SKIP_WHITESPACE ();
977
978 if (push && ISDIGIT (*input_line_pointer))
979 {
980 /* .pushsection has an optional subsection. */
981 new_subsection = (subsegT) get_absolute_expression ();
982
983 SKIP_WHITESPACE ();
984
985 /* Stop if we don't see a comma. */
986 if (*input_line_pointer != ',')
987 goto done;
988
989 /* Skip the comma. */
990 ++input_line_pointer;
991 SKIP_WHITESPACE ();
992 }
993
994 if (*input_line_pointer == '"')
995 {
996 bfd_boolean is_clone;
997
998 beg = demand_copy_C_string (&dummy);
999 if (beg == NULL)
1000 {
1001 ignore_rest_of_line ();
1002 return;
1003 }
1004 attr |= obj_elf_parse_section_letters (beg, strlen (beg), &is_clone);
1005
1006 SKIP_WHITESPACE ();
1007 if (*input_line_pointer == ',')
1008 {
1009 char c;
1010 char *save = input_line_pointer;
1011
1012 ++input_line_pointer;
1013 SKIP_WHITESPACE ();
1014 c = *input_line_pointer;
1015 if (c == '"')
1016 {
1017 beg = demand_copy_C_string (&dummy);
1018 if (beg == NULL)
1019 {
1020 ignore_rest_of_line ();
1021 return;
1022 }
1023 type = obj_elf_section_type (beg, strlen (beg), TRUE);
1024 }
1025 else if (c == '@' || c == '%')
1026 {
1027 beg = ++input_line_pointer;
1028 c = get_symbol_end ();
1029 *input_line_pointer = c;
1030 type = obj_elf_section_type (beg, input_line_pointer - beg, TRUE);
1031 }
1032 else
1033 input_line_pointer = save;
1034 }
1035
1036 SKIP_WHITESPACE ();
1037 if ((attr & SHF_MERGE) != 0 && *input_line_pointer == ',')
1038 {
1039 ++input_line_pointer;
1040 SKIP_WHITESPACE ();
1041 entsize = get_absolute_expression ();
1042 SKIP_WHITESPACE ();
1043 if (entsize < 0)
1044 {
1045 as_warn (_("invalid merge entity size"));
1046 attr &= ~SHF_MERGE;
1047 entsize = 0;
1048 }
1049 }
1050 else if ((attr & SHF_MERGE) != 0)
1051 {
1052 as_warn (_("entity size for SHF_MERGE not specified"));
1053 attr &= ~SHF_MERGE;
1054 }
1055
1056 if ((attr & SHF_GROUP) != 0 && is_clone)
1057 {
1058 as_warn (_("? section flag ignored with G present"));
1059 is_clone = FALSE;
1060 }
1061 if ((attr & SHF_GROUP) != 0 && *input_line_pointer == ',')
1062 {
1063 ++input_line_pointer;
1064 group_name = obj_elf_section_name ();
1065 if (group_name == NULL)
1066 attr &= ~SHF_GROUP;
1067 else if (*input_line_pointer == ',')
1068 {
1069 ++input_line_pointer;
1070 SKIP_WHITESPACE ();
1071 if (strncmp (input_line_pointer, "comdat", 6) == 0)
1072 {
1073 input_line_pointer += 6;
1074 linkonce = 1;
1075 }
1076 }
1077 else if (strncmp (name, ".gnu.linkonce", 13) == 0)
1078 linkonce = 1;
1079 }
1080 else if ((attr & SHF_GROUP) != 0)
1081 {
1082 as_warn (_("group name for SHF_GROUP not specified"));
1083 attr &= ~SHF_GROUP;
1084 }
1085
1086 if (is_clone)
1087 {
1088 const char *now_group = elf_group_name (now_seg);
1089 if (now_group != NULL)
1090 {
1091 group_name = xstrdup (now_group);
1092 linkonce = (now_seg->flags & SEC_LINK_ONCE) != 0;
1093 }
1094 }
1095 }
1096 else
1097 {
1098 do
1099 {
1100 char c;
1101
1102 SKIP_WHITESPACE ();
1103 if (*input_line_pointer != '#')
1104 {
1105 as_bad (_("character following name is not '#'"));
1106 ignore_rest_of_line ();
1107 return;
1108 }
1109 beg = ++input_line_pointer;
1110 c = get_symbol_end ();
1111 *input_line_pointer = c;
1112
1113 attr |= obj_elf_section_word (beg, input_line_pointer - beg, & type);
1114
1115 SKIP_WHITESPACE ();
1116 }
1117 while (*input_line_pointer++ == ',');
1118 --input_line_pointer;
1119 }
1120 }
1121
1122 done:
1123 demand_empty_rest_of_line ();
1124
1125 obj_elf_change_section (name, type, attr, entsize, group_name, linkonce, push);
1126
1127 if (push && new_subsection != -1)
1128 subseg_set (now_seg, new_subsection);
1129 }
1130
1131 /* Change to the .data section. */
1132
1133 void
obj_elf_data(int i)1134 obj_elf_data (int i)
1135 {
1136 #ifdef md_flush_pending_output
1137 md_flush_pending_output ();
1138 #endif
1139
1140 previous_section = now_seg;
1141 previous_subsection = now_subseg;
1142 s_data (i);
1143
1144 #ifdef md_elf_section_change_hook
1145 md_elf_section_change_hook ();
1146 #endif
1147 }
1148
1149 /* Change to the .text section. */
1150
1151 void
obj_elf_text(int i)1152 obj_elf_text (int i)
1153 {
1154 #ifdef md_flush_pending_output
1155 md_flush_pending_output ();
1156 #endif
1157
1158 previous_section = now_seg;
1159 previous_subsection = now_subseg;
1160 s_text (i);
1161
1162 #ifdef md_elf_section_change_hook
1163 md_elf_section_change_hook ();
1164 #endif
1165 }
1166
1167 /* Change to the *ABS* section. */
1168
1169 void
obj_elf_struct(int i)1170 obj_elf_struct (int i)
1171 {
1172 #ifdef md_flush_pending_output
1173 md_flush_pending_output ();
1174 #endif
1175
1176 previous_section = now_seg;
1177 previous_subsection = now_subseg;
1178 s_struct (i);
1179
1180 #ifdef md_elf_section_change_hook
1181 md_elf_section_change_hook ();
1182 #endif
1183 }
1184
1185 static void
obj_elf_subsection(int ignore ATTRIBUTE_UNUSED)1186 obj_elf_subsection (int ignore ATTRIBUTE_UNUSED)
1187 {
1188 int temp;
1189
1190 #ifdef md_flush_pending_output
1191 md_flush_pending_output ();
1192 #endif
1193
1194 previous_section = now_seg;
1195 previous_subsection = now_subseg;
1196
1197 temp = get_absolute_expression ();
1198 subseg_set (now_seg, (subsegT) temp);
1199 demand_empty_rest_of_line ();
1200
1201 #ifdef md_elf_section_change_hook
1202 md_elf_section_change_hook ();
1203 #endif
1204 }
1205
1206 /* This can be called from the processor backends if they change
1207 sections. */
1208
1209 void
obj_elf_section_change_hook(void)1210 obj_elf_section_change_hook (void)
1211 {
1212 previous_section = now_seg;
1213 previous_subsection = now_subseg;
1214 }
1215
1216 void
obj_elf_previous(int ignore ATTRIBUTE_UNUSED)1217 obj_elf_previous (int ignore ATTRIBUTE_UNUSED)
1218 {
1219 segT new_section;
1220 int new_subsection;
1221
1222 if (previous_section == 0)
1223 {
1224 as_warn (_(".previous without corresponding .section; ignored"));
1225 return;
1226 }
1227
1228 #ifdef md_flush_pending_output
1229 md_flush_pending_output ();
1230 #endif
1231
1232 new_section = previous_section;
1233 new_subsection = previous_subsection;
1234 previous_section = now_seg;
1235 previous_subsection = now_subseg;
1236 subseg_set (new_section, new_subsection);
1237
1238 #ifdef md_elf_section_change_hook
1239 md_elf_section_change_hook ();
1240 #endif
1241 }
1242
1243 static void
obj_elf_popsection(int xxx ATTRIBUTE_UNUSED)1244 obj_elf_popsection (int xxx ATTRIBUTE_UNUSED)
1245 {
1246 struct section_stack *top = section_stack;
1247
1248 if (top == NULL)
1249 {
1250 as_warn (_(".popsection without corresponding .pushsection; ignored"));
1251 return;
1252 }
1253
1254 #ifdef md_flush_pending_output
1255 md_flush_pending_output ();
1256 #endif
1257
1258 section_stack = top->next;
1259 previous_section = top->prev_seg;
1260 previous_subsection = top->prev_subseg;
1261 subseg_set (top->seg, top->subseg);
1262 free (top);
1263
1264 #ifdef md_elf_section_change_hook
1265 md_elf_section_change_hook ();
1266 #endif
1267 }
1268
1269 static void
obj_elf_line(int ignore ATTRIBUTE_UNUSED)1270 obj_elf_line (int ignore ATTRIBUTE_UNUSED)
1271 {
1272 /* Assume delimiter is part of expression. BSD4.2 as fails with
1273 delightful bug, so we are not being incompatible here. */
1274 new_logical_line (NULL, get_absolute_expression ());
1275 demand_empty_rest_of_line ();
1276 }
1277
1278 /* This handles the .symver pseudo-op, which is used to specify a
1279 symbol version. The syntax is ``.symver NAME,SYMVERNAME''.
1280 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This
1281 pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1282 with the same value as the symbol NAME. */
1283
1284 static void
obj_elf_symver(int ignore ATTRIBUTE_UNUSED)1285 obj_elf_symver (int ignore ATTRIBUTE_UNUSED)
1286 {
1287 char *name;
1288 char c;
1289 char old_lexat;
1290 symbolS *sym;
1291
1292 sym = get_sym_from_input_line_and_check ();
1293
1294 if (*input_line_pointer != ',')
1295 {
1296 as_bad (_("expected comma after name in .symver"));
1297 ignore_rest_of_line ();
1298 return;
1299 }
1300
1301 ++input_line_pointer;
1302 SKIP_WHITESPACE ();
1303 name = input_line_pointer;
1304
1305 /* Temporarily include '@' in symbol names. */
1306 old_lexat = lex_type[(unsigned char) '@'];
1307 lex_type[(unsigned char) '@'] |= LEX_NAME;
1308 c = get_symbol_end ();
1309 lex_type[(unsigned char) '@'] = old_lexat;
1310
1311 if (symbol_get_obj (sym)->versioned_name == NULL)
1312 {
1313 symbol_get_obj (sym)->versioned_name = xstrdup (name);
1314
1315 *input_line_pointer = c;
1316
1317 if (strchr (symbol_get_obj (sym)->versioned_name,
1318 ELF_VER_CHR) == NULL)
1319 {
1320 as_bad (_("missing version name in `%s' for symbol `%s'"),
1321 symbol_get_obj (sym)->versioned_name,
1322 S_GET_NAME (sym));
1323 ignore_rest_of_line ();
1324 return;
1325 }
1326 }
1327 else
1328 {
1329 if (strcmp (symbol_get_obj (sym)->versioned_name, name))
1330 {
1331 as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1332 name, symbol_get_obj (sym)->versioned_name,
1333 S_GET_NAME (sym));
1334 ignore_rest_of_line ();
1335 return;
1336 }
1337
1338 *input_line_pointer = c;
1339 }
1340
1341 demand_empty_rest_of_line ();
1342 }
1343
1344 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1345 to the linker the hierarchy in which a particular table resides. The
1346 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */
1347
1348 struct fix *
obj_elf_vtable_inherit(int ignore ATTRIBUTE_UNUSED)1349 obj_elf_vtable_inherit (int ignore ATTRIBUTE_UNUSED)
1350 {
1351 char *cname, *pname;
1352 symbolS *csym, *psym;
1353 char c, bad = 0;
1354
1355 if (*input_line_pointer == '#')
1356 ++input_line_pointer;
1357
1358 cname = input_line_pointer;
1359 c = get_symbol_end ();
1360 csym = symbol_find (cname);
1361
1362 /* GCFIXME: should check that we don't have two .vtable_inherits for
1363 the same child symbol. Also, we can currently only do this if the
1364 child symbol is already exists and is placed in a fragment. */
1365
1366 if (csym == NULL || symbol_get_frag (csym) == NULL)
1367 {
1368 as_bad (_("expected `%s' to have already been set for .vtable_inherit"),
1369 cname);
1370 bad = 1;
1371 }
1372
1373 *input_line_pointer = c;
1374
1375 SKIP_WHITESPACE ();
1376 if (*input_line_pointer != ',')
1377 {
1378 as_bad (_("expected comma after name in .vtable_inherit"));
1379 ignore_rest_of_line ();
1380 return NULL;
1381 }
1382
1383 ++input_line_pointer;
1384 SKIP_WHITESPACE ();
1385
1386 if (*input_line_pointer == '#')
1387 ++input_line_pointer;
1388
1389 if (input_line_pointer[0] == '0'
1390 && (input_line_pointer[1] == '\0'
1391 || ISSPACE (input_line_pointer[1])))
1392 {
1393 psym = section_symbol (absolute_section);
1394 ++input_line_pointer;
1395 }
1396 else
1397 {
1398 pname = input_line_pointer;
1399 c = get_symbol_end ();
1400 psym = symbol_find_or_make (pname);
1401 *input_line_pointer = c;
1402 }
1403
1404 demand_empty_rest_of_line ();
1405
1406 if (bad)
1407 return NULL;
1408
1409 gas_assert (symbol_get_value_expression (csym)->X_op == O_constant);
1410 return fix_new (symbol_get_frag (csym),
1411 symbol_get_value_expression (csym)->X_add_number,
1412 0, psym, 0, 0, BFD_RELOC_VTABLE_INHERIT);
1413 }
1414
1415 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1416 to the linker that a vtable slot was used. The syntax is
1417 ".vtable_entry tablename, offset". */
1418
1419 struct fix *
obj_elf_vtable_entry(int ignore ATTRIBUTE_UNUSED)1420 obj_elf_vtable_entry (int ignore ATTRIBUTE_UNUSED)
1421 {
1422 symbolS *sym;
1423 offsetT offset;
1424
1425 if (*input_line_pointer == '#')
1426 ++input_line_pointer;
1427
1428 sym = get_sym_from_input_line_and_check ();
1429 if (*input_line_pointer != ',')
1430 {
1431 as_bad (_("expected comma after name in .vtable_entry"));
1432 ignore_rest_of_line ();
1433 return NULL;
1434 }
1435
1436 ++input_line_pointer;
1437 if (*input_line_pointer == '#')
1438 ++input_line_pointer;
1439
1440 offset = get_absolute_expression ();
1441
1442 demand_empty_rest_of_line ();
1443
1444 return fix_new (frag_now, frag_now_fix (), 0, sym, offset, 0,
1445 BFD_RELOC_VTABLE_ENTRY);
1446 }
1447
1448 #define skip_whitespace(str) do { if (*(str) == ' ') ++(str); } while (0)
1449
1450 static inline int
skip_past_char(char ** str,char c)1451 skip_past_char (char ** str, char c)
1452 {
1453 if (**str == c)
1454 {
1455 (*str)++;
1456 return 0;
1457 }
1458 else
1459 return -1;
1460 }
1461 #define skip_past_comma(str) skip_past_char (str, ',')
1462
1463 /* A list of attributes that have been explicitly set by the assembly code.
1464 VENDOR is the vendor id, BASE is the tag shifted right by the number
1465 of bits in MASK, and bit N of MASK is set if tag BASE+N has been set. */
1466 struct recorded_attribute_info {
1467 struct recorded_attribute_info *next;
1468 int vendor;
1469 unsigned int base;
1470 unsigned long mask;
1471 };
1472 static struct recorded_attribute_info *recorded_attributes;
1473
1474 /* Record that we have seen an explicit specification of attribute TAG
1475 for vendor VENDOR. */
1476
1477 static void
record_attribute(int vendor,unsigned int tag)1478 record_attribute (int vendor, unsigned int tag)
1479 {
1480 unsigned int base;
1481 unsigned long mask;
1482 struct recorded_attribute_info *rai;
1483
1484 base = tag / (8 * sizeof (rai->mask));
1485 mask = 1UL << (tag % (8 * sizeof (rai->mask)));
1486 for (rai = recorded_attributes; rai; rai = rai->next)
1487 if (rai->vendor == vendor && rai->base == base)
1488 {
1489 rai->mask |= mask;
1490 return;
1491 }
1492
1493 rai = XNEW (struct recorded_attribute_info);
1494 rai->next = recorded_attributes;
1495 rai->vendor = vendor;
1496 rai->base = base;
1497 rai->mask = mask;
1498 recorded_attributes = rai;
1499 }
1500
1501 /* Return true if we have seen an explicit specification of attribute TAG
1502 for vendor VENDOR. */
1503
1504 bfd_boolean
obj_elf_seen_attribute(int vendor,unsigned int tag)1505 obj_elf_seen_attribute (int vendor, unsigned int tag)
1506 {
1507 unsigned int base;
1508 unsigned long mask;
1509 struct recorded_attribute_info *rai;
1510
1511 base = tag / (8 * sizeof (rai->mask));
1512 mask = 1UL << (tag % (8 * sizeof (rai->mask)));
1513 for (rai = recorded_attributes; rai; rai = rai->next)
1514 if (rai->vendor == vendor && rai->base == base)
1515 return (rai->mask & mask) != 0;
1516 return FALSE;
1517 }
1518
1519 /* Parse an attribute directive for VENDOR.
1520 Returns the attribute number read, or zero on error. */
1521
1522 int
obj_elf_vendor_attribute(int vendor)1523 obj_elf_vendor_attribute (int vendor)
1524 {
1525 expressionS exp;
1526 int type;
1527 int tag;
1528 unsigned int i = 0;
1529 char *s = NULL;
1530
1531 /* Read the first number or name. */
1532 skip_whitespace (input_line_pointer);
1533 s = input_line_pointer;
1534 if (ISDIGIT (*input_line_pointer))
1535 {
1536 expression (& exp);
1537 if (exp.X_op != O_constant)
1538 goto bad;
1539 tag = exp.X_add_number;
1540 }
1541 else
1542 {
1543 char *name;
1544
1545 /* A name may contain '_', but no other punctuation. */
1546 for (; ISALNUM (*input_line_pointer) || *input_line_pointer == '_';
1547 ++input_line_pointer)
1548 i++;
1549 if (i == 0)
1550 goto bad;
1551
1552 name = (char *) alloca (i + 1);
1553 memcpy (name, s, i);
1554 name[i] = '\0';
1555
1556 #ifndef CONVERT_SYMBOLIC_ATTRIBUTE
1557 #define CONVERT_SYMBOLIC_ATTRIBUTE(a) -1
1558 #endif
1559
1560 tag = CONVERT_SYMBOLIC_ATTRIBUTE (name);
1561 if (tag == -1)
1562 {
1563 as_bad (_("Attribute name not recognised: %s"), name);
1564 ignore_rest_of_line ();
1565 return 0;
1566 }
1567 }
1568
1569 type = _bfd_elf_obj_attrs_arg_type (stdoutput, vendor, tag);
1570
1571 if (skip_past_comma (&input_line_pointer) == -1)
1572 goto bad;
1573 if (type & 1)
1574 {
1575 expression (& exp);
1576 if (exp.X_op != O_constant)
1577 {
1578 as_bad (_("expected numeric constant"));
1579 ignore_rest_of_line ();
1580 return 0;
1581 }
1582 i = exp.X_add_number;
1583 }
1584 if ((type & 3) == 3
1585 && skip_past_comma (&input_line_pointer) == -1)
1586 {
1587 as_bad (_("expected comma"));
1588 ignore_rest_of_line ();
1589 return 0;
1590 }
1591 if (type & 2)
1592 {
1593 int len;
1594
1595 skip_whitespace (input_line_pointer);
1596 if (*input_line_pointer != '"')
1597 goto bad_string;
1598 s = demand_copy_C_string (&len);
1599 }
1600
1601 record_attribute (vendor, tag);
1602 switch (type & 3)
1603 {
1604 case 3:
1605 bfd_elf_add_obj_attr_int_string (stdoutput, vendor, tag, i, s);
1606 break;
1607 case 2:
1608 bfd_elf_add_obj_attr_string (stdoutput, vendor, tag, s);
1609 break;
1610 case 1:
1611 bfd_elf_add_obj_attr_int (stdoutput, vendor, tag, i);
1612 break;
1613 default:
1614 abort ();
1615 }
1616
1617 demand_empty_rest_of_line ();
1618 return tag;
1619 bad_string:
1620 as_bad (_("bad string constant"));
1621 ignore_rest_of_line ();
1622 return 0;
1623 bad:
1624 as_bad (_("expected <tag> , <value>"));
1625 ignore_rest_of_line ();
1626 return 0;
1627 }
1628
1629 /* Parse a .gnu_attribute directive. */
1630
1631 static void
obj_elf_gnu_attribute(int ignored ATTRIBUTE_UNUSED)1632 obj_elf_gnu_attribute (int ignored ATTRIBUTE_UNUSED)
1633 {
1634 obj_elf_vendor_attribute (OBJ_ATTR_GNU);
1635 }
1636
1637 void
elf_obj_read_begin_hook(void)1638 elf_obj_read_begin_hook (void)
1639 {
1640 #ifdef NEED_ECOFF_DEBUG
1641 if (ECOFF_DEBUGGING)
1642 ecoff_read_begin_hook ();
1643 #endif
1644 }
1645
1646 void
elf_obj_symbol_new_hook(symbolS * symbolP)1647 elf_obj_symbol_new_hook (symbolS *symbolP)
1648 {
1649 struct elf_obj_sy *sy_obj;
1650
1651 sy_obj = symbol_get_obj (symbolP);
1652 sy_obj->size = NULL;
1653 sy_obj->versioned_name = NULL;
1654
1655 #ifdef NEED_ECOFF_DEBUG
1656 if (ECOFF_DEBUGGING)
1657 ecoff_symbol_new_hook (symbolP);
1658 #endif
1659 }
1660
1661 /* When setting one symbol equal to another, by default we probably
1662 want them to have the same "size", whatever it means in the current
1663 context. */
1664
1665 void
elf_copy_symbol_attributes(symbolS * dest,symbolS * src)1666 elf_copy_symbol_attributes (symbolS *dest, symbolS *src)
1667 {
1668 struct elf_obj_sy *srcelf = symbol_get_obj (src);
1669 struct elf_obj_sy *destelf = symbol_get_obj (dest);
1670 if (srcelf->size)
1671 {
1672 if (destelf->size == NULL)
1673 destelf->size = (expressionS *) xmalloc (sizeof (expressionS));
1674 *destelf->size = *srcelf->size;
1675 }
1676 else
1677 {
1678 if (destelf->size != NULL)
1679 free (destelf->size);
1680 destelf->size = NULL;
1681 }
1682 S_SET_SIZE (dest, S_GET_SIZE (src));
1683 /* Don't copy visibility. */
1684 S_SET_OTHER (dest, (ELF_ST_VISIBILITY (S_GET_OTHER (dest))
1685 | (S_GET_OTHER (src) & ~ELF_ST_VISIBILITY (-1))));
1686 }
1687
1688 void
obj_elf_version(int ignore ATTRIBUTE_UNUSED)1689 obj_elf_version (int ignore ATTRIBUTE_UNUSED)
1690 {
1691 char *name;
1692 unsigned int c;
1693 char *p;
1694 asection *seg = now_seg;
1695 subsegT subseg = now_subseg;
1696 Elf_Internal_Note i_note;
1697 Elf_External_Note e_note;
1698 asection *note_secp = NULL;
1699
1700 SKIP_WHITESPACE ();
1701 if (*input_line_pointer == '\"')
1702 {
1703 unsigned int len;
1704
1705 ++input_line_pointer; /* -> 1st char of string. */
1706 name = input_line_pointer;
1707
1708 while (is_a_char (c = next_char_of_string ()))
1709 ;
1710 c = *input_line_pointer;
1711 *input_line_pointer = '\0';
1712 *(input_line_pointer - 1) = '\0';
1713 *input_line_pointer = c;
1714
1715 /* Create the .note section. */
1716 note_secp = subseg_new (".note", 0);
1717 bfd_set_section_flags (stdoutput,
1718 note_secp,
1719 SEC_HAS_CONTENTS | SEC_READONLY);
1720
1721 /* Process the version string. */
1722 len = strlen (name) + 1;
1723
1724 /* PR 3456: Although the name field is padded out to an 4-byte
1725 boundary, the namesz field should not be adjusted. */
1726 i_note.namesz = len;
1727 i_note.descsz = 0; /* No description. */
1728 i_note.type = NT_VERSION;
1729 p = frag_more (sizeof (e_note.namesz));
1730 md_number_to_chars (p, i_note.namesz, sizeof (e_note.namesz));
1731 p = frag_more (sizeof (e_note.descsz));
1732 md_number_to_chars (p, i_note.descsz, sizeof (e_note.descsz));
1733 p = frag_more (sizeof (e_note.type));
1734 md_number_to_chars (p, i_note.type, sizeof (e_note.type));
1735 p = frag_more (len);
1736 memcpy (p, name, len);
1737
1738 frag_align (2, 0, 0);
1739
1740 subseg_set (seg, subseg);
1741 }
1742 else
1743 as_bad (_("expected quoted string"));
1744
1745 demand_empty_rest_of_line ();
1746 }
1747
1748 static void
obj_elf_size(int ignore ATTRIBUTE_UNUSED)1749 obj_elf_size (int ignore ATTRIBUTE_UNUSED)
1750 {
1751 char *name = input_line_pointer;
1752 char c = get_symbol_end ();
1753 char *p;
1754 expressionS exp;
1755 symbolS *sym;
1756
1757 p = input_line_pointer;
1758 *p = c;
1759 SKIP_WHITESPACE ();
1760 if (*input_line_pointer != ',')
1761 {
1762 *p = 0;
1763 as_bad (_("expected comma after name `%s' in .size directive"), name);
1764 *p = c;
1765 ignore_rest_of_line ();
1766 return;
1767 }
1768 input_line_pointer++;
1769 expression (&exp);
1770 if (exp.X_op == O_absent)
1771 {
1772 as_bad (_("missing expression in .size directive"));
1773 exp.X_op = O_constant;
1774 exp.X_add_number = 0;
1775 }
1776 *p = 0;
1777 sym = symbol_find_or_make (name);
1778 *p = c;
1779 if (exp.X_op == O_constant)
1780 {
1781 S_SET_SIZE (sym, exp.X_add_number);
1782 if (symbol_get_obj (sym)->size)
1783 {
1784 xfree (symbol_get_obj (sym)->size);
1785 symbol_get_obj (sym)->size = NULL;
1786 }
1787 }
1788 else
1789 {
1790 symbol_get_obj (sym)->size =
1791 (expressionS *) xmalloc (sizeof (expressionS));
1792 *symbol_get_obj (sym)->size = exp;
1793 }
1794 demand_empty_rest_of_line ();
1795 }
1796
1797 /* Handle the ELF .type pseudo-op. This sets the type of a symbol.
1798 There are six syntaxes:
1799
1800 The first (used on Solaris) is
1801 .type SYM,#function
1802 The second (used on UnixWare) is
1803 .type SYM,@function
1804 The third (reportedly to be used on Irix 6.0) is
1805 .type SYM STT_FUNC
1806 The fourth (used on NetBSD/Arm and Linux/ARM) is
1807 .type SYM,%function
1808 The fifth (used on SVR4/860) is
1809 .type SYM,"function"
1810 The sixth (emitted by recent SunPRO under Solaris) is
1811 .type SYM,[0-9]
1812 where the integer is the STT_* value.
1813 */
1814
1815 static char *
obj_elf_type_name(char * cp)1816 obj_elf_type_name (char *cp)
1817 {
1818 char *p;
1819
1820 p = input_line_pointer;
1821 if (*input_line_pointer >= '0'
1822 && *input_line_pointer <= '9')
1823 {
1824 while (*input_line_pointer >= '0'
1825 && *input_line_pointer <= '9')
1826 ++input_line_pointer;
1827 *cp = *input_line_pointer;
1828 *input_line_pointer = '\0';
1829 }
1830 else
1831 *cp = get_symbol_end ();
1832
1833 return p;
1834 }
1835
1836 static void
obj_elf_type(int ignore ATTRIBUTE_UNUSED)1837 obj_elf_type (int ignore ATTRIBUTE_UNUSED)
1838 {
1839 char c;
1840 int type;
1841 const char *type_name;
1842 symbolS *sym;
1843 elf_symbol_type *elfsym;
1844
1845 sym = get_sym_from_input_line_and_check ();
1846 c = *input_line_pointer;
1847 elfsym = (elf_symbol_type *) symbol_get_bfdsym (sym);
1848
1849 if (*input_line_pointer == ',')
1850 ++input_line_pointer;
1851
1852 SKIP_WHITESPACE ();
1853 if ( *input_line_pointer == '#'
1854 || *input_line_pointer == '@'
1855 || *input_line_pointer == '"'
1856 || *input_line_pointer == '%')
1857 ++input_line_pointer;
1858
1859 type_name = obj_elf_type_name (& c);
1860
1861 type = 0;
1862 if (strcmp (type_name, "function") == 0
1863 || strcmp (type_name, "2") == 0
1864 || strcmp (type_name, "STT_FUNC") == 0)
1865 type = BSF_FUNCTION;
1866 else if (strcmp (type_name, "object") == 0
1867 || strcmp (type_name, "1") == 0
1868 || strcmp (type_name, "STT_OBJECT") == 0)
1869 type = BSF_OBJECT;
1870 else if (strcmp (type_name, "tls_object") == 0
1871 || strcmp (type_name, "6") == 0
1872 || strcmp (type_name, "STT_TLS") == 0)
1873 type = BSF_OBJECT | BSF_THREAD_LOCAL;
1874 else if (strcmp (type_name, "notype") == 0
1875 || strcmp (type_name, "0") == 0
1876 || strcmp (type_name, "STT_NOTYPE") == 0)
1877 ;
1878 else if (strcmp (type_name, "common") == 0
1879 || strcmp (type_name, "5") == 0
1880 || strcmp (type_name, "STT_COMMON") == 0)
1881 {
1882 type = BSF_OBJECT;
1883
1884 if (! S_IS_COMMON (sym))
1885 {
1886 if (S_IS_VOLATILE (sym))
1887 {
1888 sym = symbol_clone (sym, 1);
1889 S_SET_SEGMENT (sym, bfd_com_section_ptr);
1890 S_SET_VALUE (sym, 0);
1891 S_SET_EXTERNAL (sym);
1892 symbol_set_frag (sym, &zero_address_frag);
1893 S_CLEAR_VOLATILE (sym);
1894 }
1895 else if (S_IS_DEFINED (sym) || symbol_equated_p (sym))
1896 as_bad (_("symbol '%s' is already defined"), S_GET_NAME (sym));
1897 else
1898 {
1899 /* FIXME: Is it safe to just change the section ? */
1900 S_SET_SEGMENT (sym, bfd_com_section_ptr);
1901 S_SET_VALUE (sym, 0);
1902 S_SET_EXTERNAL (sym);
1903 }
1904 }
1905 }
1906 else if (strcmp (type_name, "gnu_indirect_function") == 0
1907 || strcmp (type_name, "10") == 0
1908 || strcmp (type_name, "STT_GNU_IFUNC") == 0)
1909 {
1910 const struct elf_backend_data *bed;
1911
1912 bed = get_elf_backend_data (stdoutput);
1913 if (!(bed->elf_osabi == ELFOSABI_GNU
1914 || bed->elf_osabi == ELFOSABI_FREEBSD
1915 /* GNU is still using the default value 0. */
1916 || bed->elf_osabi == ELFOSABI_NONE))
1917 as_bad (_("symbol type \"%s\" is supported only by GNU and FreeBSD targets"),
1918 type_name);
1919 type = BSF_FUNCTION | BSF_GNU_INDIRECT_FUNCTION;
1920 }
1921 else if (strcmp (type_name, "gnu_unique_object") == 0)
1922 {
1923 struct elf_backend_data *bed;
1924
1925 bed = (struct elf_backend_data *) get_elf_backend_data (stdoutput);
1926 if (!(bed->elf_osabi == ELFOSABI_GNU
1927 /* GNU is still using the default value 0. */
1928 || bed->elf_osabi == ELFOSABI_NONE))
1929 as_bad (_("symbol type \"%s\" is supported only by GNU targets"),
1930 type_name);
1931 type = BSF_OBJECT | BSF_GNU_UNIQUE;
1932 /* PR 10549: Always set OSABI field to GNU for objects containing unique symbols. */
1933 bed->elf_osabi = ELFOSABI_GNU;
1934 }
1935 #ifdef md_elf_symbol_type
1936 else if ((type = md_elf_symbol_type (type_name, sym, elfsym)) != -1)
1937 ;
1938 #endif
1939 else
1940 as_bad (_("unrecognized symbol type \"%s\""), type_name);
1941
1942 *input_line_pointer = c;
1943
1944 if (*input_line_pointer == '"')
1945 ++input_line_pointer;
1946
1947 elfsym->symbol.flags |= type;
1948
1949 demand_empty_rest_of_line ();
1950 }
1951
1952 static void
obj_elf_ident(int ignore ATTRIBUTE_UNUSED)1953 obj_elf_ident (int ignore ATTRIBUTE_UNUSED)
1954 {
1955 static segT comment_section;
1956 segT old_section = now_seg;
1957 int old_subsection = now_subseg;
1958
1959 #ifdef md_flush_pending_output
1960 md_flush_pending_output ();
1961 #endif
1962
1963 if (!comment_section)
1964 {
1965 char *p;
1966 comment_section = subseg_new (".comment", 0);
1967 bfd_set_section_flags (stdoutput, comment_section,
1968 SEC_READONLY | SEC_HAS_CONTENTS
1969 | SEC_MERGE | SEC_STRINGS);
1970 comment_section->entsize = 1;
1971 #ifdef md_elf_section_change_hook
1972 md_elf_section_change_hook ();
1973 #endif
1974 p = frag_more (1);
1975 *p = 0;
1976 }
1977 else
1978 subseg_set (comment_section, 0);
1979 stringer (8 + 1);
1980 subseg_set (old_section, old_subsection);
1981 }
1982
1983 #ifdef INIT_STAB_SECTION
1984
1985 /* The first entry in a .stabs section is special. */
1986
1987 void
obj_elf_init_stab_section(segT seg)1988 obj_elf_init_stab_section (segT seg)
1989 {
1990 char *file;
1991 char *p;
1992 char *stabstr_name;
1993 unsigned int stroff;
1994
1995 /* Force the section to align to a longword boundary. Without this,
1996 UnixWare ar crashes. */
1997 bfd_set_section_alignment (stdoutput, seg, 2);
1998
1999 /* Make space for this first symbol. */
2000 p = frag_more (12);
2001 /* Zero it out. */
2002 memset (p, 0, 12);
2003 as_where (&file, NULL);
2004 stabstr_name = (char *) xmalloc (strlen (segment_name (seg)) + 4);
2005 strcpy (stabstr_name, segment_name (seg));
2006 strcat (stabstr_name, "str");
2007 stroff = get_stab_string_offset (file, stabstr_name);
2008 know (stroff == 1 || (stroff == 0 && file[0] == '\0'));
2009 md_number_to_chars (p, stroff, 4);
2010 seg_info (seg)->stabu.p = p;
2011 }
2012
2013 #endif
2014
2015 /* Fill in the counts in the first entry in a .stabs section. */
2016
2017 static void
adjust_stab_sections(bfd * abfd,asection * sec,void * xxx ATTRIBUTE_UNUSED)2018 adjust_stab_sections (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
2019 {
2020 char *name;
2021 asection *strsec;
2022 char *p;
2023 int strsz, nsyms;
2024
2025 if (strncmp (".stab", sec->name, 5))
2026 return;
2027 if (!strcmp ("str", sec->name + strlen (sec->name) - 3))
2028 return;
2029
2030 name = (char *) alloca (strlen (sec->name) + 4);
2031 strcpy (name, sec->name);
2032 strcat (name, "str");
2033 strsec = bfd_get_section_by_name (abfd, name);
2034 if (strsec)
2035 strsz = bfd_section_size (abfd, strsec);
2036 else
2037 strsz = 0;
2038 nsyms = bfd_section_size (abfd, sec) / 12 - 1;
2039
2040 p = seg_info (sec)->stabu.p;
2041 gas_assert (p != 0);
2042
2043 bfd_h_put_16 (abfd, nsyms, p + 6);
2044 bfd_h_put_32 (abfd, strsz, p + 8);
2045 }
2046
2047 #ifdef NEED_ECOFF_DEBUG
2048
2049 /* This function is called by the ECOFF code. It is supposed to
2050 record the external symbol information so that the backend can
2051 write it out correctly. The ELF backend doesn't actually handle
2052 this at the moment, so we do it ourselves. We save the information
2053 in the symbol. */
2054
2055 #ifdef OBJ_MAYBE_ELF
2056 static
2057 #endif
2058 void
elf_ecoff_set_ext(symbolS * sym,struct ecoff_extr * ext)2059 elf_ecoff_set_ext (symbolS *sym, struct ecoff_extr *ext)
2060 {
2061 symbol_get_bfdsym (sym)->udata.p = ext;
2062 }
2063
2064 /* This function is called by bfd_ecoff_debug_externals. It is
2065 supposed to *EXT to the external symbol information, and return
2066 whether the symbol should be used at all. */
2067
2068 static bfd_boolean
elf_get_extr(asymbol * sym,EXTR * ext)2069 elf_get_extr (asymbol *sym, EXTR *ext)
2070 {
2071 if (sym->udata.p == NULL)
2072 return FALSE;
2073 *ext = *(EXTR *) sym->udata.p;
2074 return TRUE;
2075 }
2076
2077 /* This function is called by bfd_ecoff_debug_externals. It has
2078 nothing to do for ELF. */
2079
2080 static void
elf_set_index(asymbol * sym ATTRIBUTE_UNUSED,bfd_size_type indx ATTRIBUTE_UNUSED)2081 elf_set_index (asymbol *sym ATTRIBUTE_UNUSED,
2082 bfd_size_type indx ATTRIBUTE_UNUSED)
2083 {
2084 }
2085
2086 #endif /* NEED_ECOFF_DEBUG */
2087
2088 void
elf_frob_symbol(symbolS * symp,int * puntp)2089 elf_frob_symbol (symbolS *symp, int *puntp)
2090 {
2091 struct elf_obj_sy *sy_obj;
2092 expressionS *size;
2093
2094 #ifdef NEED_ECOFF_DEBUG
2095 if (ECOFF_DEBUGGING)
2096 ecoff_frob_symbol (symp);
2097 #endif
2098
2099 sy_obj = symbol_get_obj (symp);
2100
2101 size = sy_obj->size;
2102 if (size != NULL)
2103 {
2104 if (resolve_expression (size)
2105 && size->X_op == O_constant)
2106 S_SET_SIZE (symp, size->X_add_number);
2107 else
2108 {
2109 if (flag_size_check == size_check_error)
2110 as_bad (_(".size expression for %s "
2111 "does not evaluate to a constant"), S_GET_NAME (symp));
2112 else
2113 as_warn (_(".size expression for %s "
2114 "does not evaluate to a constant"), S_GET_NAME (symp));
2115 }
2116 free (sy_obj->size);
2117 sy_obj->size = NULL;
2118 }
2119
2120 if (sy_obj->versioned_name != NULL)
2121 {
2122 char *p;
2123
2124 p = strchr (sy_obj->versioned_name, ELF_VER_CHR);
2125 if (p == NULL)
2126 /* We will have already reported an error about a missing version. */
2127 *puntp = TRUE;
2128
2129 /* This symbol was given a new name with the .symver directive.
2130
2131 If this is an external reference, just rename the symbol to
2132 include the version string. This will make the relocs be
2133 against the correct versioned symbol.
2134
2135 If this is a definition, add an alias. FIXME: Using an alias
2136 will permit the debugging information to refer to the right
2137 symbol. However, it's not clear whether it is the best
2138 approach. */
2139
2140 else if (! S_IS_DEFINED (symp))
2141 {
2142 /* Verify that the name isn't using the @@ syntax--this is
2143 reserved for definitions of the default version to link
2144 against. */
2145 if (p[1] == ELF_VER_CHR)
2146 {
2147 as_bad (_("invalid attempt to declare external version name"
2148 " as default in symbol `%s'"),
2149 sy_obj->versioned_name);
2150 *puntp = TRUE;
2151 }
2152 S_SET_NAME (symp, sy_obj->versioned_name);
2153 }
2154 else
2155 {
2156 if (p[1] == ELF_VER_CHR && p[2] == ELF_VER_CHR)
2157 {
2158 size_t l;
2159
2160 /* The @@@ syntax is a special case. It renames the
2161 symbol name to versioned_name with one `@' removed. */
2162 l = strlen (&p[3]) + 1;
2163 memmove (&p[2], &p[3], l);
2164 S_SET_NAME (symp, sy_obj->versioned_name);
2165 }
2166 else
2167 {
2168 symbolS *symp2;
2169
2170 /* FIXME: Creating a new symbol here is risky. We're
2171 in the final loop over the symbol table. We can
2172 get away with it only because the symbol goes to
2173 the end of the list, where the loop will still see
2174 it. It would probably be better to do this in
2175 obj_frob_file_before_adjust. */
2176
2177 symp2 = symbol_find_or_make (sy_obj->versioned_name);
2178
2179 /* Now we act as though we saw symp2 = sym. */
2180
2181 S_SET_SEGMENT (symp2, S_GET_SEGMENT (symp));
2182
2183 /* Subtracting out the frag address here is a hack
2184 because we are in the middle of the final loop. */
2185 S_SET_VALUE (symp2,
2186 (S_GET_VALUE (symp)
2187 - symbol_get_frag (symp)->fr_address));
2188
2189 symbol_set_frag (symp2, symbol_get_frag (symp));
2190
2191 /* This will copy over the size information. */
2192 copy_symbol_attributes (symp2, symp);
2193
2194 S_SET_OTHER (symp2, S_GET_OTHER (symp));
2195
2196 if (S_IS_WEAK (symp))
2197 S_SET_WEAK (symp2);
2198
2199 if (S_IS_EXTERNAL (symp))
2200 S_SET_EXTERNAL (symp2);
2201 }
2202 }
2203 }
2204
2205 /* Double check weak symbols. */
2206 if (S_IS_WEAK (symp))
2207 {
2208 if (S_IS_COMMON (symp))
2209 as_bad (_("symbol `%s' can not be both weak and common"),
2210 S_GET_NAME (symp));
2211 }
2212
2213 #ifdef TC_MIPS
2214 /* The Irix 5 and 6 assemblers set the type of any common symbol and
2215 any undefined non-function symbol to STT_OBJECT. We try to be
2216 compatible, since newer Irix 5 and 6 linkers care. However, we
2217 only set undefined symbols to be STT_OBJECT if we are on Irix,
2218 because that is the only time gcc will generate the necessary
2219 .global directives to mark functions. */
2220
2221 if (S_IS_COMMON (symp))
2222 symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
2223
2224 if (strstr (TARGET_OS, "irix") != NULL
2225 && ! S_IS_DEFINED (symp)
2226 && (symbol_get_bfdsym (symp)->flags & BSF_FUNCTION) == 0)
2227 symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
2228 #endif
2229 }
2230
2231 struct group_list
2232 {
2233 asection **head; /* Section lists. */
2234 unsigned int *elt_count; /* Number of sections in each list. */
2235 unsigned int num_group; /* Number of lists. */
2236 struct hash_control *indexes; /* Maps group name to index in head array. */
2237 };
2238
2239 /* Called via bfd_map_over_sections. If SEC is a member of a group,
2240 add it to a list of sections belonging to the group. INF is a
2241 pointer to a struct group_list, which is where we store the head of
2242 each list. */
2243
2244 static void
build_group_lists(bfd * abfd ATTRIBUTE_UNUSED,asection * sec,void * inf)2245 build_group_lists (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
2246 {
2247 struct group_list *list = (struct group_list *) inf;
2248 const char *group_name = elf_group_name (sec);
2249 unsigned int i;
2250 unsigned int *elem_idx;
2251 unsigned int *idx_ptr;
2252
2253 if (group_name == NULL)
2254 return;
2255
2256 /* If this group already has a list, add the section to the head of
2257 the list. */
2258 elem_idx = (unsigned int *) hash_find (list->indexes, group_name);
2259 if (elem_idx != NULL)
2260 {
2261 elf_next_in_group (sec) = list->head[*elem_idx];
2262 list->head[*elem_idx] = sec;
2263 list->elt_count[*elem_idx] += 1;
2264 return;
2265 }
2266
2267 /* New group. Make the arrays bigger in chunks to minimize calls to
2268 realloc. */
2269 i = list->num_group;
2270 if ((i & 127) == 0)
2271 {
2272 unsigned int newsize = i + 128;
2273 list->head = (asection **) xrealloc (list->head,
2274 newsize * sizeof (*list->head));
2275 list->elt_count = (unsigned int *)
2276 xrealloc (list->elt_count, newsize * sizeof (*list->elt_count));
2277 }
2278 list->head[i] = sec;
2279 list->elt_count[i] = 1;
2280 list->num_group += 1;
2281
2282 /* Add index to hash. */
2283 idx_ptr = (unsigned int *) xmalloc (sizeof (unsigned int));
2284 *idx_ptr = i;
2285 hash_insert (list->indexes, group_name, idx_ptr);
2286 }
2287
free_section_idx(const char * key ATTRIBUTE_UNUSED,void * val)2288 static void free_section_idx (const char *key ATTRIBUTE_UNUSED, void *val)
2289 {
2290 free ((unsigned int *) val);
2291 }
2292
2293 void
elf_adjust_symtab(void)2294 elf_adjust_symtab (void)
2295 {
2296 struct group_list list;
2297 unsigned int i;
2298
2299 /* Go find section groups. */
2300 list.num_group = 0;
2301 list.head = NULL;
2302 list.elt_count = NULL;
2303 list.indexes = hash_new ();
2304 bfd_map_over_sections (stdoutput, build_group_lists, &list);
2305
2306 /* Make the SHT_GROUP sections that describe each section group. We
2307 can't set up the section contents here yet, because elf section
2308 indices have yet to be calculated. elf.c:set_group_contents does
2309 the rest of the work. */
2310 for (i = 0; i < list.num_group; i++)
2311 {
2312 const char *group_name = elf_group_name (list.head[i]);
2313 const char *sec_name;
2314 asection *s;
2315 flagword flags;
2316 struct symbol *sy;
2317 bfd_size_type size;
2318
2319 flags = SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_GROUP;
2320 for (s = list.head[i]; s != NULL; s = elf_next_in_group (s))
2321 if ((s->flags ^ flags) & SEC_LINK_ONCE)
2322 {
2323 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2324 if (s != list.head[i])
2325 {
2326 as_warn (_("assuming all members of group `%s' are COMDAT"),
2327 group_name);
2328 break;
2329 }
2330 }
2331
2332 sec_name = ".group";
2333 s = subseg_force_new (sec_name, 0);
2334 if (s == NULL
2335 || !bfd_set_section_flags (stdoutput, s, flags)
2336 || !bfd_set_section_alignment (stdoutput, s, 2))
2337 {
2338 as_fatal (_("can't create group: %s"),
2339 bfd_errmsg (bfd_get_error ()));
2340 }
2341 elf_section_type (s) = SHT_GROUP;
2342
2343 /* Pass a pointer to the first section in this group. */
2344 elf_next_in_group (s) = list.head[i];
2345 /* Make sure that the signature symbol for the group has the
2346 name of the group. */
2347 sy = symbol_find_exact (group_name);
2348 if (!sy
2349 || (sy != symbol_lastP
2350 && (sy->sy_next == NULL
2351 || sy->sy_next->sy_previous != sy)))
2352 {
2353 /* Create the symbol now. */
2354 sy = symbol_new (group_name, now_seg, (valueT) 0, frag_now);
2355 #ifdef TE_SOLARIS
2356 /* Before Solaris 11 build 154, Sun ld rejects local group
2357 signature symbols, so make them weak hidden instead. */
2358 symbol_get_bfdsym (sy)->flags |= BSF_WEAK;
2359 S_SET_OTHER (sy, STV_HIDDEN);
2360 #else
2361 symbol_get_obj (sy)->local = 1;
2362 #endif
2363 symbol_table_insert (sy);
2364 }
2365 elf_group_id (s) = symbol_get_bfdsym (sy);
2366
2367 size = 4 * (list.elt_count[i] + 1);
2368 bfd_set_section_size (stdoutput, s, size);
2369 s->contents = (unsigned char *) frag_more (size);
2370 frag_now->fr_fix = frag_now_fix_octets ();
2371 frag_wane (frag_now);
2372 }
2373
2374 /* Cleanup hash. */
2375 hash_traverse (list.indexes, free_section_idx);
2376 hash_die (list.indexes);
2377 }
2378
2379 void
elf_frob_file(void)2380 elf_frob_file (void)
2381 {
2382 bfd_map_over_sections (stdoutput, adjust_stab_sections, NULL);
2383
2384 #ifdef elf_tc_final_processing
2385 elf_tc_final_processing ();
2386 #endif
2387 }
2388
2389 /* It removes any unneeded versioned symbols from the symbol table. */
2390
2391 void
elf_frob_file_before_adjust(void)2392 elf_frob_file_before_adjust (void)
2393 {
2394 if (symbol_rootP)
2395 {
2396 symbolS *symp;
2397
2398 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2399 if (!S_IS_DEFINED (symp))
2400 {
2401 if (symbol_get_obj (symp)->versioned_name)
2402 {
2403 char *p;
2404
2405 /* The @@@ syntax is a special case. If the symbol is
2406 not defined, 2 `@'s will be removed from the
2407 versioned_name. */
2408
2409 p = strchr (symbol_get_obj (symp)->versioned_name,
2410 ELF_VER_CHR);
2411 if (p != NULL && p[1] == ELF_VER_CHR && p[2] == ELF_VER_CHR)
2412 {
2413 size_t l = strlen (&p[3]) + 1;
2414 memmove (&p[1], &p[3], l);
2415 }
2416 if (symbol_used_p (symp) == 0
2417 && symbol_used_in_reloc_p (symp) == 0)
2418 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2419 }
2420
2421 /* If there was .weak foo, but foo was neither defined nor
2422 used anywhere, remove it. */
2423
2424 else if (S_IS_WEAK (symp)
2425 && symbol_used_p (symp) == 0
2426 && symbol_used_in_reloc_p (symp) == 0)
2427 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2428 }
2429 }
2430 }
2431
2432 /* It is required that we let write_relocs have the opportunity to
2433 optimize away fixups before output has begun, since it is possible
2434 to eliminate all fixups for a section and thus we never should
2435 have generated the relocation section. */
2436
2437 void
elf_frob_file_after_relocs(void)2438 elf_frob_file_after_relocs (void)
2439 {
2440 #ifdef NEED_ECOFF_DEBUG
2441 if (ECOFF_DEBUGGING)
2442 /* Generate the ECOFF debugging information. */
2443 {
2444 const struct ecoff_debug_swap *debug_swap;
2445 struct ecoff_debug_info debug;
2446 char *buf;
2447 asection *sec;
2448
2449 debug_swap
2450 = get_elf_backend_data (stdoutput)->elf_backend_ecoff_debug_swap;
2451 know (debug_swap != NULL);
2452 ecoff_build_debug (&debug.symbolic_header, &buf, debug_swap);
2453
2454 /* Set up the pointers in debug. */
2455 #define SET(ptr, offset, type) \
2456 debug.ptr = (type) (buf + debug.symbolic_header.offset)
2457
2458 SET (line, cbLineOffset, unsigned char *);
2459 SET (external_dnr, cbDnOffset, void *);
2460 SET (external_pdr, cbPdOffset, void *);
2461 SET (external_sym, cbSymOffset, void *);
2462 SET (external_opt, cbOptOffset, void *);
2463 SET (external_aux, cbAuxOffset, union aux_ext *);
2464 SET (ss, cbSsOffset, char *);
2465 SET (external_fdr, cbFdOffset, void *);
2466 SET (external_rfd, cbRfdOffset, void *);
2467 /* ssext and external_ext are set up just below. */
2468
2469 #undef SET
2470
2471 /* Set up the external symbols. */
2472 debug.ssext = debug.ssext_end = NULL;
2473 debug.external_ext = debug.external_ext_end = NULL;
2474 if (! bfd_ecoff_debug_externals (stdoutput, &debug, debug_swap, TRUE,
2475 elf_get_extr, elf_set_index))
2476 as_fatal (_("failed to set up debugging information: %s"),
2477 bfd_errmsg (bfd_get_error ()));
2478
2479 sec = bfd_get_section_by_name (stdoutput, ".mdebug");
2480 gas_assert (sec != NULL);
2481
2482 know (!stdoutput->output_has_begun);
2483
2484 /* We set the size of the section, call bfd_set_section_contents
2485 to force the ELF backend to allocate a file position, and then
2486 write out the data. FIXME: Is this really the best way to do
2487 this? */
2488 bfd_set_section_size
2489 (stdoutput, sec, bfd_ecoff_debug_size (stdoutput, &debug, debug_swap));
2490
2491 /* Pass BUF to bfd_set_section_contents because this will
2492 eventually become a call to fwrite, and ISO C prohibits
2493 passing a NULL pointer to a stdio function even if the
2494 pointer will not be used. */
2495 if (! bfd_set_section_contents (stdoutput, sec, buf, 0, 0))
2496 as_fatal (_("can't start writing .mdebug section: %s"),
2497 bfd_errmsg (bfd_get_error ()));
2498
2499 know (stdoutput->output_has_begun);
2500 know (sec->filepos != 0);
2501
2502 if (! bfd_ecoff_write_debug (stdoutput, &debug, debug_swap,
2503 sec->filepos))
2504 as_fatal (_("could not write .mdebug section: %s"),
2505 bfd_errmsg (bfd_get_error ()));
2506 }
2507 #endif /* NEED_ECOFF_DEBUG */
2508 }
2509
2510 #ifdef SCO_ELF
2511
2512 /* Heavily plagiarized from obj_elf_version. The idea is to emit the
2513 SCO specific identifier in the .notes section to satisfy the SCO
2514 linker.
2515
2516 This looks more complicated than it really is. As opposed to the
2517 "obvious" solution, this should handle the cross dev cases
2518 correctly. (i.e, hosting on a 64 bit big endian processor, but
2519 generating SCO Elf code) Efficiency isn't a concern, as there
2520 should be exactly one of these sections per object module.
2521
2522 SCO OpenServer 5 identifies it's ELF modules with a standard ELF
2523 .note section.
2524
2525 int_32 namesz = 4 ; Name size
2526 int_32 descsz = 12 ; Descriptive information
2527 int_32 type = 1 ;
2528 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
2529 int_32 version = (major ver # << 16) | version of tools ;
2530 int_32 source = (tool_id << 16 ) | 1 ;
2531 int_32 info = 0 ; These are set by the SCO tools, but we
2532 don't know enough about the source
2533 environment to set them. SCO ld currently
2534 ignores them, and recommends we set them
2535 to zero. */
2536
2537 #define SCO_MAJOR_VERSION 0x1
2538 #define SCO_MINOR_VERSION 0x1
2539
2540 void
sco_id(void)2541 sco_id (void)
2542 {
2543
2544 char *name;
2545 unsigned int c;
2546 char ch;
2547 char *p;
2548 asection *seg = now_seg;
2549 subsegT subseg = now_subseg;
2550 Elf_Internal_Note i_note;
2551 Elf_External_Note e_note;
2552 asection *note_secp = NULL;
2553 int i, len;
2554
2555 /* create the .note section */
2556
2557 note_secp = subseg_new (".note", 0);
2558 bfd_set_section_flags (stdoutput,
2559 note_secp,
2560 SEC_HAS_CONTENTS | SEC_READONLY);
2561
2562 /* process the version string */
2563
2564 i_note.namesz = 4;
2565 i_note.descsz = 12; /* 12 descriptive bytes */
2566 i_note.type = NT_VERSION; /* Contains a version string */
2567
2568 p = frag_more (sizeof (i_note.namesz));
2569 md_number_to_chars (p, i_note.namesz, 4);
2570
2571 p = frag_more (sizeof (i_note.descsz));
2572 md_number_to_chars (p, i_note.descsz, 4);
2573
2574 p = frag_more (sizeof (i_note.type));
2575 md_number_to_chars (p, i_note.type, 4);
2576
2577 p = frag_more (4);
2578 strcpy (p, "SCO");
2579
2580 /* Note: this is the version number of the ELF we're representing */
2581 p = frag_more (4);
2582 md_number_to_chars (p, (SCO_MAJOR_VERSION << 16) | (SCO_MINOR_VERSION), 4);
2583
2584 /* Here, we pick a magic number for ourselves (yes, I "registered"
2585 it with SCO. The bottom bit shows that we are compat with the
2586 SCO ABI. */
2587 p = frag_more (4);
2588 md_number_to_chars (p, 0x4c520000 | 0x0001, 4);
2589
2590 /* If we knew (or cared) what the source language options were, we'd
2591 fill them in here. SCO has given us permission to ignore these
2592 and just set them to zero. */
2593 p = frag_more (4);
2594 md_number_to_chars (p, 0x0000, 4);
2595
2596 frag_align (2, 0, 0);
2597
2598 /* We probably can't restore the current segment, for there likely
2599 isn't one yet... */
2600 if (seg && subseg)
2601 subseg_set (seg, subseg);
2602
2603 }
2604
2605 #endif /* SCO_ELF */
2606
2607 static void
elf_generate_asm_lineno(void)2608 elf_generate_asm_lineno (void)
2609 {
2610 #ifdef NEED_ECOFF_DEBUG
2611 if (ECOFF_DEBUGGING)
2612 ecoff_generate_asm_lineno ();
2613 #endif
2614 }
2615
2616 static void
elf_process_stab(segT sec ATTRIBUTE_UNUSED,int what ATTRIBUTE_UNUSED,const char * string ATTRIBUTE_UNUSED,int type ATTRIBUTE_UNUSED,int other ATTRIBUTE_UNUSED,int desc ATTRIBUTE_UNUSED)2617 elf_process_stab (segT sec ATTRIBUTE_UNUSED,
2618 int what ATTRIBUTE_UNUSED,
2619 const char *string ATTRIBUTE_UNUSED,
2620 int type ATTRIBUTE_UNUSED,
2621 int other ATTRIBUTE_UNUSED,
2622 int desc ATTRIBUTE_UNUSED)
2623 {
2624 #ifdef NEED_ECOFF_DEBUG
2625 if (ECOFF_DEBUGGING)
2626 ecoff_stab (sec, what, string, type, other, desc);
2627 #endif
2628 }
2629
2630 static int
elf_separate_stab_sections(void)2631 elf_separate_stab_sections (void)
2632 {
2633 #ifdef NEED_ECOFF_DEBUG
2634 return (!ECOFF_DEBUGGING);
2635 #else
2636 return 1;
2637 #endif
2638 }
2639
2640 static void
elf_init_stab_section(segT seg)2641 elf_init_stab_section (segT seg)
2642 {
2643 #ifdef NEED_ECOFF_DEBUG
2644 if (!ECOFF_DEBUGGING)
2645 #endif
2646 obj_elf_init_stab_section (seg);
2647 }
2648
2649 const struct format_ops elf_format_ops =
2650 {
2651 bfd_target_elf_flavour,
2652 0, /* dfl_leading_underscore */
2653 1, /* emit_section_symbols */
2654 elf_begin,
2655 elf_file_symbol,
2656 elf_frob_symbol,
2657 elf_frob_file,
2658 elf_frob_file_before_adjust,
2659 0, /* obj_frob_file_before_fix */
2660 elf_frob_file_after_relocs,
2661 elf_s_get_size, elf_s_set_size,
2662 elf_s_get_align, elf_s_set_align,
2663 elf_s_get_other,
2664 elf_s_set_other,
2665 0, /* s_get_desc */
2666 0, /* s_set_desc */
2667 0, /* s_get_type */
2668 0, /* s_set_type */
2669 elf_copy_symbol_attributes,
2670 elf_generate_asm_lineno,
2671 elf_process_stab,
2672 elf_separate_stab_sections,
2673 elf_init_stab_section,
2674 elf_sec_sym_ok_for_reloc,
2675 elf_pop_insert,
2676 #ifdef NEED_ECOFF_DEBUG
2677 elf_ecoff_set_ext,
2678 #else
2679 0, /* ecoff_set_ext */
2680 #endif
2681 elf_obj_read_begin_hook,
2682 elf_obj_symbol_new_hook,
2683 0,
2684 elf_adjust_symtab
2685 };
2686