Revision 5fafdf24 linux-user/vm86.c

b/linux-user/vm86.c
1 1
/*
2 2
 *  vm86 linux syscall support
3
 * 
3
 *
4 4
 *  Copyright (c) 2003 Fabrice Bellard
5 5
 *
6 6
 *  This program is free software; you can redistribute it and/or modify
......
85 85
    target_v86->regs.eflags = tswap32(env->eflags);
86 86
    unlock_user_struct(target_v86, ts->target_v86, 1);
87 87
#ifdef DEBUG_VM86
88
    fprintf(logfile, "save_v86_state: eflags=%08x cs:ip=%04x:%04x\n", 
88
    fprintf(logfile, "save_v86_state: eflags=%08x cs:ip=%04x:%04x\n",
89 89
            env->eflags, env->segs[R_CS].selector, env->eip);
90 90
#endif
91 91

  
......
123 123
static inline int set_IF(CPUX86State *env)
124 124
{
125 125
    TaskState *ts = env->opaque;
126
    
126
   
127 127
    ts->v86flags |= VIF_MASK;
128 128
    if (ts->v86flags & VIP_MASK) {
129 129
        return_to_32bit(env, TARGET_VM86_STI);
......
202 202
        goto cannot_handle;
203 203
    if (is_revectored(intno, &ts->vm86plus.int_revectored))
204 204
        goto cannot_handle;
205
    if (intno == 0x21 && is_revectored((env->regs[R_EAX] >> 8) & 0xff, 
205
    if (intno == 0x21 && is_revectored((env->regs[R_EAX] >> 8) & 0xff,
206 206
                                       &ts->vm86plus.int21_revectored))
207 207
        goto cannot_handle;
208 208
    int_ptr = (uint32_t *)(intno << 2);
......
210 210
    if ((segoffs >> 16) == TARGET_BIOSSEG)
211 211
        goto cannot_handle;
212 212
#if defined(DEBUG_VM86)
213
    fprintf(logfile, "VM86: emulating int 0x%x. CS:IP=%04x:%04x\n", 
213
    fprintf(logfile, "VM86: emulating int 0x%x. CS:IP=%04x:%04x\n",
214 214
            intno, segoffs >> 16, segoffs & 0xffff);
215 215
#endif
216 216
    /* save old state */
......
264 264
    csp = (uint8_t *)(env->segs[R_CS].selector << 4);
265 265
    ip = env->eip & 0xffff;
266 266
    pc = csp + ip;
267
    
267
   
268 268
    ssp = (uint8_t *)(env->segs[R_SS].selector << 4);
269 269
    sp = env->regs[R_ESP] & 0xffff;
270 270

  
......
330 330
        ADD16(ip, 1);
331 331
        env->eip = ip;
332 332
        if (ts->vm86plus.vm86plus.flags & TARGET_vm86dbg_active) {
333
            if ( (ts->vm86plus.vm86plus.vm86dbg_intxxtab[intno >> 3] >> 
333
            if ( (ts->vm86plus.vm86plus.vm86dbg_intxxtab[intno >> 3] >>
334 334
                  (intno &7)) & 1) {
335 335
                return_to_32bit(env, TARGET_VM86_INTx + (intno << 8));
336 336
                return;
......
362 362
                return;
363 363
        }
364 364
        VM86_FAULT_RETURN;
365
        
365
       
366 366
    case 0xfa: /* cli */
367 367
        env->eip = ip;
368 368
        clear_IF(env);
369 369
        VM86_FAULT_RETURN;
370
        
370
       
371 371
    case 0xfb: /* sti */
372 372
        env->eip = ip;
373 373
        if (set_IF(env))
......
386 386
    TaskState *ts = env->opaque;
387 387
    struct target_vm86plus_struct * target_v86;
388 388
    int ret;
389
    
389
   
390 390
    switch (subfunction) {
391 391
    case TARGET_VM86_REQUEST_IRQ:
392 392
    case TARGET_VM86_FREE_IRQ:
......
427 427
    lock_user_struct(target_v86, vm86_addr, 1);
428 428
    /* build vm86 CPU state */
429 429
    ts->v86flags = tswap32(target_v86->regs.eflags);
430
    env->eflags = (env->eflags & ~SAFE_MASK) | 
430
    env->eflags = (env->eflags & ~SAFE_MASK) |
431 431
        (tswap32(target_v86->regs.eflags) & SAFE_MASK) | VM_MASK;
432 432

  
433 433
    ts->vm86plus.cpu_type = tswapl(target_v86->cpu_type);
......
462 462
    cpu_x86_load_seg(env, R_GS, tswap16(target_v86->regs.gs));
463 463
    ret = tswap32(target_v86->regs.eax); /* eax will be restored at
464 464
                                            the end of the syscall */
465
    memcpy(&ts->vm86plus.int_revectored, 
465
    memcpy(&ts->vm86plus.int_revectored,
466 466
           &target_v86->int_revectored, 32);
467
    memcpy(&ts->vm86plus.int21_revectored, 
467
    memcpy(&ts->vm86plus.int21_revectored,
468 468
           &target_v86->int21_revectored, 32);
469 469
    ts->vm86plus.vm86plus.flags = tswapl(target_v86->vm86plus.flags);
470
    memcpy(&ts->vm86plus.vm86plus.vm86dbg_intxxtab, 
470
    memcpy(&ts->vm86plus.vm86plus.vm86dbg_intxxtab,
471 471
           target_v86->vm86plus.vm86dbg_intxxtab, 32);
472 472
    unlock_user_struct(target_v86, vm86_addr, 0);
473
    
473
   
474 474
#ifdef DEBUG_VM86
475
    fprintf(logfile, "do_vm86: cs:ip=%04x:%04x\n", 
475
    fprintf(logfile, "do_vm86: cs:ip=%04x:%04x\n",
476 476
            env->segs[R_CS].selector, env->eip);
477 477
#endif
478 478
    /* now the virtual CPU is ready for vm86 execution ! */

Also available in: Unified diff