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   if (cached_size == 0)
1743     return TRUE;                /* Nothing to do.  */
1744
1745   cached_size *= sizeof (aout_symbol_type);
1746   cached = bfd_zmalloc (cached_size);
1747   if (cached == NULL)
1748     return FALSE;
1749
1750   /* Convert from external symbol information to internal.  */
1751   if (! (NAME (aout, translate_symbol_table)
1752          (abfd, cached,
1753           obj_aout_external_syms (abfd),
1754           obj_aout_external_sym_count (abfd),
1755           obj_aout_external_strings (abfd),
1756           obj_aout_external_string_size (abfd),
1757           FALSE)))
1758     {
1759       free (cached);
1760       return FALSE;
1761     }
1762
1763   bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
1764
1765   obj_aout_symbols (abfd) = cached;
1766
1767   /* It is very likely that anybody who calls this function will not
1768      want the external symbol information, so if it was allocated
1769      because of our call to aout_get_external_symbols, we free it up
1770      right away to save space.  */
1771   if (old_external_syms == NULL
1772       && obj_aout_external_syms (abfd) != NULL)
1773     {
1774 #ifdef USE_MMAP
1775       bfd_free_window (&obj_aout_sym_window (abfd));
1776 #else
1777       free (obj_aout_external_syms (abfd));
1778 #endif
1779       obj_aout_external_syms (abfd) = NULL;
1780     }
1781
1782   return TRUE;
1783 }
1784 \f
1785 /* We use a hash table when writing out symbols so that we only write
1786    out a particular string once.  This helps particularly when the
1787    linker writes out stabs debugging entries, because each different
1788    contributing object file tends to have many duplicate stabs
1789    strings.
1790
1791    This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1792    if BFD_TRADITIONAL_FORMAT is set.  */
1793
1794 /* Get the index of a string in a strtab, adding it if it is not
1795    already present.  */
1796
1797 static inline bfd_size_type
1798 add_to_stringtab (bfd *abfd,
1799                   struct bfd_strtab_hash *tab,
1800                   const char *str,
1801                   bfd_boolean copy)
1802 {
1803   bfd_boolean hash;
1804   bfd_size_type index;
1805
1806   /* An index of 0 always means the empty string.  */
1807   if (str == 0 || *str == '\0')
1808     return 0;
1809
1810   /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1811      doesn't understand a hashed string table.  */
1812   hash = TRUE;
1813   if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1814     hash = FALSE;
1815
1816   index = _bfd_stringtab_add (tab, str, hash, copy);
1817
1818   if (index != (bfd_size_type) -1)
1819     /* Add BYTES_IN_WORD to the return value to account for the
1820        space taken up by the string table size.  */
1821     index += BYTES_IN_WORD;
1822
1823   return index;
1824 }
1825
1826 /* Write out a strtab.  ABFD is already at the right location in the
1827    file.  */
1828
1829 static bfd_boolean
1830 emit_stringtab (bfd *abfd, struct bfd_strtab_hash *tab)
1831 {
1832   bfd_byte buffer[BYTES_IN_WORD];
1833   bfd_size_type amt = BYTES_IN_WORD;
1834
1835   /* The string table starts with the size.  */
1836   PUT_WORD (abfd, _bfd_stringtab_size (tab) + BYTES_IN_WORD, buffer);
1837   if (bfd_bwrite ((void *) buffer, amt, abfd) != amt)
1838     return FALSE;
1839
1840   return _bfd_stringtab_emit (abfd, tab);
1841 }
1842 \f
1843 bfd_boolean
1844 NAME (aout, write_syms) (bfd *abfd)
1845 {
1846   unsigned int count ;
1847   asymbol **generic = bfd_get_outsymbols (abfd);
1848   struct bfd_strtab_hash *strtab;
1849
1850   strtab = _bfd_stringtab_init ();
1851   if (strtab == NULL)
1852     return FALSE;
1853
1854   for (count = 0; count < bfd_get_symcount (abfd); count++)
1855     {
1856       asymbol *g = generic[count];
1857       bfd_size_type indx;
1858       struct external_nlist nsp;
1859       bfd_size_type amt;
1860
1861       indx = add_to_stringtab (abfd, strtab, g->name, FALSE);
1862       if (indx == (bfd_size_type) -1)
1863         goto error_return;
1864       PUT_WORD (abfd, indx, (bfd_byte *) nsp.e_strx);
1865
1866       if (bfd_asymbol_flavour (g) == abfd->xvec->flavour)
1867         {
1868           H_PUT_16 (abfd, aout_symbol (g)->desc,  nsp.e_desc);
1869           H_PUT_8  (abfd, aout_symbol (g)->other, nsp.e_other);
1870           H_PUT_8  (abfd, aout_symbol (g)->type,  nsp.e_type);
1871         }
1872       else
1873         {
1874           H_PUT_16 (abfd, 0, nsp.e_desc);
1875           H_PUT_8  (abfd, 0, nsp.e_other);
1876           H_PUT_8  (abfd, 0, nsp.e_type);
1877         }
1878
1879       if (! translate_to_native_sym_flags (abfd, g, &nsp))
1880         goto error_return;
1881
1882       amt = EXTERNAL_NLIST_SIZE;
1883       if (bfd_bwrite ((void *) &nsp, amt, abfd) != amt)
1884         goto error_return;
1885
1886       /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1887          here, at the end.  */
1888       g->KEEPIT = count;
1889     }
1890
1891   if (! emit_stringtab (abfd, strtab))
1892     goto error_return;
1893
1894   _bfd_stringtab_free (strtab);
1895
1896   return TRUE;
1897
1898 error_return:
1899   _bfd_stringtab_free (strtab);
1900   return FALSE;
1901 }
1902 \f
1903 long
1904 NAME (aout, canonicalize_symtab) (bfd *abfd, asymbol **location)
1905 {
1906   unsigned int counter = 0;
1907   aout_symbol_type *symbase;
1908
1909   if (!NAME (aout, slurp_symbol_table) (abfd))
1910     return -1;
1911
1912   for (symbase = obj_aout_symbols (abfd);
1913        counter++ < bfd_get_symcount (abfd);
1914        )
1915     *(location++) = (asymbol *) (symbase++);
1916   *location++ =0;
1917   return bfd_get_symcount (abfd);
1918 }
1919 \f
1920 /* Standard reloc stuff.  */
1921 /* Output standard relocation information to a file in target byte order.  */
1922
1923 extern void  NAME (aout, swap_std_reloc_out)
1924   (bfd *, arelent *, struct reloc_std_external *);
1925
1926 void
1927 NAME (aout, swap_std_reloc_out) (bfd *abfd,
1928                                  arelent *g,
1929                                  struct reloc_std_external *natptr)
1930 {
1931   int r_index;
1932   asymbol *sym = *(g->sym_ptr_ptr);
1933   int r_extern;
1934   unsigned int r_length;
1935   int r_pcrel;
1936   int r_baserel, r_jmptable, r_relative;
1937   asection *output_section = sym->section->output_section;
1938
1939   PUT_WORD (abfd, g->address, natptr->r_address);
1940
1941   r_length = g->howto->size ;   /* Size as a power of two.  */
1942   r_pcrel  = (int) g->howto->pc_relative; /* Relative to PC?  */
1943   /* XXX This relies on relocs coming from a.out files.  */
1944   r_baserel = (g->howto->type & 8) != 0;
1945   r_jmptable = (g->howto->type & 16) != 0;
1946   r_relative = (g->howto->type & 32) != 0;
1947
1948   /* Name was clobbered by aout_write_syms to be symbol index.  */
1949
1950   /* If this relocation is relative to a symbol then set the
1951      r_index to the symbols index, and the r_extern bit.
1952
1953      Absolute symbols can come in in two ways, either as an offset
1954      from the abs section, or as a symbol which has an abs value.
1955      check for that here.  */
1956
1957   if (bfd_is_com_section (output_section)
1958       || bfd_is_abs_section (output_section)
1959       || bfd_is_und_section (output_section)
1960       /* PR gas/3041  a.out relocs against weak symbols
1961          must be treated as if they were against externs.  */
1962       || (sym->flags & BSF_WEAK))
1963     {
1964       if (bfd_abs_section_ptr->symbol == sym)
1965         {
1966           /* Whoops, looked like an abs symbol, but is
1967              really an offset from the abs section.  */
1968           r_index = N_ABS;
1969           r_extern = 0;
1970         }
1971       else
1972         {
1973           /* Fill in symbol.  */
1974           r_extern = 1;
1975           r_index = (*(g->sym_ptr_ptr))->KEEPIT;
1976         }
1977     }
1978   else
1979     {
1980       /* Just an ordinary section.  */
1981       r_extern = 0;
1982       r_index  = output_section->target_index;
1983     }
1984
1985   /* Now the fun stuff.  */
1986   if (bfd_header_big_endian (abfd))
1987     {
1988       natptr->r_index[0] = r_index >> 16;
1989       natptr->r_index[1] = r_index >> 8;
1990       natptr->r_index[2] = r_index;
1991       natptr->r_type[0] = ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
1992                            | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
1993                            | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
1994                            | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
1995                            | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
1996                            | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
1997     }
1998   else
1999     {
2000       natptr->r_index[2] = r_index >> 16;
2001       natptr->r_index[1] = r_index >> 8;
2002       natptr->r_index[0] = r_index;
2003       natptr->r_type[0] = ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
2004                            | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
2005                            | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
2006                            | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
2007                            | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
2008                            | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
2009     }
2010 }
2011
2012 /* Extended stuff.  */
2013 /* Output extended relocation information to a file in target byte order.  */
2014
2015 extern void NAME (aout, swap_ext_reloc_out)
2016   (bfd *, arelent *, struct reloc_ext_external *);
2017
2018 void
2019 NAME (aout, swap_ext_reloc_out) (bfd *abfd,
2020                                  arelent *g,
2021                                  struct reloc_ext_external *natptr)
2022 {
2023   int r_index;
2024   int r_extern;
2025   unsigned int r_type;
2026   bfd_vma r_addend;
2027   asymbol *sym = *(g->sym_ptr_ptr);
2028   asection *output_section = sym->section->output_section;
2029
2030   PUT_WORD (abfd, g->address, natptr->r_address);
2031
2032   r_type = (unsigned int) g->howto->type;
2033
2034   r_addend = g->addend;
2035   if ((sym->flags & BSF_SECTION_SYM) != 0)
2036     r_addend += (*(g->sym_ptr_ptr))->section->output_section->vma;
2037
2038   /* If this relocation is relative to a symbol then set the
2039      r_index to the symbols index, and the r_extern bit.
2040
2041      Absolute symbols can come in in two ways, either as an offset
2042      from the abs section, or as a symbol which has an abs value.
2043      check for that here.  */
2044   if (bfd_is_abs_section (bfd_get_section (sym)))
2045     {
2046       r_extern = 0;
2047       r_index = N_ABS;
2048     }
2049   else if ((sym->flags & BSF_SECTION_SYM) == 0)
2050     {
2051       if (bfd_is_und_section (bfd_get_section (sym))
2052           || (sym->flags & BSF_GLOBAL) != 0)
2053         r_extern = 1;
2054       else
2055         r_extern = 0;
2056       r_index = (*(g->sym_ptr_ptr))->KEEPIT;
2057     }
2058   else
2059     {
2060       /* Just an ordinary section.  */
2061       r_extern = 0;
2062       r_index = output_section->target_index;
2063     }
2064
2065   /* Now the fun stuff.  */
2066   if (bfd_header_big_endian (abfd))
2067     {
2068       natptr->r_index[0] = r_index >> 16;
2069       natptr->r_index[1] = r_index >> 8;
2070       natptr->r_index[2] = r_index;
2071       natptr->r_type[0] = ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
2072                            | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG));
2073     }
2074   else
2075     {
2076       natptr->r_index[2] = r_index >> 16;
2077       natptr->r_index[1] = r_index >> 8;
2078       natptr->r_index[0] = r_index;
2079       natptr->r_type[0] = ((r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
2080                            | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE));
2081     }
2082
2083   PUT_WORD (abfd, r_addend, natptr->r_addend);
2084 }
2085
2086 /* BFD deals internally with all things based from the section they're
2087    in. so, something in 10 bytes into a text section  with a base of
2088    50 would have a symbol (.text+10) and know .text vma was 50.
2089
2090    Aout keeps all it's symbols based from zero, so the symbol would
2091    contain 60. This macro subs the base of each section from the value
2092    to give the true offset from the section.  */
2093
2094 #define MOVE_ADDRESS(ad)                                                \
2095   if (r_extern)                                                         \
2096     {                                                                   \
2097       /* Undefined symbol.  */                                          \
2098       cache_ptr->sym_ptr_ptr = symbols + r_index;                       \
2099       cache_ptr->addend = ad;                                           \
2100     }                                                                   \
2101    else                                                                 \
2102     {                                                                   \
2103       /* Defined, section relative.  Replace symbol with pointer to     \
2104          symbol which points to section.  */                            \
2105       switch (r_index)                                                  \
2106         {                                                               \
2107         case N_TEXT:                                                    \
2108         case N_TEXT | N_EXT:                                            \
2109           cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr;  \
2110           cache_ptr->addend = ad - su->textsec->vma;                    \
2111           break;                                                        \
2112         case N_DATA:                                                    \
2113         case N_DATA | N_EXT:                                            \
2114           cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr;  \
2115           cache_ptr->addend = ad - su->datasec->vma;                    \
2116           break;                                                        \
2117         case N_BSS:                                                     \
2118         case N_BSS | N_EXT:                                             \
2119           cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr;   \
2120           cache_ptr->addend = ad - su->bsssec->vma;                     \
2121           break;                                                        \
2122         default:                                                        \
2123         case N_ABS:                                                     \
2124         case N_ABS | N_EXT:                                             \
2125           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
2126           cache_ptr->addend = ad;                                       \
2127           break;                                                        \
2128         }                                                               \
2129     }
2130
2131 void
2132 NAME (aout, swap_ext_reloc_in) (bfd *abfd,
2133                                 struct reloc_ext_external *bytes,
2134                                 arelent *cache_ptr,
2135                                 asymbol **symbols,
2136                                 bfd_size_type symcount)
2137 {
2138   unsigned int r_index;
2139   int r_extern;
2140   unsigned int r_type;
2141   struct aoutdata *su = &(abfd->tdata.aout_data->a);
2142
2143   cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
2144
2145   /* Now the fun stuff.  */
2146   if (bfd_header_big_endian (abfd))
2147     {
2148       r_index = (((unsigned int) bytes->r_index[0] << 16)
2149                  | ((unsigned int) bytes->r_index[1] << 8)
2150                  | bytes->r_index[2]);
2151       r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
2152       r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
2153                 >> RELOC_EXT_BITS_TYPE_SH_BIG);
2154     }
2155   else
2156     {
2157       r_index =  (((unsigned int) bytes->r_index[2] << 16)
2158                   | ((unsigned int) bytes->r_index[1] << 8)
2159                   | bytes->r_index[0]);
2160       r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
2161       r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
2162                 >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
2163     }
2164
2165   if (r_type < TABLE_SIZE (howto_table_ext))
2166     cache_ptr->howto = howto_table_ext + r_type;
2167   else
2168     cache_ptr->howto = NULL;
2169
2170   /* Base relative relocs are always against the symbol table,
2171      regardless of the setting of r_extern.  r_extern just reflects
2172      whether the symbol the reloc is against is local or global.  */
2173   if (r_type == (unsigned int) RELOC_BASE10
2174       || r_type == (unsigned int) RELOC_BASE13
2175       || r_type == (unsigned int) RELOC_BASE22)
2176     r_extern = 1;
2177
2178   if (r_extern && r_index > symcount)
2179     {
2180       /* We could arrange to return an error, but it might be useful
2181          to see the file even if it is bad.  */
2182       r_extern = 0;
2183       r_index = N_ABS;
2184     }
2185
2186   MOVE_ADDRESS (GET_SWORD (abfd, bytes->r_addend));
2187 }
2188
2189 void
2190 NAME (aout, swap_std_reloc_in) (bfd *abfd,
2191                                 struct reloc_std_external *bytes,
2192                                 arelent *cache_ptr,
2193                                 asymbol **symbols,
2194                                 bfd_size_type symcount)
2195 {
2196   unsigned int r_index;
2197   int r_extern;
2198   unsigned int r_length;
2199   int r_pcrel;
2200   int r_baserel, r_jmptable, r_relative;
2201   struct aoutdata  *su = &(abfd->tdata.aout_data->a);
2202   unsigned int howto_idx;
2203
2204   cache_ptr->address = H_GET_32 (abfd, bytes->r_address);
2205
2206   /* Now the fun stuff.  */
2207   if (bfd_header_big_endian (abfd))
2208     {
2209       r_index = (((unsigned int) bytes->r_index[0] << 16)
2210                  | ((unsigned int) bytes->r_index[1] << 8)
2211                  | bytes->r_index[2]);
2212       r_extern  = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
2213       r_pcrel   = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
2214       r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
2215       r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
2216       r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
2217       r_length  = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
2218                    >> RELOC_STD_BITS_LENGTH_SH_BIG);
2219     }
2220   else
2221     {
2222       r_index = (((unsigned int) bytes->r_index[2] << 16)
2223                  | ((unsigned int) bytes->r_index[1] << 8)
2224                  | bytes->r_index[0]);
2225       r_extern  = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
2226       r_pcrel   = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
2227       r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
2228       r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
2229       r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_LITTLE));
2230       r_length  = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
2231                    >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
2232     }
2233
2234   howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
2235                + 16 * r_jmptable + 32 * r_relative);
2236   if (howto_idx < TABLE_SIZE (howto_table_std))
2237     {
2238       cache_ptr->howto = howto_table_std + howto_idx;
2239       if (cache_ptr->howto->type == (unsigned int) -1)
2240         cache_ptr->howto = NULL;
2241     }
2242   else
2243     cache_ptr->howto = NULL;
2244
2245   /* Base relative relocs are always against the symbol table,
2246      regardless of the setting of r_extern.  r_extern just reflects
2247      whether the symbol the reloc is against is local or global.  */
2248   if (r_baserel)
2249     r_extern = 1;
2250
2251   if (r_extern && r_index > symcount)
2252     {
2253       /* We could arrange to return an error, but it might be useful
2254          to see the file even if it is bad.  */
2255       r_extern = 0;
2256       r_index = N_ABS;
2257     }
2258
2259   MOVE_ADDRESS (0);
2260 }
2261
2262 /* Read and swap the relocs for a section.  */
2263
2264 bfd_boolean
2265 NAME (aout, slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols)
2266 {
2267   bfd_size_type count;
2268   bfd_size_type reloc_size;
2269   void * relocs;
2270   arelent *reloc_cache;
2271   size_t each_size;
2272   unsigned int counter = 0;
2273   arelent *cache_ptr;
2274   bfd_size_type amt;
2275
2276   if (asect->relocation)
2277     return TRUE;
2278
2279   if (asect->flags & SEC_CONSTRUCTOR)
2280     return TRUE;
2281
2282   if (asect == obj_datasec (abfd))
2283     reloc_size = exec_hdr (abfd)->a_drsize;
2284   else if (asect == obj_textsec (abfd))
2285     reloc_size = exec_hdr (abfd)->a_trsize;
2286   else if (asect == obj_bsssec (abfd))
2287     reloc_size = 0;
2288   else
2289     {
2290       bfd_set_error (bfd_error_invalid_operation);
2291       return FALSE;
2292     }
2293
2294   if (reloc_size == 0)
2295     return TRUE;                /* Nothing to be done.  */
2296
2297   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
2298     return FALSE;
2299
2300   each_size = obj_reloc_entry_size (abfd);
2301
2302   count = reloc_size / each_size;
2303   if (count == 0)
2304     return TRUE;                /* Nothing to be done.  */
2305
2306   amt = count * sizeof (arelent);
2307   reloc_cache = bfd_zmalloc (amt);
2308   if (reloc_cache == NULL)
2309     return FALSE;
2310
2311   relocs = bfd_malloc (reloc_size);
2312   if (relocs == NULL)
2313     {
2314       free (reloc_cache);
2315       return FALSE;
2316     }
2317
2318   if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
2319     {
2320       free (relocs);
2321       free (reloc_cache);
2322       return FALSE;
2323     }
2324
2325   cache_ptr = reloc_cache;
2326   if (each_size == RELOC_EXT_SIZE)
2327     {
2328       struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs;
2329
2330       for (; counter < count; counter++, rptr++, cache_ptr++)
2331         MY_swap_ext_reloc_in (abfd, rptr, cache_ptr, symbols,
2332                               (bfd_size_type) bfd_get_symcount (abfd));
2333     }
2334   else
2335     {
2336       struct reloc_std_external *rptr = (struct reloc_std_external *) relocs;
2337
2338       for (; counter < count; counter++, rptr++, cache_ptr++)
2339         MY_swap_std_reloc_in (abfd, rptr, cache_ptr, symbols,
2340                               (bfd_size_type) bfd_get_symcount (abfd));
2341     }
2342
2343   free (relocs);
2344
2345   asect->relocation = reloc_cache;
2346   asect->reloc_count = cache_ptr - reloc_cache;
2347
2348   return TRUE;
2349 }
2350
2351 /* Write out a relocation section into an object file.  */
2352
2353 bfd_boolean
2354 NAME (aout, squirt_out_relocs) (bfd *abfd, asection *section)
2355 {
2356   arelent **generic;
2357   unsigned char *native, *natptr;
2358   size_t each_size;
2359
2360   unsigned int count = section->reloc_count;
2361   bfd_size_type natsize;
2362
2363   if (count == 0 || section->orelocation == NULL)
2364     return TRUE;
2365
2366   each_size = obj_reloc_entry_size (abfd);
2367   natsize = (bfd_size_type) each_size * count;
2368   native = bfd_zalloc (abfd, natsize);
2369   if (!native)
2370     return FALSE;
2371
2372   generic = section->orelocation;
2373
2374   if (each_size == RELOC_EXT_SIZE)
2375     {
2376       for (natptr = native;
2377            count != 0;
2378            --count, natptr += each_size, ++generic)
2379         MY_swap_ext_reloc_out (abfd, *generic,
2380                                (struct reloc_ext_external *) natptr);
2381     }
2382   else
2383     {
2384       for (natptr = native;
2385            count != 0;
2386            --count, natptr += each_size, ++generic)
2387         MY_swap_std_reloc_out (abfd, *generic,
2388                                (struct reloc_std_external *) natptr);
2389     }
2390
2391   if (bfd_bwrite ((void *) native, natsize, abfd) != natsize)
2392     {
2393       bfd_release (abfd, native);
2394       return FALSE;
2395     }
2396   bfd_release (abfd, native);
2397
2398   return TRUE;
2399 }
2400
2401 /* This is stupid.  This function should be a boolean predicate.  */
2402
2403 long
2404 NAME (aout, canonicalize_reloc) (bfd *abfd,
2405                                  sec_ptr section,
2406                                  arelent **relptr,
2407                                  asymbol **symbols)
2408 {
2409   arelent *tblptr = section->relocation;
2410   unsigned int count;
2411
2412   if (section == obj_bsssec (abfd))
2413     {
2414       *relptr = NULL;
2415       return 0;
2416     }
2417
2418   if (!(tblptr || NAME (aout, slurp_reloc_table) (abfd, section, symbols)))
2419     return -1;
2420
2421   if (section->flags & SEC_CONSTRUCTOR)
2422     {
2423       arelent_chain *chain = section->constructor_chain;
2424       for (count = 0; count < section->reloc_count; count ++)
2425         {
2426           *relptr ++ = &chain->relent;
2427           chain = chain->next;
2428         }
2429     }
2430   else
2431     {
2432       tblptr = section->relocation;
2433
2434       for (count = 0; count++ < section->reloc_count; )
2435         {
2436           *relptr++ = tblptr++;
2437         }
2438     }
2439   *relptr = 0;
2440
2441   return section->reloc_count;
2442 }
2443
2444 long
2445 NAME (aout, get_reloc_upper_bound) (bfd *abfd, sec_ptr asect)
2446 {
2447   if (bfd_get_format (abfd) != bfd_object)
2448     {
2449       bfd_set_error (bfd_error_invalid_operation);
2450       return -1;
2451     }
2452
2453   if (asect->flags & SEC_CONSTRUCTOR)
2454     return sizeof (arelent *) * (asect->reloc_count + 1);
2455
2456   if (asect == obj_datasec (abfd))
2457     return sizeof (arelent *)
2458       * ((exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd))
2459          + 1);
2460
2461   if (asect == obj_textsec (abfd))
2462     return sizeof (arelent *)
2463       * ((exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd))
2464          + 1);
2465
2466   if (asect == obj_bsssec (abfd))
2467     return sizeof (arelent *);
2468
2469   if (asect == obj_bsssec (abfd))
2470     return 0;
2471
2472   bfd_set_error (bfd_error_invalid_operation);
2473   return -1;
2474 }
2475 \f
2476 long
2477 NAME (aout, get_symtab_upper_bound) (bfd *abfd)
2478 {
2479   if (!NAME (aout, slurp_symbol_table) (abfd))
2480     return -1;
2481
2482   return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *));
2483 }
2484
2485 alent *
2486 NAME (aout, get_lineno) (bfd *ignore_abfd ATTRIBUTE_UNUSED,
2487                          asymbol *ignore_symbol ATTRIBUTE_UNUSED)
2488 {
2489   return NULL;
2490 }
2491
2492 void
2493 NAME (aout, get_symbol_info) (bfd *ignore_abfd ATTRIBUTE_UNUSED,
2494                               asymbol *symbol,
2495                               symbol_info *ret)
2496 {
2497   bfd_symbol_info (symbol, ret);
2498
2499   if (ret->type == '?')
2500     {
2501       int type_code = aout_symbol (symbol)->type & 0xff;
2502       const char *stab_name = bfd_get_stab_name (type_code);
2503       static char buf[10];
2504
2505       if (stab_name == NULL)
2506         {
2507           sprintf (buf, "(%d)", type_code);
2508           stab_name = buf;
2509         }
2510       ret->type = '-';
2511       ret->stab_type = type_code;
2512       ret->stab_other = (unsigned) (aout_symbol (symbol)->other & 0xff);
2513       ret->stab_desc = (unsigned) (aout_symbol (symbol)->desc & 0xffff);
2514       ret->stab_name = stab_name;
2515     }
2516 }
2517
2518 void
2519 NAME (aout, print_symbol) (bfd *abfd,
2520                            void * afile,
2521                            asymbol *symbol,
2522                            bfd_print_symbol_type how)
2523 {
2524   FILE *file = (FILE *)afile;
2525
2526   switch (how)
2527     {
2528     case bfd_print_symbol_name:
2529       if (symbol->name)
2530         fprintf (file,"%s", symbol->name);
2531       break;
2532     case bfd_print_symbol_more:
2533       fprintf (file,"%4x %2x %2x",
2534                (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2535                (unsigned) (aout_symbol (symbol)->other & 0xff),
2536                (unsigned) (aout_symbol (symbol)->type));
2537       break;
2538     case bfd_print_symbol_all:
2539       {
2540         const char *section_name = symbol->section->name;
2541
2542         bfd_print_symbol_vandf (abfd, (void *)file, symbol);
2543
2544         fprintf (file," %-5s %04x %02x %02x",
2545                  section_name,
2546                  (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2547                  (unsigned) (aout_symbol (symbol)->other & 0xff),
2548                  (unsigned) (aout_symbol (symbol)->type & 0xff));
2549         if (symbol->name)
2550           fprintf (file," %s", symbol->name);
2551       }
2552       break;
2553     }
2554 }
2555
2556 /* If we don't have to allocate more than 1MB to hold the generic
2557    symbols, we use the generic minisymbol methord: it's faster, since
2558    it only translates the symbols once, not multiple times.  */
2559 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2560
2561 /* Read minisymbols.  For minisymbols, we use the unmodified a.out
2562    symbols.  The minisymbol_to_symbol function translates these into
2563    BFD asymbol structures.  */
2564
2565 long
2566 NAME (aout, read_minisymbols) (bfd *abfd,
2567                                bfd_boolean dynamic,
2568                                void * *minisymsp,
2569                                unsigned int *sizep)
2570 {
2571   if (dynamic)
2572     /* We could handle the dynamic symbols here as well, but it's
2573        easier to hand them off.  */
2574     return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2575
2576   if (! aout_get_external_symbols (abfd))
2577     return -1;
2578
2579   if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2580     return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2581
2582   *minisymsp = (void *) obj_aout_external_syms (abfd);
2583
2584   /* By passing the external symbols back from this routine, we are
2585      giving up control over the memory block.  Clear
2586      obj_aout_external_syms, so that we do not try to free it
2587      ourselves.  */
2588   obj_aout_external_syms (abfd) = NULL;
2589
2590   *sizep = EXTERNAL_NLIST_SIZE;
2591   return obj_aout_external_sym_count (abfd);
2592 }
2593
2594 /* Convert a minisymbol to a BFD asymbol.  A minisymbol is just an
2595    unmodified a.out symbol.  The SYM argument is a structure returned
2596    by bfd_make_empty_symbol, which we fill in here.  */
2597
2598 asymbol *
2599 NAME (aout, minisymbol_to_symbol) (bfd *abfd,
2600                                    bfd_boolean dynamic,
2601                                    const void * minisym,
2602                                    asymbol *sym)
2603 {
2604   if (dynamic
2605       || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2606     return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
2607
2608   memset (sym, 0, sizeof (aout_symbol_type));
2609
2610   /* We call translate_symbol_table to translate a single symbol.  */
2611   if (! (NAME (aout, translate_symbol_table)
2612          (abfd,
2613           (aout_symbol_type *) sym,
2614           (struct external_nlist *) minisym,
2615           (bfd_size_type) 1,
2616           obj_aout_external_strings (abfd),
2617           obj_aout_external_string_size (abfd),
2618           FALSE)))
2619     return NULL;
2620
2621   return sym;
2622 }
2623
2624 /* Provided a BFD, a section and an offset into the section, calculate
2625    and return the name of the source file and the line nearest to the
2626    wanted location.  */
2627
2628 bfd_boolean
2629 NAME (aout, find_nearest_line) (bfd *abfd,
2630                                 asection *section,
2631                                 asymbol **symbols,
2632                                 bfd_vma offset,
2633                                 const char **filename_ptr,
2634                                 const char **functionname_ptr,
2635                                 unsigned int *line_ptr)
2636 {
2637   /* Run down the file looking for the filename, function and linenumber.  */
2638   asymbol **p;
2639   const char *directory_name = NULL;
2640   const char *main_file_name = NULL;
2641   const char *current_file_name = NULL;
2642   const char *line_file_name = NULL;      /* Value of current_file_name at line number.  */
2643   const char *line_directory_name = NULL; /* Value of directory_name at line number.  */
2644   bfd_vma low_line_vma = 0;
2645   bfd_vma low_func_vma = 0;
2646   asymbol *func = 0;
2647   bfd_size_type filelen, funclen;
2648   char *buf;
2649
2650   *filename_ptr = abfd->filename;
2651   *functionname_ptr = 0;
2652   *line_ptr = 0;
2653
2654   if (symbols != NULL)
2655     {
2656       for (p = symbols; *p; p++)
2657         {
2658           aout_symbol_type  *q = (aout_symbol_type *) (*p);
2659         next:
2660           switch (q->type)
2661             {
2662             case N_TEXT:
2663               /* If this looks like a file name symbol, and it comes after
2664                  the line number we have found so far, but before the
2665                  offset, then we have probably not found the right line
2666                  number.  */
2667               if (q->symbol.value <= offset
2668                   && ((q->symbol.value > low_line_vma
2669                        && (line_file_name != NULL
2670                            || *line_ptr != 0))
2671                       || (q->symbol.value > low_func_vma
2672                           && func != NULL)))
2673                 {
2674                   const char *symname;
2675
2676                   symname = q->symbol.name;
2677                   if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
2678                     {
2679                       if (q->symbol.value > low_line_vma)
2680                         {
2681                           *line_ptr = 0;
2682                           line_file_name = NULL;
2683                         }
2684                       if (q->symbol.value > low_func_vma)
2685                         func = NULL;
2686                     }
2687                 }
2688               break;
2689
2690             case N_SO:
2691               /* If this symbol is less than the offset, but greater than
2692                  the line number we have found so far, then we have not
2693                  found the right line number.  */
2694               if (q->symbol.value <= offset)
2695                 {
2696                   if (q->symbol.value > low_line_vma)
2697                     {
2698                       *line_ptr = 0;
2699                       line_file_name = NULL;
2700                     }
2701                   if (q->symbol.value > low_func_vma)
2702                     func = NULL;
2703                 }
2704
2705               main_file_name = current_file_name = q->symbol.name;
2706               /* Look ahead to next symbol to check if that too is an N_SO.  */
2707               p++;
2708               if (*p == NULL)
2709                 goto done;
2710               q = (aout_symbol_type *) (*p);
2711               if (q->type != (int)N_SO)
2712                 goto next;
2713
2714               /* Found a second N_SO  First is directory; second is filename.  */
2715               directory_name = current_file_name;
2716               main_file_name = current_file_name = q->symbol.name;
2717               if (obj_textsec (abfd) != section)
2718                 goto done;
2719               break;
2720             case N_SOL:
2721               current_file_name = q->symbol.name;
2722               break;
2723
2724             case N_SLINE:
2725
2726             case N_DSLINE:
2727             case N_BSLINE:
2728               /* We'll keep this if it resolves nearer than the one we have
2729                  already.  */
2730               if (q->symbol.value >= low_line_vma
2731                   && q->symbol.value <= offset)
2732                 {
2733                   *line_ptr = q->desc;
2734                   low_line_vma = q->symbol.value;
2735                   line_file_name = current_file_name;
2736                   line_directory_name = directory_name;
2737                 }
2738               break;
2739             case N_FUN:
2740               {
2741                 /* We'll keep this if it is nearer than the one we have already.  */
2742                 if (q->symbol.value >= low_func_vma &&
2743                     q->symbol.value <= offset)
2744                   {
2745                     low_func_vma = q->symbol.value;
2746                     func = (asymbol *)q;
2747                   }
2748                 else if (q->symbol.value > offset)
2749                   goto done;
2750               }
2751               break;
2752             }
2753         }
2754     }
2755
2756  done:
2757   if (*line_ptr != 0)
2758     {
2759       main_file_name = line_file_name;
2760       directory_name = line_directory_name;
2761     }
2762
2763   if (main_file_name == NULL
2764       || IS_ABSOLUTE_PATH (main_file_name)
2765       || directory_name == NULL)
2766     filelen = 0;
2767   else
2768     filelen = strlen (directory_name) + strlen (main_file_name);
2769
2770   if (func == NULL)
2771     funclen = 0;
2772   else
2773     funclen = strlen (bfd_asymbol_name (func));
2774
2775   if (adata (abfd).line_buf != NULL)
2776     free (adata (abfd).line_buf);
2777
2778   if (filelen + funclen == 0)
2779     adata (abfd).line_buf = buf = NULL;
2780   else
2781     {
2782       buf = bfd_malloc (filelen + funclen + 3);
2783       adata (abfd).line_buf = buf;
2784       if (buf == NULL)
2785         return FALSE;
2786     }
2787
2788   if (main_file_name != NULL)
2789     {
2790       if (IS_ABSOLUTE_PATH (main_file_name) || directory_name == NULL)
2791         *filename_ptr = main_file_name;
2792       else
2793         {
2794           sprintf (buf, "%s%s", directory_name, main_file_name);
2795           *filename_ptr = buf;
2796           buf += filelen + 1;
2797         }
2798     }
2799
2800   if (func)
2801     {
2802       const char *function = func->name;
2803       char *colon;
2804
2805       /* The caller expects a symbol name.  We actually have a
2806          function name, without the leading underscore.  Put the
2807          underscore back in, so that the caller gets a symbol name.  */
2808       if (bfd_get_symbol_leading_char (abfd) == '\0')
2809         strcpy (buf, function);
2810       else
2811         {
2812           buf[0] = bfd_get_symbol_leading_char (abfd);
2813           strcpy (buf + 1, function);
2814         }
2815       /* Have to remove : stuff.  */
2816       colon = strchr (buf, ':');
2817       if (colon != NULL)
2818         *colon = '\0';
2819       *functionname_ptr = buf;
2820     }
2821
2822   return TRUE;
2823 }
2824
2825 int
2826 NAME (aout, sizeof_headers) (bfd *abfd,
2827                              struct bfd_link_info *info ATTRIBUTE_UNUSED)
2828 {
2829   return adata (abfd).exec_bytes_size;
2830 }
2831
2832 /* Free all information we have cached for this BFD.  We can always
2833    read it again later if we need it.  */
2834
2835 bfd_boolean
2836 NAME (aout, bfd_free_cached_info) (bfd *abfd)
2837 {
2838   asection *o;
2839
2840   if (bfd_get_format (abfd) != bfd_object
2841       || abfd->tdata.aout_data == NULL)
2842     return TRUE;
2843
2844 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2845   BFCI_FREE (obj_aout_symbols (abfd));
2846 #ifdef USE_MMAP
2847   obj_aout_external_syms (abfd) = 0;
2848   bfd_free_window (&obj_aout_sym_window (abfd));
2849   bfd_free_window (&obj_aout_string_window (abfd));
2850   obj_aout_external_strings (abfd) = 0;
2851 #else
2852   BFCI_FREE (obj_aout_external_syms (abfd));
2853   BFCI_FREE (obj_aout_external_strings (abfd));
2854 #endif
2855   for (o = abfd->sections; o != NULL; o = o->next)
2856     BFCI_FREE (o->relocation);
2857 #undef BFCI_FREE
2858
2859   return TRUE;
2860 }
2861 \f
2862 /* a.out link code.  */
2863
2864 /* Routine to create an entry in an a.out link hash table.  */
2865
2866 struct bfd_hash_entry *
2867 NAME (aout, link_hash_newfunc) (struct bfd_hash_entry *entry,
2868                                 struct bfd_hash_table *table,
2869                                 const char *string)
2870 {
2871   struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2872
2873   /* Allocate the structure if it has not already been allocated by a
2874      subclass.  */
2875   if (ret == NULL)
2876     ret = bfd_hash_allocate (table, sizeof (* ret));
2877   if (ret == NULL)
2878     return NULL;
2879
2880   /* Call the allocation method of the superclass.  */
2881   ret = ((struct aout_link_hash_entry *)
2882          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2883                                  table, string));
2884   if (ret)
2885     {
2886       /* Set local fields.  */
2887       ret->written = FALSE;
2888       ret->indx = -1;
2889     }
2890
2891   return (struct bfd_hash_entry *) ret;
2892 }
2893
2894 /* Initialize an a.out link hash table.  */
2895
2896 bfd_boolean
2897 NAME (aout, link_hash_table_init) (struct aout_link_hash_table *table,
2898                                    bfd *abfd,
2899                                    struct bfd_hash_entry *(*newfunc)
2900                                    (struct bfd_hash_entry *, struct bfd_hash_table *,
2901                                     const char *),
2902                                    unsigned int entsize)
2903 {
2904   return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
2905 }
2906
2907 /* Create an a.out link hash table.  */
2908
2909 struct bfd_link_hash_table *
2910 NAME (aout, link_hash_table_create) (bfd *abfd)
2911 {
2912   struct aout_link_hash_table *ret;
2913   bfd_size_type amt = sizeof (* ret);
2914
2915   ret = bfd_malloc (amt);
2916   if (ret == NULL)
2917     return NULL;
2918
2919   if (!NAME (aout, link_hash_table_init) (ret, abfd,
2920                                           NAME (aout, link_hash_newfunc),
2921                                           sizeof (struct aout_link_hash_entry)))
2922     {
2923       free (ret);
2924       return NULL;
2925     }
2926   return &ret->root;
2927 }
2928
2929 /* Add all symbols from an object file to the hash table.  */
2930
2931 static bfd_boolean
2932 aout_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
2933 {
2934   bfd_boolean (*add_one_symbol)
2935     (struct bfd_link_info *, bfd *, const char *, flagword, asection *,
2936              bfd_vma, const char *, bfd_boolean, bfd_boolean,
2937              struct bfd_link_hash_entry **);
2938   struct external_nlist *syms;
2939   bfd_size_type sym_count;
2940   char *strings;
2941   bfd_boolean copy;
2942   struct aout_link_hash_entry **sym_hash;
2943   struct external_nlist *p;
2944   struct external_nlist *pend;
2945   bfd_size_type amt;
2946
2947   syms = obj_aout_external_syms (abfd);
2948   sym_count = obj_aout_external_sym_count (abfd);
2949   strings = obj_aout_external_strings (abfd);
2950   if (info->keep_memory)
2951     copy = FALSE;
2952   else
2953     copy = TRUE;
2954
2955   if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
2956     {
2957       if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
2958              (abfd, info, &syms, &sym_count, &strings)))
2959         return FALSE;
2960     }
2961
2962   if (sym_count == 0)
2963     return TRUE;                /* Nothing to do.  */
2964
2965   /* We keep a list of the linker hash table entries that correspond
2966      to particular symbols.  We could just look them up in the hash
2967      table, but keeping the list is more efficient.  Perhaps this
2968      should be conditional on info->keep_memory.  */
2969   amt = sym_count * sizeof (struct aout_link_hash_entry *);
2970   sym_hash = bfd_alloc (abfd, amt);
2971   if (sym_hash == NULL)
2972     return FALSE;
2973   obj_aout_sym_hashes (abfd) = sym_hash;
2974
2975   add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
2976   if (add_one_symbol == NULL)
2977     add_one_symbol = _bfd_generic_link_add_one_symbol;
2978
2979   p = syms;
2980   pend = p + sym_count;
2981   for (; p < pend; p++, sym_hash++)
2982     {
2983       int type;
2984       const char *name;
2985       bfd_vma value;
2986       asection *section;
2987       flagword flags;
2988       const char *string;
2989
2990       *sym_hash = NULL;
2991
2992       type = H_GET_8 (abfd, p->e_type);
2993
2994       /* Ignore debugging symbols.  */
2995       if ((type & N_STAB) != 0)
2996         continue;
2997
2998       name = strings + GET_WORD (abfd, p->e_strx);
2999       value = GET_WORD (abfd, p->e_value);
3000       flags = BSF_GLOBAL;
3001       string = NULL;
3002       switch (type)
3003         {
3004         default:
3005           abort ();
3006
3007         case N_UNDF:
3008         case N_ABS:
3009         case N_TEXT:
3010         case N_DATA:
3011         case N_BSS:
3012         case N_FN_SEQ:
3013         case N_COMM:
3014         case N_SETV:
3015         case N_FN:
3016           /* Ignore symbols that are not externally visible.  */
3017           continue;
3018         case N_INDR:
3019           /* Ignore local indirect symbol.  */
3020           ++p;
3021           ++sym_hash;
3022           continue;
3023
3024         case N_UNDF | N_EXT:
3025           if (value == 0)
3026             {
3027               section = bfd_und_section_ptr;
3028               flags = 0;
3029             }
3030           else
3031             section = bfd_com_section_ptr;
3032           break;
3033         case N_ABS | N_EXT:
3034           section = bfd_abs_section_ptr;
3035           break;
3036         case N_TEXT | N_EXT:
3037           section = obj_textsec (abfd);
3038           value -= bfd_get_section_vma (abfd, section);
3039           break;
3040         case N_DATA | N_EXT:
3041         case N_SETV | N_EXT:
3042           /* Treat N_SETV symbols as N_DATA symbol; see comment in
3043              translate_from_native_sym_flags.  */
3044           section = obj_datasec (abfd);
3045           value -= bfd_get_section_vma (abfd, section);
3046           break;
3047         case N_BSS | N_EXT:
3048           section = obj_bsssec (abfd);
3049           value -= bfd_get_section_vma (abfd, section);
3050           break;
3051         case N_INDR | N_EXT:
3052           /* An indirect symbol.  The next symbol is the symbol
3053              which this one really is.  */
3054           BFD_ASSERT (p + 1 < pend);
3055           ++p;
3056           string = strings + GET_WORD (abfd, p->e_strx);
3057           section = bfd_ind_section_ptr;
3058           flags |= BSF_INDIRECT;
3059           break;
3060         case N_COMM | N_EXT:
3061           section = bfd_com_section_ptr;
3062           break;
3063         case N_SETA: case N_SETA | N_EXT:
3064           section = bfd_abs_section_ptr;
3065           flags |= BSF_CONSTRUCTOR;
3066           break;
3067         case N_SETT: case N_SETT | N_EXT:
3068           section = obj_textsec (abfd);
3069           flags |= BSF_CONSTRUCTOR;
3070           value -= bfd_get_section_vma (abfd, section);
3071           break;
3072         case N_SETD: case N_SETD | N_EXT:
3073           section = obj_datasec (abfd);
3074           flags |= BSF_CONSTRUCTOR;
3075           value -= bfd_get_section_vma (abfd, section);
3076           break;
3077         case N_SETB: case N_SETB | N_EXT:
3078           section = obj_bsssec (abfd);
3079           flags |= BSF_CONSTRUCTOR;
3080           value -= bfd_get_section_vma (abfd, section);
3081           break;
3082         case N_WARNING:
3083           /* A warning symbol.  The next symbol is the one to warn
3084              about.  If there is no next symbol, just look away.  */
3085           if (p + 1 >= pend)
3086             return TRUE;
3087           ++p;
3088           string = name;
3089           name = strings + GET_WORD (abfd, p->e_strx);
3090           section = bfd_und_section_ptr;
3091           flags |= BSF_WARNING;
3092           break;
3093         case N_WEAKU:
3094           section = bfd_und_section_ptr;
3095           flags = BSF_WEAK;
3096           break;
3097         case N_WEAKA:
3098           section = bfd_abs_section_ptr;
3099           flags = BSF_WEAK;
3100           break;
3101         case N_WEAKT:
3102           section = obj_textsec (abfd);
3103           value -= bfd_get_section_vma (abfd, section);
3104           flags = BSF_WEAK;
3105           break;
3106         case N_WEAKD:
3107           section = obj_datasec (abfd);
3108           value -= bfd_get_section_vma (abfd, section);
3109           flags = BSF_WEAK;
3110           break;
3111         case N_WEAKB:
3112           section = obj_bsssec (abfd);
3113           value -= bfd_get_section_vma (abfd, section);
3114           flags = BSF_WEAK;
3115           break;
3116         }
3117
3118       if (! ((*add_one_symbol)
3119              (info, abfd, name, flags, section, value, string, copy, FALSE,
3120               (struct bfd_link_hash_entry **) sym_hash)))
3121         return FALSE;
3122
3123       /* Restrict the maximum alignment of a common symbol based on
3124          the architecture, since a.out has no way to represent
3125          alignment requirements of a section in a .o file.  FIXME:
3126          This isn't quite right: it should use the architecture of the
3127          output file, not the input files.  */
3128       if ((*sym_hash)->root.type == bfd_link_hash_common
3129           && ((*sym_hash)->root.u.c.p->alignment_power >
3130               bfd_get_arch_info (abfd)->section_align_power))
3131         (*sym_hash)->root.u.c.p->alignment_power =
3132           bfd_get_arch_info (abfd)->section_align_power;
3133
3134       /* If this is a set symbol, and we are not building sets, then
3135          it is possible for the hash entry to not have been set.  In
3136          such a case, treat the symbol as not globally defined.  */
3137       if ((*sym_hash)->root.type == bfd_link_hash_new)
3138         {
3139           BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
3140           *sym_hash = NULL;
3141         }
3142
3143       if (type == (N_INDR | N_EXT) || type == N_WARNING)
3144         ++sym_hash;
3145     }
3146
3147   return TRUE;
3148 }
3149
3150 /* Free up the internal symbols read from an a.out file.  */
3151
3152 static bfd_boolean
3153 aout_link_free_symbols (bfd *abfd)
3154 {
3155   if (obj_aout_external_syms (abfd) != NULL)
3156     {
3157 #ifdef USE_MMAP
3158       bfd_free_window (&obj_aout_sym_window (abfd));
3159 #else
3160       free ((void *) obj_aout_external_syms (abfd));
3161 #endif
3162       obj_aout_external_syms (abfd) = NULL;
3163     }
3164   if (obj_aout_external_strings (abfd) != NULL)
3165     {
3166 #ifdef USE_MMAP
3167       bfd_free_window (&obj_aout_string_window (abfd));
3168 #else
3169       free ((void *) obj_aout_external_strings (abfd));
3170 #endif
3171       obj_aout_external_strings (abfd) = NULL;
3172     }
3173   return TRUE;
3174 }
3175
3176 /* Add symbols from an a.out object file.  */
3177
3178 static bfd_boolean
3179 aout_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3180 {
3181   if (! aout_get_external_symbols (abfd))
3182     return FALSE;
3183   if (! aout_link_add_symbols (abfd, info))
3184     return FALSE;
3185   if (! info->keep_memory)
3186     {
3187       if (! aout_link_free_symbols (abfd))
3188         return FALSE;
3189     }
3190   return TRUE;
3191 }
3192
3193 /* Look through the internal symbols to see if this object file should
3194    be included in the link.  We should include this object file if it
3195    defines any symbols which are currently undefined.  If this object
3196    file defines a common symbol, then we may adjust the size of the
3197    known symbol but we do not include the object file in the link
3198    (unless there is some other reason to include it).  */
3199
3200 static bfd_boolean
3201 aout_link_check_ar_symbols (bfd *abfd,
3202                             struct bfd_link_info *info,
3203                             bfd_boolean *pneeded)
3204 {
3205   struct external_nlist *p;
3206   struct external_nlist *pend;
3207   char *strings;
3208
3209   *pneeded = FALSE;
3210
3211   /* Look through all the symbols.  */
3212   p = obj_aout_external_syms (abfd);
3213   pend = p + obj_aout_external_sym_count (abfd);
3214   strings = obj_aout_external_strings (abfd);
3215   for (; p < pend; p++)
3216     {
3217       int type = H_GET_8 (abfd, p->e_type);
3218       const char *name;
3219       struct bfd_link_hash_entry *h;
3220
3221       /* Ignore symbols that are not externally visible.  This is an
3222          optimization only, as we check the type more thoroughly
3223          below.  */
3224       if (((type & N_EXT) == 0
3225            || (type & N_STAB) != 0
3226            || type == N_FN)
3227           && type != N_WEAKA
3228           && type != N_WEAKT
3229           && type != N_WEAKD
3230           && type != N_WEAKB)
3231         {
3232           if (type == N_WARNING
3233               || type == N_INDR)
3234             ++p;
3235           continue;
3236         }
3237
3238       name = strings + GET_WORD (abfd, p->e_strx);
3239       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
3240
3241       /* We are only interested in symbols that are currently
3242          undefined or common.  */
3243       if (h == NULL
3244           || (h->type != bfd_link_hash_undefined
3245               && h->type != bfd_link_hash_common))
3246         {
3247           if (type == (N_INDR | N_EXT))
3248             ++p;
3249           continue;
3250         }
3251
3252       if (type == (N_TEXT | N_EXT)
3253           || type == (N_DATA | N_EXT)
3254           || type == (N_BSS | N_EXT)
3255           || type == (N_ABS | N_EXT)
3256           || type == (N_INDR | N_EXT))
3257         {
3258           /* This object file defines this symbol.  We must link it
3259              in.  This is true regardless of whether the current
3260              definition of the symbol is undefined or common.
3261
3262              If the current definition is common, we have a case in
3263              which we have already seen an object file including:
3264                  int a;
3265              and this object file from the archive includes:
3266                  int a = 5;
3267              In such a case, whether to include this object is target
3268              dependant for backward compatibility.
3269
3270              FIXME: The SunOS 4.1.3 linker will pull in the archive
3271              element if the symbol is defined in the .data section,
3272              but not if it is defined in the .text section.  That
3273              seems a bit crazy to me, and it has not been implemented
3274              yet.  However, it might be correct.  */
3275           if (h->type == bfd_link_hash_common)
3276             {
3277               int skip = 0;
3278
3279               switch (info->common_skip_ar_aymbols)
3280                 {
3281                 case bfd_link_common_skip_text:
3282                   skip = (type == (N_TEXT | N_EXT));
3283                   break;
3284                 case bfd_link_common_skip_data:
3285                   skip = (type == (N_DATA | N_EXT));
3286                   break;
3287                 default:
3288                 case bfd_link_common_skip_all:
3289                   skip = 1;
3290                   break;
3291                 }
3292
3293               if (skip)
3294                 continue;
3295             }
3296
3297           if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3298             return FALSE;
3299           *pneeded = TRUE;
3300           return TRUE;
3301         }
3302
3303       if (type == (N_UNDF | N_EXT))
3304         {
3305           bfd_vma value;
3306
3307           value = GET_WORD (abfd, p->e_value);
3308           if (value != 0)
3309             {
3310               /* This symbol is common in the object from the archive
3311                  file.  */
3312               if (h->type == bfd_link_hash_undefined)
3313                 {
3314                   bfd *symbfd;
3315                   unsigned int power;
3316
3317                   symbfd = h->u.undef.abfd;
3318                   if (symbfd == NULL)
3319                     {
3320                       /* This symbol was created as undefined from
3321                          outside BFD.  We assume that we should link
3322                          in the object file.  This is done for the -u
3323                          option in the linker.  */
3324                       if (! (*info->callbacks->add_archive_element) (info,
3325                                                                      abfd,
3326                                                                      name))
3327                         return FALSE;
3328                       *pneeded = TRUE;
3329                       return TRUE;
3330                     }
3331                   /* Turn the current link symbol into a common
3332                      symbol.  It is already on the undefs list.  */
3333                   h->type = bfd_link_hash_common;
3334                   h->u.c.p = bfd_hash_allocate (&info->hash->table,
3335                                                 sizeof (struct bfd_link_hash_common_entry));
3336                   if (h->u.c.p == NULL)
3337                     return FALSE;
3338
3339                   h->u.c.size = value;
3340
3341                   /* FIXME: This isn't quite right.  The maximum
3342                      alignment of a common symbol should be set by the
3343                      architecture of the output file, not of the input
3344                      file.  */
3345                   power = bfd_log2 (value);
3346                   if (power > bfd_get_arch_info (abfd)->section_align_power)
3347                     power = bfd_get_arch_info (abfd)->section_align_power;
3348                   h->u.c.p->alignment_power = power;
3349
3350                   h->u.c.p->section = bfd_make_section_old_way (symbfd,
3351                                                                 "COMMON");
3352                 }
3353               else
3354                 {
3355                   /* Adjust the size of the common symbol if
3356                      necessary.  */
3357                   if (value > h->u.c.size)
3358                     h->u.c.size = value;
3359                 }
3360             }
3361         }
3362
3363       if (type == N_WEAKA
3364           || type == N_WEAKT
3365           || type == N_WEAKD
3366           || type == N_WEAKB)
3367         {
3368           /* This symbol is weak but defined.  We must pull it in if
3369              the current link symbol is undefined, but we don't want
3370              it if the current link symbol is common.  */
3371           if (h->type == bfd_link_hash_undefined)
3372             {
3373               if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3374                 return FALSE;
3375               *pneeded = TRUE;
3376               return TRUE;
3377             }
3378         }
3379     }
3380
3381   /* We do not need this object file.  */
3382   return TRUE;
3383 }
3384 /* Check a single archive element to see if we need to include it in
3385    the link.  *PNEEDED is set according to whether this element is
3386    needed in the link or not.  This is called from
3387    _bfd_generic_link_add_archive_symbols.  */
3388
3389 static bfd_boolean
3390 aout_link_check_archive_element (bfd *abfd,
3391                                  struct bfd_link_info *info,
3392                                  bfd_boolean *pneeded)
3393 {
3394   if (! aout_get_external_symbols (abfd))
3395     return FALSE;
3396
3397   if (! aout_link_check_ar_symbols (abfd, info, pneeded))
3398     return FALSE;
3399
3400   if (*pneeded)
3401     {
3402       if (! aout_link_add_symbols (abfd, info))
3403         return FALSE;
3404     }
3405
3406   if (! info->keep_memory || ! *pneeded)
3407     {
3408       if (! aout_link_free_symbols (abfd))
3409         return FALSE;
3410     }
3411
3412   return TRUE;
3413 }
3414
3415 /* Given an a.out BFD, add symbols to the global hash table as
3416    appropriate.  */
3417
3418 bfd_boolean
3419 NAME (aout, link_add_symbols) (bfd *abfd, struct bfd_link_info *info)
3420 {
3421   switch (bfd_get_format (abfd))
3422     {
3423     case bfd_object:
3424       return aout_link_add_object_symbols (abfd, info);
3425     case bfd_archive:
3426       return _bfd_generic_link_add_archive_symbols
3427         (abfd, info, aout_link_check_archive_element);
3428     default:
3429       bfd_set_error (bfd_error_wrong_format);
3430       return FALSE;
3431     }
3432 }
3433 \f
3434 /* A hash table used for header files with N_BINCL entries.  */
3435
3436 struct aout_link_includes_table
3437 {
3438   struct bfd_hash_table root;
3439 };
3440
3441 /* A linked list of totals that we have found for a particular header
3442    file.  */
3443
3444 struct aout_link_includes_totals
3445 {
3446   struct aout_link_includes_totals *next;
3447   bfd_vma total;
3448 };
3449
3450 /* An entry in the header file hash table.  */
3451
3452 struct aout_link_includes_entry
3453 {
3454   struct bfd_hash_entry root;
3455   /* List of totals we have found for this file.  */
3456   struct aout_link_includes_totals *totals;
3457 };
3458
3459 /* Look up an entry in an the header file hash table.  */
3460
3461 #define aout_link_includes_lookup(table, string, create, copy)          \
3462   ((struct aout_link_includes_entry *)                                  \
3463    bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3464
3465 /* During the final link step we need to pass around a bunch of
3466    information, so we do it in an instance of this structure.  */
3467
3468 struct aout_final_link_info
3469 {
3470   /* General link information.  */
3471   struct bfd_link_info *info;
3472   /* Output bfd.  */
3473   bfd *output_bfd;
3474   /* Reloc file positions.  */
3475   file_ptr treloff, dreloff;
3476   /* File position of symbols.  */
3477   file_ptr symoff;
3478   /* String table.  */
3479   struct bfd_strtab_hash *strtab;
3480   /* Header file hash table.  */
3481   struct aout_link_includes_table includes;
3482   /* A buffer large enough to hold the contents of any section.  */
3483   bfd_byte *contents;
3484   /* A buffer large enough to hold the relocs of any section.  */
3485   void * relocs;
3486   /* A buffer large enough to hold the symbol map of any input BFD.  */
3487   int *symbol_map;
3488   /* A buffer large enough to hold output symbols of any input BFD.  */
3489   struct external_nlist *output_syms;
3490 };
3491
3492 /* The function to create a new entry in the header file hash table.  */
3493
3494 static struct bfd_hash_entry *
3495 aout_link_includes_newfunc (struct bfd_hash_entry *entry,
3496                             struct bfd_hash_table *table,
3497                             const char *string)
3498 {
3499   struct aout_link_includes_entry *ret =
3500     (struct aout_link_includes_entry *) entry;
3501
3502   /* Allocate the structure if it has not already been allocated by a
3503      subclass.  */
3504   if (ret == NULL)
3505     ret = bfd_hash_allocate (table, sizeof (* ret));
3506   if (ret == NULL)
3507     return NULL;
3508
3509   /* Call the allocation method of the superclass.  */
3510   ret = ((struct aout_link_includes_entry *)
3511          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
3512   if (ret)
3513     {
3514       /* Set local fields.  */
3515       ret->totals = NULL;
3516     }
3517
3518   return (struct bfd_hash_entry *) ret;
3519 }
3520
3521 /* Write out a symbol that was not associated with an a.out input
3522    object.  */
3523
3524 static bfd_boolean
3525 aout_link_write_other_symbol (struct aout_link_hash_entry *h, void * data)
3526 {
3527   struct aout_final_link_info *finfo = (struct aout_final_link_info *) data;
3528   bfd *output_bfd;
3529   int type;
3530   bfd_vma val;
3531   struct external_nlist outsym;
3532   bfd_size_type indx;
3533   bfd_size_type amt;
3534
3535   if (h->root.type == bfd_link_hash_warning)
3536     {
3537       h = (struct aout_link_hash_entry *) h->root.u.i.link;
3538       if (h->root.type == bfd_link_hash_new)
3539         return TRUE;
3540     }
3541
3542   output_bfd = finfo->output_bfd;
3543
3544   if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
3545     {
3546       if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
3547              (output_bfd, finfo->info, h)))
3548         {
3549           /* FIXME: No way to handle errors.  */
3550           abort ();
3551         }
3552     }
3553
3554   if (h->written)
3555     return TRUE;
3556
3557   h->written = TRUE;
3558
3559   /* An indx of -2 means the symbol must be written.  */
3560   if (h->indx != -2
3561       && (finfo->info->strip == strip_all
3562           || (finfo->info->strip == strip_some
3563               && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
3564                                   FALSE, FALSE) == NULL)))
3565     return TRUE;
3566
3567   switch (h->root.type)
3568     {
3569     default:
3570     case bfd_link_hash_warning:
3571       abort ();
3572       /* Avoid variable not initialized warnings.  */
3573       return TRUE;
3574     case bfd_link_hash_new:
3575       /* This can happen for set symbols when sets are not being
3576          built.  */
3577       return TRUE;
3578     case bfd_link_hash_undefined:
3579       type = N_UNDF | N_EXT;
3580       val = 0;
3581       break;
3582     case bfd_link_hash_defined:
3583     case bfd_link_hash_defweak:
3584       {
3585         asection *sec;
3586
3587         sec = h->root.u.def.section->output_section;
3588         BFD_ASSERT (bfd_is_abs_section (sec)
3589                     || sec->owner == output_bfd);
3590         if (sec == obj_textsec (output_bfd))
3591           type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
3592         else if (sec == obj_datasec (output_bfd))
3593           type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
3594         else if (sec == obj_bsssec (output_bfd))
3595           type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
3596         else
3597           type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
3598         type |= N_EXT;
3599         val = (h->root.u.def.value
3600                + sec->vma
3601                + h->root.u.def.section->output_offset);
3602       }
3603       break;
3604     case bfd_link_hash_common:
3605       type = N_UNDF | N_EXT;
3606       val = h->root.u.c.size;
3607       break;
3608     case bfd_link_hash_undefweak:
3609       type = N_WEAKU;
3610       val = 0;
3611     case bfd_link_hash_indirect:
3612       /* We ignore these symbols, since the indirected symbol is
3613          already in the hash table.  */
3614       return TRUE;
3615     }
3616
3617   H_PUT_8 (output_bfd, type, outsym.e_type);
3618   H_PUT_8 (output_bfd, 0, outsym.e_other);
3619   H_PUT_16 (output_bfd, 0, outsym.e_desc);
3620   indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
3621                            FALSE);
3622   if (indx == - (bfd_size_type) 1)
3623     /* FIXME: No way to handle errors.  */
3624     abort ();
3625
3626   PUT_WORD (output_bfd, indx, outsym.e_strx);
3627   PUT_WORD (output_bfd, val, outsym.e_value);
3628
3629   amt = EXTERNAL_NLIST_SIZE;
3630   if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0
3631       || bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
3632     /* FIXME: No way to handle errors.  */
3633     abort ();
3634
3635   finfo->symoff += EXTERNAL_NLIST_SIZE;
3636   h->indx = obj_aout_external_sym_count (output_bfd);
3637   ++obj_aout_external_sym_count (output_bfd);
3638
3639   return TRUE;
3640 }
3641
3642 /* Handle a link order which is supposed to generate a reloc.  */
3643
3644 static bfd_boolean
3645 aout_link_reloc_link_order (struct aout_final_link_info *finfo,
3646                             asection *o,
3647                             struct bfd_link_order *p)
3648 {
3649   struct bfd_link_order_reloc *pr;
3650   int r_index;
3651   int r_extern;
3652   reloc_howto_type *howto;
3653   file_ptr *reloff_ptr = NULL;
3654   struct reloc_std_external srel;
3655   struct reloc_ext_external erel;
3656   void * rel_ptr;
3657   bfd_size_type amt;
3658
3659   pr = p->u.reloc.p;
3660
3661   if (p->type == bfd_section_reloc_link_order)
3662     {
3663       r_extern = 0;
3664       if (bfd_is_abs_section (pr->u.section))
3665         r_index = N_ABS | N_EXT;
3666       else
3667         {
3668           BFD_ASSERT (pr->u.section->owner == finfo->output_bfd);
3669           r_index = pr->u.section->target_index;
3670         }
3671     }
3672   else
3673     {
3674       struct aout_link_hash_entry *h;
3675
3676       BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
3677       r_extern = 1;
3678       h = ((struct aout_link_hash_entry *)
3679            bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
3680                                          pr->u.name, FALSE, FALSE, TRUE));
3681       if (h != NULL
3682           && h->indx >= 0)
3683         r_index = h->indx;
3684       else if (h != NULL)
3685         {
3686           /* We decided to strip this symbol, but it turns out that we
3687              can't.  Note that we lose the other and desc information
3688              here.  I don't think that will ever matter for a global
3689              symbol.  */
3690           h->indx = -2;
3691           h->written = FALSE;
3692           if (! aout_link_write_other_symbol (h, (void *) finfo))
3693             return FALSE;
3694           r_index = h->indx;
3695         }
3696       else
3697         {
3698           if (! ((*finfo->info->callbacks->unattached_reloc)
3699                  (finfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0)))
3700             return FALSE;
3701           r_index = 0;
3702         }
3703     }
3704
3705   howto = bfd_reloc_type_lookup (finfo->output_bfd, pr->reloc);
3706   if (howto == 0)
3707     {
3708       bfd_set_error (bfd_error_bad_value);
3709       return FALSE;
3710     }
3711
3712   if (o == obj_textsec (finfo->output_bfd))
3713     reloff_ptr = &finfo->treloff;
3714   else if (o == obj_datasec (finfo->output_bfd))
3715     reloff_ptr = &finfo->dreloff;
3716   else
3717     abort ();
3718
3719   if (obj_reloc_entry_size (finfo->output_bfd) == RELOC_STD_SIZE)
3720     {
3721 #ifdef MY_put_reloc
3722       MY_put_reloc (finfo->output_bfd, r_extern, r_index, p->offset, howto,
3723                     &srel);
3724 #else
3725       {
3726         int r_pcrel;
3727         int r_baserel;
3728         int r_jmptable;
3729         int r_relative;
3730         int r_length;
3731
3732         r_pcrel = (int) howto->pc_relative;
3733         r_baserel = (howto->type & 8) != 0;
3734         r_jmptable = (howto->type & 16) != 0;
3735         r_relative = (howto->type & 32) != 0;
3736         r_length = howto->size;
3737
3738         PUT_WORD (finfo->output_bfd, p->offset, srel.r_address);
3739         if (bfd_header_big_endian (finfo->output_bfd))
3740           {
3741             srel.r_index[0] = r_index >> 16;
3742             srel.r_index[1] = r_index >> 8;
3743             srel.r_index[2] = r_index;
3744             srel.r_type[0] =
3745               ((r_extern ?     RELOC_STD_BITS_EXTERN_BIG : 0)
3746                | (r_pcrel ?    RELOC_STD_BITS_PCREL_BIG : 0)
3747                | (r_baserel ?  RELOC_STD_BITS_BASEREL_BIG : 0)
3748                | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
3749                | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
3750                | (r_length <<  RELOC_STD_BITS_LENGTH_SH_BIG));
3751           }
3752         else
3753           {
3754             srel.r_index[2] = r_index >> 16;
3755             srel.r_index[1] = r_index >> 8;
3756             srel.r_index[0] = r_index;
3757             srel.r_type[0] =
3758               ((r_extern ?     RELOC_STD_BITS_EXTERN_LITTLE : 0)
3759                | (r_pcrel ?    RELOC_STD_BITS_PCREL_LITTLE : 0)
3760                | (r_baserel ?  RELOC_STD_BITS_BASEREL_LITTLE : 0)
3761                | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
3762                | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
3763                | (r_length <<  RELOC_STD_BITS_LENGTH_SH_LITTLE));
3764           }
3765       }
3766 #endif
3767       rel_ptr = (void *) &srel;
3768
3769       /* We have to write the addend into the object file, since
3770          standard a.out relocs are in place.  It would be more
3771          reliable if we had the current contents of the file here,
3772          rather than assuming zeroes, but we can't read the file since
3773          it was opened using bfd_openw.  */
3774       if (pr->addend != 0)
3775         {
3776           bfd_size_type size;
3777           bfd_reloc_status_type r;
3778           bfd_byte *buf;
3779           bfd_boolean ok;
3780
3781           size = bfd_get_reloc_size (howto);
3782           buf = bfd_zmalloc (size);
3783           if (buf == NULL)
3784             return FALSE;
3785           r = MY_relocate_contents (howto, finfo->output_bfd,
3786                                     (bfd_vma) pr->addend, buf);
3787           switch (r)
3788             {
3789             case bfd_reloc_ok:
3790               break;
3791             default:
3792             case bfd_reloc_outofrange:
3793               abort ();
3794             case bfd_reloc_overflow:
3795               if (! ((*finfo->info->callbacks->reloc_overflow)
3796                      (finfo->info, NULL,
3797                       (p->type == bfd_section_reloc_link_order
3798                        ? bfd_section_name (finfo->output_bfd,
3799                                            pr->u.section)
3800                        : pr->u.name),
3801                       howto->name, pr->addend, NULL, NULL, (bfd_vma) 0)))
3802                 {
3803                   free (buf);
3804                   return FALSE;
3805                 }
3806               break;
3807             }
3808           ok = bfd_set_section_contents (finfo->output_bfd, o, (void *) buf,
3809                                          (file_ptr) p->offset, size);
3810           free (buf);
3811           if (! ok)
3812             return FALSE;
3813         }
3814     }
3815   else
3816     {
3817 #ifdef MY_put_ext_reloc
3818       MY_put_ext_reloc (finfo->output_bfd, r_extern, r_index, p->offset,
3819                         howto, &erel, pr->addend);
3820 #else
3821       PUT_WORD (finfo->output_bfd, p->offset, erel.r_address);
3822
3823       if (bfd_header_big_endian (finfo->output_bfd))
3824         {
3825           erel.r_index[0] = r_index >> 16;
3826           erel.r_index[1] = r_index >> 8;
3827           erel.r_index[2] = r_index;
3828           erel.r_type[0] =
3829             ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
3830              | (howto->type << RELOC_EXT_BITS_TYPE_SH_BIG));
3831         }
3832       else
3833         {
3834           erel.r_index[2] = r_index >> 16;
3835           erel.r_index[1] = r_index >> 8;
3836           erel.r_index[0] = r_index;
3837           erel.r_type[0] =
3838             (r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
3839               | (howto->type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
3840         }
3841
3842       PUT_WORD (finfo->output_bfd, (bfd_vma) pr->addend, erel.r_addend);
3843 #endif /* MY_put_ext_reloc */
3844
3845       rel_ptr = (void *) &erel;
3846     }
3847
3848   amt = obj_reloc_entry_size (finfo->output_bfd);
3849   if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
3850       || bfd_bwrite (rel_ptr, amt, finfo->output_bfd) != amt)
3851     return FALSE;
3852
3853   *reloff_ptr += obj_reloc_entry_size (finfo->output_bfd);
3854
3855   /* Assert that the relocs have not run into the symbols, and that n
3856      the text relocs have not run into the data relocs.  */
3857   BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
3858               && (reloff_ptr != &finfo->treloff
3859                   || (*reloff_ptr
3860                       <= obj_datasec (finfo->output_bfd)->rel_filepos)));
3861
3862   return TRUE;
3863 }
3864
3865 /* Get the section corresponding to a reloc index.  */
3866
3867 static INLINE asection *
3868 aout_reloc_index_to_section (bfd *abfd, int indx)
3869 {
3870   switch (indx & N_TYPE)
3871     {
3872     case N_TEXT:   return obj_textsec (abfd);
3873     case N_DATA:   return obj_datasec (abfd);
3874     case N_BSS:    return obj_bsssec (abfd);
3875     case N_ABS:
3876     case N_UNDF:   return bfd_abs_section_ptr;
3877     default:       abort ();
3878     }
3879   return NULL;
3880 }
3881
3882 /* Relocate an a.out section using standard a.out relocs.  */
3883
3884 static bfd_boolean
3885 aout_link_input_section_std (struct aout_final_link_info *finfo,
3886                              bfd *input_bfd,
3887                              asection *input_section,
3888                              struct reloc_std_external *relocs,
3889                              bfd_size_type rel_size,
3890                              bfd_byte *contents)
3891 {
3892   bfd_boolean (*check_dynamic_reloc)
3893     (struct bfd_link_info *, bfd *, asection *,
3894              struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
3895              bfd_vma *);
3896   bfd *output_bfd;
3897   bfd_boolean relocatable;
3898   struct external_nlist *syms;
3899   char *strings;
3900   struct aout_link_hash_entry **sym_hashes;
3901   int *symbol_map;
3902   bfd_size_type reloc_count;
3903   struct reloc_std_external *rel;
3904   struct reloc_std_external *rel_end;
3905
3906   output_bfd = finfo->output_bfd;
3907   check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
3908
3909   BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE);
3910   BFD_ASSERT (input_bfd->xvec->header_byteorder
3911               == output_bfd->xvec->header_byteorder);
3912
3913   relocatable = finfo->info->relocatable;
3914   syms = obj_aout_external_syms (input_bfd);
3915   strings = obj_aout_external_strings (input_bfd);
3916   sym_hashes = obj_aout_sym_hashes (input_bfd);
3917   symbol_map = finfo->symbol_map;
3918
3919   reloc_count = rel_size / RELOC_STD_SIZE;
3920   rel = relocs;
3921   rel_end = rel + reloc_count;
3922   for (; rel < rel_end; rel++)
3923     {
3924       bfd_vma r_addr;
3925       int r_index;
3926       int r_extern;
3927       int r_pcrel;
3928       int r_baserel = 0;
3929       reloc_howto_type *howto;
3930       struct aout_link_hash_entry *h = NULL;
3931       bfd_vma relocation;
3932       bfd_reloc_status_type r;
3933
3934       r_addr = GET_SWORD (input_bfd, rel->r_address);
3935
3936 #ifdef MY_reloc_howto
3937       howto = MY_reloc_howto (input_bfd, rel, r_index, r_extern, r_pcrel);
3938 #else
3939       {
3940         int r_jmptable;
3941         int r_relative;
3942         int r_length;
3943         unsigned int howto_idx;
3944
3945         if (bfd_header_big_endian (input_bfd))
3946           {
3947             r_index   =  (((unsigned int) rel->r_index[0] << 16)
3948                           | ((unsigned int) rel->r_index[1] << 8)
3949                           | rel->r_index[2]);
3950             r_extern  = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
3951             r_pcrel   = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
3952             r_baserel = (0 != (rel->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
3953             r_jmptable= (0 != (rel->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
3954             r_relative= (0 != (rel->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
3955             r_length  = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
3956                          >> RELOC_STD_BITS_LENGTH_SH_BIG);
3957           }
3958         else
3959           {
3960             r_index   = (((unsigned int) rel->r_index[2] << 16)
3961                          | ((unsigned int) rel->r_index[1] << 8)
3962                          | rel->r_index[0]);
3963             r_extern  = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
3964             r_pcrel   = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
3965             r_baserel = (0 != (rel->r_type[0]
3966                                & RELOC_STD_BITS_BASEREL_LITTLE));
3967             r_jmptable= (0 != (rel->r_type[0]
3968                                & RELOC_STD_BITS_JMPTABLE_LITTLE));
3969             r_relative= (0 != (rel->r_type[0]
3970                                & RELOC_STD_BITS_RELATIVE_LITTLE));
3971             r_length  = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
3972                          >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
3973           }
3974
3975         howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
3976                      + 16 * r_jmptable + 32 * r_relative);
3977         if (howto_idx < TABLE_SIZE (howto_table_std))
3978           howto = howto_table_std + howto_idx;
3979         else
3980           howto = NULL;
3981       }
3982 #endif
3983
3984       if (howto == NULL)
3985         {
3986           (*finfo->info->callbacks->einfo)
3987             (_("%P: %B: unexpected relocation type\n"), input_bfd);
3988           bfd_set_error (bfd_error_bad_value);
3989           return FALSE;
3990         }
3991
3992       if (relocatable)
3993         {
3994           /* We are generating a relocatable output file, and must
3995              modify the reloc accordingly.  */
3996           if (r_extern)
3997             {
3998               /* If we know the symbol this relocation is against,
3999                  convert it into a relocation against a section.  This
4000                  is what the native linker does.  */
4001               h = sym_hashes[r_index];
4002               if (h != NULL
4003                   && (h->root.type == bfd_link_hash_defined
4004                       || h->root.type == bfd_link_hash_defweak))
4005                 {
4006                   asection *output_section;
4007
4008                   /* Change the r_extern value.  */
4009                   if (bfd_header_big_endian (output_bfd))
4010                     rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_BIG;
4011                   else
4012                     rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE;
4013
4014                   /* Compute a new r_index.  */
4015                   output_section = h->root.u.def.section->output_section;
4016                   if (output_section == obj_textsec (output_bfd))
4017                     r_index = N_TEXT;
4018                   else if (output_section == obj_datasec (output_bfd))
4019                     r_index = N_DATA;
4020                   else if (output_section == obj_bsssec (output_bfd))
4021                     r_index = N_BSS;
4022                   else
4023                     r_index = N_ABS;
4024
4025                   /* Add the symbol value and the section VMA to the
4026                      addend stored in the contents.  */
4027                   relocation = (h->root.u.def.value
4028                                 + output_section->vma
4029                                 + h->root.u.def.section->output_offset);
4030                 }
4031               else
4032                 {
4033                   /* We must change r_index according to the symbol
4034                      map.  */
4035                   r_index = symbol_map[r_index];
4036
4037                   if (r_index == -1)
4038                     {
4039                       if (h != NULL)
4040                         {
4041                           /* We decided to strip this symbol, but it
4042                              turns out that we can't.  Note that we
4043                              lose the other and desc information here.
4044                              I don't think that will ever matter for a
4045                              global symbol.  */
4046                           if (h->indx < 0)
4047                             {
4048                               h->indx = -2;
4049                               h->written = FALSE;
4050                               if (! aout_link_write_other_symbol (h,
4051                                                                   (void *) finfo))
4052                                 return FALSE;
4053                             }
4054                           r_index = h->indx;
4055                         }
4056                       else
4057                         {
4058                           const char *name;
4059
4060                           name = strings + GET_WORD (input_bfd,
4061                                                      syms[r_index].e_strx);
4062                           if (! ((*finfo->info->callbacks->unattached_reloc)
4063                                  (finfo->info, name, input_bfd, input_section,
4064                                   r_addr)))
4065                             return FALSE;
4066                           r_index = 0;
4067                         }
4068                     }
4069
4070                   relocation = 0;
4071                 }
4072
4073               /* Write out the new r_index value.  */
4074               if (bfd_header_big_endian (output_bfd))
4075                 {
4076                   rel->r_index[0] = r_index >> 16;
4077                   rel->r_index[1] = r_index >> 8;
4078                   rel->r_index[2] = r_index;
4079                 }
4080               else
4081                 {
4082                   rel->r_index[2] = r_index >> 16;
4083                   rel->r_index[1] = r_index >> 8;
4084                   rel->r_index[0] = r_index;
4085                 }
4086             }
4087           else
4088             {
4089               asection *section;
4090
4091               /* This is a relocation against a section.  We must
4092                  adjust by the amount that the section moved.  */
4093               section = aout_reloc_index_to_section (input_bfd, r_index);
4094               relocation = (section->output_section->vma
4095                             + section->output_offset
4096                             - section->vma);
4097             }
4098
4099           /* Change the address of the relocation.  */
4100           PUT_WORD (output_bfd,
4101                     r_addr + input_section->output_offset,
4102                     rel->r_address);
4103
4104           /* Adjust a PC relative relocation by removing the reference
4105              to the original address in the section and including the
4106              reference to the new address.  */
4107           if (r_pcrel)
4108             relocation -= (input_section->output_section->vma
4109                            + input_section->output_offset
4110                            - input_section->vma);
4111
4112 #ifdef MY_relocatable_reloc
4113           MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
4114 #endif
4115
4116           if (relocation == 0)
4117             r = bfd_reloc_ok;
4118           else
4119             r = MY_relocate_contents (howto,
4120                                         input_bfd, relocation,
4121                                         contents + r_addr);
4122         }
4123       else
4124         {
4125           bfd_boolean hundef;
4126
4127           /* We are generating an executable, and must do a full
4128              relocation.  */
4129           hundef = FALSE;
4130
4131           if (r_extern)
4132             {
4133               h = sym_hashes[r_index];
4134
4135               if (h != NULL
4136                   && (h->root.type == bfd_link_hash_defined
4137                       || h->root.type == bfd_link_hash_defweak))
4138                 {
4139                   relocation = (h->root.u.def.value
4140                                 + h->root.u.def.section->output_section->vma
4141                                 + h->root.u.def.section->output_offset);
4142                 }
4143               else if (h != NULL
4144                        && h->root.type == bfd_link_hash_undefweak)
4145                 relocation = 0;
4146               else
4147                 {
4148                   hundef = TRUE;
4149                   relocation = 0;
4150                 }
4151             }
4152           else
4153             {
4154               asection *section;
4155
4156               section = aout_reloc_index_to_section (input_bfd, r_index);
4157               relocation = (section->output_section->vma
4158                             + section->output_offset
4159                             - section->vma);
4160               if (r_pcrel)
4161                 relocation += input_section->vma;
4162             }
4163
4164           if (check_dynamic_reloc != NULL)
4165             {
4166               bfd_boolean skip;
4167
4168               if (! ((*check_dynamic_reloc)
4169                      (finfo->info, input_bfd, input_section, h,
4170                       (void *) rel, contents, &skip, &relocation)))
4171                 return FALSE;
4172               if (skip)
4173                 continue;
4174             }
4175
4176           /* Now warn if a global symbol is undefined.  We could not
4177              do this earlier, because check_dynamic_reloc might want
4178              to skip this reloc.  */
4179           if (hundef && ! finfo->info->shared && ! r_baserel)
4180             {
4181               const char *name;
4182
4183               if (h != NULL)
4184                 name = h->root.root.string;
4185               else
4186                 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
4187               if (! ((*finfo->info->callbacks->undefined_symbol)
4188                      (finfo->info, name, input_bfd, input_section,
4189                      r_addr, TRUE)))
4190                 return FALSE;
4191             }
4192
4193           r = MY_final_link_relocate (howto,
4194                                       input_bfd, input_section,
4195                                       contents, r_addr, relocation,
4196                                       (bfd_vma) 0);
4197         }
4198
4199       if (r != bfd_reloc_ok)
4200         {
4201           switch (r)
4202             {
4203             default:
4204             case bfd_reloc_outofrange:
4205               abort ();
4206             case bfd_reloc_overflow:
4207               {
4208                 const char *name;
4209
4210                 if (h != NULL)
4211                   name = NULL;
4212                 else if (r_extern)
4213                   name = strings + GET_WORD (input_bfd,
4214                                              syms[r_index].e_strx);
4215                 else
4216                   {
4217                     asection *s;
4218
4219                     s = aout_reloc_index_to_section (input_bfd, r_index);
4220                     name = bfd_section_name (input_bfd, s);
4221                   }
4222                 if (! ((*finfo->info->callbacks->reloc_overflow)
4223                        (finfo->info, (h ? &h->root : NULL), name,
4224                         howto->name, (bfd_vma) 0, input_bfd,
4225                         input_section, r_addr)))
4226                   return FALSE;
4227               }
4228               break;
4229             }
4230         }
4231     }
4232
4233   return TRUE;
4234 }
4235
4236 /* Relocate an a.out section using extended a.out relocs.  */
4237
4238 static bfd_boolean
4239 aout_link_input_section_ext (struct aout_final_link_info *finfo,
4240                              bfd *input_bfd,
4241                              asection *input_section,
4242                              struct reloc_ext_external *relocs,
4243                              bfd_size_type rel_size,
4244                              bfd_byte *contents)
4245 {
4246   bfd_boolean (*check_dynamic_reloc)
4247     (struct bfd_link_info *, bfd *, asection *,
4248              struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
4249              bfd_vma *);
4250   bfd *output_bfd;
4251   bfd_boolean relocatable;
4252   struct external_nlist *syms;
4253   char *strings;
4254   struct aout_link_hash_entry **sym_hashes;
4255   int *symbol_map;
4256   bfd_size_type reloc_count;
4257   struct reloc_ext_external *rel;
4258   struct reloc_ext_external *rel_end;
4259
4260   output_bfd = finfo->output_bfd;
4261   check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
4262
4263   BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_EXT_SIZE);
4264   BFD_ASSERT (input_bfd->xvec->header_byteorder
4265               == output_bfd->xvec->header_byteorder);
4266
4267   relocatable = finfo->info->relocatable;
4268   syms = obj_aout_external_syms (input_bfd);
4269   strings = obj_aout_external_strings (input_bfd);
4270   sym_hashes = obj_aout_sym_hashes (input_bfd);
4271   symbol_map = finfo->symbol_map;
4272
4273   reloc_count = rel_size / RELOC_EXT_SIZE;
4274   rel = relocs;
4275   rel_end = rel + reloc_count;
4276   for (; rel < rel_end; rel++)
4277     {
4278       bfd_vma r_addr;
4279       int r_index;
4280       int r_extern;
4281       unsigned int r_type;
4282       bfd_vma r_addend;
4283       struct aout_link_hash_entry *h = NULL;
4284       asection *r_section = NULL;
4285       bfd_vma relocation;
4286
4287       r_addr = GET_SWORD (input_bfd, rel->r_address);
4288
4289       if (bfd_header_big_endian (input_bfd))
4290         {
4291           r_index  = (((unsigned int) rel->r_index[0] << 16)
4292                       | ((unsigned int) rel->r_index[1] << 8)
4293                       | rel->r_index[2]);
4294           r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
4295           r_type   = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
4296                       >> RELOC_EXT_BITS_TYPE_SH_BIG);
4297         }
4298       else
4299         {
4300           r_index  = (((unsigned int) rel->r_index[2] << 16)
4301                       | ((unsigned int) rel->r_index[1] << 8)
4302                       | rel->r_index[0]);
4303           r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
4304           r_type   = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
4305                       >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
4306         }
4307
4308       r_addend = GET_SWORD (input_bfd, rel->r_addend);
4309
4310       if (r_type >= TABLE_SIZE (howto_table_ext))
4311         {
4312           (*finfo->info->callbacks->einfo)
4313             (_("%P: %B: unexpected relocation type\n"), input_bfd);
4314           bfd_set_error (bfd_error_bad_value);
4315           return FALSE;
4316         }
4317
4318       if (relocatable)
4319         {
4320           /* We are generating a relocatable output file, and must
4321              modify the reloc accordingly.  */
4322           if (r_extern
4323               || r_type == (unsigned int) RELOC_BASE10
4324               || r_type == (unsigned int) RELOC_BASE13
4325               || r_type == (unsigned int) RELOC_BASE22)
4326             {
4327               /* If we know the symbol this relocation is against,
4328                  convert it into a relocation against a section.  This
4329                  is what the native linker does.  */
4330               if (r_type == (unsigned int) RELOC_BASE10
4331                   || r_type == (unsigned int) RELOC_BASE13
4332                   || r_type == (unsigned int) RELOC_BASE22)
4333                 h = NULL;
4334               else
4335                 h = sym_hashes[r_index];
4336               if (h != NULL
4337                   && (h->root.type == bfd_link_hash_defined
4338                       || h->root.type == bfd_link_hash_defweak))
4339                 {
4340                   asection *output_section;
4341
4342                   /* Change the r_extern value.  */
4343                   if (bfd_header_big_endian (output_bfd))
4344                     rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_BIG;
4345                   else
4346                     rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE;
4347
4348                   /* Compute a new r_index.  */
4349                   output_section = h->root.u.def.section->output_section;
4350                   if (output_section == obj_textsec (output_bfd))
4351                     r_index = N_TEXT;
4352                   else if (output_section == obj_datasec (output_bfd))
4353                     r_index = N_DATA;
4354                   else if (output_section == obj_bsssec (output_bfd))
4355                     r_index = N_BSS;
4356                   else
4357                     r_index = N_ABS;
4358
4359                   /* Add the symbol value and the section VMA to the
4360                      addend.  */
4361                   relocation = (h->root.u.def.value
4362                                 + output_section->vma
4363                                 + h->root.u.def.section->output_offset);
4364
4365                   /* Now RELOCATION is the VMA of the final
4366                      destination.  If this is a PC relative reloc,
4367                      then ADDEND is the negative of the source VMA.
4368                      We want to set ADDEND to the difference between
4369                      the destination VMA and the source VMA, which
4370                      means we must adjust RELOCATION by the change in
4371                      the source VMA.  This is done below.  */
4372                 }
4373               else
4374                 {
4375                   /* We must change r_index according to the symbol
4376                      map.  */
4377                   r_index = symbol_map[r_index];
4378
4379                   if (r_index == -1)
4380                     {
4381                       if (h != NULL)
4382                         {
4383                           /* We decided to strip this symbol, but it
4384                              turns out that we can't.  Note that we
4385                              lose the other and desc information here.
4386                              I don't think that will ever matter for a
4387                              global symbol.  */
4388                           if (h->indx < 0)
4389                             {
4390                               h->indx = -2;
4391                               h->written = FALSE;
4392                               if (! aout_link_write_other_symbol (h,
4393                                                                   (void *) finfo))
4394                                 return FALSE;
4395                             }
4396                           r_index = h->indx;
4397                         }
4398                       else
4399                         {
4400                           const char *name;
4401
4402                           name = strings + GET_WORD (input_bfd,
4403                                                      syms[r_index].e_strx);
4404                           if (! ((*finfo->info->callbacks->unattached_reloc)
4405                                  (finfo->info, name, input_bfd, input_section,
4406                                   r_addr)))
4407                             return FALSE;
4408                           r_index = 0;
4409                         }
4410                     }
4411
4412                   relocation = 0;
4413
4414                   /* If this is a PC relative reloc, then the addend
4415                      is the negative of the source VMA.  We must
4416                      adjust it by the change in the source VMA.  This
4417                      is done below.  */
4418                 }
4419
4420               /* Write out the new r_index value.  */
4421               if (bfd_header_big_endian (output_bfd))
4422                 {
4423                   rel->r_index[0] = r_index >> 16;
4424                   rel->r_index[1] = r_index >> 8;
4425                   rel->r_index[2] = r_index;
4426                 }
4427               else
4428                 {
4429                   rel->r_index[2] = r_index >> 16;
4430                   rel->r_index[1] = r_index >> 8;
4431                   rel->r_index[0] = r_index;
4432                 }
4433             }
4434           else
4435             {
4436               /* This is a relocation against a section.  We must
4437                  adjust by the amount that the section moved.  */
4438               r_section = aout_reloc_index_to_section (input_bfd, r_index);
4439               relocation = (r_section->output_section->vma
4440                             + r_section->output_offset
4441                             - r_section->vma);
4442
4443               /* If this is a PC relative reloc, then the addend is
4444                  the difference in VMA between the destination and the
4445                  source.  We have just adjusted for the change in VMA
4446                  of the destination, so we must also adjust by the
4447                  change in VMA of the source.  This is done below.  */
4448             }
4449
4450           /* As described above, we must always adjust a PC relative
4451              reloc by the change in VMA of the source.  However, if
4452              pcrel_offset is set, then the addend does not include the
4453              location within the section, in which case we don't need
4454              to adjust anything.  */
4455           if (howto_table_ext[r_type].pc_relative
4456               && ! howto_table_ext[r_type].pcrel_offset)
4457             relocation -= (input_section->output_section->vma
4458                            + input_section->output_offset
4459                            - input_section->vma);
4460
4461           /* Change the addend if necessary.  */
4462           if (relocation != 0)
4463             PUT_WORD (output_bfd, r_addend + relocation, rel->r_addend);
4464
4465           /* Change the address of the relocation.  */
4466           PUT_WORD (output_bfd,
4467                     r_addr + input_section->output_offset,
4468                     rel->r_address);
4469         }
4470       else
4471         {
4472           bfd_boolean hundef;
4473           bfd_reloc_status_type r;
4474
4475           /* We are generating an executable, and must do a full
4476              relocation.  */
4477           hundef = FALSE;
4478
4479           if (r_extern)
4480             {
4481               h = sym_hashes[r_index];
4482
4483               if (h != NULL
4484                   && (h->root.type == bfd_link_hash_defined
4485                       || h->root.type == bfd_link_hash_defweak))
4486                 {
4487                   relocation = (h->root.u.def.value
4488                                 + h->root.u.def.section->output_section->vma
4489                                 + h->root.u.def.section->output_offset);
4490                 }
4491               else if (h != NULL
4492                        && h->root.type == bfd_link_hash_undefweak)
4493                 relocation = 0;
4494               else
4495                 {
4496                   hundef = TRUE;
4497                   relocation = 0;
4498                 }
4499             }
4500           else if (r_type == (unsigned int) RELOC_BASE10
4501                    || r_type == (unsigned int) RELOC_BASE13
4502                    || r_type == (unsigned int) RELOC_BASE22)
4503             {
4504               struct external_nlist *sym;
4505               int type;
4506
4507               /* For base relative relocs, r_index is always an index
4508                  into the symbol table, even if r_extern is 0.  */
4509               sym = syms + r_index;
4510               type = H_GET_8 (input_bfd, sym->e_type);
4511               if ((type & N_TYPE) == N_TEXT
4512                   || type == N_WEAKT)
4513                 r_section = obj_textsec (input_bfd);
4514               else if ((type & N_TYPE) == N_DATA
4515                        || type == N_WEAKD)
4516                 r_section = obj_datasec (input_bfd);
4517               else if ((type & N_TYPE) == N_BSS
4518                        || type == N_WEAKB)
4519                 r_section = obj_bsssec (input_bfd);
4520               else if ((type & N_TYPE) == N_ABS
4521                        || type == N_WEAKA)
4522                 r_section = bfd_abs_section_ptr;
4523               else
4524                 abort ();
4525               relocation = (r_section->output_section->vma
4526                             + r_section->output_offset
4527                             + (GET_WORD (input_bfd, sym->e_value)
4528                                - r_section->vma));
4529             }
4530           else
4531             {
4532               r_section = aout_reloc_index_to_section (input_bfd, r_index);
4533
4534               /* If this is a PC relative reloc, then R_ADDEND is the
4535                  difference between the two vmas, or
4536                    old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
4537                  where
4538                    old_dest_sec == section->vma
4539                  and
4540                    old_src_sec == input_section->vma
4541                  and
4542                    old_src_off == r_addr
4543
4544                  _bfd_final_link_relocate expects RELOCATION +
4545                  R_ADDEND to be the VMA of the destination minus
4546                  r_addr (the minus r_addr is because this relocation
4547                  is not pcrel_offset, which is a bit confusing and
4548                  should, perhaps, be changed), or
4549                    new_dest_sec
4550                  where
4551                    new_dest_sec == output_section->vma + output_offset
4552                  We arrange for this to happen by setting RELOCATION to
4553                    new_dest_sec + old_src_sec - old_dest_sec
4554
4555                  If this is not a PC relative reloc, then R_ADDEND is
4556                  simply the VMA of the destination, so we set
4557                  RELOCATION to the change in the destination VMA, or
4558                    new_dest_sec - old_dest_sec
4559                  */
4560               relocation = (r_section->output_section->vma
4561                             + r_section->output_offset
4562                             - r_section->vma);
4563               if (howto_table_ext[r_type].pc_relative)
4564                 relocation += input_section->vma;
4565             }
4566
4567           if (check_dynamic_reloc != NULL)
4568             {
4569               bfd_boolean skip;
4570
4571               if (! ((*check_dynamic_reloc)
4572                      (finfo->info, input_bfd, input_section, h,
4573                       (void *) rel, contents, &skip, &relocation)))
4574                 return FALSE;
4575               if (skip)
4576                 continue;
4577             }
4578
4579           /* Now warn if a global symbol is undefined.  We could not
4580              do this earlier, because check_dynamic_reloc might want
4581              to skip this reloc.  */
4582           if (hundef
4583               && ! finfo->info->shared
4584               && r_type != (unsigned int) RELOC_BASE10
4585               && r_type != (unsigned int) RELOC_BASE13
4586               && r_type != (unsigned int) RELOC_BASE22)
4587             {
4588               const char *name;
4589
4590               if (h != NULL)
4591                 name = h->root.root.string;
4592               else
4593                 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
4594               if (! ((*finfo->info->callbacks->undefined_symbol)
4595                      (finfo->info, name, input_bfd, input_section,
4596                      r_addr, TRUE)))
4597                 return FALSE;
4598             }
4599
4600           if (r_type != (unsigned int) RELOC_SPARC_REV32)
4601             r = MY_final_link_relocate (howto_table_ext + r_type,
4602                                         input_bfd, input_section,
4603                                         contents, r_addr, relocation,
4604                                         r_addend);
4605           else
4606             {
4607               bfd_vma x;
4608
4609               x = bfd_get_32 (input_bfd, contents + r_addr);
4610               x = x + relocation + r_addend;
4611               bfd_putl32 (/*input_bfd,*/ x, contents + r_addr);
4612               r = bfd_reloc_ok;
4613             }
4614
4615           if (r != bfd_reloc_ok)
4616             {
4617               switch (r)
4618                 {
4619                 default:
4620                 case bfd_reloc_outofrange:
4621                   abort ();
4622                 case bfd_reloc_overflow:
4623                   {
4624                     const char *name;
4625
4626                     if (h != NULL)
4627                       name = NULL;
4628                     else if (r_extern
4629                              || r_type == (unsigned int) RELOC_BASE10
4630                              || r_type == (unsigned int) RELOC_BASE13
4631                              || r_type == (unsigned int) RELOC_BASE22)
4632                       name = strings + GET_WORD (input_bfd,
4633                                                  syms[r_index].e_strx);
4634                     else
4635                       {
4636                         asection *s;
4637
4638                         s = aout_reloc_index_to_section (input_bfd, r_index);
4639                         name = bfd_section_name (input_bfd, s);
4640                       }
4641                     if (! ((*finfo->info->callbacks->reloc_overflow)
4642                            (finfo->info, (h ? &h->root : NULL), name,
4643                             howto_table_ext[r_type].name,
4644                             r_addend, input_bfd, input_section, r_addr)))
4645                       return FALSE;
4646                   }
4647                   break;
4648                 }
4649             }
4650         }
4651     }
4652
4653   return TRUE;
4654 }
4655
4656 /* Link an a.out section into the output file.  */
4657
4658 static bfd_boolean
4659 aout_link_input_section (struct aout_final_link_info *finfo,
4660                          bfd *input_bfd,
4661                          asection *input_section,
4662                          file_ptr *reloff_ptr,
4663                          bfd_size_type rel_size)
4664 {
4665   bfd_size_type input_size;
4666   void * relocs;
4667
4668   /* Get the section contents.  */
4669   input_size = input_section->size;
4670   if (! bfd_get_section_contents (input_bfd, input_section,
4671                                   (void *) finfo->contents,
4672                                   (file_ptr) 0, input_size))
4673     return FALSE;
4674
4675   /* Read in the relocs if we haven't already done it.  */
4676   if (aout_section_data (input_section) != NULL
4677       && aout_section_data (input_section)->relocs != NULL)
4678     relocs = aout_section_data (input_section)->relocs;
4679   else
4680     {
4681       relocs = finfo->relocs;
4682       if (rel_size > 0)
4683         {
4684           if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4685               || bfd_bread (relocs, rel_size, input_bfd) != rel_size)
4686             return FALSE;
4687         }
4688     }
4689
4690   /* Relocate the section contents.  */
4691   if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
4692     {
4693       if (! aout_link_input_section_std (finfo, input_bfd, input_section,
4694                                          (struct reloc_std_external *) relocs,
4695                                          rel_size, finfo->contents))
4696         return FALSE;
4697     }
4698   else
4699     {
4700       if (! aout_link_input_section_ext (finfo, input_bfd, input_section,
4701                                          (struct reloc_ext_external *) relocs,
4702                                          rel_size, finfo->contents))
4703         return FALSE;
4704     }
4705
4706   /* Write out the section contents.  */
4707   if (! bfd_set_section_contents (finfo->output_bfd,
4708                                   input_section->output_section,
4709                                   (void *) finfo->contents,
4710                                   (file_ptr) input_section->output_offset,
4711                                   input_size))
4712     return FALSE;
4713
4714   /* If we are producing relocatable output, the relocs were
4715      modified, and we now write them out.  */
4716   if (finfo->info->relocatable && rel_size > 0)
4717     {
4718       if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
4719         return FALSE;
4720       if (bfd_bwrite (relocs, rel_size, finfo->output_bfd) != rel_size)
4721         return FALSE;
4722       *reloff_ptr += rel_size;
4723
4724       /* Assert that the relocs have not run into the symbols, and
4725          that if these are the text relocs they have not run into the
4726          data relocs.  */
4727       BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
4728                   && (reloff_ptr != &finfo->treloff
4729                       || (*reloff_ptr
4730                           <= obj_datasec (finfo->output_bfd)->rel_filepos)));
4731     }
4732
4733   return TRUE;
4734 }
4735
4736 /* Adjust and write out the symbols for an a.out file.  Set the new
4737    symbol indices into a symbol_map.  */
4738
4739 static bfd_boolean
4740 aout_link_write_symbols (struct aout_final_link_info *finfo, bfd *input_bfd)
4741 {
4742   bfd *output_bfd;
4743   bfd_size_type sym_count;
4744   char *strings;
4745   enum bfd_link_strip strip;
4746   enum bfd_link_discard discard;
4747   struct external_nlist *outsym;
4748   bfd_size_type strtab_index;
4749   struct external_nlist *sym;
4750   struct external_nlist *sym_end;
4751   struct aout_link_hash_entry **sym_hash;
4752   int *symbol_map;
4753   bfd_boolean pass;
4754   bfd_boolean skip_next;
4755
4756   output_bfd = finfo->output_bfd;
4757   sym_count = obj_aout_external_sym_count (input_bfd);
4758   strings = obj_aout_external_strings (input_bfd);
4759   strip = finfo->info->strip;
4760   discard = finfo->info->discard;
4761   outsym = finfo->output_syms;
4762
4763   /* First write out a symbol for this object file, unless we are
4764      discarding such symbols.  */
4765   if (strip != strip_all
4766       && (strip != strip_some
4767           || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
4768                               FALSE, FALSE) != NULL)
4769       && discard != discard_all)
4770     {
4771       H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
4772       H_PUT_8 (output_bfd, 0, outsym->e_other);
4773       H_PUT_16 (output_bfd, 0, outsym->e_desc);
4774       strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4775                                        input_bfd->filename, FALSE);
4776       if (strtab_index == (bfd_size_type) -1)
4777         return FALSE;
4778       PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4779       PUT_WORD (output_bfd,
4780                 (bfd_get_section_vma (output_bfd,
4781                                       obj_textsec (input_bfd)->output_section)
4782                  + obj_textsec (input_bfd)->output_offset),
4783                 outsym->e_value);
4784       ++obj_aout_external_sym_count (output_bfd);
4785       ++outsym;
4786     }
4787
4788   pass = FALSE;
4789   skip_next = FALSE;
4790   sym = obj_aout_external_syms (input_bfd);
4791   sym_end = sym + sym_count;
4792   sym_hash = obj_aout_sym_hashes (input_bfd);
4793   symbol_map = finfo->symbol_map;
4794   memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
4795   for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
4796     {
4797       const char *name;
4798       int type;
4799       struct aout_link_hash_entry *h;
4800       bfd_boolean skip;
4801       asection *symsec;
4802       bfd_vma val = 0;
4803       bfd_boolean copy;
4804
4805       /* We set *symbol_map to 0 above for all symbols.  If it has
4806          already been set to -1 for this symbol, it means that we are
4807          discarding it because it appears in a duplicate header file.
4808          See the N_BINCL code below.  */
4809       if (*symbol_map == -1)
4810         continue;
4811
4812       /* Initialize *symbol_map to -1, which means that the symbol was
4813          not copied into the output file.  We will change it later if
4814          we do copy the symbol over.  */
4815       *symbol_map = -1;
4816
4817       type = H_GET_8 (input_bfd, sym->e_type);
4818       name = strings + GET_WORD (input_bfd, sym->e_strx);
4819
4820       h = NULL;
4821
4822       if (pass)
4823         {
4824           /* Pass this symbol through.  It is the target of an
4825              indirect or warning symbol.  */
4826           val = GET_WORD (input_bfd, sym->e_value);
4827           pass = FALSE;
4828         }
4829       else if (skip_next)
4830         {
4831           /* Skip this symbol, which is the target of an indirect
4832              symbol that we have changed to no longer be an indirect
4833              symbol.  */
4834           skip_next = FALSE;
4835           continue;
4836         }
4837       else
4838         {
4839           struct aout_link_hash_entry *hresolve;
4840
4841           /* We have saved the hash table entry for this symbol, if
4842              there is one.  Note that we could just look it up again
4843              in the hash table, provided we first check that it is an
4844              external symbol.  */
4845           h = *sym_hash;
4846
4847           /* Use the name from the hash table, in case the symbol was
4848              wrapped.  */
4849           if (h != NULL
4850               && h->root.type != bfd_link_hash_warning)
4851             name = h->root.root.string;
4852
4853           /* If this is an indirect or warning symbol, then change
4854              hresolve to the base symbol.  We also change *sym_hash so
4855              that the relocation routines relocate against the real
4856              symbol.  */
4857           hresolve = h;
4858           if (h != (struct aout_link_hash_entry *) NULL
4859               && (h->root.type == bfd_link_hash_indirect
4860                   || h->root.type == bfd_link_hash_warning))
4861             {
4862               hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
4863               while (hresolve->root.type == bfd_link_hash_indirect
4864                      || hresolve->root.type == bfd_link_hash_warning)
4865                 hresolve = ((struct aout_link_hash_entry *)
4866                             hresolve->root.u.i.link);
4867               *sym_hash = hresolve;
4868             }
4869
4870           /* If the symbol has already been written out, skip it.  */
4871           if (h != NULL
4872               && h->written)
4873             {
4874               if ((type & N_TYPE) == N_INDR
4875                   || type == N_WARNING)
4876                 skip_next = TRUE;
4877               *symbol_map = h->indx;
4878               continue;
4879             }
4880
4881           /* See if we are stripping this symbol.  */
4882           skip = FALSE;
4883           switch (strip)
4884             {
4885             case strip_none:
4886               break;
4887             case strip_debugger:
4888               if ((type & N_STAB) != 0)
4889                 skip = TRUE;
4890               break;
4891             case strip_some:
4892               if (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
4893                   == NULL)
4894                 skip = TRUE;
4895               break;
4896             case strip_all:
4897               skip = TRUE;
4898               break;
4899             }
4900           if (skip)
4901             {
4902               if (h != NULL)
4903                 h->written = TRUE;
4904               continue;
4905             }
4906
4907           /* Get the value of the symbol.  */
4908           if ((type & N_TYPE) == N_TEXT
4909               || type == N_WEAKT)
4910             symsec = obj_textsec (input_bfd);
4911           else if ((type & N_TYPE) == N_DATA
4912                    || type == N_WEAKD)
4913             symsec = obj_datasec (input_bfd);
4914           else if ((type & N_TYPE) == N_BSS
4915                    || type == N_WEAKB)
4916             symsec = obj_bsssec (input_bfd);
4917           else if ((type & N_TYPE) == N_ABS
4918                    || type == N_WEAKA)
4919             symsec = bfd_abs_section_ptr;
4920           else if (((type & N_TYPE) == N_INDR
4921                     && (hresolve == NULL
4922                         || (hresolve->root.type != bfd_link_hash_defined
4923                             && hresolve->root.type != bfd_link_hash_defweak
4924                             && hresolve->root.type != bfd_link_hash_common)))
4925                    || type == N_WARNING)
4926             {
4927               /* Pass the next symbol through unchanged.  The
4928                  condition above for indirect symbols is so that if
4929                  the indirect symbol was defined, we output it with
4930                  the correct definition so the debugger will
4931                  understand it.  */
4932               pass = TRUE;
4933               val = GET_WORD (input_bfd, sym->e_value);
4934               symsec = NULL;
4935             }
4936           else if ((type & N_STAB) != 0)
4937             {
4938               val = GET_WORD (input_bfd, sym->e_value);
4939               symsec = NULL;
4940             }
4941           else
4942             {
4943               /* If we get here with an indirect symbol, it means that
4944                  we are outputting it with a real definition.  In such
4945                  a case we do not want to output the next symbol,
4946                  which is the target of the indirection.  */
4947               if ((type & N_TYPE) == N_INDR)
4948                 skip_next = TRUE;
4949
4950               symsec = NULL;
4951
4952               /* We need to get the value from the hash table.  We use
4953                  hresolve so that if we have defined an indirect
4954                  symbol we output the final definition.  */
4955               if (h == NULL)
4956                 {
4957                   switch (type & N_TYPE)
4958                     {
4959                     case N_SETT:
4960                       symsec = obj_textsec (input_bfd);
4961                       break;
4962                     case N_SETD:
4963                       symsec = obj_datasec (input_bfd);
4964                       break;
4965                     case N_SETB:
4966                       symsec = obj_bsssec (input_bfd);
4967                       break;
4968                     case N_SETA:
4969                       symsec = bfd_abs_section_ptr;
4970                       break;
4971                     default:
4972                       val = 0;
4973                       break;
4974                     }
4975                 }
4976               else if (hresolve->root.type == bfd_link_hash_defined
4977                        || hresolve->root.type == bfd_link_hash_defweak)
4978                 {
4979                   asection *input_section;
4980                   asection *output_section;
4981
4982                   /* This case usually means a common symbol which was
4983                      turned into a defined symbol.  */
4984                   input_section = hresolve->root.u.def.section;
4985                   output_section = input_section->output_section;
4986                   BFD_ASSERT (bfd_is_abs_section (output_section)
4987                               || output_section->owner == output_bfd);
4988                   val = (hresolve->root.u.def.value
4989                          + bfd_get_section_vma (output_bfd, output_section)
4990                          + input_section->output_offset);
4991
4992                   /* Get the correct type based on the section.  If
4993                      this is a constructed set, force it to be
4994                      globally visible.  */
4995                   if (type == N_SETT
4996                       || type == N_SETD
4997                       || type == N_SETB
4998                       || type == N_SETA)
4999                     type |= N_EXT;
5000
5001                   type &=~ N_TYPE;
5002
5003                   if (output_section == obj_textsec (output_bfd))
5004                     type |= (hresolve->root.type == bfd_link_hash_defined
5005                              ? N_TEXT
5006                              : N_WEAKT);
5007                   else if (output_section == obj_datasec (output_bfd))
5008                     type |= (hresolve->root.type == bfd_link_hash_defined
5009                              ? N_DATA
5010                              : N_WEAKD);
5011                   else if (output_section == obj_bsssec (output_bfd))
5012                     type |= (hresolve->root.type == bfd_link_hash_defined
5013                              ? N_BSS
5014                              : N_WEAKB);
5015                   else
5016                     type |= (hresolve->root.type == bfd_link_hash_defined
5017                              ? N_ABS
5018                              : N_WEAKA);
5019                 }
5020               else if (hresolve->root.type == bfd_link_hash_common)
5021                 val = hresolve->root.u.c.size;
5022               else if (hresolve->root.type == bfd_link_hash_undefweak)
5023                 {
5024                   val = 0;
5025                   type = N_WEAKU;
5026                 }
5027               else
5028                 val = 0;
5029             }
5030           if (symsec != NULL)
5031             val = (symsec->output_section->vma
5032                    + symsec->output_offset
5033                    + (GET_WORD (input_bfd, sym->e_value)
5034                       - symsec->vma));
5035
5036           /* If this is a global symbol set the written flag, and if
5037              it is a local symbol see if we should discard it.  */
5038           if (h != NULL)
5039             {
5040               h->written = TRUE;
5041               h->indx = obj_aout_external_sym_count (output_bfd);
5042             }
5043           else if ((type & N_TYPE) != N_SETT
5044                    && (type & N_TYPE) != N_SETD
5045                    && (type & N_TYPE) != N_SETB
5046                    && (type & N_TYPE) != N_SETA)
5047             {
5048               switch (discard)
5049                 {
5050                 case discard_none:
5051                 case discard_sec_merge:
5052                   break;
5053                 case discard_l:
5054                   if ((type & N_STAB) == 0
5055                       && bfd_is_local_label_name (input_bfd, name))
5056                     skip = TRUE;
5057                   break;
5058                 case discard_all:
5059                   skip = TRUE;
5060                   break;
5061                 }
5062               if (skip)
5063                 {
5064                   pass = FALSE;
5065                   continue;
5066                 }
5067             }
5068
5069           /* An N_BINCL symbol indicates the start of the stabs
5070              entries for a header file.  We need to scan ahead to the
5071              next N_EINCL symbol, ignoring nesting, adding up all the
5072              characters in the symbol names, not including the file
5073              numbers in types (the first number after an open
5074              parenthesis).  */
5075           if (type == (int) N_BINCL)
5076             {
5077               struct external_nlist *incl_sym;
5078               int nest;
5079               struct aout_link_includes_entry *incl_entry;
5080               struct aout_link_includes_totals *t;
5081
5082               val = 0;
5083               nest = 0;
5084               for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
5085                 {
5086                   int incl_type;
5087
5088                   incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
5089                   if (incl_type == (int) N_EINCL)
5090                     {
5091                       if (nest == 0)
5092                         break;
5093                       --nest;
5094                     }
5095                   else if (incl_type == (int) N_BINCL)
5096                     ++nest;
5097                   else if (nest == 0)
5098                     {
5099                       const char *s;
5100
5101                       s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
5102                       for (; *s != '\0'; s++)
5103                         {
5104                           val += *s;
5105                           if (*s == '(')
5106                             {
5107                               /* Skip the file number.  */
5108                               ++s;
5109                               while (ISDIGIT (*s))
5110                                 ++s;
5111                               --s;
5112                             }
5113                         }
5114                     }
5115                 }
5116
5117               /* If we have already included a header file with the
5118                  same value, then replace this one with an N_EXCL
5119                  symbol.  */
5120               copy = (bfd_boolean) (! finfo->info->keep_memory);
5121               incl_entry = aout_link_includes_lookup (&finfo->includes,
5122                                                       name, TRUE, copy);
5123               if (incl_entry == NULL)
5124                 return FALSE;
5125               for (t = incl_entry->totals; t != NULL; t = t->next)
5126                 if (t->total == val)
5127                   break;
5128               if (t == NULL)
5129                 {
5130                   /* This is the first time we have seen this header
5131                      file with this set of stabs strings.  */
5132                   t = bfd_hash_allocate (&finfo->includes.root,
5133                                          sizeof *t);
5134                   if (t == NULL)
5135                     return FALSE;
5136                   t->total = val;
5137                   t->next = incl_entry->totals;
5138                   incl_entry->totals = t;
5139                 }
5140               else
5141                 {
5142                   int *incl_map;
5143
5144                   /* This is a duplicate header file.  We must change
5145                      it to be an N_EXCL entry, and mark all the
5146                      included symbols to prevent outputting them.  */
5147                   type = (int) N_EXCL;
5148
5149                   nest = 0;
5150                   for (incl_sym = sym + 1, incl_map = symbol_map + 1;
5151                        incl_sym < sym_end;
5152                        incl_sym++, incl_map++)
5153                     {
5154                       int incl_type;
5155
5156                       incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
5157                       if (incl_type == (int) N_EINCL)
5158                         {
5159                           if (nest == 0)
5160                             {
5161                               *incl_map = -1;
5162                               break;
5163                             }
5164                           --nest;
5165                         }
5166                       else if (incl_type == (int) N_BINCL)
5167                         ++nest;
5168                       else if (nest == 0)
5169                         *incl_map = -1;
5170                     }
5171                 }
5172             }
5173         }
5174
5175       /* Copy this symbol into the list of symbols we are going to
5176          write out.  */
5177       H_PUT_8 (output_bfd, type, outsym->e_type);
5178       H_PUT_8 (output_bfd, H_GET_8 (input_bfd, sym->e_other), outsym->e_other);
5179       H_PUT_16 (output_bfd, H_GET_16 (input_bfd, sym->e_desc), outsym->e_desc);
5180       copy = FALSE;
5181       if (! finfo->info->keep_memory)
5182         {
5183           /* name points into a string table which we are going to
5184              free.  If there is a hash table entry, use that string.
5185              Otherwise, copy name into memory.  */
5186           if (h != NULL)
5187             name = h->root.root.string;
5188           else
5189             copy = TRUE;
5190         }
5191       strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
5192                                        name, copy);
5193       if (strtab_index == (bfd_size_type) -1)
5194         return FALSE;
5195       PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
5196       PUT_WORD (output_bfd, val, outsym->e_value);
5197       *symbol_map = obj_aout_external_sym_count (output_bfd);
5198       ++obj_aout_external_sym_count (output_bfd);
5199       ++outsym;
5200     }
5201
5202   /* Write out the output symbols we have just constructed.  */
5203   if (outsym > finfo->output_syms)
5204     {
5205       bfd_size_type outsym_size;
5206
5207       if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
5208         return FALSE;
5209       outsym_size = outsym - finfo->output_syms;
5210       outsym_size *= EXTERNAL_NLIST_SIZE;
5211       if (bfd_bwrite ((void *) finfo->output_syms, outsym_size, output_bfd)
5212           != outsym_size)
5213         return FALSE;
5214       finfo->symoff += outsym_size;
5215     }
5216
5217   return TRUE;
5218 }
5219
5220 /* Link an a.out input BFD into the output file.  */
5221
5222 static bfd_boolean
5223 aout_link_input_bfd (struct aout_final_link_info *finfo, bfd *input_bfd)
5224 {
5225   bfd_size_type sym_count;
5226
5227   BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
5228
5229   /* If this is a dynamic object, it may need special handling.  */
5230   if ((input_bfd->flags & DYNAMIC) != 0
5231       && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
5232     return ((*aout_backend_info (input_bfd)->link_dynamic_object)
5233             (finfo->info, input_bfd));
5234
5235   /* Get the symbols.  We probably have them already, unless
5236      finfo->info->keep_memory is FALSE.  */
5237   if (! aout_get_external_symbols (input_bfd))
5238     return FALSE;
5239
5240   sym_count = obj_aout_external_sym_count (input_bfd);
5241
5242   /* Write out the symbols and get a map of the new indices.  The map
5243      is placed into finfo->symbol_map.  */
5244   if (! aout_link_write_symbols (finfo, input_bfd))
5245     return FALSE;
5246
5247   /* Relocate and write out the sections.  These functions use the
5248      symbol map created by aout_link_write_symbols.  The linker_mark
5249      field will be set if these sections are to be included in the
5250      link, which will normally be the case.  */
5251   if (obj_textsec (input_bfd)->linker_mark)
5252     {
5253       if (! aout_link_input_section (finfo, input_bfd,
5254                                      obj_textsec (input_bfd),
5255                                      &finfo->treloff,
5256                                      exec_hdr (input_bfd)->a_trsize))
5257         return FALSE;
5258     }
5259   if (obj_datasec (input_bfd)->linker_mark)
5260     {
5261       if (! aout_link_input_section (finfo, input_bfd,
5262                                      obj_datasec (input_bfd),
5263                                      &finfo->dreloff,
5264                                      exec_hdr (input_bfd)->a_drsize))
5265         return FALSE;
5266     }
5267
5268   /* If we are not keeping memory, we don't need the symbols any
5269      longer.  We still need them if we are keeping memory, because the
5270      strings in the hash table point into them.  */
5271   if (! finfo->info->keep_memory)
5272     {
5273       if (! aout_link_free_symbols (input_bfd))
5274         return FALSE;
5275     }
5276
5277   return TRUE;
5278 }
5279
5280 /* Do the final link step.  This is called on the output BFD.  The
5281    INFO structure should point to a list of BFDs linked through the
5282    link_next field which can be used to find each BFD which takes part
5283    in the output.  Also, each section in ABFD should point to a list
5284    of bfd_link_order structures which list all the input sections for
5285    the output section.  */
5286
5287 bfd_boolean
5288 NAME (aout, final_link) (bfd *abfd,
5289                          struct bfd_link_info *info,
5290                          void (*callback) (bfd *, file_ptr *, file_ptr *, file_ptr *))
5291 {
5292   struct aout_final_link_info aout_info;
5293   bfd_boolean includes_hash_initialized = FALSE;
5294   bfd *sub;
5295   bfd_size_type trsize, drsize;
5296   bfd_size_type max_contents_size;
5297   bfd_size_type max_relocs_size;
5298   bfd_size_type max_sym_count;
5299   bfd_size_type text_size;
5300   file_ptr text_end;
5301   struct bfd_link_order *p;
5302   asection *o;
5303   bfd_boolean have_link_order_relocs;
5304
5305   if (info->shared)
5306     abfd->flags |= DYNAMIC;
5307
5308   aout_info.info = info;
5309   aout_info.output_bfd = abfd;
5310   aout_info.contents = NULL;
5311   aout_info.relocs = NULL;
5312   aout_info.symbol_map = NULL;
5313   aout_info.output_syms = NULL;
5314
5315   if (!bfd_hash_table_init_n (&aout_info.includes.root,
5316                               aout_link_includes_newfunc,
5317                               sizeof (struct aout_link_includes_entry),
5318                               251))
5319     goto error_return;
5320   includes_hash_initialized = TRUE;
5321
5322   /* Figure out the largest section size.  Also, if generating
5323      relocatable output, count the relocs.  */
5324   trsize = 0;
5325   drsize = 0;
5326   max_contents_size = 0;
5327   max_relocs_size = 0;
5328   max_sym_count = 0;
5329   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
5330     {
5331       bfd_size_type sz;
5332
5333       if (info->relocatable)
5334         {
5335           if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
5336             {
5337               trsize += exec_hdr (sub)->a_trsize;
5338               drsize += exec_hdr (sub)->a_drsize;
5339             }
5340           else
5341             {
5342               /* FIXME: We need to identify the .text and .data sections
5343                  and call get_reloc_upper_bound and canonicalize_reloc to
5344                  work out the number of relocs needed, and then multiply
5345                  by the reloc size.  */
5346               (*_bfd_error_handler)
5347                 (_("%s: relocatable link from %s to %s not supported"),
5348                  bfd_get_filename (abfd),
5349                  sub->xvec->name, abfd->xvec->name);
5350               bfd_set_error (bfd_error_invalid_operation);
5351               goto error_return;
5352             }
5353         }
5354
5355       if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
5356         {
5357           sz = obj_textsec (sub)->size;
5358           if (sz > max_contents_size)
5359             max_contents_size = sz;
5360           sz = obj_datasec (sub)->size;
5361           if (sz > max_contents_size)
5362             max_contents_size = sz;
5363
5364           sz = exec_hdr (sub)->a_trsize;
5365           if (sz > max_relocs_size)
5366             max_relocs_size = sz;
5367           sz = exec_hdr (sub)->a_drsize;
5368           if (sz > max_relocs_size)
5369             max_relocs_size = sz;
5370
5371           sz = obj_aout_external_sym_count (sub);
5372           if (sz > max_sym_count)
5373             max_sym_count = sz;
5374         }
5375     }
5376
5377   if (info->relocatable)
5378     {
5379       if (obj_textsec (abfd) != NULL)
5380         trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
5381                                                  ->map_head.link_order)
5382                    * obj_reloc_entry_size (abfd));
5383       if (obj_datasec (abfd) != NULL)
5384         drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
5385                                                  ->map_head.link_order)
5386                    * obj_reloc_entry_size (abfd));
5387     }
5388
5389   exec_hdr (abfd)->a_trsize = trsize;
5390   exec_hdr (abfd)->a_drsize = drsize;
5391
5392   exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
5393
5394   /* Adjust the section sizes and vmas according to the magic number.
5395      This sets a_text, a_data and a_bss in the exec_hdr and sets the
5396      filepos for each section.  */
5397   if (! NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
5398     goto error_return;
5399
5400   /* The relocation and symbol file positions differ among a.out
5401      targets.  We are passed a callback routine from the backend
5402      specific code to handle this.
5403      FIXME: At this point we do not know how much space the symbol
5404      table will require.  This will not work for any (nonstandard)
5405      a.out target that needs to know the symbol table size before it
5406      can compute the relocation file positions.  This may or may not
5407      be the case for the hp300hpux target, for example.  */
5408   (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
5409                &aout_info.symoff);
5410   obj_textsec (abfd)->rel_filepos = aout_info.treloff;
5411   obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
5412   obj_sym_filepos (abfd) = aout_info.symoff;
5413
5414   /* We keep a count of the symbols as we output them.  */
5415   obj_aout_external_sym_count (abfd) = 0;
5416
5417   /* We accumulate the string table as we write out the symbols.  */
5418   aout_info.strtab = _bfd_stringtab_init ();
5419   if (aout_info.strtab == NULL)
5420     goto error_return;
5421
5422   /* Allocate buffers to hold section contents and relocs.  */
5423   aout_info.contents = bfd_malloc (max_contents_size);
5424   aout_info.relocs = bfd_malloc (max_relocs_size);
5425   aout_info.symbol_map = bfd_malloc (max_sym_count * sizeof (int *));
5426   aout_info.output_syms = bfd_malloc ((max_sym_count + 1)
5427                                       * sizeof (struct external_nlist));
5428   if ((aout_info.contents == NULL && max_contents_size != 0)
5429       || (aout_info.relocs == NULL && max_relocs_size != 0)
5430       || (aout_info.symbol_map == NULL && max_sym_count != 0)
5431       || aout_info.output_syms == NULL)
5432     goto error_return;
5433
5434   /* If we have a symbol named __DYNAMIC, force it out now.  This is
5435      required by SunOS.  Doing this here rather than in sunos.c is a
5436      hack, but it's easier than exporting everything which would be
5437      needed.  */
5438   {
5439     struct aout_link_hash_entry *h;
5440
5441     h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
5442                                FALSE, FALSE, FALSE);
5443     if (h != NULL)
5444       aout_link_write_other_symbol (h, &aout_info);
5445   }
5446
5447   /* The most time efficient way to do the link would be to read all
5448      the input object files into memory and then sort out the
5449      information into the output file.  Unfortunately, that will
5450      probably use too much memory.  Another method would be to step
5451      through everything that composes the text section and write it
5452      out, and then everything that composes the data section and write
5453      it out, and then write out the relocs, and then write out the
5454      symbols.  Unfortunately, that requires reading stuff from each
5455      input file several times, and we will not be able to keep all the
5456      input files open simultaneously, and reopening them will be slow.
5457
5458      What we do is basically process one input file at a time.  We do
5459      everything we need to do with an input file once--copy over the
5460      section contents, handle the relocation information, and write
5461      out the symbols--and then we throw away the information we read
5462      from it.  This approach requires a lot of lseeks of the output
5463      file, which is unfortunate but still faster than reopening a lot
5464      of files.
5465
5466      We use the output_has_begun field of the input BFDs to see
5467      whether we have already handled it.  */
5468   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
5469     sub->output_has_begun = FALSE;
5470
5471   /* Mark all sections which are to be included in the link.  This
5472      will normally be every section.  We need to do this so that we
5473      can identify any sections which the linker has decided to not
5474      include.  */
5475   for (o = abfd->sections; o != NULL; o = o->next)
5476     {
5477       for (p = o->map_head.link_order; p != NULL; p = p->next)
5478         if (p->type == bfd_indirect_link_order)
5479           p->u.indirect.section->linker_mark = TRUE;
5480     }
5481
5482   have_link_order_relocs = FALSE;
5483   for (o = abfd->sections; o != NULL; o = o->next)
5484     {
5485       for (p = o->map_head.link_order;
5486            p != NULL;
5487            p = p->next)
5488         {
5489           if (p->type == bfd_indirect_link_order
5490               && (bfd_get_flavour (p->u.indirect.section->owner)
5491                   == bfd_target_aout_flavour))
5492             {
5493               bfd *input_bfd;
5494
5495               input_bfd = p->u.indirect.section->owner;
5496               if (! input_bfd->output_has_begun)
5497                 {
5498                   if (! aout_link_input_bfd (&aout_info, input_bfd))
5499                     goto error_return;
5500                   input_bfd->output_has_begun = TRUE;
5501                 }
5502             }
5503           else if (p->type == bfd_section_reloc_link_order
5504                    || p->type == bfd_symbol_reloc_link_order)
5505             {
5506               /* These are handled below.  */
5507               have_link_order_relocs = TRUE;
5508             }
5509           else
5510             {
5511               if (! _bfd_default_link_order (abfd, info, o, p))
5512                 goto error_return;
5513             }
5514         }
5515     }
5516
5517   /* Write out any symbols that we have not already written out.  */
5518   aout_link_hash_traverse (aout_hash_table (info),
5519                            aout_link_write_other_symbol,
5520                            (void *) &aout_info);
5521
5522   /* Now handle any relocs we were asked to create by the linker.
5523      These did not come from any input file.  We must do these after
5524      we have written out all the symbols, so that we know the symbol
5525      indices to use.  */
5526   if (have_link_order_relocs)
5527     {
5528       for (o = abfd->sections; o != NULL; o = o->next)
5529         {
5530           for (p = o->map_head.link_order;
5531                p != NULL;
5532                p = p->next)
5533             {
5534               if (p->type == bfd_section_reloc_link_order
5535                   || p->type == bfd_symbol_reloc_link_order)
5536                 {
5537                   if (! aout_link_reloc_link_order (&aout_info, o, p))
5538                     goto error_return;
5539                 }
5540             }
5541         }
5542     }
5543
5544   if (aout_info.contents != NULL)
5545     {
5546       free (aout_info.contents);
5547       aout_info.contents = NULL;
5548     }
5549   if (aout_info.relocs != NULL)
5550     {
5551       free (aout_info.relocs);
5552       aout_info.relocs = NULL;
5553     }
5554   if (aout_info.symbol_map != NULL)
5555     {
5556       free (aout_info.symbol_map);
5557       aout_info.symbol_map = NULL;
5558     }
5559   if (aout_info.output_syms != NULL)
5560     {
5561       free (aout_info.output_syms);
5562       aout_info.output_syms = NULL;
5563     }
5564   if (includes_hash_initialized)
5565     {
5566       bfd_hash_table_free (&aout_info.includes.root);
5567       includes_hash_initialized = FALSE;
5568     }
5569
5570   /* Finish up any dynamic linking we may be doing.  */
5571   if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
5572     {
5573       if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
5574         goto error_return;
5575     }
5576
5577   /* Update the header information.  */
5578   abfd->symcount = obj_aout_external_sym_count (abfd);
5579   exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
5580   obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
5581   obj_textsec (abfd)->reloc_count =
5582     exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
5583   obj_datasec (abfd)->reloc_count =
5584     exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
5585
5586   /* Write out the string table, unless there are no symbols.  */
5587   if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0)
5588     goto error_return;
5589   if (abfd->symcount > 0)
5590     {
5591       if (!emit_stringtab (abfd, aout_info.strtab))
5592         goto error_return;
5593     }
5594   else
5595     {
5596       bfd_byte b[BYTES_IN_WORD];
5597
5598       memset (b, 0, BYTES_IN_WORD);
5599       if (bfd_bwrite (b, (bfd_size_type) BYTES_IN_WORD, abfd) != BYTES_IN_WORD)
5600         goto error_return;
5601     }
5602
5603   return TRUE;
5604
5605  error_return:
5606   if (aout_info.contents != NULL)
5607     free (aout_info.contents);
5608   if (aout_info.relocs != NULL)
5609     free (aout_info.relocs);
5610   if (aout_info.symbol_map != NULL)
5611     free (aout_info.symbol_map);
5612   if (aout_info.output_syms != NULL)
5613     free (aout_info.output_syms);
5614   if (includes_hash_initialized)
5615     bfd_hash_table_free (&aout_info.includes.root);
5616   return FALSE;
5617 }