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