gas/config/obj-aout.c

   1 /* a.out object file format
   2    Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000,
   3    2001, 2002, 2003, 2004 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-aout.h"
  23
  24 #include "as.h"
  25 #ifdef BFD_ASSEMBLER
  26 #undef NO_RELOC
  27 #include "aout/aout64.h"
  28 #endif
  29 #include "obstack.h"
  30
  31 #ifndef BFD_ASSEMBLER
  32 /* in: segT   out: N_TYPE bits */
  33 const short seg_N_TYPE[] =
  34 {
  35   N_ABS,
  36   N_TEXT,
  37   N_DATA,
  38   N_BSS,
  39   N_UNDF,                       /* unknown */
  40   N_UNDF,                       /* error */
  41   N_UNDF,                       /* expression */
  42   N_UNDF,                       /* debug */
  43   N_UNDF,                       /* ntv */
  44   N_UNDF,                       /* ptv */
  45   N_REGISTER,                   /* register */
  46 };
  47
  48 const segT N_TYPE_seg[N_TYPE + 2] =
  49 {                               /* N_TYPE == 0x1E = 32-2 */
  50   SEG_UNKNOWN,                  /* N_UNDF == 0 */
  51   SEG_GOOF,
  52   SEG_ABSOLUTE,                 /* N_ABS == 2 */
  53   SEG_GOOF,
  54   SEG_TEXT,                     /* N_TEXT == 4 */
  55   SEG_GOOF,
  56   SEG_DATA,                     /* N_DATA == 6 */
  57   SEG_GOOF,
  58   SEG_BSS,                      /* N_BSS == 8 */
  59   SEG_GOOF,
  60   SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
  61   SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
  62   SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
  63   SEG_REGISTER,                 /* dummy N_REGISTER for regs = 30 */
  64   SEG_GOOF,
  65 };
  66 #endif
  67
  68 static void obj_aout_line PARAMS ((int));
  69 static void obj_aout_weak PARAMS ((int));
  70 static void obj_aout_type PARAMS ((int));
  71
  72 const pseudo_typeS aout_pseudo_table[] =
  73 {
  74   {"line", obj_aout_line, 0},   /* source code line number */
  75   {"ln", obj_aout_line, 0},     /* coff line number that we use anyway */
  76
  77   {"weak", obj_aout_weak, 0},   /* mark symbol as weak.  */
  78
  79   {"type", obj_aout_type, 0},
  80
  81   /* coff debug pseudos (ignored) */
  82   {"def", s_ignore, 0},
  83   {"dim", s_ignore, 0},
  84   {"endef", s_ignore, 0},
  85   {"ident", s_ignore, 0},
  86   {"line", s_ignore, 0},
  87   {"ln", s_ignore, 0},
  88   {"scl", s_ignore, 0},
  89   {"size", s_ignore, 0},
  90   {"tag", s_ignore, 0},
  91   {"val", s_ignore, 0},
  92   {"version", s_ignore, 0},
  93
  94   {"optim", s_ignore, 0},       /* For sun386i cc (?) */
  95
  96   /* other stuff */
  97   {"ABORT", s_abort, 0},
  98
  99   {NULL, NULL, 0}               /* end sentinel */
 100 };                              /* aout_pseudo_table */
 101
 102 #ifdef BFD_ASSEMBLER
 103
 104 void
 105 obj_aout_frob_symbol (sym, punt)
 106      symbolS *sym;
 107      int *punt ATTRIBUTE_UNUSED;
 108 {
 109   flagword flags;
 110   asection *sec;
 111   int desc, type, other;
 112
 113   flags = symbol_get_bfdsym (sym)->flags;
 114   desc = aout_symbol (symbol_get_bfdsym (sym))->desc;
 115   type = aout_symbol (symbol_get_bfdsym (sym))->type;
 116   other = aout_symbol (symbol_get_bfdsym (sym))->other;
 117   sec = S_GET_SEGMENT (sym);
 118
 119   /* Only frob simple symbols this way right now.  */
 120   if (! (type & ~ (N_TYPE | N_EXT)))
 121     {
 122       if (type == (N_UNDF | N_EXT)
 123           && sec == &bfd_abs_section)
 124         {
 125           sec = bfd_und_section_ptr;
 126           S_SET_SEGMENT (sym, sec);
 127         }
 128
 129       if ((type & N_TYPE) != N_INDR
 130           && (type & N_TYPE) != N_SETA
 131           && (type & N_TYPE) != N_SETT
 132           && (type & N_TYPE) != N_SETD
 133           && (type & N_TYPE) != N_SETB
 134           && type != N_WARNING
 135           && (sec == &bfd_abs_section
 136               || sec == &bfd_und_section))
 137         return;
 138       if (flags & BSF_EXPORT)
 139         type |= N_EXT;
 140
 141       switch (type & N_TYPE)
 142         {
 143         case N_SETA:
 144         case N_SETT:
 145         case N_SETD:
 146         case N_SETB:
 147           /* Set the debugging flag for constructor symbols so that
 148              BFD leaves them alone.  */
 149           symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
 150
 151           /* You can't put a common symbol in a set.  The way a set
 152              element works is that the symbol has a definition and a
 153              name, and the linker adds the definition to the set of
 154              that name.  That does not work for a common symbol,
 155              because the linker can't tell which common symbol the
 156              user means.  FIXME: Using as_bad here may be
 157              inappropriate, since the user may want to force a
 158              particular type without regard to the semantics of sets;
 159              on the other hand, we certainly don't want anybody to be
 160              mislead into thinking that their code will work.  */
 161           if (S_IS_COMMON (sym))
 162             as_bad (_("Attempt to put a common symbol into set %s"),
 163                     S_GET_NAME (sym));
 164           /* Similarly, you can't put an undefined symbol in a set.  */
 165           else if (! S_IS_DEFINED (sym))
 166             as_bad (_("Attempt to put an undefined symbol into set %s"),
 167                     S_GET_NAME (sym));
 168
 169           break;
 170         case N_INDR:
 171           /* Put indirect symbols in the indirect section.  */
 172           S_SET_SEGMENT (sym, bfd_ind_section_ptr);
 173           symbol_get_bfdsym (sym)->flags |= BSF_INDIRECT;
 174           if (type & N_EXT)
 175             {
 176               symbol_get_bfdsym (sym)->flags |= BSF_EXPORT;
 177               symbol_get_bfdsym (sym)->flags &=~ BSF_LOCAL;
 178             }
 179           break;
 180         case N_WARNING:
 181           /* Mark warning symbols.  */
 182           symbol_get_bfdsym (sym)->flags |= BSF_WARNING;
 183           break;
 184         }
 185     }
 186   else
 187     {
 188       symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
 189     }
 190
 191   aout_symbol (symbol_get_bfdsym (sym))->type = type;
 192
 193   /* Double check weak symbols.  */
 194   if (S_IS_WEAK (sym))
 195     {
 196       if (S_IS_COMMON (sym))
 197         as_bad (_("Symbol `%s' can not be both weak and common"),
 198                 S_GET_NAME (sym));
 199     }
 200 }
 201
 202 void
 203 obj_aout_frob_file_before_fix ()
 204 {
 205   /* Relocation processing may require knowing the VMAs of the sections.
 206      Since writing to a section will cause the BFD back end to compute the
 207      VMAs, fake it out here....  */
 208   bfd_byte b = 0;
 209   bfd_boolean x = TRUE;
 210   if (bfd_section_size (stdoutput, text_section) != 0)
 211     {
 212       x = bfd_set_section_contents (stdoutput, text_section, &b, (file_ptr) 0,
 213                                     (bfd_size_type) 1);
 214     }
 215   else if (bfd_section_size (stdoutput, data_section) != 0)
 216     {
 217       x = bfd_set_section_contents (stdoutput, data_section, &b, (file_ptr) 0,
 218                                     (bfd_size_type) 1);
 219     }
 220   assert (x);
 221 }
 222
 223 #else /* ! BFD_ASSEMBLER */
 224
 225 /* Relocation.  */
 226
 227 /*
 228  *              emit_relocations()
 229  *
 230  * Crawl along a fixS chain. Emit the segment's relocations.
 231  */
 232 void
 233 obj_emit_relocations (where, fixP, segment_address_in_file)
 234      char **where;
 235      fixS *fixP;                /* Fixup chain for this segment.  */
 236      relax_addressT segment_address_in_file;
 237 {
 238   for (; fixP; fixP = fixP->fx_next)
 239     if (fixP->fx_done == 0)
 240       {
 241         symbolS *sym;
 242
 243         sym = fixP->fx_addsy;
 244         while (sym->sy_value.X_op == O_symbol
 245                && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
 246           sym = sym->sy_value.X_add_symbol;
 247         fixP->fx_addsy = sym;
 248
 249         if (! sym->sy_resolved && ! S_IS_DEFINED (sym))
 250           {
 251             char *file;
 252             unsigned int line;
 253
 254             if (expr_symbol_where (sym, &file, &line))
 255               as_bad_where (file, line, _("unresolved relocation"));
 256             else
 257               as_bad (_("bad relocation: symbol `%s' not in symbol table"),
 258                       S_GET_NAME (sym));
 259           }
 260
 261         tc_aout_fix_to_chars (*where, fixP, segment_address_in_file);
 262         *where += md_reloc_size;
 263       }
 264 }
 265
 266 #ifndef obj_header_append
 267 /* Aout file generation & utilities */
 268 void
 269 obj_header_append (where, headers)
 270      char **where;
 271      object_headers *headers;
 272 {
 273   tc_headers_hook (headers);
 274
 275 #ifdef CROSS_COMPILE
 276   md_number_to_chars (*where, headers->header.a_info, sizeof (headers->header.a_info));
 277   *where += sizeof (headers->header.a_info);
 278   md_number_to_chars (*where, headers->header.a_text, sizeof (headers->header.a_text));
 279   *where += sizeof (headers->header.a_text);
 280   md_number_to_chars (*where, headers->header.a_data, sizeof (headers->header.a_data));
 281   *where += sizeof (headers->header.a_data);
 282   md_number_to_chars (*where, headers->header.a_bss, sizeof (headers->header.a_bss));
 283   *where += sizeof (headers->header.a_bss);
 284   md_number_to_chars (*where, headers->header.a_syms, sizeof (headers->header.a_syms));
 285   *where += sizeof (headers->header.a_syms);
 286   md_number_to_chars (*where, headers->header.a_entry, sizeof (headers->header.a_entry));
 287   *where += sizeof (headers->header.a_entry);
 288   md_number_to_chars (*where, headers->header.a_trsize, sizeof (headers->header.a_trsize));
 289   *where += sizeof (headers->header.a_trsize);
 290   md_number_to_chars (*where, headers->header.a_drsize, sizeof (headers->header.a_drsize));
 291   *where += sizeof (headers->header.a_drsize);
 292
 293 #else /* CROSS_COMPILE */
 294
 295   append (where, (char *) &headers->header, sizeof (headers->header));
 296 #endif /* CROSS_COMPILE */
 297
 298 }
 299 #endif /* ! defined (obj_header_append) */
 300
 301 void
 302 obj_symbol_to_chars (where, symbolP)
 303      char **where;
 304      symbolS *symbolP;
 305 {
 306   md_number_to_chars ((char *) &(S_GET_OFFSET (symbolP)), S_GET_OFFSET (symbolP), sizeof (S_GET_OFFSET (symbolP)));
 307   md_number_to_chars ((char *) &(S_GET_DESC (symbolP)), S_GET_DESC (symbolP), sizeof (S_GET_DESC (symbolP)));
 308   md_number_to_chars ((char *) &(symbolP->sy_symbol.n_value), S_GET_VALUE (symbolP), sizeof (symbolP->sy_symbol.n_value));
 309
 310   append (where, (char *) &symbolP->sy_symbol, sizeof (obj_symbol_type));
 311 }
 312
 313 void
 314 obj_emit_symbols (where, symbol_rootP)
 315      char **where;
 316      symbolS *symbol_rootP;
 317 {
 318   symbolS *symbolP;
 319
 320   /* Emit all symbols left in the symbol chain.  */
 321   for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
 322     {
 323       /* Used to save the offset of the name. It is used to point
 324          to the string in memory but must be a file offset.  */
 325       register char *temp;
 326
 327       temp = S_GET_NAME (symbolP);
 328       S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
 329
 330       /* Any symbol still undefined and is not a dbg symbol is made N_EXT.  */
 331       if (!S_IS_DEBUG (symbolP) && !S_IS_DEFINED (symbolP))
 332         S_SET_EXTERNAL (symbolP);
 333
 334       /* Adjust the type of a weak symbol.  */
 335       if (S_GET_WEAK (symbolP))
 336         {
 337           switch (S_GET_TYPE (symbolP))
 338             {
 339             case N_UNDF: S_SET_TYPE (symbolP, N_WEAKU); break;
 340             case N_ABS:  S_SET_TYPE (symbolP, N_WEAKA); break;
 341             case N_TEXT: S_SET_TYPE (symbolP, N_WEAKT); break;
 342             case N_DATA: S_SET_TYPE (symbolP, N_WEAKD); break;
 343             case N_BSS:  S_SET_TYPE (symbolP, N_WEAKB); break;
 344             default: as_bad (_("%s: bad type for weak symbol"), temp); break;
 345             }
 346         }
 347
 348       obj_symbol_to_chars (where, symbolP);
 349       S_SET_NAME (symbolP, temp);
 350     }
 351 }
 352
 353 #endif /* ! BFD_ASSEMBLER */
 354
 355 static void
 356 obj_aout_line (ignore)
 357      int ignore ATTRIBUTE_UNUSED;
 358 {
 359   /* Assume delimiter is part of expression.
 360      BSD4.2 as fails with delightful bug, so we
 361      are not being incompatible here.  */
 362   new_logical_line ((char *) NULL, (int) (get_absolute_expression ()));
 363   demand_empty_rest_of_line ();
 364 }                               /* obj_aout_line() */
 365
 366 /* Handle .weak.  This is a GNU extension.  */
 367
 368 static void
 369 obj_aout_weak (ignore)
 370      int ignore ATTRIBUTE_UNUSED;
 371 {
 372   char *name;
 373   int c;
 374   symbolS *symbolP;
 375
 376   do
 377     {
 378       name = input_line_pointer;
 379       c = get_symbol_end ();
 380       symbolP = symbol_find_or_make (name);
 381       *input_line_pointer = c;
 382       SKIP_WHITESPACE ();
 383       S_SET_WEAK (symbolP);
 384       if (c == ',')
 385         {
 386           input_line_pointer++;
 387           SKIP_WHITESPACE ();
 388           if (*input_line_pointer == '\n')
 389             c = '\n';
 390         }
 391     }
 392   while (c == ',');
 393   demand_empty_rest_of_line ();
 394 }
 395
 396 /* Handle .type.  On {Net,Open}BSD, this is used to set the n_other field,
 397    which is then apparently used when doing dynamic linking.  Older
 398    versions of gas ignored the .type pseudo-op, so we also ignore it if
 399    we can't parse it.  */
 400
 401 static void
 402 obj_aout_type (ignore)
 403      int ignore ATTRIBUTE_UNUSED;
 404 {
 405   char *name;
 406   int c;
 407   symbolS *sym;
 408
 409   name = input_line_pointer;
 410   c = get_symbol_end ();
 411   sym = symbol_find_or_make (name);
 412   *input_line_pointer = c;
 413   SKIP_WHITESPACE ();
 414   if (*input_line_pointer == ',')
 415     {
 416       ++input_line_pointer;
 417       SKIP_WHITESPACE ();
 418       if (*input_line_pointer == '@')
 419         {
 420           ++input_line_pointer;
 421           if (strncmp (input_line_pointer, "object", 6) == 0)
 422             S_SET_OTHER (sym, 1);
 423           else if (strncmp (input_line_pointer, "function", 8) == 0)
 424             S_SET_OTHER (sym, 2);
 425         }
 426     }
 427
 428   /* Ignore everything else on the line.  */
 429   s_ignore (0);
 430 }
 431
 432 #ifndef BFD_ASSEMBLER
 433
 434 void
 435 obj_crawl_symbol_chain (headers)
 436      object_headers *headers;
 437 {
 438   symbolS *symbolP;
 439   symbolS **symbolPP;
 440   int symbol_number = 0;
 441
 442   tc_crawl_symbol_chain (headers);
 443
 444   symbolPP = &symbol_rootP;     /*->last symbol chain link.  */
 445   while ((symbolP = *symbolPP) != NULL)
 446     {
 447       if (symbolP->sy_mri_common)
 448         {
 449           if (S_IS_EXTERNAL (symbolP))
 450             as_bad (_("%s: global symbols not supported in common sections"),
 451                     S_GET_NAME (symbolP));
 452           *symbolPP = symbol_next (symbolP);
 453           continue;
 454         }
 455
 456       if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_DATA))
 457         {
 458           S_SET_SEGMENT (symbolP, SEG_TEXT);
 459         }                       /* if pushing data into text */
 460
 461       resolve_symbol_value (symbolP);
 462
 463       /* Skip symbols which were equated to undefined or common
 464          symbols.  Also skip defined uncommon symbols which can
 465          be resolved since in this case they should have been
 466          resolved to a non-symbolic constant.  */
 467       if (symbolP->sy_value.X_op == O_symbol
 468           && (! S_IS_DEFINED (symbolP)
 469               || S_IS_COMMON (symbolP)
 470               || symbol_resolved_p (symbolP)))
 471         {
 472           *symbolPP = symbol_next (symbolP);
 473           continue;
 474         }
 475
 476       /* OK, here is how we decide which symbols go out into the brave
 477          new symtab.  Symbols that do are:
 478
 479          * symbols with no name (stabd's?)
 480          * symbols with debug info in their N_TYPE
 481
 482          Symbols that don't are:
 483          * symbols that are registers
 484          * symbols with \1 as their 3rd character (numeric labels)
 485          * "local labels" as defined by S_LOCAL_NAME(name) if the -L
 486          switch was passed to gas.
 487
 488          All other symbols are output.  We complain if a deleted
 489          symbol was marked external.  */
 490
 491       if (!S_IS_REGISTER (symbolP)
 492           && (!S_GET_NAME (symbolP)
 493               || S_IS_DEBUG (symbolP)
 494               || !S_IS_DEFINED (symbolP)
 495               || S_IS_EXTERNAL (symbolP)
 496               || (S_GET_NAME (symbolP)[0] != '\001'
 497                   && (flag_keep_locals || !S_LOCAL_NAME (symbolP)))))
 498         {
 499           symbolP->sy_number = symbol_number++;
 500
 501           /* The + 1 after strlen account for the \0 at the
 502                            end of each string */
 503           if (!S_IS_STABD (symbolP))
 504             {
 505               /* Ordinary case.  */
 506               symbolP->sy_name_offset = string_byte_count;
 507               string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
 508             }
 509           else                  /* .Stabd case.  */
 510             symbolP->sy_name_offset = 0;
 511           symbolPP = &symbolP->sy_next;
 512         }
 513       else
 514         {
 515           if (S_IS_EXTERNAL (symbolP) || !S_IS_DEFINED (symbolP))
 516             /* This warning should never get triggered any more.
 517                Well, maybe if you're doing twisted things with
 518                register names...  */
 519             {
 520               as_bad (_("Local symbol %s never defined."), decode_local_label_name (S_GET_NAME (symbolP)));
 521             }                   /* oops.  */
 522
 523           /* Unhook it from the chain */
 524           *symbolPP = symbol_next (symbolP);
 525         }                       /* if this symbol should be in the output */
 526     }                           /* for each symbol */
 527
 528   H_SET_SYMBOL_TABLE_SIZE (headers, symbol_number);
 529 }
 530
 531 /*
 532  * Find strings by crawling along symbol table chain.
 533  */
 534
 535 void
 536 obj_emit_strings (where)
 537      char **where;
 538 {
 539   symbolS *symbolP;
 540
 541 #ifdef CROSS_COMPILE
 542   /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
 543   md_number_to_chars (*where, string_byte_count, sizeof (string_byte_count));
 544   *where += sizeof (string_byte_count);
 545 #else /* CROSS_COMPILE */
 546   append (where, (char *) &string_byte_count, (unsigned long) sizeof (string_byte_count));
 547 #endif /* CROSS_COMPILE */
 548
 549   for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
 550     {
 551       if (S_GET_NAME (symbolP))
 552         append (&next_object_file_charP, S_GET_NAME (symbolP),
 553                 (unsigned long) (strlen (S_GET_NAME (symbolP)) + 1));
 554     }                           /* walk symbol chain */
 555 }
 556
 557 #ifndef AOUT_VERSION
 558 #define AOUT_VERSION 0
 559 #endif
 560
 561 void
 562 obj_pre_write_hook (headers)
 563      object_headers *headers;
 564 {
 565   H_SET_DYNAMIC (headers, 0);
 566   H_SET_VERSION (headers, AOUT_VERSION);
 567   H_SET_MACHTYPE (headers, AOUT_MACHTYPE);
 568   tc_aout_pre_write_hook (headers);
 569 }
 570
 571 #endif /* ! BFD_ASSEMBLER */
 572
 573 #ifdef BFD_ASSEMBLER
 574
 575 /* Support for an AOUT emulation.  */
 576
 577 static void aout_pop_insert PARAMS ((void));
 578 static int obj_aout_s_get_other PARAMS ((symbolS *));
 579 static void obj_aout_s_set_other PARAMS ((symbolS *, int));
 580 static int obj_aout_s_get_desc PARAMS ((symbolS *));
 581 static void obj_aout_s_set_desc PARAMS ((symbolS *, int));
 582 static int obj_aout_s_get_type PARAMS ((symbolS *));
 583 static void obj_aout_s_set_type PARAMS ((symbolS *, int));
 584 static int obj_aout_separate_stab_sections PARAMS ((void));
 585 static int obj_aout_sec_sym_ok_for_reloc PARAMS ((asection *));
 586 static void obj_aout_process_stab PARAMS ((segT, int, const char *, int, int, int));
 587
 588 static void
 589 aout_pop_insert ()
 590 {
 591   pop_insert (aout_pseudo_table);
 592 }
 593
 594 static int
 595 obj_aout_s_get_other (sym)
 596      symbolS *sym;
 597 {
 598   return aout_symbol (symbol_get_bfdsym (sym))->other;
 599 }
 600
 601 static void
 602 obj_aout_s_set_other (sym, o)
 603      symbolS *sym;
 604      int o;
 605 {
 606   aout_symbol (symbol_get_bfdsym (sym))->other = o;
 607 }
 608
 609 static int
 610 obj_aout_sec_sym_ok_for_reloc (sec)
 611      asection *sec ATTRIBUTE_UNUSED;
 612 {
 613   return obj_sec_sym_ok_for_reloc (sec);
 614 }
 615
 616 static void
 617 obj_aout_process_stab (seg, w, s, t, o, d)
 618      segT seg ATTRIBUTE_UNUSED;
 619      int w;
 620      const char *s;
 621      int t;
 622      int o;
 623      int d;
 624 {
 625   aout_process_stab (w, s, t, o, d);
 626 }
 627
 628 static int
 629 obj_aout_s_get_desc (sym)
 630      symbolS *sym;
 631 {
 632   return aout_symbol (symbol_get_bfdsym (sym))->desc;
 633 }
 634
 635 static void
 636 obj_aout_s_set_desc (sym, d)
 637      symbolS *sym;
 638      int d;
 639 {
 640   aout_symbol (symbol_get_bfdsym (sym))->desc = d;
 641 }
 642
 643 static int
 644 obj_aout_s_get_type (sym)
 645      symbolS *sym;
 646 {
 647   return aout_symbol (symbol_get_bfdsym (sym))->type;
 648 }
 649
 650 static void
 651 obj_aout_s_set_type (sym, t)
 652      symbolS *sym;
 653      int t;
 654 {
 655   aout_symbol (symbol_get_bfdsym (sym))->type = t;
 656 }
 657
 658 static int
 659 obj_aout_separate_stab_sections ()
 660 {
 661   return 0;
 662 }
 663
 664 /* When changed, make sure these table entries match the single-format
 665    definitions in obj-aout.h.  */
 666 const struct format_ops aout_format_ops =
 667 {
 668   bfd_target_aout_flavour,
 669   1,    /* dfl_leading_underscore */
 670   0,    /* emit_section_symbols */
 671   0,    /* begin */
 672   0,    /* app_file */
 673   obj_aout_frob_symbol,
 674   0,    /* frob_file */
 675   0,    /* frob_file_before_adjust */
 676   obj_aout_frob_file_before_fix,
 677   0,    /* frob_file_after_relocs */
 678   0,    /* s_get_size */
 679   0,    /* s_set_size */
 680   0,    /* s_get_align */
 681   0,    /* s_set_align */
 682   obj_aout_s_get_other,
 683   obj_aout_s_set_other,
 684   obj_aout_s_get_desc,
 685   obj_aout_s_set_desc,
 686   obj_aout_s_get_type,
 687   obj_aout_s_set_type,
 688   0,    /* copy_symbol_attributes */
 689   0,    /* generate_asm_lineno */
 690   obj_aout_process_stab,
 691   obj_aout_separate_stab_sections,
 692   0,    /* init_stab_section */
 693   obj_aout_sec_sym_ok_for_reloc,
 694   aout_pop_insert,
 695   0,    /* ecoff_set_ext */
 696   0,    /* read_begin_hook */
 697   0     /* symbol_new_hook */
 698 };
 699 #endif /* BFD_ASSEMBLER */