bfd/aoutx.h

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