]> Git Repo - qemu.git/blob - linux-user/elfload.c
Merge remote-tracking branch 'remotes/kraxel/tags/pull-ui-20170131-2' into staging
[qemu.git] / linux-user / elfload.c
1 /* This is the Linux kernel elf-loading code, ported into user space */
2 #include "qemu/osdep.h"
3 #include <sys/param.h>
4
5 #include <sys/resource.h>
6
7 #include "qemu.h"
8 #include "disas/disas.h"
9 #include "qemu/path.h"
10
11 #ifdef _ARCH_PPC64
12 #undef ARCH_DLINFO
13 #undef ELF_PLATFORM
14 #undef ELF_HWCAP
15 #undef ELF_HWCAP2
16 #undef ELF_CLASS
17 #undef ELF_DATA
18 #undef ELF_ARCH
19 #endif
20
21 #define ELF_OSABI   ELFOSABI_SYSV
22
23 /* from personality.h */
24
25 /*
26  * Flags for bug emulation.
27  *
28  * These occupy the top three bytes.
29  */
30 enum {
31     ADDR_NO_RANDOMIZE = 0x0040000,      /* disable randomization of VA space */
32     FDPIC_FUNCPTRS =    0x0080000,      /* userspace function ptrs point to
33                                            descriptors (signal handling) */
34     MMAP_PAGE_ZERO =    0x0100000,
35     ADDR_COMPAT_LAYOUT = 0x0200000,
36     READ_IMPLIES_EXEC = 0x0400000,
37     ADDR_LIMIT_32BIT =  0x0800000,
38     SHORT_INODE =       0x1000000,
39     WHOLE_SECONDS =     0x2000000,
40     STICKY_TIMEOUTS =   0x4000000,
41     ADDR_LIMIT_3GB =    0x8000000,
42 };
43
44 /*
45  * Personality types.
46  *
47  * These go in the low byte.  Avoid using the top bit, it will
48  * conflict with error returns.
49  */
50 enum {
51     PER_LINUX =         0x0000,
52     PER_LINUX_32BIT =   0x0000 | ADDR_LIMIT_32BIT,
53     PER_LINUX_FDPIC =   0x0000 | FDPIC_FUNCPTRS,
54     PER_SVR4 =          0x0001 | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
55     PER_SVR3 =          0x0002 | STICKY_TIMEOUTS | SHORT_INODE,
56     PER_SCOSVR3 =       0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS | SHORT_INODE,
57     PER_OSR5 =          0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS,
58     PER_WYSEV386 =      0x0004 | STICKY_TIMEOUTS | SHORT_INODE,
59     PER_ISCR4 =         0x0005 | STICKY_TIMEOUTS,
60     PER_BSD =           0x0006,
61     PER_SUNOS =         0x0006 | STICKY_TIMEOUTS,
62     PER_XENIX =         0x0007 | STICKY_TIMEOUTS | SHORT_INODE,
63     PER_LINUX32 =       0x0008,
64     PER_LINUX32_3GB =   0x0008 | ADDR_LIMIT_3GB,
65     PER_IRIX32 =        0x0009 | STICKY_TIMEOUTS,/* IRIX5 32-bit */
66     PER_IRIXN32 =       0x000a | STICKY_TIMEOUTS,/* IRIX6 new 32-bit */
67     PER_IRIX64 =        0x000b | STICKY_TIMEOUTS,/* IRIX6 64-bit */
68     PER_RISCOS =        0x000c,
69     PER_SOLARIS =       0x000d | STICKY_TIMEOUTS,
70     PER_UW7 =           0x000e | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
71     PER_OSF4 =          0x000f,                  /* OSF/1 v4 */
72     PER_HPUX =          0x0010,
73     PER_MASK =          0x00ff,
74 };
75
76 /*
77  * Return the base personality without flags.
78  */
79 #define personality(pers)       (pers & PER_MASK)
80
81 /* this flag is uneffective under linux too, should be deleted */
82 #ifndef MAP_DENYWRITE
83 #define MAP_DENYWRITE 0
84 #endif
85
86 /* should probably go in elf.h */
87 #ifndef ELIBBAD
88 #define ELIBBAD 80
89 #endif
90
91 #ifdef TARGET_WORDS_BIGENDIAN
92 #define ELF_DATA        ELFDATA2MSB
93 #else
94 #define ELF_DATA        ELFDATA2LSB
95 #endif
96
97 #ifdef TARGET_ABI_MIPSN32
98 typedef abi_ullong      target_elf_greg_t;
99 #define tswapreg(ptr)   tswap64(ptr)
100 #else
101 typedef abi_ulong       target_elf_greg_t;
102 #define tswapreg(ptr)   tswapal(ptr)
103 #endif
104
105 #ifdef USE_UID16
106 typedef abi_ushort      target_uid_t;
107 typedef abi_ushort      target_gid_t;
108 #else
109 typedef abi_uint        target_uid_t;
110 typedef abi_uint        target_gid_t;
111 #endif
112 typedef abi_int         target_pid_t;
113
114 #ifdef TARGET_I386
115
116 #define ELF_PLATFORM get_elf_platform()
117
118 static const char *get_elf_platform(void)
119 {
120     static char elf_platform[] = "i386";
121     int family = object_property_get_int(OBJECT(thread_cpu), "family", NULL);
122     if (family > 6)
123         family = 6;
124     if (family >= 3)
125         elf_platform[1] = '0' + family;
126     return elf_platform;
127 }
128
129 #define ELF_HWCAP get_elf_hwcap()
130
131 static uint32_t get_elf_hwcap(void)
132 {
133     X86CPU *cpu = X86_CPU(thread_cpu);
134
135     return cpu->env.features[FEAT_1_EDX];
136 }
137
138 #ifdef TARGET_X86_64
139 #define ELF_START_MMAP 0x2aaaaab000ULL
140
141 #define ELF_CLASS      ELFCLASS64
142 #define ELF_ARCH       EM_X86_64
143
144 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
145 {
146     regs->rax = 0;
147     regs->rsp = infop->start_stack;
148     regs->rip = infop->entry;
149 }
150
151 #define ELF_NREG    27
152 typedef target_elf_greg_t  target_elf_gregset_t[ELF_NREG];
153
154 /*
155  * Note that ELF_NREG should be 29 as there should be place for
156  * TRAPNO and ERR "registers" as well but linux doesn't dump
157  * those.
158  *
159  * See linux kernel: arch/x86/include/asm/elf.h
160  */
161 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUX86State *env)
162 {
163     (*regs)[0] = env->regs[15];
164     (*regs)[1] = env->regs[14];
165     (*regs)[2] = env->regs[13];
166     (*regs)[3] = env->regs[12];
167     (*regs)[4] = env->regs[R_EBP];
168     (*regs)[5] = env->regs[R_EBX];
169     (*regs)[6] = env->regs[11];
170     (*regs)[7] = env->regs[10];
171     (*regs)[8] = env->regs[9];
172     (*regs)[9] = env->regs[8];
173     (*regs)[10] = env->regs[R_EAX];
174     (*regs)[11] = env->regs[R_ECX];
175     (*regs)[12] = env->regs[R_EDX];
176     (*regs)[13] = env->regs[R_ESI];
177     (*regs)[14] = env->regs[R_EDI];
178     (*regs)[15] = env->regs[R_EAX]; /* XXX */
179     (*regs)[16] = env->eip;
180     (*regs)[17] = env->segs[R_CS].selector & 0xffff;
181     (*regs)[18] = env->eflags;
182     (*regs)[19] = env->regs[R_ESP];
183     (*regs)[20] = env->segs[R_SS].selector & 0xffff;
184     (*regs)[21] = env->segs[R_FS].selector & 0xffff;
185     (*regs)[22] = env->segs[R_GS].selector & 0xffff;
186     (*regs)[23] = env->segs[R_DS].selector & 0xffff;
187     (*regs)[24] = env->segs[R_ES].selector & 0xffff;
188     (*regs)[25] = env->segs[R_FS].selector & 0xffff;
189     (*regs)[26] = env->segs[R_GS].selector & 0xffff;
190 }
191
192 #else
193
194 #define ELF_START_MMAP 0x80000000
195
196 /*
197  * This is used to ensure we don't load something for the wrong architecture.
198  */
199 #define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
200
201 /*
202  * These are used to set parameters in the core dumps.
203  */
204 #define ELF_CLASS       ELFCLASS32
205 #define ELF_ARCH        EM_386
206
207 static inline void init_thread(struct target_pt_regs *regs,
208                                struct image_info *infop)
209 {
210     regs->esp = infop->start_stack;
211     regs->eip = infop->entry;
212
213     /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
214        starts %edx contains a pointer to a function which might be
215        registered using `atexit'.  This provides a mean for the
216        dynamic linker to call DT_FINI functions for shared libraries
217        that have been loaded before the code runs.
218
219        A value of 0 tells we have no such handler.  */
220     regs->edx = 0;
221 }
222
223 #define ELF_NREG    17
224 typedef target_elf_greg_t  target_elf_gregset_t[ELF_NREG];
225
226 /*
227  * Note that ELF_NREG should be 19 as there should be place for
228  * TRAPNO and ERR "registers" as well but linux doesn't dump
229  * those.
230  *
231  * See linux kernel: arch/x86/include/asm/elf.h
232  */
233 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUX86State *env)
234 {
235     (*regs)[0] = env->regs[R_EBX];
236     (*regs)[1] = env->regs[R_ECX];
237     (*regs)[2] = env->regs[R_EDX];
238     (*regs)[3] = env->regs[R_ESI];
239     (*regs)[4] = env->regs[R_EDI];
240     (*regs)[5] = env->regs[R_EBP];
241     (*regs)[6] = env->regs[R_EAX];
242     (*regs)[7] = env->segs[R_DS].selector & 0xffff;
243     (*regs)[8] = env->segs[R_ES].selector & 0xffff;
244     (*regs)[9] = env->segs[R_FS].selector & 0xffff;
245     (*regs)[10] = env->segs[R_GS].selector & 0xffff;
246     (*regs)[11] = env->regs[R_EAX]; /* XXX */
247     (*regs)[12] = env->eip;
248     (*regs)[13] = env->segs[R_CS].selector & 0xffff;
249     (*regs)[14] = env->eflags;
250     (*regs)[15] = env->regs[R_ESP];
251     (*regs)[16] = env->segs[R_SS].selector & 0xffff;
252 }
253 #endif
254
255 #define USE_ELF_CORE_DUMP
256 #define ELF_EXEC_PAGESIZE       4096
257
258 #endif
259
260 #ifdef TARGET_ARM
261
262 #ifndef TARGET_AARCH64
263 /* 32 bit ARM definitions */
264
265 #define ELF_START_MMAP 0x80000000
266
267 #define ELF_ARCH        EM_ARM
268 #define ELF_CLASS       ELFCLASS32
269
270 static inline void init_thread(struct target_pt_regs *regs,
271                                struct image_info *infop)
272 {
273     abi_long stack = infop->start_stack;
274     memset(regs, 0, sizeof(*regs));
275
276     regs->uregs[16] = ARM_CPU_MODE_USR;
277     if (infop->entry & 1) {
278         regs->uregs[16] |= CPSR_T;
279     }
280     regs->uregs[15] = infop->entry & 0xfffffffe;
281     regs->uregs[13] = infop->start_stack;
282     /* FIXME - what to for failure of get_user()? */
283     get_user_ual(regs->uregs[2], stack + 8); /* envp */
284     get_user_ual(regs->uregs[1], stack + 4); /* envp */
285     /* XXX: it seems that r0 is zeroed after ! */
286     regs->uregs[0] = 0;
287     /* For uClinux PIC binaries.  */
288     /* XXX: Linux does this only on ARM with no MMU (do we care ?) */
289     regs->uregs[10] = infop->start_data;
290 }
291
292 #define ELF_NREG    18
293 typedef target_elf_greg_t  target_elf_gregset_t[ELF_NREG];
294
295 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUARMState *env)
296 {
297     (*regs)[0] = tswapreg(env->regs[0]);
298     (*regs)[1] = tswapreg(env->regs[1]);
299     (*regs)[2] = tswapreg(env->regs[2]);
300     (*regs)[3] = tswapreg(env->regs[3]);
301     (*regs)[4] = tswapreg(env->regs[4]);
302     (*regs)[5] = tswapreg(env->regs[5]);
303     (*regs)[6] = tswapreg(env->regs[6]);
304     (*regs)[7] = tswapreg(env->regs[7]);
305     (*regs)[8] = tswapreg(env->regs[8]);
306     (*regs)[9] = tswapreg(env->regs[9]);
307     (*regs)[10] = tswapreg(env->regs[10]);
308     (*regs)[11] = tswapreg(env->regs[11]);
309     (*regs)[12] = tswapreg(env->regs[12]);
310     (*regs)[13] = tswapreg(env->regs[13]);
311     (*regs)[14] = tswapreg(env->regs[14]);
312     (*regs)[15] = tswapreg(env->regs[15]);
313
314     (*regs)[16] = tswapreg(cpsr_read((CPUARMState *)env));
315     (*regs)[17] = tswapreg(env->regs[0]); /* XXX */
316 }
317
318 #define USE_ELF_CORE_DUMP
319 #define ELF_EXEC_PAGESIZE       4096
320
321 enum
322 {
323     ARM_HWCAP_ARM_SWP       = 1 << 0,
324     ARM_HWCAP_ARM_HALF      = 1 << 1,
325     ARM_HWCAP_ARM_THUMB     = 1 << 2,
326     ARM_HWCAP_ARM_26BIT     = 1 << 3,
327     ARM_HWCAP_ARM_FAST_MULT = 1 << 4,
328     ARM_HWCAP_ARM_FPA       = 1 << 5,
329     ARM_HWCAP_ARM_VFP       = 1 << 6,
330     ARM_HWCAP_ARM_EDSP      = 1 << 7,
331     ARM_HWCAP_ARM_JAVA      = 1 << 8,
332     ARM_HWCAP_ARM_IWMMXT    = 1 << 9,
333     ARM_HWCAP_ARM_CRUNCH    = 1 << 10,
334     ARM_HWCAP_ARM_THUMBEE   = 1 << 11,
335     ARM_HWCAP_ARM_NEON      = 1 << 12,
336     ARM_HWCAP_ARM_VFPv3     = 1 << 13,
337     ARM_HWCAP_ARM_VFPv3D16  = 1 << 14,
338     ARM_HWCAP_ARM_TLS       = 1 << 15,
339     ARM_HWCAP_ARM_VFPv4     = 1 << 16,
340     ARM_HWCAP_ARM_IDIVA     = 1 << 17,
341     ARM_HWCAP_ARM_IDIVT     = 1 << 18,
342     ARM_HWCAP_ARM_VFPD32    = 1 << 19,
343     ARM_HWCAP_ARM_LPAE      = 1 << 20,
344     ARM_HWCAP_ARM_EVTSTRM   = 1 << 21,
345 };
346
347 enum {
348     ARM_HWCAP2_ARM_AES      = 1 << 0,
349     ARM_HWCAP2_ARM_PMULL    = 1 << 1,
350     ARM_HWCAP2_ARM_SHA1     = 1 << 2,
351     ARM_HWCAP2_ARM_SHA2     = 1 << 3,
352     ARM_HWCAP2_ARM_CRC32    = 1 << 4,
353 };
354
355 /* The commpage only exists for 32 bit kernels */
356
357 #define TARGET_HAS_VALIDATE_GUEST_SPACE
358 /* Return 1 if the proposed guest space is suitable for the guest.
359  * Return 0 if the proposed guest space isn't suitable, but another
360  * address space should be tried.
361  * Return -1 if there is no way the proposed guest space can be
362  * valid regardless of the base.
363  * The guest code may leave a page mapped and populate it if the
364  * address is suitable.
365  */
366 static int validate_guest_space(unsigned long guest_base,
367                                 unsigned long guest_size)
368 {
369     unsigned long real_start, test_page_addr;
370
371     /* We need to check that we can force a fault on access to the
372      * commpage at 0xffff0fxx
373      */
374     test_page_addr = guest_base + (0xffff0f00 & qemu_host_page_mask);
375
376     /* If the commpage lies within the already allocated guest space,
377      * then there is no way we can allocate it.
378      */
379     if (test_page_addr >= guest_base
380         && test_page_addr <= (guest_base + guest_size)) {
381         return -1;
382     }
383
384     /* Note it needs to be writeable to let us initialise it */
385     real_start = (unsigned long)
386                  mmap((void *)test_page_addr, qemu_host_page_size,
387                      PROT_READ | PROT_WRITE,
388                      MAP_ANONYMOUS | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
389
390     /* If we can't map it then try another address */
391     if (real_start == -1ul) {
392         return 0;
393     }
394
395     if (real_start != test_page_addr) {
396         /* OS didn't put the page where we asked - unmap and reject */
397         munmap((void *)real_start, qemu_host_page_size);
398         return 0;
399     }
400
401     /* Leave the page mapped
402      * Populate it (mmap should have left it all 0'd)
403      */
404
405     /* Kernel helper versions */
406     __put_user(5, (uint32_t *)g2h(0xffff0ffcul));
407
408     /* Now it's populated make it RO */
409     if (mprotect((void *)test_page_addr, qemu_host_page_size, PROT_READ)) {
410         perror("Protecting guest commpage");
411         exit(-1);
412     }
413
414     return 1; /* All good */
415 }
416
417 #define ELF_HWCAP get_elf_hwcap()
418 #define ELF_HWCAP2 get_elf_hwcap2()
419
420 static uint32_t get_elf_hwcap(void)
421 {
422     ARMCPU *cpu = ARM_CPU(thread_cpu);
423     uint32_t hwcaps = 0;
424
425     hwcaps |= ARM_HWCAP_ARM_SWP;
426     hwcaps |= ARM_HWCAP_ARM_HALF;
427     hwcaps |= ARM_HWCAP_ARM_THUMB;
428     hwcaps |= ARM_HWCAP_ARM_FAST_MULT;
429
430     /* probe for the extra features */
431 #define GET_FEATURE(feat, hwcap) \
432     do { if (arm_feature(&cpu->env, feat)) { hwcaps |= hwcap; } } while (0)
433     /* EDSP is in v5TE and above, but all our v5 CPUs are v5TE */
434     GET_FEATURE(ARM_FEATURE_V5, ARM_HWCAP_ARM_EDSP);
435     GET_FEATURE(ARM_FEATURE_VFP, ARM_HWCAP_ARM_VFP);
436     GET_FEATURE(ARM_FEATURE_IWMMXT, ARM_HWCAP_ARM_IWMMXT);
437     GET_FEATURE(ARM_FEATURE_THUMB2EE, ARM_HWCAP_ARM_THUMBEE);
438     GET_FEATURE(ARM_FEATURE_NEON, ARM_HWCAP_ARM_NEON);
439     GET_FEATURE(ARM_FEATURE_VFP3, ARM_HWCAP_ARM_VFPv3);
440     GET_FEATURE(ARM_FEATURE_V6K, ARM_HWCAP_ARM_TLS);
441     GET_FEATURE(ARM_FEATURE_VFP4, ARM_HWCAP_ARM_VFPv4);
442     GET_FEATURE(ARM_FEATURE_ARM_DIV, ARM_HWCAP_ARM_IDIVA);
443     GET_FEATURE(ARM_FEATURE_THUMB_DIV, ARM_HWCAP_ARM_IDIVT);
444     /* All QEMU's VFPv3 CPUs have 32 registers, see VFP_DREG in translate.c.
445      * Note that the ARM_HWCAP_ARM_VFPv3D16 bit is always the inverse of
446      * ARM_HWCAP_ARM_VFPD32 (and so always clear for QEMU); it is unrelated
447      * to our VFP_FP16 feature bit.
448      */
449     GET_FEATURE(ARM_FEATURE_VFP3, ARM_HWCAP_ARM_VFPD32);
450     GET_FEATURE(ARM_FEATURE_LPAE, ARM_HWCAP_ARM_LPAE);
451
452     return hwcaps;
453 }
454
455 static uint32_t get_elf_hwcap2(void)
456 {
457     ARMCPU *cpu = ARM_CPU(thread_cpu);
458     uint32_t hwcaps = 0;
459
460     GET_FEATURE(ARM_FEATURE_V8_AES, ARM_HWCAP2_ARM_AES);
461     GET_FEATURE(ARM_FEATURE_V8_PMULL, ARM_HWCAP2_ARM_PMULL);
462     GET_FEATURE(ARM_FEATURE_V8_SHA1, ARM_HWCAP2_ARM_SHA1);
463     GET_FEATURE(ARM_FEATURE_V8_SHA256, ARM_HWCAP2_ARM_SHA2);
464     GET_FEATURE(ARM_FEATURE_CRC, ARM_HWCAP2_ARM_CRC32);
465     return hwcaps;
466 }
467
468 #undef GET_FEATURE
469
470 #else
471 /* 64 bit ARM definitions */
472 #define ELF_START_MMAP 0x80000000
473
474 #define ELF_ARCH        EM_AARCH64
475 #define ELF_CLASS       ELFCLASS64
476 #define ELF_PLATFORM    "aarch64"
477
478 static inline void init_thread(struct target_pt_regs *regs,
479                                struct image_info *infop)
480 {
481     abi_long stack = infop->start_stack;
482     memset(regs, 0, sizeof(*regs));
483
484     regs->pc = infop->entry & ~0x3ULL;
485     regs->sp = stack;
486 }
487
488 #define ELF_NREG    34
489 typedef target_elf_greg_t  target_elf_gregset_t[ELF_NREG];
490
491 static void elf_core_copy_regs(target_elf_gregset_t *regs,
492                                const CPUARMState *env)
493 {
494     int i;
495
496     for (i = 0; i < 32; i++) {
497         (*regs)[i] = tswapreg(env->xregs[i]);
498     }
499     (*regs)[32] = tswapreg(env->pc);
500     (*regs)[33] = tswapreg(pstate_read((CPUARMState *)env));
501 }
502
503 #define USE_ELF_CORE_DUMP
504 #define ELF_EXEC_PAGESIZE       4096
505
506 enum {
507     ARM_HWCAP_A64_FP            = 1 << 0,
508     ARM_HWCAP_A64_ASIMD         = 1 << 1,
509     ARM_HWCAP_A64_EVTSTRM       = 1 << 2,
510     ARM_HWCAP_A64_AES           = 1 << 3,
511     ARM_HWCAP_A64_PMULL         = 1 << 4,
512     ARM_HWCAP_A64_SHA1          = 1 << 5,
513     ARM_HWCAP_A64_SHA2          = 1 << 6,
514     ARM_HWCAP_A64_CRC32         = 1 << 7,
515 };
516
517 #define ELF_HWCAP get_elf_hwcap()
518
519 static uint32_t get_elf_hwcap(void)
520 {
521     ARMCPU *cpu = ARM_CPU(thread_cpu);
522     uint32_t hwcaps = 0;
523
524     hwcaps |= ARM_HWCAP_A64_FP;
525     hwcaps |= ARM_HWCAP_A64_ASIMD;
526
527     /* probe for the extra features */
528 #define GET_FEATURE(feat, hwcap) \
529     do { if (arm_feature(&cpu->env, feat)) { hwcaps |= hwcap; } } while (0)
530     GET_FEATURE(ARM_FEATURE_V8_AES, ARM_HWCAP_A64_AES);
531     GET_FEATURE(ARM_FEATURE_V8_PMULL, ARM_HWCAP_A64_PMULL);
532     GET_FEATURE(ARM_FEATURE_V8_SHA1, ARM_HWCAP_A64_SHA1);
533     GET_FEATURE(ARM_FEATURE_V8_SHA256, ARM_HWCAP_A64_SHA2);
534     GET_FEATURE(ARM_FEATURE_CRC, ARM_HWCAP_A64_CRC32);
535 #undef GET_FEATURE
536
537     return hwcaps;
538 }
539
540 #endif /* not TARGET_AARCH64 */
541 #endif /* TARGET_ARM */
542
543 #ifdef TARGET_UNICORE32
544
545 #define ELF_START_MMAP          0x80000000
546
547 #define ELF_CLASS               ELFCLASS32
548 #define ELF_DATA                ELFDATA2LSB
549 #define ELF_ARCH                EM_UNICORE32
550
551 static inline void init_thread(struct target_pt_regs *regs,
552         struct image_info *infop)
553 {
554     abi_long stack = infop->start_stack;
555     memset(regs, 0, sizeof(*regs));
556     regs->UC32_REG_asr = 0x10;
557     regs->UC32_REG_pc = infop->entry & 0xfffffffe;
558     regs->UC32_REG_sp = infop->start_stack;
559     /* FIXME - what to for failure of get_user()? */
560     get_user_ual(regs->UC32_REG_02, stack + 8); /* envp */
561     get_user_ual(regs->UC32_REG_01, stack + 4); /* envp */
562     /* XXX: it seems that r0 is zeroed after ! */
563     regs->UC32_REG_00 = 0;
564 }
565
566 #define ELF_NREG    34
567 typedef target_elf_greg_t  target_elf_gregset_t[ELF_NREG];
568
569 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUUniCore32State *env)
570 {
571     (*regs)[0] = env->regs[0];
572     (*regs)[1] = env->regs[1];
573     (*regs)[2] = env->regs[2];
574     (*regs)[3] = env->regs[3];
575     (*regs)[4] = env->regs[4];
576     (*regs)[5] = env->regs[5];
577     (*regs)[6] = env->regs[6];
578     (*regs)[7] = env->regs[7];
579     (*regs)[8] = env->regs[8];
580     (*regs)[9] = env->regs[9];
581     (*regs)[10] = env->regs[10];
582     (*regs)[11] = env->regs[11];
583     (*regs)[12] = env->regs[12];
584     (*regs)[13] = env->regs[13];
585     (*regs)[14] = env->regs[14];
586     (*regs)[15] = env->regs[15];
587     (*regs)[16] = env->regs[16];
588     (*regs)[17] = env->regs[17];
589     (*regs)[18] = env->regs[18];
590     (*regs)[19] = env->regs[19];
591     (*regs)[20] = env->regs[20];
592     (*regs)[21] = env->regs[21];
593     (*regs)[22] = env->regs[22];
594     (*regs)[23] = env->regs[23];
595     (*regs)[24] = env->regs[24];
596     (*regs)[25] = env->regs[25];
597     (*regs)[26] = env->regs[26];
598     (*regs)[27] = env->regs[27];
599     (*regs)[28] = env->regs[28];
600     (*regs)[29] = env->regs[29];
601     (*regs)[30] = env->regs[30];
602     (*regs)[31] = env->regs[31];
603
604     (*regs)[32] = cpu_asr_read((CPUUniCore32State *)env);
605     (*regs)[33] = env->regs[0]; /* XXX */
606 }
607
608 #define USE_ELF_CORE_DUMP
609 #define ELF_EXEC_PAGESIZE               4096
610
611 #define ELF_HWCAP                       (UC32_HWCAP_CMOV | UC32_HWCAP_UCF64)
612
613 #endif
614
615 #ifdef TARGET_SPARC
616 #ifdef TARGET_SPARC64
617
618 #define ELF_START_MMAP 0x80000000
619 #define ELF_HWCAP  (HWCAP_SPARC_FLUSH | HWCAP_SPARC_STBAR | HWCAP_SPARC_SWAP \
620                     | HWCAP_SPARC_MULDIV | HWCAP_SPARC_V9)
621 #ifndef TARGET_ABI32
622 #define elf_check_arch(x) ( (x) == EM_SPARCV9 || (x) == EM_SPARC32PLUS )
623 #else
624 #define elf_check_arch(x) ( (x) == EM_SPARC32PLUS || (x) == EM_SPARC )
625 #endif
626
627 #define ELF_CLASS   ELFCLASS64
628 #define ELF_ARCH    EM_SPARCV9
629
630 #define STACK_BIAS              2047
631
632 static inline void init_thread(struct target_pt_regs *regs,
633                                struct image_info *infop)
634 {
635 #ifndef TARGET_ABI32
636     regs->tstate = 0;
637 #endif
638     regs->pc = infop->entry;
639     regs->npc = regs->pc + 4;
640     regs->y = 0;
641 #ifdef TARGET_ABI32
642     regs->u_regs[14] = infop->start_stack - 16 * 4;
643 #else
644     if (personality(infop->personality) == PER_LINUX32)
645         regs->u_regs[14] = infop->start_stack - 16 * 4;
646     else
647         regs->u_regs[14] = infop->start_stack - 16 * 8 - STACK_BIAS;
648 #endif
649 }
650
651 #else
652 #define ELF_START_MMAP 0x80000000
653 #define ELF_HWCAP  (HWCAP_SPARC_FLUSH | HWCAP_SPARC_STBAR | HWCAP_SPARC_SWAP \
654                     | HWCAP_SPARC_MULDIV)
655
656 #define ELF_CLASS   ELFCLASS32
657 #define ELF_ARCH    EM_SPARC
658
659 static inline void init_thread(struct target_pt_regs *regs,
660                                struct image_info *infop)
661 {
662     regs->psr = 0;
663     regs->pc = infop->entry;
664     regs->npc = regs->pc + 4;
665     regs->y = 0;
666     regs->u_regs[14] = infop->start_stack - 16 * 4;
667 }
668
669 #endif
670 #endif
671
672 #ifdef TARGET_PPC
673
674 #define ELF_MACHINE    PPC_ELF_MACHINE
675 #define ELF_START_MMAP 0x80000000
676
677 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
678
679 #define elf_check_arch(x) ( (x) == EM_PPC64 )
680
681 #define ELF_CLASS       ELFCLASS64
682
683 #else
684
685 #define ELF_CLASS       ELFCLASS32
686
687 #endif
688
689 #define ELF_ARCH        EM_PPC
690
691 /* Feature masks for the Aux Vector Hardware Capabilities (AT_HWCAP).
692    See arch/powerpc/include/asm/cputable.h.  */
693 enum {
694     QEMU_PPC_FEATURE_32 = 0x80000000,
695     QEMU_PPC_FEATURE_64 = 0x40000000,
696     QEMU_PPC_FEATURE_601_INSTR = 0x20000000,
697     QEMU_PPC_FEATURE_HAS_ALTIVEC = 0x10000000,
698     QEMU_PPC_FEATURE_HAS_FPU = 0x08000000,
699     QEMU_PPC_FEATURE_HAS_MMU = 0x04000000,
700     QEMU_PPC_FEATURE_HAS_4xxMAC = 0x02000000,
701     QEMU_PPC_FEATURE_UNIFIED_CACHE = 0x01000000,
702     QEMU_PPC_FEATURE_HAS_SPE = 0x00800000,
703     QEMU_PPC_FEATURE_HAS_EFP_SINGLE = 0x00400000,
704     QEMU_PPC_FEATURE_HAS_EFP_DOUBLE = 0x00200000,
705     QEMU_PPC_FEATURE_NO_TB = 0x00100000,
706     QEMU_PPC_FEATURE_POWER4 = 0x00080000,
707     QEMU_PPC_FEATURE_POWER5 = 0x00040000,
708     QEMU_PPC_FEATURE_POWER5_PLUS = 0x00020000,
709     QEMU_PPC_FEATURE_CELL = 0x00010000,
710     QEMU_PPC_FEATURE_BOOKE = 0x00008000,
711     QEMU_PPC_FEATURE_SMT = 0x00004000,
712     QEMU_PPC_FEATURE_ICACHE_SNOOP = 0x00002000,
713     QEMU_PPC_FEATURE_ARCH_2_05 = 0x00001000,
714     QEMU_PPC_FEATURE_PA6T = 0x00000800,
715     QEMU_PPC_FEATURE_HAS_DFP = 0x00000400,
716     QEMU_PPC_FEATURE_POWER6_EXT = 0x00000200,
717     QEMU_PPC_FEATURE_ARCH_2_06 = 0x00000100,
718     QEMU_PPC_FEATURE_HAS_VSX = 0x00000080,
719     QEMU_PPC_FEATURE_PSERIES_PERFMON_COMPAT = 0x00000040,
720
721     QEMU_PPC_FEATURE_TRUE_LE = 0x00000002,
722     QEMU_PPC_FEATURE_PPC_LE = 0x00000001,
723
724     /* Feature definitions in AT_HWCAP2.  */
725     QEMU_PPC_FEATURE2_ARCH_2_07 = 0x80000000, /* ISA 2.07 */
726     QEMU_PPC_FEATURE2_HAS_HTM = 0x40000000, /* Hardware Transactional Memory */
727     QEMU_PPC_FEATURE2_HAS_DSCR = 0x20000000, /* Data Stream Control Register */
728     QEMU_PPC_FEATURE2_HAS_EBB = 0x10000000, /* Event Base Branching */
729     QEMU_PPC_FEATURE2_HAS_ISEL = 0x08000000, /* Integer Select */
730     QEMU_PPC_FEATURE2_HAS_TAR = 0x04000000, /* Target Address Register */
731 };
732
733 #define ELF_HWCAP get_elf_hwcap()
734
735 static uint32_t get_elf_hwcap(void)
736 {
737     PowerPCCPU *cpu = POWERPC_CPU(thread_cpu);
738     uint32_t features = 0;
739
740     /* We don't have to be terribly complete here; the high points are
741        Altivec/FP/SPE support.  Anything else is just a bonus.  */
742 #define GET_FEATURE(flag, feature)                                      \
743     do { if (cpu->env.insns_flags & flag) { features |= feature; } } while (0)
744 #define GET_FEATURE2(flags, feature) \
745     do { \
746         if ((cpu->env.insns_flags2 & flags) == flags) { \
747             features |= feature; \
748         } \
749     } while (0)
750     GET_FEATURE(PPC_64B, QEMU_PPC_FEATURE_64);
751     GET_FEATURE(PPC_FLOAT, QEMU_PPC_FEATURE_HAS_FPU);
752     GET_FEATURE(PPC_ALTIVEC, QEMU_PPC_FEATURE_HAS_ALTIVEC);
753     GET_FEATURE(PPC_SPE, QEMU_PPC_FEATURE_HAS_SPE);
754     GET_FEATURE(PPC_SPE_SINGLE, QEMU_PPC_FEATURE_HAS_EFP_SINGLE);
755     GET_FEATURE(PPC_SPE_DOUBLE, QEMU_PPC_FEATURE_HAS_EFP_DOUBLE);
756     GET_FEATURE(PPC_BOOKE, QEMU_PPC_FEATURE_BOOKE);
757     GET_FEATURE(PPC_405_MAC, QEMU_PPC_FEATURE_HAS_4xxMAC);
758     GET_FEATURE2(PPC2_DFP, QEMU_PPC_FEATURE_HAS_DFP);
759     GET_FEATURE2(PPC2_VSX, QEMU_PPC_FEATURE_HAS_VSX);
760     GET_FEATURE2((PPC2_PERM_ISA206 | PPC2_DIVE_ISA206 | PPC2_ATOMIC_ISA206 |
761                   PPC2_FP_CVT_ISA206 | PPC2_FP_TST_ISA206),
762                   QEMU_PPC_FEATURE_ARCH_2_06);
763 #undef GET_FEATURE
764 #undef GET_FEATURE2
765
766     return features;
767 }
768
769 #define ELF_HWCAP2 get_elf_hwcap2()
770
771 static uint32_t get_elf_hwcap2(void)
772 {
773     PowerPCCPU *cpu = POWERPC_CPU(thread_cpu);
774     uint32_t features = 0;
775
776 #define GET_FEATURE(flag, feature)                                      \
777     do { if (cpu->env.insns_flags & flag) { features |= feature; } } while (0)
778 #define GET_FEATURE2(flag, feature)                                      \
779     do { if (cpu->env.insns_flags2 & flag) { features |= feature; } } while (0)
780
781     GET_FEATURE(PPC_ISEL, QEMU_PPC_FEATURE2_HAS_ISEL);
782     GET_FEATURE2(PPC2_BCTAR_ISA207, QEMU_PPC_FEATURE2_HAS_TAR);
783     GET_FEATURE2((PPC2_BCTAR_ISA207 | PPC2_LSQ_ISA207 | PPC2_ALTIVEC_207 |
784                   PPC2_ISA207S), QEMU_PPC_FEATURE2_ARCH_2_07);
785
786 #undef GET_FEATURE
787 #undef GET_FEATURE2
788
789     return features;
790 }
791
792 /*
793  * The requirements here are:
794  * - keep the final alignment of sp (sp & 0xf)
795  * - make sure the 32-bit value at the first 16 byte aligned position of
796  *   AUXV is greater than 16 for glibc compatibility.
797  *   AT_IGNOREPPC is used for that.
798  * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
799  *   even if DLINFO_ARCH_ITEMS goes to zero or is undefined.
800  */
801 #define DLINFO_ARCH_ITEMS       5
802 #define ARCH_DLINFO                                     \
803     do {                                                \
804         PowerPCCPU *cpu = POWERPC_CPU(thread_cpu);              \
805         NEW_AUX_ENT(AT_DCACHEBSIZE, cpu->env.dcache_line_size); \
806         NEW_AUX_ENT(AT_ICACHEBSIZE, cpu->env.icache_line_size); \
807         NEW_AUX_ENT(AT_UCACHEBSIZE, 0);                 \
808         /*                                              \
809          * Now handle glibc compatibility.              \
810          */                                             \
811         NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC);        \
812         NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC);        \
813     } while (0)
814
815 static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)
816 {
817     _regs->gpr[1] = infop->start_stack;
818 #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
819     if (get_ppc64_abi(infop) < 2) {
820         uint64_t val;
821         get_user_u64(val, infop->entry + 8);
822         _regs->gpr[2] = val + infop->load_bias;
823         get_user_u64(val, infop->entry);
824         infop->entry = val + infop->load_bias;
825     } else {
826         _regs->gpr[12] = infop->entry;  /* r12 set to global entry address */
827     }
828 #endif
829     _regs->nip = infop->entry;
830 }
831
832 /* See linux kernel: arch/powerpc/include/asm/elf.h.  */
833 #define ELF_NREG 48
834 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
835
836 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUPPCState *env)
837 {
838     int i;
839     target_ulong ccr = 0;
840
841     for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
842         (*regs)[i] = tswapreg(env->gpr[i]);
843     }
844
845     (*regs)[32] = tswapreg(env->nip);
846     (*regs)[33] = tswapreg(env->msr);
847     (*regs)[35] = tswapreg(env->ctr);
848     (*regs)[36] = tswapreg(env->lr);
849     (*regs)[37] = tswapreg(env->xer);
850
851     for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
852         ccr |= env->crf[i] << (32 - ((i + 1) * 4));
853     }
854     (*regs)[38] = tswapreg(ccr);
855 }
856
857 #define USE_ELF_CORE_DUMP
858 #define ELF_EXEC_PAGESIZE       4096
859
860 #endif
861
862 #ifdef TARGET_MIPS
863
864 #define ELF_START_MMAP 0x80000000
865
866 #ifdef TARGET_MIPS64
867 #define ELF_CLASS   ELFCLASS64
868 #else
869 #define ELF_CLASS   ELFCLASS32
870 #endif
871 #define ELF_ARCH    EM_MIPS
872
873 static inline void init_thread(struct target_pt_regs *regs,
874                                struct image_info *infop)
875 {
876     regs->cp0_status = 2 << CP0St_KSU;
877     regs->cp0_epc = infop->entry;
878     regs->regs[29] = infop->start_stack;
879 }
880
881 /* See linux kernel: arch/mips/include/asm/elf.h.  */
882 #define ELF_NREG 45
883 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
884
885 /* See linux kernel: arch/mips/include/asm/reg.h.  */
886 enum {
887 #ifdef TARGET_MIPS64
888     TARGET_EF_R0 = 0,
889 #else
890     TARGET_EF_R0 = 6,
891 #endif
892     TARGET_EF_R26 = TARGET_EF_R0 + 26,
893     TARGET_EF_R27 = TARGET_EF_R0 + 27,
894     TARGET_EF_LO = TARGET_EF_R0 + 32,
895     TARGET_EF_HI = TARGET_EF_R0 + 33,
896     TARGET_EF_CP0_EPC = TARGET_EF_R0 + 34,
897     TARGET_EF_CP0_BADVADDR = TARGET_EF_R0 + 35,
898     TARGET_EF_CP0_STATUS = TARGET_EF_R0 + 36,
899     TARGET_EF_CP0_CAUSE = TARGET_EF_R0 + 37
900 };
901
902 /* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs.  */
903 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUMIPSState *env)
904 {
905     int i;
906
907     for (i = 0; i < TARGET_EF_R0; i++) {
908         (*regs)[i] = 0;
909     }
910     (*regs)[TARGET_EF_R0] = 0;
911
912     for (i = 1; i < ARRAY_SIZE(env->active_tc.gpr); i++) {
913         (*regs)[TARGET_EF_R0 + i] = tswapreg(env->active_tc.gpr[i]);
914     }
915
916     (*regs)[TARGET_EF_R26] = 0;
917     (*regs)[TARGET_EF_R27] = 0;
918     (*regs)[TARGET_EF_LO] = tswapreg(env->active_tc.LO[0]);
919     (*regs)[TARGET_EF_HI] = tswapreg(env->active_tc.HI[0]);
920     (*regs)[TARGET_EF_CP0_EPC] = tswapreg(env->active_tc.PC);
921     (*regs)[TARGET_EF_CP0_BADVADDR] = tswapreg(env->CP0_BadVAddr);
922     (*regs)[TARGET_EF_CP0_STATUS] = tswapreg(env->CP0_Status);
923     (*regs)[TARGET_EF_CP0_CAUSE] = tswapreg(env->CP0_Cause);
924 }
925
926 #define USE_ELF_CORE_DUMP
927 #define ELF_EXEC_PAGESIZE        4096
928
929 #endif /* TARGET_MIPS */
930
931 #ifdef TARGET_MICROBLAZE
932
933 #define ELF_START_MMAP 0x80000000
934
935 #define elf_check_arch(x) ( (x) == EM_MICROBLAZE || (x) == EM_MICROBLAZE_OLD)
936
937 #define ELF_CLASS   ELFCLASS32
938 #define ELF_ARCH    EM_MICROBLAZE
939
940 static inline void init_thread(struct target_pt_regs *regs,
941                                struct image_info *infop)
942 {
943     regs->pc = infop->entry;
944     regs->r1 = infop->start_stack;
945
946 }
947
948 #define ELF_EXEC_PAGESIZE        4096
949
950 #define USE_ELF_CORE_DUMP
951 #define ELF_NREG 38
952 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
953
954 /* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs.  */
955 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUMBState *env)
956 {
957     int i, pos = 0;
958
959     for (i = 0; i < 32; i++) {
960         (*regs)[pos++] = tswapreg(env->regs[i]);
961     }
962
963     for (i = 0; i < 6; i++) {
964         (*regs)[pos++] = tswapreg(env->sregs[i]);
965     }
966 }
967
968 #endif /* TARGET_MICROBLAZE */
969
970 #ifdef TARGET_NIOS2
971
972 #define ELF_START_MMAP 0x80000000
973
974 #define elf_check_arch(x) ((x) == EM_ALTERA_NIOS2)
975
976 #define ELF_CLASS   ELFCLASS32
977 #define ELF_ARCH    EM_ALTERA_NIOS2
978
979 static void init_thread(struct target_pt_regs *regs, struct image_info *infop)
980 {
981     regs->ea = infop->entry;
982     regs->sp = infop->start_stack;
983     regs->estatus = 0x3;
984 }
985
986 #define ELF_EXEC_PAGESIZE        4096
987
988 #define USE_ELF_CORE_DUMP
989 #define ELF_NREG 49
990 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
991
992 /* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs.  */
993 static void elf_core_copy_regs(target_elf_gregset_t *regs,
994                                const CPUNios2State *env)
995 {
996     int i;
997
998     (*regs)[0] = -1;
999     for (i = 1; i < 8; i++)    /* r0-r7 */
1000         (*regs)[i] = tswapreg(env->regs[i + 7]);
1001
1002     for (i = 8; i < 16; i++)   /* r8-r15 */
1003         (*regs)[i] = tswapreg(env->regs[i - 8]);
1004
1005     for (i = 16; i < 24; i++)  /* r16-r23 */
1006         (*regs)[i] = tswapreg(env->regs[i + 7]);
1007     (*regs)[24] = -1;    /* R_ET */
1008     (*regs)[25] = -1;    /* R_BT */
1009     (*regs)[26] = tswapreg(env->regs[R_GP]);
1010     (*regs)[27] = tswapreg(env->regs[R_SP]);
1011     (*regs)[28] = tswapreg(env->regs[R_FP]);
1012     (*regs)[29] = tswapreg(env->regs[R_EA]);
1013     (*regs)[30] = -1;    /* R_SSTATUS */
1014     (*regs)[31] = tswapreg(env->regs[R_RA]);
1015
1016     (*regs)[32] = tswapreg(env->regs[R_PC]);
1017
1018     (*regs)[33] = -1; /* R_STATUS */
1019     (*regs)[34] = tswapreg(env->regs[CR_ESTATUS]);
1020
1021     for (i = 35; i < 49; i++)    /* ... */
1022         (*regs)[i] = -1;
1023 }
1024
1025 #endif /* TARGET_NIOS2 */
1026
1027 #ifdef TARGET_OPENRISC
1028
1029 #define ELF_START_MMAP 0x08000000
1030
1031 #define ELF_ARCH EM_OPENRISC
1032 #define ELF_CLASS ELFCLASS32
1033 #define ELF_DATA  ELFDATA2MSB
1034
1035 static inline void init_thread(struct target_pt_regs *regs,
1036                                struct image_info *infop)
1037 {
1038     regs->pc = infop->entry;
1039     regs->gpr[1] = infop->start_stack;
1040 }
1041
1042 #define USE_ELF_CORE_DUMP
1043 #define ELF_EXEC_PAGESIZE 8192
1044
1045 /* See linux kernel arch/openrisc/include/asm/elf.h.  */
1046 #define ELF_NREG 34 /* gprs and pc, sr */
1047 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1048
1049 static void elf_core_copy_regs(target_elf_gregset_t *regs,
1050                                const CPUOpenRISCState *env)
1051 {
1052     int i;
1053
1054     for (i = 0; i < 32; i++) {
1055         (*regs)[i] = tswapreg(env->gpr[i]);
1056     }
1057
1058     (*regs)[32] = tswapreg(env->pc);
1059     (*regs)[33] = tswapreg(env->sr);
1060 }
1061 #define ELF_HWCAP 0
1062 #define ELF_PLATFORM NULL
1063
1064 #endif /* TARGET_OPENRISC */
1065
1066 #ifdef TARGET_SH4
1067
1068 #define ELF_START_MMAP 0x80000000
1069
1070 #define ELF_CLASS ELFCLASS32
1071 #define ELF_ARCH  EM_SH
1072
1073 static inline void init_thread(struct target_pt_regs *regs,
1074                                struct image_info *infop)
1075 {
1076     /* Check other registers XXXXX */
1077     regs->pc = infop->entry;
1078     regs->regs[15] = infop->start_stack;
1079 }
1080
1081 /* See linux kernel: arch/sh/include/asm/elf.h.  */
1082 #define ELF_NREG 23
1083 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1084
1085 /* See linux kernel: arch/sh/include/asm/ptrace.h.  */
1086 enum {
1087     TARGET_REG_PC = 16,
1088     TARGET_REG_PR = 17,
1089     TARGET_REG_SR = 18,
1090     TARGET_REG_GBR = 19,
1091     TARGET_REG_MACH = 20,
1092     TARGET_REG_MACL = 21,
1093     TARGET_REG_SYSCALL = 22
1094 };
1095
1096 static inline void elf_core_copy_regs(target_elf_gregset_t *regs,
1097                                       const CPUSH4State *env)
1098 {
1099     int i;
1100
1101     for (i = 0; i < 16; i++) {
1102         (*regs[i]) = tswapreg(env->gregs[i]);
1103     }
1104
1105     (*regs)[TARGET_REG_PC] = tswapreg(env->pc);
1106     (*regs)[TARGET_REG_PR] = tswapreg(env->pr);
1107     (*regs)[TARGET_REG_SR] = tswapreg(env->sr);
1108     (*regs)[TARGET_REG_GBR] = tswapreg(env->gbr);
1109     (*regs)[TARGET_REG_MACH] = tswapreg(env->mach);
1110     (*regs)[TARGET_REG_MACL] = tswapreg(env->macl);
1111     (*regs)[TARGET_REG_SYSCALL] = 0; /* FIXME */
1112 }
1113
1114 #define USE_ELF_CORE_DUMP
1115 #define ELF_EXEC_PAGESIZE        4096
1116
1117 enum {
1118     SH_CPU_HAS_FPU            = 0x0001, /* Hardware FPU support */
1119     SH_CPU_HAS_P2_FLUSH_BUG   = 0x0002, /* Need to flush the cache in P2 area */
1120     SH_CPU_HAS_MMU_PAGE_ASSOC = 0x0004, /* SH3: TLB way selection bit support */
1121     SH_CPU_HAS_DSP            = 0x0008, /* SH-DSP: DSP support */
1122     SH_CPU_HAS_PERF_COUNTER   = 0x0010, /* Hardware performance counters */
1123     SH_CPU_HAS_PTEA           = 0x0020, /* PTEA register */
1124     SH_CPU_HAS_LLSC           = 0x0040, /* movli.l/movco.l */
1125     SH_CPU_HAS_L2_CACHE       = 0x0080, /* Secondary cache / URAM */
1126     SH_CPU_HAS_OP32           = 0x0100, /* 32-bit instruction support */
1127     SH_CPU_HAS_PTEAEX         = 0x0200, /* PTE ASID Extension support */
1128 };
1129
1130 #define ELF_HWCAP get_elf_hwcap()
1131
1132 static uint32_t get_elf_hwcap(void)
1133 {
1134     SuperHCPU *cpu = SUPERH_CPU(thread_cpu);
1135     uint32_t hwcap = 0;
1136
1137     hwcap |= SH_CPU_HAS_FPU;
1138
1139     if (cpu->env.features & SH_FEATURE_SH4A) {
1140         hwcap |= SH_CPU_HAS_LLSC;
1141     }
1142
1143     return hwcap;
1144 }
1145
1146 #endif
1147
1148 #ifdef TARGET_CRIS
1149
1150 #define ELF_START_MMAP 0x80000000
1151
1152 #define ELF_CLASS ELFCLASS32
1153 #define ELF_ARCH  EM_CRIS
1154
1155 static inline void init_thread(struct target_pt_regs *regs,
1156                                struct image_info *infop)
1157 {
1158     regs->erp = infop->entry;
1159 }
1160
1161 #define ELF_EXEC_PAGESIZE        8192
1162
1163 #endif
1164
1165 #ifdef TARGET_M68K
1166
1167 #define ELF_START_MMAP 0x80000000
1168
1169 #define ELF_CLASS       ELFCLASS32
1170 #define ELF_ARCH        EM_68K
1171
1172 /* ??? Does this need to do anything?
1173    #define ELF_PLAT_INIT(_r) */
1174
1175 static inline void init_thread(struct target_pt_regs *regs,
1176                                struct image_info *infop)
1177 {
1178     regs->usp = infop->start_stack;
1179     regs->sr = 0;
1180     regs->pc = infop->entry;
1181 }
1182
1183 /* See linux kernel: arch/m68k/include/asm/elf.h.  */
1184 #define ELF_NREG 20
1185 typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
1186
1187 static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUM68KState *env)
1188 {
1189     (*regs)[0] = tswapreg(env->dregs[1]);
1190     (*regs)[1] = tswapreg(env->dregs[2]);
1191     (*regs)[2] = tswapreg(env->dregs[3]);
1192     (*regs)[3] = tswapreg(env->dregs[4]);
1193     (*regs)[4] = tswapreg(env->dregs[5]);
1194     (*regs)[5] = tswapreg(env->dregs[6]);
1195     (*regs)[6] = tswapreg(env->dregs[7]);
1196     (*regs)[7] = tswapreg(env->aregs[0]);
1197     (*regs)[8] = tswapreg(env->aregs[1]);
1198     (*regs)[9] = tswapreg(env->aregs[2]);
1199     (*regs)[10] = tswapreg(env->aregs[3]);
1200     (*regs)[11] = tswapreg(env->aregs[4]);
1201     (*regs)[12] = tswapreg(env->aregs[5]);
1202     (*regs)[13] = tswapreg(env->aregs[6]);
1203     (*regs)[14] = tswapreg(env->dregs[0]);
1204     (*regs)[15] = tswapreg(env->aregs[7]);
1205     (*regs)[16] = tswapreg(env->dregs[0]); /* FIXME: orig_d0 */
1206     (*regs)[17] = tswapreg(env->sr);
1207     (*regs)[18] = tswapreg(env->pc);
1208     (*regs)[19] = 0;  /* FIXME: regs->format | regs->vector */
1209 }
1210
1211 #define USE_ELF_CORE_DUMP
1212 #define ELF_EXEC_PAGESIZE       8192
1213
1214 #endif
1215
1216 #ifdef TARGET_ALPHA
1217
1218 #define ELF_START_MMAP (0x30000000000ULL)
1219
1220 #define ELF_CLASS      ELFCLASS64
1221 #define ELF_ARCH       EM_ALPHA
1222
1223 static inline void init_thread(struct target_pt_regs *regs,
1224                                struct image_info *infop)
1225 {
1226     regs->pc = infop->entry;
1227     regs->ps = 8;
1228     regs->usp = infop->start_stack;
1229 }
1230
1231 #define ELF_EXEC_PAGESIZE        8192
1232
1233 #endif /* TARGET_ALPHA */
1234
1235 #ifdef TARGET_S390X
1236
1237 #define ELF_START_MMAP (0x20000000000ULL)
1238
1239 #define ELF_CLASS       ELFCLASS64
1240 #define ELF_DATA        ELFDATA2MSB
1241 #define ELF_ARCH        EM_S390
1242
1243 static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
1244 {
1245     regs->psw.addr = infop->entry;
1246     regs->psw.mask = PSW_MASK_64 | PSW_MASK_32;
1247     regs->gprs[15] = infop->start_stack;
1248 }
1249
1250 #endif /* TARGET_S390X */
1251
1252 #ifdef TARGET_TILEGX
1253
1254 /* 42 bits real used address, a half for user mode */
1255 #define ELF_START_MMAP (0x00000020000000000ULL)
1256
1257 #define elf_check_arch(x) ((x) == EM_TILEGX)
1258
1259 #define ELF_CLASS   ELFCLASS64
1260 #define ELF_DATA    ELFDATA2LSB
1261 #define ELF_ARCH    EM_TILEGX
1262
1263 static inline void init_thread(struct target_pt_regs *regs,
1264                                struct image_info *infop)
1265 {
1266     regs->pc = infop->entry;
1267     regs->sp = infop->start_stack;
1268
1269 }
1270
1271 #define ELF_EXEC_PAGESIZE        65536 /* TILE-Gx page size is 64KB */
1272
1273 #endif /* TARGET_TILEGX */
1274
1275 #ifdef TARGET_HPPA
1276
1277 #define ELF_START_MMAP  0x80000000
1278 #define ELF_CLASS       ELFCLASS32
1279 #define ELF_ARCH        EM_PARISC
1280 #define ELF_PLATFORM    "PARISC"
1281 #define STACK_GROWS_DOWN 0
1282 #define STACK_ALIGNMENT  64
1283
1284 static inline void init_thread(struct target_pt_regs *regs,
1285                                struct image_info *infop)
1286 {
1287     regs->iaoq[0] = infop->entry;
1288     regs->iaoq[1] = infop->entry + 4;
1289     regs->gr[23] = 0;
1290     regs->gr[24] = infop->arg_start;
1291     regs->gr[25] = (infop->arg_end - infop->arg_start) / sizeof(abi_ulong);
1292     /* The top-of-stack contains a linkage buffer.  */
1293     regs->gr[30] = infop->start_stack + 64;
1294     regs->gr[31] = infop->entry;
1295 }
1296
1297 #endif /* TARGET_HPPA */
1298
1299 #ifndef ELF_PLATFORM
1300 #define ELF_PLATFORM (NULL)
1301 #endif
1302
1303 #ifndef ELF_MACHINE
1304 #define ELF_MACHINE ELF_ARCH
1305 #endif
1306
1307 #ifndef elf_check_arch
1308 #define elf_check_arch(x) ((x) == ELF_ARCH)
1309 #endif
1310
1311 #ifndef ELF_HWCAP
1312 #define ELF_HWCAP 0
1313 #endif
1314
1315 #ifndef STACK_GROWS_DOWN
1316 #define STACK_GROWS_DOWN 1
1317 #endif
1318
1319 #ifndef STACK_ALIGNMENT
1320 #define STACK_ALIGNMENT 16
1321 #endif
1322
1323 #ifdef TARGET_ABI32
1324 #undef ELF_CLASS
1325 #define ELF_CLASS ELFCLASS32
1326 #undef bswaptls
1327 #define bswaptls(ptr) bswap32s(ptr)
1328 #endif
1329
1330 #include "elf.h"
1331
1332 struct exec
1333 {
1334     unsigned int a_info;   /* Use macros N_MAGIC, etc for access */
1335     unsigned int a_text;   /* length of text, in bytes */
1336     unsigned int a_data;   /* length of data, in bytes */
1337     unsigned int a_bss;    /* length of uninitialized data area, in bytes */
1338     unsigned int a_syms;   /* length of symbol table data in file, in bytes */
1339     unsigned int a_entry;  /* start address */
1340     unsigned int a_trsize; /* length of relocation info for text, in bytes */
1341     unsigned int a_drsize; /* length of relocation info for data, in bytes */
1342 };
1343
1344
1345 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
1346 #define OMAGIC 0407
1347 #define NMAGIC 0410
1348 #define ZMAGIC 0413
1349 #define QMAGIC 0314
1350
1351 /* Necessary parameters */
1352 #define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
1353 #define TARGET_ELF_PAGESTART(_v) ((_v) & \
1354                                  ~(abi_ulong)(TARGET_ELF_EXEC_PAGESIZE-1))
1355 #define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))
1356
1357 #define DLINFO_ITEMS 14
1358
1359 static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)
1360 {
1361     memcpy(to, from, n);
1362 }
1363
1364 #ifdef BSWAP_NEEDED
1365 static void bswap_ehdr(struct elfhdr *ehdr)
1366 {
1367     bswap16s(&ehdr->e_type);            /* Object file type */
1368     bswap16s(&ehdr->e_machine);         /* Architecture */
1369     bswap32s(&ehdr->e_version);         /* Object file version */
1370     bswaptls(&ehdr->e_entry);           /* Entry point virtual address */
1371     bswaptls(&ehdr->e_phoff);           /* Program header table file offset */
1372     bswaptls(&ehdr->e_shoff);           /* Section header table file offset */
1373     bswap32s(&ehdr->e_flags);           /* Processor-specific flags */
1374     bswap16s(&ehdr->e_ehsize);          /* ELF header size in bytes */
1375     bswap16s(&ehdr->e_phentsize);       /* Program header table entry size */
1376     bswap16s(&ehdr->e_phnum);           /* Program header table entry count */
1377     bswap16s(&ehdr->e_shentsize);       /* Section header table entry size */
1378     bswap16s(&ehdr->e_shnum);           /* Section header table entry count */
1379     bswap16s(&ehdr->e_shstrndx);        /* Section header string table index */
1380 }
1381
1382 static void bswap_phdr(struct elf_phdr *phdr, int phnum)
1383 {
1384     int i;
1385     for (i = 0; i < phnum; ++i, ++phdr) {
1386         bswap32s(&phdr->p_type);        /* Segment type */
1387         bswap32s(&phdr->p_flags);       /* Segment flags */
1388         bswaptls(&phdr->p_offset);      /* Segment file offset */
1389         bswaptls(&phdr->p_vaddr);       /* Segment virtual address */
1390         bswaptls(&phdr->p_paddr);       /* Segment physical address */
1391         bswaptls(&phdr->p_filesz);      /* Segment size in file */
1392         bswaptls(&phdr->p_memsz);       /* Segment size in memory */
1393         bswaptls(&phdr->p_align);       /* Segment alignment */
1394     }
1395 }
1396
1397 static void bswap_shdr(struct elf_shdr *shdr, int shnum)
1398 {
1399     int i;
1400     for (i = 0; i < shnum; ++i, ++shdr) {
1401         bswap32s(&shdr->sh_name);
1402         bswap32s(&shdr->sh_type);
1403         bswaptls(&shdr->sh_flags);
1404         bswaptls(&shdr->sh_addr);
1405         bswaptls(&shdr->sh_offset);
1406         bswaptls(&shdr->sh_size);
1407         bswap32s(&shdr->sh_link);
1408         bswap32s(&shdr->sh_info);
1409         bswaptls(&shdr->sh_addralign);
1410         bswaptls(&shdr->sh_entsize);
1411     }
1412 }
1413
1414 static void bswap_sym(struct elf_sym *sym)
1415 {
1416     bswap32s(&sym->st_name);
1417     bswaptls(&sym->st_value);
1418     bswaptls(&sym->st_size);
1419     bswap16s(&sym->st_shndx);
1420 }
1421 #else
1422 static inline void bswap_ehdr(struct elfhdr *ehdr) { }
1423 static inline void bswap_phdr(struct elf_phdr *phdr, int phnum) { }
1424 static inline void bswap_shdr(struct elf_shdr *shdr, int shnum) { }
1425 static inline void bswap_sym(struct elf_sym *sym) { }
1426 #endif
1427
1428 #ifdef USE_ELF_CORE_DUMP
1429 static int elf_core_dump(int, const CPUArchState *);
1430 #endif /* USE_ELF_CORE_DUMP */
1431 static void load_symbols(struct elfhdr *hdr, int fd, abi_ulong load_bias);
1432
1433 /* Verify the portions of EHDR within E_IDENT for the target.
1434    This can be performed before bswapping the entire header.  */
1435 static bool elf_check_ident(struct elfhdr *ehdr)
1436 {
1437     return (ehdr->e_ident[EI_MAG0] == ELFMAG0
1438             && ehdr->e_ident[EI_MAG1] == ELFMAG1
1439             && ehdr->e_ident[EI_MAG2] == ELFMAG2
1440             && ehdr->e_ident[EI_MAG3] == ELFMAG3
1441             && ehdr->e_ident[EI_CLASS] == ELF_CLASS
1442             && ehdr->e_ident[EI_DATA] == ELF_DATA
1443             && ehdr->e_ident[EI_VERSION] == EV_CURRENT);
1444 }
1445
1446 /* Verify the portions of EHDR outside of E_IDENT for the target.
1447    This has to wait until after bswapping the header.  */
1448 static bool elf_check_ehdr(struct elfhdr *ehdr)
1449 {
1450     return (elf_check_arch(ehdr->e_machine)
1451             && ehdr->e_ehsize == sizeof(struct elfhdr)
1452             && ehdr->e_phentsize == sizeof(struct elf_phdr)
1453             && (ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN));
1454 }
1455
1456 /*
1457  * 'copy_elf_strings()' copies argument/envelope strings from user
1458  * memory to free pages in kernel mem. These are in a format ready
1459  * to be put directly into the top of new user memory.
1460  *
1461  */
1462 static abi_ulong copy_elf_strings(int argc, char **argv, char *scratch,
1463                                   abi_ulong p, abi_ulong stack_limit)
1464 {
1465     char *tmp;
1466     int len, i;
1467     abi_ulong top = p;
1468
1469     if (!p) {
1470         return 0;       /* bullet-proofing */
1471     }
1472
1473     if (STACK_GROWS_DOWN) {
1474         int offset = ((p - 1) % TARGET_PAGE_SIZE) + 1;
1475         for (i = argc - 1; i >= 0; --i) {
1476             tmp = argv[i];
1477             if (!tmp) {
1478                 fprintf(stderr, "VFS: argc is wrong");
1479                 exit(-1);
1480             }
1481             len = strlen(tmp) + 1;
1482             tmp += len;
1483
1484             if (len > (p - stack_limit)) {
1485                 return 0;
1486             }
1487             while (len) {
1488                 int bytes_to_copy = (len > offset) ? offset : len;
1489                 tmp -= bytes_to_copy;
1490                 p -= bytes_to_copy;
1491                 offset -= bytes_to_copy;
1492                 len -= bytes_to_copy;
1493
1494                 memcpy_fromfs(scratch + offset, tmp, bytes_to_copy);
1495
1496                 if (offset == 0) {
1497                     memcpy_to_target(p, scratch, top - p);
1498                     top = p;
1499                     offset = TARGET_PAGE_SIZE;
1500                 }
1501             }
1502         }
1503         if (p != top) {
1504             memcpy_to_target(p, scratch + offset, top - p);
1505         }
1506     } else {
1507         int remaining = TARGET_PAGE_SIZE - (p % TARGET_PAGE_SIZE);
1508         for (i = 0; i < argc; ++i) {
1509             tmp = argv[i];
1510             if (!tmp) {
1511                 fprintf(stderr, "VFS: argc is wrong");
1512                 exit(-1);
1513             }
1514             len = strlen(tmp) + 1;
1515             if (len > (stack_limit - p)) {
1516                 return 0;
1517             }
1518             while (len) {
1519                 int bytes_to_copy = (len > remaining) ? remaining : len;
1520
1521                 memcpy_fromfs(scratch + (p - top), tmp, bytes_to_copy);
1522
1523                 tmp += bytes_to_copy;
1524                 remaining -= bytes_to_copy;
1525                 p += bytes_to_copy;
1526                 len -= bytes_to_copy;
1527
1528                 if (remaining == 0) {
1529                     memcpy_to_target(top, scratch, p - top);
1530                     top = p;
1531                     remaining = TARGET_PAGE_SIZE;
1532                 }
1533             }
1534         }
1535         if (p != top) {
1536             memcpy_to_target(top, scratch, p - top);
1537         }
1538     }
1539
1540     return p;
1541 }
1542
1543 /* Older linux kernels provide up to MAX_ARG_PAGES (default: 32) of
1544  * argument/environment space. Newer kernels (>2.6.33) allow more,
1545  * dependent on stack size, but guarantee at least 32 pages for
1546  * backwards compatibility.
1547  */
1548 #define STACK_LOWER_LIMIT (32 * TARGET_PAGE_SIZE)
1549
1550 static abi_ulong setup_arg_pages(struct linux_binprm *bprm,
1551                                  struct image_info *info)
1552 {
1553     abi_ulong size, error, guard;
1554
1555     size = guest_stack_size;
1556     if (size < STACK_LOWER_LIMIT) {
1557         size = STACK_LOWER_LIMIT;
1558     }
1559     guard = TARGET_PAGE_SIZE;
1560     if (guard < qemu_real_host_page_size) {
1561         guard = qemu_real_host_page_size;
1562     }
1563
1564     error = target_mmap(0, size + guard, PROT_READ | PROT_WRITE,
1565                         MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
1566     if (error == -1) {
1567         perror("mmap stack");
1568         exit(-1);
1569     }
1570
1571     /* We reserve one extra page at the top of the stack as guard.  */
1572     if (STACK_GROWS_DOWN) {
1573         target_mprotect(error, guard, PROT_NONE);
1574         info->stack_limit = error + guard;
1575         return info->stack_limit + size - sizeof(void *);
1576     } else {
1577         target_mprotect(error + size, guard, PROT_NONE);
1578         info->stack_limit = error + size;
1579         return error;
1580     }
1581 }
1582
1583 /* Map and zero the bss.  We need to explicitly zero any fractional pages
1584    after the data section (i.e. bss).  */
1585 static void zero_bss(abi_ulong elf_bss, abi_ulong last_bss, int prot)
1586 {
1587     uintptr_t host_start, host_map_start, host_end;
1588
1589     last_bss = TARGET_PAGE_ALIGN(last_bss);
1590
1591     /* ??? There is confusion between qemu_real_host_page_size and
1592        qemu_host_page_size here and elsewhere in target_mmap, which
1593        may lead to the end of the data section mapping from the file
1594        not being mapped.  At least there was an explicit test and
1595        comment for that here, suggesting that "the file size must
1596        be known".  The comment probably pre-dates the introduction
1597        of the fstat system call in target_mmap which does in fact
1598        find out the size.  What isn't clear is if the workaround
1599        here is still actually needed.  For now, continue with it,
1600        but merge it with the "normal" mmap that would allocate the bss.  */
1601
1602     host_start = (uintptr_t) g2h(elf_bss);
1603     host_end = (uintptr_t) g2h(last_bss);
1604     host_map_start = REAL_HOST_PAGE_ALIGN(host_start);
1605
1606     if (host_map_start < host_end) {
1607         void *p = mmap((void *)host_map_start, host_end - host_map_start,
1608                        prot, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
1609         if (p == MAP_FAILED) {
1610             perror("cannot mmap brk");
1611             exit(-1);
1612         }
1613     }
1614
1615     /* Ensure that the bss page(s) are valid */
1616     if ((page_get_flags(last_bss-1) & prot) != prot) {
1617         page_set_flags(elf_bss & TARGET_PAGE_MASK, last_bss, prot | PAGE_VALID);
1618     }
1619
1620     if (host_start < host_map_start) {
1621         memset((void *)host_start, 0, host_map_start - host_start);
1622     }
1623 }
1624
1625 #ifdef CONFIG_USE_FDPIC
1626 static abi_ulong loader_build_fdpic_loadmap(struct image_info *info, abi_ulong sp)
1627 {
1628     uint16_t n;
1629     struct elf32_fdpic_loadseg *loadsegs = info->loadsegs;
1630
1631     /* elf32_fdpic_loadseg */
1632     n = info->nsegs;
1633     while (n--) {
1634         sp -= 12;
1635         put_user_u32(loadsegs[n].addr, sp+0);
1636         put_user_u32(loadsegs[n].p_vaddr, sp+4);
1637         put_user_u32(loadsegs[n].p_memsz, sp+8);
1638     }
1639
1640     /* elf32_fdpic_loadmap */
1641     sp -= 4;
1642     put_user_u16(0, sp+0); /* version */
1643     put_user_u16(info->nsegs, sp+2); /* nsegs */
1644
1645     info->personality = PER_LINUX_FDPIC;
1646     info->loadmap_addr = sp;
1647
1648     return sp;
1649 }
1650 #endif
1651
1652 static abi_ulong create_elf_tables(abi_ulong p, int argc, int envc,
1653                                    struct elfhdr *exec,
1654                                    struct image_info *info,
1655                                    struct image_info *interp_info)
1656 {
1657     abi_ulong sp;
1658     abi_ulong u_argc, u_argv, u_envp, u_auxv;
1659     int size;
1660     int i;
1661     abi_ulong u_rand_bytes;
1662     uint8_t k_rand_bytes[16];
1663     abi_ulong u_platform;
1664     const char *k_platform;
1665     const int n = sizeof(elf_addr_t);
1666
1667     sp = p;
1668
1669 #ifdef CONFIG_USE_FDPIC
1670     /* Needs to be before we load the env/argc/... */
1671     if (elf_is_fdpic(exec)) {
1672         /* Need 4 byte alignment for these structs */
1673         sp &= ~3;
1674         sp = loader_build_fdpic_loadmap(info, sp);
1675         info->other_info = interp_info;
1676         if (interp_info) {
1677             interp_info->other_info = info;
1678             sp = loader_build_fdpic_loadmap(interp_info, sp);
1679         }
1680     }
1681 #endif
1682
1683     u_platform = 0;
1684     k_platform = ELF_PLATFORM;
1685     if (k_platform) {
1686         size_t len = strlen(k_platform) + 1;
1687         if (STACK_GROWS_DOWN) {
1688             sp -= (len + n - 1) & ~(n - 1);
1689             u_platform = sp;
1690             /* FIXME - check return value of memcpy_to_target() for failure */
1691             memcpy_to_target(sp, k_platform, len);
1692         } else {
1693             memcpy_to_target(sp, k_platform, len);
1694             u_platform = sp;
1695             sp += len + 1;
1696         }
1697     }
1698
1699     /* Provide 16 byte alignment for the PRNG, and basic alignment for
1700      * the argv and envp pointers.
1701      */
1702     if (STACK_GROWS_DOWN) {
1703         sp = QEMU_ALIGN_DOWN(sp, 16);
1704     } else {
1705         sp = QEMU_ALIGN_UP(sp, 16);
1706     }
1707
1708     /*
1709      * Generate 16 random bytes for userspace PRNG seeding (not
1710      * cryptically secure but it's not the aim of QEMU).
1711      */
1712     for (i = 0; i < 16; i++) {
1713         k_rand_bytes[i] = rand();
1714     }
1715     if (STACK_GROWS_DOWN) {
1716         sp -= 16;
1717         u_rand_bytes = sp;
1718         /* FIXME - check return value of memcpy_to_target() for failure */
1719         memcpy_to_target(sp, k_rand_bytes, 16);
1720     } else {
1721         memcpy_to_target(sp, k_rand_bytes, 16);
1722         u_rand_bytes = sp;
1723         sp += 16;
1724     }
1725
1726     size = (DLINFO_ITEMS + 1) * 2;
1727     if (k_platform)
1728         size += 2;
1729 #ifdef DLINFO_ARCH_ITEMS
1730     size += DLINFO_ARCH_ITEMS * 2;
1731 #endif
1732 #ifdef ELF_HWCAP2
1733     size += 2;
1734 #endif
1735     size += envc + argc + 2;
1736     size += 1;  /* argc itself */
1737     size *= n;
1738
1739     /* Allocate space and finalize stack alignment for entry now.  */
1740     if (STACK_GROWS_DOWN) {
1741         u_argc = QEMU_ALIGN_DOWN(sp - size, STACK_ALIGNMENT);
1742         sp = u_argc;
1743     } else {
1744         u_argc = sp;
1745         sp = QEMU_ALIGN_UP(sp + size, STACK_ALIGNMENT);
1746     }
1747
1748     u_argv = u_argc + n;
1749     u_envp = u_argv + (argc + 1) * n;
1750     u_auxv = u_envp + (envc + 1) * n;
1751     info->saved_auxv = u_auxv;
1752     info->arg_start = u_argv;
1753     info->arg_end = u_argv + argc * n;
1754
1755     /* This is correct because Linux defines
1756      * elf_addr_t as Elf32_Off / Elf64_Off
1757      */
1758 #define NEW_AUX_ENT(id, val) do {               \
1759         put_user_ual(id, u_auxv);  u_auxv += n; \
1760         put_user_ual(val, u_auxv); u_auxv += n; \
1761     } while(0)
1762
1763     /* There must be exactly DLINFO_ITEMS entries here.  */
1764     NEW_AUX_ENT(AT_PHDR, (abi_ulong)(info->load_addr + exec->e_phoff));
1765     NEW_AUX_ENT(AT_PHENT, (abi_ulong)(sizeof (struct elf_phdr)));
1766     NEW_AUX_ENT(AT_PHNUM, (abi_ulong)(exec->e_phnum));
1767     NEW_AUX_ENT(AT_PAGESZ, (abi_ulong)(MAX(TARGET_PAGE_SIZE, getpagesize())));
1768     NEW_AUX_ENT(AT_BASE, (abi_ulong)(interp_info ? interp_info->load_addr : 0));
1769     NEW_AUX_ENT(AT_FLAGS, (abi_ulong)0);
1770     NEW_AUX_ENT(AT_ENTRY, info->entry);
1771     NEW_AUX_ENT(AT_UID, (abi_ulong) getuid());
1772     NEW_AUX_ENT(AT_EUID, (abi_ulong) geteuid());
1773     NEW_AUX_ENT(AT_GID, (abi_ulong) getgid());
1774     NEW_AUX_ENT(AT_EGID, (abi_ulong) getegid());
1775     NEW_AUX_ENT(AT_HWCAP, (abi_ulong) ELF_HWCAP);
1776     NEW_AUX_ENT(AT_CLKTCK, (abi_ulong) sysconf(_SC_CLK_TCK));
1777     NEW_AUX_ENT(AT_RANDOM, (abi_ulong) u_rand_bytes);
1778
1779 #ifdef ELF_HWCAP2
1780     NEW_AUX_ENT(AT_HWCAP2, (abi_ulong) ELF_HWCAP2);
1781 #endif
1782
1783     if (u_platform) {
1784         NEW_AUX_ENT(AT_PLATFORM, u_platform);
1785     }
1786 #ifdef ARCH_DLINFO
1787     /*
1788      * ARCH_DLINFO must come last so platform specific code can enforce
1789      * special alignment requirements on the AUXV if necessary (eg. PPC).
1790      */
1791     ARCH_DLINFO;
1792 #endif
1793     NEW_AUX_ENT (AT_NULL, 0);
1794 #undef NEW_AUX_ENT
1795
1796     info->auxv_len = u_argv - info->saved_auxv;
1797
1798     put_user_ual(argc, u_argc);
1799
1800     p = info->arg_strings;
1801     for (i = 0; i < argc; ++i) {
1802         put_user_ual(p, u_argv);
1803         u_argv += n;
1804         p += target_strlen(p) + 1;
1805     }
1806     put_user_ual(0, u_argv);
1807
1808     p = info->env_strings;
1809     for (i = 0; i < envc; ++i) {
1810         put_user_ual(p, u_envp);
1811         u_envp += n;
1812         p += target_strlen(p) + 1;
1813     }
1814     put_user_ual(0, u_envp);
1815
1816     return sp;
1817 }
1818
1819 #ifndef TARGET_HAS_VALIDATE_GUEST_SPACE
1820 /* If the guest doesn't have a validation function just agree */
1821 static int validate_guest_space(unsigned long guest_base,
1822                                 unsigned long guest_size)
1823 {
1824     return 1;
1825 }
1826 #endif
1827
1828 unsigned long init_guest_space(unsigned long host_start,
1829                                unsigned long host_size,
1830                                unsigned long guest_start,
1831                                bool fixed)
1832 {
1833     unsigned long current_start, real_start;
1834     int flags;
1835
1836     assert(host_start || host_size);
1837
1838     /* If just a starting address is given, then just verify that
1839      * address.  */
1840     if (host_start && !host_size) {
1841         if (validate_guest_space(host_start, host_size) == 1) {
1842             return host_start;
1843         } else {
1844             return (unsigned long)-1;
1845         }
1846     }
1847
1848     /* Setup the initial flags and start address.  */
1849     current_start = host_start & qemu_host_page_mask;
1850     flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE;
1851     if (fixed) {
1852         flags |= MAP_FIXED;
1853     }
1854
1855     /* Otherwise, a non-zero size region of memory needs to be mapped
1856      * and validated.  */
1857     while (1) {
1858         unsigned long real_size = host_size;
1859
1860         /* Do not use mmap_find_vma here because that is limited to the
1861          * guest address space.  We are going to make the
1862          * guest address space fit whatever we're given.
1863          */
1864         real_start = (unsigned long)
1865             mmap((void *)current_start, host_size, PROT_NONE, flags, -1, 0);
1866         if (real_start == (unsigned long)-1) {
1867             return (unsigned long)-1;
1868         }
1869
1870         /* Ensure the address is properly aligned.  */
1871         if (real_start & ~qemu_host_page_mask) {
1872             munmap((void *)real_start, host_size);
1873             real_size = host_size + qemu_host_page_size;
1874             real_start = (unsigned long)
1875                 mmap((void *)real_start, real_size, PROT_NONE, flags, -1, 0);
1876             if (real_start == (unsigned long)-1) {
1877                 return (unsigned long)-1;
1878             }
1879             real_start = HOST_PAGE_ALIGN(real_start);
1880         }
1881
1882         /* Check to see if the address is valid.  */
1883         if (!host_start || real_start == current_start) {
1884             int valid = validate_guest_space(real_start - guest_start,
1885                                              real_size);
1886             if (valid == 1) {
1887                 break;
1888             } else if (valid == -1) {
1889                 return (unsigned long)-1;
1890             }
1891             /* valid == 0, so try again. */
1892         }
1893
1894         /* That address didn't work.  Unmap and try a different one.
1895          * The address the host picked because is typically right at
1896          * the top of the host address space and leaves the guest with
1897          * no usable address space.  Resort to a linear search.  We
1898          * already compensated for mmap_min_addr, so this should not
1899          * happen often.  Probably means we got unlucky and host
1900          * address space randomization put a shared library somewhere
1901          * inconvenient.
1902          */
1903         munmap((void *)real_start, host_size);
1904         current_start += qemu_host_page_size;
1905         if (host_start == current_start) {
1906             /* Theoretically possible if host doesn't have any suitably
1907              * aligned areas.  Normally the first mmap will fail.
1908              */
1909             return (unsigned long)-1;
1910         }
1911     }
1912
1913     qemu_log_mask(CPU_LOG_PAGE, "Reserved 0x%lx bytes of guest address space\n", host_size);
1914
1915     return real_start;
1916 }
1917
1918 static void probe_guest_base(const char *image_name,
1919                              abi_ulong loaddr, abi_ulong hiaddr)
1920 {
1921     /* Probe for a suitable guest base address, if the user has not set
1922      * it explicitly, and set guest_base appropriately.
1923      * In case of error we will print a suitable message and exit.
1924      */
1925     const char *errmsg;
1926     if (!have_guest_base && !reserved_va) {
1927         unsigned long host_start, real_start, host_size;
1928
1929         /* Round addresses to page boundaries.  */
1930         loaddr &= qemu_host_page_mask;
1931         hiaddr = HOST_PAGE_ALIGN(hiaddr);
1932
1933         if (loaddr < mmap_min_addr) {
1934             host_start = HOST_PAGE_ALIGN(mmap_min_addr);
1935         } else {
1936             host_start = loaddr;
1937             if (host_start != loaddr) {
1938                 errmsg = "Address overflow loading ELF binary";
1939                 goto exit_errmsg;
1940             }
1941         }
1942         host_size = hiaddr - loaddr;
1943
1944         /* Setup the initial guest memory space with ranges gleaned from
1945          * the ELF image that is being loaded.
1946          */
1947         real_start = init_guest_space(host_start, host_size, loaddr, false);
1948         if (real_start == (unsigned long)-1) {
1949             errmsg = "Unable to find space for application";
1950             goto exit_errmsg;
1951         }
1952         guest_base = real_start - loaddr;
1953
1954         qemu_log_mask(CPU_LOG_PAGE, "Relocating guest address space from 0x"
1955                       TARGET_ABI_FMT_lx " to 0x%lx\n",
1956                       loaddr, real_start);
1957     }
1958     return;
1959
1960 exit_errmsg:
1961     fprintf(stderr, "%s: %s\n", image_name, errmsg);
1962     exit(-1);
1963 }
1964
1965
1966 /* Load an ELF image into the address space.
1967
1968    IMAGE_NAME is the filename of the image, to use in error messages.
1969    IMAGE_FD is the open file descriptor for the image.
1970
1971    BPRM_BUF is a copy of the beginning of the file; this of course
1972    contains the elf file header at offset 0.  It is assumed that this
1973    buffer is sufficiently aligned to present no problems to the host
1974    in accessing data at aligned offsets within the buffer.
1975
1976    On return: INFO values will be filled in, as necessary or available.  */
1977
1978 static void load_elf_image(const char *image_name, int image_fd,
1979                            struct image_info *info, char **pinterp_name,
1980                            char bprm_buf[BPRM_BUF_SIZE])
1981 {
1982     struct elfhdr *ehdr = (struct elfhdr *)bprm_buf;
1983     struct elf_phdr *phdr;
1984     abi_ulong load_addr, load_bias, loaddr, hiaddr, error;
1985     int i, retval;
1986     const char *errmsg;
1987
1988     /* First of all, some simple consistency checks */
1989     errmsg = "Invalid ELF image for this architecture";
1990     if (!elf_check_ident(ehdr)) {
1991         goto exit_errmsg;
1992     }
1993     bswap_ehdr(ehdr);
1994     if (!elf_check_ehdr(ehdr)) {
1995         goto exit_errmsg;
1996     }
1997
1998     i = ehdr->e_phnum * sizeof(struct elf_phdr);
1999     if (ehdr->e_phoff + i <= BPRM_BUF_SIZE) {
2000         phdr = (struct elf_phdr *)(bprm_buf + ehdr->e_phoff);
2001     } else {
2002         phdr = (struct elf_phdr *) alloca(i);
2003         retval = pread(image_fd, phdr, i, ehdr->e_phoff);
2004         if (retval != i) {
2005             goto exit_read;
2006         }
2007     }
2008     bswap_phdr(phdr, ehdr->e_phnum);
2009
2010 #ifdef CONFIG_USE_FDPIC
2011     info->nsegs = 0;
2012     info->pt_dynamic_addr = 0;
2013 #endif
2014
2015     mmap_lock();
2016
2017     /* Find the maximum size of the image and allocate an appropriate
2018        amount of memory to handle that.  */
2019     loaddr = -1, hiaddr = 0;
2020     for (i = 0; i < ehdr->e_phnum; ++i) {
2021         if (phdr[i].p_type == PT_LOAD) {
2022             abi_ulong a = phdr[i].p_vaddr - phdr[i].p_offset;
2023             if (a < loaddr) {
2024                 loaddr = a;
2025             }
2026             a = phdr[i].p_vaddr + phdr[i].p_memsz;
2027             if (a > hiaddr) {
2028                 hiaddr = a;
2029             }
2030 #ifdef CONFIG_USE_FDPIC
2031             ++info->nsegs;
2032 #endif
2033         }
2034     }
2035
2036     load_addr = loaddr;
2037     if (ehdr->e_type == ET_DYN) {
2038         /* The image indicates that it can be loaded anywhere.  Find a
2039            location that can hold the memory space required.  If the
2040            image is pre-linked, LOADDR will be non-zero.  Since we do
2041            not supply MAP_FIXED here we'll use that address if and
2042            only if it remains available.  */
2043         load_addr = target_mmap(loaddr, hiaddr - loaddr, PROT_NONE,
2044                                 MAP_PRIVATE | MAP_ANON | MAP_NORESERVE,
2045                                 -1, 0);
2046         if (load_addr == -1) {
2047             goto exit_perror;
2048         }
2049     } else if (pinterp_name != NULL) {
2050         /* This is the main executable.  Make sure that the low
2051            address does not conflict with MMAP_MIN_ADDR or the
2052            QEMU application itself.  */
2053         probe_guest_base(image_name, loaddr, hiaddr);
2054     }
2055     load_bias = load_addr - loaddr;
2056
2057 #ifdef CONFIG_USE_FDPIC
2058     {
2059         struct elf32_fdpic_loadseg *loadsegs = info->loadsegs =
2060             g_malloc(sizeof(*loadsegs) * info->nsegs);
2061
2062         for (i = 0; i < ehdr->e_phnum; ++i) {
2063             switch (phdr[i].p_type) {
2064             case PT_DYNAMIC:
2065                 info->pt_dynamic_addr = phdr[i].p_vaddr + load_bias;
2066                 break;
2067             case PT_LOAD:
2068                 loadsegs->addr = phdr[i].p_vaddr + load_bias;
2069                 loadsegs->p_vaddr = phdr[i].p_vaddr;
2070                 loadsegs->p_memsz = phdr[i].p_memsz;
2071                 ++loadsegs;
2072                 break;
2073             }
2074         }
2075     }
2076 #endif
2077
2078     info->load_bias = load_bias;
2079     info->load_addr = load_addr;
2080     info->entry = ehdr->e_entry + load_bias;
2081     info->start_code = -1;
2082     info->end_code = 0;
2083     info->start_data = -1;
2084     info->end_data = 0;
2085     info->brk = 0;
2086     info->elf_flags = ehdr->e_flags;
2087
2088     for (i = 0; i < ehdr->e_phnum; i++) {
2089         struct elf_phdr *eppnt = phdr + i;
2090         if (eppnt->p_type == PT_LOAD) {
2091             abi_ulong vaddr, vaddr_po, vaddr_ps, vaddr_ef, vaddr_em;
2092             int elf_prot = 0;
2093
2094             if (eppnt->p_flags & PF_R) elf_prot =  PROT_READ;
2095             if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
2096             if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
2097
2098             vaddr = load_bias + eppnt->p_vaddr;
2099             vaddr_po = TARGET_ELF_PAGEOFFSET(vaddr);
2100             vaddr_ps = TARGET_ELF_PAGESTART(vaddr);
2101
2102             error = target_mmap(vaddr_ps, eppnt->p_filesz + vaddr_po,
2103                                 elf_prot, MAP_PRIVATE | MAP_FIXED,
2104                                 image_fd, eppnt->p_offset - vaddr_po);
2105             if (error == -1) {
2106                 goto exit_perror;
2107             }
2108
2109             vaddr_ef = vaddr + eppnt->p_filesz;
2110             vaddr_em = vaddr + eppnt->p_memsz;
2111
2112             /* If the load segment requests extra zeros (e.g. bss), map it.  */
2113             if (vaddr_ef < vaddr_em) {
2114                 zero_bss(vaddr_ef, vaddr_em, elf_prot);
2115             }
2116
2117             /* Find the full program boundaries.  */
2118             if (elf_prot & PROT_EXEC) {
2119                 if (vaddr < info->start_code) {
2120                     info->start_code = vaddr;
2121                 }
2122                 if (vaddr_ef > info->end_code) {
2123                     info->end_code = vaddr_ef;
2124                 }
2125             }
2126             if (elf_prot & PROT_WRITE) {
2127                 if (vaddr < info->start_data) {
2128                     info->start_data = vaddr;
2129                 }
2130                 if (vaddr_ef > info->end_data) {
2131                     info->end_data = vaddr_ef;
2132                 }
2133                 if (vaddr_em > info->brk) {
2134                     info->brk = vaddr_em;
2135                 }
2136             }
2137         } else if (eppnt->p_type == PT_INTERP && pinterp_name) {
2138             char *interp_name;
2139
2140             if (*pinterp_name) {
2141                 errmsg = "Multiple PT_INTERP entries";
2142                 goto exit_errmsg;
2143             }
2144             interp_name = malloc(eppnt->p_filesz);
2145             if (!interp_name) {
2146                 goto exit_perror;
2147             }
2148
2149             if (eppnt->p_offset + eppnt->p_filesz <= BPRM_BUF_SIZE) {
2150                 memcpy(interp_name, bprm_buf + eppnt->p_offset,
2151                        eppnt->p_filesz);
2152             } else {
2153                 retval = pread(image_fd, interp_name, eppnt->p_filesz,
2154                                eppnt->p_offset);
2155                 if (retval != eppnt->p_filesz) {
2156                     goto exit_perror;
2157                 }
2158             }
2159             if (interp_name[eppnt->p_filesz - 1] != 0) {
2160                 errmsg = "Invalid PT_INTERP entry";
2161                 goto exit_errmsg;
2162             }
2163             *pinterp_name = interp_name;
2164         }
2165     }
2166
2167     if (info->end_data == 0) {
2168         info->start_data = info->end_code;
2169         info->end_data = info->end_code;
2170         info->brk = info->end_code;
2171     }
2172
2173     if (qemu_log_enabled()) {
2174         load_symbols(ehdr, image_fd, load_bias);
2175     }
2176
2177     mmap_unlock();
2178
2179     close(image_fd);
2180     return;
2181
2182  exit_read:
2183     if (retval >= 0) {
2184         errmsg = "Incomplete read of file header";
2185         goto exit_errmsg;
2186     }
2187  exit_perror:
2188     errmsg = strerror(errno);
2189  exit_errmsg:
2190     fprintf(stderr, "%s: %s\n", image_name, errmsg);
2191     exit(-1);
2192 }
2193
2194 static void load_elf_interp(const char *filename, struct image_info *info,
2195                             char bprm_buf[BPRM_BUF_SIZE])
2196 {
2197     int fd, retval;
2198
2199     fd = open(path(filename), O_RDONLY);
2200     if (fd < 0) {
2201         goto exit_perror;
2202     }
2203
2204     retval = read(fd, bprm_buf, BPRM_BUF_SIZE);
2205     if (retval < 0) {
2206         goto exit_perror;
2207     }
2208     if (retval < BPRM_BUF_SIZE) {
2209         memset(bprm_buf + retval, 0, BPRM_BUF_SIZE - retval);
2210     }
2211
2212     load_elf_image(filename, fd, info, NULL, bprm_buf);
2213     return;
2214
2215  exit_perror:
2216     fprintf(stderr, "%s: %s\n", filename, strerror(errno));
2217     exit(-1);
2218 }
2219
2220 static int symfind(const void *s0, const void *s1)
2221 {
2222     target_ulong addr = *(target_ulong *)s0;
2223     struct elf_sym *sym = (struct elf_sym *)s1;
2224     int result = 0;
2225     if (addr < sym->st_value) {
2226         result = -1;
2227     } else if (addr >= sym->st_value + sym->st_size) {
2228         result = 1;
2229     }
2230     return result;
2231 }
2232
2233 static const char *lookup_symbolxx(struct syminfo *s, target_ulong orig_addr)
2234 {
2235 #if ELF_CLASS == ELFCLASS32
2236     struct elf_sym *syms = s->disas_symtab.elf32;
2237 #else
2238     struct elf_sym *syms = s->disas_symtab.elf64;
2239 #endif
2240
2241     // binary search
2242     struct elf_sym *sym;
2243
2244     sym = bsearch(&orig_addr, syms, s->disas_num_syms, sizeof(*syms), symfind);
2245     if (sym != NULL) {
2246         return s->disas_strtab + sym->st_name;
2247     }
2248
2249     return "";
2250 }
2251
2252 /* FIXME: This should use elf_ops.h  */
2253 static int symcmp(const void *s0, const void *s1)
2254 {
2255     struct elf_sym *sym0 = (struct elf_sym *)s0;
2256     struct elf_sym *sym1 = (struct elf_sym *)s1;
2257     return (sym0->st_value < sym1->st_value)
2258         ? -1
2259         : ((sym0->st_value > sym1->st_value) ? 1 : 0);
2260 }
2261
2262 /* Best attempt to load symbols from this ELF object. */
2263 static void load_symbols(struct elfhdr *hdr, int fd, abi_ulong load_bias)
2264 {
2265     int i, shnum, nsyms, sym_idx = 0, str_idx = 0;
2266     struct elf_shdr *shdr;
2267     char *strings = NULL;
2268     struct syminfo *s = NULL;
2269     struct elf_sym *new_syms, *syms = NULL;
2270
2271     shnum = hdr->e_shnum;
2272     i = shnum * sizeof(struct elf_shdr);
2273     shdr = (struct elf_shdr *)alloca(i);
2274     if (pread(fd, shdr, i, hdr->e_shoff) != i) {
2275         return;
2276     }
2277
2278     bswap_shdr(shdr, shnum);
2279     for (i = 0; i < shnum; ++i) {
2280         if (shdr[i].sh_type == SHT_SYMTAB) {
2281             sym_idx = i;
2282             str_idx = shdr[i].sh_link;
2283             goto found;
2284         }
2285     }
2286
2287     /* There will be no symbol table if the file was stripped.  */
2288     return;
2289
2290  found:
2291     /* Now know where the strtab and symtab are.  Snarf them.  */
2292     s = g_try_new(struct syminfo, 1);
2293     if (!s) {
2294         goto give_up;
2295     }
2296
2297     i = shdr[str_idx].sh_size;
2298     s->disas_strtab = strings = g_try_malloc(i);
2299     if (!strings || pread(fd, strings, i, shdr[str_idx].sh_offset) != i) {
2300         goto give_up;
2301     }
2302
2303     i = shdr[sym_idx].sh_size;
2304     syms = g_try_malloc(i);
2305     if (!syms || pread(fd, syms, i, shdr[sym_idx].sh_offset) != i) {
2306         goto give_up;
2307     }
2308
2309     nsyms = i / sizeof(struct elf_sym);
2310     for (i = 0; i < nsyms; ) {
2311         bswap_sym(syms + i);
2312         /* Throw away entries which we do not need.  */
2313         if (syms[i].st_shndx == SHN_UNDEF
2314             || syms[i].st_shndx >= SHN_LORESERVE
2315             || ELF_ST_TYPE(syms[i].st_info) != STT_FUNC) {
2316             if (i < --nsyms) {
2317                 syms[i] = syms[nsyms];
2318             }
2319         } else {
2320 #if defined(TARGET_ARM) || defined (TARGET_MIPS)
2321             /* The bottom address bit marks a Thumb or MIPS16 symbol.  */
2322             syms[i].st_value &= ~(target_ulong)1;
2323 #endif
2324             syms[i].st_value += load_bias;
2325             i++;
2326         }
2327     }
2328
2329     /* No "useful" symbol.  */
2330     if (nsyms == 0) {
2331         goto give_up;
2332     }
2333
2334     /* Attempt to free the storage associated with the local symbols
2335        that we threw away.  Whether or not this has any effect on the
2336        memory allocation depends on the malloc implementation and how
2337        many symbols we managed to discard.  */
2338     new_syms = g_try_renew(struct elf_sym, syms, nsyms);
2339     if (new_syms == NULL) {
2340         goto give_up;
2341     }
2342     syms = new_syms;
2343
2344     qsort(syms, nsyms, sizeof(*syms), symcmp);
2345
2346     s->disas_num_syms = nsyms;
2347 #if ELF_CLASS == ELFCLASS32
2348     s->disas_symtab.elf32 = syms;
2349 #else
2350     s->disas_symtab.elf64 = syms;
2351 #endif
2352     s->lookup_symbol = lookup_symbolxx;
2353     s->next = syminfos;
2354     syminfos = s;
2355
2356     return;
2357
2358 give_up:
2359     g_free(s);
2360     g_free(strings);
2361     g_free(syms);
2362 }
2363
2364 int load_elf_binary(struct linux_binprm *bprm, struct image_info *info)
2365 {
2366     struct image_info interp_info;
2367     struct elfhdr elf_ex;
2368     char *elf_interpreter = NULL;
2369     char *scratch;
2370
2371     info->start_mmap = (abi_ulong)ELF_START_MMAP;
2372
2373     load_elf_image(bprm->filename, bprm->fd, info,
2374                    &elf_interpreter, bprm->buf);
2375
2376     /* ??? We need a copy of the elf header for passing to create_elf_tables.
2377        If we do nothing, we'll have overwritten this when we re-use bprm->buf
2378        when we load the interpreter.  */
2379     elf_ex = *(struct elfhdr *)bprm->buf;
2380
2381     /* Do this so that we can load the interpreter, if need be.  We will
2382        change some of these later */
2383     bprm->p = setup_arg_pages(bprm, info);
2384
2385     scratch = g_new0(char, TARGET_PAGE_SIZE);
2386     if (STACK_GROWS_DOWN) {
2387         bprm->p = copy_elf_strings(1, &bprm->filename, scratch,
2388                                    bprm->p, info->stack_limit);
2389         info->file_string = bprm->p;
2390         bprm->p = copy_elf_strings(bprm->envc, bprm->envp, scratch,
2391                                    bprm->p, info->stack_limit);
2392         info->env_strings = bprm->p;
2393         bprm->p = copy_elf_strings(bprm->argc, bprm->argv, scratch,
2394                                    bprm->p, info->stack_limit);
2395         info->arg_strings = bprm->p;
2396     } else {
2397         info->arg_strings = bprm->p;
2398         bprm->p = copy_elf_strings(bprm->argc, bprm->argv, scratch,
2399                                    bprm->p, info->stack_limit);
2400         info->env_strings = bprm->p;
2401         bprm->p = copy_elf_strings(bprm->envc, bprm->envp, scratch,
2402                                    bprm->p, info->stack_limit);
2403         info->file_string = bprm->p;
2404         bprm->p = copy_elf_strings(1, &bprm->filename, scratch,
2405                                    bprm->p, info->stack_limit);
2406     }
2407
2408     g_free(scratch);
2409
2410     if (!bprm->p) {
2411         fprintf(stderr, "%s: %s\n", bprm->filename, strerror(E2BIG));
2412         exit(-1);
2413     }
2414
2415     if (elf_interpreter) {
2416         load_elf_interp(elf_interpreter, &interp_info, bprm->buf);
2417
2418         /* If the program interpreter is one of these two, then assume
2419            an iBCS2 image.  Otherwise assume a native linux image.  */
2420
2421         if (strcmp(elf_interpreter, "/usr/lib/libc.so.1") == 0
2422             || strcmp(elf_interpreter, "/usr/lib/ld.so.1") == 0) {
2423             info->personality = PER_SVR4;
2424
2425             /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
2426                and some applications "depend" upon this behavior.  Since
2427                we do not have the power to recompile these, we emulate
2428                the SVr4 behavior.  Sigh.  */
2429             target_mmap(0, qemu_host_page_size, PROT_READ | PROT_EXEC,
2430                         MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
2431         }
2432     }
2433
2434     bprm->p = create_elf_tables(bprm->p, bprm->argc, bprm->envc, &elf_ex,
2435                                 info, (elf_interpreter ? &interp_info : NULL));
2436     info->start_stack = bprm->p;
2437
2438     /* If we have an interpreter, set that as the program's entry point.
2439        Copy the load_bias as well, to help PPC64 interpret the entry
2440        point as a function descriptor.  Do this after creating elf tables
2441        so that we copy the original program entry point into the AUXV.  */
2442     if (elf_interpreter) {
2443         info->load_bias = interp_info.load_bias;
2444         info->entry = interp_info.entry;
2445         free(elf_interpreter);
2446     }
2447
2448 #ifdef USE_ELF_CORE_DUMP
2449     bprm->core_dump = &elf_core_dump;
2450 #endif
2451
2452     return 0;
2453 }
2454
2455 #ifdef USE_ELF_CORE_DUMP
2456 /*
2457  * Definitions to generate Intel SVR4-like core files.
2458  * These mostly have the same names as the SVR4 types with "target_elf_"
2459  * tacked on the front to prevent clashes with linux definitions,
2460  * and the typedef forms have been avoided.  This is mostly like
2461  * the SVR4 structure, but more Linuxy, with things that Linux does
2462  * not support and which gdb doesn't really use excluded.
2463  *
2464  * Fields we don't dump (their contents is zero) in linux-user qemu
2465  * are marked with XXX.
2466  *
2467  * Core dump code is copied from linux kernel (fs/binfmt_elf.c).
2468  *
2469  * Porting ELF coredump for target is (quite) simple process.  First you
2470  * define USE_ELF_CORE_DUMP in target ELF code (where init_thread() for
2471  * the target resides):
2472  *
2473  * #define USE_ELF_CORE_DUMP
2474  *
2475  * Next you define type of register set used for dumping.  ELF specification
2476  * says that it needs to be array of elf_greg_t that has size of ELF_NREG.
2477  *
2478  * typedef <target_regtype> target_elf_greg_t;
2479  * #define ELF_NREG <number of registers>
2480  * typedef taret_elf_greg_t target_elf_gregset_t[ELF_NREG];
2481  *
2482  * Last step is to implement target specific function that copies registers
2483  * from given cpu into just specified register set.  Prototype is:
2484  *
2485  * static void elf_core_copy_regs(taret_elf_gregset_t *regs,
2486  *                                const CPUArchState *env);
2487  *
2488  * Parameters:
2489  *     regs - copy register values into here (allocated and zeroed by caller)
2490  *     env - copy registers from here
2491  *
2492  * Example for ARM target is provided in this file.
2493  */
2494
2495 /* An ELF note in memory */
2496 struct memelfnote {
2497     const char *name;
2498     size_t     namesz;
2499     size_t     namesz_rounded;
2500     int        type;
2501     size_t     datasz;
2502     size_t     datasz_rounded;
2503     void       *data;
2504     size_t     notesz;
2505 };
2506
2507 struct target_elf_siginfo {
2508     abi_int    si_signo; /* signal number */
2509     abi_int    si_code;  /* extra code */
2510     abi_int    si_errno; /* errno */
2511 };
2512
2513 struct target_elf_prstatus {
2514     struct target_elf_siginfo pr_info;      /* Info associated with signal */
2515     abi_short          pr_cursig;    /* Current signal */
2516     abi_ulong          pr_sigpend;   /* XXX */
2517     abi_ulong          pr_sighold;   /* XXX */
2518     target_pid_t       pr_pid;
2519     target_pid_t       pr_ppid;
2520     target_pid_t       pr_pgrp;
2521     target_pid_t       pr_sid;
2522     struct target_timeval pr_utime;  /* XXX User time */
2523     struct target_timeval pr_stime;  /* XXX System time */
2524     struct target_timeval pr_cutime; /* XXX Cumulative user time */
2525     struct target_timeval pr_cstime; /* XXX Cumulative system time */
2526     target_elf_gregset_t      pr_reg;       /* GP registers */
2527     abi_int            pr_fpvalid;   /* XXX */
2528 };
2529
2530 #define ELF_PRARGSZ     (80) /* Number of chars for args */
2531
2532 struct target_elf_prpsinfo {
2533     char         pr_state;       /* numeric process state */
2534     char         pr_sname;       /* char for pr_state */
2535     char         pr_zomb;        /* zombie */
2536     char         pr_nice;        /* nice val */
2537     abi_ulong    pr_flag;        /* flags */
2538     target_uid_t pr_uid;
2539     target_gid_t pr_gid;
2540     target_pid_t pr_pid, pr_ppid, pr_pgrp, pr_sid;
2541     /* Lots missing */
2542     char    pr_fname[16];           /* filename of executable */
2543     char    pr_psargs[ELF_PRARGSZ]; /* initial part of arg list */
2544 };
2545
2546 /* Here is the structure in which status of each thread is captured. */
2547 struct elf_thread_status {
2548     QTAILQ_ENTRY(elf_thread_status)  ets_link;
2549     struct target_elf_prstatus prstatus;   /* NT_PRSTATUS */
2550 #if 0
2551     elf_fpregset_t fpu;             /* NT_PRFPREG */
2552     struct task_struct *thread;
2553     elf_fpxregset_t xfpu;           /* ELF_CORE_XFPREG_TYPE */
2554 #endif
2555     struct memelfnote notes[1];
2556     int num_notes;
2557 };
2558
2559 struct elf_note_info {
2560     struct memelfnote   *notes;
2561     struct target_elf_prstatus *prstatus;  /* NT_PRSTATUS */
2562     struct target_elf_prpsinfo *psinfo;    /* NT_PRPSINFO */
2563
2564     QTAILQ_HEAD(thread_list_head, elf_thread_status) thread_list;
2565 #if 0
2566     /*
2567      * Current version of ELF coredump doesn't support
2568      * dumping fp regs etc.
2569      */
2570     elf_fpregset_t *fpu;
2571     elf_fpxregset_t *xfpu;
2572     int thread_status_size;
2573 #endif
2574     int notes_size;
2575     int numnote;
2576 };
2577
2578 struct vm_area_struct {
2579     target_ulong   vma_start;  /* start vaddr of memory region */
2580     target_ulong   vma_end;    /* end vaddr of memory region */
2581     abi_ulong      vma_flags;  /* protection etc. flags for the region */
2582     QTAILQ_ENTRY(vm_area_struct) vma_link;
2583 };
2584
2585 struct mm_struct {
2586     QTAILQ_HEAD(, vm_area_struct) mm_mmap;
2587     int mm_count;           /* number of mappings */
2588 };
2589
2590 static struct mm_struct *vma_init(void);
2591 static void vma_delete(struct mm_struct *);
2592 static int vma_add_mapping(struct mm_struct *, target_ulong,
2593                            target_ulong, abi_ulong);
2594 static int vma_get_mapping_count(const struct mm_struct *);
2595 static struct vm_area_struct *vma_first(const struct mm_struct *);
2596 static struct vm_area_struct *vma_next(struct vm_area_struct *);
2597 static abi_ulong vma_dump_size(const struct vm_area_struct *);
2598 static int vma_walker(void *priv, target_ulong start, target_ulong end,
2599                       unsigned long flags);
2600
2601 static void fill_elf_header(struct elfhdr *, int, uint16_t, uint32_t);
2602 static void fill_note(struct memelfnote *, const char *, int,
2603                       unsigned int, void *);
2604 static void fill_prstatus(struct target_elf_prstatus *, const TaskState *, int);
2605 static int fill_psinfo(struct target_elf_prpsinfo *, const TaskState *);
2606 static void fill_auxv_note(struct memelfnote *, const TaskState *);
2607 static void fill_elf_note_phdr(struct elf_phdr *, int, off_t);
2608 static size_t note_size(const struct memelfnote *);
2609 static void free_note_info(struct elf_note_info *);
2610 static int fill_note_info(struct elf_note_info *, long, const CPUArchState *);
2611 static void fill_thread_info(struct elf_note_info *, const CPUArchState *);
2612 static int core_dump_filename(const TaskState *, char *, size_t);
2613
2614 static int dump_write(int, const void *, size_t);
2615 static int write_note(struct memelfnote *, int);
2616 static int write_note_info(struct elf_note_info *, int);
2617
2618 #ifdef BSWAP_NEEDED
2619 static void bswap_prstatus(struct target_elf_prstatus *prstatus)
2620 {
2621     prstatus->pr_info.si_signo = tswap32(prstatus->pr_info.si_signo);
2622     prstatus->pr_info.si_code = tswap32(prstatus->pr_info.si_code);
2623     prstatus->pr_info.si_errno = tswap32(prstatus->pr_info.si_errno);
2624     prstatus->pr_cursig = tswap16(prstatus->pr_cursig);
2625     prstatus->pr_sigpend = tswapal(prstatus->pr_sigpend);
2626     prstatus->pr_sighold = tswapal(prstatus->pr_sighold);
2627     prstatus->pr_pid = tswap32(prstatus->pr_pid);
2628     prstatus->pr_ppid = tswap32(prstatus->pr_ppid);
2629     prstatus->pr_pgrp = tswap32(prstatus->pr_pgrp);
2630     prstatus->pr_sid = tswap32(prstatus->pr_sid);
2631     /* cpu times are not filled, so we skip them */
2632     /* regs should be in correct format already */
2633     prstatus->pr_fpvalid = tswap32(prstatus->pr_fpvalid);
2634 }
2635
2636 static void bswap_psinfo(struct target_elf_prpsinfo *psinfo)
2637 {
2638     psinfo->pr_flag = tswapal(psinfo->pr_flag);
2639     psinfo->pr_uid = tswap16(psinfo->pr_uid);
2640     psinfo->pr_gid = tswap16(psinfo->pr_gid);
2641     psinfo->pr_pid = tswap32(psinfo->pr_pid);
2642     psinfo->pr_ppid = tswap32(psinfo->pr_ppid);
2643     psinfo->pr_pgrp = tswap32(psinfo->pr_pgrp);
2644     psinfo->pr_sid = tswap32(psinfo->pr_sid);
2645 }
2646
2647 static void bswap_note(struct elf_note *en)
2648 {
2649     bswap32s(&en->n_namesz);
2650     bswap32s(&en->n_descsz);
2651     bswap32s(&en->n_type);
2652 }
2653 #else
2654 static inline void bswap_prstatus(struct target_elf_prstatus *p) { }
2655 static inline void bswap_psinfo(struct target_elf_prpsinfo *p) {}
2656 static inline void bswap_note(struct elf_note *en) { }
2657 #endif /* BSWAP_NEEDED */
2658
2659 /*
2660  * Minimal support for linux memory regions.  These are needed
2661  * when we are finding out what memory exactly belongs to
2662  * emulated process.  No locks needed here, as long as
2663  * thread that received the signal is stopped.
2664  */
2665
2666 static struct mm_struct *vma_init(void)
2667 {
2668     struct mm_struct *mm;
2669
2670     if ((mm = g_malloc(sizeof (*mm))) == NULL)
2671         return (NULL);
2672
2673     mm->mm_count = 0;
2674     QTAILQ_INIT(&mm->mm_mmap);
2675
2676     return (mm);
2677 }
2678
2679 static void vma_delete(struct mm_struct *mm)
2680 {
2681     struct vm_area_struct *vma;
2682
2683     while ((vma = vma_first(mm)) != NULL) {
2684         QTAILQ_REMOVE(&mm->mm_mmap, vma, vma_link);
2685         g_free(vma);
2686     }
2687     g_free(mm);
2688 }
2689
2690 static int vma_add_mapping(struct mm_struct *mm, target_ulong start,
2691                            target_ulong end, abi_ulong flags)
2692 {
2693     struct vm_area_struct *vma;
2694
2695     if ((vma = g_malloc0(sizeof (*vma))) == NULL)
2696         return (-1);
2697
2698     vma->vma_start = start;
2699     vma->vma_end = end;
2700     vma->vma_flags = flags;
2701
2702     QTAILQ_INSERT_TAIL(&mm->mm_mmap, vma, vma_link);
2703     mm->mm_count++;
2704
2705     return (0);
2706 }
2707
2708 static struct vm_area_struct *vma_first(const struct mm_struct *mm)
2709 {
2710     return (QTAILQ_FIRST(&mm->mm_mmap));
2711 }
2712
2713 static struct vm_area_struct *vma_next(struct vm_area_struct *vma)
2714 {
2715     return (QTAILQ_NEXT(vma, vma_link));
2716 }
2717
2718 static int vma_get_mapping_count(const struct mm_struct *mm)
2719 {
2720     return (mm->mm_count);
2721 }
2722
2723 /*
2724  * Calculate file (dump) size of given memory region.
2725  */
2726 static abi_ulong vma_dump_size(const struct vm_area_struct *vma)
2727 {
2728     /* if we cannot even read the first page, skip it */
2729     if (!access_ok(VERIFY_READ, vma->vma_start, TARGET_PAGE_SIZE))
2730         return (0);
2731
2732     /*
2733      * Usually we don't dump executable pages as they contain
2734      * non-writable code that debugger can read directly from
2735      * target library etc.  However, thread stacks are marked
2736      * also executable so we read in first page of given region
2737      * and check whether it contains elf header.  If there is
2738      * no elf header, we dump it.
2739      */
2740     if (vma->vma_flags & PROT_EXEC) {
2741         char page[TARGET_PAGE_SIZE];
2742
2743         copy_from_user(page, vma->vma_start, sizeof (page));
2744         if ((page[EI_MAG0] == ELFMAG0) &&
2745             (page[EI_MAG1] == ELFMAG1) &&
2746             (page[EI_MAG2] == ELFMAG2) &&
2747             (page[EI_MAG3] == ELFMAG3)) {
2748             /*
2749              * Mappings are possibly from ELF binary.  Don't dump
2750              * them.
2751              */
2752             return (0);
2753         }
2754     }
2755
2756     return (vma->vma_end - vma->vma_start);
2757 }
2758
2759 static int vma_walker(void *priv, target_ulong start, target_ulong end,
2760                       unsigned long flags)
2761 {
2762     struct mm_struct *mm = (struct mm_struct *)priv;
2763
2764     vma_add_mapping(mm, start, end, flags);
2765     return (0);
2766 }
2767
2768 static void fill_note(struct memelfnote *note, const char *name, int type,
2769                       unsigned int sz, void *data)
2770 {
2771     unsigned int namesz;
2772
2773     namesz = strlen(name) + 1;
2774     note->name = name;
2775     note->namesz = namesz;
2776     note->namesz_rounded = roundup(namesz, sizeof (int32_t));
2777     note->type = type;
2778     note->datasz = sz;
2779     note->datasz_rounded = roundup(sz, sizeof (int32_t));
2780
2781     note->data = data;
2782
2783     /*
2784      * We calculate rounded up note size here as specified by
2785      * ELF document.
2786      */
2787     note->notesz = sizeof (struct elf_note) +
2788         note->namesz_rounded + note->datasz_rounded;
2789 }
2790
2791 static void fill_elf_header(struct elfhdr *elf, int segs, uint16_t machine,
2792                             uint32_t flags)
2793 {
2794     (void) memset(elf, 0, sizeof(*elf));
2795
2796     (void) memcpy(elf->e_ident, ELFMAG, SELFMAG);
2797     elf->e_ident[EI_CLASS] = ELF_CLASS;
2798     elf->e_ident[EI_DATA] = ELF_DATA;
2799     elf->e_ident[EI_VERSION] = EV_CURRENT;
2800     elf->e_ident[EI_OSABI] = ELF_OSABI;
2801
2802     elf->e_type = ET_CORE;
2803     elf->e_machine = machine;
2804     elf->e_version = EV_CURRENT;
2805     elf->e_phoff = sizeof(struct elfhdr);
2806     elf->e_flags = flags;
2807     elf->e_ehsize = sizeof(struct elfhdr);
2808     elf->e_phentsize = sizeof(struct elf_phdr);
2809     elf->e_phnum = segs;
2810
2811     bswap_ehdr(elf);
2812 }
2813
2814 static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, off_t offset)
2815 {
2816     phdr->p_type = PT_NOTE;
2817     phdr->p_offset = offset;
2818     phdr->p_vaddr = 0;
2819     phdr->p_paddr = 0;
2820     phdr->p_filesz = sz;
2821     phdr->p_memsz = 0;
2822     phdr->p_flags = 0;
2823     phdr->p_align = 0;
2824
2825     bswap_phdr(phdr, 1);
2826 }
2827
2828 static size_t note_size(const struct memelfnote *note)
2829 {
2830     return (note->notesz);
2831 }
2832
2833 static void fill_prstatus(struct target_elf_prstatus *prstatus,
2834                           const TaskState *ts, int signr)
2835 {
2836     (void) memset(prstatus, 0, sizeof (*prstatus));
2837     prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
2838     prstatus->pr_pid = ts->ts_tid;
2839     prstatus->pr_ppid = getppid();
2840     prstatus->pr_pgrp = getpgrp();
2841     prstatus->pr_sid = getsid(0);
2842
2843     bswap_prstatus(prstatus);
2844 }
2845
2846 static int fill_psinfo(struct target_elf_prpsinfo *psinfo, const TaskState *ts)
2847 {
2848     char *base_filename;
2849     unsigned int i, len;
2850
2851     (void) memset(psinfo, 0, sizeof (*psinfo));
2852
2853     len = ts->info->arg_end - ts->info->arg_start;
2854     if (len >= ELF_PRARGSZ)
2855         len = ELF_PRARGSZ - 1;
2856     if (copy_from_user(&psinfo->pr_psargs, ts->info->arg_start, len))
2857         return -EFAULT;
2858     for (i = 0; i < len; i++)
2859         if (psinfo->pr_psargs[i] == 0)
2860             psinfo->pr_psargs[i] = ' ';
2861     psinfo->pr_psargs[len] = 0;
2862
2863     psinfo->pr_pid = getpid();
2864     psinfo->pr_ppid = getppid();
2865     psinfo->pr_pgrp = getpgrp();
2866     psinfo->pr_sid = getsid(0);
2867     psinfo->pr_uid = getuid();
2868     psinfo->pr_gid = getgid();
2869
2870     base_filename = g_path_get_basename(ts->bprm->filename);
2871     /*
2872      * Using strncpy here is fine: at max-length,
2873      * this field is not NUL-terminated.
2874      */
2875     (void) strncpy(psinfo->pr_fname, base_filename,
2876                    sizeof(psinfo->pr_fname));
2877
2878     g_free(base_filename);
2879     bswap_psinfo(psinfo);
2880     return (0);
2881 }
2882
2883 static void fill_auxv_note(struct memelfnote *note, const TaskState *ts)
2884 {
2885     elf_addr_t auxv = (elf_addr_t)ts->info->saved_auxv;
2886     elf_addr_t orig_auxv = auxv;
2887     void *ptr;
2888     int len = ts->info->auxv_len;
2889
2890     /*
2891      * Auxiliary vector is stored in target process stack.  It contains
2892      * {type, value} pairs that we need to dump into note.  This is not
2893      * strictly necessary but we do it here for sake of completeness.
2894      */
2895
2896     /* read in whole auxv vector and copy it to memelfnote */
2897     ptr = lock_user(VERIFY_READ, orig_auxv, len, 0);
2898     if (ptr != NULL) {
2899         fill_note(note, "CORE", NT_AUXV, len, ptr);
2900         unlock_user(ptr, auxv, len);
2901     }
2902 }
2903
2904 /*
2905  * Constructs name of coredump file.  We have following convention
2906  * for the name:
2907  *     qemu_<basename-of-target-binary>_<date>-<time>_<pid>.core
2908  *
2909  * Returns 0 in case of success, -1 otherwise (errno is set).
2910  */
2911 static int core_dump_filename(const TaskState *ts, char *buf,
2912                               size_t bufsize)
2913 {
2914     char timestamp[64];
2915     char *base_filename = NULL;
2916     struct timeval tv;
2917     struct tm tm;
2918
2919     assert(bufsize >= PATH_MAX);
2920
2921     if (gettimeofday(&tv, NULL) < 0) {
2922         (void) fprintf(stderr, "unable to get current timestamp: %s",
2923                        strerror(errno));
2924         return (-1);
2925     }
2926
2927     base_filename = g_path_get_basename(ts->bprm->filename);
2928     (void) strftime(timestamp, sizeof (timestamp), "%Y%m%d-%H%M%S",
2929                     localtime_r(&tv.tv_sec, &tm));
2930     (void) snprintf(buf, bufsize, "qemu_%s_%s_%d.core",
2931                     base_filename, timestamp, (int)getpid());
2932     g_free(base_filename);
2933
2934     return (0);
2935 }
2936
2937 static int dump_write(int fd, const void *ptr, size_t size)
2938 {
2939     const char *bufp = (const char *)ptr;
2940     ssize_t bytes_written, bytes_left;
2941     struct rlimit dumpsize;
2942     off_t pos;
2943
2944     bytes_written = 0;
2945     getrlimit(RLIMIT_CORE, &dumpsize);
2946     if ((pos = lseek(fd, 0, SEEK_CUR))==-1) {
2947         if (errno == ESPIPE) { /* not a seekable stream */
2948             bytes_left = size;
2949         } else {
2950             return pos;
2951         }
2952     } else {
2953         if (dumpsize.rlim_cur <= pos) {
2954             return -1;
2955         } else if (dumpsize.rlim_cur == RLIM_INFINITY) {
2956             bytes_left = size;
2957         } else {
2958             size_t limit_left=dumpsize.rlim_cur - pos;
2959             bytes_left = limit_left >= size ? size : limit_left ;
2960         }
2961     }
2962
2963     /*
2964      * In normal conditions, single write(2) should do but
2965      * in case of socket etc. this mechanism is more portable.
2966      */
2967     do {
2968         bytes_written = write(fd, bufp, bytes_left);
2969         if (bytes_written < 0) {
2970             if (errno == EINTR)
2971                 continue;
2972             return (-1);
2973         } else if (bytes_written == 0) { /* eof */
2974             return (-1);
2975         }
2976         bufp += bytes_written;
2977         bytes_left -= bytes_written;
2978     } while (bytes_left > 0);
2979
2980     return (0);
2981 }
2982
2983 static int write_note(struct memelfnote *men, int fd)
2984 {
2985     struct elf_note en;
2986
2987     en.n_namesz = men->namesz;
2988     en.n_type = men->type;
2989     en.n_descsz = men->datasz;
2990
2991     bswap_note(&en);
2992
2993     if (dump_write(fd, &en, sizeof(en)) != 0)
2994         return (-1);
2995     if (dump_write(fd, men->name, men->namesz_rounded) != 0)
2996         return (-1);
2997     if (dump_write(fd, men->data, men->datasz_rounded) != 0)
2998         return (-1);
2999
3000     return (0);
3001 }
3002
3003 static void fill_thread_info(struct elf_note_info *info, const CPUArchState *env)
3004 {
3005     CPUState *cpu = ENV_GET_CPU((CPUArchState *)env);
3006     TaskState *ts = (TaskState *)cpu->opaque;
3007     struct elf_thread_status *ets;
3008
3009     ets = g_malloc0(sizeof (*ets));
3010     ets->num_notes = 1; /* only prstatus is dumped */
3011     fill_prstatus(&ets->prstatus, ts, 0);
3012     elf_core_copy_regs(&ets->prstatus.pr_reg, env);
3013     fill_note(&ets->notes[0], "CORE", NT_PRSTATUS, sizeof (ets->prstatus),
3014               &ets->prstatus);
3015
3016     QTAILQ_INSERT_TAIL(&info->thread_list, ets, ets_link);
3017
3018     info->notes_size += note_size(&ets->notes[0]);
3019 }
3020
3021 static void init_note_info(struct elf_note_info *info)
3022 {
3023     /* Initialize the elf_note_info structure so that it is at
3024      * least safe to call free_note_info() on it. Must be
3025      * called before calling fill_note_info().
3026      */
3027     memset(info, 0, sizeof (*info));
3028     QTAILQ_INIT(&info->thread_list);
3029 }
3030
3031 static int fill_note_info(struct elf_note_info *info,
3032                           long signr, const CPUArchState *env)
3033 {
3034 #define NUMNOTES 3
3035     CPUState *cpu = ENV_GET_CPU((CPUArchState *)env);
3036     TaskState *ts = (TaskState *)cpu->opaque;
3037     int i;
3038
3039     info->notes = g_new0(struct memelfnote, NUMNOTES);
3040     if (info->notes == NULL)
3041         return (-ENOMEM);
3042     info->prstatus = g_malloc0(sizeof (*info->prstatus));
3043     if (info->prstatus == NULL)
3044         return (-ENOMEM);
3045     info->psinfo = g_malloc0(sizeof (*info->psinfo));
3046     if (info->prstatus == NULL)
3047         return (-ENOMEM);
3048
3049     /*
3050      * First fill in status (and registers) of current thread
3051      * including process info & aux vector.
3052      */
3053     fill_prstatus(info->prstatus, ts, signr);
3054     elf_core_copy_regs(&info->prstatus->pr_reg, env);
3055     fill_note(&info->notes[0], "CORE", NT_PRSTATUS,
3056               sizeof (*info->prstatus), info->prstatus);
3057     fill_psinfo(info->psinfo, ts);
3058     fill_note(&info->notes[1], "CORE", NT_PRPSINFO,
3059               sizeof (*info->psinfo), info->psinfo);
3060     fill_auxv_note(&info->notes[2], ts);
3061     info->numnote = 3;
3062
3063     info->notes_size = 0;
3064     for (i = 0; i < info->numnote; i++)
3065         info->notes_size += note_size(&info->notes[i]);
3066
3067     /* read and fill status of all threads */
3068     cpu_list_lock();
3069     CPU_FOREACH(cpu) {
3070         if (cpu == thread_cpu) {
3071             continue;
3072         }
3073         fill_thread_info(info, (CPUArchState *)cpu->env_ptr);
3074     }
3075     cpu_list_unlock();
3076
3077     return (0);
3078 }
3079
3080 static void free_note_info(struct elf_note_info *info)
3081 {
3082     struct elf_thread_status *ets;
3083
3084     while (!QTAILQ_EMPTY(&info->thread_list)) {
3085         ets = QTAILQ_FIRST(&info->thread_list);
3086         QTAILQ_REMOVE(&info->thread_list, ets, ets_link);
3087         g_free(ets);
3088     }
3089
3090     g_free(info->prstatus);
3091     g_free(info->psinfo);
3092     g_free(info->notes);
3093 }
3094
3095 static int write_note_info(struct elf_note_info *info, int fd)
3096 {
3097     struct elf_thread_status *ets;
3098     int i, error = 0;
3099
3100     /* write prstatus, psinfo and auxv for current thread */
3101     for (i = 0; i < info->numnote; i++)
3102         if ((error = write_note(&info->notes[i], fd)) != 0)
3103             return (error);
3104
3105     /* write prstatus for each thread */
3106     QTAILQ_FOREACH(ets, &info->thread_list, ets_link) {
3107         if ((error = write_note(&ets->notes[0], fd)) != 0)
3108             return (error);
3109     }
3110
3111     return (0);
3112 }
3113
3114 /*
3115  * Write out ELF coredump.
3116  *
3117  * See documentation of ELF object file format in:
3118  * http://www.caldera.com/developers/devspecs/gabi41.pdf
3119  *
3120  * Coredump format in linux is following:
3121  *
3122  * 0   +----------------------+         \
3123  *     | ELF header           | ET_CORE  |
3124  *     +----------------------+          |
3125  *     | ELF program headers  |          |--- headers
3126  *     | - NOTE section       |          |
3127  *     | - PT_LOAD sections   |          |
3128  *     +----------------------+         /
3129  *     | NOTEs:               |
3130  *     | - NT_PRSTATUS        |
3131  *     | - NT_PRSINFO         |
3132  *     | - NT_AUXV            |
3133  *     +----------------------+ <-- aligned to target page
3134  *     | Process memory dump  |
3135  *     :                      :
3136  *     .                      .
3137  *     :                      :
3138  *     |                      |
3139  *     +----------------------+
3140  *
3141  * NT_PRSTATUS -> struct elf_prstatus (per thread)
3142  * NT_PRSINFO  -> struct elf_prpsinfo
3143  * NT_AUXV is array of { type, value } pairs (see fill_auxv_note()).
3144  *
3145  * Format follows System V format as close as possible.  Current
3146  * version limitations are as follows:
3147  *     - no floating point registers are dumped
3148  *
3149  * Function returns 0 in case of success, negative errno otherwise.
3150  *
3151  * TODO: make this work also during runtime: it should be
3152  * possible to force coredump from running process and then
3153  * continue processing.  For example qemu could set up SIGUSR2
3154  * handler (provided that target process haven't registered
3155  * handler for that) that does the dump when signal is received.
3156  */
3157 static int elf_core_dump(int signr, const CPUArchState *env)
3158 {
3159     const CPUState *cpu = ENV_GET_CPU((CPUArchState *)env);
3160     const TaskState *ts = (const TaskState *)cpu->opaque;
3161     struct vm_area_struct *vma = NULL;
3162     char corefile[PATH_MAX];
3163     struct elf_note_info info;
3164     struct elfhdr elf;
3165     struct elf_phdr phdr;
3166     struct rlimit dumpsize;
3167     struct mm_struct *mm = NULL;
3168     off_t offset = 0, data_offset = 0;
3169     int segs = 0;
3170     int fd = -1;
3171
3172     init_note_info(&info);
3173
3174     errno = 0;
3175     getrlimit(RLIMIT_CORE, &dumpsize);
3176     if (dumpsize.rlim_cur == 0)
3177         return 0;
3178
3179     if (core_dump_filename(ts, corefile, sizeof (corefile)) < 0)
3180         return (-errno);
3181
3182     if ((fd = open(corefile, O_WRONLY | O_CREAT,
3183                    S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
3184         return (-errno);
3185
3186     /*
3187      * Walk through target process memory mappings and
3188      * set up structure containing this information.  After
3189      * this point vma_xxx functions can be used.
3190      */
3191     if ((mm = vma_init()) == NULL)
3192         goto out;
3193
3194     walk_memory_regions(mm, vma_walker);
3195     segs = vma_get_mapping_count(mm);
3196
3197     /*
3198      * Construct valid coredump ELF header.  We also
3199      * add one more segment for notes.
3200      */
3201     fill_elf_header(&elf, segs + 1, ELF_MACHINE, 0);
3202     if (dump_write(fd, &elf, sizeof (elf)) != 0)
3203         goto out;
3204
3205     /* fill in the in-memory version of notes */
3206     if (fill_note_info(&info, signr, env) < 0)
3207         goto out;
3208
3209     offset += sizeof (elf);                             /* elf header */
3210     offset += (segs + 1) * sizeof (struct elf_phdr);    /* program headers */
3211
3212     /* write out notes program header */
3213     fill_elf_note_phdr(&phdr, info.notes_size, offset);
3214
3215     offset += info.notes_size;
3216     if (dump_write(fd, &phdr, sizeof (phdr)) != 0)
3217         goto out;
3218
3219     /*
3220      * ELF specification wants data to start at page boundary so
3221      * we align it here.
3222      */
3223     data_offset = offset = roundup(offset, ELF_EXEC_PAGESIZE);
3224
3225     /*
3226      * Write program headers for memory regions mapped in
3227      * the target process.
3228      */
3229     for (vma = vma_first(mm); vma != NULL; vma = vma_next(vma)) {
3230         (void) memset(&phdr, 0, sizeof (phdr));
3231
3232         phdr.p_type = PT_LOAD;
3233         phdr.p_offset = offset;
3234         phdr.p_vaddr = vma->vma_start;
3235         phdr.p_paddr = 0;
3236         phdr.p_filesz = vma_dump_size(vma);
3237         offset += phdr.p_filesz;
3238         phdr.p_memsz = vma->vma_end - vma->vma_start;
3239         phdr.p_flags = vma->vma_flags & PROT_READ ? PF_R : 0;
3240         if (vma->vma_flags & PROT_WRITE)
3241             phdr.p_flags |= PF_W;
3242         if (vma->vma_flags & PROT_EXEC)
3243             phdr.p_flags |= PF_X;
3244         phdr.p_align = ELF_EXEC_PAGESIZE;
3245
3246         bswap_phdr(&phdr, 1);
3247         if (dump_write(fd, &phdr, sizeof(phdr)) != 0) {
3248             goto out;
3249         }
3250     }
3251
3252     /*
3253      * Next we write notes just after program headers.  No
3254      * alignment needed here.
3255      */
3256     if (write_note_info(&info, fd) < 0)
3257         goto out;
3258
3259     /* align data to page boundary */
3260     if (lseek(fd, data_offset, SEEK_SET) != data_offset)
3261         goto out;
3262
3263     /*
3264      * Finally we can dump process memory into corefile as well.
3265      */
3266     for (vma = vma_first(mm); vma != NULL; vma = vma_next(vma)) {
3267         abi_ulong addr;
3268         abi_ulong end;
3269
3270         end = vma->vma_start + vma_dump_size(vma);
3271
3272         for (addr = vma->vma_start; addr < end;
3273              addr += TARGET_PAGE_SIZE) {
3274             char page[TARGET_PAGE_SIZE];
3275             int error;
3276
3277             /*
3278              *  Read in page from target process memory and
3279              *  write it to coredump file.
3280              */
3281             error = copy_from_user(page, addr, sizeof (page));
3282             if (error != 0) {
3283                 (void) fprintf(stderr, "unable to dump " TARGET_ABI_FMT_lx "\n",
3284                                addr);
3285                 errno = -error;
3286                 goto out;
3287             }
3288             if (dump_write(fd, page, TARGET_PAGE_SIZE) < 0)
3289                 goto out;
3290         }
3291     }
3292
3293  out:
3294     free_note_info(&info);
3295     if (mm != NULL)
3296         vma_delete(mm);
3297     (void) close(fd);
3298
3299     if (errno != 0)
3300         return (-errno);
3301     return (0);
3302 }
3303 #endif /* USE_ELF_CORE_DUMP */
3304
3305 void do_init_thread(struct target_pt_regs *regs, struct image_info *infop)
3306 {
3307     init_thread(regs, infop);
3308 }
This page took 0.210888 seconds and 4 git commands to generate.