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
 219             if (dwarf2_virtual_unwind(csw, frame->AddrPC.Offset - deltapc, context, &xframe))
 220             {
 221                 frame->AddrStack.Mode = frame->AddrFrame.Mode = frame->AddrReturn.Mode = AddrModeFlat;
 222                 frame->AddrStack.Offset = context->Esp = xframe;
 223                 frame->AddrFrame.Offset = context->Ebp;
 224                 frame->AddrReturn.Offset = context->Eip;
 225                 goto done_pep;
 226             }
 227         }
 228 #endif
 229     }
 230     else
 231     {
 232         if (frame->AddrFrame.Offset == 0) goto done_err;
 233         if (frame->AddrFrame.Mode == AddrModeFlat)
 234         {
 235             assert(curr_mode == stm_32bit);
 236             do_switch = curr_switch && frame->AddrFrame.Offset >= curr_switch;
 237         }
 238         else
 239         {
 240             assert(curr_mode == stm_16bit);
 241             do_switch = curr_switch &&
 242                 frame->AddrFrame.Segment == SELECTOROF(curr_switch) &&
 243                 frame->AddrFrame.Offset >= OFFSETOF(curr_switch);
 244         }
 245
 246         if (do_switch)
 247         {
 248             if (curr_mode == stm_16bit)
 249             {
 250                 if (!sw_read_mem(csw, next_switch, &frame32, sizeof(frame32)))
 251                 {
 252                     WARN("Bad stack frame %p\n", (void*)(DWORD_PTR)next_switch);
 253                     goto done_err;
 254                 }
 255
 256                 frame->AddrPC.Mode        = AddrModeFlat;
 257                 frame->AddrPC.Segment     = 0;
 258                 frame->AddrPC.Offset      = frame32.retaddr;
 259                 frame->AddrFrame.Mode     = AddrModeFlat;
 260                 frame->AddrFrame.Segment  = 0;
 261                 frame->AddrFrame.Offset   = frame32.ebp;
 262
 263                 frame->AddrStack.Mode     = AddrModeFlat;
 264                 frame->AddrStack.Segment  = 0;
 265                 frame->AddrReturn.Mode    = AddrModeFlat;
 266                 frame->AddrReturn.Segment = 0;
 267
 268                 next_switch = curr_switch;
 269                 tmp.Mode    = AddrMode1616;
 270                 tmp.Segment = SELECTOROF(next_switch);
 271                 tmp.Offset  = OFFSETOF(next_switch);
 272                 p = sw_xlat_addr(csw, &tmp);
 273
 274                 if (!sw_read_mem(csw, p, &frame16, sizeof(frame16)))
 275                 {
 276                     WARN("Bad stack frame 0x%08x\n", p);
 277                     goto done_err;
 278                 }
 279                 curr_switch = (DWORD_PTR)frame16.frame32;
 280                 curr_mode = stm_32bit;
 281                 if (!sw_read_mem(csw, curr_switch, &ch, sizeof(ch)))
 282                     curr_switch = 0;
 283             }
 284             else
 285             {
 286                 tmp.Mode    = AddrMode1616;
 287                 tmp.Segment = SELECTOROF(next_switch);
 288                 tmp.Offset  = OFFSETOF(next_switch);
 289                 p = sw_xlat_addr(csw, &tmp);
 290
 291                 if (!sw_read_mem(csw, p, &frame16, sizeof(frame16)))
 292                 {
 293                     WARN("Bad stack frame 0x%08x\n", p);
 294                     goto done_err;
 295                 }
 296
 297                 TRACE("Got a 16 bit stack switch:"
 298                       "\n\tframe32: %08lx"
 299                       "\n\tedx:%08x ecx:%08x ebp:%08x"
 300                       "\n\tds:%04x es:%04x fs:%04x gs:%04x"
 301                       "\n\tcall_from_ip:%08x module_cs:%04x relay=%08x"
 302                       "\n\tentry_ip:%04x entry_point:%08x"
 303                       "\n\tbp:%04x ip:%04x cs:%04x\n",
 304                       (unsigned long)frame16.frame32,
 305                       frame16.edx, frame16.ecx, frame16.ebp,
 306                       frame16.ds, frame16.es, frame16.fs, frame16.gs,
 307                       frame16.callfrom_ip, frame16.module_cs, frame16.relay,
 308                       frame16.entry_ip, frame16.entry_point,
 309                       frame16.bp, frame16.ip, frame16.cs);
 310
 311                 frame->AddrPC.Mode       = AddrMode1616;
 312                 frame->AddrPC.Segment    = frame16.cs;
 313                 frame->AddrPC.Offset     = frame16.ip;
 314
 315                 frame->AddrFrame.Mode    = AddrMode1616;
 316                 frame->AddrFrame.Segment = SELECTOROF(next_switch);
 317                 frame->AddrFrame.Offset  = frame16.bp;
 318
 319                 frame->AddrStack.Mode    = AddrMode1616;
 320                 frame->AddrStack.Segment = SELECTOROF(next_switch);
 321
 322                 frame->AddrReturn.Mode    = AddrMode1616;
 323                 frame->AddrReturn.Segment = frame16.cs;
 324
 325                 next_switch = curr_switch;
 326                 if (!sw_read_mem(csw, next_switch, &frame32, sizeof(frame32)))
 327                 {
 328                     WARN("Bad stack frame %p\n", (void*)(DWORD_PTR)next_switch);
 329                     goto done_err;
 330                 }
 331                 curr_switch = (DWORD)frame32.frame16;
 332                 tmp.Mode    = AddrMode1616;
 333                 tmp.Segment = SELECTOROF(curr_switch);
 334                 tmp.Offset  = OFFSETOF(curr_switch);
 335
 336                 if (!sw_read_mem(csw, sw_xlat_addr(csw, &tmp), &ch, sizeof(ch)))
 337                     curr_switch = 0;
 338                 curr_mode = stm_16bit;
 339             }
 340         }
 341         else
 342         {
 343             frame->AddrPC = frame->AddrReturn;
 344             if (curr_mode == stm_16bit)
 345             {
 346                 frame->AddrStack.Offset = frame->AddrFrame.Offset + 2 * sizeof(WORD);
 347                 /* "pop up" previous BP value */
 348                 if (!sw_read_mem(csw, sw_xlat_addr(csw, &frame->AddrFrame),
 349                                  &val, sizeof(WORD)))
 350                     goto done_err;
 351                 frame->AddrFrame.Offset = val;
 352             }
 353             else
 354             {
 355 #ifdef __i386__
 356                 DWORD_PTR       xframe;
 357
 358                 if (dwarf2_virtual_unwind(csw, frame->AddrPC.Offset - deltapc, context, &xframe))
 359                 {
 360                     frame->AddrStack.Mode = frame->AddrFrame.Mode = frame->AddrReturn.Mode = AddrModeFlat;
 361                     frame->AddrStack.Offset = context->Esp = xframe;
 362                     frame->AddrFrame.Offset = context->Ebp;
 363                     frame->AddrReturn.Offset = context->Eip;
 364                     goto done_pep;
 365                 }
 366 #endif
 367                 frame->AddrStack.Offset = frame->AddrFrame.Offset + 2 * sizeof(DWORD);
 368                 /* "pop up" previous EBP value */
 369                 if (!sw_read_mem(csw, frame->AddrFrame.Offset,
 370                                  &frame->AddrFrame.Offset, sizeof(DWORD)))
 371                     goto done_err;
 372             }
 373         }
 374     }
 375
 376     if (curr_mode == stm_16bit)
 377     {
 378         unsigned int     i;
 379
 380         p = sw_xlat_addr(csw, &frame->AddrFrame);
 381         if (!sw_read_mem(csw, p + sizeof(WORD), &val, sizeof(WORD)))
 382             goto done_err;
 383         frame->AddrReturn.Offset = val;
 384         /* get potential cs if a far call was used */
 385         if (!sw_read_mem(csw, p + 2 * sizeof(WORD), &val, sizeof(WORD)))
 386             goto done_err;
 387         if (frame->AddrFrame.Offset & 1)
 388             frame->AddrReturn.Segment = val; /* far call assumed */
 389         else
 390         {
 391             /* not explicitly marked as far call,
 392              * but check whether it could be anyway
 393              */
 394             if ((val & 7) == 7 && val != frame->AddrReturn.Segment)
 395             {
 396                 LDT_ENTRY       le;
 397
 398                 if (GetThreadSelectorEntry(csw->hThread, val, &le) &&
 399                     (le.HighWord.Bits.Type & 0x08)) /* code segment */
 400                 {
 401                     /* it is very uncommon to push a code segment cs as
 402                      * a parameter, so this should work in most cases
 403                      */
 404                     frame->AddrReturn.Segment = val;
 405                 }
 406             }
 407         }
 408         frame->AddrFrame.Offset &= ~1;
 409         /* we "pop" parameters as 16 bit entities... of course, this won't
 410          * work if the parameter is in fact bigger than 16bit, but
 411          * there's no way to know that here
 412          */
 413         for (i = 0; i < sizeof(frame->Params) / sizeof(frame->Params[0]); i++)
 414         {
 415             sw_read_mem(csw, p + (2 + i) * sizeof(WORD), &val, sizeof(val));
 416             frame->Params[i] = val;
 417         }
 418     }
 419     else
 420     {
 421         if (!sw_read_mem(csw, frame->AddrFrame.Offset + sizeof(DWORD),
 422                          &frame->AddrReturn.Offset, sizeof(DWORD)))
 423         {
 424             WARN("Cannot read new frame offset %p\n",
 425                  (void*)(DWORD_PTR)(frame->AddrFrame.Offset + (int)sizeof(DWORD)));
 426             goto done_err;
 427         }
 428         sw_read_mem(csw, frame->AddrFrame.Offset + 2 * sizeof(DWORD),
 429                     frame->Params, sizeof(frame->Params));
 430     }
 431 #ifdef __i386__
 432     if (context)
 433     {
 434 #define SET(field, seg, reg) \
 435         switch (frame->field.Mode) \
 436         { \
 437         case AddrModeFlat: context->reg = frame->field.Offset; break; \
 438         case AddrMode1616: context->seg = frame->field.Segment; context->reg = frame->field.Offset; break; \
 439         default: assert(0); \
 440         }
 441         SET(AddrStack,  SegSs, Esp);
 442         SET(AddrFrame,  SegSs, Ebp);
 443         SET(AddrReturn, SegCs, Eip);
 444 #undef SET
 445     }
 446 done_pep:
 447 #endif
 448
 449     frame->Far = TRUE;
 450     frame->Virtual = TRUE;
 451     p = sw_xlat_addr(csw, &frame->AddrPC);
 452     if (p && sw_module_base(csw, p))
 453         frame->FuncTableEntry = sw_table_access(csw, p);
 454     else
 455         frame->FuncTableEntry = NULL;
 456
 457     TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%p nSwitch=%p FuncTable=%p\n",
 458           wine_dbgstr_addr(&frame->AddrPC),
 459           wine_dbgstr_addr(&frame->AddrFrame),
 460           wine_dbgstr_addr(&frame->AddrReturn),
 461           wine_dbgstr_addr(&frame->AddrStack),
 462           curr_mode == stm_start ? "start" : (curr_mode == stm_16bit ? "16bit" : "32bit"),
 463           (void*)(DWORD_PTR)curr_switch, (void*)(DWORD_PTR)next_switch, frame->FuncTableEntry);
 464
 465     return TRUE;
 466 done_err:
 467     curr_mode = stm_done;
 468     return FALSE;
 469 }
 470
 471 static unsigned i386_map_dwarf_register(unsigned regno)
 472 {
 473     unsigned    reg;
 474
 475     switch (regno)
 476     {
 477     case  0: reg = CV_REG_EAX; break;
 478     case  1: reg = CV_REG_ECX; break;
 479     case  2: reg = CV_REG_EDX; break;
 480     case  3: reg = CV_REG_EBX; break;
 481     case  4: reg = CV_REG_ESP; break;
 482     case  5: reg = CV_REG_EBP; break;
 483     case  6: reg = CV_REG_ESI; break;
 484     case  7: reg = CV_REG_EDI; break;
 485     case  8: reg = CV_REG_EIP; break;
 486     case  9: reg = CV_REG_EFLAGS; break;
 487     case 10: reg = CV_REG_CS;  break;
 488     case 11: reg = CV_REG_SS;  break;
 489     case 12: reg = CV_REG_DS;  break;
 490     case 13: reg = CV_REG_ES;  break;
 491     case 14: reg = CV_REG_FS;  break;
 492     case 15: reg = CV_REG_GS;  break;
 493     case 16: case 17: case 18: case 19:
 494     case 20: case 21: case 22: case 23:
 495         reg = CV_REG_ST0 + regno - 16; break;
 496     case 24: reg = CV_REG_CTRL; break;
 497     case 25: reg = CV_REG_STAT; break;
 498     case 26: reg = CV_REG_TAG; break;
 499 /*
 500 reg: fiseg 27
 501 reg: fioff 28
 502 reg: foseg 29
 503 reg: fooff 30
 504 reg: fop   31
 505 */
 506     case 32: case 33: case 34: case 35:
 507     case 36: case 37: case 38: case 39:
 508         reg = CV_REG_XMM0 + regno - 32; break;
 509     case 40: reg = CV_REG_MXCSR; break;
 510     default:
 511         FIXME("Don't know how to map register %d\n", regno);
 512         return 0;
 513     }
 514     return reg;
 515 }
 516
 517 static void* i386_fetch_context_reg(CONTEXT* ctx, unsigned regno, unsigned* size)
 518 {
 519 #ifdef __i386__
 520     switch (regno)
 521     {
 522     case CV_REG_EAX: *size = sizeof(ctx->Eax); return &ctx->Eax;
 523     case CV_REG_EDX: *size = sizeof(ctx->Edx); return &ctx->Edx;
 524     case CV_REG_ECX: *size = sizeof(ctx->Ecx); return &ctx->Ecx;
 525     case CV_REG_EBX: *size = sizeof(ctx->Ebx); return &ctx->Ebx;
 526     case CV_REG_ESI: *size = sizeof(ctx->Esi); return &ctx->Esi;
 527     case CV_REG_EDI: *size = sizeof(ctx->Edi); return &ctx->Edi;
 528     case CV_REG_EBP: *size = sizeof(ctx->Ebp); return &ctx->Ebp;
 529     case CV_REG_ESP: *size = sizeof(ctx->Esp); return &ctx->Esp;
 530     case CV_REG_EIP: *size = sizeof(ctx->Eip); return &ctx->Eip;
 531
 532     case CV_REG_ST0 + 0: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[0*sizeof(long double)];
 533     case CV_REG_ST0 + 1: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[1*sizeof(long double)];
 534     case CV_REG_ST0 + 2: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[2*sizeof(long double)];
 535     case CV_REG_ST0 + 3: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[3*sizeof(long double)];
 536     case CV_REG_ST0 + 4: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[4*sizeof(long double)];
 537     case CV_REG_ST0 + 5: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[5*sizeof(long double)];
 538     case CV_REG_ST0 + 6: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[6*sizeof(long double)];
 539     case CV_REG_ST0 + 7: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[7*sizeof(long double)];
 540
 541     case CV_REG_EFLAGS: *size = sizeof(ctx->EFlags); return &ctx->EFlags;
 542     case CV_REG_ES: *size = sizeof(ctx->SegEs); return &ctx->SegEs;
 543     case CV_REG_CS: *size = sizeof(ctx->SegCs); return &ctx->SegCs;
 544     case CV_REG_SS: *size = sizeof(ctx->SegSs); return &ctx->SegSs;
 545     case CV_REG_DS: *size = sizeof(ctx->SegDs); return &ctx->SegDs;
 546     case CV_REG_FS: *size = sizeof(ctx->SegFs); return &ctx->SegFs;
 547     case CV_REG_GS: *size = sizeof(ctx->SegGs); return &ctx->SegGs;
 548
 549     }
 550 #endif
 551     FIXME("Unknown register %x\n", regno);
 552     return NULL;
 553 }
 554
 555 static const char* i386_fetch_regname(unsigned regno)
 556 {
 557     switch (regno)
 558     {
 559     case CV_REG_EAX: return "eax";
 560     case CV_REG_EDX: return "edx";
 561     case CV_REG_ECX: return "ecx";
 562     case CV_REG_EBX: return "ebx";
 563     case CV_REG_ESI: return "esi";
 564     case CV_REG_EDI: return "edi";
 565     case CV_REG_EBP: return "ebp";
 566     case CV_REG_ESP: return "esp";
 567     case CV_REG_EIP: return "eip";
 568
 569     case CV_REG_ST0 + 0: return "st0";
 570     case CV_REG_ST0 + 1: return "st1";
 571     case CV_REG_ST0 + 2: return "st2";
 572     case CV_REG_ST0 + 3: return "st3";
 573     case CV_REG_ST0 + 4: return "st4";
 574     case CV_REG_ST0 + 5: return "st5";
 575     case CV_REG_ST0 + 6: return "st6";
 576     case CV_REG_ST0 + 7: return "st7";
 577
 578     case CV_REG_EFLAGS: return "eflags";
 579     case CV_REG_ES: return "es";
 580     case CV_REG_CS: return "cs";
 581     case CV_REG_SS: return "ss";
 582     case CV_REG_DS: return "ds";
 583     case CV_REG_FS: return "fs";
 584     case CV_REG_GS: return "gs";
 585     }
 586     FIXME("Unknown register %x\n", regno);
 587     return NULL;
 588 }
 589
 590 struct cpu cpu_i386 = {
 591     IMAGE_FILE_MACHINE_I386,
 592     4,
 593     i386_get_addr,
 594     i386_stack_walk,
 595     NULL,
 596     i386_map_dwarf_register,
 597     i386_fetch_context_reg,
 598     i386_fetch_regname,
 599 };