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