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