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