2 /* BFD semi-generic back-end for a.out binaries
3 Copyright (C) 1990-1991 Free Software Foundation, Inc.
4 Written by Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
29 BFD supports a number of different flavours of a.out format,
30 though the major differences are only the sizes of the
31 structures on disk, and the shape of the relocation
34 The support is split into a basic support file @code{aoutx.h}
35 and other files which derive functions from the base. One
36 derivation file is @code{aoutf1.h} (for a.out flavour 1), and
37 adds to the basic a.out functions support for sun3, sun4, 386
38 and 29k a.out files, to create a target jump vector for a
41 This information is further split out into more specific files
42 for each machine, including @code{sunos.c} for sun3 and sun4,
43 @code{newsos3.c} for the Sony NEWS, and @code{demo64.c} for a
44 demonstration of a 64 bit a.out format.
46 The base file @code{aoutx.h} defines general mechanisms for
47 reading and writing records to and from disk, and various
48 other methods which BFD requires. It is included by
49 @code{aout32.c} and @code{aout64.c} to form the names
50 aout_32_swap_exec_header_in, aout_64_swap_exec_header_in, etc.
52 As an example, this is what goes on to make the back end for a
55 | #define ARCH_SIZE 32
61 | aout_32_canonicalize_reloc
62 | aout_32_find_nearest_line
64 | aout_32_get_reloc_upper_bound
70 | #define TARGET_NAME "a.out-sunos-big"
71 | #define VECNAME sunos_big_vec
74 requires all the names from aout32.c, and produces the jump vector
78 The file host-aout.c is a special case. It is for a large set
79 of hosts that use ``more or less standard'' a.out files, and
80 for which cross-debugging is not interesting. It uses the
81 standard 32-bit a.out support routines, but determines the
82 file offsets and addresses of the text, data, and BSS
83 sections, the machine architecture and machine type, and the
84 entry point address, in a host-dependent manner. Once these
85 values have been determined, generic code is used to handle
88 When porting it to run on a new system, you must supply:
92 | HOST_MACHINE_ARCH (optional)
93 | HOST_MACHINE_MACHINE (optional)
94 | HOST_TEXT_START_ADDR
97 in the file <<../include/sys/h-XXX.h>> (for your host). These
98 values, plus the structures and macros defined in <<a.out.h>> on
99 your host system, will produce a BFD target that will access
100 ordinary a.out files on your host. To configure a new machine
101 to use <<host-aout.c>., specify:
103 | TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec
104 | TDEPFILES= host-aout.o trad-core.o
106 in the <<config/mt-XXX>> file, and modify configure.in to use the
107 <<mt-XXX>> file (by setting "<<bfd_target=XXX>>") when your
108 configuration is selected.
113 * Any BFD with D_PAGED set is ZMAGIC, and vice versa.
114 Doesn't matter what the setting of WP_TEXT is on output, but it'll
116 * Any BFD with D_PAGED clear and WP_TEXT set is NMAGIC.
117 * Any BFD with both flags clear is OMAGIC.
118 (Just want to make these explicit, so the conditions tested in this
119 file make sense if you're more familiar with a.out than with BFD.) */
122 #define KEEPITTYPE int
126 #include <ansidecl.h>
128 struct external_exec
;
131 #include "aout/aout64.h"
132 #include "aout/stab_gnu.h"
135 extern void (*bfd_error_trap
)();
142 The file @code{aoutx.h} caters for both the @emph{standard}
143 and @emph{extended} forms of a.out relocation records.
145 The standard records are characterised by containing only an
146 address, a symbol index and a type field. The extended records
147 (used on 29ks and sparcs) also have a full integer for an
151 #define CTOR_TABLE_RELOC_IDX 2
153 #define howto_table_ext NAME(aout,ext_howto_table)
154 #define howto_table_std NAME(aout,std_howto_table)
156 reloc_howto_type howto_table_ext
[] =
158 HOWTO(RELOC_8
, 0, 0, 8, false, 0, true, true,0,"8", false, 0,0x000000ff, false),
159 HOWTO(RELOC_16
, 0, 1, 16, false, 0, true, true,0,"16", false, 0,0x0000ffff, false),
160 HOWTO(RELOC_32
, 0, 2, 32, false, 0, true, true,0,"32", false, 0,0xffffffff, false),
161 HOWTO(RELOC_DISP8
, 0, 0, 8, true, 0, false, true,0,"DISP8", false, 0,0x000000ff, false),
162 HOWTO(RELOC_DISP16
, 0, 1, 16, true, 0, false, true,0,"DISP16", false, 0,0x0000ffff, false),
163 HOWTO(RELOC_DISP32
, 0, 2, 32, true, 0, false, true,0,"DISP32", false, 0,0xffffffff, false),
164 HOWTO(RELOC_WDISP30
,2, 2, 30, true, 0, false, true,0,"WDISP30", false, 0,0x3fffffff, false),
165 HOWTO(RELOC_WDISP22
,2, 2, 22, true, 0, false, true,0,"WDISP22", false, 0,0x003fffff, false),
166 HOWTO(RELOC_HI22
, 10, 2, 22, false, 0, false, true,0,"HI22", false, 0,0x003fffff, false),
167 HOWTO(RELOC_22
, 0, 2, 22, false, 0, false, true,0,"22", false, 0,0x003fffff, false),
168 HOWTO(RELOC_13
, 0, 2, 13, false, 0, false, true,0,"13", false, 0,0x00001fff, false),
169 HOWTO(RELOC_LO10
, 0, 2, 10, false, 0, false, true,0,"LO10", false, 0,0x000003ff, false),
170 HOWTO(RELOC_SFA_BASE
,0, 2, 32, false, 0, false, true,0,"SFA_BASE", false, 0,0xffffffff, false),
171 HOWTO(RELOC_SFA_OFF13
,0,2, 32, false, 0, false, true,0,"SFA_OFF13",false, 0,0xffffffff, false),
172 HOWTO(RELOC_BASE10
, 0, 2, 16, false, 0, false, true,0,"BASE10", false, 0,0x0000ffff, false),
173 HOWTO(RELOC_BASE13
, 0, 2, 13, false, 0, false, true,0,"BASE13", false, 0,0x00001fff, false),
174 HOWTO(RELOC_BASE22
, 0, 2, 0, false, 0, false, true,0,"BASE22", false, 0,0x00000000, false),
175 HOWTO(RELOC_PC10
, 0, 2, 10, false, 0, false, true,0,"PC10", false, 0,0x000003ff, false),
176 HOWTO(RELOC_PC22
, 0, 2, 22, false, 0, false, true,0,"PC22", false, 0,0x003fffff, false),
177 HOWTO(RELOC_JMP_TBL
,0, 2, 32, false, 0, false, true,0,"JMP_TBL", false, 0,0xffffffff, false),
178 HOWTO(RELOC_SEGOFF16
,0, 2, 0, false, 0, false, true,0,"SEGOFF16", false, 0,0x00000000, false),
179 HOWTO(RELOC_GLOB_DAT
,0, 2, 0, false, 0, false, true,0,"GLOB_DAT", false, 0,0x00000000, false),
180 HOWTO(RELOC_JMP_SLOT
,0, 2, 0, false, 0, false, true,0,"JMP_SLOT", false, 0,0x00000000, false),
181 HOWTO(RELOC_RELATIVE
,0, 2, 0, false, 0, false, true,0,"RELATIVE", false, 0,0x00000000, false),
185 /* Convert standard reloc records to "arelent" format (incl byte swap). */
187 reloc_howto_type howto_table_std
[] = {
188 /* type rs size bsz pcrel bitpos abs ovrf sf name part_inpl readmask setmask pcdone */
189 HOWTO( 0, 0, 0, 8, false, 0, true, true,0,"8", true, 0x000000ff,0x000000ff, false),
190 HOWTO( 1, 0, 1, 16, false, 0, true, true,0,"16", true, 0x0000ffff,0x0000ffff, false),
191 HOWTO( 2, 0, 2, 32, false, 0, true, true,0,"32", true, 0xffffffff,0xffffffff, false),
192 HOWTO( 3, 0, 3, 64, false, 0, true, true,0,"64", true, 0xdeaddead,0xdeaddead, false),
193 HOWTO( 4, 0, 0, 8, true, 0, false, true,0,"DISP8", true, 0x000000ff,0x000000ff, false),
194 HOWTO( 5, 0, 1, 16, true, 0, false, true,0,"DISP16", true, 0x0000ffff,0x0000ffff, false),
195 HOWTO( 6, 0, 2, 32, true, 0, false, true,0,"DISP32", true, 0xffffffff,0xffffffff, false),
196 HOWTO( 7, 0, 3, 64, true, 0, false, true,0,"DISP64", true, 0xfeedface,0xfeedface, false),
200 extern bfd_error_vector_type bfd_error_vector
;
204 Internal Entry Points
207 @code{aoutx.h} exports several routines for accessing the
208 contents of an a.out file, which are gathered and exported in
209 turn by various format specific files (eg sunos.c).
215 aout_<size>_swap_exec_header_in
218 Swaps the information in an executable header taken from a raw
219 byte stream memory image, into the internal exec_header
223 void aout_<size>_swap_exec_header_in,
225 struct external_exec *raw_bytes,
226 struct internal_exec *execp);
230 DEFUN(NAME(aout
,swap_exec_header_in
),(abfd
, raw_bytes
, execp
),
232 struct external_exec
*raw_bytes AND
233 struct internal_exec
*execp
)
235 struct external_exec
*bytes
= (struct external_exec
*)raw_bytes
;
237 /* The internal_exec structure has some fields that are unused in this
238 configuration (IE for i960), so ensure that all such uninitialized
239 fields are zero'd out. There are places where two of these structs
240 are memcmp'd, and thus the contents do matter. */
241 memset (execp
, 0, sizeof (struct internal_exec
));
242 /* Now fill in fields in the execp, from the bytes in the raw data. */
243 execp
->a_info
= bfd_h_get_32 (abfd
, bytes
->e_info
);
244 execp
->a_text
= GET_WORD (abfd
, bytes
->e_text
);
245 execp
->a_data
= GET_WORD (abfd
, bytes
->e_data
);
246 execp
->a_bss
= GET_WORD (abfd
, bytes
->e_bss
);
247 execp
->a_syms
= GET_WORD (abfd
, bytes
->e_syms
);
248 execp
->a_entry
= GET_WORD (abfd
, bytes
->e_entry
);
249 execp
->a_trsize
= GET_WORD (abfd
, bytes
->e_trsize
);
250 execp
->a_drsize
= GET_WORD (abfd
, bytes
->e_drsize
);
255 aout_<size>_swap_exec_header_out
258 Swaps the information in an internal exec header structure
259 into the supplied buffer ready for writing to disk.
262 void aout_<size>_swap_exec_header_out
264 struct internal_exec *execp,
265 struct external_exec *raw_bytes);
268 DEFUN(NAME(aout
,swap_exec_header_out
),(abfd
, execp
, raw_bytes
),
270 struct internal_exec
*execp AND
271 struct external_exec
*raw_bytes
)
273 struct external_exec
*bytes
= (struct external_exec
*)raw_bytes
;
275 /* Now fill in fields in the raw data, from the fields in the exec struct. */
276 bfd_h_put_32 (abfd
, execp
->a_info
, bytes
->e_info
);
277 PUT_WORD (abfd
, execp
->a_text
, bytes
->e_text
);
278 PUT_WORD (abfd
, execp
->a_data
, bytes
->e_data
);
279 PUT_WORD (abfd
, execp
->a_bss
, bytes
->e_bss
);
280 PUT_WORD (abfd
, execp
->a_syms
, bytes
->e_syms
);
281 PUT_WORD (abfd
, execp
->a_entry
, bytes
->e_entry
);
282 PUT_WORD (abfd
, execp
->a_trsize
, bytes
->e_trsize
);
283 PUT_WORD (abfd
, execp
->a_drsize
, bytes
->e_drsize
);
290 aout_<size>_some_aout_object_p
293 Some A.OUT variant thinks that the file whose format we're
294 checking is an a.out file. Do some more checking, and set up
295 for access if it really is. Call back to the calling
296 environments "finish up" function just before returning, to
297 handle any last-minute setup.
300 bfd_target *aout_<size>_some_aout_object_p
302 bfd_target *(*callback_to_real_object_p)());
306 DEFUN(NAME(aout
,some_aout_object_p
),(abfd
, execp
, callback_to_real_object_p
),
308 struct internal_exec
*execp AND
309 bfd_target
*(*callback_to_real_object_p
) ())
311 struct aout_data_struct
*rawptr
;
314 rawptr
= (struct aout_data_struct
*) bfd_zalloc (abfd
, sizeof (struct aout_data_struct
));
315 if (rawptr
== NULL
) {
316 bfd_error
= no_memory
;
320 abfd
->tdata
.aout_data
= rawptr
;
321 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
322 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
; /* Copy in the internal_exec struct */
323 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
325 /* Set the file flags */
326 abfd
->flags
= NO_FLAGS
;
327 if (execp
->a_drsize
|| execp
->a_trsize
)
328 abfd
->flags
|= HAS_RELOC
;
329 /* Setting of EXEC_P has been deferred to the bottom of this function */
331 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
333 if (N_MAGIC (*execp
) == ZMAGIC
)
335 abfd
->flags
|= D_PAGED
|WP_TEXT
;
336 adata(abfd
).magic
= z_magic
;
338 else if (N_MAGIC (*execp
) == NMAGIC
)
340 abfd
->flags
|= WP_TEXT
;
341 adata(abfd
).magic
= n_magic
;
344 adata(abfd
).magic
= o_magic
;
346 bfd_get_start_address (abfd
) = execp
->a_entry
;
348 obj_aout_symbols (abfd
) = (aout_symbol_type
*)NULL
;
349 bfd_get_symcount (abfd
) = execp
->a_syms
/ sizeof (struct external_nlist
);
351 /* The default relocation entry size is that of traditional V7 Unix. */
352 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
354 /* The default symbol entry size is that of traditional Unix. */
355 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
357 /* create the sections. This is raunchy, but bfd_close wants to reclaim
360 obj_textsec (abfd
) = (asection
*)NULL
;
361 obj_datasec (abfd
) = (asection
*)NULL
;
362 obj_bsssec (abfd
) = (asection
*)NULL
;
364 (void)bfd_make_section(abfd
, ".text");
365 (void)bfd_make_section(abfd
, ".data");
366 (void)bfd_make_section(abfd
, ".bss");
367 /* (void)bfd_make_section(abfd, BFD_ABS_SECTION_NAME);
368 (void)bfd_make_section (abfd, BFD_UND_SECTION_NAME);
369 (void)bfd_make_section (abfd, BFD_COM_SECTION_NAME);*/
370 abfd
->sections
= obj_textsec (abfd
);
371 obj_textsec (abfd
)->next
= obj_datasec (abfd
);
372 obj_datasec (abfd
)->next
= obj_bsssec (abfd
);
374 obj_datasec (abfd
)->_raw_size
= execp
->a_data
;
375 obj_bsssec (abfd
)->_raw_size
= execp
->a_bss
;
377 obj_textsec (abfd
)->flags
= (execp
->a_trsize
!= 0 ?
378 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_HAS_CONTENTS
) :
379 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
));
380 obj_datasec (abfd
)->flags
= (execp
->a_drsize
!= 0 ?
381 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_HAS_CONTENTS
) :
382 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
));
383 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
385 #ifdef THIS_IS_ONLY_DOCUMENTATION
386 /* The common code can't fill in these things because they depend
387 on either the start address of the text segment, the rounding
388 up of virtual addersses between segments, or the starting file
389 position of the text segment -- all of which varies among different
390 versions of a.out. */
392 /* Call back to the format-dependent code to fill in the rest of the
393 fields and do any further cleanup. Things that should be filled
394 in by the callback: */
396 struct exec
*execp
= exec_hdr (abfd
);
398 obj_textsec (abfd
)->size
= N_TXTSIZE(*execp
);
399 obj_textsec (abfd
)->raw_size
= N_TXTSIZE(*execp
);
400 /* data and bss are already filled in since they're so standard */
402 /* The virtual memory addresses of the sections */
403 obj_textsec (abfd
)->vma
= N_TXTADDR(*execp
);
404 obj_datasec (abfd
)->vma
= N_DATADDR(*execp
);
405 obj_bsssec (abfd
)->vma
= N_BSSADDR(*execp
);
407 /* The file offsets of the sections */
408 obj_textsec (abfd
)->filepos
= N_TXTOFF(*execp
);
409 obj_datasec (abfd
)->filepos
= N_DATOFF(*execp
);
411 /* The file offsets of the relocation info */
412 obj_textsec (abfd
)->rel_filepos
= N_TRELOFF(*execp
);
413 obj_datasec (abfd
)->rel_filepos
= N_DRELOFF(*execp
);
415 /* The file offsets of the string table and symbol table. */
416 obj_str_filepos (abfd
) = N_STROFF (*execp
);
417 obj_sym_filepos (abfd
) = N_SYMOFF (*execp
);
419 /* Determine the architecture and machine type of the object file. */
420 switch (N_MACHTYPE (*exec_hdr (abfd
))) {
422 abfd
->obj_arch
= bfd_arch_obscure
;
426 /* Determine the size of a relocation entry */
427 switch (abfd
->obj_arch
) {
430 obj_reloc_entry_size (abfd
) = RELOC_EXT_SIZE
;
432 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
435 adata(abfd
)->page_size
= PAGE_SIZE
;
436 adata(abfd
)->segment_size
= SEGMENT_SIZE
;
437 adata(abfd
)->exec_bytes_size
= EXEC_BYTES_SIZE
;
441 /* The architecture is encoded in various ways in various a.out variants,
442 or is not encoded at all in some of them. The relocation size depends
443 on the architecture and the a.out variant. Finally, the return value
444 is the bfd_target vector in use. If an error occurs, return zero and
445 set bfd_error to the appropriate error code.
447 Formats such as b.out, which have additional fields in the a.out
448 header, should cope with them in this callback as well. */
449 #endif /* DOCUMENTATION */
451 result
= (*callback_to_real_object_p
)(abfd
);
453 /* Now that the segment addresses have been worked out, take a better
454 guess at whether the file is executable. If the entry point
455 is within the text segment, assume it is. (This makes files
456 executable even if their entry point address is 0, as long as
457 their text starts at zero.)
459 At some point we should probably break down and stat the file and
460 declare it executable if (one of) its 'x' bits are on... */
461 if ((execp
->a_entry
>= obj_textsec(abfd
)->vma
) &&
462 (execp
->a_entry
< obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->_raw_size
))
463 abfd
->flags
|= EXEC_P
;
472 This routine initializes a BFD for use with a.out files.
475 boolean aout_<size>_mkobject, (bfd *);
479 DEFUN(NAME(aout
,mkobject
),(abfd
),
482 struct aout_data_struct
*rawptr
;
484 bfd_error
= system_call_error
;
486 /* Use an intermediate variable for clarity */
487 rawptr
= (struct aout_data_struct
*)bfd_zalloc (abfd
, sizeof (struct aout_data_struct
));
489 if (rawptr
== NULL
) {
490 bfd_error
= no_memory
;
494 abfd
->tdata
.aout_data
= rawptr
;
495 exec_hdr (abfd
) = &(rawptr
->e
);
497 /* For simplicity's sake we just make all the sections right here. */
499 obj_textsec (abfd
) = (asection
*)NULL
;
500 obj_datasec (abfd
) = (asection
*)NULL
;
501 obj_bsssec (abfd
) = (asection
*)NULL
;
502 bfd_make_section (abfd
, ".text");
503 bfd_make_section (abfd
, ".data");
504 bfd_make_section (abfd
, ".bss");
505 bfd_make_section (abfd
, BFD_ABS_SECTION_NAME
);
506 bfd_make_section (abfd
, BFD_UND_SECTION_NAME
);
507 bfd_make_section (abfd
, BFD_COM_SECTION_NAME
);
515 aout_<size>_machine_type
518 Keep track of machine architecture and machine type for
519 a.out's. Return the machine_type for a particular
520 arch&machine, or M_UNKNOWN if that exact arch&machine can't be
521 represented in a.out format.
523 If the architecture is understood, machine type 0 (default)
524 should always be understood.
527 enum machine_type aout_<size>_machine_type
528 (enum bfd_architecture arch,
529 unsigned long machine));
533 DEFUN(NAME(aout
,machine_type
),(arch
, machine
),
534 enum bfd_architecture arch AND
535 unsigned long machine
)
537 enum machine_type arch_flags
;
539 arch_flags
= M_UNKNOWN
;
543 if (machine
== 0) arch_flags
= M_SPARC
;
548 case 0: arch_flags
= M_68010
; break;
549 case 68000: arch_flags
= M_UNKNOWN
; break;
550 case 68010: arch_flags
= M_68010
; break;
551 case 68020: arch_flags
= M_68020
; break;
552 default: arch_flags
= M_UNKNOWN
; break;
557 if (machine
== 0) arch_flags
= M_386
;
561 if (machine
== 0) arch_flags
= M_29K
;
565 arch_flags
= M_UNKNOWN
;
574 aout_<size>_set_arch_mach
577 Sets the architecture and the machine of the BFD to those
578 values supplied. Verifies that the format can support the
579 architecture required.
582 boolean aout_<size>_set_arch_mach,
584 enum bfd_architecture,
585 unsigned long machine));
589 DEFUN(NAME(aout
,set_arch_mach
),(abfd
, arch
, machine
),
591 enum bfd_architecture arch AND
592 unsigned long machine
)
594 bfd_arch_info_type
*ainfo
;
596 bfd_default_set_arch_mach(abfd
, arch
, machine
);
597 if (arch
!= bfd_arch_unknown
&&
598 NAME(aout
,machine_type
) (arch
, machine
) == M_UNKNOWN
)
599 return false; /* We can't represent this type */
601 BFD_ASSERT (&adata(abfd
) != 0);
602 ainfo
= bfd_get_arch_info (abfd
);
603 if (ainfo
->segment_size
)
604 adata(abfd
).segment_size
= ainfo
->segment_size
;
605 if (ainfo
->page_size
)
606 adata(abfd
).page_size
= ainfo
->page_size
;
607 return true; /* We're easy ... */
611 DEFUN (NAME (aout
,adjust_sizes_and_vmas
), (abfd
, text_size
, text_end
),
612 bfd
*abfd AND bfd_size_type
*text_size AND file_ptr
*text_end
)
614 struct internal_exec
*execp
= exec_hdr (abfd
);
615 if ((obj_textsec (abfd
) == NULL
) || (obj_datasec (abfd
) == NULL
))
617 bfd_error
= invalid_operation
;
620 if (adata(abfd
).magic
!= undecided_magic
) return true;
621 obj_textsec(abfd
)->_raw_size
=
622 align_power(obj_textsec(abfd
)->_raw_size
,
623 obj_textsec(abfd
)->alignment_power
);
625 *text_size
= obj_textsec (abfd
)->_raw_size
;
626 /* Rule (heuristic) for when to pad to a new page. Note that there
627 * are (at least) two ways demand-paged (ZMAGIC) files have been
628 * handled. Most Berkeley-based systems start the text segment at
629 * (PAGE_SIZE). However, newer versions of SUNOS start the text
630 * segment right after the exec header; the latter is counted in the
631 * text segment size, and is paged in by the kernel with the rest of
634 /* This perhaps isn't the right way to do this, but made it simpler for me
635 to understand enough to implement it. Better would probably be to go
636 right from BFD flags to alignment/positioning characteristics. But the
637 old code was sloppy enough about handling the flags, and had enough
638 other magic, that it was a little hard for me to understand. I think
639 I understand it better now, but I haven't time to do the cleanup this
641 if (adata(abfd
).magic
== undecided_magic
)
643 if (abfd
->flags
& D_PAGED
)
644 /* whether or not WP_TEXT is set */
645 adata(abfd
).magic
= z_magic
;
646 else if (abfd
->flags
& WP_TEXT
)
647 adata(abfd
).magic
= n_magic
;
649 adata(abfd
).magic
= o_magic
;
652 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
654 fprintf (stderr
, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
656 switch (adata(abfd
).magic
) {
657 case n_magic
: str
= "NMAGIC"; break;
658 case o_magic
: str
= "OMAGIC"; break;
659 case z_magic
: str
= "ZMAGIC"; break;
664 obj_textsec(abfd
)->vma
, obj_textsec(abfd
)->_raw_size
, obj_textsec(abfd
)->alignment_power
,
665 obj_datasec(abfd
)->vma
, obj_datasec(abfd
)->_raw_size
, obj_datasec(abfd
)->alignment_power
,
666 obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->_raw_size
, obj_bsssec(abfd
)->alignment_power
);
670 switch (adata(abfd
).magic
)
674 file_ptr pos
= adata (abfd
).exec_bytes_size
;
678 obj_textsec(abfd
)->filepos
= pos
;
679 pos
+= obj_textsec(abfd
)->_raw_size
;
680 vma
+= obj_textsec(abfd
)->_raw_size
;
681 if (!obj_datasec(abfd
)->user_set_vma
)
683 /* ?? Does alignment in the file image really matter? */
684 pad
= align_power (vma
, obj_datasec(abfd
)->alignment_power
) - vma
;
685 obj_textsec(abfd
)->_raw_size
+= pad
;
688 obj_datasec(abfd
)->vma
= vma
;
690 obj_datasec(abfd
)->filepos
= pos
;
691 pos
+= obj_datasec(abfd
)->_raw_size
;
692 vma
+= obj_datasec(abfd
)->_raw_size
;
693 if (!obj_bsssec(abfd
)->user_set_vma
)
695 pad
= align_power (vma
, obj_bsssec(abfd
)->alignment_power
) - vma
;
696 obj_datasec(abfd
)->_raw_size
+= pad
;
699 obj_bsssec(abfd
)->vma
= vma
;
701 obj_bsssec(abfd
)->filepos
= pos
;
702 execp
->a_text
= obj_textsec(abfd
)->_raw_size
;
703 execp
->a_data
= obj_datasec(abfd
)->_raw_size
;
704 execp
->a_bss
= obj_bsssec(abfd
)->_raw_size
;
705 N_SET_MAGIC (*execp
, OMAGIC
);
710 bfd_size_type data_pad
, text_pad
;
712 CONST
struct aout_backend_data
*abdp
;
716 abdp
= aout_backend_info (abfd
);
717 ztih
= abdp
&& abdp
->text_includes_header
;
718 obj_textsec(abfd
)->filepos
= (ztih
719 ? adata(abfd
).exec_bytes_size
720 : adata(abfd
).page_size
);
721 if (! obj_textsec(abfd
)->user_set_vma
)
722 /* ?? Do we really need to check for relocs here? */
723 obj_textsec(abfd
)->vma
= ((abfd
->flags
& HAS_RELOC
)
726 ? (abdp
->default_text_vma
727 + adata(abfd
).exec_bytes_size
)
728 : abdp
->default_text_vma
));
729 /* Could take strange alignment of text section into account here? */
731 /* Find start of data. */
732 text_end
= obj_textsec(abfd
)->filepos
+ obj_textsec(abfd
)->_raw_size
;
733 text_pad
= BFD_ALIGN (text_end
, adata(abfd
).page_size
) - text_end
;
734 obj_textsec(abfd
)->_raw_size
+= text_pad
;
735 text_end
+= text_pad
;
737 if (!obj_datasec(abfd
)->user_set_vma
)
740 vma
= obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->_raw_size
;
741 obj_datasec(abfd
)->vma
= BFD_ALIGN (vma
, adata(abfd
).segment_size
);
743 data_vma
= obj_datasec(abfd
)->vma
;
744 if (abdp
&& abdp
->zmagic_mapped_contiguous
)
746 text_pad
= (obj_datasec(abfd
)->vma
747 - obj_textsec(abfd
)->vma
748 - obj_textsec(abfd
)->_raw_size
);
749 obj_textsec(abfd
)->_raw_size
+= text_pad
;
751 obj_datasec(abfd
)->filepos
= (obj_textsec(abfd
)->filepos
752 + obj_textsec(abfd
)->_raw_size
);
754 /* Fix up exec header while we're at it. */
755 execp
->a_text
= obj_textsec(abfd
)->_raw_size
;
757 execp
->a_text
+= adata(abfd
).exec_bytes_size
;
758 N_SET_MAGIC (*execp
, ZMAGIC
);
759 /* Spec says data section should be rounded up to page boundary. */
760 /* If extra space in page is left after data section, fudge data
761 in the header so that the bss section looks smaller by that
762 amount. We'll start the bss section there, and lie to the OS. */
763 obj_datasec(abfd
)->_raw_size
764 = align_power (obj_datasec(abfd
)->_raw_size
,
765 obj_bsssec(abfd
)->alignment_power
);
766 execp
->a_data
= BFD_ALIGN (obj_datasec(abfd
)->_raw_size
,
767 adata(abfd
).page_size
);
768 data_pad
= execp
->a_data
- obj_datasec(abfd
)->_raw_size
;
769 /* This code is almost surely botched. It'll only get tested
770 for the case where the application does explicitly set the VMA
771 of the BSS section. */
772 if (obj_bsssec(abfd
)->user_set_vma
773 && (obj_bsssec(abfd
)->vma
774 > BFD_ALIGN (obj_datasec(abfd
)->vma
775 + obj_datasec(abfd
)->_raw_size
,
776 adata(abfd
).page_size
)))
778 /* Can't play with squeezing into data pages; fix this code. */
781 if (!obj_bsssec(abfd
)->user_set_vma
)
782 obj_bsssec(abfd
)->vma
= (obj_datasec(abfd
)->vma
783 + obj_datasec(abfd
)->_raw_size
);
784 if (data_pad
> obj_bsssec(abfd
)->_raw_size
)
787 execp
->a_bss
= obj_bsssec(abfd
)->_raw_size
- data_pad
;
792 CONST
struct aout_backend_data
*abdp
;
793 file_ptr pos
= adata(abfd
).exec_bytes_size
;
797 obj_textsec(abfd
)->filepos
= pos
;
798 if (!obj_textsec(abfd
)->user_set_vma
)
799 obj_textsec(abfd
)->vma
= vma
;
801 vma
= obj_textsec(abfd
)->vma
;
802 pos
+= obj_textsec(abfd
)->_raw_size
;
803 vma
+= obj_textsec(abfd
)->_raw_size
;
804 obj_datasec(abfd
)->filepos
= pos
;
805 if (!obj_datasec(abfd
)->user_set_vma
)
806 obj_datasec(abfd
)->vma
= BFD_ALIGN (vma
, adata(abfd
).segment_size
);
807 vma
= obj_datasec(abfd
)->vma
;
809 /* Since BSS follows data immediately, see if it needs alignment. */
810 vma
+= obj_datasec(abfd
)->_raw_size
;
811 pad
= align_power (vma
, obj_bsssec(abfd
)->alignment_power
) - vma
;
812 obj_datasec(abfd
)->_raw_size
+= pad
;
813 pos
+= obj_datasec(abfd
)->_raw_size
;
815 if (!obj_bsssec(abfd
)->user_set_vma
)
816 obj_bsssec(abfd
)->vma
= vma
;
818 vma
= obj_bsssec(abfd
)->vma
;
820 execp
->a_text
= obj_textsec(abfd
)->_raw_size
;
821 execp
->a_data
= obj_datasec(abfd
)->_raw_size
;
822 execp
->a_bss
= obj_bsssec(abfd
)->_raw_size
;
823 N_SET_MAGIC (*execp
, NMAGIC
);
828 #ifdef BFD_AOUT_DEBUG
829 fprintf (stderr
, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
830 obj_textsec(abfd
)->vma
, obj_textsec(abfd
)->_raw_size
, obj_textsec(abfd
)->filepos
,
831 obj_datasec(abfd
)->vma
, obj_datasec(abfd
)->_raw_size
, obj_datasec(abfd
)->filepos
,
832 obj_bsssec(abfd
)->vma
, obj_bsssec(abfd
)->_raw_size
);
838 aout_<size>new_section_hook
841 Called by the BFD in response to a @code{bfd_make_section}
845 boolean aout_<size>_new_section_hook,
850 DEFUN(NAME(aout
,new_section_hook
),(abfd
, newsect
),
854 /* align to double at least */
855 newsect
->alignment_power
= bfd_get_arch_info(abfd
)->section_align_power
;
858 if (bfd_get_format (abfd
) == bfd_object
)
860 if (obj_textsec(abfd
) == NULL
&& !strcmp(newsect
->name
, ".text")) {
861 obj_textsec(abfd
)= newsect
;
862 newsect
->target_index
= N_TEXT
| N_EXT
;
866 if (obj_datasec(abfd
) == NULL
&& !strcmp(newsect
->name
, ".data")) {
867 obj_datasec(abfd
) = newsect
;
868 newsect
->target_index
= N_DATA
| N_EXT
;
872 if (obj_bsssec(abfd
) == NULL
&& !strcmp(newsect
->name
, ".bss")) {
873 obj_bsssec(abfd
) = newsect
;
874 newsect
->target_index
= N_BSS
| N_EXT
;
880 /* We allow more than three sections internally */
885 DEFUN(NAME(aout
,set_section_contents
),(abfd
, section
, location
, offset
, count
),
893 bfd_size_type text_size
;
895 if (abfd
->output_has_begun
== false)
896 { /* set by bfd.c handler */
897 switch (abfd
->direction
)
901 bfd_error
= invalid_operation
;
904 case write_direction
:
905 if (NAME(aout
,adjust_sizes_and_vmas
) (abfd
,
914 /* regardless, once we know what we're doing, we might as well get going */
915 if (section
!= obj_bsssec(abfd
))
917 bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
);
920 return (bfd_write ((PTR
)location
, 1, count
, abfd
) == count
) ?
928 /* Classify stabs symbols */
930 #define sym_in_text_section(sym) \
931 (((sym)->type & (N_ABS | N_TEXT | N_DATA | N_BSS))== N_TEXT)
933 #define sym_in_data_section(sym) \
934 (((sym)->type & (N_ABS | N_TEXT | N_DATA | N_BSS))== N_DATA)
936 #define sym_in_bss_section(sym) \
937 (((sym)->type & (N_ABS | N_TEXT | N_DATA | N_BSS))== N_BSS)
939 /* Symbol is undefined if type is N_UNDF|N_EXT and if it has
940 zero in the "value" field. Nonzeroes there are fortrancommon
942 #define sym_is_undefined(sym) \
943 ((sym)->type == (N_UNDF | N_EXT) && (sym)->symbol.value == 0)
945 /* Symbol is a global definition if N_EXT is on and if it has
946 a nonzero type field. */
947 #define sym_is_global_defn(sym) \
948 (((sym)->type & N_EXT) && (sym)->type & N_TYPE)
950 /* Symbol is debugger info if any bits outside N_TYPE or N_EXT
952 #define sym_is_debugger_info(sym) \
953 ((sym)->type & ~(N_EXT | N_TYPE))
955 #define sym_is_fortrancommon(sym) \
956 (((sym)->type == (N_EXT)) && (sym)->symbol.value != 0)
958 /* Symbol is absolute if it has N_ABS set */
959 #define sym_is_absolute(sym) \
960 (((sym)->type & N_TYPE)== N_ABS)
963 #define sym_is_indirect(sym) \
964 (((sym)->type & N_ABS)== N_ABS)
966 /* Only in their own functions for ease of debugging; when sym flags have
967 stabilised these should be inlined into their (single) caller */
970 DEFUN(translate_from_native_sym_flags
,(sym_pointer
, cache_ptr
, abfd
),
971 struct external_nlist
*sym_pointer AND
972 aout_symbol_type
*cache_ptr AND
975 switch (cache_ptr
->type
& N_TYPE
)
982 char *copy
= bfd_alloc(abfd
, strlen(cache_ptr
->symbol
.name
)+1);
984 asection
*into_section
;
986 arelent_chain
*reloc
= (arelent_chain
*)bfd_alloc(abfd
, sizeof(arelent_chain
));
987 strcpy(copy
, cache_ptr
->symbol
.name
);
989 /* Make sure that this bfd has a section with the right contructor
991 section
= bfd_get_section_by_name (abfd
, copy
);
993 section
= bfd_make_section(abfd
,copy
);
995 /* Build a relocation entry for the constructor */
996 switch ( (cache_ptr
->type
& N_TYPE
) )
999 into_section
= &bfd_abs_section
;
1002 into_section
= (asection
*)obj_textsec(abfd
);
1005 into_section
= (asection
*)obj_datasec(abfd
);
1008 into_section
= (asection
*)obj_bsssec(abfd
);
1014 /* Build a relocation pointing into the constuctor section
1015 pointing at the symbol in the set vector specified */
1017 reloc
->relent
.addend
= cache_ptr
->symbol
.value
;
1018 cache_ptr
->symbol
.section
= into_section
->symbol
->section
;
1019 reloc
->relent
.sym_ptr_ptr
= into_section
->symbol_ptr_ptr
;
1022 /* We modify the symbol to belong to a section depending upon the
1023 name of the symbol - probably __CTOR__ or __DTOR__ but we don't
1024 really care, and add to the size of the section to contain a
1025 pointer to the symbol. Build a reloc entry to relocate to this
1026 symbol attached to this section. */
1028 section
->flags
= SEC_CONSTRUCTOR
;
1031 section
->reloc_count
++;
1032 section
->alignment_power
= 2;
1034 reloc
->next
= section
->constructor_chain
;
1035 section
->constructor_chain
= reloc
;
1036 reloc
->relent
.address
= section
->_raw_size
;
1037 section
->_raw_size
+= sizeof(int *);
1039 reloc
->relent
.howto
= howto_table_ext
+ CTOR_TABLE_RELOC_IDX
;
1040 cache_ptr
->symbol
.flags
|= BSF_DEBUGGING
| BSF_CONSTRUCTOR
;
1044 if (cache_ptr
->type
== N_WARNING
)
1046 /* This symbol is the text of a warning message, the next symbol
1047 is the symbol to associate the warning with */
1048 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_WARNING
;
1049 cache_ptr
->symbol
.value
= (bfd_vma
)((cache_ptr
+1));
1050 /* We furgle with the next symbol in place. We don't want it to be undefined, we'll trample the type */
1051 (sym_pointer
+1)->e_type
[0] = 0xff;
1054 if ((cache_ptr
->type
| N_EXT
) == (N_INDR
| N_EXT
)) {
1055 /* Two symbols in a row for an INDR message. The first symbol
1056 contains the name we will match, the second symbol contains the
1057 name the first name is translated into. It is supplied to us
1058 undefined. This is good, since we want to pull in any files which
1060 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
| BSF_INDIRECT
;
1061 cache_ptr
->symbol
.value
= (bfd_vma
)((cache_ptr
+1));
1062 cache_ptr
->symbol
.section
= &bfd_und_section
;
1067 if (sym_is_debugger_info (cache_ptr
)) {
1068 cache_ptr
->symbol
.flags
= BSF_DEBUGGING
;
1069 /* Work out the section correct for this symbol */
1070 switch (cache_ptr
->type
& N_TYPE
)
1074 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1075 cache_ptr
->symbol
.value
-= obj_textsec(abfd
)->vma
;
1078 cache_ptr
->symbol
.value
-= obj_datasec(abfd
)->vma
;
1079 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1082 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1083 cache_ptr
->symbol
.value
-= obj_bsssec(abfd
)->vma
;
1088 cache_ptr
->symbol
.section
= &bfd_abs_section
;
1094 if (sym_is_fortrancommon (cache_ptr
))
1096 cache_ptr
->symbol
.flags
= 0;
1097 cache_ptr
->symbol
.section
= &bfd_com_section
;
1104 /* In a.out, the value of a symbol is always relative to the
1105 * start of the file, if this is a data symbol we'll subtract
1106 * the size of the text section to get the section relative
1107 * value. If this is a bss symbol (which would be strange)
1108 * we'll subtract the size of the previous two sections
1109 * to find the section relative address.
1112 if (sym_in_text_section (cache_ptr
)) {
1113 cache_ptr
->symbol
.value
-= obj_textsec(abfd
)->vma
;
1114 cache_ptr
->symbol
.section
= obj_textsec (abfd
);
1116 else if (sym_in_data_section (cache_ptr
)){
1117 cache_ptr
->symbol
.value
-= obj_datasec(abfd
)->vma
;
1118 cache_ptr
->symbol
.section
= obj_datasec (abfd
);
1120 else if (sym_in_bss_section(cache_ptr
)) {
1121 cache_ptr
->symbol
.section
= obj_bsssec (abfd
);
1122 cache_ptr
->symbol
.value
-= obj_bsssec(abfd
)->vma
;
1124 else if (sym_is_undefined (cache_ptr
)) {
1125 cache_ptr
->symbol
.flags
= 0;
1126 cache_ptr
->symbol
.section
= &bfd_und_section
;
1128 else if (sym_is_absolute(cache_ptr
))
1130 cache_ptr
->symbol
.section
= &bfd_abs_section
;
1133 if (sym_is_global_defn (cache_ptr
))
1135 cache_ptr
->symbol
.flags
= BSF_GLOBAL
| BSF_EXPORT
;
1139 cache_ptr
->symbol
.flags
= BSF_LOCAL
;
1148 DEFUN(translate_to_native_sym_flags
,(sym_pointer
, cache_ptr
, abfd
),
1149 struct external_nlist
*sym_pointer AND
1150 asymbol
*cache_ptr AND
1153 bfd_vma value
= cache_ptr
->value
;
1155 /* mask out any existing type bits in case copying from one section
1157 sym_pointer
->e_type
[0] &= ~N_TYPE
;
1159 if (bfd_get_output_section(cache_ptr
) == obj_bsssec (abfd
)) {
1160 sym_pointer
->e_type
[0] |= N_BSS
;
1162 else if (bfd_get_output_section(cache_ptr
) == obj_datasec (abfd
)) {
1163 sym_pointer
->e_type
[0] |= N_DATA
;
1165 else if (bfd_get_output_section(cache_ptr
) == obj_textsec (abfd
)) {
1166 sym_pointer
->e_type
[0] |= N_TEXT
;
1168 else if (bfd_get_output_section(cache_ptr
) == &bfd_abs_section
)
1170 sym_pointer
->e_type
[0] |= N_ABS
;
1172 else if (bfd_get_output_section(cache_ptr
) == &bfd_und_section
)
1174 sym_pointer
->e_type
[0] = (N_UNDF
| N_EXT
);
1176 else if (bfd_get_output_section(cache_ptr
) == &bfd_com_section
) {
1177 sym_pointer
->e_type
[0] = (N_UNDF
| N_EXT
);
1180 if (cache_ptr
->section
->output_section
)
1183 bfd_error_vector
.nonrepresentable_section(abfd
,
1184 bfd_get_output_section(cache_ptr
)->name
);
1188 bfd_error_vector
.nonrepresentable_section(abfd
,
1189 cache_ptr
->section
->name
);
1194 /* Turn the symbol from section relative to absolute again */
1196 value
+= cache_ptr
->section
->output_section
->vma
+ cache_ptr
->section
->output_offset
;
1199 if (cache_ptr
->flags
& (BSF_WARNING
)) {
1200 (sym_pointer
+1)->e_type
[0] = 1;
1203 if (cache_ptr
->flags
& (BSF_GLOBAL
| BSF_EXPORT
)) {
1204 sym_pointer
->e_type
[0] |= N_EXT
;
1206 if (cache_ptr
->flags
& BSF_DEBUGGING
) {
1207 sym_pointer
->e_type
[0]= ((aout_symbol_type
*)cache_ptr
)->type
;
1210 PUT_WORD(abfd
, value
, sym_pointer
->e_value
);
1213 /* Native-level interface to symbols. */
1215 /* We read the symbols into a buffer, which is discarded when this
1216 function exits. We read the strings into a buffer large enough to
1217 hold them all plus all the cached symbol entries. */
1220 DEFUN(NAME(aout
,make_empty_symbol
),(abfd
),
1223 aout_symbol_type
*new =
1224 (aout_symbol_type
*)bfd_zalloc (abfd
, sizeof (aout_symbol_type
));
1225 new->symbol
.the_bfd
= abfd
;
1227 return &new->symbol
;
1231 DEFUN(NAME(aout
,slurp_symbol_table
),(abfd
),
1234 bfd_size_type symbol_size
;
1235 bfd_size_type string_size
;
1236 unsigned char string_chars
[BYTES_IN_WORD
];
1237 struct external_nlist
*syms
;
1239 aout_symbol_type
*cached
;
1241 /* If there's no work to be done, don't do any */
1242 if (obj_aout_symbols (abfd
) != (aout_symbol_type
*)NULL
) return true;
1243 symbol_size
= exec_hdr(abfd
)->a_syms
;
1244 if (symbol_size
== 0) {
1245 bfd_error
= no_symbols
;
1249 bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
);
1250 if (bfd_read ((PTR
)string_chars
, BYTES_IN_WORD
, 1, abfd
) != BYTES_IN_WORD
)
1252 string_size
= GET_WORD (abfd
, string_chars
);
1254 strings
=(char *) bfd_alloc(abfd
, string_size
+ 1);
1255 cached
= (aout_symbol_type
*)
1256 bfd_zalloc(abfd
, (bfd_size_type
)(bfd_get_symcount (abfd
) * sizeof(aout_symbol_type
)));
1258 /* malloc this, so we can free it if simply. The symbol caching
1259 might want to allocate onto the bfd's obstack */
1260 syms
= (struct external_nlist
*) bfd_xmalloc(symbol_size
);
1261 bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
);
1262 if (bfd_read ((PTR
)syms
, 1, symbol_size
, abfd
) != symbol_size
) {
1264 if (syms
) free (syms
);
1265 if (cached
) bfd_release (abfd
, cached
);
1266 if (strings
)bfd_release (abfd
, strings
);
1270 bfd_seek (abfd
, obj_str_filepos (abfd
), SEEK_SET
);
1271 if (bfd_read ((PTR
)strings
, 1, string_size
, abfd
) != string_size
) {
1275 /* OK, now walk the new symtable, cacheing symbol properties */
1277 register struct external_nlist
*sym_pointer
;
1278 register struct external_nlist
*sym_end
= syms
+ bfd_get_symcount (abfd
);
1279 register aout_symbol_type
*cache_ptr
= cached
;
1281 /* Run through table and copy values */
1282 for (sym_pointer
= syms
, cache_ptr
= cached
;
1283 sym_pointer
< sym_end
; sym_pointer
++, cache_ptr
++)
1285 bfd_vma x
= GET_WORD(abfd
, sym_pointer
->e_strx
);
1286 cache_ptr
->symbol
.the_bfd
= abfd
;
1288 cache_ptr
->symbol
.name
= x
+ strings
;
1290 cache_ptr
->symbol
.name
= (char *)NULL
;
1292 cache_ptr
->symbol
.value
= GET_SWORD(abfd
, sym_pointer
->e_value
);
1293 cache_ptr
->desc
= bfd_get_16(abfd
, sym_pointer
->e_desc
);
1294 cache_ptr
->other
=bfd_get_8(abfd
, sym_pointer
->e_other
);
1295 cache_ptr
->type
= bfd_get_8(abfd
, sym_pointer
->e_type
);
1296 cache_ptr
->symbol
.udata
= 0;
1297 translate_from_native_sym_flags (sym_pointer
, cache_ptr
, abfd
);
1301 obj_aout_symbols (abfd
) = cached
;
1309 DEFUN(NAME(aout
,write_syms
),(abfd
),
1312 unsigned int count
;
1313 asymbol
**generic
= bfd_get_outsymbols (abfd
);
1315 bfd_size_type stindex
= BYTES_IN_WORD
; /* initial string length */
1317 for (count
= 0; count
< bfd_get_symcount (abfd
); count
++) {
1318 asymbol
*g
= generic
[count
];
1319 struct external_nlist nsp
;
1323 unsigned int length
= strlen(g
->name
) +1;
1324 PUT_WORD (abfd
, stindex
, (unsigned char *)nsp
.e_strx
);
1330 PUT_WORD (abfd
, 0, (unsigned char *)nsp
.e_strx
);
1333 if (g
->the_bfd
->xvec
->flavour
== abfd
->xvec
->flavour
)
1335 bfd_h_put_16(abfd
, aout_symbol(g
)->desc
, nsp
.e_desc
);
1336 bfd_h_put_8(abfd
, aout_symbol(g
)->other
, nsp
.e_other
);
1337 bfd_h_put_8(abfd
, aout_symbol(g
)->type
, nsp
.e_type
);
1341 bfd_h_put_16(abfd
,0, nsp
.e_desc
);
1342 bfd_h_put_8(abfd
, 0, nsp
.e_other
);
1343 bfd_h_put_8(abfd
, 0, nsp
.e_type
);
1346 translate_to_native_sym_flags (&nsp
, g
, abfd
);
1348 bfd_write((PTR
)&nsp
,1,EXTERNAL_NLIST_SIZE
, abfd
);
1351 /* Now output the strings. Be sure to put string length into correct
1352 byte ordering before writing it. */
1354 char buffer
[BYTES_IN_WORD
];
1355 PUT_WORD (abfd
, stindex
, (unsigned char *)buffer
);
1357 bfd_write((PTR
)buffer
, 1, BYTES_IN_WORD
, abfd
);
1359 generic
= bfd_get_outsymbols(abfd
);
1360 for (count
= 0; count
< bfd_get_symcount(abfd
); count
++)
1362 asymbol
*g
= *(generic
++);
1366 size_t length
= strlen(g
->name
)+1;
1367 bfd_write((PTR
)g
->name
, 1, length
, abfd
);
1369 g
->KEEPIT
= (KEEPITTYPE
) count
;
1376 DEFUN(NAME(aout
,get_symtab
),(abfd
, location
),
1380 unsigned int counter
= 0;
1381 aout_symbol_type
*symbase
;
1383 if (!NAME(aout
,slurp_symbol_table
)(abfd
)) return 0;
1385 for (symbase
= obj_aout_symbols(abfd
); counter
++ < bfd_get_symcount (abfd
);)
1386 *(location
++) = (asymbol
*)( symbase
++);
1388 return bfd_get_symcount (abfd
);
1392 /* Standard reloc stuff */
1393 /* Output standard relocation information to a file in target byte order. */
1396 DEFUN(NAME(aout
,swap_std_reloc_out
),(abfd
, g
, natptr
),
1399 struct reloc_std_external
*natptr
)
1402 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1404 unsigned int r_length
;
1406 int r_baserel
, r_jmptable
, r_relative
;
1407 unsigned int r_addend
;
1408 asection
*output_section
= sym
->section
->output_section
;
1410 PUT_WORD(abfd
, g
->address
, natptr
->r_address
);
1412 r_length
= g
->howto
->size
; /* Size as a power of two */
1413 r_pcrel
= (int) g
->howto
->pc_relative
; /* Relative to PC? */
1414 /* r_baserel, r_jmptable, r_relative??? FIXME-soon */
1419 r_addend
= g
->addend
+ (*(g
->sym_ptr_ptr
))->section
->output_section
->vma
;
1421 /* name was clobbered by aout_write_syms to be symbol index */
1423 if (output_section
== &bfd_com_section
1424 || output_section
== &bfd_abs_section
1425 || output_section
== &bfd_und_section
)
1427 /* Fill in symbol */
1429 r_index
= stoi((*(g
->sym_ptr_ptr
))->KEEPIT
);
1433 /* Just an ordinary section */
1435 r_index
= output_section
->target_index
;
1438 /* now the fun stuff */
1439 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
1440 natptr
->r_index
[0] = r_index
>> 16;
1441 natptr
->r_index
[1] = r_index
>> 8;
1442 natptr
->r_index
[2] = r_index
;
1444 (r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
1445 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
1446 | (r_baserel
? RELOC_STD_BITS_BASEREL_BIG
: 0)
1447 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_BIG
: 0)
1448 | (r_relative
? RELOC_STD_BITS_RELATIVE_BIG
: 0)
1449 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
);
1451 natptr
->r_index
[2] = r_index
>> 16;
1452 natptr
->r_index
[1] = r_index
>> 8;
1453 natptr
->r_index
[0] = r_index
;
1455 (r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
1456 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
1457 | (r_baserel
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
1458 | (r_jmptable
? RELOC_STD_BITS_JMPTABLE_LITTLE
: 0)
1459 | (r_relative
? RELOC_STD_BITS_RELATIVE_LITTLE
: 0)
1460 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
);
1465 /* Extended stuff */
1466 /* Output extended relocation information to a file in target byte order. */
1469 DEFUN(NAME(aout
,swap_ext_reloc_out
),(abfd
, g
, natptr
),
1472 register struct reloc_ext_external
*natptr
)
1476 unsigned int r_type
;
1477 unsigned int r_addend
;
1478 asymbol
*sym
= *(g
->sym_ptr_ptr
);
1479 asection
*output_section
= sym
->section
->output_section
;
1481 PUT_WORD (abfd
, g
->address
, natptr
->r_address
);
1483 r_type
= (unsigned int) g
->howto
->type
;
1485 r_addend
= g
->addend
+ (*(g
->sym_ptr_ptr
))->section
->output_section
->vma
;
1488 if (output_section
== &bfd_com_section
1489 || output_section
== &bfd_abs_section
1490 || output_section
== &bfd_und_section
)
1492 /* Fill in symbol */
1494 r_index
= stoi((*(g
->sym_ptr_ptr
))->KEEPIT
);
1498 /* Just an ordinary section */
1500 r_index
= output_section
->target_index
;
1504 /* now the fun stuff */
1505 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
1506 natptr
->r_index
[0] = r_index
>> 16;
1507 natptr
->r_index
[1] = r_index
>> 8;
1508 natptr
->r_index
[2] = r_index
;
1510 (r_extern
? RELOC_EXT_BITS_EXTERN_BIG
: 0)
1511 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_BIG
);
1513 natptr
->r_index
[2] = r_index
>> 16;
1514 natptr
->r_index
[1] = r_index
>> 8;
1515 natptr
->r_index
[0] = r_index
;
1517 (r_extern
? RELOC_EXT_BITS_EXTERN_LITTLE
: 0)
1518 | (r_type
<< RELOC_EXT_BITS_TYPE_SH_LITTLE
);
1521 PUT_WORD (abfd
, r_addend
, natptr
->r_addend
);
1524 /* BFD deals internally with all things based from the section they're
1525 in. so, something in 10 bytes into a text section with a base of
1526 50 would have a symbol (.text+10) and know .text vma was 50.
1528 Aout keeps all it's symbols based from zero, so the symbol would
1529 contain 60. This macro subs the base of each section from the value
1530 to give the true offset from the section */
1533 #define MOVE_ADDRESS(ad) \
1535 /* undefined symbol */ \
1536 cache_ptr->sym_ptr_ptr = symbols + r_index; \
1537 cache_ptr->addend = ad; \
1539 /* defined, section relative. replace symbol with pointer to \
1540 symbol which points to section */ \
1541 switch (r_index) { \
1543 case N_TEXT | N_EXT: \
1544 cache_ptr->sym_ptr_ptr = obj_textsec(abfd)->symbol_ptr_ptr; \
1545 cache_ptr->addend = ad - su->textsec->vma; \
1548 case N_DATA | N_EXT: \
1549 cache_ptr->sym_ptr_ptr = obj_datasec(abfd)->symbol_ptr_ptr; \
1550 cache_ptr->addend = ad - su->datasec->vma; \
1553 case N_BSS | N_EXT: \
1554 cache_ptr->sym_ptr_ptr = obj_bsssec(abfd)->symbol_ptr_ptr; \
1555 cache_ptr->addend = ad - su->bsssec->vma; \
1559 case N_ABS | N_EXT: \
1560 cache_ptr->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr; \
1561 cache_ptr->addend = ad; \
1567 DEFUN(NAME(aout
,swap_ext_reloc_in
), (abfd
, bytes
, cache_ptr
, symbols
),
1569 struct reloc_ext_external
*bytes AND
1570 arelent
*cache_ptr AND
1575 unsigned int r_type
;
1576 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
1578 cache_ptr
->address
= (GET_SWORD (abfd
, bytes
->r_address
));
1580 /* now the fun stuff */
1581 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
1582 r_index
= (bytes
->r_index
[0] << 16)
1583 | (bytes
->r_index
[1] << 8)
1584 | bytes
->r_index
[2];
1585 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_BIG
));
1586 r_type
= (bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
1587 >> RELOC_EXT_BITS_TYPE_SH_BIG
;
1589 r_index
= (bytes
->r_index
[2] << 16)
1590 | (bytes
->r_index
[1] << 8)
1591 | bytes
->r_index
[0];
1592 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_EXT_BITS_EXTERN_LITTLE
));
1593 r_type
= (bytes
->r_type
[0] & RELOC_EXT_BITS_TYPE_LITTLE
)
1594 >> RELOC_EXT_BITS_TYPE_SH_LITTLE
;
1597 cache_ptr
->howto
= howto_table_ext
+ r_type
;
1598 MOVE_ADDRESS(GET_SWORD(abfd
, bytes
->r_addend
));
1602 DEFUN(NAME(aout
,swap_std_reloc_in
), (abfd
, bytes
, cache_ptr
, symbols
),
1604 struct reloc_std_external
*bytes AND
1605 arelent
*cache_ptr AND
1610 unsigned int r_length
;
1612 int r_baserel
, r_jmptable
, r_relative
;
1613 struct aoutdata
*su
= &(abfd
->tdata
.aout_data
->a
);
1615 cache_ptr
->address
= (int32_type
)(bfd_h_get_32 (abfd
, bytes
->r_address
));
1617 /* now the fun stuff */
1618 if (abfd
->xvec
->header_byteorder_big_p
!= false) {
1619 r_index
= (bytes
->r_index
[0] << 16)
1620 | (bytes
->r_index
[1] << 8)
1621 | bytes
->r_index
[2];
1622 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_BIG
));
1623 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_BIG
));
1624 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_BIG
));
1625 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
));
1626 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_BIG
));
1627 r_length
= (bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_BIG
)
1628 >> RELOC_STD_BITS_LENGTH_SH_BIG
;
1630 r_index
= (bytes
->r_index
[2] << 16)
1631 | (bytes
->r_index
[1] << 8)
1632 | bytes
->r_index
[0];
1633 r_extern
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_EXTERN_LITTLE
));
1634 r_pcrel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_PCREL_LITTLE
));
1635 r_baserel
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_BASEREL_LITTLE
));
1636 r_jmptable
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_LITTLE
));
1637 r_relative
= (0 != (bytes
->r_type
[0] & RELOC_STD_BITS_RELATIVE_LITTLE
));
1638 r_length
= (bytes
->r_type
[0] & RELOC_STD_BITS_LENGTH_LITTLE
)
1639 >> RELOC_STD_BITS_LENGTH_SH_LITTLE
;
1642 cache_ptr
->howto
= howto_table_std
+ r_length
+ 4 * r_pcrel
;
1643 /* FIXME-soon: Roll baserel, jmptable, relative bits into howto setting */
1651 DEFUN(NAME(aout
,slurp_reloc_table
),(abfd
, asect
, symbols
),
1657 bfd_size_type reloc_size
;
1659 arelent
*reloc_cache
;
1662 if (asect
->relocation
) return true;
1664 if (asect
->flags
& SEC_CONSTRUCTOR
) return true;
1666 if (asect
== obj_datasec (abfd
)) {
1667 reloc_size
= exec_hdr(abfd
)->a_drsize
;
1671 if (asect
== obj_textsec (abfd
)) {
1672 reloc_size
= exec_hdr(abfd
)->a_trsize
;
1676 bfd_error
= invalid_operation
;
1680 bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
);
1681 each_size
= obj_reloc_entry_size (abfd
);
1683 count
= reloc_size
/ each_size
;
1686 reloc_cache
= (arelent
*) bfd_zalloc (abfd
, (size_t)(count
* sizeof
1690 bfd_error
= no_memory
;
1694 relocs
= (PTR
) bfd_alloc (abfd
, reloc_size
);
1696 bfd_release (abfd
, reloc_cache
);
1700 if (bfd_read (relocs
, 1, reloc_size
, abfd
) != reloc_size
) {
1701 bfd_release (abfd
, relocs
);
1702 bfd_release (abfd
, reloc_cache
);
1703 bfd_error
= system_call_error
;
1707 if (each_size
== RELOC_EXT_SIZE
) {
1708 register struct reloc_ext_external
*rptr
= (struct reloc_ext_external
*) relocs
;
1709 unsigned int counter
= 0;
1710 arelent
*cache_ptr
= reloc_cache
;
1712 for (; counter
< count
; counter
++, rptr
++, cache_ptr
++) {
1713 NAME(aout
,swap_ext_reloc_in
)(abfd
, rptr
, cache_ptr
, symbols
);
1716 register struct reloc_std_external
*rptr
= (struct reloc_std_external
*) relocs
;
1717 unsigned int counter
= 0;
1718 arelent
*cache_ptr
= reloc_cache
;
1720 for (; counter
< count
; counter
++, rptr
++, cache_ptr
++) {
1721 NAME(aout
,swap_std_reloc_in
)(abfd
, rptr
, cache_ptr
, symbols
);
1726 bfd_release (abfd
,relocs
);
1727 asect
->relocation
= reloc_cache
;
1728 asect
->reloc_count
= count
;
1734 /* Write out a relocation section into an object file. */
1737 DEFUN(NAME(aout
,squirt_out_relocs
),(abfd
, section
),
1742 unsigned char *native
, *natptr
;
1745 unsigned int count
= section
->reloc_count
;
1748 if (count
== 0) return true;
1750 each_size
= obj_reloc_entry_size (abfd
);
1751 natsize
= each_size
* count
;
1752 native
= (unsigned char *) bfd_zalloc (abfd
, natsize
);
1754 bfd_error
= no_memory
;
1758 generic
= section
->orelocation
;
1760 if (each_size
== RELOC_EXT_SIZE
)
1762 for (natptr
= native
;
1764 --count
, natptr
+= each_size
, ++generic
)
1765 NAME(aout
,swap_ext_reloc_out
) (abfd
, *generic
, (struct reloc_ext_external
*)natptr
);
1769 for (natptr
= native
;
1771 --count
, natptr
+= each_size
, ++generic
)
1772 NAME(aout
,swap_std_reloc_out
)(abfd
, *generic
, (struct reloc_std_external
*)natptr
);
1775 if ( bfd_write ((PTR
) native
, 1, natsize
, abfd
) != natsize
) {
1776 bfd_release(abfd
, native
);
1779 bfd_release (abfd
, native
);
1784 /* This is stupid. This function should be a boolean predicate */
1786 DEFUN(NAME(aout
,canonicalize_reloc
),(abfd
, section
, relptr
, symbols
),
1789 arelent
**relptr AND
1792 arelent
*tblptr
= section
->relocation
;
1795 if (!(tblptr
|| NAME(aout
,slurp_reloc_table
)(abfd
, section
, symbols
)))
1798 if (section
->flags
& SEC_CONSTRUCTOR
) {
1799 arelent_chain
*chain
= section
->constructor_chain
;
1800 for (count
= 0; count
< section
->reloc_count
; count
++) {
1801 *relptr
++ = &chain
->relent
;
1802 chain
= chain
->next
;
1806 tblptr
= section
->relocation
;
1807 if (!tblptr
) return 0;
1809 for (count
= 0; count
++ < section
->reloc_count
;)
1811 *relptr
++ = tblptr
++;
1816 return section
->reloc_count
;
1820 DEFUN(NAME(aout
,get_reloc_upper_bound
),(abfd
, asect
),
1824 if (bfd_get_format (abfd
) != bfd_object
) {
1825 bfd_error
= invalid_operation
;
1828 if (asect
->flags
& SEC_CONSTRUCTOR
) {
1829 return (sizeof (arelent
*) * (asect
->reloc_count
+1));
1833 if (asect
== obj_datasec (abfd
))
1834 return (sizeof (arelent
*) *
1835 ((exec_hdr(abfd
)->a_drsize
/ obj_reloc_entry_size (abfd
))
1838 if (asect
== obj_textsec (abfd
))
1839 return (sizeof (arelent
*) *
1840 ((exec_hdr(abfd
)->a_trsize
/ obj_reloc_entry_size (abfd
))
1843 bfd_error
= invalid_operation
;
1849 DEFUN(NAME(aout
,get_symtab_upper_bound
),(abfd
),
1852 if (!NAME(aout
,slurp_symbol_table
)(abfd
)) return 0;
1854 return (bfd_get_symcount (abfd
)+1) * (sizeof (aout_symbol_type
*));
1857 DEFUN(NAME(aout
,get_lineno
),(ignore_abfd
, ignore_symbol
),
1858 bfd
*ignore_abfd AND
1859 asymbol
*ignore_symbol
)
1861 return (alent
*)NULL
;
1866 DEFUN(NAME(aout
,print_symbol
),(ignore_abfd
, afile
, symbol
, how
),
1867 bfd
*ignore_abfd AND
1870 bfd_print_symbol_type how
)
1872 FILE *file
= (FILE *)afile
;
1875 case bfd_print_symbol_name
:
1877 fprintf(file
,"%s", symbol
->name
);
1879 case bfd_print_symbol_more
:
1880 fprintf(file
,"%4x %2x %2x",(unsigned)(aout_symbol(symbol
)->desc
& 0xffff),
1881 (unsigned)(aout_symbol(symbol
)->other
& 0xff),
1882 (unsigned)(aout_symbol(symbol
)->type
));
1884 case bfd_print_symbol_all
:
1886 CONST
char *section_name
= symbol
->section
->name
;
1889 bfd_print_symbol_vandf((PTR
)file
,symbol
);
1891 fprintf(file
," %-5s %04x %02x %02x",
1893 (unsigned)(aout_symbol(symbol
)->desc
& 0xffff),
1894 (unsigned)(aout_symbol(symbol
)->other
& 0xff),
1895 (unsigned)(aout_symbol(symbol
)->type
& 0xff));
1897 fprintf(file
," %s", symbol
->name
);
1900 case bfd_print_symbol_nm
:
1902 int section_code
= bfd_decode_symclass (symbol
);
1904 if (section_code
== 'U')
1907 fprintf_vma(file
, symbol
->value
+symbol
->section
->vma
);
1908 if (section_code
== '?')
1910 int type_code
= aout_symbol(symbol
)->type
& 0xff;
1911 char *stab_name
= aout_stab_name(type_code
);
1913 if (stab_name
== NULL
)
1915 sprintf(buf
, "(%d)", type_code
);
1918 fprintf(file
," - %02x %04x %5s",
1919 (unsigned)(aout_symbol(symbol
)->other
& 0xff),
1920 (unsigned)(aout_symbol(symbol
)->desc
& 0xffff),
1924 fprintf(file
," %c", section_code
);
1926 fprintf(file
," %s", symbol
->name
);
1933 provided a BFD, a section and an offset into the section, calculate
1934 and return the name of the source file and the line nearest to the
1939 DEFUN(NAME(aout
,find_nearest_line
),(abfd
,
1947 asection
*section AND
1948 asymbol
**symbols AND
1950 CONST
char **filename_ptr AND
1951 CONST
char **functionname_ptr AND
1952 unsigned int *line_ptr
)
1954 /* Run down the file looking for the filename, function and linenumber */
1956 static char buffer
[100];
1957 static char filename_buffer
[200];
1958 CONST
char *directory_name
= NULL
;
1959 CONST
char *main_file_name
= NULL
;
1960 CONST
char *current_file_name
= NULL
;
1961 CONST
char *line_file_name
= NULL
; /* Value of current_file_name at line number. */
1962 bfd_vma high_line_vma
= ~0;
1963 bfd_vma low_func_vma
= 0;
1965 *filename_ptr
= abfd
->filename
;
1966 *functionname_ptr
= 0;
1968 if (symbols
!= (asymbol
**)NULL
) {
1969 for (p
= symbols
; *p
; p
++) {
1970 aout_symbol_type
*q
= (aout_symbol_type
*)(*p
);
1974 main_file_name
= current_file_name
= q
->symbol
.name
;
1975 /* Look ahead to next symbol to check if that too is an N_SO. */
1979 q
= (aout_symbol_type
*)(*p
);
1980 if (q
->type
!= (int)N_SO
)
1983 /* Found a second N_SO First is directory; second is filename. */
1984 directory_name
= current_file_name
;
1985 main_file_name
= current_file_name
= q
->symbol
.name
;
1986 if (obj_textsec(abfd
) != section
)
1990 current_file_name
= q
->symbol
.name
;
1997 /* We'll keep this if it resolves nearer than the one we have already */
1998 if (q
->symbol
.value
>= offset
&&
1999 q
->symbol
.value
< high_line_vma
) {
2000 *line_ptr
= q
->desc
;
2001 high_line_vma
= q
->symbol
.value
;
2002 line_file_name
= current_file_name
;
2007 /* We'll keep this if it is nearer than the one we have already */
2008 if (q
->symbol
.value
>= low_func_vma
&&
2009 q
->symbol
.value
<= offset
) {
2010 low_func_vma
= q
->symbol
.value
;
2011 func
= (asymbol
*)q
;
2013 if (*line_ptr
&& func
) {
2014 CONST
char *function
= func
->name
;
2016 strncpy(buffer
, function
, sizeof(buffer
)-1);
2017 buffer
[sizeof(buffer
)-1] = 0;
2018 /* Have to remove : stuff */
2019 p
= strchr(buffer
,':');
2020 if (p
!= NULL
) { *p
= '\0'; }
2021 *functionname_ptr
= buffer
;
2033 main_file_name
= line_file_name
;
2034 if (main_file_name
) {
2035 if (main_file_name
[0] == '/' || directory_name
== NULL
)
2036 *filename_ptr
= main_file_name
;
2038 sprintf(filename_buffer
, "%.140s%.50s",
2039 directory_name
, main_file_name
);
2040 *filename_ptr
= filename_buffer
;
2048 DEFUN(NAME(aout
,sizeof_headers
),(abfd
, execable
),
2052 return adata(abfd
).exec_bytes_size
;