daily update
[binutils.git] / bfd / pdp11.c
bloba4af824e4598ba0f29d5269f892de775cc8ba52f
1 /* BFD back-end for PDP-11 a.out binaries.
2 Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
20 /* BFD backend for PDP-11, running 2.11BSD in particular.
22 This file was hacked up by looking hard at the existing vaxnetbsd
23 back end and the header files in 2.11BSD.
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)
31 Search for TODO to find other areas needing more work. */
33 #define BYTES_IN_WORD 2
34 #define BYTES_IN_LONG 4
35 #define ARCH_SIZE 16
36 #undef TARGET_IS_BIG_ENDIAN_P
38 #define TARGET_PAGE_SIZE 1024
39 #define SEGMENT__SIZE TARGET_PAGE_SIZE
41 #define DEFAULT_ARCH bfd_arch_pdp11
42 #define DEFAULT_MID M_PDP11
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)
49 /* This needs to start with a.out so GDB knows it is an a.out variant. */
50 #define TARGETNAME "a.out-pdp11"
52 /* This is the normal load address for executables. */
53 #define TEXT_START_ADDR 0
55 /* The header is not included in the text segment. */
56 #define N_HEADER_IN_TEXT(x) 0
58 /* There are no shared libraries. */
59 #define N_SHARED_LIB(x) 0
61 /* There is no flags field. */
62 #define N_FLAGS(exec) 0
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))
72 #include "bfd.h"
74 #define external_exec pdp11_external_exec
75 struct pdp11_external_exec
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 */
88 #define EXEC_BYTES_SIZE (8 * 2)
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
102 #define A_FLAG_RELOC_STRIPPED 0x0001
104 #define external_nlist pdp11_external_nlist
105 struct pdp11_external_nlist
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 */
114 #define EXTERNAL_NLIST_SIZE 8
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)
123 #define WRITE_HEADERS(abfd, execp) pdp11_aout_write_headers (abfd, execp)
125 #include "sysdep.h"
126 #include "libbfd.h"
127 #include "libaout.h"
129 #define SWAP_MAGIC(ext) bfd_getl16 (ext)
131 #define MY_entry_is_text_address 1
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
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 *));
141 #define MY_BFD_TARGET
143 #include "aout-target.h"
145 const bfd_target MY(vec) =
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},
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),
181 /* Alternative_target */
182 NULL,
184 (PTR) MY_backend_data,
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.
193 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
210 SECTION
211 a.out backends
214 DESCRIPTION
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.
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.
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.
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.
239 As an example, this is what goes on to make the back end for a
240 sun4, from @file{aout32.c}:
242 | #define ARCH_SIZE 32
243 | #include "aoutx.h"
245 Which exports names:
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 | ...
254 from @file{sunos.c}:
256 | #define TARGET_NAME "a.out-sunos-big"
257 | #define VECNAME sunos_big_vec
258 | #include "aoutf1.h"
260 requires all the names from @file{aout32.c}, and produces the jump vector
262 | sunos_big_vec
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.
274 When porting it to run on a new system, you must supply:
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
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:
289 | TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec
290 | TDEPFILES= host-aout.o trad-core.o
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.
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.) */
308 #define KEEPIT udata.i
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"
316 #include "libaout.h"
317 /*#include "libbfd.h"*/
318 #include "aout/aout64.h"
319 #include "aout/stab_gnu.h"
320 #include "aout/ar.h"
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 */
340 #define N_EXT 0x20 /* external flag */
342 #define RELOC_SIZE 2
344 struct pdp11_aout_reloc_external
346 bfd_byte e_reloc_entry[2];
349 #define RELFLG 0x0001 /* pc-relative flag */
350 #define RTYPE 0x000e /* type mask */
351 #define RIDXMASK 0xfff0 /* index mask */
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 */
359 #define RINDEX(x) (((x) & 0xfff0) >> 4)
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 *));
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));
377 SUBSECTION
378 Relocations
380 DESCRIPTION
381 The file @file{aoutx.h} provides for both the @emph{standard}
382 and @emph{extended} forms of a.out relocation records.
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.
391 #ifndef MY_final_link_relocate
392 #define MY_final_link_relocate _bfd_final_link_relocate
393 #endif
395 #ifndef MY_relocate_contents
396 #define MY_relocate_contents _bfd_relocate_contents
397 #endif
399 reloc_howto_type howto_table_pdp11[] =
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),
406 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
408 reloc_howto_type *
409 NAME(aout,reloc_type_lookup) (abfd,code)
410 bfd * abfd ATTRIBUTE_UNUSED;
411 bfd_reloc_code_real_type code;
413 switch (code)
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;
424 static int
425 pdp11_aout_write_headers (abfd, execp)
426 bfd *abfd;
427 struct internal_exec *execp;
429 struct external_exec exec_bytes;
430 bfd_size_type text_size;
431 file_ptr text_end;
433 if (adata(abfd).magic == undecided_magic)
434 NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
436 execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE;
437 execp->a_entry = bfd_get_start_address (abfd);
439 if (obj_textsec (abfd)->reloc_count > 0 ||
440 obj_datasec (abfd)->reloc_count > 0)
442 execp->a_trsize = execp->a_text;
443 execp->a_drsize = execp->a_data;
445 else
447 execp->a_trsize = 0;
448 execp->a_drsize = 0;
451 NAME(aout,swap_exec_header_out) (abfd, execp, &exec_bytes);
453 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
454 return FALSE;
456 if (bfd_bwrite ((PTR) &exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd)
457 != EXEC_BYTES_SIZE)
458 return FALSE;
460 /* Now write out reloc info, followed by syms and strings */
462 if (bfd_get_outsymbols (abfd) != (asymbol **) NULL
463 && bfd_get_symcount (abfd) != 0)
465 if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*execp)), SEEK_SET) != 0)
466 return FALSE;
468 if (! NAME(aout,write_syms) (abfd))
469 return FALSE;
472 if (obj_textsec (abfd)->reloc_count > 0 ||
473 obj_datasec (abfd)->reloc_count > 0)
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;
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;
486 return TRUE;
489 /* Write an object file.
490 Section contents have already been written. We write the
491 file header, symbols, and relocation. */
493 static bfd_boolean
494 MY(write_object_contents) (abfd)
495 bfd *abfd;
497 struct internal_exec *execp = exec_hdr (abfd);
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)
504 bfd_size_type text_size;
505 file_ptr text_end;
507 NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
510 obj_reloc_entry_size (abfd) = RELOC_SIZE;
512 return WRITE_HEADERS(abfd, execp);
516 SUBSECTION
517 Internal entry points
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).
527 FUNCTION
528 aout_@var{size}_swap_exec_header_in
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);
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}.
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;
549 struct external_exec *bytes = (struct external_exec *)raw_bytes;
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);
564 if (GET_WORD (abfd, bytes->e_flag) & A_FLAG_RELOC_STRIPPED)
566 execp->a_trsize = 0;
567 execp->a_drsize = 0;
569 else
571 execp->a_trsize = execp->a_text;
572 execp->a_drsize = execp->a_data;
575 #define NAME_swap_exec_header_in NAME(aout,swap_exec_header_in)
576 #endif
579 FUNCTION
580 aout_@var{size}_swap_exec_header_out
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);
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.
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;
598 struct external_exec *bytes = (struct external_exec *)raw_bytes;
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);
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
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);
623 /* Make all the section for an a.out file. */
625 bfd_boolean
626 NAME(aout,make_sections) (abfd)
627 bfd *abfd;
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;
642 FUNCTION
643 aout_@var{size}_some_aout_object_p
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)());
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.
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 *));
664 struct aout_data_struct *rawptr, *oldrawptr;
665 const bfd_target *result;
666 bfd_size_type amt = sizeof (struct aout_data_struct);
668 rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, amt);
669 if (rawptr == NULL)
670 return 0;
672 oldrawptr = abfd->tdata.aout_data;
673 abfd->tdata.aout_data = rawptr;
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;
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;
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;
696 if (N_MAGIC (*execp) == ZMAGIC)
698 abfd->flags |= D_PAGED | WP_TEXT;
699 adata (abfd).magic = z_magic;
701 else if (N_MAGIC (*execp) == QMAGIC)
703 abfd->flags |= D_PAGED | WP_TEXT;
704 adata (abfd).magic = z_magic;
705 adata (abfd).subformat = q_magic_format;
707 else if (N_MAGIC (*execp) == NMAGIC)
709 abfd->flags |= WP_TEXT;
710 adata (abfd).magic = n_magic;
712 else if (N_MAGIC (*execp) == OMAGIC
713 || N_MAGIC (*execp) == BMAGIC)
714 adata (abfd).magic = o_magic;
715 else
717 /* Should have been checked with N_BADMAG before this routine
718 was called. */
719 abort ();
722 bfd_get_start_address (abfd) = execp->a_entry;
724 obj_aout_symbols (abfd) = (aout_symbol_type *)NULL;
725 bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist);
727 /* The default relocation entry size is that of traditional V7 Unix. */
728 obj_reloc_entry_size (abfd) = RELOC_SIZE;
730 /* The default symbol entry size is that of traditional Unix. */
731 obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;
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;
741 if (! NAME(aout,make_sections) (abfd))
742 return NULL;
744 obj_datasec (abfd)->_raw_size = execp->a_data;
745 obj_bsssec (abfd)->_raw_size = execp->a_bss;
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;
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. */
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: */
768 struct exec *execp = exec_hdr (abfd);
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 */
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);
779 /* The file offsets of the sections */
780 obj_textsec (abfd)->filepos = N_TXTOFF(*execp);
781 obj_datasec (abfd)->filepos = N_DATOFF(*execp);
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);
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);
791 /* Determine the architecture and machine type of the object file. */
792 abfd->obj_arch = bfd_arch_obscure;
794 adata(abfd)->page_size = TARGET_PAGE_SIZE;
795 adata(abfd)->segment_size = SEGMENT_SIZE;
796 adata(abfd)->exec_bytes_size = EXEC_BYTES_SIZE;
798 return abfd->xvec;
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.
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 */
810 result = (*callback_to_real_object_p)(abfd);
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.).
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.
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. */
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
834 struct stat stat_buf;
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;
849 #endif /* STAT_FOR_EXEC */
851 if (result)
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
859 else
861 free (rawptr);
862 abfd->tdata.aout_data = oldrawptr;
864 return result;
868 FUNCTION
869 aout_@var{size}_mkobject
871 SYNOPSIS
872 bfd_boolean aout_@var{size}_mkobject, (bfd *abfd);
874 DESCRIPTION
875 Initialize BFD @var{abfd} for use with a.out files.
878 bfd_boolean
879 NAME(aout,mkobject) (abfd)
880 bfd *abfd;
882 struct aout_data_struct *rawptr;
883 bfd_size_type amt = sizeof (struct aout_data_struct);
885 bfd_set_error (bfd_error_system_call);
887 /* Use an intermediate variable for clarity */
888 rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, amt);
890 if (rawptr == NULL)
891 return FALSE;
893 abfd->tdata.aout_data = rawptr;
894 exec_hdr (abfd) = &(rawptr->e);
896 obj_textsec (abfd) = (asection *)NULL;
897 obj_datasec (abfd) = (asection *)NULL;
898 obj_bsssec (abfd) = (asection *)NULL;
900 return TRUE;
905 FUNCTION
906 aout_@var{size}_machine_type
908 SYNOPSIS
909 enum machine_type aout_@var{size}_machine_type
910 (enum bfd_architecture arch,
911 unsigned long machine));
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.
919 If the architecture is understood, machine type 0 (default)
920 is always understood.
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;
929 enum machine_type arch_flags;
931 arch_flags = M_UNKNOWN;
932 *unknown = TRUE;
934 switch (arch)
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;
946 case bfd_arch_m68k:
947 switch (machine)
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;
955 break;
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;
964 case bfd_arch_a29k:
965 if (machine == 0) arch_flags = M_29K;
966 break;
968 case bfd_arch_arm:
969 if (machine == 0) arch_flags = M_ARM;
970 break;
972 case bfd_arch_mips:
973 switch (machine)
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;
990 break;
992 case bfd_arch_ns32k:
993 switch (machine)
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;
1000 break;
1002 case bfd_arch_pdp11:
1003 /* TODO: arch_flags = M_PDP11; */
1004 *unknown = FALSE;
1005 break;
1007 case bfd_arch_vax:
1008 *unknown = FALSE;
1009 break;
1011 default:
1012 arch_flags = M_UNKNOWN;
1015 if (arch_flags != M_UNKNOWN)
1016 *unknown = FALSE;
1018 return arch_flags;
1023 FUNCTION
1024 aout_@var{size}_set_arch_mach
1026 SYNOPSIS
1027 bfd_boolean aout_@var{size}_set_arch_mach,
1028 (bfd *,
1029 enum bfd_architecture arch,
1030 unsigned long machine));
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.
1038 bfd_boolean
1039 NAME(aout,set_arch_mach) (abfd, arch, machine)
1040 bfd *abfd;
1041 enum bfd_architecture arch;
1042 unsigned long machine;
1044 if (! bfd_default_set_arch_mach (abfd, arch, machine))
1045 return FALSE;
1047 if (arch != bfd_arch_unknown)
1049 bfd_boolean unknown;
1051 NAME(aout,machine_type) (arch, machine, &unknown);
1052 if (unknown)
1053 return FALSE;
1056 obj_reloc_entry_size (abfd) = RELOC_SIZE;
1058 return (*aout_backend_info(abfd)->set_sizes) (abfd);
1061 static void
1062 adjust_o_magic (abfd, execp)
1063 bfd *abfd;
1064 struct internal_exec *execp;
1066 file_ptr pos = adata (abfd).exec_bytes_size;
1067 bfd_vma vma = 0;
1068 int pad = 0;
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;
1077 pos += obj_textsec (abfd)->_raw_size;
1078 vma += obj_textsec (abfd)->_raw_size;
1080 /* Data. */
1081 if (!obj_datasec (abfd)->user_set_vma)
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;
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;
1097 /* BSS. */
1098 if (! obj_bsssec (abfd)->user_set_vma)
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;
1108 else
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)
1116 obj_datasec (abfd)->_raw_size += pad;
1117 pos += pad;
1120 obj_bsssec (abfd)->filepos = pos;
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);
1129 static void
1130 adjust_z_magic (abfd, execp)
1131 bfd *abfd;
1132 struct internal_exec *execp;
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. */
1139 abdp = aout_backend_info (abfd);
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)
1150 /* ?? Do we really need to check for relocs here? */
1151 obj_textsec(abfd)->vma = ((abfd->flags & HAS_RELOC)
1153 : (ztih
1154 ? (abdp->default_text_vma
1155 + adata (abfd).exec_bytes_size)
1156 : abdp->default_text_vma));
1157 text_pad = 0;
1159 else
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));
1172 /* Find start of data. */
1173 if (ztih)
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;
1178 else
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;
1188 obj_textsec (abfd)->_raw_size += text_pad;
1189 text_end += text_pad;
1191 /* Data. */
1192 if (!obj_datasec(abfd)->user_set_vma)
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);
1198 if (abdp && abdp->zmagic_mapped_contiguous)
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;
1205 obj_datasec (abfd)->filepos = (obj_textsec (abfd)->filepos
1206 + obj_textsec (abfd)->_raw_size);
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);
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;
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;
1244 static void
1245 adjust_n_magic (abfd, execp)
1246 bfd *abfd;
1247 struct internal_exec *execp;
1249 file_ptr pos = adata(abfd).exec_bytes_size;
1250 bfd_vma vma = 0;
1251 int pad;
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;
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;
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;
1274 /* BSS. */
1275 if (!obj_bsssec(abfd)->user_set_vma)
1276 obj_bsssec(abfd)->vma = vma;
1277 else
1278 vma = obj_bsssec(abfd)->vma;
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);
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;
1293 struct internal_exec *execp = exec_hdr (abfd);
1295 if (! NAME(aout,make_sections) (abfd))
1296 return FALSE;
1298 if (adata(abfd).magic != undecided_magic)
1299 return TRUE;
1301 obj_textsec(abfd)->_raw_size =
1302 align_power(obj_textsec(abfd)->_raw_size,
1303 obj_textsec(abfd)->alignment_power);
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. */
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. */
1322 if (abfd->flags & WP_TEXT)
1323 adata(abfd).magic = n_magic;
1324 else
1325 adata(abfd).magic = o_magic;
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 ();
1337 str;
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
1348 switch (adata(abfd).magic)
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 ();
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
1372 return TRUE;
1376 FUNCTION
1377 aout_@var{size}_new_section_hook
1379 SYNOPSIS
1380 bfd_boolean aout_@var{size}_new_section_hook,
1381 (bfd *abfd,
1382 asection *newsect));
1384 DESCRIPTION
1385 Called by the BFD in response to a @code{bfd_make_section}
1386 request.
1388 bfd_boolean
1389 NAME(aout,new_section_hook) (abfd, newsect)
1390 bfd *abfd;
1391 asection *newsect;
1393 /* align to double at least */
1394 newsect->alignment_power = bfd_get_arch_info(abfd)->section_align_power;
1397 if (bfd_get_format (abfd) == bfd_object)
1399 if (obj_textsec (abfd) == NULL
1400 && ! strcmp (newsect->name, ".text"))
1402 obj_textsec(abfd)= newsect;
1403 newsect->target_index = N_TEXT;
1404 return TRUE;
1407 if (obj_datasec (abfd) == NULL
1408 && ! strcmp (newsect->name, ".data"))
1410 obj_datasec (abfd) = newsect;
1411 newsect->target_index = N_DATA;
1412 return TRUE;
1415 if (obj_bsssec (abfd) == NULL
1416 && !strcmp (newsect->name, ".bss"))
1418 obj_bsssec (abfd) = newsect;
1419 newsect->target_index = N_BSS;
1420 return TRUE;
1424 /* We allow more than three sections internally */
1425 return TRUE;
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;
1436 file_ptr text_end;
1437 bfd_size_type text_size;
1439 if (! abfd->output_has_begun)
1441 if (! NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
1442 return FALSE;
1445 if (section == obj_bsssec (abfd))
1447 bfd_set_error (bfd_error_no_contents);
1448 return FALSE;
1451 if (section != obj_textsec (abfd)
1452 && section != obj_datasec (abfd))
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;
1461 if (count != 0)
1463 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1464 || bfd_bwrite (location, count, abfd) != count)
1465 return FALSE;
1468 return TRUE;
1471 /* Read the external symbols from an a.out file. */
1473 static bfd_boolean
1474 aout_get_external_symbols (abfd)
1475 bfd *abfd;
1477 if (obj_aout_external_syms (abfd) == (struct external_nlist *) NULL)
1479 bfd_size_type count;
1480 struct external_nlist *syms;
1482 count = exec_hdr (abfd)->a_syms / EXTERNAL_NLIST_SIZE;
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;
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))
1502 free (syms);
1503 return FALSE;
1505 #endif
1507 obj_aout_external_syms (abfd) = syms;
1508 obj_aout_external_sym_count (abfd) = count;
1511 if (obj_aout_external_strings (abfd) == NULL
1512 && exec_hdr (abfd)->a_syms != 0)
1514 unsigned char string_chars[BYTES_IN_LONG];
1515 bfd_size_type stringsize;
1516 char *strings;
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);
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;
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)
1539 free (strings);
1540 return FALSE;
1542 #endif
1544 /* Ensure that a zero index yields an empty string. */
1545 strings[0] = '\0';
1547 strings[stringsize - 1] = 0;
1549 obj_aout_external_strings (abfd) = strings;
1550 obj_aout_external_string_size (abfd) = stringsize;
1553 return TRUE;
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. */
1561 static bfd_boolean
1562 translate_from_native_sym_flags (abfd, cache_ptr)
1563 bfd *abfd;
1564 aout_symbol_type *cache_ptr;
1566 flagword visible;
1568 if (cache_ptr->type == N_FN)
1570 asection *sec;
1572 /* This is a debugging symbol. */
1574 cache_ptr->symbol.flags = BSF_DEBUGGING;
1576 /* Work out the symbol section. */
1577 switch (cache_ptr->type & N_TYPE)
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;
1595 cache_ptr->symbol.section = sec;
1596 cache_ptr->symbol.value -= sec->vma;
1598 return TRUE;
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;
1608 switch (cache_ptr->type)
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;
1616 case N_UNDF | N_EXT:
1617 if (cache_ptr->symbol.value != 0)
1619 /* This is a common symbol. */
1620 cache_ptr->symbol.flags = BSF_GLOBAL;
1621 cache_ptr->symbol.section = bfd_com_section_ptr;
1623 else
1625 cache_ptr->symbol.flags = 0;
1626 cache_ptr->symbol.section = bfd_und_section_ptr;
1628 break;
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;
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;
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;
1649 return TRUE;
1652 /* Set the fields of SYM_POINTER according to CACHE_PTR. */
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;
1660 bfd_vma value = cache_ptr->value;
1661 asection *sec;
1662 bfd_vma off;
1664 /* Mask out any existing type bits in case copying from one section
1665 to another. */
1666 sym_pointer->e_type[0] &= ~N_TYPE;
1668 sec = bfd_get_section (cache_ptr);
1669 off = 0;
1671 if (sec == NULL)
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;
1683 if (sec->output_section != NULL)
1685 off = sec->output_offset;
1686 sec = sec->output_section;
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
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;
1710 /* Turn the symbol from section relative to absolute again */
1711 value += sec->vma + off;
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;
1718 #if 0
1719 if ((cache_ptr->flags & BSF_CONSTRUCTOR) != 0)
1721 int type = ((aout_symbol_type *) cache_ptr)->type;
1724 switch (type)
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;
1731 sym_pointer->e_type[0] = type;
1733 #endif
1735 #if 0
1736 if ((cache_ptr->flags & BSF_WEAK) != 0)
1738 int type;
1740 switch (sym_pointer->e_type[0] & N_TYPE)
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;
1749 sym_pointer->e_type[0] = type;
1751 #endif
1753 PUT_WORD(abfd, value, sym_pointer->e_value);
1755 return TRUE;
1758 /* Native-level interface to symbols. */
1760 asymbol *
1761 NAME(aout,make_empty_symbol) (abfd)
1762 bfd *abfd;
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;
1770 return &new->symbol;
1773 /* Translate a set of internal symbols into external symbols. */
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;
1785 struct external_nlist *ext_end;
1787 ext_end = ext + count;
1788 for (; ext < ext_end; ext++, in++)
1790 bfd_vma x;
1792 x = GET_WORD (abfd, ext->e_strx);
1793 in->symbol.the_bfd = abfd;
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;
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;
1814 if (! translate_from_native_sym_flags (abfd, in))
1815 return FALSE;
1817 if (dynamic)
1818 in->symbol.flags |= BSF_DYNAMIC;
1821 return TRUE;
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. */
1828 bfd_boolean
1829 NAME(aout,slurp_symbol_table) (abfd)
1830 bfd *abfd;
1832 struct external_nlist *old_external_syms;
1833 aout_symbol_type *cached;
1834 bfd_size_type cached_size;
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;
1840 old_external_syms = obj_aout_external_syms (abfd);
1842 if (! aout_get_external_symbols (abfd))
1843 return FALSE;
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;
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)))
1860 free (cached);
1861 return FALSE;
1864 bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
1866 obj_aout_symbols (abfd) = cached;
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)
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;
1883 return TRUE;
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.
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. */
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 *));
1899 /* Get the index of a string in a strtab, adding it if it is not
1900 already present. */
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;
1909 bfd_boolean hash;
1910 bfd_size_type index;
1912 /* An index of 0 always means the empty string. */
1913 if (str == 0 || *str == '\0')
1914 return 0;
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;
1922 index = _bfd_stringtab_add (tab, str, hash, copy);
1924 if (index != (bfd_size_type) -1)
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;
1931 return index;
1934 /* Write out a strtab. ABFD is already at the right location in the
1935 file. */
1937 static bfd_boolean
1938 emit_stringtab (abfd, tab)
1939 register bfd *abfd;
1940 struct bfd_strtab_hash *tab;
1942 bfd_byte buffer[BYTES_IN_LONG];
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;
1950 return _bfd_stringtab_emit (abfd, tab);
1953 bfd_boolean
1954 NAME(aout,write_syms) (abfd)
1955 bfd *abfd;
1957 unsigned int count ;
1958 asymbol **generic = bfd_get_outsymbols (abfd);
1959 struct bfd_strtab_hash *strtab;
1961 strtab = _bfd_stringtab_init ();
1962 if (strtab == NULL)
1963 return FALSE;
1965 for (count = 0; count < bfd_get_symcount (abfd); count++)
1967 asymbol *g = generic[count];
1968 bfd_size_type indx;
1969 struct external_nlist nsp;
1971 PUT_WORD (abfd, 0, nsp.e_unused);
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);
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);
1983 if (! translate_to_native_sym_flags (abfd, g, &nsp))
1984 goto error_return;
1986 H_PUT_8 (abfd, 0, nsp.e_ovly);
1988 if (bfd_bwrite ((PTR)&nsp, (bfd_size_type) EXTERNAL_NLIST_SIZE, abfd)
1989 != EXTERNAL_NLIST_SIZE)
1990 goto error_return;
1992 /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1993 here, at the end. */
1994 g->KEEPIT = count;
1997 if (! emit_stringtab (abfd, strtab))
1998 goto error_return;
2000 _bfd_stringtab_free (strtab);
2002 return TRUE;
2004 error_return:
2005 _bfd_stringtab_free (strtab);
2006 return FALSE;
2010 long
2011 NAME(aout,canonicalize_symtab) (abfd, location)
2012 bfd *abfd;
2013 asymbol **location;
2015 unsigned int counter = 0;
2016 aout_symbol_type *symbase;
2018 if (!NAME(aout,slurp_symbol_table)(abfd))
2019 return -1;
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);
2028 /* Standard reloc stuff */
2030 /* Extended stuff */
2031 /* Output extended relocation information to a file in target byte order. */
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;
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;
2046 if (g->addend != 0)
2047 fprintf (stderr, "BFD: can't do this reloc addend stuff\n");
2049 r_pcrel = g->howto->pc_relative;
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;
2066 BFD_ASSERT (r_type != -1);
2068 if (r_type == RABS)
2069 r_index = 0;
2070 else
2071 r_index = (*(g->sym_ptr_ptr))->KEEPIT;
2073 #if 0
2074 if (bfd_is_abs_section (bfd_get_section (sym)))
2076 r_extern = 0;
2077 r_index = N_ABS;
2078 r_type = RABS;
2080 else if ((sym->flags & BSF_SECTION_SYM) == 0)
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;
2089 else
2091 /* Just an ordinary section */
2092 r_extern = 0;
2093 r_index = output_section->target_index;
2095 #endif
2097 reloc_entry = r_index << 4 | r_type | r_pcrel;
2099 PUT_WORD (abfd, reloc_entry, natptr->e_reloc_entry);
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.
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 */
2111 #define MOVE_ADDRESS(ad) \
2112 if (r_extern) \
2114 /* Undefined symbol. */ \
2115 cache_ptr->sym_ptr_ptr = symbols + r_index; \
2116 cache_ptr->addend = ad; \
2118 else \
2120 /* Defined, section relative. replace symbol with pointer to \
2121 symbol which points to section. */ \
2122 switch (r_index) \
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; \
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;
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;
2164 reloc_entry = GET_WORD (abfd, (PTR)bytes);
2166 r_pcrel = reloc_entry & RELFLG;
2168 cache_ptr->address = offset;
2169 cache_ptr->howto = howto_table_pdp11 + (r_pcrel ? 1 : 0);
2171 if ((reloc_entry & RTYPE) == RABS)
2172 r_index = N_ABS;
2173 else
2174 r_index = RINDEX (reloc_entry);
2176 /* r_extern reflects whether the symbol the reloc is against is
2177 local or global. */
2178 r_extern = (reloc_entry & RTYPE) == REXT;
2180 if (r_extern && r_index > symcount)
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;
2188 MOVE_ADDRESS(0);
2191 /* Read and swap the relocs for a section. */
2193 bfd_boolean
2194 NAME(aout,slurp_reloc_table) (abfd, asect, symbols)
2195 bfd *abfd;
2196 sec_ptr asect;
2197 asymbol **symbols;
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;
2208 if (asect->relocation)
2209 return TRUE;
2211 if (asect->flags & SEC_CONSTRUCTOR)
2212 return TRUE;
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
2222 bfd_set_error (bfd_error_invalid_operation);
2223 return FALSE;
2226 if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
2227 return FALSE;
2229 each_size = obj_reloc_entry_size (abfd);
2231 relocs = bfd_malloc (reloc_size);
2232 if (relocs == NULL && reloc_size != 0)
2233 return FALSE;
2235 if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
2237 free (relocs);
2238 return FALSE;
2241 count = reloc_size / each_size;
2243 /* Count the number of NON-ZERO relocs, this is the count we want. */
2245 unsigned int real_count = 0;
2247 for (counter = 0; counter < count; counter++)
2249 int x;
2251 x = GET_WORD (abfd, (char *) relocs + each_size * counter);
2252 if (x != 0)
2253 real_count++;
2256 count = real_count;
2259 reloc_cache = (arelent *) bfd_zmalloc (count * sizeof (arelent));
2260 if (reloc_cache == NULL && count != 0)
2261 return FALSE;
2263 cache_ptr = reloc_cache;
2265 rptr = (struct pdp11_aout_reloc_external *) relocs;
2266 for (counter = 0;
2267 counter < count;
2268 counter++, ((char *)rptr) += RELOC_SIZE, cache_ptr++)
2270 while (GET_WORD (abfd, (PTR)rptr) == 0)
2272 rptr =
2273 (struct pdp11_aout_reloc_external *)
2274 ((char *) rptr + RELOC_SIZE);
2275 if ((char *) rptr >= (char *) relocs + reloc_size)
2276 goto done;
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));
2284 done:
2285 /* Just in case, if rptr >= relocs + reloc_size should happen
2286 too early. */
2287 BFD_ASSERT (counter == count);
2289 free (relocs);
2291 asect->relocation = reloc_cache;
2292 asect->reloc_count = cache_ptr - reloc_cache;
2294 return TRUE;
2297 /* Write out a relocation section into an object file. */
2299 bfd_boolean
2300 NAME(aout,squirt_out_relocs) (abfd, section)
2301 bfd *abfd;
2302 asection *section;
2304 arelent **generic;
2305 unsigned char *native;
2306 unsigned int count = section->reloc_count;
2307 bfd_size_type natsize;
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
2317 natsize = bfd_get_section_size_before_reloc (section);
2318 native = (unsigned char *) bfd_zalloc (abfd, natsize);
2319 if (!native)
2320 return FALSE;
2322 generic = section->orelocation;
2323 if (generic != NULL)
2325 while (count > 0)
2327 struct pdp11_aout_reloc_external *r;
2329 r = (struct pdp11_aout_reloc_external *)
2330 (native + (*generic)->address);
2331 pdp11_aout_swap_reloc_out (abfd, *generic, r);
2332 count--;
2333 generic++;
2337 if (bfd_bwrite ((PTR) native, natsize, abfd) != natsize)
2339 bfd_release (abfd, native);
2340 return FALSE;
2343 bfd_release (abfd, native);
2344 return TRUE;
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;
2355 arelent *tblptr = section->relocation;
2356 unsigned int count;
2358 if (section == obj_bsssec (abfd))
2360 *relptr = NULL;
2361 return 0;
2364 if (!(tblptr || NAME(aout,slurp_reloc_table)(abfd, section, symbols)))
2365 return -1;
2367 if (section->flags & SEC_CONSTRUCTOR)
2369 arelent_chain *chain = section->constructor_chain;
2371 for (count = 0; count < section->reloc_count; count ++)
2373 *relptr ++ = &chain->relent;
2374 chain = chain->next;
2377 else
2379 tblptr = section->relocation;
2381 for (count = 0; count++ < section->reloc_count;)
2382 *relptr++ = tblptr++;
2385 *relptr = 0;
2387 return section->reloc_count;
2390 long
2391 NAME(aout,get_reloc_upper_bound) (abfd, asect)
2392 bfd *abfd;
2393 sec_ptr asect;
2395 if (bfd_get_format (abfd) != bfd_object)
2397 bfd_set_error (bfd_error_invalid_operation);
2398 return -1;
2401 if (asect->flags & SEC_CONSTRUCTOR)
2402 return (sizeof (arelent *) * (asect->reloc_count+1));
2404 if (asect == obj_datasec (abfd))
2405 return (sizeof (arelent *)
2406 * ((exec_hdr(abfd)->a_drsize / obj_reloc_entry_size (abfd))
2407 + 1));
2409 if (asect == obj_textsec (abfd))
2410 return (sizeof (arelent *)
2411 * ((exec_hdr(abfd)->a_trsize / obj_reloc_entry_size (abfd))
2412 + 1));
2414 /* TODO: why are there two if statements for obj_bsssec()? */
2416 if (asect == obj_bsssec (abfd))
2417 return sizeof (arelent *);
2419 if (asect == obj_bsssec (abfd))
2420 return 0;
2422 bfd_set_error (bfd_error_invalid_operation);
2423 return -1;
2427 long
2428 NAME(aout,get_symtab_upper_bound) (abfd)
2429 bfd *abfd;
2431 if (!NAME(aout,slurp_symbol_table)(abfd))
2432 return -1;
2434 return (bfd_get_symcount (abfd) + 1) * (sizeof (aout_symbol_type *));
2437 alent *
2438 NAME(aout,get_lineno) (abfd, symbol)
2439 bfd * abfd ATTRIBUTE_UNUSED;
2440 asymbol * symbol ATTRIBUTE_UNUSED;
2442 return (alent *)NULL;
2445 void
2446 NAME(aout,get_symbol_info) (abfd, symbol, ret)
2447 bfd * abfd ATTRIBUTE_UNUSED;
2448 asymbol *symbol;
2449 symbol_info *ret;
2451 bfd_symbol_info (symbol, ret);
2453 if (ret->type == '?')
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];
2459 if (stab_name == NULL)
2461 sprintf(buf, "(%d)", type_code);
2462 stab_name = buf;
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;
2472 void
2473 NAME(aout,print_symbol) (abfd, afile, symbol, how)
2474 bfd * abfd;
2475 PTR afile;
2476 asymbol *symbol;
2477 bfd_print_symbol_type how;
2479 FILE *file = (FILE *)afile;
2481 switch (how)
2483 case bfd_print_symbol_name:
2484 if (symbol->name)
2485 fprintf(file,"%s", symbol->name);
2486 break;
2487 case bfd_print_symbol_more:
2488 fprintf(file,"%4x %2x %2x",(unsigned)(aout_symbol(symbol)->desc & 0xffff),
2489 (unsigned)(aout_symbol(symbol)->other & 0xff),
2490 (unsigned)(aout_symbol(symbol)->type));
2491 break;
2492 case bfd_print_symbol_all:
2494 const char *section_name = symbol->section->name;
2496 bfd_print_symbol_vandf (abfd, (PTR)file, symbol);
2498 fprintf (file," %-5s %04x %02x %02x",
2499 section_name,
2500 (unsigned)(aout_symbol(symbol)->desc & 0xffff),
2501 (unsigned)(aout_symbol(symbol)->other & 0xff),
2502 (unsigned)(aout_symbol(symbol)->type & 0xff));
2503 if (symbol->name)
2504 fprintf(file," %s", symbol->name);
2506 break;
2510 /* If we don't have to allocate more than 1MB to hold the generic
2511 symbols, we use the generic minisymbol method: it's faster, since
2512 it only translates the symbols once, not multiple times. */
2513 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2515 /* Read minisymbols. For minisymbols, we use the unmodified a.out
2516 symbols. The minisymbol_to_symbol function translates these into
2517 BFD asymbol structures. */
2519 long
2520 NAME(aout,read_minisymbols) (abfd, dynamic, minisymsp, sizep)
2521 bfd *abfd;
2522 bfd_boolean dynamic;
2523 PTR *minisymsp;
2524 unsigned int *sizep;
2526 if (dynamic)
2528 /* We could handle the dynamic symbols here as well, but it's
2529 easier to hand them off. */
2530 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2533 if (! aout_get_external_symbols (abfd))
2534 return -1;
2536 if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2537 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2539 *minisymsp = (PTR) obj_aout_external_syms (abfd);
2541 /* By passing the external symbols back from this routine, we are
2542 giving up control over the memory block. Clear
2543 obj_aout_external_syms, so that we do not try to free it
2544 ourselves. */
2545 obj_aout_external_syms (abfd) = NULL;
2547 *sizep = EXTERNAL_NLIST_SIZE;
2548 return obj_aout_external_sym_count (abfd);
2551 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
2552 unmodified a.out symbol. The SYM argument is a structure returned
2553 by bfd_make_empty_symbol, which we fill in here. */
2555 asymbol *
2556 NAME(aout,minisymbol_to_symbol) (abfd, dynamic, minisym, sym)
2557 bfd *abfd;
2558 bfd_boolean dynamic;
2559 const PTR minisym;
2560 asymbol *sym;
2562 if (dynamic
2563 || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2564 return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
2566 memset (sym, 0, sizeof (aout_symbol_type));
2568 /* We call translate_symbol_table to translate a single symbol. */
2569 if (! (NAME(aout,translate_symbol_table)
2570 (abfd,
2571 (aout_symbol_type *) sym,
2572 (struct external_nlist *) minisym,
2573 (bfd_size_type) 1,
2574 obj_aout_external_strings (abfd),
2575 obj_aout_external_string_size (abfd),
2576 FALSE)))
2577 return NULL;
2579 return sym;
2583 provided a BFD, a section and an offset into the section, calculate
2584 and return the name of the source file and the line nearest to the
2585 wanted location.
2588 bfd_boolean
2589 NAME(aout,find_nearest_line)
2590 (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2591 bfd *abfd;
2592 asection *section;
2593 asymbol **symbols;
2594 bfd_vma offset;
2595 const char **filename_ptr;
2596 const char **functionname_ptr;
2597 unsigned int *line_ptr;
2599 /* Run down the file looking for the filename, function and linenumber */
2600 asymbol **p;
2601 const char *directory_name = NULL;
2602 const char *main_file_name = NULL;
2603 const char *current_file_name = NULL;
2604 const char *line_file_name = NULL; /* Value of current_file_name at line number. */
2605 bfd_vma low_line_vma = 0;
2606 bfd_vma low_func_vma = 0;
2607 asymbol *func = 0;
2608 size_t filelen, funclen;
2609 char *buf;
2611 *filename_ptr = abfd->filename;
2612 *functionname_ptr = 0;
2613 *line_ptr = 0;
2615 if (symbols != (asymbol **)NULL)
2617 for (p = symbols; *p; p++)
2619 aout_symbol_type *q = (aout_symbol_type *)(*p);
2620 next:
2621 switch (q->type)
2623 case N_TEXT:
2624 /* If this looks like a file name symbol, and it comes after
2625 the line number we have found so far, but before the
2626 offset, then we have probably not found the right line
2627 number. */
2628 if (q->symbol.value <= offset
2629 && ((q->symbol.value > low_line_vma
2630 && (line_file_name != NULL
2631 || *line_ptr != 0))
2632 || (q->symbol.value > low_func_vma
2633 && func != NULL)))
2635 const char * symname;
2637 symname = q->symbol.name;
2638 if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
2640 if (q->symbol.value > low_line_vma)
2642 *line_ptr = 0;
2643 line_file_name = NULL;
2645 if (q->symbol.value > low_func_vma)
2646 func = NULL;
2649 break;
2651 case N_SO:
2652 /* If this symbol is less than the offset, but greater than
2653 the line number we have found so far, then we have not
2654 found the right line number. */
2655 if (q->symbol.value <= offset)
2657 if (q->symbol.value > low_line_vma)
2659 *line_ptr = 0;
2660 line_file_name = NULL;
2662 if (q->symbol.value > low_func_vma)
2663 func = NULL;
2666 main_file_name = current_file_name = q->symbol.name;
2667 /* Look ahead to next symbol to check if that too is an N_SO. */
2668 p++;
2669 if (*p == NULL)
2670 break;
2671 q = (aout_symbol_type *)(*p);
2672 if (q->type != (int)N_SO)
2673 goto next;
2675 /* Found a second N_SO First is directory; second is filename. */
2676 directory_name = current_file_name;
2677 main_file_name = current_file_name = q->symbol.name;
2678 if (obj_textsec(abfd) != section)
2679 goto done;
2680 break;
2681 case N_SOL:
2682 current_file_name = q->symbol.name;
2683 break;
2685 case N_SLINE:
2686 case N_DSLINE:
2687 case N_BSLINE:
2688 /* We'll keep this if it resolves nearer than the one we have
2689 already. */
2690 if (q->symbol.value >= low_line_vma
2691 && q->symbol.value <= offset)
2693 *line_ptr = q->desc;
2694 low_line_vma = q->symbol.value;
2695 line_file_name = current_file_name;
2697 break;
2699 case N_FUN:
2701 /* We'll keep this if it is nearer than the one we have already */
2702 if (q->symbol.value >= low_func_vma &&
2703 q->symbol.value <= offset)
2705 low_func_vma = q->symbol.value;
2706 func = (asymbol *)q;
2708 else if (q->symbol.value > offset)
2709 goto done;
2711 break;
2716 done:
2717 if (*line_ptr != 0)
2718 main_file_name = line_file_name;
2720 if (main_file_name == NULL
2721 || main_file_name[0] == '/'
2722 || directory_name == NULL)
2723 filelen = 0;
2724 else
2725 filelen = strlen (directory_name) + strlen (main_file_name);
2726 if (func == NULL)
2727 funclen = 0;
2728 else
2729 funclen = strlen (bfd_asymbol_name (func));
2731 if (adata (abfd).line_buf != NULL)
2732 free (adata (abfd).line_buf);
2733 if (filelen + funclen == 0)
2734 adata (abfd).line_buf = buf = NULL;
2735 else
2737 buf = (char *) bfd_malloc ((bfd_size_type) filelen + funclen + 3);
2738 adata (abfd).line_buf = buf;
2739 if (buf == NULL)
2740 return FALSE;
2743 if (main_file_name != NULL)
2745 if (main_file_name[0] == '/' || directory_name == NULL)
2746 *filename_ptr = main_file_name;
2747 else
2749 sprintf (buf, "%s%s", directory_name, main_file_name);
2750 *filename_ptr = buf;
2751 buf += filelen + 1;
2755 if (func)
2757 const char *function = func->name;
2758 char *colon;
2760 /* The caller expects a symbol name. We actually have a
2761 function name, without the leading underscore. Put the
2762 underscore back in, so that the caller gets a symbol name. */
2763 if (bfd_get_symbol_leading_char (abfd) == '\0')
2764 strcpy (buf, function);
2765 else
2767 buf[0] = bfd_get_symbol_leading_char (abfd);
2768 strcpy (buf + 1, function);
2771 /* Have to remove : stuff. */
2772 colon = strchr (buf, ':');
2773 if (colon != NULL)
2774 *colon = '\0';
2775 *functionname_ptr = buf;
2778 return TRUE;
2782 NAME(aout,sizeof_headers) (abfd, execable)
2783 bfd *abfd;
2784 bfd_boolean execable ATTRIBUTE_UNUSED;
2786 return adata(abfd).exec_bytes_size;
2789 /* Free all information we have cached for this BFD. We can always
2790 read it again later if we need it. */
2792 bfd_boolean
2793 NAME(aout,bfd_free_cached_info) (abfd)
2794 bfd *abfd;
2796 asection *o;
2798 if (bfd_get_format (abfd) != bfd_object)
2799 return TRUE;
2801 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2802 BFCI_FREE (obj_aout_symbols (abfd));
2803 #ifdef USE_MMAP
2804 obj_aout_external_syms (abfd) = 0;
2805 bfd_free_window (&obj_aout_sym_window (abfd));
2806 bfd_free_window (&obj_aout_string_window (abfd));
2807 obj_aout_external_strings (abfd) = 0;
2808 #else
2809 BFCI_FREE (obj_aout_external_syms (abfd));
2810 BFCI_FREE (obj_aout_external_strings (abfd));
2811 #endif
2812 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
2813 BFCI_FREE (o->relocation);
2814 #undef BFCI_FREE
2816 return TRUE;
2819 /* a.out link code. */
2821 static bfd_boolean aout_link_add_object_symbols
2822 PARAMS ((bfd *, struct bfd_link_info *));
2823 static bfd_boolean aout_link_check_archive_element
2824 PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean *));
2825 static bfd_boolean aout_link_free_symbols PARAMS ((bfd *));
2826 static bfd_boolean aout_link_check_ar_symbols
2827 PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean *pneeded));
2828 static bfd_boolean aout_link_add_symbols
2829 PARAMS ((bfd *, struct bfd_link_info *));
2831 /* Routine to create an entry in an a.out link hash table. */
2833 struct bfd_hash_entry *
2834 NAME(aout,link_hash_newfunc) (entry, table, string)
2835 struct bfd_hash_entry *entry;
2836 struct bfd_hash_table *table;
2837 const char *string;
2839 struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2841 /* Allocate the structure if it has not already been allocated by a
2842 subclass. */
2843 if (ret == (struct aout_link_hash_entry *) NULL)
2844 ret = ((struct aout_link_hash_entry *)
2845 bfd_hash_allocate (table, sizeof (struct aout_link_hash_entry)));
2846 if (ret == (struct aout_link_hash_entry *) NULL)
2847 return (struct bfd_hash_entry *) ret;
2849 /* Call the allocation method of the superclass. */
2850 ret = ((struct aout_link_hash_entry *)
2851 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2852 table, string));
2853 if (ret)
2855 /* Set local fields. */
2856 ret->written = FALSE;
2857 ret->indx = -1;
2860 return (struct bfd_hash_entry *) ret;
2863 /* Initialize an a.out link hash table. */
2865 bfd_boolean
2866 NAME(aout,link_hash_table_init) (table, abfd, newfunc)
2867 struct aout_link_hash_table *table;
2868 bfd *abfd;
2869 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
2870 struct bfd_hash_table *,
2871 const char *));
2873 return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
2876 /* Create an a.out link hash table. */
2878 struct bfd_link_hash_table *
2879 NAME(aout,link_hash_table_create) (abfd)
2880 bfd *abfd;
2882 struct aout_link_hash_table *ret;
2883 bfd_size_type amt = sizeof (struct aout_link_hash_table);
2885 ret = ((struct aout_link_hash_table *) bfd_alloc (abfd, amt));
2886 if (ret == NULL)
2887 return (struct bfd_link_hash_table *) NULL;
2888 if (! NAME(aout,link_hash_table_init) (ret, abfd,
2889 NAME(aout,link_hash_newfunc)))
2891 free (ret);
2892 return (struct bfd_link_hash_table *) NULL;
2894 return &ret->root;
2897 /* Given an a.out BFD, add symbols to the global hash table as
2898 appropriate. */
2900 bfd_boolean
2901 NAME(aout,link_add_symbols) (abfd, info)
2902 bfd *abfd;
2903 struct bfd_link_info *info;
2905 switch (bfd_get_format (abfd))
2907 case bfd_object:
2908 return aout_link_add_object_symbols (abfd, info);
2909 case bfd_archive:
2910 return _bfd_generic_link_add_archive_symbols
2911 (abfd, info, aout_link_check_archive_element);
2912 default:
2913 bfd_set_error (bfd_error_wrong_format);
2914 return FALSE;
2918 /* Add symbols from an a.out object file. */
2920 static bfd_boolean
2921 aout_link_add_object_symbols (abfd, info)
2922 bfd *abfd;
2923 struct bfd_link_info *info;
2925 if (! aout_get_external_symbols (abfd))
2926 return FALSE;
2927 if (! aout_link_add_symbols (abfd, info))
2928 return FALSE;
2929 if (! info->keep_memory)
2931 if (! aout_link_free_symbols (abfd))
2932 return FALSE;
2934 return TRUE;
2937 /* Check a single archive element to see if we need to include it in
2938 the link. *PNEEDED is set according to whether this element is
2939 needed in the link or not. This is called from
2940 _bfd_generic_link_add_archive_symbols. */
2942 static bfd_boolean
2943 aout_link_check_archive_element (abfd, info, pneeded)
2944 bfd *abfd;
2945 struct bfd_link_info *info;
2946 bfd_boolean *pneeded;
2948 if (! aout_get_external_symbols (abfd))
2949 return FALSE;
2951 if (! aout_link_check_ar_symbols (abfd, info, pneeded))
2952 return FALSE;
2954 if (*pneeded)
2956 if (! aout_link_add_symbols (abfd, info))
2957 return FALSE;
2960 if (! info->keep_memory || ! *pneeded)
2962 if (! aout_link_free_symbols (abfd))
2963 return FALSE;
2966 return TRUE;
2969 /* Free up the internal symbols read from an a.out file. */
2971 static bfd_boolean
2972 aout_link_free_symbols (abfd)
2973 bfd *abfd;
2975 if (obj_aout_external_syms (abfd) != (struct external_nlist *) NULL)
2977 #ifdef USE_MMAP
2978 bfd_free_window (&obj_aout_sym_window (abfd));
2979 #else
2980 free ((PTR) obj_aout_external_syms (abfd));
2981 #endif
2982 obj_aout_external_syms (abfd) = (struct external_nlist *) NULL;
2984 if (obj_aout_external_strings (abfd) != (char *) NULL)
2986 #ifdef USE_MMAP
2987 bfd_free_window (&obj_aout_string_window (abfd));
2988 #else
2989 free ((PTR) obj_aout_external_strings (abfd));
2990 #endif
2991 obj_aout_external_strings (abfd) = (char *) NULL;
2993 return TRUE;
2996 /* Look through the internal symbols to see if this object file should
2997 be included in the link. We should include this object file if it
2998 defines any symbols which are currently undefined. If this object
2999 file defines a common symbol, then we may adjust the size of the
3000 known symbol but we do not include the object file in the link
3001 (unless there is some other reason to include it). */
3003 static bfd_boolean
3004 aout_link_check_ar_symbols (abfd, info, pneeded)
3005 bfd *abfd;
3006 struct bfd_link_info *info;
3007 bfd_boolean *pneeded;
3009 register struct external_nlist *p;
3010 struct external_nlist *pend;
3011 char *strings;
3013 *pneeded = FALSE;
3015 /* Look through all the symbols. */
3016 p = obj_aout_external_syms (abfd);
3017 pend = p + obj_aout_external_sym_count (abfd);
3018 strings = obj_aout_external_strings (abfd);
3019 for (; p < pend; p++)
3021 int type = H_GET_8 (abfd, p->e_type);
3022 const char *name;
3023 struct bfd_link_hash_entry *h;
3025 /* Ignore symbols that are not externally visible. This is an
3026 optimization only, as we check the type more thoroughly
3027 below. */
3028 if ((type & N_EXT) == 0
3029 || type == N_FN)
3030 continue;
3032 name = strings + GET_WORD (abfd, p->e_strx);
3033 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
3035 /* We are only interested in symbols that are currently
3036 undefined or common. */
3037 if (h == (struct bfd_link_hash_entry *) NULL
3038 || (h->type != bfd_link_hash_undefined
3039 && h->type != bfd_link_hash_common))
3040 continue;
3042 if (type == (N_TEXT | N_EXT)
3043 || type == (N_DATA | N_EXT)
3044 || type == (N_BSS | N_EXT)
3045 || type == (N_ABS | N_EXT))
3047 /* This object file defines this symbol. We must link it
3048 in. This is true regardless of whether the current
3049 definition of the symbol is undefined or common. If the
3050 current definition is common, we have a case in which we
3051 have already seen an object file including
3052 int a;
3053 and this object file from the archive includes
3054 int a = 5;
3055 In such a case we must include this object file.
3057 FIXME: The SunOS 4.1.3 linker will pull in the archive
3058 element if the symbol is defined in the .data section,
3059 but not if it is defined in the .text section. That
3060 seems a bit crazy to me, and I haven't implemented it.
3061 However, it might be correct. */
3062 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
3063 return FALSE;
3064 *pneeded = TRUE;
3065 return TRUE;
3068 if (type == (N_UNDF | N_EXT))
3070 bfd_vma value;
3072 value = GET_WORD (abfd, p->e_value);
3073 if (value != 0)
3075 /* This symbol is common in the object from the archive
3076 file. */
3077 if (h->type == bfd_link_hash_undefined)
3079 bfd *symbfd;
3080 unsigned int power;
3082 symbfd = h->u.undef.abfd;
3083 if (symbfd == (bfd *) NULL)
3085 /* This symbol was created as undefined from
3086 outside BFD. We assume that we should link
3087 in the object file. This is done for the -u
3088 option in the linker. */
3089 if (! (*info->callbacks->add_archive_element) (info,
3090 abfd,
3091 name))
3092 return FALSE;
3093 *pneeded = TRUE;
3094 return TRUE;
3096 /* Turn the current link symbol into a common
3097 symbol. It is already on the undefs list. */
3098 h->type = bfd_link_hash_common;
3099 h->u.c.p = ((struct bfd_link_hash_common_entry *)
3100 bfd_hash_allocate (&info->hash->table,
3101 sizeof (struct bfd_link_hash_common_entry)));
3102 if (h->u.c.p == NULL)
3103 return FALSE;
3105 h->u.c.size = value;
3107 /* FIXME: This isn't quite right. The maximum
3108 alignment of a common symbol should be set by the
3109 architecture of the output file, not of the input
3110 file. */
3111 power = bfd_log2 (value);
3112 if (power > bfd_get_arch_info (abfd)->section_align_power)
3113 power = bfd_get_arch_info (abfd)->section_align_power;
3114 h->u.c.p->alignment_power = power;
3116 h->u.c.p->section = bfd_make_section_old_way (symbfd,
3117 "COMMON");
3119 else
3121 /* Adjust the size of the common symbol if
3122 necessary. */
3123 if (value > h->u.c.size)
3124 h->u.c.size = value;
3130 /* We do not need this object file. */
3131 return TRUE;
3134 /* Add all symbols from an object file to the hash table. */
3136 static bfd_boolean
3137 aout_link_add_symbols (abfd, info)
3138 bfd *abfd;
3139 struct bfd_link_info *info;
3141 bfd_boolean (*add_one_symbol)
3142 PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
3143 bfd_vma, const char *, bfd_boolean, bfd_boolean,
3144 struct bfd_link_hash_entry **));
3145 struct external_nlist *syms;
3146 bfd_size_type sym_count;
3147 char *strings;
3148 bfd_boolean copy;
3149 struct aout_link_hash_entry **sym_hash;
3150 register struct external_nlist *p;
3151 struct external_nlist *pend;
3153 syms = obj_aout_external_syms (abfd);
3154 sym_count = obj_aout_external_sym_count (abfd);
3155 strings = obj_aout_external_strings (abfd);
3156 if (info->keep_memory)
3157 copy = FALSE;
3158 else
3159 copy = TRUE;
3161 if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
3163 if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
3164 (abfd, info, &syms, &sym_count, &strings)))
3165 return FALSE;
3168 /* We keep a list of the linker hash table entries that correspond
3169 to particular symbols. We could just look them up in the hash
3170 table, but keeping the list is more efficient. Perhaps this
3171 should be conditional on info->keep_memory. */
3172 sym_hash = ((struct aout_link_hash_entry **)
3173 bfd_alloc (abfd,
3174 sym_count * sizeof (struct aout_link_hash_entry *)));
3175 if (sym_hash == NULL && sym_count != 0)
3176 return FALSE;
3177 obj_aout_sym_hashes (abfd) = sym_hash;
3179 add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
3180 if (add_one_symbol == NULL)
3181 add_one_symbol = _bfd_generic_link_add_one_symbol;
3183 p = syms;
3184 pend = p + sym_count;
3185 for (; p < pend; p++, sym_hash++)
3187 int type;
3188 const char *name;
3189 bfd_vma value;
3190 asection *section;
3191 flagword flags;
3192 const char *string;
3194 *sym_hash = NULL;
3196 type = H_GET_8 (abfd, p->e_type);
3198 #if 0 /* not supported in PDP-11 a.out */
3199 /* Ignore debugging symbols. */
3200 if ((type & N_STAB) != 0)
3201 continue;
3202 #endif
3204 name = strings + GET_WORD (abfd, p->e_strx);
3205 value = GET_WORD (abfd, p->e_value);
3206 flags = BSF_GLOBAL;
3207 string = NULL;
3208 switch (type)
3210 default:
3211 abort ();
3213 case N_UNDF:
3214 case N_ABS:
3215 case N_TEXT:
3216 case N_DATA:
3217 case N_BSS:
3218 case N_REG:
3219 case N_FN:
3220 /* Ignore symbols that are not externally visible. */
3221 continue;
3223 case N_UNDF | N_EXT:
3224 if (value == 0)
3226 section = bfd_und_section_ptr;
3227 flags = 0;
3229 else
3230 section = bfd_com_section_ptr;
3231 break;
3232 case N_ABS | N_EXT:
3233 section = bfd_abs_section_ptr;
3234 break;
3235 case N_TEXT | N_EXT:
3236 section = obj_textsec (abfd);
3237 value -= bfd_get_section_vma (abfd, section);
3238 break;
3239 case N_DATA | N_EXT:
3240 /* Treat N_SETV symbols as N_DATA symbol; see comment in
3241 translate_from_native_sym_flags. */
3242 section = obj_datasec (abfd);
3243 value -= bfd_get_section_vma (abfd, section);
3244 break;
3245 case N_BSS | N_EXT:
3246 section = obj_bsssec (abfd);
3247 value -= bfd_get_section_vma (abfd, section);
3248 break;
3251 if (! ((*add_one_symbol)
3252 (info, abfd, name, flags, section, value, string, copy, FALSE,
3253 (struct bfd_link_hash_entry **) sym_hash)))
3254 return FALSE;
3256 /* Restrict the maximum alignment of a common symbol based on
3257 the architecture, since a.out has no way to represent
3258 alignment requirements of a section in a .o file. FIXME:
3259 This isn't quite right: it should use the architecture of the
3260 output file, not the input files. */
3261 if ((*sym_hash)->root.type == bfd_link_hash_common
3262 && ((*sym_hash)->root.u.c.p->alignment_power >
3263 bfd_get_arch_info (abfd)->section_align_power))
3264 (*sym_hash)->root.u.c.p->alignment_power =
3265 bfd_get_arch_info (abfd)->section_align_power;
3267 /* If this is a set symbol, and we are not building sets, then
3268 it is possible for the hash entry to not have been set. In
3269 such a case, treat the symbol as not globally defined. */
3270 if ((*sym_hash)->root.type == bfd_link_hash_new)
3272 BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
3273 *sym_hash = NULL;
3277 return TRUE;
3280 /* A hash table used for header files with N_BINCL entries. */
3282 struct aout_link_includes_table
3284 struct bfd_hash_table root;
3287 /* A linked list of totals that we have found for a particular header
3288 file. */
3290 struct aout_link_includes_totals
3292 struct aout_link_includes_totals *next;
3293 bfd_vma total;
3296 /* An entry in the header file hash table. */
3298 struct aout_link_includes_entry
3300 struct bfd_hash_entry root;
3301 /* List of totals we have found for this file. */
3302 struct aout_link_includes_totals *totals;
3305 /* Look up an entry in an the header file hash table. */
3307 #define aout_link_includes_lookup(table, string, create, copy) \
3308 ((struct aout_link_includes_entry *) \
3309 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
3311 /* During the final link step we need to pass around a bunch of
3312 information, so we do it in an instance of this structure. */
3314 struct aout_final_link_info
3316 /* General link information. */
3317 struct bfd_link_info *info;
3318 /* Output bfd. */
3319 bfd *output_bfd;
3320 /* Reloc file positions. */
3321 file_ptr treloff, dreloff;
3322 /* File position of symbols. */
3323 file_ptr symoff;
3324 /* String table. */
3325 struct bfd_strtab_hash *strtab;
3326 /* Header file hash table. */
3327 struct aout_link_includes_table includes;
3328 /* A buffer large enough to hold the contents of any section. */
3329 bfd_byte *contents;
3330 /* A buffer large enough to hold the relocs of any section. */
3331 PTR relocs;
3332 /* A buffer large enough to hold the symbol map of any input BFD. */
3333 int *symbol_map;
3334 /* A buffer large enough to hold output symbols of any input BFD. */
3335 struct external_nlist *output_syms;
3338 static struct bfd_hash_entry *aout_link_includes_newfunc
3339 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
3340 static bfd_boolean aout_link_input_bfd
3341 PARAMS ((struct aout_final_link_info *, bfd *input_bfd));
3342 static bfd_boolean aout_link_write_symbols
3343 PARAMS ((struct aout_final_link_info *, bfd *input_bfd));
3344 static bfd_boolean aout_link_write_other_symbol
3345 PARAMS ((struct aout_link_hash_entry *, PTR));
3346 static bfd_boolean aout_link_input_section
3347 PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
3348 asection *input_section, file_ptr *reloff_ptr,
3349 bfd_size_type rel_size));
3350 static INLINE asection *aout_reloc_type_to_section
3351 PARAMS ((bfd *, int));
3352 static bfd_boolean aout_link_reloc_link_order
3353 PARAMS ((struct aout_final_link_info *, asection *,
3354 struct bfd_link_order *));
3355 static bfd_boolean pdp11_aout_link_input_section
3356 PARAMS ((struct aout_final_link_info *finfo,
3357 bfd *input_bfd,
3358 asection *input_section,
3359 struct pdp11_aout_reloc_external *relocs,
3360 bfd_size_type rel_size,
3361 bfd_byte *contents));
3363 /* The function to create a new entry in the header file hash table. */
3365 static struct bfd_hash_entry *
3366 aout_link_includes_newfunc (entry, table, string)
3367 struct bfd_hash_entry *entry;
3368 struct bfd_hash_table *table;
3369 const char *string;
3371 struct aout_link_includes_entry *ret =
3372 (struct aout_link_includes_entry *) entry;
3374 /* Allocate the structure if it has not already been allocated by a
3375 subclass. */
3376 if (ret == (struct aout_link_includes_entry *) NULL)
3377 ret = ((struct aout_link_includes_entry *)
3378 bfd_hash_allocate (table,
3379 sizeof (struct aout_link_includes_entry)));
3380 if (ret == (struct aout_link_includes_entry *) NULL)
3381 return (struct bfd_hash_entry *) ret;
3383 /* Call the allocation method of the superclass. */
3384 ret = ((struct aout_link_includes_entry *)
3385 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
3386 if (ret)
3388 /* Set local fields. */
3389 ret->totals = NULL;
3392 return (struct bfd_hash_entry *) ret;
3395 /* Do the final link step. This is called on the output BFD. The
3396 INFO structure should point to a list of BFDs linked through the
3397 link_next field which can be used to find each BFD which takes part
3398 in the output. Also, each section in ABFD should point to a list
3399 of bfd_link_order structures which list all the input sections for
3400 the output section. */
3402 bfd_boolean
3403 NAME(aout,final_link) (abfd, info, callback)
3404 bfd *abfd;
3405 struct bfd_link_info *info;
3406 void (*callback) PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *));
3408 struct aout_final_link_info aout_info;
3409 bfd_boolean includes_hash_initialized = FALSE;
3410 register bfd *sub;
3411 bfd_size_type trsize, drsize;
3412 bfd_size_type max_contents_size;
3413 bfd_size_type max_relocs_size;
3414 bfd_size_type max_sym_count;
3415 bfd_size_type text_size;
3416 file_ptr text_end;
3417 register struct bfd_link_order *p;
3418 asection *o;
3419 bfd_boolean have_link_order_relocs;
3421 if (info->shared)
3422 abfd->flags |= DYNAMIC;
3424 aout_info.info = info;
3425 aout_info.output_bfd = abfd;
3426 aout_info.contents = NULL;
3427 aout_info.relocs = NULL;
3428 aout_info.symbol_map = NULL;
3429 aout_info.output_syms = NULL;
3431 if (! bfd_hash_table_init_n (&aout_info.includes.root,
3432 aout_link_includes_newfunc,
3433 251))
3434 goto error_return;
3435 includes_hash_initialized = TRUE;
3437 /* Figure out the largest section size. Also, if generating
3438 relocatable output, count the relocs. */
3439 trsize = 0;
3440 drsize = 0;
3441 max_contents_size = 0;
3442 max_relocs_size = 0;
3443 max_sym_count = 0;
3444 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3446 size_t sz;
3448 if (info->relocatable)
3450 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3452 trsize += exec_hdr (sub)->a_trsize;
3453 drsize += exec_hdr (sub)->a_drsize;
3455 else
3457 /* FIXME: We need to identify the .text and .data sections
3458 and call get_reloc_upper_bound and canonicalize_reloc to
3459 work out the number of relocs needed, and then multiply
3460 by the reloc size. */
3461 (*_bfd_error_handler)
3462 ("%s: relocatable link from %s to %s not supported",
3463 bfd_get_filename (abfd),
3464 sub->xvec->name, abfd->xvec->name);
3465 bfd_set_error (bfd_error_invalid_operation);
3466 goto error_return;
3470 if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3472 sz = bfd_section_size (sub, obj_textsec (sub));
3473 if (sz > max_contents_size)
3474 max_contents_size = sz;
3475 sz = bfd_section_size (sub, obj_datasec (sub));
3476 if (sz > max_contents_size)
3477 max_contents_size = sz;
3479 sz = exec_hdr (sub)->a_trsize;
3480 if (sz > max_relocs_size)
3481 max_relocs_size = sz;
3482 sz = exec_hdr (sub)->a_drsize;
3483 if (sz > max_relocs_size)
3484 max_relocs_size = sz;
3486 sz = obj_aout_external_sym_count (sub);
3487 if (sz > max_sym_count)
3488 max_sym_count = sz;
3492 if (info->relocatable)
3494 if (obj_textsec (abfd) != (asection *) NULL)
3495 trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
3496 ->link_order_head)
3497 * obj_reloc_entry_size (abfd));
3498 if (obj_datasec (abfd) != (asection *) NULL)
3499 drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
3500 ->link_order_head)
3501 * obj_reloc_entry_size (abfd));
3504 exec_hdr (abfd)->a_trsize = trsize;
3505 exec_hdr (abfd)->a_drsize = drsize;
3507 exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
3509 /* Adjust the section sizes and vmas according to the magic number.
3510 This sets a_text, a_data and a_bss in the exec_hdr and sets the
3511 filepos for each section. */
3512 if (! NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
3513 goto error_return;
3515 /* The relocation and symbol file positions differ among a.out
3516 targets. We are passed a callback routine from the backend
3517 specific code to handle this.
3518 FIXME: At this point we do not know how much space the symbol
3519 table will require. This will not work for any (nonstandard)
3520 a.out target that needs to know the symbol table size before it
3521 can compute the relocation file positions. This may or may not
3522 be the case for the hp300hpux target, for example. */
3523 (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
3524 &aout_info.symoff);
3525 obj_textsec (abfd)->rel_filepos = aout_info.treloff;
3526 obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
3527 obj_sym_filepos (abfd) = aout_info.symoff;
3529 /* We keep a count of the symbols as we output them. */
3530 obj_aout_external_sym_count (abfd) = 0;
3532 /* We accumulate the string table as we write out the symbols. */
3533 aout_info.strtab = _bfd_stringtab_init ();
3534 if (aout_info.strtab == NULL)
3535 goto error_return;
3537 /* Allocate buffers to hold section contents and relocs. */
3538 aout_info.contents = (bfd_byte *) bfd_malloc (max_contents_size);
3539 aout_info.relocs = (PTR) bfd_malloc (max_relocs_size);
3540 aout_info.symbol_map = (int *) bfd_malloc (max_sym_count * sizeof (int *));
3541 aout_info.output_syms = ((struct external_nlist *)
3542 bfd_malloc ((max_sym_count + 1)
3543 * sizeof (struct external_nlist)));
3544 if ((aout_info.contents == NULL && max_contents_size != 0)
3545 || (aout_info.relocs == NULL && max_relocs_size != 0)
3546 || (aout_info.symbol_map == NULL && max_sym_count != 0)
3547 || aout_info.output_syms == NULL)
3548 goto error_return;
3550 /* If we have a symbol named __DYNAMIC, force it out now. This is
3551 required by SunOS. Doing this here rather than in sunos.c is a
3552 hack, but it's easier than exporting everything which would be
3553 needed. */
3555 struct aout_link_hash_entry *h;
3557 h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
3558 FALSE, FALSE, FALSE);
3559 if (h != NULL)
3560 aout_link_write_other_symbol (h, &aout_info);
3563 /* The most time efficient way to do the link would be to read all
3564 the input object files into memory and then sort out the
3565 information into the output file. Unfortunately, that will
3566 probably use too much memory. Another method would be to step
3567 through everything that composes the text section and write it
3568 out, and then everything that composes the data section and write
3569 it out, and then write out the relocs, and then write out the
3570 symbols. Unfortunately, that requires reading stuff from each
3571 input file several times, and we will not be able to keep all the
3572 input files open simultaneously, and reopening them will be slow.
3574 What we do is basically process one input file at a time. We do
3575 everything we need to do with an input file once--copy over the
3576 section contents, handle the relocation information, and write
3577 out the symbols--and then we throw away the information we read
3578 from it. This approach requires a lot of lseeks of the output
3579 file, which is unfortunate but still faster than reopening a lot
3580 of files.
3582 We use the output_has_begun field of the input BFDs to see
3583 whether we have already handled it. */
3584 for (sub = info->input_bfds; sub != (bfd *) NULL; sub = sub->link_next)
3585 sub->output_has_begun = FALSE;
3587 /* Mark all sections which are to be included in the link. This
3588 will normally be every section. We need to do this so that we
3589 can identify any sections which the linker has decided to not
3590 include. */
3591 for (o = abfd->sections; o != NULL; o = o->next)
3593 for (p = o->link_order_head; p != NULL; p = p->next)
3595 if (p->type == bfd_indirect_link_order)
3596 p->u.indirect.section->linker_mark = TRUE;
3600 have_link_order_relocs = FALSE;
3601 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3603 for (p = o->link_order_head;
3604 p != (struct bfd_link_order *) NULL;
3605 p = p->next)
3607 if (p->type == bfd_indirect_link_order
3608 && (bfd_get_flavour (p->u.indirect.section->owner)
3609 == bfd_target_aout_flavour))
3611 bfd *input_bfd;
3613 input_bfd = p->u.indirect.section->owner;
3614 if (! input_bfd->output_has_begun)
3616 if (! aout_link_input_bfd (&aout_info, input_bfd))
3617 goto error_return;
3618 input_bfd->output_has_begun = TRUE;
3621 else if (p->type == bfd_section_reloc_link_order
3622 || p->type == bfd_symbol_reloc_link_order)
3624 /* These are handled below. */
3625 have_link_order_relocs = TRUE;
3627 else
3629 if (! _bfd_default_link_order (abfd, info, o, p))
3630 goto error_return;
3635 /* Write out any symbols that we have not already written out. */
3636 aout_link_hash_traverse (aout_hash_table (info),
3637 aout_link_write_other_symbol,
3638 (PTR) &aout_info);
3640 /* Now handle any relocs we were asked to create by the linker.
3641 These did not come from any input file. We must do these after
3642 we have written out all the symbols, so that we know the symbol
3643 indices to use. */
3644 if (have_link_order_relocs)
3646 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3648 for (p = o->link_order_head;
3649 p != (struct bfd_link_order *) NULL;
3650 p = p->next)
3652 if (p->type == bfd_section_reloc_link_order
3653 || p->type == bfd_symbol_reloc_link_order)
3655 if (! aout_link_reloc_link_order (&aout_info, o, p))
3656 goto error_return;
3662 if (aout_info.contents != NULL)
3664 free (aout_info.contents);
3665 aout_info.contents = NULL;
3667 if (aout_info.relocs != NULL)
3669 free (aout_info.relocs);
3670 aout_info.relocs = NULL;
3672 if (aout_info.symbol_map != NULL)
3674 free (aout_info.symbol_map);
3675 aout_info.symbol_map = NULL;
3677 if (aout_info.output_syms != NULL)
3679 free (aout_info.output_syms);
3680 aout_info.output_syms = NULL;
3682 if (includes_hash_initialized)
3684 bfd_hash_table_free (&aout_info.includes.root);
3685 includes_hash_initialized = FALSE;
3688 /* Finish up any dynamic linking we may be doing. */
3689 if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
3691 if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
3692 goto error_return;
3695 /* Update the header information. */
3696 abfd->symcount = obj_aout_external_sym_count (abfd);
3697 exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
3698 obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
3699 obj_textsec (abfd)->reloc_count =
3700 exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
3701 obj_datasec (abfd)->reloc_count =
3702 exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
3704 /* Write out the string table, unless there are no symbols. */
3705 if (abfd->symcount > 0)
3707 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
3708 || ! emit_stringtab (abfd, aout_info.strtab))
3709 goto error_return;
3711 else if (obj_textsec (abfd)->reloc_count == 0
3712 && obj_datasec (abfd)->reloc_count == 0)
3714 bfd_byte b;
3716 b = 0;
3717 if (bfd_seek (abfd,
3718 (file_ptr) (obj_datasec (abfd)->filepos
3719 + exec_hdr (abfd)->a_data
3720 - 1),
3721 SEEK_SET) != 0
3722 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3723 goto error_return;
3726 return TRUE;
3728 error_return:
3729 if (aout_info.contents != NULL)
3730 free (aout_info.contents);
3731 if (aout_info.relocs != NULL)
3732 free (aout_info.relocs);
3733 if (aout_info.symbol_map != NULL)
3734 free (aout_info.symbol_map);
3735 if (aout_info.output_syms != NULL)
3736 free (aout_info.output_syms);
3737 if (includes_hash_initialized)
3738 bfd_hash_table_free (&aout_info.includes.root);
3739 return FALSE;
3742 /* Link an a.out input BFD into the output file. */
3744 static bfd_boolean
3745 aout_link_input_bfd (finfo, input_bfd)
3746 struct aout_final_link_info *finfo;
3747 bfd *input_bfd;
3749 bfd_size_type sym_count;
3751 BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
3753 /* If this is a dynamic object, it may need special handling. */
3754 if ((input_bfd->flags & DYNAMIC) != 0
3755 && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
3757 return ((*aout_backend_info (input_bfd)->link_dynamic_object)
3758 (finfo->info, input_bfd));
3761 /* Get the symbols. We probably have them already, unless
3762 finfo->info->keep_memory is FALSE. */
3763 if (! aout_get_external_symbols (input_bfd))
3764 return FALSE;
3766 sym_count = obj_aout_external_sym_count (input_bfd);
3768 /* Write out the symbols and get a map of the new indices. The map
3769 is placed into finfo->symbol_map. */
3770 if (! aout_link_write_symbols (finfo, input_bfd))
3771 return FALSE;
3773 /* Relocate and write out the sections. These functions use the
3774 symbol map created by aout_link_write_symbols. The linker_mark
3775 field will be set if these sections are to be included in the
3776 link, which will normally be the case. */
3777 if (obj_textsec (input_bfd)->linker_mark)
3779 if (! aout_link_input_section (finfo, input_bfd,
3780 obj_textsec (input_bfd),
3781 &finfo->treloff,
3782 exec_hdr (input_bfd)->a_trsize))
3783 return FALSE;
3785 if (obj_datasec (input_bfd)->linker_mark)
3787 if (! aout_link_input_section (finfo, input_bfd,
3788 obj_datasec (input_bfd),
3789 &finfo->dreloff,
3790 exec_hdr (input_bfd)->a_drsize))
3791 return FALSE;
3794 /* If we are not keeping memory, we don't need the symbols any
3795 longer. We still need them if we are keeping memory, because the
3796 strings in the hash table point into them. */
3797 if (! finfo->info->keep_memory)
3799 if (! aout_link_free_symbols (input_bfd))
3800 return FALSE;
3803 return TRUE;
3806 /* Adjust and write out the symbols for an a.out file. Set the new
3807 symbol indices into a symbol_map. */
3809 static bfd_boolean
3810 aout_link_write_symbols (finfo, input_bfd)
3811 struct aout_final_link_info *finfo;
3812 bfd *input_bfd;
3814 bfd *output_bfd;
3815 bfd_size_type sym_count;
3816 char *strings;
3817 enum bfd_link_strip strip;
3818 enum bfd_link_discard discard;
3819 struct external_nlist *outsym;
3820 bfd_size_type strtab_index;
3821 register struct external_nlist *sym;
3822 struct external_nlist *sym_end;
3823 struct aout_link_hash_entry **sym_hash;
3824 int *symbol_map;
3825 bfd_boolean pass;
3826 bfd_boolean skip_next;
3828 output_bfd = finfo->output_bfd;
3829 sym_count = obj_aout_external_sym_count (input_bfd);
3830 strings = obj_aout_external_strings (input_bfd);
3831 strip = finfo->info->strip;
3832 discard = finfo->info->discard;
3833 outsym = finfo->output_syms;
3835 /* First write out a symbol for this object file, unless we are
3836 discarding such symbols. */
3837 if (strip != strip_all
3838 && (strip != strip_some
3839 || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
3840 FALSE, FALSE) != NULL)
3841 && discard != discard_all)
3843 H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
3844 strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
3845 input_bfd->filename, FALSE);
3846 if (strtab_index == (bfd_size_type) -1)
3847 return FALSE;
3848 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
3849 PUT_WORD (output_bfd,
3850 (bfd_get_section_vma (output_bfd,
3851 obj_textsec (input_bfd)->output_section)
3852 + obj_textsec (input_bfd)->output_offset),
3853 outsym->e_value);
3854 ++obj_aout_external_sym_count (output_bfd);
3855 ++outsym;
3858 pass = FALSE;
3859 skip_next = FALSE;
3860 sym = obj_aout_external_syms (input_bfd);
3861 sym_end = sym + sym_count;
3862 sym_hash = obj_aout_sym_hashes (input_bfd);
3863 symbol_map = finfo->symbol_map;
3864 memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
3865 for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
3867 const char *name;
3868 int type;
3869 struct aout_link_hash_entry *h;
3870 bfd_boolean skip;
3871 asection *symsec;
3872 bfd_vma val = 0;
3873 bfd_boolean copy;
3875 /* We set *symbol_map to 0 above for all symbols. If it has
3876 already been set to -1 for this symbol, it means that we are
3877 discarding it because it appears in a duplicate header file.
3878 See the N_BINCL code below. */
3879 if (*symbol_map == -1)
3880 continue;
3882 /* Initialize *symbol_map to -1, which means that the symbol was
3883 not copied into the output file. We will change it later if
3884 we do copy the symbol over. */
3885 *symbol_map = -1;
3887 type = H_GET_8 (input_bfd, sym->e_type);
3888 name = strings + GET_WORD (input_bfd, sym->e_strx);
3890 h = NULL;
3892 if (pass)
3894 /* Pass this symbol through. It is the target of an
3895 indirect or warning symbol. */
3896 val = GET_WORD (input_bfd, sym->e_value);
3897 pass = FALSE;
3899 else if (skip_next)
3901 /* Skip this symbol, which is the target of an indirect
3902 symbol that we have changed to no longer be an indirect
3903 symbol. */
3904 skip_next = FALSE;
3905 continue;
3907 else
3909 struct aout_link_hash_entry *hresolve;
3911 /* We have saved the hash table entry for this symbol, if
3912 there is one. Note that we could just look it up again
3913 in the hash table, provided we first check that it is an
3914 external symbol. */
3915 h = *sym_hash;
3917 /* Use the name from the hash table, in case the symbol was
3918 wrapped. */
3919 if (h != NULL)
3920 name = h->root.root.string;
3922 /* If this is an indirect or warning symbol, then change
3923 hresolve to the base symbol. We also change *sym_hash so
3924 that the relocation routines relocate against the real
3925 symbol. */
3926 hresolve = h;
3927 if (h != (struct aout_link_hash_entry *) NULL
3928 && (h->root.type == bfd_link_hash_indirect
3929 || h->root.type == bfd_link_hash_warning))
3931 hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
3932 while (hresolve->root.type == bfd_link_hash_indirect
3933 || hresolve->root.type == bfd_link_hash_warning)
3934 hresolve = ((struct aout_link_hash_entry *)
3935 hresolve->root.u.i.link);
3936 *sym_hash = hresolve;
3939 /* If the symbol has already been written out, skip it. */
3940 if (h != (struct aout_link_hash_entry *) NULL
3941 && h->root.type != bfd_link_hash_warning
3942 && h->written)
3944 if ((type & N_TYPE) == N_INDR
3945 || type == N_WARNING)
3946 skip_next = TRUE;
3947 *symbol_map = h->indx;
3948 continue;
3951 /* See if we are stripping this symbol. */
3952 skip = FALSE;
3953 switch (strip)
3955 case strip_none:
3956 break;
3957 case strip_debugger:
3958 if ((type & N_STAB) != 0)
3959 skip = TRUE;
3960 break;
3961 case strip_some:
3962 if (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
3963 == NULL)
3964 skip = TRUE;
3965 break;
3966 case strip_all:
3967 skip = TRUE;
3968 break;
3970 if (skip)
3972 if (h != (struct aout_link_hash_entry *) NULL)
3973 h->written = TRUE;
3974 continue;
3977 /* Get the value of the symbol. */
3978 if ((type & N_TYPE) == N_TEXT
3979 || type == N_WEAKT)
3980 symsec = obj_textsec (input_bfd);
3981 else if ((type & N_TYPE) == N_DATA
3982 || type == N_WEAKD)
3983 symsec = obj_datasec (input_bfd);
3984 else if ((type & N_TYPE) == N_BSS
3985 || type == N_WEAKB)
3986 symsec = obj_bsssec (input_bfd);
3987 else if ((type & N_TYPE) == N_ABS
3988 || type == N_WEAKA)
3989 symsec = bfd_abs_section_ptr;
3990 else if (((type & N_TYPE) == N_INDR
3991 && (hresolve == (struct aout_link_hash_entry *) NULL
3992 || (hresolve->root.type != bfd_link_hash_defined
3993 && hresolve->root.type != bfd_link_hash_defweak
3994 && hresolve->root.type != bfd_link_hash_common)))
3995 || type == N_WARNING)
3997 /* Pass the next symbol through unchanged. The
3998 condition above for indirect symbols is so that if
3999 the indirect symbol was defined, we output it with
4000 the correct definition so the debugger will
4001 understand it. */
4002 pass = TRUE;
4003 val = GET_WORD (input_bfd, sym->e_value);
4004 symsec = NULL;
4006 else if ((type & N_STAB) != 0)
4008 val = GET_WORD (input_bfd, sym->e_value);
4009 symsec = NULL;
4011 else
4013 /* If we get here with an indirect symbol, it means that
4014 we are outputting it with a real definition. In such
4015 a case we do not want to output the next symbol,
4016 which is the target of the indirection. */
4017 if ((type & N_TYPE) == N_INDR)
4018 skip_next = TRUE;
4020 symsec = NULL;
4022 /* We need to get the value from the hash table. We use
4023 hresolve so that if we have defined an indirect
4024 symbol we output the final definition. */
4025 if (h == (struct aout_link_hash_entry *) NULL)
4027 switch (type & N_TYPE)
4029 case N_SETT:
4030 symsec = obj_textsec (input_bfd);
4031 break;
4032 case N_SETD:
4033 symsec = obj_datasec (input_bfd);
4034 break;
4035 case N_SETB:
4036 symsec = obj_bsssec (input_bfd);
4037 break;
4038 case N_SETA:
4039 symsec = bfd_abs_section_ptr;
4040 break;
4041 default:
4042 val = 0;
4043 break;
4046 else if (hresolve->root.type == bfd_link_hash_defined
4047 || hresolve->root.type == bfd_link_hash_defweak)
4049 asection *input_section;
4050 asection *output_section;
4052 /* This case usually means a common symbol which was
4053 turned into a defined symbol. */
4054 input_section = hresolve->root.u.def.section;
4055 output_section = input_section->output_section;
4056 BFD_ASSERT (bfd_is_abs_section (output_section)
4057 || output_section->owner == output_bfd);
4058 val = (hresolve->root.u.def.value
4059 + bfd_get_section_vma (output_bfd, output_section)
4060 + input_section->output_offset);
4062 /* Get the correct type based on the section. If
4063 this is a constructed set, force it to be
4064 globally visible. */
4065 if (type == N_SETT
4066 || type == N_SETD
4067 || type == N_SETB
4068 || type == N_SETA)
4069 type |= N_EXT;
4071 type &=~ N_TYPE;
4073 if (output_section == obj_textsec (output_bfd))
4074 type |= (hresolve->root.type == bfd_link_hash_defined
4075 ? N_TEXT
4076 : N_WEAKT);
4077 else if (output_section == obj_datasec (output_bfd))
4078 type |= (hresolve->root.type == bfd_link_hash_defined
4079 ? N_DATA
4080 : N_WEAKD);
4081 else if (output_section == obj_bsssec (output_bfd))
4082 type |= (hresolve->root.type == bfd_link_hash_defined
4083 ? N_BSS
4084 : N_WEAKB);
4085 else
4086 type |= (hresolve->root.type == bfd_link_hash_defined
4087 ? N_ABS
4088 : N_WEAKA);
4090 else if (hresolve->root.type == bfd_link_hash_common)
4091 val = hresolve->root.u.c.size;
4092 else if (hresolve->root.type == bfd_link_hash_undefweak)
4094 val = 0;
4095 type = N_WEAKU;
4097 else
4098 val = 0;
4100 if (symsec != (asection *) NULL)
4101 val = (symsec->output_section->vma
4102 + symsec->output_offset
4103 + (GET_WORD (input_bfd, sym->e_value)
4104 - symsec->vma));
4106 /* If this is a global symbol set the written flag, and if
4107 it is a local symbol see if we should discard it. */
4108 if (h != (struct aout_link_hash_entry *) NULL)
4110 h->written = TRUE;
4111 h->indx = obj_aout_external_sym_count (output_bfd);
4113 else if ((type & N_TYPE) != N_SETT
4114 && (type & N_TYPE) != N_SETD
4115 && (type & N_TYPE) != N_SETB
4116 && (type & N_TYPE) != N_SETA)
4118 switch (discard)
4120 case discard_none:
4121 case discard_sec_merge:
4122 break;
4123 case discard_l:
4124 if ((type & N_STAB) == 0
4125 && bfd_is_local_label_name (input_bfd, name))
4126 skip = TRUE;
4127 break;
4128 case discard_all:
4129 skip = TRUE;
4130 break;
4132 if (skip)
4134 pass = FALSE;
4135 continue;
4139 /* An N_BINCL symbol indicates the start of the stabs
4140 entries for a header file. We need to scan ahead to the
4141 next N_EINCL symbol, ignoring nesting, adding up all the
4142 characters in the symbol names, not including the file
4143 numbers in types (the first number after an open
4144 parenthesis). */
4145 if (type == N_BINCL)
4147 struct external_nlist *incl_sym;
4148 int nest;
4149 struct aout_link_includes_entry *incl_entry;
4150 struct aout_link_includes_totals *t;
4152 val = 0;
4153 nest = 0;
4154 for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
4156 int incl_type;
4158 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
4159 if (incl_type == N_EINCL)
4161 if (nest == 0)
4162 break;
4163 --nest;
4165 else if (incl_type == N_BINCL)
4166 ++nest;
4167 else if (nest == 0)
4169 const char *s;
4171 s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
4172 for (; *s != '\0'; s++)
4174 val += *s;
4175 if (*s == '(')
4177 /* Skip the file number. */
4178 ++s;
4179 while (ISDIGIT (*s))
4180 ++s;
4181 --s;
4187 /* If we have already included a header file with the
4188 same value, then replace this one with an N_EXCL
4189 symbol. */
4190 copy = ! finfo->info->keep_memory;
4191 incl_entry = aout_link_includes_lookup (&finfo->includes,
4192 name, TRUE, copy);
4193 if (incl_entry == NULL)
4194 return FALSE;
4195 for (t = incl_entry->totals; t != NULL; t = t->next)
4196 if (t->total == val)
4197 break;
4198 if (t == NULL)
4200 /* This is the first time we have seen this header
4201 file with this set of stabs strings. */
4202 t = ((struct aout_link_includes_totals *)
4203 bfd_hash_allocate (&finfo->includes.root,
4204 sizeof *t));
4205 if (t == NULL)
4206 return FALSE;
4207 t->total = val;
4208 t->next = incl_entry->totals;
4209 incl_entry->totals = t;
4211 else
4213 int *incl_map;
4215 /* This is a duplicate header file. We must change
4216 it to be an N_EXCL entry, and mark all the
4217 included symbols to prevent outputting them. */
4218 type = N_EXCL;
4220 nest = 0;
4221 for (incl_sym = sym + 1, incl_map = symbol_map + 1;
4222 incl_sym < sym_end;
4223 incl_sym++, incl_map++)
4225 int incl_type;
4227 incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
4228 if (incl_type == N_EINCL)
4230 if (nest == 0)
4232 *incl_map = -1;
4233 break;
4235 --nest;
4237 else if (incl_type == N_BINCL)
4238 ++nest;
4239 else if (nest == 0)
4240 *incl_map = -1;
4246 /* Copy this symbol into the list of symbols we are going to
4247 write out. */
4248 H_PUT_8 (output_bfd, type, outsym->e_type);
4249 copy = FALSE;
4250 if (! finfo->info->keep_memory)
4252 /* name points into a string table which we are going to
4253 free. If there is a hash table entry, use that string.
4254 Otherwise, copy name into memory. */
4255 if (h != (struct aout_link_hash_entry *) NULL)
4256 name = h->root.root.string;
4257 else
4258 copy = TRUE;
4260 strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4261 name, copy);
4262 if (strtab_index == (bfd_size_type) -1)
4263 return FALSE;
4264 PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4265 PUT_WORD (output_bfd, val, outsym->e_value);
4266 *symbol_map = obj_aout_external_sym_count (output_bfd);
4267 ++obj_aout_external_sym_count (output_bfd);
4268 ++outsym;
4271 /* Write out the output symbols we have just constructed. */
4272 if (outsym > finfo->output_syms)
4274 bfd_size_type size;
4276 if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
4277 return FALSE;
4278 size = outsym - finfo->output_syms;
4279 size *= EXTERNAL_NLIST_SIZE;
4280 if (bfd_bwrite ((PTR) finfo->output_syms, size, output_bfd) != size)
4281 return FALSE;
4282 finfo->symoff += size;
4285 return TRUE;
4288 /* Write out a symbol that was not associated with an a.out input
4289 object. */
4291 static bfd_boolean
4292 aout_link_write_other_symbol (h, data)
4293 struct aout_link_hash_entry *h;
4294 PTR data;
4296 struct aout_final_link_info *finfo = (struct aout_final_link_info *) data;
4297 bfd *output_bfd;
4298 int type;
4299 bfd_vma val;
4300 struct external_nlist outsym;
4301 bfd_size_type indx;
4302 bfd_size_type amt;
4304 if (h->root.type == bfd_link_hash_warning)
4306 h = (struct aout_link_hash_entry *) h->root.u.i.link;
4307 if (h->root.type == bfd_link_hash_new)
4308 return TRUE;
4311 output_bfd = finfo->output_bfd;
4313 if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
4315 if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
4316 (output_bfd, finfo->info, h)))
4318 /* FIXME: No way to handle errors. */
4319 abort ();
4323 if (h->written)
4324 return TRUE;
4326 h->written = TRUE;
4328 /* An indx of -2 means the symbol must be written. */
4329 if (h->indx != -2
4330 && (finfo->info->strip == strip_all
4331 || (finfo->info->strip == strip_some
4332 && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
4333 FALSE, FALSE) == NULL)))
4334 return TRUE;
4336 switch (h->root.type)
4338 default:
4339 abort ();
4340 /* Avoid variable not initialized warnings. */
4341 return TRUE;
4342 case bfd_link_hash_new:
4343 /* This can happen for set symbols when sets are not being
4344 built. */
4345 return TRUE;
4346 case bfd_link_hash_undefined:
4347 type = N_UNDF | N_EXT;
4348 val = 0;
4349 break;
4350 case bfd_link_hash_defined:
4351 case bfd_link_hash_defweak:
4353 asection *sec;
4355 sec = h->root.u.def.section->output_section;
4356 BFD_ASSERT (bfd_is_abs_section (sec)
4357 || sec->owner == output_bfd);
4358 if (sec == obj_textsec (output_bfd))
4359 type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
4360 else if (sec == obj_datasec (output_bfd))
4361 type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
4362 else if (sec == obj_bsssec (output_bfd))
4363 type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
4364 else
4365 type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
4366 type |= N_EXT;
4367 val = (h->root.u.def.value
4368 + sec->vma
4369 + h->root.u.def.section->output_offset);
4371 break;
4372 case bfd_link_hash_common:
4373 type = N_UNDF | N_EXT;
4374 val = h->root.u.c.size;
4375 break;
4376 case bfd_link_hash_undefweak:
4377 type = N_WEAKU;
4378 val = 0;
4379 case bfd_link_hash_indirect:
4380 case bfd_link_hash_warning:
4381 /* FIXME: Ignore these for now. The circumstances under which
4382 they should be written out are not clear to me. */
4383 return TRUE;
4386 H_PUT_8 (output_bfd, type, outsym.e_type);
4387 indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
4388 FALSE);
4389 if (indx == (bfd_size_type) -1)
4391 /* FIXME: No way to handle errors. */
4392 abort ();
4394 PUT_WORD (output_bfd, indx, outsym.e_strx);
4395 PUT_WORD (output_bfd, val, outsym.e_value);
4397 amt = EXTERNAL_NLIST_SIZE;
4398 if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0
4399 || bfd_bwrite ((PTR) &outsym, amt, output_bfd) != amt)
4401 /* FIXME: No way to handle errors. */
4402 abort ();
4405 finfo->symoff += amt;
4406 h->indx = obj_aout_external_sym_count (output_bfd);
4407 ++obj_aout_external_sym_count (output_bfd);
4409 return TRUE;
4412 /* Link an a.out section into the output file. */
4414 static bfd_boolean
4415 aout_link_input_section (finfo, input_bfd, input_section, reloff_ptr,
4416 rel_size)
4417 struct aout_final_link_info *finfo;
4418 bfd *input_bfd;
4419 asection *input_section;
4420 file_ptr *reloff_ptr;
4421 bfd_size_type rel_size;
4423 bfd_size_type input_size;
4424 PTR relocs;
4426 /* Get the section contents. */
4427 input_size = bfd_section_size (input_bfd, input_section);
4428 if (! bfd_get_section_contents (input_bfd, input_section,
4429 (PTR) finfo->contents,
4430 (file_ptr) 0, input_size))
4431 return FALSE;
4433 /* Read in the relocs if we haven't already done it. */
4434 if (aout_section_data (input_section) != NULL
4435 && aout_section_data (input_section)->relocs != NULL)
4436 relocs = aout_section_data (input_section)->relocs;
4437 else
4439 relocs = finfo->relocs;
4440 if (rel_size > 0)
4442 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
4443 || bfd_bread (relocs, rel_size, input_bfd) != rel_size)
4444 return FALSE;
4448 /* Relocate the section contents. */
4449 if (! pdp11_aout_link_input_section (finfo, input_bfd, input_section,
4450 (struct pdp11_aout_reloc_external *) relocs,
4451 rel_size, finfo->contents))
4452 return FALSE;
4454 /* Write out the section contents. */
4455 if (! bfd_set_section_contents (finfo->output_bfd,
4456 input_section->output_section,
4457 (PTR) finfo->contents,
4458 (file_ptr) input_section->output_offset,
4459 input_size))
4460 return FALSE;
4462 /* If we are producing relocatable output, the relocs were
4463 modified, and we now write them out. */
4464 if (finfo->info->relocatable && rel_size > 0)
4466 if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
4467 return FALSE;
4468 if (bfd_bwrite (relocs, rel_size, finfo->output_bfd) != rel_size)
4469 return FALSE;
4470 *reloff_ptr += rel_size;
4472 /* Assert that the relocs have not run into the symbols, and
4473 that if these are the text relocs they have not run into the
4474 data relocs. */
4475 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
4476 && (reloff_ptr != &finfo->treloff
4477 || (*reloff_ptr
4478 <= obj_datasec (finfo->output_bfd)->rel_filepos)));
4481 return TRUE;
4484 /* Get the section corresponding to a reloc index. */
4486 static INLINE asection *
4487 aout_reloc_type_to_section (abfd, type)
4488 bfd *abfd;
4489 int type;
4491 switch (type)
4493 case RTEXT:
4494 return obj_textsec (abfd);
4495 case RDATA:
4496 return obj_datasec (abfd);
4497 case RBSS:
4498 return obj_bsssec (abfd);
4499 case RABS:
4500 return bfd_abs_section_ptr;
4501 case REXT:
4502 return bfd_und_section_ptr;
4503 default:
4504 abort ();
4508 static bfd_boolean
4509 pdp11_aout_link_input_section (finfo, input_bfd, input_section, relocs,
4510 rel_size, contents)
4511 struct aout_final_link_info *finfo;
4512 bfd *input_bfd;
4513 asection *input_section;
4514 struct pdp11_aout_reloc_external *relocs;
4515 bfd_size_type rel_size;
4516 bfd_byte *contents;
4518 bfd_boolean (*check_dynamic_reloc)
4519 PARAMS ((struct bfd_link_info *, bfd *, asection *,
4520 struct aout_link_hash_entry *, PTR, bfd_byte *, bfd_boolean *,
4521 bfd_vma *));
4522 bfd *output_bfd;
4523 bfd_boolean relocatable;
4524 struct external_nlist *syms;
4525 char *strings;
4526 struct aout_link_hash_entry **sym_hashes;
4527 int *symbol_map;
4528 bfd_size_type reloc_count;
4529 register struct pdp11_aout_reloc_external *rel;
4530 struct pdp11_aout_reloc_external *rel_end;
4532 output_bfd = finfo->output_bfd;
4533 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
4535 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_SIZE);
4536 BFD_ASSERT (input_bfd->xvec->header_byteorder
4537 == output_bfd->xvec->header_byteorder);
4539 relocatable = finfo->info->relocatable;
4540 syms = obj_aout_external_syms (input_bfd);
4541 strings = obj_aout_external_strings (input_bfd);
4542 sym_hashes = obj_aout_sym_hashes (input_bfd);
4543 symbol_map = finfo->symbol_map;
4545 reloc_count = rel_size / RELOC_SIZE;
4546 rel = relocs;
4547 rel_end = (struct pdp11_aout_reloc_external *)(((char *)rel) + rel_size);
4548 for (; rel < rel_end; ((char *)rel) += RELOC_SIZE)
4550 bfd_vma r_addr;
4551 int r_index;
4552 int r_type;
4553 int r_pcrel;
4554 int r_extern;
4555 reloc_howto_type *howto;
4556 struct aout_link_hash_entry *h = NULL;
4557 bfd_vma relocation;
4558 bfd_reloc_status_type r;
4559 int reloc_entry;
4561 reloc_entry = GET_WORD (input_bfd, (PTR)rel);
4562 if (reloc_entry == 0)
4563 continue;
4566 unsigned int howto_idx;
4568 r_index = (reloc_entry & RIDXMASK) >> 4;
4569 r_type = reloc_entry & RTYPE;
4570 r_pcrel = reloc_entry & RELFLG;
4571 r_addr = (char *)rel - (char *)relocs;
4573 r_extern = (r_type == REXT);
4575 howto_idx = r_pcrel;
4576 BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_pdp11));
4577 howto = howto_table_pdp11 + howto_idx;
4580 if (relocatable)
4582 /* We are generating a relocatable output file, and must
4583 modify the reloc accordingly. */
4584 if (r_extern)
4586 /* If we know the symbol this relocation is against,
4587 convert it into a relocation against a section. This
4588 is what the native linker does. */
4589 h = sym_hashes[r_index];
4590 if (h != (struct aout_link_hash_entry *) NULL
4591 && (h->root.type == bfd_link_hash_defined
4592 || h->root.type == bfd_link_hash_defweak))
4594 asection *output_section;
4596 /* Compute a new r_index. */
4597 output_section = h->root.u.def.section->output_section;
4598 if (output_section == obj_textsec (output_bfd))
4599 r_type = N_TEXT;
4600 else if (output_section == obj_datasec (output_bfd))
4601 r_type = N_DATA;
4602 else if (output_section == obj_bsssec (output_bfd))
4603 r_type = N_BSS;
4604 else
4605 r_type = N_ABS;
4607 /* Add the symbol value and the section VMA to the
4608 addend stored in the contents. */
4609 relocation = (h->root.u.def.value
4610 + output_section->vma
4611 + h->root.u.def.section->output_offset);
4613 else
4615 /* We must change r_index according to the symbol
4616 map. */
4617 r_index = symbol_map[r_index];
4619 if (r_index == -1)
4621 if (h != NULL)
4623 /* We decided to strip this symbol, but it
4624 turns out that we can't. Note that we
4625 lose the other and desc information here.
4626 I don't think that will ever matter for a
4627 global symbol. */
4628 if (h->indx < 0)
4630 h->indx = -2;
4631 h->written = FALSE;
4632 if (! aout_link_write_other_symbol (h,
4633 (PTR) finfo))
4634 return FALSE;
4636 r_index = h->indx;
4638 else
4640 const char *name;
4642 name = strings + GET_WORD (input_bfd,
4643 syms[r_index].e_strx);
4644 if (! ((*finfo->info->callbacks->unattached_reloc)
4645 (finfo->info, name, input_bfd, input_section,
4646 r_addr)))
4647 return FALSE;
4648 r_index = 0;
4652 relocation = 0;
4655 /* Write out the new r_index value. */
4656 reloc_entry = GET_WORD (input_bfd, rel->e_reloc_entry);
4657 reloc_entry &= RIDXMASK;
4658 reloc_entry |= r_index << 4;
4659 PUT_WORD (input_bfd, reloc_entry, rel->e_reloc_entry);
4661 else
4663 asection *section;
4665 /* This is a relocation against a section. We must
4666 adjust by the amount that the section moved. */
4667 section = aout_reloc_type_to_section (input_bfd, r_type);
4668 relocation = (section->output_section->vma
4669 + section->output_offset
4670 - section->vma);
4673 /* Change the address of the relocation. */
4674 #if 0
4675 PUT_WORD (output_bfd,
4676 r_addr + input_section->output_offset,
4677 rel->r_address);
4678 #else
4679 fprintf (stderr, "TODO: change the address of the relocation\n");
4680 #endif
4682 /* Adjust a PC relative relocation by removing the reference
4683 to the original address in the section and including the
4684 reference to the new address. */
4685 if (r_pcrel)
4686 relocation -= (input_section->output_section->vma
4687 + input_section->output_offset
4688 - input_section->vma);
4690 #ifdef MY_relocatable_reloc
4691 MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
4692 #endif
4694 if (relocation == 0)
4695 r = bfd_reloc_ok;
4696 else
4697 r = MY_relocate_contents (howto,
4698 input_bfd, relocation,
4699 contents + r_addr);
4701 else
4703 bfd_boolean hundef;
4705 /* We are generating an executable, and must do a full
4706 relocation. */
4707 hundef = FALSE;
4708 if (r_extern)
4710 h = sym_hashes[r_index];
4712 if (h != (struct aout_link_hash_entry *) NULL
4713 && (h->root.type == bfd_link_hash_defined
4714 || h->root.type == bfd_link_hash_defweak))
4716 relocation = (h->root.u.def.value
4717 + h->root.u.def.section->output_section->vma
4718 + h->root.u.def.section->output_offset);
4720 else if (h != (struct aout_link_hash_entry *) NULL
4721 && h->root.type == bfd_link_hash_undefweak)
4722 relocation = 0;
4723 else
4725 hundef = TRUE;
4726 relocation = 0;
4729 else
4731 asection *section;
4733 section = aout_reloc_type_to_section (input_bfd, r_type);
4734 relocation = (section->output_section->vma
4735 + section->output_offset
4736 - section->vma);
4737 if (r_pcrel)
4738 relocation += input_section->vma;
4741 if (check_dynamic_reloc != NULL)
4743 bfd_boolean skip;
4745 if (! ((*check_dynamic_reloc)
4746 (finfo->info, input_bfd, input_section, h,
4747 (PTR) rel, contents, &skip, &relocation)))
4748 return FALSE;
4749 if (skip)
4750 continue;
4753 /* Now warn if a global symbol is undefined. We could not
4754 do this earlier, because check_dynamic_reloc might want
4755 to skip this reloc. */
4756 if (hundef && ! finfo->info->shared)
4758 const char *name;
4760 if (h != NULL)
4761 name = h->root.root.string;
4762 else
4763 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
4764 if (! ((*finfo->info->callbacks->undefined_symbol)
4765 (finfo->info, name, input_bfd, input_section,
4766 r_addr, TRUE)))
4767 return FALSE;
4770 r = MY_final_link_relocate (howto,
4771 input_bfd, input_section,
4772 contents, r_addr, relocation,
4773 (bfd_vma) 0);
4776 if (r != bfd_reloc_ok)
4778 switch (r)
4780 default:
4781 case bfd_reloc_outofrange:
4782 abort ();
4783 case bfd_reloc_overflow:
4785 const char *name;
4787 if (h != NULL)
4788 name = h->root.root.string;
4789 else if (r_extern)
4790 name = strings + GET_WORD (input_bfd,
4791 syms[r_index].e_strx);
4792 else
4794 asection *s;
4796 s = aout_reloc_type_to_section (input_bfd, r_type);
4797 name = bfd_section_name (input_bfd, s);
4799 if (! ((*finfo->info->callbacks->reloc_overflow)
4800 (finfo->info, name, howto->name,
4801 (bfd_vma) 0, input_bfd, input_section, r_addr)))
4802 return FALSE;
4804 break;
4809 return TRUE;
4812 /* Handle a link order which is supposed to generate a reloc. */
4814 static bfd_boolean
4815 aout_link_reloc_link_order (finfo, o, p)
4816 struct aout_final_link_info *finfo;
4817 asection *o;
4818 struct bfd_link_order *p;
4820 struct bfd_link_order_reloc *pr;
4821 int r_index;
4822 int r_extern;
4823 reloc_howto_type *howto;
4824 file_ptr *reloff_ptr;
4825 struct reloc_std_external srel;
4826 PTR rel_ptr;
4827 bfd_size_type rel_size;
4829 pr = p->u.reloc.p;
4831 if (p->type == bfd_section_reloc_link_order)
4833 r_extern = 0;
4834 if (bfd_is_abs_section (pr->u.section))
4835 r_index = N_ABS | N_EXT;
4836 else
4838 BFD_ASSERT (pr->u.section->owner == finfo->output_bfd);
4839 r_index = pr->u.section->target_index;
4842 else
4844 struct aout_link_hash_entry *h;
4846 BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
4847 r_extern = 1;
4848 h = ((struct aout_link_hash_entry *)
4849 bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
4850 pr->u.name, FALSE, FALSE, TRUE));
4851 if (h != (struct aout_link_hash_entry *) NULL
4852 && h->indx >= 0)
4853 r_index = h->indx;
4854 else if (h != NULL)
4856 /* We decided to strip this symbol, but it turns out that we
4857 can't. Note that we lose the other and desc information
4858 here. I don't think that will ever matter for a global
4859 symbol. */
4860 h->indx = -2;
4861 h->written = FALSE;
4862 if (! aout_link_write_other_symbol (h, (PTR) finfo))
4863 return FALSE;
4864 r_index = h->indx;
4866 else
4868 if (! ((*finfo->info->callbacks->unattached_reloc)
4869 (finfo->info, pr->u.name, (bfd *) NULL,
4870 (asection *) NULL, (bfd_vma) 0)))
4871 return FALSE;
4872 r_index = 0;
4876 howto = bfd_reloc_type_lookup (finfo->output_bfd, pr->reloc);
4877 if (howto == 0)
4879 bfd_set_error (bfd_error_bad_value);
4880 return FALSE;
4883 if (o == obj_textsec (finfo->output_bfd))
4884 reloff_ptr = &finfo->treloff;
4885 else if (o == obj_datasec (finfo->output_bfd))
4886 reloff_ptr = &finfo->dreloff;
4887 else
4888 abort ();
4890 #ifdef MY_put_reloc
4891 MY_put_reloc(finfo->output_bfd, r_extern, r_index, p->offset, howto,
4892 &srel);
4893 #else
4895 int r_pcrel;
4896 int r_baserel;
4897 int r_jmptable;
4898 int r_relative;
4899 int r_length;
4901 fprintf (stderr, "TODO: line %d in bfd/pdp11.c\n", __LINE__);
4903 r_pcrel = howto->pc_relative;
4904 r_baserel = (howto->type & 8) != 0;
4905 r_jmptable = (howto->type & 16) != 0;
4906 r_relative = (howto->type & 32) != 0;
4907 r_length = howto->size;
4909 PUT_WORD (finfo->output_bfd, p->offset, srel.r_address);
4910 if (bfd_header_big_endian (finfo->output_bfd))
4912 srel.r_index[0] = r_index >> 16;
4913 srel.r_index[1] = r_index >> 8;
4914 srel.r_index[2] = r_index;
4915 srel.r_type[0] =
4916 ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
4917 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
4918 | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
4919 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
4920 | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
4921 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
4923 else
4925 srel.r_index[2] = r_index >> 16;
4926 srel.r_index[1] = r_index >> 8;
4927 srel.r_index[0] = r_index;
4928 srel.r_type[0] =
4929 ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
4930 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
4931 | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
4932 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
4933 | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
4934 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
4937 #endif
4938 rel_ptr = (PTR) &srel;
4940 /* We have to write the addend into the object file, since
4941 standard a.out relocs are in place. It would be more
4942 reliable if we had the current contents of the file here,
4943 rather than assuming zeroes, but we can't read the file since
4944 it was opened using bfd_openw. */
4945 if (pr->addend != 0)
4947 bfd_size_type size;
4948 bfd_reloc_status_type r;
4949 bfd_byte *buf;
4950 bfd_boolean ok;
4952 size = bfd_get_reloc_size (howto);
4953 buf = (bfd_byte *) bfd_zmalloc (size);
4954 if (buf == (bfd_byte *) NULL)
4955 return FALSE;
4956 r = MY_relocate_contents (howto, finfo->output_bfd,
4957 pr->addend, buf);
4958 switch (r)
4960 case bfd_reloc_ok:
4961 break;
4962 default:
4963 case bfd_reloc_outofrange:
4964 abort ();
4965 case bfd_reloc_overflow:
4966 if (! ((*finfo->info->callbacks->reloc_overflow)
4967 (finfo->info,
4968 (p->type == bfd_section_reloc_link_order
4969 ? bfd_section_name (finfo->output_bfd,
4970 pr->u.section)
4971 : pr->u.name),
4972 howto->name, pr->addend, (bfd *) NULL,
4973 (asection *) NULL, (bfd_vma) 0)))
4975 free (buf);
4976 return FALSE;
4978 break;
4980 ok = bfd_set_section_contents (finfo->output_bfd, o,
4981 (PTR) buf,
4982 (file_ptr) p->offset,
4983 size);
4984 free (buf);
4985 if (! ok)
4986 return FALSE;
4989 rel_size = obj_reloc_entry_size (finfo->output_bfd);
4990 if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
4991 || bfd_bwrite (rel_ptr, rel_size, finfo->output_bfd) != rel_size)
4992 return FALSE;
4994 *reloff_ptr += rel_size;
4996 /* Assert that the relocs have not run into the symbols, and that n
4997 the text relocs have not run into the data relocs. */
4998 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
4999 && (reloff_ptr != &finfo->treloff
5000 || (*reloff_ptr
5001 <= obj_datasec (finfo->output_bfd)->rel_filepos)));
5003 return TRUE;
5005 /* end of modified aoutx.h */
5007 bfd_vma
5008 bfd_getp32 (addr)
5009 const bfd_byte *addr;
5011 return (((((bfd_vma)addr[1] << 8) | addr[0]) << 8)
5012 | addr[3]) << 8 | addr[2];
5015 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
5017 bfd_signed_vma
5018 bfd_getp_signed_32 (addr)
5019 const bfd_byte *addr;
5021 return COERCE32((((((bfd_vma)addr[1] << 8) | addr[0]) << 8)
5022 | addr[3]) << 8 | addr[2]);
5025 void
5026 bfd_putp32 (data, addr)
5027 bfd_vma data;
5028 bfd_byte *addr;
5030 addr[0] = (bfd_byte)(data >> 16);
5031 addr[1] = (bfd_byte)(data >> 24);
5032 addr[2] = (bfd_byte)data;
5033 addr[3] = (bfd_byte)(data >> 8);