Lines Matching +full:- +full:- +full:enable +full:- +full:tcg +full:- +full:interpreter
1 /* This is the Linux kernel elf-loading code, ported into user space */
10 #include "user/tswap-target.h"
11 #include "user/page-protection.h"
12 #include "exec/page-protection.h"
13 #include "exec/mmap-lock.h"
14 #include "exec/translation-block.h"
16 #include "user/guest-base.h"
17 #include "user-internals.h"
18 #include "signal-common.h"
20 #include "user-mmap.h"
25 #include "qemu/guest-random.h"
30 #include "qemu/error-report.h"
32 #include "tcg/debuginfo.h"
35 #include "target/arm/cpu-features.h"
105 PER_IRIX32 = 0x0009 | STICKY_TIMEOUTS,/* IRIX5 32-bit */
106 PER_IRIXN32 = 0x000a | STICKY_TIMEOUTS,/* IRIX6 new 32-bit */
107 PER_IRIX64 = 0x000b | STICKY_TIMEOUTS,/* IRIX6 64-bit */
123 return info->personality == PER_LINUX_FDPIC;
167 return cpu->env.features[FEAT_1_EDX];
178 regs->rax = 0;
179 regs->rsp = infop->start_stack;
180 regs->rip = infop->entry;
195 (*regs)[0] = tswapreg(env->regs[15]);
196 (*regs)[1] = tswapreg(env->regs[14]);
197 (*regs)[2] = tswapreg(env->regs[13]);
198 (*regs)[3] = tswapreg(env->regs[12]);
199 (*regs)[4] = tswapreg(env->regs[R_EBP]);
200 (*regs)[5] = tswapreg(env->regs[R_EBX]);
201 (*regs)[6] = tswapreg(env->regs[11]);
202 (*regs)[7] = tswapreg(env->regs[10]);
203 (*regs)[8] = tswapreg(env->regs[9]);
204 (*regs)[9] = tswapreg(env->regs[8]);
205 (*regs)[10] = tswapreg(env->regs[R_EAX]);
206 (*regs)[11] = tswapreg(env->regs[R_ECX]);
207 (*regs)[12] = tswapreg(env->regs[R_EDX]);
208 (*regs)[13] = tswapreg(env->regs[R_ESI]);
209 (*regs)[14] = tswapreg(env->regs[R_EDI]);
210 (*regs)[15] = tswapreg(get_task_state(env_cpu_const(env))->orig_ax);
211 (*regs)[16] = tswapreg(env->eip);
212 (*regs)[17] = tswapreg(env->segs[R_CS].selector & 0xffff);
213 (*regs)[18] = tswapreg(env->eflags);
214 (*regs)[19] = tswapreg(env->regs[R_ESP]);
215 (*regs)[20] = tswapreg(env->segs[R_SS].selector & 0xffff);
216 (*regs)[21] = tswapreg(env->segs[R_FS].selector & 0xffff);
217 (*regs)[22] = tswapreg(env->segs[R_GS].selector & 0xffff);
218 (*regs)[23] = tswapreg(env->segs[R_DS].selector & 0xffff);
219 (*regs)[24] = tswapreg(env->segs[R_ES].selector & 0xffff);
220 (*regs)[25] = tswapreg(env->segs[R_FS].selector & 0xffff);
221 (*regs)[26] = tswapreg(env->segs[R_GS].selector & 0xffff);
232 * has specified -R reserved_va, which would trigger an assert().
235 TARGET_VSYSCALL_PAGE + TARGET_PAGE_SIZE - 1 > reserved_va) {
277 regs->esp = infop->start_stack;
278 regs->eip = infop->entry;
280 /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
287 regs->edx = 0;
302 (*regs)[0] = tswapreg(env->regs[R_EBX]);
303 (*regs)[1] = tswapreg(env->regs[R_ECX]);
304 (*regs)[2] = tswapreg(env->regs[R_EDX]);
305 (*regs)[3] = tswapreg(env->regs[R_ESI]);
306 (*regs)[4] = tswapreg(env->regs[R_EDI]);
307 (*regs)[5] = tswapreg(env->regs[R_EBP]);
308 (*regs)[6] = tswapreg(env->regs[R_EAX]);
309 (*regs)[7] = tswapreg(env->segs[R_DS].selector & 0xffff);
310 (*regs)[8] = tswapreg(env->segs[R_ES].selector & 0xffff);
311 (*regs)[9] = tswapreg(env->segs[R_FS].selector & 0xffff);
312 (*regs)[10] = tswapreg(env->segs[R_GS].selector & 0xffff);
313 (*regs)[11] = tswapreg(get_task_state(env_cpu_const(env))->orig_ax);
314 (*regs)[12] = tswapreg(env->eip);
315 (*regs)[13] = tswapreg(env->segs[R_CS].selector & 0xffff);
316 (*regs)[14] = tswapreg(env->eflags);
317 (*regs)[15] = tswapreg(env->regs[R_ESP]);
318 (*regs)[16] = tswapreg(env->segs[R_SS].selector & 0xffff);
329 NEW_AUX_ENT(AT_SYSINFO, vdso_info->entry); \
354 abi_long stack = infop->start_stack;
357 regs->uregs[16] = ARM_CPU_MODE_USR;
358 if (infop->entry & 1) {
359 regs->uregs[16] |= CPSR_T;
361 regs->uregs[15] = infop->entry & 0xfffffffe;
362 regs->uregs[13] = infop->start_stack;
363 /* FIXME - what to for failure of get_user()? */
364 get_user_ual(regs->uregs[2], stack + 8); /* envp */
365 get_user_ual(regs->uregs[1], stack + 4); /* envp */
367 regs->uregs[0] = 0;
370 regs->uregs[10] = infop->start_data;
375 * prepared by the kernel. If an interpreter is needed, r8 points
376 * to the interpreter loadmap and r9 points to the interpreter
377 * PT_DYNAMIC info. If no interpreter is needed, r8 is zero, and
380 regs->uregs[7] = infop->loadmap_addr;
381 if (infop->interpreter_loadmap_addr) {
383 regs->uregs[8] = infop->interpreter_loadmap_addr;
384 regs->uregs[9] = infop->interpreter_pt_dynamic_addr;
386 regs->uregs[8] = 0;
387 regs->uregs[9] = infop->pt_dynamic_addr;
397 (*regs)[0] = tswapreg(env->regs[0]);
398 (*regs)[1] = tswapreg(env->regs[1]);
399 (*regs)[2] = tswapreg(env->regs[2]);
400 (*regs)[3] = tswapreg(env->regs[3]);
401 (*regs)[4] = tswapreg(env->regs[4]);
402 (*regs)[5] = tswapreg(env->regs[5]);
403 (*regs)[6] = tswapreg(env->regs[6]);
404 (*regs)[7] = tswapreg(env->regs[7]);
405 (*regs)[8] = tswapreg(env->regs[8]);
406 (*regs)[9] = tswapreg(env->regs[9]);
407 (*regs)[10] = tswapreg(env->regs[10]);
408 (*regs)[11] = tswapreg(env->regs[11]);
409 (*regs)[12] = tswapreg(env->regs[12]);
410 (*regs)[13] = tswapreg(env->regs[13]);
411 (*regs)[14] = tswapreg(env->regs[14]);
412 (*regs)[15] = tswapreg(env->regs[15]);
415 (*regs)[17] = tswapreg(env->regs[0]); /* XXX */
476 * M-profile allocates maximum of 2GB address space, so can never
479 if (arm_feature(&cpu->env, ARM_FEATURE_M)) {
483 commpage = HI_COMMPAGE & -host_page_size;
488 -1, 0);
506 page_set_flags(commpage, commpage | (host_page_size - 1),
526 do { if (arm_feature(&cpu->env, feat)) { hwcaps |= hwcap; } } while (0)
668 #include "vdso-be8.c.inc"
669 #include "vdso-be32.c.inc"
680 # define VDSO_HEADER "vdso-le.c.inc"
697 abi_long stack = infop->start_stack;
700 regs->pc = infop->entry & ~0x3ULL;
701 regs->sp = stack;
713 (*regs)[i] = tswapreg(env->xregs[i]);
715 (*regs)[32] = tswapreg(env->pc);
1060 # define VDSO_HEADER "vdso-be.c.inc"
1062 # define VDSO_HEADER "vdso-le.c.inc"
1088 /* There are not many sparc32 hwcap bits -- we have all of them. */
1094 uint32_t features = env->def.features;
1116 regs->pc = infop->entry;
1117 regs->npc = regs->pc + 4;
1118 regs->y = 0;
1119 regs->u_regs[14] = (infop->start_stack - 16 * sizeof(abi_ulong)
1120 - TARGET_STACK_BIAS);
1186 QEMU_PPC_FEATURE2_HAS_IEEE128 = 0x00400000, /* VSX IEEE Bin Float 128-bit */
1191 QEMU_PPC_FEATURE2_MMA = 0x00020000, /* Matrix-Multiply Assist */
1204 do { if (cpu->env.insns_flags & flag) { features |= feature; } } while (0)
1207 if ((cpu->env.insns_flags2 & flags) == flags) { \
1238 do { if (cpu->env.insns_flags & flag) { features |= feature; } } while (0)
1240 do { if (cpu->env.insns_flags2 & flag) { features |= feature; } } while (0)
1260 * - keep the final alignment of sp (sp & 0xf)
1261 * - make sure the 32-bit value at the first 16 byte aligned position of
1264 * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
1277 NEW_AUX_ENT(AT_DCACHEBSIZE, cpu->env.dcache_line_size); \
1278 NEW_AUX_ENT(AT_ICACHEBSIZE, cpu->env.icache_line_size); \
1284 _regs->gpr[1] = infop->start_stack;
1288 get_user_u64(val, infop->entry + 8);
1289 _regs->gpr[2] = val + infop->load_bias;
1290 get_user_u64(val, infop->entry);
1291 infop->entry = val + infop->load_bias;
1293 _regs->gpr[12] = infop->entry; /* r12 set to global entry address */
1296 _regs->nip = infop->entry;
1308 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
1309 (*regs)[i] = tswapreg(env->gpr[i]);
1312 (*regs)[32] = tswapreg(env->nip);
1313 (*regs)[33] = tswapreg(env->msr);
1314 (*regs)[35] = tswapreg(env->ctr);
1315 (*regs)[36] = tswapreg(env->lr);
1326 # define VDSO_HEADER "vdso-32.c.inc"
1328 # define VDSO_HEADER "vdso-64.c.inc"
1330 # define VDSO_HEADER "vdso-64le.c.inc"
1349 regs->csr.crmd = 2 << 3;
1350 regs->csr.era = infop->entry;
1351 regs->regs[3] = infop->start_stack;
1371 for (i = 1; i < ARRAY_SIZE(env->gpr); i++) {
1372 (*regs)[TARGET_EF_R0 + i] = tswapreg(env->gpr[i]);
1375 (*regs)[TARGET_EF_CSR_ERA] = tswapreg(env->pc);
1376 (*regs)[TARGET_EF_CSR_BADV] = tswapreg(env->CSR_BADV);
1408 if (FIELD_EX32(cpu->env.cpucfg[1], CPUCFG1, UAL)) {
1412 if (FIELD_EX32(cpu->env.cpucfg[2], CPUCFG2, FP)) {
1416 if (FIELD_EX32(cpu->env.cpucfg[2], CPUCFG2, LAM)) {
1420 if (FIELD_EX32(cpu->env.cpucfg[2], CPUCFG2, LSX)) {
1424 if (FIELD_EX32(cpu->env.cpucfg[2], CPUCFG2, LASX)) {
1454 do { if ((cpu->env.insn_flags & (_flags)) == _flags) \
1485 regs->cp0_status = 2 << CP0St_KSU;
1486 regs->cp0_epc = infop->entry;
1487 regs->regs[29] = infop->start_stack;
1521 for (i = 1; i < ARRAY_SIZE(env->active_tc.gpr); i++) {
1522 (*regs)[TARGET_EF_R0 + i] = tswapreg(env->active_tc.gpr[i]);
1527 (*regs)[TARGET_EF_LO] = tswapreg(env->active_tc.LO[0]);
1528 (*regs)[TARGET_EF_HI] = tswapreg(env->active_tc.HI[0]);
1529 (*regs)[TARGET_EF_CP0_EPC] = tswapreg(env->active_tc.PC);
1530 (*regs)[TARGET_EF_CP0_BADVADDR] = tswapreg(env->CP0_BadVAddr);
1531 (*regs)[TARGET_EF_CP0_STATUS] = tswapreg(env->CP0_Status);
1532 (*regs)[TARGET_EF_CP0_CAUSE] = tswapreg(env->CP0_Cause);
1560 do { if (cpu->env.insn_flags & (_flag)) { hwcaps |= _hwcap; } } while (0)
1563 do { if (cpu->env._reg & (_mask)) { hwcaps |= _hwcap; } } while (0)
1567 if (extract32(cpu->env._reg, (_start), (_length)) == (_val)) { \
1602 regs->pc = infop->entry;
1603 regs->r1 = infop->start_stack;
1619 (*regs)[pos++] = tswapreg(env->regs[i]);
1622 (*regs)[pos++] = tswapreg(env->pc);
1625 (*regs)[pos++] = tswapreg(env->ear);
1627 (*regs)[pos++] = tswapreg(env->esr);
1641 regs->pc = infop->entry;
1642 regs->gpr[1] = infop->start_stack;
1660 (*regs)[32] = tswapreg(env->pc);
1677 regs->pc = infop->entry;
1678 regs->regs[15] = infop->start_stack;
1702 (*regs)[i] = tswapreg(env->gregs[i]);
1705 (*regs)[TARGET_REG_PC] = tswapreg(env->pc);
1706 (*regs)[TARGET_REG_PR] = tswapreg(env->pr);
1707 (*regs)[TARGET_REG_SR] = tswapreg(env->sr);
1708 (*regs)[TARGET_REG_GBR] = tswapreg(env->gbr);
1709 (*regs)[TARGET_REG_MACH] = tswapreg(env->mach);
1710 (*regs)[TARGET_REG_MACL] = tswapreg(env->macl);
1721 SH_CPU_HAS_DSP = 0x0008, /* SH-DSP: DSP support */
1726 SH_CPU_HAS_OP32 = 0x0100, /* 32-bit instruction support */
1739 if (cpu->env.features & SH_FEATURE_SH4A) {
1759 regs->usp = infop->start_stack;
1760 regs->sr = 0;
1761 regs->pc = infop->entry;
1770 (*regs)[0] = tswapreg(env->dregs[1]);
1771 (*regs)[1] = tswapreg(env->dregs[2]);
1772 (*regs)[2] = tswapreg(env->dregs[3]);
1773 (*regs)[3] = tswapreg(env->dregs[4]);
1774 (*regs)[4] = tswapreg(env->dregs[5]);
1775 (*regs)[5] = tswapreg(env->dregs[6]);
1776 (*regs)[6] = tswapreg(env->dregs[7]);
1777 (*regs)[7] = tswapreg(env->aregs[0]);
1778 (*regs)[8] = tswapreg(env->aregs[1]);
1779 (*regs)[9] = tswapreg(env->aregs[2]);
1780 (*regs)[10] = tswapreg(env->aregs[3]);
1781 (*regs)[11] = tswapreg(env->aregs[4]);
1782 (*regs)[12] = tswapreg(env->aregs[5]);
1783 (*regs)[13] = tswapreg(env->aregs[6]);
1784 (*regs)[14] = tswapreg(env->dregs[0]);
1785 (*regs)[15] = tswapreg(env->aregs[7]);
1786 (*regs)[16] = tswapreg(env->dregs[0]); /* FIXME: orig_d0 */
1787 (*regs)[17] = tswapreg(env->sr);
1788 (*regs)[18] = tswapreg(env->pc);
1789 (*regs)[19] = 0; /* FIXME: regs->format | regs->vector */
1805 regs->pc = infop->entry;
1806 regs->ps = 8;
1807 regs->usp = infop->start_stack;
1831 * 31-bit processes can use 64-bit registers (high gprs).
1882 regs->psw.addr = infop->entry;
1883 regs->psw.mask = PSW_MASK_DAT | PSW_MASK_IO | PSW_MASK_EXT | \
1886 regs->gprs[15] = infop->start_stack;
1907 (*regs)[TARGET_REG_PSWM] = tswapreg(env->psw.mask);
1908 (*regs)[TARGET_REG_PSWA] = tswapreg(env->psw.addr);
1910 (*regs)[TARGET_REG_GPRS + i] = tswapreg(env->regs[i]);
1914 aregs[i] = tswap32(env->aregs[i]);
1932 #define VDSO_HEADER "vdso-32.c.inc"
1935 #define VDSO_HEADER "vdso-64.c.inc"
1942 #define MISA_BIT(EXT) (1 << (EXT - 'A'))
1948 return cpu->env.misa_ext & mask;
1955 regs->sepc = infop->entry;
1956 regs->sp = infop->start_stack;
1976 regs->iaoq[0] = infop->entry | PRIV_USER;
1977 regs->iaoq[1] = regs->iaoq[0] + 4;
1978 regs->gr[23] = 0;
1979 regs->gr[24] = infop->argv;
1980 regs->gr[25] = infop->argc;
1981 /* The top-of-stack contains a linkage buffer. */
1982 regs->gr[30] = infop->start_stack + 64;
1983 regs->gr[31] = infop->entry;
1996 MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED_NOREPLACE, -1, 0);
2028 regs->windowbase = 0;
2029 regs->windowstart = 1;
2030 regs->areg[1] = infop->start_stack;
2031 regs->pc = infop->entry;
2033 regs->areg[4] = infop->loadmap_addr;
2034 regs->areg[5] = infop->interpreter_loadmap_addr;
2035 if (infop->interpreter_loadmap_addr) {
2036 regs->areg[6] = infop->interpreter_pt_dynamic_addr;
2038 regs->areg[6] = infop->pt_dynamic_addr;
2065 (*regs)[TARGET_REG_PC] = tswapreg(env->pc);
2066 (*regs)[TARGET_REG_PS] = tswapreg(env->sregs[PS] & ~PS_EXCM);
2067 (*regs)[TARGET_REG_LBEG] = tswapreg(env->sregs[LBEG]);
2068 (*regs)[TARGET_REG_LEND] = tswapreg(env->sregs[LEND]);
2069 (*regs)[TARGET_REG_LCOUNT] = tswapreg(env->sregs[LCOUNT]);
2070 (*regs)[TARGET_REG_SAR] = tswapreg(env->sregs[SAR]);
2071 (*regs)[TARGET_REG_WINDOWSTART] = tswapreg(env->sregs[WINDOW_START]);
2072 (*regs)[TARGET_REG_WINDOWBASE] = tswapreg(env->sregs[WINDOW_BASE]);
2073 (*regs)[TARGET_REG_THREADPTR] = tswapreg(env->uregs[THREADPTR]);
2075 for (i = 0; i < env->config->nareg; ++i) {
2076 (*regs)[TARGET_REG_AR0 + i] = tswapreg(env->phys_regs[i]);
2093 regs->sepc = infop->entry;
2094 regs->sp = infop->start_stack;
2154 error_setg(errp, "Ill-formed GNU_PROPERTY_AARCH64_FEATURE_1_AND");
2158 info->note_flags = *data;
2209 bswap16s(&ehdr->e_type); /* Object file type */
2210 bswap16s(&ehdr->e_machine); /* Architecture */
2211 bswap32s(&ehdr->e_version); /* Object file version */
2212 bswaptls(&ehdr->e_entry); /* Entry point virtual address */
2213 bswaptls(&ehdr->e_phoff); /* Program header table file offset */
2214 bswaptls(&ehdr->e_shoff); /* Section header table file offset */
2215 bswap32s(&ehdr->e_flags); /* Processor-specific flags */
2216 bswap16s(&ehdr->e_ehsize); /* ELF header size in bytes */
2217 bswap16s(&ehdr->e_phentsize); /* Program header table entry size */
2218 bswap16s(&ehdr->e_phnum); /* Program header table entry count */
2219 bswap16s(&ehdr->e_shentsize); /* Section header table entry size */
2220 bswap16s(&ehdr->e_shnum); /* Section header table entry count */
2221 bswap16s(&ehdr->e_shstrndx); /* Section header string table index */
2231 bswap32s(&phdr->p_type); /* Segment type */
2232 bswap32s(&phdr->p_flags); /* Segment flags */
2233 bswaptls(&phdr->p_offset); /* Segment file offset */
2234 bswaptls(&phdr->p_vaddr); /* Segment virtual address */
2235 bswaptls(&phdr->p_paddr); /* Segment physical address */
2236 bswaptls(&phdr->p_filesz); /* Segment size in file */
2237 bswaptls(&phdr->p_memsz); /* Segment size in memory */
2238 bswaptls(&phdr->p_align); /* Segment alignment */
2249 bswap32s(&shdr->sh_name);
2250 bswap32s(&shdr->sh_type);
2251 bswaptls(&shdr->sh_flags);
2252 bswaptls(&shdr->sh_addr);
2253 bswaptls(&shdr->sh_offset);
2254 bswaptls(&shdr->sh_size);
2255 bswap32s(&shdr->sh_link);
2256 bswap32s(&shdr->sh_info);
2257 bswaptls(&shdr->sh_addralign);
2258 bswaptls(&shdr->sh_entsize);
2268 bswap32s(&sym->st_name);
2269 bswaptls(&sym->st_value);
2270 bswaptls(&sym->st_size);
2271 bswap16s(&sym->st_shndx);
2281 bswap16s(&abiflags->version);
2282 bswap32s(&abiflags->ases);
2283 bswap32s(&abiflags->isa_ext);
2284 bswap32s(&abiflags->flags1);
2285 bswap32s(&abiflags->flags2);
2299 return (ehdr->e_ident[EI_MAG0] == ELFMAG0
2300 && ehdr->e_ident[EI_MAG1] == ELFMAG1
2301 && ehdr->e_ident[EI_MAG2] == ELFMAG2
2302 && ehdr->e_ident[EI_MAG3] == ELFMAG3
2303 && ehdr->e_ident[EI_CLASS] == ELF_CLASS
2304 && ehdr->e_ident[EI_DATA] == ELF_DATA
2305 && ehdr->e_ident[EI_VERSION] == EV_CURRENT);
2312 return (elf_check_arch(ehdr->e_machine)
2313 && elf_check_abi(ehdr->e_flags)
2314 && ehdr->e_ehsize == sizeof(struct elfhdr)
2315 && ehdr->e_phentsize == sizeof(struct elf_phdr)
2316 && (ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN));
2333 return 0; /* bullet-proofing */
2337 int offset = ((p - 1) % TARGET_PAGE_SIZE) + 1;
2338 for (i = argc - 1; i >= 0; --i) {
2342 exit(-1);
2347 if (len > (p - stack_limit)) {
2352 tmp -= bytes_to_copy;
2353 p -= bytes_to_copy;
2354 offset -= bytes_to_copy;
2355 len -= bytes_to_copy;
2360 memcpy_to_target(p, scratch, top - p);
2367 memcpy_to_target(p, scratch + offset, top - p);
2370 int remaining = TARGET_PAGE_SIZE - (p % TARGET_PAGE_SIZE);
2375 exit(-1);
2378 if (len > (stack_limit - p)) {
2384 memcpy_fromfs(scratch + (p - top), tmp, bytes_to_copy);
2387 remaining -= bytes_to_copy;
2389 len -= bytes_to_copy;
2392 memcpy_to_target(top, scratch, p - top);
2399 memcpy_to_target(top, scratch, p - top);
2435 if (info->exec_stack) {
2439 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
2440 if (error == -1) {
2442 exit(-1);
2448 info->stack_limit = error + guard;
2449 return info->stack_limit + size - sizeof(void *);
2451 info->stack_limit = error + size;
2469 error_setg(errp, "PT_LOAD with non-writable bss");
2488 align_bss -= TARGET_PAGE_SIZE;
2498 "non-writable page");
2503 memset(g2h_untagged(start_bss), 0, align_bss - start_bss);
2508 target_mmap(align_bss, end_bss - align_bss, prot,
2509 MAP_FIXED | MAP_PRIVATE | MAP_ANON, -1, 0) == -1) {
2519 return exec->e_ident[EI_OSABI] == ELFOSABI_ARM_FDPIC;
2524 return exec->e_ident[EI_OSABI] == ELFOSABI_XTENSA_FDPIC;
2537 struct elf32_fdpic_loadseg *loadsegs = info->loadsegs;
2540 n = info->nsegs;
2541 while (n--) {
2542 sp -= 12;
2549 sp -= 4;
2551 put_user_u16(info->nsegs, sp+2); /* nsegs */
2553 info->personality = PER_LINUX_FDPIC;
2554 info->loadmap_addr = sp;
2582 info->other_info = interp_info;
2584 interp_info->other_info = info;
2586 info->interpreter_loadmap_addr = interp_info->loadmap_addr;
2587 info->interpreter_pt_dynamic_addr = interp_info->pt_dynamic_addr;
2589 info->interpreter_loadmap_addr = 0;
2590 info->interpreter_pt_dynamic_addr = 0;
2599 sp -= (len + n - 1) & ~(n - 1);
2601 /* FIXME - check return value of memcpy_to_target() for failure */
2615 sp -= (len + n - 1) & ~(n - 1);
2617 /* FIXME - check return value of memcpy_to_target() for failure */
2640 sp -= 16;
2642 /* FIXME - check return value of memcpy_to_target() for failure */
2666 info->auxv_len = size * n;
2674 u_argc = QEMU_ALIGN_DOWN(sp - size, STACK_ALIGNMENT);
2684 info->saved_auxv = u_auxv;
2685 info->argc = argc;
2686 info->envc = envc;
2687 info->argv = u_argv;
2688 info->envp = u_envp;
2706 * on info->auxv_len will trigger.
2708 NEW_AUX_ENT(AT_PHDR, (abi_ulong)(info->load_addr + exec->e_phoff));
2710 NEW_AUX_ENT(AT_PHNUM, (abi_ulong)(exec->e_phnum));
2712 NEW_AUX_ENT(AT_BASE, (abi_ulong)(interp_info ? interp_info->load_addr : 0));
2714 NEW_AUX_ENT(AT_ENTRY, info->entry);
2723 NEW_AUX_ENT(AT_EXECFN, info->file_string);
2736 NEW_AUX_ENT(AT_SYSINFO_EHDR, vdso_info->load_addr);
2744 assert(info->auxv_len == u_auxv - info->saved_auxv);
2748 p = info->arg_strings;
2756 p = info->env_strings;
2768 #define LO_COMMPAGE -1
2773 #define LO_COMMPAGE -1
2786 * return 0 if it is not available to map, and -1 on mmap error.
2791 size_t size = addr_last - addr + 1;
2794 MAP_NORESERVE | MAP_FIXED_NOREPLACE, -1, 0);
2798 return errno == EEXIST ? 0 : -1;
2818 uintptr_t brk_last = brk + 16 * MiB - 1;
2844 for (int i = ga->nbounds - 1; i >= 0; --i) {
2845 if (pgb_try_mmap_skip_brk(ga->bounds[i][0] + base,
2846 ga->bounds[i][1] + base,
2873 if (LO_COMMPAGE != -1 && LO_COMMPAGE < mmap_min_addr) {
2885 ga->bounds[n][0] = try_identity ? mmap_min_addr : 0;
2886 ga->bounds[n][1] = reserved_va;
2891 if (LO_COMMPAGE != -1) {
2892 ga->bounds[n][0] = 0;
2893 ga->bounds[n][1] = LO_COMMPAGE + TARGET_PAGE_SIZE - 1;
2896 ga->bounds[n][0] = 0;
2897 ga->bounds[n][1] = TARGET_PAGE_SIZE - 1;
2903 ga->bounds[n][0] = guest_loaddr;
2904 ga->bounds[n][1] = guest_hiaddr;
2915 #pragma GCC diagnostic ignored "-Wtype-limits"
2919 ga->bounds[n][0] = HI_COMMPAGE & qemu_real_host_page_mask();
2920 ga->bounds[n][1] = HI_COMMPAGE + TARGET_PAGE_SIZE - 1;
2926 ga->nbounds = n;
2933 "(omit the -B option or choose a different value)",
2976 if (base >= -skip) {
2977 return -1;
2985 for (int i = ga->nbounds - 1; i >= 0; --i) {
2986 uintptr_t s = base + ga->bounds[i][0];
2987 uintptr_t l = base + ga->bounds[i][1];
2992 return mmap_min_addr - s;
2998 return n->last - s + 1;
3013 return -1;
3023 return -1;
3033 return pgb_try_mmap_set(ga, base, brk) ? base : -1;
3053 * Rebuild the address set for non-identity map.
3071 b->start = brk;
3072 b->last = brk + 16 * MiB - 1;
3079 if (ret == -1) {
3086 error_printf(" %0*" PRIx64 "-%0*" PRIx64 "\n",
3156 datasz -= *off;
3165 datasz -= 2 * sizeof(uint32_t);
3190 error_setg(errp, "Ill-formed property in PT_GNU_PROPERTY");
3215 n = phdr->p_filesz;
3225 if (!imgsrc_read(¬e, phdr->p_offset, n, src, errp)) {
3311 phdr = imgsrc_read_alloc(ehdr->e_phoff,
3312 ehdr->e_phnum * sizeof(struct elf_phdr),
3317 bswap_phdr(phdr, ehdr->e_phnum);
3319 info->nsegs = 0;
3320 info->pt_dynamic_addr = 0;
3326 * amount of memory to handle that. Locate the interpreter, if any.
3328 loaddr = -1, hiaddr = 0;
3330 info->exec_stack = EXSTACK_DEFAULT;
3331 for (i = 0; i < ehdr->e_phnum; ++i) {
3333 if (eppnt->p_type == PT_LOAD) {
3334 abi_ulong a = eppnt->p_vaddr & TARGET_PAGE_MASK;
3338 a = eppnt->p_vaddr + eppnt->p_memsz - 1;
3342 ++info->nsegs;
3343 align |= eppnt->p_align;
3344 } else if (eppnt->p_type == PT_INTERP && pinterp_name) {
3352 interp_name = imgsrc_read_alloc(eppnt->p_offset, eppnt->p_filesz,
3357 if (interp_name[eppnt->p_filesz - 1] != 0) {
3362 } else if (eppnt->p_type == PT_GNU_PROPERTY) {
3366 } else if (eppnt->p_type == PT_GNU_STACK) {
3367 info->exec_stack = eppnt->p_flags & PF_X;
3376 if (ehdr->e_type == ET_EXEC) {
3387 probe_guest_base(image_name, 0, hiaddr - loaddr);
3402 load_addr &= -align;
3418 * pre-linked, LOAD_ADDR will be non-zero, and the kernel should
3424 reserve_size = (size_t)hiaddr - loaddr + 1;
3427 if (ehdr->e_type != ET_EXEC && align > qemu_real_host_page_size()) {
3428 align_size += align - 1;
3433 (ehdr->e_type == ET_EXEC ? MAP_FIXED_NOREPLACE : 0),
3434 -1, 0);
3435 if (load_addr == -1) {
3445 target_munmap(load_addr, align_addr - load_addr);
3448 target_munmap(align_end, load_end - align_end);
3453 load_bias = load_addr - loaddr;
3456 struct elf32_fdpic_loadseg *loadsegs = info->loadsegs =
3457 g_malloc(sizeof(*loadsegs) * info->nsegs);
3459 for (i = 0; i < ehdr->e_phnum; ++i) {
3462 info->pt_dynamic_addr = phdr[i].p_vaddr + load_bias;
3465 loadsegs->addr = phdr[i].p_vaddr + load_bias;
3466 loadsegs->p_vaddr = phdr[i].p_vaddr;
3467 loadsegs->p_memsz = phdr[i].p_memsz;
3474 info->load_bias = load_bias;
3475 info->code_offset = load_bias;
3476 info->data_offset = load_bias;
3477 info->load_addr = load_addr;
3478 info->entry = ehdr->e_entry + load_bias;
3479 info->start_code = -1;
3480 info->end_code = 0;
3481 info->start_data = -1;
3482 info->end_data = 0;
3484 info->brk = TARGET_PAGE_ALIGN(hiaddr + load_bias);
3485 info->elf_flags = ehdr->e_flags;
3494 * The startup binary is either the interpreter or the static executable.
3495 * The interpreter is responsible for all pages of a dynamic executable.
3498 * Do not enable BTI unless it is supported.
3500 if ((info->note_flags & GNU_PROPERTY_AARCH64_FEATURE_1_BTI)
3507 for (i = 0; i < ehdr->e_phnum; i++) {
3509 if (eppnt->p_type == PT_LOAD) {
3513 if (eppnt->p_flags & PF_R) {
3516 if (eppnt->p_flags & PF_W) {
3519 if (eppnt->p_flags & PF_X) {
3523 vaddr = load_bias + eppnt->p_vaddr;
3527 vaddr_ef = vaddr + eppnt->p_filesz;
3528 vaddr_em = vaddr + eppnt->p_memsz;
3531 * Some segments may be completely empty, with a non-zero p_memsz
3534 if (eppnt->p_filesz != 0) {
3535 error = imgsrc_mmap(vaddr_ps, eppnt->p_filesz + vaddr_po,
3537 src, eppnt->p_offset - vaddr_po);
3538 if (error == -1) {
3551 if (vaddr < info->start_code) {
3552 info->start_code = vaddr;
3554 if (vaddr_ef > info->end_code) {
3555 info->end_code = vaddr_ef;
3559 if (vaddr < info->start_data) {
3560 info->start_data = vaddr;
3562 if (vaddr_ef > info->end_data) {
3563 info->end_data = vaddr_ef;
3567 } else if (eppnt->p_type == PT_MIPS_ABIFLAGS) {
3570 if (!imgsrc_read(&abiflags, eppnt->p_offset, sizeof(abiflags),
3575 info->fp_abi = abiflags.fp_abi;
3580 if (info->end_data == 0) {
3581 info->start_data = info->end_code;
3582 info->end_data = info->end_code;
3589 debuginfo_report_elf(image_name, src->fd, load_bias);
3593 close(src->fd);
3601 exit(-1);
3616 exit(-1);
3623 exit(-1);
3648 src.fd = -1;
3649 src.cache = vdso->image;
3650 src.cache_size = vdso->image_size;
3652 load_elf_image("<internal-vdso>", &src, info, &ehdr, NULL);
3653 load_addr = info->load_addr;
3654 load_bias = info->load_bias;
3660 * We pre-processed the image to locate all of the addresses that need
3663 for (unsigned i = 0, n = vdso->reloc_count; i < n; i++) {
3664 abi_ulong *addr = g2h_untagged(load_addr + vdso->relocs[i]);
3669 if (vdso->sigreturn_ofs) {
3670 default_sigreturn = load_addr + vdso->sigreturn_ofs;
3672 if (vdso->rt_sigreturn_ofs) {
3673 default_rt_sigreturn = load_addr + vdso->rt_sigreturn_ofs;
3677 target_mprotect(info->start_data, info->end_data - info->start_data,
3684 __typeof(sym->st_value) addr = *(uint64_t *)s0;
3687 if (addr < sym->st_value) {
3688 result = -1;
3689 } else if (addr >= sym->st_value + sym->st_size) {
3698 struct elf_sym *syms = s->disas_symtab.elf32;
3700 struct elf_sym *syms = s->disas_symtab.elf64;
3706 sym = bsearch(&orig_addr, syms, s->disas_num_syms, sizeof(*syms), symfind);
3708 return s->disas_strtab + sym->st_name;
3719 return (sym0->st_value < sym1->st_value)
3720 ? -1
3721 : ((sym0->st_value > sym1->st_value) ? 1 : 0);
3735 shnum = hdr->e_shnum;
3736 shdr = imgsrc_read_alloc(hdr->e_shoff, shnum * sizeof(struct elf_shdr),
3789 if (i < --nsyms) {
3824 s->disas_strtab = strings;
3825 s->disas_num_syms = nsyms;
3827 s->disas_symtab.elf32 = syms;
3829 s->disas_symtab.elf64 = syms;
3831 s->lookup_symbol = lookup_symbolxx;
3832 s->next = syminfos;
3850 if (offset == (off_t) -1) {
3858 if (offset == (off_t) -1) {
3881 * We will have overwritten the original when we re-use bprm->buf
3882 * while loading the interpreter. Allocate the storage for this now
3895 load_elf_image(bprm->filename, &bprm->src, info, &ehdr, &elf_interpreter);
3897 /* Do this so that we can load the interpreter, if need be. We will
3899 bprm->p = setup_arg_pages(bprm, info);
3903 bprm->p = copy_elf_strings(1, &bprm->filename, scratch,
3904 bprm->p, info->stack_limit);
3905 info->file_string = bprm->p;
3906 bprm->p = copy_elf_strings(bprm->envc, bprm->envp, scratch,
3907 bprm->p, info->stack_limit);
3908 info->env_strings = bprm->p;
3909 bprm->p = copy_elf_strings(bprm->argc, bprm->argv, scratch,
3910 bprm->p, info->stack_limit);
3911 info->arg_strings = bprm->p;
3913 info->arg_strings = bprm->p;
3914 bprm->p = copy_elf_strings(bprm->argc, bprm->argv, scratch,
3915 bprm->p, info->stack_limit);
3916 info->env_strings = bprm->p;
3917 bprm->p = copy_elf_strings(bprm->envc, bprm->envp, scratch,
3918 bprm->p, info->stack_limit);
3919 info->file_string = bprm->p;
3920 bprm->p = copy_elf_strings(1, &bprm->filename, scratch,
3921 bprm->p, info->stack_limit);
3926 if (!bprm->p) {
3927 fprintf(stderr, "%s: %s\n", bprm->filename, strerror(E2BIG));
3928 exit(-1);
3932 load_elf_interp(elf_interpreter, &interp_info, bprm->buf);
3936 * with the mappings the interpreter can be loaded above but
3940 * interpreter.
3942 if (interp_info.brk > info->brk &&
3943 interp_info.load_bias - info->brk < 16 * MiB) {
3944 info->brk = interp_info.brk;
3947 /* If the program interpreter is one of these two, then assume
3952 info->personality = PER_SVR4;
3954 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
3960 -1, 0);
3963 info->interp_fp_abi = interp_info.fp_abi;
3971 const VdsoImageInfo *vdso = vdso_image_info(info->elf_flags);
3974 info->vdso = vdso_info.load_bias;
3978 MAP_PRIVATE | MAP_ANON, -1, 0);
3979 if (tramp_page == -1) {
3980 return -errno;
3987 bprm->p = create_elf_tables(bprm->p, bprm->argc, bprm->envc, &ehdr, info,
3990 info->start_stack = bprm->p;
3992 /* If we have an interpreter, set that as the program's entry point.
3997 info->load_bias = interp_info.load_bias;
3998 info->entry = interp_info.entry;
4003 bprm->core_dump = &elf_core_dump;
4012 * Definitions to generate Intel SVR4-like core files.
4019 * Fields we don't dump (their contents is zero) in linux-user qemu
4044 * regs - copy register values into here (allocated and zeroed by caller)
4045 * env - copy registers from here
4095 prstatus->pr_info.si_signo = tswap32(prstatus->pr_info.si_signo);
4096 prstatus->pr_info.si_code = tswap32(prstatus->pr_info.si_code);
4097 prstatus->pr_info.si_errno = tswap32(prstatus->pr_info.si_errno);
4098 prstatus->pr_cursig = tswap16(prstatus->pr_cursig);
4099 prstatus->pr_sigpend = tswapal(prstatus->pr_sigpend);
4100 prstatus->pr_sighold = tswapal(prstatus->pr_sighold);
4101 prstatus->pr_pid = tswap32(prstatus->pr_pid);
4102 prstatus->pr_ppid = tswap32(prstatus->pr_ppid);
4103 prstatus->pr_pgrp = tswap32(prstatus->pr_pgrp);
4104 prstatus->pr_sid = tswap32(prstatus->pr_sid);
4107 prstatus->pr_fpvalid = tswap32(prstatus->pr_fpvalid);
4116 psinfo->pr_flag = tswapal(psinfo->pr_flag);
4117 psinfo->pr_uid = tswap16(psinfo->pr_uid);
4118 psinfo->pr_gid = tswap16(psinfo->pr_gid);
4119 psinfo->pr_pid = tswap32(psinfo->pr_pid);
4120 psinfo->pr_ppid = tswap32(psinfo->pr_ppid);
4121 psinfo->pr_pgrp = tswap32(psinfo->pr_pgrp);
4122 psinfo->pr_sid = tswap32(psinfo->pr_sid);
4131 bswap32s(&en->n_namesz);
4132 bswap32s(&en->n_descsz);
4133 bswap32s(&en->n_type);
4148 * non-writable code that debugger can read directly from
4157 return end - start;
4176 n->n_namesz = namesz;
4177 n->n_descsz = datasz;
4178 n->n_type = type;
4194 memcpy(elf->e_ident, ELFMAG, SELFMAG);
4196 elf->e_ident[EI_CLASS] = ELF_CLASS;
4197 elf->e_ident[EI_DATA] = ELF_DATA;
4198 elf->e_ident[EI_VERSION] = EV_CURRENT;
4199 elf->e_ident[EI_OSABI] = ELF_OSABI;
4201 elf->e_type = ET_CORE;
4202 elf->e_machine = machine;
4203 elf->e_version = EV_CURRENT;
4204 elf->e_phoff = sizeof(struct elfhdr);
4205 elf->e_flags = flags;
4206 elf->e_ehsize = sizeof(struct elfhdr);
4207 elf->e_phentsize = sizeof(struct elf_phdr);
4208 elf->e_phnum = segs;
4215 phdr->p_type = PT_NOTE;
4216 phdr->p_offset = offset;
4217 phdr->p_filesz = sz;
4232 .pr_pid = get_task_state(cpu)->ts_tid,
4261 len = ts->info->env_strings - ts->info->arg_strings;
4263 memcpy(&psinfo.pr_psargs, g2h_untagged(ts->info->arg_strings), len);
4270 base_filename = g_path_get_basename(ts->bprm->filename);
4272 * Using strncpy here is fine: at max-length,
4273 * this field is not NUL-terminated.
4284 memcpy(data, g2h_untagged(ts->info->saved_auxv), ts->info->auxv_len);
4290 * qemu_<basename-of-target-binary>_<date>-<time>_<pid>.core
4297 g_autofree char *nowstr = g_date_time_format(now, "%Y%m%d-%H%M%S");
4298 g_autofree char *base_filename = g_path_get_basename(ts->bprm->filename);
4321 return (-1);
4323 return (-1);
4326 bytes_left -= bytes_written;
4340 if (end - start <= step) {
4359 css->count++;
4360 css->size += vma_dump_size(start, end, flags);
4373 struct elf_phdr *phdr = d->phdr;
4375 phdr->p_type = PT_LOAD;
4376 phdr->p_vaddr = start;
4377 phdr->p_paddr = 0;
4378 phdr->p_filesz = vma_dump_size(start, end, flags);
4379 phdr->p_offset = d->offset;
4380 d->offset += phdr->p_filesz;
4381 phdr->p_memsz = end - start;
4382 phdr->p_flags = (flags & PAGE_READ ? PF_R : 0)
4385 phdr->p_align = ELF_EXEC_PAGESIZE;
4388 d->phdr = phdr + 1;
4412 * 0 +----------------------+ \
4414 * +----------------------+ |
4415 * | ELF program headers | |--- headers
4416 * | - NOTE section | |
4417 * | - PT_LOAD sections | |
4418 * +----------------------+ /
4420 * | - NT_PRSTATUS |
4421 * | - NT_PRSINFO |
4422 * | - NT_AUXV |
4423 * +----------------------+ <-- aligned to target page
4429 * +----------------------+
4431 * NT_PRSTATUS -> struct elf_prstatus (per thread)
4432 * NT_PRSINFO -> struct elf_prpsinfo
4437 * - no floating point registers are dumped
4456 int fd = -1;
4489 offset += size_note("CORE", ts->info->auxv_len);
4492 note_size = offset - note_offset;
4537 dptr = fill_note(&hptr, NT_AUXV, "CORE", ts->info->auxv_len);
4564 ret = -errno;