bfd/aoutx.h

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