1 /* BFD back-end for RISC iX (Acorn, arm) binaries.
2 Copyright 1994, 1995, 1996, 1997, 1998, 2000, 2001
3 Free Software Foundation, Inc.
4 Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* RISC iX overloads the MAGIC field to indicate more than just the usual
23 [ZNO]MAGIC values. Also included are squeezing information and
24 shared library usage. */
26 /* The following come from the man page. */
29 #define MF_IMPURE 00200
30 #define MF_SQUEEZED 01000
31 #define MF_USES_SL 02000
32 #define MF_IS_SL 04000
34 /* Common combinations. */
35 #define IMAGIC (MF_IMPURE|ZMAGIC) /* Demand load (impure text) */
36 #define SPOMAGIC (MF_USES_SL|OMAGIC) /* OMAGIC with large header */
37 /* -- may contain a ref to a */
38 /* shared lib required by the */
40 #define SLOMAGIC (MF_IS_SL|OMAGIC) /* A reference to a shared library */
41 /* The text portion of the object */
42 /* contains "overflow text" from */
43 /* the shared library to be linked */
44 /* in with an object */
45 #define QMAGIC (MF_SQUEEZED|ZMAGIC) /* Sqeezed demand paged. */
46 /* NOTE: This interpretation of */
47 /* QMAGIC seems to be at variance */
48 /* With that used on other */
50 #define SPZMAGIC (MF_USES_SL|ZMAGIC) /* program which uses sl */
51 #define SPQMAGIC (MF_USES_SL|QMAGIC) /* sqeezed ditto */
52 #define SLZMAGIC (MF_IS_SL|ZMAGIC) /* shared lib part of prog */
53 #define SLPZMAGIC (MF_USES_SL|SLZMAGIC) /* sl which uses another */
55 #define N_SHARED_LIB(x) ((x).a_info & MF_USES_SL)
57 /* Only a pure OMAGIC file has the minimal header */
59 ((x).a_info == OMAGIC ? 32 \
60 : (N_MAGIC(x) == ZMAGIC) ? TARGET_PAGE_SIZE \
63 #define N_TXTADDR(x) \
64 (N_MAGIC(x) != ZMAGIC ? 0 /* object file or NMAGIC */ \
65 /* Programs with shared libs are loaded at the first page after all the \
66 text segments of the shared library programs. Without looking this \
67 up we can't know exactly what the address will be. A reasonable guess \
68 is that a_entry will be in the first page of the executable. */ \
69 : N_SHARED_LIB(x) ? ((x).a_entry & ~(TARGET_PAGE_SIZE - 1)) \
73 (N_TXTOFF (x) + (x).a_text + (x).a_data + (x).a_trsize + (x).a_drsize)
75 #define N_STROFF(x) (N_SYMOFF (x) + (x).a_syms)
77 #define TEXT_START_ADDR 32768
78 #define TARGET_PAGE_SIZE 32768
79 #define SEGMENT_SIZE TARGET_PAGE_SIZE
80 #define DEFAULT_ARCH bfd_arch_arm
82 #define MY(OP) CAT(riscix_,OP)
83 #define TARGETNAME "a.out-riscix"
84 #define N_BADMAG(x) ((((x).a_info & ~007200) != ZMAGIC) && \
85 (((x).a_info & ~006000) != OMAGIC) && \
86 ((x).a_info != NMAGIC))
87 #define N_MAGIC(x) ((x).a_info & ~07200)
93 #define WRITE_HEADERS(abfd, execp) \
95 bfd_size_type text_size; /* dummy vars */ \
97 if (adata(abfd).magic == undecided_magic) \
98 NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end); \
100 execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE; \
101 execp->a_entry = bfd_get_start_address (abfd); \
103 execp->a_trsize = ((obj_textsec (abfd)->reloc_count) * \
104 obj_reloc_entry_size (abfd)); \
105 execp->a_drsize = ((obj_datasec (abfd)->reloc_count) * \
106 obj_reloc_entry_size (abfd)); \
107 NAME(aout,swap_exec_header_out) (abfd, execp, &exec_bytes); \
109 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) return false; \
110 if (bfd_write ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd) \
111 != EXEC_BYTES_SIZE) \
113 /* Now write out reloc info, followed by syms and strings */ \
115 if (bfd_get_outsymbols (abfd) != (asymbol **) NULL \
116 && bfd_get_symcount (abfd) != 0) \
118 if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*execp)), SEEK_SET) != 0) \
121 if (! NAME(aout,write_syms) (abfd)) return false; \
123 if (bfd_seek (abfd, (file_ptr) (N_TRELOFF(*execp)), SEEK_SET) != 0) \
126 if (! riscix_squirt_out_relocs (abfd, obj_textsec (abfd))) \
128 if (bfd_seek (abfd, (file_ptr) (N_DRELOFF(*execp)), SEEK_SET) != 0) \
131 if (!NAME(aout,squirt_out_relocs) (abfd, obj_datasec (abfd))) \
137 #include "aout/aout64.h"
139 static bfd_reloc_status_type
140 riscix_fix_pcrel_26_done
PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
,
141 asection
*, bfd
*, char **));
143 static bfd_reloc_status_type
144 riscix_fix_pcrel_26
PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
,
145 asection
*, bfd
*, char **));
146 static const bfd_target
*
147 MY (object_p
) PARAMS ((bfd
*));
150 riscix_reloc_type_lookup
PARAMS ((bfd
*, bfd_reloc_code_real_type
));
153 riscix_swap_std_reloc_out
PARAMS ((bfd
*, arelent
*, struct reloc_std_external
*));
156 riscix_squirt_out_relocs
PARAMS ((bfd
*, asection
*));
159 MY (canonicalize_reloc
) PARAMS ((bfd
*, sec_ptr
, arelent
**, asymbol
**));
162 riscix_some_aout_object_p
PARAMS ((bfd
*, struct internal_exec
*, const bfd_target
*(*) (bfd
*)));
165 static reloc_howto_type riscix_std_reloc_howto
[] = {
166 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
167 HOWTO( 0, 0, 0, 8, false, 0, complain_overflow_bitfield
,0,"8", true, 0x000000ff,0x000000ff, false),
168 HOWTO( 1, 0, 1, 16, false, 0, complain_overflow_bitfield
,0,"16", true, 0x0000ffff,0x0000ffff, false),
169 HOWTO( 2, 0, 2, 32, false, 0, complain_overflow_bitfield
,0,"32", true, 0xffffffff,0xffffffff, false),
170 HOWTO( 3, 2, 3, 26, true, 0, complain_overflow_signed
, riscix_fix_pcrel_26
, "ARM26", true, 0x00ffffff,0x00ffffff, false),
171 HOWTO( 4, 0, 0, 8, true, 0, complain_overflow_signed
, 0,"DISP8", true, 0x000000ff,0x000000ff, true),
172 HOWTO( 5, 0, 1, 16, true, 0, complain_overflow_signed
, 0,"DISP16", true, 0x0000ffff,0x0000ffff, true),
173 HOWTO( 6, 0, 2, 32, true, 0, complain_overflow_signed
, 0,"DISP32", true, 0xffffffff,0xffffffff, true),
174 HOWTO( 7, 2, 3, 26, false, 0, complain_overflow_signed
, riscix_fix_pcrel_26_done
, "ARM26D",true,0x00ffffff,0x00ffffff, false),
176 HOWTO( 9, 0, -1, 16, false, 0, complain_overflow_bitfield
,0,"NEG16", true, 0x0000ffff,0x0000ffff, false),
177 HOWTO( 10, 0, -2, 32, false, 0, complain_overflow_bitfield
,0,"NEG32", true, 0xffffffff,0xffffffff, false)
180 #define RISCIX_TABLE_SIZE \
181 (sizeof (riscix_std_reloc_howto) / sizeof (reloc_howto_type))
183 static bfd_reloc_status_type
184 riscix_fix_pcrel_26_done (abfd
, reloc_entry
, symbol
, data
, input_section
,
185 output_bfd
, error_message
)
186 bfd
*abfd ATTRIBUTE_UNUSED
;
187 arelent
*reloc_entry ATTRIBUTE_UNUSED
;
188 asymbol
*symbol ATTRIBUTE_UNUSED
;
189 PTR data ATTRIBUTE_UNUSED
;
190 asection
*input_section ATTRIBUTE_UNUSED
;
191 bfd
*output_bfd ATTRIBUTE_UNUSED
;
192 char **error_message ATTRIBUTE_UNUSED
;
194 /* This is dead simple at present. */
198 static bfd_reloc_status_type
199 riscix_fix_pcrel_26 (abfd
, reloc_entry
, symbol
, data
, input_section
,
200 output_bfd
, error_message
)
202 arelent
*reloc_entry
;
205 asection
*input_section
;
207 char **error_message ATTRIBUTE_UNUSED
;
210 bfd_size_type addr
= reloc_entry
->address
;
211 long target
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ addr
);
212 bfd_reloc_status_type flag
= bfd_reloc_ok
;
214 /* If this is an undefined symbol, return error */
215 if (symbol
->section
== &bfd_und_section
216 && (symbol
->flags
& BSF_WEAK
) == 0)
217 return output_bfd
? bfd_reloc_continue
: bfd_reloc_undefined
;
219 /* If the sections are different, and we are doing a partial relocation,
220 just ignore it for now. */
221 if (symbol
->section
->name
!= input_section
->name
222 && output_bfd
!= (bfd
*)NULL
)
223 return bfd_reloc_continue
;
225 relocation
= (target
& 0x00ffffff) << 2;
226 relocation
= (relocation
^ 0x02000000) - 0x02000000; /* Sign extend */
227 relocation
+= symbol
->value
;
228 relocation
+= symbol
->section
->output_section
->vma
;
229 relocation
+= symbol
->section
->output_offset
;
230 relocation
+= reloc_entry
->addend
;
231 relocation
-= input_section
->output_section
->vma
;
232 relocation
-= input_section
->output_offset
;
235 return bfd_reloc_overflow
;
237 /* Check for overflow */
238 if (relocation
& 0x02000000)
240 if ((relocation
& ~ (bfd_vma
) 0x03ffffff) != ~ (bfd_vma
) 0x03ffffff)
241 flag
= bfd_reloc_overflow
;
243 else if (relocation
& ~0x03ffffff)
244 flag
= bfd_reloc_overflow
;
246 target
&= ~0x00ffffff;
247 target
|= (relocation
>> 2) & 0x00ffffff;
248 bfd_put_32 (abfd
, target
, (bfd_byte
*) data
+ addr
);
250 /* Now the ARM magic... Change the reloc type so that it is marked as done.
251 Strictly this is only necessary if we are doing a partial relocation. */
252 reloc_entry
->howto
= &riscix_std_reloc_howto
[7];
258 riscix_reloc_type_lookup (abfd
, code
)
260 bfd_reloc_code_real_type code
;
262 #define ASTD(i,j) case i: return &riscix_std_reloc_howto[j]
263 if (code
== BFD_RELOC_CTOR
)
264 switch (bfd_get_arch_info (abfd
)->bits_per_address
)
269 default: return (reloc_howto_type
*) NULL
;
274 ASTD (BFD_RELOC_16
, 1);
275 ASTD (BFD_RELOC_32
, 2);
276 ASTD (BFD_RELOC_ARM_PCREL_BRANCH
, 3);
277 ASTD (BFD_RELOC_8_PCREL
, 4);
278 ASTD (BFD_RELOC_16_PCREL
, 5);
279 ASTD (BFD_RELOC_32_PCREL
, 6);
280 default: return (reloc_howto_type
*) NULL
;
284 #define MY_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
285 #define MY_bfd_link_add_symbols _bfd_generic_link_add_symbols
286 #define MY_final_link_callback should_not_be_used
287 #define MY_bfd_final_link _bfd_generic_final_link
289 #define MY_bfd_reloc_type_lookup riscix_reloc_type_lookup
290 #define MY_canonicalize_reloc riscix_canonicalize_reloc
291 #define MY_object_p riscix_object_p
293 static const bfd_target
*riscix_callback
PARAMS ((bfd
*));
296 riscix_swap_std_reloc_out (abfd
, g
, natptr
)
299 struct reloc_std_external
*natptr
;
302 asymbol
*sym
= *(g
->sym_ptr_ptr
);
306 int r_neg
= 0; /* Negative relocs use the BASEREL bit. */
307 asection
*output_section
= sym
->section
->output_section
;
309 PUT_WORD(abfd
, g
->address
, natptr
->r_address
);
311 r_length
= g
->howto
->size
; /* Size as a power of two */
314 r_length
= -r_length
;
318 r_pcrel
= (int) g
->howto
->pc_relative
; /* Relative to PC? */
320 /* For RISC iX, in pc-relative relocs the r_pcrel bit means that the
321 relocation has been done already (Only for the 26-bit one I think)???!!!
325 r_pcrel
= r_pcrel
? 0 : 1;
328 /* For a standard reloc, the addend is in the object file. */
329 r_addend
= g
->addend
+ (*(g
->sym_ptr_ptr
))->section
->output_section
->vma
;
332 /* name was clobbered by aout_write_syms to be symbol index */
334 /* If this relocation is relative to a symbol then set the
335 r_index to the symbols index, and the r_extern bit.
337 Absolute symbols can come in in two ways, either as an offset
338 from the abs section, or as a symbol which has an abs value.
342 if (bfd_is_com_section (output_section
)
343 || output_section
== &bfd_abs_section
344 || output_section
== &bfd_und_section
)
346 if (bfd_abs_section
.symbol
== sym
)
348 /* Whoops, looked like an abs symbol, but is really an offset
349 from the abs section */
357 r_index
= (*g
->sym_ptr_ptr
)->udata
.i
;
362 /* Just an ordinary section */
364 r_index
= output_section
->target_index
;
367 /* now the fun stuff */
368 if (bfd_header_big_endian (abfd
))
370 natptr
->r_index
[0] = r_index
>> 16;
371 natptr
->r_index
[1] = r_index
>> 8;
372 natptr
->r_index
[2] = r_index
;
374 ( (r_extern
? RELOC_STD_BITS_EXTERN_BIG
: 0)
375 | (r_pcrel
? RELOC_STD_BITS_PCREL_BIG
: 0)
376 | (r_neg
? RELOC_STD_BITS_BASEREL_BIG
: 0)
377 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_BIG
));
381 natptr
->r_index
[2] = r_index
>> 16;
382 natptr
->r_index
[1] = r_index
>> 8;
383 natptr
->r_index
[0] = r_index
;
385 ( (r_extern
? RELOC_STD_BITS_EXTERN_LITTLE
: 0)
386 | (r_pcrel
? RELOC_STD_BITS_PCREL_LITTLE
: 0)
387 | (r_neg
? RELOC_STD_BITS_BASEREL_LITTLE
: 0)
388 | (r_length
<< RELOC_STD_BITS_LENGTH_SH_LITTLE
));
393 riscix_squirt_out_relocs (abfd
, section
)
398 unsigned char *native
, *natptr
;
401 unsigned int count
= section
->reloc_count
;
404 if (count
== 0) return true;
406 each_size
= obj_reloc_entry_size (abfd
);
407 natsize
= each_size
* count
;
408 native
= (unsigned char *) bfd_zalloc (abfd
, natsize
);
412 generic
= section
->orelocation
;
414 for (natptr
= native
;
416 --count
, natptr
+= each_size
, ++generic
)
417 riscix_swap_std_reloc_out (abfd
, *generic
,
418 (struct reloc_std_external
*) natptr
);
420 if ( bfd_write ((PTR
) native
, 1, natsize
, abfd
) != natsize
)
422 bfd_release(abfd
, native
);
426 bfd_release (abfd
, native
);
431 * This is just like the standard aoutx.h version but we need to do our
432 * own mapping of external reloc type values to howto entries.
435 MY(canonicalize_reloc
) (abfd
, section
, relptr
, symbols
)
441 arelent
*tblptr
= section
->relocation
;
442 unsigned int count
, c
;
443 extern reloc_howto_type
NAME(aout
,std_howto_table
)[];
445 /* If we have already read in the relocation table, return the values. */
446 if (section
->flags
& SEC_CONSTRUCTOR
) {
447 arelent_chain
*chain
= section
->constructor_chain
;
449 for (count
= 0; count
< section
->reloc_count
; count
++) {
450 *relptr
++ = &chain
->relent
;
454 return section
->reloc_count
;
456 if (tblptr
&& section
->reloc_count
) {
457 for (count
= 0; count
++ < section
->reloc_count
;)
458 *relptr
++ = tblptr
++;
460 return section
->reloc_count
;
463 if (!NAME(aout
,slurp_reloc_table
) (abfd
, section
, symbols
))
465 tblptr
= section
->relocation
;
467 /* fix up howto entries */
468 for (count
= 0; count
++ < section
->reloc_count
;)
470 c
= tblptr
->howto
- NAME(aout
,std_howto_table
);
471 BFD_ASSERT (c
< RISCIX_TABLE_SIZE
);
472 tblptr
->howto
= &riscix_std_reloc_howto
[c
];
474 *relptr
++ = tblptr
++;
477 return section
->reloc_count
;
480 /* This is the same as NAME(aout,some_aout_object_p), but has different
481 expansions of the macro definitions. */
484 riscix_some_aout_object_p (abfd
, execp
, callback_to_real_object_p
)
486 struct internal_exec
*execp
;
487 const bfd_target
*(*callback_to_real_object_p
) PARAMS ((bfd
*));
489 struct aout_data_struct
*rawptr
, *oldrawptr
;
490 const bfd_target
*result
;
492 rawptr
= ((struct aout_data_struct
*)
493 bfd_zalloc (abfd
, sizeof (struct aout_data_struct
)));
498 oldrawptr
= abfd
->tdata
.aout_data
;
499 abfd
->tdata
.aout_data
= rawptr
;
501 /* Copy the contents of the old tdata struct.
502 In particular, we want the subformat, since for hpux it was set in
503 hp300hpux.c:swap_exec_header_in and will be used in
504 hp300hpux.c:callback. */
505 if (oldrawptr
!= NULL
)
506 *abfd
->tdata
.aout_data
= *oldrawptr
;
508 abfd
->tdata
.aout_data
->a
.hdr
= &rawptr
->e
;
509 *(abfd
->tdata
.aout_data
->a
.hdr
) = *execp
; /* Copy in the internal_exec
511 execp
= abfd
->tdata
.aout_data
->a
.hdr
;
513 /* Set the file flags */
514 abfd
->flags
= BFD_NO_FLAGS
;
515 if (execp
->a_drsize
|| execp
->a_trsize
)
516 abfd
->flags
|= HAS_RELOC
;
517 /* Setting of EXEC_P has been deferred to the bottom of this function */
519 abfd
->flags
|= HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
;
520 if (N_DYNAMIC(*execp
))
521 abfd
->flags
|= DYNAMIC
;
523 if ((execp
->a_info
& MF_SQUEEZED
) != 0) /* Squeezed files aren't supported
526 bfd_set_error (bfd_error_wrong_format
);
529 else if ((execp
->a_info
& MF_IS_SL
) != 0) /* Nor are shared libraries */
531 bfd_set_error (bfd_error_wrong_format
);
534 else if (N_MAGIC (*execp
) == ZMAGIC
)
536 abfd
->flags
|= D_PAGED
| WP_TEXT
;
537 adata (abfd
).magic
= z_magic
;
539 else if (N_MAGIC (*execp
) == NMAGIC
)
541 abfd
->flags
|= WP_TEXT
;
542 adata (abfd
).magic
= n_magic
;
544 else if (N_MAGIC (*execp
) == OMAGIC
)
545 adata (abfd
).magic
= o_magic
;
548 /* Should have been checked with N_BADMAG before this routine
553 bfd_get_start_address (abfd
) = execp
->a_entry
;
555 obj_aout_symbols (abfd
) = (aout_symbol_type
*)NULL
;
556 bfd_get_symcount (abfd
) = execp
->a_syms
/ sizeof (struct external_nlist
);
558 /* The default relocation entry size is that of traditional V7 Unix. */
559 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
561 /* The default symbol entry size is that of traditional Unix. */
562 obj_symbol_entry_size (abfd
) = EXTERNAL_NLIST_SIZE
;
564 obj_aout_external_syms (abfd
) = NULL
;
565 obj_aout_external_strings (abfd
) = NULL
;
566 obj_aout_sym_hashes (abfd
) = NULL
;
568 if (! NAME(aout
,make_sections
) (abfd
))
571 obj_datasec (abfd
)->_raw_size
= execp
->a_data
;
572 obj_bsssec (abfd
)->_raw_size
= execp
->a_bss
;
574 obj_textsec (abfd
)->flags
=
575 (execp
->a_trsize
!= 0
576 ? (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_RELOC
)
577 : (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
));
578 obj_datasec (abfd
)->flags
=
579 (execp
->a_drsize
!= 0
580 ? (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_RELOC
)
581 : (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_HAS_CONTENTS
));
582 obj_bsssec (abfd
)->flags
= SEC_ALLOC
;
584 result
= (*callback_to_real_object_p
) (abfd
);
586 #if defined(MACH) || defined(STAT_FOR_EXEC)
587 /* The original heuristic doesn't work in some important cases. The
588 * a.out file has no information about the text start address. For
589 * files (like kernels) linked to non-standard addresses (ld -Ttext
590 * nnn) the entry point may not be between the default text start
591 * (obj_textsec(abfd)->vma) and (obj_textsec(abfd)->vma) + text size
592 * This is not just a mach issue. Many kernels are loaded at non
593 * standard addresses.
596 struct stat stat_buf
;
597 if (abfd
->iostream
!= NULL
598 && (abfd
->flags
& BFD_IN_MEMORY
) == 0
599 && (fstat(fileno((FILE *) (abfd
->iostream
)), &stat_buf
) == 0)
600 && ((stat_buf
.st_mode
& 0111) != 0))
601 abfd
->flags
|= EXEC_P
;
604 /* Now that the segment addresses have been worked out, take a better
605 guess at whether the file is executable. If the entry point
606 is within the text segment, assume it is. (This makes files
607 executable even if their entry point address is 0, as long as
608 their text starts at zero.)
610 At some point we should probably break down and stat the file and
611 declare it executable if (one of) its 'x' bits are on... */
612 if ((execp
->a_entry
>= obj_textsec(abfd
)->vma
) &&
613 (execp
->a_entry
< obj_textsec(abfd
)->vma
+ obj_textsec(abfd
)->_raw_size
))
614 abfd
->flags
|= EXEC_P
;
622 abfd
->tdata
.aout_data
= oldrawptr
;
627 static const bfd_target
*
631 struct external_exec exec_bytes
; /* Raw exec header from file */
632 struct internal_exec exec
; /* Cleaned-up exec header */
633 const bfd_target
*target
;
635 if (bfd_read ((PTR
) &exec_bytes
, 1, EXEC_BYTES_SIZE
, abfd
)
636 != EXEC_BYTES_SIZE
) {
637 if (bfd_get_error () != bfd_error_system_call
)
638 bfd_set_error (bfd_error_wrong_format
);
642 exec
.a_info
= bfd_h_get_32 (abfd
, exec_bytes
.e_info
);
644 if (N_BADMAG (exec
)) return 0;
646 if (!(MACHTYPE_OK (N_MACHTYPE (exec
)))) return 0;
649 NAME(aout
,swap_exec_header_in
) (abfd
, &exec_bytes
, &exec
);
651 target
= riscix_some_aout_object_p (abfd
, &exec
, MY(callback
));
656 #include "aout-target.h"