?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
c2man: Fix .spec file flag recognition.
[wine/testsucceed.git] / dlls / dbghelp / cpu_i386.c
blob61ed42701793658217e79fc7dd89b72cc9885f07
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 };
Quick hack tree for wine patches julliard doesn't want to commit