bfd/aoutx.h

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