bfd/pdp11.c

   1 /* BFD back-end for PDP-11 a.out binaries.
   2    Copyright 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
  19
  20 /* BFD backend for PDP-11, running 2.11BSD in particular.
  21
  22    This file was hacked up by looking hard at the existing vaxnetbsd
  23    back end and the header files in 2.11BSD.
  24
  25    TODO
  26    * support for V7 file formats
  27    * support for overlay object files (see 2.11 a.out(5))
  28    * support for old and very old archives
  29    (see 2.11 ar(5), historical section)
  30
  31    Search for TODO to find other areas needing more work.  */
  32
  33 #define BYTES_IN_WORD   2
  34 #define BYTES_IN_LONG   4
  35 #define ARCH_SIZE       16
  36 #undef TARGET_IS_BIG_ENDIAN_P
  37
  38 #define TARGET_PAGE_SIZE        1024
  39 #define SEGMENT__SIZE   TARGET_PAGE_SIZE
  40
  41 #define DEFAULT_ARCH    bfd_arch_pdp11
  42 #define DEFAULT_MID     M_PDP11
  43
  44 /* Do not "beautify" the CONCAT* macro args.  Traditional C will not
  45    remove whitespace added here, and thus will fail to concatenate
  46    the tokens.  */
  47 #define MY(OP) CONCAT2 (pdp11_aout_,OP)
  48
  49 /* This needs to start with a.out so GDB knows it is an a.out variant.  */
  50 #define TARGETNAME "a.out-pdp11"
  51
  52 /* This is the normal load address for executables.  */
  53 #define TEXT_START_ADDR         0
  54
  55 /* The header is not included in the text segment.  */
  56 #define N_HEADER_IN_TEXT(x)     0
  57
  58 /* There are no shared libraries.  */
  59 #define N_SHARED_LIB(x)         0
  60
  61 /* There is no flags field.  */
  62 #define N_FLAGS(exec)           0
  63
  64 #define N_SET_FLAGS(exec, flags) do { } while (0)
  65 #define N_BADMAG(x) (((x).a_info != OMAGIC)   \
  66                   && ((x).a_info != NMAGIC)   \
  67                   && ((x).a_info != A_MAGIC3) \
  68                   && ((x).a_info != A_MAGIC4) \
  69                   && ((x).a_info != A_MAGIC5) \
  70                   && ((x).a_info != A_MAGIC6))
  71
  72 #include "bfd.h"
  73
  74 #define external_exec pdp11_external_exec
  75 struct pdp11_external_exec
  76 {
  77   bfd_byte e_info[2];           /* Magic number.  */
  78   bfd_byte e_text[2];           /* Length of text section in bytes.  */
  79   bfd_byte e_data[2];           /* Length of data section in bytes.  */
  80   bfd_byte e_bss[2];            /* Length of bss area in bytes.  */
  81   bfd_byte e_syms[2];           /* Length of symbol table in bytes.  */
  82   bfd_byte e_entry[2];          /* Start address.  */
  83   bfd_byte e_unused[2];         /* Not used.  */
  84   bfd_byte e_flag[2];           /* Relocation info stripped.  */
  85   bfd_byte e_relocatable;       /* Ugly hack.  */
  86 };
  87
  88 #define EXEC_BYTES_SIZE (8 * 2)
  89
  90 #define A_MAGIC1        OMAGIC
  91 #define OMAGIC          0407    /* ...object file or impure executable.  */
  92 #define A_MAGIC2        NMAGIC
  93 #define NMAGIC          0410    /* Pure executable.  */
  94 #define ZMAGIC          0413    /* Demand-paged executable.  */
  95 #define A_MAGIC3        0411    /* Separated I&D.  */
  96 #define A_MAGIC4        0405    /* Overlay.  */
  97 #define A_MAGIC5        0430    /* Auto-overlay (nonseparate).  */
  98 #define A_MAGIC6        0431    /* Auto-overlay (separate).  */
  99 #define QMAGIC          0
 100 #define BMAGIC          0
 101
 102 #define A_FLAG_RELOC_STRIPPED   0x0001
 103
 104 #define external_nlist pdp11_external_nlist
 105 struct pdp11_external_nlist
 106 {
 107   bfd_byte e_unused[2];         /* Unused.  */
 108   bfd_byte e_strx[2];           /* Index into string table of name.  */
 109   bfd_byte e_type[1];           /* Type of symbol.  */
 110   bfd_byte e_ovly[1];           /* Overlay number.  */
 111   bfd_byte e_value[2];          /* Value of symbol.  */
 112 };
 113
 114 #define EXTERNAL_NLIST_SIZE     8
 115
 116 #define N_TXTOFF(x)     (EXEC_BYTES_SIZE)
 117 #define N_DATOFF(x)     (N_TXTOFF(x) + (x).a_text)
 118 #define N_TRELOFF(x)    (N_DATOFF(x) + (x).a_data)
 119 #define N_DRELOFF(x)    (N_TRELOFF(x) + (x).a_trsize)
 120 #define N_SYMOFF(x)     (N_DRELOFF(x) + (x).a_drsize)
 121 #define N_STROFF(x)     (N_SYMOFF(x) + (x).a_syms)
 122
 123 #define WRITE_HEADERS(abfd, execp) pdp11_aout_write_headers (abfd, execp)
 124
 125 #include "sysdep.h"
 126 #include "libbfd.h"
 127 #include "libaout.h"
 128
 129 #define SWAP_MAGIC(ext) bfd_getl16 (ext)
 130
 131 #define MY_entry_is_text_address 1
 132
 133 #define MY_write_object_contents MY(write_object_contents)
 134 static bfd_boolean MY(write_object_contents) (bfd *);
 135 #define MY_text_includes_header 1
 136
 137 #define MY_BFD_TARGET
 138
 139 #include "aout-target.h"
 140
 141 /* Start of modified aoutx.h.  */
 142 #define KEEPIT udata.i
 143
 144 #include <string.h>             /* For strchr and friends.  */
 145 #include "bfd.h"
 146 #include "sysdep.h"
 147 #include "safe-ctype.h"
 148 #include "bfdlink.h"
 149
 150 #include "libaout.h"
 151 #include "aout/aout64.h"
 152 #include "aout/stab_gnu.h"
 153 #include "aout/ar.h"
 154
 155 #undef N_TYPE
 156 #undef N_UNDF
 157 #undef N_ABS
 158 #undef N_TEXT
 159 #undef N_DATA
 160 #undef N_BSS
 161 #undef N_REG
 162 #undef N_FN
 163 #undef N_EXT
 164 #define N_TYPE          0x1f    /* Type mask.  */
 165 #define N_UNDF          0x00    /* Undefined.  */
 166 #define N_ABS           0x01    /* Absolute.  */
 167 #define N_TEXT          0x02    /* Text segment.  */
 168 #define N_DATA          0x03    /* Data segment.  */
 169 #define N_BSS           0x04    /* Bss segment.  */
 170 #define N_REG           0x14    /* Register symbol.  */
 171 #define N_FN            0x1f    /* File name.  */
 172 #define N_EXT           0x20    /* External flag.  */
 173
 174 #define RELOC_SIZE 2
 175
 176 #define RELFLG          0x0001  /* PC-relative flag.  */
 177 #define RTYPE           0x000e  /* Type mask.  */
 178 #define RIDXMASK        0xfff0  /* Index mask.  */
 179
 180 #define RABS            0x00    /* Absolute.  */
 181 #define RTEXT           0x02    /* Text.  */
 182 #define RDATA           0x04    /* Data.  */
 183 #define RBSS            0x06    /* Bss.  */
 184 #define REXT            0x08    /* External.  */
 185
 186 #define RINDEX(x)       (((x) & 0xfff0) >> 4)
 187
 188 #ifndef MY_final_link_relocate
 189 #define MY_final_link_relocate _bfd_final_link_relocate
 190 #endif
 191
 192 #ifndef MY_relocate_contents
 193 #define MY_relocate_contents _bfd_relocate_contents
 194 #endif
 195
 196 /* A hash table used for header files with N_BINCL entries.  */
 197
 198 struct aout_link_includes_table
 199 {
 200   struct bfd_hash_table root;
 201 };
 202
 203 /* A linked list of totals that we have found for a particular header
 204    file.  */
 205
 206 struct aout_link_includes_totals
 207 {
 208   struct aout_link_includes_totals *next;
 209   bfd_vma total;
 210 };
 211
 212 /* An entry in the header file hash table.  */
 213
 214 struct aout_link_includes_entry
 215 {
 216   struct bfd_hash_entry root;
 217   /* List of totals we have found for this file.  */
 218   struct aout_link_includes_totals *totals;
 219 };
 220
 221 /* During the final link step we need to pass around a bunch of
 222    information, so we do it in an instance of this structure.  */
 223
 224 struct aout_final_link_info
 225 {
 226   /* General link information.  */
 227   struct bfd_link_info *info;
 228   /* Output bfd.  */
 229   bfd *output_bfd;
 230   /* Reloc file positions.  */
 231   file_ptr treloff, dreloff;
 232   /* File position of symbols.  */
 233   file_ptr symoff;
 234   /* String table.  */
 235   struct bfd_strtab_hash *strtab;
 236   /* Header file hash table.  */
 237   struct aout_link_includes_table includes;
 238   /* A buffer large enough to hold the contents of any section.  */
 239   bfd_byte *contents;
 240   /* A buffer large enough to hold the relocs of any section.  */
 241   void * relocs;
 242   /* A buffer large enough to hold the symbol map of any input BFD.  */
 243   int *symbol_map;
 244   /* A buffer large enough to hold output symbols of any input BFD.  */
 245   struct external_nlist *output_syms;
 246 };
 247
 248 reloc_howto_type howto_table_pdp11[] =
 249 {
 250   /* type              rs size bsz  pcrel bitpos ovrf                     sf name     part_inpl readmask  setmask    pcdone */
 251 HOWTO( 0,              0,  1,  16,  FALSE, 0, complain_overflow_signed,0,"16",  TRUE, 0x0000ffff,0x0000ffff, FALSE),
 252 HOWTO( 1,              0,  1,  16,  TRUE,  0, complain_overflow_signed,0,"DISP16",      TRUE, 0x0000ffff,0x0000ffff, FALSE),
 253 };
 254
 255 #define TABLE_SIZE(TABLE)       (sizeof(TABLE)/sizeof(TABLE[0]))
 256
 257
 258 static bfd_boolean aout_link_check_archive_element (bfd *, struct bfd_link_info *, bfd_boolean *);
 259 static bfd_boolean aout_link_add_object_symbols    (bfd *, struct bfd_link_info *);
 260 static bfd_boolean aout_link_add_symbols           (bfd *, struct bfd_link_info *);
 261 static bfd_boolean aout_link_write_symbols         (struct aout_final_link_info *, bfd *);
 262
 263
 264 reloc_howto_type *
 265 NAME (aout, reloc_type_lookup) (bfd * abfd ATTRIBUTE_UNUSED,
 266                                 bfd_reloc_code_real_type code)
 267 {
 268   switch (code)
 269     {
 270     case BFD_RELOC_16:
 271       return &howto_table_pdp11[0];
 272     case BFD_RELOC_16_PCREL:
 273       return &howto_table_pdp11[1];
 274     default:
 275       return NULL;
 276     }
 277 }
 278
 279 static int
 280 pdp11_aout_write_headers (bfd *abfd, struct internal_exec *execp)
 281 {
 282   struct external_exec exec_bytes;
 283   bfd_size_type text_size;
 284   file_ptr text_end;
 285
 286   if (adata(abfd).magic == undecided_magic)
 287     NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
 288
 289   execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE;
 290   execp->a_entry = bfd_get_start_address (abfd);
 291
 292   if (obj_textsec (abfd)->reloc_count > 0
 293       || obj_datasec (abfd)->reloc_count > 0)
 294     {
 295       execp->a_trsize = execp->a_text;
 296       execp->a_drsize = execp->a_data;
 297     }
 298   else
 299     {
 300       execp->a_trsize = 0;
 301       execp->a_drsize = 0;
 302     }
 303
 304   NAME (aout, swap_exec_header_out) (abfd, execp, & exec_bytes);
 305
 306   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 307     return FALSE;
 308
 309   if (bfd_bwrite ((void *) &exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd)
 310       != EXEC_BYTES_SIZE)
 311     return FALSE;
 312
 313   /* Now write out reloc info, followed by syms and strings.  */
 314   if (bfd_get_outsymbols (abfd) != NULL
 315       && bfd_get_symcount (abfd) != 0)
 316     {
 317       if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*execp)), SEEK_SET) != 0)
 318         return FALSE;
 319
 320       if (! NAME (aout, write_syms) (abfd))
 321         return FALSE;
 322     }
 323
 324   if (obj_textsec (abfd)->reloc_count > 0
 325       || obj_datasec (abfd)->reloc_count > 0)
 326     {
 327       if (bfd_seek (abfd, (file_ptr) (N_TRELOFF(*execp)), SEEK_SET) != 0
 328           || !NAME (aout, squirt_out_relocs) (abfd, obj_textsec (abfd))
 329           || bfd_seek (abfd, (file_ptr) (N_DRELOFF(*execp)), SEEK_SET) != 0
 330           || !NAME (aout, squirt_out_relocs) (abfd, obj_datasec (abfd)))
 331         return FALSE;
 332     }
 333
 334   return TRUE;
 335 }
 336
 337 /* Write an object file.
 338    Section contents have already been written.  We write the
 339    file header, symbols, and relocation.  */
 340
 341 static bfd_boolean
 342 MY(write_object_contents) (bfd *abfd)
 343 {
 344   struct internal_exec *execp = exec_hdr (abfd);
 345
 346   /* We must make certain that the magic number has been set.  This
 347      will normally have been done by set_section_contents, but only if
 348      there actually are some section contents.  */
 349   if (! abfd->output_has_begun)
 350     {
 351       bfd_size_type text_size;
 352       file_ptr text_end;
 353
 354       NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
 355     }
 356
 357   obj_reloc_entry_size (abfd) = RELOC_SIZE;
 358
 359   return WRITE_HEADERS (abfd, execp);
 360 }
 361
 362 /* Swap the information in an executable header @var{raw_bytes} taken
 363    from a raw byte stream memory image into the internal exec header
 364    structure "execp".  */
 365
 366 #ifndef NAME_swap_exec_header_in
 367 void
 368 NAME (aout, swap_exec_header_in) (bfd *abfd,
 369                                   struct external_exec *bytes,
 370                                   struct internal_exec *execp)
 371 {
 372   /* The internal_exec structure has some fields that are unused in this
 373      configuration (IE for i960), so ensure that all such uninitialized
 374      fields are zero'd out.  There are places where two of these structs
 375      are memcmp'd, and thus the contents do matter.  */
 376   memset ((void *) execp, 0, sizeof (struct internal_exec));
 377   /* Now fill in fields in the execp, from the bytes in the raw data.  */
 378   execp->a_info   = GET_MAGIC (abfd, bytes->e_info);
 379   execp->a_text   = GET_WORD (abfd, bytes->e_text);
 380   execp->a_data   = GET_WORD (abfd, bytes->e_data);
 381   execp->a_bss    = GET_WORD (abfd, bytes->e_bss);
 382   execp->a_syms   = GET_WORD (abfd, bytes->e_syms);
 383   execp->a_entry  = GET_WORD (abfd, bytes->e_entry);
 384
 385   if (GET_WORD (abfd, bytes->e_flag) & A_FLAG_RELOC_STRIPPED)
 386     {
 387       execp->a_trsize = 0;
 388       execp->a_drsize = 0;
 389     }
 390   else
 391     {
 392       execp->a_trsize = execp->a_text;
 393       execp->a_drsize = execp->a_data;
 394     }
 395 }
 396 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
 397 #endif
 398
 399 /*  Swap the information in an internal exec header structure
 400     "execp" into the buffer "bytes" ready for writing to disk.  */
 401 void
 402 NAME (aout, swap_exec_header_out) (bfd *abfd,
 403                                    struct internal_exec *execp,
 404                                    struct external_exec *bytes)
 405 {
 406   /* Now fill in fields in the raw data, from the fields in the exec struct.  */
 407   PUT_MAGIC (abfd, execp->a_info,               bytes->e_info);
 408   PUT_WORD (abfd, execp->a_text,                bytes->e_text);
 409   PUT_WORD (abfd, execp->a_data,                bytes->e_data);
 410   PUT_WORD (abfd, execp->a_bss,                 bytes->e_bss);
 411   PUT_WORD (abfd, execp->a_syms,                bytes->e_syms);
 412   PUT_WORD (abfd, execp->a_entry,               bytes->e_entry);
 413   PUT_WORD (abfd, 0,                            bytes->e_unused);
 414
 415   if ((execp->a_trsize == 0 || execp->a_text == 0)
 416       && (execp->a_drsize == 0 || execp->a_data == 0))
 417     PUT_WORD (abfd, A_FLAG_RELOC_STRIPPED, bytes->e_flag);
 418   else if (execp->a_trsize == execp->a_text
 419            && execp->a_drsize == execp->a_data)
 420     PUT_WORD (abfd, 0, bytes->e_flag);
 421   else
 422     {
 423       /* TODO: print a proper warning message.  */
 424       fprintf (stderr, "BFD:%s:%d: internal error\n", __FILE__, __LINE__);
 425       PUT_WORD (abfd, 0,                        bytes->e_flag);
 426     }
 427 }
 428
 429 /* Make all the section for an a.out file.  */
 430
 431 bfd_boolean
 432 NAME (aout, make_sections) (bfd *abfd)
 433 {
 434   if (obj_textsec (abfd) == NULL && bfd_make_section (abfd, ".text") == NULL)
 435     return FALSE;
 436   if (obj_datasec (abfd) == NULL && bfd_make_section (abfd, ".data") == NULL)
 437     return FALSE;
 438   if (obj_bsssec (abfd) == NULL  && bfd_make_section (abfd, ".bss") == NULL)
 439     return FALSE;
 440   return TRUE;
 441 }
 442
 443 /* Some a.out variant thinks that the file open in ABFD
 444    checking is an a.out file.  Do some more checking, and set up
 445    for access if it really is.  Call back to the calling
 446    environment's "finish up" function just before returning, to
 447    handle any last-minute setup.  */
 448
 449 const bfd_target *
 450 NAME (aout, some_aout_object_p) (bfd *abfd,
 451                                  struct internal_exec *execp,
 452                                  const bfd_target *(*callback_to_real_object_p) (bfd *))
 453 {
 454   struct aout_data_struct *rawptr, *oldrawptr;
 455   const bfd_target *result;
 456   bfd_size_type amt = sizeof (struct aout_data_struct);
 457
 458   rawptr = bfd_zalloc (abfd, amt);
 459   if (rawptr == NULL)
 460     return 0;
 461
 462   oldrawptr = abfd->tdata.aout_data;
 463   abfd->tdata.aout_data = rawptr;
 464
 465   /* Copy the contents of the old tdata struct.
 466      In particular, we want the subformat, since for hpux it was set in
 467      hp300hpux.c:swap_exec_header_in and will be used in
 468      hp300hpux.c:callback.  */
 469   if (oldrawptr != NULL)
 470     *abfd->tdata.aout_data = *oldrawptr;
 471
 472   abfd->tdata.aout_data->a.hdr = &rawptr->e;
 473   *(abfd->tdata.aout_data->a.hdr) = *execp;     /* Copy in the internal_exec struct.  */
 474   execp = abfd->tdata.aout_data->a.hdr;
 475
 476   /* Set the file flags.  */
 477   abfd->flags = BFD_NO_FLAGS;
 478   if (execp->a_drsize || execp->a_trsize)
 479     abfd->flags |= HAS_RELOC;
 480   /* Setting of EXEC_P has been deferred to the bottom of this function.  */
 481   if (execp->a_syms)
 482     abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
 483   if (N_DYNAMIC(*execp))
 484     abfd->flags |= DYNAMIC;
 485
 486   if (N_MAGIC (*execp) == ZMAGIC)
 487     {
 488       abfd->flags |= D_PAGED | WP_TEXT;
 489       adata (abfd).magic = z_magic;
 490     }
 491   else if (N_MAGIC (*execp) == QMAGIC)
 492     {
 493       abfd->flags |= D_PAGED | WP_TEXT;
 494       adata (abfd).magic = z_magic;
 495       adata (abfd).subformat = q_magic_format;
 496     }
 497   else if (N_MAGIC (*execp) == NMAGIC)
 498     {
 499       abfd->flags |= WP_TEXT;
 500       adata (abfd).magic = n_magic;
 501     }
 502   else if (N_MAGIC (*execp) == OMAGIC
 503            || N_MAGIC (*execp) == BMAGIC)
 504     adata (abfd).magic = o_magic;
 505   else
 506     {
 507       /* Should have been checked with N_BADMAG before this routine
 508          was called.  */
 509       abort ();
 510     }
 511
 512   bfd_get_start_address (abfd) = execp->a_entry;
 513
 514   obj_aout_symbols (abfd) = NULL;
 515   bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist);
 516
 517   /* The default relocation entry size is that of traditional V7 Unix.  */
 518   obj_reloc_entry_size (abfd) = RELOC_SIZE;
 519
 520   /* The default symbol entry size is that of traditional Unix.  */
 521   obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;
 522
 523 #ifdef USE_MMAP
 524   bfd_init_window (&obj_aout_sym_window (abfd));
 525   bfd_init_window (&obj_aout_string_window (abfd));
 526 #endif
 527
 528   obj_aout_external_syms (abfd) = NULL;
 529   obj_aout_external_strings (abfd) = NULL;
 530   obj_aout_sym_hashes (abfd) = NULL;
 531
 532   if (! NAME (aout, make_sections) (abfd))
 533     return NULL;
 534
 535   obj_datasec (abfd)->size = execp->a_data;
 536   obj_bsssec (abfd)->size = execp->a_bss;
 537
 538   obj_textsec (abfd)->flags =
 539     (execp->a_trsize != 0
 540      ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC)
 541      : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS));
 542   obj_datasec (abfd)->flags =
 543     (execp->a_drsize != 0
 544      ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC)
 545      : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS));
 546   obj_bsssec (abfd)->flags = SEC_ALLOC;
 547
 548 #ifdef THIS_IS_ONLY_DOCUMENTATION
 549   /* The common code can't fill in these things because they depend
 550      on either the start address of the text segment, the rounding
 551      up of virtual addresses between segments, or the starting file
 552      position of the text segment -- all of which varies among different
 553      versions of a.out.  */
 554
 555   /* Call back to the format-dependent code to fill in the rest of the
 556      fields and do any further cleanup.  Things that should be filled
 557      in by the callback:  */
 558   struct exec *execp = exec_hdr (abfd);
 559
 560   obj_textsec (abfd)->size = N_TXTSIZE(*execp);
 561   /* Data and bss are already filled in since they're so standard.  */
 562
 563   /* The virtual memory addresses of the sections.  */
 564   obj_textsec (abfd)->vma = N_TXTADDR(*execp);
 565   obj_datasec (abfd)->vma = N_DATADDR(*execp);
 566   obj_bsssec  (abfd)->vma = N_BSSADDR(*execp);
 567
 568   /* The file offsets of the sections.  */
 569   obj_textsec (abfd)->filepos = N_TXTOFF(*execp);
 570   obj_datasec (abfd)->filepos = N_DATOFF(*execp);
 571
 572   /* The file offsets of the relocation info.  */
 573   obj_textsec (abfd)->rel_filepos = N_TRELOFF(*execp);
 574   obj_datasec (abfd)->rel_filepos = N_DRELOFF(*execp);
 575
 576   /* The file offsets of the string table and symbol table.  */
 577   obj_str_filepos (abfd) = N_STROFF (*execp);
 578   obj_sym_filepos (abfd) = N_SYMOFF (*execp);
 579
 580   /* Determine the architecture and machine type of the object file.  */
 581   abfd->obj_arch = bfd_arch_obscure;
 582
 583   adata(abfd)->page_size = TARGET_PAGE_SIZE;
 584   adata(abfd)->segment_size = SEGMENT_SIZE;
 585   adata(abfd)->exec_bytes_size = EXEC_BYTES_SIZE;
 586
 587   return abfd->xvec;
 588
 589   /* The architecture is encoded in various ways in various a.out variants,
 590      or is not encoded at all in some of them.  The relocation size depends
 591      on the architecture and the a.out variant.  Finally, the return value
 592      is the bfd_target vector in use.  If an error occurs, return zero and
 593      set bfd_error to the appropriate error code.
 594
 595      Formats such as b.out, which have additional fields in the a.out
 596      header, should cope with them in this callback as well.  */
 597 #endif  /* DOCUMENTATION */
 598
 599   result = (*callback_to_real_object_p)(abfd);
 600
 601   /* Now that the segment addresses have been worked out, take a better
 602      guess at whether the file is executable.  If the entry point
 603      is within the text segment, assume it is.  (This makes files
 604      executable even if their entry point address is 0, as long as
 605      their text starts at zero.).
 606
 607      This test had to be changed to deal with systems where the text segment
 608      runs at a different location than the default.  The problem is that the
 609      entry address can appear to be outside the text segment, thus causing an
 610      erroneous conclusion that the file isn't executable.
 611
 612      To fix this, we now accept any non-zero entry point as an indication of
 613      executability.  This will work most of the time, since only the linker
 614      sets the entry point, and that is likely to be non-zero for most systems. */
 615
 616   if (execp->a_entry != 0
 617       || (execp->a_entry >= obj_textsec(abfd)->vma
 618           && execp->a_entry < obj_textsec(abfd)->vma + obj_textsec(abfd)->size))
 619     abfd->flags |= EXEC_P;
 620 #ifdef STAT_FOR_EXEC
 621   else
 622     {
 623       struct stat stat_buf;
 624
 625       /* The original heuristic doesn't work in some important cases.
 626         The a.out file has no information about the text start
 627         address.  For files (like kernels) linked to non-standard
 628         addresses (ld -Ttext nnn) the entry point may not be between
 629         the default text start (obj_textsec(abfd)->vma) and
 630         (obj_textsec(abfd)->vma) + text size.  This is not just a mach
 631         issue.  Many kernels are loaded at non standard addresses.  */
 632       if (abfd->iostream != NULL
 633           && (abfd->flags & BFD_IN_MEMORY) == 0
 634           && (fstat(fileno((FILE *) (abfd->iostream)), &stat_buf) == 0)
 635           && ((stat_buf.st_mode & 0111) != 0))
 636         abfd->flags |= EXEC_P;
 637     }
 638 #endif /* STAT_FOR_EXEC */
 639
 640   if (!result)
 641     {
 642       free (rawptr);
 643       abfd->tdata.aout_data = oldrawptr;
 644     }
 645   return result;
 646 }
 647
 648 /* Initialize ABFD for use with a.out files.  */
 649
 650 bfd_boolean
 651 NAME (aout, mkobject) (bfd *abfd)
 652 {
 653   struct aout_data_struct  *rawptr;
 654   bfd_size_type amt = sizeof (struct aout_data_struct);
 655
 656   bfd_set_error (bfd_error_system_call);
 657
 658   /* Use an intermediate variable for clarity.  */
 659   rawptr = bfd_zalloc (abfd, amt);
 660
 661   if (rawptr == NULL)
 662     return FALSE;
 663
 664   abfd->tdata.aout_data = rawptr;
 665   exec_hdr (abfd) = &(rawptr->e);
 666
 667   obj_textsec (abfd) = NULL;
 668   obj_datasec (abfd) = NULL;
 669   obj_bsssec (abfd)  = NULL;
 670
 671   return TRUE;
 672 }
 673
 674 /* Keep track of machine architecture and machine type for
 675    a.out's. Return the <<machine_type>> for a particular
 676    architecture and machine, or <<M_UNKNOWN>> if that exact architecture
 677    and machine can't be represented in a.out format.
 678
 679    If the architecture is understood, machine type 0 (default)
 680    is always understood.  */
 681
 682 enum machine_type
 683 NAME (aout, machine_type) (enum bfd_architecture arch,
 684                            unsigned long machine,
 685                            bfd_boolean *unknown)
 686 {
 687   enum machine_type arch_flags;
 688
 689   arch_flags = M_UNKNOWN;
 690   *unknown = TRUE;
 691
 692   switch (arch)
 693     {
 694     case bfd_arch_sparc:
 695       if (machine == 0
 696           || machine == bfd_mach_sparc
 697           || machine == bfd_mach_sparc_sparclite
 698           || machine == bfd_mach_sparc_v9)
 699         arch_flags = M_SPARC;
 700       else if (machine == bfd_mach_sparc_sparclet)
 701         arch_flags = M_SPARCLET;
 702       break;
 703
 704     case bfd_arch_m68k:
 705       switch (machine)
 706         {
 707         case 0:               arch_flags = M_68010; break;
 708         case bfd_mach_m68000: arch_flags = M_UNKNOWN; *unknown = FALSE; break;
 709         case bfd_mach_m68010: arch_flags = M_68010; break;
 710         case bfd_mach_m68020: arch_flags = M_68020; break;
 711         default:              arch_flags = M_UNKNOWN; break;
 712         }
 713       break;
 714
 715     case bfd_arch_i386:
 716       if (machine == 0
 717           || machine == bfd_mach_i386_i386
 718           || machine == bfd_mach_i386_i386_intel_syntax)
 719         arch_flags = M_386;
 720       break;
 721
 722     case bfd_arch_arm:
 723       if (machine == 0) arch_flags = M_ARM;
 724       break;
 725
 726     case bfd_arch_mips:
 727       switch (machine)
 728         {
 729         case 0:
 730         case 2000:
 731         case bfd_mach_mips3000:
 732           arch_flags = M_MIPS1;
 733           break;
 734         case bfd_mach_mips4000: /* MIPS3 */
 735         case bfd_mach_mips4400:
 736         case bfd_mach_mips8000: /* MIPS4 */
 737         case bfd_mach_mips6000: /* Real MIPS2: */
 738           arch_flags = M_MIPS2;
 739           break;
 740         default:
 741           arch_flags = M_UNKNOWN;
 742           break;
 743         }
 744       break;
 745
 746     case bfd_arch_ns32k:
 747       switch (machine)
 748         {
 749         case 0:                 arch_flags = M_NS32532; break;
 750         case 32032:             arch_flags = M_NS32032; break;
 751         case 32532:             arch_flags = M_NS32532; break;
 752         default:                arch_flags = M_UNKNOWN; break;
 753         }
 754       break;
 755
 756     case bfd_arch_pdp11:
 757       /* TODO: arch_flags = M_PDP11; */
 758       *unknown = FALSE;
 759       break;
 760
 761     case bfd_arch_vax:
 762       *unknown = FALSE;
 763       break;
 764
 765     default:
 766       arch_flags = M_UNKNOWN;
 767     }
 768
 769   if (arch_flags != M_UNKNOWN)
 770     *unknown = FALSE;
 771
 772   return arch_flags;
 773 }
 774
 775 /* Set the architecture and the machine of the ABFD to the
 776    values ARCH and MACHINE.  Verify that @ABFD's format
 777    can support the architecture required.  */
 778
 779 bfd_boolean
 780 NAME (aout, set_arch_mach) (bfd *abfd,
 781                             enum bfd_architecture arch,
 782                             unsigned long machine)
 783 {
 784   if (! bfd_default_set_arch_mach (abfd, arch, machine))
 785     return FALSE;
 786
 787   if (arch != bfd_arch_unknown)
 788     {
 789       bfd_boolean unknown;
 790
 791       NAME (aout, machine_type) (arch, machine, &unknown);
 792       if (unknown)
 793         return FALSE;
 794     }
 795
 796   obj_reloc_entry_size (abfd) = RELOC_SIZE;
 797
 798   return (*aout_backend_info(abfd)->set_sizes) (abfd);
 799 }
 800
 801 static void
 802 adjust_o_magic (bfd *abfd, struct internal_exec *execp)
 803 {
 804   file_ptr pos = adata (abfd).exec_bytes_size;
 805   bfd_vma vma = 0;
 806   int pad = 0;
 807
 808   /* Text.  */
 809   obj_textsec (abfd)->filepos = pos;
 810   if (! obj_textsec (abfd)->user_set_vma)
 811     obj_textsec (abfd)->vma = vma;
 812   else
 813     vma = obj_textsec (abfd)->vma;
 814
 815   pos += obj_textsec (abfd)->size;
 816   vma += obj_textsec (abfd)->size;
 817
 818   /* Data.  */
 819   if (!obj_datasec (abfd)->user_set_vma)
 820     {
 821       obj_textsec (abfd)->size += pad;
 822       pos += pad;
 823       vma += pad;
 824       obj_datasec (abfd)->vma = vma;
 825     }
 826   else
 827     vma = obj_datasec (abfd)->vma;
 828   obj_datasec (abfd)->filepos = pos;
 829   pos += obj_datasec (abfd)->size;
 830   vma += obj_datasec (abfd)->size;
 831
 832   /* BSS.  */
 833   if (! obj_bsssec (abfd)->user_set_vma)
 834     {
 835       obj_datasec (abfd)->size += pad;
 836       pos += pad;
 837       vma += pad;
 838       obj_bsssec (abfd)->vma = vma;
 839     }
 840   else
 841     {
 842       /* The VMA of the .bss section is set by the VMA of the
 843          .data section plus the size of the .data section.  We may
 844          need to add padding bytes to make this true.  */
 845       pad = obj_bsssec (abfd)->vma - vma;
 846       if (pad > 0)
 847         {
 848           obj_datasec (abfd)->size += pad;
 849           pos += pad;
 850         }
 851     }
 852   obj_bsssec (abfd)->filepos = pos;
 853
 854   /* Fix up the exec header.  */
 855   execp->a_text = obj_textsec (abfd)->size;
 856   execp->a_data = obj_datasec (abfd)->size;
 857   execp->a_bss  = obj_bsssec (abfd)->size;
 858   N_SET_MAGIC (*execp, OMAGIC);
 859 }
 860
 861 static void
 862 adjust_z_magic (bfd *abfd, struct internal_exec *execp)
 863 {
 864   bfd_size_type data_pad, text_pad;
 865   file_ptr text_end;
 866   const struct aout_backend_data *abdp;
 867   int ztih;                     /* Nonzero if text includes exec header.  */
 868
 869   abdp = aout_backend_info (abfd);
 870
 871   /* Text.  */
 872   ztih = (abdp != NULL
 873           && (abdp->text_includes_header
 874               || obj_aout_subformat (abfd) == q_magic_format));
 875   obj_textsec(abfd)->filepos = (ztih
 876                                 ? adata(abfd).exec_bytes_size
 877                                 : adata(abfd).zmagic_disk_block_size);
 878   if (! obj_textsec(abfd)->user_set_vma)
 879     {
 880       /* ?? Do we really need to check for relocs here?  */
 881       obj_textsec(abfd)->vma = ((abfd->flags & HAS_RELOC)
 882                                 ? 0
 883                                 : (ztih
 884                                    ? (abdp->default_text_vma
 885                                       + adata (abfd).exec_bytes_size)
 886                                    : abdp->default_text_vma));
 887       text_pad = 0;
 888     }
 889   else
 890     {
 891       /* The .text section is being loaded at an unusual address.  We
 892          may need to pad it such that the .data section starts at a page
 893          boundary.  */
 894       if (ztih)
 895         text_pad = ((obj_textsec (abfd)->filepos - obj_textsec (abfd)->vma)
 896                     & (adata (abfd).page_size - 1));
 897       else
 898         text_pad = ((- obj_textsec (abfd)->vma)
 899                     & (adata (abfd).page_size - 1));
 900     }
 901
 902   /* Find start of data.  */
 903   if (ztih)
 904     {
 905       text_end = obj_textsec (abfd)->filepos + obj_textsec (abfd)->size;
 906       text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
 907     }
 908   else
 909     {
 910       /* Note that if page_size == zmagic_disk_block_size, then
 911          filepos == page_size, and this case is the same as the ztih
 912          case.  */
 913       text_end = obj_textsec (abfd)->size;
 914       text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
 915       text_end += obj_textsec (abfd)->filepos;
 916     }
 917
 918   obj_textsec (abfd)->size += text_pad;
 919   text_end += text_pad;
 920
 921   /* Data.  */
 922   if (!obj_datasec(abfd)->user_set_vma)
 923     {
 924       bfd_vma vma;
 925       vma = obj_textsec(abfd)->vma + obj_textsec(abfd)->size;
 926       obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
 927     }
 928   if (abdp && abdp->zmagic_mapped_contiguous)
 929     {
 930       text_pad = (obj_datasec(abfd)->vma
 931                   - obj_textsec(abfd)->vma
 932                   - obj_textsec(abfd)->size);
 933       obj_textsec(abfd)->size += text_pad;
 934     }
 935   obj_datasec (abfd)->filepos = (obj_textsec (abfd)->filepos
 936                                 + obj_textsec (abfd)->size);
 937
 938   /* Fix up exec header while we're at it.  */
 939   execp->a_text = obj_textsec(abfd)->size;
 940   if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted)))
 941     execp->a_text += adata(abfd).exec_bytes_size;
 942   if (obj_aout_subformat (abfd) == q_magic_format)
 943     N_SET_MAGIC (*execp, QMAGIC);
 944   else
 945     N_SET_MAGIC (*execp, ZMAGIC);
 946
 947   /* Spec says data section should be rounded up to page boundary.  */
 948   obj_datasec(abfd)->size
 949     = align_power (obj_datasec(abfd)->size,
 950                    obj_bsssec(abfd)->alignment_power);
 951   execp->a_data = BFD_ALIGN (obj_datasec(abfd)->size,
 952                              adata(abfd).page_size);
 953   data_pad = execp->a_data - obj_datasec(abfd)->size;
 954
 955   /* BSS.  */
 956   if (!obj_bsssec(abfd)->user_set_vma)
 957     obj_bsssec(abfd)->vma = (obj_datasec(abfd)->vma
 958                              + obj_datasec(abfd)->size);
 959   /* If the BSS immediately follows the data section and extra space
 960      in the page is left after the data section, fudge data
 961      in the header so that the bss section looks smaller by that
 962      amount.  We'll start the bss section there, and lie to the OS.
 963      (Note that a linker script, as well as the above assignment,
 964      could have explicitly set the BSS vma to immediately follow
 965      the data section.)  */
 966   if (align_power (obj_bsssec(abfd)->vma, obj_bsssec(abfd)->alignment_power)
 967       == obj_datasec(abfd)->vma + obj_datasec(abfd)->size)
 968     execp->a_bss = (data_pad > obj_bsssec(abfd)->size) ? 0 :
 969       obj_bsssec(abfd)->size - data_pad;
 970   else
 971     execp->a_bss = obj_bsssec(abfd)->size;
 972 }
 973
 974 static void
 975 adjust_n_magic (bfd *abfd, struct internal_exec *execp)
 976 {
 977   file_ptr pos = adata(abfd).exec_bytes_size;
 978   bfd_vma vma = 0;
 979   int pad;
 980
 981   /* Text.  */
 982   obj_textsec(abfd)->filepos = pos;
 983   if (!obj_textsec(abfd)->user_set_vma)
 984     obj_textsec(abfd)->vma = vma;
 985   else
 986     vma = obj_textsec(abfd)->vma;
 987   pos += obj_textsec(abfd)->size;
 988   vma += obj_textsec(abfd)->size;
 989
 990   /* Data.  */
 991   obj_datasec(abfd)->filepos = pos;
 992   if (!obj_datasec(abfd)->user_set_vma)
 993     obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
 994   vma = obj_datasec(abfd)->vma;
 995
 996   /* Since BSS follows data immediately, see if it needs alignment.  */
 997   vma += obj_datasec(abfd)->size;
 998   pad = align_power (vma, obj_bsssec(abfd)->alignment_power) - vma;
 999   obj_datasec(abfd)->size += pad;
1000   pos += obj_datasec(abfd)->size;
1001
1002   /* BSS.  */
1003   if (!obj_bsssec(abfd)->user_set_vma)
1004     obj_bsssec(abfd)->vma = vma;
1005   else
1006     vma = obj_bsssec(abfd)->vma;
1007
1008   /* Fix up exec header.  */
1009   execp->a_text = obj_textsec(abfd)->size;
1010   execp->a_data = obj_datasec(abfd)->size;
1011   execp->a_bss = obj_bsssec(abfd)->size;
1012   N_SET_MAGIC (*execp, NMAGIC);
1013 }
1014
1015 bfd_boolean
1016 NAME (aout, adjust_sizes_and_vmas) (bfd *abfd,
1017                                     bfd_size_type *text_size,
1018                                     file_ptr * text_end ATTRIBUTE_UNUSED)
1019 {
1020   struct internal_exec *execp = exec_hdr (abfd);
1021
1022   if (! NAME (aout, make_sections) (abfd))
1023     return FALSE;
1024
1025   if (adata(abfd).magic != undecided_magic)
1026     return TRUE;
1027
1028   obj_textsec(abfd)->size =
1029     align_power(obj_textsec(abfd)->size,
1030                 obj_textsec(abfd)->alignment_power);
1031
1032   *text_size = obj_textsec (abfd)->size;
1033   /* Rule (heuristic) for when to pad to a new page.  Note that there
1034      are (at least) two ways demand-paged (ZMAGIC) files have been
1035      handled.  Most Berkeley-based systems start the text segment at
1036      (TARGET_PAGE_SIZE).  However, newer versions of SUNOS start the text
1037      segment right after the exec header; the latter is counted in the
1038      text segment size, and is paged in by the kernel with the rest of
1039      the text. */
1040
1041   /* This perhaps isn't the right way to do this, but made it simpler for me
1042      to understand enough to implement it.  Better would probably be to go
1043      right from BFD flags to alignment/positioning characteristics.  But the
1044      old code was sloppy enough about handling the flags, and had enough
1045      other magic, that it was a little hard for me to understand.  I think
1046      I understand it better now, but I haven't time to do the cleanup this
1047      minute.  */
1048
1049   if (abfd->flags & WP_TEXT)
1050     adata(abfd).magic = n_magic;
1051   else
1052     adata(abfd).magic = o_magic;
1053
1054 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1055 #if __GNUC__ >= 2
1056   fprintf (stderr, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1057            ({ char *str;
1058               switch (adata(abfd).magic) {
1059               case n_magic: str = "NMAGIC"; break;
1060               case o_magic: str = "OMAGIC"; break;
1061               case z_magic: str = "ZMAGIC"; break;
1062               default: abort ();
1063               }
1064               str;
1065             }),
1066            obj_textsec(abfd)->vma, obj_textsec(abfd)->size,
1067                 obj_textsec(abfd)->alignment_power,
1068            obj_datasec(abfd)->vma, obj_datasec(abfd)->size,
1069                 obj_datasec(abfd)->alignment_power,
1070            obj_bsssec(abfd)->vma, obj_bsssec(abfd)->size,
1071                 obj_bsssec(abfd)->alignment_power);
1072 #endif
1073 #endif
1074
1075   switch (adata(abfd).magic)
1076     {
1077     case o_magic:
1078       adjust_o_magic (abfd, execp);
1079       break;
1080     case z_magic:
1081       adjust_z_magic (abfd, execp);
1082       break;
1083     case n_magic:
1084       adjust_n_magic (abfd, execp);
1085       break;
1086     default:
1087       abort ();
1088     }
1089
1090 #ifdef BFD_AOUT_DEBUG
1091   fprintf (stderr, "       text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1092            obj_textsec(abfd)->vma, obj_textsec(abfd)->size,
1093                 obj_textsec(abfd)->filepos,
1094            obj_datasec(abfd)->vma, obj_datasec(abfd)->size,
1095                 obj_datasec(abfd)->filepos,
1096            obj_bsssec(abfd)->vma, obj_bsssec(abfd)->size);
1097 #endif
1098
1099   return TRUE;
1100 }
1101
1102 /* Called by the BFD in response to a bfd_make_section request.  */
1103
1104 bfd_boolean
1105 NAME (aout, new_section_hook) (bfd *abfd, asection *newsect)
1106 {
1107   /* Align to double at least.  */
1108   newsect->alignment_power = bfd_get_arch_info(abfd)->section_align_power;
1109
1110   if (bfd_get_format (abfd) == bfd_object)
1111     {
1112       if (obj_textsec (abfd) == NULL
1113           && ! strcmp (newsect->name, ".text"))
1114         {
1115           obj_textsec(abfd)= newsect;
1116           newsect->target_index = N_TEXT;
1117           return TRUE;
1118         }
1119
1120     if (obj_datasec (abfd) == NULL
1121         && ! strcmp (newsect->name, ".data"))
1122       {
1123         obj_datasec (abfd) = newsect;
1124         newsect->target_index = N_DATA;
1125         return TRUE;
1126       }
1127
1128     if (obj_bsssec (abfd) == NULL
1129         && !strcmp (newsect->name, ".bss"))
1130       {
1131         obj_bsssec (abfd) = newsect;
1132         newsect->target_index = N_BSS;
1133         return TRUE;
1134       }
1135   }
1136
1137   /* We allow more than three sections internally.  */
1138   return TRUE;
1139 }
1140
1141 bfd_boolean
1142 NAME (aout, set_section_contents) (bfd *abfd,
1143                                    sec_ptr section,
1144                                    const void * location,
1145                                    file_ptr offset,
1146                                    bfd_size_type count)
1147 {
1148   file_ptr text_end;
1149   bfd_size_type text_size;
1150
1151   if (! abfd->output_has_begun)
1152     {
1153       if (! NAME (aout, adjust_sizes_and_vmas) (abfd, & text_size, & text_end))
1154         return FALSE;
1155     }
1156
1157   if (section == obj_bsssec (abfd))
1158     {
1159       bfd_set_error (bfd_error_no_contents);
1160       return FALSE;
1161     }
1162
1163   if (section != obj_textsec (abfd)
1164       && section != obj_datasec (abfd))
1165     {
1166       (*_bfd_error_handler)
1167         ("%s: can not represent section `%s' in a.out object file format",
1168          bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
1169       bfd_set_error (bfd_error_nonrepresentable_section);
1170       return FALSE;
1171     }
1172
1173   if (count != 0)
1174     {
1175       if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1176           || bfd_bwrite (location, count, abfd) != count)
1177         return FALSE;
1178     }
1179
1180   return TRUE;
1181 }
1182 \f
1183 /* Read the external symbols from an a.out file.  */
1184
1185 static bfd_boolean
1186 aout_get_external_symbols (bfd *abfd)
1187 {
1188   if (obj_aout_external_syms (abfd) == NULL)
1189     {
1190       bfd_size_type count;
1191       struct external_nlist *syms;
1192
1193       count = exec_hdr (abfd)->a_syms / EXTERNAL_NLIST_SIZE;
1194
1195 #ifdef USE_MMAP
1196       if (! bfd_get_file_window (abfd, obj_sym_filepos (abfd),
1197                                  exec_hdr (abfd)->a_syms,
1198                                  &obj_aout_sym_window (abfd), TRUE))
1199         return FALSE;
1200       syms = (struct external_nlist *) obj_aout_sym_window (abfd).data;
1201 #else
1202       /* We allocate using malloc to make the values easy to free
1203          later on.  If we put them on the objalloc it might not be
1204          possible to free them.  */
1205       syms = bfd_malloc (count * EXTERNAL_NLIST_SIZE);
1206       if (syms == NULL && count != 0)
1207         return FALSE;
1208
1209       if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1210           || (bfd_bread (syms, exec_hdr (abfd)->a_syms, abfd)
1211               != exec_hdr (abfd)->a_syms))
1212         {
1213           free (syms);
1214           return FALSE;
1215         }
1216 #endif
1217
1218       obj_aout_external_syms (abfd) = syms;
1219       obj_aout_external_sym_count (abfd) = count;
1220     }
1221
1222   if (obj_aout_external_strings (abfd) == NULL
1223       && exec_hdr (abfd)->a_syms != 0)
1224     {
1225       unsigned char string_chars[BYTES_IN_LONG];
1226       bfd_size_type stringsize;
1227       char *strings;
1228
1229       /* Get the size of the strings.  */
1230       if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
1231           || (bfd_bread ((void *) string_chars, (bfd_size_type) BYTES_IN_LONG,
1232                         abfd) != BYTES_IN_LONG))
1233         return FALSE;
1234       stringsize = H_GET_32 (abfd, string_chars);
1235
1236 #ifdef USE_MMAP
1237       if (! bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
1238                                  &obj_aout_string_window (abfd), TRUE))
1239         return FALSE;
1240       strings = (char *) obj_aout_string_window (abfd).data;
1241 #else
1242       strings = bfd_malloc (stringsize + 1);
1243       if (strings == NULL)
1244         return FALSE;
1245
1246       /* Skip space for the string count in the buffer for convenience
1247          when using indexes.  */
1248       if (bfd_bread (strings + 4, stringsize - 4, abfd) != stringsize - 4)
1249         {
1250           free (strings);
1251           return FALSE;
1252         }
1253 #endif
1254       /* Ensure that a zero index yields an empty string.  */
1255       strings[0] = '\0';
1256
1257       strings[stringsize - 1] = 0;
1258
1259       obj_aout_external_strings (abfd) = strings;
1260       obj_aout_external_string_size (abfd) = stringsize;
1261     }
1262
1263   return TRUE;
1264 }
1265
1266 /* Translate an a.out symbol into a BFD symbol.  The desc, other, type
1267    and symbol->value fields of CACHE_PTR will be set from the a.out
1268    nlist structure.  This function is responsible for setting
1269    symbol->flags and symbol->section, and adjusting symbol->value.  */
1270
1271 static bfd_boolean
1272 translate_from_native_sym_flags (bfd *abfd,
1273                                  aout_symbol_type *cache_ptr)
1274 {
1275   flagword visible;
1276
1277   if (cache_ptr->type == N_FN)
1278     {
1279       asection *sec;
1280
1281       /* This is a debugging symbol.  */
1282       cache_ptr->symbol.flags = BSF_DEBUGGING;
1283
1284       /* Work out the symbol section.  */
1285       switch (cache_ptr->type & N_TYPE)
1286         {
1287         case N_TEXT:
1288         case N_FN:
1289           sec = obj_textsec (abfd);
1290           break;
1291         case N_DATA:
1292           sec = obj_datasec (abfd);
1293           break;
1294         case N_BSS:
1295           sec = obj_bsssec (abfd);
1296           break;
1297         default:
1298         case N_ABS:
1299           sec = bfd_abs_section_ptr;
1300           break;
1301         }
1302
1303       cache_ptr->symbol.section = sec;
1304       cache_ptr->symbol.value -= sec->vma;
1305
1306       return TRUE;
1307     }
1308
1309   /* Get the default visibility.  This does not apply to all types, so
1310      we just hold it in a local variable to use if wanted.  */
1311   if ((cache_ptr->type & N_EXT) == 0)
1312     visible = BSF_LOCAL;
1313   else
1314     visible = BSF_GLOBAL;
1315
1316   switch (cache_ptr->type)
1317     {
1318     default:
1319     case N_ABS: case N_ABS | N_EXT:
1320       cache_ptr->symbol.section = bfd_abs_section_ptr;
1321       cache_ptr->symbol.flags = visible;
1322       break;
1323
1324     case N_UNDF | N_EXT:
1325       if (cache_ptr->symbol.value != 0)
1326         {
1327           /* This is a common symbol.  */
1328           cache_ptr->symbol.flags = BSF_GLOBAL;
1329           cache_ptr->symbol.section = bfd_com_section_ptr;
1330         }
1331       else
1332         {
1333           cache_ptr->symbol.flags = 0;
1334           cache_ptr->symbol.section = bfd_und_section_ptr;
1335         }
1336       break;
1337
1338     case N_TEXT: case N_TEXT | N_EXT:
1339       cache_ptr->symbol.section = obj_textsec (abfd);
1340       cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1341       cache_ptr->symbol.flags = visible;
1342       break;
1343
1344     case N_DATA: case N_DATA | N_EXT:
1345       cache_ptr->symbol.section = obj_datasec (abfd);
1346       cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1347       cache_ptr->symbol.flags = visible;
1348       break;
1349
1350     case N_BSS: case N_BSS | N_EXT:
1351       cache_ptr->symbol.section = obj_bsssec (abfd);
1352       cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1353       cache_ptr->symbol.flags = visible;
1354       break;
1355     }
1356
1357   return TRUE;
1358 }
1359
1360 /* Set the fields of SYM_POINTER according to CACHE_PTR.  */
1361
1362 static bfd_boolean
1363 translate_to_native_sym_flags (bfd *abfd,
1364                                asymbol *cache_ptr,
1365                                struct external_nlist *sym_pointer)
1366 {
1367   bfd_vma value = cache_ptr->value;
1368   asection *sec;
1369   bfd_vma off;
1370
1371   /* Mask out any existing type bits in case copying from one section
1372      to another.  */
1373   sym_pointer->e_type[0] &= ~N_TYPE;
1374
1375   sec = bfd_get_section (cache_ptr);
1376   off = 0;
1377
1378   if (sec == NULL)
1379     {
1380       /* This case occurs, e.g., for the *DEBUG* section of a COFF
1381          file.  */
1382       (*_bfd_error_handler)
1383         ("%B: can not represent section for symbol `%s' in a.out object file format",
1384          abfd, cache_ptr->name != NULL ? cache_ptr->name : "*unknown*");
1385       bfd_set_error (bfd_error_nonrepresentable_section);
1386       return FALSE;
1387     }
1388
1389   if (sec->output_section != NULL)
1390     {
1391       off = sec->output_offset;
1392       sec = sec->output_section;
1393     }
1394
1395   if (bfd_is_abs_section (sec))
1396     sym_pointer->e_type[0] |= N_ABS;
1397   else if (sec == obj_textsec (abfd))
1398     sym_pointer->e_type[0] |= N_TEXT;
1399   else if (sec == obj_datasec (abfd))
1400     sym_pointer->e_type[0] |= N_DATA;
1401   else if (sec == obj_bsssec (abfd))
1402     sym_pointer->e_type[0] |= N_BSS;
1403   else if (bfd_is_und_section (sec))
1404     sym_pointer->e_type[0] = N_UNDF | N_EXT;
1405   else if (bfd_is_com_section (sec))
1406     sym_pointer->e_type[0] = N_UNDF | N_EXT;
1407   else
1408     {
1409       (*_bfd_error_handler)
1410         ("%B: can not represent section `%A' in a.out object file format",
1411          abfd, sec);
1412       bfd_set_error (bfd_error_nonrepresentable_section);
1413       return FALSE;
1414     }
1415
1416   /* Turn the symbol from section relative to absolute again */
1417   value += sec->vma + off;
1418
1419   if ((cache_ptr->flags & BSF_DEBUGGING) != 0)
1420     sym_pointer->e_type[0] = ((aout_symbol_type *) cache_ptr)->type;
1421   else if ((cache_ptr->flags & BSF_GLOBAL) != 0)
1422     sym_pointer->e_type[0] |= N_EXT;
1423
1424   PUT_WORD(abfd, value, sym_pointer->e_value);
1425
1426   return TRUE;
1427 }
1428 \f
1429 /* Native-level interface to symbols. */
1430
1431 asymbol *
1432 NAME (aout, make_empty_symbol) (bfd *abfd)
1433 {
1434   bfd_size_type amt = sizeof (aout_symbol_type);
1435   aout_symbol_type *new = bfd_zalloc (abfd, amt);
1436
1437   if (!new)
1438     return NULL;
1439   new->symbol.the_bfd = abfd;
1440
1441   return &new->symbol;
1442 }
1443
1444 /* Translate a set of internal symbols into external symbols.  */
1445
1446 bfd_boolean
1447 NAME (aout, translate_symbol_table) (bfd *abfd,
1448                                      aout_symbol_type *in,
1449                                      struct external_nlist *ext,
1450                                      bfd_size_type count,
1451                                      char *str,
1452                                      bfd_size_type strsize,
1453                                      bfd_boolean dynamic)
1454 {
1455   struct external_nlist *ext_end;
1456
1457   ext_end = ext + count;
1458   for (; ext < ext_end; ext++, in++)
1459     {
1460       bfd_vma x;
1461
1462       x = GET_WORD (abfd, ext->e_strx);
1463       in->symbol.the_bfd = abfd;
1464
1465       /* For the normal symbols, the zero index points at the number
1466          of bytes in the string table but is to be interpreted as the
1467          null string.  For the dynamic symbols, the number of bytes in
1468          the string table is stored in the __DYNAMIC structure and the
1469          zero index points at an actual string.  */
1470       if (x == 0 && ! dynamic)
1471         in->symbol.name = "";
1472       else if (x < strsize)
1473         in->symbol.name = str + x;
1474       else
1475         return FALSE;
1476
1477       in->symbol.value = GET_SWORD (abfd,  ext->e_value);
1478       /* TODO: is 0 a safe value here?  */
1479       in->desc = 0;
1480       in->other = 0;
1481       in->type = H_GET_8 (abfd,  ext->e_type);
1482       in->symbol.udata.p = NULL;
1483
1484       if (! translate_from_native_sym_flags (abfd, in))
1485         return FALSE;
1486
1487       if (dynamic)
1488         in->symbol.flags |= BSF_DYNAMIC;
1489     }
1490
1491   return TRUE;
1492 }
1493
1494 /* We read the symbols into a buffer, which is discarded when this
1495    function exits.  We read the strings into a buffer large enough to
1496    hold them all plus all the cached symbol entries.  */
1497
1498 bfd_boolean
1499 NAME (aout, slurp_symbol_table) (bfd *abfd)
1500 {
1501   struct external_nlist *old_external_syms;
1502   aout_symbol_type *cached;
1503   bfd_size_type cached_size;
1504
1505   /* If there's no work to be done, don't do any.  */
1506   if (obj_aout_symbols (abfd) != NULL)
1507     return TRUE;
1508
1509   old_external_syms = obj_aout_external_syms (abfd);
1510
1511   if (! aout_get_external_symbols (abfd))
1512     return FALSE;
1513
1514   cached_size = obj_aout_external_sym_count (abfd);
1515   cached_size *= sizeof (aout_symbol_type);
1516   cached = bfd_zmalloc (cached_size);
1517   if (cached == NULL && cached_size != 0)
1518     return FALSE;
1519
1520   /* Convert from external symbol information to internal.  */
1521   if (! (NAME (aout, translate_symbol_table)
1522          (abfd, cached,
1523           obj_aout_external_syms (abfd),
1524           obj_aout_external_sym_count (abfd),
1525           obj_aout_external_strings (abfd),
1526           obj_aout_external_string_size (abfd),
1527           FALSE)))
1528     {
1529       free (cached);
1530       return FALSE;
1531     }
1532
1533   bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
1534
1535   obj_aout_symbols (abfd) = cached;
1536
1537   /* It is very likely that anybody who calls this function will not
1538      want the external symbol information, so if it was allocated
1539      because of our call to aout_get_external_symbols, we free it up
1540      right away to save space.  */
1541   if (old_external_syms == NULL
1542       && obj_aout_external_syms (abfd) != NULL)
1543     {
1544 #ifdef USE_MMAP
1545       bfd_free_window (&obj_aout_sym_window (abfd));
1546 #else
1547       free (obj_aout_external_syms (abfd));
1548 #endif
1549       obj_aout_external_syms (abfd) = NULL;
1550     }
1551
1552   return TRUE;
1553 }
1554 \f
1555 /* We use a hash table when writing out symbols so that we only write
1556    out a particular string once.  This helps particularly when the
1557    linker writes out stabs debugging entries, because each different
1558    contributing object file tends to have many duplicate stabs
1559    strings.
1560
1561    This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1562    if BFD_TRADITIONAL_FORMAT is set.  */
1563
1564 /* Get the index of a string in a strtab, adding it if it is not
1565    already present.  */
1566
1567 static INLINE bfd_size_type
1568 add_to_stringtab (bfd *abfd,
1569                   struct bfd_strtab_hash *tab,
1570                   const char *str,
1571                   bfd_boolean copy)
1572 {
1573   bfd_boolean hash;
1574   bfd_size_type index;
1575
1576   /* An index of 0 always means the empty string.  */
1577   if (str == 0 || *str == '\0')
1578     return 0;
1579
1580   /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1581      doesn't understand a hashed string table.  */
1582   hash = TRUE;
1583   if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1584     hash = FALSE;
1585
1586   index = _bfd_stringtab_add (tab, str, hash, copy);
1587
1588   if (index != (bfd_size_type) -1)
1589     /* Add BYTES_IN_LONG to the return value to account for the
1590        space taken up by the string table size.  */
1591     index += BYTES_IN_LONG;
1592
1593   return index;
1594 }
1595
1596 /* Write out a strtab.  ABFD is already at the right location in the
1597    file.  */
1598
1599 static bfd_boolean
1600 emit_stringtab (bfd *abfd, struct bfd_strtab_hash *tab)
1601 {
1602   bfd_byte buffer[BYTES_IN_LONG];
1603
1604   /* The string table starts with the size.  */
1605   H_PUT_32 (abfd, _bfd_stringtab_size (tab) + BYTES_IN_LONG, buffer);
1606   if (bfd_bwrite ((void *) buffer, (bfd_size_type) BYTES_IN_LONG, abfd)
1607       != BYTES_IN_LONG)
1608     return FALSE;
1609
1610   return _bfd_stringtab_emit (abfd, tab);
1611 }
1612 \f
1613 bfd_boolean
1614 NAME (aout, write_syms) (bfd *abfd)
1615 {
1616   unsigned int count ;
1617   asymbol **generic = bfd_get_outsymbols (abfd);
1618   struct bfd_strtab_hash *strtab;
1619
1620   strtab = _bfd_stringtab_init ();
1621   if (strtab == NULL)
1622     return FALSE;
1623
1624   for (count = 0; count < bfd_get_symcount (abfd); count++)
1625     {
1626       asymbol *g = generic[count];
1627       bfd_size_type indx;
1628       struct external_nlist nsp;
1629
1630       PUT_WORD (abfd, 0, nsp.e_unused);
1631
1632       indx = add_to_stringtab (abfd, strtab, g->name, FALSE);
1633       if (indx == (bfd_size_type) -1)
1634         goto error_return;
1635       PUT_WORD (abfd, indx, nsp.e_strx);
1636
1637       if (bfd_asymbol_flavour(g) == abfd->xvec->flavour)
1638         H_PUT_8 (abfd, aout_symbol(g)->type,  nsp.e_type);
1639       else
1640         H_PUT_8 (abfd, 0, nsp.e_type);
1641
1642       if (! translate_to_native_sym_flags (abfd, g, &nsp))
1643         goto error_return;
1644
1645       H_PUT_8 (abfd, 0, nsp.e_ovly);
1646
1647       if (bfd_bwrite ((void *)&nsp, (bfd_size_type) EXTERNAL_NLIST_SIZE, abfd)
1648           != EXTERNAL_NLIST_SIZE)
1649         goto error_return;
1650
1651       /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1652          here, at the end.  */
1653       g->KEEPIT = count;
1654     }
1655
1656   if (! emit_stringtab (abfd, strtab))
1657     goto error_return;
1658
1659   _bfd_stringtab_free (strtab);
1660
1661   return TRUE;
1662
1663 error_return:
1664   _bfd_stringtab_free (strtab);
1665   return FALSE;
1666 }
1667
1668 \f
1669 long
1670 NAME (aout, canonicalize_symtab) (bfd *abfd, asymbol **location)
1671 {
1672   unsigned int counter = 0;
1673   aout_symbol_type *symbase;
1674
1675   if (!NAME (aout, slurp_symbol_table) (abfd))
1676     return -1;
1677
1678   for (symbase = obj_aout_symbols (abfd); counter++ < bfd_get_symcount (abfd);)
1679     *(location++) = (asymbol *)(symbase++);
1680   *location++ =0;
1681   return bfd_get_symcount (abfd);
1682 }
1683
1684 \f
1685 /* Output extended relocation information to a file in target byte order.  */
1686
1687 static void
1688 pdp11_aout_swap_reloc_out (bfd *abfd, arelent *g, bfd_byte *natptr)
1689 {
1690   int r_index;
1691   int r_pcrel;
1692   int reloc_entry;
1693   int r_type;
1694   asymbol *sym = *(g->sym_ptr_ptr);
1695   asection *output_section = sym->section->output_section;
1696
1697   if (g->addend != 0)
1698     fprintf (stderr, "BFD: can't do this reloc addend stuff\n");
1699
1700   r_pcrel = g->howto->pc_relative;
1701
1702   if (bfd_is_abs_section (output_section))
1703     r_type = RABS;
1704   else if (output_section == obj_textsec (abfd))
1705     r_type = RTEXT;
1706   else if (output_section == obj_datasec (abfd))
1707     r_type = RDATA;
1708   else if (output_section == obj_bsssec (abfd))
1709     r_type = RBSS;
1710   else if (bfd_is_und_section (output_section))
1711     r_type = REXT;
1712   else if (bfd_is_com_section (output_section))
1713     r_type = REXT;
1714   else
1715     r_type = -1;
1716
1717   BFD_ASSERT (r_type != -1);
1718
1719   if (r_type == RABS)
1720     r_index = 0;
1721   else
1722     r_index = (*(g->sym_ptr_ptr))->KEEPIT;
1723
1724   reloc_entry = r_index << 4 | r_type | r_pcrel;
1725
1726   PUT_WORD (abfd, reloc_entry, natptr);
1727 }
1728
1729 /* BFD deals internally with all things based from the section they're
1730    in. so, something in 10 bytes into a text section  with a base of
1731    50 would have a symbol (.text+10) and know .text vma was 50.
1732
1733    Aout keeps all it's symbols based from zero, so the symbol would
1734    contain 60. This macro subs the base of each section from the value
1735    to give the true offset from the section */
1736
1737
1738 #define MOVE_ADDRESS(ad)                                                \
1739   if (r_extern)                                                         \
1740     {                                                                   \
1741       /* Undefined symbol.  */                                          \
1742       cache_ptr->sym_ptr_ptr = symbols + r_index;                       \
1743       cache_ptr->addend = ad;                                           \
1744     }                                                                   \
1745   else                                                                  \
1746     {                                                                   \
1747       /* Defined, section relative. replace symbol with pointer to      \
1748          symbol which points to section.  */                            \
1749       switch (r_index)                                                  \
1750         {                                                               \
1751         case N_TEXT:                                                    \
1752         case N_TEXT | N_EXT:                                            \
1753           cache_ptr->sym_ptr_ptr  = obj_textsec (abfd)->symbol_ptr_ptr; \
1754           cache_ptr->addend = ad  - su->textsec->vma;                   \
1755           break;                                                        \
1756         case N_DATA:                                                    \
1757         case N_DATA | N_EXT:                                            \
1758           cache_ptr->sym_ptr_ptr  = obj_datasec (abfd)->symbol_ptr_ptr; \
1759           cache_ptr->addend = ad - su->datasec->vma;                    \
1760           break;                                                        \
1761         case N_BSS:                                                     \
1762         case N_BSS | N_EXT:                                             \
1763           cache_ptr->sym_ptr_ptr  = obj_bsssec (abfd)->symbol_ptr_ptr;  \
1764           cache_ptr->addend = ad - su->bsssec->vma;                     \
1765           break;                                                        \
1766         default:                                                        \
1767         case N_ABS:                                                     \
1768         case N_ABS | N_EXT:                                             \
1769           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1770           cache_ptr->addend = ad;                                       \
1771           break;                                                        \
1772         }                                                               \
1773     }
1774
1775 static void
1776 pdp11_aout_swap_reloc_in (bfd *          abfd,
1777                           bfd_byte *     bytes,
1778                           arelent *      cache_ptr,
1779                           bfd_size_type  offset,
1780                           asymbol **     symbols,
1781                           bfd_size_type  symcount)
1782 {
1783   struct aoutdata *su = &(abfd->tdata.aout_data->a);
1784   unsigned int r_index;
1785   int reloc_entry;
1786   int r_extern;
1787   int r_pcrel;
1788
1789   reloc_entry = GET_WORD (abfd, (void *) bytes);
1790
1791   r_pcrel = reloc_entry & RELFLG;
1792
1793   cache_ptr->address = offset;
1794   cache_ptr->howto = howto_table_pdp11 + (r_pcrel ? 1 : 0);
1795
1796   if ((reloc_entry & RTYPE) == RABS)
1797     r_index = N_ABS;
1798   else
1799     r_index = RINDEX (reloc_entry);
1800
1801   /* r_extern reflects whether the symbol the reloc is against is
1802      local or global.  */
1803   r_extern = (reloc_entry & RTYPE) == REXT;
1804
1805   if (r_extern && r_index > symcount)
1806     {
1807       /* We could arrange to return an error, but it might be useful
1808          to see the file even if it is bad.  */
1809       r_extern = 0;
1810       r_index = N_ABS;
1811     }
1812
1813   MOVE_ADDRESS(0);
1814 }
1815
1816 /* Read and swap the relocs for a section.  */
1817
1818 bfd_boolean
1819 NAME (aout, slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols)
1820 {
1821   bfd_byte *rptr;
1822   bfd_size_type count;
1823   bfd_size_type reloc_size;
1824   void * relocs;
1825   arelent *reloc_cache;
1826   size_t each_size;
1827   unsigned int counter = 0;
1828   arelent *cache_ptr;
1829
1830   if (asect->relocation)
1831     return TRUE;
1832
1833   if (asect->flags & SEC_CONSTRUCTOR)
1834     return TRUE;
1835
1836   if (asect == obj_datasec (abfd))
1837     reloc_size = exec_hdr(abfd)->a_drsize;
1838   else if (asect == obj_textsec (abfd))
1839     reloc_size = exec_hdr(abfd)->a_trsize;
1840   else if (asect == obj_bsssec (abfd))
1841     reloc_size = 0;
1842   else
1843     {
1844       bfd_set_error (bfd_error_invalid_operation);
1845       return FALSE;
1846     }
1847
1848   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
1849     return FALSE;
1850
1851   each_size = obj_reloc_entry_size (abfd);
1852
1853   relocs = bfd_malloc (reloc_size);
1854   if (relocs == NULL && reloc_size != 0)
1855     return FALSE;
1856
1857   if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
1858     {
1859       free (relocs);
1860       return FALSE;
1861     }
1862
1863   count = reloc_size / each_size;
1864
1865   /* Count the number of NON-ZERO relocs, this is the count we want.  */
1866   {
1867     unsigned int real_count = 0;
1868
1869     for (counter = 0; counter < count; counter++)
1870       {
1871         int x;
1872
1873         x = GET_WORD (abfd, (char *) relocs + each_size * counter);
1874         if (x != 0)
1875           real_count++;
1876       }
1877
1878     count = real_count;
1879   }
1880
1881   reloc_cache = bfd_zmalloc (count * sizeof (arelent));
1882   if (reloc_cache == NULL && count != 0)
1883     return FALSE;
1884
1885   cache_ptr = reloc_cache;
1886
1887   rptr = relocs;
1888   for (counter = 0;
1889        counter < count;
1890        counter++, rptr += RELOC_SIZE, cache_ptr++)
1891     {
1892       while (GET_WORD (abfd, (void *) rptr) == 0)
1893         {
1894           rptr += RELOC_SIZE;
1895           if ((char *) rptr >= (char *) relocs + reloc_size)
1896             goto done;
1897         }
1898
1899       pdp11_aout_swap_reloc_in (abfd, rptr, cache_ptr,
1900                                 (bfd_size_type) ((char *) rptr - (char *) relocs),
1901                                 symbols,
1902                                 (bfd_size_type) bfd_get_symcount (abfd));
1903     }
1904  done:
1905   /* Just in case, if rptr >= relocs + reloc_size should happen
1906      too early.  */
1907   BFD_ASSERT (counter == count);
1908
1909   free (relocs);
1910
1911   asect->relocation = reloc_cache;
1912   asect->reloc_count = cache_ptr - reloc_cache;
1913
1914   return TRUE;
1915 }
1916
1917 /* Write out a relocation section into an object file.  */
1918
1919 bfd_boolean
1920 NAME (aout, squirt_out_relocs) (bfd *abfd, asection *section)
1921 {
1922   arelent **generic;
1923   unsigned char *native;
1924   unsigned int count = section->reloc_count;
1925   bfd_size_type natsize;
1926
1927   natsize = section->size;
1928   native = bfd_zalloc (abfd, natsize);
1929   if (!native)
1930     return FALSE;
1931
1932   generic = section->orelocation;
1933   if (generic != NULL)
1934     {
1935       while (count > 0)
1936         {
1937           bfd_byte *r;
1938
1939           r = native + (*generic)->address;
1940           pdp11_aout_swap_reloc_out (abfd, *generic, r);
1941           count--;
1942           generic++;
1943         }
1944     }
1945
1946   if (bfd_bwrite ((void *) native, natsize, abfd) != natsize)
1947     {
1948       bfd_release (abfd, native);
1949       return FALSE;
1950     }
1951
1952   bfd_release (abfd, native);
1953   return TRUE;
1954 }
1955
1956 /* This is stupid.  This function should be a boolean predicate.  */
1957
1958 long
1959 NAME (aout, canonicalize_reloc) (bfd *abfd,
1960                                  sec_ptr section,
1961                                  arelent **relptr,
1962                                  asymbol **symbols)
1963 {
1964   arelent *tblptr = section->relocation;
1965   unsigned int count;
1966
1967   if (section == obj_bsssec (abfd))
1968     {
1969       *relptr = NULL;
1970       return 0;
1971     }
1972
1973   if (!(tblptr || NAME (aout, slurp_reloc_table)(abfd, section, symbols)))
1974     return -1;
1975
1976   if (section->flags & SEC_CONSTRUCTOR)
1977     {
1978       arelent_chain *chain = section->constructor_chain;
1979
1980       for (count = 0; count < section->reloc_count; count ++)
1981         {
1982           *relptr ++ = &chain->relent;
1983           chain = chain->next;
1984         }
1985     }
1986   else
1987     {
1988       tblptr = section->relocation;
1989
1990       for (count = 0; count++ < section->reloc_count;)
1991         *relptr++ = tblptr++;
1992     }
1993
1994   *relptr = 0;
1995
1996   return section->reloc_count;
1997 }
1998
1999 long
2000 NAME (aout, get_reloc_upper_bound) (bfd *abfd, sec_ptr asect)
2001 {
2002   if (bfd_get_format (abfd) != bfd_object)
2003     {
2004       bfd_set_error (bfd_error_invalid_operation);
2005       return -1;
2006     }
2007
2008   if (asect->flags & SEC_CONSTRUCTOR)
2009     return (sizeof (arelent *) * (asect->reloc_count + 1));
2010
2011   if (asect == obj_datasec (abfd))
2012     return (sizeof (arelent *)
2013             * ((exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd))
2014                + 1));
2015
2016   if (asect == obj_textsec (abfd))
2017     return (sizeof (arelent *)
2018             * ((exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd))
2019                + 1));
2020
2021   /* TODO: why are there two if statements for obj_bsssec()? */
2022
2023   if (asect == obj_bsssec (abfd))
2024     return sizeof (arelent *);
2025
2026   if (asect == obj_bsssec (abfd))
2027     return 0;
2028
2029   bfd_set_error (bfd_error_invalid_operation);
2030   return -1;
2031 }
2032
2033 \f
2034 long
2035 NAME (aout, get_symtab_upper_bound) (bfd *abfd)
2036 {
2037   if (!NAME (aout, slurp_symbol_table) (abfd))
2038     return -1;
2039
2040   return (bfd_get_symcount (abfd) + 1) * (sizeof (aout_symbol_type *));
2041 }
2042
2043 alent *
2044 NAME (aout, get_lineno) (bfd * abfd ATTRIBUTE_UNUSED,
2045                          asymbol * symbol ATTRIBUTE_UNUSED)
2046 {
2047   return NULL;
2048 }
2049
2050 void
2051 NAME (aout, get_symbol_info) (bfd * abfd ATTRIBUTE_UNUSED,
2052                               asymbol *symbol,
2053                               symbol_info *ret)
2054 {
2055   bfd_symbol_info (symbol, ret);
2056
2057   if (ret->type == '?')
2058     {
2059       int type_code = aout_symbol(symbol)->type & 0xff;
2060       const char *stab_name = bfd_get_stab_name (type_code);
2061       static char buf[10];
2062
2063       if (stab_name == NULL)
2064         {
2065           sprintf(buf, "(%d)", type_code);
2066           stab_name = buf;
2067         }
2068       ret->type = '-';
2069       ret->stab_type  = type_code;
2070       ret->stab_other = (unsigned) (aout_symbol(symbol)->other & 0xff);
2071       ret->stab_desc  = (unsigned) (aout_symbol(symbol)->desc & 0xffff);
2072       ret->stab_name  = stab_name;
2073     }
2074 }
2075
2076 void
2077 NAME (aout, print_symbol) (bfd * abfd,
2078                            void * afile,
2079                            asymbol *symbol,
2080                            bfd_print_symbol_type how)
2081 {
2082   FILE *file = (FILE *) afile;
2083
2084   switch (how)
2085     {
2086     case bfd_print_symbol_name:
2087       if (symbol->name)
2088         fprintf(file,"%s", symbol->name);
2089       break;
2090     case bfd_print_symbol_more:
2091       fprintf(file,"%4x %2x %2x",
2092               (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2093               (unsigned) (aout_symbol (symbol)->other & 0xff),
2094               (unsigned) (aout_symbol (symbol)->type));
2095       break;
2096     case bfd_print_symbol_all:
2097       {
2098         const char *section_name = symbol->section->name;
2099
2100         bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2101
2102         fprintf (file," %-5s %04x %02x %02x",
2103                  section_name,
2104                  (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2105                  (unsigned) (aout_symbol (symbol)->other & 0xff),
2106                  (unsigned) (aout_symbol (symbol)->type  & 0xff));
2107         if (symbol->name)
2108           fprintf(file," %s", symbol->name);
2109       }
2110       break;
2111     }
2112 }
2113
2114 /* If we don't have to allocate more than 1MB to hold the generic
2115    symbols, we use the generic minisymbol method: it's faster, since
2116    it only translates the symbols once, not multiple times.  */
2117 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2118
2119 /* Read minisymbols.  For minisymbols, we use the unmodified a.out
2120    symbols.  The minisymbol_to_symbol function translates these into
2121    BFD asymbol structures.  */
2122
2123 long
2124 NAME (aout, read_minisymbols) (bfd *abfd,
2125                                bfd_boolean dynamic,
2126                                void * *minisymsp,
2127                                unsigned int *sizep)
2128 {
2129   if (dynamic)
2130     /* We could handle the dynamic symbols here as well, but it's
2131        easier to hand them off.  */
2132     return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2133
2134   if (! aout_get_external_symbols (abfd))
2135     return -1;
2136
2137   if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2138     return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2139
2140   *minisymsp = (void *) obj_aout_external_syms (abfd);
2141
2142   /* By passing the external symbols back from this routine, we are
2143      giving up control over the memory block.  Clear
2144      obj_aout_external_syms, so that we do not try to free it
2145      ourselves.  */
2146   obj_aout_external_syms (abfd) = NULL;
2147
2148   *sizep = EXTERNAL_NLIST_SIZE;
2149   return obj_aout_external_sym_count (abfd);
2150 }
2151
2152 /* Convert a minisymbol to a BFD asymbol.  A minisymbol is just an
2153    unmodified a.out symbol.  The SYM argument is a structure returned
2154    by bfd_make_empty_symbol, which we fill in here.  */
2155
2156 asymbol *
2157 NAME (aout, minisymbol_to_symbol) (bfd *abfd,
2158                                    bfd_boolean dynamic,
2159                                    const void * minisym,
2160                                    asymbol *sym)
2161 {
2162   if (dynamic
2163       || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2164     return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
2165
2166   memset (sym, 0, sizeof (aout_symbol_type));
2167
2168   /* We call translate_symbol_table to translate a single symbol.  */
2169   if (! (NAME (aout, translate_symbol_table)
2170          (abfd,
2171           (aout_symbol_type *) sym,
2172           (struct external_nlist *) minisym,
2173           (bfd_size_type) 1,
2174           obj_aout_external_strings (abfd),
2175           obj_aout_external_string_size (abfd),
2176           FALSE)))
2177     return NULL;
2178
2179   return sym;
2180 }
2181
2182 /* Provided a BFD, a section and an offset into the section, calculate
2183    and return the name of the source file and the line nearest to the
2184    wanted location.  */
2185
2186 bfd_boolean
2187 NAME (aout, find_nearest_line) (bfd *abfd,
2188                                 asection *section,
2189                                 asymbol **symbols,
2190                                 bfd_vma offset,
2191                                 const char **filename_ptr,
2192                                 const char **functionname_ptr,
2193                                 unsigned int *line_ptr)
2194 {
2195   /* Run down the file looking for the filename, function and linenumber.  */
2196   asymbol **p;
2197   const char *directory_name = NULL;
2198   const char *main_file_name = NULL;
2199   const char *current_file_name = NULL;
2200   const char *line_file_name = NULL; /* Value of current_file_name at line number.  */
2201   bfd_vma low_line_vma = 0;
2202   bfd_vma low_func_vma = 0;
2203   asymbol *func = 0;
2204   size_t filelen, funclen;
2205   char *buf;
2206
2207   *filename_ptr = abfd->filename;
2208   *functionname_ptr = 0;
2209   *line_ptr = 0;
2210
2211   if (symbols != NULL)
2212     {
2213       for (p = symbols; *p; p++)
2214         {
2215           aout_symbol_type  *q = (aout_symbol_type *)(*p);
2216         next:
2217           switch (q->type)
2218             {
2219             case N_TEXT:
2220               /* If this looks like a file name symbol, and it comes after
2221                  the line number we have found so far, but before the
2222                  offset, then we have probably not found the right line
2223                  number.  */
2224               if (q->symbol.value <= offset
2225                   && ((q->symbol.value > low_line_vma
2226                        && (line_file_name != NULL
2227                            || *line_ptr != 0))
2228                       || (q->symbol.value > low_func_vma
2229                           && func != NULL)))
2230                 {
2231                   const char * symname;
2232
2233                   symname = q->symbol.name;
2234                   if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
2235                     {
2236                       if (q->symbol.value > low_line_vma)
2237                         {
2238                           *line_ptr = 0;
2239                           line_file_name = NULL;
2240                         }
2241                       if (q->symbol.value > low_func_vma)
2242                         func = NULL;
2243                     }
2244                 }
2245               break;
2246
2247             case N_SO:
2248               /* If this symbol is less than the offset, but greater than
2249                  the line number we have found so far, then we have not
2250                  found the right line number.  */
2251               if (q->symbol.value <= offset)
2252                 {
2253                   if (q->symbol.value > low_line_vma)
2254                     {
2255                       *line_ptr = 0;
2256                       line_file_name = NULL;
2257                     }
2258                   if (q->symbol.value > low_func_vma)
2259                     func = NULL;
2260                 }
2261
2262               main_file_name = current_file_name = q->symbol.name;
2263               /* Look ahead to next symbol to check if that too is an N_SO.  */
2264               p++;
2265               if (*p == NULL)
2266                 break;
2267               q = (aout_symbol_type *)(*p);
2268               if (q->type != (int) N_SO)
2269                 goto next;
2270
2271               /* Found a second N_SO  First is directory; second is filename.  */
2272               directory_name = current_file_name;
2273               main_file_name = current_file_name = q->symbol.name;
2274               if (obj_textsec(abfd) != section)
2275                 goto done;
2276               break;
2277             case N_SOL:
2278               current_file_name = q->symbol.name;
2279               break;
2280
2281             case N_SLINE:
2282             case N_DSLINE:
2283             case N_BSLINE:
2284               /* We'll keep this if it resolves nearer than the one we have
2285                  already.  */
2286               if (q->symbol.value >= low_line_vma
2287                   && q->symbol.value <= offset)
2288                 {
2289                   *line_ptr = q->desc;
2290                   low_line_vma = q->symbol.value;
2291                   line_file_name = current_file_name;
2292                 }
2293               break;
2294
2295             case N_FUN:
2296               {
2297                 /* We'll keep this if it is nearer than the one we have already.  */
2298                 if (q->symbol.value >= low_func_vma &&
2299                     q->symbol.value <= offset)
2300                   {
2301                     low_func_vma = q->symbol.value;
2302                     func = (asymbol *) q;
2303                   }
2304                 else if (q->symbol.value > offset)
2305                   goto done;
2306               }
2307               break;
2308             }
2309         }
2310     }
2311
2312  done:
2313   if (*line_ptr != 0)
2314     main_file_name = line_file_name;
2315
2316   if (main_file_name == NULL
2317       || main_file_name[0] == '/'
2318       || directory_name == NULL)
2319     filelen = 0;
2320   else
2321     filelen = strlen (directory_name) + strlen (main_file_name);
2322   if (func == NULL)
2323     funclen = 0;
2324   else
2325     funclen = strlen (bfd_asymbol_name (func));
2326
2327   if (adata (abfd).line_buf != NULL)
2328     free (adata (abfd).line_buf);
2329   if (filelen + funclen == 0)
2330     adata (abfd).line_buf = buf = NULL;
2331   else
2332     {
2333       buf = bfd_malloc ((bfd_size_type) filelen + funclen + 3);
2334       adata (abfd).line_buf = buf;
2335       if (buf == NULL)
2336         return FALSE;
2337     }
2338
2339   if (main_file_name != NULL)
2340     {
2341       if (main_file_name[0] == '/' || directory_name == NULL)
2342         *filename_ptr = main_file_name;
2343       else
2344         {
2345           sprintf (buf, "%s%s", directory_name, main_file_name);
2346           *filename_ptr = buf;
2347           buf += filelen + 1;
2348         }
2349     }
2350
2351   if (func)
2352     {
2353       const char *function = func->name;
2354       char *colon;
2355
2356       /* The caller expects a symbol name.  We actually have a
2357          function name, without the leading underscore.  Put the
2358          underscore back in, so that the caller gets a symbol name.  */
2359       if (bfd_get_symbol_leading_char (abfd) == '\0')
2360         strcpy (buf, function);
2361       else
2362         {
2363           buf[0] = bfd_get_symbol_leading_char (abfd);
2364           strcpy (buf + 1, function);
2365         }
2366
2367       /* Have to remove : stuff.  */
2368       colon = strchr (buf, ':');
2369       if (colon != NULL)
2370         *colon = '\0';
2371       *functionname_ptr = buf;
2372     }
2373
2374   return TRUE;
2375 }
2376
2377 int
2378 NAME (aout, sizeof_headers) (bfd *abfd, bfd_boolean execable ATTRIBUTE_UNUSED)
2379 {
2380   return adata (abfd).exec_bytes_size;
2381 }
2382
2383 /* Free all information we have cached for this BFD.  We can always
2384    read it again later if we need it.  */
2385
2386 bfd_boolean
2387 NAME (aout, bfd_free_cached_info) (bfd *abfd)
2388 {
2389   asection *o;
2390
2391   if (bfd_get_format (abfd) != bfd_object)
2392     return TRUE;
2393
2394 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2395   BFCI_FREE (obj_aout_symbols (abfd));
2396
2397 #ifdef USE_MMAP
2398   obj_aout_external_syms (abfd) = 0;
2399   bfd_free_window (&obj_aout_sym_window (abfd));
2400   bfd_free_window (&obj_aout_string_window (abfd));
2401   obj_aout_external_strings (abfd) = 0;
2402 #else
2403   BFCI_FREE (obj_aout_external_syms (abfd));
2404   BFCI_FREE (obj_aout_external_strings (abfd));
2405 #endif
2406   for (o = abfd->sections; o != NULL; o = o->next)
2407     BFCI_FREE (o->relocation);
2408 #undef BFCI_FREE
2409
2410   return TRUE;
2411 }
2412 \f
2413 /* Routine to create an entry in an a.out link hash table.  */
2414
2415 struct bfd_hash_entry *
2416 NAME (aout, link_hash_newfunc) (struct bfd_hash_entry *entry,
2417                                 struct bfd_hash_table *table,
2418                                 const char *string)
2419 {
2420   struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2421
2422   /* Allocate the structure if it has not already been allocated by a
2423      subclass.  */
2424   if (ret == NULL)
2425     ret = bfd_hash_allocate (table, sizeof (* ret));
2426   if (ret == NULL)
2427     return NULL;
2428
2429   /* Call the allocation method of the superclass.  */
2430   ret = (struct aout_link_hash_entry *)
2431          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
2432   if (ret)
2433     {
2434       /* Set local fields.  */
2435       ret->written = FALSE;
2436       ret->indx = -1;
2437     }
2438
2439   return (struct bfd_hash_entry *) ret;
2440 }
2441
2442 /* Initialize an a.out link hash table.  */
2443
2444 bfd_boolean
2445 NAME (aout, link_hash_table_init) (struct aout_link_hash_table *table,
2446                                    bfd *abfd,
2447                                    struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
2448                                                                      struct bfd_hash_table *,
2449                                                                      const char *))
2450 {
2451   return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
2452 }
2453
2454 /* Create an a.out link hash table.  */
2455
2456 struct bfd_link_hash_table *
2457 NAME (aout, link_hash_table_create) (bfd *abfd)
2458 {
2459   struct aout_link_hash_table *ret;
2460   bfd_size_type amt = sizeof (struct aout_link_hash_table);
2461
2462   ret = bfd_alloc (abfd, amt);
2463   if (ret == NULL)
2464     return NULL;
2465   if (! NAME (aout, link_hash_table_init) (ret, abfd,
2466                                            NAME (aout, link_hash_newfunc)))
2467     {
2468       free (ret);
2469       return NULL;
2470     }
2471   return &ret->root;
2472 }
2473
2474 /* Free up the internal symbols read from an a.out file.  */
2475
2476 static bfd_boolean
2477 aout_link_free_symbols (bfd *abfd)
2478 {
2479   if (obj_aout_external_syms (abfd) != NULL)
2480     {
2481 #ifdef USE_MMAP
2482       bfd_free_window (&obj_aout_sym_window (abfd));
2483 #else
2484       free ((void *) obj_aout_external_syms (abfd));
2485 #endif
2486       obj_aout_external_syms (abfd) = NULL;
2487     }
2488
2489   if (obj_aout_external_strings (abfd) != NULL)
2490     {
2491 #ifdef USE_MMAP
2492       bfd_free_window (&obj_aout_string_window (abfd));
2493 #else
2494       free ((void *) obj_aout_external_strings (abfd));
2495 #endif
2496       obj_aout_external_strings (abfd) = NULL;
2497     }
2498   return TRUE;
2499 }
2500
2501 /* Given an a.out BFD, add symbols to the global hash table as
2502    appropriate.  */
2503
2504 bfd_boolean
2505 NAME (aout, link_add_symbols) (bfd *abfd, struct bfd_link_info *info)
2506 {
2507   switch (bfd_get_format (abfd))
2508     {
2509     case bfd_object:
2510       return aout_link_add_object_symbols (abfd, info);
2511     case bfd_archive:
2512       return _bfd_generic_link_add_archive_symbols
2513         (abfd, info, aout_link_check_archive_element);
2514     default:
2515       bfd_set_error (bfd_error_wrong_format);
2516       return FALSE;
2517     }
2518 }
2519
2520 /* Add symbols from an a.out object file.  */
2521
2522 static bfd_boolean
2523 aout_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
2524 {
2525   if (! aout_get_external_symbols (abfd))
2526     return FALSE;
2527   if (! aout_link_add_symbols (abfd, info))
2528     return FALSE;
2529   if (! info->keep_memory)
2530     {
2531       if (! aout_link_free_symbols (abfd))
2532         return FALSE;
2533     }
2534   return TRUE;
2535 }
2536
2537 /* Look through the internal symbols to see if this object file should
2538    be included in the link.  We should include this object file if it
2539    defines any symbols which are currently undefined.  If this object
2540    file defines a common symbol, then we may adjust the size of the
2541    known symbol but we do not include the object file in the link
2542    (unless there is some other reason to include it).  */
2543
2544 static bfd_boolean
2545 aout_link_check_ar_symbols (bfd *abfd,
2546                             struct bfd_link_info *info,
2547                             bfd_boolean *pneeded)
2548 {
2549   struct external_nlist *p;
2550   struct external_nlist *pend;
2551   char *strings;
2552
2553   *pneeded = FALSE;
2554
2555   /* Look through all the symbols.  */
2556   p = obj_aout_external_syms (abfd);
2557   pend = p + obj_aout_external_sym_count (abfd);
2558   strings = obj_aout_external_strings (abfd);
2559   for (; p < pend; p++)
2560     {
2561       int type = H_GET_8 (abfd, p->e_type);
2562       const char *name;
2563       struct bfd_link_hash_entry *h;
2564
2565       /* Ignore symbols that are not externally visible.  This is an
2566          optimization only, as we check the type more thoroughly
2567          below.  */
2568       if ((type & N_EXT) == 0
2569           || type == N_FN)
2570         continue;
2571
2572       name = strings + GET_WORD (abfd, p->e_strx);
2573       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
2574
2575       /* We are only interested in symbols that are currently
2576          undefined or common.  */
2577       if (h == NULL
2578           || (h->type != bfd_link_hash_undefined
2579               && h->type != bfd_link_hash_common))
2580         continue;
2581
2582       if (type == (N_TEXT | N_EXT)
2583           || type == (N_DATA | N_EXT)
2584           || type == (N_BSS | N_EXT)
2585           || type == (N_ABS | N_EXT))
2586         {
2587           /* This object file defines this symbol.  We must link it
2588              in.  This is true regardless of whether the current
2589              definition of the symbol is undefined or common.  If the
2590              current definition is common, we have a case in which we
2591              have already seen an object file including
2592                  int a;
2593              and this object file from the archive includes
2594                  int a = 5;
2595              In such a case we must include this object file.
2596
2597              FIXME: The SunOS 4.1.3 linker will pull in the archive
2598              element if the symbol is defined in the .data section,
2599              but not if it is defined in the .text section.  That
2600              seems a bit crazy to me, and I haven't implemented it.
2601              However, it might be correct.  */
2602           if (! (*info->callbacks->add_archive_element) (info, abfd, name))
2603             return FALSE;
2604           *pneeded = TRUE;
2605           return TRUE;
2606         }
2607
2608       if (type == (N_UNDF | N_EXT))
2609         {
2610           bfd_vma value;
2611
2612           value = GET_WORD (abfd, p->e_value);
2613           if (value != 0)
2614             {
2615               /* This symbol is common in the object from the archive
2616                  file.  */
2617               if (h->type == bfd_link_hash_undefined)
2618                 {
2619                   bfd *symbfd;
2620                   unsigned int power;
2621
2622                   symbfd = h->u.undef.abfd;
2623                   if (symbfd == NULL)
2624                     {
2625                       /* This symbol was created as undefined from
2626                          outside BFD.  We assume that we should link
2627                          in the object file.  This is done for the -u
2628                          option in the linker.  */
2629                       if (! (*info->callbacks->add_archive_element)
2630                           (info, abfd, name))
2631                         return FALSE;
2632                       *pneeded = TRUE;
2633                       return TRUE;
2634                     }
2635                   /* Turn the current link symbol into a common
2636                      symbol.  It is already on the undefs list.  */
2637                   h->type = bfd_link_hash_common;
2638                   h->u.c.p = bfd_hash_allocate (&info->hash->table,
2639                                                 sizeof (struct bfd_link_hash_common_entry));
2640                   if (h->u.c.p == NULL)
2641                     return FALSE;
2642
2643                   h->u.c.size = value;
2644
2645                   /* FIXME: This isn't quite right.  The maximum
2646                      alignment of a common symbol should be set by the
2647                      architecture of the output file, not of the input
2648                      file.  */
2649                   power = bfd_log2 (value);
2650                   if (power > bfd_get_arch_info (abfd)->section_align_power)
2651                     power = bfd_get_arch_info (abfd)->section_align_power;
2652                   h->u.c.p->alignment_power = power;
2653
2654                   h->u.c.p->section = bfd_make_section_old_way (symbfd,
2655                                                                 "COMMON");
2656                 }
2657               else
2658                 {
2659                   /* Adjust the size of the common symbol if
2660                      necessary.  */
2661                   if (value > h->u.c.size)
2662                     h->u.c.size = value;
2663                 }
2664             }
2665         }
2666     }
2667
2668   /* We do not need this object file.  */
2669   return TRUE;
2670 }
2671
2672 /* Check a single archive element to see if we need to include it in
2673    the link.  *PNEEDED is set according to whether this element is
2674    needed in the link or not.  This is called from
2675    _bfd_generic_link_add_archive_symbols.  */
2676
2677 static bfd_boolean
2678 aout_link_check_archive_element (bfd *abfd,
2679                                  struct bfd_link_info *info,
2680                                  bfd_boolean *pneeded)
2681 {
2682   if (! aout_get_external_symbols (abfd))
2683     return FALSE;
2684
2685   if (! aout_link_check_ar_symbols (abfd, info, pneeded))
2686     return FALSE;
2687
2688   if (*pneeded)
2689     {
2690       if (! aout_link_add_symbols (abfd, info))
2691         return FALSE;
2692     }
2693
2694   if (! info->keep_memory || ! *pneeded)
2695     {
2696       if (! aout_link_free_symbols (abfd))
2697         return FALSE;
2698     }
2699
2700   return TRUE;
2701 }
2702
2703 /* Add all symbols from an object file to the hash table.  */
2704
2705 static bfd_boolean
2706 aout_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
2707 {
2708   bfd_boolean (*add_one_symbol)
2709     (struct bfd_link_info *, bfd *, const char *, flagword, asection *,
2710      bfd_vma, const char *, bfd_boolean, bfd_boolean,
2711      struct bfd_link_hash_entry **);
2712   struct external_nlist *syms;
2713   bfd_size_type sym_count;
2714   char *strings;
2715   bfd_boolean copy;
2716   struct aout_link_hash_entry **sym_hash;
2717   struct external_nlist *p;
2718   struct external_nlist *pend;
2719
2720   syms = obj_aout_external_syms (abfd);
2721   sym_count = obj_aout_external_sym_count (abfd);
2722   strings = obj_aout_external_strings (abfd);
2723   if (info->keep_memory)
2724     copy = FALSE;
2725   else
2726     copy = TRUE;
2727
2728   if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
2729     {
2730       if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
2731              (abfd, info, &syms, &sym_count, &strings)))
2732         return FALSE;
2733     }
2734
2735   /* We keep a list of the linker hash table entries that correspond
2736      to particular symbols.  We could just look them up in the hash
2737      table, but keeping the list is more efficient.  Perhaps this
2738      should be conditional on info->keep_memory.  */
2739   sym_hash = bfd_alloc (abfd,
2740                         sym_count * sizeof (struct aout_link_hash_entry *));
2741   if (sym_hash == NULL && sym_count != 0)
2742     return FALSE;
2743   obj_aout_sym_hashes (abfd) = sym_hash;
2744
2745   add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
2746   if (add_one_symbol == NULL)
2747     add_one_symbol = _bfd_generic_link_add_one_symbol;
2748
2749   p = syms;
2750   pend = p + sym_count;
2751   for (; p < pend; p++, sym_hash++)
2752     {
2753       int type;
2754       const char *name;
2755       bfd_vma value;
2756       asection *section;
2757       flagword flags;
2758       const char *string;
2759
2760       *sym_hash = NULL;
2761
2762       type = H_GET_8 (abfd, p->e_type);
2763
2764       name = strings + GET_WORD (abfd, p->e_strx);
2765       value = GET_WORD (abfd, p->e_value);
2766       flags = BSF_GLOBAL;
2767       string = NULL;
2768       switch (type)
2769         {
2770         default:
2771           abort ();
2772
2773         case N_UNDF:
2774         case N_ABS:
2775         case N_TEXT:
2776         case N_DATA:
2777         case N_BSS:
2778         case N_REG:
2779         case N_FN:
2780           /* Ignore symbols that are not externally visible.  */
2781           continue;
2782
2783         case N_UNDF | N_EXT:
2784           if (value == 0)
2785             {
2786               section = bfd_und_section_ptr;
2787               flags = 0;
2788             }
2789           else
2790             section = bfd_com_section_ptr;
2791           break;
2792         case N_ABS | N_EXT:
2793           section = bfd_abs_section_ptr;
2794           break;
2795         case N_TEXT | N_EXT:
2796           section = obj_textsec (abfd);
2797           value -= bfd_get_section_vma (abfd, section);
2798           break;
2799         case N_DATA | N_EXT:
2800           /* Treat N_SETV symbols as N_DATA symbol; see comment in
2801              translate_from_native_sym_flags.  */
2802           section = obj_datasec (abfd);
2803           value -= bfd_get_section_vma (abfd, section);
2804           break;
2805         case N_BSS | N_EXT:
2806           section = obj_bsssec (abfd);
2807           value -= bfd_get_section_vma (abfd, section);
2808           break;
2809         }
2810
2811       if (! ((*add_one_symbol)
2812              (info, abfd, name, flags, section, value, string, copy, FALSE,
2813               (struct bfd_link_hash_entry **) sym_hash)))
2814         return FALSE;
2815
2816       /* Restrict the maximum alignment of a common symbol based on
2817          the architecture, since a.out has no way to represent
2818          alignment requirements of a section in a .o file.  FIXME:
2819          This isn't quite right: it should use the architecture of the
2820          output file, not the input files.  */
2821       if ((*sym_hash)->root.type == bfd_link_hash_common
2822           && ((*sym_hash)->root.u.c.p->alignment_power >
2823               bfd_get_arch_info (abfd)->section_align_power))
2824         (*sym_hash)->root.u.c.p->alignment_power =
2825           bfd_get_arch_info (abfd)->section_align_power;
2826
2827       /* If this is a set symbol, and we are not building sets, then
2828          it is possible for the hash entry to not have been set.  In
2829          such a case, treat the symbol as not globally defined.  */
2830       if ((*sym_hash)->root.type == bfd_link_hash_new)
2831         {
2832           BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
2833           *sym_hash = NULL;
2834         }
2835     }
2836
2837   return TRUE;
2838 }
2839 \f
2840 /* Look up an entry in an the header file hash table.  */
2841
2842 #define aout_link_includes_lookup(table, string, create, copy) \
2843   ((struct aout_link_includes_entry *) \
2844    bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
2845
2846 /* The function to create a new entry in the header file hash table.  */
2847
2848 static struct bfd_hash_entry *
2849 aout_link_includes_newfunc (struct bfd_hash_entry *entry,
2850                             struct bfd_hash_table *table,
2851                             const char *string)
2852 {
2853   struct aout_link_includes_entry * ret =
2854     (struct aout_link_includes_entry *) entry;
2855
2856   /* Allocate the structure if it has not already been allocated by a
2857      subclass.  */
2858   if (ret == NULL)
2859     ret = bfd_hash_allocate (table,
2860                              sizeof (struct aout_link_includes_entry));
2861   if (ret == NULL)
2862     return NULL;
2863
2864   /* Call the allocation method of the superclass.  */
2865   ret = ((struct aout_link_includes_entry *)
2866          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
2867   if (ret)
2868     /* Set local fields.  */
2869     ret->totals = NULL;
2870
2871   return (struct bfd_hash_entry *) ret;
2872 }
2873
2874 static bfd_boolean
2875 aout_link_write_other_symbol (struct aout_link_hash_entry *h, void * data)
2876 {
2877   struct aout_final_link_info *finfo = (struct aout_final_link_info *) data;
2878   bfd *output_bfd;
2879   int type;
2880   bfd_vma val;
2881   struct external_nlist outsym;
2882   bfd_size_type indx;
2883   bfd_size_type amt;
2884
2885   if (h->root.type == bfd_link_hash_warning)
2886     {
2887       h = (struct aout_link_hash_entry *) h->root.u.i.link;
2888       if (h->root.type == bfd_link_hash_new)
2889         return TRUE;
2890     }
2891
2892   output_bfd = finfo->output_bfd;
2893
2894   if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
2895     {
2896       if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
2897              (output_bfd, finfo->info, h)))
2898         {
2899           /* FIXME: No way to handle errors.  */
2900           abort ();
2901         }
2902     }
2903
2904   if (h->written)
2905     return TRUE;
2906
2907   h->written = TRUE;
2908
2909   /* An indx of -2 means the symbol must be written.  */
2910   if (h->indx != -2
2911       && (finfo->info->strip == strip_all
2912           || (finfo->info->strip == strip_some
2913               && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
2914                                   FALSE, FALSE) == NULL)))
2915     return TRUE;
2916
2917   switch (h->root.type)
2918     {
2919     default:
2920       abort ();
2921       /* Avoid variable not initialized warnings.  */
2922       return TRUE;
2923     case bfd_link_hash_new:
2924       /* This can happen for set symbols when sets are not being
2925          built.  */
2926       return TRUE;
2927     case bfd_link_hash_undefined:
2928       type = N_UNDF | N_EXT;
2929       val = 0;
2930       break;
2931     case bfd_link_hash_defined:
2932     case bfd_link_hash_defweak:
2933       {
2934         asection *sec;
2935
2936         sec = h->root.u.def.section->output_section;
2937         BFD_ASSERT (bfd_is_abs_section (sec)
2938                     || sec->owner == output_bfd);
2939         if (sec == obj_textsec (output_bfd))
2940           type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
2941         else if (sec == obj_datasec (output_bfd))
2942           type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
2943         else if (sec == obj_bsssec (output_bfd))
2944           type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
2945         else
2946           type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
2947         type |= N_EXT;
2948         val = (h->root.u.def.value
2949                + sec->vma
2950                + h->root.u.def.section->output_offset);
2951       }
2952       break;
2953     case bfd_link_hash_common:
2954       type = N_UNDF | N_EXT;
2955       val = h->root.u.c.size;
2956       break;
2957     case bfd_link_hash_undefweak:
2958       type = N_WEAKU;
2959       val = 0;
2960     case bfd_link_hash_indirect:
2961     case bfd_link_hash_warning:
2962       /* FIXME: Ignore these for now.  The circumstances under which
2963          they should be written out are not clear to me.  */
2964       return TRUE;
2965     }
2966
2967   H_PUT_8 (output_bfd, type, outsym.e_type);
2968   indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
2969                            FALSE);
2970   if (indx == (bfd_size_type) -1)
2971     /* FIXME: No way to handle errors.  */
2972     abort ();
2973
2974   PUT_WORD (output_bfd, indx, outsym.e_strx);
2975   PUT_WORD (output_bfd, val, outsym.e_value);
2976
2977   amt = EXTERNAL_NLIST_SIZE;
2978   if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0
2979       || bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
2980     /* FIXME: No way to handle errors.  */
2981     abort ();
2982
2983   finfo->symoff += amt;
2984   h->indx = obj_aout_external_sym_count (output_bfd);
2985   ++obj_aout_external_sym_count (output_bfd);
2986
2987   return TRUE;
2988 }
2989
2990 /* Handle a link order which is supposed to generate a reloc.  */
2991
2992 static bfd_boolean
2993 aout_link_reloc_link_order (struct aout_final_link_info *finfo,
2994                             asection *o,
2995                             struct bfd_link_order *p)
2996 {
2997   struct bfd_link_order_reloc *pr;
2998   int r_index;
2999   int r_extern;
3000   reloc_howto_type *howto;
3001   file_ptr *reloff_ptr;
3002   struct reloc_std_external srel;
3003   void * rel_ptr;
3004   bfd_size_type rel_size;
3005
3006   pr = p->u.reloc.p;
3007
3008   if (p->type == bfd_section_reloc_link_order)
3009     {
3010       r_extern = 0;
3011       if (bfd_is_abs_section (pr->u.section))
3012         r_index = N_ABS | N_EXT;
3013       else
3014         {
3015           BFD_ASSERT (pr->u.section->owner == finfo->output_bfd);
3016           r_index = pr->u.section->target_index;
3017         }
3018     }
3019   else
3020     {
3021       struct aout_link_hash_entry *h;
3022
3023       BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
3024       r_extern = 1;
3025       h = ((struct aout_link_hash_entry *)
3026            bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
3027                                          pr->u.name, FALSE, FALSE, TRUE));
3028       if (h != NULL
3029           && h->indx >= 0)
3030         r_index = h->indx;
3031       else if (h != NULL)
3032         {
3033           /* We decided to strip this symbol, but it turns out that we
3034              can't.  Note that we lose the other and desc information
3035              here.  I don't think that will ever matter for a global
3036              symbol.  */
3037           h->indx = -2;
3038           h->written = FALSE;
3039           if (! aout_link_write_other_symbol (h, (void *) finfo))
3040             return FALSE;
3041           r_index = h->indx;
3042         }
3043       else
3044         {
3045           if (! ((*finfo->info->callbacks->unattached_reloc)
3046                  (finfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0)))
3047             return FALSE;
3048           r_index = 0;
3049         }
3050     }
3051
3052   howto = bfd_reloc_type_lookup (finfo->output_bfd, pr->reloc);
3053   if (howto == 0)
3054     {
3055       bfd_set_error (bfd_error_bad_value);
3056       return FALSE;
3057     }
3058
3059   if (o == obj_textsec (finfo->output_bfd))
3060     reloff_ptr = &finfo->treloff;
3061   else if (o == obj_datasec (finfo->output_bfd))
3062     reloff_ptr = &finfo->dreloff;
3063   else
3064     abort ();
3065
3066 #ifdef MY_put_reloc
3067   MY_put_reloc(finfo->output_bfd, r_extern, r_index, p->offset, howto,
3068                &srel);
3069 #else
3070   {
3071     int r_pcrel;
3072     int r_baserel;
3073     int r_jmptable;
3074     int r_relative;
3075     int r_length;
3076
3077     fprintf (stderr, "TODO: line %d in bfd/pdp11.c\n", __LINE__);
3078
3079     r_pcrel = howto->pc_relative;
3080     r_baserel = (howto->type & 8) != 0;
3081     r_jmptable = (howto->type & 16) != 0;
3082     r_relative = (howto->type & 32) != 0;
3083     r_length = howto->size;
3084
3085     PUT_WORD (finfo->output_bfd, p->offset, srel.r_address);
3086     if (bfd_header_big_endian (finfo->output_bfd))
3087       {
3088         srel.r_index[0] = r_index >> 16;
3089         srel.r_index[1] = r_index >> 8;
3090         srel.r_index[2] = r_index;
3091         srel.r_type[0] =
3092           ((r_extern ?     RELOC_STD_BITS_EXTERN_BIG : 0)
3093            | (r_pcrel ?    RELOC_STD_BITS_PCREL_BIG : 0)
3094            | (r_baserel ?  RELOC_STD_BITS_BASEREL_BIG : 0)
3095            | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
3096            | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
3097            | (r_length <<  RELOC_STD_BITS_LENGTH_SH_BIG));
3098       }
3099     else
3100       {
3101         srel.r_index[2] = r_index >> 16;
3102         srel.r_index[1] = r_index >> 8;
3103         srel.r_index[0] = r_index;
3104         srel.r_type[0] =
3105           ((r_extern ?     RELOC_STD_BITS_EXTERN_LITTLE : 0)
3106            | (r_pcrel ?    RELOC_STD_BITS_PCREL_LITTLE : 0)
3107            | (r_baserel ?  RELOC_STD_BITS_BASEREL_LITTLE : 0)
3108            | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
3109            | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
3110            | (r_length <<  RELOC_STD_BITS_LENGTH_SH_LITTLE));
3111       }
3112   }
3113 #endif
3114   rel_ptr = (void *) &srel;
3115
3116   /* We have to write the addend into the object file, since
3117      standard a.out relocs are in place.  It would be more
3118      reliable if we had the current contents of the file here,
3119      rather than assuming zeroes, but we can't read the file since
3120      it was opened using bfd_openw.  */
3121   if (pr->addend != 0)
3122     {
3123       bfd_size_type size;
3124       bfd_reloc_status_type r;
3125       bfd_byte *buf;
3126       bfd_boolean ok;
3127
3128       size = bfd_get_reloc_size (howto);
3129       buf = bfd_zmalloc (size);
3130       if (buf == NULL)
3131         return FALSE;
3132       r = MY_relocate_contents (howto, finfo->output_bfd,
3133                                 pr->addend, buf);
3134       switch (r)
3135         {
3136         case bfd_reloc_ok:
3137           break;
3138         default:
3139         case bfd_reloc_outofrange:
3140           abort ();
3141         case bfd_reloc_overflow:
3142           if (! ((*finfo->info->callbacks->reloc_overflow)
3143                  (finfo->info, NULL,
3144                   (p->type == bfd_section_reloc_link_order
3145                    ? bfd_section_name (finfo->output_bfd,
3146                                        pr->u.section)
3147                    : pr->u.name),
3148                   howto->name, pr->addend, NULL,
3149                   (asection *) NULL, (bfd_vma) 0)))
3150             {
3151               free (buf);
3152               return FALSE;
3153             }
3154           break;
3155         }
3156       ok = bfd_set_section_contents (finfo->output_bfd, o,
3157                                      (void *) buf,
3158                                      (file_ptr) p->offset,
3159                                      size);
3160       free (buf);
3161       if (! ok)
3162         return FALSE;
3163     }
3164
3165   rel_size = obj_reloc_entry_size (finfo->output_bfd);
3166   if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
3167       || bfd_bwrite (rel_ptr, rel_size, finfo->output_bfd) != rel_size)
3168     return FALSE;
3169
3170   *reloff_ptr += rel_size;
3171
3172   /* Assert that the relocs have not run into the symbols, and that n
3173      the text relocs have not run into the data relocs.  */
3174   BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
3175               && (reloff_ptr != &finfo->treloff
3176                   || (*reloff_ptr
3177                       <= obj_datasec (finfo->output_bfd)->rel_filepos)));
3178
3179   return TRUE;
3180 }
3181
3182 /* Get the section corresponding to a reloc index.  */
3183
3184 static inline asection *
3185 aout_reloc_type_to_section (bfd *abfd, int type)
3186 {
3187   switch (type)
3188     {
3189     case RTEXT: return obj_textsec (abfd);
3190     case RDATA: return obj_datasec (abfd);
3191     case RBSS:  return obj_bsssec (abfd);
3192     case RABS:  return bfd_abs_section_ptr;
3193     case REXT:  return bfd_und_section_ptr;
3194     default:    abort ();
3195     }
3196 }
3197
3198 static bfd_boolean
3199 pdp11_aout_link_input_section (struct aout_final_link_info *finfo,
3200                                bfd *input_bfd,
3201                                asection *input_section,
3202                                bfd_byte *relocs,
3203                                bfd_size_type rel_size,
3204                                bfd_byte *contents)
3205 {
3206   bfd_boolean (*check_dynamic_reloc)
3207     (struct bfd_link_info *, bfd *, asection *,
3208      struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
3209      bfd_vma *);
3210   bfd *output_bfd;
3211   bfd_boolean relocatable;
3212   struct external_nlist *syms;
3213   char *strings;
3214   struct aout_link_hash_entry **sym_hashes;
3215   int *symbol_map;
3216   bfd_size_type reloc_count;
3217   bfd_byte *rel;
3218   bfd_byte *rel_end;
3219
3220   output_bfd = finfo->output_bfd;
3221   check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
3222
3223   BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_SIZE);
3224   BFD_ASSERT (input_bfd->xvec->header_byteorder
3225               == output_bfd->xvec->header_byteorder);
3226
3227   relocatable = finfo->info->relocatable;
3228   syms = obj_aout_external_syms (input_bfd);
3229   strings = obj_aout_external_strings (input_bfd);
3230   sym_hashes = obj_aout_sym_hashes (input_bfd);
3231   symbol_map = finfo->symbol_map;
3232
3233   reloc_count = rel_size / RELOC_SIZE;
3234   rel = relocs;
3235   rel_end = rel + rel_size;
3236   for (; rel < rel_end; rel += RELOC_SIZE)
3237     {
3238       bfd_vma r_addr;
3239       int r_index;
3240       int r_type;
3241       int r_pcrel;
3242       int r_extern;
3243       reloc_howto_type *howto;
3244       struct aout_link_hash_entry *h = NULL;
3245       bfd_vma relocation;
3246       bfd_reloc_status_type r;
3247       int reloc_entry;
3248
3249       reloc_entry = GET_WORD (input_bfd, (void *) rel);
3250       if (reloc_entry == 0)
3251         continue;
3252
3253       {
3254         unsigned int howto_idx;
3255
3256         r_index = (reloc_entry & RIDXMASK) >> 4;
3257         r_type = reloc_entry & RTYPE;
3258         r_pcrel = reloc_entry & RELFLG;
3259         r_addr = (char *) rel - (char *) relocs;
3260
3261         r_extern = (r_type == REXT);
3262
3263         howto_idx = r_pcrel;
3264         BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_pdp11));
3265         howto = howto_table_pdp11 + howto_idx;
3266       }
3267
3268       if (relocatable)
3269         {
3270           /* We are generating a relocatable output file, and must
3271              modify the reloc accordingly.  */
3272           if (r_extern)
3273             {
3274               /* If we know the symbol this relocation is against,
3275                  convert it into a relocation against a section.  This
3276                  is what the native linker does.  */
3277               h = sym_hashes[r_index];
3278               if (h != NULL
3279                   && (h->root.type == bfd_link_hash_defined
3280                       || h->root.type == bfd_link_hash_defweak))
3281                 {
3282                   asection *output_section;
3283
3284                   /* Compute a new r_index.  */
3285                   output_section = h->root.u.def.section->output_section;
3286                   if (output_section == obj_textsec (output_bfd))
3287                     r_type = N_TEXT;
3288                   else if (output_section == obj_datasec (output_bfd))
3289                     r_type = N_DATA;
3290                   else if (output_section == obj_bsssec (output_bfd))
3291                     r_type = N_BSS;
3292                   else
3293                     r_type = N_ABS;
3294
3295                   /* Add the symbol value and the section VMA to the
3296                      addend stored in the contents.  */
3297                   relocation = (h->root.u.def.value
3298                                 + output_section->vma
3299                                 + h->root.u.def.section->output_offset);
3300                 }
3301               else
3302                 {
3303                   /* We must change r_index according to the symbol
3304                      map.  */
3305                   r_index = symbol_map[r_index];
3306
3307                   if (r_index == -1)
3308                     {
3309                       if (h != NULL)
3310                         {
3311                           /* We decided to strip this symbol, but it
3312                              turns out that we can't.  Note that we
3313                              lose the other and desc information here.
3314                              I don't think that will ever matter for a
3315                              global symbol.  */
3316                           if (h->indx < 0)
3317                             {
3318                               h->indx = -2;
3319                               h->written = FALSE;
3320                               if (! aout_link_write_other_symbol (h,
3321                                                                   (void *) finfo))
3322                                 return FALSE;
3323                             }
3324                           r_index = h->indx;
3325                         }
3326                       else
3327                         {
3328                           const char *name;
3329
3330                           name = strings + GET_WORD (input_bfd,
3331                                                      syms[r_index].e_strx);
3332                           if (! ((*finfo->info->callbacks->unattached_reloc)
3333                                  (finfo->info, name, input_bfd, input_section,
3334                                   r_addr)))
3335                             return FALSE;
3336                           r_index = 0;
3337                         }
3338                     }
3339
3340                   relocation = 0;
3341                 }
3342
3343               /* Write out the new r_index value.  */
3344               reloc_entry = GET_WORD (input_bfd, rel);
3345               reloc_entry &= RIDXMASK;
3346               reloc_entry |= r_index << 4;
3347               PUT_WORD (input_bfd, reloc_entry, rel);
3348             }
3349           else
3350             {
3351               asection *section;
3352
3353               /* This is a relocation against a section.  We must
3354                  adjust by the amount that the section moved.  */
3355               section = aout_reloc_type_to_section (input_bfd, r_type);
3356               relocation = (section->output_section->vma
3357                             + section->output_offset
3358                             - section->vma);
3359             }
3360
3361           /* Change the address of the relocation.  */
3362           fprintf (stderr, "TODO: change the address of the relocation\n");
3363
3364           /* Adjust a PC relative relocation by removing the reference
3365              to the original address in the section and including the
3366              reference to the new address.  */
3367           if (r_pcrel)
3368             relocation -= (input_section->output_section->vma
3369                            + input_section->output_offset
3370                            - input_section->vma);
3371
3372 #ifdef MY_relocatable_reloc
3373           MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
3374 #endif
3375
3376           if (relocation == 0)
3377             r = bfd_reloc_ok;
3378           else
3379             r = MY_relocate_contents (howto,
3380                                       input_bfd, relocation,
3381                                       contents + r_addr);
3382         }
3383       else
3384         {
3385           bfd_boolean hundef;
3386
3387           /* We are generating an executable, and must do a full
3388              relocation.  */
3389           hundef = FALSE;
3390           if (r_extern)
3391             {
3392               h = sym_hashes[r_index];
3393
3394               if (h != NULL
3395                   && (h->root.type == bfd_link_hash_defined
3396                       || h->root.type == bfd_link_hash_defweak))
3397                 {
3398                   relocation = (h->root.u.def.value
3399                                 + h->root.u.def.section->output_section->vma
3400                                 + h->root.u.def.section->output_offset);
3401                 }
3402               else if (h != NULL
3403                        && h->root.type == bfd_link_hash_undefweak)
3404                 relocation = 0;
3405               else
3406                 {
3407                   hundef = TRUE;
3408                   relocation = 0;
3409                 }
3410             }
3411           else
3412             {
3413               asection *section;
3414
3415               section = aout_reloc_type_to_section (input_bfd, r_type);
3416               relocation = (section->output_section->vma
3417                             + section->output_offset
3418                             - section->vma);
3419               if (r_pcrel)
3420                 relocation += input_section->vma;
3421             }
3422
3423           if (check_dynamic_reloc != NULL)
3424             {
3425               bfd_boolean skip;
3426
3427               if (! ((*check_dynamic_reloc)
3428                      (finfo->info, input_bfd, input_section, h,
3429                       (void *) rel, contents, &skip, &relocation)))
3430                 return FALSE;
3431               if (skip)
3432                 continue;
3433             }
3434
3435           /* Now warn if a global symbol is undefined.  We could not
3436              do this earlier, because check_dynamic_reloc might want
3437              to skip this reloc.  */
3438           if (hundef && ! finfo->info->shared)
3439             {
3440               const char *name;
3441
3442               if (h != NULL)
3443                 name = h->root.root.string;
3444               else
3445                 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
3446               if (! ((*finfo->info->callbacks->undefined_symbol)
3447                      (finfo->info, name, input_bfd, input_section,
3448                       r_addr, TRUE)))
3449                 return FALSE;
3450             }
3451
3452           r = MY_final_link_relocate (howto,
3453                                       input_bfd, input_section,
3454                                       contents, r_addr, relocation,
3455                                       (bfd_vma) 0);
3456         }
3457
3458       if (r != bfd_reloc_ok)
3459         {
3460           switch (r)
3461             {
3462             default:
3463             case bfd_reloc_outofrange:
3464               abort ();
3465             case bfd_reloc_overflow:
3466               {
3467                 const char *name;
3468
3469                 if (h != NULL)
3470                   name = NULL;
3471                 else if (r_extern)
3472                   name = strings + GET_WORD (input_bfd,
3473                                              syms[r_index].e_strx);
3474                 else
3475                   {
3476                     asection *s;
3477
3478                     s = aout_reloc_type_to_section (input_bfd, r_type);
3479                     name = bfd_section_name (input_bfd, s);
3480                   }
3481                 if (! ((*finfo->info->callbacks->reloc_overflow)
3482                        (finfo->info, (h ? &h->root : NULL), name,
3483                         howto->name, (bfd_vma) 0, input_bfd,
3484                         input_section, r_addr)))
3485                   return FALSE;
3486               }
3487               break;
3488             }
3489         }
3490     }
3491
3492   return TRUE;
3493 }
3494
3495 /* Link an a.out section into the output file.  */
3496
3497 static bfd_boolean
3498 aout_link_input_section (struct aout_final_link_info *finfo,
3499                          bfd *input_bfd,
3500                          asection *input_section,
3501                          file_ptr *reloff_ptr,
3502                          bfd_size_type rel_size)
3503 {
3504   bfd_size_type input_size;
3505   void * relocs;
3506
3507   /* Get the section contents.  */
3508   input_size = input_section->size;
3509   if (! bfd_get_section_contents (input_bfd, input_section,
3510                                   (void *) finfo->contents,
3511                                   (file_ptr) 0, input_size))
3512     return FALSE;
3513
3514   /* Read in the relocs if we haven't already done it.  */
3515   if (aout_section_data (input_section) != NULL
3516       && aout_section_data (input_section)->relocs != NULL)
3517     relocs = aout_section_data (input_section)->relocs;
3518   else
3519     {
3520       relocs = finfo->relocs;
3521       if (rel_size > 0)
3522         {
3523           if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
3524               || bfd_bread (relocs, rel_size, input_bfd) != rel_size)
3525             return FALSE;
3526         }
3527     }
3528
3529   /* Relocate the section contents.  */
3530   if (! pdp11_aout_link_input_section (finfo, input_bfd, input_section,
3531                                        (bfd_byte *) relocs,
3532                                        rel_size, finfo->contents))
3533     return FALSE;
3534
3535   /* Write out the section contents.  */
3536   if (! bfd_set_section_contents (finfo->output_bfd,
3537                                   input_section->output_section,
3538                                   (void *) finfo->contents,
3539                                   (file_ptr) input_section->output_offset,
3540                                   input_size))
3541     return FALSE;
3542
3543   /* If we are producing relocatable output, the relocs were
3544      modified, and we now write them out.  */
3545   if (finfo->info->relocatable && rel_size > 0)
3546     {
3547       if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
3548         return FALSE;
3549       if (bfd_bwrite (relocs, rel_size, finfo->output_bfd) != rel_size)
3550         return FALSE;
3551       *reloff_ptr += rel_size;
3552
3553       /* Assert that the relocs have not run into the symbols, and
3554          that if these are the text relocs they have not run into the
3555          data relocs.  */
3556       BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
3557                   && (reloff_ptr != &finfo->treloff
3558                       || (*reloff_ptr
3559                           <= obj_datasec (finfo->output_bfd)->rel_filepos)));
3560     }
3561
3562   return TRUE;
3563 }
3564
3565 /* Link an a.out input BFD into the output file.  */
3566
3567 static bfd_boolean
3568 aout_link_input_bfd (struct aout_final_link_info *finfo, bfd *input_bfd)
3569 {
3570   bfd_size_type sym_count;
3571
3572   BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
3573
3574   /* If this is a dynamic object, it may need special handling.  */
3575   if ((input_bfd->flags & DYNAMIC) != 0
3576       && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
3577     return ((*aout_backend_info (input_bfd)->link_dynamic_object)
3578             (finfo->info, input_bfd));
3579
3580   /* Get the symbols.  We probably have them already, unless
3581      finfo->info->keep_memory is FALSE.  */
3582   if (! aout_get_external_symbols (input_bfd))
3583     return FALSE;
3584
3585   sym_count = obj_aout_external_sym_count (input_bfd);
3586
3587   /* Write out the symbols and get a map of the new indices.  The map
3588      is placed into finfo->symbol_map.  */
3589   if (! aout_link_write_symbols (finfo, input_bfd))
3590     return FALSE;
3591
3592   /* Relocate and write out the sections.  These functions use the
3593      symbol map created by aout_link_write_symbols.  The linker_mark
3594      field will be set if these sections are to be included in the
3595      link, which will normally be the case.  */
3596   if (obj_textsec (input_bfd)->linker_mark)
3597     {
3598       if (! aout_link_input_section (finfo, input_bfd,
3599                                      obj_textsec (input_bfd),
3600                                      &finfo->treloff,
3601                                      exec_hdr (input_bfd)->a_trsize))
3602         return FALSE;
3603     }
3604   if (obj_datasec (input_bfd)->linker_mark)
3605     {
3606       if (! aout_link_input_section (finfo, input_bfd,
3607                                      obj_datasec (input_bfd),
3608                                      &finfo->dreloff,
3609                                      exec_hdr (input_bfd)->a_drsize))
3610         return FALSE;
3611     }
3612
3613   /* If we are not keeping memory, we don't need the symbols any
3614      longer.  We still need them if we are keeping memory, because the
3615      strings in the hash table point into them.  */
3616   if (! finfo->info->keep_memory)
3617     {
3618       if (! aout_link_free_symbols (input_bfd))
3619         return FALSE;
3620     }
3621
3622   return TRUE;
3623 }
3624
3625 /* Do the final link step.  This is called on the output BFD.  The
3626    INFO structure should point to a list of BFDs linked through the
3627    link_next field which can be used to find each BFD which takes part
3628    in the output.  Also, each section in ABFD should point to a list
3629    of bfd_link_order structures which list all the input sections for
3630    the output section.  */
3631
3632 bfd_boolean
3633 NAME (aout, final_link) (bfd *abfd,
3634                          struct bfd_link_info *info,
3635                          void (*callback) (bfd *, file_ptr *, file_ptr *, file_ptr *))
3636 {
3637   struct aout_final_link_info aout_info;
3638   bfd_boolean includes_hash_initialized = FALSE;
3639   bfd *sub;
3640   bfd_size_type trsize, drsize;
3641   bfd_size_type max_contents_size;
3642   bfd_size_type max_relocs_size;
3643   bfd_size_type max_sym_count;
3644   bfd_size_type text_size;
3645   file_ptr text_end;
3646   struct bfd_link_order *p;
3647   asection *o;
3648   bfd_boolean have_link_order_relocs;
3649
3650   if (info->shared)
3651     abfd->flags |= DYNAMIC;
3652
3653   aout_info.info = info;
3654   aout_info.output_bfd = abfd;
3655   aout_info.contents = NULL;
3656   aout_info.relocs = NULL;
3657   aout_info.symbol_map = NULL;
3658   aout_info.output_syms = NULL;
3659
3660   if (! bfd_hash_table_init_n (&aout_info.includes.root,
3661                                aout_link_includes_newfunc,
3662                                251))
3663     goto error_return;
3664   includes_hash_initialized = TRUE;
3665
3666   /* Figure out the largest section size.  Also, if generating
3667      relocatable output, count the relocs.  */
3668   trsize = 0;
3669   drsize = 0;
3670   max_contents_size = 0;
3671   max_relocs_size = 0;
3672   max_sym_count = 0;
3673   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3674     {
3675       size_t sz;
3676
3677       if (info->relocatable)
3678         {
3679           if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3680             {
3681               trsize += exec_hdr (sub)->a_trsize;
3682               drsize += exec_hdr (sub)->a_drsize;
3683             }
3684           else
3685             {
3686               /* FIXME: We need to identify the .text and .data sections
3687                  and call get_reloc_upper_bound and canonicalize_reloc to
3688                  work out the number of relocs needed, and then multiply
3689                  by the reloc size.  */
3690               (*_bfd_error_handler)
3691                 ("%s: relocatable link from %s to %s not supported",
3692                  bfd_get_filename (abfd),
3693                  sub->xvec->name, abfd->xvec->name);
3694               bfd_set_error (bfd_error_invalid_operation);
3695               goto error_return;
3696             }
3697         }
3698
3699       if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3700         {
3701           sz = obj_textsec (sub)->size;
3702           if (sz > max_contents_size)
3703             max_contents_size = sz;
3704           sz = obj_datasec (sub)->size;
3705           if (sz > max_contents_size)
3706             max_contents_size = sz;
3707
3708           sz = exec_hdr (sub)->a_trsize;
3709           if (sz > max_relocs_size)
3710             max_relocs_size = sz;
3711           sz = exec_hdr (sub)->a_drsize;
3712           if (sz > max_relocs_size)
3713             max_relocs_size = sz;
3714
3715           sz = obj_aout_external_sym_count (sub);
3716           if (sz > max_sym_count)
3717             max_sym_count = sz;
3718         }
3719     }
3720
3721   if (info->relocatable)
3722     {
3723       if (obj_textsec (abfd) != NULL)
3724         trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
3725                                                  ->map_head.link_order)
3726                    * obj_reloc_entry_size (abfd));
3727       if (obj_datasec (abfd) != NULL)
3728         drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
3729                                                  ->map_head.link_order)
3730                    * obj_reloc_entry_size (abfd));
3731     }
3732
3733   exec_hdr (abfd)->a_trsize = trsize;
3734   exec_hdr (abfd)->a_drsize = drsize;
3735   exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
3736
3737   /* Adjust the section sizes and vmas according to the magic number.
3738      This sets a_text, a_data and a_bss in the exec_hdr and sets the
3739      filepos for each section.  */
3740   if (! NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
3741     goto error_return;
3742
3743   /* The relocation and symbol file positions differ among a.out
3744      targets.  We are passed a callback routine from the backend
3745      specific code to handle this.
3746      FIXME: At this point we do not know how much space the symbol
3747      table will require.  This will not work for any (nonstandard)
3748      a.out target that needs to know the symbol table size before it
3749      can compute the relocation file positions.  This may or may not
3750      be the case for the hp300hpux target, for example.  */
3751   (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
3752                &aout_info.symoff);
3753   obj_textsec (abfd)->rel_filepos = aout_info.treloff;
3754   obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
3755   obj_sym_filepos (abfd) = aout_info.symoff;
3756
3757   /* We keep a count of the symbols as we output them.  */
3758   obj_aout_external_sym_count (abfd) = 0;
3759
3760   /* We accumulate the string table as we write out the symbols.  */
3761   aout_info.strtab = _bfd_stringtab_init ();
3762   if (aout_info.strtab == NULL)
3763     goto error_return;
3764
3765   /* Allocate buffers to hold section contents and relocs.  */
3766   aout_info.contents = bfd_malloc (max_contents_size);
3767   aout_info.relocs = bfd_malloc (max_relocs_size);
3768   aout_info.symbol_map = bfd_malloc (max_sym_count * sizeof (int *));
3769   aout_info.output_syms = bfd_malloc ((max_sym_count + 1)
3770                                       * sizeof (struct external_nlist));
3771   if ((aout_info.contents == NULL && max_contents_size != 0)
3772       || (aout_info.relocs == NULL && max_relocs_size != 0)
3773       || (aout_info.symbol_map == NULL && max_sym_count != 0)
3774       || aout_info.output_syms == NULL)
3775     goto error_return;
3776
3777   /* If we have a symbol named __DYNAMIC, force it out now.  This is
3778      required by SunOS.  Doing this here rather than in sunos.c is a
3779      hack, but it's easier than exporting everything which would be
3780      needed.  */
3781   {
3782     struct aout_link_hash_entry *h;
3783
3784     h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
3785                                FALSE, FALSE, FALSE);
3786     if (h != NULL)
3787       aout_link_write_other_symbol (h, &aout_info);
3788   }
3789
3790   /* The most time efficient way to do the link would be to read all
3791      the input object files into memory and then sort out the
3792      information into the output file.  Unfortunately, that will
3793      probably use too much memory.  Another method would be to step
3794      through everything that composes the text section and write it
3795      out, and then everything that composes the data section and write
3796      it out, and then write out the relocs, and then write out the
3797      symbols.  Unfortunately, that requires reading stuff from each
3798      input file several times, and we will not be able to keep all the
3799      input files open simultaneously, and reopening them will be slow.
3800
3801      What we do is basically process one input file at a time.  We do
3802      everything we need to do with an input file once--copy over the
3803      section contents, handle the relocation information, and write
3804      out the symbols--and then we throw away the information we read
3805      from it.  This approach requires a lot of lseeks of the output
3806      file, which is unfortunate but still faster than reopening a lot
3807      of files.
3808
3809      We use the output_has_begun field of the input BFDs to see
3810      whether we have already handled it.  */
3811   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3812     sub->output_has_begun = FALSE;
3813
3814   /* Mark all sections which are to be included in the link.  This
3815      will normally be every section.  We need to do this so that we
3816      can identify any sections which the linker has decided to not
3817      include.  */
3818   for (o = abfd->sections; o != NULL; o = o->next)
3819     {
3820       for (p = o->map_head.link_order; p != NULL; p = p->next)
3821         if (p->type == bfd_indirect_link_order)
3822           p->u.indirect.section->linker_mark = TRUE;
3823     }
3824
3825   have_link_order_relocs = FALSE;
3826   for (o = abfd->sections; o != NULL; o = o->next)
3827     {
3828       for (p = o->map_head.link_order;
3829            p != NULL;
3830            p = p->next)
3831         {
3832           if (p->type == bfd_indirect_link_order
3833               && (bfd_get_flavour (p->u.indirect.section->owner)
3834                   == bfd_target_aout_flavour))
3835             {
3836               bfd *input_bfd;
3837
3838               input_bfd = p->u.indirect.section->owner;
3839               if (! input_bfd->output_has_begun)
3840                 {
3841                   if (! aout_link_input_bfd (&aout_info, input_bfd))
3842                     goto error_return;
3843                   input_bfd->output_has_begun = TRUE;
3844                 }
3845             }
3846           else if (p->type == bfd_section_reloc_link_order
3847                    || p->type == bfd_symbol_reloc_link_order)
3848             /* These are handled below.  */
3849             have_link_order_relocs = TRUE;
3850           else
3851             {
3852               if (! _bfd_default_link_order (abfd, info, o, p))
3853                 goto error_return;
3854             }
3855         }
3856     }
3857
3858   /* Write out any symbols that we have not already written out.  */
3859   aout_link_hash_traverse (aout_hash_table (info),
3860                            aout_link_write_other_symbol,
3861                            (void *) &aout_info);
3862
3863   /* Now handle any relocs we were asked to create by the linker.
3864      These did not come from any input file.  We must do these after
3865      we have written out all the symbols, so that we know the symbol
3866      indices to use.  */
3867   if (have_link_order_relocs)
3868     {
3869       for (o = abfd->sections; o != NULL; o = o->next)
3870         {
3871           for (p = o->map_head.link_order;
3872                p != NULL;
3873                p = p->next)
3874             {
3875               if (p->type == bfd_section_reloc_link_order
3876                   || p->type == bfd_symbol_reloc_link_order)
3877                 {
3878                   if (! aout_link_reloc_link_order (&aout_info, o, p))
3879                     goto error_return;
3880                 }
3881             }
3882         }
3883     }
3884
3885   if (aout_info.contents != NULL)
3886     {
3887       free (aout_info.contents);
3888       aout_info.contents = NULL;
3889     }
3890   if (aout_info.relocs != NULL)
3891     {
3892       free (aout_info.relocs);
3893       aout_info.relocs = NULL;
3894     }
3895   if (aout_info.symbol_map != NULL)
3896     {
3897       free (aout_info.symbol_map);
3898       aout_info.symbol_map = NULL;
3899     }
3900   if (aout_info.output_syms != NULL)
3901     {
3902       free (aout_info.output_syms);
3903       aout_info.output_syms = NULL;
3904     }
3905   if (includes_hash_initialized)
3906     {
3907       bfd_hash_table_free (&aout_info.includes.root);
3908       includes_hash_initialized = FALSE;
3909     }
3910
3911   /* Finish up any dynamic linking we may be doing.  */
3912   if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
3913     {
3914       if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
3915         goto error_return;
3916     }
3917
3918   /* Update the header information.  */
3919   abfd->symcount = obj_aout_external_sym_count (abfd);
3920   exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
3921   obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
3922   obj_textsec (abfd)->reloc_count =
3923     exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
3924   obj_datasec (abfd)->reloc_count =
3925     exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
3926
3927   /* Write out the string table, unless there are no symbols.  */
3928   if (abfd->symcount > 0)
3929     {
3930       if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
3931           || ! emit_stringtab (abfd, aout_info.strtab))
3932         goto error_return;
3933     }
3934   else if (obj_textsec (abfd)->reloc_count == 0
3935            && obj_datasec (abfd)->reloc_count == 0)
3936     {
3937       bfd_byte b;
3938
3939       b = 0;
3940       if (bfd_seek (abfd,
3941                     (file_ptr) (obj_datasec (abfd)->filepos
3942                                 + exec_hdr (abfd)->a_data
3943                                 - 1),
3944                     SEEK_SET) != 0
3945           || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3946         goto error_return;
3947     }
3948
3949   return TRUE;
3950
3951  error_return:
3952   if (aout_info.contents != NULL)
3953     free (aout_info.contents);
3954   if (aout_info.relocs != NULL)
3955     free (aout_info.relocs);
3956   if (aout_info.symbol_map != NULL)
3957     free (aout_info.symbol_map);
3958   if (aout_info.output_syms != NULL)
3959     free (aout_info.output_syms);
3960   if (includes_hash_initialized)
3961     bfd_hash_table_free (&aout_info.includes.root);
3962   return FALSE;
3963 }
3964
3965 /* Adjust and write out the symbols for an a.out file.  Set the new
3966    symbol indices into a symbol_map.  */
3967
3968 static bfd_boolean
3969 aout_link_write_symbols (struct aout_final_link_info *finfo, bfd *input_bfd)
3970 {
3971   bfd *output_bfd;
3972   bfd_size_type sym_count;
3973   char *strings;
3974   enum bfd_link_strip strip;
3975   enum bfd_link_discard discard;
3976   struct external_nlist *outsym;
3977   bfd_size_type strtab_index;
3978   struct external_nlist *sym;
3979   struct external_nlist *sym_end;
3980   struct aout_link_hash_entry **sym_hash;
3981   int *symbol_map;
3982   bfd_boolean pass;
3983   bfd_boolean skip_next;
3984
3985   output_bfd = finfo->output_bfd;
3986   sym_count = obj_aout_external_sym_count (input_bfd);
3987   strings = obj_aout_external_strings (input_bfd);
3988   strip = finfo->info->strip;
3989   discard = finfo->info->discard;
3990   outsym = finfo->output_syms;
3991
3992   /* First write out a symbol for this object file, unless we are
3993      discarding such symbols.  */
3994   if (strip != strip_all
3995       && (strip != strip_some
3996           || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
3997                               FALSE, FALSE) != NULL)
3998       && discard != discard_all)
3999     {
4000       H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
4001       strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4002                                        input_bfd->filename, FALSE);
4003       if (strtab_index == (bfd_size_type) -1)
4004         return FALSE;
4005       PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4006       PUT_WORD (output_bfd,
4007                 (bfd_get_section_vma (output_bfd,
4008                                       obj_textsec (input_bfd)->output_section)
4009                  + obj_textsec (input_bfd)->output_offset),
4010                 outsym->e_value);
4011       ++obj_aout_external_sym_count (output_bfd);
4012       ++outsym;
4013     }
4014
4015   pass = FALSE;
4016   skip_next = FALSE;
4017   sym = obj_aout_external_syms (input_bfd);
4018   sym_end = sym + sym_count;
4019   sym_hash = obj_aout_sym_hashes (input_bfd);
4020   symbol_map = finfo->symbol_map;
4021   memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
4022   for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
4023     {
4024       const char *name;
4025       int type;
4026       struct aout_link_hash_entry *h;
4027       bfd_boolean skip;
4028       asection *symsec;
4029       bfd_vma val = 0;
4030       bfd_boolean copy;
4031
4032       /* We set *symbol_map to 0 above for all symbols.  If it has
4033          already been set to -1 for this symbol, it means that we are
4034          discarding it because it appears in a duplicate header file.
4035          See the N_BINCL code below.  */
4036       if (*symbol_map == -1)
4037         continue;
4038
4039       /* Initialize *symbol_map to -1, which means that the symbol was
4040          not copied into the output file.  We will change it later if
4041          we do copy the symbol over.  */
4042       *symbol_map = -1;
4043
4044       type = H_GET_8 (input_bfd, sym->e_type);
4045       name = strings + GET_WORD (input_bfd, sym->e_strx);
4046
4047       h = NULL;
4048
4049       if (pass)
4050         {
4051           /* Pass this symbol through.  It is the target of an
4052              indirect or warning symbol.  */
4053           val = GET_WORD (input_bfd, sym->e_value);
4054           pass = FALSE;
4055         }
4056       else if (skip_next)
4057         {
4058           /* Skip this symbol, which is the target of an indirect
4059              symbol that we have changed to no longer be an indirect
4060              symbol.  */
4061           skip_next = FALSE;
4062           continue;
4063         }
4064       else
4065         {
4066           struct aout_link_hash_entry *hresolve;
4067
4068           /* We have saved the hash table entry for this symbol, if
4069              there is one.  Note that we could just look it up again
4070              in the hash table, provided we first check that it is an
4071              external symbol. */
4072           h = *sym_hash;
4073
4074           /* Use the name from the hash table, in case the symbol was
4075              wrapped.  */
4076           if (h != NULL)
4077             name = h->root.root.string;
4078
4079           /* If this is an indirect or warning symbol, then change
4080              hresolve to the base symbol.  We also change *sym_hash so
4081              that the relocation routines relocate against the real
4082              symbol.  */
4083           hresolve = h;
4084           if (h != NULL
4085               && (h->root.type == bfd_link_hash_indirect
4086                   || h->root.type == bfd_link_hash_warning))
4087             {
4088               hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
4089               while (hresolve->root.type == bfd_link_hash_indirect
4090                      || hresolve->root.type == bfd_link_hash_warning)
4091                 hresolve = ((struct aout_link_hash_entry *)
4092                             hresolve->root.u.i.link);
4093               *sym_hash = hresolve;
4094             }
4095
4096           /* If the symbol has already been written out, skip it.  */
4097           if (h != NULL
4098               && h->root.type != bfd_link_hash_warning
4099               && h->written)
4100             {
4101               if ((type & N_TYPE) == N_INDR
4102                   || type == N_WARNING)
4103                 skip_next = TRUE;
4104               *symbol_map = h->indx;
4105               continue;
4106             }
4107
4108           /* See if we are stripping this symbol.  */
4109           skip = FALSE;
4110           switch (strip)
4111             {
4112             case strip_none:
4113               break;
4114             case strip_debugger:
4115               if ((type & N_STAB) != 0)
4116                 skip = TRUE;
4117               break;
4118             case strip_some:
4119               if (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
4120                   == NULL)
4121                 skip = TRUE;
4122               break;
4123             case strip_all:
4124               skip = TRUE;
4125               break;
4126             }
4127           if (skip)
4128             {
4129               if (h != NULL)
4130                 h->written = TRUE;
4131               continue;
4132             }
4133
4134           /* Get the value of the symbol.  */
4135           if ((type & N_TYPE) == N_TEXT
4136               || type == N_WEAKT)
4137             symsec = obj_textsec (input_bfd);
4138           else if ((type & N_TYPE) == N_DATA
4139                    || type == N_WEAKD)
4140             symsec = obj_datasec (input_bfd);
4141           else if ((type & N_TYPE) == N_BSS
4142                    || type == N_WEAKB)
4143             symsec = obj_bsssec (input_bfd);
4144           else if ((type & N_TYPE) == N_ABS
4145                    || type == N_WEAKA)
4146             symsec = bfd_abs_section_ptr;
4147           else if (((type & N_TYPE) == N_INDR
4148                     && (hresolve == NULL
4149                         || (hresolve->root.type != bfd_link_hash_defined
4150                             && hresolve->root.type != bfd_link_hash_defweak
4151                             && hresolve->root.type != bfd_link_hash_common)))
4152                    || type == N_WARNING)
4153             {
4154               /* Pass the next symbol through unchanged.  The
4155                  condition above for indirect symbols is so that if
4156                  the indirect symbol was defined, we output it with
4157                  the correct definition so the debugger will
4158                  understand it.  */
4159               pass = TRUE;
4160               val = GET_WORD (input_bfd, sym->e_value);
4161               symsec = NULL;
4162             }
4163           else if ((type & N_STAB) != 0)
4164             {
4165               val = GET_WORD (input_bfd, sym->e_value);
4166               symsec = NULL;
4167             }
4168           else
4169             {
4170               /* If we get here with an indirect symbol, it means that
4171                  we are outputting it with a real definition.  In such
4172                  a case we do not want to output the next symbol,
4173                  which is the target of the indirection.  */
4174               if ((type & N_TYPE) == N_INDR)
4175                 skip_next = TRUE;
4176
4177               symsec = NULL;
4178
4179               /* We need to get the value from the hash table.  We use
4180                  hresolve so that if we have defined an indirect
4181                  symbol we output the final definition.  */
4182               if (h == NULL)
4183                 {
4184                   switch (type & N_TYPE)
4185                     {
4186                     case N_SETT:
4187                       symsec = obj_textsec (input_bfd);
4188                       break;
4189                     case N_SETD:
4190                       symsec = obj_datasec (input_bfd);
4191                       break;
4192                     case N_SETB:
4193                       symsec = obj_bsssec (input_bfd);
4194                       break;
4195                     case N_SETA:
4196                       symsec = bfd_abs_section_ptr;
4197                       break;
4198                     default:
4199                       val = 0;
4200                       break;
4201                     }
4202                 }
4203               else if (hresolve->root.type == bfd_link_hash_defined
4204                        || hresolve->root.type == bfd_link_hash_defweak)
4205                 {
4206                   asection *input_section;
4207                   asection *output_section;
4208
4209                   /* This case usually means a common symbol which was
4210                      turned into a defined symbol.  */
4211                   input_section = hresolve->root.u.def.section;
4212                   output_section = input_section->output_section;
4213                   BFD_ASSERT (bfd_is_abs_section (output_section)
4214                               || output_section->owner == output_bfd);
4215                   val = (hresolve->root.u.def.value
4216                          + bfd_get_section_vma (output_bfd, output_section)
4217                          + input_section->output_offset);
4218
4219                   /* Get the correct type based on the section.  If
4220                      this is a constructed set, force it to be
4221                      globally visible.  */
4222                   if (type == N_SETT
4223                       || type == N_SETD
4224                       || type == N_SETB
4225                       || type == N_SETA)
4226                     type |= N_EXT;
4227
4228                   type &=~ N_TYPE;
4229
4230                   if (output_section == obj_textsec (output_bfd))
4231                     type |= (hresolve->root.type == bfd_link_hash_defined
4232                              ? N_TEXT
4233                              : N_WEAKT);
4234                   else if (output_section == obj_datasec (output_bfd))
4235                     type |= (hresolve->root.type == bfd_link_hash_defined
4236                              ? N_DATA
4237                              : N_WEAKD);
4238                   else if (output_section == obj_bsssec (output_bfd))
4239                     type |= (hresolve->root.type == bfd_link_hash_defined
4240                              ? N_BSS
4241                              : N_WEAKB);
4242                   else
4243                     type |= (hresolve->root.type == bfd_link_hash_defined
4244                              ? N_ABS
4245                              : N_WEAKA);
4246                 }
4247               else if (hresolve->root.type == bfd_link_hash_common)
4248                 val = hresolve->root.u.c.size;
4249               else if (hresolve->root.type == bfd_link_hash_undefweak)
4250                 {
4251                   val = 0;
4252                   type = N_WEAKU;
4253                 }
4254               else
4255                 val = 0;
4256             }
4257           if (symsec != NULL)
4258             val = (symsec->output_section->vma
4259                    + symsec->output_offset
4260                    + (GET_WORD (input_bfd, sym->e_value)
4261                       - symsec->vma));
4262
4263           /* If this is a global symbol set the written flag, and if
4264              it is a local symbol see if we should discard it.  */
4265           if (h != NULL)
4266             {
4267               h->written = TRUE;
4268               h->indx = obj_aout_external_sym_count (output_bfd);
4269             }
4270           else if ((type & N_TYPE) != N_SETT
4271                    && (type & N_TYPE) != N_SETD
4272                    && (type & N_TYPE) != N_SETB
4273                    && (type & N_TYPE) != N_SETA)
4274             {
4275               switch (discard)
4276                 {
4277                 case discard_none:
4278                 case discard_sec_merge:
4279                   break;
4280                 case discard_l:
4281                   if ((type & N_STAB) == 0
4282                       && bfd_is_local_label_name (input_bfd, name))
4283                     skip = TRUE;
4284                   break;
4285                 case discard_all:
4286                   skip = TRUE;
4287                   break;
4288                 }
4289               if (skip)
4290                 {
4291                   pass = FALSE;
4292                   continue;
4293                 }
4294             }
4295
4296           /* An N_BINCL symbol indicates the start of the stabs
4297              entries for a header file.  We need to scan ahead to the
4298              next N_EINCL symbol, ignoring nesting, adding up all the
4299              characters in the symbol names, not including the file
4300              numbers in types (the first number after an open
4301              parenthesis).  */
4302           if (type == N_BINCL)
4303             {
4304               struct external_nlist *incl_sym;
4305               int nest;
4306               struct aout_link_includes_entry *incl_entry;
4307               struct aout_link_includes_totals *t;
4308
4309               val = 0;
4310               nest = 0;
4311               for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
4312                 {
4313                   int incl_type;
4314
4315                   incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
4316                   if (incl_type == N_EINCL)
4317                     {
4318                       if (nest == 0)
4319                         break;
4320                       --nest;
4321                     }
4322                   else if (incl_type == N_BINCL)
4323                     ++nest;
4324                   else if (nest == 0)
4325                     {
4326                       const char *s;
4327
4328                       s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
4329                       for (; *s != '\0'; s++)
4330                         {
4331                           val += *s;
4332                           if (*s == '(')
4333                             {
4334                               /* Skip the file number.  */
4335                               ++s;
4336                               while (ISDIGIT (*s))
4337                                 ++s;
4338                               --s;
4339                             }
4340                         }
4341                     }
4342                 }
4343
4344               /* If we have already included a header file with the
4345                  same value, then replace this one with an N_EXCL
4346                  symbol.  */
4347               copy = ! finfo->info->keep_memory;
4348               incl_entry = aout_link_includes_lookup (&finfo->includes,
4349                                                       name, TRUE, copy);
4350               if (incl_entry == NULL)
4351                 return FALSE;
4352               for (t = incl_entry->totals; t != NULL; t = t->next)
4353                 if (t->total == val)
4354                   break;
4355               if (t == NULL)
4356                 {
4357                   /* This is the first time we have seen this header
4358                      file with this set of stabs strings.  */
4359                   t = bfd_hash_allocate (&finfo->includes.root,
4360                                          sizeof *t);
4361                   if (t == NULL)
4362                     return FALSE;
4363                   t->total = val;
4364                   t->next = incl_entry->totals;
4365                   incl_entry->totals = t;
4366                 }
4367               else
4368                 {
4369                   int *incl_map;
4370
4371                   /* This is a duplicate header file.  We must change
4372                      it to be an N_EXCL entry, and mark all the
4373                      included symbols to prevent outputting them.  */
4374                   type = N_EXCL;
4375
4376                   nest = 0;
4377                   for (incl_sym = sym + 1, incl_map = symbol_map + 1;
4378                        incl_sym < sym_end;
4379                        incl_sym++, incl_map++)
4380                     {
4381                       int incl_type;
4382
4383                       incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
4384                       if (incl_type == N_EINCL)
4385                         {
4386                           if (nest == 0)
4387                             {
4388                               *incl_map = -1;
4389                               break;
4390                             }
4391                           --nest;
4392                         }
4393                       else if (incl_type == N_BINCL)
4394                         ++nest;
4395                       else if (nest == 0)
4396                         *incl_map = -1;
4397                     }
4398                 }
4399             }
4400         }
4401
4402       /* Copy this symbol into the list of symbols we are going to
4403          write out.  */
4404       H_PUT_8 (output_bfd, type, outsym->e_type);
4405       copy = FALSE;
4406       if (! finfo->info->keep_memory)
4407         {
4408           /* name points into a string table which we are going to
4409              free.  If there is a hash table entry, use that string.
4410              Otherwise, copy name into memory.  */
4411           if (h != NULL)
4412             name = h->root.root.string;
4413           else
4414             copy = TRUE;
4415         }
4416       strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4417                                        name, copy);
4418       if (strtab_index == (bfd_size_type) -1)
4419         return FALSE;
4420       PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4421       PUT_WORD (output_bfd, val, outsym->e_value);
4422       *symbol_map = obj_aout_external_sym_count (output_bfd);
4423       ++obj_aout_external_sym_count (output_bfd);
4424       ++outsym;
4425     }
4426
4427   /* Write out the output symbols we have just constructed.  */
4428   if (outsym > finfo->output_syms)
4429     {
4430       bfd_size_type size;
4431
4432       if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
4433         return FALSE;
4434       size = outsym - finfo->output_syms;
4435       size *= EXTERNAL_NLIST_SIZE;
4436       if (bfd_bwrite ((void *) finfo->output_syms, size, output_bfd) != size)
4437         return FALSE;
4438       finfo->symoff += size;
4439     }
4440
4441   return TRUE;
4442 }
4443
4444 /* Write out a symbol that was not associated with an a.out input
4445    object.  */
4446
4447 static bfd_vma
4448 bfd_getp32 (const void *p)
4449 {
4450   const bfd_byte *addr = p;
4451   unsigned long v;
4452
4453   v = (unsigned long) addr[1] << 24;
4454   v |= (unsigned long) addr[0] << 16;
4455   v |= (unsigned long) addr[3] << 8;
4456   v |= (unsigned long) addr[2];
4457   return v;
4458 }
4459
4460 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4461
4462 static bfd_signed_vma
4463 bfd_getp_signed_32 (const void *p)
4464 {
4465   const bfd_byte *addr = p;
4466   unsigned long v;
4467
4468   v = (unsigned long) addr[1] << 24;
4469   v |= (unsigned long) addr[0] << 16;
4470   v |= (unsigned long) addr[3] << 8;
4471   v |= (unsigned long) addr[2];
4472   return COERCE32 (v);
4473 }
4474
4475 static void
4476 bfd_putp32 (bfd_vma data, void *p)
4477 {
4478   bfd_byte *addr = p;
4479
4480   addr[0] = (data >> 16) & 0xff;
4481   addr[1] = (data >> 24) & 0xff;
4482   addr[2] = (data >> 0) & 0xff;
4483   addr[3] = (data >> 8) & 0xff;
4484 }
4485
4486 const bfd_target MY (vec) =
4487 {
4488   TARGETNAME,                   /* Name.  */
4489   bfd_target_aout_flavour,
4490   BFD_ENDIAN_LITTLE,            /* Target byte order (little).  */
4491   BFD_ENDIAN_LITTLE,            /* Target headers byte order (little).  */
4492   (HAS_RELOC | EXEC_P |         /* Object flags.  */
4493    HAS_LINENO | HAS_DEBUG |
4494    HAS_SYMS | HAS_LOCALS | WP_TEXT),
4495   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
4496   MY_symbol_leading_char,
4497   AR_PAD_CHAR,                  /* AR_pad_char.  */
4498   15,                           /* AR_max_namelen.  */
4499   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
4500      bfd_getp32, bfd_getp_signed_32, bfd_putp32,
4501      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data.  */
4502   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
4503      bfd_getp32, bfd_getp_signed_32, bfd_putp32,
4504      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Headers.  */
4505     {_bfd_dummy_target, MY_object_p,            /* bfd_check_format.  */
4506        bfd_generic_archive_p, MY_core_file_p},
4507     {bfd_false, MY_mkobject,                    /* bfd_set_format.  */
4508        _bfd_generic_mkarchive, bfd_false},
4509     {bfd_false, MY_write_object_contents,       /* bfd_write_contents.  */
4510        _bfd_write_archive_contents, bfd_false},
4511
4512      BFD_JUMP_TABLE_GENERIC (MY),
4513      BFD_JUMP_TABLE_COPY (MY),
4514      BFD_JUMP_TABLE_CORE (MY),
4515      BFD_JUMP_TABLE_ARCHIVE (MY),
4516      BFD_JUMP_TABLE_SYMBOLS (MY),
4517      BFD_JUMP_TABLE_RELOCS (MY),
4518      BFD_JUMP_TABLE_WRITE (MY),
4519      BFD_JUMP_TABLE_LINK (MY),
4520      BFD_JUMP_TABLE_DYNAMIC (MY),
4521
4522   /* Alternative_target.  */
4523   NULL,
4524
4525   (void *) MY_backend_data
4526 };