source: trunk/binutils/gas/config/obj-elf.c@ 2446

Last change on this file since 2446 was 610, checked in by bird, 22 years ago

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