Revision 53a5960a linux-user/main.c
| b/linux-user/main.c | ||
|---|---|---|
| 152 | 152 |
int flags) |
| 153 | 153 |
{
|
| 154 | 154 |
unsigned int e1, e2; |
| 155 |
uint32_t *p; |
|
| 155 | 156 |
e1 = (addr << 16) | (limit & 0xffff); |
| 156 | 157 |
e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000); |
| 157 | 158 |
e2 |= flags; |
| 158 |
stl((uint8_t *)ptr, e1); |
|
| 159 |
stl((uint8_t *)ptr + 4, e2); |
|
| 159 |
p = ptr; |
|
| 160 |
p[0] = tswapl(e1); |
|
| 161 |
p[1] = tswapl(e2); |
|
| 160 | 162 |
} |
| 161 | 163 |
|
| 162 | 164 |
static void set_gate(void *ptr, unsigned int type, unsigned int dpl, |
| 163 | 165 |
unsigned long addr, unsigned int sel) |
| 164 | 166 |
{
|
| 165 | 167 |
unsigned int e1, e2; |
| 168 |
uint32_t *p; |
|
| 166 | 169 |
e1 = (addr & 0xffff) | (sel << 16); |
| 167 | 170 |
e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8); |
| 168 |
stl((uint8_t *)ptr, e1); |
|
| 169 |
stl((uint8_t *)ptr + 4, e2); |
|
| 171 |
p = ptr; |
|
| 172 |
p[0] = tswapl(e1); |
|
| 173 |
p[1] = tswapl(e2); |
|
| 170 | 174 |
} |
| 171 | 175 |
|
| 172 | 176 |
uint64_t gdt_table[6]; |
| ... | ... | |
| 343 | 347 |
|
| 344 | 348 |
/* we handle the FPU emulation here, as Linux */ |
| 345 | 349 |
/* we get the opcode */ |
| 346 |
opcode = ldl_raw((uint8_t *)env->regs[15]);
|
|
| 350 |
opcode = tget32(env->regs[15]);
|
|
| 347 | 351 |
|
| 348 | 352 |
if (EmulateAll(opcode, &ts->fpa, env) == 0) {
|
| 349 | 353 |
info.si_signo = SIGILL; |
| ... | ... | |
| 364 | 368 |
/* system call */ |
| 365 | 369 |
if (trapnr == EXCP_BKPT) {
|
| 366 | 370 |
if (env->thumb) {
|
| 367 |
insn = lduw((void *)(env->regs[15]));
|
|
| 371 |
insn = tget16(env->regs[15]);
|
|
| 368 | 372 |
n = insn & 0xff; |
| 369 | 373 |
env->regs[15] += 2; |
| 370 | 374 |
} else {
|
| 371 |
insn = ldl((void *)(env->regs[15]));
|
|
| 375 |
insn = tget32(env->regs[15]);
|
|
| 372 | 376 |
n = (insn & 0xf) | ((insn >> 4) & 0xff0); |
| 373 | 377 |
env->regs[15] += 4; |
| 374 | 378 |
} |
| 375 | 379 |
} else {
|
| 376 | 380 |
if (env->thumb) {
|
| 377 |
insn = lduw((void *)(env->regs[15] - 2));
|
|
| 381 |
insn = tget16(env->regs[15] - 2);
|
|
| 378 | 382 |
n = insn & 0xff; |
| 379 | 383 |
} else {
|
| 380 |
insn = ldl((void *)(env->regs[15] - 4));
|
|
| 384 |
insn = tget32(env->regs[15] - 4);
|
|
| 381 | 385 |
n = insn & 0xffffff; |
| 382 | 386 |
} |
| 383 | 387 |
} |
| ... | ... | |
| 475 | 479 |
static inline void save_window_offset(CPUSPARCState *env, int cwp1) |
| 476 | 480 |
{
|
| 477 | 481 |
unsigned int i; |
| 478 |
uint32_t *sp_ptr;
|
|
| 482 |
target_ulong sp_ptr;
|
|
| 479 | 483 |
|
| 480 |
sp_ptr = (uint32_t *)(env->regbase[get_reg_index(env, cwp1, 6)]);
|
|
| 484 |
sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
|
|
| 481 | 485 |
#if defined(DEBUG_WIN) |
| 482 | 486 |
printf("win_overflow: sp_ptr=0x%x save_cwp=%d\n",
|
| 483 | 487 |
(int)sp_ptr, cwp1); |
| 484 | 488 |
#endif |
| 485 | 489 |
for(i = 0; i < 16; i++) {
|
| 486 |
put_user(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
|
|
| 487 |
sp_ptr++;
|
|
| 490 |
tputl(sp_ptr, env->regbase[get_reg_index(env, cwp1, 8 + i)]);
|
|
| 491 |
sp_ptr += sizeof(target_ulong);
|
|
| 488 | 492 |
} |
| 489 | 493 |
} |
| 490 | 494 |
|
| ... | ... | |
| 500 | 504 |
static void restore_window(CPUSPARCState *env) |
| 501 | 505 |
{
|
| 502 | 506 |
unsigned int new_wim, i, cwp1; |
| 503 |
uint32_t *sp_ptr, reg;
|
|
| 507 |
target_ulong sp_ptr;
|
|
| 504 | 508 |
|
| 505 | 509 |
new_wim = ((env->wim << 1) | (env->wim >> (NWINDOWS - 1))) & |
| 506 | 510 |
((1LL << NWINDOWS) - 1); |
| 507 | 511 |
|
| 508 | 512 |
/* restore the invalid window */ |
| 509 | 513 |
cwp1 = (env->cwp + 1) & (NWINDOWS - 1); |
| 510 |
sp_ptr = (uint32_t *)(env->regbase[get_reg_index(env, cwp1, 6)]);
|
|
| 514 |
sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
|
|
| 511 | 515 |
#if defined(DEBUG_WIN) |
| 512 | 516 |
printf("win_underflow: sp_ptr=0x%x load_cwp=%d\n",
|
| 513 | 517 |
(int)sp_ptr, cwp1); |
| 514 | 518 |
#endif |
| 515 | 519 |
for(i = 0; i < 16; i++) {
|
| 516 |
get_user(reg, sp_ptr); |
|
| 517 |
env->regbase[get_reg_index(env, cwp1, 8 + i)] = reg; |
|
| 518 |
sp_ptr++; |
|
| 520 |
env->regbase[get_reg_index(env, cwp1, 8 + i)] = tgetl(sp_ptr); |
|
| 521 |
sp_ptr += sizeof(target_ulong); |
|
| 519 | 522 |
} |
| 520 | 523 |
env->wim = new_wim; |
| 521 | 524 |
} |
| ... | ... | |
| 1304 | 1307 |
if (nb_args >= 5) {
|
| 1305 | 1308 |
sp_reg = env->gpr[29]; |
| 1306 | 1309 |
/* these arguments are taken from the stack */ |
| 1307 |
if (get_user(arg5, (target_ulong *)(sp_reg + 16))) {
|
|
| 1308 |
ret = -EFAULT; |
|
| 1309 |
goto fail; |
|
| 1310 |
} |
|
| 1310 |
arg5 = tgetl(sp_reg + 16); |
|
| 1311 | 1311 |
if (nb_args >= 6) {
|
| 1312 |
if (get_user(arg6, (target_ulong *)(sp_reg + 20))) {
|
|
| 1313 |
ret = -EFAULT; |
|
| 1314 |
goto fail; |
|
| 1315 |
} |
|
| 1312 |
arg6 = tgetl(sp_reg + 20); |
|
| 1316 | 1313 |
} else {
|
| 1317 | 1314 |
arg6 = 0; |
| 1318 | 1315 |
} |
| ... | ... | |
| 1347 | 1344 |
{
|
| 1348 | 1345 |
uint32_t insn, op; |
| 1349 | 1346 |
|
| 1350 |
if (get_user(insn, (uint32_t *)env->PC) < 0) |
|
| 1351 |
goto sigill; |
|
| 1347 |
insn = tget32(env->PC); |
|
| 1352 | 1348 |
op = insn >> 26; |
| 1353 | 1349 |
// printf("insn=%08x op=%02x\n", insn, op);
|
| 1354 | 1350 |
/* XXX: totally dummy FP ops just to be able to launch |
| ... | ... | |
| 1531 | 1527 |
fprintf(logfile, "entry 0x%08lx\n" , info->entry); |
| 1532 | 1528 |
} |
| 1533 | 1529 |
|
| 1534 |
target_set_brk((char *)info->brk);
|
|
| 1530 |
target_set_brk(info->brk); |
|
| 1535 | 1531 |
syscall_init(); |
| 1536 | 1532 |
signal_init(); |
| 1537 | 1533 |
|
| ... | ... | |
| 1566 | 1562 |
env->eip = regs->eip; |
| 1567 | 1563 |
|
| 1568 | 1564 |
/* linux interrupt setup */ |
| 1569 |
env->idt.base = (long)idt_table;
|
|
| 1565 |
env->idt.base = h2g(idt_table);
|
|
| 1570 | 1566 |
env->idt.limit = sizeof(idt_table) - 1; |
| 1571 | 1567 |
set_idt(0, 0); |
| 1572 | 1568 |
set_idt(1, 0); |
| ... | ... | |
| 1591 | 1587 |
set_idt(0x80, 3); |
| 1592 | 1588 |
|
| 1593 | 1589 |
/* linux segment setup */ |
| 1594 |
env->gdt.base = (long)gdt_table;
|
|
| 1590 |
env->gdt.base = h2g(gdt_table);
|
|
| 1595 | 1591 |
env->gdt.limit = sizeof(gdt_table) - 1; |
| 1596 | 1592 |
write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff, |
| 1597 | 1593 |
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | |
Also available in: Unified diff