bfd/aoutx.h

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