bfd/aoutx.h

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