1 /* This is the Linux kernel elf-loading code, ported into user space */
3 #include "qemu/osdep.h"
6 #include "disas/disas.h"
18 /* from personality.h */
21 * Flags for bug emulation.
23 * These occupy the top three bytes.
26 ADDR_NO_RANDOMIZE
= 0x0040000, /* disable randomization of VA space */
27 FDPIC_FUNCPTRS
= 0x0080000, /* userspace function ptrs point to descriptors
30 MMAP_PAGE_ZERO
= 0x0100000,
31 ADDR_COMPAT_LAYOUT
= 0x0200000,
32 READ_IMPLIES_EXEC
= 0x0400000,
33 ADDR_LIMIT_32BIT
= 0x0800000,
34 SHORT_INODE
= 0x1000000,
35 WHOLE_SECONDS
= 0x2000000,
36 STICKY_TIMEOUTS
= 0x4000000,
37 ADDR_LIMIT_3GB
= 0x8000000,
43 * These go in the low byte. Avoid using the top bit, it will
44 * conflict with error returns.
48 PER_LINUX_32BIT
= 0x0000 | ADDR_LIMIT_32BIT
,
49 PER_LINUX_FDPIC
= 0x0000 | FDPIC_FUNCPTRS
,
50 PER_SVR4
= 0x0001 | STICKY_TIMEOUTS
| MMAP_PAGE_ZERO
,
51 PER_SVR3
= 0x0002 | STICKY_TIMEOUTS
| SHORT_INODE
,
52 PER_SCOSVR3
= 0x0003 | STICKY_TIMEOUTS
|
53 WHOLE_SECONDS
| SHORT_INODE
,
54 PER_OSR5
= 0x0003 | STICKY_TIMEOUTS
| WHOLE_SECONDS
,
55 PER_WYSEV386
= 0x0004 | STICKY_TIMEOUTS
| SHORT_INODE
,
56 PER_ISCR4
= 0x0005 | STICKY_TIMEOUTS
,
58 PER_SUNOS
= 0x0006 | STICKY_TIMEOUTS
,
59 PER_XENIX
= 0x0007 | STICKY_TIMEOUTS
| SHORT_INODE
,
61 PER_LINUX32_3GB
= 0x0008 | ADDR_LIMIT_3GB
,
62 PER_IRIX32
= 0x0009 | STICKY_TIMEOUTS
,/* IRIX5 32-bit */
63 PER_IRIXN32
= 0x000a | STICKY_TIMEOUTS
,/* IRIX6 new 32-bit */
64 PER_IRIX64
= 0x000b | STICKY_TIMEOUTS
,/* IRIX6 64-bit */
66 PER_SOLARIS
= 0x000d | STICKY_TIMEOUTS
,
67 PER_UW7
= 0x000e | STICKY_TIMEOUTS
| MMAP_PAGE_ZERO
,
68 PER_OSF4
= 0x000f, /* OSF/1 v4 */
74 * Return the base personality without flags.
76 #define personality(pers) (pers & PER_MASK)
78 /* this flag is uneffective under linux too, should be deleted */
80 #define MAP_DENYWRITE 0
83 /* should probably go in elf.h */
90 #define ELF_PLATFORM get_elf_platform()
92 static const char *get_elf_platform(void)
94 static char elf_platform
[] = "i386";
95 int family
= object_property_get_int(OBJECT(thread_cpu
), "family", NULL
);
99 elf_platform
[1] = '0' + family
;
103 #define ELF_HWCAP get_elf_hwcap()
105 static uint32_t get_elf_hwcap(void)
107 X86CPU
*cpu
= X86_CPU(thread_cpu
);
109 return cpu
->env
.features
[FEAT_1_EDX
];
113 #define ELF_START_MMAP 0x2aaaaab000ULL
114 #define elf_check_arch(x) (((x) == ELF_ARCH))
116 #define ELF_CLASS ELFCLASS64
117 #define ELF_DATA ELFDATA2LSB
118 #define ELF_ARCH EM_X86_64
120 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
123 regs
->rsp
= infop
->start_stack
;
124 regs
->rip
= infop
->entry
;
125 if (bsd_type
== target_freebsd
) {
126 regs
->rdi
= infop
->start_stack
;
132 #define ELF_START_MMAP 0x80000000
135 * This is used to ensure we don't load something for the wrong architecture.
137 #define elf_check_arch(x) (((x) == EM_386) || ((x) == EM_486))
140 * These are used to set parameters in the core dumps.
142 #define ELF_CLASS ELFCLASS32
143 #define ELF_DATA ELFDATA2LSB
144 #define ELF_ARCH EM_386
146 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
148 regs
->esp
= infop
->start_stack
;
149 regs
->eip
= infop
->entry
;
151 /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
152 starts %edx contains a pointer to a function which might be
153 registered using `atexit'. This provides a mean for the
154 dynamic linker to call DT_FINI functions for shared libraries
155 that have been loaded before the code runs.
157 A value of 0 tells we have no such handler. */
162 #define USE_ELF_CORE_DUMP
163 #define ELF_EXEC_PAGESIZE 4096
169 #define ELF_START_MMAP 0x80000000
171 #define elf_check_arch(x) ((x) == EM_ARM)
173 #define ELF_CLASS ELFCLASS32
174 #ifdef TARGET_WORDS_BIGENDIAN
175 #define ELF_DATA ELFDATA2MSB
177 #define ELF_DATA ELFDATA2LSB
179 #define ELF_ARCH EM_ARM
181 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
183 abi_long stack
= infop
->start_stack
;
184 memset(regs
, 0, sizeof(*regs
));
185 regs
->ARM_cpsr
= 0x10;
186 if (infop
->entry
& 1)
187 regs
->ARM_cpsr
|= CPSR_T
;
188 regs
->ARM_pc
= infop
->entry
& 0xfffffffe;
189 regs
->ARM_sp
= infop
->start_stack
;
190 /* FIXME - what to for failure of get_user()? */
191 get_user_ual(regs
->ARM_r2
, stack
+ 8); /* envp */
192 get_user_ual(regs
->ARM_r1
, stack
+ 4); /* envp */
193 /* XXX: it seems that r0 is zeroed after ! */
195 /* For uClinux PIC binaries. */
196 /* XXX: Linux does this only on ARM with no MMU (do we care ?) */
197 regs
->ARM_r10
= infop
->start_data
;
200 #define USE_ELF_CORE_DUMP
201 #define ELF_EXEC_PAGESIZE 4096
205 ARM_HWCAP_ARM_SWP
= 1 << 0,
206 ARM_HWCAP_ARM_HALF
= 1 << 1,
207 ARM_HWCAP_ARM_THUMB
= 1 << 2,
208 ARM_HWCAP_ARM_26BIT
= 1 << 3,
209 ARM_HWCAP_ARM_FAST_MULT
= 1 << 4,
210 ARM_HWCAP_ARM_FPA
= 1 << 5,
211 ARM_HWCAP_ARM_VFP
= 1 << 6,
212 ARM_HWCAP_ARM_EDSP
= 1 << 7,
215 #define ELF_HWCAP (ARM_HWCAP_ARM_SWP | ARM_HWCAP_ARM_HALF \
216 | ARM_HWCAP_ARM_THUMB | ARM_HWCAP_ARM_FAST_MULT \
217 | ARM_HWCAP_ARM_FPA | ARM_HWCAP_ARM_VFP)
222 #ifdef TARGET_SPARC64
224 #define ELF_START_MMAP 0x80000000
227 #define elf_check_arch(x) ((x) == EM_SPARCV9 || (x) == EM_SPARC32PLUS)
229 #define elf_check_arch(x) ((x) == EM_SPARC32PLUS || (x) == EM_SPARC)
232 #define ELF_CLASS ELFCLASS64
233 #define ELF_DATA ELFDATA2MSB
234 #define ELF_ARCH EM_SPARCV9
236 #define STACK_BIAS 2047
238 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
243 regs
->pc
= infop
->entry
;
244 regs
->npc
= regs
->pc
+ 4;
247 regs
->u_regs
[14] = infop
->start_stack
- 16 * 4;
249 if (personality(infop
->personality
) == PER_LINUX32
)
250 regs
->u_regs
[14] = infop
->start_stack
- 16 * 4;
252 regs
->u_regs
[14] = infop
->start_stack
- 16 * 8 - STACK_BIAS
;
253 if (bsd_type
== target_freebsd
) {
254 regs
->u_regs
[8] = infop
->start_stack
;
255 regs
->u_regs
[11] = infop
->start_stack
;
262 #define ELF_START_MMAP 0x80000000
264 #define elf_check_arch(x) ((x) == EM_SPARC)
266 #define ELF_CLASS ELFCLASS32
267 #define ELF_DATA ELFDATA2MSB
268 #define ELF_ARCH EM_SPARC
270 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
273 regs
->pc
= infop
->entry
;
274 regs
->npc
= regs
->pc
+ 4;
276 regs
->u_regs
[14] = infop
->start_stack
- 16 * 4;
284 #define ELF_START_MMAP 0x80000000
286 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
288 #define elf_check_arch(x) ((x) == EM_PPC64)
290 #define ELF_CLASS ELFCLASS64
294 #define elf_check_arch(x) ((x) == EM_PPC)
296 #define ELF_CLASS ELFCLASS32
300 #ifdef TARGET_WORDS_BIGENDIAN
301 #define ELF_DATA ELFDATA2MSB
303 #define ELF_DATA ELFDATA2LSB
305 #define ELF_ARCH EM_PPC
308 * We need to put in some extra aux table entries to tell glibc what
309 * the cache block size is, so it can use the dcbz instruction safely.
311 #define AT_DCACHEBSIZE 19
312 #define AT_ICACHEBSIZE 20
313 #define AT_UCACHEBSIZE 21
314 /* A special ignored type value for PPC, for glibc compatibility. */
315 #define AT_IGNOREPPC 22
317 * The requirements here are:
318 * - keep the final alignment of sp (sp & 0xf)
319 * - make sure the 32-bit value at the first 16 byte aligned position of
320 * AUXV is greater than 16 for glibc compatibility.
321 * AT_IGNOREPPC is used for that.
322 * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
323 * even if DLINFO_ARCH_ITEMS goes to zero or is undefined.
325 #define DLINFO_ARCH_ITEMS 5
326 #define ARCH_DLINFO \
328 NEW_AUX_ENT(AT_DCACHEBSIZE, 0x20); \
329 NEW_AUX_ENT(AT_ICACHEBSIZE, 0x20); \
330 NEW_AUX_ENT(AT_UCACHEBSIZE, 0); \
332 * Now handle glibc compatibility. \
334 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
335 NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
338 static inline void init_thread(struct target_pt_regs
*_regs
, struct image_info
*infop
)
340 abi_ulong pos
= infop
->start_stack
;
342 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
343 abi_ulong entry
, toc
;
346 _regs
->gpr
[1] = infop
->start_stack
;
347 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
348 get_user_u64(entry
, infop
->entry
);
349 entry
+= infop
->load_addr
;
350 get_user_u64(toc
, infop
->entry
+ 8);
351 toc
+= infop
->load_addr
;
353 infop
->entry
= entry
;
355 _regs
->nip
= infop
->entry
;
356 /* Note that isn't exactly what regular kernel does
357 * but this is what the ABI wants and is needed to allow
358 * execution of PPC BSD programs.
360 /* FIXME - what to for failure of get_user()? */
361 get_user_ual(_regs
->gpr
[3], pos
);
362 pos
+= sizeof(abi_ulong
);
364 for (tmp
= 1; tmp
!= 0; pos
+= sizeof(abi_ulong
)) {
365 get_user_ual(tmp
, pos
);
370 #define USE_ELF_CORE_DUMP
371 #define ELF_EXEC_PAGESIZE 4096
377 #define ELF_START_MMAP 0x80000000
379 #define elf_check_arch(x) ((x) == EM_MIPS)
382 #define ELF_CLASS ELFCLASS64
384 #define ELF_CLASS ELFCLASS32
386 #ifdef TARGET_WORDS_BIGENDIAN
387 #define ELF_DATA ELFDATA2MSB
389 #define ELF_DATA ELFDATA2LSB
391 #define ELF_ARCH EM_MIPS
393 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
395 regs
->cp0_status
= 2 << CP0St_KSU
;
396 regs
->cp0_epc
= infop
->entry
;
397 regs
->regs
[29] = infop
->start_stack
;
400 #define USE_ELF_CORE_DUMP
401 #define ELF_EXEC_PAGESIZE 4096
403 #endif /* TARGET_MIPS */
407 #define ELF_START_MMAP 0x80000000
409 #define elf_check_arch(x) ((x) == EM_SH)
411 #define ELF_CLASS ELFCLASS32
412 #define ELF_DATA ELFDATA2LSB
413 #define ELF_ARCH EM_SH
415 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
417 /* Check other registers XXXXX */
418 regs
->pc
= infop
->entry
;
419 regs
->regs
[15] = infop
->start_stack
;
422 #define USE_ELF_CORE_DUMP
423 #define ELF_EXEC_PAGESIZE 4096
429 #define ELF_START_MMAP 0x80000000
431 #define elf_check_arch(x) ((x) == EM_CRIS)
433 #define ELF_CLASS ELFCLASS32
434 #define ELF_DATA ELFDATA2LSB
435 #define ELF_ARCH EM_CRIS
437 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
439 regs
->erp
= infop
->entry
;
442 #define USE_ELF_CORE_DUMP
443 #define ELF_EXEC_PAGESIZE 8192
449 #define ELF_START_MMAP 0x80000000
451 #define elf_check_arch(x) ((x) == EM_68K)
453 #define ELF_CLASS ELFCLASS32
454 #define ELF_DATA ELFDATA2MSB
455 #define ELF_ARCH EM_68K
457 /* ??? Does this need to do anything?
458 #define ELF_PLAT_INIT(_r) */
460 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
462 regs
->usp
= infop
->start_stack
;
464 regs
->pc
= infop
->entry
;
467 #define USE_ELF_CORE_DUMP
468 #define ELF_EXEC_PAGESIZE 8192
474 #define ELF_START_MMAP (0x30000000000ULL)
476 #define elf_check_arch(x) ((x) == ELF_ARCH)
478 #define ELF_CLASS ELFCLASS64
479 #define ELF_DATA ELFDATA2MSB
480 #define ELF_ARCH EM_ALPHA
482 static inline void init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
484 regs
->pc
= infop
->entry
;
486 regs
->usp
= infop
->start_stack
;
487 regs
->unique
= infop
->start_data
; /* ? */
488 printf("Set unique value to " TARGET_FMT_lx
" (" TARGET_FMT_lx
")\n",
489 regs
->unique
, infop
->start_data
);
492 #define USE_ELF_CORE_DUMP
493 #define ELF_EXEC_PAGESIZE 8192
495 #endif /* TARGET_ALPHA */
498 #define ELF_PLATFORM (NULL)
507 #define ELF_CLASS ELFCLASS32
509 #define bswaptls(ptr) bswap32s(ptr)
516 unsigned int a_info
; /* Use macros N_MAGIC, etc for access */
517 unsigned int a_text
; /* length of text, in bytes */
518 unsigned int a_data
; /* length of data, in bytes */
519 unsigned int a_bss
; /* length of uninitialized data area, in bytes */
520 unsigned int a_syms
; /* length of symbol table data in file, in bytes */
521 unsigned int a_entry
; /* start address */
522 unsigned int a_trsize
; /* length of relocation info for text, in bytes */
523 unsigned int a_drsize
; /* length of relocation info for data, in bytes */
527 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
533 /* max code+data+bss space allocated to elf interpreter */
534 #define INTERP_MAP_SIZE (32 * 1024 * 1024)
536 /* max code+data+bss+brk space allocated to ET_DYN executables */
537 #define ET_DYN_MAP_SIZE (128 * 1024 * 1024)
539 /* Necessary parameters */
540 #define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
541 #define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE - 1))
542 #define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE - 1))
544 #define INTERPRETER_NONE 0
545 #define INTERPRETER_AOUT 1
546 #define INTERPRETER_ELF 2
548 #define DLINFO_ITEMS 12
550 static inline void memcpy_fromfs(void *to
, const void *from
, unsigned long n
)
555 static int load_aout_interp(void *exptr
, int interp_fd
);
558 static void bswap_ehdr(struct elfhdr
*ehdr
)
560 bswap16s(&ehdr
->e_type
); /* Object file type */
561 bswap16s(&ehdr
->e_machine
); /* Architecture */
562 bswap32s(&ehdr
->e_version
); /* Object file version */
563 bswaptls(&ehdr
->e_entry
); /* Entry point virtual address */
564 bswaptls(&ehdr
->e_phoff
); /* Program header table file offset */
565 bswaptls(&ehdr
->e_shoff
); /* Section header table file offset */
566 bswap32s(&ehdr
->e_flags
); /* Processor-specific flags */
567 bswap16s(&ehdr
->e_ehsize
); /* ELF header size in bytes */
568 bswap16s(&ehdr
->e_phentsize
); /* Program header table entry size */
569 bswap16s(&ehdr
->e_phnum
); /* Program header table entry count */
570 bswap16s(&ehdr
->e_shentsize
); /* Section header table entry size */
571 bswap16s(&ehdr
->e_shnum
); /* Section header table entry count */
572 bswap16s(&ehdr
->e_shstrndx
); /* Section header string table index */
575 static void bswap_phdr(struct elf_phdr
*phdr
)
577 bswap32s(&phdr
->p_type
); /* Segment type */
578 bswaptls(&phdr
->p_offset
); /* Segment file offset */
579 bswaptls(&phdr
->p_vaddr
); /* Segment virtual address */
580 bswaptls(&phdr
->p_paddr
); /* Segment physical address */
581 bswaptls(&phdr
->p_filesz
); /* Segment size in file */
582 bswaptls(&phdr
->p_memsz
); /* Segment size in memory */
583 bswap32s(&phdr
->p_flags
); /* Segment flags */
584 bswaptls(&phdr
->p_align
); /* Segment alignment */
587 static void bswap_shdr(struct elf_shdr
*shdr
)
589 bswap32s(&shdr
->sh_name
);
590 bswap32s(&shdr
->sh_type
);
591 bswaptls(&shdr
->sh_flags
);
592 bswaptls(&shdr
->sh_addr
);
593 bswaptls(&shdr
->sh_offset
);
594 bswaptls(&shdr
->sh_size
);
595 bswap32s(&shdr
->sh_link
);
596 bswap32s(&shdr
->sh_info
);
597 bswaptls(&shdr
->sh_addralign
);
598 bswaptls(&shdr
->sh_entsize
);
601 static void bswap_sym(struct elf_sym
*sym
)
603 bswap32s(&sym
->st_name
);
604 bswaptls(&sym
->st_value
);
605 bswaptls(&sym
->st_size
);
606 bswap16s(&sym
->st_shndx
);
611 * 'copy_elf_strings()' copies argument/envelope strings from user
612 * memory to free pages in kernel mem. These are in a format ready
613 * to be put directly into the top of new user memory.
616 static abi_ulong
copy_elf_strings(int argc
, char **argv
, void **page
,
619 char *tmp
, *tmp1
, *pag
= NULL
;
623 return 0; /* bullet-proofing */
628 fprintf(stderr
, "VFS: argc is wrong");
634 if (p
< len
) { /* this shouldn't happen - 128kB */
640 offset
= p
% TARGET_PAGE_SIZE
;
641 pag
= (char *)page
[p
/ TARGET_PAGE_SIZE
];
643 pag
= g_try_malloc0(TARGET_PAGE_SIZE
);
644 page
[p
/ TARGET_PAGE_SIZE
] = pag
;
649 if (len
== 0 || offset
== 0) {
650 *(pag
+ offset
) = *tmp
;
653 int bytes_to_copy
= (len
> offset
) ? offset
: len
;
654 tmp
-= bytes_to_copy
;
656 offset
-= bytes_to_copy
;
657 len
-= bytes_to_copy
;
658 memcpy_fromfs(pag
+ offset
, tmp
, bytes_to_copy
+ 1);
665 static abi_ulong
setup_arg_pages(abi_ulong p
, struct bsd_binprm
*bprm
,
666 struct image_info
*info
)
668 abi_ulong stack_base
, size
, error
;
671 /* Create enough stack to hold everything. If we don't use
672 * it for args, we'll use it for something else...
674 size
= x86_stack_size
;
675 if (size
< MAX_ARG_PAGES
* TARGET_PAGE_SIZE
)
676 size
= MAX_ARG_PAGES
* TARGET_PAGE_SIZE
;
677 error
= target_mmap(0,
678 size
+ qemu_host_page_size
,
679 PROT_READ
| PROT_WRITE
,
680 MAP_PRIVATE
| MAP_ANON
,
686 /* we reserve one extra page at the top of the stack as guard */
687 target_mprotect(error
+ size
, qemu_host_page_size
, PROT_NONE
);
689 stack_base
= error
+ size
- MAX_ARG_PAGES
* TARGET_PAGE_SIZE
;
692 for (i
= 0 ; i
< MAX_ARG_PAGES
; i
++) {
695 /* FIXME - check return value of memcpy_to_target() for failure */
696 memcpy_to_target(stack_base
, bprm
->page
[i
], TARGET_PAGE_SIZE
);
697 g_free(bprm
->page
[i
]);
699 stack_base
+= TARGET_PAGE_SIZE
;
704 static void set_brk(abi_ulong start
, abi_ulong end
)
706 /* page-align the start and end addresses... */
707 start
= HOST_PAGE_ALIGN(start
);
708 end
= HOST_PAGE_ALIGN(end
);
711 if (target_mmap(start
, end
- start
,
712 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
713 MAP_FIXED
| MAP_PRIVATE
| MAP_ANON
, -1, 0) == -1) {
714 perror("cannot mmap brk");
720 /* We need to explicitly zero any fractional pages after the data
721 section (i.e. bss). This would contain the junk from the file that
722 should not be in memory. */
723 static void padzero(abi_ulong elf_bss
, abi_ulong last_bss
)
727 if (elf_bss
>= last_bss
)
730 /* XXX: this is really a hack : if the real host page size is
731 smaller than the target page size, some pages after the end
732 of the file may not be mapped. A better fix would be to
733 patch target_mmap(), but it is more complicated as the file
734 size must be known */
735 if (qemu_real_host_page_size
< qemu_host_page_size
) {
736 abi_ulong end_addr
, end_addr1
;
737 end_addr1
= REAL_HOST_PAGE_ALIGN(elf_bss
);
738 end_addr
= HOST_PAGE_ALIGN(elf_bss
);
739 if (end_addr1
< end_addr
) {
740 mmap((void *)g2h_untagged(end_addr1
), end_addr
- end_addr1
,
741 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
742 MAP_FIXED
| MAP_PRIVATE
| MAP_ANON
, -1, 0);
746 nbyte
= elf_bss
& (qemu_host_page_size
- 1);
748 nbyte
= qemu_host_page_size
- nbyte
;
750 /* FIXME - what to do if put_user() fails? */
751 put_user_u8(0, elf_bss
);
758 static abi_ulong
create_elf_tables(abi_ulong p
, int argc
, int envc
,
759 struct elfhdr
* exec
,
762 abi_ulong interp_load_addr
, int ibcs
,
763 struct image_info
*info
)
767 abi_ulong u_platform
;
768 const char *k_platform
;
769 const int n
= sizeof(elf_addr_t
);
773 k_platform
= ELF_PLATFORM
;
775 size_t len
= strlen(k_platform
) + 1;
776 sp
-= (len
+ n
- 1) & ~(n
- 1);
778 /* FIXME - check return value of memcpy_to_target() for failure */
779 memcpy_to_target(sp
, k_platform
, len
);
782 * Force 16 byte _final_ alignment here for generality.
784 sp
= sp
& ~(abi_ulong
)15;
785 size
= (DLINFO_ITEMS
+ 1) * 2;
788 #ifdef DLINFO_ARCH_ITEMS
789 size
+= DLINFO_ARCH_ITEMS
* 2;
791 size
+= envc
+ argc
+ 2;
792 size
+= (!ibcs
? 3 : 1); /* argc itself */
795 sp
-= 16 - (size
& 15);
797 /* This is correct because Linux defines
798 * elf_addr_t as Elf32_Off / Elf64_Off
800 #define NEW_AUX_ENT(id, val) do { \
801 sp -= n; put_user_ual(val, sp); \
802 sp -= n; put_user_ual(id, sp); \
805 NEW_AUX_ENT(AT_NULL
, 0);
807 /* There must be exactly DLINFO_ITEMS entries here. */
808 NEW_AUX_ENT(AT_PHDR
, (abi_ulong
)(load_addr
+ exec
->e_phoff
));
809 NEW_AUX_ENT(AT_PHENT
, (abi_ulong
)(sizeof(struct elf_phdr
)));
810 NEW_AUX_ENT(AT_PHNUM
, (abi_ulong
)(exec
->e_phnum
));
811 NEW_AUX_ENT(AT_PAGESZ
, (abi_ulong
)(TARGET_PAGE_SIZE
));
812 NEW_AUX_ENT(AT_BASE
, (abi_ulong
)(interp_load_addr
));
813 NEW_AUX_ENT(AT_FLAGS
, (abi_ulong
)0);
814 NEW_AUX_ENT(AT_ENTRY
, load_bias
+ exec
->e_entry
);
815 NEW_AUX_ENT(AT_UID
, (abi_ulong
) getuid());
816 NEW_AUX_ENT(AT_EUID
, (abi_ulong
) geteuid());
817 NEW_AUX_ENT(AT_GID
, (abi_ulong
) getgid());
818 NEW_AUX_ENT(AT_EGID
, (abi_ulong
) getegid());
819 NEW_AUX_ENT(AT_HWCAP
, (abi_ulong
) ELF_HWCAP
);
820 NEW_AUX_ENT(AT_CLKTCK
, (abi_ulong
) sysconf(_SC_CLK_TCK
));
822 NEW_AUX_ENT(AT_PLATFORM
, u_platform
);
825 * ARCH_DLINFO must come last so platform specific code can enforce
826 * special alignment requirements on the AUXV if necessary (eg. PPC).
832 sp
= loader_build_argptr(envc
, argc
, sp
, p
, !ibcs
);
837 static abi_ulong
load_elf_interp(struct elfhdr
*interp_elf_ex
,
839 abi_ulong
*interp_load_addr
)
841 struct elf_phdr
*elf_phdata
= NULL
;
842 struct elf_phdr
*eppnt
;
843 abi_ulong load_addr
= 0;
844 int load_addr_set
= 0;
846 abi_ulong last_bss
, elf_bss
;
855 bswap_ehdr(interp_elf_ex
);
857 /* First of all, some simple consistency checks */
858 if ((interp_elf_ex
->e_type
!= ET_EXEC
&&
859 interp_elf_ex
->e_type
!= ET_DYN
) ||
860 !elf_check_arch(interp_elf_ex
->e_machine
)) {
861 return ~((abi_ulong
)0UL);
865 /* Now read in all of the header information */
867 if (sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
> TARGET_PAGE_SIZE
)
868 return ~(abi_ulong
)0UL;
870 elf_phdata
= (struct elf_phdr
*)
871 malloc(sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
);
874 return ~((abi_ulong
)0UL);
877 * If the size of this structure has changed, then punt, since
878 * we will be doing the wrong thing.
880 if (interp_elf_ex
->e_phentsize
!= sizeof(struct elf_phdr
)) {
882 return ~((abi_ulong
)0UL);
885 retval
= lseek(interpreter_fd
, interp_elf_ex
->e_phoff
, SEEK_SET
);
887 retval
= read(interpreter_fd
,
889 sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
);
892 perror("load_elf_interp");
899 for (i
= 0; i
<interp_elf_ex
->e_phnum
; i
++, eppnt
++) {
904 if (interp_elf_ex
->e_type
== ET_DYN
) {
905 /* in order to avoid hardcoding the interpreter load
906 address in qemu, we allocate a big enough memory zone */
907 error
= target_mmap(0, INTERP_MAP_SIZE
,
908 PROT_NONE
, MAP_PRIVATE
| MAP_ANON
,
919 for (i
= 0; i
< interp_elf_ex
->e_phnum
; i
++, eppnt
++)
920 if (eppnt
->p_type
== PT_LOAD
) {
921 int elf_type
= MAP_PRIVATE
| MAP_DENYWRITE
;
926 if (eppnt
->p_flags
& PF_R
) elf_prot
= PROT_READ
;
927 if (eppnt
->p_flags
& PF_W
) elf_prot
|= PROT_WRITE
;
928 if (eppnt
->p_flags
& PF_X
) elf_prot
|= PROT_EXEC
;
929 if (interp_elf_ex
->e_type
== ET_EXEC
|| load_addr_set
) {
930 elf_type
|= MAP_FIXED
;
931 vaddr
= eppnt
->p_vaddr
;
933 error
= target_mmap(load_addr
+ TARGET_ELF_PAGESTART(vaddr
),
934 eppnt
->p_filesz
+ TARGET_ELF_PAGEOFFSET(eppnt
->p_vaddr
),
938 eppnt
->p_offset
- TARGET_ELF_PAGEOFFSET(eppnt
->p_vaddr
));
942 close(interpreter_fd
);
944 return ~((abi_ulong
)0UL);
947 if (!load_addr_set
&& interp_elf_ex
->e_type
== ET_DYN
) {
953 * Find the end of the file mapping for this phdr, and keep
954 * track of the largest address we see for this.
956 k
= load_addr
+ eppnt
->p_vaddr
+ eppnt
->p_filesz
;
957 if (k
> elf_bss
) elf_bss
= k
;
960 * Do the same thing for the memory mapping - between
961 * elf_bss and last_bss is the bss section.
963 k
= load_addr
+ eppnt
->p_memsz
+ eppnt
->p_vaddr
;
964 if (k
> last_bss
) last_bss
= k
;
967 /* Now use mmap to map the library into memory. */
969 close(interpreter_fd
);
972 * Now fill out the bss section. First pad the last page up
973 * to the page boundary, and then perform a mmap to make sure
974 * that there are zeromapped pages up to and including the last
977 padzero(elf_bss
, last_bss
);
978 elf_bss
= TARGET_ELF_PAGESTART(elf_bss
+ qemu_host_page_size
- 1); /* What we have mapped so far */
980 /* Map the last of the bss segment */
981 if (last_bss
> elf_bss
) {
982 target_mmap(elf_bss
, last_bss
- elf_bss
,
983 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
984 MAP_FIXED
| MAP_PRIVATE
| MAP_ANON
, -1, 0);
988 *interp_load_addr
= load_addr
;
989 return ((abi_ulong
) interp_elf_ex
->e_entry
) + load_addr
;
992 static int symfind(const void *s0
, const void *s1
)
994 target_ulong addr
= *(target_ulong
*)s0
;
995 struct elf_sym
*sym
= (struct elf_sym
*)s1
;
997 if (addr
< sym
->st_value
) {
999 } else if (addr
>= sym
->st_value
+ sym
->st_size
) {
1005 static const char *lookup_symbolxx(struct syminfo
*s
, target_ulong orig_addr
)
1007 #if ELF_CLASS == ELFCLASS32
1008 struct elf_sym
*syms
= s
->disas_symtab
.elf32
;
1010 struct elf_sym
*syms
= s
->disas_symtab
.elf64
;
1014 struct elf_sym
*sym
;
1016 sym
= bsearch(&orig_addr
, syms
, s
->disas_num_syms
, sizeof(*syms
), symfind
);
1018 return s
->disas_strtab
+ sym
->st_name
;
1024 /* FIXME: This should use elf_ops.h */
1025 static int symcmp(const void *s0
, const void *s1
)
1027 struct elf_sym
*sym0
= (struct elf_sym
*)s0
;
1028 struct elf_sym
*sym1
= (struct elf_sym
*)s1
;
1029 return (sym0
->st_value
< sym1
->st_value
)
1031 : ((sym0
->st_value
> sym1
->st_value
) ? 1 : 0);
1034 /* Best attempt to load symbols from this ELF object. */
1035 static void load_symbols(struct elfhdr
*hdr
, int fd
)
1037 unsigned int i
, nsyms
;
1038 struct elf_shdr sechdr
, symtab
, strtab
;
1041 struct elf_sym
*syms
, *new_syms
;
1043 lseek(fd
, hdr
->e_shoff
, SEEK_SET
);
1044 for (i
= 0; i
< hdr
->e_shnum
; i
++) {
1045 if (read(fd
, &sechdr
, sizeof(sechdr
)) != sizeof(sechdr
))
1048 bswap_shdr(&sechdr
);
1050 if (sechdr
.sh_type
== SHT_SYMTAB
) {
1052 lseek(fd
, hdr
->e_shoff
1053 + sizeof(sechdr
) * sechdr
.sh_link
, SEEK_SET
);
1054 if (read(fd
, &strtab
, sizeof(strtab
))
1058 bswap_shdr(&strtab
);
1063 return; /* Shouldn't happen... */
1066 /* Now know where the strtab and symtab are. Snarf them. */
1067 s
= malloc(sizeof(*s
));
1068 syms
= malloc(symtab
.sh_size
);
1073 s
->disas_strtab
= strings
= malloc(strtab
.sh_size
);
1074 if (!s
->disas_strtab
) {
1080 lseek(fd
, symtab
.sh_offset
, SEEK_SET
);
1081 if (read(fd
, syms
, symtab
.sh_size
) != symtab
.sh_size
) {
1088 nsyms
= symtab
.sh_size
/ sizeof(struct elf_sym
);
1093 bswap_sym(syms
+ i
);
1095 // Throw away entries which we do not need.
1096 if (syms
[i
].st_shndx
== SHN_UNDEF
||
1097 syms
[i
].st_shndx
>= SHN_LORESERVE
||
1098 ELF_ST_TYPE(syms
[i
].st_info
) != STT_FUNC
) {
1101 syms
[i
] = syms
[nsyms
];
1105 #if defined(TARGET_ARM) || defined(TARGET_MIPS)
1106 /* The bottom address bit marks a Thumb or MIPS16 symbol. */
1107 syms
[i
].st_value
&= ~(target_ulong
)1;
1112 /* Attempt to free the storage associated with the local symbols
1113 that we threw away. Whether or not this has any effect on the
1114 memory allocation depends on the malloc implementation and how
1115 many symbols we managed to discard. */
1116 new_syms
= realloc(syms
, nsyms
* sizeof(*syms
));
1117 if (new_syms
== NULL
) {
1125 qsort(syms
, nsyms
, sizeof(*syms
), symcmp
);
1127 lseek(fd
, strtab
.sh_offset
, SEEK_SET
);
1128 if (read(fd
, strings
, strtab
.sh_size
) != strtab
.sh_size
) {
1134 s
->disas_num_syms
= nsyms
;
1135 #if ELF_CLASS == ELFCLASS32
1136 s
->disas_symtab
.elf32
= syms
;
1137 s
->lookup_symbol
= (lookup_symbol_t
)lookup_symbolxx
;
1139 s
->disas_symtab
.elf64
= syms
;
1140 s
->lookup_symbol
= (lookup_symbol_t
)lookup_symbolxx
;
1146 int load_elf_binary(struct bsd_binprm
*bprm
, struct target_pt_regs
*regs
,
1147 struct image_info
*info
)
1149 struct elfhdr elf_ex
;
1150 struct elfhdr interp_elf_ex
;
1151 struct exec interp_ex
;
1152 int interpreter_fd
= -1; /* avoid warning */
1153 abi_ulong load_addr
, load_bias
;
1154 int load_addr_set
= 0;
1155 unsigned int interpreter_type
= INTERPRETER_NONE
;
1156 unsigned char ibcs2_interpreter
;
1158 struct elf_phdr
* elf_ppnt
;
1159 struct elf_phdr
*elf_phdata
;
1160 abi_ulong elf_bss
, k
, elf_brk
;
1162 char * elf_interpreter
;
1163 abi_ulong elf_entry
, interp_load_addr
= 0;
1164 abi_ulong start_code
, end_code
, start_data
, end_data
;
1165 abi_ulong reloc_func_desc
= 0;
1166 #ifdef LOW_ELF_STACK
1167 abi_ulong elf_stack
= ~((abi_ulong
)0UL);
1169 char passed_fileno
[6];
1171 ibcs2_interpreter
= 0;
1174 elf_ex
= *((struct elfhdr
*) bprm
->buf
); /* exec-header */
1176 bswap_ehdr(&elf_ex
);
1179 /* First of all, some simple consistency checks */
1180 if ((elf_ex
.e_type
!= ET_EXEC
&& elf_ex
.e_type
!= ET_DYN
) ||
1181 (!elf_check_arch(elf_ex
.e_machine
))) {
1185 bprm
->p
= copy_elf_strings(1, &bprm
->filename
, bprm
->page
, bprm
->p
);
1186 bprm
->p
= copy_elf_strings(bprm
->envc
, bprm
->envp
, bprm
->page
,bprm
->p
);
1187 bprm
->p
= copy_elf_strings(bprm
->argc
, bprm
->argv
, bprm
->page
,bprm
->p
);
1192 /* Now read in all of the header information */
1193 elf_phdata
= (struct elf_phdr
*)malloc(elf_ex
.e_phentsize
*elf_ex
.e_phnum
);
1194 if (elf_phdata
== NULL
) {
1198 retval
= lseek(bprm
->fd
, elf_ex
.e_phoff
, SEEK_SET
);
1200 retval
= read(bprm
->fd
, (char *)elf_phdata
,
1201 elf_ex
.e_phentsize
* elf_ex
.e_phnum
);
1205 perror("load_elf_binary");
1212 elf_ppnt
= elf_phdata
;
1213 for (i
= 0; i
< elf_ex
.e_phnum
; i
++, elf_ppnt
++) {
1214 bswap_phdr(elf_ppnt
);
1217 elf_ppnt
= elf_phdata
;
1223 elf_interpreter
= NULL
;
1224 start_code
= ~((abi_ulong
)0UL);
1228 interp_ex
.a_info
= 0;
1230 for (i
= 0;i
< elf_ex
.e_phnum
; i
++) {
1231 if (elf_ppnt
->p_type
== PT_INTERP
) {
1232 if (elf_interpreter
!= NULL
)
1235 free(elf_interpreter
);
1240 /* This is the program interpreter used for
1241 * shared libraries - for now assume that this
1242 * is an a.out format binary
1245 elf_interpreter
= (char *)malloc(elf_ppnt
->p_filesz
);
1247 if (elf_interpreter
== NULL
) {
1253 retval
= lseek(bprm
->fd
, elf_ppnt
->p_offset
, SEEK_SET
);
1255 retval
= read(bprm
->fd
, elf_interpreter
, elf_ppnt
->p_filesz
);
1258 perror("load_elf_binary2");
1262 /* If the program interpreter is one of these two,
1263 then assume an iBCS2 image. Otherwise assume
1264 a native linux image. */
1266 /* JRP - Need to add X86 lib dir stuff here... */
1268 if (strcmp(elf_interpreter
, "/usr/lib/libc.so.1") == 0 ||
1269 strcmp(elf_interpreter
, "/usr/lib/ld.so.1") == 0) {
1270 ibcs2_interpreter
= 1;
1274 printf("Using ELF interpreter %s\n", path(elf_interpreter
));
1277 retval
= open(path(elf_interpreter
), O_RDONLY
);
1279 interpreter_fd
= retval
;
1282 perror(elf_interpreter
);
1284 /* retval = -errno; */
1289 retval
= lseek(interpreter_fd
, 0, SEEK_SET
);
1291 retval
= read(interpreter_fd
, bprm
->buf
, 128);
1295 interp_ex
= *((struct exec
*) bprm
->buf
); /* aout exec-header */
1296 interp_elf_ex
= *((struct elfhdr
*) bprm
->buf
); /* elf exec-header */
1299 perror("load_elf_binary3");
1302 free(elf_interpreter
);
1310 /* Some simple consistency checks for the interpreter */
1311 if (elf_interpreter
) {
1312 interpreter_type
= INTERPRETER_ELF
| INTERPRETER_AOUT
;
1314 /* Now figure out which format our binary is */
1315 if ((N_MAGIC(interp_ex
) != OMAGIC
) && (N_MAGIC(interp_ex
) != ZMAGIC
) &&
1316 (N_MAGIC(interp_ex
) != QMAGIC
)) {
1317 interpreter_type
= INTERPRETER_ELF
;
1320 if (interp_elf_ex
.e_ident
[0] != 0x7f ||
1321 strncmp((char *)&interp_elf_ex
.e_ident
[1], "ELF", 3) != 0) {
1322 interpreter_type
&= ~INTERPRETER_ELF
;
1325 if (!interpreter_type
) {
1326 free(elf_interpreter
);
1333 /* OK, we are done with that, now set up the arg stuff,
1334 and then start this sucker up */
1339 if (interpreter_type
== INTERPRETER_AOUT
) {
1340 snprintf(passed_fileno
, sizeof(passed_fileno
), "%d", bprm
->fd
);
1341 passed_p
= passed_fileno
;
1343 if (elf_interpreter
) {
1344 bprm
->p
= copy_elf_strings(1, &passed_p
, bprm
->page
, bprm
->p
);
1349 free(elf_interpreter
);
1356 /* OK, This is the point of no return */
1359 info
->start_mmap
= (abi_ulong
)ELF_START_MMAP
;
1361 elf_entry
= (abi_ulong
) elf_ex
.e_entry
;
1364 * In case where user has not explicitly set the guest_base, we
1365 * probe here that should we set it automatically.
1367 if (!have_guest_base
) {
1369 * Go through ELF program header table and find out whether
1370 * any of the segments drop below our current mmap_min_addr and
1371 * in that case set guest_base to corresponding address.
1373 for (i
= 0, elf_ppnt
= elf_phdata
; i
< elf_ex
.e_phnum
;
1375 if (elf_ppnt
->p_type
!= PT_LOAD
)
1377 if (HOST_PAGE_ALIGN(elf_ppnt
->p_vaddr
) < mmap_min_addr
) {
1378 guest_base
= HOST_PAGE_ALIGN(mmap_min_addr
);
1384 /* Do this so that we can load the interpreter, if need be. We will
1385 change some of these later */
1387 bprm
->p
= setup_arg_pages(bprm
->p
, bprm
, info
);
1388 info
->start_stack
= bprm
->p
;
1390 /* Now we do a little grungy work by mmaping the ELF image into
1391 * the correct location in memory. At this point, we assume that
1392 * the image should be loaded at fixed address, not at a variable
1396 for (i
= 0, elf_ppnt
= elf_phdata
; i
< elf_ex
.e_phnum
; i
++, elf_ppnt
++) {
1401 if (elf_ppnt
->p_type
!= PT_LOAD
)
1404 if (elf_ppnt
->p_flags
& PF_R
) elf_prot
|= PROT_READ
;
1405 if (elf_ppnt
->p_flags
& PF_W
) elf_prot
|= PROT_WRITE
;
1406 if (elf_ppnt
->p_flags
& PF_X
) elf_prot
|= PROT_EXEC
;
1407 elf_flags
= MAP_PRIVATE
| MAP_DENYWRITE
;
1408 if (elf_ex
.e_type
== ET_EXEC
|| load_addr_set
) {
1409 elf_flags
|= MAP_FIXED
;
1410 } else if (elf_ex
.e_type
== ET_DYN
) {
1411 /* Try and get dynamic programs out of the way of the default mmap
1412 base, as well as whatever program they might try to exec. This
1413 is because the brk will follow the loader, and is not movable. */
1414 /* NOTE: for qemu, we do a big mmap to get enough space
1415 without hardcoding any address */
1416 error
= target_mmap(0, ET_DYN_MAP_SIZE
,
1417 PROT_NONE
, MAP_PRIVATE
| MAP_ANON
,
1423 load_bias
= TARGET_ELF_PAGESTART(error
- elf_ppnt
->p_vaddr
);
1426 error
= target_mmap(TARGET_ELF_PAGESTART(load_bias
+ elf_ppnt
->p_vaddr
),
1427 (elf_ppnt
->p_filesz
+
1428 TARGET_ELF_PAGEOFFSET(elf_ppnt
->p_vaddr
)),
1430 (MAP_FIXED
| MAP_PRIVATE
| MAP_DENYWRITE
),
1432 (elf_ppnt
->p_offset
-
1433 TARGET_ELF_PAGEOFFSET(elf_ppnt
->p_vaddr
)));
1439 #ifdef LOW_ELF_STACK
1440 if (TARGET_ELF_PAGESTART(elf_ppnt
->p_vaddr
) < elf_stack
)
1441 elf_stack
= TARGET_ELF_PAGESTART(elf_ppnt
->p_vaddr
);
1444 if (!load_addr_set
) {
1446 load_addr
= elf_ppnt
->p_vaddr
- elf_ppnt
->p_offset
;
1447 if (elf_ex
.e_type
== ET_DYN
) {
1448 load_bias
+= error
-
1449 TARGET_ELF_PAGESTART(load_bias
+ elf_ppnt
->p_vaddr
);
1450 load_addr
+= load_bias
;
1451 reloc_func_desc
= load_bias
;
1454 k
= elf_ppnt
->p_vaddr
;
1459 k
= elf_ppnt
->p_vaddr
+ elf_ppnt
->p_filesz
;
1462 if ((elf_ppnt
->p_flags
& PF_X
) && end_code
< k
)
1466 k
= elf_ppnt
->p_vaddr
+ elf_ppnt
->p_memsz
;
1467 if (k
> elf_brk
) elf_brk
= k
;
1470 elf_entry
+= load_bias
;
1471 elf_bss
+= load_bias
;
1472 elf_brk
+= load_bias
;
1473 start_code
+= load_bias
;
1474 end_code
+= load_bias
;
1475 start_data
+= load_bias
;
1476 end_data
+= load_bias
;
1478 if (elf_interpreter
) {
1479 if (interpreter_type
& 1) {
1480 elf_entry
= load_aout_interp(&interp_ex
, interpreter_fd
);
1482 else if (interpreter_type
& 2) {
1483 elf_entry
= load_elf_interp(&interp_elf_ex
, interpreter_fd
,
1486 reloc_func_desc
= interp_load_addr
;
1488 close(interpreter_fd
);
1489 free(elf_interpreter
);
1491 if (elf_entry
== ~((abi_ulong
)0UL)) {
1492 printf("Unable to load interpreter\n");
1501 if (qemu_log_enabled())
1502 load_symbols(&elf_ex
, bprm
->fd
);
1504 if (interpreter_type
!= INTERPRETER_AOUT
) close(bprm
->fd
);
1505 info
->personality
= (ibcs2_interpreter
? PER_SVR4
: PER_LINUX
);
1507 #ifdef LOW_ELF_STACK
1508 info
->start_stack
= bprm
->p
= elf_stack
- 4;
1510 bprm
->p
= create_elf_tables(bprm
->p
,
1514 load_addr
, load_bias
,
1516 (interpreter_type
== INTERPRETER_AOUT
? 0 : 1),
1518 info
->load_addr
= reloc_func_desc
;
1519 info
->start_brk
= info
->brk
= elf_brk
;
1520 info
->end_code
= end_code
;
1521 info
->start_code
= start_code
;
1522 info
->start_data
= start_data
;
1523 info
->end_data
= end_data
;
1524 info
->start_stack
= bprm
->p
;
1526 /* Calling set_brk effectively mmaps the pages that we need for the bss and break
1528 set_brk(elf_bss
, elf_brk
);
1530 padzero(elf_bss
, elf_brk
);
1533 printf("(start_brk) %x\n" , info
->start_brk
);
1534 printf("(end_code) %x\n" , info
->end_code
);
1535 printf("(start_code) %x\n" , info
->start_code
);
1536 printf("(end_data) %x\n" , info
->end_data
);
1537 printf("(start_stack) %x\n" , info
->start_stack
);
1538 printf("(brk) %x\n" , info
->brk
);
1541 if (info
->personality
== PER_SVR4
)
1543 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1544 and some applications "depend" upon this behavior.
1545 Since we do not have the power to recompile these, we
1546 emulate the SVr4 behavior. Sigh. */
1547 target_mmap(0, qemu_host_page_size
, PROT_READ
| PROT_EXEC
,
1548 MAP_FIXED
| MAP_PRIVATE
, -1, 0);
1551 info
->entry
= elf_entry
;
1556 static int load_aout_interp(void *exptr
, int interp_fd
)
1558 printf("a.out interpreter not yet supported\n");
1562 void do_init_thread(struct target_pt_regs
*regs
, struct image_info
*infop
)
1564 init_thread(regs
, infop
);