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