bfd/pdp11.c

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