bfd/aoutx.h

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