git.oblomov.eu Git - wine/blob - programs/winedbg/be_i386.c

   1 /*
   2  * Debugger i386 specific functions
   3  *
   4  * Copyright 2004 Eric Pouech
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "debugger.h"
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
  25
  26 #ifdef __i386__
  27
  28   /* debugger/db_disasm.c */
  29 extern void             be_i386_disasm_one_insn(ADDRESS64* addr, int display);
  30
  31 #define STEP_FLAG 0x00000100 /* single step flag */
  32 #define V86_FLAG  0x00020000
  33
  34 #define IS_VM86_MODE(ctx) (ctx->EFlags & V86_FLAG)
  35
  36 static ADDRESS_MODE get_selector_type(HANDLE hThread, const CONTEXT* ctx, WORD sel)
  37 {
  38     LDT_ENTRY   le;
  39
  40     if (IS_VM86_MODE(ctx)) return AddrModeReal;
  41     /* null or system selector */
  42     if (!(sel & 4) || ((sel >> 3) < 17)) return AddrModeFlat;
  43     if (GetThreadSelectorEntry(hThread, sel, &le))
  44         return le.HighWord.Bits.Default_Big ? AddrMode1632 : AddrMode1616;
  45     /* selector doesn't exist */
  46     return -1;
  47 }
  48
  49 static void* be_i386_linearize(HANDLE hThread, const ADDRESS64* addr)
  50 {
  51     LDT_ENTRY   le;
  52
  53     switch (addr->Mode)
  54     {
  55     case AddrModeReal:
  56         return (void*)((DWORD)(LOWORD(addr->Segment) << 4) + (DWORD)addr->Offset);
  57     case AddrMode1632:
  58         if (!(addr->Segment & 4) || ((addr->Segment >> 3) < 17))
  59             return (void*)(DWORD)addr->Offset;
  60         /* fall through */
  61     case AddrMode1616:
  62         if (!GetThreadSelectorEntry(hThread, addr->Segment, &le)) return NULL;
  63         return (void*)((le.HighWord.Bits.BaseHi << 24) +
  64                        (le.HighWord.Bits.BaseMid << 16) + le.BaseLow +
  65                        (DWORD)addr->Offset);
  66         break;
  67     case AddrModeFlat:
  68         return (void*)(DWORD)addr->Offset;
  69     }
  70     return NULL;
  71 }
  72
  73 static unsigned be_i386_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* addr,
  74                                    unsigned seg, unsigned long offset)
  75 {
  76     addr->Mode    = AddrModeFlat;
  77     addr->Segment = seg;
  78     addr->Offset  = offset;
  79     if (seg)
  80     {
  81         addr->Mode = get_selector_type(hThread, ctx, seg);
  82         switch (addr->Mode)
  83         {
  84         case AddrModeReal:
  85         case AddrMode1616:
  86             addr->Offset &= 0xffff;
  87             break;
  88         case AddrModeFlat:
  89         case AddrMode1632:
  90             break;
  91         default:
  92             addr->Mode = -1;
  93             return FALSE;
  94         }
  95     }
  96     return TRUE;
  97 }
  98
  99 static unsigned be_i386_get_addr(HANDLE hThread, const CONTEXT* ctx,
 100                                  enum be_cpu_addr bca, ADDRESS64* addr)
 101 {
 102     switch (bca)
 103     {
 104     case be_cpu_addr_pc:
 105         return be_i386_build_addr(hThread, ctx, addr, ctx->SegCs, ctx->Eip);
 106     case be_cpu_addr_stack:
 107         return be_i386_build_addr(hThread, ctx, addr, ctx->SegSs, ctx->Esp);
 108     case be_cpu_addr_frame:
 109         return be_i386_build_addr(hThread, ctx, addr, ctx->SegSs, ctx->Ebp);
 110     }
 111     return FALSE;
 112 }
 113
 114 static void be_i386_single_step(CONTEXT* ctx, unsigned enable)
 115 {
 116     if (enable) ctx->EFlags |= STEP_FLAG;
 117     else ctx->EFlags &= ~STEP_FLAG;
 118 }
 119
 120 static void be_i386_all_print_context(HANDLE hThread, const CONTEXT* ctx)
 121 {
 122     long double ST[8];                         /* These are for floating regs */
 123     int         cnt;
 124
 125     /* Break out the FPU state and the floating point registers    */
 126     dbg_printf("Floating Point Unit status:\n");
 127     dbg_printf(" FLCW:%04x ", LOWORD(ctx->FloatSave.ControlWord));
 128     dbg_printf(" FLTW:%04x ", LOWORD(ctx->FloatSave.TagWord));
 129     dbg_printf(" FLEO:%08x ", (unsigned int) ctx->FloatSave.ErrorOffset);
 130     dbg_printf(" FLSW:%04x", LOWORD(ctx->FloatSave.StatusWord));
 131
 132     /* Isolate the condition code bits - note they are not contiguous */
 133     dbg_printf("(CC:%ld%ld%ld%ld", (ctx->FloatSave.StatusWord & 0x00004000) >> 14,
 134                                    (ctx->FloatSave.StatusWord & 0x00000400) >> 10,
 135                                    (ctx->FloatSave.StatusWord & 0x00000200) >> 9,
 136                                    (ctx->FloatSave.StatusWord & 0x00000100) >> 8);
 137
 138     /* Now pull out hte 3 bit of the TOP stack pointer */
 139     dbg_printf(" TOP:%01x", (unsigned int) (ctx->FloatSave.StatusWord & 0x00003800) >> 11);
 140
 141     /* Lets analyse the error bits and indicate the status
 142      * the Invalid Op flag has sub status which is tested as follows */
 143     if (ctx->FloatSave.StatusWord & 0x00000001) {     /* Invalid Fl OP   */
 144        if (ctx->FloatSave.StatusWord & 0x00000040) {  /* Stack Fault     */
 145           if (ctx->FloatSave.StatusWord & 0x00000200) /* C1 says Overflow */
 146              dbg_printf(" #IE(Stack Overflow)");
 147           else
 148              dbg_printf(" #IE(Stack Underflow)");     /* Underflow */
 149        }
 150        else  dbg_printf(" #IE(Arthimetic error)");    /* Invalid Fl OP   */
 151     }
 152
 153     if (ctx->FloatSave.StatusWord & 0x00000002) dbg_printf(" #DE"); /* Denormalised OP */
 154     if (ctx->FloatSave.StatusWord & 0x00000004) dbg_printf(" #ZE"); /* Zero Divide     */
 155     if (ctx->FloatSave.StatusWord & 0x00000008) dbg_printf(" #OE"); /* Overflow        */
 156     if (ctx->FloatSave.StatusWord & 0x00000010) dbg_printf(" #UE"); /* Underflow       */
 157     if (ctx->FloatSave.StatusWord & 0x00000020) dbg_printf(" #PE"); /* Precision error */
 158     if (ctx->FloatSave.StatusWord & 0x00000040)
 159        if (!(ctx->FloatSave.StatusWord & 0x00000001))
 160            dbg_printf(" #SE");                 /* Stack Fault (don't think this can occur) */
 161     if (ctx->FloatSave.StatusWord & 0x00000080) dbg_printf(" #ES"); /* Error Summary   */
 162     if (ctx->FloatSave.StatusWord & 0x00008000) dbg_printf(" #FB"); /* FPU Busy        */
 163     dbg_printf(")\n");
 164
 165     /* Here are the rest of the registers */
 166     dbg_printf(" FLES:%08x ", (unsigned int) ctx->FloatSave.ErrorSelector);
 167     dbg_printf(" FLDO:%08x ", (unsigned int) ctx->FloatSave.DataOffset);
 168     dbg_printf(" FLDS:%08x ", (unsigned int) ctx->FloatSave.DataSelector);
 169     dbg_printf(" FLCNS:%08x \n", (unsigned int) ctx->FloatSave.Cr0NpxState);
 170
 171     /* Now for the floating point registers */
 172     dbg_printf("Floating Point Registers:\n");
 173     for (cnt = 0; cnt < 4; cnt++)
 174     {
 175         memcpy(&ST[cnt], &ctx->FloatSave.RegisterArea[cnt * 10], 10);
 176         dbg_printf(" ST%d:%Lf ", cnt, ST[cnt]);
 177     }
 178     dbg_printf("\n");
 179     for (cnt = 4; cnt < 8; cnt++)
 180     {
 181         memcpy(&ST[cnt], &ctx->FloatSave.RegisterArea[cnt * 10], 10);
 182         dbg_printf(" ST%d:%Lf ", cnt, ST[cnt]);
 183     }
 184     dbg_printf("\n");
 185 }
 186
 187 static void be_i386_print_context(HANDLE hThread, const CONTEXT* ctx, int all_regs)
 188 {
 189     char        buf[33];
 190     char*       pt;
 191
 192     dbg_printf("Register dump:\n");
 193
 194     /* First get the segment registers out of the way */
 195     dbg_printf(" CS:%04x SS:%04x DS:%04x ES:%04x FS:%04x GS:%04x",
 196                (WORD)ctx->SegCs, (WORD)ctx->SegSs,
 197                (WORD)ctx->SegDs, (WORD)ctx->SegEs,
 198                (WORD)ctx->SegFs, (WORD)ctx->SegGs);
 199
 200     strcpy(buf, "   - 00      - - - ");
 201     pt = buf + strlen(buf) - 1;
 202     if (ctx->EFlags & 0x00000001) *pt-- = 'C'; /* Carry Flag */
 203     if (ctx->EFlags & 0x00000002) *pt-- = '1';
 204     if (ctx->EFlags & 0x00000004) *pt-- = 'P'; /* Parity Flag */
 205     if (ctx->EFlags & 0x00000008) *pt-- = '-';
 206     if (ctx->EFlags & 0x00000010) *pt-- = 'A'; /* Auxiliary Carry Flag */
 207     if (ctx->EFlags & 0x00000020) *pt-- = '-';
 208     if (ctx->EFlags & 0x00000040) *pt-- = 'Z'; /* Zero Flag */
 209     if (ctx->EFlags & 0x00000080) *pt-- = 'S'; /* Sign Flag */
 210     if (ctx->EFlags & 0x00000100) *pt-- = 'T'; /* Trap/Trace Flag */
 211     if (ctx->EFlags & 0x00000200) *pt-- = 'I'; /* Interupt Enable Flag */
 212     if (ctx->EFlags & 0x00000400) *pt-- = 'D'; /* Direction Indicator */
 213     if (ctx->EFlags & 0x00000800) *pt-- = 'O'; /* Overflow flags */
 214     if (ctx->EFlags & 0x00001000) *pt-- = '1'; /* I/O Privilege Level */
 215     if (ctx->EFlags & 0x00002000) *pt-- = '1'; /* I/O Privilege Level */
 216     if (ctx->EFlags & 0x00004000) *pt-- = 'N'; /* Nested Task Flag */
 217     if (ctx->EFlags & 0x00008000) *pt-- = '-';
 218     if (ctx->EFlags & 0x00010000) *pt-- = 'R'; /* Resume Flag */
 219     if (ctx->EFlags & 0x00020000) *pt-- = 'V'; /* Vritual Mode Flag */
 220     if (ctx->EFlags & 0x00040000) *pt-- = 'a'; /* Alignment Check Flag */
 221
 222     switch (get_selector_type(hThread, ctx, ctx->SegCs))
 223     {
 224     case AddrMode1616:
 225     case AddrModeReal:
 226         dbg_printf("\n IP:%04x SP:%04x BP:%04x FLAGS:%04x(%s)\n",
 227                    LOWORD(ctx->Eip), LOWORD(ctx->Esp),
 228                    LOWORD(ctx->Ebp), LOWORD(ctx->EFlags), buf);
 229         dbg_printf(" AX:%04x BX:%04x CX:%04x DX:%04x SI:%04x DI:%04x\n",
 230                    LOWORD(ctx->Eax), LOWORD(ctx->Ebx),
 231                    LOWORD(ctx->Ecx), LOWORD(ctx->Edx),
 232                    LOWORD(ctx->Esi), LOWORD(ctx->Edi));
 233         break;
 234     case AddrModeFlat:
 235     case AddrMode1632:
 236         dbg_printf("\n EIP:%08lx ESP:%08lx EBP:%08lx EFLAGS:%08lx(%s)\n",
 237                    ctx->Eip, ctx->Esp, ctx->Ebp, ctx->EFlags, buf);
 238         dbg_printf(" EAX:%08lx EBX:%08lx ECX:%08lx EDX:%08lx\n",
 239                    ctx->Eax, ctx->Ebx, ctx->Ecx, ctx->Edx);
 240         dbg_printf(" ESI:%08lx EDI:%08lx\n",
 241                    ctx->Esi, ctx->Edi);
 242         break;
 243     }
 244
 245     if (all_regs) be_i386_all_print_context(hThread, ctx); /* print floating regs */
 246
 247 }
 248
 249 static void be_i386_print_segment_info(HANDLE hThread, const CONTEXT* ctx)
 250 {
 251     if (get_selector_type(hThread, ctx, ctx->SegCs) == AddrMode1616)
 252     {
 253         info_win32_segments(ctx->SegDs >> 3, 1);
 254         if (ctx->SegEs != ctx->SegDs) info_win32_segments(ctx->SegEs >> 3, 1);
 255     }
 256     info_win32_segments(ctx->SegFs >> 3, 1);
 257 }
 258
 259 static struct dbg_internal_var be_i386_ctx[] =
 260 {
 261     {CV_REG_AL,         "AL",           (DWORD*)FIELD_OFFSET(CONTEXT, Eax),     dbg_itype_unsigned_char_int},
 262     {CV_REG_CL,         "CL",           (DWORD*)FIELD_OFFSET(CONTEXT, Ecx),     dbg_itype_unsigned_char_int},
 263     {CV_REG_DL,         "DL",           (DWORD*)FIELD_OFFSET(CONTEXT, Edx),     dbg_itype_unsigned_char_int},
 264     {CV_REG_BL,         "BL",           (DWORD*)FIELD_OFFSET(CONTEXT, Ebx),     dbg_itype_unsigned_char_int},
 265     {CV_REG_AH,         "AH",           (DWORD*)(FIELD_OFFSET(CONTEXT, Eax)+1), dbg_itype_unsigned_char_int},
 266     {CV_REG_CH,         "CH",           (DWORD*)(FIELD_OFFSET(CONTEXT, Ecx)+1), dbg_itype_unsigned_char_int},
 267     {CV_REG_DH,         "DH",           (DWORD*)(FIELD_OFFSET(CONTEXT, Edx)+1), dbg_itype_unsigned_char_int},
 268     {CV_REG_BH,         "BH",           (DWORD*)(FIELD_OFFSET(CONTEXT, Ebx)+1), dbg_itype_unsigned_char_int},
 269     {CV_REG_AX,         "AX",           (DWORD*)FIELD_OFFSET(CONTEXT, Eax),     dbg_itype_unsigned_short_int},
 270     {CV_REG_CX,         "CX",           (DWORD*)FIELD_OFFSET(CONTEXT, Ecx),     dbg_itype_unsigned_short_int},
 271     {CV_REG_DX,         "DX",           (DWORD*)FIELD_OFFSET(CONTEXT, Edx),     dbg_itype_unsigned_short_int},
 272     {CV_REG_BX,         "BX",           (DWORD*)FIELD_OFFSET(CONTEXT, Ebx),     dbg_itype_unsigned_short_int},
 273     {CV_REG_SP,         "SP",           (DWORD*)FIELD_OFFSET(CONTEXT, Esp),     dbg_itype_unsigned_short_int},
 274     {CV_REG_BP,         "BP",           (DWORD*)FIELD_OFFSET(CONTEXT, Ebp),     dbg_itype_unsigned_short_int},
 275     {CV_REG_SI,         "SI",           (DWORD*)FIELD_OFFSET(CONTEXT, Esi),     dbg_itype_unsigned_short_int},
 276     {CV_REG_DI,         "DI",           (DWORD*)FIELD_OFFSET(CONTEXT, Edi),     dbg_itype_unsigned_short_int},
 277     {CV_REG_EAX,        "EAX",          (DWORD*)FIELD_OFFSET(CONTEXT, Eax),     dbg_itype_unsigned_int},
 278     {CV_REG_ECX,        "ECX",          (DWORD*)FIELD_OFFSET(CONTEXT, Ecx),     dbg_itype_unsigned_int},
 279     {CV_REG_EDX,        "EDX",          (DWORD*)FIELD_OFFSET(CONTEXT, Edx),     dbg_itype_unsigned_int},
 280     {CV_REG_EBX,        "EBX",          (DWORD*)FIELD_OFFSET(CONTEXT, Ebx),     dbg_itype_unsigned_int},
 281     {CV_REG_ESP,        "ESP",          (DWORD*)FIELD_OFFSET(CONTEXT, Esp),     dbg_itype_unsigned_int},
 282     {CV_REG_EBP,        "EBP",          (DWORD*)FIELD_OFFSET(CONTEXT, Ebp),     dbg_itype_unsigned_int},
 283     {CV_REG_ESI,        "ESI",          (DWORD*)FIELD_OFFSET(CONTEXT, Esi),     dbg_itype_unsigned_int},
 284     {CV_REG_EDI,        "EDI",          (DWORD*)FIELD_OFFSET(CONTEXT, Edi),     dbg_itype_unsigned_int},
 285     {CV_REG_ES,         "ES",           (DWORD*)FIELD_OFFSET(CONTEXT, SegEs),   dbg_itype_unsigned_short_int},
 286     {CV_REG_CS,         "CS",           (DWORD*)FIELD_OFFSET(CONTEXT, SegCs),   dbg_itype_unsigned_short_int},
 287     {CV_REG_SS,         "SS",           (DWORD*)FIELD_OFFSET(CONTEXT, SegSs),   dbg_itype_unsigned_short_int},
 288     {CV_REG_DS,         "DS",           (DWORD*)FIELD_OFFSET(CONTEXT, SegDs),   dbg_itype_unsigned_short_int},
 289     {CV_REG_FS,         "FS",           (DWORD*)FIELD_OFFSET(CONTEXT, SegFs),   dbg_itype_unsigned_short_int},
 290     {CV_REG_GS,         "GS",           (DWORD*)FIELD_OFFSET(CONTEXT, SegGs),   dbg_itype_unsigned_short_int},
 291     {CV_REG_IP,         "IP",           (DWORD*)FIELD_OFFSET(CONTEXT, Eip),     dbg_itype_unsigned_short_int},
 292     {CV_REG_FLAGS,      "FLAGS",        (DWORD*)FIELD_OFFSET(CONTEXT, EFlags),  dbg_itype_unsigned_short_int},
 293     {CV_REG_EIP,        "EIP",          (DWORD*)FIELD_OFFSET(CONTEXT, Eip),     dbg_itype_unsigned_int},
 294     {CV_REG_EFLAGS,     "EFLAGS",       (DWORD*)FIELD_OFFSET(CONTEXT, EFlags),  dbg_itype_unsigned_int},
 295     {0,                 NULL,           0,                                      dbg_itype_none}
 296 };
 297
 298 static const struct dbg_internal_var* be_i386_init_registers(CONTEXT* ctx)
 299 {
 300     struct dbg_internal_var*    div;
 301
 302     for (div = be_i386_ctx; div->name; div++)
 303         div->pval = (DWORD*)((char*)ctx + (DWORD)div->pval);
 304     return be_i386_ctx;
 305 }
 306
 307 static unsigned be_i386_is_step_over_insn(const void* insn)
 308 {
 309     BYTE        ch;
 310
 311     for (;;)
 312     {
 313         if (!dbg_read_memory(insn, &ch, sizeof(ch))) return FALSE;
 314
 315         switch (ch)
 316         {
 317         /* Skip all prefixes */
 318         case 0x2e:  /* cs: */
 319         case 0x36:  /* ss: */
 320         case 0x3e:  /* ds: */
 321         case 0x26:  /* es: */
 322         case 0x64:  /* fs: */
 323         case 0x65:  /* gs: */
 324         case 0x66:  /* opcode size prefix */
 325         case 0x67:  /* addr size prefix */
 326         case 0xf0:  /* lock */
 327         case 0xf2:  /* repne */
 328         case 0xf3:  /* repe */
 329             insn = (const char*)insn + 1;
 330             continue;
 331
 332         /* Handle call instructions */
 333         case 0xcd:  /* int <intno> */
 334         case 0xe8:  /* call <offset> */
 335         case 0x9a:  /* lcall <seg>:<off> */
 336             return TRUE;
 337
 338         case 0xff:  /* call <regmodrm> */
 339             if (!dbg_read_memory((const char*)insn + 1, &ch, sizeof(ch)))
 340                 return FALSE;
 341             return (((ch & 0x38) == 0x10) || ((ch & 0x38) == 0x18));
 342
 343         /* Handle string instructions */
 344         case 0x6c:  /* insb */
 345         case 0x6d:  /* insw */
 346         case 0x6e:  /* outsb */
 347         case 0x6f:  /* outsw */
 348         case 0xa4:  /* movsb */
 349         case 0xa5:  /* movsw */
 350         case 0xa6:  /* cmpsb */
 351         case 0xa7:  /* cmpsw */
 352         case 0xaa:  /* stosb */
 353         case 0xab:  /* stosw */
 354         case 0xac:  /* lodsb */
 355         case 0xad:  /* lodsw */
 356         case 0xae:  /* scasb */
 357         case 0xaf:  /* scasw */
 358             return TRUE;
 359
 360         default:
 361             return FALSE;
 362         }
 363     }
 364 }
 365
 366 static unsigned be_i386_is_function_return(const void* insn)
 367 {
 368     BYTE ch;
 369
 370     if (!dbg_read_memory(insn, &ch, sizeof(ch))) return FALSE;
 371     return (ch == 0xC2) || (ch == 0xC3);
 372 }
 373
 374 static unsigned be_i386_is_break_insn(const void* insn)
 375 {
 376     BYTE        c;
 377
 378     if (!dbg_read_memory(insn, &c, sizeof(c))) return FALSE;
 379     return c == 0xCC;
 380 }
 381
 382 static unsigned be_i386_is_func_call(const void* insn, ADDRESS64* callee)
 383 {
 384     BYTE        ch;
 385     int         delta;
 386
 387     if (!dbg_read_memory(insn, &ch, sizeof(ch))) return FALSE;
 388     switch (ch)
 389     {
 390     case 0xe8:
 391         dbg_read_memory((const char*)insn + 1, &delta, sizeof(delta));
 392
 393         callee->Mode = AddrModeFlat;
 394         callee->Offset = (DWORD)insn;
 395         be_i386_disasm_one_insn(callee, FALSE);
 396         callee->Offset += delta;
 397
 398         return TRUE;
 399     case 0xff:
 400         if (!dbg_read_memory((const char*)insn + 1, &ch, sizeof(ch)))
 401             return FALSE;
 402         ch &= 0x38;
 403         if (ch != 0x10 && ch != 0x18) return FALSE;
 404         /* fall through */
 405     case 0x9a:
 406     case 0xCD:
 407         WINE_FIXME("Unsupported yet call insn (0x%02x) at %p\n", ch, insn);
 408         /* fall through */
 409     default:
 410         return FALSE;
 411     }
 412 }
 413
 414 #define DR7_CONTROL_SHIFT       16
 415 #define DR7_CONTROL_SIZE        4
 416
 417 #define DR7_RW_EXECUTE          (0x0)
 418 #define DR7_RW_WRITE            (0x1)
 419 #define DR7_RW_READ             (0x3)
 420
 421 #define DR7_LEN_1               (0x0)
 422 #define DR7_LEN_2               (0x4)
 423 #define DR7_LEN_4               (0xC)
 424
 425 #define DR7_LOCAL_ENABLE_SHIFT  0
 426 #define DR7_GLOBAL_ENABLE_SHIFT 1
 427 #define DR7_ENABLE_SIZE         2
 428
 429 #define DR7_LOCAL_ENABLE_MASK   (0x55)
 430 #define DR7_GLOBAL_ENABLE_MASK  (0xAA)
 431
 432 #define DR7_CONTROL_RESERVED    (0xFC00)
 433 #define DR7_LOCAL_SLOWDOWN      (0x100)
 434 #define DR7_GLOBAL_SLOWDOWN     (0x200)
 435
 436 #define DR7_ENABLE_MASK(dr)     (1<<(DR7_LOCAL_ENABLE_SHIFT+DR7_ENABLE_SIZE*(dr)))
 437 #define IS_DR7_SET(ctrl,dr)     ((ctrl)&DR7_ENABLE_MASK(dr))
 438
 439 static inline int be_i386_get_unused_DR(CONTEXT* ctx, unsigned long** r)
 440 {
 441     if (!IS_DR7_SET(ctx->Dr7, 0))
 442     {
 443         *r = &ctx->Dr0;
 444         return 0;
 445     }
 446     if (!IS_DR7_SET(ctx->Dr7, 1))
 447     {
 448         *r = &ctx->Dr1;
 449         return 1;
 450     }
 451     if (!IS_DR7_SET(ctx->Dr7, 2))
 452     {
 453         *r = &ctx->Dr2;
 454         return 2;
 455     }
 456     if (!IS_DR7_SET(ctx->Dr7, 3))
 457     {
 458         *r = &ctx->Dr3;
 459         return 3;
 460     }
 461     dbg_printf("All hardware registers have been used\n");
 462
 463     return -1;
 464 }
 465
 466 static unsigned be_i386_insert_Xpoint(HANDLE hProcess, const struct be_process_io* pio,
 467                                       CONTEXT* ctx, enum be_xpoint_type type,
 468                                       void* addr, unsigned long* val, unsigned size)
 469 {
 470     unsigned char       ch;
 471     SIZE_T              sz;
 472     unsigned long*      pr;
 473     int                 reg;
 474     unsigned long       bits;
 475
 476     switch (type)
 477     {
 478     case be_xpoint_break:
 479         if (size != 0) return 0;
 480         if (!pio->read(hProcess, addr, &ch, 1, &sz) || sz != 1) return 0;
 481         *val = ch;
 482         ch = 0xcc;
 483         if (!pio->write(hProcess, addr, &ch, 1, &sz) || sz != 1) return 0;
 484         break;
 485     case be_xpoint_watch_exec:
 486         bits = DR7_RW_EXECUTE;
 487         goto hw_bp;
 488     case be_xpoint_watch_read:
 489         bits = DR7_RW_READ;
 490         goto hw_bp;
 491     case be_xpoint_watch_write:
 492         bits = DR7_RW_WRITE;
 493     hw_bp:
 494         if ((reg = be_i386_get_unused_DR(ctx, &pr)) == -1) return 0;
 495         *pr = (unsigned long)addr;
 496         if (type != be_xpoint_watch_exec) switch (size)
 497         {
 498         case 4: bits |= DR7_LEN_4; break;
 499         case 2: bits |= DR7_LEN_2; break;
 500         case 1: bits |= DR7_LEN_1; break;
 501         default: return 0;
 502         }
 503         *val = reg;
 504         /* clear old values */
 505         ctx->Dr7 &= ~(0x0F << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg));
 506         /* set the correct ones */
 507         ctx->Dr7 |= bits << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg);
 508         ctx->Dr7 |= DR7_ENABLE_MASK(reg) | DR7_LOCAL_SLOWDOWN;
 509         break;
 510     default:
 511         dbg_printf("Unknown bp type %c\n", type);
 512         return 0;
 513     }
 514     return 1;
 515 }
 516
 517 static unsigned be_i386_remove_Xpoint(HANDLE hProcess, const struct be_process_io* pio,
 518                                       CONTEXT* ctx, enum be_xpoint_type type,
 519                                       void* addr, unsigned long val, unsigned size)
 520 {
 521     SIZE_T              sz;
 522     unsigned char       ch;
 523
 524     switch (type)
 525     {
 526     case be_xpoint_break:
 527         if (size != 0) return 0;
 528         if (!pio->read(hProcess, addr, &ch, 1, &sz) || sz != 1) return 0;
 529         if (ch != (unsigned char)0xCC)
 530             WINE_FIXME("Cannot get back %02x instead of 0xCC at %08lx\n",
 531                        ch, (unsigned long)addr);
 532         ch = (unsigned char)val;
 533         if (!pio->write(hProcess, addr, &ch, 1, &sz) || sz != 1) return 0;
 534         break;
 535     case be_xpoint_watch_exec:
 536     case be_xpoint_watch_read:
 537     case be_xpoint_watch_write:
 538         /* simply disable the entry */
 539         ctx->Dr7 &= ~DR7_ENABLE_MASK(val);
 540         break;
 541     default:
 542         dbg_printf("Unknown bp type %c\n", type);
 543         return 0;
 544     }
 545     return 1;
 546 }
 547
 548 static unsigned be_i386_is_watchpoint_set(const CONTEXT* ctx, unsigned idx)
 549 {
 550     return ctx->Dr6 & (1 << idx);
 551 }
 552
 553 static void be_i386_clear_watchpoint(CONTEXT* ctx, unsigned idx)
 554 {
 555     ctx->Dr6 &= ~(1 << idx);
 556 }
 557
 558 static int be_i386_adjust_pc_for_break(CONTEXT* ctx, BOOL way)
 559 {
 560     if (way)
 561     {
 562         ctx->Eip--;
 563         return -1;
 564     }
 565     ctx->Eip++;
 566     return 1;
 567 }
 568
 569 static int be_i386_fetch_integer(const struct dbg_lvalue* lvalue, unsigned size,
 570                                  unsigned ext_sign, LONGLONG* ret)
 571 {
 572     if (size != 1 && size != 2 && size != 4 && size != 8) return FALSE;
 573
 574     memset(ret, 0, sizeof(*ret)); /* clear unread bytes */
 575     /* FIXME: this assumes that debuggee and debugger use the same
 576      * integral representation
 577      */
 578     if (!memory_read_value(lvalue, size, ret)) return FALSE;
 579
 580     /* propagate sign information */
 581     if (ext_sign && size < 8 && (*ret >> (size * 8 - 1)) != 0)
 582     {
 583         ULONGLONG neg = -1;
 584         *ret |= neg << (size * 8);
 585     }
 586     return TRUE;
 587 }
 588
 589 static int be_i386_fetch_float(const struct dbg_lvalue* lvalue, unsigned size,
 590                                long double* ret)
 591 {
 592     char        tmp[12];
 593
 594     /* FIXME: this assumes that debuggee and debugger use the same
 595      * representation for reals
 596      */
 597     if (!memory_read_value(lvalue, size, tmp)) return FALSE;
 598
 599     /* float & double types have to be promoted to a long double */
 600     switch (size)
 601     {
 602     case sizeof(float):         *ret = *(float*)tmp;            break;
 603     case sizeof(double):        *ret = *(double*)tmp;           break;
 604     case sizeof(long double):   *ret = *(long double*)tmp;      break;
 605     default:                    return FALSE;
 606     }
 607     return TRUE;
 608 }
 609
 610 struct backend_cpu be_i386 =
 611 {
 612     be_i386_linearize,
 613     be_i386_build_addr,
 614     be_i386_get_addr,
 615     be_i386_single_step,
 616     be_i386_print_context,
 617     be_i386_print_segment_info,
 618     be_i386_init_registers,
 619     be_i386_is_step_over_insn,
 620     be_i386_is_function_return,
 621     be_i386_is_break_insn,
 622     be_i386_is_func_call,
 623     be_i386_disasm_one_insn,
 624     be_i386_insert_Xpoint,
 625     be_i386_remove_Xpoint,
 626     be_i386_is_watchpoint_set,
 627     be_i386_clear_watchpoint,
 628     be_i386_adjust_pc_for_break,
 629     be_i386_fetch_integer,
 630     be_i386_fetch_float,
 631 };
 632 #endif