contrib/binutils/bfd/aoutx.h

   1 /* BFD semi-generic back-end for a.out binaries.
   2    Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 1998
   3    Free Software Foundation, Inc.
   4    Written by Cygnus Support.
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 /*
  23 SECTION
  24         a.out backends
  25
  26
  27 DESCRIPTION
  28
  29         BFD supports a number of different flavours of a.out format,
  30         though the major differences are only the sizes of the
  31         structures on disk, and the shape of the relocation
  32         information.
  33
  34         The support is split into a basic support file @file{aoutx.h}
  35         and other files which derive functions from the base. One
  36         derivation file is @file{aoutf1.h} (for a.out flavour 1), and
  37         adds to the basic a.out functions support for sun3, sun4, 386
  38         and 29k a.out files, to create a target jump vector for a
  39         specific target.
  40
  41         This information is further split out into more specific files
  42         for each machine, including @file{sunos.c} for sun3 and sun4,
  43         @file{newsos3.c} for the Sony NEWS, and @file{demo64.c} for a
  44         demonstration of a 64 bit a.out format.
  45
  46         The base file @file{aoutx.h} defines general mechanisms for
  47         reading and writing records to and from disk and various
  48         other methods which BFD requires. It is included by
  49         @file{aout32.c} and @file{aout64.c} to form the names
  50         <<aout_32_swap_exec_header_in>>, <<aout_64_swap_exec_header_in>>, etc.
  51
  52         As an example, this is what goes on to make the back end for a
  53         sun4, from @file{aout32.c}:
  54
  55 |       #define ARCH_SIZE 32
  56 |       #include "aoutx.h"
  57
  58         Which exports names:
  59
  60 |       ...
  61 |       aout_32_canonicalize_reloc
  62 |       aout_32_find_nearest_line
  63 |       aout_32_get_lineno
  64 |       aout_32_get_reloc_upper_bound
  65 |       ...
  66
  67         from @file{sunos.c}:
  68
  69 |       #define TARGET_NAME "a.out-sunos-big"
  70 |       #define VECNAME    sunos_big_vec
  71 |       #include "aoutf1.h"
  72
  73         requires all the names from @file{aout32.c}, and produces the jump vector
  74
  75 |       sunos_big_vec
  76
  77         The file @file{host-aout.c} is a special case.  It is for a large set
  78         of hosts that use ``more or less standard'' a.out files, and
  79         for which cross-debugging is not interesting.  It uses the
  80         standard 32-bit a.out support routines, but determines the
  81         file offsets and addresses of the text, data, and BSS
  82         sections, the machine architecture and machine type, and the
  83         entry point address, in a host-dependent manner.  Once these
  84         values have been determined, generic code is used to handle
  85         the  object file.
  86
  87         When porting it to run on a new system, you must supply:
  88
  89 |        HOST_PAGE_SIZE
  90 |        HOST_SEGMENT_SIZE
  91 |        HOST_MACHINE_ARCH       (optional)
  92 |        HOST_MACHINE_MACHINE    (optional)
  93 |        HOST_TEXT_START_ADDR
  94 |        HOST_STACK_END_ADDR
  95
  96         in the file @file{../include/sys/h-@var{XXX}.h} (for your host).  These
  97         values, plus the structures and macros defined in @file{a.out.h} on
  98         your host system, will produce a BFD target that will access
  99         ordinary a.out files on your host. To configure a new machine
 100         to use @file{host-aout.c}, specify:
 101
 102 |       TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec
 103 |       TDEPFILES= host-aout.o trad-core.o
 104
 105         in the @file{config/@var{XXX}.mt} file, and modify @file{configure.in}
 106         to use the
 107         @file{@var{XXX}.mt} file (by setting "<<bfd_target=XXX>>") when your
 108         configuration is selected.
 109
 110 */
 111
 112 /* Some assumptions:
 113    * Any BFD with D_PAGED set is ZMAGIC, and vice versa.
 114      Doesn't matter what the setting of WP_TEXT is on output, but it'll
 115      get set on input.
 116    * Any BFD with D_PAGED clear and WP_TEXT set is NMAGIC.
 117    * Any BFD with both flags clear is OMAGIC.
 118    (Just want to make these explicit, so the conditions tested in this
 119    file make sense if you're more familiar with a.out than with BFD.)  */
 120
 121 #define KEEPIT udata.i
 122
 123 #include <string.h>             /* For strchr and friends */
 124 #include <ctype.h>
 125 #include "bfd.h"
 126 #include <sysdep.h>
 127 #include "bfdlink.h"
 128
 129 #include "libaout.h"
 130 #include "libbfd.h"
 131 #include "aout/aout64.h"
 132 #include "aout/stab_gnu.h"
 133 #include "aout/ar.h"
 134
 135 static boolean aout_get_external_symbols PARAMS ((bfd *));
 136 static boolean translate_from_native_sym_flags
 137   PARAMS ((bfd *, aout_symbol_type *));
 138 static boolean translate_to_native_sym_flags
 139   PARAMS ((bfd *, asymbol *, struct external_nlist *));
 140 static void adjust_o_magic PARAMS ((bfd *, struct internal_exec *));
 141 static void adjust_z_magic PARAMS ((bfd *, struct internal_exec *));
 142 static void adjust_n_magic PARAMS ((bfd *, struct internal_exec *));
 143
 144 /*
 145 SUBSECTION
 146         Relocations
 147
 148 DESCRIPTION
 149         The file @file{aoutx.h} provides for both the @emph{standard}
 150         and @emph{extended} forms of a.out relocation records.
 151
 152         The standard records contain only an
 153         address, a symbol index, and a type field. The extended records
 154         (used on 29ks and sparcs) also have a full integer for an
 155         addend.
 156
 157 */
 158 #ifndef CTOR_TABLE_RELOC_HOWTO
 159 #define CTOR_TABLE_RELOC_IDX 2
 160 #define CTOR_TABLE_RELOC_HOWTO(BFD) ((obj_reloc_entry_size(BFD) == RELOC_EXT_SIZE \
 161              ? howto_table_ext : howto_table_std) \
 162             + CTOR_TABLE_RELOC_IDX)
 163 #endif
 164
 165 #ifndef MY_swap_std_reloc_in
 166 #define MY_swap_std_reloc_in NAME(aout,swap_std_reloc_in)
 167 #endif
 168
 169 #ifndef MY_swap_std_reloc_out
 170 #define MY_swap_std_reloc_out NAME(aout,swap_std_reloc_out)
 171 #endif
 172
 173 #ifndef MY_final_link_relocate
 174 #define MY_final_link_relocate _bfd_final_link_relocate
 175 #endif
 176
 177 #ifndef MY_relocate_contents
 178 #define MY_relocate_contents _bfd_relocate_contents
 179 #endif
 180
 181 #define howto_table_ext NAME(aout,ext_howto_table)
 182 #define howto_table_std NAME(aout,std_howto_table)
 183
 184 reloc_howto_type howto_table_ext[] =
 185 {
 186   /* type           rs   size bsz  pcrel bitpos ovrf                  sf name          part_inpl readmask setmask pcdone */
 187   HOWTO(RELOC_8,      0,  0,    8,  false, 0, complain_overflow_bitfield,0,"8",        false, 0,0x000000ff, false),
 188   HOWTO(RELOC_16,     0,  1,    16, false, 0, complain_overflow_bitfield,0,"16",       false, 0,0x0000ffff, false),
 189   HOWTO(RELOC_32,     0,  2,    32, false, 0, complain_overflow_bitfield,0,"32",       false, 0,0xffffffff, false),
 190   HOWTO(RELOC_DISP8,  0,  0,    8,  true,  0, complain_overflow_signed,0,"DISP8",       false, 0,0x000000ff, false),
 191   HOWTO(RELOC_DISP16, 0,  1,    16, true,  0, complain_overflow_signed,0,"DISP16",      false, 0,0x0000ffff, false),
 192   HOWTO(RELOC_DISP32, 0,  2,    32, true,  0, complain_overflow_signed,0,"DISP32",      false, 0,0xffffffff, false),
 193   HOWTO(RELOC_WDISP30,2,  2,    30, true,  0, complain_overflow_signed,0,"WDISP30",     false, 0,0x3fffffff, false),
 194   HOWTO(RELOC_WDISP22,2,  2,    22, true,  0, complain_overflow_signed,0,"WDISP22",     false, 0,0x003fffff, false),
 195   HOWTO(RELOC_HI22,   10, 2,    22, false, 0, complain_overflow_bitfield,0,"HI22",      false, 0,0x003fffff, false),
 196   HOWTO(RELOC_22,     0,  2,    22, false, 0, complain_overflow_bitfield,0,"22",       false, 0,0x003fffff, false),
 197   HOWTO(RELOC_13,     0,  2,    13, false, 0, complain_overflow_bitfield,0,"13",       false, 0,0x00001fff, false),
 198   HOWTO(RELOC_LO10,   0,  2,    10, false, 0, complain_overflow_dont,0,"LO10",     false, 0,0x000003ff, false),
 199   HOWTO(RELOC_SFA_BASE,0, 2,    32, false, 0, complain_overflow_bitfield,0,"SFA_BASE", false, 0,0xffffffff, false),
 200   HOWTO(RELOC_SFA_OFF13,0,2,    32, false, 0, complain_overflow_bitfield,0,"SFA_OFF13",false, 0,0xffffffff, false),
 201   HOWTO(RELOC_BASE10, 0,  2,    10, false, 0, complain_overflow_dont,0,"BASE10",   false, 0,0x000003ff, false),
 202   HOWTO(RELOC_BASE13, 0,  2,    13, false, 0, complain_overflow_bitfield,0,"BASE13",   false, 0,0x00001fff, false),
 203   HOWTO(RELOC_BASE22, 10, 2,    22, false, 0, complain_overflow_bitfield,0,"BASE22",   false, 0,0x003fffff, false),
 204   HOWTO(RELOC_PC10,   0,  2,    10, true,  0, complain_overflow_dont,0,"PC10",  false, 0,0x000003ff, true),
 205   HOWTO(RELOC_PC22,   10,  2,   22, true,  0, complain_overflow_signed,0,"PC22", false, 0,0x003fffff, true),
 206   HOWTO(RELOC_JMP_TBL,2,  2,    30, true,  0, complain_overflow_signed,0,"JMP_TBL",     false, 0,0x3fffffff, false),
 207   HOWTO(RELOC_SEGOFF16,0, 2,    0,  false, 0, complain_overflow_bitfield,0,"SEGOFF16",  false, 0,0x00000000, false),
 208   HOWTO(RELOC_GLOB_DAT,0, 2,    0,  false, 0, complain_overflow_bitfield,0,"GLOB_DAT",  false, 0,0x00000000, false),
 209   HOWTO(RELOC_JMP_SLOT,0, 2,    0,  false, 0, complain_overflow_bitfield,0,"JMP_SLOT",  false, 0,0x00000000, false),
 210   HOWTO(RELOC_RELATIVE,0, 2,    0,  false, 0, complain_overflow_bitfield,0,"RELATIVE",  false, 0,0x00000000, false),
 211 };
 212
 213 /* Convert standard reloc records to "arelent" format (incl byte swap).  */
 214
 215 reloc_howto_type howto_table_std[] = {
 216   /* type              rs size bsz  pcrel bitpos ovrf                     sf name     part_inpl readmask  setmask    pcdone */
 217 HOWTO( 0,              0,  0,   8,  false, 0, complain_overflow_bitfield,0,"8",         true, 0x000000ff,0x000000ff, false),
 218 HOWTO( 1,              0,  1,   16, false, 0, complain_overflow_bitfield,0,"16",        true, 0x0000ffff,0x0000ffff, false),
 219 HOWTO( 2,              0,  2,   32, false, 0, complain_overflow_bitfield,0,"32",        true, 0xffffffff,0xffffffff, false),
 220 HOWTO( 3,              0,  4,   64, false, 0, complain_overflow_bitfield,0,"64",        true, 0xdeaddead,0xdeaddead, false),
 221 HOWTO( 4,              0,  0,   8,  true,  0, complain_overflow_signed,  0,"DISP8",     true, 0x000000ff,0x000000ff, false),
 222 HOWTO( 5,              0,  1,   16, true,  0, complain_overflow_signed,  0,"DISP16",    true, 0x0000ffff,0x0000ffff, false),
 223 HOWTO( 6,              0,  2,   32, true,  0, complain_overflow_signed,  0,"DISP32",    true, 0xffffffff,0xffffffff, false),
 224 HOWTO( 7,              0,  4,   64, true,  0, complain_overflow_signed,  0,"DISP64",    true, 0xfeedface,0xfeedface, false),
 225 HOWTO( 8,              0,  2,    0, false, 0, complain_overflow_bitfield,0,"GOT_REL",   false,         0,0x00000000, false),
 226 HOWTO( 9,              0,  1,   16, false, 0, complain_overflow_bitfield,0,"BASE16",    false,0xffffffff,0xffffffff, false),
 227 HOWTO(10,              0,  2,   32, false, 0, complain_overflow_bitfield,0,"BASE32",    false,0xffffffff,0xffffffff, false),
 228 { -1 },
 229 { -1 },
 230 { -1 },
 231 { -1 },
 232 { -1 },
 233   HOWTO(16,            0,  2,    0, false, 0, complain_overflow_bitfield,0,"JMP_TABLE", false,         0,0x00000000, false),
 234 { -1 },
 235 { -1 },
 236 { -1 },
 237 { -1 },
 238 { -1 },
 239 { -1 },
 240 { -1 },
 241 { -1 }, { -1 }, { -1 }, { -1 }, { -1 }, { -1 }, { -1 }, { -1 },
 242   HOWTO(32,            0,  2,    0, false, 0, complain_overflow_bitfield,0,"RELATIVE",  false,         0,0x00000000, false),
 243 { -1 },
 244 { -1 },
 245 { -1 },
 246 { -1 },
 247 { -1 },
 248 { -1 },
 249 { -1 },
 250   HOWTO(40,            0,  2,    0, false, 0, complain_overflow_bitfield,0,"BASEREL",   false,         0,0x00000000, false),
 251 };
 252
 253 #define TABLE_SIZE(TABLE)       (sizeof(TABLE)/sizeof(TABLE[0]))
 254
 255 reloc_howto_type *
 256 NAME(aout,reloc_type_lookup) (abfd,code)
 257      bfd *abfd;
 258      bfd_reloc_code_real_type code;
 259 {
 260 #define EXT(i,j)        case i: return &howto_table_ext[j]
 261 #define STD(i,j)        case i: return &howto_table_std[j]
 262   int ext = obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE;
 263   if (code == BFD_RELOC_CTOR)
 264     switch (bfd_get_arch_info (abfd)->bits_per_address)
 265       {
 266       case 32:
 267         code = BFD_RELOC_32;
 268         break;
 269       case 64:
 270         code = BFD_RELOC_64;
 271         break;
 272       }
 273   if (ext)
 274     switch (code)
 275       {
 276         EXT (BFD_RELOC_32, 2);
 277         EXT (BFD_RELOC_HI22, 8);
 278         EXT (BFD_RELOC_LO10, 11);
 279         EXT (BFD_RELOC_32_PCREL_S2, 6);
 280         EXT (BFD_RELOC_SPARC_WDISP22, 7);
 281         EXT (BFD_RELOC_SPARC13, 10);
 282         EXT (BFD_RELOC_SPARC_GOT10, 14);
 283         EXT (BFD_RELOC_SPARC_BASE13, 15);
 284         EXT (BFD_RELOC_SPARC_GOT13, 15);
 285         EXT (BFD_RELOC_SPARC_GOT22, 16);
 286         EXT (BFD_RELOC_SPARC_PC10, 17);
 287         EXT (BFD_RELOC_SPARC_PC22, 18);
 288         EXT (BFD_RELOC_SPARC_WPLT30, 19);
 289       default: return (reloc_howto_type *) NULL;
 290       }
 291   else
 292     /* std relocs */
 293     switch (code)
 294       {
 295         STD (BFD_RELOC_16, 1);
 296         STD (BFD_RELOC_32, 2);
 297         STD (BFD_RELOC_8_PCREL, 4);
 298         STD (BFD_RELOC_16_PCREL, 5);
 299         STD (BFD_RELOC_32_PCREL, 6);
 300         STD (BFD_RELOC_16_BASEREL, 9);
 301         STD (BFD_RELOC_32_BASEREL, 10);
 302       default: return (reloc_howto_type *) NULL;
 303       }
 304 }
 305
 306 /*
 307 SUBSECTION
 308         Internal entry points
 309
 310 DESCRIPTION
 311         @file{aoutx.h} exports several routines for accessing the
 312         contents of an a.out file, which are gathered and exported in
 313         turn by various format specific files (eg sunos.c).
 314
 315 */
 316
 317 /*
 318 FUNCTION
 319          aout_@var{size}_swap_exec_header_in
 320
 321 SYNOPSIS
 322         void aout_@var{size}_swap_exec_header_in,
 323            (bfd *abfd,
 324             struct external_exec *raw_bytes,
 325             struct internal_exec *execp);
 326
 327 DESCRIPTION
 328         Swap the information in an executable header @var{raw_bytes} taken
 329         from a raw byte stream memory image into the internal exec header
 330         structure @var{execp}.
 331 */
 332
 333 #ifndef NAME_swap_exec_header_in
 334 void
 335 NAME(aout,swap_exec_header_in) (abfd, raw_bytes, execp)
 336      bfd *abfd;
 337      struct external_exec *raw_bytes;
 338      struct internal_exec *execp;
 339 {
 340   struct external_exec *bytes = (struct external_exec *)raw_bytes;
 341
 342   /* The internal_exec structure has some fields that are unused in this
 343      configuration (IE for i960), so ensure that all such uninitialized
 344      fields are zero'd out.  There are places where two of these structs
 345      are memcmp'd, and thus the contents do matter. */
 346   memset ((PTR) execp, 0, sizeof (struct internal_exec));
 347   /* Now fill in fields in the execp, from the bytes in the raw data.  */
 348   execp->a_info   = bfd_h_get_32 (abfd, bytes->e_info);
 349   execp->a_text   = GET_WORD (abfd, bytes->e_text);
 350   execp->a_data   = GET_WORD (abfd, bytes->e_data);
 351   execp->a_bss    = GET_WORD (abfd, bytes->e_bss);
 352   execp->a_syms   = GET_WORD (abfd, bytes->e_syms);
 353   execp->a_entry  = GET_WORD (abfd, bytes->e_entry);
 354   execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
 355   execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
 356 }
 357 #define NAME_swap_exec_header_in NAME(aout,swap_exec_header_in)
 358 #endif
 359
 360 /*
 361 FUNCTION
 362         aout_@var{size}_swap_exec_header_out
 363
 364 SYNOPSIS
 365         void aout_@var{size}_swap_exec_header_out
 366           (bfd *abfd,
 367            struct internal_exec *execp,
 368            struct external_exec *raw_bytes);
 369
 370 DESCRIPTION
 371         Swap the information in an internal exec header structure
 372         @var{execp} into the buffer @var{raw_bytes} ready for writing to disk.
 373 */
 374 void
 375 NAME(aout,swap_exec_header_out) (abfd, execp, raw_bytes)
 376      bfd *abfd;
 377      struct internal_exec *execp;
 378      struct external_exec *raw_bytes;
 379 {
 380   struct external_exec *bytes = (struct external_exec *)raw_bytes;
 381
 382   /* Now fill in fields in the raw data, from the fields in the exec struct. */
 383   bfd_h_put_32 (abfd, execp->a_info  , bytes->e_info);
 384   PUT_WORD (abfd, execp->a_text  , bytes->e_text);
 385   PUT_WORD (abfd, execp->a_data  , bytes->e_data);
 386   PUT_WORD (abfd, execp->a_bss   , bytes->e_bss);
 387   PUT_WORD (abfd, execp->a_syms  , bytes->e_syms);
 388   PUT_WORD (abfd, execp->a_entry , bytes->e_entry);
 389   PUT_WORD (abfd, execp->a_trsize, bytes->e_trsize);
 390   PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize);
 391 }
 392
 393 /* Make all the section for an a.out file.  */
 394
 395 boolean
 396 NAME(aout,make_sections) (abfd)
 397      bfd *abfd;
 398 {
 399   if (obj_textsec (abfd) == (asection *) NULL
 400       && bfd_make_section (abfd, ".text") == (asection *) NULL)
 401     return false;
 402   if (obj_datasec (abfd) == (asection *) NULL
 403       && bfd_make_section (abfd, ".data") == (asection *) NULL)
 404     return false;
 405   if (obj_bsssec (abfd) == (asection *) NULL
 406       && bfd_make_section (abfd, ".bss") == (asection *) NULL)
 407     return false;
 408   return true;
 409 }
 410
 411 /*
 412 FUNCTION
 413         aout_@var{size}_some_aout_object_p
 414
 415 SYNOPSIS
 416         const bfd_target *aout_@var{size}_some_aout_object_p
 417          (bfd *abfd,
 418           const bfd_target *(*callback_to_real_object_p)());
 419
 420 DESCRIPTION
 421         Some a.out variant thinks that the file open in @var{abfd}
 422         checking is an a.out file.  Do some more checking, and set up
 423         for access if it really is.  Call back to the calling
 424         environment's "finish up" function just before returning, to
 425         handle any last-minute setup.
 426 */
 427
 428 const bfd_target *
 429 NAME(aout,some_aout_object_p) (abfd, execp, callback_to_real_object_p)
 430      bfd *abfd;
 431      struct internal_exec *execp;
 432      const bfd_target *(*callback_to_real_object_p) PARAMS ((bfd *));
 433 {
 434   struct aout_data_struct *rawptr, *oldrawptr;
 435   const bfd_target *result;
 436
 437   rawptr = (struct aout_data_struct  *) bfd_zalloc (abfd, sizeof (struct aout_data_struct ));
 438   if (rawptr == NULL)
 439     return 0;
 440
 441   oldrawptr = abfd->tdata.aout_data;
 442   abfd->tdata.aout_data = rawptr;
 443
 444   /* Copy the contents of the old tdata struct.
 445      In particular, we want the subformat, since for hpux it was set in
 446      hp300hpux.c:swap_exec_header_in and will be used in
 447      hp300hpux.c:callback.  */
 448   if (oldrawptr != NULL)
 449     *abfd->tdata.aout_data = *oldrawptr;
 450
 451   abfd->tdata.aout_data->a.hdr = &rawptr->e;
 452   *(abfd->tdata.aout_data->a.hdr) = *execp;     /* Copy in the internal_exec struct */
 453   execp = abfd->tdata.aout_data->a.hdr;
 454
 455   /* Set the file flags */
 456   abfd->flags = BFD_NO_FLAGS;
 457   if (execp->a_drsize || execp->a_trsize)
 458     abfd->flags |= HAS_RELOC;
 459   /* Setting of EXEC_P has been deferred to the bottom of this function */
 460   if (execp->a_syms)
 461     abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
 462   if (N_DYNAMIC(*execp))
 463     abfd->flags |= DYNAMIC;
 464
 465   if (N_MAGIC (*execp) == ZMAGIC)
 466     {
 467       abfd->flags |= D_PAGED | WP_TEXT;
 468       adata (abfd).magic = z_magic;
 469     }
 470   else if (N_MAGIC (*execp) == QMAGIC)
 471     {
 472       abfd->flags |= D_PAGED | WP_TEXT;
 473       adata (abfd).magic = z_magic;
 474       adata (abfd).subformat = q_magic_format;
 475     }
 476   else if (N_MAGIC (*execp) == NMAGIC)
 477     {
 478       abfd->flags |= WP_TEXT;
 479       adata (abfd).magic = n_magic;
 480     }
 481   else if (N_MAGIC (*execp) == OMAGIC
 482            || N_MAGIC (*execp) == BMAGIC)
 483     adata (abfd).magic = o_magic;
 484   else
 485     {
 486       /* Should have been checked with N_BADMAG before this routine
 487          was called.  */
 488       abort ();
 489     }
 490
 491   bfd_get_start_address (abfd) = execp->a_entry;
 492
 493   obj_aout_symbols (abfd) = (aout_symbol_type *)NULL;
 494   bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist);
 495
 496   /* The default relocation entry size is that of traditional V7 Unix.  */
 497   obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
 498
 499   /* The default symbol entry size is that of traditional Unix. */
 500   obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;
 501
 502 #ifdef USE_MMAP
 503   bfd_init_window (&obj_aout_sym_window (abfd));
 504   bfd_init_window (&obj_aout_string_window (abfd));
 505 #endif
 506   obj_aout_external_syms (abfd) = NULL;
 507   obj_aout_external_strings (abfd) = NULL;
 508   obj_aout_sym_hashes (abfd) = NULL;
 509
 510   if (! NAME(aout,make_sections) (abfd))
 511     return NULL;
 512
 513   obj_datasec (abfd)->_raw_size = execp->a_data;
 514   obj_bsssec (abfd)->_raw_size = execp->a_bss;
 515
 516   obj_textsec (abfd)->flags =
 517     (execp->a_trsize != 0
 518      ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC)
 519      : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS));
 520   obj_datasec (abfd)->flags =
 521     (execp->a_drsize != 0
 522      ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC)
 523      : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS));
 524   obj_bsssec (abfd)->flags = SEC_ALLOC;
 525
 526 #ifdef THIS_IS_ONLY_DOCUMENTATION
 527   /* The common code can't fill in these things because they depend
 528      on either the start address of the text segment, the rounding
 529      up of virtual addresses between segments, or the starting file
 530      position of the text segment -- all of which varies among different
 531      versions of a.out.  */
 532
 533   /* Call back to the format-dependent code to fill in the rest of the
 534      fields and do any further cleanup.  Things that should be filled
 535      in by the callback:  */
 536
 537   struct exec *execp = exec_hdr (abfd);
 538
 539   obj_textsec (abfd)->size = N_TXTSIZE(*execp);
 540   obj_textsec (abfd)->raw_size = N_TXTSIZE(*execp);
 541   /* data and bss are already filled in since they're so standard */
 542
 543   /* The virtual memory addresses of the sections */
 544   obj_textsec (abfd)->vma = N_TXTADDR(*execp);
 545   obj_datasec (abfd)->vma = N_DATADDR(*execp);
 546   obj_bsssec  (abfd)->vma = N_BSSADDR(*execp);
 547
 548   /* The file offsets of the sections */
 549   obj_textsec (abfd)->filepos = N_TXTOFF(*execp);
 550   obj_datasec (abfd)->filepos = N_DATOFF(*execp);
 551
 552   /* The file offsets of the relocation info */
 553   obj_textsec (abfd)->rel_filepos = N_TRELOFF(*execp);
 554   obj_datasec (abfd)->rel_filepos = N_DRELOFF(*execp);
 555
 556   /* The file offsets of the string table and symbol table.  */
 557   obj_str_filepos (abfd) = N_STROFF (*execp);
 558   obj_sym_filepos (abfd) = N_SYMOFF (*execp);
 559
 560   /* Determine the architecture and machine type of the object file.  */
 561   switch (N_MACHTYPE (*exec_hdr (abfd))) {
 562   default:
 563     abfd->obj_arch = bfd_arch_obscure;
 564     break;
 565   }
 566
 567   adata(abfd)->page_size = TARGET_PAGE_SIZE;
 568   adata(abfd)->segment_size = SEGMENT_SIZE;
 569   adata(abfd)->exec_bytes_size = EXEC_BYTES_SIZE;
 570
 571   return abfd->xvec;
 572
 573   /* The architecture is encoded in various ways in various a.out variants,
 574      or is not encoded at all in some of them.  The relocation size depends
 575      on the architecture and the a.out variant.  Finally, the return value
 576      is the bfd_target vector in use.  If an error occurs, return zero and
 577      set bfd_error to the appropriate error code.
 578
 579      Formats such as b.out, which have additional fields in the a.out
 580      header, should cope with them in this callback as well.  */
 581 #endif                          /* DOCUMENTATION */
 582
 583   result = (*callback_to_real_object_p)(abfd);
 584
 585   /* Now that the segment addresses have been worked out, take a better
 586      guess at whether the file is executable.  If the entry point
 587      is within the text segment, assume it is.  (This makes files
 588      executable even if their entry point address is 0, as long as
 589      their text starts at zero.).
 590
 591      This test had to be changed to deal with systems where the text segment
 592      runs at a different location than the default.  The problem is that the
 593      entry address can appear to be outside the text segment, thus causing an
 594      erroneous conclusion that the file isn't executable.
 595
 596      To fix this, we now accept any non-zero entry point as an indication of
 597      executability.  This will work most of the time, since only the linker
 598      sets the entry point, and that is likely to be non-zero for most systems. */
 599
 600   if (execp->a_entry != 0
 601       || (execp->a_entry >= obj_textsec(abfd)->vma
 602           && execp->a_entry < obj_textsec(abfd)->vma + obj_textsec(abfd)->_raw_size))
 603     abfd->flags |= EXEC_P;
 604 #ifdef STAT_FOR_EXEC
 605   else
 606     {
 607       struct stat stat_buf;
 608
 609       /* The original heuristic doesn't work in some important cases.
 610         The a.out file has no information about the text start
 611         address.  For files (like kernels) linked to non-standard
 612         addresses (ld -Ttext nnn) the entry point may not be between
 613         the default text start (obj_textsec(abfd)->vma) and
 614         (obj_textsec(abfd)->vma) + text size.  This is not just a mach
 615         issue.  Many kernels are loaded at non standard addresses.  */
 616       if (abfd->iostream != NULL
 617           && (abfd->flags & BFD_IN_MEMORY) == 0
 618           && (fstat(fileno((FILE *) (abfd->iostream)), &stat_buf) == 0)
 619           && ((stat_buf.st_mode & 0111) != 0))
 620         abfd->flags |= EXEC_P;
 621     }
 622 #endif /* STAT_FOR_EXEC */
 623
 624   if (result)
 625     {
 626 #if 0 /* These should be set correctly anyways.  */
 627       abfd->sections = obj_textsec (abfd);
 628       obj_textsec (abfd)->next = obj_datasec (abfd);
 629       obj_datasec (abfd)->next = obj_bsssec (abfd);
 630 #endif
 631     }
 632   else
 633     {
 634       free (rawptr);
 635       abfd->tdata.aout_data = oldrawptr;
 636     }
 637   return result;
 638 }
 639
 640 /*
 641 FUNCTION
 642         aout_@var{size}_mkobject
 643
 644 SYNOPSIS
 645         boolean aout_@var{size}_mkobject, (bfd *abfd);
 646
 647 DESCRIPTION
 648         Initialize BFD @var{abfd} for use with a.out files.
 649 */
 650
 651 boolean
 652 NAME(aout,mkobject) (abfd)
 653      bfd *abfd;
 654 {
 655   struct aout_data_struct  *rawptr;
 656
 657   bfd_set_error (bfd_error_system_call);
 658
 659   /* Use an intermediate variable for clarity */
 660   rawptr = (struct aout_data_struct *)bfd_zalloc (abfd, sizeof (struct aout_data_struct ));
 661
 662   if (rawptr == NULL)
 663     return false;
 664
 665   abfd->tdata.aout_data = rawptr;
 666   exec_hdr (abfd) = &(rawptr->e);
 667
 668   obj_textsec (abfd) = (asection *)NULL;
 669   obj_datasec (abfd) = (asection *)NULL;
 670   obj_bsssec (abfd) = (asection *)NULL;
 671
 672   return true;
 673 }
 674
 675
 676 /*
 677 FUNCTION
 678         aout_@var{size}_machine_type
 679
 680 SYNOPSIS
 681         enum machine_type  aout_@var{size}_machine_type
 682          (enum bfd_architecture arch,
 683           unsigned long machine));
 684
 685 DESCRIPTION
 686         Keep track of machine architecture and machine type for
 687         a.out's. Return the <<machine_type>> for a particular
 688         architecture and machine, or <<M_UNKNOWN>> if that exact architecture
 689         and machine can't be represented in a.out format.
 690
 691         If the architecture is understood, machine type 0 (default)
 692         is always understood.
 693 */
 694
 695 enum machine_type
 696 NAME(aout,machine_type) (arch, machine, unknown)
 697      enum bfd_architecture arch;
 698      unsigned long machine;
 699      boolean *unknown;
 700 {
 701   enum machine_type arch_flags;
 702
 703   arch_flags = M_UNKNOWN;
 704   *unknown = true;
 705
 706   switch (arch) {
 707   case bfd_arch_sparc:
 708     if (machine == 0
 709         || machine == bfd_mach_sparc
 710         || machine == bfd_mach_sparc_sparclite
 711         || machine == bfd_mach_sparc_v9)
 712       arch_flags = M_SPARC;
 713     else if (machine == bfd_mach_sparc_sparclet)
 714       arch_flags = M_SPARCLET;
 715     break;
 716
 717   case bfd_arch_m68k:
 718     switch (machine) {
 719     case 0:               arch_flags = M_68010; break;
 720     case bfd_mach_m68000: arch_flags = M_UNKNOWN; *unknown = false; break;
 721     case bfd_mach_m68010: arch_flags = M_68010; break;
 722     case bfd_mach_m68020: arch_flags = M_68020; break;
 723     default:              arch_flags = M_UNKNOWN; break;
 724     }
 725     break;
 726
 727   case bfd_arch_i386:
 728     if (machine == 0)   arch_flags = M_386;
 729     break;
 730
 731   case bfd_arch_a29k:
 732     if (machine == 0)   arch_flags = M_29K;
 733     break;
 734
 735   case bfd_arch_arm:
 736     if (machine == 0)   arch_flags = M_ARM;
 737     break;
 738
 739   case bfd_arch_mips:
 740     switch (machine) {
 741     case 0:
 742     case 2000:
 743     case 3000:          arch_flags = M_MIPS1; break;
 744     case 4000: /* mips3 */
 745     case 4400:
 746     case 8000: /* mips4 */
 747       /* real mips2: */
 748     case 6000:          arch_flags = M_MIPS2; break;
 749     default:            arch_flags = M_UNKNOWN; break;
 750     }
 751     break;
 752
 753   case bfd_arch_ns32k:
 754     switch (machine) {
 755     case 0:             arch_flags = M_NS32532; break;
 756     case 32032:         arch_flags = M_NS32032; break;
 757     case 32532:         arch_flags = M_NS32532; break;
 758     default:            arch_flags = M_UNKNOWN; break;
 759     }
 760     break;
 761
 762   case bfd_arch_vax:
 763     *unknown = false;
 764     break;
 765
 766   default:
 767     arch_flags = M_UNKNOWN;
 768   }
 769
 770   if (arch_flags != M_UNKNOWN)
 771     *unknown = false;
 772
 773   return arch_flags;
 774 }
 775
 776
 777 /*
 778 FUNCTION
 779         aout_@var{size}_set_arch_mach
 780
 781 SYNOPSIS
 782         boolean aout_@var{size}_set_arch_mach,
 783          (bfd *,
 784           enum bfd_architecture arch,
 785           unsigned long machine));
 786
 787 DESCRIPTION
 788         Set the architecture and the machine of the BFD @var{abfd} to the
 789         values @var{arch} and @var{machine}.  Verify that @var{abfd}'s format
 790         can support the architecture required.
 791 */
 792
 793 boolean
 794 NAME(aout,set_arch_mach) (abfd, arch, machine)
 795      bfd *abfd;
 796      enum bfd_architecture arch;
 797      unsigned long machine;
 798 {
 799   if (! bfd_default_set_arch_mach (abfd, arch, machine))
 800     return false;
 801
 802   if (arch != bfd_arch_unknown)
 803     {
 804       boolean unknown;
 805
 806       NAME(aout,machine_type) (arch, machine, &unknown);
 807       if (unknown)
 808         return false;
 809     }
 810
 811   /* Determine the size of a relocation entry */
 812   switch (arch) {
 813   case bfd_arch_sparc:
 814   case bfd_arch_a29k:
 815   case bfd_arch_mips:
 816     obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE;
 817     break;
 818   default:
 819     obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
 820     break;
 821   }
 822
 823   return (*aout_backend_info(abfd)->set_sizes) (abfd);
 824 }
 825
 826 static void
 827 adjust_o_magic (abfd, execp)
 828      bfd *abfd;
 829      struct internal_exec *execp;
 830 {
 831   file_ptr pos = adata (abfd).exec_bytes_size;
 832   bfd_vma vma = 0;
 833   int pad = 0;
 834
 835   /* Text.  */
 836   obj_textsec(abfd)->filepos = pos;
 837   if (!obj_textsec(abfd)->user_set_vma)
 838     obj_textsec(abfd)->vma = vma;
 839   else
 840     vma = obj_textsec(abfd)->vma;
 841
 842   pos += obj_textsec(abfd)->_raw_size;
 843   vma += obj_textsec(abfd)->_raw_size;
 844
 845   /* Data.  */
 846   if (!obj_datasec(abfd)->user_set_vma)
 847     {
 848 #if 0       /* ?? Does alignment in the file image really matter? */
 849       pad = align_power (vma, obj_datasec(abfd)->alignment_power) - vma;
 850 #endif
 851       obj_textsec(abfd)->_raw_size += pad;
 852       pos += pad;
 853       vma += pad;
 854       obj_datasec(abfd)->vma = vma;
 855     }
 856   else
 857     vma = obj_datasec(abfd)->vma;
 858   obj_datasec(abfd)->filepos = pos;
 859   pos += obj_datasec(abfd)->_raw_size;
 860   vma += obj_datasec(abfd)->_raw_size;
 861
 862   /* BSS.  */
 863   if (!obj_bsssec(abfd)->user_set_vma)
 864     {
 865 #if 0
 866       pad = align_power (vma, obj_bsssec(abfd)->alignment_power) - vma;
 867 #endif
 868       obj_datasec(abfd)->_raw_size += pad;
 869       pos += pad;
 870       vma += pad;
 871       obj_bsssec(abfd)->vma = vma;
 872     }
 873   else
 874     {
 875       /* The VMA of the .bss section is set by the the VMA of the
 876          .data section plus the size of the .data section.  We may
 877          need to add padding bytes to make this true.  */
 878       pad = obj_bsssec (abfd)->vma - vma;
 879       if (pad > 0)
 880         {
 881           obj_datasec (abfd)->_raw_size += pad;
 882           pos += pad;
 883         }
 884     }
 885   obj_bsssec(abfd)->filepos = pos;
 886
 887   /* Fix up the exec header.  */
 888   execp->a_text = obj_textsec(abfd)->_raw_size;
 889   execp->a_data = obj_datasec(abfd)->_raw_size;
 890   execp->a_bss = obj_bsssec(abfd)->_raw_size;
 891   N_SET_MAGIC (*execp, OMAGIC);
 892 }
 893
 894 static void
 895 adjust_z_magic (abfd, execp)
 896      bfd *abfd;
 897      struct internal_exec *execp;
 898 {
 899   bfd_size_type data_pad, text_pad;
 900   file_ptr text_end;
 901   CONST struct aout_backend_data *abdp;
 902   int ztih;                     /* Nonzero if text includes exec header.  */
 903
 904   abdp = aout_backend_info (abfd);
 905
 906   /* Text.  */
 907   ztih = (abdp != NULL
 908           && (abdp->text_includes_header
 909               || obj_aout_subformat (abfd) == q_magic_format));
 910   obj_textsec(abfd)->filepos = (ztih
 911                                 ? adata(abfd).exec_bytes_size
 912                                 : adata(abfd).zmagic_disk_block_size);
 913   if (! obj_textsec(abfd)->user_set_vma)
 914     {
 915       /* ?? Do we really need to check for relocs here?  */
 916       obj_textsec(abfd)->vma = ((abfd->flags & HAS_RELOC)
 917                                 ? 0
 918                                 : (ztih
 919                                    ? (abdp->default_text_vma
 920                                       + adata(abfd).exec_bytes_size)
 921                                    : abdp->default_text_vma));
 922       text_pad = 0;
 923     }
 924   else
 925     {
 926       /* The .text section is being loaded at an unusual address.  We
 927          may need to pad it such that the .data section starts at a page
 928          boundary.  */
 929       if (ztih)
 930         text_pad = ((obj_textsec (abfd)->filepos - obj_textsec (abfd)->vma)
 931                     & (adata (abfd).page_size - 1));
 932       else
 933         text_pad = ((- obj_textsec (abfd)->vma)
 934                     & (adata (abfd).page_size - 1));
 935     }
 936
 937   /* Find start of data.  */
 938   if (ztih)
 939     {
 940       text_end = obj_textsec (abfd)->filepos + obj_textsec (abfd)->_raw_size;
 941       text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
 942     }
 943   else
 944     {
 945       /* Note that if page_size == zmagic_disk_block_size, then
 946          filepos == page_size, and this case is the same as the ztih
 947          case.  */
 948       text_end = obj_textsec (abfd)->_raw_size;
 949       text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
 950       text_end += obj_textsec (abfd)->filepos;
 951     }
 952   obj_textsec(abfd)->_raw_size += text_pad;
 953   text_end += text_pad;
 954
 955   /* Data.  */
 956   if (!obj_datasec(abfd)->user_set_vma)
 957     {
 958       bfd_vma vma;
 959       vma = obj_textsec(abfd)->vma + obj_textsec(abfd)->_raw_size;
 960       obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
 961     }
 962   if (abdp && abdp->zmagic_mapped_contiguous)
 963     {
 964       text_pad = (obj_datasec(abfd)->vma
 965                   - obj_textsec(abfd)->vma
 966                   - obj_textsec(abfd)->_raw_size);
 967       obj_textsec(abfd)->_raw_size += text_pad;
 968     }
 969   obj_datasec(abfd)->filepos = (obj_textsec(abfd)->filepos
 970                                 + obj_textsec(abfd)->_raw_size);
 971
 972   /* Fix up exec header while we're at it.  */
 973   execp->a_text = obj_textsec(abfd)->_raw_size;
 974   if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted)))
 975     execp->a_text += adata(abfd).exec_bytes_size;
 976   if (obj_aout_subformat (abfd) == q_magic_format)
 977     N_SET_MAGIC (*execp, QMAGIC);
 978   else
 979     N_SET_MAGIC (*execp, ZMAGIC);
 980
 981   /* Spec says data section should be rounded up to page boundary.  */
 982   obj_datasec(abfd)->_raw_size
 983     = align_power (obj_datasec(abfd)->_raw_size,
 984                    obj_bsssec(abfd)->alignment_power);
 985   execp->a_data = BFD_ALIGN (obj_datasec(abfd)->_raw_size,
 986                              adata(abfd).page_size);
 987   data_pad = execp->a_data - obj_datasec(abfd)->_raw_size;
 988
 989   /* BSS.  */
 990   if (!obj_bsssec(abfd)->user_set_vma)
 991     obj_bsssec(abfd)->vma = (obj_datasec(abfd)->vma
 992                              + obj_datasec(abfd)->_raw_size);
 993   /* If the BSS immediately follows the data section and extra space
 994      in the page is left after the data section, fudge data
 995      in the header so that the bss section looks smaller by that
 996      amount.  We'll start the bss section there, and lie to the OS.
 997      (Note that a linker script, as well as the above assignment,
 998      could have explicitly set the BSS vma to immediately follow
 999      the data section.)  */
