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