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   /* We keep a list of the linker hash table entries that correspond
2963      to particular symbols.  We could just look them up in the hash
2964      table, but keeping the list is more efficient.  Perhaps this
2965      should be conditional on info->keep_memory.  */
2966   amt = sym_count * sizeof (struct aout_link_hash_entry *);
2967   sym_hash = bfd_alloc (abfd, amt);
2968   if (sym_hash == NULL && sym_count != 0)
2969     return FALSE;
2970   obj_aout_sym_hashes (abfd) = sym_hash;
2971
2972   add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
2973   if (add_one_symbol == NULL)
2974     add_one_symbol = _bfd_generic_link_add_one_symbol;
2975
2976   p = syms;
2977   pend = p + sym_count;
2978   for (; p < pend; p++, sym_hash++)
2979     {
2980       int type;
2981       const char *name;
2982       bfd_vma value;
2983       asection *section;
2984       flagword flags;
2985       const char *string;
2986
2987       *sym_hash = NULL;
2988
2989       type = H_GET_8 (abfd, p->e_type);
2990
2991       /* Ignore debugging symbols.  */
2992       if ((type & N_STAB) != 0)
2993         continue;
2994
2995       name = strings + GET_WORD (abfd, p->e_strx);
2996       value = GET_WORD (abfd, p->e_value);
2997       flags = BSF_GLOBAL;
2998       string = NULL;
2999       switch (type)
3000         {
3001         default:
3002           abort ();
3003
3004         case N_UNDF:
3005         case N_ABS:
3006         case N_TEXT:
3007         case N_DATA:
3008         case N_BSS:
3009         case N_FN_SEQ:
3010         case N_COMM:
3011         case N_SETV:
3012         case N_FN:
3013           /* Ignore symbols that are not externally visible.  */
3014           continue;
3015         case N_INDR:
3016           /* Ignore local indirect symbol.  */
3017           ++p;
3018           ++sym_hash;
3019           continue;
3020
3021         case N_UNDF | N_EXT:
3022           if (value == 0)
3023             {
3024               section = bfd_und_section_ptr;
3025               flags = 0;
3026             }
3027           else
3028             section = bfd_com_section_ptr;
3029           break;
3030         case N_ABS | N_EXT:
3031           section = bfd_abs_section_ptr;
3032           break;
3033         case N_TEXT | N_EXT:
3034           section = obj_textsec (abfd);
3035           value -= bfd_get_section_vma (abfd, section);
3036           break;
3037         case N_DATA | N_EXT:
3038         case N_SETV | N_EXT:
3039           /* Treat N_SETV symbols as N_DATA symbol; see comment in
3040              translate_from_native_sym_flags.  */
3041           section = obj_datasec (abfd);
3042           value -= bfd_get_section_vma (abfd, section);
3043           break;
3044         case N_BSS | N_EXT:
3045           section = obj_bsssec (abfd);
3046           value -= bfd_get_section_vma (abfd, section);
3047           break;
3048         case N_INDR | N_EXT:
3049           /* An indirect symbol.  The next symbol is the symbol
3050              which this one really is.  */
3051           BFD_ASSERT (p + 1 < pend);
3052           ++p;
3053           string = strings + GET_WORD (abfd, p->e_strx);
3054           section = bfd_ind_section_ptr;
3055           flags |= BSF_INDIRECT;
3056           break;
3057         case N_COMM | N_EXT:
3058           section = bfd_com_section_ptr;
3059           break;
3060         case N_SETA: case N_SETA | N_EXT:
3061           section = bfd_abs_section_ptr;
3062           flags |= BSF_CONSTRUCTOR;
3063           break;
3064         case N_SETT: case N_SETT | N_EXT:
3065           section = obj_textsec (abfd);
3066           flags |= BSF_CONSTRUCTOR;
3067           value -= bfd_get_section_vma (abfd, section);
3068           break;
3069         case N_SETD: case N_SETD | N_EXT:
3070           section = obj_datasec (abfd);
3071           flags |= BSF_CONSTRUCTOR;
3072           value -= bfd_get_section_vma (abfd, section);
3073           break;
3074         case N_SETB: case N_SETB | N_EXT:
3075           section = obj_bsssec (abfd);
3076           flags |= BSF_CONSTRUCTOR;
3077           value -= bfd_get_section_vma (abfd, section);
3078           break;
3079         case N_WARNING:
3080           /* A warning symbol.  The next symbol is the one to warn
3081              about.  If there is no next symbol, just look away.  */
3082           if (p + 1 >= pend)
3083             return TRUE;
3084           ++p;
3085           string = name;
3086           name = strings + GET_WORD (abfd, p->e_strx);
3087           section = bfd_und_section_ptr;
3088           flags |= BSF_WARNING;
3089           break;
3090         case N_WEAKU:
3091           section = bfd_und_section_ptr;
3092           flags = BSF_WEAK;
3093           break;
3094         case N_WEAKA:
3095           section = bfd_abs_section_ptr;
3096           flags = BSF_WEAK;
3097           break;
3098         case N_WEAKT:
3099           section = obj_textsec (abfd);
3100           value -= bfd_get_section_vma (abfd, section);
3101           flags = BSF_WEAK;
3102           break;
3103         case N_WEAKD:
3104           section = obj_datasec (abfd);
3105           value -= bfd_get_section_vma (abfd, section);
3106           flags = BSF_WEAK;
3107           break;
3108         case N_WEAKB:
3109           section = obj_bsssec (abfd);
3110           value -= bfd_get_section_vma (abfd, section);
3111           flags = BSF_WEAK;
3112           break;
3113         }
3114
3115       if (! ((*add_one_symbol)
3116              (info, abfd, name, flags, section, value, string, copy, FALSE,
3117               (struct bfd_link_hash_entry **) sym_hash)))
3118         return FALSE;
3119
3120       /* Restrict the maximum alignment of a common symbol based on
3121          the architecture, since a.out has no way to represent
3122          alignment requirements of a section in a .o file.  FIXME:
3123          This isn't quite right: it should use the architecture of the
3124          output file, not the input files.  */
3125       if ((*sym_hash)->root.type == bfd_link_hash_common
3126           && ((*sym_hash)->root.u.c.p->alignment_power >
3127               bfd_get_arch_info (abfd)->section_align_power))
3128         (*sym_hash)->root.u.c.p->alignment_power =
3129           bfd_get_arch_info (abfd)->section_align_power;
3130
3131       /* If this is a set symbol, and we are not building sets, then
3132          it is possible for the hash entry to not have been set.  In
3133          such a case, treat the symbol as not globally defined.  */
3134       if ((*sym_hash)->root.type == bfd_link_hash_new)
3135         {
3136           BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
3137           *sym_hash = NULL;
3138         }
3139
3140       if (type == (N_INDR | N_EXT) || type == N_WARNING)
3141         ++sym_hash;
3142     }
3143
3144   return TRUE;
3145 }
3146
3147 /* Free up the internal symbols read from an a.out file.  */
3148
3149 static bfd_boolean
3150 aout_link_free_symbols (bfd *abfd)
3151 {
3152   if (obj_aout_external_syms (abfd) != NULL)
3153     {
3154 #ifdef USE_MMAP
3155       bfd_free_window (&obj_aout_sym_window (abfd));
3156 #else
3157       free ((void *) obj_aout_external_syms (abfd));
3158 #endif
3159       obj_aout_external_syms (abfd) = NULL;
3160     }
3161   if (obj_aout_external_strings (abfd) != NULL)
3162     {
3163 #ifdef USE_MMAP
3164       bfd_free_window (&obj_aout_string_window (abfd));
3165 #else
3166       free ((void *) obj_aout_external_strings (abfd));
3167 #endif
3168       obj_aout_external_strings (abfd) = NULL;
3169     }
3170   return TRUE;
3171 }
3172
3173 /* Add symbols from an a.out object file.  */
3174
3175 static bfd_boolean
3176 aout_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3177 {
3178   if (! aout_get_external_symbols (abfd))
3179     return FALSE;
3180   if (! aout_link_add_symbols (abfd, info))
3181     return FALSE;
3182   if (! info->keep_memory)
3183     {
3184       if (! aout_link_free_symbols (abfd))
3185         return FALSE;
3186     }
3187   return TRUE;
3188 }
3189
3190 /* Look through the internal symbols to see if this object file should
3191    be included in the link.  We should include this object file if it
3192    defines any symbols which are currently undefined.  If this object
3193    file defines a common symbol, then we may adjust the size of the
3194    known symbol but we do not include the object file in the link
3195    (unless there is some other reason to include it).  */
3196
3197 static bfd_boolean
3198 aout_link_check_ar_symbols (bfd *abfd,
3199                             struct bfd_link_info *info,
3200                             bfd_boolean *pneeded)
3201 {
3202   struct external_nlist *p;
3203   struct external_nlist *pend;
3204   char *strings;
3205
3206   *pneeded = FALSE;
3207
3208   /* Look through all the symbols.  */
3209   p = obj_aout_external_syms (abfd);
3210   pend = p + obj_aout_external_sym_count (abfd);
3211   strings = obj_aout_external_strings (abfd);
3212   for (; p < pend; p++)
3213     {
3214       int type = H_GET_8 (abfd, p->e_type);
3215       const char *name;
3216       struct bfd_link_hash_entry *h;
3217
3218       /* Ignore symbols that are not externally visible.  This is an
3219          optimization only, as we check the type more thoroughly
3220          below.  */
3221       if (((type & N_EXT) == 0
3222            || (type & N_STAB) != 0
3223            || type == N_FN)
3224           && type != N_WEAKA
3225           && type != N_WEAKT
3226           && type != N_WEAKD
3227           && type != N_WEAKB)
3228         {
3229           if (type == N_WARNING
3230               || type == N_INDR)
3231             ++p;
3232           continue;
3233         }
3234
3235       name = strings + GET_WORD (abfd, p->e_strx);
3236       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
3237
3238       /* We are only interested in symbols that are currently
3239          undefined or common.  */
3240       if (h == NULL
3241           || (h->type != bfd_link_hash_undefined
3242               && h->type != bfd_link_hash_common))
3243         {
3244           if (type == (N_INDR | N_EXT))
3245             ++p;
3246           continue;
3247         }
3248
3249       if (type == (N_TEXT | N_EXT)
3250           || type == (N_DATA | N_EXT)
3251           || type == (N_BSS | N_EXT)
3252           || type == (N_ABS | N_EXT)
3253           || type == (N_INDR | N_EXT))
3254         {
3255           /* This object file defines this symbol.  We must link it
3256              in.  This is true regardless of whether the current
3257              definition of the symbol is undefined or common.
3258
3259              If the current definition is common, we have a case in
3260              which we have already seen an object file including:
3261                  int a;
3262              and this object file from the archive includes:
3263                  int a = 5;
3264              In such a case, whether to include this object is target
3265              dependant for backward compatibility.
3266
3267              FIXME: The SunOS 4.1.3 linker will pull in the archive
3268              element if the symbol is defined in the .data section,
3269              but not if it is defined in the .text section.  That
3270              seems a bit crazy to me, and it has not been implemented
3271              yet.  However, it might be correct.  */
3272           if (h->type == bfd_link_hash_common)
3273             {
3274               int skip = 0;
3275
3276               switch (info->common_skip_ar_aymbols)
3277                 {
3278                 case bfd_link_common_skip_text:
3279                   skip = (type == (N_TEXT | N_EXT));
3280                   break;
3281                 case bfd_link_common_skip_data:
3282                   skip = (type == (N_DATA | N_EXT));
3283                   break;
3284                 default:
3285                 case bfd_link_common_skip_all:
3286                   skip = 1;
3287                   break;
3288                 }
3289
3290               if (skip)
3291                 continue;
3292             }
3293
3294           if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3295             return FALSE;
3296           *pneeded = TRUE;
3297           return TRUE;
3298         }
3299
3300       if (type == (N_UNDF | N_EXT))
3301         {
3302           bfd_vma value;
3303
3304           value = GET_WORD (abfd, p->e_value);
3305           if (value != 0)
3306             {
3307               /* This symbol is common in the object from the archive
3308                  file.  */
3309               if (h->type == bfd_link_hash_undefined)
3310                 {
3311                   bfd *symbfd;
3312                   unsigned int power;
3313
3314                   symbfd = h->u.undef.abfd;
3315                   if (symbfd == NULL)
3316                     {
3317                       /* This symbol was created as undefined from
3318                          outside BFD.  We assume that we should link
3319                          in the object file.  This is done for the -u
3320                          option in the linker.  */
3321                       if (! (*info->callbacks->add_archive_element) (info,
3322                                                                      abfd,
3323                                                                      name))
3324                         return FALSE;
3325                       *pneeded = TRUE;
3326                       return TRUE;
3327                     }
3328                   /* Turn the current link symbol into a common
3329                      symbol.  It is already on the undefs list.  */
3330                   h->type = bfd_link_hash_common;
3331                   h->u.c.p = bfd_hash_allocate (&info->hash->table,
3332                                                 sizeof (struct bfd_link_hash_common_entry));
3333                   if (h->u.c.p == NULL)
3334                     return FALSE;
3335
3336                   h->u.c.size = value;
3337
3338                   /* FIXME: This isn't quite right.  The maximum
3339                      alignment of a common symbol should be set by the
3340                      architecture of the output file, not of the input
3341                      file.  */
3342                   power = bfd_log2 (value);
3343                   if (power > bfd_get_arch_info (abfd)->section_align_power)
3344                     power = bfd_get_arch_info (abfd)->section_align_power;
3345                   h->u.c.p->alignment_power = power;
3346
3347                   h->u.c.p->section = bfd_make_section_old_way (symbfd,
3348                                                                 "COMMON");
3349                 }
3350               else
3351                 {
3352                   /* Adjust the size of the common symbol if
3353                      necessary.  */
3354                   if (value > h->u.c.size)
3355                     h->u.c.size = value;
3356                 }
3357             }
3358         }
3359
3360       if (type == N_WEAKA
3361           || type == N_WEAKT
3362           || type == N_WEAKD
3363           || type == N_WEAKB)
3364         {
3365           /* This symbol is weak but defined.  We must pull it in if
3366              the current link symbol is undefined, but we don't want
3367              it if the current link symbol is common.  */
3368           if (h->type == bfd_link_hash_undefined)
3369             {
3370               if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3371                 return FALSE;
3372               *pneeded = TRUE;
3373               return TRUE;
3374             }
3375         }
3376     }
3377
3378   /* We do not need this object file.  */
3379   return TRUE;
3380 }
3381 /* Check a single archive element to see if we need to include it in
3382    the link.  *PNEEDED is set according to whether this element is
3383    needed in the link or not.  This is called from
3384    _bfd_generic_link_add_archive_symbols.  */
3385
3386 static bfd_boolean
3387 aout_link_check_archive_element (bfd *abfd,
3388                                  struct bfd_link_info *info,
3389                                  bfd_boolean *pneeded)
3390 {
3391   if (! aout_get_external_symbols (abfd))
3392     return FALSE;
3393
3394   if (! aout_link_check_ar_symbols (abfd, info, pneeded))
3395     return FALSE;
3396
3397   if (*pneeded)
3398     {
3399       if (! aout_link_add_symbols (abfd, info))
3400         return FALSE;
3401     }
3402
3403   if (! info->keep_memory || ! *pneeded)
3404     {
3405       if (! aout_link_free_symbols (abfd))
3406         return FALSE;
3407     }
3408
3409   return TRUE;
3410 }
3411
3412 /* Given an a.out BFD, add symbols to the global hash table as
3413    appropriate.  */
3414
3415 bfd_boolean
3416 NAME (aout, link_add_symbols) (bfd *abfd, struct bfd_link_info *info)
3417 {
3418   switch (bfd_get_format (abfd))
3419     {
3420     case bfd_object:
3421       return aout_link_add_object_symbols (abfd, info);
3422     case bfd_archive:
3423       return _bfd_generic_link_add_archive_symbols
3424         (abfd, info, aout_link_check_archive_element);
3425     default:
3426       bfd_set_error (bfd_error_wrong_format);
3427       return FALSE;
3428     }
3429 }
3430 \f
3431 /* A hash table used for header files with N_BINCL entries.  */
3432
3433 struct aout_link_includes_table
3434 {
3435   struct bfd_hash_table root;
3436 };
3437
3438 /* A linked list of totals that we have found for a particular header
3439    file.  */
3440
3441 struct aout_link_includes_totals
3442 {
3443   struct aout_link_includes_totals *next;
3444   bfd_vma total;
3445 };
3446
3447 /* An entry in the header file hash table.  */
3448
3449 struct aout_link_includes_entry
3450 {
3451   struct bfd_hash_entry root;
3452   /* List of totals we have found for this file.  */
3453   struct aout_link_includes_totals *totals;
3454 };
3455
3456 /* Look up an entry in an the header file hash table.  */
3457
3458 #define aout_link_includes_lookup(table, string, create, copy)          \
3459   ((struct aout_link_includes_entry *)                                  \
3460    bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3461
3462 /* During the final link step we need to pass around a bunch of
3463    information, so we do it in an instance of this structure.  */
3464
3465 struct aout_final_link_info
3466 {
3467   /* General link information.  */
3468   struct bfd_link_info *info;
3469   /* Output bfd.  */
3470   bfd *output_bfd;
3471   /* Reloc file positions.  */
3472   file_ptr treloff, dreloff;
3473   /* File position of symbols.  */
3474   file_ptr symoff;
3475   /* String table.  */
3476   struct bfd_strtab_hash *strtab;
3477   /* Header file hash table.  */
3478   struct aout_link_includes_table includes;
3479   /* A buffer large enough to hold the contents of any section.  */
3480   bfd_byte *contents;
3481   /* A buffer large enough to hold the relocs of any section.  */
3482   void * relocs;
3483   /* A buffer large enough to hold the symbol map of any input BFD.  */
3484   int *symbol_map;
3485   /* A buffer large enough to hold output symbols of any input BFD.  */
3486   struct external_nlist *output_syms;
3487 };
3488
3489 /* The function to create a new entry in the header file hash table.  */
3490
3491 static struct bfd_hash_entry *
3492 aout_link_includes_newfunc (struct bfd_hash_entry *entry,
3493                             struct bfd_hash_table *table,
3494                             const char *string)
3495 {
3496   struct aout_link_includes_entry *ret =
3497     (struct aout_link_includes_entry *) entry;
3498
3499   /* Allocate the structure if it has not already been allocated by a
3500      subclass.  */
3501   if (ret == NULL)
3502     ret = bfd_hash_allocate (table, sizeof (* ret));
3503   if (ret == NULL)
3504     return NULL;
3505
3506   /* Call the allocation method of the superclass.  */
3507   ret = ((struct aout_link_includes_entry *)
3508          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
3509   if (ret)
3510     {
3511       /* Set local fields.  */
3512       ret->totals = NULL;
3513     }
3514
3515   return (struct bfd_hash_entry *) ret;
3516 }
3517
3518 /* Write out a symbol that was not associated with an a.out input
3519    object.  */
3520
3521 static bfd_boolean
3522 aout_link_write_other_symbol (struct aout_link_hash_entry *h, void * data)
3523 {
3524   struct aout_final_link_info *finfo = (struct aout_final_link_info *) data;
3525   bfd *output_bfd;
3526   int type;
3527   bfd_vma val;
3528   struct external_nlist outsym;
3529   bfd_size_type indx;
3530   bfd_size_type amt;
3531
3532   if (h->root.type == bfd_link_hash_warning)
3533     {
3534       h = (struct aout_link_hash_entry *) h->root.u.i.link;
3535       if (h->root.type == bfd_link_hash_new)
3536         return TRUE;
3537     }
3538
3539   output_bfd = finfo->output_bfd;
3540
3541   if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
3542     {
3543       if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
3544              (output_bfd, finfo->info, h)))
3545         {
3546           /* FIXME: No way to handle errors.  */
3547           abort ();
3548         }
3549     }
3550
3551   if (h->written)
3552     return TRUE;
3553
3554   h->written = TRUE;
3555
3556   /* An indx of -2 means the symbol must be written.  */
3557   if (h->indx != -2
3558       && (finfo->info->strip == strip_all
3559           || (finfo->info->strip == strip_some
3560               && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
3561                                   FALSE, FALSE) == NULL)))
3562     return TRUE;
3563
3564   switch (h->root.type)
3565     {
3566     default:
3567     case bfd_link_hash_warning:
3568       abort ();
3569       /* Avoid variable not initialized warnings.  */
3570       return TRUE;
3571     case bfd_link_hash_new:
3572       /* This can happen for set symbols when sets are not being
3573          built.  */
3574       return TRUE;
3575     case bfd_link_hash_undefined:
3576       type = N_UNDF | N_EXT;
3577       val = 0;
3578       break;
3579     case bfd_link_hash_defined:
3580     case bfd_link_hash_defweak:
3581       {
3582         asection *sec;
3583
3584         sec = h->root.u.def.section->output_section;
3585         BFD_ASSERT (bfd_is_abs_section (sec)
3586                     || sec->owner == output_bfd);
3587         if (sec == obj_textsec (output_bfd))
3588           type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
3589         else if (sec == obj_datasec (output_bfd))
3590           type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
3591         else if (sec == obj_bsssec (output_bfd))
3592           type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
3593         else
3594           type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
3595         type |= N_EXT;
3596         val = (h->root.u.def.value
3597                + sec->vma
3598                + h->root.u.def.section->output_offset);
3599       }
3600       break;
3601     case bfd_link_hash_common:
3602       type = N_UNDF | N_EXT;
3603       val = h->root.u.c.size;
3604       break;
3605     case bfd_link_hash_undefweak:
3606       type = N_WEAKU;
3607       val = 0;
3608     case bfd_link_hash_indirect:
3609       /* We ignore these symbols, since the indirected symbol is
3610          already in the hash table.  */
3611       return TRUE;
3612     }
3613
3614   H_PUT_8 (output_bfd, type, outsym.e_type);
3615   H_PUT_8 (output_bfd, 0, outsym.e_other);
3616   H_PUT_16 (output_bfd, 0, outsym.e_desc);
3617   indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
3618                            FALSE);
3619   if (indx == - (bfd_size_type) 1)
3620     /* FIXME: No way to handle errors.  */
3621     abort ();
3622
3623   PUT_WORD (output_bfd, indx, outsym.e_strx);
3624   PUT_WORD (output_bfd, val, outsym.e_value);
3625
3626   amt = EXTERNAL_NLIST_SIZE;
3627   if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0
3628       || bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
3629     /* FIXME: No way to handle errors.  */
3630     abort ();
3631
3632   finfo->symoff += EXTERNAL_NLIST_SIZE;
3633   h->indx = obj_aout_external_sym_count (output_bfd);
3634   ++obj_aout_external_sym_count (output_bfd);
3635
3636   return TRUE;
3637 }
3638
3639 /* Handle a link order which is supposed to generate a reloc.  */
3640
3641 static bfd_boolean
3642 aout_link_reloc_link_order (struct aout_final_link_info *finfo,
3643                             asection *o,
3644                             struct bfd_link_order *p)
3645 {
3646   struct bfd_link_order_reloc *pr;
3647   int r_index;
3648   int r_extern;
3649   reloc_howto_type *howto;
3650   file_ptr *reloff_ptr = NULL;
3651   struct reloc_std_external srel;
3652   struct reloc_ext_external erel;
3653   void * rel_ptr;
3654   bfd_size_type amt;
3655
3656   pr = p->u.reloc.p;
3657
3658   if (p->type == bfd_section_reloc_link_order)
3659     {
3660       r_extern = 0;
3661       if (bfd_is_abs_section (pr->u.section))
3662         r_index = N_ABS | N_EXT;
3663       else
3664         {
3665           BFD_ASSERT (pr->u.section->owner == finfo->output_bfd);
3666           r_index = pr->u.section->target_index;
3667         }
3668     }
3669   else
3670     {
3671       struct aout_link_hash_entry *h;
3672
3673       BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
3674       r_extern = 1;
3675       h = ((struct aout_link_hash_entry *)
3676            bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
3677                                          pr->u.name, FALSE, FALSE, TRUE));
3678       if (h != NULL
3679           && h->indx >= 0)
3680         r_index = h->indx;
3681       else if (h != NULL)
3682         {
3683           /* We decided to strip this symbol, but it turns out that we
3684              can't.  Note that we lose the other and desc information
3685              here.  I don't think that will ever matter for a global
3686              symbol.  */
3687           h->indx = -2;
3688           h->written = FALSE;
3689           if (! aout_link_write_other_symbol (h, (void *) finfo))
3690             return FALSE;
3691           r_index = h->indx;
3692         }
3693       else
3694         {
3695           if (! ((*finfo->info->callbacks->unattached_reloc)
3696                  (finfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0)))
3697             return FALSE;
3698           r_index = 0;
3699         }
3700     }
3701
3702   howto = bfd_reloc_type_lookup (finfo->output_bfd, pr->reloc);
3703   if (howto == 0)
3704     {
3705       bfd_set_error (bfd_error_bad_value);
3706       return FALSE;
3707     }
3708
3709   if (o == obj_textsec (finfo->output_bfd))
3710     reloff_ptr = &finfo->treloff;
3711   else if (o == obj_datasec (finfo->output_bfd))
3712     reloff_ptr = &finfo->dreloff;
3713   else
3714     abort ();
3715
3716   if (obj_reloc_entry_size (finfo->output_bfd) == RELOC_STD_SIZE)
3717     {
3718 #ifdef MY_put_reloc
3719       MY_put_reloc (finfo->output_bfd, r_extern, r_index, p->offset, howto,
3720                     &srel);
3721 #else
3722       {
3723         int r_pcrel;
3724         int r_baserel;
3725         int r_jmptable;
3726         int r_relative;
3727         int r_length;
3728
3729         r_pcrel = (int) howto->pc_relative;
3730         r_baserel = (howto->type & 8) != 0;
3731         r_jmptable = (howto->type & 16) != 0;
3732         r_relative = (howto->type & 32) != 0;
3733         r_length = howto->size;
3734
3735         PUT_WORD (finfo->output_bfd, p->offset, srel.r_address);
3736         if (bfd_header_big_endian (finfo->output_bfd))
3737           {
3738             srel.r_index[0] = r_index >> 16;
3739             srel.r_index[1] = r_index >> 8;
3740             srel.r_index[2] = r_index;
3741             srel.r_type[0] =
3742               ((r_extern ?     RELOC_STD_BITS_EXTERN_BIG : 0)
3743                | (r_pcrel ?    RELOC_STD_BITS_PCREL_BIG : 0)
3744                | (r_baserel ?  RELOC_STD_BITS_BASEREL_BIG : 0)
3745                | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
3746                | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
3747                | (r_length <<  RELOC_STD_BITS_LENGTH_SH_BIG));
3748           }
3749         else
3750           {
3751             srel.r_index[2] = r_index >> 16;
3752             srel.r_index[1] = r_index >> 8;
3753             srel.r_index[0] = r_index;
3754             srel.r_type[0] =
3755               ((r_extern ?     RELOC_STD_BITS_EXTERN_LITTLE : 0)
3756                | (r_pcrel ?    RELOC_STD_BITS_PCREL_LITTLE : 0)
3757                | (r_baserel ?  RELOC_STD_BITS_BASEREL_LITTLE : 0)
3758                | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
3759                | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
3760                | (r_length <<  RELOC_STD_BITS_LENGTH_SH_LITTLE));
3761           }
3762       }
3763 #endif
3764       rel_ptr = (void *) &srel;
3765
3766       /* We have to write the addend into the object file, since
3767          standard a.out relocs are in place.  It would be more
3768          reliable if we had the current contents of the file here,
3769          rather than assuming zeroes, but we can't read the file since
3770          it was opened using bfd_openw.  */
3771       if (pr->addend != 0)
3772         {
3773           bfd_size_type size;
3774           bfd_reloc_status_type r;
3775           bfd_byte *buf;
3776           bfd_boolean ok;
3777
3778           size = bfd_get_reloc_size (howto);
3779           buf = bfd_zmalloc (size);
3780           if (buf == NULL)
3781             return FALSE;
3782           r = MY_relocate_contents (howto, finfo->output_bfd,
3783                                     (bfd_vma) pr->addend, buf);
3784           switch (r)
3785             {
3786             case bfd_reloc_ok:
3787               break;
3788             default:
3789             case bfd_reloc_outofrange:
3790               abort ();
3791             case bfd_reloc_overflow:
3792               if (! ((*finfo->info->callbacks->reloc_overflow)
3793                      (finfo->info, NULL,
3794                       (p->type == bfd_section_reloc_link_order
3795                        ? bfd_section_name (finfo->output_bfd,
3796                                            pr->u.section)
3797                        : pr->u.name),
3798                       howto->name, pr->addend, NULL, NULL, (bfd_vma) 0)))
3799                 {
3800                   free (buf);
3801                   return FALSE;
3802                 }
3803               break;
3804             }
3805           ok = bfd_set_section_contents (finfo->output_bfd, o, (void *) buf,
3806                                          (file_ptr) p->offset, size);
3807           free (buf);
3808           if (! ok)
3809             return FALSE;
3810         }
3811     }
3812   else
3813     {
3814 #ifdef MY_put_ext_reloc
3815       MY_put_ext_reloc (finfo->output_bfd, r_extern, r_index, p->offset,
3816                         howto, &erel, pr->addend);
3817 #else
3818       PUT_WORD (finfo->output_bfd, p->offset, erel.r_address);
3819
3820       if (bfd_header_big_endian (finfo->output_bfd))
3821         {
3822           erel.r_index[0] = r_index >> 16;
3823           erel.r_index[1] = r_index >> 8;
3824           erel.r_index[2] = r_index;
3825           erel.r_type[0] =
3826             ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
3827              | (howto->type << RELOC_EXT_BITS_TYPE_SH_BIG));
3828         }
3829       else
3830         {
3831           erel.r_index[2] = r_index >> 16;
3832           erel.r_index[1] = r_index >> 8;
3833           erel.r_index[0] = r_index;
3834           erel.r_type[0] =
3835             (r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
3836               | (howto->type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
3837         }
3838
3839       PUT_WORD (finfo->output_bfd, (bfd_vma) pr->addend, erel.r_addend);
3840 #endif /* MY_put_ext_reloc */
3841
3842       rel_ptr = (void *) &erel;
3843     }
3844
3845   amt = obj_reloc_entry_size (finfo->output_bfd);
3846   if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
3847       || bfd_bwrite (rel_ptr, amt, finfo->output_bfd) != amt)
3848     return FALSE;
3849
3850   *reloff_ptr += obj_reloc_entry_size (finfo->output_bfd);
3851
3852   /* Assert that the relocs have not run into the symbols, and that n
3853      the text relocs have not run into the data relocs.  */
3854   BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
3855               && (reloff_ptr != &finfo->treloff
3856                   || (*reloff_ptr
3857                       <= obj_datasec (finfo->output_bfd)->rel_filepos)));
3858
3859   return TRUE;
3860 }
3861
3862 /* Get the section corresponding to a reloc index.  */
3863
3864 static INLINE asection *
3865 aout_reloc_index_to_section (bfd *abfd, int indx)
3866 {
3867   switch (indx & N_TYPE)
3868     {
3869     case N_TEXT:   return obj_textsec (abfd);
3870     case N_DATA:   return obj_datasec (abfd);
3871     case N_BSS:    return obj_bsssec (abfd);
3872     case N_ABS:
3873     case N_UNDF:   return bfd_abs_section_ptr;
3874     default:       abort ();
3875     }
3876   return NULL;
3877 }
3878
3879 /* Relocate an a.out section using standard a.out relocs.  */
3880
3881 static bfd_boolean
3882 aout_link_input_section_std (struct aout_final_link_info *finfo,
3883                              bfd *input_bfd,
3884                              asection *input_section,
3885                              struct reloc_std_external *relocs,
3886                              bfd_size_type rel_size,
3887                              bfd_byte *contents)
3888 {
3889   bfd_boolean (*check_dynamic_reloc)
3890     (struct bfd_link_info *, bfd *, asection *,
3891              struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
3892              bfd_vma *);
3893   bfd *output_bfd;
3894   bfd_boolean relocatable;
3895   struct external_nlist *syms;
3896   char *strings;
3897   struct aout_link_hash_entry **sym_hashes;
3898   int *symbol_map;
3899   bfd_size_type reloc_count;
3900   struct reloc_std_external *rel;
3901   struct reloc_std_external *rel_end;
3902
3903   output_bfd = finfo->output_bfd;
3904   check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
3905
3906   BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE);
3907   BFD_ASSERT (input_bfd->xvec->header_byteorder
3908               == output_bfd->xvec->header_byteorder);
3909
3910   relocatable = finfo->info->relocatable;
3911   syms = obj_aout_external_syms (input_bfd);
3912   strings = obj_aout_external_strings (input_bfd);
3913   sym_hashes = obj_aout_sym_hashes (input_bfd);
3914   symbol_map = finfo->symbol_map;
3915
3916   reloc_count = rel_size / RELOC_STD_SIZE;
3917   rel = relocs;
3918   rel_end = rel + reloc_count;
3919   for (; rel < rel_end; rel++)
3920     {
3921       bfd_vma r_addr;
3922       int r_index;
3923       int r_extern;
3924       int r_pcrel;
3925       int r_baserel = 0;
3926       reloc_howto_type *howto;
3927       struct aout_link_hash_entry *h = NULL;
3928       bfd_vma relocation;
3929       bfd_reloc_status_type r;
3930
3931       r_addr = GET_SWORD (input_bfd, rel->r_address);
3932
3933 #ifdef MY_reloc_howto
3934       howto = MY_reloc_howto (input_bfd, rel, r_index, r_extern, r_pcrel);
3935 #else
3936       {
3937         int r_jmptable;
3938         int r_relative;
3939         int r_length;
3940         unsigned int howto_idx;
3941
3942         if (bfd_header_big_endian (input_bfd))
3943           {
3944             r_index   =  (((unsigned int) rel->r_index[0] << 16)
3945                           | ((unsigned int) rel->r_index[1] << 8)
3946                           | rel->r_index[2]);
3947             r_extern  = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
3948             r_pcrel   = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
3949             r_baserel = (0 != (rel->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
3950             r_jmptable= (0 != (rel->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
3951             r_relative= (0 != (rel->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
3952             r_length  = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
3953                          >> RELOC_STD_BITS_LENGTH_SH_BIG);
3954           }
3955         else
3956           {
3957             r_index   = (((unsigned int) rel->r_index[2] << 16)
3958                          | ((unsigned int) rel->r_index[1] << 8)
3959                          | rel->r_index[0]);
3960             r_extern  = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
3961             r_pcrel   = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
3962             r_baserel = (0 != (rel->r_type[0]
3963                                & RELOC_STD_BITS_BASEREL_LITTLE));
3964             r_jmptable= (0 != (rel->r_type[0]
3965                                & RELOC_STD_BITS_JMPTABLE_LITTLE));
3966             r_relative= (0 != (rel->r_type[0]
3967                                & RELOC_STD_BITS_RELATIVE_LITTLE));
3968             r_length  = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
3969                          >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
3970           }
3971
3972         howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
3973                      + 16 * r_jmptable + 32 * r_relative);
3974         if (howto_idx < TABLE_SIZE (howto_table_std))
3975           howto = howto_table_std + howto_idx;
3976         else
3977           howto = NULL;
3978       }
3979 #endif
3980
3981       if (howto == NULL)
3982         {
3983           (*finfo->info->callbacks->einfo)
3984             (_("%P: %B: unexpected relocation type\n"), input_bfd);
3985           bfd_set_error (bfd_error_bad_value);
3986           return FALSE;
3987         }
3988
3989       if (relocatable)
3990         {
3991           /* We are generating a relocatable output file, and must
3992              modify the reloc accordingly.  */
3993           if (r_extern)
3994             {
3995               /* If we know the symbol this relocation is against,
3996                  convert it into a relocation against a section.  This
3997                  is what the native linker does.  */
3998               h = sym_hashes[r_index];
3999               if (h != NULL
4000                   && (h->root.type == bfd_link_hash_defined
4001                       || h->root.type == bfd_link_hash_defweak))
4002                 {
4003                   asection *output_section;
4004
4005                   /* Change the r_extern value.  */
4006                   if (bfd_header_big_endian (output_bfd))
4007                     rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_BIG;
4008                   else
4009                     rel->r_type[0] &=~ RELOC_STD_BITS_EXTERN_LITTLE;
4010
4011                   /* Compute a new r_index.  */
4012                   output_section = h->root.u.def.section->output_section;
4013                   if (output_section == obj_textsec (output_bfd))
4014                     r_index = N_TEXT;
4015                   else if (output_section == obj_datasec (output_bfd))
4016                     r_index = N_DATA;
4017                   else if (output_section == obj_bsssec (output_bfd))
4018                     r_index = N_BSS;
4019                   else
4020                     r_index = N_ABS;
4021
4022                   /* Add the symbol value and the section VMA to the
4023                      addend stored in the contents.  */
4024                   relocation = (h->root.u.def.value
4025                                 + output_section->vma
4026                                 + h->root.u.def.section->output_offset);
4027                 }
4028               else
4029                 {
4030                   /* We must change r_index according to the symbol
4031                      map.  */
4032                   r_index = symbol_map[r_index];
4033
4034                   if (r_index == -1)
4035                     {
4036                       if (h != NULL)
4037                         {
4038                           /* We decided to strip this symbol, but it
4039                              turns out that we can't.  Note that we
4040                              lose the other and desc information here.
4041                              I don't think that will ever matter for a
4042                              global symbol.  */
4043                           if (h->indx < 0)
4044                             {
4045                               h->indx = -2;
4046                               h->written = FALSE;
4047                               if (! aout_link_write_other_symbol (h,
4048                                                                   (void *) finfo))
4049                                 return FALSE;
4050                             }
4051                           r_index = h->indx;
4052                         }
4053                       else
4054                         {
4055                           const char *name;
4056
4057                           name = strings + GET_WORD (input_bfd,
4058                                                      syms[r_index].e_strx);
4059                           if (! ((*finfo->info->callbacks->unattached_reloc)
4060                                  (finfo->info, name, input_bfd, input_section,
4061                                   r_addr)))
4062                             return FALSE;
4063                           r_index = 0;
4064                         }
4065                     }
4066
4067                   relocation = 0;
4068                 }
4069
4070               /* Write out the new r_index value.  */
4071               if (bfd_header_big_endian (output_bfd))
4072                 {
4073                   rel->r_index[0] = r_index >> 16;
4074                   rel->r_index[1] = r_index >> 8;
4075                   rel->r_index[2] = r_index;
4076                 }
4077               else
4078                 {
4079                   rel->r_index[2] = r_index >> 16;
4080                   rel->r_index[1] = r_index >> 8;
4081                   rel->r_index[0] = r_index;
4082                 }
4083             }
4084           else
4085             {
4086               asection *section;
4087
4088               /* This is a relocation against a section.  We must
4089                  adjust by the amount that the section moved.  */
4090               section = aout_reloc_index_to_section (input_bfd, r_index);
4091               relocation = (section->output_section->vma
4092                             + section->output_offset
4093                             - section->vma);
4094             }
4095
4096           /* Change the address of the relocation.  */
4097           PUT_WORD (output_bfd,
4098                     r_addr + input_section->output_offset,
4099                     rel->r_address);
4100
4101           /* Adjust a PC relative relocation by removing the reference
4102              to the original address in the section and including the
4103              reference to the new address.  */
4104           if (r_pcrel)
4105             relocation -= (input_section->output_section->vma
4106                            + input_section->output_offset
4107                            - input_section->vma);
4108
4109 #ifdef MY_relocatable_reloc
4110           MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
4111 #endif
4112
4113           if (relocation == 0)
4114             r = bfd_reloc_ok;
4115           else
4116             r = MY_relocate_contents (howto,
4117                                         input_bfd, relocation,
4118                                         contents + r_addr);
4119         }
4120       else
4121         {
4122           bfd_boolean hundef;
4123
4124           /* We are generating an executable, and must do a full
4125              relocation.  */
4126           hundef = FALSE;
4127
4128           if (r_extern)
4129             {
4130               h = sym_hashes[r_index];
4131
4132               if (h != NULL
4133                   && (h->root.type == bfd_link_hash_defined
4134                       || h->root.type == bfd_link_hash_defweak))
4135                 {
4136                   relocation = (h->root.u.def.value
4137                                 + h->root.u.def.section->output_section->vma
4138                                 + h->root.u.def.section->output_offset);
4139                 }
4140               else if (h != NULL
4141                        && h->root.type == bfd_link_hash_undefweak)
4142                 relocation = 0;
4143               else
4144                 {
4145                   hundef = TRUE;
4146                   relocation = 0;
4147                 }
4148             }
4149           else
4150             {
4151               asection *section;
4152
4153               section = aout_reloc_index_to_section (input_bfd, r_index);
4154               relocation = (section->output_section->vma
4155                             + section->output_offset
4156                             - section->vma);
4157               if (r_pcrel)
4158                 relocation += input_section->vma;
4159             }
4160
4161           if (check_dynamic_reloc != NULL)
4162             {
4163               bfd_boolean skip;
4164
4165               if (! ((*check_dynamic_reloc)
4166                      (finfo->info, input_bfd, input_section, h,
4167                       (void *) rel, contents, &skip, &relocation)))
4168                 return FALSE;
4169               if (skip)
4170                 continue;
4171             }
4172
4173           /* Now warn if a global symbol is undefined.  We could not
4174              do this earlier, because check_dynamic_reloc might want
4175              to skip this reloc.  */
4176           if (hundef && ! finfo->info->shared && ! r_baserel)
4177             {
4178               const char *name;
4179
4180               if (h != NULL)
4181                 name = h->root.root.string;
4182               else
4183                 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
4184               if (! ((*finfo->info->callbacks->undefined_symbol)
4185                      (finfo->info, name, input_bfd, input_section,
4186                      r_addr, TRUE)))
4187                 return FALSE;
4188             }
4189
4190           r = MY_final_link_relocate (howto,
4191                                       input_bfd, input_section,
4192                                       contents, r_addr, relocation,
4193                                       (bfd_vma) 0);
4194         }
4195
4196       if (r != bfd_reloc_ok)
4197         {
4198           switch (r)
4199             {
4200             default:
4201             case bfd_reloc_outofrange:
4202               abort ();
4203             case bfd_reloc_overflow:
4204               {
4205                 const char *name;
4206
4207                 if (h != NULL)
4208                   name = NULL;
4209                 else if (r_extern)
4210                   name = strings + GET_WORD (input_bfd,
4211                                              syms[r_index].e_strx);
4212                 else
4213                   {
4214                     asection *s;
4215
4216                     s = aout_reloc_index_to_section (input_bfd, r_index);
4217                     name = bfd_section_name (input_bfd, s);
4218                   }
4219                 if (! ((*finfo->info->callbacks->reloc_overflow)
4220                        (finfo->info, (h ? &h->root : NULL), name,
4221                         howto->name, (bfd_vma) 0, input_bfd,
4222                         input_section, r_addr)))
4223                   return FALSE;
4224               }
4225               break;
4226             }
4227         }
4228     }
4229
4230   return TRUE;
4231 }
4232
4233 /* Relocate an a.out section using extended a.out relocs.  */
4234
4235 static bfd_boolean
4236 aout_link_input_section_ext (struct aout_final_link_info *finfo,
4237                              bfd *input_bfd,
4238                              asection *input_section,
4239                              struct reloc_ext_external *relocs,
4240                              bfd_size_type rel_size,
4241                              bfd_byte *contents)
4242 {
4243   bfd_boolean (*check_dynamic_reloc)
4244     (struct bfd_link_info *, bfd *, asection *,
4245              struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
4246              bfd_vma *);
4247   bfd *output_bfd;
4248   bfd_boolean relocatable;
4249   struct external_nlist *syms;
4250   char *strings;
4251   struct aout_link_hash_entry **sym_hashes;
4252   int *symbol_map;
4253   bfd_size_type reloc_count;
4254   struct reloc_ext_external *rel;
4255   struct reloc_ext_external *rel_end;
4256
4257   output_bfd = finfo->output_bfd;
4258   check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
4259
4260   BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_EXT_SIZE);
4261   BFD_ASSERT (input_bfd->xvec->header_byteorder
4262               == output_bfd->xvec->header_byteorder);
4263
4264   relocatable = finfo->info->relocatable;
4265   syms = obj_aout_external_syms (input_bfd);
4266   strings = obj_aout_external_strings (input_bfd);
4267   sym_hashes = obj_aout_sym_hashes (input_bfd);
4268   symbol_map = finfo->symbol_map;
4269
4270   reloc_count = rel_size / RELOC_EXT_SIZE;
4271   rel = relocs;
4272   rel_end = rel + reloc_count;
4273   for (; rel < rel_end; rel++)
4274     {
4275       bfd_vma r_addr;
4276       int r_index;
4277       int r_extern;
4278       unsigned int r_type;
4279       bfd_vma r_addend;
4280       struct aout_link_hash_entry *h = NULL;
4281       asection *r_section = NULL;
4282       bfd_vma relocation;
4283
4284       r_addr = GET_SWORD (input_bfd, rel->r_address);
4285
4286       if (bfd_header_big_endian (input_bfd))
4287         {
4288           r_index  = (((unsigned int) rel->r_index[0] << 16)
4289                       | ((unsigned int) rel->r_index[1] << 8)
4290                       | rel->r_index[2]);
4291           r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
4292           r_type   = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
4293                       >> RELOC_EXT_BITS_TYPE_SH_BIG);
4294         }
4295       else
4296         {
4297           r_index  = (((unsigned int) rel->r_index[2] << 16)
4298                       | ((unsigned int) rel->r_index[1] << 8)
4299                       | rel->r_index[0]);
4300           r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
4301           r_type   = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
4302                       >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
4303         }
4304
4305       r_addend = GET_SWORD (input_bfd, rel->r_addend);
4306
4307       if (r_type >= TABLE_SIZE (howto_table_ext))
4308         {
4309           (*finfo->info->callbacks->einfo)
4310             (_("%P: %B: unexpected relocation type\n"), input_bfd);
4311           bfd_set_error (bfd_error_bad_value);
4312           return FALSE;
4313         }
4314
4315       if (relocatable)
4316         {
4317           /* We are generating a relocatable output file, and must
4318              modify the reloc accordingly.  */
4319           if (r_extern
4320               || r_type == (unsigned int) RELOC_BASE10
4321               || r_type == (unsigned int) RELOC_BASE13
4322               || r_type == (unsigned int) RELOC_BASE22)
4323             {
4324               /* If we know the symbol this relocation is against,
4325                  convert it into a relocation against a section.  This
4326                  is what the native linker does.  */
4327               if (r_type == (unsigned int) RELOC_BASE10
4328                   || r_type == (unsigned int) RELOC_BASE13
4329                   || r_type == (unsigned int) RELOC_BASE22)
4330                 h = NULL;
4331               else
4332                 h = sym_hashes[r_index];
4333               if (h != NULL
4334                   && (h->root.type == bfd_link_hash_defined
4335                       || h->root.type == bfd_link_hash_defweak))
4336                 {
4337                   asection *output_section;
4338
4339                   /* Change the r_extern value.  */
4340                   if (bfd_header_big_endian (output_bfd))
4341                     rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_BIG;
4342                   else
4343                     rel->r_type[0] &=~ RELOC_EXT_BITS_EXTERN_LITTLE;
4344
4345                   /* Compute a new r_index.  */
4346                   output_section = h->root.u.def.section->output_section;
4347                   if (output_section == obj_textsec (output_bfd))
4348                     r_index = N_TEXT;
4349                   else if (output_section == obj_datasec (output_bfd))
4350                     r_index = N_DATA;
4351                   else if (output_section == obj_bsssec (output_bfd))
4352                     r_index = N_BSS;
4353                   else
4354                     r_index = N_ABS;
4355
4356                   /* Add the symbol value and the section VMA to the
4357                      addend.  */
4358                   relocation = (h->root.u.def.value
4359                                 + output_section->vma
4360                                 + h->root.u.def.section->output_offset);
4361
4362                   /* Now RELOCATION is the VMA of the final
4363                      destination.  If this is a PC relative reloc,
4364                      then ADDEND is the negative of the source VMA.
4365                      We want to set ADDEND to the difference between
4366                      the destination VMA and the source VMA, which
4367                      means we must adjust RELOCATION by the change in
4368                      the source VMA.  This is done below.  */
4369                 }
4370               else
4371                 {
4372                   /* We must change r_index according to the symbol
4373                      map.  */
4374                   r_index = symbol_map[r_index];
4375
4376                   if (r_index == -1)
4377                     {
4378                       if (h != NULL)
4379                         {
4380                           /* We decided to strip this symbol, but it
4381                              turns out that we can't.  Note that we
4382                              lose the other and desc information here.
4383                              I don't think that will ever matter for a
4384                              global symbol.  */
4385                           if (h->indx < 0)
4386                             {
4387                               h->indx = -2;
4388                               h->written = FALSE;
4389                               if (! aout_link_write_other_symbol (h,
4390                                                                   (void *) finfo))
4391                                 return FALSE;
4392                             }
4393                           r_index = h->indx;
4394                         }
4395                       else
4396                         {
4397                           const char *name;
4398
4399                           name = strings + GET_WORD (input_bfd,
4400                                                      syms[r_index].e_strx);
4401                           if (! ((*finfo->info->callbacks->unattached_reloc)
4402                                  (finfo->info, name, input_bfd, input_section,
4403                                   r_addr)))
4404                             return FALSE;
4405                           r_index = 0;
4406                         }
4407                     }
4408
4409                   relocation = 0;
4410
4411                   /* If this is a PC relative reloc, then the addend
4412                      is the negative of the source VMA.  We must
4413                      adjust it by the change in the source VMA.  This
4414                      is done below.  */
4415                 }
4416
4417               /* Write out the new r_index value.  */
4418               if (bfd_header_big_endian (output_bfd))
4419                 {
4420                   rel->r_index[0] = r_index >> 16;
4421                   rel->r_index[1] = r_index >> 8;
4422                   rel->r_index[2] = r_index;
4423                 }
4424               else
4425                 {
4426                   rel->r_index[2] = r_index >> 16;
4427                   rel->r_index[1] = r_index >> 8;
4428                   rel->r_index[0] = r_index;
4429                 }
4430             }
4431           else
4432             {
4433               /* This is a relocation against a section.  We must
4434                  adjust by the amount that the section moved.  */
4435               r_section = aout_reloc_index_to_section (input_bfd, r_index);
4436               relocation = (r_section->output_section->vma
4437                             + r_section->output_offset
4438                             - r_section->vma);
4439
4440               /* If this is a PC relative reloc, then the addend is
4441                  the difference in VMA between the destination and the
4442                  source.  We have just adjusted for the change in VMA
4443                  of the destination, so we must also adjust by the
4444                  change in VMA of the source.  This is done below.  */
4445             }
4446
4447           /* As described above, we must always adjust a PC relative
4448              reloc by the change in VMA of the source.  However, if
4449              pcrel_offset is set, then the addend does not include the
4450              location within the section, in which case we don't need
4451              to adjust anything.  */
4452           if (howto_table_ext[r_type].pc_relative
4453               && ! howto_table_ext[r_type].pcrel_offset)
4454             relocation -= (input_section->output_section->vma
4455                            + input_section->output_offset
4456                            - input_section->vma);
4457
4458           /* Change the addend if necessary.  */
4459           if (relocation != 0)
4460             PUT_WORD (output_bfd, r_addend + relocation, rel->r_addend);
4461
4462           /* Change the address of the relocation.  */
4463           PUT_WORD (output_bfd,
4464                     r_addr + input_section->output_offset,
4465                     rel->r_address);
4466         }
4467       else
4468         {
4469           bfd_boolean hundef;
4470           bfd_reloc_status_type r;
4471
4472           /* We are generating an executable, and must do a full
4473              relocation.  */
4474           hundef = FALSE;
4475
4476           if (r_extern)
4477             {
4478               h = sym_hashes[r_index];
4479
4480               if (h != NULL
4481                   && (h->root.type == bfd_link_hash_defined
4482                       || h->root.type == bfd_link_hash_defweak))
4483                 {
4484                   relocation = (h->root.u.def.value
4485                                 + h->root.u.def.section->output_section->vma
4486                                 + h->root.u.def.section->output_offset);
4487                 }
4488               else if (h != NULL
4489                        && h->root.type == bfd_link_hash_undefweak)
4490                 relocation = 0;
4491               else
4492                 {
4493                   hundef = TRUE;
4494                   relocation = 0;
4495                 }
4496             }
4497           else if (r_type == (unsigned int) RELOC_BASE10
4498                    || r_type == (unsigned int) RELOC_BASE13
4499                    || r_type == (unsigned int) RELOC_BASE22)
4500             {
4501               struct external_nlist *sym;
4502               int type;
4503
4504               /* For base relative relocs, r_index is always an index
4505                  into the symbol table, even if r_extern is 0.  */
4506               sym = syms + r_index;
4507               type = H_GET_8 (input_bfd, sym->e_type);
4508               if ((type & N_TYPE) == N_TEXT
4509                   || type == N_WEAKT)
4510                 r_section = obj_textsec (input_bfd);
4511               else if ((type & N_TYPE) == N_DATA
4512                        || type == N_WEAKD)
4513                 r_section = obj_datasec (input_bfd);
4514               else if ((type & N_TYPE) == N_BSS
4515                        || type == N_WEAKB)
4516                 r_section = obj_bsssec (input_bfd);
4517               else if ((type & N_TYPE) == N_ABS
4518                        || type == N_WEAKA)
4519                 r_section = bfd_abs_section_ptr;
4520               else
4521                 abort ();
4522               relocation = (r_section->output_section->vma
4523                             + r_section->output_offset
4524                             + (GET_WORD (input_bfd, sym->e_value)
4525                                - r_section->vma));
4526             }
4527           else
4528             {
4529               r_section = aout_reloc_index_to_section (input_bfd, r_index);
4530
4531               /* If this is a PC relative reloc, then R_ADDEND is the
4532                  difference between the two vmas, or
4533                    old_dest_sec + old_dest_off - (old_src_sec + old_src_off)
4534                  where
4535                    old_dest_sec == section->vma
4536                  and
4537                    old_src_sec == input_section->vma
4538                  and
4539                    old_src_off == r_addr
4540
4541                  _bfd_final_link_relocate expects RELOCATION +
4542                  R_ADDEND to be the VMA of the destination minus
4543                  r_addr (the minus r_addr is because this relocation
4544                  is not pcrel_offset, which is a bit confusing and
4545                  should, perhaps, be changed), or
4546                    new_dest_sec
4547                  where
4548                    new_dest_sec == output_section->vma + output_offset
4549                  We arrange for this to happen by setting RELOCATION to
4550                    new_dest_sec + old_src_sec - old_dest_sec
4551
4552                  If this is not a PC relative reloc, then R_ADDEND is
4553                  simply the VMA of the destination, so we set
4554                  RELOCATION to the change in the destination VMA, or
4555                    new_dest_sec - old_dest_sec
4556                  */
4557               relocation = (r_section->output_section->vma
4558                             + r_section->output_offset
4559                             - r_section->vma);
4560               if (howto_table_ext[r_type].pc_relative)
4561                 relocation += input_section->vma;
4562             }
4563
4564           if (check_dynamic_reloc != NULL)
4565             {
4566               bfd_boolean skip;
4567
4568               if (! ((*check_dynamic_reloc)
4569                      (finfo->info, input_bfd, input_section, h,
4570                       (void *) rel, contents, &skip, &relocation)))
4571                 return FALSE;
4572               if (skip)
4573                 continue;
4574             }
4575
4576           /* Now warn if a global symbol is undefined.  We could not
4577              do this earlier, because check_dynamic_reloc might want
4578              to skip this reloc.  */
4579           if (hundef
4580               && ! finfo->info->shared
4581               && r_type != (unsigned int) RELOC_BASE10
4582               && r_type != (unsigned int) RELOC_BASE13
4583               && r_type != (unsigned int) RELOC_BASE22)
4584             {
4585               const char *name;
4586
4587               if (h != NULL)
4588                 name = h->root.root.string;
4589               else
4590                 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
4591               if (! ((*finfo->info->callbacks->undefined_symbol)
4592                      (finfo->info, name, input_bfd, input_section,
4593                      r_addr, TRUE)))
4594                 return FALSE;
4595             }
4596
4597           if (r_type != (unsigned int) RELOC_SPARC_REV32)
4598             r = MY_final_link_relocate (howto_table_ext + r_type,
4599                                         input_bfd, input_section,
4600                                         contents, r_addr, relocation,
4601                                         r_addend);
4602           else
4603             {
4604               bfd_vma x;
4605
4606               x = bfd_get_32 (input_bfd, contents + r_addr);
4607               x = x + relocation + r_addend;
4608               bfd_putl32 (/*input_bfd,*/ x, contents + r_addr);
4609               r = bfd_reloc_ok;
4610             }
4611
4612           if (r != bfd_reloc_ok)
4613             {
4614               switch (r)
4615                 {
4616                 default:
4617                 case bfd_reloc_outofrange:
4618                   abort ();
4619                 case bfd_reloc_overflow:
4620                   {
4621                     const char *name;
4622
4623                     if (h != NULL)
4624                       name = NULL;
4625                     else if (r_extern
4626                              || r_type == (unsigned int) RELOC_BASE10
4627                              || r_type == (unsigned int) RELOC_BASE13
4628                              || r_type == (unsigned int) RELOC_BASE22)
4629                       name = strings + GET_WORD (input_bfd,
4630                                                  syms[r_index].e_strx);
4631                     else
4632                       {
4633                         asection *s;
4634
4635                         s = aout_reloc_index_to_section (input_bfd, r_index);
4636                         name = bfd_section_name (input_bfd, s);
4637                       }
4638                     if (! ((*finfo->info->callbacks->reloc_overflow)
4639                            (finfo->info, (h ? &h->root : NULL), name,
4640                             howto_table_ext[r_type].name,
4641                             r_addend, input_bfd, input_section, r_addr)))
4642                       return FALSE;
4643                   }
4644                   break;
4645                 }
4646             }
4647         }
4648     }
4649
4650   return TRUE;
4651 }
4652
4653 /* Link an a.out section into the output file.  */
4654
4655 static bfd_boolean
4656 aout_link_input_section (struct aout_final_link_info *finfo,
4657                          bfd *input_bfd,
4658                          asection *input_section,
4659                          file_ptr *reloff_ptr,
4660                          bfd_size_type rel_size)
4661 {
4662   bfd_size_type input_size;
4663   void * relocs;
4664
4665   /* Get the section contents.  */
4666   input_size = input_section->size;
4667   if (! bfd_get_section_contents (input_bfd, input_section,
4668                                   (void *) finfo->contents,
4669                                   (file_ptr) 0, input_size))
4670     return FALSE;
4671
4672   /* Read in the relocs if we haven't already done it.  */
4673   if (aout_section_data (input_section) != NULL
4674       && aout_section_data (input_section)->relocs != NULL)
4675     relocs = aout_section_data (input_section)->relocs;
4676   else
4677     {
4678       relocs = finfo->relocs;
4679       if (rel_size > 0)
4680         {
4681           if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4682               || bfd_bread (relocs, rel_size, input_bfd) != rel_size)
4683             return FALSE;
4684         }
4685     }
4686
4687   /* Relocate the section contents.  */
4688   if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
4689     {
4690       if (! aout_link_input_section_std (finfo, input_bfd, input_section,
4691                                          (struct reloc_std_external *) relocs,
4692                                          rel_size, finfo->contents))
4693         return FALSE;
4694     }
4695   else
4696     {
4697       if (! aout_link_input_section_ext (finfo, input_bfd, input_section,
4698                                          (struct reloc_ext_external *) relocs,
4699                                          rel_size, finfo->contents))
4700         return FALSE;
4701     }
4702
4703   /* Write out the section contents.  */
4704   if (! bfd_set_section_contents (finfo->output_bfd,
4705                                   input_section->output_section,
4706                                   (void *) finfo->contents,
4707                                   (file_ptr) input_section->output_offset,
4708                                   input_size))
4709     return FALSE;
4710
4711   /* If we are producing relocatable output, the relocs were
4712      modified, and we now write them out.  */
4713   if (finfo->info->relocatable && rel_size > 0)
4714     {
4715       if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
4716         return FALSE;
4717       if (bfd_bwrite (relocs, rel_size, finfo->output_bfd) != rel_size)
4718         return FALSE;
4719       *reloff_ptr += rel_size;
4720
4721       /* Assert that the relocs have not run into the symbols, and
4722          that if these are the text relocs they have not run into the
4723          data relocs.  */
4724       BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
4725                   && (reloff_ptr != &finfo->treloff
4726                       || (*reloff_ptr
4727                           <= obj_datasec (finfo->output_bfd)->rel_filepos)));
4728     }
4729
4730   return TRUE;
4731 }
4732
4733 /* Adjust and write out the symbols for an a.out file.  Set the new
4734    symbol indices into a symbol_map.  */
4735
4736 static bfd_boolean
4737 aout_link_write_symbols (struct aout_final_link_info *finfo, bfd *input_bfd)
4738 {
4739   bfd *output_bfd;
4740   bfd_size_type sym_count;
4741   char *strings;
4742   enum bfd_link_strip strip;
4743   enum bfd_link_discard discard;
4744   struct external_nlist *outsym;
4745   bfd_size_type strtab_index;
4746   struct external_nlist *sym;
4747   struct external_nlist *sym_end;
4748   struct aout_link_hash_entry **sym_hash;
4749   int *symbol_map;
4750   bfd_boolean pass;
4751   bfd_boolean skip_next;
4752
4753   output_bfd = finfo->output_bfd;
4754   sym_count = obj_aout_external_sym_count (input_bfd);
4755   strings = obj_aout_external_strings (input_bfd);
4756   strip = finfo->info->strip;
4757   discard = finfo->info->discard;
4758   outsym = finfo->output_syms;
4759
4760   /* First write out a symbol for this object file, unless we are
4761      discarding such symbols.  */
4762   if (strip != strip_all
4763       && (strip != strip_some
4764           || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
4765                               FALSE, FALSE) != NULL)
4766       && discard != discard_all)
4767     {
4768       H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
4769       H_PUT_8 (output_bfd, 0, outsym->e_other);
4770       H_PUT_16 (output_bfd, 0, outsym->e_desc);
4771       strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4772                                        input_bfd->filename, FALSE);
4773       if (strtab_index == (bfd_size_type) -1)
4774         return FALSE;
4775       PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4776       PUT_WORD (output_bfd,
4777                 (bfd_get_section_vma (output_bfd,
4778                                       obj_textsec (input_bfd)->output_section)
4779                  + obj_textsec (input_bfd)->output_offset),
4780                 outsym->e_value);
4781       ++obj_aout_external_sym_count (output_bfd);
4782       ++outsym;
4783     }
4784
4785   pass = FALSE;
4786   skip_next = FALSE;
4787   sym = obj_aout_external_syms (input_bfd);
4788   sym_end = sym + sym_count;
4789   sym_hash = obj_aout_sym_hashes (input_bfd);
4790   symbol_map = finfo->symbol_map;
4791   memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
4792   for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
4793     {
4794       const char *name;
4795       int type;
4796       struct aout_link_hash_entry *h;
4797       bfd_boolean skip;
4798       asection *symsec;
4799       bfd_vma val = 0;
4800       bfd_boolean copy;
4801
4802       /* We set *symbol_map to 0 above for all symbols.  If it has
4803          already been set to -1 for this symbol, it means that we are
4804          discarding it because it appears in a duplicate header file.
4805          See the N_BINCL code below.  */
4806       if (*symbol_map == -1)
4807         continue;
4808
4809       /* Initialize *symbol_map to -1, which means that the symbol was
4810          not copied into the output file.  We will change it later if
4811          we do copy the symbol over.  */
4812       *symbol_map = -1;
4813
4814       type = H_GET_8 (input_bfd, sym->e_type);
4815       name = strings + GET_WORD (input_bfd, sym->e_strx);
4816
4817       h = NULL;
4818
4819       if (pass)
4820         {
4821           /* Pass this symbol through.  It is the target of an
4822              indirect or warning symbol.  */
4823           val = GET_WORD (input_bfd, sym->e_value);
4824           pass = FALSE;
4825         }
4826       else if (skip_next)
4827         {
4828           /* Skip this symbol, which is the target of an indirect
4829              symbol that we have changed to no longer be an indirect
4830              symbol.  */
4831           skip_next = FALSE;
4832           continue;
4833         }
4834       else
4835         {
4836           struct aout_link_hash_entry *hresolve;
4837
4838           /* We have saved the hash table entry for this symbol, if
4839              there is one.  Note that we could just look it up again
4840              in the hash table, provided we first check that it is an
4841              external symbol.  */
4842           h = *sym_hash;
4843
4844           /* Use the name from the hash table, in case the symbol was
4845              wrapped.  */
4846           if (h != NULL
4847               && h->root.type != bfd_link_hash_warning)
4848             name = h->root.root.string;
4849
4850           /* If this is an indirect or warning symbol, then change
4851              hresolve to the base symbol.  We also change *sym_hash so
4852              that the relocation routines relocate against the real
4853              symbol.  */
4854           hresolve = h;
4855           if (h != (struct aout_link_hash_entry *) NULL
4856               && (h->root.type == bfd_link_hash_indirect
4857                   || h->root.type == bfd_link_hash_warning))
4858             {
4859               hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
4860               while (hresolve->root.type == bfd_link_hash_indirect
4861                      || hresolve->root.type == bfd_link_hash_warning)
4862                 hresolve = ((struct aout_link_hash_entry *)
4863                             hresolve->root.u.i.link);
4864               *sym_hash = hresolve;
4865             }
4866
4867           /* If the symbol has already been written out, skip it.  */
4868           if (h != NULL
4869               && h->written)
4870             {
4871               if ((type & N_TYPE) == N_INDR
4872                   || type == N_WARNING)
4873                 skip_next = TRUE;
4874               *symbol_map = h->indx;
4875               continue;
4876             }
4877
4878           /* See if we are stripping this symbol.  */
4879           skip = FALSE;
4880           switch (strip)
4881             {
4882             case strip_none:
4883               break;
4884             case strip_debugger:
4885               if ((type & N_STAB) != 0)
4886                 skip = TRUE;
4887               break;
4888             case strip_some:
4889               if (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
4890                   == NULL)
4891                 skip = TRUE;
4892               break;
4893             case strip_all:
4894               skip = TRUE;
4895               break;
4896             }
4897           if (skip)
4898             {
4899               if (h != NULL)
4900                 h->written = TRUE;
4901               continue;
4902             }
4903
4904           /* Get the value of the symbol.  */
4905           if ((type & N_TYPE) == N_TEXT
4906               || type == N_WEAKT)
4907             symsec = obj_textsec (input_bfd);
4908           else if ((type & N_TYPE) == N_DATA
4909                    || type == N_WEAKD)
4910             symsec = obj_datasec (input_bfd);
4911           else if ((type & N_TYPE) == N_BSS
4912                    || type == N_WEAKB)
4913             symsec = obj_bsssec (input_bfd);
4914           else if ((type & N_TYPE) == N_ABS
4915                    || type == N_WEAKA)
4916             symsec = bfd_abs_section_ptr;
4917           else if (((type & N_TYPE) == N_INDR
4918                     && (hresolve == NULL
4919                         || (hresolve->root.type != bfd_link_hash_defined
4920                             && hresolve->root.type != bfd_link_hash_defweak
4921                             && hresolve->root.type != bfd_link_hash_common)))
4922                    || type == N_WARNING)
4923             {
4924               /* Pass the next symbol through unchanged.  The
4925                  condition above for indirect symbols is so that if
4926                  the indirect symbol was defined, we output it with
4927                  the correct definition so the debugger will
4928                  understand it.  */
4929               pass = TRUE;
4930               val = GET_WORD (input_bfd, sym->e_value);
4931               symsec = NULL;
4932             }
4933           else if ((type & N_STAB) != 0)
4934             {
4935               val = GET_WORD (input_bfd, sym->e_value);
4936               symsec = NULL;
4937             }
4938           else
4939             {
4940               /* If we get here with an indirect symbol, it means that
4941                  we are outputting it with a real definition.  In such
4942                  a case we do not want to output the next symbol,
4943                  which is the target of the indirection.  */
4944               if ((type & N_TYPE) == N_INDR)
4945                 skip_next = TRUE;
4946
4947               symsec = NULL;
4948
4949               /* We need to get the value from the hash table.  We use
4950                  hresolve so that if we have defined an indirect
4951                  symbol we output the final definition.  */
4952               if (h == NULL)
4953                 {
4954                   switch (type & N_TYPE)
4955                     {
4956                     case N_SETT:
4957                       symsec = obj_textsec (input_bfd);
4958                       break;
4959                     case N_SETD:
4960                       symsec = obj_datasec (input_bfd);
4961                       break;
4962                     case N_SETB:
4963                       symsec = obj_bsssec (input_bfd);
4964                       break;
4965                     case N_SETA:
4966                       symsec = bfd_abs_section_ptr;
4967                       break;
4968                     default:
4969                       val = 0;
4970                       break;
4971                     }
4972                 }
4973               else if (hresolve->root.type == bfd_link_hash_defined
4974                        || hresolve->root.type == bfd_link_hash_defweak)
4975                 {
4976                   asection *input_section;
4977                   asection *output_section;
4978
4979                   /* This case usually means a common symbol which was
4980                      turned into a defined symbol.  */
4981                   input_section = hresolve->root.u.def.section;
4982                   output_section = input_section->output_section;
4983                   BFD_ASSERT (bfd_is_abs_section (output_section)
4984                               || output_section->owner == output_bfd);
4985                   val = (hresolve->root.u.def.value
4986                          + bfd_get_section_vma (output_bfd, output_section)
4987                          + input_section->output_offset);
4988
4989                   /* Get the correct type based on the section.  If
4990                      this is a constructed set, force it to be
4991                      globally visible.  */
4992                   if (type == N_SETT
4993                       || type == N_SETD
4994                       || type == N_SETB
4995                       || type == N_SETA)
4996                     type |= N_EXT;
4997
4998                   type &=~ N_TYPE;
4999
5000                   if (output_section == obj_textsec (output_bfd))
5001                     type |= (hresolve->root.type == bfd_link_hash_defined
5002                              ? N_TEXT
5003                              : N_WEAKT);
5004                   else if (output_section == obj_datasec (output_bfd))
5005                     type |= (hresolve->root.type == bfd_link_hash_defined
5006                              ? N_DATA
5007                              : N_WEAKD);
5008                   else if (output_section == obj_bsssec (output_bfd))
5009                     type |= (hresolve->root.type == bfd_link_hash_defined
5010                              ? N_BSS
5011                              : N_WEAKB);
5012                   else
5013                     type |= (hresolve->root.type == bfd_link_hash_defined
5014                              ? N_ABS
5015                              : N_WEAKA);
5016                 }
5017               else if (hresolve->root.type == bfd_link_hash_common)
5018                 val = hresolve->root.u.c.size;
5019               else if (hresolve->root.type == bfd_link_hash_undefweak)
5020                 {
5021                   val = 0;
5022                   type = N_WEAKU;
5023                 }
5024               else
5025                 val = 0;
5026             }
5027           if (symsec != NULL)
5028             val = (symsec->output_section->vma
5029                    + symsec->output_offset
5030                    + (GET_WORD (input_bfd, sym->e_value)
5031                       - symsec->vma));
5032
5033           /* If this is a global symbol set the written flag, and if
5034              it is a local symbol see if we should discard it.  */
5035           if (h != NULL)
5036             {
5037               h->written = TRUE;
5038               h->indx = obj_aout_external_sym_count (output_bfd);
5039             }
5040           else if ((type & N_TYPE) != N_SETT
5041                    && (type & N_TYPE) != N_SETD
5042                    && (type & N_TYPE) != N_SETB
5043                    && (type & N_TYPE) != N_SETA)
5044             {
5045               switch (discard)
5046                 {
5047                 case discard_none:
5048                 case discard_sec_merge:
5049                   break;
5050                 case discard_l:
5051                   if ((type & N_STAB) == 0
5052                       && bfd_is_local_label_name (input_bfd, name))
5053                     skip = TRUE;
5054                   break;
5055                 case discard_all:
5056                   skip = TRUE;
5057                   break;
5058                 }
5059               if (skip)
5060                 {
5061                   pass = FALSE;
5062                   continue;
5063                 }
5064             }
5065
5066           /* An N_BINCL symbol indicates the start of the stabs
5067              entries for a header file.  We need to scan ahead to the
5068              next N_EINCL symbol, ignoring nesting, adding up all the
5069              characters in the symbol names, not including the file
5070              numbers in types (the first number after an open
5071              parenthesis).  */
5072           if (type == (int) N_BINCL)
5073             {
5074               struct external_nlist *incl_sym;
5075               int nest;
5076               struct aout_link_includes_entry *incl_entry;
5077               struct aout_link_includes_totals *t;
5078
5079               val = 0;
5080               nest = 0;
5081               for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
5082                 {
5083                   int incl_type;
5084
5085                   incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
5086                   if (incl_type == (int) N_EINCL)
5087                     {
5088                       if (nest == 0)
5089                         break;
5090                       --nest;
5091                     }
5092                   else if (incl_type == (int) N_BINCL)
5093                     ++nest;
5094                   else if (nest == 0)
5095                     {
5096                       const char *s;
5097
5098                       s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
5099                       for (; *s != '\0'; s++)
5100                         {
5101                           val += *s;
5102                           if (*s == '(')
5103                             {
5104                               /* Skip the file number.  */
5105                               ++s;
5106                               while (ISDIGIT (*s))
5107                                 ++s;
5108                               --s;
5109                             }
5110                         }
5111                     }
5112                 }
5113
5114               /* If we have already included a header file with the
5115                  same value, then replace this one with an N_EXCL
5116                  symbol.  */
5117               copy = (bfd_boolean) (! finfo->info->keep_memory);
5118               incl_entry = aout_link_includes_lookup (&finfo->includes,
5119                                                       name, TRUE, copy);
5120               if (incl_entry == NULL)
5121                 return FALSE;
5122               for (t = incl_entry->totals; t != NULL; t = t->next)
5123                 if (t->total == val)
5124                   break;
5125               if (t == NULL)
5126                 {
5127                   /* This is the first time we have seen this header
5128                      file with this set of stabs strings.  */
5129                   t = bfd_hash_allocate (&finfo->includes.root,
5130                                          sizeof *t);
5131                   if (t == NULL)
5132                     return FALSE;
5133                   t->total = val;
5134                   t->next = incl_entry->totals;
5135                   incl_entry->totals = t;
5136                 }
5137               else
5138                 {
5139                   int *incl_map;
5140
5141                   /* This is a duplicate header file.  We must change
5142                      it to be an N_EXCL entry, and mark all the
5143                      included symbols to prevent outputting them.  */
5144                   type = (int) N_EXCL;
5145
5146                   nest = 0;
5147                   for (incl_sym = sym + 1, incl_map = symbol_map + 1;
5148                        incl_sym < sym_end;
5149                        incl_sym++, incl_map++)
5150                     {
5151                       int incl_type;
5152
5153                       incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
5154                       if (incl_type == (int) N_EINCL)
5155                         {
5156                           if (nest == 0)
5157                             {
5158                               *incl_map = -1;
5159                               break;
5160                             }
5161                           --nest;
5162                         }
5163                       else if (incl_type == (int) N_BINCL)
5164                         ++nest;
5165                       else if (nest == 0)
5166                         *incl_map = -1;
5167                     }
5168                 }
5169             }
5170         }
5171
5172       /* Copy this symbol into the list of symbols we are going to
5173          write out.  */
5174       H_PUT_8 (output_bfd, type, outsym->e_type);
5175       H_PUT_8 (output_bfd, H_GET_8 (input_bfd, sym->e_other), outsym->e_other);
5176       H_PUT_16 (output_bfd, H_GET_16 (input_bfd, sym->e_desc), outsym->e_desc);
5177       copy = FALSE;
5178       if (! finfo->info->keep_memory)
5179         {
5180           /* name points into a string table which we are going to
5181              free.  If there is a hash table entry, use that string.
5182              Otherwise, copy name into memory.  */
5183           if (h != NULL)
5184             name = h->root.root.string;
5185           else
5186             copy = TRUE;
5187         }
5188       strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
5189                                        name, copy);
5190       if (strtab_index == (bfd_size_type) -1)
5191         return FALSE;
5192       PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
5193       PUT_WORD (output_bfd, val, outsym->e_value);
5194       *symbol_map = obj_aout_external_sym_count (output_bfd);
5195       ++obj_aout_external_sym_count (output_bfd);
5196       ++outsym;
5197     }
5198
5199   /* Write out the output symbols we have just constructed.  */
5200   if (outsym > finfo->output_syms)
5201     {
5202       bfd_size_type outsym_size;
5203
5204       if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
5205         return FALSE;
5206       outsym_size = outsym - finfo->output_syms;
5207       outsym_size *= EXTERNAL_NLIST_SIZE;
5208       if (bfd_bwrite ((void *) finfo->output_syms, outsym_size, output_bfd)
5209           != outsym_size)
5210         return FALSE;
5211       finfo->symoff += outsym_size;
5212     }
5213
5214   return TRUE;
5215 }
5216
5217 /* Link an a.out input BFD into the output file.  */
5218
5219 static bfd_boolean
5220 aout_link_input_bfd (struct aout_final_link_info *finfo, bfd *input_bfd)
5221 {
5222   bfd_size_type sym_count;
5223
5224   BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
5225
5226   /* If this is a dynamic object, it may need special handling.  */
5227   if ((input_bfd->flags & DYNAMIC) != 0
5228       && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
5229     return ((*aout_backend_info (input_bfd)->link_dynamic_object)
5230             (finfo->info, input_bfd));
5231
5232   /* Get the symbols.  We probably have them already, unless
5233      finfo->info->keep_memory is FALSE.  */
5234   if (! aout_get_external_symbols (input_bfd))
5235     return FALSE;
5236
5237   sym_count = obj_aout_external_sym_count (input_bfd);
5238
5239   /* Write out the symbols and get a map of the new indices.  The map
5240      is placed into finfo->symbol_map.  */
5241   if (! aout_link_write_symbols (finfo, input_bfd))
5242     return FALSE;
5243
5244   /* Relocate and write out the sections.  These functions use the
5245      symbol map created by aout_link_write_symbols.  The linker_mark
5246      field will be set if these sections are to be included in the
5247      link, which will normally be the case.  */
5248   if (obj_textsec (input_bfd)->linker_mark)
5249     {
5250       if (! aout_link_input_section (finfo, input_bfd,
5251                                      obj_textsec (input_bfd),
5252                                      &finfo->treloff,
5253                                      exec_hdr (input_bfd)->a_trsize))
5254         return FALSE;
5255     }
5256   if (obj_datasec (input_bfd)->linker_mark)
5257     {
5258       if (! aout_link_input_section (finfo, input_bfd,
5259                                      obj_datasec (input_bfd),
5260                                      &finfo->dreloff,
5261                                      exec_hdr (input_bfd)->a_drsize))
5262         return FALSE;
5263     }
5264
5265   /* If we are not keeping memory, we don't need the symbols any
5266      longer.  We still need them if we are keeping memory, because the
5267      strings in the hash table point into them.  */
5268   if (! finfo->info->keep_memory)
5269     {
5270       if (! aout_link_free_symbols (input_bfd))
5271         return FALSE;
5272     }
5273
5274   return TRUE;
5275 }
5276
5277 /* Do the final link step.  This is called on the output BFD.  The
5278    INFO structure should point to a list of BFDs linked through the
5279    link_next field which can be used to find each BFD which takes part
5280    in the output.  Also, each section in ABFD should point to a list
5281    of bfd_link_order structures which list all the input sections for
5282    the output section.  */
5283
5284 bfd_boolean
5285 NAME (aout, final_link) (bfd *abfd,
5286                          struct bfd_link_info *info,
5287                          void (*callback) (bfd *, file_ptr *, file_ptr *, file_ptr *))
5288 {
5289   struct aout_final_link_info aout_info;
5290   bfd_boolean includes_hash_initialized = FALSE;
5291   bfd *sub;
5292   bfd_size_type trsize, drsize;
5293   bfd_size_type max_contents_size;
5294   bfd_size_type max_relocs_size;
5295   bfd_size_type max_sym_count;
5296   bfd_size_type text_size;
5297   file_ptr text_end;
5298   struct bfd_link_order *p;
5299   asection *o;
5300   bfd_boolean have_link_order_relocs;
5301
5302   if (info->shared)
5303     abfd->flags |= DYNAMIC;
5304
5305   aout_info.info = info;
5306   aout_info.output_bfd = abfd;
5307   aout_info.contents = NULL;
5308   aout_info.relocs = NULL;
5309   aout_info.symbol_map = NULL;
5310   aout_info.output_syms = NULL;
5311
5312   if (!bfd_hash_table_init_n (&aout_info.includes.root,
5313                               aout_link_includes_newfunc,
5314                               sizeof (struct aout_link_includes_entry),
5315                               251))
5316     goto error_return;
5317   includes_hash_initialized = TRUE;
5318
5319   /* Figure out the largest section size.  Also, if generating
5320      relocatable output, count the relocs.  */
5321   trsize = 0;
5322   drsize = 0;
5323   max_contents_size = 0;
5324   max_relocs_size = 0;
5325   max_sym_count = 0;
5326   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
5327     {
5328       bfd_size_type sz;
5329
5330       if (info->relocatable)
5331         {
5332           if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
5333             {
5334               trsize += exec_hdr (sub)->a_trsize;
5335               drsize += exec_hdr (sub)->a_drsize;
5336             }
5337           else
5338             {
5339               /* FIXME: We need to identify the .text and .data sections
5340                  and call get_reloc_upper_bound and canonicalize_reloc to
5341                  work out the number of relocs needed, and then multiply
5342                  by the reloc size.  */
5343               (*_bfd_error_handler)
5344                 (_("%s: relocatable link from %s to %s not supported"),
5345                  bfd_get_filename (abfd),
5346                  sub->xvec->name, abfd->xvec->name);
5347               bfd_set_error (bfd_error_invalid_operation);
5348               goto error_return;
5349             }
5350         }
5351
5352       if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
5353         {
5354           sz = obj_textsec (sub)->size;
5355           if (sz > max_contents_size)
5356             max_contents_size = sz;
5357           sz = obj_datasec (sub)->size;
5358           if (sz > max_contents_size)
5359             max_contents_size = sz;
5360
5361           sz = exec_hdr (sub)->a_trsize;
5362           if (sz > max_relocs_size)
5363             max_relocs_size = sz;
5364           sz = exec_hdr (sub)->a_drsize;
5365           if (sz > max_relocs_size)
5366             max_relocs_size = sz;
5367
5368           sz = obj_aout_external_sym_count (sub);
5369           if (sz > max_sym_count)
5370             max_sym_count = sz;
5371         }
5372     }
5373
5374   if (info->relocatable)
5375     {
5376       if (obj_textsec (abfd) != NULL)
5377         trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
5378                                                  ->map_head.link_order)
5379                    * obj_reloc_entry_size (abfd));
5380       if (obj_datasec (abfd) != NULL)
5381         drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
5382                                                  ->map_head.link_order)
5383                    * obj_reloc_entry_size (abfd));
5384     }
5385
5386   exec_hdr (abfd)->a_trsize = trsize;
5387   exec_hdr (abfd)->a_drsize = drsize;
5388
5389   exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
5390
5391   /* Adjust the section sizes and vmas according to the magic number.
5392      This sets a_text, a_data and a_bss in the exec_hdr and sets the
5393      filepos for each section.  */
5394   if (! NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
5395     goto error_return;
5396
5397   /* The relocation and symbol file positions differ among a.out
5398      targets.  We are passed a callback routine from the backend
5399      specific code to handle this.
5400      FIXME: At this point we do not know how much space the symbol
5401      table will require.  This will not work for any (nonstandard)
5402      a.out target that needs to know the symbol table size before it
5403      can compute the relocation file positions.  This may or may not
5404      be the case for the hp300hpux target, for example.  */
5405   (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
5406                &aout_info.symoff);
5407   obj_textsec (abfd)->rel_filepos = aout_info.treloff;
5408   obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
5409   obj_sym_filepos (abfd) = aout_info.symoff;
5410
5411   /* We keep a count of the symbols as we output them.  */
5412   obj_aout_external_sym_count (abfd) = 0;
5413
5414   /* We accumulate the string table as we write out the symbols.  */
5415   aout_info.strtab = _bfd_stringtab_init ();
5416   if (aout_info.strtab == NULL)
5417     goto error_return;
5418
5419   /* Allocate buffers to hold section contents and relocs.  */
5420   aout_info.contents = bfd_malloc (max_contents_size);
5421   aout_info.relocs = bfd_malloc (max_relocs_size);
5422   aout_info.symbol_map = bfd_malloc (max_sym_count * sizeof (int *));
5423   aout_info.output_syms = bfd_malloc ((max_sym_count + 1)
5424                                       * sizeof (struct external_nlist));
5425   if ((aout_info.contents == NULL && max_contents_size != 0)
5426       || (aout_info.relocs == NULL && max_relocs_size != 0)
5427       || (aout_info.symbol_map == NULL && max_sym_count != 0)
5428       || aout_info.output_syms == NULL)
5429     goto error_return;
5430
5431   /* If we have a symbol named __DYNAMIC, force it out now.  This is
5432      required by SunOS.  Doing this here rather than in sunos.c is a
5433      hack, but it's easier than exporting everything which would be
5434      needed.  */
5435   {
5436     struct aout_link_hash_entry *h;
5437
5438     h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
5439                                FALSE, FALSE, FALSE);
5440     if (h != NULL)
5441       aout_link_write_other_symbol (h, &aout_info);
5442   }
5443
5444   /* The most time efficient way to do the link would be to read all
5445      the input object files into memory and then sort out the
5446      information into the output file.  Unfortunately, that will
5447      probably use too much memory.  Another method would be to step
5448      through everything that composes the text section and write it
5449      out, and then everything that composes the data section and write
5450      it out, and then write out the relocs, and then write out the
5451      symbols.  Unfortunately, that requires reading stuff from each
5452      input file several times, and we will not be able to keep all the
5453      input files open simultaneously, and reopening them will be slow.
5454
5455      What we do is basically process one input file at a time.  We do
5456      everything we need to do with an input file once--copy over the
5457      section contents, handle the relocation information, and write
5458      out the symbols--and then we throw away the information we read
5459      from it.  This approach requires a lot of lseeks of the output
5460      file, which is unfortunate but still faster than reopening a lot
5461      of files.
5462
5463      We use the output_has_begun field of the input BFDs to see
5464      whether we have already handled it.  */
5465   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
5466     sub->output_has_begun = FALSE;
5467
5468   /* Mark all sections which are to be included in the link.  This
5469      will normally be every section.  We need to do this so that we
5470      can identify any sections which the linker has decided to not
5471      include.  */
5472   for (o = abfd->sections; o != NULL; o = o->next)
5473     {
5474       for (p = o->map_head.link_order; p != NULL; p = p->next)
5475         if (p->type == bfd_indirect_link_order)
5476           p->u.indirect.section->linker_mark = TRUE;
5477     }
5478
5479   have_link_order_relocs = FALSE;
5480   for (o = abfd->sections; o != NULL; o = o->next)
5481     {
5482       for (p = o->map_head.link_order;
5483            p != NULL;
5484            p = p->next)
5485         {
5486           if (p->type == bfd_indirect_link_order
5487               && (bfd_get_flavour (p->u.indirect.section->owner)
5488                   == bfd_target_aout_flavour))
5489             {
5490               bfd *input_bfd;
5491
5492               input_bfd = p->u.indirect.section->owner;
5493               if (! input_bfd->output_has_begun)
5494                 {
5495                   if (! aout_link_input_bfd (&aout_info, input_bfd))
5496                     goto error_return;
5497                   input_bfd->output_has_begun = TRUE;
5498                 }
5499             }
5500           else if (p->type == bfd_section_reloc_link_order
5501                    || p->type == bfd_symbol_reloc_link_order)
5502             {
5503               /* These are handled below.  */
5504               have_link_order_relocs = TRUE;
5505             }
5506           else
5507             {
5508               if (! _bfd_default_link_order (abfd, info, o, p))
5509                 goto error_return;
5510             }
5511         }
5512     }
5513
5514   /* Write out any symbols that we have not already written out.  */
5515   aout_link_hash_traverse (aout_hash_table (info),
5516                            aout_link_write_other_symbol,
5517                            (void *) &aout_info);
5518
5519   /* Now handle any relocs we were asked to create by the linker.
5520      These did not come from any input file.  We must do these after
5521      we have written out all the symbols, so that we know the symbol
5522      indices to use.  */
5523   if (have_link_order_relocs)
5524     {
5525       for (o = abfd->sections; o != NULL; o = o->next)
5526         {
5527           for (p = o->map_head.link_order;
5528                p != NULL;
5529                p = p->next)
5530             {
5531               if (p->type == bfd_section_reloc_link_order
5532                   || p->type == bfd_symbol_reloc_link_order)
5533                 {
5534                   if (! aout_link_reloc_link_order (&aout_info, o, p))
5535                     goto error_return;
5536                 }
5537             }
5538         }
5539     }
5540
5541   if (aout_info.contents != NULL)
5542     {
5543       free (aout_info.contents);
5544       aout_info.contents = NULL;
5545     }
5546   if (aout_info.relocs != NULL)
5547     {
5548       free (aout_info.relocs);
5549       aout_info.relocs = NULL;
5550     }
5551   if (aout_info.symbol_map != NULL)
5552     {
5553       free (aout_info.symbol_map);
5554       aout_info.symbol_map = NULL;
5555     }
5556   if (aout_info.output_syms != NULL)
5557     {
5558       free (aout_info.output_syms);
5559       aout_info.output_syms = NULL;
5560     }
5561   if (includes_hash_initialized)
5562     {
5563       bfd_hash_table_free (&aout_info.includes.root);
5564       includes_hash_initialized = FALSE;
5565     }
5566
5567   /* Finish up any dynamic linking we may be doing.  */
5568   if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
5569     {
5570       if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
5571         goto error_return;
5572     }
5573
5574   /* Update the header information.  */
5575   abfd->symcount = obj_aout_external_sym_count (abfd);
5576   exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
5577   obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
5578   obj_textsec (abfd)->reloc_count =
5579     exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
5580   obj_datasec (abfd)->reloc_count =
5581     exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
5582
5583   /* Write out the string table, unless there are no symbols.  */
5584   if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0)
5585     goto error_return;
5586   if (abfd->symcount > 0)
5587     {
5588       if (!emit_stringtab (abfd, aout_info.strtab))
5589         goto error_return;
5590     }
5591   else
5592     {
5593       bfd_byte b[BYTES_IN_WORD];
5594
5595       memset (b, 0, BYTES_IN_WORD);
5596       if (bfd_bwrite (b, (bfd_size_type) BYTES_IN_WORD, abfd) != BYTES_IN_WORD)
5597         goto error_return;
5598     }
5599
5600   return TRUE;
5601
5602  error_return:
5603   if (aout_info.contents != NULL)
5604     free (aout_info.contents);
5605   if (aout_info.relocs != NULL)
5606     free (aout_info.relocs);
5607   if (aout_info.symbol_map != NULL)
5608     free (aout_info.symbol_map);
5609   if (aout_info.output_syms != NULL)
5610     free (aout_info.output_syms);
5611   if (includes_hash_initialized)
5612     bfd_hash_table_free (&aout_info.includes.root);
5613   return FALSE;
5614 }