source: trunk/src/binutils/bfd/riscix.c@ 490

Last change on this file since 490 was 10, checked in by bird, 23 years ago

Initial revision
  • Property cvs2svn:cvs-rev set to 1.1
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 21.5 KB
Line 
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)
5
6This file is part of BFD, the Binary File Descriptor library.
7
8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2 of the License, or
11(at your option) any later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program; if not, write to the Free Software
20Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
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. */
25
26/* The following come from the man page. */
27#define SHLIBLEN 60
28
29#define MF_IMPURE 00200
30#define MF_SQUEEZED 01000
31#define MF_USES_SL 02000
32#define MF_IS_SL 04000
33
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 */
54
55#define N_SHARED_LIB(x) ((x).a_info & MF_USES_SL)
56
57/* Only a pure OMAGIC file has the minimal header */
58#define N_TXTOFF(x) \
59 ((x).a_info == OMAGIC ? 32 \
60 : (N_MAGIC(x) == ZMAGIC) ? TARGET_PAGE_SIZE \
61 : 999)
62
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)) \
70 : TEXT_START_ADDR)
71
72#define N_SYMOFF(x) \
73 (N_TXTOFF (x) + (x).a_text + (x).a_data + (x).a_trsize + (x).a_drsize)
74
75#define N_STROFF(x) (N_SYMOFF (x) + (x).a_syms)
76
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
81
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)
88
89#include "bfd.h"
90#include "sysdep.h"
91#include "libbfd.h"
92
93#define WRITE_HEADERS(abfd, execp) \
94 { \
95 bfd_size_type text_size; /* dummy vars */ \
96 file_ptr text_end; \
97 if (adata(abfd).magic == undecided_magic) \
98 NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end); \
99 \
100 execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE; \
101 execp->a_entry = bfd_get_start_address (abfd); \
102 \
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); \
108 \
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) \
112 return false; \
113 /* Now write out reloc info, followed by syms and strings */ \
114 \
115 if (bfd_get_outsymbols (abfd) != (asymbol **) NULL \
116 && bfd_get_symcount (abfd) != 0) \
117 { \
118 if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*execp)), SEEK_SET) != 0) \
119 return false; \
120 \
121 if (! NAME(aout,write_syms) (abfd)) return false; \
122 \
123 if (bfd_seek (abfd, (file_ptr) (N_TRELOFF(*execp)), SEEK_SET) != 0) \
124 return false; \
125 \
126 if (! riscix_squirt_out_relocs (abfd, obj_textsec (abfd))) \
127 return false; \
128 if (bfd_seek (abfd, (file_ptr) (N_DRELOFF(*execp)), SEEK_SET) != 0) \
129 return false; \
130 \
131 if (!NAME(aout,squirt_out_relocs) (abfd, obj_datasec (abfd))) \
132 return false; \
133 } \
134 }
135
136#include "libaout.h"
137#include "aout/aout64.h"
138
139static bfd_reloc_status_type
140riscix_fix_pcrel_26_done PARAMS ((bfd *, arelent *, asymbol *, PTR,
141 asection *, bfd *, char **));
142
143static bfd_reloc_status_type
144riscix_fix_pcrel_26 PARAMS ((bfd *, arelent *, asymbol *, PTR,
145 asection *, bfd *, char **));
146
147static reloc_howto_type riscix_std_reloc_howto[] = {
148 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
149 HOWTO( 0, 0, 0, 8, false, 0, complain_overflow_bitfield,0,"8", true, 0x000000ff,0x000000ff, false),
150 HOWTO( 1, 0, 1, 16, false, 0, complain_overflow_bitfield,0,"16", true, 0x0000ffff,0x0000ffff, false),
151 HOWTO( 2, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"32", true, 0xffffffff,0xffffffff, false),
152 HOWTO( 3, 2, 3, 26, true, 0, complain_overflow_signed, riscix_fix_pcrel_26 , "ARM26", true, 0x00ffffff,0x00ffffff, false),
153 HOWTO( 4, 0, 0, 8, true, 0, complain_overflow_signed, 0,"DISP8", true, 0x000000ff,0x000000ff, true),
154 HOWTO( 5, 0, 1, 16, true, 0, complain_overflow_signed, 0,"DISP16", true, 0x0000ffff,0x0000ffff, true),
155 HOWTO( 6, 0, 2, 32, true, 0, complain_overflow_signed, 0,"DISP32", true, 0xffffffff,0xffffffff, true),
156 HOWTO( 7, 2, 3, 26, false, 0, complain_overflow_signed, riscix_fix_pcrel_26_done, "ARM26D",true,0x00ffffff,0x00ffffff, false),
157 EMPTY_HOWTO (-1),
158 HOWTO( 9, 0, -1, 16, false, 0, complain_overflow_bitfield,0,"NEG16", true, 0x0000ffff,0x0000ffff, false),
159 HOWTO( 10, 0, -2, 32, false, 0, complain_overflow_bitfield,0,"NEG32", true, 0xffffffff,0xffffffff, false)
160};
161
162#define RISCIX_TABLE_SIZE \
163 (sizeof (riscix_std_reloc_howto) / sizeof (reloc_howto_type))
164
165static bfd_reloc_status_type
166riscix_fix_pcrel_26_done (abfd, reloc_entry, symbol, data, input_section,
167 output_bfd, error_message)
168 bfd *abfd ATTRIBUTE_UNUSED;
169 arelent *reloc_entry ATTRIBUTE_UNUSED;
170 asymbol *symbol ATTRIBUTE_UNUSED;
171 PTR data ATTRIBUTE_UNUSED;
172 asection *input_section ATTRIBUTE_UNUSED;
173 bfd *output_bfd ATTRIBUTE_UNUSED;
174 char **error_message ATTRIBUTE_UNUSED;
175{
176 /* This is dead simple at present. */
177 return bfd_reloc_ok;
178}
179
180static bfd_reloc_status_type
181riscix_fix_pcrel_26 (abfd, reloc_entry, symbol, data, input_section,
182 output_bfd, error_message)
183 bfd *abfd;
184 arelent *reloc_entry;
185 asymbol *symbol;
186 PTR data;
187 asection *input_section;
188 bfd *output_bfd;
189 char **error_message ATTRIBUTE_UNUSED;
190{
191 bfd_vma relocation;
192 bfd_size_type addr = reloc_entry->address;
193 long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
194 bfd_reloc_status_type flag = bfd_reloc_ok;
195
196 /* If this is an undefined symbol, return error */
197 if (symbol->section == &bfd_und_section
198 && (symbol->flags & BSF_WEAK) == 0)
199 return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
200
201 /* If the sections are different, and we are doing a partial relocation,
202 just ignore it for now. */
203 if (symbol->section->name != input_section->name
204 && output_bfd != (bfd *)NULL)
205 return bfd_reloc_continue;
206
207 relocation = (target & 0x00ffffff) << 2;
208 relocation = (relocation ^ 0x02000000) - 0x02000000; /* Sign extend */
209 relocation += symbol->value;
210 relocation += symbol->section->output_section->vma;
211 relocation += symbol->section->output_offset;
212 relocation += reloc_entry->addend;
213 relocation -= input_section->output_section->vma;
214 relocation -= input_section->output_offset;
215 relocation -= addr;
216 if (relocation & 3)
217 return bfd_reloc_overflow;
218
219 /* Check for overflow */
220 if (relocation & 0x02000000)
221 {
222 if ((relocation & ~ (bfd_vma) 0x03ffffff) != ~ (bfd_vma) 0x03ffffff)
223 flag = bfd_reloc_overflow;
224 }
225 else if (relocation & ~0x03ffffff)
226 flag = bfd_reloc_overflow;
227
228 target &= ~0x00ffffff;
229 target |= (relocation >> 2) & 0x00ffffff;
230 bfd_put_32 (abfd, target, (bfd_byte *) data + addr);
231
232 /* Now the ARM magic... Change the reloc type so that it is marked as done.
233 Strictly this is only necessary if we are doing a partial relocation. */
234 reloc_entry->howto = &riscix_std_reloc_howto[7];
235
236 return flag;
237}
238
239reloc_howto_type *
240riscix_reloc_type_lookup (abfd, code)
241 bfd *abfd;
242 bfd_reloc_code_real_type code;
243{
244#define ASTD(i,j) case i: return &riscix_std_reloc_howto[j]
245 if (code == BFD_RELOC_CTOR)
246 switch (bfd_get_arch_info (abfd)->bits_per_address)
247 {
248 case 32:
249 code = BFD_RELOC_32;
250 break;
251 default: return (reloc_howto_type *) NULL;
252 }
253
254 switch (code)
255 {
256 ASTD (BFD_RELOC_16, 1);
257 ASTD (BFD_RELOC_32, 2);
258 ASTD (BFD_RELOC_ARM_PCREL_BRANCH, 3);
259 ASTD (BFD_RELOC_8_PCREL, 4);
260 ASTD (BFD_RELOC_16_PCREL, 5);
261 ASTD (BFD_RELOC_32_PCREL, 6);
262 default: return (reloc_howto_type *) NULL;
263 }
264}
265
266#define MY_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
267#define MY_bfd_link_add_symbols _bfd_generic_link_add_symbols
268#define MY_final_link_callback should_not_be_used
269#define MY_bfd_final_link _bfd_generic_final_link
270
271#define MY_bfd_reloc_type_lookup riscix_reloc_type_lookup
272#define MY_canonicalize_reloc riscix_canonicalize_reloc
273#define MY_object_p riscix_object_p
274
275static const bfd_target *riscix_callback PARAMS ((bfd *));
276
277void
278riscix_swap_std_reloc_out (abfd, g, natptr)
279 bfd *abfd;
280 arelent *g;
281 struct reloc_std_external *natptr;
282{
283 int r_index;
284 asymbol *sym = *(g->sym_ptr_ptr);
285 int r_extern;
286 int r_length;
287 int r_pcrel;
288 int r_neg = 0; /* Negative relocs use the BASEREL bit. */
289 asection *output_section = sym->section->output_section;
290
291 PUT_WORD(abfd, g->address, natptr->r_address);
292
293 r_length = g->howto->size ; /* Size as a power of two */
294 if (r_length < 0)
295 {
296 r_length = -r_length;
297 r_neg = 1;
298 }
299
300 r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */
301
302 /* For RISC iX, in pc-relative relocs the r_pcrel bit means that the
303 relocation has been done already (Only for the 26-bit one I think)???!!!
304 */
305
306 if (r_length == 3)
307 r_pcrel = r_pcrel ? 0 : 1;
308
309#if 0
310 /* For a standard reloc, the addend is in the object file. */
311 r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
312#endif
313
314 /* name was clobbered by aout_write_syms to be symbol index */
315
316 /* If this relocation is relative to a symbol then set the
317 r_index to the symbols index, and the r_extern bit.
318
319 Absolute symbols can come in in two ways, either as an offset
320 from the abs section, or as a symbol which has an abs value.
321 check for that here
322 */
323
324 if (bfd_is_com_section (output_section)
325 || output_section == &bfd_abs_section
326 || output_section == &bfd_und_section)
327 {
328 if (bfd_abs_section.symbol == sym)
329 {
330 /* Whoops, looked like an abs symbol, but is really an offset
331 from the abs section */
332 r_index = 0;
333 r_extern = 0;
334 }
335 else
336 {
337 /* Fill in symbol */
338 r_extern = 1;
339 r_index = (*g->sym_ptr_ptr)->udata.i;
340 }
341 }
342 else
343 {
344 /* Just an ordinary section */
345 r_extern = 0;
346 r_index = output_section->target_index;
347 }
348
349 /* now the fun stuff */
350 if (bfd_header_big_endian (abfd))
351 {
352 natptr->r_index[0] = r_index >> 16;
353 natptr->r_index[1] = r_index >> 8;
354 natptr->r_index[2] = r_index;
355 natptr->r_type[0] =
356 ( (r_extern ? RELOC_STD_BITS_EXTERN_BIG: 0)
357 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG: 0)
358 | (r_neg ? RELOC_STD_BITS_BASEREL_BIG: 0)
359 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
360 }
361 else
362 {
363 natptr->r_index[2] = r_index >> 16;
364 natptr->r_index[1] = r_index >> 8;
365 natptr->r_index[0] = r_index;
366 natptr->r_type[0] =
367 ( (r_extern ? RELOC_STD_BITS_EXTERN_LITTLE: 0)
368 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE: 0)
369 | (r_neg ? RELOC_STD_BITS_BASEREL_LITTLE: 0)
370 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
371 }
372}
373
374boolean
375riscix_squirt_out_relocs (abfd, section)
376 bfd *abfd;
377 asection *section;
378{
379 arelent **generic;
380 unsigned char *native, *natptr;
381 size_t each_size;
382
383 unsigned int count = section->reloc_count;
384 size_t natsize;
385
386 if (count == 0) return true;
387
388 each_size = obj_reloc_entry_size (abfd);
389 natsize = each_size * count;
390 native = (unsigned char *) bfd_zalloc (abfd, natsize);
391 if (!native)
392 return false;
393
394 generic = section->orelocation;
395
396 for (natptr = native;
397 count != 0;
398 --count, natptr += each_size, ++generic)
399 riscix_swap_std_reloc_out (abfd, *generic,
400 (struct reloc_std_external *) natptr);
401
402 if ( bfd_write ((PTR) native, 1, natsize, abfd) != natsize)
403 {
404 bfd_release(abfd, native);
405 return false;
406 }
407
408 bfd_release (abfd, native);
409 return true;
410}
411
412/*
413 * This is just like the standard aoutx.h version but we need to do our
414 * own mapping of external reloc type values to howto entries.
415 */
416long
417MY(canonicalize_reloc) (abfd, section, relptr, symbols)
418 bfd *abfd;
419 sec_ptr section;
420 arelent **relptr;
421 asymbol **symbols;
422{
423 arelent *tblptr = section->relocation;
424 unsigned int count, c;
425 extern reloc_howto_type NAME(aout,std_howto_table)[];
426
427 /* If we have already read in the relocation table, return the values. */
428 if (section->flags & SEC_CONSTRUCTOR) {
429 arelent_chain *chain = section->constructor_chain;
430
431 for (count = 0; count < section->reloc_count; count++) {
432 *relptr++ = &chain->relent;
433 chain = chain->next;
434 }
435 *relptr = 0;
436 return section->reloc_count;
437 }
438 if (tblptr && section->reloc_count) {
439 for (count = 0; count++ < section->reloc_count;)
440 *relptr++ = tblptr++;
441 *relptr = 0;
442 return section->reloc_count;
443 }
444
445 if (!NAME(aout,slurp_reloc_table) (abfd, section, symbols))
446 return -1;
447 tblptr = section->relocation;
448
449 /* fix up howto entries */
450 for (count = 0; count++ < section->reloc_count;)
451 {
452 c = tblptr->howto - NAME(aout,std_howto_table);
453 BFD_ASSERT (c < RISCIX_TABLE_SIZE);
454 tblptr->howto = &riscix_std_reloc_howto[c];
455
456 *relptr++ = tblptr++;
457 }
458 *relptr = 0;
459 return section->reloc_count;
460}
461
462/* This is the same as NAME(aout,some_aout_object_p), but has different
463 expansions of the macro definitions. */
464
465const bfd_target *
466riscix_some_aout_object_p (abfd, execp, callback_to_real_object_p)
467 bfd *abfd;
468 struct internal_exec *execp;
469 const bfd_target *(*callback_to_real_object_p) PARAMS ((bfd *));
470{
471 struct aout_data_struct *rawptr, *oldrawptr;
472 const bfd_target *result;
473
474 rawptr = ((struct aout_data_struct *)
475 bfd_zalloc (abfd, sizeof (struct aout_data_struct )));
476
477 if (rawptr == NULL)
478 return 0;
479
480 oldrawptr = abfd->tdata.aout_data;
481 abfd->tdata.aout_data = rawptr;
482
483 /* Copy the contents of the old tdata struct.
484 In particular, we want the subformat, since for hpux it was set in
485 hp300hpux.c:swap_exec_header_in and will be used in
486 hp300hpux.c:callback. */
487 if (oldrawptr != NULL)
488 *abfd->tdata.aout_data = *oldrawptr;
489
490 abfd->tdata.aout_data->a.hdr = &rawptr->e;
491 *(abfd->tdata.aout_data->a.hdr) = *execp; /* Copy in the internal_exec
492 struct */
493 execp = abfd->tdata.aout_data->a.hdr;
494
495 /* Set the file flags */
496 abfd->flags = BFD_NO_FLAGS;
497 if (execp->a_drsize || execp->a_trsize)
498 abfd->flags |= HAS_RELOC;
499 /* Setting of EXEC_P has been deferred to the bottom of this function */
500 if (execp->a_syms)
501 abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
502 if (N_DYNAMIC(*execp))
503 abfd->flags |= DYNAMIC;
504
505 if ((execp->a_info & MF_SQUEEZED) != 0) /* Squeezed files aren't supported
506 (yet)! */
507 {
508 bfd_set_error (bfd_error_wrong_format);
509 return NULL;
510 }
511 else if ((execp->a_info & MF_IS_SL) != 0) /* Nor are shared libraries */
512 {
513 bfd_set_error (bfd_error_wrong_format);
514 return NULL;
515 }
516 else if (N_MAGIC (*execp) == ZMAGIC)
517 {
518 abfd->flags |= D_PAGED | WP_TEXT;
519 adata (abfd).magic = z_magic;
520 }
521 else if (N_MAGIC (*execp) == NMAGIC)
522 {
523 abfd->flags |= WP_TEXT;
524 adata (abfd).magic = n_magic;
525 }
526 else if (N_MAGIC (*execp) == OMAGIC)
527 adata (abfd).magic = o_magic;
528 else
529 {
530 /* Should have been checked with N_BADMAG before this routine
531 was called. */
532 abort ();
533 }
534
535 bfd_get_start_address (abfd) = execp->a_entry;
536
537 obj_aout_symbols (abfd) = (aout_symbol_type *)NULL;
538 bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist);
539
540 /* The default relocation entry size is that of traditional V7 Unix. */
541 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
542
543 /* The default symbol entry size is that of traditional Unix. */
544 obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;
545
546 obj_aout_external_syms (abfd) = NULL;
547 obj_aout_external_strings (abfd) = NULL;
548 obj_aout_sym_hashes (abfd) = NULL;
549
550 if (! NAME(aout,make_sections) (abfd))
551 return NULL;
552
553 obj_datasec (abfd)->_raw_size = execp->a_data;
554 obj_bsssec (abfd)->_raw_size = execp->a_bss;
555
556 obj_textsec (abfd)->flags =
557 (execp->a_trsize != 0
558 ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC)
559 : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS));
560 obj_datasec (abfd)->flags =
561 (execp->a_drsize != 0
562 ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC)
563 : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS));
564 obj_bsssec (abfd)->flags = SEC_ALLOC;
565
566 result = (*callback_to_real_object_p) (abfd);
567
568#if defined(MACH) || defined(STAT_FOR_EXEC)
569 /* The original heuristic doesn't work in some important cases. The
570 * a.out file has no information about the text start address. For
571 * files (like kernels) linked to non-standard addresses (ld -Ttext
572 * nnn) the entry point may not be between the default text start
573 * (obj_textsec(abfd)->vma) and (obj_textsec(abfd)->vma) + text size
574 * This is not just a mach issue. Many kernels are loaded at non
575 * standard addresses.
576 */
577 {
578 struct stat stat_buf;
579 if (abfd->iostream != NULL
580 && (abfd->flags & BFD_IN_MEMORY) == 0
581 && (fstat(fileno((FILE *) (abfd->iostream)), &stat_buf) == 0)
582 && ((stat_buf.st_mode & 0111) != 0))
583 abfd->flags |= EXEC_P;
584 }
585#else /* ! MACH */
586 /* Now that the segment addresses have been worked out, take a better
587 guess at whether the file is executable. If the entry point
588 is within the text segment, assume it is. (This makes files
589 executable even if their entry point address is 0, as long as
590 their text starts at zero.)
591
592 At some point we should probably break down and stat the file and
593 declare it executable if (one of) its 'x' bits are on... */
594 if ((execp->a_entry >= obj_textsec(abfd)->vma) &&
595 (execp->a_entry < obj_textsec(abfd)->vma + obj_textsec(abfd)->_raw_size))
596 abfd->flags |= EXEC_P;
597#endif /* MACH */
598 if (result)
599 {
600 }
601 else
602 {
603 free (rawptr);
604 abfd->tdata.aout_data = oldrawptr;
605 }
606 return result;
607}
608
609static const bfd_target *
610MY(object_p) (abfd)
611 bfd *abfd;
612{
613 struct external_exec exec_bytes; /* Raw exec header from file */
614 struct internal_exec exec; /* Cleaned-up exec header */
615 const bfd_target *target;
616
617 if (bfd_read ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd)
618 != EXEC_BYTES_SIZE) {
619 if (bfd_get_error () != bfd_error_system_call)
620 bfd_set_error (bfd_error_wrong_format);
621 return 0;
622 }
623
624 exec.a_info = bfd_h_get_32 (abfd, exec_bytes.e_info);
625
626 if (N_BADMAG (exec)) return 0;
627#ifdef MACHTYPE_OK
628 if (!(MACHTYPE_OK (N_MACHTYPE (exec)))) return 0;
629#endif
630
631 NAME(aout,swap_exec_header_in) (abfd, &exec_bytes, &exec);
632
633 target = riscix_some_aout_object_p (abfd, &exec, MY(callback));
634
635 return target;
636}
637
638#include "aout-target.h"
Note: See TracBrowser for help on using the repository browser.