gas/config/obj-elf.c

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