bfd/pdp11.c

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