contrib/binutils/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 2,
  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
 887 #ifndef TC_I370
 888   if (flag_mri)
 889     {
 890       char mri_type;
 891
 892 #ifdef md_flush_pending_output
 893       md_flush_pending_output ();
 894 #endif
 895
 896       previous_section = now_seg;
 897       previous_subsection = now_subseg;
 898
 899       s_mri_sect (&mri_type);
 900
 901 #ifdef md_elf_section_change_hook
 902       md_elf_section_change_hook ();
 903 #endif
 904
 905       return;
 906     }
 907 #endif /* ! defined (TC_I370) */
 908
 909   name = obj_elf_section_name ();
 910   if (name == NULL)
 911     return;
 912   type = SHT_NULL;
 913   attr = 0;
 914   group_name = NULL;
 915   entsize = 0;
 916   linkonce = 0;
 917
 918   if (*input_line_pointer == ',')
 919     {
 920       /* Skip the comma.  */
 921       ++input_line_pointer;
 922       SKIP_WHITESPACE ();
 923
 924       if (*input_line_pointer == '"')
 925         {
 926           beg = demand_copy_C_string (&dummy);
 927           if (beg == NULL)
 928             {
 929               ignore_rest_of_line ();
 930               return;
 931             }
 932           attr |= obj_elf_parse_section_letters (beg, strlen (beg));
 933
 934           SKIP_WHITESPACE ();
 935           if (*input_line_pointer == ',')
 936             {
 937               char c;
 938               char *save = input_line_pointer;
 939
 940               ++input_line_pointer;
 941               SKIP_WHITESPACE ();
 942               c = *input_line_pointer;
 943               if (c == '"')
 944                 {
 945                   beg = demand_copy_C_string (&dummy);
 946                   if (beg == NULL)
 947                     {
 948                       ignore_rest_of_line ();
 949                       return;
 950                     }
 951                   type = obj_elf_section_type (beg, strlen (beg));
 952                 }
 953               else if (c == '@' || c == '%')
 954                 {
 955                   beg = ++input_line_pointer;
 956                   c = get_symbol_end ();
 957                   *input_line_pointer = c;
 958                   type = obj_elf_section_type (beg, input_line_pointer - beg);
 959                 }
 960               else
 961                 input_line_pointer = save;
 962             }
 963
 964           SKIP_WHITESPACE ();
 965           if ((attr & SHF_MERGE) != 0 && *input_line_pointer == ',')
 966             {
 967               ++input_line_pointer;
 968               SKIP_WHITESPACE ();
 969               entsize = get_absolute_expression ();
 970               SKIP_WHITESPACE ();
 971               if (entsize < 0)
 972                 {
 973                   as_warn (_("invalid merge entity size"));
 974                   attr &= ~SHF_MERGE;
 975                   entsize = 0;
 976                 }
 977             }
 978           else if ((attr & SHF_MERGE) != 0)
 979             {
 980               as_warn (_("entity size for SHF_MERGE not specified"));
 981               attr &= ~SHF_MERGE;
 982             }
 983
 984           if ((attr & SHF_GROUP) != 0 && *input_line_pointer == ',')
 985             {
 986               ++input_line_pointer;
 987               group_name = obj_elf_section_name ();
 988               if (group_name == NULL)
 989                 attr &= ~SHF_GROUP;
 990               else if (strncmp (input_line_pointer, ",comdat", 7) == 0)
 991                 {
 992                   input_line_pointer += 7;
 993                   linkonce = 1;
 994                 }
 995               else if (strncmp (name, ".gnu.linkonce", 13) == 0)
 996                 linkonce = 1;
 997             }
 998           else if ((attr & SHF_GROUP) != 0)
 999             {
1000               as_warn (_("group name for SHF_GROUP not specified"));
1001               attr &= ~SHF_GROUP;
1002             }
1003         }
1004       else
1005         {
1006           do
1007             {
1008               char c;
1009
1010               SKIP_WHITESPACE ();
1011               if (*input_line_pointer != '#')
1012                 {
1013                   as_bad (_("character following name is not '#'"));
1014                   ignore_rest_of_line ();
1015                   return;
1016                 }
1017               beg = ++input_line_pointer;
1018               c = get_symbol_end ();
1019               *input_line_pointer = c;
1020
1021               attr |= obj_elf_section_word (beg, input_line_pointer - beg);
1022
1023               SKIP_WHITESPACE ();
1024             }
1025           while (*input_line_pointer++ == ',');
1026           --input_line_pointer;
1027         }
1028     }
1029
1030   demand_empty_rest_of_line ();
1031
1032   obj_elf_change_section (name, type, attr, entsize, group_name, linkonce, push);
1033 }
1034
1035 /* Change to the .data section.  */
1036
1037 void
1038 obj_elf_data (int i)
1039 {
1040 #ifdef md_flush_pending_output
1041   md_flush_pending_output ();
1042 #endif
1043
1044   previous_section = now_seg;
1045   previous_subsection = now_subseg;
1046   s_data (i);
1047
1048 #ifdef md_elf_section_change_hook
1049   md_elf_section_change_hook ();
1050 #endif
1051 }
1052
1053 /* Change to the .text section.  */
1054
1055 void
1056 obj_elf_text (int i)
1057 {
1058 #ifdef md_flush_pending_output
1059   md_flush_pending_output ();
1060 #endif
1061
1062   previous_section = now_seg;
1063   previous_subsection = now_subseg;
1064   s_text (i);
1065
1066 #ifdef md_elf_section_change_hook
1067   md_elf_section_change_hook ();
1068 #endif
1069 }
1070
1071 /* Change to the *ABS* section.  */
1072
1073 void
1074 obj_elf_struct (int i)
1075 {
1076 #ifdef md_flush_pending_output
1077   md_flush_pending_output ();
1078 #endif
1079
1080   previous_section = now_seg;
1081   previous_subsection = now_subseg;
1082   s_struct (i);
1083
1084 #ifdef md_elf_section_change_hook
1085   md_elf_section_change_hook ();
1086 #endif
1087 }
1088
1089 static void
1090 obj_elf_subsection (int ignore ATTRIBUTE_UNUSED)
1091 {
1092   register int temp;
1093
1094 #ifdef md_flush_pending_output
1095   md_flush_pending_output ();
1096 #endif
1097
1098   previous_section = now_seg;
1099   previous_subsection = now_subseg;
1100
1101   temp = get_absolute_expression ();
1102   subseg_set (now_seg, (subsegT) temp);
1103   demand_empty_rest_of_line ();
1104
1105 #ifdef md_elf_section_change_hook
1106   md_elf_section_change_hook ();
1107 #endif
1108 }
1109
1110 /* This can be called from the processor backends if they change
1111    sections.  */
1112
1113 void
1114 obj_elf_section_change_hook (void)
1115 {
1116   previous_section = now_seg;
1117   previous_subsection = now_subseg;
1118 }
1119
1120 void
1121 obj_elf_previous (int ignore ATTRIBUTE_UNUSED)
1122 {
1123   segT new_section;
1124   int new_subsection;
1125
1126   if (previous_section == 0)
1127     {
1128       as_warn (_(".previous without corresponding .section; ignored"));
1129       return;
1130     }
1131
1132 #ifdef md_flush_pending_output
1133   md_flush_pending_output ();
1134 #endif
1135
1136   new_section = previous_section;
1137   new_subsection = previous_subsection;
1138   previous_section = now_seg;
1139   previous_subsection = now_subseg;
1140   subseg_set (new_section, new_subsection);
1141
1142 #ifdef md_elf_section_change_hook
1143   md_elf_section_change_hook ();
1144 #endif
1145 }
1146
1147 static void
1148 obj_elf_popsection (int xxx ATTRIBUTE_UNUSED)
1149 {
1150   struct section_stack *top = section_stack;
1151
1152   if (top == NULL)
1153     {
1154       as_warn (_(".popsection without corresponding .pushsection; ignored"));
1155       return;
1156     }
1157
1158 #ifdef md_flush_pending_output
1159   md_flush_pending_output ();
1160 #endif
1161
1162   section_stack = top->next;
1163   previous_section = top->prev_seg;
1164   previous_subsection = top->prev_subseg;
1165   subseg_set (top->seg, top->subseg);
1166   free (top);
1167
1168 #ifdef md_elf_section_change_hook
1169   md_elf_section_change_hook ();
1170 #endif
1171 }
1172
1173 static void
1174 obj_elf_line (int ignore ATTRIBUTE_UNUSED)
1175 {
1176   /* Assume delimiter is part of expression.  BSD4.2 as fails with
1177      delightful bug, so we are not being incompatible here.  */
1178   new_logical_line (NULL, get_absolute_expression ());
1179   demand_empty_rest_of_line ();
1180 }
1181
1182 /* This handles the .symver pseudo-op, which is used to specify a
1183    symbol version.  The syntax is ``.symver NAME,SYMVERNAME''.
1184    SYMVERNAME may contain ELF_VER_CHR ('@') characters.  This
1185    pseudo-op causes the assembler to emit a symbol named SYMVERNAME
1186    with the same value as the symbol NAME.  */
1187
1188 static void
1189 obj_elf_symver (int ignore ATTRIBUTE_UNUSED)
1190 {
1191   char *name;
1192   char c;
1193   char old_lexat;
1194   symbolS *sym;
1195
1196   name = input_line_pointer;
1197   c = get_symbol_end ();
1198
1199   sym = symbol_find_or_make (name);
1200
1201   *input_line_pointer = c;
1202
1203   SKIP_WHITESPACE ();
1204   if (*input_line_pointer != ',')
1205     {
1206       as_bad (_("expected comma after name in .symver"));
1207       ignore_rest_of_line ();
1208       return;
1209     }
1210
1211   ++input_line_pointer;
1212   SKIP_WHITESPACE ();
1213   name = input_line_pointer;
1214
1215   /* Temporarily include '@' in symbol names.  */
1216   old_lexat = lex_type[(unsigned char) '@'];
1217   lex_type[(unsigned char) '@'] |= LEX_NAME;
1218   c = get_symbol_end ();
1219   lex_type[(unsigned char) '@'] = old_lexat;
1220
1221   if (symbol_get_obj (sym)->versioned_name == NULL)
1222     {
1223       symbol_get_obj (sym)->versioned_name = xstrdup (name);
1224
1225       *input_line_pointer = c;
1226
1227       if (strchr (symbol_get_obj (sym)->versioned_name,
1228                   ELF_VER_CHR) == NULL)
1229         {
1230           as_bad (_("missing version name in `%s' for symbol `%s'"),
1231                   symbol_get_obj (sym)->versioned_name,
1232                   S_GET_NAME (sym));
1233           ignore_rest_of_line ();
1234           return;
1235         }
1236     }
1237   else
1238     {
1239       if (strcmp (symbol_get_obj (sym)->versioned_name, name))
1240         {
1241           as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"),
1242                   name, symbol_get_obj (sym)->versioned_name,
1243                   S_GET_NAME (sym));
1244           ignore_rest_of_line ();
1245           return;
1246         }
1247
1248       *input_line_pointer = c;
1249     }
1250
1251   demand_empty_rest_of_line ();
1252 }
1253
1254 /* This handles the .vtable_inherit pseudo-op, which is used to indicate
1255    to the linker the hierarchy in which a particular table resides.  The
1256    syntax is ".vtable_inherit CHILDNAME, PARENTNAME".  */
1257
1258 struct fix *
1259 obj_elf_vtable_inherit (int ignore ATTRIBUTE_UNUSED)
1260 {
1261   char *cname, *pname;
1262   symbolS *csym, *psym;
1263   char c, bad = 0;
1264
1265   if (*input_line_pointer == '#')
1266     ++input_line_pointer;
1267
1268   cname = input_line_pointer;
1269   c = get_symbol_end ();
1270   csym = symbol_find (cname);
1271
1272   /* GCFIXME: should check that we don't have two .vtable_inherits for
1273      the same child symbol.  Also, we can currently only do this if the
1274      child symbol is already exists and is placed in a fragment.  */
1275
1276   if (csym == NULL || symbol_get_frag (csym) == NULL)
1277     {
1278       as_bad ("expected `%s' to have already been set for .vtable_inherit",
1279               cname);
1280       bad = 1;
1281     }
1282
1283   *input_line_pointer = c;
1284
1285   SKIP_WHITESPACE ();
1286   if (*input_line_pointer != ',')
1287     {
1288       as_bad ("expected comma after name in .vtable_inherit");
1289       ignore_rest_of_line ();
1290       return NULL;
1291     }
1292
1293   ++input_line_pointer;
1294   SKIP_WHITESPACE ();
1295
1296   if (*input_line_pointer == '#')
1297     ++input_line_pointer;
1298
1299   if (input_line_pointer[0] == '0'
1300       && (input_line_pointer[1] == '\0'
1301           || ISSPACE (input_line_pointer[1])))
1302     {
1303       psym = section_symbol (absolute_section);
1304       ++input_line_pointer;
1305     }
1306   else
1307     {
1308       pname = input_line_pointer;
1309       c = get_symbol_end ();
1310       psym = symbol_find_or_make (pname);
1311       *input_line_pointer = c;
1312     }
1313
1314   demand_empty_rest_of_line ();
1315
1316   if (bad)
1317     return NULL;
1318
1319   assert (symbol_get_value_expression (csym)->X_op == O_constant);
1320   return fix_new (symbol_get_frag (csym),
1321                   symbol_get_value_expression (csym)->X_add_number,
1322                   0, psym, 0, 0, BFD_RELOC_VTABLE_INHERIT);
1323 }
1324
1325 /* This handles the .vtable_entry pseudo-op, which is used to indicate
1326    to the linker that a vtable slot was used.  The syntax is
1327    ".vtable_entry tablename, offset".  */
1328
1329 struct fix *
1330 obj_elf_vtable_entry (int ignore ATTRIBUTE_UNUSED)
1331 {
1332   char *name;
1333   symbolS *sym;
1334   offsetT offset;
1335   char c;
1336
1337   if (*input_line_pointer == '#')
1338     ++input_line_pointer;
1339
1340   name = input_line_pointer;
1341   c = get_symbol_end ();
1342   sym = symbol_find_or_make (name);
1343   *input_line_pointer = c;
1344
1345   SKIP_WHITESPACE ();
1346   if (*input_line_pointer != ',')
1347     {
1348       as_bad ("expected comma after name in .vtable_entry");
1349       ignore_rest_of_line ();
1350       return NULL;
1351     }
1352
1353   ++input_line_pointer;
1354   if (*input_line_pointer == '#')
1355     ++input_line_pointer;
1356
1357   offset = get_absolute_expression ();
1358
1359   demand_empty_rest_of_line ();
1360
1361   return fix_new (frag_now, frag_now_fix (), 0, sym, offset, 0,
1362                   BFD_RELOC_VTABLE_ENTRY);
1363 }
1364
1365 void
1366 elf_obj_read_begin_hook (void)
1367 {
1368 #ifdef NEED_ECOFF_DEBUG
1369   if (ECOFF_DEBUGGING)
1370     ecoff_read_begin_hook ();
1371 #endif
1372 }
1373
1374 void
1375 elf_obj_symbol_new_hook (symbolS *symbolP)
1376 {
1377   struct elf_obj_sy *sy_obj;
1378
1379   sy_obj = symbol_get_obj (symbolP);
1380   sy_obj->size = NULL;
1381   sy_obj->versioned_name = NULL;
1382
1383 #ifdef NEED_ECOFF_DEBUG
1384   if (ECOFF_DEBUGGING)
1385     ecoff_symbol_new_hook (symbolP);
1386 #endif
1387 }
1388
1389 /* When setting one symbol equal to another, by default we probably
1390    want them to have the same "size", whatever it means in the current
1391    context.  */
1392
1393 void
1394 elf_copy_symbol_attributes (symbolS *dest, symbolS *src)
1395 {
1396   struct elf_obj_sy *srcelf = symbol_get_obj (src);
1397   struct elf_obj_sy *destelf = symbol_get_obj (dest);
1398   if (srcelf->size)
1399     {
1400       if (destelf->size == NULL)
1401         destelf->size = xmalloc (sizeof (expressionS));
1402       *destelf->size = *srcelf->size;
1403     }
1404   else
1405     {
1406       if (destelf->size != NULL)
1407         free (destelf->size);
1408       destelf->size = NULL;
1409     }
1410   S_SET_SIZE (dest, S_GET_SIZE (src));
1411   /* Don't copy visibility.  */
1412   S_SET_OTHER (dest, (ELF_ST_VISIBILITY (S_GET_OTHER (dest))
1413                       | (S_GET_OTHER (src) & ~ELF_ST_VISIBILITY (-1))));
1414 }
1415
1416 void
1417 obj_elf_version (int ignore ATTRIBUTE_UNUSED)
1418 {
1419   char *name;
1420   unsigned int c;
1421   char *p;
1422   asection *seg = now_seg;
1423   subsegT subseg = now_subseg;
1424   Elf_Internal_Note i_note;
1425   Elf_External_Note e_note;
1426   asection *note_secp = NULL;
1427
1428   SKIP_WHITESPACE ();
1429   if (*input_line_pointer == '\"')
1430     {
1431       unsigned int len;
1432
1433       ++input_line_pointer;     /* -> 1st char of string.  */
1434       name = input_line_pointer;
1435
1436       while (is_a_char (c = next_char_of_string ()))
1437         ;
1438       c = *input_line_pointer;
1439       *input_line_pointer = '\0';
1440       *(input_line_pointer - 1) = '\0';
1441       *input_line_pointer = c;
1442
1443       /* Create the .note section.  */
1444       note_secp = subseg_new (".note", 0);
1445       bfd_set_section_flags (stdoutput,
1446                              note_secp,
1447                              SEC_HAS_CONTENTS | SEC_READONLY);
1448
1449       /* Process the version string.  */
1450       len = strlen (name) + 1;
1451
1452       /* PR 3456: Although the name field is padded out to an 4-byte
1453          boundary, the namesz field should not be adjusted.  */
1454       i_note.namesz = len;
1455       i_note.descsz = 0;        /* No description.  */
1456       i_note.type = NT_VERSION;
1457       p = frag_more (sizeof (e_note.namesz));
1458       md_number_to_chars (p, i_note.namesz, sizeof (e_note.namesz));
1459       p = frag_more (sizeof (e_note.descsz));
1460       md_number_to_chars (p, i_note.descsz, sizeof (e_note.descsz));
1461       p = frag_more (sizeof (e_note.type));
1462       md_number_to_chars (p, i_note.type, sizeof (e_note.type));
1463       p = frag_more (len);
1464       memcpy (p, name, len);
1465
1466       frag_align (2, 0, 0);
1467
1468       subseg_set (seg, subseg);
1469     }
1470   else
1471     as_bad (_("expected quoted string"));
1472
1473   demand_empty_rest_of_line ();
1474 }
1475
1476 static void
1477 obj_elf_size (int ignore ATTRIBUTE_UNUSED)
1478 {
1479   char *name = input_line_pointer;
1480   char c = get_symbol_end ();
1481   char *p;
1482   expressionS exp;
1483   symbolS *sym;
1484
1485   p = input_line_pointer;
1486   *p = c;
1487   SKIP_WHITESPACE ();
1488   if (*input_line_pointer != ',')
1489     {
1490       *p = 0;
1491       as_bad (_("expected comma after name `%s' in .size directive"), name);
1492       *p = c;
1493       ignore_rest_of_line ();
1494       return;
1495     }
1496   input_line_pointer++;
1497   expression (&exp);
1498   if (exp.X_op == O_absent)
1499     {
1500       as_bad (_("missing expression in .size directive"));
1501       exp.X_op = O_constant;
1502       exp.X_add_number = 0;
1503     }
1504   *p = 0;
1505   sym = symbol_find_or_make (name);
1506   *p = c;
1507   if (exp.X_op == O_constant)
1508     {
1509       S_SET_SIZE (sym, exp.X_add_number);
1510       if (symbol_get_obj (sym)->size)
1511         {
1512           xfree (symbol_get_obj (sym)->size);
1513           symbol_get_obj (sym)->size = NULL;
1514         }
1515     }
1516   else
1517     {
1518       symbol_get_obj (sym)->size = xmalloc (sizeof (expressionS));
1519       *symbol_get_obj (sym)->size = exp;
1520     }
1521   demand_empty_rest_of_line ();
1522 }
1523
1524 /* Handle the ELF .type pseudo-op.  This sets the type of a symbol.
1525    There are five syntaxes:
1526
1527    The first (used on Solaris) is
1528        .type SYM,#function
1529    The second (used on UnixWare) is
1530        .type SYM,@function
1531    The third (reportedly to be used on Irix 6.0) is
1532        .type SYM STT_FUNC
1533    The fourth (used on NetBSD/Arm and Linux/ARM) is
1534        .type SYM,%function
1535    The fifth (used on SVR4/860) is
1536        .type SYM,"function"
1537    */
1538
1539 static void
1540 obj_elf_type (int ignore ATTRIBUTE_UNUSED)
1541 {
1542   char *name;
1543   char c;
1544   int type;
1545   const char *typename;
1546   symbolS *sym;
1547   elf_symbol_type *elfsym;
1548
1549   name = input_line_pointer;
1550   c = get_symbol_end ();
1551   sym = symbol_find_or_make (name);
1552   elfsym = (elf_symbol_type *) symbol_get_bfdsym (sym);
1553   *input_line_pointer = c;
1554
1555   SKIP_WHITESPACE ();
1556   if (*input_line_pointer == ',')
1557     ++input_line_pointer;
1558
1559   SKIP_WHITESPACE ();
1560   if (   *input_line_pointer == '#'
1561       || *input_line_pointer == '@'
1562       || *input_line_pointer == '"'
1563       || *input_line_pointer == '%')
1564     ++input_line_pointer;
1565
1566   typename = input_line_pointer;
1567   c = get_symbol_end ();
1568
1569   type = 0;
1570   if (strcmp (typename, "function") == 0
1571       || strcmp (typename, "STT_FUNC") == 0)
1572     type = BSF_FUNCTION;
1573   else if (strcmp (typename, "object") == 0
1574            || strcmp (typename, "STT_OBJECT") == 0)
1575     type = BSF_OBJECT;
1576   else if (strcmp (typename, "tls_object") == 0
1577            || strcmp (typename, "STT_TLS") == 0)
1578     type = BSF_OBJECT | BSF_THREAD_LOCAL;
1579   else if (strcmp (typename, "notype") == 0
1580            || strcmp (typename, "STT_NOTYPE") == 0)
1581     ;
1582 #ifdef md_elf_symbol_type
1583   else if ((type = md_elf_symbol_type (typename, sym, elfsym)) != -1)
1584     ;
1585 #endif
1586   else
1587     as_bad (_("unrecognized symbol type \"%s\""), typename);
1588
1589   *input_line_pointer = c;
1590
1591   if (*input_line_pointer == '"')
1592     ++input_line_pointer;
1593
1594   elfsym->symbol.flags |= type;
1595
1596   demand_empty_rest_of_line ();
1597 }
1598
1599 static void
1600 obj_elf_ident (int ignore ATTRIBUTE_UNUSED)
1601 {
1602   static segT comment_section;
1603   segT old_section = now_seg;
1604   int old_subsection = now_subseg;
1605
1606 #ifdef md_flush_pending_output
1607   md_flush_pending_output ();
1608 #endif
1609
1610   if (!comment_section)
1611     {
1612       char *p;
1613       comment_section = subseg_new (".comment", 0);
1614       bfd_set_section_flags (stdoutput, comment_section,
1615                              SEC_READONLY | SEC_HAS_CONTENTS);
1616       p = frag_more (1);
1617       *p = 0;
1618     }
1619   else
1620     subseg_set (comment_section, 0);
1621   stringer (1);
1622   subseg_set (old_section, old_subsection);
1623 }
1624
1625 #ifdef INIT_STAB_SECTION
1626
1627 /* The first entry in a .stabs section is special.  */
1628
1629 void
1630 obj_elf_init_stab_section (segT seg)
1631 {
1632   char *file;
1633   char *p;
1634   char *stabstr_name;
1635   unsigned int stroff;
1636
1637   /* Force the section to align to a longword boundary.  Without this,
1638      UnixWare ar crashes.  */
1639   (void) bfd_set_section_alignment (stdoutput, seg, 2);
1640
1641   /* Make space for this first symbol.  */
1642   p = frag_more (12);
1643   /* Zero it out.  */
1644   memset (p, 0, 12);
1645   as_where (&file, NULL);
1646   stabstr_name = xmalloc (strlen (segment_name (seg)) + 4);
1647   strcpy (stabstr_name, segment_name (seg));
1648   strcat (stabstr_name, "str");
1649   stroff = get_stab_string_offset (file, stabstr_name);
1650   know (stroff == 1);
1651   md_number_to_chars (p, stroff, 4);
1652   seg_info (seg)->stabu.p = p;
1653 }
1654
1655 #endif
1656
1657 /* Fill in the counts in the first entry in a .stabs section.  */
1658
1659 static void
1660 adjust_stab_sections (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1661 {
1662   char *name;
1663   asection *strsec;
1664   char *p;
1665   int strsz, nsyms;
1666
1667   if (strncmp (".stab", sec->name, 5))
1668     return;
1669   if (!strcmp ("str", sec->name + strlen (sec->name) - 3))
1670     return;
1671
1672   name = alloca (strlen (sec->name) + 4);
1673   strcpy (name, sec->name);
1674   strcat (name, "str");
1675   strsec = bfd_get_section_by_name (abfd, name);
1676   if (strsec)
1677     strsz = bfd_section_size (abfd, strsec);
1678   else
1679     strsz = 0;
1680   nsyms = bfd_section_size (abfd, sec) / 12 - 1;
1681
1682   p = seg_info (sec)->stabu.p;
1683   assert (p != 0);
1684
1685   bfd_h_put_16 (abfd, nsyms, p + 6);
1686   bfd_h_put_32 (abfd, strsz, p + 8);
1687 }
1688
1689 #ifdef NEED_ECOFF_DEBUG
1690
1691 /* This function is called by the ECOFF code.  It is supposed to
1692    record the external symbol information so that the backend can
1693    write it out correctly.  The ELF backend doesn't actually handle
1694    this at the moment, so we do it ourselves.  We save the information
1695    in the symbol.  */
1696
1697 #ifdef OBJ_MAYBE_ELF
1698 static
1699 #endif
1700 void
1701 elf_ecoff_set_ext (symbolS *sym, struct ecoff_extr *ext)
1702 {
1703   symbol_get_bfdsym (sym)->udata.p = ext;
1704 }
1705
1706 /* This function is called by bfd_ecoff_debug_externals.  It is
1707    supposed to *EXT to the external symbol information, and return
1708    whether the symbol should be used at all.  */
1709
1710 static bfd_boolean
1711 elf_get_extr (asymbol *sym, EXTR *ext)
1712 {
1713   if (sym->udata.p == NULL)
1714     return FALSE;
1715   *ext = *(EXTR *) sym->udata.p;
1716   return TRUE;
1717 }
1718
1719 /* This function is called by bfd_ecoff_debug_externals.  It has
1720    nothing to do for ELF.  */
1721
1722 static void
1723 elf_set_index (asymbol *sym ATTRIBUTE_UNUSED,
1724                bfd_size_type indx ATTRIBUTE_UNUSED)
1725 {
1726 }
1727
1728 #endif /* NEED_ECOFF_DEBUG */
1729
1730 void
1731 elf_frob_symbol (symbolS *symp, int *puntp)
1732 {
1733   struct elf_obj_sy *sy_obj;
1734
1735 #ifdef NEED_ECOFF_DEBUG
1736   if (ECOFF_DEBUGGING)
1737     ecoff_frob_symbol (symp);
1738 #endif
1739
1740   sy_obj = symbol_get_obj (symp);
1741
1742   if (sy_obj->size != NULL)
1743     {
1744       switch (sy_obj->size->X_op)
1745         {
1746         case O_subtract:
1747           S_SET_SIZE (symp,
1748                       (S_GET_VALUE (sy_obj->size->X_add_symbol)
1749                        + sy_obj->size->X_add_number
1750                        - S_GET_VALUE (sy_obj->size->X_op_symbol)));
1751           break;
1752         case O_constant:
1753           S_SET_SIZE (symp,
1754                       (S_GET_VALUE (sy_obj->size->X_add_symbol)
1755                        + sy_obj->size->X_add_number));
1756           break;
1757         default:
1758           as_bad (_(".size expression too complicated to fix up"));
1759           break;
1760         }
1761       free (sy_obj->size);
1762       sy_obj->size = NULL;
1763     }
1764
1765   if (sy_obj->versioned_name != NULL)
1766     {
1767       char *p;
1768
1769       p = strchr (sy_obj->versioned_name, ELF_VER_CHR);
1770       know (p != NULL);
1771
1772       /* This symbol was given a new name with the .symver directive.
1773
1774          If this is an external reference, just rename the symbol to
1775          include the version string.  This will make the relocs be
1776          against the correct versioned symbol.
1777
1778          If this is a definition, add an alias.  FIXME: Using an alias
1779          will permit the debugging information to refer to the right
1780          symbol.  However, it's not clear whether it is the best
1781          approach.  */
1782
1783       if (! S_IS_DEFINED (symp))
1784         {
1785           /* Verify that the name isn't using the @@ syntax--this is
1786              reserved for definitions of the default version to link
1787              against.  */
1788           if (p[1] == ELF_VER_CHR)
1789             {
1790               as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"),
1791                       sy_obj->versioned_name);
1792               *puntp = TRUE;
1793             }
1794           S_SET_NAME (symp, sy_obj->versioned_name);
1795         }
1796       else
1797         {
1798           if (p[1] == ELF_VER_CHR && p[2] == ELF_VER_CHR)
1799             {
1800               size_t l;
1801
1802               /* The @@@ syntax is a special case. It renames the
1803                  symbol name to versioned_name with one `@' removed.  */
1804               l = strlen (&p[3]) + 1;
1805               memmove (&p[2], &p[3], l);
1806               S_SET_NAME (symp, sy_obj->versioned_name);
1807             }
1808           else
1809             {
1810               symbolS *symp2;
1811
1812               /* FIXME: Creating a new symbol here is risky.  We're
1813                  in the final loop over the symbol table.  We can
1814                  get away with it only because the symbol goes to
1815                  the end of the list, where the loop will still see
1816                  it.  It would probably be better to do this in
1817                  obj_frob_file_before_adjust.  */
1818
1819               symp2 = symbol_find_or_make (sy_obj->versioned_name);
1820
1821               /* Now we act as though we saw symp2 = sym.  */
1822
1823               S_SET_SEGMENT (symp2, S_GET_SEGMENT (symp));
1824
1825               /* Subtracting out the frag address here is a hack
1826                  because we are in the middle of the final loop.  */
1827               S_SET_VALUE (symp2,
1828                            (S_GET_VALUE (symp)
1829                             - symbol_get_frag (symp)->fr_address));
1830
1831               symbol_set_frag (symp2, symbol_get_frag (symp));
1832
1833               /* This will copy over the size information.  */
1834               copy_symbol_attributes (symp2, symp);
1835
1836               S_SET_OTHER (symp2, S_GET_OTHER (symp));
1837
1838               if (S_IS_WEAK (symp))
1839                 S_SET_WEAK (symp2);
1840
1841               if (S_IS_EXTERNAL (symp))
1842                 S_SET_EXTERNAL (symp2);
1843             }
1844         }
1845     }
1846
1847   /* Double check weak symbols.  */
1848   if (S_IS_WEAK (symp))
1849     {
1850       if (S_IS_COMMON (symp))
1851         as_bad (_("symbol `%s' can not be both weak and common"),
1852                 S_GET_NAME (symp));
1853     }
1854
1855 #ifdef TC_MIPS
1856   /* The Irix 5 and 6 assemblers set the type of any common symbol and
1857      any undefined non-function symbol to STT_OBJECT.  We try to be
1858      compatible, since newer Irix 5 and 6 linkers care.  However, we
1859      only set undefined symbols to be STT_OBJECT if we are on Irix,
1860      because that is the only time gcc will generate the necessary
1861      .global directives to mark functions.  */
1862
1863   if (S_IS_COMMON (symp))
1864     symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
1865
1866   if (strstr (TARGET_OS, "irix") != NULL
1867       && ! S_IS_DEFINED (symp)
1868       && (symbol_get_bfdsym (symp)->flags & BSF_FUNCTION) == 0)
1869     symbol_get_bfdsym (symp)->flags |= BSF_OBJECT;
1870 #endif
1871 }
1872
1873 struct group_list
1874 {
1875   asection **head;              /* Section lists.  */
1876   unsigned int *elt_count;      /* Number of sections in each list.  */
1877   unsigned int num_group;       /* Number of lists.  */
1878 };
1879
1880 /* Called via bfd_map_over_sections.  If SEC is a member of a group,
1881    add it to a list of sections belonging to the group.  INF is a
1882    pointer to a struct group_list, which is where we store the head of
1883    each list.  */
1884
1885 static void
1886 build_group_lists (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
1887 {
1888   struct group_list *list = inf;
1889   const char *group_name = elf_group_name (sec);
1890   unsigned int i;
1891
1892   if (group_name == NULL)
1893     return;
1894
1895   /* If this group already has a list, add the section to the head of
1896      the list.  */
1897   for (i = 0; i < list->num_group; i++)
1898     {
1899       if (strcmp (group_name, elf_group_name (list->head[i])) == 0)
1900         {
1901           elf_next_in_group (sec) = list->head[i];
1902           list->head[i] = sec;
1903           list->elt_count[i] += 1;
1904           return;
1905         }
1906     }
1907
1908   /* New group.  Make the arrays bigger in chunks to minimize calls to
1909      realloc.  */
1910   i = list->num_group;
1911   if ((i & 127) == 0)
1912     {
1913       unsigned int newsize = i + 128;
1914       list->head = xrealloc (list->head, newsize * sizeof (*list->head));
1915       list->elt_count = xrealloc (list->elt_count,
1916                                   newsize * sizeof (*list->elt_count));
1917     }
1918   list->head[i] = sec;
1919   list->elt_count[i] = 1;
1920   list->num_group += 1;
1921 }
1922
1923 void
1924 elf_frob_file (void)
1925 {
1926   struct group_list list;
1927   unsigned int i;
1928
1929   bfd_map_over_sections (stdoutput, adjust_stab_sections, NULL);
1930
1931   /* Go find section groups.  */
1932   list.num_group = 0;
1933   list.head = NULL;
1934   list.elt_count = NULL;
1935   bfd_map_over_sections (stdoutput, build_group_lists, &list);
1936
1937   /* Make the SHT_GROUP sections that describe each section group.  We
1938      can't set up the section contents here yet, because elf section
1939      indices have yet to be calculated.  elf.c:set_group_contents does
1940      the rest of the work.  */
1941   for (i = 0; i < list.num_group; i++)
1942     {
1943       const char *group_name = elf_group_name (list.head[i]);
1944       const char *sec_name;
1945       asection *s;
1946       flagword flags;
1947       struct symbol *sy;
1948       int has_sym;
1949       bfd_size_type size;
1950
1951       flags = SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_GROUP;
1952       for (s = list.head[i]; s != NULL; s = elf_next_in_group (s))
1953         if ((s->flags ^ flags) & SEC_LINK_ONCE)
1954           {
1955             flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1956             if (s != list.head[i])
1957               {
1958                 as_warn (_("assuming all members of group `%s' are COMDAT"),
1959                          group_name);
1960                 break;
1961               }
1962           }
1963
1964       sec_name = group_name;
1965       sy = symbol_find_exact (group_name);
1966       has_sym = 0;
1967       if (sy != NULL
1968           && (sy == symbol_lastP
1969               || (sy->sy_next != NULL
1970                   && sy->sy_next->sy_previous == sy)))
1971         {
1972           has_sym = 1;
1973           sec_name = ".group";
1974         }
1975       s = subseg_force_new (sec_name, 0);
1976       if (s == NULL
1977           || !bfd_set_section_flags (stdoutput, s, flags)
1978           || !bfd_set_section_alignment (stdoutput, s, 2))
1979         {
1980           as_fatal (_("can't create group: %s"),
1981                     bfd_errmsg (bfd_get_error ()));
1982         }
1983       elf_section_type (s) = SHT_GROUP;
1984
1985       /* Pass a pointer to the first section in this group.  */
1986       elf_next_in_group (s) = list.head[i];
1987       if (has_sym)
1988         elf_group_id (s) = sy->bsym;
1989
1990       size = 4 * (list.elt_count[i] + 1);
1991       bfd_set_section_size (stdoutput, s, size);
1992       s->contents = (unsigned char *) frag_more (size);
1993       frag_now->fr_fix = frag_now_fix_octets ();
1994       frag_wane (frag_now);
1995     }
1996
1997 #ifdef elf_tc_final_processing
1998   elf_tc_final_processing ();
1999 #endif
2000 }
2001
2002 /* It removes any unneeded versioned symbols from the symbol table.  */
2003
2004 void
2005 elf_frob_file_before_adjust (void)
2006 {
2007   if (symbol_rootP)
2008     {
2009       symbolS *symp;
2010
2011       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2012         if (!S_IS_DEFINED (symp))
2013           {
2014             if (symbol_get_obj (symp)->versioned_name)
2015               {
2016                 char *p;
2017
2018                 /* The @@@ syntax is a special case. If the symbol is
2019                    not defined, 2 `@'s will be removed from the
2020                    versioned_name.  */
2021
2022                 p = strchr (symbol_get_obj (symp)->versioned_name,
2023                             ELF_VER_CHR);
2024                 know (p != NULL);
2025                 if (p[1] == ELF_VER_CHR && p[2] == ELF_VER_CHR)
2026                   {
2027                     size_t l = strlen (&p[3]) + 1;
2028                     memmove (&p[1], &p[3], l);
2029                   }
2030                 if (symbol_used_p (symp) == 0
2031                     && symbol_used_in_reloc_p (symp) == 0)
2032                   symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2033               }
2034
2035             /* If there was .weak foo, but foo was neither defined nor
2036                used anywhere, remove it.  */
2037
2038             else if (S_IS_WEAK (symp)
2039                      && symbol_used_p (symp) == 0
2040                      && symbol_used_in_reloc_p (symp) == 0)
2041               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2042           }
2043     }
2044 }
2045
2046 /* It is required that we let write_relocs have the opportunity to
2047    optimize away fixups before output has begun, since it is possible
2048    to eliminate all fixups for a section and thus we never should
2049    have generated the relocation section.  */
2050
2051 void
2052 elf_frob_file_after_relocs (void)
2053 {
2054 #ifdef NEED_ECOFF_DEBUG
2055   if (ECOFF_DEBUGGING)
2056     /* Generate the ECOFF debugging information.  */
2057     {
2058       const struct ecoff_debug_swap *debug_swap;
2059       struct ecoff_debug_info debug;
2060       char *buf;
2061       asection *sec;
2062
2063       debug_swap
2064         = get_elf_backend_data (stdoutput)->elf_backend_ecoff_debug_swap;
2065       know (debug_swap != NULL);
2066       ecoff_build_debug (&debug.symbolic_header, &buf, debug_swap);
2067
2068       /* Set up the pointers in debug.  */
2069 #define SET(ptr, offset, type) \
2070     debug.ptr = (type) (buf + debug.symbolic_header.offset)
2071
2072       SET (line, cbLineOffset, unsigned char *);
2073       SET (external_dnr, cbDnOffset, void *);
2074       SET (external_pdr, cbPdOffset, void *);
2075       SET (external_sym, cbSymOffset, void *);
2076       SET (external_opt, cbOptOffset, void *);
2077       SET (external_aux, cbAuxOffset, union aux_ext *);
2078       SET (ss, cbSsOffset, char *);
2079       SET (external_fdr, cbFdOffset, void *);
2080       SET (external_rfd, cbRfdOffset, void *);
2081       /* ssext and external_ext are set up just below.  */
2082
2083 #undef SET
2084
2085       /* Set up the external symbols.  */
2086       debug.ssext = debug.ssext_end = NULL;
2087       debug.external_ext = debug.external_ext_end = NULL;
2088       if (! bfd_ecoff_debug_externals (stdoutput, &debug, debug_swap, TRUE,
2089                                        elf_get_extr, elf_set_index))
2090         as_fatal (_("failed to set up debugging information: %s"),
2091                   bfd_errmsg (bfd_get_error ()));
2092
2093       sec = bfd_get_section_by_name (stdoutput, ".mdebug");
2094       assert (sec != NULL);
2095
2096       know (!stdoutput->output_has_begun);
2097
2098       /* We set the size of the section, call bfd_set_section_contents
2099          to force the ELF backend to allocate a file position, and then
2100          write out the data.  FIXME: Is this really the best way to do
2101          this?  */
2102       bfd_set_section_size
2103         (stdoutput, sec, bfd_ecoff_debug_size (stdoutput, &debug, debug_swap));
2104
2105       /* Pass BUF to bfd_set_section_contents because this will
2106          eventually become a call to fwrite, and ISO C prohibits
2107          passing a NULL pointer to a stdio function even if the
2108          pointer will not be used.  */
2109       if (! bfd_set_section_contents (stdoutput, sec, buf, 0, 0))
2110         as_fatal (_("can't start writing .mdebug section: %s"),
2111                   bfd_errmsg (bfd_get_error ()));
2112
2113       know (stdoutput->output_has_begun);
2114       know (sec->filepos != 0);
2115
2116       if (! bfd_ecoff_write_debug (stdoutput, &debug, debug_swap,
2117                                    sec->filepos))
2118         as_fatal (_("could not write .mdebug section: %s"),
2119                   bfd_errmsg (bfd_get_error ()));
2120     }
2121 #endif /* NEED_ECOFF_DEBUG */
2122 }
2123
2124 #ifdef SCO_ELF
2125
2126 /* Heavily plagiarized from obj_elf_version.  The idea is to emit the
2127    SCO specific identifier in the .notes section to satisfy the SCO
2128    linker.
2129
2130    This looks more complicated than it really is.  As opposed to the
2131    "obvious" solution, this should handle the cross dev cases
2132    correctly.  (i.e, hosting on a 64 bit big endian processor, but
2133    generating SCO Elf code) Efficiency isn't a concern, as there
2134    should be exactly one of these sections per object module.
2135
2136    SCO OpenServer 5 identifies it's ELF modules with a standard ELF
2137    .note section.
2138
2139    int_32 namesz  = 4 ;  Name size
2140    int_32 descsz  = 12 ; Descriptive information
2141    int_32 type    = 1 ;
2142    char   name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
2143    int_32 version = (major ver # << 16)  | version of tools ;
2144    int_32 source  = (tool_id << 16 ) | 1 ;
2145    int_32 info    = 0 ;    These are set by the SCO tools, but we
2146                            don't know enough about the source
2147                            environment to set them.  SCO ld currently
2148                            ignores them, and recommends we set them
2149                            to zero.  */
2150
2151 #define SCO_MAJOR_VERSION 0x1
2152 #define SCO_MINOR_VERSION 0x1
2153
2154 void
2155 sco_id (void)
2156 {
2157
2158   char *name;
2159   unsigned int c;
2160   char ch;
2161   char *p;
2162   asection *seg = now_seg;
2163   subsegT subseg = now_subseg;
2164   Elf_Internal_Note i_note;
2165   Elf_External_Note e_note;
2166   asection *note_secp = NULL;
2167   int i, len;
2168
2169   /* create the .note section */
2170
2171   note_secp = subseg_new (".note", 0);
2172   bfd_set_section_flags (stdoutput,
2173                          note_secp,
2174                          SEC_HAS_CONTENTS | SEC_READONLY);
2175
2176   /* process the version string */
2177
2178   i_note.namesz = 4;
2179   i_note.descsz = 12;           /* 12 descriptive bytes */
2180   i_note.type = NT_VERSION;     /* Contains a version string */
2181
2182   p = frag_more (sizeof (i_note.namesz));
2183   md_number_to_chars (p, i_note.namesz, 4);
2184
2185   p = frag_more (sizeof (i_note.descsz));
2186   md_number_to_chars (p, i_note.descsz, 4);
2187
2188   p = frag_more (sizeof (i_note.type));
2189   md_number_to_chars (p, i_note.type, 4);
2190
2191   p = frag_more (4);
2192   strcpy (p, "SCO");
2193
2194   /* Note: this is the version number of the ELF we're representing */
2195   p = frag_more (4);
2196   md_number_to_chars (p, (SCO_MAJOR_VERSION << 16) | (SCO_MINOR_VERSION), 4);
2197
2198   /* Here, we pick a magic number for ourselves (yes, I "registered"
2199      it with SCO.  The bottom bit shows that we are compat with the
2200      SCO ABI.  */
2201   p = frag_more (4);
2202   md_number_to_chars (p, 0x4c520000 | 0x0001, 4);
2203
2204   /* If we knew (or cared) what the source language options were, we'd
2205      fill them in here.  SCO has given us permission to ignore these
2206      and just set them to zero.  */
2207   p = frag_more (4);
2208   md_number_to_chars (p, 0x0000, 4);
2209
2210   frag_align (2, 0, 0);
2211
2212   /* We probably can't restore the current segment, for there likely
2213      isn't one yet...  */
2214   if (seg && subseg)
2215     subseg_set (seg, subseg);
2216
2217 }
2218
2219 #endif /* SCO_ELF */
2220
2221 static int
2222 elf_separate_stab_sections (void)
2223 {
2224 #ifdef NEED_ECOFF_DEBUG
2225   return (!ECOFF_DEBUGGING);
2226 #else
2227   return 1;
2228 #endif
2229 }
2230
2231 static void
2232 elf_init_stab_section (segT seg)
2233 {
2234 #ifdef NEED_ECOFF_DEBUG
2235   if (!ECOFF_DEBUGGING)
2236 #endif
2237     obj_elf_init_stab_section (seg);
2238 }
2239
2240 const struct format_ops elf_format_ops =
2241 {
2242   bfd_target_elf_flavour,
2243   0,    /* dfl_leading_underscore */
2244   1,    /* emit_section_symbols */
2245   elf_begin,
2246   elf_file_symbol,
2247   elf_frob_symbol,
2248   elf_frob_file,
2249   elf_frob_file_before_adjust,
2250   0,    /* obj_frob_file_before_fix */
2251   elf_frob_file_after_relocs,
2252   elf_s_get_size, elf_s_set_size,
2253   elf_s_get_align, elf_s_set_align,
2254   elf_s_get_other,
2255   elf_s_set_other,
2256   0,    /* s_get_desc */
2257   0,    /* s_set_desc */
2258   0,    /* s_get_type */
2259   0,    /* s_set_type */
2260   elf_copy_symbol_attributes,
2261 #ifdef NEED_ECOFF_DEBUG
2262   ecoff_generate_asm_lineno,
2263   ecoff_stab,
2264 #else
2265   0,    /* generate_asm_lineno */
2266   0,    /* process_stab */
2267 #endif
2268   elf_separate_stab_sections,
2269   elf_init_stab_section,
2270   elf_sec_sym_ok_for_reloc,
2271   elf_pop_insert,
2272 #ifdef NEED_ECOFF_DEBUG
2273   elf_ecoff_set_ext,
2274 #else
2275   0,    /* ecoff_set_ext */
2276 #endif
2277   elf_obj_read_begin_hook,
2278   elf_obj_symbol_new_hook
2279 };