gas/config/obj-elf.c

   1 /* ELF object file format
   2    Copyright (C) 1992, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as
   8    published by the Free Software Foundation; either version 2,
   9    or (at your option) any later version.
  10
  11    GAS is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  14    the GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to the Free
  18    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  19    02111-1307, USA. */
  20
  21 #define OBJ_HEADER "obj-elf.h"
  22 #include "as.h"
  23 #include "subsegs.h"
  24 #include "obstack.h"
  25
  26 #ifndef ECOFF_DEBUGGING
  27 #define ECOFF_DEBUGGING 0
  28 #else
  29 #define NEED_ECOFF_DEBUG
  30 #endif
  31
  32 #ifdef NEED_ECOFF_DEBUG
  33 #include "ecoff.h"
  34 #endif
  35
  36 #ifdef TC_MIPS
  37 #include "elf/mips.h"
  38 #endif
  39
  40 #ifdef TC_PPC
  41 #include "elf/ppc.h"
  42 #endif
  43
  44 static bfd_vma elf_s_get_size PARAMS ((symbolS *));
  45 static void elf_s_set_size PARAMS ((symbolS *, bfd_vma));
  46 static bfd_vma elf_s_get_align PARAMS ((symbolS *));
  47 static void elf_s_set_align PARAMS ((symbolS *, bfd_vma));
  48 static void elf_copy_symbol_attributes PARAMS ((symbolS *, symbolS *));
  49 static int elf_sec_sym_ok_for_reloc PARAMS ((asection *));
  50 static void adjust_stab_sections PARAMS ((bfd *, asection *, PTR));
  51
  52 #ifdef NEED_ECOFF_DEBUG
  53 static boolean elf_get_extr PARAMS ((asymbol *, EXTR *));
  54 static void elf_set_index PARAMS ((asymbol *, bfd_size_type));
  55 #endif
  56
  57 static void obj_elf_line PARAMS ((int));
  58 void obj_elf_version PARAMS ((int));
  59 static void obj_elf_size PARAMS ((int));
  60 static void obj_elf_type PARAMS ((int));
  61 static void obj_elf_ident PARAMS ((int));
  62 static void obj_elf_weak PARAMS ((int));
  63 static void obj_elf_local PARAMS ((int));
  64 static void obj_elf_common PARAMS ((int));
  65 static void obj_elf_symver PARAMS ((int));
  66 static void obj_elf_data PARAMS ((int));
  67 static void obj_elf_text PARAMS ((int));
  68
  69 static const pseudo_typeS elf_pseudo_table[] =
  70 {
  71   {"comm", obj_elf_common, 0},
  72   {"ident", obj_elf_ident, 0},
  73   {"local", obj_elf_local, 0},
  74   {"previous", obj_elf_previous, 0},
  75   {"section", obj_elf_section, 0},
  76   {"section.s", obj_elf_section, 0},
  77   {"sect", obj_elf_section, 0},
  78   {"sect.s", obj_elf_section, 0},
  79   {"size", obj_elf_size, 0},
  80   {"type", obj_elf_type, 0},
  81   {"version", obj_elf_version, 0},
  82   {"weak", obj_elf_weak, 0},
  83
  84   /* These are used for stabs-in-elf configurations.  */
  85   {"line", obj_elf_line, 0},
  86
  87   /* This is a GNU extension to handle symbol versions.  */
  88   {"symver", obj_elf_symver, 0},
  89
  90   /* These are used for dwarf. */
  91   {"2byte", cons, 2},
  92   {"4byte", cons, 4},
  93   {"8byte", cons, 8},
  94
  95   /* We need to trap the section changing calls to handle .previous.  */
  96   {"data", obj_elf_data, 0},
  97   {"text", obj_elf_text, 0},
  98
  99   /* End sentinel.  */
 100   {NULL},
 101 };
 102
 103 static const pseudo_typeS ecoff_debug_pseudo_table[] =
 104 {
 105 #ifdef NEED_ECOFF_DEBUG
 106   /* COFF style debugging information for ECOFF. .ln is not used; .loc
 107      is used instead.  */
 108   { "def",      ecoff_directive_def,    0 },
 109   { "dim",      ecoff_directive_dim,    0 },
 110   { "endef",    ecoff_directive_endef,  0 },
 111   { "file",     ecoff_directive_file,   0 },
 112   { "scl",      ecoff_directive_scl,    0 },
 113   { "tag",      ecoff_directive_tag,    0 },
 114   { "val",      ecoff_directive_val,    0 },
 115
 116   /* COFF debugging requires pseudo-ops .size and .type, but ELF
 117      already has meanings for those.  We use .esize and .etype
 118      instead.  These are only generated by gcc anyhow.  */
 119   { "esize",    ecoff_directive_size,   0 },
 120   { "etype",    ecoff_directive_type,   0 },
 121
 122   /* ECOFF specific debugging information.  */
 123   { "begin",    ecoff_directive_begin,  0 },
 124   { "bend",     ecoff_directive_bend,   0 },
 125   { "end",      ecoff_directive_end,    0 },
 126   { "ent",      ecoff_directive_ent,    0 },
 127   { "fmask",    ecoff_directive_fmask,  0 },
 128   { "frame",    ecoff_directive_frame,  0 },
 129   { "loc",      ecoff_directive_loc,    0 },
 130   { "mask",     ecoff_directive_mask,   0 },
 131
 132   /* Other ECOFF directives.  */
 133   { "extern",   ecoff_directive_extern, 0 },
 134
 135   /* These are used on Irix.  I don't know how to implement them.  */
 136   { "alias",    s_ignore,               0 },
 137   { "bgnb",     s_ignore,               0 },
 138   { "endb",     s_ignore,               0 },
 139   { "lab",      s_ignore,               0 },
 140   { "noalias",  s_ignore,               0 },
 141   { "verstamp", s_ignore,               0 },
 142   { "vreg",     s_ignore,               0 },
 143 #endif
 144
 145   {NULL}                        /* end sentinel */
 146 };
 147
 148 #undef NO_RELOC
 149 #include "aout/aout64.h"
 150
 151 /* This is called when the assembler starts.  */
 152
 153 void
 154 elf_begin ()
 155 {
 156   /* Add symbols for the known sections to the symbol table.  */
 157   symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput,
 158                                                                 ".text")));
 159   symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput,
 160                                                                 ".data")));
 161   symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput,
 162                                                                 ".bss")));
 163 }
 164
 165 void
 166 elf_pop_insert ()
 167 {
 168   pop_insert (elf_pseudo_table);
 169   if (ECOFF_DEBUGGING)
 170     pop_insert (ecoff_debug_pseudo_table);
 171 }
 172
 173 static bfd_vma
 174 elf_s_get_size (sym)
 175      symbolS *sym;
 176 {
 177   return S_GET_SIZE (sym);
 178 }
 179
 180 static void
 181 elf_s_set_size (sym, sz)
 182      symbolS *sym;
 183      bfd_vma sz;
 184 {
 185   S_SET_SIZE (sym, sz);
 186 }
 187
 188 static bfd_vma
 189 elf_s_get_align (sym)
 190      symbolS *sym;
 191 {
 192   return S_GET_ALIGN (sym);
 193 }
 194
 195 static void
 196 elf_s_set_align (sym, align)
 197      symbolS *sym;
 198      bfd_vma align;
 199 {
 200   S_SET_ALIGN (sym, align);
 201 }
 202
 203 static void
 204 elf_copy_symbol_attributes (dest, src)
 205      symbolS *dest, *src;
 206 {
 207   OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
 208 }
 209
 210 static int
 211 elf_sec_sym_ok_for_reloc (sec)
 212      asection *sec;
 213 {
 214   return obj_sec_sym_ok_for_reloc (sec);
 215 }
 216
 217 void
 218 elf_file_symbol (s)
 219      char *s;
 220 {
 221   symbolS *sym;
 222
 223   sym = symbol_new (s, absolute_section, (valueT) 0, (struct frag *) 0);
 224   sym->sy_frag = &zero_address_frag;
 225   sym->bsym->flags |= BSF_FILE;
 226
 227   if (symbol_rootP != sym)
 228     {
 229       symbol_remove (sym, &symbol_rootP, &symbol_lastP);
 230       symbol_insert (sym, symbol_rootP, &symbol_rootP, &symbol_lastP);
 231 #ifdef DEBUG
 232       verify_symbol_chain (symbol_rootP, symbol_lastP);
 233 #endif
 234     }
 235
 236 #ifdef NEED_ECOFF_DEBUG
 237   ecoff_new_file (s);
 238 #endif
 239 }
 240
 241 static void
 242 obj_elf_common (ignore)
 243      int ignore;
 244 {
 245   char *name;
 246   char c;
 247   char *p;
 248   int temp, size;
 249   symbolS *symbolP;
 250   int have_align;
 251
 252   name = input_line_pointer;
 253   c = get_symbol_end ();
 254   /* just after name is now '\0' */
 255   p = input_line_pointer;
 256   *p = c;
 257   SKIP_WHITESPACE ();
 258   if (*input_line_pointer != ',')
 259     {
 260       as_bad ("Expected comma after symbol-name");
 261       ignore_rest_of_line ();
 262       return;
 263     }
 264   input_line_pointer++;         /* skip ',' */
 265   if ((temp = get_absolute_expression ()) < 0)
 266     {
 267       as_bad (".COMMon length (%d.) <0! Ignored.", temp);
 268       ignore_rest_of_line ();
 269       return;
 270     }
 271   size = temp;
 272   *p = 0;
 273   symbolP = symbol_find_or_make (name);
 274   *p = c;
 275   if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
 276     {
 277       as_bad ("Ignoring attempt to re-define symbol");
 278       ignore_rest_of_line ();
 279       return;
 280     }
 281   if (S_GET_VALUE (symbolP) != 0)
 282     {
 283       if (S_GET_VALUE (symbolP) != size)
 284         {
 285           as_warn ("Length of .comm \"%s\" is already %ld. Not changed to %d.",
 286                    S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), size);
 287         }
 288     }
 289   know (symbolP->sy_frag == &zero_address_frag);
 290   if (*input_line_pointer != ',')
 291     have_align = 0;
 292   else
 293     {
 294       have_align = 1;
 295       input_line_pointer++;
 296       SKIP_WHITESPACE ();
 297     }
 298   if (! have_align || *input_line_pointer != '"')
 299     {
 300       if (! have_align)
 301         temp = 0;
 302       else
 303         {
 304           temp = get_absolute_expression ();
 305           if (temp < 0)
 306             {
 307               temp = 0;
 308               as_warn ("Common alignment negative; 0 assumed");
 309             }
 310         }
 311       if (symbolP->local)
 312         {
 313           segT old_sec;
 314           int old_subsec;
 315           char *pfrag;
 316           int align;
 317
 318         /* allocate_bss: */
 319           old_sec = now_seg;
 320           old_subsec = now_subseg;
 321           if (temp)
 322             {
 323               /* convert to a power of 2 alignment */
 324               for (align = 0; (temp & 1) == 0; temp >>= 1, ++align);
 325               if (temp != 1)
 326                 {
 327                   as_bad ("Common alignment not a power of 2");
 328                   ignore_rest_of_line ();
 329                   return;
 330                 }
 331             }
 332           else
 333             align = 0;
 334           record_alignment (bss_section, align);
 335           subseg_set (bss_section, 0);
 336           if (align)
 337             frag_align (align, 0, 0);
 338           if (S_GET_SEGMENT (symbolP) == bss_section)
 339             symbolP->sy_frag->fr_symbol = 0;
 340           symbolP->sy_frag = frag_now;
 341           pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
 342                             (offsetT) size, (char *) 0);
 343           *pfrag = 0;
 344           S_SET_SIZE (symbolP, size);
 345           S_SET_SEGMENT (symbolP, bss_section);
 346           S_CLEAR_EXTERNAL (symbolP);
 347           subseg_set (old_sec, old_subsec);
 348         }
 349       else
 350         {
 351         allocate_common:
 352           S_SET_VALUE (symbolP, (valueT) size);
 353           S_SET_ALIGN (symbolP, temp);
 354           S_SET_EXTERNAL (symbolP);
 355           S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
 356         }
 357     }
 358   else
 359     {
 360       input_line_pointer++;
 361       /* @@ Some use the dot, some don't.  Can we get some consistency??  */
 362       if (*input_line_pointer == '.')
 363         input_line_pointer++;
 364       /* @@ Some say data, some say bss.  */
 365       if (strncmp (input_line_pointer, "bss\"", 4)
 366           && strncmp (input_line_pointer, "data\"", 5))
 367         {
 368           while (*--input_line_pointer != '"')
 369             ;
 370           input_line_pointer--;
 371           goto bad_common_segment;
 372         }
 373       while (*input_line_pointer++ != '"')
 374         ;
 375       goto allocate_common;
 376     }
 377
 378   symbolP->bsym->flags |= BSF_OBJECT;
 379
 380   demand_empty_rest_of_line ();
 381   return;
 382
 383   {
 384   bad_common_segment:
 385     p = input_line_pointer;
 386     while (*p && *p != '\n')
 387       p++;
 388     c = *p;
 389     *p = '\0';
 390     as_bad ("bad .common segment %s", input_line_pointer + 1);
 391     *p = c;
 392     input_line_pointer = p;
 393     ignore_rest_of_line ();
 394     return;
 395   }
 396 }
 397
 398 static void
 399 obj_elf_local (ignore)
 400      int ignore;
 401 {
 402   char *name;
 403   int c;
 404   symbolS *symbolP;
 405
 406   do
 407     {
 408       name = input_line_pointer;
 409       c = get_symbol_end ();
 410       symbolP = symbol_find_or_make (name);
 411       *input_line_pointer = c;
 412       SKIP_WHITESPACE ();
 413       S_CLEAR_EXTERNAL (symbolP);
 414       symbolP->local = 1;
 415       if (c == ',')
 416         {
 417           input_line_pointer++;
 418           SKIP_WHITESPACE ();
 419           if (*input_line_pointer == '\n')
 420             c = '\n';
 421         }
 422     }
 423   while (c == ',');
 424   demand_empty_rest_of_line ();
 425 }
 426
 427 static void
 428 obj_elf_weak (ignore)
 429      int ignore;
 430 {
 431   char *name;
 432   int c;
 433   symbolS *symbolP;
 434
 435   do
 436     {
 437       name = input_line_pointer;
 438       c = get_symbol_end ();
 439       symbolP = symbol_find_or_make (name);
 440       *input_line_pointer = c;
 441       SKIP_WHITESPACE ();
 442       S_SET_WEAK (symbolP);
 443       symbolP->local = 1;
 444       if (c == ',')
 445         {
 446           input_line_pointer++;
 447           SKIP_WHITESPACE ();
 448           if (*input_line_pointer == '\n')
 449             c = '\n';
 450         }
 451     }
 452   while (c == ',');
 453   demand_empty_rest_of_line ();
 454 }
 455
 456 static segT previous_section;
 457 static int previous_subsection;
 458
 459 /* Handle the .section pseudo-op.  This code supports two different
 460    syntaxes.
 461
 462    The first is found on Solaris, and looks like
 463        .section ".sec1",#alloc,#execinstr,#write
 464    Here the names after '#' are the SHF_* flags to turn on for the
 465    section.  I'm not sure how it determines the SHT_* type (BFD
 466    doesn't really give us control over the type, anyhow).
 467
 468    The second format is found on UnixWare, and probably most SVR4
 469    machines, and looks like
 470        .section .sec1,"a",@progbits
 471    The quoted string may contain any combination of a, w, x, and
 472    represents the SHF_* flags to turn on for the section.  The string
 473    beginning with '@' can be progbits or nobits.  There should be
 474    other possibilities, but I don't know what they are.  In any case,
 475    BFD doesn't really let us set the section type.  */
 476
 477 /* Certain named sections have particular defined types, listed on p.
 478    4-19 of the ABI.  */
 479 struct special_section
 480 {
 481   const char *name;
 482   int type;
 483   int attributes;
 484 };
 485
 486 static struct special_section special_sections[] =
 487 {
 488   { ".bss",     SHT_NOBITS,     SHF_ALLOC + SHF_WRITE           },
 489   { ".comment", SHT_PROGBITS,   0                               },
 490   { ".data",    SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE           },
 491   { ".data1",   SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE           },
 492   { ".debug",   SHT_PROGBITS,   0                               },
 493   { ".fini",    SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR       },
 494   { ".init",    SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR       },
 495   { ".line",    SHT_PROGBITS,   0                               },
 496   { ".note",    SHT_NOTE,       0                               },
 497   { ".rodata",  SHT_PROGBITS,   SHF_ALLOC                       },
 498   { ".rodata1", SHT_PROGBITS,   SHF_ALLOC                       },
 499   { ".text",    SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR       },
 500
 501 #ifdef ELF_TC_SPECIAL_SECTIONS
 502   ELF_TC_SPECIAL_SECTIONS
 503 #endif
 504
 505 #if 0
 506   /* The following section names are special, but they can not
 507      reasonably appear in assembler code.  Some of the attributes are
 508      processor dependent.  */
 509   { ".dynamic", SHT_DYNAMIC,    SHF_ALLOC /* + SHF_WRITE */     },
 510   { ".dynstr",  SHT_STRTAB,     SHF_ALLOC                       },
 511   { ".dynsym",  SHT_DYNSYM,     SHF_ALLOC                       },
 512   { ".got",     SHT_PROGBITS,   0                               },
 513   { ".hash",    SHT_HASH,       SHF_ALLOC                       },
 514   { ".interp",  SHT_PROGBITS,   /* SHF_ALLOC */                 },
 515   { ".plt",     SHT_PROGBITS,   0                               },
 516   { ".shstrtab",SHT_STRTAB,     0                               },
 517   { ".strtab",  SHT_STRTAB,     /* SHF_ALLOC */                 },
 518   { ".symtab",  SHT_SYMTAB,     /* SHF_ALLOC */                 },
 519 #endif
 520
 521   { NULL,       0,              0                               }
 522 };
 523
 524 void
 525 obj_elf_section (xxx)
 526      int xxx;
 527 {
 528   char *string;
 529   int new_sec;
 530   segT sec;
 531   int type, attr;
 532   int i;
 533   flagword flags;
 534   symbolS *secsym;
 535
 536 #ifdef md_flush_pending_output
 537   md_flush_pending_output ();
 538 #endif
 539
 540   if (flag_mri)
 541     {
 542       char mri_type;
 543
 544       previous_section = now_seg;
 545       previous_subsection = now_subseg;
 546
 547       s_mri_sect (&mri_type);
 548
 549 #ifdef md_elf_section_change_hook
 550       md_elf_section_change_hook ();
 551 #endif
 552
 553       return;
 554     }
 555
 556   /* Get name of section.  */
 557   SKIP_WHITESPACE ();
 558   if (*input_line_pointer == '"')
 559     {
 560       string = demand_copy_C_string (&xxx);
 561       if (string == NULL)
 562         {
 563           ignore_rest_of_line ();
 564           return;
 565         }
 566     }
 567   else
 568     {
 569       char *p = input_line_pointer;
 570       char c;
 571       while (0 == strchr ("\n\t,; ", *p))
 572         p++;
 573       if (p == input_line_pointer)
 574         {
 575           as_warn ("Missing section name");
 576           ignore_rest_of_line ();
 577           return;
 578         }
 579       c = *p;
 580       *p = 0;
 581       string = xmalloc ((unsigned long) (p - input_line_pointer + 1));
 582       strcpy (string, input_line_pointer);
 583       *p = c;
 584       input_line_pointer = p;
 585     }
 586
 587   /* Switch to the section, creating it if necessary.  */
 588   previous_section = now_seg;
 589   previous_subsection = now_subseg;
 590
 591   new_sec = bfd_get_section_by_name (stdoutput, string) == NULL;
 592   sec = subseg_new (string, 0);
 593
 594   /* If this section already existed, we don't bother to change the
 595      flag values.  */
 596   if (! new_sec)
 597     {
 598       while (! is_end_of_line[(unsigned char) *input_line_pointer])
 599         ++input_line_pointer;
 600       ++input_line_pointer;
 601
 602 #ifdef md_elf_section_change_hook
 603       md_elf_section_change_hook ();
 604 #endif
 605
 606       return;
 607     }
 608
 609   SKIP_WHITESPACE ();
 610
 611   type = SHT_NULL;
 612   attr = 0;
 613
 614   if (*input_line_pointer == ',')
 615     {
 616       /* Skip the comma.  */
 617       ++input_line_pointer;
 618
 619       SKIP_WHITESPACE ();
 620       if (*input_line_pointer == '"')
 621         {
 622           /* Pick up a string with a combination of a, w, x.  */
 623           ++input_line_pointer;
 624           while (*input_line_pointer != '"')
 625             {
 626               switch (*input_line_pointer)
 627                 {
 628                 case 'a':
 629                   attr |= SHF_ALLOC;
 630                   break;
 631                 case 'w':
 632                   attr |= SHF_WRITE;
 633                   break;
 634                 case 'x':
 635                   attr |= SHF_EXECINSTR;
 636                   break;
 637                 default:
 638                   {
 639                     char *bad_msg = "Bad .section directive: want a,w,x in string";
 640 #ifdef md_elf_section_letter
 641                     int md_attr = md_elf_section_letter (*input_line_pointer, &bad_msg);
 642                     if (md_attr)
 643                       attr |= md_attr;
 644                     else
 645 #endif
 646                       {
 647                         as_warn (bad_msg);
 648                         ignore_rest_of_line ();
 649                         return;
 650                       }
 651                   }
 652                 }
 653               ++input_line_pointer;
 654             }
 655
 656           /* Skip the closing quote.  */
 657           ++input_line_pointer;
 658
 659           SKIP_WHITESPACE ();
 660           if (*input_line_pointer == ',')
 661             {
 662               ++input_line_pointer;
 663               SKIP_WHITESPACE ();
 664               if (*input_line_pointer == '@')
 665                 {
 666                   ++input_line_pointer;
 667                   if (strncmp (input_line_pointer, "progbits",
 668                                sizeof "progbits" - 1) == 0)
 669                     {
 670                       type = SHT_PROGBITS;
 671                       input_line_pointer += sizeof "progbits" - 1;
 672                     }
 673                   else if (strncmp (input_line_pointer, "nobits",
 674                                     sizeof "nobits" - 1) == 0)
 675                     {
 676                       type = SHT_NOBITS;
 677                       input_line_pointer += sizeof "nobits" - 1;
 678                     }
 679                   else
 680                     {
 681 #ifdef md_elf_section_type
 682                     int md_type = md_elf_section_type (&input_line_pointer);
 683                     if (md_type)
 684                       type = md_type;
 685                     else
 686 #endif
 687                       {
 688                         as_warn ("Unrecognized section type");
 689                         ignore_rest_of_line ();
 690                       }
 691                     }
 692                 }
 693             }
 694         }
 695       else
 696         {
 697           do
 698             {
 699               SKIP_WHITESPACE ();
 700               if (*input_line_pointer != '#')
 701                 {
 702                   as_warn ("Bad .section directive");
 703                   ignore_rest_of_line ();
 704                   return;
 705                 }
 706               ++input_line_pointer;
 707               if (strncmp (input_line_pointer, "write",
 708                            sizeof "write" - 1) == 0)
 709                 {
 710                   attr |= SHF_WRITE;
 711                   input_line_pointer += sizeof "write" - 1;
 712                 }
 713               else if (strncmp (input_line_pointer, "alloc",
 714                                 sizeof "alloc" - 1) == 0)
 715                 {
 716                   attr |= SHF_ALLOC;
 717                   input_line_pointer += sizeof "alloc" - 1;
 718                 }
 719               else if (strncmp (input_line_pointer, "execinstr",
 720                                 sizeof "execinstr" - 1) == 0)
 721                 {
 722                   attr |= SHF_EXECINSTR;
 723                   input_line_pointer += sizeof "execinstr" - 1;
 724                 }
 725               else
 726                 {
 727 #ifdef md_elf_section_word
 728                   int md_attr = md_elf_section_word (&input_line_pointer);
 729                   if (md_attr)
 730                     attr |= md_attr;
 731                   else
 732 #endif
 733                     {
 734                       as_warn ("Unrecognized section attribute");
 735                       ignore_rest_of_line ();
 736                       return;
 737                     }
 738                 }
 739               SKIP_WHITESPACE ();
 740             }
 741           while (*input_line_pointer++ == ',');
 742           --input_line_pointer;
 743         }
 744     }
 745
 746   /* See if this is one of the special sections.  */
 747   for (i = 0; special_sections[i].name != NULL; i++)
 748     {
 749       if (string[1] == special_sections[i].name[1]
 750           && strcmp (string, special_sections[i].name) == 0)
 751         {
 752           if (type == SHT_NULL)
 753             type = special_sections[i].type;
 754           else if (type != special_sections[i].type)
 755             as_warn ("Setting incorrect section type for %s", string);
 756
 757           if ((attr &~ special_sections[i].attributes) != 0)
 758             {
 759               /* As a GNU extension, we permit a .note section to be
 760                  allocatable.  If the linker sees an allocateable
 761                  .note section, it will create a PT_NOTE segment in
 762                  the output file.  */
 763               if (strcmp (string, ".note") != 0
 764                   || attr != SHF_ALLOC)
 765                 as_warn ("Setting incorrect section attributes for %s",
 766                          string);
 767             }
 768           attr |= special_sections[i].attributes;
 769
 770           break;
 771         }
 772     }
 773
 774   flags = (SEC_RELOC
 775            | ((attr & SHF_WRITE) ? 0 : SEC_READONLY)
 776            | ((attr & SHF_ALLOC) ? SEC_ALLOC : 0)
 777            | (((attr & SHF_ALLOC) && type != SHT_NOBITS) ? SEC_LOAD : 0)
 778            | ((attr & SHF_EXECINSTR) ? SEC_CODE : 0));
 779   if (special_sections[i].name == NULL)
 780     {
 781       if (type == SHT_PROGBITS)
 782         flags |= SEC_ALLOC | SEC_LOAD;
 783       else if (type == SHT_NOBITS)
 784         {
 785           flags |= SEC_ALLOC;
 786           flags &=~ SEC_LOAD;
 787         }
 788
 789 #ifdef md_elf_section_flags
 790       flags = md_elf_section_flags (flags, attr, type);
 791 #endif
 792     }
 793
 794   bfd_set_section_flags (stdoutput, sec, flags);
 795
 796   /* Add a symbol for this section to the symbol table.  */
 797   secsym = symbol_find (string);
 798   if (secsym != NULL)
 799     secsym->bsym = sec->symbol;
 800   else
 801     symbol_table_insert (section_symbol (sec));
 802
 803 #ifdef md_elf_section_change_hook
 804   md_elf_section_change_hook ();
 805 #endif
 806
 807   demand_empty_rest_of_line ();
 808 }
 809
 810 /* Change to the .data section.  */
 811
 812 static void
 813 obj_elf_data (i)
 814      int i;
 815 {
 816 #ifdef md_flush_pending_output
 817   md_flush_pending_output ();
 818 #endif
 819
 820   previous_section = now_seg;
 821   previous_subsection = now_subseg;
 822   s_data (i);
 823
 824 #ifdef md_elf_section_change_hook
 825   md_elf_section_change_hook ();
 826 #endif
 827 }
 828
 829 /* Change to the .text section.  */
 830
 831 static void
 832 obj_elf_text (i)
 833      int i;
 834 {
 835 #ifdef md_flush_pending_output
 836   md_flush_pending_output ();
 837 #endif
 838
 839   previous_section = now_seg;
 840   previous_subsection = now_subseg;
 841   s_text (i);
 842
 843 #ifdef md_elf_section_change_hook
 844   md_elf_section_change_hook ();
 845 #endif
 846 }
 847
 848 void
 849 obj_elf_previous (ignore)
 850      int ignore;
 851 {
 852   if (previous_section == 0)
 853     {
 854       as_bad (".previous without corresponding .section; ignored");
 855       return;
 856     }
 857
 858 #ifdef md_flush_pending_output
 859   md_flush_pending_output ();
 860 #endif
 861
 862   subseg_set (previous_section, previous_subsection);
 863   previous_section = 0;
 864
 865 #ifdef md_elf_section_change_hook
 866   md_elf_section_change_hook ();
 867 #endif
 868 }
 869
 870 static void
 871 obj_elf_line (ignore)
 872      int ignore;
 873 {
 874   /* Assume delimiter is part of expression.  BSD4.2 as fails with
 875      delightful bug, so we are not being incompatible here. */
 876   new_logical_line ((char *) NULL, (int) (get_absolute_expression ()));
 877   demand_empty_rest_of_line ();
 878 }
 879
 880 /* This handle the .symver pseudo-op, which is used to specify a
 881    symbol version.  The syntax is ``.symver NAME,SYMVERNAME''.
 882    SYMVERNAME may contain ELF_VER_CHR ('@') characters.  This
 883    pseudo-op causes the assembler to emit a symbol named SYMVERNAME
 884    with the same value as the symbol NAME.  */
 885
 886 static void
 887 obj_elf_symver (ignore)
 888      int ignore;
 889 {
 890   char *name;
 891   char c;
 892   symbolS *sym;
 893
 894   name = input_line_pointer;
 895   c = get_symbol_end ();
 896
 897   sym = symbol_find_or_make (name);
 898
 899   *input_line_pointer = c;
 900
 901   if (sym->sy_obj.versioned_name != NULL)
 902     {
 903       as_bad ("multiple .symver directives for symbol `%s'",
 904               S_GET_NAME (sym));
 905       ignore_rest_of_line ();
 906       return;
 907     }
 908
 909   SKIP_WHITESPACE ();
 910   if (*input_line_pointer != ',')
 911     {
 912       as_bad ("expected comma after name in .symver");
 913       ignore_rest_of_line ();
 914       return;
 915     }
 916
 917   ++input_line_pointer;
 918   name = input_line_pointer;
 919   while (1)
 920     {
 921       c = get_symbol_end ();
 922       if (c != ELF_VER_CHR)
 923         break;
 924       *input_line_pointer++ = c;
 925     }
 926
 927   sym->sy_obj.versioned_name = xstrdup (name);
 928
 929   *input_line_pointer = c;
 930
 931   if (strchr (sym->sy_obj.versioned_name, ELF_VER_CHR) == NULL)
 932     {
 933       as_bad ("missing version name in `%s' for symbol `%s'",
 934               sym->sy_obj.versioned_name, S_GET_NAME (sym));
 935       ignore_rest_of_line ();
 936       return;
 937     }
 938
 939   demand_empty_rest_of_line ();
 940 }
 941
 942 void
 943 obj_read_begin_hook ()
 944 {
 945 #ifdef NEED_ECOFF_DEBUG
 946   if (ECOFF_DEBUGGING)
 947     ecoff_read_begin_hook ();
 948 #endif
 949 }
 950
 951 void
 952 obj_symbol_new_hook (symbolP)
 953      symbolS *symbolP;
 954 {
 955   symbolP->sy_obj.size = NULL;
 956   symbolP->sy_obj.versioned_name = NULL;
 957
 958 #ifdef NEED_ECOFF_DEBUG
 959   if (ECOFF_DEBUGGING)
 960     ecoff_symbol_new_hook (symbolP);
 961 #endif
 962 }
 963
 964 void
 965 obj_elf_version (ignore)
 966      int ignore;
 967 {
 968   char *name;
 969   unsigned int c;
 970   char ch;
 971   char *p;
 972   asection *seg = now_seg;
 973   subsegT subseg = now_subseg;
 974   Elf_Internal_Note i_note;
 975   Elf_External_Note e_note;
 976   asection *note_secp = (asection *) NULL;
 977   int i, len;
 978
 979   SKIP_WHITESPACE ();
 980   if (*input_line_pointer == '\"')
 981     {
 982       ++input_line_pointer;     /* -> 1st char of string. */
 983       name = input_line_pointer;
 984
 985       while (is_a_char (c = next_char_of_string ()))
 986         ;
 987       c = *input_line_pointer;
 988       *input_line_pointer = '\0';
 989       *(input_line_pointer - 1) = '\0';
 990       *input_line_pointer = c;
 991
 992       /* create the .note section */
 993
 994       note_secp = subseg_new (".note", 0);
 995       bfd_set_section_flags (stdoutput,
 996                              note_secp,
 997                              SEC_HAS_CONTENTS | SEC_READONLY);
 998
 999       /* process the version string */
1000
1001       len = strlen (name);
1002
1003       i_note.namesz = ((len + 1) + 3) & ~3; /* round this to word boundary */
1004       i_note.descsz = 0;        /* no description */
1005       i_note.type = NT_VERSION;
1006       p = frag_more (sizeof (e_note.namesz));
1007       md_number_to_chars (p, (valueT) i_note.namesz, 4);
1008       p = frag_more (sizeof (e_note.descsz));
1009       md_number_to_chars (p, (valueT) i_note.descsz, 4);
1010       p = frag_more (sizeof (e_note.type));
1011       md_number_to_chars (p, (valueT) i_note.type, 4);
1012
1013       for (i = 0; i < len; i++)
1014         {
1015           ch = *(name + i);
1016           {
1017             FRAG_APPEND_1_CHAR (ch);
1018           }
1019         }
1020       frag_align (2, 0, 0);
1021
1022       subseg_set (seg, subseg);
1023     }
1024   else
1025     {
1026       as_bad ("Expected quoted string");
1027     }
1028   demand_empty_rest_of_line ();
1029 }
1030
1031 static void
1032 obj_elf_size (ignore)
1033      int ignore;
1034 {
1035   char *name = input_line_pointer;
1036   char c = get_symbol_end ();
1037   char *p;
1038   expressionS exp;
1039   symbolS *sym;
1040
1041   p = input_line_pointer;
1042   *p = c;
1043   SKIP_WHITESPACE ();
1044   if (*input_line_pointer != ',')
1045     {
1046       *p = 0;
1047       as_bad ("expected comma after name `%s' in .size directive", name);
1048       *p = c;
1049       ignore_rest_of_line ();
1050       return;
1051     }
1052   input_line_pointer++;
1053   expression (&exp);
1054   if (exp.X_op == O_absent)
1055     {
1056       as_bad ("missing expression in .size directive");
1057       exp.X_op = O_constant;
1058       exp.X_add_number = 0;
1059     }
1060   *p = 0;
1061   sym = symbol_find_or_make (name);
1062   *p = c;
1063   if (exp.X_op == O_constant)
1064     S_SET_SIZE (sym, exp.X_add_number);
1065   else
1066     {
1067       sym->sy_obj.size = (expressionS *) xmalloc (sizeof (expressionS));
1068       *sym->sy_obj.size = exp;
1069     }
1070   demand_empty_rest_of_line ();
1071 }
1072
1073 /* Handle the ELF .type pseudo-op.  This sets the type of a symbol.
1074    There are three syntaxes.  The first (used on Solaris) is
1075        .type SYM,#function
1076    The second (used on UnixWare) is
1077        .type SYM,@function
1078    The third (reportedly to be used on Irix 6.0) is
1079        .type SYM STT_FUNC
1080    */
1081
1082 static void
1083 obj_elf_type (ignore)
1084      int ignore;
1085 {
1086   char *name;
1087   char c;
1088   int type;
1089   const char *typename;
1090   symbolS *sym;
1091
1092   name = input_line_pointer;
1093   c = get_symbol_end ();
1094   sym = symbol_find_or_make (name);
1095   *input_line_pointer = c;
1096
1097   SKIP_WHITESPACE ();
1098   if (*input_line_pointer == ',')
1099     ++input_line_pointer;
1100
1101   SKIP_WHITESPACE ();
1102   if (*input_line_pointer == '#' || *input_line_pointer == '@')
1103     ++input_line_pointer;
1104
1105   typename = input_line_pointer;
1106   c = get_symbol_end ();
1107
1108   type = 0;
1109   if (strcmp (typename, "function") == 0
1110       || strcmp (typename, "STT_FUNC") == 0)
1111     type = BSF_FUNCTION;
1112   else if (strcmp (typename, "object") == 0
1113            || strcmp (typename, "STT_OBJECT") == 0)
1114     type = BSF_OBJECT;
1115   else
1116     as_bad ("ignoring unrecognized symbol type \"%s\"", typename);
1117
1118   *input_line_pointer = c;
1119
1120   sym->bsym->flags |= type;
1121
1122   demand_empty_rest_of_line ();
1123 }
1124
1125 static void
1126 obj_elf_ident (ignore)
1127      int ignore;
1128 {
1129   static segT comment_section;
1130   segT old_section = now_seg;
1131   int old_subsection = now_subseg;
1132
1133   if (!comment_section)
1134     {
1135       char *p;
1136       comment_section = subseg_new (".comment", 0);
1137       bfd_set_section_flags (stdoutput, comment_section,
1138                              SEC_READONLY | SEC_HAS_CONTENTS);
1139       p = frag_more (1);
1140       *p = 0;
1141     }
1142   else
1143     subseg_set (comment_section, 0);
1144   stringer (1);
1145   subseg_set (old_section, old_subsection);
1146 }
1147
1148 #ifdef INIT_STAB_SECTION
1149
1150 /* The first entry in a .stabs section is special.  */
1151
1152 void
1153 obj_elf_init_stab_section (seg)
1154      segT seg;
1155 {
1156   char *file;
1157   char *p;
1158   char *stabstr_name;
1159   unsigned int stroff;
1160
1161   /* Force the section to align to a longword boundary.  Without this,
1162      UnixWare ar crashes.  */
1163   bfd_set_section_alignment (stdoutput, seg, 2);
1164
1165   /* Make space for this first symbol. */
1166   p = frag_more (12);
1167   /* Zero it out. */
1168   memset (p, 0, 12);
1169   as_where (&file, (unsigned int *) NULL);
1170   stabstr_name = (char *) alloca (strlen (segment_name (seg)) + 4);
1171   strcpy (stabstr_name, segment_name (seg));
1172   strcat (stabstr_name, "str");
1173   stroff = get_stab_string_offset (file, stabstr_name);
1174   know (stroff == 1);
1175   md_number_to_chars (p, stroff, 4);
1176   seg_info (seg)->stabu.p = p;
1177 }
1178
1179 #endif
1180
1181 /* Fill in the counts in the first entry in a .stabs section.  */
1182
1183 static void
1184 adjust_stab_sections (abfd, sec, xxx)
1185      bfd *abfd;
1186      asection *sec;
1187      PTR xxx;
1188 {
1189   char *name;
1190   asection *strsec;
1191   char *p;
1192   int strsz, nsyms;
1193
1194   if (strncmp (".stab", sec->name, 5))
1195     return;
1196   if (!strcmp ("str", sec->name + strlen (sec->name) - 3))
1197     return;
1198
1199   name = (char *) alloca (strlen (sec->name) + 4);
1200   strcpy (name, sec->name);
1201   strcat (name, "str");
1202   strsec = bfd_get_section_by_name (abfd, name);
1203   if (strsec)
1204     strsz = bfd_section_size (abfd, strsec);
1205   else
1206     strsz = 0;
1207   nsyms = bfd_section_size (abfd, sec) / 12 - 1;
1208
1209   p = seg_info (sec)->stabu.p;
1210   assert (p != 0);
1211
1212   bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
1213   bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
1214 }
1215
1216 #ifdef NEED_ECOFF_DEBUG
1217
1218 /* This function is called by the ECOFF code.  It is supposed to
1219    record the external symbol information so that the backend can
1220    write it out correctly.  The ELF backend doesn't actually handle
1221    this at the moment, so we do it ourselves.  We save the information
1222    in the symbol.  */
1223
1224 void
1225 elf_ecoff_set_ext (sym, ext)
1226      symbolS *sym;
1227      struct ecoff_extr *ext;
1228 {
1229   sym->bsym->udata.p = (PTR) ext;
1230 }
1231
1232 /* This function is called by bfd_ecoff_debug_externals.  It is
1233    supposed to *EXT to the external symbol information, and return
1234    whether the symbol should be used at all.  */
1235
1236 static boolean
1237 elf_get_extr (sym, ext)
1238      asymbol *sym;
1239      EXTR *ext;
1240 {
1241   if (sym->udata.p == NULL)
1242     return false;
1243   *ext = *(EXTR *) sym->udata.p;
1244   return true;
1245 }
1246
1247 /* This function is called by bfd_ecoff_debug_externals.  It has
1248    nothing to do for ELF.  */
1249
1250 /*ARGSUSED*/
1251 static void
1252 elf_set_index (sym, indx)
1253      asymbol *sym;
1254      bfd_size_type indx;
1255 {
1256 }
1257
1258 #endif /* NEED_ECOFF_DEBUG */
1259
1260 void
1261 elf_frob_symbol (symp, puntp)
1262      symbolS *symp;
1263      int *puntp;
1264 {
1265 #ifdef NEED_ECOFF_DEBUG
1266   if (ECOFF_DEBUGGING)
1267     ecoff_frob_symbol (symp);
1268 #endif
1269
1270   if (symp->sy_obj.size != NULL)
1271     {
1272       switch (symp->sy_obj.size->X_op)
1273         {
1274         case O_subtract:
1275           S_SET_SIZE (symp,
1276                       (S_GET_VALUE (symp->sy_obj.size->X_add_symbol)
1277                        + symp->sy_obj.size->X_add_number
1278                        - S_GET_VALUE (symp->sy_obj.size->X_op_symbol)));
1279           break;
1280         case O_constant:
1281           S_SET_SIZE (symp,
1282                       (S_GET_VALUE (symp->sy_obj.size->X_add_symbol)
1283                        + symp->sy_obj.size->X_add_number));
1284           break;
1285         default:
1286           as_bad (".size expression too complicated to fix up");
1287           break;
1288         }
1289       free (symp->sy_obj.size);
1290       symp->sy_obj.size = NULL;
1291     }
1292
1293   if (symp->sy_obj.versioned_name != NULL)
1294     {
1295       /* This symbol was given a new name with the .symver directive.
1296
1297          If this is an external reference, just rename the symbol to
1298          include the version string.  This will make the relocs be
1299          against the correct versioned symbol.
1300
1301          If this is a definition, add an alias.  FIXME: Using an alias
1302          will permit the debugging information to refer to the right
1303          symbol.  However, it's not clear whether it is the best
1304          approach.  */
1305
1306       if (! S_IS_DEFINED (symp))
1307         {
1308           char *p;
1309
1310           /* Verify that the name isn't using the @@ syntax--this is
1311              reserved for definitions of the default version to link
1312              against.  */
1313           p = strchr (symp->sy_obj.versioned_name, ELF_VER_CHR);
1314           know (p != NULL);
1315           if (p[1] == ELF_VER_CHR)
1316             {
1317               as_bad ("invalid attempt to declare external version name as default in symbol `%s'",
1318                       symp->sy_obj.versioned_name);
1319               *puntp = true;
1320             }
1321           S_SET_NAME (symp, symp->sy_obj.versioned_name);
1322         }
1323       else
1324         {
1325           symbolS *symp2;
1326
1327           /* FIXME: Creating a new symbol here is risky.  We're in the
1328              final loop over the symbol table.  We can get away with
1329              it only because the symbol goes to the end of the list,
1330              where the loop will still see it.  It would probably be
1331              better to do this in obj_frob_file_before_adjust. */
1332
1333           symp2 = symbol_find_or_make (symp->sy_obj.versioned_name);
1334
1335           /* Now we act as though we saw symp2 = sym.  */
1336
1337           S_SET_SEGMENT (symp2, S_GET_SEGMENT (symp));
1338
1339           /* Subtracting out the frag address here is a hack because
1340              we are in the middle of the final loop.  */
1341           S_SET_VALUE (symp2, S_GET_VALUE (symp) - symp->sy_frag->fr_address);
1342
1343           symp2->sy_frag = symp->sy_frag;
1344
1345           /* This will copy over the size information.  */
1346           copy_symbol_attributes (symp2, symp);
1347
1348           if (S_IS_WEAK (symp))
1349             S_SET_WEAK (symp2);
1350
1351           if (S_IS_EXTERNAL (symp))
1352             S_SET_EXTERNAL (symp2);
1353         }
1354     }
1355
1356   /* Double check weak symbols.  */
1357   if (symp->bsym->flags & BSF_WEAK)
1358     {
1359       if (S_IS_COMMON (symp))
1360         as_bad ("Symbol `%s' can not be both weak and common",
1361                 S_GET_NAME (symp));
1362     }
1363
1364 #ifdef TC_MIPS
1365   /* The Irix 5 assembler appears to set the type of any common symbol
1366      to STT_OBJECT.  We try to be compatible, since the Irix 5 linker
1367      apparently sometimes cares.  FIXME: What about Irix 6?  */
1368   if (S_IS_COMMON (symp))
1369     symp->bsym->flags |= BSF_OBJECT;
1370 #endif
1371
1372 #ifdef TC_PPC
1373   /* Frob the PowerPC, so that the symbol always has object type
1374      if it is not some other type.  VxWorks needs this.  */
1375   if ((symp->bsym->flags & (BSF_FUNCTION | BSF_FILE | BSF_SECTION_SYM)) == 0
1376       && S_IS_DEFINED (symp))
1377     symp->bsym->flags |= BSF_OBJECT;
1378 #endif
1379 }
1380
1381 void
1382 elf_frob_file ()
1383 {
1384   bfd_map_over_sections (stdoutput, adjust_stab_sections, (PTR) 0);
1385
1386 #ifdef elf_tc_final_processing
1387   elf_tc_final_processing ();
1388 #endif
1389 }
1390
1391 /* It is required that we let write_relocs have the opportunity to
1392    optimize away fixups before output has begun, since it is possible
1393    to eliminate all fixups for a section and thus we never should
1394    have generated the relocation section.  */
1395
1396 void
1397 elf_frob_file_after_relocs ()
1398 {
1399 #ifdef NEED_ECOFF_DEBUG
1400   if (ECOFF_DEBUGGING)
1401     /* Generate the ECOFF debugging information.  */
1402     {
1403       const struct ecoff_debug_swap *debug_swap;
1404       struct ecoff_debug_info debug;
1405       char *buf;
1406       asection *sec;
1407
1408       debug_swap
1409         = get_elf_backend_data (stdoutput)->elf_backend_ecoff_debug_swap;
1410       know (debug_swap != (const struct ecoff_debug_swap *) NULL);
1411       ecoff_build_debug (&debug.symbolic_header, &buf, debug_swap);
1412
1413       /* Set up the pointers in debug.  */
1414 #define SET(ptr, offset, type) \
1415     debug.ptr = (type) (buf + debug.symbolic_header.offset)
1416
1417       SET (line, cbLineOffset, unsigned char *);
1418       SET (external_dnr, cbDnOffset, PTR);
1419       SET (external_pdr, cbPdOffset, PTR);
1420       SET (external_sym, cbSymOffset, PTR);
1421       SET (external_opt, cbOptOffset, PTR);
1422       SET (external_aux, cbAuxOffset, union aux_ext *);
1423       SET (ss, cbSsOffset, char *);
1424       SET (external_fdr, cbFdOffset, PTR);
1425       SET (external_rfd, cbRfdOffset, PTR);
1426       /* ssext and external_ext are set up just below.  */
1427
1428 #undef SET
1429
1430       /* Set up the external symbols.  */
1431       debug.ssext = debug.ssext_end = NULL;
1432       debug.external_ext = debug.external_ext_end = NULL;
1433       if (! bfd_ecoff_debug_externals (stdoutput, &debug, debug_swap, true,
1434                                        elf_get_extr, elf_set_index))
1435         as_fatal ("Failed to set up debugging information: %s",
1436                   bfd_errmsg (bfd_get_error ()));
1437
1438       sec = bfd_get_section_by_name (stdoutput, ".mdebug");
1439       assert (sec != NULL);
1440
1441       know (stdoutput->output_has_begun == false);
1442
1443       /* We set the size of the section, call bfd_set_section_contents
1444          to force the ELF backend to allocate a file position, and then
1445          write out the data.  FIXME: Is this really the best way to do
1446          this?  */
1447       sec->_raw_size = bfd_ecoff_debug_size (stdoutput, &debug, debug_swap);
1448
1449       if (! bfd_set_section_contents (stdoutput, sec, (PTR) NULL,
1450                                       (file_ptr) 0, (bfd_size_type) 0))
1451         as_fatal ("Can't start writing .mdebug section: %s",
1452                   bfd_errmsg (bfd_get_error ()));
1453
1454       know (stdoutput->output_has_begun == true);
1455       know (sec->filepos != 0);
1456
1457       if (! bfd_ecoff_write_debug (stdoutput, &debug, debug_swap,
1458                                    sec->filepos))
1459         as_fatal ("Could not write .mdebug section: %s",
1460                   bfd_errmsg (bfd_get_error ()));
1461     }
1462 #endif /* NEED_ECOFF_DEBUG */
1463 }
1464
1465 #ifdef SCO_ELF
1466
1467 /* Heavily plagarized from obj_elf_version.  The idea is to emit the
1468    SCO specific identifier in the .notes section to satisfy the SCO
1469    linker.
1470
1471    This looks more complicated than it really is.  As opposed to the
1472    "obvious" solution, this should handle the cross dev cases
1473    correctly.  (i.e, hosting on a 64 bit big endian processor, but
1474    generating SCO Elf code) Efficiency isn't a concern, as there
1475    should be exactly one of these sections per object module.
1476
1477    SCO OpenServer 5 identifies it's ELF modules with a standard ELF
1478    .note section.
1479
1480    int_32 namesz  = 4 ;  Name size
1481    int_32 descsz  = 12 ; Descriptive information
1482    int_32 type    = 1 ;
1483    char   name[4] = "SCO" ; Originator name ALWAYS SCO + NULL
1484    int_32 version = (major ver # << 16)  | version of tools ;
1485    int_32 source  = (tool_id << 16 ) | 1 ;
1486    int_32 info    = 0 ;    These are set by the SCO tools, but we
1487                            don't know enough about the source
1488                            environment to set them.  SCO ld currently
1489                            ignores them, and recommends we set them
1490                            to zero.  */
1491
1492 #define SCO_MAJOR_VERSION 0x1
1493 #define SCO_MINOR_VERSION 0x1
1494
1495 void
1496 sco_id ()
1497 {
1498
1499   char *name;
1500   unsigned int c;
1501   char ch;
1502   char *p;
1503   asection *seg = now_seg;
1504   subsegT subseg = now_subseg;
1505   Elf_Internal_Note i_note;
1506   Elf_External_Note e_note;
1507   asection *note_secp = (asection *) NULL;
1508   int i, len;
1509
1510   /* create the .note section */
1511
1512   note_secp = subseg_new (".note", 0);
1513   bfd_set_section_flags (stdoutput,
1514                          note_secp,
1515                          SEC_HAS_CONTENTS | SEC_READONLY);
1516
1517   /* process the version string */
1518
1519   i_note.namesz = 4;
1520   i_note.descsz = 12;           /* 12 descriptive bytes */
1521   i_note.type = NT_VERSION;     /* Contains a version string */
1522
1523   p = frag_more (sizeof (i_note.namesz));
1524   md_number_to_chars (p, (valueT) i_note.namesz, 4);
1525
1526   p = frag_more (sizeof (i_note.descsz));
1527   md_number_to_chars (p, (valueT) i_note.descsz, 4);
1528
1529   p = frag_more (sizeof (i_note.type));
1530   md_number_to_chars (p, (valueT) i_note.type, 4);
1531
1532   p = frag_more (4);
1533   strcpy (p, "SCO");
1534
1535   /* Note: this is the version number of the ELF we're representing */
1536   p = frag_more (4);
1537   md_number_to_chars (p, (SCO_MAJOR_VERSION << 16) | (SCO_MINOR_VERSION), 4);
1538
1539   /* Here, we pick a magic number for ourselves (yes, I "registered"
1540      it with SCO.  The bottom bit shows that we are compat with the
1541      SCO ABI.  */
1542   p = frag_more (4);
1543   md_number_to_chars (p, 0x4c520000 | 0x0001, 4);
1544
1545   /* If we knew (or cared) what the source language options were, we'd
1546      fill them in here.  SCO has given us permission to ignore these
1547      and just set them to zero.  */
1548   p = frag_more (4);
1549   md_number_to_chars (p, 0x0000, 4);
1550
1551   frag_align (2, 0, 0);
1552
1553   /* We probably can't restore the current segment, for there likely
1554      isn't one yet...  */
1555   if (seg && subseg)
1556     subseg_set (seg, subseg);
1557
1558 }
1559
1560 #endif /* SCO_ELF */
1561
1562 const struct format_ops elf_format_ops =
1563 {
1564   bfd_target_elf_flavour,
1565   0,
1566   1,
1567   elf_frob_symbol,
1568   elf_frob_file,
1569   elf_frob_file_after_relocs,
1570   elf_s_get_size, elf_s_set_size,
1571   elf_s_get_align, elf_s_set_align,
1572   elf_copy_symbol_attributes,
1573 #ifdef NEED_ECOFF_DEBUG
1574   ecoff_generate_asm_lineno,
1575   ecoff_stab,
1576 #else
1577   0,
1578   0,                            /* process_stab */
1579 #endif
1580   elf_sec_sym_ok_for_reloc,
1581   elf_pop_insert,
1582 #ifdef NEED_ECOFF_DEBUG
1583   elf_ecoff_set_ext,
1584 #else
1585   0,
1586 #endif
1587   obj_read_begin_hook,
1588   obj_symbol_new_hook,
1589 };