1000   if (align_power (obj_bsssec(abfd)->vma, obj_bsssec(abfd)->alignment_power)
1001       == obj_datasec(abfd)->vma + obj_datasec(abfd)->_raw_size)
1002     execp->a_bss = (data_pad > obj_bsssec(abfd)->_raw_size) ? 0 :
1003       obj_bsssec(abfd)->_raw_size - data_pad;
1004   else
1005     execp->a_bss = obj_bsssec(abfd)->_raw_size;
1006 }
1007
1008 static void
1009 adjust_n_magic (abfd, execp)
1010      bfd *abfd;
1011      struct internal_exec *execp;
1012 {
1013   file_ptr pos = adata(abfd).exec_bytes_size;
1014   bfd_vma vma = 0;
1015   int pad;
1016
1017   /* Text.  */
1018   obj_textsec(abfd)->filepos = pos;
1019   if (!obj_textsec(abfd)->user_set_vma)
1020     obj_textsec(abfd)->vma = vma;
1021   else
1022     vma = obj_textsec(abfd)->vma;
1023   pos += obj_textsec(abfd)->_raw_size;
1024   vma += obj_textsec(abfd)->_raw_size;
1025
1026   /* Data.  */
1027   obj_datasec(abfd)->filepos = pos;
1028   if (!obj_datasec(abfd)->user_set_vma)
1029     obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
1030   vma = obj_datasec(abfd)->vma;
1031
1032   /* Since BSS follows data immediately, see if it needs alignment.  */
1033   vma += obj_datasec(abfd)->_raw_size;
1034   pad = align_power (vma, obj_bsssec(abfd)->alignment_power) - vma;
1035   obj_datasec(abfd)->_raw_size += pad;
1036   pos += obj_datasec(abfd)->_raw_size;
1037
1038   /* BSS.  */
1039   if (!obj_bsssec(abfd)->user_set_vma)
1040     obj_bsssec(abfd)->vma = vma;
1041   else
1042     vma = obj_bsssec(abfd)->vma;
1043
1044   /* Fix up exec header.  */
1045   execp->a_text = obj_textsec(abfd)->_raw_size;
1046   execp->a_data = obj_datasec(abfd)->_raw_size;
1047   execp->a_bss = obj_bsssec(abfd)->_raw_size;
1048   N_SET_MAGIC (*execp, NMAGIC);
1049 }
1050
1051 boolean
1052 NAME(aout,adjust_sizes_and_vmas) (abfd, text_size, text_end)
1053      bfd *abfd;
1054      bfd_size_type *text_size;
1055      file_ptr *text_end;
1056 {
1057   struct internal_exec *execp = exec_hdr (abfd);
1058
1059   if (! NAME(aout,make_sections) (abfd))
1060     return false;
1061
1062   if (adata(abfd).magic != undecided_magic)
1063     return true;
1064
1065   obj_textsec(abfd)->_raw_size =
1066     align_power(obj_textsec(abfd)->_raw_size,
1067                 obj_textsec(abfd)->alignment_power);
1068
1069   *text_size = obj_textsec (abfd)->_raw_size;
1070   /* Rule (heuristic) for when to pad to a new page.  Note that there
1071      are (at least) two ways demand-paged (ZMAGIC) files have been
1072      handled.  Most Berkeley-based systems start the text segment at
1073      (TARGET_PAGE_SIZE).  However, newer versions of SUNOS start the text
1074      segment right after the exec header; the latter is counted in the
1075      text segment size, and is paged in by the kernel with the rest of
1076      the text. */
1077
1078   /* This perhaps isn't the right way to do this, but made it simpler for me
1079      to understand enough to implement it.  Better would probably be to go
1080      right from BFD flags to alignment/positioning characteristics.  But the
1081      old code was sloppy enough about handling the flags, and had enough
1082      other magic, that it was a little hard for me to understand.  I think
1083      I understand it better now, but I haven't time to do the cleanup this
1084      minute.  */
1085
1086   if (abfd->flags & D_PAGED)
1087     /* Whether or not WP_TEXT is set -- let D_PAGED override.  */
1088     adata(abfd).magic = z_magic;
1089   else if (abfd->flags & WP_TEXT)
1090     adata(abfd).magic = n_magic;
1091   else
1092     adata(abfd).magic = o_magic;
1093
1094 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1095 #if __GNUC__ >= 2
1096   fprintf (stderr, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1097            ({ char *str;
1098               switch (adata(abfd).magic) {
1099               case n_magic: str = "NMAGIC"; break;
1100               case o_magic: str = "OMAGIC"; break;
1101               case z_magic: str = "ZMAGIC"; break;
1102               default: abort ();
1103               }
1104               str;
1105             }),
1106            obj_textsec(abfd)->vma, obj_textsec(abfd)->_raw_size,
1107                 obj_textsec(abfd)->alignment_power,
1108            obj_datasec(abfd)->vma, obj_datasec(abfd)->_raw_size,
1109                 obj_datasec(abfd)->alignment_power,
1110            obj_bsssec(abfd)->vma, obj_bsssec(abfd)->_raw_size,
1111                 obj_bsssec(abfd)->alignment_power);
1112 #endif
1113 #endif
1114
1115   switch (adata(abfd).magic)
1116     {
1117     case o_magic:
1118       adjust_o_magic (abfd, execp);
1119       break;
1120     case z_magic:
1121       adjust_z_magic (abfd, execp);
1122       break;
1123     case n_magic:
1124       adjust_n_magic (abfd, execp);
1125       break;
1126     default:
1127       abort ();
1128     }
1129
1130 #ifdef BFD_AOUT_DEBUG
1131   fprintf (stderr, "       text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1132            obj_textsec(abfd)->vma, obj_textsec(abfd)->_raw_size,
1133                 obj_textsec(abfd)->filepos,
1134            obj_datasec(abfd)->vma, obj_datasec(abfd)->_raw_size,
1135                 obj_datasec(abfd)->filepos,
1136            obj_bsssec(abfd)->vma, obj_bsssec(abfd)->_raw_size);
1137 #endif
1138
1139   return true;
1140 }
1141
1142 /*
1143 FUNCTION
1144         aout_@var{size}_new_section_hook
1145
1146 SYNOPSIS
1147         boolean aout_@var{size}_new_section_hook,
1148            (bfd *abfd,
1149             asection *newsect));
1150
1151 DESCRIPTION
1152         Called by the BFD in response to a @code{bfd_make_section}
1153         request.
1154 */
1155 boolean
1156 NAME(aout,new_section_hook) (abfd, newsect)
1157      bfd *abfd;
1158      asection *newsect;
1159 {
1160   /* align to double at least */
1161   newsect->alignment_power = bfd_get_arch_info(abfd)->section_align_power;
1162
1163
1164   if (bfd_get_format (abfd) == bfd_object)
1165   {
1166     if (obj_textsec(abfd) == NULL && !strcmp(newsect->name, ".text")) {
1167         obj_textsec(abfd)= newsect;
1168         newsect->target_index = N_TEXT;
1169         return true;
1170       }
1171
1172     if (obj_datasec(abfd) == NULL && !strcmp(newsect->name, ".data")) {
1173         obj_datasec(abfd) = newsect;
1174         newsect->target_index = N_DATA;
1175         return true;
1176       }
1177
1178     if (obj_bsssec(abfd) == NULL && !strcmp(newsect->name, ".bss")) {
1179         obj_bsssec(abfd) = newsect;
1180         newsect->target_index = N_BSS;
1181         return true;
1182       }
1183
1184   }
1185
1186   /* We allow more than three sections internally */
1187   return true;
1188 }
1189
1190 boolean
1191 NAME(aout,set_section_contents) (abfd, section, location, offset, count)
1192      bfd *abfd;
1193      sec_ptr section;
1194      PTR location;
1195      file_ptr offset;
1196      bfd_size_type count;
1197 {
1198   file_ptr text_end;
1199   bfd_size_type text_size;
1200
1201   if (! abfd->output_has_begun)
1202     {
1203       if (! NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
1204         return false;
1205     }
1206
1207   if (section == obj_bsssec (abfd))
1208     {
1209       bfd_set_error (bfd_error_no_contents);
1210       return false;
1211     }
1212
1213   if (section != obj_textsec (abfd)
1214       && section != obj_datasec (abfd))
1215     {
1216       (*_bfd_error_handler)
1217         ("%s: can not represent section `%s' in a.out object file format",
1218          bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
1219       bfd_set_error (bfd_error_nonrepresentable_section);
1220       return false;
1221     }
1222
1223   if (count != 0)
1224     {
1225       if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1226           || bfd_write (location, 1, count, abfd) != count)
1227         return false;
1228     }
1229
1230   return true;
1231 }
1232 \f
1233 /* Read the external symbols from an a.out file.  */
1234
1235 static boolean
1236 aout_get_external_symbols (abfd)
1237      bfd *abfd;
1238 {
1239   if (obj_aout_external_syms (abfd) == (struct external_nlist *) NULL)
1240     {
1241       bfd_size_type count;
1242       struct external_nlist *syms;
1243
1244       count = exec_hdr (abfd)->a_syms / EXTERNAL_NLIST_SIZE;
1245
1246 #ifdef USE_MMAP
1247       if (bfd_get_file_window (abfd,
1248                                obj_sym_filepos (abfd), exec_hdr (abfd)->a_syms,
1249                                &obj_aout_sym_window (abfd), true) == false)
1250         return false;
1251       syms = (struct external_nlist *) obj_aout_sym_window (abfd).data;
1252 #else
1253       /* We allocate using malloc to make the values easy to free
1254          later on.  If we put them on the objalloc it might not be
1255          possible to free them.  */
1256       syms = ((struct external_nlist *)
1257               bfd_malloc ((size_t) count * EXTERNAL_NLIST_SIZE));
1258       if (syms == (struct external_nlist *) NULL && count != 0)
1259         return false;
1260
1261       if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1262           || (bfd_read (syms, 1, exec_hdr (abfd)->a_syms, abfd)
1263               != exec_hdr (abfd)->a_syms))
1264         {
1265           free (syms);
1266           return false;
1267         }
1268 #endif
1269
1270       obj_aout_external_syms (abfd) = syms;
1271       obj_aout_external_sym_count (abfd) = count;
1272     }
1273
1274   if (obj_aout_external_strings (abfd) == NULL
1275       && exec_hdr (abfd)->a_syms != 0)
1276     {
1277       unsigned char string_chars[BYTES_IN_WORD];
1278       bfd_size_type stringsize;
1279       char *strings;
1280
1281       /* Get the size of the strings.  */
1282       if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
1283           || (bfd_read ((PTR) string_chars, BYTES_IN_WORD, 1, abfd)
1284               != BYTES_IN_WORD))
1285         return false;
1286       stringsize = GET_WORD (abfd, string_chars);
1287
1288 #ifdef USE_MMAP
1289       if (bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
1290                                &obj_aout_string_window (abfd), true) == false)
1291         return false;
1292       strings = (char *) obj_aout_string_window (abfd).data;
1293 #else
1294       strings = (char *) bfd_malloc ((size_t) stringsize + 1);
1295       if (strings == NULL)
1296         return false;
1297
1298       /* Skip space for the string count in the buffer for convenience
1299          when using indexes.  */
1300       if (bfd_read (strings + BYTES_IN_WORD, 1, stringsize - BYTES_IN_WORD,
1301                     abfd)
1302           != stringsize - BYTES_IN_WORD)
1303         {
1304           free (strings);
1305           return false;
1306         }
1307 #endif
1308
1309       /* Ensure that a zero index yields an empty string.  */
1310       strings[0] = '\0';
1311
1312       strings[stringsize - 1] = 0;
1313
1314       obj_aout_external_strings (abfd) = strings;
1315       obj_aout_external_string_size (abfd) = stringsize;
1316     }
1317
1318   return true;
1319 }
1320
1321 /* Translate an a.out symbol into a BFD symbol.  The desc, other, type
1322    and symbol->value fields of CACHE_PTR will be set from the a.out
1323    nlist structure.  This function is responsible for setting
1324    symbol->flags and symbol->section, and adjusting symbol->value.  */
1325
1326 static boolean
1327 translate_from_native_sym_flags (abfd, cache_ptr)
1328      bfd *abfd;
1329      aout_symbol_type *cache_ptr;
1330 {
1331   flagword visible;
1332
1333   if ((cache_ptr->type & N_STAB) != 0
1334       || cache_ptr->type == N_FN)
1335     {
1336       asection *sec;
1337
1338       /* This is a debugging symbol.  */
1339
1340       cache_ptr->symbol.flags = BSF_DEBUGGING;
1341
1342       /* Work out the symbol section.  */
1343       switch (cache_ptr->type & N_TYPE)
1344         {
1345         case N_TEXT:
1346         case N_FN:
1347           sec = obj_textsec (abfd);
1348           break;
1349         case N_DATA:
1350           sec = obj_datasec (abfd);
1351           break;
1352         case N_BSS:
1353           sec = obj_bsssec (abfd);
1354           break;
1355         default:
1356         case N_ABS:
1357           sec = bfd_abs_section_ptr;
1358           break;
1359         }
1360
1361       cache_ptr->symbol.section = sec;
1362       cache_ptr->symbol.value -= sec->vma;
1363
1364       return true;
1365     }
1366
1367   /* Get the default visibility.  This does not apply to all types, so
1368      we just hold it in a local variable to use if wanted.  */
1369   if ((cache_ptr->type & N_EXT) == 0)
1370     visible = BSF_LOCAL;
1371   else
1372     visible = BSF_GLOBAL;
1373
1374   switch (cache_ptr->type)
1375     {
1376     default:
1377     case N_ABS: case N_ABS | N_EXT:
1378       cache_ptr->symbol.section = bfd_abs_section_ptr;
1379       cache_ptr->symbol.flags = visible;
1380       break;
1381
1382     case N_UNDF | N_EXT:
1383       if (cache_ptr->symbol.value != 0)
1384         {
1385           /* This is a common symbol.  */
1386           cache_ptr->symbol.flags = BSF_GLOBAL;
1387           cache_ptr->symbol.section = bfd_com_section_ptr;
1388         }
1389       else
1390         {
1391           cache_ptr->symbol.flags = 0;
1392           cache_ptr->symbol.section = bfd_und_section_ptr;
1393         }
1394       break;
1395
1396     case N_TEXT: case N_TEXT | N_EXT:
1397       cache_ptr->symbol.section = obj_textsec (abfd);
1398       cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1399       cache_ptr->symbol.flags = visible;
1400       break;
1401
1402       /* N_SETV symbols used to represent set vectors placed in the
1403          data section.  They are no longer generated.  Theoretically,
1404          it was possible to extract the entries and combine them with
1405          new ones, although I don't know if that was ever actually
1406          done.  Unless that feature is restored, treat them as data
1407          symbols.  */
1408     case N_SETV: case N_SETV | N_EXT:
1409     case N_DATA: case N_DATA | N_EXT:
1410       cache_ptr->symbol.section = obj_datasec (abfd);
1411       cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1412       cache_ptr->symbol.flags = visible;
1413       break;
1414
1415     case N_BSS: case N_BSS | N_EXT:
1416       cache_ptr->symbol.section = obj_bsssec (abfd);
1417       cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1418       cache_ptr->symbol.flags = visible;
1419       break;
1420
1421     case N_SETA: case N_SETA | N_EXT:
1422     case N_SETT: case N_SETT | N_EXT:
1423     case N_SETD: case N_SETD | N_EXT:
1424     case N_SETB: case N_SETB | N_EXT:
1425       {
1426         /* This code is no longer needed.  It used to be used to make
1427            the linker handle set symbols, but they are now handled in
1428            the add_symbols routine instead.  */
1429 #if 0
1430         asection *section;
1431         arelent_chain *reloc;
1432         asection *into_section;
1433
1434         /* This is a set symbol.  The name of the symbol is the name
1435            of the set (e.g., __CTOR_LIST__).  The value of the symbol
1436            is the value to add to the set.  We create a section with
1437            the same name as the symbol, and add a reloc to insert the
1438            appropriate value into the section.
1439
1440            This action is actually obsolete; it used to make the
1441            linker do the right thing, but the linker no longer uses
1442            this function.  */
1443
1444         section = bfd_get_section_by_name (abfd, cache_ptr->symbol.name);
1445         if (section == NULL)
1446           {
1447             char *copy;
1448
1449             copy = bfd_alloc (abfd, strlen (cache_ptr->symbol.name) + 1);
1450             if (copy == NULL)
1451               return false;
1452
1453             strcpy (copy, cache_ptr->symbol.name);
1454             section = bfd_make_section (abfd, copy);
1455             if (section == NULL)
1456               return false;
1457           }
1458
1459         reloc = (arelent_chain *) bfd_alloc (abfd, sizeof (arelent_chain));
1460         if (reloc == NULL)
1461           return false;
1462
1463         /* Build a relocation entry for the constructor.  */
1464         switch (cache_ptr->type & N_TYPE)
1465           {
1466           case N_SETA:
1467             into_section = bfd_abs_section_ptr;
1468             cache_ptr->type = N_ABS;
1469             break;
1470           case N_SETT:
1471             into_section = obj_textsec (abfd);
1472             cache_ptr->type = N_TEXT;
1473             break;
1474           case N_SETD:
1475             into_section = obj_datasec (abfd);
1476             cache_ptr->type = N_DATA;
1477             break;
1478           case N_SETB:
1479             into_section = obj_bsssec (abfd);
1480             cache_ptr->type = N_BSS;
1481             break;
1482           }
1483
1484         /* Build a relocation pointing into the constructor section
1485            pointing at the symbol in the set vector specified.  */
1486         reloc->relent.addend = cache_ptr->symbol.value;
1487         cache_ptr->symbol.section = into_section;
1488         reloc->relent.sym_ptr_ptr = into_section->symbol_ptr_ptr;
1489
1490         /* We modify the symbol to belong to a section depending upon
1491            the name of the symbol, and add to the size of the section
1492            to contain a pointer to the symbol. Build a reloc entry to
1493            relocate to this symbol attached to this section.  */
1494         section->flags = SEC_CONSTRUCTOR | SEC_RELOC;
1495
1496         section->reloc_count++;
1497         section->alignment_power = 2;
1498
1499         reloc->next = section->constructor_chain;
1500         section->constructor_chain = reloc;
1501         reloc->relent.address = section->_raw_size;
1502         section->_raw_size += BYTES_IN_WORD;
1503
1504         reloc->relent.howto = CTOR_TABLE_RELOC_HOWTO(abfd);
1505
1506 #endif /* 0 */
1507
1508         switch (cache_ptr->type & N_TYPE)
1509           {
1510           case N_SETA:
1511             cache_ptr->symbol.section = bfd_abs_section_ptr;
1512             break;
1513           case N_SETT:
1514             cache_ptr->symbol.section = obj_textsec (abfd);
1515             break;
1516           case N_SETD:
1517             cache_ptr->symbol.section = obj_datasec (abfd);
1518             break;
1519           case N_SETB:
1520             cache_ptr->symbol.section = obj_bsssec (abfd);
1521             break;
1522           }
1523
1524         cache_ptr->symbol.flags |= BSF_CONSTRUCTOR;
1525       }
1526       break;
1527
1528     case N_WARNING:
1529       /* This symbol is the text of a warning message.  The next
1530          symbol is the symbol to associate the warning with.  If a
1531          reference is made to that symbol, a warning is issued.  */
1532       cache_ptr->symbol.flags = BSF_DEBUGGING | BSF_WARNING;
1533       cache_ptr->symbol.section = bfd_abs_section_ptr;
1534       break;
1535
1536     case N_INDR: case N_INDR | N_EXT:
1537       /* An indirect symbol.  This consists of two symbols in a row.
1538          The first symbol is the name of the indirection.  The second
1539          symbol is the name of the target.  A reference to the first
1540          symbol becomes a reference to the second.  */
1541       cache_ptr->symbol.flags = BSF_DEBUGGING | BSF_INDIRECT | visible;
1542       cache_ptr->symbol.section = bfd_ind_section_ptr;
1543       break;
1544
1545     case N_WEAKU:
1546       cache_ptr->symbol.section = bfd_und_section_ptr;
1547       cache_ptr->symbol.flags = BSF_WEAK;
1548       break;
1549
1550     case N_WEAKA:
1551       cache_ptr->symbol.section = bfd_abs_section_ptr;
1552       cache_ptr->symbol.flags = BSF_WEAK;
1553       break;
1554
1555     case N_WEAKT:
1556       cache_ptr->symbol.section = obj_textsec (abfd);
1557       cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1558       cache_ptr->symbol.flags = BSF_WEAK;
1559       break;
1560
1561     case N_WEAKD:
1562       cache_ptr->symbol.section = obj_datasec (abfd);
1563       cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1564       cache_ptr->symbol.flags = BSF_WEAK;
1565       break;
1566
1567     case N_WEAKB:
1568       cache_ptr->symbol.section = obj_bsssec (abfd);
1569       cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1570       cache_ptr->symbol.flags = BSF_WEAK;
1571       break;
1572     }
1573
1574   return true;
1575 }
1576
1577 /* Set the fields of SYM_POINTER according to CACHE_PTR.  */
1578
1579 static boolean
1580 translate_to_native_sym_flags (abfd, cache_ptr, sym_pointer)
1581      bfd *abfd;
1582      asymbol *cache_ptr;
1583      struct external_nlist *sym_pointer;
1584 {
1585   bfd_vma value = cache_ptr->value;
1586   asection *sec;
1587   bfd_vma off;
1588
1589   /* Mask out any existing type bits in case copying from one section
1590      to another.  */
1591   sym_pointer->e_type[0] &= ~N_TYPE;
1592
1593   sec = bfd_get_section (cache_ptr);
1594   off = 0;
1595
1596   if (sec == NULL)
1597     {
1598       /* This case occurs, e.g., for the *DEBUG* section of a COFF
1599          file.  */
1600       (*_bfd_error_handler)
1601         ("%s: can not represent section for symbol `%s' in a.out object file format",
1602          bfd_get_filename (abfd),
1603          cache_ptr->name != NULL ? cache_ptr->name : "*unknown*");
1604       bfd_set_error (bfd_error_nonrepresentable_section);
1605       return false;
1606     }
1607
1608   if (sec->output_section != NULL)
1609     {
1610       off = sec->output_offset;
1611       sec = sec->output_section;
1612     }
1613
1614   if (bfd_is_abs_section (sec))
1615     sym_pointer->e_type[0] |= N_ABS;
1616   else if (sec == obj_textsec (abfd))
1617     sym_pointer->e_type[0] |= N_TEXT;
1618   else if (sec == obj_datasec (abfd))
1619     sym_pointer->e_type[0] |= N_DATA;
1620   else if (sec == obj_bsssec (abfd))
1621     sym_pointer->e_type[0] |= N_BSS;
1622   else if (bfd_is_und_section (sec))
1623     sym_pointer->e_type[0] = N_UNDF | N_EXT;
1624   else if (bfd_is_ind_section (sec))
1625     sym_pointer->e_type[0] = N_INDR;
1626   else if (bfd_is_com_section (sec))
1627     sym_pointer->e_type[0] = N_UNDF | N_EXT;
1628   else
1629     {
1630       (*_bfd_error_handler)
1631         ("%s: can not represent section `%s' in a.out object file format",
1632          bfd_get_filename (abfd), bfd_get_section_name (abfd, sec));
1633       bfd_set_error (bfd_error_nonrepresentable_section);
1634       return false;
1635     }
1636
1637   /* Turn the symbol from section relative to absolute again */
1638   value += sec->vma + off;
1639
1640   if ((cache_ptr->flags & BSF_WARNING) != 0)
1641     sym_pointer->e_type[0] = N_WARNING;
1642
1643   if ((cache_ptr->flags & BSF_DEBUGGING) != 0)
1644     sym_pointer->e_type[0] = ((aout_symbol_type *) cache_ptr)->type;
1645   else if ((cache_ptr->flags & BSF_GLOBAL) != 0)
1646     sym_pointer->e_type[0] |= N_EXT;
1647
1648   if ((cache_ptr->flags & BSF_CONSTRUCTOR) != 0)
1649     {
1650       int type = ((aout_symbol_type *) cache_ptr)->type;
1651       switch (type)
1652         {
1653         case N_ABS:     type = N_SETA; break;
1654         case N_TEXT:    type = N_SETT; break;
1655         case N_DATA:    type = N_SETD; break;
1656         case N_BSS:     type = N_SETB; break;
1657         }
1658       sym_pointer->e_type[0] = type;
1659     }
1660
1661   if ((cache_ptr->flags & BSF_WEAK) != 0)
1662     {
1663       int type;
1664
1665       switch (sym_pointer->e_type[0] & N_TYPE)
1666         {
1667         default:
1668         case N_ABS:     type = N_WEAKA; break;
1669         case N_TEXT:    type = N_WEAKT; break;
1670         case N_DATA:    type = N_WEAKD; break;
1671         case N_BSS:     type = N_WEAKB; break;
1672         case N_UNDF:    type = N_WEAKU; break;
1673         }
1674       sym_pointer->e_type[0] = type;
1675     }
1676
1677   PUT_WORD(abfd, value, sym_pointer->e_value);
1678
1679   return true;
1680 }
1681 \f
1682 /* Native-level interface to symbols. */
1683
1684 asymbol *
1685 NAME(aout,make_empty_symbol) (abfd)
1686      bfd *abfd;
1687 {
1688   aout_symbol_type  *new =
1689     (aout_symbol_type *)bfd_zalloc (abfd, sizeof (aout_symbol_type));
1690   if (!new)
1691     return NULL;
1692   new->symbol.the_bfd = abfd;
1693
1694   return &new->symbol;
1695 }
1696
1697 /* Translate a set of internal symbols into external symbols.  */
1698
1699 boolean
1700 NAME(aout,translate_symbol_table) (abfd, in, ext, count, str, strsize, dynamic)
1701      bfd *abfd;
1702      aout_symbol_type *in;
1703      struct external_nlist *ext;
1704      bfd_size_type count;
1705      char *str;
1706      bfd_size_type strsize;
1707      boolean dynamic;
1708 {
1709   struct external_nlist *ext_end;
1710
1711   ext_end = ext + count;
1712   for (; ext < ext_end; ext++, in++)
1713     {
1714       bfd_vma x;
1715
1716       x = GET_WORD (abfd, ext->e_strx);
1717       in->symbol.the_bfd = abfd;
1718
1719       /* For the normal symbols, the zero index points at the number
1720          of bytes in the string table but is to be interpreted as the
1721          null string.  For the dynamic symbols, the number of bytes in
1722          the string table is stored in the __DYNAMIC structure and the
1723          zero index points at an actual string.  */
1724       if (x == 0 && ! dynamic)
1725         in->symbol.name = "";
1726       else if (x < strsize)
1727         in->symbol.name = str + x;
1728       else
1729         return false;
1730
1731       in->symbol.value = GET_SWORD (abfd,  ext->e_value);
1732       in->desc = bfd_h_get_16 (abfd, ext->e_desc);
1733       in->other = bfd_h_get_8 (abfd, ext->e_other);
1734       in->type = bfd_h_get_8 (abfd,  ext->e_type);
1735       in->symbol.udata.p = NULL;
1736
1737       if (! translate_from_native_sym_flags (abfd, in))
1738         return false;
1739
1740       if (dynamic)
1741         in->symbol.flags |= BSF_DYNAMIC;
1742     }
1743
1744   return true;
1745 }
1746
1747 /* We read the symbols into a buffer, which is discarded when this
1748    function exits.  We read the strings into a buffer large enough to
1749    hold them all plus all the cached symbol entries. */
1750
1751 boolean
1752 NAME(aout,slurp_symbol_table) (abfd)
1753      bfd *abfd;
1754 {
1755   struct external_nlist *old_external_syms;
1756   aout_symbol_type *cached;
1757   size_t cached_size;
1758
1759   /* If there's no work to be done, don't do any */
1760   if (obj_aout_symbols (abfd) != (aout_symbol_type *) NULL)
1761     return true;
1762
1763   old_external_syms = obj_aout_external_syms (abfd);
1764
1765   if (! aout_get_external_symbols (abfd))
1766     return false;
1767
1768   cached_size = (obj_aout_external_sym_count (abfd)
1769                  * sizeof (aout_symbol_type));
1770   cached = (aout_symbol_type *) bfd_malloc (cached_size);
1771   if (cached == NULL && cached_size != 0)
1772     return false;
1773   if (cached_size != 0)
1774     memset (cached, 0, cached_size);
1775
1776   /* Convert from external symbol information to internal.  */
1777   if (! (NAME(aout,translate_symbol_table)
1778          (abfd, cached,
1779           obj_aout_external_syms (abfd),
1780           obj_aout_external_sym_count (abfd),
1781           obj_aout_external_strings (abfd),
1782           obj_aout_external_string_size (abfd),
1783           false)))
1784     {
1785       free (cached);
1786       return false;
1787     }
1788
1789   bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
1790
1791   obj_aout_symbols (abfd) = cached;
1792
1793   /* It is very likely that anybody who calls this function will not
1794      want the external symbol information, so if it was allocated
1795      because of our call to aout_get_external_symbols, we free it up
1796      right away to save space.  */
1797   if (old_external_syms == (struct external_nlist *) NULL
1798       && obj_aout_external_syms (abfd) != (struct external_nlist *) NULL)
1799     {
1800 #ifdef USE_MMAP
1801       bfd_free_window (&obj_aout_sym_window (abfd));
1802 #else
1803       free (obj_aout_external_syms (abfd));
1804 #endif
1805       obj_aout_external_syms (abfd) = NULL;
1806     }
1807
1808   return true;
1809 }
1810 \f
1811 /* We use a hash table when writing out symbols so that we only write
1812    out a particular string once.  This helps particularly when the
1813    linker writes out stabs debugging entries, because each different
1814    contributing object file tends to have many duplicate stabs
1815    strings.
1816
1817    This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1818    if BFD_TRADITIONAL_FORMAT is set.  */
1819
1820 static bfd_size_type add_to_stringtab
1821   PARAMS ((bfd *, struct bfd_strtab_hash *, const char *, boolean));
1822 static boolean emit_stringtab PARAMS ((bfd *, struct bfd_strtab_hash *));
1823
1824 /* Get the index of a string in a strtab, adding it if it is not
1825    already present.  */
1826
1827 static INLINE bfd_size_type
1828 add_to_stringtab (abfd, tab, str, copy)
1829      bfd *abfd;
1830      struct bfd_strtab_hash *tab;
1831      const char *str;
1832      boolean copy;
1833 {
1834   boolean hash;
1835   bfd_size_type index;
1836
1837   /* An index of 0 always means the empty string.  */
1838   if (str == 0 || *str == '\0')
1839     return 0;
1840
1841   /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1842      doesn't understand a hashed string table.  */
1843   hash = true;
1844   if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1845     hash = false;
1846
1847   index = _bfd_stringtab_add (tab, str, hash, copy);
1848
1849   if (index != (bfd_size_type) -1)
1850     {
1851       /* Add BYTES_IN_WORD to the return value to account for the
1852          space taken up by the string table size.  */
1853       index += BYTES_IN_WORD;
1854     }
1855
1856   return index;
1857 }
1858
1859 /* Write out a strtab.  ABFD is already at the right location in the
1860    file.  */
1861
1862 static boolean
1863 emit_stringtab (abfd, tab)
1864      register bfd *abfd;
1865      struct bfd_strtab_hash *tab;
1866 {
1867   bfd_byte buffer[BYTES_IN_WORD];
1868
1869   /* The string table starts with the size.  */
1870   PUT_WORD (abfd, _bfd_stringtab_size (tab) + BYTES_IN_WORD, buffer);
1871   if (bfd_write ((PTR) buffer, 1, BYTES_IN_WORD, abfd) != BYTES_IN_WORD)
1872     return false;
1873
1874   return _bfd_stringtab_emit (abfd, tab);
1875 }
1876 \f
1877 boolean
1878 NAME(aout,write_syms) (abfd)
1879      bfd *abfd;
1880 {
1881   unsigned int count ;
1882   asymbol **generic = bfd_get_outsymbols (abfd);
1883   struct bfd_strtab_hash *strtab;
1884
1885   strtab = _bfd_stringtab_init ();
1886   if (strtab == NULL)
1887     return false;
1888
1889   for (count = 0; count < bfd_get_symcount (abfd); count++)
1890     {
1891       asymbol *g = generic[count];
1892       bfd_size_type indx;
1893       struct external_nlist nsp;
1894
1895       indx = add_to_stringtab (abfd, strtab, g->name, false);
1896       if (indx == (bfd_size_type) -1)
1897         goto error_return;
1898       PUT_WORD (abfd, indx, (bfd_byte *) nsp.e_strx);
1899
1900       if (bfd_asymbol_flavour(g) == abfd->xvec->flavour)
1901         {
1902           bfd_h_put_16(abfd, aout_symbol(g)->desc,  nsp.e_desc);
1903           bfd_h_put_8(abfd, aout_symbol(g)->other,  nsp.e_other);
1904           bfd_h_put_8(abfd, aout_symbol(g)->type,  nsp.e_type);
1905         }
1906       else
1907         {
1908           bfd_h_put_16(abfd,0, nsp.e_desc);
1909           bfd_h_put_8(abfd, 0, nsp.e_other);
1910           bfd_h_put_8(abfd, 0, nsp.e_type);
1911         }
1912
1913       if (! translate_to_native_sym_flags (abfd, g, &nsp))
1914         goto error_return;
1915
1916       if (bfd_write((PTR)&nsp,1,EXTERNAL_NLIST_SIZE, abfd)
1917           != EXTERNAL_NLIST_SIZE)
1918         goto error_return;
1919
1920       /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1921          here, at the end.  */
1922       g->KEEPIT = count;
1923     }
1924
1925   if (! emit_stringtab (abfd, strtab))
1926     goto error_return;
1927
1928   _bfd_stringtab_free (strtab);
1929
1930   return true;
1931
1932 error_return:
1933   _bfd_stringtab_free (strtab);
1934   return false;
1935 }
1936
1937 \f
1938 long
1939 NAME(aout,get_symtab) (abfd, location)
1940      bfd *abfd;
1941      asymbol **location;
1942 {
1943     unsigned int counter = 0;
1944     aout_symbol_type *symbase;
1945
1946     if (!NAME(aout,slurp_symbol_table)(abfd))
1947       return -1;
1948
1949     for (symbase = obj_aout_symbols(abfd); counter++ < bfd_get_symcount (abfd);)
1950       *(location++) = (asymbol *)( symbase++);
1951     *location++ =0;
1952     return bfd_get_symcount (abfd);
1953 }
1954
1955 \f
1956 /* Standard reloc stuff */
1957 /* Output standard relocation information to a file in target byte order. */
1958
1959 extern void  NAME(aout,swap_std_reloc_out)
1960   PARAMS ((bfd *, arelent *, struct reloc_std_external *));
1961
1962 void
1963 NAME(aout,swap_std_reloc_out) (abfd, g, natptr)
1964      bfd *abfd;
1965      arelent *g;
1966      struct reloc_std_external *natptr;
1967 {
1968   int r_index;
1969   asymbol *sym = *(g->sym_ptr_ptr);
1970   int r_extern;
1971   unsigned int r_length;
1972   int r_pcrel;
1973   int r_baserel, r_jmptable, r_relative;
1974   asection *output_section = sym->section->output_section;
1975
1976   PUT_WORD(abfd, g->address, natptr->r_address);
1977
1978   r_length = g->howto->size ;   /* Size as a power of two */
1979   r_pcrel  = (int) g->howto->pc_relative; /* Relative to PC? */
1980   /* XXX This relies on relocs coming from a.out files.  */
1981   r_baserel = (g->howto->type & 8) != 0;
1982   r_jmptable = (g->howto->type & 16) != 0;
1983   r_relative = (g->howto->type & 32) != 0;
1984
1985 #if 0
1986   /* For a standard reloc, the addend is in the object file.  */
1987   r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
1988 #endif
1989
1990   /* name was clobbered by aout_write_syms to be symbol index */
1991
1992   /* If this relocation is relative to a symbol then set the
1993      r_index to the symbols index, and the r_extern bit.
1994
1995      Absolute symbols can come in in two ways, either as an offset
1996      from the abs section, or as a symbol which has an abs value.
1997      check for that here
1998      */
1999
2000
2001   if (bfd_is_com_section (output_section)
2002       || bfd_is_abs_section (output_section)
2003       || bfd_is_und_section (output_section))
2004     {
2005       if (bfd_abs_section_ptr->symbol == sym)
2006       {
2007         /* Whoops, looked like an abs symbol, but is really an offset
2008            from the abs section */
2009         r_index = N_ABS;
2010         r_extern = 0;
2011        }
2012       else
2013       {
2014         /* Fill in symbol */
2015         r_extern = 1;
2016         r_index = (*(g->sym_ptr_ptr))->KEEPIT;
2017
2018       }
2019     }
2020   else
2021     {
2022       /* Just an ordinary section */
2023       r_extern = 0;
2024       r_index  = output_section->target_index;
2025     }
2026
2027   /* now the fun stuff */
2028   if (bfd_header_big_endian (abfd)) {
2029       natptr->r_index[0] = r_index >> 16;
2030       natptr->r_index[1] = r_index >> 8;
2031       natptr->r_index[2] = r_index;
2032       natptr->r_type[0] =
2033        (r_extern?    RELOC_STD_BITS_EXTERN_BIG: 0)
2034         | (r_pcrel?     RELOC_STD_BITS_PCREL_BIG: 0)
2035          | (r_baserel?   RELOC_STD_BITS_BASEREL_BIG: 0)
2036           | (r_jmptable?  RELOC_STD_BITS_JMPTABLE_BIG: 0)
2037            | (r_relative?  RELOC_STD_BITS_RELATIVE_BIG: 0)
2038             | (r_length <<  RELOC_STD_BITS_LENGTH_SH_BIG);
2039     } else {
2040         natptr->r_index[2] = r_index >> 16;
2041         natptr->r_index[1] = r_index >> 8;
2042         natptr->r_index[0] = r_index;
2043         natptr->r_type[0] =
2044          (r_extern?    RELOC_STD_BITS_EXTERN_LITTLE: 0)
2045           | (r_pcrel?     RELOC_STD_BITS_PCREL_LITTLE: 0)
2046            | (r_baserel?   RELOC_STD_BITS_BASEREL_LITTLE: 0)
2047             | (r_jmptable?  RELOC_STD_BITS_JMPTABLE_LITTLE: 0)
2048              | (r_relative?  RELOC_STD_BITS_RELATIVE_LITTLE: 0)
2049               | (r_length <<  RELOC_STD_BITS_LENGTH_SH_LITTLE);
2050       }
2051 }
2052
2053
2054 /* Extended stuff */
2055 /* Output extended relocation information to a file in target byte order. */
2056
2057 extern void NAME(aout,swap_ext_reloc_out)
2058   PARAMS ((bfd *, arelent *, struct reloc_ext_external *));
2059
2060 void
2061 NAME(aout,swap_ext_reloc_out) (abfd, g, natptr)
2062      bfd *abfd;
2063      arelent *g;
2064      register struct reloc_ext_external *natptr;
2065 {
2066   int r_index;
2067   int r_extern;
2068   unsigned int r_type;
2069   unsigned int r_addend;
2070   asymbol *sym = *(g->sym_ptr_ptr);
2071   asection *output_section = sym->section->output_section;
2072
2073   PUT_WORD (abfd, g->address, natptr->r_address);
2074
2075   r_type = (unsigned int) g->howto->type;
2076
2077   r_addend = g->addend;
2078   if ((sym->flags & BSF_SECTION_SYM) != 0)
2079     r_addend += (*(g->sym_ptr_ptr))->section->output_section->vma;
2080
2081   /* If this relocation is relative to a symbol then set the
2082      r_index to the symbols index, and the r_extern bit.
2083
2084      Absolute symbols can come in in two ways, either as an offset
2085      from the abs section, or as a symbol which has an abs value.
2086      check for that here.  */
2087
2088   if (bfd_is_abs_section (bfd_get_section (sym)))
2089     {
2090       r_extern = 0;
2091       r_index = N_ABS;
2092     }
2093   else if ((sym->flags & BSF_SECTION_SYM) == 0)
2094     {
2095       if (bfd_is_und_section (bfd_get_section (sym))
2096           || (sym->flags & BSF_GLOBAL) != 0)
2097         r_extern = 1;
2098       else
2099         r_extern = 0;
2100       r_index = (*(g->sym_ptr_ptr))->KEEPIT;
2101     }
2102   else
2103     {
2104       /* Just an ordinary section */
2105       r_extern = 0;
2106       r_index = output_section->target_index;
2107     }
2108
2109   /* now the fun stuff */
2110   if (bfd_header_big_endian (abfd)) {
2111     natptr->r_index[0] = r_index >> 16;
2112     natptr->r_index[1] = r_index >> 8;
2113     natptr->r_index[2] = r_index;
2114     natptr->r_type[0] =
2115       ((r_extern? RELOC_EXT_BITS_EXTERN_BIG: 0)
2116        | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG));
2117   } else {
2118     natptr->r_index[2] = r_index >> 16;
2119     natptr->r_index[1] = r_index >> 8;
2120     natptr->r_index[0] = r_index;
2121     natptr->r_type[0] =
2122      (r_extern? RELOC_EXT_BITS_EXTERN_LITTLE: 0)
2123       | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
2124   }
2125
2126   PUT_WORD (abfd, r_addend, natptr->r_addend);
2127 }
2128
2129 /* BFD deals internally with all things based from the section they're
2130    in. so, something in 10 bytes into a text section  with a base of
2131    50 would have a symbol (.text+10) and know .text vma was 50.
2132
2133    Aout keeps all it's symbols based from zero, so the symbol would
2134    contain 60. This macro subs the base of each section from the value
2135    to give the true offset from the section */
2136
2137
2138 #define MOVE_ADDRESS(ad)                                                \
2139   if (r_extern) {                                                       \
2140    /* undefined symbol */                                               \
2141      cache_ptr->sym_ptr_ptr = symbols + r_index;                        \
2142      cache_ptr->addend = ad;                                            \
2143      } else {                                                           \
2144     /* defined, section relative. replace symbol with pointer to        \
2145        symbol which points to section  */                               \
2146     switch (r_index) {                                                  \
2147     case N_TEXT:                                                        \
2148     case N_TEXT | N_EXT:                                                \
2149       cache_ptr->sym_ptr_ptr  = obj_textsec(abfd)->symbol_ptr_ptr;      \
2150       cache_ptr->addend = ad  - su->textsec->vma;                       \
2151       break;                                                            \
2152     case N_DATA:                                                        \
2153     case N_DATA | N_EXT:                                                \
2154       cache_ptr->sym_ptr_ptr  = obj_datasec(abfd)->symbol_ptr_ptr;      \
2155       cache_ptr->addend = ad - su->datasec->vma;                        \
2156       break;                                                            \
2157     case N_BSS:                                                         \
2158     case N_BSS | N_EXT:                                                 \
2159       cache_ptr->sym_ptr_ptr  = obj_bsssec(abfd)->symbol_ptr_ptr;       \
2160       cache_ptr->addend = ad - su->bsssec->vma;                         \
2161       break;                                                            \
2162     default:                                                            \
2163     case N_ABS:                                                         \
2164     case N_ABS | N_EXT:                                                 \
2165      cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;      \
2166       cache_ptr->addend = ad;                                           \
2167       break;                                                            \
2168     }                                                                   \
2169   }                                                                     \
2170
2171 void
2172 NAME(aout,swap_ext_reloc_in) (abfd, bytes, cache_ptr, symbols, symcount)
2173      bfd *abfd;
2174      struct reloc_ext_external *bytes;
2175      arelent *cache_ptr;
2176      asymbol **symbols;
2177      bfd_size_type symcount;
2178 {
2179   unsigned int r_index;
2180   int r_extern;
2181   unsigned int r_type;
2182   struct aoutdata *su = &(abfd->tdata.aout_data->a);
2183
2184   cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
2185
2186   /* now the fun stuff */
2187   if (bfd_header_big_endian (abfd)) {
2188     r_index =  (bytes->r_index[0] << 16)
2189              | (bytes->r_index[1] << 8)
2190              |  bytes->r_index[2];
2191     r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
2192     r_type   =       (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
2193                                       >> RELOC_EXT_BITS_TYPE_SH_BIG;
2194   } else {
2195     r_index =  (bytes->r_index[2] << 16)
2196              | (bytes->r_index[1] << 8)
2197              |  bytes->r_index[0];
2198     r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
2199     r_type   =       (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
2200                                       >> RELOC_EXT_BITS_TYPE_SH_LITTLE;
2201   }
2202
2203   cache_ptr->howto =  howto_table_ext + r_type;
2204
2205   /* Base relative relocs are always against the symbol table,
2206      regardless of the setting of r_extern.  r_extern just reflects
2207      whether the symbol the reloc is against is local or global.  */
2208   if (r_type == RELOC_BASE10
2209       || r_type == RELOC_BASE13
2210       || r_type == RELOC_BASE22)
2211     r_extern = 1;
2212
2213   if (r_extern && r_index > symcount)
2214     {
2215       /* We could arrange to return an error, but it might be useful
2216          to see the file even if it is bad.  */
2217       r_extern = 0;
2218       r_index = N_ABS;
2219     }
2220
2221   MOVE_ADDRESS(GET_SWORD(abfd, bytes->r_addend));
2222 }
2223
2224 void
2225 NAME(aout,swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols, symcount)
2226      bfd *abfd;
2227      struct reloc_std_external *bytes;
2228      arelent *cache_ptr;
2229      asymbol **symbols;
2230      bfd_size_type symcount;
2231 {
2232   unsigned int r_index;
2233   int r_extern;
2234   unsigned int r_length;
2235   int r_pcrel;
2236   int r_baserel, r_jmptable, r_relative;
2237   struct aoutdata  *su = &(abfd->tdata.aout_data->a);
2238   unsigned int howto_idx;
2239
2240   cache_ptr->address = bfd_h_get_32 (abfd, bytes->r_address);
2241
2242   /* now the fun stuff */
2243   if (bfd_header_big_endian (abfd)) {
2244     r_index =  (bytes->r_index[0] << 16)
2245       | (bytes->r_index[1] << 8)
2246         |  bytes->r_index[2];
2247     r_extern  = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
2248     r_pcrel   = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
2249     r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
2250     r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
2251     r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
2252     r_length  =       (bytes->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
2253                         >> RELOC_STD_BITS_LENGTH_SH_BIG;
2254   } else {
2255     r_index =  (bytes->r_index[2] << 16)
2256       | (bytes->r_index[1] << 8)
2257         |  bytes->r_index[0];
2258     r_extern  = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
2259     r_pcrel   = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
2260     r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
2261     r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
2262     r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_LITTLE));
2263     r_length  =       (bytes->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
2264                         >> RELOC_STD_BITS_LENGTH_SH_LITTLE;
2265   }
2266
2267   howto_idx = r_length + 4 * r_pcrel + 8 * r_baserel
2268               + 16 * r_jmptable + 32 * r_relative;
2269   BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_std));
2270   cache_ptr->howto =  howto_table_std + howto_idx;
2271   BFD_ASSERT (cache_ptr->howto->type != (unsigned int) -1);
2272
2273   /* Base relative relocs are always against the symbol table,
2274      regardless of the setting of r_extern.  r_extern just reflects
2275      whether the symbol the reloc is against is local or global.  */
2276   if (r_baserel)
2277     r_extern = 1;
2278
2279   if (r_extern && r_index > symcount)
2280     {
2281       /* We could arrange to return an error, but it might be useful
2282          to see the file even if it is bad.  */
2283       r_extern = 0;
2284       r_index = N_ABS;
2285     }
2286
2287   MOVE_ADDRESS(0);
2288 }
2289
2290 /* Read and swap the relocs for a section.  */
2291
2292 boolean
2293 NAME(aout,slurp_reloc_table) (abfd, asect, symbols)
2294      bfd *abfd;
2295      sec_ptr asect;
2296      asymbol **symbols;
2297 {
2298   unsigned int count;
2299   bfd_size_type reloc_size;
2300   PTR relocs;
2301   arelent *reloc_cache;
2302   size_t each_size;
2303   unsigned int counter = 0;
2304   arelent *cache_ptr;
2305
2306   if (asect->relocation)
2307     return true;
2308
2309   if (asect->flags & SEC_CONSTRUCTOR)
2310     return true;
2311
2312   if (asect == obj_datasec (abfd))
2313     reloc_size = exec_hdr(abfd)->a_drsize;
2314   else if (asect == obj_textsec (abfd))
2315     reloc_size = exec_hdr(abfd)->a_trsize;
2316   else if (asect == obj_bsssec (abfd))
2317     reloc_size = 0;
2318   else
2319     {
2320       bfd_set_error (bfd_error_invalid_operation);
2321       return false;
2322     }
2323
2324   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
2325     return false;
2326
2327   each_size = obj_reloc_entry_size (abfd);
2328
2329   count = reloc_size / each_size;
2330
2331   reloc_cache = (arelent *) bfd_malloc ((size_t) (count * sizeof (arelent)));
2332   if (reloc_cache == NULL && count != 0)
2333     return false;
2334   memset (reloc_cache, 0, count * sizeof (arelent));
2335
2336   relocs = bfd_malloc ((size_t) reloc_size);
2337   if (relocs == NULL && reloc_size != 0)
2338     {
2339       free (reloc_cache);
2340       return false;
2341     }
2342
2343   if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size)
2344     {
2345       free (relocs);
2346       free (reloc_cache);
2347       return false;
2348     }
2349
2350   cache_ptr = reloc_cache;
2351   if (each_size == RELOC_EXT_SIZE)
2352     {
2353       register struct reloc_ext_external *rptr =
2354         (struct reloc_ext_external *) relocs;
2355
2356       for (; counter < count; counter++, rptr++, cache_ptr++)
2357         NAME(aout,swap_ext_reloc_in) (abfd, rptr, cache_ptr, symbols,
2358                                       bfd_get_symcount (abfd));
2359     }
2360   else
2361     {
2362       register struct reloc_std_external *rptr =
2363         (struct reloc_std_external *) relocs;
2364
2365       for (; counter < count; counter++, rptr++, cache_ptr++)
2366         MY_swap_std_reloc_in (abfd, rptr, cache_ptr, symbols,
2367                               bfd_get_symcount (abfd));
2368     }
2369
2370   free (relocs);
2371
2372   asect->relocation = reloc_cache;
2373   asect->reloc_count = cache_ptr - reloc_cache;
2374
2375   return true;
2376 }
2377
2378 /* Write out a relocation section into an object file.  */
2379
2380 boolean
2381 NAME(aout,squirt_out_relocs) (abfd, section)
2382      bfd *abfd;
2383      asection *section;
2384 {
2385   arelent **generic;
2386   unsigned char *native, *natptr;
2387   size_t each_size;
2388
2389   unsigned int count = section->reloc_count;
2390   size_t natsize;
2391
2392   if (count == 0 || section->orelocation == NULL)
2393     return true;
2394
2395   each_size = obj_reloc_entry_size (abfd);
2396   natsize = each_size * count;
2397   native = (unsigned char *) bfd_zalloc (abfd, natsize);
2398   if (!native)
2399     return false;
2400
2401   generic = section->orelocation;
2402
2403   if (each_size == RELOC_EXT_SIZE)
2404     {
2405       for (natptr = native;
2406            count != 0;
2407            --count, natptr += each_size, ++generic)
2408         NAME(aout,swap_ext_reloc_out) (abfd, *generic, (struct reloc_ext_external *)natptr);
2409     }
2410   else
2411     {
2412       for (natptr = native;
2413            count != 0;
2414            --count, natptr += each_size, ++generic)
2415         MY_swap_std_reloc_out(abfd, *generic, (struct reloc_std_external *)natptr);
2416     }
2417
2418   if ( bfd_write ((PTR) native, 1, natsize, abfd) != natsize) {
2419     bfd_release(abfd, native);
2420     return false;
2421   }
2422   bfd_release (abfd, native);
2423
2424   return true;
2425 }
2426
2427 /* This is stupid.  This function should be a boolean predicate */
2428 long
2429 NAME(aout,canonicalize_reloc) (abfd, section, relptr, symbols)
2430      bfd *abfd;
2431      sec_ptr section;
2432      arelent **relptr;
2433      asymbol **symbols;
2434 {
2435   arelent *tblptr = section->relocation;
2436   unsigned int count;
2437
2438   if (section == obj_bsssec (abfd))
2439     {
2440       *relptr = NULL;
2441       return 0;
2442     }
2443
2444   if (!(tblptr || NAME(aout,slurp_reloc_table)(abfd, section, symbols)))
2445     return -1;
2446
2447   if (section->flags & SEC_CONSTRUCTOR) {
2448     arelent_chain *chain = section->constructor_chain;
2449     for (count = 0; count < section->reloc_count; count ++) {
2450       *relptr ++ = &chain->relent;
2451       chain = chain->next;
2452     }
2453   }
2454   else {
2455     tblptr = section->relocation;
2456
2457     for (count = 0; count++ < section->reloc_count;)
2458       {
2459         *relptr++ = tblptr++;
2460       }
2461   }
2462   *relptr = 0;
2463
2464   return section->reloc_count;
2465 }
2466
2467 long
2468 NAME(aout,get_reloc_upper_bound) (abfd, asect)
2469      bfd *abfd;
2470      sec_ptr asect;
2471 {
2472   if (bfd_get_format (abfd) != bfd_object) {
2473     bfd_set_error (bfd_error_invalid_operation);
2474     return -1;
2475   }
2476   if (asect->flags & SEC_CONSTRUCTOR) {
2477     return (sizeof (arelent *) * (asect->reloc_count+1));
2478   }
2479
2480   if (asect == obj_datasec (abfd))
2481     return (sizeof (arelent *)
2482             * ((exec_hdr(abfd)->a_drsize / obj_reloc_entry_size (abfd))
2483                + 1));
2484
2485   if (asect == obj_textsec (abfd))
2486     return (sizeof (arelent *)
2487             * ((exec_hdr(abfd)->a_trsize / obj_reloc_entry_size (abfd))
2488                + 1));
2489
2490   if (asect == obj_bsssec (abfd))
2491     return sizeof (arelent *);
2492
2493   if (asect == obj_bsssec (abfd))
2494     return 0;
2495
2496   bfd_set_error (bfd_error_invalid_operation);
2497   return -1;
2498 }
2499
2500 \f
2501 long
2502 NAME(aout,get_symtab_upper_bound) (abfd)
2503      bfd *abfd;
2504 {
2505   if (!NAME(aout,slurp_symbol_table)(abfd))
2506     return -1;
2507
2508   return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *));
2509 }
2510
2511 /*ARGSUSED*/
2512  alent *
2513 NAME(aout,get_lineno) (ignore_abfd, ignore_symbol)
2514      bfd *ignore_abfd;
2515      asymbol *ignore_symbol;
2516 {
2517 return (alent *)NULL;
2518 }
2519
2520 /*ARGSUSED*/
2521 void
2522 NAME(aout,get_symbol_info) (ignore_abfd, symbol, ret)
2523      bfd *ignore_abfd;
2524      asymbol *symbol;
2525      symbol_info *ret;
2526 {
2527   bfd_symbol_info (symbol, ret);
2528
2529   if (ret->type == '?')
2530     {
2531       int type_code = aout_symbol(symbol)->type & 0xff;
2532       const char *stab_name = bfd_get_stab_name (type_code);
2533       static char buf[10];
2534
2535       if (stab_name == NULL)
2536         {
2537           sprintf(buf, "(%d)", type_code);
2538           stab_name = buf;
2539         }
2540       ret->type = '-';
2541       ret->stab_type = type_code;
2542       ret->stab_other = (unsigned)(aout_symbol(symbol)->other & 0xff);
2543       ret->stab_desc = (unsigned)(aout_symbol(symbol)->desc & 0xffff);
2544       ret->stab_name = stab_name;
2545     }
2546 }
2547
2548 /*ARGSUSED*/
2549 void
2550 NAME(aout,print_symbol) (ignore_abfd, afile, symbol, how)
2551      bfd *ignore_abfd;
2552      PTR afile;
2553      asymbol *symbol;
2554      bfd_print_symbol_type how;
2555 {
2556   FILE *file = (FILE *)afile;
2557
2558   switch (how) {
2559   case bfd_print_symbol_name:
2560     if (symbol->name)
2561       fprintf(file,"%s", symbol->name);
2562     break;
2563   case bfd_print_symbol_more:
2564     fprintf(file,"%4x %2x %2x",(unsigned)(aout_symbol(symbol)->desc & 0xffff),
2565             (unsigned)(aout_symbol(symbol)->other & 0xff),
2566             (unsigned)(aout_symbol(symbol)->type));
2567     break;
2568   case bfd_print_symbol_all:
2569     {
2570    CONST char *section_name = symbol->section->name;
2571
2572
2573       bfd_print_symbol_vandf((PTR)file,symbol);
2574
2575       fprintf(file," %-5s %04x %02x %02x",
2576               section_name,
2577               (unsigned)(aout_symbol(symbol)->desc & 0xffff),
2578               (unsigned)(aout_symbol(symbol)->other & 0xff),
2579               (unsigned)(aout_symbol(symbol)->type  & 0xff));
2580       if (symbol->name)
2581         fprintf(file," %s", symbol->name);
2582     }
2583     break;
2584   }
2585 }
2586
2587 /* If we don't have to allocate more than 1MB to hold the generic
2588    symbols, we use the generic minisymbol methord: it's faster, since
2589    it only translates the symbols once, not multiple times.  */
2590 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2591
2592 /* Read minisymbols.  For minisymbols, we use the unmodified a.out
2593    symbols.  The minisymbol_to_symbol function translates these into
2594    BFD asymbol structures.  */
2595
2596 long
2597 NAME(aout,read_minisymbols) (abfd, dynamic, minisymsp, sizep)
2598      bfd *abfd;
2599      boolean dynamic;
2600      PTR *minisymsp;
2601      unsigned int *sizep;
2602 {
2603   if (dynamic)
2604     {
2605       /* We could handle the dynamic symbols here as well, but it's
2606          easier to hand them off.  */
2607       return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2608     }
2609
2610   if (! aout_get_external_symbols (abfd))
2611     return -1;
2612
2613   if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2614     return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2615
2616   *minisymsp = (PTR) obj_aout_external_syms (abfd);
2617
2618   /* By passing the external symbols back from this routine, we are
2619      giving up control over the memory block.  Clear
2620      obj_aout_external_syms, so that we do not try to free it
2621      ourselves.  */
2622   obj_aout_external_syms (abfd) = NULL;
2623
2624   *sizep = EXTERNAL_NLIST_SIZE;
2625   return obj_aout_external_sym_count (abfd);
2626 }
2627
2628 /* Convert a minisymbol to a BFD asymbol.  A minisymbol is just an
2629    unmodified a.out symbol.  The SYM argument is a structure returned
2630    by bfd_make_empty_symbol, which we fill in here.  */
2631
2632 asymbol *
2633 NAME(aout,minisymbol_to_symbol) (abfd, dynamic, minisym, sym)
2634      bfd *abfd;
2635      boolean dynamic;
2636      const PTR minisym;
2637      asymbol *sym;
2638 {
2639   if (dynamic
2640       || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2641     return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
2642
2643   memset (sym, 0, sizeof (aout_symbol_type));
2644
2645   /* We call translate_symbol_table to translate a single symbol.  */
2646   if (! (NAME(aout,translate_symbol_table)
2647          (abfd,
2648           (aout_symbol_type *) sym,
2649           (struct external_nlist *) minisym,
2650           (bfd_size_type) 1,
2651           obj_aout_external_strings (abfd),
2652           obj_aout_external_string_size (abfd),
2653           false)))
2654     return NULL;
2655
2656   return sym;
2657 }
2658
2659 /*
2660  provided a BFD, a section and an offset into the section, calculate
2661  and return the name of the source file and the line nearest to the
2662  wanted location.
2663 */
2664
2665 boolean
2666 NAME(aout,find_nearest_line)
2667      (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2668      bfd *abfd;
2669      asection *section;
2670      asymbol **symbols;
2671      bfd_vma offset;
2672      CONST char **filename_ptr;
2673      CONST char **functionname_ptr;
2674      unsigned int *line_ptr;
2675 {
2676   /* Run down the file looking for the filename, function and linenumber */
2677   asymbol **p;
2678   CONST char *directory_name = NULL;
2679   CONST char *main_file_name = NULL;
2680   CONST char *current_file_name = NULL;
2681   CONST char *line_file_name = NULL; /* Value of current_file_name at line number. */
2682   bfd_vma low_line_vma = 0;
2683   bfd_vma low_func_vma = 0;
2684   asymbol *func = 0;
2685   size_t filelen, funclen;
2686   char *buf;
2687
2688   *filename_ptr = abfd->filename;
2689   *functionname_ptr = 0;
2690   *line_ptr = 0;
2691   if (symbols != (asymbol **)NULL) {
2692     for (p = symbols; *p; p++) {
2693       aout_symbol_type  *q = (aout_symbol_type *)(*p);
2694     next:
2695       switch (q->type){
2696       case N_TEXT:
2697         /* If this looks like a file name symbol, and it comes after
2698            the line number we have found so far, but before the
2699            offset, then we have probably not found the right line
2700            number.  */
2701         if (q->symbol.value <= offset
2702             && ((q->symbol.value > low_line_vma
2703                  && (line_file_name != NULL
2704                      || *line_ptr != 0))
2705                 || (q->symbol.value > low_func_vma
2706                     && func != NULL)))
2707           {
2708             const char *symname;
2709
2710             symname = q->symbol.name;
2711             if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
2712               {
2713                 if (q->symbol.value > low_line_vma)
2714                   {
2715                     *line_ptr = 0;
2716                     line_file_name = NULL;
2717                   }
2718                 if (q->symbol.value > low_func_vma)
2719                   func = NULL;
2720               }
2721           }
2722         break;
2723
2724       case N_SO:
2725         /* If this symbol is less than the offset, but greater than
2726            the line number we have found so far, then we have not
2727            found the right line number.  */
2728         if (q->symbol.value <= offset)
2729           {
2730             if (q->symbol.value > low_line_vma)
2731               {
2732                 *line_ptr = 0;
2733                 line_file_name = NULL;
2734               }
2735             if (q->symbol.value > low_func_vma)
2736               func = NULL;
2737           }
2738
2739         main_file_name = current_file_name = q->symbol.name;
2740         /* Look ahead to next symbol to check if that too is an N_SO. */
2741         p++;
2742         if (*p == NULL)
2743           break;
2744         q = (aout_symbol_type *)(*p);
2745         if (q->type != (int)N_SO)
2746           goto next;
2747
2748         /* Found a second N_SO  First is directory; second is filename. */
2749         directory_name = current_file_name;
2750         main_file_name = current_file_name = q->symbol.name;
2751         if (obj_textsec(abfd) != section)
2752           goto done;
2753         break;
2754       case N_SOL:
2755         current_file_name = q->symbol.name;
2756         break;
2757
2758       case N_SLINE:
2759
2760       case N_DSLINE:
2761       case N_BSLINE:
2762         /* We'll keep this if it resolves nearer than the one we have
2763            already.  */
2764         if (q->symbol.value >= low_line_vma
2765             && q->symbol.value <= offset)
2766           {
2767             *line_ptr = q->desc;
2768             low_line_vma = q->symbol.value;
2769             line_file_name = current_file_name;
2770           }
2771         break;
2772       case N_FUN:
2773         {
2774           /* We'll keep this if it is nearer than the one we have already */
2775           if (q->symbol.value >= low_func_vma &&
2776               q->symbol.value <= offset) {
2777             low_func_vma = q->symbol.value;
2778             func = (asymbol *)q;
2779           }
2780           else if (q->symbol.value > offset)
2781             goto done;
2782         }
2783         break;
2784       }
2785     }
2786   }
2787
2788  done:
2789   if (*line_ptr != 0)
2790     main_file_name = line_file_name;
2791
2792   if (main_file_name == NULL
2793       || main_file_name[0] == '/'
2794       || directory_name == NULL)
2795     filelen = 0;
2796   else
2797     filelen = strlen (directory_name) + strlen (main_file_name);
2798   if (func == NULL)
2799     funclen = 0;
2800   else
2801     funclen = strlen (bfd_asymbol_name (func));
2802
2803   if (adata (abfd).line_buf != NULL)
2804     free (adata (abfd).line_buf);
2805   if (filelen + funclen == 0)
2806     adata (abfd).line_buf = buf = NULL;
2807   else
2808     {
2809       buf = (char *) bfd_malloc (filelen + funclen + 3);
2810       adata (abfd).line_buf = buf;
2811       if (buf == NULL)
2812         return false;
2813     }
2814
2815   if (main_file_name != NULL)
2816     {
2817       if (main_file_name[0] == '/' || directory_name == NULL)
2818         *filename_ptr = main_file_name;
2819       else
2820         {
2821           sprintf (buf, "%s%s", directory_name, main_file_name);
2822           *filename_ptr = buf;
2823           buf += filelen + 1;
2824         }
2825     }
2826
2827   if (func)
2828     {
2829       const char *function = func->name;
2830       char *p;
2831
2832       /* The caller expects a symbol name.  We actually have a
2833          function name, without the leading underscore.  Put the
2834          underscore back in, so that the caller gets a symbol name.  */
2835       if (bfd_get_symbol_leading_char (abfd) == '\0')
2836         strcpy (buf, function);
2837       else
2838         {
2839           buf[0] = bfd_get_symbol_leading_char (abfd);
2840           strcpy (buf + 1, function);
2841         }
2842       /* Have to remove : stuff */
2843       p = strchr (buf, ':');
2844       if (p != NULL)
2845         *p = '\0';
2846       *functionname_ptr = buf;
2847     }
2848
2849   return true;
2850 }
2851
2852 /*ARGSUSED*/
2853 int
2854 NAME(aout,sizeof_headers) (abfd, execable)
2855      bfd *abfd;
2856      boolean execable;
2857 {
2858   return adata(abfd).exec_bytes_size;
2859 }
2860
2861 /* Free all information we have cached for this BFD.  We can always
2862    read it again later if we need it.  */
2863
2864 boolean
2865 NAME(aout,bfd_free_cached_info) (abfd)
2866      bfd *abfd;
2867 {
2868   asection *o;
2869
2870   if (bfd_get_format (abfd) != bfd_object)
2871     return true;
2872
2873 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2874   BFCI_FREE (obj_aout_symbols (abfd));
2875 #ifdef USE_MMAP
2876   obj_aout_external_syms (abfd) = 0;
2877   bfd_free_window (&obj_aout_sym_window (abfd));
2878   bfd_free_window (&obj_aout_string_window (abfd));
2879   obj_aout_external_strings (abfd) = 0;
2880 #else
2881   BFCI_FREE (obj_aout_external_syms (abfd));
2882   BFCI_FREE (obj_aout_external_strings (abfd));
2883 #endif
2884   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
2885     BFCI_FREE (o->relocation);
2886 #undef BFCI_FREE
2887
2888   return true;
2889 }
2890 \f
2891 /* a.out link code.  */
2892
2893 static boolean aout_link_add_object_symbols
2894   PARAMS ((bfd *, struct bfd_link_info *));
2895 static boolean aout_link_check_archive_element
2896   PARAMS ((bfd *, struct bfd_link_info *, boolean *));
2897 static boolean aout_link_free_symbols PARAMS ((bfd *));
2898 static boolean aout_link_check_ar_symbols
2899   PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
2900 static boolean aout_link_add_symbols
2901   PARAMS ((bfd *, struct bfd_link_info *));
2902
2903 /* Routine to create an entry in an a.out link hash table.  */
2904
2905 struct bfd_hash_entry *
2906 NAME(aout,link_hash_newfunc) (entry, table, string)
2907      struct bfd_hash_entry *entry;
2908      struct bfd_hash_table *table;
2909      const char *string;
2910 {
2911   struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2912
2913   /* Allocate the structure if it has not already been allocated by a
2914      subclass.  */
2915   if (ret == (struct aout_link_hash_entry *) NULL)
2916     ret = ((struct aout_link_hash_entry *)
2917            bfd_hash_allocate (table, sizeof (struct aout_link_hash_entry)));
2918   if (ret == (struct aout_link_hash_entry *) NULL)
2919     return (struct bfd_hash_entry *) ret;
2920
2921   /* Call the allocation method of the superclass.  */
2922   ret = ((struct aout_link_hash_entry *)
2923          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2924                                  table, string));
2925   if (ret)
2926     {
2927       /* Set local fields.  */
2928       ret->written = false;
2929       ret->indx = -1;
2930     }
2931
2932   return (struct bfd_hash_entry *) ret;
2933 }
2934
2935 /* Initialize an a.out link hash table.  */
2936
2937 boolean
2938 NAME(aout,link_hash_table_init) (table, abfd, newfunc)
2939      struct aout_link_hash_table *table;
2940      bfd *abfd;
2941      struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
2942                                                 struct bfd_hash_table *,
2943                                                 const char *));
2944 {
2945   return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
2946 }
2947
2948 /* Create an a.out link hash table.  */
2949
2950 struct bfd_link_hash_table *
2951 NAME(aout,link_hash_table_create) (abfd)
2952      bfd *abfd;
2953 {
2954   struct aout_link_hash_table *ret;
2955
2956   ret = ((struct aout_link_hash_table *)
2957          bfd_alloc (abfd, sizeof (struct aout_link_hash_table)));
2958   if (ret == NULL)
2959     return (struct bfd_link_hash_table *) NULL;
2960   if (! NAME(aout,link_hash_table_init) (ret, abfd,
2961                                          NAME(aout,link_hash_newfunc)))
2962     {
2963       free (ret);
2964       return (struct bfd_link_hash_table *) NULL;
2965     }
2966   return &ret->root;
2967 }
2968
2969 /* Given an a.out BFD, add symbols to the global hash table as
2970    appropriate.  */
2971
2972 boolean
2973 NAME(aout,link_add_symbols) (abfd, info)
2974      bfd *abfd;
2975      struct bfd_link_info *info;
2976 {
2977   switch (bfd_get_format (abfd))
2978     {
2979     case bfd_object:
2980       return aout_link_add_object_symbols (abfd, info);
2981     case bfd_archive:
2982       return _bfd_generic_link_add_archive_symbols
2983         (abfd, info, aout_link_check_archive_element);
2984     default:
2985       bfd_set_error (bfd_error_wrong_format);
2986       return false;
2987     }
2988 }
2989
2990 /* Add symbols from an a.out object file.  */
2991
2992 static boolean
2993 aout_link_add_object_symbols (abfd, info)
2994      bfd *abfd;
2995      struct bfd_link_info *info;
2996 {
2997   if (! aout_get_external_symbols (abfd))
2998     return false;
2999   if (! aout_link_add_symbols (abfd, info))
3000     return false;
3001   if (! info->keep_memory)
3002     {
3003       if (! aout_link_free_symbols (abfd))
3004         return false;
3005     }
3006   return true;
3007 }
3008
3009 /* Check a single archive element to see if we need to include it in
3010    the link.  *PNEEDED is set according to whether this element is
3011    needed in the link or not.  This is called from
3012    _bfd_generic_link_add_archive_symbols.  */
3013
3014 static boolean
3015 aout_link_check_archive_element (abfd, info, pneeded)
3016      bfd *abfd;
3017      struct bfd_link_info *info;
3018      boolean *pneeded;
3019 {
3020   if (! aout_get_external_symbols (abfd))
3021     return false;
3022
3023   if (! aout_link_check_ar_symbols (abfd, info, pneeded))
3024     return false;
3025
3026   if (*pneeded)
3027     {
3028       if (! aout_link_add_symbols (abfd, info))
3029         return false;
3030     }
3031
3032   if (! info->keep_memory || ! *pneeded)
3033     {
3034       if (! aout_link_free_symbols (abfd))
3035         return false;
3036     }
3037
3038   return true;
3039 }
3040
3041 /* Free up the internal symbols read from an a.out file.  */
3042
3043 static boolean
3044 aout_link_free_symbols (abfd)
3045      bfd *abfd;
3046 {
3047   if (obj_aout_external_syms (abfd) != (struct external_nlist *) NULL)
3048     {
3049 #ifdef USE_MMAP
3050       bfd_free_window (&obj_aout_sym_window (abfd));
3051 #else
3052       free ((PTR) obj_aout_external_syms (abfd));
3053 #endif
3054       obj_aout_external_syms (abfd) = (struct external_nlist *) NULL;
3055     }
3056   if (obj_aout_external_strings (abfd) != (char *) NULL)
3057     {
3058 #ifdef USE_MMAP
3059       bfd_free_window (&obj_aout_string_window (abfd));
3060 #else
3061       free ((PTR) obj_aout_external_strings (abfd));
3062 #endif
3063       obj_aout_external_strings (abfd) = (char *) NULL;
3064     }
3065   return true;
3066 }
3067
3068 /* Look through the internal symbols to see if this object file should
3069    be included in the link.  We should include this object file if it
3070    defines any symbols which are currently undefined.  If this object
3071    file defines a common symbol, then we may adjust the size of the
3072    known symbol but we do not include the object file in the link
3073    (unless there is some other reason to include it).  */
3074
3075 static boolean
3076 aout_link_check_ar_symbols (abfd, info, pneeded)
3077      bfd *abfd;
3078      struct bfd_link_info *info;
3079      boolean *pneeded;
3080 {
3081   register struct external_nlist *p;
3082   struct external_nlist *pend;
3083   char *strings;
3084
3085   *pneeded = false;
3086
3087   /* Look through all the symbols.  */
3088   p = obj_aout_external_syms (abfd);
3089   pend = p + obj_aout_external_sym_count (abfd);
3090   strings = obj_aout_external_strings (abfd);
3091   for (; p < pend; p++)
3092     {
3093       int type = bfd_h_get_8 (abfd, p->e_type);
3094       const char *name;
3095       struct bfd_link_hash_entry *h;
3096
3097       /* Ignore symbols that are not externally visible.  This is an
3098          optimization only, as we check the type more thoroughly
3099          below.  */
3100       if (((type & N_EXT) == 0
3101            || (type & N_STAB) != 0
3102            || type == N_FN)
3103           && type != N_WEAKA
3104           && type != N_WEAKT
3105           && type != N_WEAKD
3106           && type != N_WEAKB)
3107         {
3108           if (type == N_WARNING
3109               || type == N_INDR)
3110             ++p;
3111           continue;
3112         }
3113
3114       name = strings + GET_WORD (abfd, p->e_strx);
3115       h = bfd_link_hash_lookup (info->hash, name, false, false, true);
3116
3117       /* We are only interested in symbols that are currently
3118          undefined or common.  */
3119       if (h == (struct bfd_link_hash_entry *) NULL
3120           || (h->type != bfd_link_hash_undefined
3121               && h->type != bfd_link_hash_common))
3122         {
3123           if (type == (N_INDR | N_EXT))
3124             ++p;
3125           continue;
3126         }
3127
3128       if (type == (N_TEXT | N_EXT)
3129           || type == (N_DATA | N_EXT)
3130           || type == (N_BSS | N_EXT)
3131           || type == (N_ABS | N_EXT)
3132           || type == (N_INDR | N_EXT))
3133         {
3134           /* This object file defines this symbol.  We must link it
3135              in.  This is true regardless of whether the current
3136              definition of the symbol is undefined or common.  If the
3137              current definition is common, we have a case in which we
3138              have already seen an object file including
3139                  int a;
3140              and this object file from the archive includes
3141                  int a = 5;
3142              In such a case we must include this object file.
3143
3144              FIXME: The SunOS 4.1.3 linker will pull in the archive
3145              element if the symbol is defined in the .data section,
3146              but not if it is defined in the .text section.  That
3147              seems a bit crazy to me, and I haven't implemented it.
3148              However, it might be correct.  */
3149           if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3150             return false;
3151           *pneeded = true;
3152           return true;
3153         }
3154
3155       if (type == (N_UNDF | N_EXT))
3156         {
3157           bfd_vma value;
3158
3159           value = GET_WORD (abfd, p->e_value);
3160           if (value != 0)
3161             {
3162               /* This symbol is common in the object from the archive
3163                  file.  */
3164               if (h->type == bfd_link_hash_undefined)
3165                 {
3166                   bfd *symbfd;
3167                   unsigned int power;
3168
3169                   symbfd = h->u.undef.abfd;
3170                   if (symbfd == (bfd *) NULL)
3171                     {
3172                       /* This symbol was created as undefined from
3173                          outside BFD.  We assume that we should link
3174                          in the object file.  This is done for the -u
3175                          option in the linker.  */
3176                       if (! (*info->callbacks->add_archive_element) (info,
3177                                                                      abfd,
3178                                                                      name))
3179                         return false;
3180                       *pneeded = true;
3181                       return true;
3182                     }
3183                   /* Turn the current link symbol into a common
3184                      symbol.  It is already on the undefs list.  */
3185                   h->type = bfd_link_hash_common;
3186                   h->u.c.p = ((struct bfd_link_hash_common_entry *)
3187                               bfd_hash_allocate (&info->hash->table,
3188                                   sizeof (struct bfd_link_hash_common_entry)));
3189                   if (h->u.c.p == NULL)
3190                     return false;
3191
3192                   h->u.c.size = value;
3193
3194                   /* FIXME: This isn't quite right.  The maximum
3195                      alignment of a common symbol should be set by the
3196                      architecture of the output file, not of the input
3197                      file.  */
3198                   power = bfd_log2 (value);
3199                   if (power > bfd_get_arch_info (abfd)->section_align_power)
3200                     power = bfd_get_arch_info (abfd)->section_align_power;
3201                   h->u.c.p->alignment_power = power;
3202
3203                   h->u.c.p->section = bfd_make_section_old_way (symbfd,
3204                                                                 "COMMON");
3205                 }
3206               else
3207                 {
3208                   /* Adjust the size of the common symbol if
3209                      necessary.  */
3210                   if (value > h->u.c.size)
3211                     h->u.c.size = value;
3212                 }
3213             }
3214         }
3215
3216       if (type == N_WEAKA
3217           || type == N_WEAKT
3218           || type == N_WEAKD
3219           || type == N_WEAKB)
3220         {
3221           /* This symbol is weak but defined.  We must pull it in if
3222              the current link symbol is undefined, but we don't want
3223              it if the current link symbol is common.  */
3224           if (h->type == bfd_link_hash_undefined)
3225             {
3226               if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3227                 return false;
3228               *pneeded = true;
3229               return true;
3230             }
3231         }
3232     }
3233
3234   /* We do not need this object file.  */
3235   return true;
3236 }
3237
3238 /* Add all symbols from an object file to the hash table.  */
3239
3240 static boolean
3241 aout_link_add_symbols (abfd, info)
3242      bfd *abfd;
3243      struct bfd_link_info *info;
3244 {
3245   boolean (*add_one_symbol) PARAMS ((struct bfd_link_info *, bfd *,
3246                                      const char *, flagword, asection *,
3247                                      bfd_vma, const char *, boolean,
3248                                      boolean,
3249                                      struct bfd_link_hash_entry **));
3250   struct external_nlist *syms;
3251   bfd_size_type sym_count;
3252   char *strings;
3253   boolean copy;
3254   struct aout_link_hash_entry **sym_hash;
3255   register struct external_nlist *p;
3256   struct external_nlist *pend;
3257
3258   syms = obj_aout_external_syms (abfd);
3259   sym_count = obj_aout_external_sym_count (abfd);
3260   strings = obj_aout_external_strings (abfd);
3261   if (info->keep_memory)
3262     copy = false;
3263   else
3264     copy = true;
3265
3266   if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
3267     {
3268       if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
3269              (abfd, info, &syms, &sym_count, &strings)))
3270         return false;
3271     }
3272
3273   /* We keep a list of the linker hash table entries that correspond
3274      to particular symbols.  We could just look them up in the hash
3275      table, but keeping the list is more efficient.  Perhaps this
3276      should be conditional on info->keep_memory.  */
3277   sym_hash = ((struct aout_link_hash_entry **)
3278               bfd_alloc (abfd,
3279                          ((size_t) sym_count
3280                           * sizeof (struct aout_link_hash_entry *))));
3281   if (sym_hash == NULL && sym_count != 0)
3282     return false;
3283   obj_aout_sym_hashes (abfd) = sym_hash;
3284
3285   add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
3286   if (add_one_symbol == NULL)
3287     add_one_symbol = _bfd_generic_link_add_one_symbol;
3288
3289   p = syms;
3290   pend = p + sym_count;
3291   for (; p < pend; p++, sym_hash++)
3292     {
3293       int type;
3294       const char *name;
3295       bfd_vma value;
3296       asection *section;
3297       flagword flags;
3298       const char *string;
3299
3300       *sym_hash = NULL;
3301
3302       type = bfd_h_get_8 (abfd, p->e_type);
3303
3304       /* Ignore debugging symbols.  */
3305       if ((type & N_STAB) != 0)
3306         continue;
3307
3308       name = strings + GET_WORD (abfd, p->e_strx);
3309       value = GET_WORD (abfd, p->e_value);
3310       flags = BSF_GLOBAL;
3311       string = NULL;
3312       switch (type)
3313         {
3314         default:
3315           abort ();
3316
3317         case N_UNDF:
3318         case N_ABS:
3319         case N_TEXT:
3320         case N_DATA:
3321         case N_BSS:
3322         case N_FN_SEQ:
3323         case N_COMM:
3324         case N_SETV:
3325         case N_FN:
3326           /* Ignore symbols that are not externally visible.  */
3327           continue;
3328         case N_INDR:
3329           /* Ignore local indirect symbol.  */
3330           ++p;
3331           ++sym_hash;
3332           continue;
3333
3334         case N_UNDF | N_EXT:
3335           if (value == 0)
3336             {
3337               section = bfd_und_section_ptr;
3338               flags = 0;
3339             }
3340           else
3341             section = bfd_com_section_ptr;
3342           break;
3343         case N_ABS | N_EXT:
3344           section = bfd_abs_section_ptr;
3345           break;
3346         case N_TEXT | N_EXT:
3347           section = obj_textsec (abfd);
3348           value -= bfd_get_section_vma (abfd, section);
3349           break;
3350         case N_DATA | N_EXT:
3351         case N_SETV | N_EXT:
3352           /* Treat N_SETV symbols as N_DATA symbol; see comment in
3353              translate_from_native_sym_flags.  */
3354           section = obj_datasec (abfd);
3355           value -= bfd_get_section_vma (abfd, section);
3356           break;
3357         case N_BSS | N_EXT:
3358           section = obj_bsssec (abfd);
3359           value -= bfd_get_section_vma (abfd, section);
3360           break;
3361         case N_INDR | N_EXT:
3362           /* An indirect symbol.  The next symbol is the symbol
3363              which this one really is.  */
3364           BFD_ASSERT (p + 1 < pend);
3365           ++p;
3366           string = strings + GET_WORD (abfd, p->e_strx);
3367           section = bfd_ind_section_ptr;
3368           flags |= BSF_INDIRECT;
3369           break;
3370         case N_COMM | N_EXT:
3371           section = bfd_com_section_ptr;
3372           break;
3373         case N_SETA: case N_SETA | N_EXT:
3374           section = bfd_abs_section_ptr;
3375           flags |= BSF_CONSTRUCTOR;
3376           break;
3377         case N_SETT: case N_SETT | N_EXT:
3378           section = obj_textsec (abfd);
3379           flags |= BSF_CONSTRUCTOR;
3380           value -= bfd_get_section_vma (abfd, section);
3381           break;
3382         case N_SETD: case N_SETD | N_EXT:
3383           section = obj_datasec (abfd);
3384           flags |= BSF_CONSTRUCTOR;
3385           value -= bfd_get_section_vma (abfd, section);
3386           break;
3387         case N_SETB: case N_SETB | N_EXT:
3388           section = obj_bsssec (abfd);
3389           flags |= BSF_CONSTRUCTOR;
3390           value -= bfd_get_section_vma (abfd, section);
3391           break;
3392         case N_WARNING:
3393           /* A warning symbol.  The next symbol is the one to warn
3394              about.  */
3395           BFD_ASSERT (p + 1 < pend);
3396           ++p;
3397           string = name;
3398           name = strings + GET_WORD (abfd, p->e_strx);
3399           section = bfd_und_section_ptr;
3400           flags |= BSF_WARNING;
3401           break;
3402         case N_WEAKU:
3403           section = bfd_und_section_ptr;
3404           flags = BSF_WEAK;
3405           break;
3406         case N_WEAKA:
3407           section = bfd_abs_section_ptr;
3408           flags = BSF_WEAK;
3409           break;
3410         case N_WEAKT:
3411           section = obj_textsec (abfd);
3412           value -= bfd_get_section_vma (abfd, section);
3413           flags = BSF_WEAK;
3414           break;
3415         case N_WEAKD:
3416           section = obj_datasec (abfd);
3417           value -= bfd_get_section_vma (abfd, section);
3418           flags = BSF_WEAK;
3419           break;
3420         case N_WEAKB:
3421           section = obj_bsssec (abfd);
3422           value -= bfd_get_section_vma (abfd, section);
3423           flags = BSF_WEAK;
3424           break;
3425         }
3426
3427       if (! ((*add_one_symbol)
3428              (info, abfd, name, flags, section, value, string, copy, false,
3429               (struct bfd_link_hash_entry **) sym_hash)))
3430         return false;
3431
3432       /* Restrict the maximum alignment of a common symbol based on
3433          the architecture, since a.out has no way to represent
3434          alignment requirements of a section in a .o file.  FIXME:
3435          This isn't quite right: it should use the architecture of the
3436          output file, not the input files.  */
3437       if ((*sym_hash)->root.type == bfd_link_hash_common
3438           && ((*sym_hash)->root.u.c.p->alignment_power >
3439               bfd_get_arch_info (abfd)->section_align_power))
3440         (*sym_hash)->root.u.c.p->alignment_power =
3441           bfd_get_arch_info (abfd)->section_align_power;
3442
3443       /* If this is a set symbol, and we are not building sets, then
3444          it is possible for the hash entry to not have been set.  In
3445          such a case, treat the symbol as not globally defined.  */
3446       if ((*sym_hash)->root.type == bfd_link_hash_new)
3447         {
3448           BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
3449           *sym_hash = NULL;
3450         }
3451
3452       if (type == (N_INDR | N_EXT) || type == N_WARNING)
3453         ++sym_hash;
3454     }
3455
3456   return true;
3457 }
3458 \f
3459 /* A hash table used for header files with N_BINCL entries.  */
3460
3461 struct aout_link_includes_table
3462 {
3463   struct bfd_hash_table root;
3464 };
3465
3466 /* A linked list of totals that we have found for a particular header
3467    file.  */
3468
3469 struct aout_link_includes_totals
3470 {
3471   struct aout_link_includes_totals *next;
3472   bfd_vma total;
3473 };
3474
3475 /* An entry in the header file hash table.  */
3476
3477 struct aout_link_includes_entry
3478 {
3479   struct bfd_hash_entry root;
3480   /* List of totals we have found for this file.  */
3481   struct aout_link_includes_totals *totals;
3482 };
3483
3484 /* Look up an entry in an the header file hash table.  */
3485
3486 #define aout_link_includes_lookup(table, string, create, copy) \
3487   ((struct aout_link_includes_entry *) \
3488    bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3489
3490 /* During the final link step we need to pass around a bunch of
3491    information, so we do it in an instance of this structure.  */
3492
3493 struct aout_final_link_info
3494 {
3495   /* General link information.  */
3496   struct bfd_link_info *info;
3497   /* Output bfd.  */
3498   bfd *output_bfd;
3499   /* Reloc file positions.  */
3500   file_ptr treloff, dreloff;
3501   /* File position of symbols.  */
3502   file_ptr symoff;
3503   /* String table.  */
3504   struct bfd_strtab_hash *strtab;
3505   /* Header file hash table.  */
3506   struct aout_link_includes_table includes;
3507   /* A buffer large enough to hold the contents of any section.  */
3508   bfd_byte *contents;
3509   /* A buffer large enough to hold the relocs of any section.  */
3510   PTR relocs;
3511   /* A buffer large enough to hold the symbol map of any input BFD.  */
3512   int *symbol_map;
3513   /* A buffer large enough to hold output symbols of any input BFD.  */
3514   struct external_nlist *output_syms;
3515 };
3516
3517 static struct bfd_hash_entry *aout_link_includes_newfunc
3518   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
3519 static boolean aout_link_input_bfd
3520   PARAMS ((struct aout_final_link_info *, bfd *input_bfd));
3521 static boolean aout_link_write_symbols
3522   PARAMS ((struct aout_final_link_info *, bfd *input_bfd));
3523 static boolean aout_link_write_other_symbol
3524   PARAMS ((struct aout_link_hash_entry *, PTR));
3525 static boolean aout_link_input_section
3526   PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
3527            asection *input_section, file_ptr *reloff_ptr,
3528            bfd_size_type rel_size));
3529 static boolean aout_link_input_section_std
3530   PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
3531            asection *input_section, struct reloc_std_external *,
3532            bfd_size_type rel_size, bfd_byte *contents));
3533 static boolean aout_link_input_section_ext
3534   PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
3535            asection *input_section, struct reloc_ext_external *,
3536            bfd_size_type rel_size, bfd_byte *contents));
3537 static INLINE asection *aout_reloc_index_to_section
3538   PARAMS ((bfd *, int));
3539 static boolean aout_link_reloc_link_order
3540   PARAMS ((struct aout_final_link_info *, asection *,
3541            struct bfd_link_order *));
3542
3543 /* The function to create a new entry in the header file hash table.  */
3544
3545 static struct bfd_hash_entry *
3546 aout_link_includes_newfunc (entry, table, string)
3547      struct bfd_hash_entry *entry;
3548      struct bfd_hash_table *table;
3549      const char *string;
3550 {
3551   struct aout_link_includes_entry *ret =
3552     (struct aout_link_includes_entry *) entry;
3553
3554   /* Allocate the structure if it has not already been allocated by a
3555      subclass.  */
3556   if (ret == (struct aout_link_includes_entry *) NULL)
3557     ret = ((struct aout_link_includes_entry *)
3558            bfd_hash_allocate (table,
3559                               sizeof (struct aout_link_includes_entry)));
3560   if (ret == (struct aout_link_includes_entry *) NULL)
3561     return (struct bfd_hash_entry *) ret;
3562
3563   /* Call the allocation method of the superclass.  */
3564   ret = ((struct aout_link_includes_entry *)
3565          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
3566   if (ret)
3567     {
3568       /* Set local fields.  */
3569       ret->totals = NULL;
3570     }
3571
3572   return (struct bfd_hash_entry *) ret;
3573 }
3574
3575 /* Do the final link step.  This is called on the output BFD.  The
3576    INFO structure should point to a list of BFDs linked through the
3577    link_next field which can be used to find each BFD which takes part
3578    in the output.  Also, each section in ABFD should point to a list
3579    of bfd_link_order structures which list all the input sections for
3580    the output section.  */
3581
3582 boolean
3583 NAME(aout,final_link) (abfd, info, callback)
3584      bfd *abfd;
3585      struct bfd_link_info *info;
3586      void (*callback) PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *));
3587 {
3588   struct aout_final_link_info aout_info;
3589   boolean includes_hash_initialized = false;
3590   register bfd *sub;
3591   bfd_size_type trsize, drsize;
3592   size_t max_contents_size;
3593   size_t max_relocs_size;
3594   size_t max_sym_count;
3595   bfd_size_type text_size;
3596   file_ptr text_end;
3597   register struct bfd_link_order *p;
3598   asection *o;
3599   boolean have_link_order_relocs;
3600
3601   if (info->shared)
3602     abfd->flags |= DYNAMIC;
3603
3604   aout_info.info = info;
3605   aout_info.output_bfd = abfd;
3606   aout_info.contents = NULL;
3607   aout_info.relocs = NULL;
3608   aout_info.symbol_map = NULL;
3609   aout_info.output_syms = NULL;
3610
3611   if (! bfd_hash_table_init_n (&aout_info.includes.root,
3612                                aout_link_includes_newfunc,
3613                                251))
3614     goto error_return;
3615   includes_hash_initialized = true;
3616
3617   /* Figure out the largest section size.  Also, if generating
3618      relocateable output, count the relocs.  */
3619   trsize = 0;
3620   drsize = 0;
3621   max_contents_size = 0;
3622   max_relocs_size = 0;
3623   max_sym_count = 0;
3624   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3625     {
3626       size_t sz;
3627
3628       if (info->relocateable)
3629         {
3630           if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3631             {
3632               trsize += exec_hdr (sub)->a_trsize;
3633               drsize += exec_hdr (sub)->a_drsize;
3634             }
3635           else
3636             {
3637               /* FIXME: We need to identify the .text and .data sections
3638                  and call get_reloc_upper_bound and canonicalize_reloc to
3639                  work out the number of relocs needed, and then multiply
3640                  by the reloc size.  */
3641               (*_bfd_error_handler)
3642                 ("%s: relocateable link from %s to %s not supported",
3643                  bfd_get_filename (abfd),
3644                  sub->xvec->name, abfd->xvec->name);
3645               bfd_set_error (bfd_error_invalid_operation);
3646               goto error_return;
3647             }
3648         }
3649
3650       if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3651         {
3652           sz = bfd_section_size (sub, obj_textsec (sub));
3653           if (sz > max_contents_size)
3654             max_contents_size = sz;
3655           sz = bfd_section_size (sub, obj_datasec (sub));
3656           if (sz > max_contents_size)
3657             max_contents_size = sz;
3658
3659           sz = exec_hdr (sub)->a_trsize;
3660           if (sz > max_relocs_size)
3661             max_relocs_size = sz;
3662           sz = exec_hdr (sub)->a_drsize;
3663           if (sz > max_relocs_size)
3664             max_relocs_size = sz;
3665
3666           sz = obj_aout_external_sym_count (sub);
3667           if (sz > max_sym_count)
3668             max_sym_count = sz;
3669         }
3670     }
3671
3672   if (info->relocateable)
3673     {
3674       if (obj_textsec (abfd) != (asection *) NULL)
3675         trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
3676                                                  ->link_order_head)
3677                    * obj_reloc_entry_size (abfd));
3678       if (obj_datasec (abfd) != (asection *) NULL)
3679         drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
3680                                                  ->link_order_head)
3681                    * obj_reloc_entry_size (abfd));
3682     }
3683
3684   exec_hdr (abfd)->a_trsize = trsize;
3685   exec_hdr (abfd)->a_drsize = drsize;
3686
3687   exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
3688
3689   /* Adjust the section sizes and vmas according to the magic number.
3690      This sets a_text, a_data and a_bss in the exec_hdr and sets the
3691      filepos for each section.  */
3692   if (! NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
3693     goto error_return;
3694
3695   /* The relocation and symbol file positions differ among a.out
3696      targets.  We are passed a callback routine from the backend
3697      specific code to handle this.
3698      FIXME: At this point we do not know how much space the symbol
3699      table will require.  This will not work for any (nonstandard)
3700      a.out target that needs to know the symbol table size before it
3701      can compute the relocation file positions.  This may or may not
3702      be the case for the hp300hpux target, for example.  */
3703   (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
3704                &aout_info.symoff);
3705   obj_textsec (abfd)->rel_filepos = aout_info.treloff;
3706   obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
3707   obj_sym_filepos (abfd) = aout_info.symoff;
3708
3709   /* We keep a count of the symbols as we output them.  */
3710   obj_aout_external_sym_count (abfd) = 0;
3711
3712   /* We accumulate the string table as we write out the symbols.  */
3713   aout_info.strtab = _bfd_stringtab_init ();
3714   if (aout_info.strtab == NULL)
3715     goto error_return;
3716
3717   /* Allocate buffers to hold section contents and relocs.  */
3718   aout_info.contents = (bfd_byte *) bfd_malloc (max_contents_size);
3719   aout_info.relocs = (PTR) bfd_malloc (max_relocs_size);
3720   aout_info.symbol_map = (int *) bfd_malloc (max_sym_count * sizeof (int *));
3721   aout_info.output_syms = ((struct external_nlist *)
3722                            bfd_malloc ((max_sym_count + 1)
3723                                        * sizeof (struct external_nlist)));
3724   if ((aout_info.contents == NULL && max_contents_size != 0)
3725       || (aout_info.relocs == NULL && max_relocs_size != 0)
3726       || (aout_info.symbol_map == NULL && max_sym_count != 0)
3727       || aout_info.output_syms == NULL)
3728     goto error_return;
3729
3730   /* If we have a symbol named __DYNAMIC, force it out now.  This is
3731      required by SunOS.  Doing this here rather than in sunos.c is a
3732      hack, but it's easier than exporting everything which would be
3733      needed.  */
3734   {
3735     struct aout_link_hash_entry *h;
3736
3737     h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
3738                                false, false, false);
3739     if (h != NULL)
3740       aout_link_write_other_symbol (h, &aout_info);
3741   }
3742
3743   /* The most time efficient way to do the link would be to read all
3744      the input object files into memory and then sort out the
3745      information into the output file.  Unfortunately, that will
3746      probably use too much memory.  Another method would be to step
3747      through everything that composes the text section and write it
3748      out, and then everything that composes the data section and write
3749      it out, and then write out the relocs, and then write out the
3750      symbols.  Unfortunately, that requires reading stuff from each
3751      input file several times, and we will not be able to keep all the
3752      input files open simultaneously, and reopening them will be slow.
3753
3754      What we do is basically process one input file at a time.  We do
3755      everything we need to do with an input file once--copy over the
3756      section contents, handle the relocation information, and write
3757      out the symbols--and then we throw away the information we read
3758      from it.  This approach requires a lot of lseeks of the output
3759      file, which is unfortunate but still faster than reopening a lot
3760      of files.
3761
3762      We use the output_has_begun field of the input BFDs to see
3763      whether we have already handled it.  */
3764   for (sub = info->input_bfds; sub != (bfd *) NULL; sub = sub->link_next)
3765     sub->output_has_begun = false;
3766
3767   /* Mark all sections which are to be included in the link.  This
3768      will normally be every section.  We need to do this so that we
3769      can identify any sections which the linker has decided to not
3770      include.  */
3771   for (o = abfd->sections; o != NULL; o = o->next)
3772     {
3773       for (p = o->link_order_head; p != NULL; p = p->next)
3774         {
3775           if (p->type == bfd_indirect_link_order)
3776             p->u.indirect.section->linker_mark = true;
3777         }
3778     }
3779
3780   have_link_order_relocs = false;
3781   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3782     {
3783       for (p = o->link_order_head;
3784            p != (struct bfd_link_order *) NULL;
3785            p = p->next)
3786         {
3787           if (p->type == bfd_indirect_link_order
3788               && (bfd_get_flavour (p->u.indirect.section->owner)
3789                   == bfd_target_aout_flavour))
3790             {
3791               bfd *input_bfd;
3792
3793               input_bfd = p->u.indirect.section->owner;
3794               if (! input_bfd->output_has_begun)
3795                 {
3796                   if (! aout_link_input_bfd (&aout_info, input_bfd))
3797                     goto error_return;
3798                   input_bfd->output_has_begun = true;
3799                 }
3800             }
3801           else if (p->type == bfd_section_reloc_link_order
3802                    || p->type == bfd_symbol_reloc_link_order)
3803             {
3804               /* These are handled below.  */
3805               have_link_order_relocs = true;
3806             }
3807           else
3808             {
3809               if (! _bfd_default_link_order (abfd, info, o, p))
3810                 goto error_return;
3811             }
3812         }
3813     }
3814
3815   /* Write out any symbols that we have not already written out.  */
3816   aout_link_hash_traverse (aout_hash_table (info),
3817                            aout_link_write_other_symbol,
3818                            (PTR) &aout_info);
3819
3820   /* Now handle any relocs we were asked to create by the linker.
3821      These did not come from any input file.  We must do these after
3822      we have written out all the symbols, so that we know the symbol
3823      indices to use.  */
3824   if (have_link_order_relocs)
3825     {
3826       for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3827         {
3828           for (p = o->link_order_head;
3829                p != (struct bfd_link_order *) NULL;
3830                p = p->next)
3831             {
3832               if (p->type == bfd_section_reloc_link_order
3833                   || p->type == bfd_symbol_reloc_link_order)
3834                 {
3835                   if (! aout_link_reloc_link_order (&aout_info, o, p))
3836                     goto error_return;
3837                 }
3838             }
3839         }
3840     }
3841
3842   if (aout_info.contents != NULL)
3843     {
3844       free (aout_info.contents);
3845       aout_info.contents = NULL;
3846     }
3847   if (aout_info.relocs != NULL)
3848     {
3849       free (aout_info.relocs);
3850       aout_info.relocs = NULL;
3851     }
3852   if (aout_info.symbol_map != NULL)
3853     {
3854       free (aout_info.symbol_map);
3855       aout_info.symbol_map = NULL;
3856     }
3857   if (aout_info.output_syms != NULL)
3858     {
3859       free (aout_info.output_syms);
3860       aout_info.output_syms = NULL;
3861     }
3862   if (includes_hash_initialized)
3863     {
3864       bfd_hash_table_free (&aout_info.includes.root);
3865       includes_hash_initialized = false;
3866     }
3867
3868   /* Finish up any dynamic linking we may be doing.  */
3869   if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
3870     {
3871       if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
3872         goto error_return;
3873     }
3874
3875   /* Update the header information.  */
3876   abfd->symcount = obj_aout_external_sym_count (abfd);
3877   exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
3878   obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
3879   obj_textsec (abfd)->reloc_count =
3880     exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
3881   obj_datasec (abfd)->reloc_count =
3882     exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
3883
3884   /* Write out the string table, unless there are no symbols.  */
3885   if (abfd->symcount > 0)
3886     {
3887       if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
3888           || ! emit_stringtab (abfd, aout_info.strtab))
3889         goto error_return;
3890     }
3891   else if (obj_textsec (abfd)->reloc_count == 0
3892            && obj_datasec (abfd)->reloc_count == 0)
3893     {
3894       bfd_byte b;
3895
3896       b = 0;
3897       if (bfd_seek (abfd,
3898                     (obj_datasec (abfd)->filepos
3899                      + exec_hdr (abfd)->a_data
3900                      - 1),
3901                     SEEK_SET) != 0
3902           || bfd_write (&b, 1, 1, abfd) != 1)
3903         goto error_return;
3904     }
3905
3906   return true;
3907
3908  error_return:
3909   if (aout_info.contents != NULL)
3910     free (aout_info.contents);
3911   if (aout_info.relocs != NULL)
3912     free (aout_info.relocs);
3913   if (aout_info.symbol_map != NULL)
3914     free (aout_info.symbol_map);
3915   if (aout_info.output_syms != NULL)
3916     free (aout_info.output_syms);
3917   if (includes_hash_initialized)
3918     bfd_hash_table_free (&aout_info.includes.root);
3919   return false;
3920 }
3921
3922 /* Link an a.out input BFD into the output file.  */
3923
3924 static boolean
3925 aout_link_input_bfd (finfo, input_bfd)
3926      struct aout_final_link_info *finfo;
3927      bfd *input_bfd;
3928 {
3929   bfd_size_type sym_count;
3930
3931   BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
3932
3933   /* If this is a dynamic object, it may need special handling.  */
3934   if ((input_bfd->flags & DYNAMIC) != 0
3935       && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
3936     {
3937       return ((*aout_backend_info (input_bfd)->link_dynamic_object)
3938               (finfo->info, input_bfd));
3939     }
3940
3941   /* Get the symbols.  We probably have them already, unless
3942      finfo->info->keep_memory is false.  */
3943   if (! aout_get_external_symbols (input_bfd))
3944     return false;
3945
3946   sym_count = obj_aout_external_sym_count (input_bfd);
3947
3948   /* Write out the symbols and get a map of the new indices.  The map
3949      is placed into finfo->symbol_map.  */
3950   if (! aout_link_write_symbols (finfo, input_bfd))
3951     return false;
3952
3953   /* Relocate and write out the sections.  These functions use the
3954      symbol map created by aout_link_write_symbols.  The linker_mark
3955      field will be set if these sections are to be included in the
3956      link, which will normally be the case.  */
3957   if (obj_textsec (input_bfd)->linker_mark)
3958     {
3959       if (! aout_link_input_section (finfo, input_bfd,
3960                                      obj_textsec (input_bfd),
3961                                      &finfo->treloff,
3962                                      exec_hdr (input_bfd)->a_trsize))
3963         return false;
3964     }
3965   if (obj_datasec (input_bfd)->linker_mark)
3966     {
3967       if (! aout_link_input_section (finfo, input_bfd,
3968                                      obj_datasec (input_bfd),
3969                                      &finfo->dreloff,
3970                                      exec_hdr (input_bfd)->a_drsize))
3971         return false;
3972     }
3973
3974   /* If we are not keeping memory, we don't need the symbols any
3975      longer.  We still need them if we are keeping memory, because the
3976      strings in the hash table point into them.  */
3977   if (! finfo->info->keep_memory)
3978     {
3979       if (! aout_link_free_symbols (input_bfd))
3980         return false;
3981     }
3982
3983   return true;
3984 }
3985
3986 /* Adjust and write out the symbols for an a.out file.  Set the new
3987    symbol indices into a symbol_map.  */
3988
3989 static boolean
3990 aout_link_write_symbols (finfo, input_bfd)
3991      struct aout_final_link_info *finfo;
3992      bfd *input_bfd;
3993 {
3994   bfd *output_bfd;
3995   bfd_size_type sym_count;
3996   char *strings;
3997   enum bfd_link_strip strip;
3998   enum bfd_link_discard discard;
3999   struct external_nlist *outsym;
4000   bfd_size_type strtab_index;
4001   register struct external_nlist *sym;
4002   struct external_nlist *sym_end;
4003   struct aout_link_hash_entry **sym_hash;
4004   int *symbol_map;
4005   boolean pass;
4006   boolean skip_next;
4007
4008   output_bfd = finfo->output_bfd;
4009   sym_count = obj_aout_external_sym_count (input_bfd);
4010   strings = obj_aout_external_strings (input_bfd);
4011   strip = finfo->info->strip;
4012   discard = finfo->info->discard;
4013   outsym = finfo->output_syms;
4014
4015   /* First write out a symbol for this object file, unless we are
4016      discarding such symbols.  */
4017   if (strip != strip_all
4018       && (strip != strip_some
4019           || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
4020                               false, false) != NULL)
4021       && discard != discard_all)
4022     {
4023       bfd_h_put_8 (output_bfd, N_TEXT, outsym->e_type);
4024       bfd_h_put_8 (output_bfd, 0, outsym->e_other);
4025       bfd_h_put_16 (output_bfd, (bfd_vma) 0, outsym->e_desc);
4026       strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4027                                        input_bfd->filename, false);
4028       if (strtab_index == (bfd_size_type) -1)
4029         return false;
4030       PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4031       PUT_WORD (output_bfd,
4032                 (bfd_get_section_vma (output_bfd,
4033                                       obj_textsec (input_bfd)->output_section)
4034                  + obj_textsec (input_bfd)->output_offset),
4035                 outsym->e_value);
4036       ++obj_aout_external_sym_count (output_bfd);
4037       ++outsym;
4038     }
4039
4040   pass = false;
4041   skip_next = false;
4042   sym = obj_aout_external_syms (input_bfd);
4043   sym_end = sym + sym_count;
4044   sym_hash = obj_aout_sym_hashes (input_bfd);
4045   symbol_map = finfo->symbol_map;
4046   memset (symbol_map, 0, sym_count * sizeof *symbol_map);
4047   for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
4048     {
4049       const char *name;
4050       int type;
4051       struct aout_link_hash_entry *h;
4052       boolean skip;
4053       asection *symsec;
4054       bfd_vma val = 0;
4055       boolean copy;
4056
4057       /* We set *symbol_map to 0 above for all symbols.  If it has
4058          already been set to -1 for this symbol, it means that we are
4059          discarding it because it appears in a duplicate header file.
4060          See the N_BINCL code below.  */
4061       if (*symbol_map == -1)
4062         continue;
4063
4064       /* Initialize *symbol_map to -1, which means that the symbol was
4065          not copied into the output file.  We will change it later if
4066          we do copy the symbol over.  */
4067       *symbol_map = -1;
4068
4069       type = bfd_h_get_8 (input_bfd, sym->e_type);
4070       name = strings + GET_WORD (input_bfd, sym->e_strx);
4071
4072       h = NULL;
4073
4074       if (pass)
4075         {
4076           /* Pass this symbol through.  It is the target of an
4077              indirect or warning symbol.  */
4078           val = GET_WORD (input_bfd, sym->e_value);
4079           pass = false;
4080         }
4081       else if (skip_next)
4082         {
4083           /* Skip this symbol, which is the target of an indirect
4084              symbol that we have changed to no longer be an indirect
4085              symbol.  */
4086           skip_next = false;
4087           continue;
4088         }
4089       else
4090         {
4091           struct aout_link_hash_entry *hresolve;
4092
4093           /* We have saved the hash table entry for this symbol, if
4094              there is one.  Note that we could just look it up again
4095              in the hash table, provided we first check that it is an
4096              external symbol. */
4097           h = *sym_hash;
4098
4099           /* Use the name from the hash table, in case the symbol was
4100              wrapped.  */
4101           if (h != NULL)
4102             name = h->root.root.string;
4103
4104           /* If this is an indirect or warning symbol, then change
4105              hresolve to the base symbol.  We also change *sym_hash so
4106              that the relocation routines relocate against the real
4107              symbol.  */
4108           hresolve = h;
4109           if (h != (struct aout_link_hash_entry *) NULL
4110               && (h->root.type == bfd_link_hash_indirect
4111                   || h->root.type == bfd_link_hash_warning))
4112             {
4113               hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
4114               while (hresolve->root.type == bfd_link_hash_indirect
4115                      || hresolve->root.type == bfd_link_hash_warning)
4116                 hresolve = ((struct aout_link_hash_entry *)
4117                             hresolve->root.u.i.link);
4118               *sym_hash = hresolve;
4119             }
4120
4121           /* If the symbol has already been written out, skip it.  */
4122           if (h != (struct aout_link_hash_entry *) NULL
4123               && h->root.type != bfd_link_hash_warning
4124               && h->written)
4125             {
4126               if ((type & N_TYPE) == N_INDR
4127                   || type == N_WARNING)
4128                 skip_next = true;
4129               *symbol_map = h->indx;
4130               continue;
4131             }
4132
4133           /* See if we are stripping this symbol.  */
4134           skip = false;
4135           switch (strip)
4136             {
4137             case strip_none:
4138               break;
4139             case strip_debugger:
4140               if ((type & N_STAB) != 0)
4141                 skip = true;
4142               break;
4143             case strip_some:
4144               if (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
4145                   == NULL)
4146                 skip = true;
4147               break;
4148             case strip_all:
4149               skip = true;
4150               break;
4151             }
4152           if (skip)
4153             {
4154               if (h != (struct aout_link_hash_entry *) NULL)
4155                 h->written = true;
4156               continue;
4157             }
4158
4159           /* Get the value of the symbol.  */
4160           if ((type & N_TYPE) == N_TEXT
4161               || type == N_WEAKT)
4162             symsec = obj_textsec (input_bfd);
4163           else if ((type & N_TYPE) == N_DATA
4164                    || type == N_WEAKD)
4165             symsec = obj_datasec (input_bfd);
4166           else if ((type & N_TYPE) == N_BSS
4167                    || type == N_WEAKB)
4168             symsec = obj_bsssec (input_bfd);
4169           else if ((type & N_TYPE) == N_ABS
4170                    || type == N_WEAKA)
4171             symsec = bfd_abs_section_ptr;
4172           else if (((type & N_TYPE) == N_INDR
4173                     && (hresolve == (struct aout_link_hash_entry *) NULL
4174                         || (hresolve->root.type != bfd_link_hash_defined
4175                             && hresolve->root.type != bfd_link_hash_defweak
4176                             && hresolve->root.type != bfd_link_hash_common)))
4177                    || type == N_WARNING)
4178             {
4179               /* Pass the next symbol through unchanged.  The
4180                  condition above for indirect symbols is so that if
4181                  the indirect symbol was defined, we output it with
4182                  the correct definition so the debugger will
4183                  understand it.  */
4184               pass = true;
4185               val = GET_WORD (input_bfd, sym->e_value);
4186               symsec = NULL;
4187             }
4188           else if ((type & N_STAB) != 0)
4189             {
4190               val = GET_WORD (input_bfd, sym->e_value);
4191               symsec = NULL;
4192             }
4193           else
4194             {
4195               /* If we get here with an indirect symbol, it means that
4196                  we are outputting it with a real definition.  In such
4197                  a case we do not want to output the next symbol,
4198                  which is the target of the indirection.  */
4199               if ((type & N_TYPE) == N_INDR)
4200                 skip_next = true;
4201
4202               symsec = NULL;
4203
4204               /* We need to get the value from the hash table.  We use
4205                  hresolve so that if we have defined an indirect
4206                  symbol we output the final definition.  */
4207               if (h == (struct aout_link_hash_entry *) NULL)
4208                 {
4209                   switch (type & N_TYPE)
4210                     {
4211                     case N_SETT:
4212                       symsec = obj_textsec (input_bfd);
4213                       break;
4214                     case N_SETD:
4215                       symsec = obj_datasec (input_bfd);
4216                       break;
4217                     case N_SETB:
4218                       symsec = obj_bsssec (input_bfd);
4219                       break;
4220                     case N_SETA:
4221                       symsec = bfd_abs_section_ptr;
4222                       break;
4223                     default:
4224                       val = 0;
4225                       break;
4226                     }
4227                 }
4228               else if (hresolve->root.type == bfd_link_hash_defined
4229                        || hresolve->root.type == bfd_link_hash_defweak)
4230                 {
4231                   asection *input_section;
4232                   asection *output_section;
4233
4234                   /* This case usually means a common symbol which was
4235                      turned into a defined symbol.  */
4236                   input_section = hresolve->root.u.def.section;
4237                   output_section = input_section->output_section;
4238                   BFD_ASSERT (bfd_is_abs_section (output_section)
4239                               || output_section->owner == output_bfd);
4240                   val = (hresolve->root.u.def.value
4241                          + bfd_get_section_vma (output_bfd, output_section)
4242                          + input_section->output_offset);
4243
4244                   /* Get the correct type based on the section.  If
4245                      this is a constructed set, force it to be
4246                      globally visible.  */
4247                   if (type == N_SETT
4248                       || type == N_SETD
4249                       || type == N_SETB
4250                       || type == N_SETA)
4251                     type |= N_EXT;
4252
4253                   type &=~ N_TYPE;
4254
4255                   if (output_section == obj_textsec (output_bfd))
4256                     type |= (hresolve->root.type == bfd_link_hash_defined
4257                              ? N_TEXT
4258                              : N_WEAKT);
4259                   else if (output_section == obj_datasec (output_bfd))
4260                     type |= (hresolve->root.type == bfd_link_hash_defined
4261                              ? N_DATA
4262                              : N_WEAKD);
4263                   else if (output_section == obj_bsssec (output_bfd))
4264                     type |= (hresolve->root.type == bfd_link_hash_defined
4265                              ? N_BSS
4266                              : N_WEAKB);
4267                   else
4268                     type |= (hresolve->root.type == bfd_link_hash_defined
4269                              ? N_ABS
4270                              : N_WEAKA);
4271                 }
4272               else if (hresolve->root.type == bfd_link_hash_common)
4273                 val = hresolve->root.u.c.size;
4274               else if (hresolve->root.type == bfd_link_hash_undefweak)
4275                 {
4276                   val = 0;
4277                   type = N_WEAKU;
4278                 }
4279               else
4280                 val = 0;
4281             }
4282           if (symsec != (asection *) NULL)
4283             val = (symsec->output_section->vma
4284                    + symsec->output_offset
4285                    + (GET_WORD (input_bfd, sym->e_value)
4286                       - symsec->vma));
4287
4288           /* If this is a global symbol set the written flag, and if
4289              it is a local symbol see if we should discard it.  */
4290           if (h != (struct aout_link_hash_entry *) NULL)
4291             {
4292               h->written = true;
4293               h->indx = obj_aout_external_sym_count (output_bfd);
4294             }
4295           else if ((type & N_TYPE) != N_SETT
4296                    && (type & N_TYPE) != N_SETD
4297                    && (type & N_TYPE) != N_SETB
4298                    && (type & N_TYPE) != N_SETA)
4299             {
4300               switch (discard)
4301                 {
4302                 case discard_none:
4303                   break;
4304                 case discard_l:
4305                   if ((type & N_STAB) == 0
4306                       && bfd_is_local_label_name (input_bfd, name))
4307                     skip = true;
4308                   break;
4309                 case discard_all:
4310                   skip = true;
4311                   break;
4312                 }
4313               if (skip)
4314                 {
4315                   pass = false;
4316                   continue;
4317                 }
4318             }
4319
4320           /* An N_BINCL symbol indicates the start of the stabs
4321              entries for a header file.  We need to scan ahead to the
4322              next N_EINCL symbol, ignoring nesting, adding up all the
4323              characters in the symbol names, not including the file
4324              numbers in types (the first number after an open
4325              parenthesis).  */
4326           if (type == N_BINCL)
4327             {
4328               struct external_nlist *incl_sym;
4329               int nest;
4330               struct aout_link_includes_entry *incl_entry;
4331               struct aout_link_includes_totals *t;
4332
4333               val = 0;
4334               nest = 0;
4335               for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
4336                 {
4337                   int incl_type;
4338
4339                   incl_type = bfd_h_get_8 (input_bfd, incl_sym->e_type);
4340                   if (incl_type == N_EINCL)
4341                     {
4342                       if (nest == 0)
4343                         break;
4344                       --nest;
4345                     }
4346                   else if (incl_type == N_BINCL)
4347                     ++nest;
4348                   else if (nest == 0)
4349                     {
4350                       const char *s;
4351
4352                       s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
4353                       for (; *s != '\0'; s++)
4354                         {
4355                           val += *s;
4356                           if (*s == '(')
4357                             {
4358                               /* Skip the file number.  */
4359                               ++s;
4360                               while (isdigit ((unsigned char) *s))
4361                                 ++s;
4362                               --s;
4363                             }
4364                         }
4365                     }
4366                 }
4367
4368               /* If we have already included a header file with the
4369                  same value, then replace this one with an N_EXCL
4370                  symbol.  */
4371               copy = ! finfo->info->keep_memory;
4372               incl_entry = aout_link_includes_lookup (&finfo->includes,
4373                                                       name, true, copy);
4374               if (incl_entry == NULL)
4375                 return false;
4376               for (t = incl_entry->totals; t != NULL; t = t->next)
4377                 if (t->total == val)
4378                   break;
4379               if (t == NULL)
4380                 {
4381                   /* This is the first time we have seen this header
4382                      file with this set of stabs strings.  */
4383                   t = ((struct aout_link_includes_totals *)
4384                        bfd_hash_allocate (&finfo->includes.root,
4385                                           sizeof *t));
4386                   if (t == NULL)
4387                     return false;
4388                   t->total = val;
4389                   t->next = incl_entry->totals;
4390                   incl_entry->totals = t;
4391                 }
4392               else
4393                 {
4394                   int *incl_map;
4395
4396                   /* This is a duplicate header file.  We must change
4397                      it to be an N_EXCL entry, and mark all the
4398                      included symbols to prevent outputting them.  */
4399                   type = N_EXCL;
4400
4401                   nest = 0;
4402                   for (incl_sym = sym + 1, incl_map = symbol_map + 1;
4403                        incl_sym < sym_end;
4404                        incl_sym++, incl_map++)
4405                     {
4406                       int incl_type;
4407
4408                       incl_type = bfd_h_get_8 (input_bfd, incl_sym->e_type);
4409                       if (incl_type == N_EINCL)
4410                         {
4411                           if (nest == 0)
4412                             {
4413                               *incl_map = -1;
4414                               break;
4415                             }
4416                           --nest;
4417                         }
4418                       else if (incl_type == N_BINCL)
4419                         ++nest;
4420                       else if (nest == 0)
4421                         *incl_map = -1;
4422                     }
4423                 }
4424             }
4425         }
4426
4427       /* Copy this symbol into the list of symbols we are going to
4428          write out.  */
4429       bfd_h_put_8 (output_bfd, type, outsym->e_type);
4430       bfd_h_put_8 (output_bfd, bfd_h_get_8 (input_bfd, sym->e_other),
4431                    outsym->e_other);
4432       bfd_h_put_16 (output_bfd, bfd_h_get_16 (input_bfd, sym->e_desc),
4433                     outsym->e_desc);
4434       copy = false;
4435       if (! finfo->info->keep_memory)
4436         {
4437           /* name points into a string table which we are going to
4438              free.  If there is a hash table entry, use that string.
4439              Otherwise, copy name into memory.  */
4440           if (h != (struct aout_link_hash_entry *) NULL)
4441             name = h->root.root.string;
4442           else
4443             copy = true;
4444         }
4445       strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4446                                        name, copy);
4447       if (strtab_index == (bfd_size_type) -1)
4448         return false;
4449       PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4450       PUT_WORD (output_bfd, val, outsym->e_value);
4451       *symbol_map = obj_aout_external_sym_count (output_bfd);
4452       ++obj_aout_external_sym_count (output_bfd);
4453       ++outsym;
4454     }
4455
4456   /* Write out the output symbols we have just constructed.  */
4457   if (outsym > finfo->output_syms)
4458     {
4459       bfd_size_type outsym_count;
4460
4461       if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
4462         return false;
4463       outsym_count = outsym - finfo->output_syms;
4464       if (bfd_write ((PTR) finfo->output_syms,
4465                      (bfd_size_type) EXTERNAL_NLIST_SIZE,
4466                      (bfd_size_type) outsym_count, output_bfd)
4467           != outsym_count * EXTERNAL_NLIST_SIZE)
4468         return false;
4469       finfo->symoff += outsym_count * EXTERNAL_NLIST_SIZE;
4470     }
4471
4472   return true;
4473 }
4474
4475 /* Write out a symbol that was not associated with an a.out input
4476    object.  */
4477
4478 static boolean
4479 aout_link_write_other_symbol (h, data)
4480      struct aout_link_hash_entry *h;
4481      PTR data;
4482 {
4483   struct aout_final_link_info *finfo = (struct aout_final_link_info *) data;
4484   bfd *output_bfd;
4485   int type;
4486   bfd_vma val;
4487   struct external_nlist outsym;
4488   bfd_size_type indx;
4489
4490   output_bfd = finfo->output_bfd;
4491
4492   if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
4493     {
4494       if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
4495              (output_bfd, finfo->info, h)))
4496         {
4497           /* FIXME: No way to handle errors.  */
4498           abort ();
4499         }
4500     }
4501
4502   if (h->written)
4503     return true;
4504
4505   h->written = true;
4506
4507   /* An indx of -2 means the symbol must be written.  */
4508   if (h->indx != -2
4509       && (finfo->info->strip == strip_all
4510           || (finfo->info->strip == strip_some
4511               && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
4512                                   false, false) == NULL)))
4513     return true;
4514
4515   switch (h->root.type)
4516     {
4517     default:
4518       abort ();
4519       /* Avoid variable not initialized warnings.  */
4520       return true;
4521     case bfd_link_hash_new:
4522       /* This can happen for set symbols when sets are not being
4523          built.  */
4524       return true;
4525     case bfd_link_hash_undefined:
4526       type = N_UNDF | N_EXT;
4527       val = 0;
4528       break;
4529     case bfd_link_hash_defined:
4530     case bfd_link_hash_defweak:
4531       {
4532         asection *sec;
4533
4534         sec = h->root.u.def.section->output_section;
4535         BFD_ASSERT (bfd_is_abs_section (sec)
4536                     || sec->owner == output_bfd);
4537         if (sec == obj_textsec (output_bfd))
4538           type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
4539         else if (sec == obj_datasec (output_bfd))
4540           type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
4541         else if (sec == obj_bsssec (output_bfd))
4542           type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
4543         else
4544           type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
4545         type |= N_EXT;
4546         val = (h->root.u.def.value
4547                + sec->vma
4548                + h->root.u.def.section->output_offset);
4549       }
4550       break;
4551     case bfd_link_hash_common:
4552       type = N_UNDF | N_EXT;
4553       val = h->root.u.c.size;
4554       break;
4555     case bfd_link_hash_undefweak:
4556       type = N_WEAKU;
4557       val = 0;
4558     case bfd_link_hash_indirect:
4559     case bfd_link_hash_warning:
4560       /* FIXME: Ignore these for now.  The circumstances under which
4561          they should be written out are not clear to me.  */
4562       return true;
4563     }
4564
4565   bfd_h_put_8 (output_bfd, type, outsym.e_type);
4566   bfd_h_put_8 (output_bfd, 0, outsym.e_other);
4567   bfd_h_put_16 (output_bfd, 0, outsym.e_desc);
4568   indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
4569                            false);
4570   if (indx == (bfd_size_type) -1)
4571     {
4572       /* FIXME: No way to handle errors.  */
4573       abort ();
4574     }
4575   PUT_WORD (output_bfd, indx, outsym.e_strx);
4576   PUT_WORD (output_bfd, val, outsym.e_value);
4577
4578   if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0
4579       || bfd_write ((PTR) &outsym, (bfd_size_type) EXTERNAL_NLIST_SIZE,
4580                     (bfd_size_type) 1, output_bfd) != EXTERNAL_NLIST_SIZE)
4581     {
4582       /* FIXME: No way to handle errors.  */
4583       abort ();
4584     }
4585
4586   finfo->symoff += EXTERNAL_NLIST_SIZE;
4587   h->indx = obj_aout_external_sym_count (output_bfd);
4588   ++obj_aout_external_sym_count (output_bfd);
4589
4590   return true;
4591 }
4592
4593 /* Link an a.out section into the output file.  */
4594
4595 static boolean
4596 aout_link_input_section (finfo, input_bfd, input_section, reloff_ptr,
4597                          rel_size)
4598      struct aout_final_link_info *finfo;
4599      bfd *input_bfd;
4600      asection *input_section;
4601      file_ptr *reloff_ptr;
4602      bfd_size_type rel_size;
4603 {
4604   bfd_size_type input_size;
4605   PTR relocs;
4606
4607   /* Get the section contents.  */
4608   input_size = bfd_section_size (input_bfd, input_section);
4609   if (! bfd_get_section_contents (input_bfd, input_section,
4610                                   (PTR) finfo->contents,
4611                                   (file_ptr) 0, input_size))
4612     return false;
4613
4614   /* Read in the relocs if we haven't already done it.  */
4615   if (aout_section_data (input_section) != NULL
4616       && aout_section_data (input_section)->relocs != NULL)
4617     relocs = aout_section_data (input_section)->relocs;
4618   else
4619     {
4620       relocs = finfo->relocs;
4621       if (rel_size > 0)
4622         {
4623           if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4624               || bfd_read (relocs, 1, rel_size, input_bfd) != rel_size)
4625             return false;
4626         }
4627     }
4628
4629   /* Relocate the section contents.  */
4630   if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
4631     {
4632       if (! aout_link_input_section_std (finfo, input_bfd, input_section,
4633                                          (struct reloc_std_external *) relocs,
4634                                          rel_size, finfo->contents))
4635         return false;
4636     }
4637   else
4638     {
4639       if (! aout_link_input_section_ext (finfo, input_bfd, input_section,
4640                                          (struct reloc_ext_external *) relocs,
4641                                          rel_size, finfo->contents))
4642         return false;
4643     }
4644
4645   /* Write out the section contents.  */
4646   if (! bfd_set_section_contents (finfo->output_bfd,
4647                                   input_section->output_section,
4648                                   (PTR) finfo->contents,
4649                                   input_section->output_offset,
4650                                   input_size))
4651     return false;
4652
4653   /* If we are producing relocateable output, the relocs were
4654      modified, and we now write them out.  */
4655   if (finfo->info->relocateable && rel_size > 0)
4656     {
4657       if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
4658         return false;
4659       if (bfd_write (relocs, (bfd_size_type) 1, rel_size, finfo->output_bfd)
4660           != rel_size)
4661         return false;
4662       *reloff_ptr += rel_size;
4663
4664       /* Assert that the relocs have not run into the symbols, and
4665          that if these are the text relocs they have not run into the
4666          data relocs.  */
4667       BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
4668                   && (reloff_ptr != &finfo->treloff
4669                       || (*reloff_ptr
4670                           <= obj_datasec (finfo->output_bfd)->rel_filepos)));
4671     }
4672
4673   return true;
4674 }
4675
4676 /* Get the section corresponding to a reloc index.  */
4677
4678 static INLINE asection *
4679 aout_reloc_index_to_section (abfd, indx)
4680      bfd *abfd;
4681      int indx;
4682 {
4683   switch (indx & N_TYPE)
4684     {
4685     case N_TEXT:
4686       return obj_textsec (abfd);
4687     case N_DATA:
4688       return obj_datasec (abfd);
4689     case N_BSS:
4690       return obj_bsssec (abfd);
4691     case N_ABS:
4692     case N_UNDF:
4693       return bfd_abs_section_ptr;
4694     default:
4695       abort ();
4696     }
4697 }
4698
4699 /* Relocate an a.out section using standard a.out relocs.  */
4700
4701 static boolean
4702 aout_link_input_section_std (finfo, input_bfd, input_section, relocs,
4703                              rel_size, contents)
4704      struct aout_final_link_info *finfo;
4705      bfd *input_bfd;
4706      asection *input_section;
4707      struct reloc_std_external *relocs;
4708      bfd_size_type rel_size;
4709      bfd_byte *contents;
4710 {
4711   boolean (*check_dynamic_reloc) PARAMS ((struct bfd_link_info *,
4712                                           bfd *, asection *,
4713                                           struct aout_link_hash_entry *,
4714                                           PTR, bfd_byte *, boolean *,
4715                                           bfd_vma *));
4716   bfd *output_bfd;
4717   boolean relocateable;
4718   struct external_nlist *syms;
4719   char *strings;
4720   struct aout_link_hash_entry **sym_hashes;
4721   int *symbol_map;
4722   bfd_size_type reloc_count;
4723   register struct reloc_std_external *rel;
4724   struct reloc_std_external *rel_end;
4725
4726   output_bfd = finfo->output_bfd;
4727   check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
4728
4729   BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE);
4730   BFD_ASSERT (input_bfd->xvec->header_byteorder
4731               == output_bfd->xvec->header_byteorder);
4732
4733   relocateable = finfo->info->relocateable;
4734   syms = obj_aout_external_syms (input_bfd);
4735   strings = obj_aout_external_strings (input_bfd);
4736   sym_hashes = obj_aout_sym_hashes (input_bfd);
4737   symbol_map = finfo->symbol_map;
4738
4739   reloc_count = rel_size / RELOC_STD_SIZE;
4740   rel = relocs;
4741   rel_end = rel + reloc_count;
4742   for (; rel < rel_end; rel++)
4743     {
4744       bfd_vma r_addr;
4745       int r_index;
4746       int r_extern;
4747       int r_pcrel;
4748       int r_baserel = 0;
4749       reloc_howto_type *howto;
4750       struct aout_link_hash_entry *h = NULL;
4751       bfd_vma relocation;
4752       bfd_reloc_status_type r;
4753
4754       r_addr = GET_SWORD (input_bfd, rel->r_address);
4755
4756 #ifdef MY_reloc_howto
4757       howto = MY_reloc_howto(input_bfd, rel, r_index, r_extern, r_pcrel);
4758 #else
4759       {
4760         int r_jmptable;
4761         int r_relative;
4762         int r_length;
4763         unsigned int howto_idx;
4764
4765         if (bfd_header_big_endian (input_bfd))
4766           {
4767             r_index   =  ((rel->r_index[0] << 16)
4768                           | (rel->r_index[1] << 8)
4769                           | rel->r_index[2]);
4770             r_extern  = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
4771             r_pcrel   = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
4772             r_baserel = (0 != (rel->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
4773             r_jmptable= (0 != (rel->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
4774             r_relative= (0 != (rel->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
4775             r_length  = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
4776                          >> RELOC_STD_BITS_LENGTH_SH_BIG);
4777           }
4778         else
4779           {
4780             r_index   = ((rel->r_index[2] << 16)
4781                          | (rel->r_index[1] << 8)
4782                          | rel->r_index[0]);
4783             r_extern  = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
4784             r_pcrel   = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
4785             r_baserel = (0 != (rel->r_type[0]
4786                                & RELOC_STD_BITS_BASEREL_LITTLE));
4787             r_jmptable= (0 != (rel->r_type[0]
4788                                & RELOC_STD_BITS_JMPTABLE_LITTLE));
4789             r_relative= (0 != (rel->r_type[0]
4790                                & RELOC_STD_BITS_RELATIVE_LITTLE));
4791             r_length  = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
4792                          >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
4793           }
4794
4795         howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
4796                      + 16 * r_jmptable + 32 * r_relative);
4797         BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_std));
4798         howto = howto_table_std + howto_idx;
4799       }
4800 #endif
4801
4802       if (relocateable)
4803         {
4804           /* We are generating a relocateable output file, and must
4805              modify the reloc accordingly.  */
4806           if (r_extern)
4807             {
4808               /* If we know the symbol this relocation is against,
4809                  convert it into a relocation against a section.  This
4810                  is what the native linker does.  */
4811               h = sym_hashes[r_index];
4812               if (h != (struct aout_link_hash_entry *) NULL
4813                   && (h->root.type == bfd_link_hash_defined
4814                       || h->root.type == bfd_link_hash_defweak))
4815                 {
4816                   asection *output_section;
4817
4818                   /* Change the r_extern value.  */
4819                   if (bfd_header_big_endian (output_bfd))
4820                     rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_BIG;
4821                   else
4822                     rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE;
4823
4824                   /* Compute a new r_index.  */
4825                   output_section = h->root.u.def.section->output_section;
4826                   if (output_section == obj_textsec (output_bfd))
4827                     r_index = N_TEXT;
4828                   else if (output_section == obj_datasec (output_bfd))
4829                     r_index = N_DATA;
4830                   else if (output_section == obj_bsssec (output_bfd))
4831                     r_index = N_BSS;
4832                   else
4833                     r_index = N_ABS;
4834
4835                   /* Add the symbol value and the section VMA to the
4836                      addend stored in the contents.  */
4837                   relocation = (h->root.u.def.value
4838                                 + output_section->vma
4839                                 + h->root.u.def.section->output_offset);
4840                 }
4841               else
4842                 {
4843                   /* We must change r_index according to the symbol
4844                      map.  */
4845                   r_index = symbol_map[r_index];
4846
4847                   if (r_index == -1)
4848                     {
4849                       if (h != NULL)
4850                         {
4851                           /* We decided to strip this symbol, but it
4852                              turns out that we can't.  Note that we
4853                              lose the other and desc information here.
4854                              I don't think that will ever matter for a
4855                              global symbol.  */
4856                           if (h->indx < 0)
4857                             {
4858                               h->indx = -2;
4859                               h->written = false;
4860                               if (! aout_link_write_other_symbol (h,
4861                                                                   (PTR) finfo))
4862                                 return false;
4863                             }
4864                           r_index = h->indx;
4865                         }
4866                       else
4867                         {
4868                           const char *name;
4869
4870                           name = strings + GET_WORD (input_bfd,
4871                                                      syms[r_index].e_strx);
4872                           if (! ((*finfo->info->callbacks->unattached_reloc)
4873                                  (finfo->info, name, input_bfd, input_section,
4874                                   r_addr)))
4875                             return false;
4876                           r_index = 0;
4877                         }
4878                     }
4879
4880                   relocation = 0;
4881                 }
4882
4883               /* Write out the new r_index value.  */
4884               if (bfd_header_big_endian (output_bfd))
4885                 {
4886                   rel->r_index[0] = r_index >> 16;
4887                   rel->r_index[1] = r_index >> 8;
4888                   rel->r_index[2] = r_index;
4889                 }
4890               else
4891                 {
4892                   rel->r_index[2] = r_index >> 16;
4893                   rel->r_index[1] = r_index >> 8;
4894                   rel->r_index[0] = r_index;
4895                 }
4896             }
4897           else
4898             {
4899               asection *section;
4900
4901               /* This is a relocation against a section.  We must
4902                  adjust by the amount that the section moved.  */
4903               section = aout_reloc_index_to_section (input_bfd, r_index);
4904               relocation = (section->output_section->vma
4905                             + section->output_offset
4906                             - section->vma);
4907             }
4908
4909           /* Change the address of the relocation.  */
4910           PUT_WORD (output_bfd,
4911                     r_addr + input_section->output_offset,
4912                     rel->r_address);
4913
4914           /* Adjust a PC relative relocation by removing the reference
4915              to the original address in the section and including the
4916              reference to the new address.  */
4917           if (r_pcrel)
4918             relocation -= (input_section->output_section->vma
4919                            + input_section->output_offset
4920                            - input_section->vma);
4921
4922 #ifdef MY_relocatable_reloc
4923           MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
4924 #endif
4925
4926           if (relocation == 0)
4927             r = bfd_reloc_ok;
4928           else
4929             r = MY_relocate_contents (howto,
4930                                         input_bfd, relocation,
4931                                         contents + r_addr);
4932         }
4933       else
4934         {
4935           boolean hundef;
4936
4937           /* We are generating an executable, and must do a full
4938              relocation.  */
4939           hundef = false;
4940           if (r_extern)
4941             {
4942               h = sym_hashes[r_index];
4943
4944               if (h != (struct aout_link_hash_entry *) NULL
4945                   && (h->root.type == bfd_link_hash_defined
4946                       || h->root.type == bfd_link_hash_defweak))
4947                 {
4948                   relocation = (h->root.u.def.value
4949                                 + h->root.u.def.section->output_section->vma
4950                                 + h->root.u.def.section->output_offset);
4951                 }
4952               else if (h != (struct aout_link_hash_entry *) NULL
4953                        && h->root.type == bfd_link_hash_undefweak)
4954                 relocation = 0;
4955               else
4956                 {
4957                   hundef = true;
4958                   relocation = 0;
4959                 }
4960             }
4961           else
4962             {
4963               asection *section;
4964
4965               section = aout_reloc_index_to_section (input_bfd, r_index);
4966               relocation = (section->output_section->vma
4967                             + section->output_offset
4968                             - section->vma);
4969               if (r_pcrel)
4970                 relocation += input_section->vma;
4971             }
4972
4973           if (check_dynamic_reloc != NULL)
4974             {
4975               boolean skip;
4976
4977               if (! ((*check_dynamic_reloc)
4978                      (finfo->info, input_bfd, input_section, h,
4979                       (PTR) rel, contents, &skip, &relocation)))
4980                 return false;
4981               if (skip)
4982                 continue;
4983             }
4984
4985           /* Now warn if a global symbol is undefined.  We could not
4986              do this earlier, because check_dynamic_reloc might want
4987              to skip this reloc.  */
4988           if (hundef && ! finfo->info->shared && ! r_baserel)
4989             {
4990               const char *name;
4991
4992               if (h != NULL)
4993                 name = h->root.root.string;
4994               else
4995                 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
4996               if (! ((*finfo->info->callbacks->undefined_symbol)
4997                      (finfo->info, name, input_bfd, input_section, r_addr)))
4998                 return false;
4999             }
5000
5001           r = MY_final_link_relocate (howto,
5002                                       input_bfd, input_section,
5003                                       contents, r_addr, relocation,
5004                                       (bfd_vma) 0);
5005         }
5006
5007       if (r != bfd_reloc_ok)
5008         {
5009           switch (r)
5010             {
5011             default:
5012             case bfd_reloc_outofrange:
5013               abort ();
5014             case bfd_reloc_overflow:
5015               {
5016                 const char *name;
5017
5018                 if (h != NULL)
5019                   name = h->root.root.string;
5020                 else if (r_extern)
5021                   name = strings + GET_WORD (input_bfd,
5022                                              syms[r_index].e_strx);
5023                 else
5024                   {
5025                     asection *s;
5026
5027                     s = aout_reloc_index_to_section (input_bfd, r_index);
5028                     name = bfd_section_name (input_bfd, s);
5029                   }
5030                 if (! ((*finfo->info->callbacks->reloc_overflow)
5031                        (finfo->info, name, howto->name,
5032                         (bfd_vma) 0, input_bfd, input_section, r_addr)))
5033                   return false;
5034               }
5035               break;
5036             }
5037         }
5038     }
5039
5040   return true;
5041 }
5042
5043 /* Relocate an a.out section using extended a.out relocs.  */
5044
5045 static boolean
5046 aout_link_input_section_ext (finfo, input_bfd, input_section, relocs,
5047                              rel_size, contents)
5048      struct aout_final_link_info *finfo;
5049      bfd *input_bfd;
5050      asection *input_section;
5051      struct reloc_ext_external *relocs;
5052      bfd_size_type rel_size;
5053      bfd_byte *contents;
5054 {
5055   boolean (*check_dynamic_reloc) PARAMS ((struct bfd_link_info *,
5056                                           bfd *, asection *,
5057                                           struct aout_link_hash_entry *,
5058                                           PTR, bfd_byte *, boolean *,
5059                                           bfd_vma *));
5060   bfd *output_bfd;
5061   boolean relocateable;
5062   struct external_nlist *syms;
5063   char *strings;
5064   struct aout_link_hash_entry **sym_hashes;
5065   int *symbol_map;
5066   bfd_size_type reloc_count;
5067   register struct reloc_ext_external *rel;
5068   struct reloc_ext_external *rel_end;
5069
5070   output_bfd = finfo->output_bfd;
5071   check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
5072
5073   BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_EXT_SIZE);
5074   BFD_ASSERT (input_bfd->xvec->header_byteorder
5075               == output_bfd->xvec->header_byteorder);
5076
5077   relocateable = finfo->info->relocateable;
5078   syms = obj_aout_external_syms (input_bfd);
5079   strings = obj_aout_external_strings (input_bfd);
5080   sym_hashes = obj_aout_sym_hashes (input_bfd);
5081   symbol_map = finfo->symbol_map;
5082
5083   reloc_count = rel_size / RELOC_EXT_SIZE;
5084   rel = relocs;
5085   rel_end = rel + reloc_count;
5086   for (; rel < rel_end; rel++)
5087     {
5088       bfd_vma r_addr;
5089       int r_index;
5090       int r_extern;
5091       unsigned int r_type;
5092       bfd_vma r_addend;
5093       struct aout_link_hash_entry *h = NULL;
5094       asection *r_section = NULL;
5095       bfd_vma relocation;
5096
5097       r_addr = GET_SWORD (input_bfd, rel->r_address);
5098
5099       if (bfd_header_big_endian (input_bfd))
5100         {
5101           r_index  = ((rel->r_index[0] << 16)
5102                       | (rel->r_index[1] << 8)
5103                       | rel->r_index[2]);
5104           r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
5105           r_type   = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
5106                       >> RELOC_EXT_BITS_TYPE_SH_BIG);
5107         }
5108       else
5109         {
5110           r_index  = ((rel->r_index[2] << 16)
5111                       | (rel->r_index[1] << 8)
5112                       | rel->r_index[0]);
5113           r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
5114           r_type   = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
5115                       >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
5116         }
5117
5118       r_addend = GET_SWORD (input_bfd, rel->r_addend);
5119
5120       BFD_ASSERT (r_type < TABLE_SIZE (howto_table_ext));
5121
5122       if (relocateable)
5123         {
5124           /* We are generating a relocateable output file, and must
5125              modify the reloc accordingly.  */
5126           if (r_extern
5127               || r_type == RELOC_BASE10
5128               || r_type == RELOC_BASE13
5129               || r_type == RELOC_BASE22)
5130             {
5131               /* If we know the symbol this relocation is against,
5132                  convert it into a relocation against a section.  This
5133                  is what the native linker does.  */
5134               if (r_type == RELOC_BASE10
5135                   || r_type == RELOC_BASE13
5136                   || r_type == RELOC_BASE22)
5137                 h = NULL;
5138               else
5139                 h = sym_hashes[r_index];
5140               if (h != (struct aout_link_hash_entry *) NULL
5141                   && (h->root.type == bfd_link_hash_defined
5142                       || h->root.type == bfd_link_hash_defweak))
5143                 {
5144                   asection *output_section;
5145
5146                   /* Change the r_extern value.  */
5147                   if (bfd_header_big_endian (output_bfd))
5148                     rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_BIG;
5149                   else
5150                     rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE;
5151
5152                   /* Compute a new r_index.  */
5153                   output_section = h->root.u.def.section->output_section;
5154                   if (output_section == obj_textsec (output_bfd))
5155                     r_index = N_TEXT;
5156                   else if (output_section == obj_datasec (output_bfd))
5157                     r_index = N_DATA;
5158                   else if (output_section == obj_bsssec (output_bfd))
5159                     r_index = N_BSS;
5160                   else
5161                     r_index = N_ABS;
5162
5163                   /* Add the symbol value and the section VMA to the
5164                      addend.  */
5165                   relocation = (h->root.u.def.value
5166                                 + output_section->vma
5167                                 + h->root.u.def.section->output_offset);
5168
5169                   /* Now RELOCATION is the VMA of the final
5170                      destination.  If this is a PC relative reloc,
5171                      then ADDEND is the negative of the source VMA.
5172                      We want to set ADDEND to the difference between
5173                      the destination VMA and the source VMA, which
5174                      means we must adjust RELOCATION by the change in
5175                      the source VMA.  This is done below.  */
5176                 }
5177               else
5178                 {
5179                   /* We must change r_index according to the symbol
5180                      map.  */
5181                   r_index = symbol_map[r_index];
5182
5183                   if (r_index == -1)
5184                     {
5185                       if (h != NULL)
5186                         {
5187                           /* We decided to strip this symbol, but it
5188                              turns out that we can't.  Note that we
5189                              lose the other and desc information here.
5190                              I don't think that will ever matter for a
5191                              global symbol.  */
5192                           if (h->indx < 0)
5193                             {
5194                               h->indx = -2;
5195                               h->written = false;
5196                               if (! aout_link_write_other_symbol (h,
5197                                                                   (PTR) finfo))
5198                                 return false;
5199                             }
5200                           r_index = h->indx;
5201                         }
5202                       else
5203                         {
5204                           const char *name;
5205
5206                           name = strings + GET_WORD (input_bfd,
5207                                                      syms[r_index].e_strx);
5208                           if (! ((*finfo->info->callbacks->unattached_reloc)
5209                                  (finfo->info, name, input_bfd, input_section,
5210                                   r_addr)))
5211                             return false;
5212                           r_index = 0;
5213                         }
5214                     }
5215
5216                   relocation = 0;
5217
5218                   /* If this is a PC relative reloc, then the addend
5219                      is the negative of the source VMA.  We must
5220                      adjust it by the change in the source VMA.  This
5221                      is done below.  */
5222                 }
5223
5224               /* Write out the new r_index value.  */
5225               if (bfd_header_big_endian (output_bfd))
5226                 {
5227                   rel->r_index[0] = r_index >> 16;
5228                   rel->r_index[1] = r_index >> 8;
5229                   rel->r_index[2] = r_index;
5230                 }
5231               else
5232                 {
5233                   rel->r_index[2] = r_index >> 16;
5234                   rel->r_index[1] = r_index >> 8;
5235                   rel->r_index[0] = r_index;
5236                 }
5237             }
5238           else
5239             {
5240               /* This is a relocation against a section.  We must
5241                  adjust by the amount that the section moved.  */
5242               r_section = aout_reloc_index_to_section (input_bfd, r_index);
5243               relocation = (r_section->output_section->vma
5244                             + r_section->output_offset
5245                             - r_section->vma);
5246
5247               /* If this is a PC relative reloc, then the addend is
5248                  the difference in VMA between the destination and the
5249                  source.  We have just adjusted for the change in VMA
5250                  of the destination, so we must also adjust by the
5251                  change in VMA of the source.  This is done below.  */
5252             }
5253
5254           /* As described above, we must always adjust a PC relative
5255              reloc by the change in VMA of the source.  However, if
5256              pcrel_offset is set, then the addend does not include the
5257              location within the section, in which case we don't need
5258              to adjust anything.  */
5259           if (howto_table_ext[r_type].pc_relative
5260               && ! howto_table_ext[r_type].pcrel_offset)
5261             relocation -= (input_section->output_section->vma
5262                            + input_section->output_offset
5263                            - input_section->vma);
5264
5265           /* Change the addend if necessary.  */
5266           if (relocation != 0)
5267             PUT_WORD (output_bfd, r_addend + relocation, rel->r_addend);
5268
5269           /* Change the address of the relocation.  */
5270           PUT_WORD (output_bfd,
5271                     r_addr + input_section->output_offset,
5272                     rel->r_address);
5273         }
5274       else
5275         {
5276           boolean hundef;
5277           bfd_reloc_status_type r;
5278
5279           /* We are generating an executable, and must do a full
5280              relocation.  */
5281           hundef = false;
5282           if (r_extern)
5283             {
5284               h = sym_hashes[r_index];
5285
5286               if (h != (struct aout_link_hash_entry *) NULL
5287                   && (h->root.type == bfd_link_hash_defined
5288                       || h->root.type == bfd_link_hash_defweak))
5289                 {
5290                   relocation = (h->root.u.def.value
5291                                 + h->root.u.def.section->output_section->vma
5292                                 + h->root.u.def.section->output_offset);
5293                 }
5294               else if (h != (struct aout_link_hash_entry *) NULL
5295                        && h->root.type == bfd_link_hash_undefweak)
5296                 relocation = 0;
5297               else
5298                 {
5299                   hundef = true;
5300                   relocation = 0;
5301                 }
5302             }
5303           else if (r_type == RELOC_BASE10
5304                    || r_type == RELOC_BASE13
5305                    || r_type == RELOC_BASE22)
5306             {
5307               struct external_nlist *sym;
5308               int type;
5309
5310               /* For base relative relocs, r_index is always an index
5311                  into the symbol table, even if r_extern is 0.  */
5312               sym = syms + r_index;
5313               type = bfd_h_get_8 (input_bfd, sym->e_type);
5314               if ((type & N_TYPE) == N_TEXT
5315                   || type == N_WEAKT)
5316                 r_section = obj_textsec (input_bfd);
5317               else if ((type & N_TYPE) == N_DATA
5318                        || type == N_WEAKD)
5319                 r_section = obj_datasec (input_bfd);
5320               else if ((type & N_TYPE) == N_BSS
5321                        || type == N_WEAKB)
5322                 r_section = obj_bsssec (input_bfd);
5323               else if ((type & N_TYPE) == N_ABS
5324                        || type == N_WEAKA)
5325                 r_section = bfd_abs_section_ptr;
5326               else
5327                 abort ();
5328               relocation = (r_section->output_section->vma
5329                             + r_section->output_offset
5330                             + (GET_WORD (input_bfd, sym->e_value)
5331                                - r_section->vma));
5332             }
5333           else
5334             {
5335               r_section = aout_reloc_index_to_section (input_bfd, r_index);
5336
5337               /* If this is a PC relative reloc, then R_ADDEND is the
5338                  difference between the two vmas, or
5339                    old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
5340                  where
5341                    old_dest_sec == section->vma
5342                  and
5343                    old_src_sec == input_section->vma
5344                  and
5345                    old_src_off == r_addr
5346
5347                  _bfd_final_link_relocate expects RELOCATION +
5348                  R_ADDEND to be the VMA of the destination minus
5349                  r_addr (the minus r_addr is because this relocation
5350                  is not pcrel_offset, which is a bit confusing and
5351                  should, perhaps, be changed), or
5352                    new_dest_sec
5353                  where
5354                    new_dest_sec == output_section->vma + output_offset
5355                  We arrange for this to happen by setting RELOCATION to
5356                    new_dest_sec + old_src_sec - old_dest_sec
5357
5358                  If this is not a PC relative reloc, then R_ADDEND is
5359                  simply the VMA of the destination, so we set
5360                  RELOCATION to the change in the destination VMA, or
5361                    new_dest_sec - old_dest_sec
5362                  */
5363               relocation = (r_section->output_section->vma
5364                             + r_section->output_offset
5365                             - r_section->vma);
5366               if (howto_table_ext[r_type].pc_relative)
5367                 relocation += input_section->vma;
5368             }
5369
5370           if (check_dynamic_reloc != NULL)
5371             {
5372               boolean skip;
5373
5374               if (! ((*check_dynamic_reloc)
5375                      (finfo->info, input_bfd, input_section, h,
5376                       (PTR) rel, contents, &skip, &relocation)))
5377                 return false;
5378               if (skip)
5379                 continue;
5380             }
5381
5382           /* Now warn if a global symbol is undefined.  We could not
5383              do this earlier, because check_dynamic_reloc might want
5384              to skip this reloc.  */
5385           if (hundef
5386               && ! finfo->info->shared
5387               && r_type != RELOC_BASE10
5388               && r_type != RELOC_BASE13
5389               && r_type != RELOC_BASE22)
5390             {
5391               const char *name;
5392
5393               if (h != NULL)
5394                 name = h->root.root.string;
5395               else
5396                 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
5397               if (! ((*finfo->info->callbacks->undefined_symbol)
5398                      (finfo->info, name, input_bfd, input_section, r_addr)))
5399                 return false;
5400             }
5401
5402           r = MY_final_link_relocate (howto_table_ext + r_type,
5403                                       input_bfd, input_section,
5404                                       contents, r_addr, relocation,
5405                                       r_addend);
5406           if (r != bfd_reloc_ok)
5407             {
5408               switch (r)
5409                 {
5410                 default:
5411                 case bfd_reloc_outofrange:
5412                   abort ();
5413                 case bfd_reloc_overflow:
5414                   {
5415                     const char *name;
5416
5417                     if (h != NULL)
5418                       name = h->root.root.string;
5419                     else if (r_extern
5420                              || r_type == RELOC_BASE10
5421                              || r_type == RELOC_BASE13
5422                              || r_type == RELOC_BASE22)
5423                       name = strings + GET_WORD (input_bfd,
5424                                                  syms[r_index].e_strx);
5425                     else
5426                       {
5427                         asection *s;
5428
5429                         s = aout_reloc_index_to_section (input_bfd, r_index);
5430                         name = bfd_section_name (input_bfd, s);
5431                       }
5432                     if (! ((*finfo->info->callbacks->reloc_overflow)
5433                            (finfo->info, name, howto_table_ext[r_type].name,
5434                             r_addend, input_bfd, input_section, r_addr)))
5435                       return false;
5436                   }
5437                   break;
5438                 }
5439             }
5440         }
5441     }
5442
5443   return true;
5444 }
5445
5446 /* Handle a link order which is supposed to generate a reloc.  */
5447
5448 static boolean
5449 aout_link_reloc_link_order (finfo, o, p)
5450      struct aout_final_link_info *finfo;
5451      asection *o;
5452      struct bfd_link_order *p;
5453 {
5454   struct bfd_link_order_reloc *pr;
5455   int r_index;
5456   int r_extern;
5457   reloc_howto_type *howto;
5458   file_ptr *reloff_ptr;
5459   struct reloc_std_external srel;
5460   struct reloc_ext_external erel;
5461   PTR rel_ptr;
5462
5463   pr = p->u.reloc.p;
5464
5465   if (p->type == bfd_section_reloc_link_order)
5466     {
5467       r_extern = 0;
5468       if (bfd_is_abs_section (pr->u.section))
5469         r_index = N_ABS | N_EXT;
5470       else
5471         {
5472           BFD_ASSERT (pr->u.section->owner == finfo->output_bfd);
5473           r_index = pr->u.section->target_index;
5474         }
5475     }
5476   else
5477     {
5478       struct aout_link_hash_entry *h;
5479
5480       BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
5481       r_extern = 1;
5482       h = ((struct aout_link_hash_entry *)
5483            bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
5484                                          pr->u.name, false, false, true));
5485       if (h != (struct aout_link_hash_entry *) NULL
5486           && h->indx >= 0)
5487         r_index = h->indx;
5488       else if (h != NULL)
5489         {
5490           /* We decided to strip this symbol, but it turns out that we
5491              can't.  Note that we lose the other and desc information
5492              here.  I don't think that will ever matter for a global
5493              symbol.  */
5494           h->indx = -2;
5495           h->written = false;
5496           if (! aout_link_write_other_symbol (h, (PTR) finfo))
5497             return false;
5498           r_index = h->indx;
5499         }
5500       else
5501         {
5502           if (! ((*finfo->info->callbacks->unattached_reloc)
5503                  (finfo->info, pr->u.name, (bfd *) NULL,
5504                   (asection *) NULL, (bfd_vma) 0)))
5505             return false;
5506           r_index = 0;
5507         }
5508     }
5509
5510   howto = bfd_reloc_type_lookup (finfo->output_bfd, pr->reloc);
5511   if (howto == 0)
5512     {
5513       bfd_set_error (bfd_error_bad_value);
5514       return false;
5515     }
5516
5517   if (o == obj_textsec (finfo->output_bfd))
5518     reloff_ptr = &finfo->treloff;
5519   else if (o == obj_datasec (finfo->output_bfd))
5520     reloff_ptr = &finfo->dreloff;
5521   else
5522     abort ();
5523
5524   if (obj_reloc_entry_size (finfo->output_bfd) == RELOC_STD_SIZE)
5525     {
5526 #ifdef MY_put_reloc
5527       MY_put_reloc(finfo->output_bfd, r_extern, r_index, p->offset, howto,
5528                    &srel);
5529 #else
5530       {
5531         int r_pcrel;
5532         int r_baserel;
5533         int r_jmptable;
5534         int r_relative;
5535         int r_length;
5536
5537         r_pcrel = howto->pc_relative;
5538         r_baserel = (howto->type & 8) != 0;
5539         r_jmptable = (howto->type & 16) != 0;
5540         r_relative = (howto->type & 32) != 0;
5541         r_length = howto->size;
5542
5543         PUT_WORD (finfo->output_bfd, p->offset, srel.r_address);
5544         if (bfd_header_big_endian (finfo->output_bfd))
5545           {
5546             srel.r_index[0] = r_index >> 16;
5547             srel.r_index[1] = r_index >> 8;
5548             srel.r_index[2] = r_index;
5549             srel.r_type[0] =
5550               ((r_extern ?     RELOC_STD_BITS_EXTERN_BIG : 0)
5551                | (r_pcrel ?    RELOC_STD_BITS_PCREL_BIG : 0)
5552                | (r_baserel ?  RELOC_STD_BITS_BASEREL_BIG : 0)
5553                | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
5554                | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
5555                | (r_length <<  RELOC_STD_BITS_LENGTH_SH_BIG));
5556           }
5557         else
5558           {
5559             srel.r_index[2] = r_index >> 16;
5560             srel.r_index[1] = r_index >> 8;
5561             srel.r_index[0] = r_index;
5562             srel.r_type[0] =
5563               ((r_extern ?     RELOC_STD_BITS_EXTERN_LITTLE : 0)
5564                | (r_pcrel ?    RELOC_STD_BITS_PCREL_LITTLE : 0)
5565                | (r_baserel ?  RELOC_STD_BITS_BASEREL_LITTLE : 0)
5566                | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
5567                | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
5568                | (r_length <<  RELOC_STD_BITS_LENGTH_SH_LITTLE));
5569           }
5570       }
5571 #endif
5572       rel_ptr = (PTR) &srel;
5573
5574       /* We have to write the addend into the object file, since
5575          standard a.out relocs are in place.  It would be more
5576          reliable if we had the current contents of the file here,
5577          rather than assuming zeroes, but we can't read the file since
5578          it was opened using bfd_openw.  */
5579       if (pr->addend != 0)
5580         {
5581           bfd_size_type size;
5582           bfd_reloc_status_type r;
5583           bfd_byte *buf;
5584           boolean ok;
5585
5586           size = bfd_get_reloc_size (howto);
5587           buf = (bfd_byte *) bfd_zmalloc (size);
5588           if (buf == (bfd_byte *) NULL)
5589             return false;
5590           r = MY_relocate_contents (howto, finfo->output_bfd,
5591                                       pr->addend, buf);
5592           switch (r)
5593             {
5594             case bfd_reloc_ok:
5595               break;
5596             default:
5597             case bfd_reloc_outofrange:
5598               abort ();
5599             case bfd_reloc_overflow:
5600               if (! ((*finfo->info->callbacks->reloc_overflow)
5601                      (finfo->info,
5602                       (p->type == bfd_section_reloc_link_order
5603                        ? bfd_section_name (finfo->output_bfd,
5604                                            pr->u.section)
5605                        : pr->u.name),
5606                       howto->name, pr->addend, (bfd *) NULL,
5607                       (asection *) NULL, (bfd_vma) 0)))
5608                 {
5609                   free (buf);
5610                   return false;
5611                 }
5612               break;
5613             }
5614           ok = bfd_set_section_contents (finfo->output_bfd, o,
5615                                          (PTR) buf,
5616                                          (file_ptr) p->offset,
5617                                          size);
5618           free (buf);
5619           if (! ok)
5620             return false;
5621         }
5622     }
5623   else
5624     {
5625       PUT_WORD (finfo->output_bfd, p->offset, erel.r_address);
5626
5627       if (bfd_header_big_endian (finfo->output_bfd))
5628         {
5629           erel.r_index[0] = r_index >> 16;
5630           erel.r_index[1] = r_index >> 8;
5631           erel.r_index[2] = r_index;
5632           erel.r_type[0] =
5633             ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
5634              | (howto->type << RELOC_EXT_BITS_TYPE_SH_BIG));
5635         }
5636       else
5637         {
5638           erel.r_index[2] = r_index >> 16;
5639           erel.r_index[1] = r_index >> 8;
5640           erel.r_index[0] = r_index;
5641           erel.r_type[0] =
5642             (r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
5643               | (howto->type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
5644         }
5645
5646       PUT_WORD (finfo->output_bfd, pr->addend, erel.r_addend);
5647
5648       rel_ptr = (PTR) &erel;
5649     }
5650
5651   if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
5652       || (bfd_write (rel_ptr, (bfd_size_type) 1,
5653                      obj_reloc_entry_size (finfo->output_bfd),
5654                      finfo->output_bfd)
5655           != obj_reloc_entry_size (finfo->output_bfd)))
5656     return false;
5657
5658   *reloff_ptr += obj_reloc_entry_size (finfo->output_bfd);
5659
5660   /* Assert that the relocs have not run into the symbols, and that n
5661      the text relocs have not run into the data relocs.  */
5662   BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
5663               && (reloff_ptr != &finfo->treloff
5664                   || (*reloff_ptr
5665                       <= obj_datasec (finfo->output_bfd)->rel_filepos)));
5666
5667   return true;
5668 }