bfd/pdp11.c

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