* pe-dll.c (make_import_fixup_mark): Avoid type-punned pointer.
[binutils.git] / bfd / riscix.c
blob6ec78246a7f35381795bd77dcebf124d786fa7ea
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. */
27 #define SHLIBLEN 60
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 */
39 /* object. */
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 */
49 /* architectures. */
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 */
58 #define N_TXTOFF(x) \
59 ((x).a_info == OMAGIC \
60 ? 32 \
61 : (N_MAGIC(x) == ZMAGIC \
62 ? TARGET_PAGE_SIZE \
63 : 999))
65 #define N_TXTADDR(x) \
66 (N_MAGIC(x) != ZMAGIC \
67 ? (bfd_vma) 0 /* object file or NMAGIC */ \
68 /* Programs with shared libs are loaded at the first page after all the \
69 text segments of the shared library programs. Without looking this \
70 up we can't know exactly what the address will be. A reasonable guess \
71 is that a_entry will be in the first page of the executable. */ \
72 : (N_SHARED_LIB(x) \
73 ? ((x).a_entry & ~(bfd_vma) (TARGET_PAGE_SIZE - 1)) \
74 : (bfd_vma) TEXT_START_ADDR))
76 #define N_SYMOFF(x) \
77 (N_TXTOFF (x) + (x).a_text + (x).a_data + (x).a_trsize + (x).a_drsize)
79 #define N_STROFF(x) (N_SYMOFF (x) + (x).a_syms)
81 #define TEXT_START_ADDR 32768
82 #define TARGET_PAGE_SIZE 32768
83 #define SEGMENT_SIZE TARGET_PAGE_SIZE
84 #define DEFAULT_ARCH bfd_arch_arm
86 /* Do not "beautify" the CONCAT* macro args. Traditional C will not
87 remove whitespace added here, and thus will fail to concatenate
88 the tokens. */
89 #define MY(OP) CONCAT2 (riscix_,OP)
90 #define TARGETNAME "a.out-riscix"
91 #define N_BADMAG(x) ((((x).a_info & ~007200) != ZMAGIC) && \
92 (((x).a_info & ~006000) != OMAGIC) && \
93 ((x).a_info != NMAGIC))
94 #define N_MAGIC(x) ((x).a_info & ~07200)
96 #include "bfd.h"
97 #include "sysdep.h"
98 #include "libbfd.h"
100 #define WRITE_HEADERS(abfd, execp) \
102 bfd_size_type text_size; /* dummy vars */ \
103 file_ptr text_end; \
104 if (adata(abfd).magic == undecided_magic) \
105 NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end); \
107 execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE; \
108 execp->a_entry = bfd_get_start_address (abfd); \
110 execp->a_trsize = ((obj_textsec (abfd)->reloc_count) * \
111 obj_reloc_entry_size (abfd)); \
112 execp->a_drsize = ((obj_datasec (abfd)->reloc_count) * \
113 obj_reloc_entry_size (abfd)); \
114 NAME(aout,swap_exec_header_out) (abfd, execp, &exec_bytes); \
116 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 \
117 || bfd_bwrite ((PTR) &exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, \
118 abfd) != EXEC_BYTES_SIZE) \
119 return false; \
120 /* Now write out reloc info, followed by syms and strings */ \
122 if (bfd_get_outsymbols (abfd) != (asymbol **) NULL \
123 && bfd_get_symcount (abfd) != 0) \
125 if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*execp)), SEEK_SET) != 0) \
126 return false; \
128 if (! NAME(aout,write_syms) (abfd)) return false; \
130 if (bfd_seek (abfd, (file_ptr) (N_TRELOFF(*execp)), SEEK_SET) != 0) \
131 return false; \
133 if (! riscix_squirt_out_relocs (abfd, obj_textsec (abfd))) \
134 return false; \
135 if (bfd_seek (abfd, (file_ptr) (N_DRELOFF(*execp)), SEEK_SET) != 0) \
136 return false; \
138 if (!NAME(aout,squirt_out_relocs) (abfd, obj_datasec (abfd))) \
139 return false; \
143 #include "libaout.h"
144 #include "aout/aout64.h"
146 static bfd_reloc_status_type
147 riscix_fix_pcrel_26_done PARAMS ((bfd *, arelent *, asymbol *, PTR,
148 asection *, bfd *, char **));
150 static bfd_reloc_status_type
151 riscix_fix_pcrel_26 PARAMS ((bfd *, arelent *, asymbol *, PTR,
152 asection *, bfd *, char **));
153 static const bfd_target *
154 MY (object_p) PARAMS ((bfd *));
156 reloc_howto_type *
157 riscix_reloc_type_lookup PARAMS ((bfd *, bfd_reloc_code_real_type));
159 void
160 riscix_swap_std_reloc_out PARAMS ((bfd *, arelent *, struct reloc_std_external *));
162 boolean
163 riscix_squirt_out_relocs PARAMS ((bfd *, asection *));
165 long
166 MY (canonicalize_reloc) PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));
168 const bfd_target *
169 riscix_some_aout_object_p PARAMS ((bfd *, struct internal_exec *, const bfd_target *(*) (bfd *)));
172 static reloc_howto_type riscix_std_reloc_howto[] = {
173 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
174 HOWTO( 0, 0, 0, 8, false, 0, complain_overflow_bitfield,0,"8", true, 0x000000ff,0x000000ff, false),
175 HOWTO( 1, 0, 1, 16, false, 0, complain_overflow_bitfield,0,"16", true, 0x0000ffff,0x0000ffff, false),
176 HOWTO( 2, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"32", true, 0xffffffff,0xffffffff, false),
177 HOWTO( 3, 2, 3, 26, true, 0, complain_overflow_signed, riscix_fix_pcrel_26 , "ARM26", true, 0x00ffffff,0x00ffffff, false),
178 HOWTO( 4, 0, 0, 8, true, 0, complain_overflow_signed, 0,"DISP8", true, 0x000000ff,0x000000ff, true),
179 HOWTO( 5, 0, 1, 16, true, 0, complain_overflow_signed, 0,"DISP16", true, 0x0000ffff,0x0000ffff, true),
180 HOWTO( 6, 0, 2, 32, true, 0, complain_overflow_signed, 0,"DISP32", true, 0xffffffff,0xffffffff, true),
181 HOWTO( 7, 2, 3, 26, false, 0, complain_overflow_signed, riscix_fix_pcrel_26_done, "ARM26D",true,0x00ffffff,0x00ffffff, false),
182 EMPTY_HOWTO (-1),
183 HOWTO( 9, 0, -1, 16, false, 0, complain_overflow_bitfield,0,"NEG16", true, 0x0000ffff,0x0000ffff, false),
184 HOWTO( 10, 0, -2, 32, false, 0, complain_overflow_bitfield,0,"NEG32", true, 0xffffffff,0xffffffff, false)
187 #define RISCIX_TABLE_SIZE \
188 (sizeof (riscix_std_reloc_howto) / sizeof (reloc_howto_type))
190 static bfd_reloc_status_type
191 riscix_fix_pcrel_26_done (abfd, reloc_entry, symbol, data, input_section,
192 output_bfd, error_message)
193 bfd *abfd ATTRIBUTE_UNUSED;
194 arelent *reloc_entry ATTRIBUTE_UNUSED;
195 asymbol *symbol ATTRIBUTE_UNUSED;
196 PTR data ATTRIBUTE_UNUSED;
197 asection *input_section ATTRIBUTE_UNUSED;
198 bfd *output_bfd ATTRIBUTE_UNUSED;
199 char **error_message ATTRIBUTE_UNUSED;
201 /* This is dead simple at present. */
202 return bfd_reloc_ok;
205 static bfd_reloc_status_type
206 riscix_fix_pcrel_26 (abfd, reloc_entry, symbol, data, input_section,
207 output_bfd, error_message)
208 bfd *abfd;
209 arelent *reloc_entry;
210 asymbol *symbol;
211 PTR data;
212 asection *input_section;
213 bfd *output_bfd;
214 char **error_message ATTRIBUTE_UNUSED;
216 bfd_vma relocation;
217 bfd_size_type addr = reloc_entry->address;
218 long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
219 bfd_reloc_status_type flag = bfd_reloc_ok;
221 /* If this is an undefined symbol, return error */
222 if (symbol->section == &bfd_und_section
223 && (symbol->flags & BSF_WEAK) == 0)
224 return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
226 /* If the sections are different, and we are doing a partial relocation,
227 just ignore it for now. */
228 if (symbol->section->name != input_section->name
229 && output_bfd != (bfd *)NULL)
230 return bfd_reloc_continue;
232 relocation = (target & 0x00ffffff) << 2;
233 relocation = (relocation ^ 0x02000000) - 0x02000000; /* Sign extend */
234 relocation += symbol->value;
235 relocation += symbol->section->output_section->vma;
236 relocation += symbol->section->output_offset;
237 relocation += reloc_entry->addend;
238 relocation -= input_section->output_section->vma;
239 relocation -= input_section->output_offset;
240 relocation -= addr;
241 if (relocation & 3)
242 return bfd_reloc_overflow;
244 /* Check for overflow */
245 if (relocation & 0x02000000)
247 if ((relocation & ~ (bfd_vma) 0x03ffffff) != ~ (bfd_vma) 0x03ffffff)
248 flag = bfd_reloc_overflow;
250 else if (relocation & ~ (bfd_vma) 0x03ffffff)
251 flag = bfd_reloc_overflow;
253 target &= ~0x00ffffff;
254 target |= (relocation >> 2) & 0x00ffffff;
255 bfd_put_32 (abfd, (bfd_vma) target, (bfd_byte *) data + addr);
257 /* Now the ARM magic... Change the reloc type so that it is marked as done.
258 Strictly this is only necessary if we are doing a partial relocation. */
259 reloc_entry->howto = &riscix_std_reloc_howto[7];
261 return flag;
264 reloc_howto_type *
265 riscix_reloc_type_lookup (abfd, code)
266 bfd *abfd;
267 bfd_reloc_code_real_type code;
269 #define ASTD(i,j) case i: return &riscix_std_reloc_howto[j]
270 if (code == BFD_RELOC_CTOR)
271 switch (bfd_get_arch_info (abfd)->bits_per_address)
273 case 32:
274 code = BFD_RELOC_32;
275 break;
276 default: return (reloc_howto_type *) NULL;
279 switch (code)
281 ASTD (BFD_RELOC_16, 1);
282 ASTD (BFD_RELOC_32, 2);
283 ASTD (BFD_RELOC_ARM_PCREL_BRANCH, 3);
284 ASTD (BFD_RELOC_8_PCREL, 4);
285 ASTD (BFD_RELOC_16_PCREL, 5);
286 ASTD (BFD_RELOC_32_PCREL, 6);
287 default: return (reloc_howto_type *) NULL;
291 #define MY_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
292 #define MY_bfd_link_add_symbols _bfd_generic_link_add_symbols
293 #define MY_final_link_callback should_not_be_used
294 #define MY_bfd_final_link _bfd_generic_final_link
296 #define MY_bfd_reloc_type_lookup riscix_reloc_type_lookup
297 #define MY_canonicalize_reloc riscix_canonicalize_reloc
298 #define MY_object_p riscix_object_p
300 static const bfd_target *riscix_callback PARAMS ((bfd *));
302 void
303 riscix_swap_std_reloc_out (abfd, g, natptr)
304 bfd *abfd;
305 arelent *g;
306 struct reloc_std_external *natptr;
308 int r_index;
309 asymbol *sym = *(g->sym_ptr_ptr);
310 int r_extern;
311 int r_length;
312 int r_pcrel;
313 int r_neg = 0; /* Negative relocs use the BASEREL bit. */
314 asection *output_section = sym->section->output_section;
316 PUT_WORD(abfd, g->address, natptr->r_address);
318 r_length = g->howto->size ; /* Size as a power of two */
319 if (r_length < 0)
321 r_length = -r_length;
322 r_neg = 1;
325 r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */
327 /* For RISC iX, in pc-relative relocs the r_pcrel bit means that the
328 relocation has been done already (Only for the 26-bit one I think)???!!!
331 if (r_length == 3)
332 r_pcrel = r_pcrel ? 0 : 1;
334 #if 0
335 /* For a standard reloc, the addend is in the object file. */
336 r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
337 #endif
339 /* name was clobbered by aout_write_syms to be symbol index */
341 /* If this relocation is relative to a symbol then set the
342 r_index to the symbols index, and the r_extern bit.
344 Absolute symbols can come in in two ways, either as an offset
345 from the abs section, or as a symbol which has an abs value.
346 check for that here
349 if (bfd_is_com_section (output_section)
350 || output_section == &bfd_abs_section
351 || output_section == &bfd_und_section)
353 if (bfd_abs_section.symbol == sym)
355 /* Whoops, looked like an abs symbol, but is really an offset
356 from the abs section */
357 r_index = 0;
358 r_extern = 0;
360 else
362 /* Fill in symbol */
363 r_extern = 1;
364 r_index = (*g->sym_ptr_ptr)->udata.i;
367 else
369 /* Just an ordinary section */
370 r_extern = 0;
371 r_index = output_section->target_index;
374 /* now the fun stuff */
375 if (bfd_header_big_endian (abfd))
377 natptr->r_index[0] = r_index >> 16;
378 natptr->r_index[1] = r_index >> 8;
379 natptr->r_index[2] = r_index;
380 natptr->r_type[0] =
381 ( (r_extern ? RELOC_STD_BITS_EXTERN_BIG: 0)
382 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG: 0)
383 | (r_neg ? RELOC_STD_BITS_BASEREL_BIG: 0)
384 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
386 else
388 natptr->r_index[2] = r_index >> 16;
389 natptr->r_index[1] = r_index >> 8;
390 natptr->r_index[0] = r_index;
391 natptr->r_type[0] =
392 ( (r_extern ? RELOC_STD_BITS_EXTERN_LITTLE: 0)
393 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE: 0)
394 | (r_neg ? RELOC_STD_BITS_BASEREL_LITTLE: 0)
395 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
399 boolean
400 riscix_squirt_out_relocs (abfd, section)
401 bfd *abfd;
402 asection *section;
404 arelent **generic;
405 unsigned char *native, *natptr;
406 size_t each_size;
408 unsigned int count = section->reloc_count;
409 bfd_size_type natsize;
411 if (count == 0) return true;
413 each_size = obj_reloc_entry_size (abfd);
414 natsize = each_size;
415 natsize *= count;
416 native = (unsigned char *) bfd_zalloc (abfd, natsize);
417 if (!native)
418 return false;
420 generic = section->orelocation;
422 for (natptr = native;
423 count != 0;
424 --count, natptr += each_size, ++generic)
425 riscix_swap_std_reloc_out (abfd, *generic,
426 (struct reloc_std_external *) natptr);
428 if (bfd_bwrite ((PTR) native, natsize, abfd) != natsize)
430 bfd_release (abfd, native);
431 return false;
434 bfd_release (abfd, native);
435 return true;
439 * This is just like the standard aoutx.h version but we need to do our
440 * own mapping of external reloc type values to howto entries.
442 long
443 MY(canonicalize_reloc) (abfd, section, relptr, symbols)
444 bfd *abfd;
445 sec_ptr section;
446 arelent **relptr;
447 asymbol **symbols;
449 arelent *tblptr = section->relocation;
450 unsigned int count, c;
451 extern reloc_howto_type NAME(aout,std_howto_table)[];
453 /* If we have already read in the relocation table, return the values. */
454 if (section->flags & SEC_CONSTRUCTOR) {
455 arelent_chain *chain = section->constructor_chain;
457 for (count = 0; count < section->reloc_count; count++) {
458 *relptr++ = &chain->relent;
459 chain = chain->next;
461 *relptr = 0;
462 return section->reloc_count;
464 if (tblptr && section->reloc_count) {
465 for (count = 0; count++ < section->reloc_count;)
466 *relptr++ = tblptr++;
467 *relptr = 0;
468 return section->reloc_count;
471 if (!NAME(aout,slurp_reloc_table) (abfd, section, symbols))
472 return -1;
473 tblptr = section->relocation;
475 /* fix up howto entries */
476 for (count = 0; count++ < section->reloc_count;)
478 c = tblptr->howto - NAME(aout,std_howto_table);
479 BFD_ASSERT (c < RISCIX_TABLE_SIZE);
480 tblptr->howto = &riscix_std_reloc_howto[c];
482 *relptr++ = tblptr++;
484 *relptr = 0;
485 return section->reloc_count;
488 /* This is the same as NAME(aout,some_aout_object_p), but has different
489 expansions of the macro definitions. */
491 const bfd_target *
492 riscix_some_aout_object_p (abfd, execp, callback_to_real_object_p)
493 bfd *abfd;
494 struct internal_exec *execp;
495 const bfd_target *(*callback_to_real_object_p) PARAMS ((bfd *));
497 struct aout_data_struct *rawptr, *oldrawptr;
498 const bfd_target *result;
499 bfd_size_type amt = sizeof (struct aout_data_struct);
501 rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, amt);
503 if (rawptr == NULL)
504 return 0;
506 oldrawptr = abfd->tdata.aout_data;
507 abfd->tdata.aout_data = rawptr;
509 /* Copy the contents of the old tdata struct.
510 In particular, we want the subformat, since for hpux it was set in
511 hp300hpux.c:swap_exec_header_in and will be used in
512 hp300hpux.c:callback. */
513 if (oldrawptr != NULL)
514 *abfd->tdata.aout_data = *oldrawptr;
516 abfd->tdata.aout_data->a.hdr = &rawptr->e;
517 *(abfd->tdata.aout_data->a.hdr) = *execp; /* Copy in the internal_exec
518 struct */
519 execp = abfd->tdata.aout_data->a.hdr;
521 /* Set the file flags */
522 abfd->flags = BFD_NO_FLAGS;
523 if (execp->a_drsize || execp->a_trsize)
524 abfd->flags |= HAS_RELOC;
525 /* Setting of EXEC_P has been deferred to the bottom of this function */
526 if (execp->a_syms)
527 abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
528 if (N_DYNAMIC(*execp))
529 abfd->flags |= DYNAMIC;
531 if ((execp->a_info & MF_SQUEEZED) != 0) /* Squeezed files aren't supported
532 (yet)! */
534 bfd_set_error (bfd_error_wrong_format);
535 return NULL;
537 else if ((execp->a_info & MF_IS_SL) != 0) /* Nor are shared libraries */
539 bfd_set_error (bfd_error_wrong_format);
540 return NULL;
542 else if (N_MAGIC (*execp) == ZMAGIC)
544 abfd->flags |= D_PAGED | WP_TEXT;
545 adata (abfd).magic = z_magic;
547 else if (N_MAGIC (*execp) == NMAGIC)
549 abfd->flags |= WP_TEXT;
550 adata (abfd).magic = n_magic;
552 else if (N_MAGIC (*execp) == OMAGIC)
553 adata (abfd).magic = o_magic;
554 else
556 /* Should have been checked with N_BADMAG before this routine
557 was called. */
558 abort ();
561 bfd_get_start_address (abfd) = execp->a_entry;
563 obj_aout_symbols (abfd) = (aout_symbol_type *)NULL;
564 bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist);
566 /* The default relocation entry size is that of traditional V7 Unix. */
567 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
569 /* The default symbol entry size is that of traditional Unix. */
570 obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;
572 obj_aout_external_syms (abfd) = NULL;
573 obj_aout_external_strings (abfd) = NULL;
574 obj_aout_sym_hashes (abfd) = NULL;
576 if (! NAME(aout,make_sections) (abfd))
577 return NULL;
579 obj_datasec (abfd)->_raw_size = execp->a_data;
580 obj_bsssec (abfd)->_raw_size = execp->a_bss;
582 obj_textsec (abfd)->flags =
583 (execp->a_trsize != 0
584 ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC)
585 : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS));
586 obj_datasec (abfd)->flags =
587 (execp->a_drsize != 0
588 ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC)
589 : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS));
590 obj_bsssec (abfd)->flags = SEC_ALLOC;
592 result = (*callback_to_real_object_p) (abfd);
594 #if defined(MACH) || defined(STAT_FOR_EXEC)
595 /* The original heuristic doesn't work in some important cases. The
596 * a.out file has no information about the text start address. For
597 * files (like kernels) linked to non-standard addresses (ld -Ttext
598 * nnn) the entry point may not be between the default text start
599 * (obj_textsec(abfd)->vma) and (obj_textsec(abfd)->vma) + text size
600 * This is not just a mach issue. Many kernels are loaded at non
601 * standard addresses.
604 struct stat stat_buf;
605 if (abfd->iostream != NULL
606 && (abfd->flags & BFD_IN_MEMORY) == 0
607 && (fstat(fileno((FILE *) (abfd->iostream)), &stat_buf) == 0)
608 && ((stat_buf.st_mode & 0111) != 0))
609 abfd->flags |= EXEC_P;
611 #else /* ! MACH */
612 /* Now that the segment addresses have been worked out, take a better
613 guess at whether the file is executable. If the entry point
614 is within the text segment, assume it is. (This makes files
615 executable even if their entry point address is 0, as long as
616 their text starts at zero.)
618 At some point we should probably break down and stat the file and
619 declare it executable if (one of) its 'x' bits are on... */
620 if ((execp->a_entry >= obj_textsec(abfd)->vma) &&
621 (execp->a_entry < obj_textsec(abfd)->vma + obj_textsec(abfd)->_raw_size))
622 abfd->flags |= EXEC_P;
623 #endif /* MACH */
624 if (result)
627 else
629 free (rawptr);
630 abfd->tdata.aout_data = oldrawptr;
632 return result;
635 static const bfd_target *
636 MY(object_p) (abfd)
637 bfd *abfd;
639 struct external_exec exec_bytes; /* Raw exec header from file */
640 struct internal_exec exec; /* Cleaned-up exec header */
641 const bfd_target *target;
643 if (bfd_bread ((PTR) &exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd)
644 != EXEC_BYTES_SIZE)
646 if (bfd_get_error () != bfd_error_system_call)
647 bfd_set_error (bfd_error_wrong_format);
648 return 0;
651 exec.a_info = H_GET_32 (abfd, exec_bytes.e_info);
653 if (N_BADMAG (exec)) return 0;
654 #ifdef MACHTYPE_OK
655 if (!(MACHTYPE_OK (N_MACHTYPE (exec)))) return 0;
656 #endif
658 NAME(aout,swap_exec_header_in) (abfd, &exec_bytes, &exec);
660 target = riscix_some_aout_object_p (abfd, &exec, MY(callback));
662 return target;
665 #include "aout-target.h"