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