bfd/pdp11.c

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