gas/config/obj-aout.c

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