?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
shlwapi: Handle URL_WININET_COMPATIBILITY flag in UrlCanonicalize.
[wine/multimedia.git] / dlls / dbghelp / cpu_i386.c
blob7739d13bb50ffb9bc06fefd41f693848f1e6b12c
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 };
Maarten's multimedia branch