git.oblomov.eu Git - wine/blob - dlls/dbghelp/cpu_i386.c

   1 /*
   2  * File cpu_i386.c
   3  *
   4  * Copyright (C) 2009-2009, 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 <assert.h>
  22
  23 #include "ntstatus.h"
  24 #define WIN32_NO_STATUS
  25 #include "dbghelp_private.h"
  26 #include "wine/winbase16.h"
  27 #include "winternl.h"
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
  31
  32 #define STEP_FLAG 0x00000100 /* single step flag */
  33 #define V86_FLAG  0x00020000
  34
  35 #define IS_VM86_MODE(ctx) (ctx->EFlags & V86_FLAG)
  36
  37 #ifdef __i386__
  38 static ADDRESS_MODE get_selector_type(HANDLE hThread, const CONTEXT* ctx, WORD sel)
  39 {
  40     LDT_ENTRY   le;
  41
  42     if (IS_VM86_MODE(ctx)) return AddrModeReal;
  43     /* null or system selector */
  44     if (!(sel & 4) || ((sel >> 3) < 17)) return AddrModeFlat;
  45     if (hThread && GetThreadSelectorEntry(hThread, sel, &le))
  46         return le.HighWord.Bits.Default_Big ? AddrMode1632 : AddrMode1616;
  47     /* selector doesn't exist */
  48     return -1;
  49 }
  50
  51 static unsigned i386_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* addr,
  52                                 unsigned seg, unsigned long offset)
  53 {
  54     addr->Mode    = AddrModeFlat;
  55     addr->Segment = seg;
  56     addr->Offset  = offset;
  57     if (seg)
  58     {
  59         switch (addr->Mode = get_selector_type(hThread, ctx, seg))
  60         {
  61         case AddrModeReal:
  62         case AddrMode1616:
  63             addr->Offset &= 0xffff;
  64             break;
  65         case AddrModeFlat:
  66         case AddrMode1632:
  67             break;
  68         default:
  69             return FALSE;
  70         }
  71     }
  72     return TRUE;
  73 }
  74 #endif
  75
  76 static unsigned i386_get_addr(HANDLE hThread, const CONTEXT* ctx,
  77                               enum cpu_addr ca, ADDRESS64* addr)
  78 {
  79 #ifdef __i386__
  80     switch (ca)
  81     {
  82     case cpu_addr_pc:    return i386_build_addr(hThread, ctx, addr, ctx->SegCs, ctx->Eip);
  83     case cpu_addr_stack: return i386_build_addr(hThread, ctx, addr, ctx->SegSs, ctx->Esp);
  84     case cpu_addr_frame: return i386_build_addr(hThread, ctx, addr, ctx->SegSs, ctx->Ebp);
  85     }
  86 #endif
  87     return FALSE;
  88 }
  89
  90 enum st_mode {stm_start, stm_32bit, stm_16bit, stm_done};
  91
  92 /* indexes in Reserved array */
  93 #define __CurrentMode     0
  94 #define __CurrentSwitch   1
  95 #define __NextSwitch      2
  96
  97 #define curr_mode   (frame->Reserved[__CurrentMode])
  98 #define curr_switch (frame->Reserved[__CurrentSwitch])
  99 #define next_switch (frame->Reserved[__NextSwitch])
 100
 101 static BOOL i386_stack_walk(struct cpu_stack_walk* csw, LPSTACKFRAME64 frame, CONTEXT* context)
 102 {
 103     STACK32FRAME        frame32;
 104     STACK16FRAME        frame16;
 105     char                ch;
 106     ADDRESS64           tmp;
 107     DWORD               p;
 108     WORD                val;
 109     BOOL                do_switch;
 110     unsigned            deltapc = 1;
 111 #ifdef __i386__
 112     CONTEXT             _context;
 113 #endif
 114
 115     /* sanity check */
 116     if (curr_mode >= stm_done) return FALSE;
 117
 118     TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%p nSwitch=%p\n",
 119           wine_dbgstr_addr(&frame->AddrPC),
 120           wine_dbgstr_addr(&frame->AddrFrame),
 121           wine_dbgstr_addr(&frame->AddrReturn),
 122           wine_dbgstr_addr(&frame->AddrStack),
 123           curr_mode == stm_start ? "start" : (curr_mode == stm_16bit ? "16bit" : "32bit"),
 124           (void*)(DWORD_PTR)curr_switch, (void*)(DWORD_PTR)next_switch);
 125
 126 #ifdef __i386__
 127     if (!context)
 128     {
 129         /* setup a pseudo context for the rest of the code (esp. unwinding) */
 130         context = &_context;
 131         memset(context, 0, sizeof(*context));
 132         context->ContextFlags = CONTEXT_CONTROL | CONTEXT_SEGMENTS;
 133         if (frame->AddrPC.Mode != AddrModeFlat)    context->SegCs = frame->AddrPC.Segment;
 134         context->Eip = frame->AddrPC.Offset;
 135         if (frame->AddrFrame.Mode != AddrModeFlat) context->SegSs = frame->AddrFrame.Segment;
 136         context->Ebp = frame->AddrFrame.Offset;
 137         if (frame->AddrStack.Mode != AddrModeFlat) context->SegSs = frame->AddrStack.Segment;
 138         context->Esp = frame->AddrStack.Offset;
 139     }
 140 #endif
 141     if (curr_mode == stm_start)
 142     {
 143         THREAD_BASIC_INFORMATION info;
 144
 145         if ((frame->AddrPC.Mode == AddrModeFlat) &&
 146             (frame->AddrFrame.Mode != AddrModeFlat))
 147         {
 148             WARN("Bad AddrPC.Mode / AddrFrame.Mode combination\n");
 149             goto done_err;
 150         }
 151
 152         /* Init done */
 153         curr_mode = (frame->AddrPC.Mode == AddrModeFlat) ? stm_32bit : stm_16bit;
 154         deltapc = 0;
 155
 156         /* cur_switch holds address of WOW32Reserved field in TEB in debuggee
 157          * address space
 158          */
 159         if (NtQueryInformationThread(csw->hThread, ThreadBasicInformation, &info,
 160                                      sizeof(info), NULL) == STATUS_SUCCESS)
 161         {
 162             curr_switch = (unsigned long)info.TebBaseAddress + FIELD_OFFSET(TEB, WOW32Reserved);
 163             if (!sw_read_mem(csw, curr_switch, &p, sizeof(p)))
 164             {
 165                 WARN("Can't read TEB:WOW32Reserved\n");
 166                 goto done_err;
 167             }
 168             next_switch = p;
 169             if (!next_switch)  /* no 16-bit stack */
 170             {
 171                 curr_switch = 0;
 172             }
 173             else if (curr_mode == stm_16bit)
 174             {
 175                 if (!sw_read_mem(csw, next_switch, &frame32, sizeof(frame32)))
 176                 {
 177                     WARN("Bad stack frame %p\n", (void*)(DWORD_PTR)next_switch);
 178                     goto done_err;
 179                 }
 180                 curr_switch = (DWORD)frame32.frame16;
 181                 tmp.Mode    = AddrMode1616;
 182                 tmp.Segment = SELECTOROF(curr_switch);
 183                 tmp.Offset  = OFFSETOF(curr_switch);
 184                 if (!sw_read_mem(csw, sw_xlat_addr(csw, &tmp), &ch, sizeof(ch)))
 185                     curr_switch = 0xFFFFFFFF;
 186             }
 187             else
 188             {
 189                 tmp.Mode    = AddrMode1616;
 190                 tmp.Segment = SELECTOROF(next_switch);
 191                 tmp.Offset  = OFFSETOF(next_switch);
 192                 p = sw_xlat_addr(csw, &tmp);
 193                 if (!sw_read_mem(csw, p, &frame16, sizeof(frame16)))
 194                 {
 195                     WARN("Bad stack frame 0x%08x\n", p);
 196                     goto done_err;
 197                 }
 198                 curr_switch = (DWORD_PTR)frame16.frame32;
 199
 200                 if (!sw_read_mem(csw, curr_switch, &ch, sizeof(ch)))
 201                     curr_switch = 0xFFFFFFFF;
 202             }
 203         }
 204         else
 205             /* FIXME: this will allow to work when we're not attached to a live target,
 206              * but the 16 <=> 32 switch facility won't be available.
 207              */
 208             curr_switch = 0;
 209         frame->AddrReturn.Mode = frame->AddrStack.Mode = (curr_mode == stm_16bit) ? AddrMode1616 : AddrModeFlat;
 210         /* don't set up AddrStack on first call. Either the caller has set it up, or
 211          * we will get it in the next frame
 212          */
 213         memset(&frame->AddrBStore, 0, sizeof(frame->AddrBStore));
 214 #ifdef __i386__
 215         if (curr_mode == stm_32bit)
 216         {
 217             DWORD_PTR           xframe;
 218             struct pdb_cmd_pair cpair[4];
 219
 220             if (dwarf2_virtual_unwind(csw, frame->AddrPC.Offset - deltapc, context, &xframe))
 221             {
 222                 frame->AddrStack.Mode = frame->AddrFrame.Mode = frame->AddrReturn.Mode = AddrModeFlat;
 223                 frame->AddrStack.Offset = context->Esp = xframe;
 224                 frame->AddrFrame.Offset = context->Ebp;
 225                 frame->AddrReturn.Offset = context->Eip;
 226                 goto done_pep;
 227             }
 228             cpair[0].name = "$ebp"; cpair[0].pvalue = &context->Ebp;
 229             cpair[1].name = "$esp"; cpair[1].pvalue = &context->Esp;
 230             cpair[2].name = "$eip"; cpair[2].pvalue = &context->Eip;
 231             cpair[3].name = NULL;   cpair[3].pvalue = NULL;
 232
 233             if (pdb_virtual_unwind(csw, frame->AddrPC.Offset - deltapc, context, cpair))
 234             {
 235                 frame->AddrStack.Mode = frame->AddrFrame.Mode = frame->AddrReturn.Mode = AddrModeFlat;
 236                 frame->AddrStack.Offset = context->Esp;
 237                 frame->AddrFrame.Offset = context->Ebp;
 238                 frame->AddrReturn.Offset = context->Eip;
 239                 goto done_pep;
 240             }
 241         }
 242 #endif
 243     }
 244     else
 245     {
 246         if (frame->AddrFrame.Offset == 0) goto done_err;
 247         if (frame->AddrFrame.Mode == AddrModeFlat)
 248         {
 249             assert(curr_mode == stm_32bit);
 250             do_switch = curr_switch && frame->AddrFrame.Offset >= curr_switch;
 251         }
 252         else
 253         {
 254             assert(curr_mode == stm_16bit);
 255             do_switch = curr_switch &&
 256                 frame->AddrFrame.Segment == SELECTOROF(curr_switch) &&
 257                 frame->AddrFrame.Offset >= OFFSETOF(curr_switch);
 258         }
 259
 260         if (do_switch)
 261         {
 262             if (curr_mode == stm_16bit)
 263             {
 264                 if (!sw_read_mem(csw, next_switch, &frame32, sizeof(frame32)))
 265                 {
 266                     WARN("Bad stack frame %p\n", (void*)(DWORD_PTR)next_switch);
 267                     goto done_err;
 268                 }
 269
 270                 frame->AddrPC.Mode        = AddrModeFlat;
 271                 frame->AddrPC.Segment     = 0;
 272                 frame->AddrPC.Offset      = frame32.retaddr;
 273                 frame->AddrFrame.Mode     = AddrModeFlat;
 274                 frame->AddrFrame.Segment  = 0;
 275                 frame->AddrFrame.Offset   = frame32.ebp;
 276
 277                 frame->AddrStack.Mode     = AddrModeFlat;
 278                 frame->AddrStack.Segment  = 0;
 279                 frame->AddrReturn.Mode    = AddrModeFlat;
 280                 frame->AddrReturn.Segment = 0;
 281
 282                 next_switch = curr_switch;
 283                 tmp.Mode    = AddrMode1616;
 284                 tmp.Segment = SELECTOROF(next_switch);
 285                 tmp.Offset  = OFFSETOF(next_switch);
 286                 p = sw_xlat_addr(csw, &tmp);
 287
 288                 if (!sw_read_mem(csw, p, &frame16, sizeof(frame16)))
 289                 {
 290                     WARN("Bad stack frame 0x%08x\n", p);
 291                     goto done_err;
 292                 }
 293                 curr_switch = (DWORD_PTR)frame16.frame32;
 294                 curr_mode = stm_32bit;
 295                 if (!sw_read_mem(csw, curr_switch, &ch, sizeof(ch)))
 296                     curr_switch = 0;
 297             }
 298             else
 299             {
 300                 tmp.Mode    = AddrMode1616;
 301                 tmp.Segment = SELECTOROF(next_switch);
 302                 tmp.Offset  = OFFSETOF(next_switch);
 303                 p = sw_xlat_addr(csw, &tmp);
 304
 305                 if (!sw_read_mem(csw, p, &frame16, sizeof(frame16)))
 306                 {
 307                     WARN("Bad stack frame 0x%08x\n", p);
 308                     goto done_err;
 309                 }
 310
 311                 TRACE("Got a 16 bit stack switch:"
 312                       "\n\tframe32: %08lx"
 313                       "\n\tedx:%08x ecx:%08x ebp:%08x"
 314                       "\n\tds:%04x es:%04x fs:%04x gs:%04x"
 315                       "\n\tcall_from_ip:%08x module_cs:%04x relay=%08x"
 316                       "\n\tentry_ip:%04x entry_point:%08x"
 317                       "\n\tbp:%04x ip:%04x cs:%04x\n",
 318                       (unsigned long)frame16.frame32,
 319                       frame16.edx, frame16.ecx, frame16.ebp,
 320                       frame16.ds, frame16.es, frame16.fs, frame16.gs,
 321                       frame16.callfrom_ip, frame16.module_cs, frame16.relay,
 322                       frame16.entry_ip, frame16.entry_point,
 323                       frame16.bp, frame16.ip, frame16.cs);
 324
 325                 frame->AddrPC.Mode       = AddrMode1616;
 326                 frame->AddrPC.Segment    = frame16.cs;
 327                 frame->AddrPC.Offset     = frame16.ip;
 328
 329                 frame->AddrFrame.Mode    = AddrMode1616;
 330                 frame->AddrFrame.Segment = SELECTOROF(next_switch);
 331                 frame->AddrFrame.Offset  = frame16.bp;
 332
 333                 frame->AddrStack.Mode    = AddrMode1616;
 334                 frame->AddrStack.Segment = SELECTOROF(next_switch);
 335
 336                 frame->AddrReturn.Mode    = AddrMode1616;
 337                 frame->AddrReturn.Segment = frame16.cs;
 338
 339                 next_switch = curr_switch;
 340                 if (!sw_read_mem(csw, next_switch, &frame32, sizeof(frame32)))
 341                 {
 342                     WARN("Bad stack frame %p\n", (void*)(DWORD_PTR)next_switch);
 343                     goto done_err;
 344                 }
 345                 curr_switch = (DWORD)frame32.frame16;
 346                 tmp.Mode    = AddrMode1616;
 347                 tmp.Segment = SELECTOROF(curr_switch);
 348                 tmp.Offset  = OFFSETOF(curr_switch);
 349
 350                 if (!sw_read_mem(csw, sw_xlat_addr(csw, &tmp), &ch, sizeof(ch)))
 351                     curr_switch = 0;
 352                 curr_mode = stm_16bit;
 353             }
 354         }
 355         else
 356         {
 357             frame->AddrPC = frame->AddrReturn;
 358             if (curr_mode == stm_16bit)
 359             {
 360                 frame->AddrStack.Offset = frame->AddrFrame.Offset + 2 * sizeof(WORD);
 361                 /* "pop up" previous BP value */
 362                 if (!sw_read_mem(csw, sw_xlat_addr(csw, &frame->AddrFrame),
 363                                  &val, sizeof(WORD)))
 364                     goto done_err;
 365                 frame->AddrFrame.Offset = val;
 366             }
 367             else
 368             {
 369 #ifdef __i386__
 370                 DWORD_PTR               xframe;
 371                 struct pdb_cmd_pair     cpair[4];
 372
 373                 if (dwarf2_virtual_unwind(csw, frame->AddrPC.Offset - deltapc, context, &xframe))
 374                 {
 375                     frame->AddrStack.Mode = frame->AddrFrame.Mode = frame->AddrReturn.Mode = AddrModeFlat;
 376                     frame->AddrStack.Offset = context->Esp = xframe;
 377                     frame->AddrFrame.Offset = context->Ebp;
 378                     frame->AddrReturn.Offset = context->Eip;
 379                     goto done_pep;
 380                 }
 381                 cpair[0].name = "$ebp"; cpair[0].pvalue = &context->Ebp;
 382                 cpair[1].name = "$esp"; cpair[1].pvalue = &context->Esp;
 383                 cpair[2].name = "$eip"; cpair[2].pvalue = &context->Eip;
 384                 cpair[3].name = NULL;   cpair[3].pvalue = NULL;
 385
 386                 if (pdb_virtual_unwind(csw, frame->AddrPC.Offset - deltapc, context, cpair))
 387                 {
 388                     frame->AddrStack.Mode = frame->AddrFrame.Mode = frame->AddrReturn.Mode = AddrModeFlat;
 389                     frame->AddrStack.Offset = context->Esp;
 390                     frame->AddrFrame.Offset = context->Ebp;
 391                     frame->AddrReturn.Offset = context->Eip;
 392                     goto done_pep;
 393                 }
 394 #endif
 395                 frame->AddrStack.Offset = frame->AddrFrame.Offset + 2 * sizeof(DWORD);
 396                 /* "pop up" previous EBP value */
 397                 if (!sw_read_mem(csw, frame->AddrFrame.Offset,
 398                                  &frame->AddrFrame.Offset, sizeof(DWORD)))
 399                     goto done_err;
 400             }
 401         }
 402     }
 403
 404     if (curr_mode == stm_16bit)
 405     {
 406         unsigned int     i;
 407
 408         p = sw_xlat_addr(csw, &frame->AddrFrame);
 409         if (!sw_read_mem(csw, p + sizeof(WORD), &val, sizeof(WORD)))
 410             goto done_err;
 411         frame->AddrReturn.Offset = val;
 412         /* get potential cs if a far call was used */
 413         if (!sw_read_mem(csw, p + 2 * sizeof(WORD), &val, sizeof(WORD)))
 414             goto done_err;
 415         if (frame->AddrFrame.Offset & 1)
 416             frame->AddrReturn.Segment = val; /* far call assumed */
 417         else
 418         {
 419             /* not explicitly marked as far call,
 420              * but check whether it could be anyway
 421              */
 422             if ((val & 7) == 7 && val != frame->AddrReturn.Segment)
 423             {
 424                 LDT_ENTRY       le;
 425
 426                 if (GetThreadSelectorEntry(csw->hThread, val, &le) &&
 427                     (le.HighWord.Bits.Type & 0x08)) /* code segment */
 428                 {
 429                     /* it is very uncommon to push a code segment cs as
 430                      * a parameter, so this should work in most cases
 431                      */
 432                     frame->AddrReturn.Segment = val;
 433                 }
 434             }
 435         }
 436         frame->AddrFrame.Offset &= ~1;
 437         /* we "pop" parameters as 16 bit entities... of course, this won't
 438          * work if the parameter is in fact bigger than 16bit, but
 439          * there's no way to know that here
 440          */
 441         for (i = 0; i < sizeof(frame->Params) / sizeof(frame->Params[0]); i++)
 442         {
 443             sw_read_mem(csw, p + (2 + i) * sizeof(WORD), &val, sizeof(val));
 444             frame->Params[i] = val;
 445         }
 446     }
 447     else
 448     {
 449         if (!sw_read_mem(csw, frame->AddrFrame.Offset + sizeof(DWORD),
 450                          &frame->AddrReturn.Offset, sizeof(DWORD)))
 451         {
 452             WARN("Cannot read new frame offset %p\n",
 453                  (void*)(DWORD_PTR)(frame->AddrFrame.Offset + (int)sizeof(DWORD)));
 454             goto done_err;
 455         }
 456         sw_read_mem(csw, frame->AddrFrame.Offset + 2 * sizeof(DWORD),
 457                     frame->Params, sizeof(frame->Params));
 458     }
 459 #ifdef __i386__
 460     if (context)
 461     {
 462 #define SET(field, seg, reg) \
 463         switch (frame->field.Mode) \
 464         { \
 465         case AddrModeFlat: context->reg = frame->field.Offset; break; \
 466         case AddrMode1616: context->seg = frame->field.Segment; context->reg = frame->field.Offset; break; \
 467         default: assert(0); \
 468         }
 469         SET(AddrStack,  SegSs, Esp);
 470         SET(AddrFrame,  SegSs, Ebp);
 471         SET(AddrReturn, SegCs, Eip);
 472 #undef SET
 473     }
 474 done_pep:
 475 #endif
 476
 477     frame->Far = TRUE;
 478     frame->Virtual = TRUE;
 479     p = sw_xlat_addr(csw, &frame->AddrPC);
 480     if (p && sw_module_base(csw, p))
 481         frame->FuncTableEntry = sw_table_access(csw, p);
 482     else
 483         frame->FuncTableEntry = NULL;
 484
 485     TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%p nSwitch=%p FuncTable=%p\n",
 486           wine_dbgstr_addr(&frame->AddrPC),
 487           wine_dbgstr_addr(&frame->AddrFrame),
 488           wine_dbgstr_addr(&frame->AddrReturn),
 489           wine_dbgstr_addr(&frame->AddrStack),
 490           curr_mode == stm_start ? "start" : (curr_mode == stm_16bit ? "16bit" : "32bit"),
 491           (void*)(DWORD_PTR)curr_switch, (void*)(DWORD_PTR)next_switch, frame->FuncTableEntry);
 492
 493     return TRUE;
 494 done_err:
 495     curr_mode = stm_done;
 496     return FALSE;
 497 }
 498
 499 static unsigned i386_map_dwarf_register(unsigned regno)
 500 {
 501     unsigned    reg;
 502
 503     switch (regno)
 504     {
 505     case  0: reg = CV_REG_EAX; break;
 506     case  1: reg = CV_REG_ECX; break;
 507     case  2: reg = CV_REG_EDX; break;
 508     case  3: reg = CV_REG_EBX; break;
 509     case  4: reg = CV_REG_ESP; break;
 510     case  5: reg = CV_REG_EBP; break;
 511     case  6: reg = CV_REG_ESI; break;
 512     case  7: reg = CV_REG_EDI; break;
 513     case  8: reg = CV_REG_EIP; break;
 514     case  9: reg = CV_REG_EFLAGS; break;
 515     case 10: reg = CV_REG_CS;  break;
 516     case 11: reg = CV_REG_SS;  break;
 517     case 12: reg = CV_REG_DS;  break;
 518     case 13: reg = CV_REG_ES;  break;
 519     case 14: reg = CV_REG_FS;  break;
 520     case 15: reg = CV_REG_GS;  break;
 521     case 16: case 17: case 18: case 19:
 522     case 20: case 21: case 22: case 23:
 523         reg = CV_REG_ST0 + regno - 16; break;
 524     case 24: reg = CV_REG_CTRL; break;
 525     case 25: reg = CV_REG_STAT; break;
 526     case 26: reg = CV_REG_TAG; break;
 527 /*
 528 reg: fiseg 27
 529 reg: fioff 28
 530 reg: foseg 29
 531 reg: fooff 30
 532 reg: fop   31
 533 */
 534     case 32: case 33: case 34: case 35:
 535     case 36: case 37: case 38: case 39:
 536         reg = CV_REG_XMM0 + regno - 32; break;
 537     case 40: reg = CV_REG_MXCSR; break;
 538     default:
 539         FIXME("Don't know how to map register %d\n", regno);
 540         return 0;
 541     }
 542     return reg;
 543 }
 544
 545 static void* i386_fetch_context_reg(CONTEXT* ctx, unsigned regno, unsigned* size)
 546 {
 547 #ifdef __i386__
 548     switch (regno)
 549     {
 550     case CV_REG_EAX: *size = sizeof(ctx->Eax); return &ctx->Eax;
 551     case CV_REG_EDX: *size = sizeof(ctx->Edx); return &ctx->Edx;
 552     case CV_REG_ECX: *size = sizeof(ctx->Ecx); return &ctx->Ecx;
 553     case CV_REG_EBX: *size = sizeof(ctx->Ebx); return &ctx->Ebx;
 554     case CV_REG_ESI: *size = sizeof(ctx->Esi); return &ctx->Esi;
 555     case CV_REG_EDI: *size = sizeof(ctx->Edi); return &ctx->Edi;
 556     case CV_REG_EBP: *size = sizeof(ctx->Ebp); return &ctx->Ebp;
 557     case CV_REG_ESP: *size = sizeof(ctx->Esp); return &ctx->Esp;
 558     case CV_REG_EIP: *size = sizeof(ctx->Eip); return &ctx->Eip;
 559
 560     case CV_REG_ST0 + 0: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[0*sizeof(long double)];
 561     case CV_REG_ST0 + 1: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[1*sizeof(long double)];
 562     case CV_REG_ST0 + 2: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[2*sizeof(long double)];
 563     case CV_REG_ST0 + 3: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[3*sizeof(long double)];
 564     case CV_REG_ST0 + 4: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[4*sizeof(long double)];
 565     case CV_REG_ST0 + 5: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[5*sizeof(long double)];
 566     case CV_REG_ST0 + 6: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[6*sizeof(long double)];
 567     case CV_REG_ST0 + 7: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[7*sizeof(long double)];
 568
 569     case CV_REG_EFLAGS: *size = sizeof(ctx->EFlags); return &ctx->EFlags;
 570     case CV_REG_ES: *size = sizeof(ctx->SegEs); return &ctx->SegEs;
 571     case CV_REG_CS: *size = sizeof(ctx->SegCs); return &ctx->SegCs;
 572     case CV_REG_SS: *size = sizeof(ctx->SegSs); return &ctx->SegSs;
 573     case CV_REG_DS: *size = sizeof(ctx->SegDs); return &ctx->SegDs;
 574     case CV_REG_FS: *size = sizeof(ctx->SegFs); return &ctx->SegFs;
 575     case CV_REG_GS: *size = sizeof(ctx->SegGs); return &ctx->SegGs;
 576
 577     }
 578 #endif
 579     FIXME("Unknown register %x\n", regno);
 580     return NULL;
 581 }
 582
 583 static const char* i386_fetch_regname(unsigned regno)
 584 {
 585     switch (regno)
 586     {
 587     case CV_REG_EAX: return "eax";
 588     case CV_REG_EDX: return "edx";
 589     case CV_REG_ECX: return "ecx";
 590     case CV_REG_EBX: return "ebx";
 591     case CV_REG_ESI: return "esi";
 592     case CV_REG_EDI: return "edi";
 593     case CV_REG_EBP: return "ebp";
 594     case CV_REG_ESP: return "esp";
 595     case CV_REG_EIP: return "eip";
 596
 597     case CV_REG_ST0 + 0: return "st0";
 598     case CV_REG_ST0 + 1: return "st1";
 599     case CV_REG_ST0 + 2: return "st2";
 600     case CV_REG_ST0 + 3: return "st3";
 601     case CV_REG_ST0 + 4: return "st4";
 602     case CV_REG_ST0 + 5: return "st5";
 603     case CV_REG_ST0 + 6: return "st6";
 604     case CV_REG_ST0 + 7: return "st7";
 605
 606     case CV_REG_EFLAGS: return "eflags";
 607     case CV_REG_ES: return "es";
 608     case CV_REG_CS: return "cs";
 609     case CV_REG_SS: return "ss";
 610     case CV_REG_DS: return "ds";
 611     case CV_REG_FS: return "fs";
 612     case CV_REG_GS: return "gs";
 613     }
 614     FIXME("Unknown register %x\n", regno);
 615     return NULL;
 616 }
 617
 618 struct cpu cpu_i386 = {
 619     IMAGE_FILE_MACHINE_I386,
 620     4,
 621     i386_get_addr,
 622     i386_stack_walk,
 623     NULL,
 624     i386_map_dwarf_register,
 625     i386_fetch_context_reg,
 626     i386_fetch_regname,
 627 };