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           break;
1292         }
1293       if ((cache_ptr->type | N_EXT) == (N_INDR | N_EXT))
1294         {
1295           /* Two symbols in a row for an INDR message. The first symbol
1296              contains the name we will match, the second symbol contains
1297              the name the first name is translated into. It is supplied to
1298              us undefined. This is good, since we want to pull in any files
1299              which define it */
1300           cache_ptr->symbol.flags = BSF_DEBUGGING | BSF_INDIRECT;
1301
1302           /* @@ Stuffing pointers into integers is a no-no.
1303              We can usually get away with it if the integer is
1304              large enough though.  */
1305           if (sizeof (cache_ptr + 1) > sizeof (bfd_vma))
1306             abort ();
1307
1308           cache_ptr->symbol.value = (bfd_vma) ((cache_ptr + 1));
1309           cache_ptr->symbol.section = &bfd_ind_section;
1310         }
1311
1312       else if (sym_is_debugger_info (cache_ptr))
1313         {
1314           cache_ptr->symbol.flags = BSF_DEBUGGING;
1315           /* Work out the section correct for this symbol */
1316           switch (cache_ptr->type & N_TYPE)
1317             {
1318             case N_TEXT:
1319             case N_FN:
1320               cache_ptr->symbol.section = obj_textsec (abfd);
1321               cache_ptr->symbol.value -= obj_textsec (abfd)->vma;
1322               break;
1323             case N_DATA:
1324               cache_ptr->symbol.value -= obj_datasec (abfd)->vma;
1325               cache_ptr->symbol.section = obj_datasec (abfd);
1326               break;
1327             case N_BSS:
1328               cache_ptr->symbol.section = obj_bsssec (abfd);
1329               cache_ptr->symbol.value -= obj_bsssec (abfd)->vma;
1330               break;
1331             default:
1332             case N_ABS:
1333               cache_ptr->symbol.section = &bfd_abs_section;
1334               break;
1335             }
1336         }
1337       else
1338         {
1339
1340           if (sym_is_fortrancommon (cache_ptr))
1341             {
1342               cache_ptr->symbol.flags = 0;
1343               cache_ptr->symbol.section = &bfd_com_section;
1344             }
1345           else
1346             {
1347
1348
1349             }
1350
1351           /* In a.out, the value of a symbol is always relative to the
1352            * start of the file, if this is a data symbol we'll subtract
1353            * the size of the text section to get the section relative
1354            * value. If this is a bss symbol (which would be strange)
1355            * we'll subtract the size of the previous two sections
1356            * to find the section relative address.
1357            */
1358
1359           if (sym_in_text_section (cache_ptr))
1360             {
1361               cache_ptr->symbol.value -= obj_textsec (abfd)->vma;
1362               cache_ptr->symbol.section = obj_textsec (abfd);
1363             }
1364           else if (sym_in_data_section (cache_ptr))
1365             {
1366               cache_ptr->symbol.value -= obj_datasec (abfd)->vma;
1367               cache_ptr->symbol.section = obj_datasec (abfd);
1368             }
1369           else if (sym_in_bss_section (cache_ptr))
1370             {
1371               cache_ptr->symbol.section = obj_bsssec (abfd);
1372               cache_ptr->symbol.value -= obj_bsssec (abfd)->vma;
1373             }
1374           else if (sym_is_undefined (cache_ptr))
1375             {
1376               cache_ptr->symbol.flags = 0;
1377               cache_ptr->symbol.section = &bfd_und_section;
1378             }
1379           else if (sym_is_absolute (cache_ptr))
1380             {
1381               cache_ptr->symbol.section = &bfd_abs_section;
1382             }
1383
1384           if (sym_is_global_defn (cache_ptr))
1385             {
1386               cache_ptr->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
1387             }
1388           else if (! sym_is_undefined (cache_ptr))
1389             {
1390               cache_ptr->symbol.flags = BSF_LOCAL;
1391             }
1392         }
1393     }
1394   if (cache_ptr->symbol.section == 0)
1395     abort ();
1396   return true;
1397 }
1398
1399
1400 static boolean
1401 translate_to_native_sym_flags (sym_pointer, cache_ptr, abfd)
1402      struct external_nlist *sym_pointer;
1403      asymbol *cache_ptr;
1404      bfd *abfd;
1405 {
1406   bfd_vma value = cache_ptr->value;
1407
1408   /* mask out any existing type bits in case copying from one section
1409      to another */
1410   sym_pointer->e_type[0] &= ~N_TYPE;
1411
1412   /* We attempt to order these tests by decreasing frequency of success,
1413      according to tcov when linking the linker.  */
1414   if (bfd_get_output_section(cache_ptr) == &bfd_abs_section) {
1415     sym_pointer->e_type[0] |= N_ABS;
1416   }
1417   else if (bfd_get_output_section(cache_ptr) == obj_textsec (abfd)) {
1418     sym_pointer->e_type[0] |= N_TEXT;
1419   }
1420   else if (bfd_get_output_section(cache_ptr) == obj_datasec (abfd)) {
1421     sym_pointer->e_type[0] |= N_DATA;
1422   }
1423   else if (bfd_get_output_section(cache_ptr) == obj_bsssec (abfd)) {
1424     sym_pointer->e_type[0] |= N_BSS;
1425   }
1426   else if (bfd_get_output_section(cache_ptr) == &bfd_und_section) {
1427     sym_pointer->e_type[0] = (N_UNDF | N_EXT);
1428   }
1429   else if (bfd_get_output_section(cache_ptr) == &bfd_ind_section) {
1430     sym_pointer->e_type[0] = N_INDR;
1431   }
1432   else if (bfd_get_output_section(cache_ptr) == NULL) {
1433     /* Protect the bfd_is_com_section call.
1434        This case occurs, e.g., for the *DEBUG* section of a COFF file.  */
1435     bfd_set_error (bfd_error_nonrepresentable_section);
1436     return false;
1437   }
1438   else if (bfd_is_com_section (bfd_get_output_section (cache_ptr))) {
1439     sym_pointer->e_type[0] = (N_UNDF | N_EXT);
1440   }
1441   else {
1442     bfd_set_error (bfd_error_nonrepresentable_section);
1443     return false;
1444   }
1445
1446   /* Turn the symbol from section relative to absolute again */
1447
1448   value +=  cache_ptr->section->output_section->vma  + cache_ptr->section->output_offset ;
1449
1450
1451   if (cache_ptr->flags & (BSF_WARNING)) {
1452     sym_pointer->e_type[0] = N_WARNING;
1453   }
1454
1455   if (cache_ptr->flags & BSF_DEBUGGING) {
1456     sym_pointer->e_type[0] = ((aout_symbol_type *)cache_ptr)->type;
1457   }
1458   else if (cache_ptr->flags & (BSF_GLOBAL | BSF_EXPORT)) {
1459     sym_pointer->e_type[0] |= N_EXT;
1460   }
1461   if (cache_ptr->flags & BSF_CONSTRUCTOR) {
1462     int type = ((aout_symbol_type *)cache_ptr)->type;
1463     switch (type)
1464       {
1465       case N_ABS:       type = N_SETA; break;
1466       case N_TEXT:      type = N_SETT; break;
1467       case N_DATA:      type = N_SETD; break;
1468       case N_BSS:       type = N_SETB; break;
1469       }
1470     sym_pointer->e_type[0] = type;
1471   }
1472
1473   PUT_WORD(abfd, value, sym_pointer->e_value);
1474
1475   return true;
1476 }
1477 \f
1478 /* Native-level interface to symbols. */
1479
1480
1481 asymbol *
1482 NAME(aout,make_empty_symbol) (abfd)
1483      bfd *abfd;
1484 {
1485   aout_symbol_type  *new =
1486     (aout_symbol_type *)bfd_zalloc (abfd, sizeof (aout_symbol_type));
1487   if (!new)
1488     {
1489       bfd_set_error (bfd_error_no_memory);
1490       return NULL;
1491     }
1492   new->symbol.the_bfd = abfd;
1493
1494   return &new->symbol;
1495 }
1496
1497 /* Translate a set of internal symbols into external symbols.  */
1498
1499 boolean
1500 NAME(aout,translate_symbol_table) (abfd, in, ext, count, str, strsize, dynamic)
1501      bfd *abfd;
1502      aout_symbol_type *in;
1503      struct external_nlist *ext;
1504      bfd_size_type count;
1505      char *str;
1506      bfd_size_type strsize;
1507      boolean dynamic;
1508 {
1509   struct external_nlist *ext_end;
1510
1511   ext_end = ext + count;
1512   for (; ext < ext_end; ext++, in++)
1513     {
1514       bfd_vma x;
1515
1516       x = GET_WORD (abfd, ext->e_strx);
1517       in->symbol.the_bfd = abfd;
1518
1519       /* For the normal symbols, the zero index points at the number
1520          of bytes in the string table but is to be interpreted as the
1521          null string.  For the dynamic symbols, the number of bytes in
1522          the string table is stored in the __DYNAMIC structure and the
1523          zero index points at an actual string.  */
1524       if (x == 0 && ! dynamic)
1525         in->symbol.name = "";
1526       else if (x < strsize)
1527         in->symbol.name = str + x;
1528       else
1529         return false;
1530
1531       in->symbol.value = GET_SWORD (abfd,  ext->e_value);
1532       in->desc = bfd_h_get_16 (abfd, ext->e_desc);
1533       in->other = bfd_h_get_8 (abfd, ext->e_other);
1534       in->type = bfd_h_get_8 (abfd,  ext->e_type);
1535       in->symbol.udata = 0;
1536
1537       if (!translate_from_native_sym_flags (ext, in, abfd))
1538         return false;
1539
1540       if (dynamic)
1541         in->symbol.flags |= BSF_DYNAMIC;
1542     }
1543
1544   return true;
1545 }
1546
1547 /* We read the symbols into a buffer, which is discarded when this
1548    function exits.  We read the strings into a buffer large enough to
1549    hold them all plus all the cached symbol entries. */
1550
1551 boolean
1552 NAME(aout,slurp_symbol_table) (abfd)
1553      bfd *abfd;
1554 {
1555   struct external_nlist *old_external_syms;
1556   aout_symbol_type *cached;
1557   size_t cached_size;
1558
1559   /* If there's no work to be done, don't do any */
1560   if (obj_aout_symbols (abfd) != (aout_symbol_type *) NULL)
1561     return true;
1562
1563   old_external_syms = obj_aout_external_syms (abfd);
1564
1565   if (! aout_get_external_symbols (abfd))
1566     return false;
1567
1568   if (obj_aout_external_sym_count (abfd) == 0)
1569     {
1570       bfd_set_error (bfd_error_no_symbols);
1571       return false;
1572     }
1573
1574   cached_size = (obj_aout_external_sym_count (abfd)
1575                  * sizeof (aout_symbol_type));
1576   cached = (aout_symbol_type *) malloc (cached_size);
1577   if (cached == NULL)
1578     {
1579       bfd_set_error (bfd_error_no_memory);
1580       return false;
1581     }
1582   memset (cached, 0, cached_size);
1583
1584   /* Convert from external symbol information to internal.  */
1585   if (! (NAME(aout,translate_symbol_table)
1586          (abfd, cached,
1587           obj_aout_external_syms (abfd),
1588           obj_aout_external_sym_count (abfd),
1589           obj_aout_external_strings (abfd),
1590           obj_aout_external_string_size (abfd),
1591           false)))
1592     {
1593       free (cached);
1594       return false;
1595     }
1596
1597   bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
1598
1599   obj_aout_symbols (abfd) = cached;
1600
1601   /* It is very likely that anybody who calls this function will not
1602      want the external symbol information, so if it was allocated
1603      because of our call to aout_get_external_symbols, we free it up
1604      right away to save space.  */
1605   if (old_external_syms == (struct external_nlist *) NULL
1606       && obj_aout_external_syms (abfd) != (struct external_nlist *) NULL)
1607     {
1608       free (obj_aout_external_syms (abfd));
1609       obj_aout_external_syms (abfd) = NULL;
1610     }
1611
1612   return true;
1613 }
1614 \f
1615 /* Possible improvements:
1616    + look for strings matching trailing substrings of other strings
1617    + better data structures?  balanced trees?
1618    + smaller per-string or per-symbol data?  re-use some of the symbol's
1619      data fields?
1620    + also look at reducing memory use elsewhere -- maybe if we didn't have to
1621      construct the entire symbol table at once, we could get by with smaller
1622      amounts of VM?  (What effect does that have on the string table
1623      reductions?)
1624    + rip this out of here, put it into its own file in bfd or libiberty, so
1625      coff and elf can use it too.  I'll work on this soon, but have more
1626      pressing tasks right now.
1627
1628    A hash table might(?) be more efficient for handling exactly the cases that
1629    are handled now, but for trailing substring matches, I think we want to
1630    examine the `nearest' values (reverse-)lexically, not merely impose a strict
1631    order, nor look only for exact-match or not-match.  I don't think a hash
1632    table would be very useful for that, and I don't feel like fleshing out two
1633    completely different implementations.  [raeburn:930419.0331EDT] */
1634
1635 struct stringtab_entry {
1636   /* Hash value for this string.  Only useful so long as we aren't doing
1637      substring matches.  */
1638   unsigned int hash;
1639
1640   /* Next node to look at, depending on whether the hash value of the string
1641      being searched for is less than or greater than the hash value of the
1642      current node.  For now, `equal to' is lumped in with `greater than', for
1643      space efficiency.  It's not a common enough case to warrant another field
1644      to be used for all nodes.  */
1645   struct stringtab_entry *less;
1646   struct stringtab_entry *greater;
1647
1648   /* The string itself.  */
1649   CONST char *string;
1650
1651   /* The index allocated for this string.  */
1652   bfd_size_type index;
1653
1654 #ifdef GATHER_STATISTICS
1655   /* How many references have there been to this string?  (Not currently used;
1656      could be dumped out for anaylsis, if anyone's interested.)  */
1657   unsigned long count;
1658 #endif
1659
1660   /* Next node in linked list, in suggested output order.  */
1661   struct stringtab_entry *next_to_output;
1662 };
1663
1664 struct stringtab_data {
1665   /* Tree of string table entries.  */
1666   struct stringtab_entry *strings;
1667
1668   /* Fudge factor used to center top node of tree.  */
1669   int hash_zero;
1670
1671   /* Next index value to issue.  */
1672   bfd_size_type index;
1673
1674   /* Index used for empty strings.  Cached here because checking for them
1675      is really easy, and we can avoid searching the tree.  */
1676   bfd_size_type empty_string_index;
1677
1678   /* These fields indicate the two ends of a singly-linked list that indicates
1679      the order strings should be written out in.  Use this order, and no
1680      seeking will need to be done, so output efficiency should be maximized. */
1681   struct stringtab_entry **end;
1682   struct stringtab_entry *output_order;
1683
1684 #ifdef GATHER_STATISTICS
1685   /* Number of strings which duplicate strings already in the table.  */
1686   unsigned long duplicates;
1687
1688   /* Number of bytes saved by not having to write all the duplicate strings. */
1689   unsigned long bytes_saved;
1690
1691   /* Number of zero-length strings.  Currently, these all turn into
1692      references to the null byte at the end of the first string.  In some
1693      cases (possibly not all?  explore this...), it should be possible to
1694      simply write out a zero index value.  */
1695   unsigned long empty_strings;
1696
1697   /* Number of times the hash values matched but the strings were different.
1698      Note that this includes the number of times the other string(s) occurs, so
1699      there may only be two strings hashing to the same value, even if this
1700      number is very large.  */
1701   unsigned long bad_hash_matches;
1702
1703   /* Null strings aren't counted in this one.
1704      This will probably only be nonzero if we've got an input file
1705      which was produced by `ld -r' (i.e., it's already been processed
1706      through this code).  Under some operating systems, native tools
1707      may make all empty strings have the same index; but the pointer
1708      check won't catch those, because to get to that stage we'd already
1709      have to compute the checksum, which requires reading the string,
1710      so we short-circuit that case with empty_string_index above.  */
1711   unsigned long pointer_matches;
1712
1713   /* Number of comparisons done.  I figure with the algorithms in use below,
1714      the average number of comparisons done (per symbol) should be roughly
1715      log-base-2 of the number of unique strings.  */
1716   unsigned long n_compares;
1717 #endif
1718 };
1719
1720 /* Some utility functions for the string table code.  */
1721
1722 /* For speed, only hash on the first this many bytes of strings.
1723    This number was chosen by profiling ld linking itself, with -g.  */
1724 #define HASHMAXLEN 25
1725
1726 #define HASH_CHAR(c) (sum ^= sum >> 20, sum ^= sum << 7, sum += (c))
1727
1728 static INLINE unsigned int
1729 hash (string, len)
1730      unsigned char *string;
1731      register unsigned int len;
1732 {
1733   register unsigned int sum = 0;
1734
1735   if (len > HASHMAXLEN)
1736     {
1737       HASH_CHAR (len);
1738       len = HASHMAXLEN;
1739     }
1740
1741   while (len--)
1742     {
1743       HASH_CHAR (*string++);
1744     }
1745   return sum;
1746 }
1747
1748 static INLINE void
1749 stringtab_init (tab)
1750      struct stringtab_data *tab;
1751 {
1752   tab->strings = 0;
1753   tab->output_order = 0;
1754   tab->hash_zero = 0;
1755   tab->end = &tab->output_order;
1756
1757   /* Initial string table length includes size of length field.  */
1758   tab->index = BYTES_IN_WORD;
1759   tab->empty_string_index = -1;
1760 #ifdef GATHER_STATISTICS
1761   tab->duplicates = 0;
1762   tab->empty_strings = 0;
1763   tab->bad_hash_matches = 0;
1764   tab->pointer_matches = 0;
1765   tab->bytes_saved = 0;
1766   tab->n_compares = 0;
1767 #endif
1768 }
1769
1770 static INLINE int
1771 compare (entry, str, hash)
1772      struct stringtab_entry *entry;
1773      CONST char *str;
1774      unsigned int hash;
1775 {
1776   return hash - entry->hash;
1777 }
1778
1779 #ifdef GATHER_STATISTICS
1780 /* Don't want to have to link in math library with all bfd applications...  */
1781 static INLINE double
1782 log2 (num)
1783      int num;
1784 {
1785   double d = num;
1786   int n = 0;
1787   while (d >= 2.0)
1788     n++, d /= 2.0;
1789   return ((d > 1.41) ? 0.5 : 0) + n;
1790 }
1791 #endif
1792
1793 /* Main string table routines.  */
1794 /* Returns index in string table.  Whether or not this actually adds an
1795    entry into the string table should be irrelevant -- it just has to
1796    return a valid index.  */
1797 static bfd_size_type
1798 add_to_stringtab (abfd, str, tab)
1799      bfd *abfd;
1800      CONST char *str;
1801      struct stringtab_data *tab;
1802 {
1803   struct stringtab_entry **ep;
1804   register struct stringtab_entry *entry;
1805   unsigned int hashval, len;
1806
1807   if (str[0] == 0)
1808     {
1809       bfd_size_type index;
1810       CONST bfd_size_type minus_one = -1;
1811
1812 #ifdef GATHER_STATISTICS
1813       tab->empty_strings++;
1814 #endif
1815       index = tab->empty_string_index;
1816       if (index != minus_one)
1817         {
1818         got_empty:
1819 #ifdef GATHER_STATISTICS
1820           tab->bytes_saved++;
1821           tab->duplicates++;
1822 #endif
1823           return index;
1824         }
1825
1826       /* Need to find it.  */
1827       entry = tab->strings;
1828       if (entry)
1829         {
1830           index = entry->index + strlen (entry->string);
1831           tab->empty_string_index = index;
1832           goto got_empty;
1833         }
1834       len = 0;
1835     }
1836   else
1837     len = strlen (str);
1838
1839   /* The hash_zero value is chosen such that the first symbol gets a value of
1840      zero.  With a balanced tree, this wouldn't be very useful, but without it,
1841      we might get a more even split at the top level, instead of skewing it
1842      badly should hash("/usr/lib/crt0.o") (or whatever) be far from zero. */
1843   hashval = hash (str, len) ^ tab->hash_zero;
1844   ep = &tab->strings;
1845   if (!*ep)
1846     {
1847       tab->hash_zero = hashval;
1848       hashval = 0;
1849       goto add_it;
1850     }
1851
1852   while (*ep)
1853     {
1854       register int cmp;
1855
1856       entry = *ep;
1857 #ifdef GATHER_STATISTICS
1858       tab->n_compares++;
1859 #endif
1860       cmp = compare (entry, str, hashval);
1861       /* The not-equal cases are more frequent, so check them first.  */
1862       if (cmp > 0)
1863         ep = &entry->greater;
1864       else if (cmp < 0)
1865         ep = &entry->less;
1866       else
1867         {
1868           if (entry->string == str)
1869             {
1870 #ifdef GATHER_STATISTICS
1871               tab->pointer_matches++;
1872 #endif
1873               goto match;
1874             }
1875           /* Compare the first bytes to save a function call if they
1876              don't match.  */
1877           if (entry->string[0] == str[0] && !strcmp (entry->string, str))
1878             {
1879             match:
1880 #ifdef GATHER_STATISTICS
1881               entry->count++;
1882               tab->bytes_saved += len + 1;
1883               tab->duplicates++;
1884 #endif
1885               /* If we're in the linker, and the new string is from a new
1886                  input file which might have already had these reductions
1887                  run over it, we want to keep the new string pointer.  I
1888                  don't think we're likely to see any (or nearly as many,
1889                  at least) cases where a later string is in the same location
1890                  as an earlier one rather than this one.  */
1891               entry->string = str;
1892               return entry->index;
1893             }
1894 #ifdef GATHER_STATISTICS
1895           tab->bad_hash_matches++;
1896 #endif
1897           ep = &entry->greater;
1898         }
1899     }
1900
1901   /* If we get here, nothing that's in the table already matched.
1902      EP points to the `next' field at the end of the chain; stick a
1903      new entry on here.  */
1904  add_it:
1905   entry = (struct stringtab_entry *)
1906     bfd_alloc_by_size_t (abfd, sizeof (struct stringtab_entry));
1907   if (!entry)
1908     {
1909       bfd_set_error (bfd_error_no_memory);
1910       abort();                  /* FIXME */
1911     }
1912
1913   entry->less = entry->greater = 0;
1914   entry->hash = hashval;
1915   entry->index = tab->index;
1916   entry->string = str;
1917   entry->next_to_output = 0;
1918 #ifdef GATHER_STATISTICS
1919   entry->count = 1;
1920 #endif
1921
1922   BFD_ASSERT (*tab->end == 0);
1923   *(tab->end) = entry;
1924   tab->end = &entry->next_to_output;
1925   BFD_ASSERT (*tab->end == 0);
1926
1927   {
1928     tab->index += len + 1;
1929     if (len == 0)
1930       tab->empty_string_index = entry->index;
1931   }
1932   BFD_ASSERT (*ep == 0);
1933   *ep = entry;
1934   return entry->index;
1935 }
1936
1937 static boolean
1938 emit_strtab (abfd, tab)
1939      bfd *abfd;
1940      struct stringtab_data *tab;
1941 {
1942   struct stringtab_entry *entry;
1943 #ifdef GATHER_STATISTICS
1944   int count = 0;
1945 #endif
1946
1947   /* Be sure to put string length into correct byte ordering before writing
1948      it out.  */
1949   char buffer[BYTES_IN_WORD];
1950
1951   PUT_WORD (abfd, tab->index, (unsigned char *) buffer);
1952   if (bfd_write ((PTR) buffer, 1, BYTES_IN_WORD, abfd) != BYTES_IN_WORD)
1953     return false;
1954
1955   for (entry = tab->output_order; entry; entry = entry->next_to_output)
1956     {
1957       size_t len = strlen (entry->string) + 1;
1958
1959       if (bfd_write ((PTR) entry->string, 1, len, abfd) != len)
1960         return false;
1961
1962 #ifdef GATHER_STATISTICS
1963       count++;
1964 #endif
1965     }
1966
1967 #ifdef GATHER_STATISTICS
1968   /* Short form only, for now.
1969      To do:  Specify output file.  Conditionalize on environment?  Detailed
1970      analysis if desired.  */
1971   {
1972     int n_syms = bfd_get_symcount (abfd);
1973
1974     fprintf (stderr, "String table data for output file:\n");
1975     fprintf (stderr, "  %8d symbols output\n", n_syms);
1976     fprintf (stderr, "  %8d duplicate strings\n", tab->duplicates);
1977     fprintf (stderr, "  %8d empty strings\n", tab->empty_strings);
1978     fprintf (stderr, "  %8d unique strings output\n", count);
1979     fprintf (stderr, "  %8d pointer matches\n", tab->pointer_matches);
1980     fprintf (stderr, "  %8d bytes saved\n", tab->bytes_saved);
1981     fprintf (stderr, "  %8d bad hash matches\n", tab->bad_hash_matches);
1982     fprintf (stderr, "  %8d hash-val comparisons\n", tab->n_compares);
1983     if (n_syms)
1984       {
1985         double n_compares = tab->n_compares;
1986         double avg_compares = n_compares / n_syms;
1987         /* The second value here should usually be near one.  */
1988         fprintf (stderr,
1989                  "\t    average %f comparisons per symbol (%f * log2 nstrings)\n",
1990                  avg_compares, avg_compares / log2 (count));
1991       }
1992   }
1993 #endif
1994
1995 /* Old code:
1996   unsigned int count;
1997   generic = bfd_get_outsymbols(abfd);
1998   for (count = 0; count < bfd_get_symcount(abfd); count++)
1999     {
2000       asymbol *g = *(generic++);
2001
2002       if (g->name)
2003         {
2004           size_t length = strlen(g->name)+1;
2005           bfd_write((PTR)g->name, 1, length, abfd);
2006         }
2007       g->KEEPIT = (KEEPITTYPE) count;
2008     } */
2009
2010   return true;
2011 }
2012
2013 boolean
2014 NAME(aout,write_syms) (abfd)
2015      bfd *abfd;
2016 {
2017   unsigned int count ;
2018   asymbol **generic = bfd_get_outsymbols (abfd);
2019   struct stringtab_data strtab;
2020
2021   stringtab_init (&strtab);
2022
2023   for (count = 0; count < bfd_get_symcount (abfd); count++)
2024     {
2025       asymbol *g = generic[count];
2026       struct external_nlist nsp;
2027
2028       if (g->name)
2029         PUT_WORD (abfd, add_to_stringtab (abfd, g->name, &strtab),
2030                   (unsigned char *) nsp.e_strx);
2031       else
2032         PUT_WORD (abfd, 0, (unsigned char *)nsp.e_strx);
2033
2034       if (bfd_asymbol_flavour(g) == abfd->xvec->flavour)
2035         {
2036           bfd_h_put_16(abfd, aout_symbol(g)->desc,  nsp.e_desc);
2037           bfd_h_put_8(abfd, aout_symbol(g)->other,  nsp.e_other);
2038           bfd_h_put_8(abfd, aout_symbol(g)->type,  nsp.e_type);
2039         }
2040       else
2041         {
2042           bfd_h_put_16(abfd,0, nsp.e_desc);
2043           bfd_h_put_8(abfd, 0, nsp.e_other);
2044           bfd_h_put_8(abfd, 0, nsp.e_type);
2045         }
2046
2047       if (! translate_to_native_sym_flags (&nsp, g, abfd))
2048         return false;
2049
2050       if (bfd_write((PTR)&nsp,1,EXTERNAL_NLIST_SIZE, abfd)
2051           != EXTERNAL_NLIST_SIZE)
2052         return false;
2053
2054       /* NB: `KEEPIT' currently overlays `flags', so set this only
2055          here, at the end.  */
2056       g->KEEPIT = count;
2057     }
2058
2059   return emit_strtab (abfd, &strtab);
2060 }
2061
2062 \f
2063 long
2064 NAME(aout,get_symtab) (abfd, location)
2065      bfd *abfd;
2066      asymbol **location;
2067 {
2068     unsigned int counter = 0;
2069     aout_symbol_type *symbase;
2070
2071     if (!NAME(aout,slurp_symbol_table)(abfd))
2072       return -1;
2073
2074     for (symbase = obj_aout_symbols(abfd); counter++ < bfd_get_symcount (abfd);)
2075       *(location++) = (asymbol *)( symbase++);
2076     *location++ =0;
2077     return bfd_get_symcount (abfd);
2078 }
2079
2080 \f
2081 /* Standard reloc stuff */
2082 /* Output standard relocation information to a file in target byte order. */
2083
2084 void
2085 NAME(aout,swap_std_reloc_out) (abfd, g, natptr)
2086      bfd *abfd;
2087      arelent *g;
2088      struct reloc_std_external *natptr;
2089 {
2090   int r_index;
2091   asymbol *sym = *(g->sym_ptr_ptr);
2092   int r_extern;
2093   unsigned int r_length;
2094   int r_pcrel;
2095   int r_baserel, r_jmptable, r_relative;
2096   asection *output_section = sym->section->output_section;
2097
2098   PUT_WORD(abfd, g->address, natptr->r_address);
2099
2100   r_length = g->howto->size ;   /* Size as a power of two */
2101   r_pcrel  = (int) g->howto->pc_relative; /* Relative to PC? */
2102   /* XXX This relies on relocs coming from a.out files.  */
2103   r_baserel = (g->howto->type & 8) != 0;
2104   r_jmptable = (g->howto->type & 16) != 0;
2105   r_relative = (g->howto->type & 32) != 0;
2106
2107 #if 0
2108   /* For a standard reloc, the addend is in the object file.  */
2109   r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
2110 #endif
2111
2112   /* name was clobbered by aout_write_syms to be symbol index */
2113
2114   /* If this relocation is relative to a symbol then set the
2115      r_index to the symbols index, and the r_extern bit.
2116
2117      Absolute symbols can come in in two ways, either as an offset
2118      from the abs section, or as a symbol which has an abs value.
2119      check for that here
2120      */
2121
2122
2123   if (bfd_is_com_section (output_section)
2124       || output_section == &bfd_abs_section
2125       || output_section == &bfd_und_section)
2126     {
2127       if (bfd_abs_section.symbol == sym)
2128       {
2129         /* Whoops, looked like an abs symbol, but is really an offset
2130            from the abs section */
2131         r_index = 0;
2132         r_extern = 0;
2133        }
2134       else
2135       {
2136         /* Fill in symbol */
2137         r_extern = 1;
2138         r_index =  stoi((*(g->sym_ptr_ptr))->KEEPIT);
2139
2140       }
2141     }
2142   else
2143     {
2144       /* Just an ordinary section */
2145       r_extern = 0;
2146       r_index  = output_section->target_index;
2147     }
2148
2149   /* now the fun stuff */
2150   if (abfd->xvec->header_byteorder_big_p != false) {
2151       natptr->r_index[0] = r_index >> 16;
2152       natptr->r_index[1] = r_index >> 8;
2153       natptr->r_index[2] = r_index;
2154       natptr->r_type[0] =
2155        (r_extern?    RELOC_STD_BITS_EXTERN_BIG: 0)
2156         | (r_pcrel?     RELOC_STD_BITS_PCREL_BIG: 0)
2157          | (r_baserel?   RELOC_STD_BITS_BASEREL_BIG: 0)
2158           | (r_jmptable?  RELOC_STD_BITS_JMPTABLE_BIG: 0)
2159            | (r_relative?  RELOC_STD_BITS_RELATIVE_BIG: 0)
2160             | (r_length <<  RELOC_STD_BITS_LENGTH_SH_BIG);
2161     } else {
2162         natptr->r_index[2] = r_index >> 16;
2163         natptr->r_index[1] = r_index >> 8;
2164         natptr->r_index[0] = r_index;
2165         natptr->r_type[0] =
2166          (r_extern?    RELOC_STD_BITS_EXTERN_LITTLE: 0)
2167           | (r_pcrel?     RELOC_STD_BITS_PCREL_LITTLE: 0)
2168            | (r_baserel?   RELOC_STD_BITS_BASEREL_LITTLE: 0)
2169             | (r_jmptable?  RELOC_STD_BITS_JMPTABLE_LITTLE: 0)
2170              | (r_relative?  RELOC_STD_BITS_RELATIVE_LITTLE: 0)
2171               | (r_length <<  RELOC_STD_BITS_LENGTH_SH_LITTLE);
2172       }
2173 }
2174
2175
2176 /* Extended stuff */
2177 /* Output extended relocation information to a file in target byte order. */
2178
2179 void
2180 NAME(aout,swap_ext_reloc_out) (abfd, g, natptr)
2181      bfd *abfd;
2182      arelent *g;
2183      register struct reloc_ext_external *natptr;
2184 {
2185   int r_index;
2186   int r_extern;
2187   unsigned int r_type;
2188   unsigned int r_addend;
2189   asymbol *sym = *(g->sym_ptr_ptr);
2190   asection *output_section = sym->section->output_section;
2191
2192   PUT_WORD (abfd, g->address, natptr->r_address);
2193
2194   r_type = (unsigned int) g->howto->type;
2195
2196   r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
2197
2198   /* If this relocation is relative to a symbol then set the
2199      r_index to the symbols index, and the r_extern bit.
2200
2201      Absolute symbols can come in in two ways, either as an offset
2202      from the abs section, or as a symbol which has an abs value.
2203      check for that here.  */
2204
2205   if (bfd_is_com_section (output_section)
2206       || output_section == &bfd_abs_section
2207       || output_section == &bfd_und_section)
2208   {
2209     if (bfd_abs_section.symbol == sym)
2210     {
2211       /* Whoops, looked like an abs symbol, but is really an offset
2212          from the abs section */
2213       r_index = 0;
2214       r_extern = 0;
2215      }
2216     else
2217     {
2218       r_extern = 1;
2219       r_index =  stoi((*(g->sym_ptr_ptr))->KEEPIT);
2220     }
2221   }
2222   else
2223   {
2224     /* Just an ordinary section */
2225     r_extern = 0;
2226     r_index  = output_section->target_index;
2227   }
2228
2229   /* now the fun stuff */
2230   if (abfd->xvec->header_byteorder_big_p != false) {
2231     natptr->r_index[0] = r_index >> 16;
2232     natptr->r_index[1] = r_index >> 8;
2233     natptr->r_index[2] = r_index;
2234     natptr->r_type[0] =
2235       ((r_extern? RELOC_EXT_BITS_EXTERN_BIG: 0)
2236        | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG));
2237   } else {
2238     natptr->r_index[2] = r_index >> 16;
2239     natptr->r_index[1] = r_index >> 8;
2240     natptr->r_index[0] = r_index;
2241     natptr->r_type[0] =
2242      (r_extern? RELOC_EXT_BITS_EXTERN_LITTLE: 0)
2243       | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
2244   }
2245
2246   PUT_WORD (abfd, r_addend, natptr->r_addend);
2247 }
2248
2249 /* BFD deals internally with all things based from the section they're
2250    in. so, something in 10 bytes into a text section  with a base of
2251    50 would have a symbol (.text+10) and know .text vma was 50.
2252
2253    Aout keeps all it's symbols based from zero, so the symbol would
2254    contain 60. This macro subs the base of each section from the value
2255    to give the true offset from the section */
2256
2257
2258 #define MOVE_ADDRESS(ad)                                                \
2259   if (r_extern) {                                                       \
2260    /* undefined symbol */                                               \
2261      cache_ptr->sym_ptr_ptr = symbols + r_index;                        \
2262      cache_ptr->addend = ad;                                            \
2263      } else {                                                           \
2264     /* defined, section relative. replace symbol with pointer to        \
2265        symbol which points to section  */                               \
2266     switch (r_index) {                                                  \
2267     case N_TEXT:                                                        \
2268     case N_TEXT | N_EXT:                                                \
2269       cache_ptr->sym_ptr_ptr  = obj_textsec(abfd)->symbol_ptr_ptr;      \
2270       cache_ptr->addend = ad  - su->textsec->vma;                       \
2271       break;                                                            \
2272     case N_DATA:                                                        \
2273     case N_DATA | N_EXT:                                                \
2274       cache_ptr->sym_ptr_ptr  = obj_datasec(abfd)->symbol_ptr_ptr;      \
2275       cache_ptr->addend = ad - su->datasec->vma;                        \
2276       break;                                                            \
2277     case N_BSS:                                                         \
2278     case N_BSS | N_EXT:                                                 \
2279       cache_ptr->sym_ptr_ptr  = obj_bsssec(abfd)->symbol_ptr_ptr;       \
2280       cache_ptr->addend = ad - su->bsssec->vma;                         \
2281       break;                                                            \
2282     default:                                                            \
2283     case N_ABS:                                                         \
2284     case N_ABS | N_EXT:                                                 \
2285      cache_ptr->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;   \
2286       cache_ptr->addend = ad;                                           \
2287       break;                                                            \
2288     }                                                                   \
2289   }                                                                     \
2290
2291 void
2292 NAME(aout,swap_ext_reloc_in) (abfd, bytes, cache_ptr, symbols)
2293      bfd *abfd;
2294      struct reloc_ext_external *bytes;
2295      arelent *cache_ptr;
2296      asymbol **symbols;
2297 {
2298   int r_index;
2299   int r_extern;
2300   unsigned int r_type;
2301   struct aoutdata *su = &(abfd->tdata.aout_data->a);
2302
2303   cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
2304
2305   /* now the fun stuff */
2306   if (abfd->xvec->header_byteorder_big_p != false) {
2307     r_index =  (bytes->r_index[0] << 16)
2308              | (bytes->r_index[1] << 8)
2309              |  bytes->r_index[2];
2310     r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
2311     r_type   =       (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
2312                                       >> RELOC_EXT_BITS_TYPE_SH_BIG;
2313   } else {
2314     r_index =  (bytes->r_index[2] << 16)
2315              | (bytes->r_index[1] << 8)
2316              |  bytes->r_index[0];
2317     r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
2318     r_type   =       (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
2319                                       >> RELOC_EXT_BITS_TYPE_SH_LITTLE;
2320   }
2321
2322   cache_ptr->howto =  howto_table_ext + r_type;
2323   MOVE_ADDRESS(GET_SWORD(abfd, bytes->r_addend));
2324 }
2325
2326 void
2327 NAME(aout,swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols)
2328      bfd *abfd;
2329      struct reloc_std_external *bytes;
2330      arelent *cache_ptr;
2331      asymbol **symbols;
2332 {
2333   int r_index;
2334   int r_extern;
2335   unsigned int r_length;
2336   int r_pcrel;
2337   int r_baserel, r_jmptable, r_relative;
2338   struct aoutdata  *su = &(abfd->tdata.aout_data->a);
2339   int howto_idx;
2340
2341   cache_ptr->address = bfd_h_get_32 (abfd, bytes->r_address);
2342
2343   /* now the fun stuff */
2344   if (abfd->xvec->header_byteorder_big_p != false) {
2345     r_index =  (bytes->r_index[0] << 16)
2346       | (bytes->r_index[1] << 8)
2347         |  bytes->r_index[2];
2348     r_extern  = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
2349     r_pcrel   = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
2350     r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
2351     r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
2352     r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
2353     r_length  =       (bytes->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
2354                         >> RELOC_STD_BITS_LENGTH_SH_BIG;
2355   } else {
2356     r_index =  (bytes->r_index[2] << 16)
2357       | (bytes->r_index[1] << 8)
2358         |  bytes->r_index[0];
2359     r_extern  = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
2360     r_pcrel   = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
2361     r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
2362     r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
2363     r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_LITTLE));
2364     r_length  =       (bytes->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
2365                         >> RELOC_STD_BITS_LENGTH_SH_LITTLE;
2366   }
2367
2368   howto_idx = r_length + 4 * r_pcrel + 8 * r_baserel
2369               + 16 * r_jmptable + 32 * r_relative;
2370   BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_std));
2371   cache_ptr->howto =  howto_table_std + howto_idx;
2372   BFD_ASSERT (cache_ptr->howto->type != -1);
2373
2374   MOVE_ADDRESS(0);
2375 }
2376
2377 /* Read and swap the relocs for a section.  */
2378
2379 boolean
2380 NAME(aout,slurp_reloc_table) (abfd, asect, symbols)
2381      bfd *abfd;
2382      sec_ptr asect;
2383      asymbol **symbols;
2384 {
2385   unsigned int count;
2386   bfd_size_type reloc_size;
2387   PTR relocs;
2388   arelent *reloc_cache;
2389   size_t each_size;
2390   unsigned int counter = 0;
2391   arelent *cache_ptr;
2392
2393   if (asect->relocation)
2394     return true;
2395
2396   if (asect->flags & SEC_CONSTRUCTOR)
2397     return true;
2398
2399   if (asect == obj_datasec (abfd))
2400     reloc_size = exec_hdr(abfd)->a_drsize;
2401   else if (asect == obj_textsec (abfd))
2402     reloc_size = exec_hdr(abfd)->a_trsize;
2403   else
2404     {
2405       bfd_set_error (bfd_error_invalid_operation);
2406       return false;
2407     }
2408
2409   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
2410     return false;
2411
2412   each_size = obj_reloc_entry_size (abfd);
2413
2414   count = reloc_size / each_size;
2415
2416   reloc_cache = (arelent *) malloc ((size_t) (count * sizeof (arelent)));
2417   if (reloc_cache == NULL && count != 0)
2418     {
2419       bfd_set_error (bfd_error_no_memory);
2420       return false;
2421     }
2422   memset (reloc_cache, 0, count * sizeof (arelent));
2423
2424   relocs = malloc (reloc_size);
2425   if (relocs == NULL && reloc_size != 0)
2426     {
2427       free (reloc_cache);
2428       bfd_set_error (bfd_error_no_memory);
2429       return false;
2430     }
2431
2432   if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size)
2433     {
2434       free (relocs);
2435       free (reloc_cache);
2436       return false;
2437     }
2438
2439   cache_ptr = reloc_cache;
2440   if (each_size == RELOC_EXT_SIZE)
2441     {
2442       register struct reloc_ext_external *rptr =
2443         (struct reloc_ext_external *) relocs;
2444
2445       for (; counter < count; counter++, rptr++, cache_ptr++)
2446         NAME(aout,swap_ext_reloc_in) (abfd, rptr, cache_ptr, symbols);
2447     }
2448   else
2449     {
2450       register struct reloc_std_external *rptr =
2451         (struct reloc_std_external *) relocs;
2452
2453       for (; counter < count; counter++, rptr++, cache_ptr++)
2454         NAME(aout,swap_std_reloc_in) (abfd, rptr, cache_ptr, symbols);
2455     }
2456
2457   free (relocs);
2458
2459   asect->relocation = reloc_cache;
2460   asect->reloc_count = cache_ptr - reloc_cache;
2461
2462   return true;
2463 }
2464
2465 /* Write out a relocation section into an object file.  */
2466
2467 boolean
2468 NAME(aout,squirt_out_relocs) (abfd, section)
2469      bfd *abfd;
2470      asection *section;
2471 {
2472   arelent **generic;
2473   unsigned char *native, *natptr;
2474   size_t each_size;
2475
2476   unsigned int count = section->reloc_count;
2477   size_t natsize;
2478
2479   if (count == 0) return true;
2480
2481   each_size = obj_reloc_entry_size (abfd);
2482   natsize = each_size * count;
2483   native = (unsigned char *) bfd_zalloc (abfd, natsize);
2484   if (!native) {
2485     bfd_set_error (bfd_error_no_memory);
2486     return false;
2487   }
2488
2489   generic = section->orelocation;
2490
2491   if (each_size == RELOC_EXT_SIZE)
2492     {
2493       for (natptr = native;
2494            count != 0;
2495            --count, natptr += each_size, ++generic)
2496         NAME(aout,swap_ext_reloc_out) (abfd, *generic, (struct reloc_ext_external *)natptr);
2497     }
2498   else
2499     {
2500       for (natptr = native;
2501            count != 0;
2502            --count, natptr += each_size, ++generic)
2503         NAME(aout,swap_std_reloc_out)(abfd, *generic, (struct reloc_std_external *)natptr);
2504     }
2505
2506   if ( bfd_write ((PTR) native, 1, natsize, abfd) != natsize) {
2507     bfd_release(abfd, native);
2508     return false;
2509   }
2510   bfd_release (abfd, native);
2511
2512   return true;
2513 }
2514
2515 /* This is stupid.  This function should be a boolean predicate */
2516 long
2517 NAME(aout,canonicalize_reloc) (abfd, section, relptr, symbols)
2518      bfd *abfd;
2519      sec_ptr section;
2520      arelent **relptr;
2521      asymbol **symbols;
2522 {
2523   arelent *tblptr = section->relocation;
2524   unsigned int count;
2525
2526   if (!(tblptr || NAME(aout,slurp_reloc_table)(abfd, section, symbols)))
2527     return -1;
2528
2529   if (section->flags & SEC_CONSTRUCTOR) {
2530     arelent_chain *chain = section->constructor_chain;
2531     for (count = 0; count < section->reloc_count; count ++) {
2532       *relptr ++ = &chain->relent;
2533       chain = chain->next;
2534     }
2535   }
2536   else {
2537     tblptr = section->relocation;
2538
2539     for (count = 0; count++ < section->reloc_count;)
2540       {
2541         *relptr++ = tblptr++;
2542       }
2543   }
2544   *relptr = 0;
2545
2546   return section->reloc_count;
2547 }
2548
2549 long
2550 NAME(aout,get_reloc_upper_bound) (abfd, asect)
2551      bfd *abfd;
2552      sec_ptr asect;
2553 {
2554   if (bfd_get_format (abfd) != bfd_object) {
2555     bfd_set_error (bfd_error_invalid_operation);
2556     return -1;
2557   }
2558   if (asect->flags & SEC_CONSTRUCTOR) {
2559     return (sizeof (arelent *) * (asect->reloc_count+1));
2560   }
2561
2562   if (asect == obj_datasec (abfd))
2563     return (sizeof (arelent *)
2564             * ((exec_hdr(abfd)->a_drsize / obj_reloc_entry_size (abfd))
2565                + 1));
2566
2567   if (asect == obj_textsec (abfd))
2568     return (sizeof (arelent *)
2569             * ((exec_hdr(abfd)->a_trsize / obj_reloc_entry_size (abfd))
2570                + 1));
2571
2572   bfd_set_error (bfd_error_invalid_operation);
2573   return -1;
2574 }
2575
2576 \f
2577 long
2578 NAME(aout,get_symtab_upper_bound) (abfd)
2579      bfd *abfd;
2580 {
2581   if (!NAME(aout,slurp_symbol_table)(abfd))
2582     return -1;
2583
2584   return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *));
2585 }
2586
2587 /*ARGSUSED*/
2588  alent *
2589 NAME(aout,get_lineno) (ignore_abfd, ignore_symbol)
2590      bfd *ignore_abfd;
2591      asymbol *ignore_symbol;
2592 {
2593 return (alent *)NULL;
2594 }
2595
2596 /*ARGSUSED*/
2597 void
2598 NAME(aout,get_symbol_info) (ignore_abfd, symbol, ret)
2599      bfd *ignore_abfd;
2600      asymbol *symbol;
2601      symbol_info *ret;
2602 {
2603   bfd_symbol_info (symbol, ret);
2604
2605   if (ret->type == '?')
2606     {
2607       int type_code = aout_symbol(symbol)->type & 0xff;
2608       CONST char *stab_name = aout_stab_name(type_code);
2609       static char buf[10];
2610
2611       if (stab_name == NULL)
2612         {
2613           sprintf(buf, "(%d)", type_code);
2614           stab_name = buf;
2615         }
2616       ret->type = '-';
2617       ret->stab_other = (unsigned)(aout_symbol(symbol)->other & 0xff);
2618       ret->stab_desc = (unsigned)(aout_symbol(symbol)->desc & 0xffff);
2619       ret->stab_name = stab_name;
2620     }
2621 }
2622
2623 /*ARGSUSED*/
2624 void
2625 NAME(aout,print_symbol) (ignore_abfd, afile, symbol, how)
2626      bfd *ignore_abfd;
2627      PTR afile;
2628      asymbol *symbol;
2629      bfd_print_symbol_type how;
2630 {
2631   FILE *file = (FILE *)afile;
2632
2633   switch (how) {
2634   case bfd_print_symbol_name:
2635     if (symbol->name)
2636       fprintf(file,"%s", symbol->name);
2637     break;
2638   case bfd_print_symbol_more:
2639     fprintf(file,"%4x %2x %2x",(unsigned)(aout_symbol(symbol)->desc & 0xffff),
2640             (unsigned)(aout_symbol(symbol)->other & 0xff),
2641             (unsigned)(aout_symbol(symbol)->type));
2642     break;
2643   case bfd_print_symbol_all:
2644     {
2645    CONST char *section_name = symbol->section->name;
2646
2647
2648       bfd_print_symbol_vandf((PTR)file,symbol);
2649
2650       fprintf(file," %-5s %04x %02x %02x",
2651               section_name,
2652               (unsigned)(aout_symbol(symbol)->desc & 0xffff),
2653               (unsigned)(aout_symbol(symbol)->other & 0xff),
2654               (unsigned)(aout_symbol(symbol)->type  & 0xff));
2655       if (symbol->name)
2656         fprintf(file," %s", symbol->name);
2657     }
2658     break;
2659   }
2660 }
2661
2662 /*
2663  provided a BFD, a section and an offset into the section, calculate
2664  and return the name of the source file and the line nearest to the
2665  wanted location.
2666 */
2667
2668 boolean
2669 NAME(aout,find_nearest_line)
2670      (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2671      bfd *abfd;
2672      asection *section;
2673      asymbol **symbols;
2674      bfd_vma offset;
2675      CONST char **filename_ptr;
2676      CONST char **functionname_ptr;
2677      unsigned int *line_ptr;
2678 {
2679   /* Run down the file looking for the filename, function and linenumber */
2680   asymbol **p;
2681   static  char buffer[100];
2682   static  char filename_buffer[200];
2683   CONST char *directory_name = NULL;
2684   CONST char *main_file_name = NULL;
2685   CONST char *current_file_name = NULL;
2686   CONST char *line_file_name = NULL; /* Value of current_file_name at line number. */
2687   bfd_vma high_line_vma = ~0;
2688   bfd_vma low_func_vma = 0;
2689   asymbol *func = 0;
2690   *filename_ptr = abfd->filename;
2691   *functionname_ptr = 0;
2692   *line_ptr = 0;
2693   if (symbols != (asymbol **)NULL) {
2694     for (p = symbols; *p; p++) {
2695       aout_symbol_type  *q = (aout_symbol_type *)(*p);
2696     next:
2697       switch (q->type){
2698       case N_SO:
2699         main_file_name = current_file_name = q->symbol.name;
2700         /* Look ahead to next symbol to check if that too is an N_SO. */
2701         p++;
2702         if (*p == NULL)
2703           break;
2704         q = (aout_symbol_type *)(*p);
2705         if (q->type != (int)N_SO)
2706           goto next;
2707
2708         /* Found a second N_SO  First is directory; second is filename. */
2709         directory_name = current_file_name;
2710         main_file_name = current_file_name = q->symbol.name;
2711         if (obj_textsec(abfd) != section)
2712           goto done;
2713         break;
2714       case N_SOL:
2715         current_file_name = q->symbol.name;
2716         break;
2717
2718       case N_SLINE:
2719
2720       case N_DSLINE:
2721       case N_BSLINE:
2722         /* We'll keep this if it resolves nearer than the one we have already */
2723         if (q->symbol.value >= offset &&
2724             q->symbol.value < high_line_vma) {
2725           *line_ptr = q->desc;
2726           high_line_vma = q->symbol.value;
2727           line_file_name = current_file_name;
2728         }
2729         break;
2730       case N_FUN:
2731         {
2732           /* We'll keep this if it is nearer than the one we have already */
2733           if (q->symbol.value >= low_func_vma &&
2734               q->symbol.value <= offset) {
2735             low_func_vma = q->symbol.value;
2736             func = (asymbol *)q;
2737           }
2738           if (*line_ptr && func) {
2739             CONST char *function = func->name;
2740             char *p;
2741
2742             /* The caller expects a symbol name.  We actually have a
2743                function name, without the leading underscore.  Put the
2744                underscore back in, so that the caller gets a symbol
2745                name.  */
2746             if (bfd_get_symbol_leading_char (abfd) == '\0')
2747               strncpy (buffer, function, sizeof (buffer) - 1);
2748             else
2749               {
2750                 buffer[0] = bfd_get_symbol_leading_char (abfd);
2751                 strncpy (buffer + 1, function, sizeof (buffer) - 2);
2752               }
2753             buffer[sizeof(buffer)-1] = 0;
2754             /* Have to remove : stuff */
2755             p = strchr(buffer,':');
2756             if (p != NULL) { *p = '\0'; }
2757             *functionname_ptr = buffer;
2758             goto done;
2759
2760           }
2761         }
2762         break;
2763       }
2764     }
2765   }
2766
2767  done:
2768   if (*line_ptr)
2769     main_file_name = line_file_name;
2770   if (main_file_name) {
2771       if (main_file_name[0] == '/' || directory_name == NULL)
2772           *filename_ptr = main_file_name;
2773       else {
2774           sprintf(filename_buffer, "%.140s%.50s",
2775                   directory_name, main_file_name);
2776           *filename_ptr = filename_buffer;
2777       }
2778   }
2779   return true;
2780
2781 }
2782
2783 /*ARGSUSED*/
2784 int
2785 NAME(aout,sizeof_headers) (abfd, execable)
2786      bfd *abfd;
2787      boolean execable;
2788 {
2789   return adata(abfd).exec_bytes_size;
2790 }
2791
2792 /* Free all information we have cached for this BFD.  We can always
2793    read it again later if we need it.  */
2794
2795 boolean
2796 NAME(aout,bfd_free_cached_info) (abfd)
2797      bfd *abfd;
2798 {
2799   asection *o;
2800
2801   if (bfd_get_format (abfd) != bfd_object)
2802     return true;
2803
2804 #define FREE(x) if (x != NULL) { free (x); x = NULL; }
2805   FREE (obj_aout_symbols (abfd));
2806   FREE (obj_aout_external_syms (abfd));
2807   FREE (obj_aout_external_strings (abfd));
2808   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
2809     FREE (o->relocation);
2810 #undef FREE
2811
2812   return true;
2813 }
2814 \f
2815 /* a.out link code.  */
2816
2817 static boolean aout_link_add_object_symbols
2818   PARAMS ((bfd *, struct bfd_link_info *));
2819 static boolean aout_link_check_archive_element
2820   PARAMS ((bfd *, struct bfd_link_info *, boolean *));
2821 static boolean aout_link_free_symbols PARAMS ((bfd *));
2822 static boolean aout_link_check_ar_symbols
2823   PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
2824 static boolean aout_link_add_symbols
2825   PARAMS ((bfd *, struct bfd_link_info *));
2826
2827 /* Routine to create an entry in an a.out link hash table.  */
2828
2829 struct bfd_hash_entry *
2830 NAME(aout,link_hash_newfunc) (entry, table, string)
2831      struct bfd_hash_entry *entry;
2832      struct bfd_hash_table *table;
2833      const char *string;
2834 {
2835   struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2836
2837   /* Allocate the structure if it has not already been allocated by a
2838      subclass.  */
2839   if (ret == (struct aout_link_hash_entry *) NULL)
2840     ret = ((struct aout_link_hash_entry *)
2841            bfd_hash_allocate (table, sizeof (struct aout_link_hash_entry)));
2842   if (ret == (struct aout_link_hash_entry *) NULL)
2843     {
2844       bfd_set_error (bfd_error_no_memory);
2845       return (struct bfd_hash_entry *) ret;
2846     }
2847
2848   /* Call the allocation method of the superclass.  */
2849   ret = ((struct aout_link_hash_entry *)
2850          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2851                                  table, string));
2852   if (ret)
2853     {
2854       /* Set local fields.  */
2855       ret->written = false;
2856       ret->indx = -1;
2857     }
2858
2859   return (struct bfd_hash_entry *) ret;
2860 }
2861
2862 /* Initialize an a.out link hash table.  */
2863
2864 boolean
2865 NAME(aout,link_hash_table_init) (table, abfd, newfunc)
2866      struct aout_link_hash_table *table;
2867      bfd *abfd;
2868      struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
2869                                                 struct bfd_hash_table *,
2870                                                 const char *));
2871 {
2872   return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
2873 }
2874
2875 /* Create an a.out link hash table.  */
2876
2877 struct bfd_link_hash_table *
2878 NAME(aout,link_hash_table_create) (abfd)
2879      bfd *abfd;
2880 {
2881   struct aout_link_hash_table *ret;
2882
2883   ret = ((struct aout_link_hash_table *)
2884          malloc (sizeof (struct aout_link_hash_table)));
2885   if (ret == (struct aout_link_hash_table *) NULL)
2886       {
2887         bfd_set_error (bfd_error_no_memory);
2888         return (struct bfd_link_hash_table *) NULL;
2889       }
2890   if (! NAME(aout,link_hash_table_init) (ret, abfd,
2891                                          NAME(aout,link_hash_newfunc)))
2892     {
2893       free (ret);
2894       return (struct bfd_link_hash_table *) NULL;
2895     }
2896   return &ret->root;
2897 }
2898
2899 /* Given an a.out BFD, add symbols to the global hash table as
2900    appropriate.  */
2901
2902 boolean
2903 NAME(aout,link_add_symbols) (abfd, info)
2904      bfd *abfd;
2905      struct bfd_link_info *info;
2906 {
2907   switch (bfd_get_format (abfd))
2908     {
2909     case bfd_object:
2910       return aout_link_add_object_symbols (abfd, info);
2911     case bfd_archive:
2912       return _bfd_generic_link_add_archive_symbols
2913         (abfd, info, aout_link_check_archive_element);
2914     default:
2915       bfd_set_error (bfd_error_wrong_format);
2916       return false;
2917     }
2918 }
2919
2920 /* Add symbols from an a.out object file.  */
2921
2922 static boolean
2923 aout_link_add_object_symbols (abfd, info)
2924      bfd *abfd;
2925      struct bfd_link_info *info;
2926 {
2927   if (! aout_get_external_symbols (abfd))
2928     return false;
2929   if (! aout_link_add_symbols (abfd, info))
2930     return false;
2931   if (! info->keep_memory)
2932     {
2933       if (! aout_link_free_symbols (abfd))
2934         return false;
2935     }
2936   return true;
2937 }
2938
2939 /* Check a single archive element to see if we need to include it in
2940    the link.  *PNEEDED is set according to whether this element is
2941    needed in the link or not.  This is called from
2942    _bfd_generic_link_add_archive_symbols.  */
2943
2944 static boolean
2945 aout_link_check_archive_element (abfd, info, pneeded)
2946      bfd *abfd;
2947      struct bfd_link_info *info;
2948      boolean *pneeded;
2949 {
2950   if (! aout_get_external_symbols (abfd))
2951     return false;
2952
2953   if (! aout_link_check_ar_symbols (abfd, info, pneeded))
2954     return false;
2955
2956   if (*pneeded)
2957     {
2958       if (! aout_link_add_symbols (abfd, info))
2959         return false;
2960     }
2961
2962   /* We keep around the symbols even if we aren't going to use this
2963      object file, because we may want to reread it.  This doesn't
2964      waste too much memory, because it isn't all that common to read
2965      an archive element but not need it.  */
2966   if (! info->keep_memory)
2967     {
2968       if (! aout_link_free_symbols (abfd))
2969         return false;
2970     }
2971
2972   return true;
2973 }
2974
2975 /* Free up the internal symbols read from an a.out file.  */
2976
2977 static boolean
2978 aout_link_free_symbols (abfd)
2979      bfd *abfd;
2980 {
2981   if (obj_aout_external_syms (abfd) != (struct external_nlist *) NULL)
2982     {
2983       free ((PTR) obj_aout_external_syms (abfd));
2984       obj_aout_external_syms (abfd) = (struct external_nlist *) NULL;
2985     }
2986   if (obj_aout_external_strings (abfd) != (char *) NULL)
2987     {
2988       free ((PTR) obj_aout_external_strings (abfd));
2989       obj_aout_external_strings (abfd) = (char *) NULL;
2990     }
2991   return true;
2992 }
2993
2994 /* Look through the internal symbols to see if this object file should
2995    be included in the link.  We should include this object file if it
2996    defines any symbols which are currently undefined.  If this object
2997    file defines a common symbol, then we may adjust the size of the
2998    known symbol but we do not include the object file in the link
2999    (unless there is some other reason to include it).  */
3000
3001 static boolean
3002 aout_link_check_ar_symbols (abfd, info, pneeded)
3003      bfd *abfd;
3004      struct bfd_link_info *info;
3005      boolean *pneeded;
3006 {
3007   register struct external_nlist *p;
3008   struct external_nlist *pend;
3009   char *strings;
3010
3011   *pneeded = false;
3012
3013   /* Look through all the symbols.  */
3014   p = obj_aout_external_syms (abfd);
3015   pend = p + obj_aout_external_sym_count (abfd);
3016   strings = obj_aout_external_strings (abfd);
3017   for (; p < pend; p++)
3018     {
3019       int type = bfd_h_get_8 (abfd, p->e_type);
3020       const char *name;
3021       struct bfd_link_hash_entry *h;
3022
3023       /* Ignore symbols that are not externally visible.  */
3024       if ((type & N_EXT) == 0)
3025         {
3026           if (type == N_WARNING
3027               || type == N_INDR)
3028             ++p;
3029           continue;
3030         }
3031
3032       name = strings + GET_WORD (abfd, p->e_strx);
3033       h = bfd_link_hash_lookup (info->hash, name, false, false, true);
3034
3035       /* We are only interested in symbols that are currently
3036          undefined or common.  */
3037       if (h == (struct bfd_link_hash_entry *) NULL
3038           || (h->type != bfd_link_hash_undefined
3039               && h->type != bfd_link_hash_common))
3040         {
3041           if (type == (N_INDR | N_EXT))
3042             ++p;
3043           continue;
3044         }
3045
3046       if (type == (N_TEXT | N_EXT)
3047           || type == (N_DATA | N_EXT)
3048           || type == (N_BSS | N_EXT)
3049           || type == (N_ABS | N_EXT)
3050           || type == (N_INDR | N_EXT))
3051         {
3052           /* This object file defines this symbol.  We must link it
3053              in.  This is true regardless of whether the current
3054              definition of the symbol is undefined or common.  If the
3055              current definition is common, we have a case in which we
3056              have already seen an object file including
3057                  int a;
3058              and this object file from the archive includes
3059                  int a = 5;
3060              In such a case we must include this object file.  */
3061           if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3062             return false;
3063           *pneeded = true;
3064           return true;
3065         }
3066
3067       if (type == (N_UNDF | N_EXT))
3068         {
3069           bfd_vma value;
3070
3071           value = GET_WORD (abfd, p->e_value);
3072           if (value != 0)
3073             {
3074               /* This symbol is common in the object from the archive
3075                  file.  */
3076               if (h->type == bfd_link_hash_undefined)
3077                 {
3078                   bfd *symbfd;
3079
3080                   symbfd = h->u.undef.abfd;
3081                   if (symbfd == (bfd *) NULL)
3082                     {
3083                       /* This symbol was created as undefined from
3084                          outside BFD.  We assume that we should link
3085                          in the object file.  This is done for the -u
3086                          option in the linker.  */
3087                       if (! (*info->callbacks->add_archive_element) (info,
3088                                                                      abfd,
3089                                                                      name))
3090                         return false;
3091                       *pneeded = true;
3092                       return true;
3093                     }
3094                   /* Turn the current link symbol into a common
3095                      symbol.  It is already on the undefs list.  */
3096                   h->type = bfd_link_hash_common;
3097                   h->u.c.size = value;
3098                   h->u.c.section = bfd_make_section_old_way (symbfd,
3099                                                              "COMMON");
3100                 }
3101               else
3102                 {
3103                   /* Adjust the size of the common symbol if
3104                      necessary.  */
3105                   if (value > h->u.c.size)
3106                     h->u.c.size = value;
3107                 }
3108             }
3109         }
3110     }
3111
3112   /* We do not need this object file.  */
3113   return true;
3114 }
3115
3116 /* Add all symbols from an object file to the hash table.  */
3117
3118 static boolean
3119 aout_link_add_symbols (abfd, info)
3120      bfd *abfd;
3121      struct bfd_link_info *info;
3122 {
3123   boolean (*add_one_symbol) PARAMS ((struct bfd_link_info *, bfd *,
3124                                      const char *, flagword, asection *,
3125                                      bfd_vma, const char *, boolean,
3126                                      boolean,
3127                                      struct bfd_link_hash_entry **));
3128   bfd_size_type sym_count;
3129   char *strings;
3130   boolean copy;
3131   struct aout_link_hash_entry **sym_hash;
3132   register struct external_nlist *p;
3133   struct external_nlist *pend;
3134
3135   sym_count = obj_aout_external_sym_count (abfd);
3136   strings = obj_aout_external_strings (abfd);
3137   if (info->keep_memory)
3138     copy = false;
3139   else
3140     copy = true;
3141
3142   /* We keep a list of the linker hash table entries that correspond
3143      to particular symbols.  We could just look them up in the hash
3144      table, but keeping the list is more efficient.  Perhaps this
3145      should be conditional on info->keep_memory.  */
3146   sym_hash = ((struct aout_link_hash_entry **)
3147               bfd_alloc (abfd,
3148                          ((size_t) sym_count
3149                           * sizeof (struct aout_link_hash_entry *))));
3150   if (sym_hash == NULL && sym_count != 0)
3151     {
3152       bfd_set_error (bfd_error_no_memory);
3153       return false;
3154     }
3155   obj_aout_sym_hashes (abfd) = sym_hash;
3156
3157   if ((abfd->flags & DYNAMIC) != 0
3158       && aout_backend_info (abfd)->add_dynamic_symbols != NULL)
3159     {
3160       if (! (*aout_backend_info (abfd)->add_dynamic_symbols) (abfd, info))
3161         return false;
3162     }
3163
3164   add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
3165   if (add_one_symbol == NULL)
3166     add_one_symbol = _bfd_generic_link_add_one_symbol;
3167
3168   p = obj_aout_external_syms (abfd);
3169   pend = p + sym_count;
3170   for (; p < pend; p++, sym_hash++)
3171     {
3172       int type;
3173       const char *name;
3174       bfd_vma value;
3175       asection *section;
3176       flagword flags;
3177       const char *string;
3178
3179       *sym_hash = NULL;
3180
3181       type = bfd_h_get_8 (abfd, p->e_type);
3182
3183       /* Ignore debugging symbols.  */
3184       if ((type & N_STAB) != 0)
3185         continue;
3186
3187       /* Ignore symbols that are not external.  */
3188       if ((type & N_EXT) == 0
3189           && type != N_WARNING
3190           && type != N_SETA
3191           && type != N_SETT
3192           && type != N_SETD
3193           && type != N_SETB)
3194         {
3195           /* If this is an N_INDR symbol we must skip the next entry,
3196              which is the symbol to indirect to (actually, an N_INDR
3197              symbol without N_EXT set is pretty useless).  */
3198           if (type == N_INDR)
3199             {
3200               ++p;
3201               ++sym_hash;
3202             }
3203           continue;
3204         }
3205
3206       /* Ignore N_FN symbols (these appear to have N_EXT set).  */
3207       if (type == N_FN)
3208         continue;
3209
3210       name = strings + GET_WORD (abfd, p->e_strx);
3211       value = GET_WORD (abfd, p->e_value);
3212       flags = BSF_GLOBAL;
3213       string = NULL;
3214       switch (type)
3215         {
3216         default:
3217           abort ();
3218         case N_UNDF | N_EXT:
3219           if (value != 0)
3220             section = &bfd_com_section;
3221           else
3222             section = &bfd_und_section;
3223           break;
3224         case N_ABS | N_EXT:
3225           section = &bfd_abs_section;
3226           break;
3227         case N_TEXT | N_EXT:
3228           section = obj_textsec (abfd);
3229           value -= bfd_get_section_vma (abfd, section);
3230           break;
3231         case N_DATA | N_EXT:
3232           section = obj_datasec (abfd);
3233           value -= bfd_get_section_vma (abfd, section);
3234           break;
3235         case N_BSS | N_EXT:
3236           section = obj_bsssec (abfd);
3237           value -= bfd_get_section_vma (abfd, section);
3238           break;
3239         case N_INDR | N_EXT:
3240           /* An indirect symbol.  The next symbol is the symbol
3241              which this one really is.  */
3242           BFD_ASSERT (p + 1 < pend);
3243           ++p;
3244           string = strings + GET_WORD (abfd, p->e_strx);
3245           section = &bfd_ind_section;
3246           flags |= BSF_INDIRECT;
3247           break;
3248         case N_COMM | N_EXT:
3249           section = &bfd_com_section;
3250           break;
3251         case N_SETA: case N_SETA | N_EXT:
3252           section = &bfd_abs_section;
3253           flags |= BSF_CONSTRUCTOR;
3254           break;
3255         case N_SETT: case N_SETT | N_EXT:
3256           section = obj_textsec (abfd);
3257           flags |= BSF_CONSTRUCTOR;
3258           value -= bfd_get_section_vma (abfd, section);
3259           break;
3260         case N_SETD: case N_SETD | N_EXT:
3261           section = obj_datasec (abfd);
3262           flags |= BSF_CONSTRUCTOR;
3263           value -= bfd_get_section_vma (abfd, section);
3264           break;
3265         case N_SETB: case N_SETB | N_EXT:
3266           section = obj_bsssec (abfd);
3267           flags |= BSF_CONSTRUCTOR;
3268           value -= bfd_get_section_vma (abfd, section);
3269           break;
3270         case N_WARNING:
3271           /* A warning symbol.  The next symbol is the one to warn
3272              about.  */
3273           BFD_ASSERT (p + 1 < pend);
3274           ++p;
3275           string = name;
3276           name = strings + GET_WORD (abfd, p->e_strx);
3277           section = &bfd_und_section;
3278           flags |= BSF_WARNING;
3279           break;
3280         }
3281
3282       if (! ((*add_one_symbol)
3283              (info, abfd, name, flags, section, value, string, copy, false,
3284               (struct bfd_link_hash_entry **) sym_hash)))
3285         return false;
3286
3287       if (type == (N_INDR | N_EXT) || type == N_WARNING)
3288         ++sym_hash;
3289     }
3290
3291   return true;
3292 }
3293
3294 /* During the final link step we need to pass around a bunch of
3295    information, so we do it in an instance of this structure.  */
3296
3297 struct aout_final_link_info
3298 {
3299   /* General link information.  */
3300   struct bfd_link_info *info;
3301   /* Output bfd.  */
3302   bfd *output_bfd;
3303   /* Reloc file positions.  */
3304   file_ptr treloff, dreloff;
3305   /* File position of symbols.  */
3306   file_ptr symoff;
3307   /* String table.  */
3308   struct stringtab_data strtab;
3309 };
3310
3311 static boolean aout_link_input_bfd
3312   PARAMS ((struct aout_final_link_info *, bfd *input_bfd));
3313 static boolean aout_link_write_symbols
3314   PARAMS ((struct aout_final_link_info *, bfd *input_bfd, int *symbol_map));
3315 static boolean aout_link_write_other_symbol
3316   PARAMS ((struct aout_link_hash_entry *, PTR));
3317 static boolean aout_link_input_section
3318   PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
3319            asection *input_section, file_ptr *reloff_ptr,
3320            bfd_size_type rel_size, int *symbol_map));
3321 static boolean aout_link_input_section_std
3322   PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
3323            asection *input_section, struct reloc_std_external *,
3324            bfd_size_type rel_size, bfd_byte *contents, int *symbol_map));
3325 static boolean aout_link_input_section_ext
3326   PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
3327            asection *input_section, struct reloc_ext_external *,
3328            bfd_size_type rel_size, bfd_byte *contents, int *symbol_map));
3329 static INLINE asection *aout_reloc_index_to_section
3330   PARAMS ((bfd *, int));
3331 static boolean aout_link_reloc_link_order
3332   PARAMS ((struct aout_final_link_info *, asection *,
3333            struct bfd_link_order *));
3334
3335 /* Do the final link step.  This is called on the output BFD.  The
3336    INFO structure should point to a list of BFDs linked through the
3337    link_next field which can be used to find each BFD which takes part
3338    in the output.  Also, each section in ABFD should point to a list
3339    of bfd_link_order structures which list all the input sections for
3340    the output section.  */
3341
3342 boolean
3343 NAME(aout,final_link) (abfd, info, callback)
3344      bfd *abfd;
3345      struct bfd_link_info *info;
3346      void (*callback) PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *));
3347 {
3348   struct aout_final_link_info aout_info;
3349   register bfd *sub;
3350   bfd_size_type text_size;
3351   file_ptr text_end;
3352   register struct bfd_link_order *p;
3353   asection *o;
3354   boolean have_link_order_relocs;
3355
3356   aout_info.info = info;
3357   aout_info.output_bfd = abfd;
3358
3359   if (! info->relocateable)
3360     {
3361       exec_hdr (abfd)->a_trsize = 0;
3362       exec_hdr (abfd)->a_drsize = 0;
3363     }
3364   else
3365     {
3366       bfd_size_type trsize, drsize;
3367
3368       /* Count up the relocation sizes.  */
3369       trsize = 0;
3370       drsize = 0;
3371       for (sub = info->input_bfds; sub != (bfd *) NULL; sub = sub->link_next)
3372         {
3373           if (bfd_get_flavour (abfd) == bfd_target_aout_flavour)
3374             {
3375               trsize += exec_hdr (sub)->a_trsize;
3376               drsize += exec_hdr (sub)->a_drsize;
3377             }
3378           else
3379             {
3380               /* FIXME: We need to identify the .text and .data sections
3381                  and call get_reloc_upper_bound and canonicalize_reloc to
3382                  work out the number of relocs needed, and then multiply
3383                  by the reloc size.  */
3384               abort ();
3385             }
3386         }
3387       if (obj_textsec (abfd) != (asection *) NULL)
3388         trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
3389                                                  ->link_order_head)
3390                    * obj_reloc_entry_size (abfd));
3391       exec_hdr (abfd)->a_trsize = trsize;
3392       if (obj_datasec (abfd) != (asection *) NULL)
3393         drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
3394                                                  ->link_order_head)
3395                    * obj_reloc_entry_size (abfd));
3396       exec_hdr (abfd)->a_drsize = drsize;
3397     }
3398
3399   exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
3400
3401   /* Adjust the section sizes and vmas according to the magic number.
3402      This sets a_text, a_data and a_bss in the exec_hdr and sets the
3403      filepos for each section.  */
3404   if (! NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
3405     return false;
3406
3407   /* The relocation and symbol file positions differ among a.out
3408      targets.  We are passed a callback routine from the backend
3409      specific code to handle this.
3410      FIXME: At this point we do not know how much space the symbol
3411      table will require.  This will not work for any (nonstandard)
3412      a.out target that needs to know the symbol table size before it
3413      can compute the relocation file positions.  This may or may not
3414      be the case for the hp300hpux target, for example.  */
3415   (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
3416                &aout_info.symoff);
3417   obj_textsec (abfd)->rel_filepos = aout_info.treloff;
3418   obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
3419   obj_sym_filepos (abfd) = aout_info.symoff;
3420
3421   /* We keep a count of the symbols as we output them.  */
3422   obj_aout_external_sym_count (abfd) = 0;
3423
3424   /* We accumulate the string table as we write out the symbols.  */
3425   stringtab_init (&aout_info.strtab);
3426
3427   /* The most time efficient way to do the link would be to read all
3428      the input object files into memory and then sort out the
3429      information into the output file.  Unfortunately, that will
3430      probably use too much memory.  Another method would be to step
3431      through everything that composes the text section and write it
3432      out, and then everything that composes the data section and write
3433      it out, and then write out the relocs, and then write out the
3434      symbols.  Unfortunately, that requires reading stuff from each
3435      input file several times, and we will not be able to keep all the
3436      input files open simultaneously, and reopening them will be slow.
3437
3438      What we do is basically process one input file at a time.  We do
3439      everything we need to do with an input file once--copy over the
3440      section contents, handle the relocation information, and write
3441      out the symbols--and then we throw away the information we read
3442      from it.  This approach requires a lot of lseeks of the output
3443      file, which is unfortunate but still faster than reopening a lot
3444      of files.
3445
3446      We use the output_has_begun field of the input BFDs to see
3447      whether we have already handled it.  */
3448   for (sub = info->input_bfds; sub != (bfd *) NULL; sub = sub->link_next)
3449     sub->output_has_begun = false;
3450
3451   have_link_order_relocs = false;
3452   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3453     {
3454       for (p = o->link_order_head;
3455            p != (struct bfd_link_order *) NULL;
3456            p = p->next)
3457         {
3458           if (p->type == bfd_indirect_link_order
3459               && (bfd_get_flavour (p->u.indirect.section->owner)
3460                   == bfd_target_aout_flavour))
3461             {
3462               bfd *input_bfd;
3463
3464               input_bfd = p->u.indirect.section->owner;
3465               if (! input_bfd->output_has_begun)
3466                 {
3467                   if (! aout_link_input_bfd (&aout_info, input_bfd))
3468                     return false;
3469                   input_bfd->output_has_begun = true;
3470                 }
3471             }
3472           else if (p->type == bfd_section_reloc_link_order
3473                    || p->type == bfd_symbol_reloc_link_order)
3474             {
3475               /* These are handled below.  */
3476               have_link_order_relocs = true;
3477             }
3478           else
3479             {
3480               if (! _bfd_default_link_order (abfd, info, o, p))
3481                 return false;
3482             }
3483         }
3484     }
3485
3486   /* Write out any symbols that we have not already written out.  */
3487   aout_link_hash_traverse (aout_hash_table (info),
3488                            aout_link_write_other_symbol,
3489                            (PTR) &aout_info);
3490
3491   /* Now handle any relocs we were asked to create by the linker.
3492      These did not come from any input file.  We must do these after
3493      we have written out all the symbols, so that we know the symbol
3494      indices to use.  */
3495   if (have_link_order_relocs)
3496     {
3497       for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3498         {
3499           for (p = o->link_order_head;
3500                p != (struct bfd_link_order *) NULL;
3501                p = p->next)
3502             {
3503               if (p->type == bfd_section_reloc_link_order
3504                   || p->type == bfd_symbol_reloc_link_order)
3505                 {
3506                   if (! aout_link_reloc_link_order (&aout_info, o, p))
3507                     return false;
3508                 }
3509             }
3510         }
3511     }
3512
3513   /* Finish up any dynamic linking we may be doing.  */
3514   if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
3515     {
3516       if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
3517         return false;
3518     }
3519
3520   /* Update the header information.  */
3521   abfd->symcount = obj_aout_external_sym_count (abfd);
3522   exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
3523   obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
3524   obj_textsec (abfd)->reloc_count =
3525     exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
3526   obj_datasec (abfd)->reloc_count =
3527     exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
3528
3529   /* Write out the string table.  */
3530   if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0)
3531     return false;
3532   return emit_strtab (abfd, &aout_info.strtab);
3533 }
3534
3535 /* Link an a.out input BFD into the output file.  */
3536
3537 static boolean
3538 aout_link_input_bfd (finfo, input_bfd)
3539      struct aout_final_link_info *finfo;
3540      bfd *input_bfd;
3541 {
3542   bfd_size_type sym_count;
3543   int *symbol_map = NULL;
3544
3545   BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
3546
3547   /* If this is a dynamic object, it may need special handling.  */
3548   if ((input_bfd->flags & DYNAMIC) != 0
3549       && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
3550     {
3551       return ((*aout_backend_info (input_bfd)->link_dynamic_object)
3552               (finfo->info, input_bfd));
3553     }
3554
3555   /* Get the symbols.  We probably have them already, unless
3556      finfo->info->keep_memory is false.  */
3557   if (! aout_get_external_symbols (input_bfd))
3558     return false;
3559
3560   sym_count = obj_aout_external_sym_count (input_bfd);
3561   symbol_map = (int *) malloc ((size_t) sym_count * sizeof (int));
3562   if (symbol_map == NULL && sym_count != 0)
3563     {
3564       bfd_set_error (bfd_error_no_memory);
3565       return false;
3566     }
3567
3568   /* Write out the symbols and get a map of the new indices.  */
3569   if (! aout_link_write_symbols (finfo, input_bfd, symbol_map))
3570     goto error_return;
3571
3572   /* Relocate and write out the sections.  */
3573   if (! aout_link_input_section (finfo, input_bfd,
3574                                  obj_textsec (input_bfd),
3575                                  &finfo->treloff,
3576                                  exec_hdr (input_bfd)->a_trsize,
3577                                  symbol_map)
3578       || ! aout_link_input_section (finfo, input_bfd,
3579                                     obj_datasec (input_bfd),
3580                                     &finfo->dreloff,
3581                                     exec_hdr (input_bfd)->a_drsize,
3582                                     symbol_map))
3583     goto error_return;
3584
3585   /* If we are not keeping memory, we don't need the symbols any
3586      longer.  We still need them if we are keeping memory, because the
3587      strings in the hash table point into them.  */
3588   if (! finfo->info->keep_memory)
3589     {
3590       if (! aout_link_free_symbols (input_bfd))
3591         goto error_return;
3592     }
3593
3594   if (symbol_map != NULL)
3595     free (symbol_map);
3596   return true;
3597  error_return:
3598   if (symbol_map != NULL)
3599     free (symbol_map);
3600   return false;
3601 }
3602
3603 /* Adjust and write out the symbols for an a.out file.  Set the new
3604    symbol indices into a symbol_map.  */
3605
3606 static boolean
3607 aout_link_write_symbols (finfo, input_bfd, symbol_map)
3608      struct aout_final_link_info *finfo;
3609      bfd *input_bfd;
3610      int *symbol_map;
3611 {
3612   bfd *output_bfd;
3613   bfd_size_type sym_count;
3614   char *strings;
3615   enum bfd_link_strip strip;
3616   enum bfd_link_discard discard;
3617   struct external_nlist *output_syms = NULL;
3618   struct external_nlist *outsym;
3619   register struct external_nlist *sym;
3620   struct external_nlist *sym_end;
3621   struct aout_link_hash_entry **sym_hash;
3622   boolean pass;
3623   boolean skip_indirect;
3624
3625   output_bfd = finfo->output_bfd;
3626   sym_count = obj_aout_external_sym_count (input_bfd);
3627   strings = obj_aout_external_strings (input_bfd);
3628   strip = finfo->info->strip;
3629   discard = finfo->info->discard;
3630   output_syms = ((struct external_nlist *)
3631                  malloc ((size_t) (sym_count + 1) * EXTERNAL_NLIST_SIZE));
3632   if (output_syms == NULL)
3633     {
3634       bfd_set_error (bfd_error_no_memory);
3635       goto error_return;
3636     }
3637   outsym = output_syms;
3638
3639   /* First write out a symbol for this object file, unless we are
3640      discarding such symbols.  */
3641   if (strip != strip_all
3642       && (strip != strip_some
3643           || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
3644                               false, false) != NULL)
3645       && discard != discard_all)
3646     {
3647       bfd_h_put_8 (output_bfd, N_TEXT, outsym->e_type);
3648       bfd_h_put_8 (output_bfd, 0, outsym->e_other);
3649       bfd_h_put_16 (output_bfd, (bfd_vma) 0, outsym->e_desc);
3650       PUT_WORD (output_bfd,
3651                 add_to_stringtab (output_bfd, input_bfd->filename,
3652                                   &finfo->strtab),
3653                 outsym->e_strx);
3654       PUT_WORD (output_bfd,
3655                 (bfd_get_section_vma (output_bfd,
3656                                       obj_textsec (input_bfd)->output_section)
3657                  + obj_textsec (input_bfd)->output_offset),
3658                 outsym->e_value);
3659       ++obj_aout_external_sym_count (output_bfd);
3660       ++outsym;
3661     }
3662
3663   pass = false;
3664   skip_indirect = false;
3665   sym = obj_aout_external_syms (input_bfd);
3666   sym_end = sym + sym_count;
3667   sym_hash = obj_aout_sym_hashes (input_bfd);
3668   for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
3669     {
3670       const char *name;
3671       int type;
3672       struct aout_link_hash_entry *h;
3673       boolean skip;
3674       asection *symsec;
3675       bfd_vma val = 0;
3676
3677       *symbol_map = -1;
3678
3679       type = bfd_h_get_8 (input_bfd, sym->e_type);
3680       name = strings + GET_WORD (input_bfd, sym->e_strx);
3681
3682       h = NULL;
3683
3684       if (pass)
3685         {
3686           /* Pass this symbol through.  It is the target of an
3687              indirect or warning symbol.  */
3688           val = GET_WORD (input_bfd, sym->e_value);
3689           pass = false;
3690         }
3691       else if (skip_indirect)
3692         {
3693           /* Skip this symbol, which is the target of an indirect
3694              symbol that we have changed to no longer be an indirect
3695              symbol.  */
3696           skip_indirect = false;
3697           continue;
3698         }
3699       else
3700         {
3701           struct aout_link_hash_entry *hresolve;
3702
3703           /* We have saved the hash table entry for this symbol, if
3704              there is one.  Note that we could just look it up again
3705              in the hash table, provided we first check that it is an
3706              external symbol. */
3707           h = *sym_hash;
3708
3709           /* If this is an indirect or warning symbol, then change
3710              hresolve to the base symbol.  We also change *sym_hash so
3711              that the relocation routines relocate against the real
3712              symbol.  */
3713           hresolve = h;
3714           if (h != (struct aout_link_hash_entry *) NULL
3715               && (h->root.type == bfd_link_hash_indirect
3716                   || h->root.type == bfd_link_hash_warning))
3717             {
3718               hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
3719               while (hresolve->root.type == bfd_link_hash_indirect
3720                      || hresolve->root.type == bfd_link_hash_warning)
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->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->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->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->written)
3969     return true;
3970
3971   h->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 }