bfd/aoutx.h

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