bfd/aoutx.h

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