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
 112     /* sanity check */
 113     if (curr_mode >= stm_done) return FALSE;
 114
 115     TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%p nSwitch=%p\n",
 116           wine_dbgstr_addr(&frame->AddrPC),
 117           wine_dbgstr_addr(&frame->AddrFrame),
 118           wine_dbgstr_addr(&frame->AddrReturn),
 119           wine_dbgstr_addr(&frame->AddrStack),
 120           curr_mode == stm_start ? "start" : (curr_mode == stm_16bit ? "16bit" : "32bit"),
 121           (void*)(DWORD_PTR)curr_switch, (void*)(DWORD_PTR)next_switch);
 122
 123     if (curr_mode == stm_start)
 124     {
 125         THREAD_BASIC_INFORMATION info;
 126
 127         if ((frame->AddrPC.Mode == AddrModeFlat) &&
 128             (frame->AddrFrame.Mode != AddrModeFlat))
 129         {
 130             WARN("Bad AddrPC.Mode / AddrFrame.Mode combination\n");
 131             goto done_err;
 132         }
 133
 134         /* Init done */
 135         curr_mode = (frame->AddrPC.Mode == AddrModeFlat) ? stm_32bit : stm_16bit;
 136         deltapc = 0;
 137
 138         /* cur_switch holds address of WOW32Reserved field in TEB in debuggee
 139          * address space
 140          */
 141         if (NtQueryInformationThread(csw->hThread, ThreadBasicInformation, &info,
 142                                      sizeof(info), NULL) == STATUS_SUCCESS)
 143         {
 144             curr_switch = (unsigned long)info.TebBaseAddress + FIELD_OFFSET(TEB, WOW32Reserved);
 145             if (!sw_read_mem(csw, curr_switch, &p, sizeof(p)))
 146             {
 147                 WARN("Can't read TEB:WOW32Reserved\n");
 148                 goto done_err;
 149             }
 150             next_switch = p;
 151             if (!next_switch)  /* no 16-bit stack */
 152             {
 153                 curr_switch = 0;
 154             }
 155             else if (curr_mode == stm_16bit)
 156             {
 157                 if (!sw_read_mem(csw, next_switch, &frame32, sizeof(frame32)))
 158                 {
 159                     WARN("Bad stack frame %p\n", (void*)(DWORD_PTR)next_switch);
 160                     goto done_err;
 161                 }
 162                 curr_switch = (DWORD)frame32.frame16;
 163                 tmp.Mode    = AddrMode1616;
 164                 tmp.Segment = SELECTOROF(curr_switch);
 165                 tmp.Offset  = OFFSETOF(curr_switch);
 166                 if (!sw_read_mem(csw, sw_xlat_addr(csw, &tmp), &ch, sizeof(ch)))
 167                     curr_switch = 0xFFFFFFFF;
 168             }
 169             else
 170             {
 171                 tmp.Mode    = AddrMode1616;
 172                 tmp.Segment = SELECTOROF(next_switch);
 173                 tmp.Offset  = OFFSETOF(next_switch);
 174                 p = sw_xlat_addr(csw, &tmp);
 175                 if (!sw_read_mem(csw, p, &frame16, sizeof(frame16)))
 176                 {
 177                     WARN("Bad stack frame 0x%08x\n", p);
 178                     goto done_err;
 179                 }
 180                 curr_switch = (DWORD_PTR)frame16.frame32;
 181
 182                 if (!sw_read_mem(csw, curr_switch, &ch, sizeof(ch)))
 183                     curr_switch = 0xFFFFFFFF;
 184             }
 185         }
 186         else
 187             /* FIXME: this will allow to work when we're not attached to a live target,
 188              * but the 16 <=> 32 switch facility won't be available.
 189              */
 190             curr_switch = 0;
 191         frame->AddrReturn.Mode = frame->AddrStack.Mode = (curr_mode == stm_16bit) ? AddrMode1616 : AddrModeFlat;
 192         /* don't set up AddrStack on first call. Either the caller has set it up, or
 193          * we will get it in the next frame
 194          */
 195         memset(&frame->AddrBStore, 0, sizeof(frame->AddrBStore));
 196 #ifdef __i386__
 197         if (curr_mode == stm_32bit)
 198         {
 199             DWORD_PTR       xframe;
 200
 201             if (dwarf2_virtual_unwind(csw, frame->AddrPC.Offset - deltapc, context, &xframe))
 202             {
 203                 frame->AddrStack.Mode = frame->AddrFrame.Mode = frame->AddrReturn.Mode = AddrModeFlat;
 204                 frame->AddrStack.Offset = context->Esp = xframe;
 205                 frame->AddrFrame.Offset = context->Ebp;
 206                 frame->AddrReturn.Offset = context->Eip;
 207                 goto done_pep;
 208             }
 209         }
 210 #endif
 211     }
 212     else
 213     {
 214         if (frame->AddrFrame.Offset == 0) goto done_err;
 215         if (frame->AddrFrame.Mode == AddrModeFlat)
 216         {
 217             assert(curr_mode == stm_32bit);
 218             do_switch = curr_switch && frame->AddrFrame.Offset >= curr_switch;
 219         }
 220         else
 221         {
 222             assert(curr_mode == stm_16bit);
 223             do_switch = curr_switch &&
 224                 frame->AddrFrame.Segment == SELECTOROF(curr_switch) &&
 225                 frame->AddrFrame.Offset >= OFFSETOF(curr_switch);
 226         }
 227
 228         if (do_switch)
 229         {
 230             if (curr_mode == stm_16bit)
 231             {
 232                 if (!sw_read_mem(csw, next_switch, &frame32, sizeof(frame32)))
 233                 {
 234                     WARN("Bad stack frame %p\n", (void*)(DWORD_PTR)next_switch);
 235                     goto done_err;
 236                 }
 237
 238                 frame->AddrPC.Mode        = AddrModeFlat;
 239                 frame->AddrPC.Segment     = 0;
 240                 frame->AddrPC.Offset      = frame32.retaddr;
 241                 frame->AddrFrame.Mode     = AddrModeFlat;
 242                 frame->AddrFrame.Segment  = 0;
 243                 frame->AddrFrame.Offset   = frame32.ebp;
 244
 245                 frame->AddrStack.Mode     = AddrModeFlat;
 246                 frame->AddrStack.Segment  = 0;
 247                 frame->AddrReturn.Mode    = AddrModeFlat;
 248                 frame->AddrReturn.Segment = 0;
 249
 250                 next_switch = curr_switch;
 251                 tmp.Mode    = AddrMode1616;
 252                 tmp.Segment = SELECTOROF(next_switch);
 253                 tmp.Offset  = OFFSETOF(next_switch);
 254                 p = sw_xlat_addr(csw, &tmp);
 255
 256                 if (!sw_read_mem(csw, p, &frame16, sizeof(frame16)))
 257                 {
 258                     WARN("Bad stack frame 0x%08x\n", p);
 259                     goto done_err;
 260                 }
 261                 curr_switch = (DWORD_PTR)frame16.frame32;
 262                 curr_mode = stm_32bit;
 263                 if (!sw_read_mem(csw, curr_switch, &ch, sizeof(ch)))
 264                     curr_switch = 0;
 265             }
 266             else
 267             {
 268                 tmp.Mode    = AddrMode1616;
 269                 tmp.Segment = SELECTOROF(next_switch);
 270                 tmp.Offset  = OFFSETOF(next_switch);
 271                 p = sw_xlat_addr(csw, &tmp);
 272
 273                 if (!sw_read_mem(csw, p, &frame16, sizeof(frame16)))
 274                 {
 275                     WARN("Bad stack frame 0x%08x\n", p);
 276                     goto done_err;
 277                 }
 278
 279                 TRACE("Got a 16 bit stack switch:"
 280                       "\n\tframe32: %08lx"
 281                       "\n\tedx:%08x ecx:%08x ebp:%08x"
 282                       "\n\tds:%04x es:%04x fs:%04x gs:%04x"
 283                       "\n\tcall_from_ip:%08x module_cs:%04x relay=%08x"
 284                       "\n\tentry_ip:%04x entry_point:%08x"
 285                       "\n\tbp:%04x ip:%04x cs:%04x\n",
 286                       (unsigned long)frame16.frame32,
 287                       frame16.edx, frame16.ecx, frame16.ebp,
 288                       frame16.ds, frame16.es, frame16.fs, frame16.gs,
 289                       frame16.callfrom_ip, frame16.module_cs, frame16.relay,
 290                       frame16.entry_ip, frame16.entry_point,
 291                       frame16.bp, frame16.ip, frame16.cs);
 292
 293                 frame->AddrPC.Mode       = AddrMode1616;
 294                 frame->AddrPC.Segment    = frame16.cs;
 295                 frame->AddrPC.Offset     = frame16.ip;
 296
 297                 frame->AddrFrame.Mode    = AddrMode1616;
 298                 frame->AddrFrame.Segment = SELECTOROF(next_switch);
 299                 frame->AddrFrame.Offset  = frame16.bp;
 300
 301                 frame->AddrStack.Mode    = AddrMode1616;
 302                 frame->AddrStack.Segment = SELECTOROF(next_switch);
 303
 304                 frame->AddrReturn.Mode    = AddrMode1616;
 305                 frame->AddrReturn.Segment = frame16.cs;
 306
 307                 next_switch = curr_switch;
 308                 if (!sw_read_mem(csw, next_switch, &frame32, sizeof(frame32)))
 309                 {
 310                     WARN("Bad stack frame %p\n", (void*)(DWORD_PTR)next_switch);
 311                     goto done_err;
 312                 }
 313                 curr_switch = (DWORD)frame32.frame16;
 314                 tmp.Mode    = AddrMode1616;
 315                 tmp.Segment = SELECTOROF(curr_switch);
 316                 tmp.Offset  = OFFSETOF(curr_switch);
 317
 318                 if (!sw_read_mem(csw, sw_xlat_addr(csw, &tmp), &ch, sizeof(ch)))
 319                     curr_switch = 0;
 320                 curr_mode = stm_16bit;
 321             }
 322         }
 323         else
 324         {
 325             frame->AddrPC = frame->AddrReturn;
 326             if (curr_mode == stm_16bit)
 327             {
 328                 frame->AddrStack.Offset = frame->AddrFrame.Offset + 2 * sizeof(WORD);
 329                 /* "pop up" previous BP value */
 330                 if (!sw_read_mem(csw, sw_xlat_addr(csw, &frame->AddrFrame),
 331                                  &val, sizeof(WORD)))
 332                     goto done_err;
 333                 frame->AddrFrame.Offset = val;
 334             }
 335             else
 336             {
 337 #ifdef __i386__
 338                 DWORD_PTR       xframe;
 339
 340                 if (dwarf2_virtual_unwind(csw, frame->AddrPC.Offset - deltapc, context, &xframe))
 341                 {
 342                     frame->AddrStack.Mode = frame->AddrFrame.Mode = frame->AddrReturn.Mode = AddrModeFlat;
 343                     frame->AddrStack.Offset = context->Esp = xframe;
 344                     frame->AddrFrame.Offset = context->Ebp;
 345                     frame->AddrReturn.Offset = context->Eip;
 346                     goto done_pep;
 347                 }
 348 #endif
 349                 frame->AddrStack.Offset = frame->AddrFrame.Offset + 2 * sizeof(DWORD);
 350                 /* "pop up" previous EBP value */
 351                 if (!sw_read_mem(csw, frame->AddrFrame.Offset,
 352                                  &frame->AddrFrame.Offset, sizeof(DWORD)))
 353                     goto done_err;
 354             }
 355         }
 356     }
 357
 358     if (curr_mode == stm_16bit)
 359     {
 360         unsigned int     i;
 361
 362         p = sw_xlat_addr(csw, &frame->AddrFrame);
 363         if (!sw_read_mem(csw, p + sizeof(WORD), &val, sizeof(WORD)))
 364             goto done_err;
 365         frame->AddrReturn.Offset = val;
 366         /* get potential cs if a far call was used */
 367         if (!sw_read_mem(csw, p + 2 * sizeof(WORD), &val, sizeof(WORD)))
 368             goto done_err;
 369         if (frame->AddrFrame.Offset & 1)
 370             frame->AddrReturn.Segment = val; /* far call assumed */
 371         else
 372         {
 373             /* not explicitly marked as far call,
 374              * but check whether it could be anyway
 375              */
 376             if ((val & 7) == 7 && val != frame->AddrReturn.Segment)
 377             {
 378                 LDT_ENTRY       le;
 379
 380                 if (GetThreadSelectorEntry(csw->hThread, val, &le) &&
 381                     (le.HighWord.Bits.Type & 0x08)) /* code segment */
 382                 {
 383                     /* it is very uncommon to push a code segment cs as
 384                      * a parameter, so this should work in most cases
 385                      */
 386                     frame->AddrReturn.Segment = val;
 387                 }
 388             }
 389         }
 390         frame->AddrFrame.Offset &= ~1;
 391         /* we "pop" parameters as 16 bit entities... of course, this won't
 392          * work if the parameter is in fact bigger than 16bit, but
 393          * there's no way to know that here
 394          */
 395         for (i = 0; i < sizeof(frame->Params) / sizeof(frame->Params[0]); i++)
 396         {
 397             sw_read_mem(csw, p + (2 + i) * sizeof(WORD), &val, sizeof(val));
 398             frame->Params[i] = val;
 399         }
 400     }
 401     else
 402     {
 403         if (!sw_read_mem(csw, frame->AddrFrame.Offset + sizeof(DWORD),
 404                          &frame->AddrReturn.Offset, sizeof(DWORD)))
 405         {
 406             WARN("Cannot read new frame offset %p\n",
 407                  (void*)(DWORD_PTR)(frame->AddrFrame.Offset + (int)sizeof(DWORD)));
 408             goto done_err;
 409         }
 410         sw_read_mem(csw, frame->AddrFrame.Offset + 2 * sizeof(DWORD),
 411                     frame->Params, sizeof(frame->Params));
 412     }
 413     goto done_pep; /* just to ensure done_pep label is referenced */
 414 done_pep:
 415
 416     frame->Far = TRUE;
 417     frame->Virtual = TRUE;
 418     p = sw_xlat_addr(csw, &frame->AddrPC);
 419     if (p && sw_module_base(csw, p))
 420         frame->FuncTableEntry = sw_table_access(csw, p);
 421     else
 422         frame->FuncTableEntry = NULL;
 423
 424     TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%p nSwitch=%p FuncTable=%p\n",
 425           wine_dbgstr_addr(&frame->AddrPC),
 426           wine_dbgstr_addr(&frame->AddrFrame),
 427           wine_dbgstr_addr(&frame->AddrReturn),
 428           wine_dbgstr_addr(&frame->AddrStack),
 429           curr_mode == stm_start ? "start" : (curr_mode == stm_16bit ? "16bit" : "32bit"),
 430           (void*)(DWORD_PTR)curr_switch, (void*)(DWORD_PTR)next_switch, frame->FuncTableEntry);
 431
 432     return TRUE;
 433 done_err:
 434     curr_mode = stm_done;
 435     return FALSE;
 436 }
 437
 438 static unsigned i386_map_dwarf_register(unsigned regno)
 439 {
 440     unsigned    reg;
 441
 442     switch (regno)
 443     {
 444     case  0: reg = CV_REG_EAX; break;
 445     case  1: reg = CV_REG_ECX; break;
 446     case  2: reg = CV_REG_EDX; break;
 447     case  3: reg = CV_REG_EBX; break;
 448     case  4: reg = CV_REG_ESP; break;
 449     case  5: reg = CV_REG_EBP; break;
 450     case  6: reg = CV_REG_ESI; break;
 451     case  7: reg = CV_REG_EDI; break;
 452     case  8: reg = CV_REG_EIP; break;
 453     case  9: reg = CV_REG_EFLAGS; break;
 454     case 10: reg = CV_REG_CS;  break;
 455     case 11: reg = CV_REG_SS;  break;
 456     case 12: reg = CV_REG_DS;  break;
 457     case 13: reg = CV_REG_ES;  break;
 458     case 14: reg = CV_REG_FS;  break;
 459     case 15: reg = CV_REG_GS;  break;
 460     case 16: case 17: case 18: case 19:
 461     case 20: case 21: case 22: case 23:
 462         reg = CV_REG_ST0 + regno - 16; break;
 463     case 24: reg = CV_REG_CTRL; break;
 464     case 25: reg = CV_REG_STAT; break;
 465     case 26: reg = CV_REG_TAG; break;
 466 /*
 467 reg: fiseg 27
 468 reg: fioff 28
 469 reg: foseg 29
 470 reg: fooff 30
 471 reg: fop   31
 472 */
 473     case 32: case 33: case 34: case 35:
 474     case 36: case 37: case 38: case 39:
 475         reg = CV_REG_XMM0 + regno - 32; break;
 476     case 40: reg = CV_REG_MXCSR; break;
 477     default:
 478         FIXME("Don't know how to map register %d\n", regno);
 479         return 0;
 480     }
 481     return reg;
 482 }
 483
 484 static void* i386_fetch_context_reg(CONTEXT* ctx, unsigned regno, unsigned* size)
 485 {
 486 #ifdef __i386__
 487     switch (regno)
 488     {
 489     case CV_REG_EAX: *size = sizeof(ctx->Eax); return &ctx->Eax;
 490     case CV_REG_EDX: *size = sizeof(ctx->Edx); return &ctx->Edx;
 491     case CV_REG_ECX: *size = sizeof(ctx->Ecx); return &ctx->Ecx;
 492     case CV_REG_EBX: *size = sizeof(ctx->Ebx); return &ctx->Ebx;
 493     case CV_REG_ESI: *size = sizeof(ctx->Esi); return &ctx->Esi;
 494     case CV_REG_EDI: *size = sizeof(ctx->Edi); return &ctx->Edi;
 495     case CV_REG_EBP: *size = sizeof(ctx->Ebp); return &ctx->Ebp;
 496     case CV_REG_ESP: *size = sizeof(ctx->Esp); return &ctx->Esp;
 497     case CV_REG_EIP: *size = sizeof(ctx->Eip); return &ctx->Eip;
 498
 499     case CV_REG_ST0 + 0: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[0*sizeof(long double)];
 500     case CV_REG_ST0 + 1: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[1*sizeof(long double)];
 501     case CV_REG_ST0 + 2: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[2*sizeof(long double)];
 502     case CV_REG_ST0 + 3: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[3*sizeof(long double)];
 503     case CV_REG_ST0 + 4: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[4*sizeof(long double)];
 504     case CV_REG_ST0 + 5: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[5*sizeof(long double)];
 505     case CV_REG_ST0 + 6: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[6*sizeof(long double)];
 506     case CV_REG_ST0 + 7: *size = sizeof(long double); return &ctx->FloatSave.RegisterArea[7*sizeof(long double)];
 507
 508     case CV_REG_EFLAGS: *size = sizeof(ctx->EFlags); return &ctx->EFlags;
 509     case CV_REG_ES: *size = sizeof(ctx->SegEs); return &ctx->SegEs;
 510     case CV_REG_CS: *size = sizeof(ctx->SegCs); return &ctx->SegCs;
 511     case CV_REG_SS: *size = sizeof(ctx->SegSs); return &ctx->SegSs;
 512     case CV_REG_DS: *size = sizeof(ctx->SegDs); return &ctx->SegDs;
 513     case CV_REG_FS: *size = sizeof(ctx->SegFs); return &ctx->SegFs;
 514     case CV_REG_GS: *size = sizeof(ctx->SegGs); return &ctx->SegGs;
 515
 516     }
 517 #endif
 518     FIXME("Unknown register %x\n", regno);
 519     return NULL;
 520 }
 521
 522 static const char* i386_fetch_regname(unsigned regno)
 523 {
 524     switch (regno)
 525     {
 526     case CV_REG_EAX: return "eax";
 527     case CV_REG_EDX: return "edx";
 528     case CV_REG_ECX: return "ecx";
 529     case CV_REG_EBX: return "ebx";
 530     case CV_REG_ESI: return "esi";
 531     case CV_REG_EDI: return "edi";
 532     case CV_REG_EBP: return "ebp";
 533     case CV_REG_ESP: return "esp";
 534     case CV_REG_EIP: return "eip";
 535
 536     case CV_REG_ST0 + 0: return "st0";
 537     case CV_REG_ST0 + 1: return "st1";
 538     case CV_REG_ST0 + 2: return "st2";
 539     case CV_REG_ST0 + 3: return "st3";
 540     case CV_REG_ST0 + 4: return "st4";
 541     case CV_REG_ST0 + 5: return "st5";
 542     case CV_REG_ST0 + 6: return "st6";
 543     case CV_REG_ST0 + 7: return "st7";
 544
 545     case CV_REG_EFLAGS: return "eflags";
 546     case CV_REG_ES: return "es";
 547     case CV_REG_CS: return "cs";
 548     case CV_REG_SS: return "ss";
 549     case CV_REG_DS: return "ds";
 550     case CV_REG_FS: return "fs";
 551     case CV_REG_GS: return "gs";
 552     }
 553     FIXME("Unknown register %x\n", regno);
 554     return NULL;
 555 }
 556
 557 struct cpu cpu_i386 = {
 558     IMAGE_FILE_MACHINE_I386,
 559     4,
 560     i386_get_addr,
 561     i386_stack_walk,
 562     NULL,
 563     i386_map_dwarf_register,
 564     i386_fetch_context_reg,
 565     i386_fetch_regname,
 566 };