?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
windowscodecs: Add support for 8bpp grayscale TIFF with 8bpp alpha.
[wine.git] / dlls / dbghelp / cpu_i386.c
blob00745cb0ec4d0ac2e2305fab7fb8e7b35cd2b5ce
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 V86_FLAG 0x00020000
33
34 #define IS_VM86_MODE(ctx) (ctx->EFlags & V86_FLAG)
35
36 #ifdef __i386__
37 static ADDRESS_MODE get_selector_type(HANDLE hThread, const CONTEXT* ctx, WORD sel)
38 {
39 LDT_ENTRY le;
40
41 if (IS_VM86_MODE(ctx)) return AddrModeReal;
42 /* null or system selector */
43 if (!(sel & 4) || ((sel >> 3) < 17)) return AddrModeFlat;
44 if (hThread && GetThreadSelectorEntry(hThread, sel, &le))
45 return le.HighWord.Bits.Default_Big ? AddrMode1632 : AddrMode1616;
46 /* selector doesn't exist */
47 return -1;
48 }
49
50 static BOOL i386_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* addr,
51 unsigned seg, unsigned long offset)
52 {
53 addr->Mode = AddrModeFlat;
54 addr->Segment = seg;
55 addr->Offset = offset;
56 if (seg)
57 {
58 switch (addr->Mode = get_selector_type(hThread, ctx, seg))
59 {
60 case AddrModeReal:
61 case AddrMode1616:
62 addr->Offset &= 0xffff;
63 break;
64 case AddrModeFlat:
65 case AddrMode1632:
66 break;
67 default:
68 return FALSE;
69 }
70 }
71 return TRUE;
72 }
73 #endif
74
75 static BOOL i386_get_addr(HANDLE hThread, const CONTEXT* ctx,
76 enum cpu_addr ca, ADDRESS64* addr)
77 {
78 #ifdef __i386__
79 switch (ca)
80 {
81 case cpu_addr_pc: return i386_build_addr(hThread, ctx, addr, ctx->SegCs, ctx->Eip);
82 case cpu_addr_stack: return i386_build_addr(hThread, ctx, addr, ctx->SegSs, ctx->Esp);
83 case cpu_addr_frame: return i386_build_addr(hThread, ctx, addr, ctx->SegSs, ctx->Ebp);
84 }
85 #endif
86 return FALSE;
87 }
88
89 #ifdef __i386__
90 /* fetch_next_frame32()
91 *
92 * modify (at least) context.{eip, esp, ebp} using unwind information
93 * either out of debug info (dwarf, pdb), or simple stack unwind
94 */
95 static BOOL fetch_next_frame32(struct cpu_stack_walk* csw,
96 CONTEXT* context, DWORD_PTR curr_pc)
97 {
98 DWORD_PTR xframe;
99 struct pdb_cmd_pair cpair[4];
100 DWORD val32;
101
102 if (dwarf2_virtual_unwind(csw, curr_pc, context, &xframe))
103 {
104 context->Esp = xframe;
105 return TRUE;
106 }
107 cpair[0].name = "$ebp"; cpair[0].pvalue = &context->Ebp;
108 cpair[1].name = "$esp"; cpair[1].pvalue = &context->Esp;
109 cpair[2].name = "$eip"; cpair[2].pvalue = &context->Eip;
110 cpair[3].name = NULL; cpair[3].pvalue = NULL;
111
112 if (!pdb_virtual_unwind(csw, curr_pc, context, cpair))
113 {
114 /* do a simple unwind using ebp
115 * we assume a "regular" prologue in the function has been used
116 */
117 if (!context->Ebp) return FALSE;
118 context->Esp = context->Ebp + 2 * sizeof(DWORD);
119 if (!sw_read_mem(csw, context->Ebp + sizeof(DWORD), &val32, sizeof(DWORD)))
120 {
121 WARN("Cannot read new frame offset %p\n",
122 (void*)(DWORD_PTR)(context->Ebp + (int)sizeof(DWORD)));
123 return FALSE;
124 }
125 context->Eip = val32;
126 /* "pop up" previous EBP value */
127 if (!sw_read_mem(csw, context->Ebp, &val32, sizeof(DWORD)))
128 return FALSE;
129 context->Ebp = val32;
130 }
131 return TRUE;
132 }
133 #endif
134
135 enum st_mode {stm_start, stm_32bit, stm_16bit, stm_done};
136
137 /* indexes in Reserved array */
138 #define __CurrentModeCount 0
139 #define __CurrentSwitch 1
140 #define __NextSwitch 2
141
142 #define curr_mode (frame->Reserved[__CurrentModeCount] & 0x0F)
143 #define curr_count (frame->Reserved[__CurrentModeCount] >> 4)
144 #define curr_switch (frame->Reserved[__CurrentSwitch])
145 #define next_switch (frame->Reserved[__NextSwitch])
146
147 #define set_curr_mode(m) {frame->Reserved[__CurrentModeCount] &= ~0x0F; frame->Reserved[__CurrentModeCount] |= (m & 0x0F);}
148 #define inc_curr_count() (frame->Reserved[__CurrentModeCount] += 0x10)
149
150 static BOOL i386_stack_walk(struct cpu_stack_walk* csw, LPSTACKFRAME64 frame, CONTEXT* context)
151 {
152 STACK32FRAME frame32;
153 STACK16FRAME frame16;
154 char ch;
155 ADDRESS64 tmp;
156 DWORD p;
157 WORD val16;
158 DWORD val32;
159 BOOL do_switch;
160 #ifdef __i386__
161 unsigned deltapc;
162 CONTEXT _context;
163 #endif
164
165 /* sanity check */
166 if (curr_mode >= stm_done) return FALSE;
167
168 TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s cSwitch=%p nSwitch=%p\n",
169 wine_dbgstr_addr(&frame->AddrPC),
170 wine_dbgstr_addr(&frame->AddrFrame),
171 wine_dbgstr_addr(&frame->AddrReturn),
172 wine_dbgstr_addr(&frame->AddrStack),
173 curr_mode == stm_start ? "start" : (curr_mode == stm_16bit ? "16bit" : "32bit"),
174 wine_dbgstr_longlong(curr_count),
175 (void*)(DWORD_PTR)curr_switch, (void*)(DWORD_PTR)next_switch);
176
177 #ifdef __i386__
178 /* if we're at first call (which doesn't actually unwind, it just computes ReturnPC,
179 * or if we're doing the first real unwind (count == 1), then we can directly use
180 * eip. otherwise, eip is *after* the insn that actually made the call to
181 * previous frame, so decrease eip by delta pc (1!) so that we're inside previous
182 * insn.
183 * Doing so, we ensure that the pc used for unwinding is always inside the function
184 * we want to use for next frame
185 */
186 deltapc = curr_count <= 1 ? 0 : 1;
187
188 if (!context)
189 {
190 /* setup a pseudo context for the rest of the code (esp. unwinding) */
191 context = &_context;
192 memset(context, 0, sizeof(*context));
193 context->ContextFlags = CONTEXT_CONTROL | CONTEXT_SEGMENTS;
194 if (frame->AddrPC.Mode != AddrModeFlat) context->SegCs = frame->AddrPC.Segment;
195 context->Eip = frame->AddrPC.Offset;
196 if (frame->AddrFrame.Mode != AddrModeFlat) context->SegSs = frame->AddrFrame.Segment;
197 context->Ebp = frame->AddrFrame.Offset;
198 if (frame->AddrStack.Mode != AddrModeFlat) context->SegSs = frame->AddrStack.Segment;
199 context->Esp = frame->AddrStack.Offset;
200 }
201 #endif
202 if (curr_mode == stm_start)
203 {
204 THREAD_BASIC_INFORMATION info;
205
206 if ((frame->AddrPC.Mode == AddrModeFlat) &&
207 (frame->AddrFrame.Mode != AddrModeFlat))
208 {
209 WARN("Bad AddrPC.Mode / AddrFrame.Mode combination\n");
210 goto done_err;
211 }
212
213 /* Init done */
214 set_curr_mode((frame->AddrPC.Mode == AddrModeFlat) ? stm_32bit : stm_16bit);
215
216 /* cur_switch holds address of WOW32Reserved field in TEB in debuggee
217 * address space
218 */
219 if (NtQueryInformationThread(csw->hThread, ThreadBasicInformation, &info,
220 sizeof(info), NULL) == STATUS_SUCCESS)
221 {
222 curr_switch = (DWORD_PTR)info.TebBaseAddress + FIELD_OFFSET(TEB, WOW32Reserved);
223 if (!sw_read_mem(csw, curr_switch, &p, sizeof(p)))
224 {
225 WARN("Can't read TEB:WOW32Reserved\n");
226 goto done_err;
227 }
228 next_switch = p;
229 if (!next_switch) /* no 16-bit stack */
230 {
231 curr_switch = 0;
232 }
233 else if (curr_mode == stm_16bit)
234 {
235 if (!sw_read_mem(csw, next_switch, &frame32, sizeof(frame32)))
236 {
237 WARN("Bad stack frame %p\n", (void*)(DWORD_PTR)next_switch);
238 goto done_err;
239 }
240 curr_switch = (DWORD)frame32.frame16;
241 tmp.Mode = AddrMode1616;
242 tmp.Segment = SELECTOROF(curr_switch);
243 tmp.Offset = OFFSETOF(curr_switch);
244 if (!sw_read_mem(csw, sw_xlat_addr(csw, &tmp), &ch, sizeof(ch)))
245 curr_switch = 0xFFFFFFFF;
246 }
247 else
248 {
249 tmp.Mode = AddrMode1616;
250 tmp.Segment = SELECTOROF(next_switch);
251 tmp.Offset = OFFSETOF(next_switch);
252 p = sw_xlat_addr(csw, &tmp);
253 if (!sw_read_mem(csw, p, &frame16, sizeof(frame16)))
254 {
255 WARN("Bad stack frame 0x%08x\n", p);
256 goto done_err;
257 }
258 curr_switch = (DWORD_PTR)frame16.frame32;
259 if (!sw_read_mem(csw, curr_switch, &ch, sizeof(ch)))
260 curr_switch = 0xFFFFFFFF;
261 }
262 }
263 else
264 /* FIXME: this will allow to work when we're not attached to a live target,
265 * but the 16 <=> 32 switch facility won't be available.
266 */
267 curr_switch = 0;
268 frame->AddrReturn.Mode = frame->AddrStack.Mode = (curr_mode == stm_16bit) ? AddrMode1616 : AddrModeFlat;
269 /* don't set up AddrStack on first call. Either the caller has set it up, or
270 * we will get it in the next frame
271 */
272 memset(&frame->AddrBStore, 0, sizeof(frame->AddrBStore));
273 }
274 else
275 {
276 if (frame->AddrFrame.Mode == AddrModeFlat)
277 {
278 assert(curr_mode == stm_32bit);
279 do_switch = curr_switch && frame->AddrFrame.Offset >= curr_switch;
280 }
281 else
282 {
283 assert(curr_mode == stm_16bit);
284 do_switch = curr_switch &&
285 frame->AddrFrame.Segment == SELECTOROF(curr_switch) &&
286 frame->AddrFrame.Offset >= OFFSETOF(curr_switch);
287 }
288
289 if (do_switch)
290 {
291 if (curr_mode == stm_16bit)
292 {
293 if (!sw_read_mem(csw, next_switch, &frame32, sizeof(frame32)))
294 {
295 WARN("Bad stack frame %p\n", (void*)(DWORD_PTR)next_switch);
296 goto done_err;
297 }
298
299 frame->AddrPC.Mode = AddrModeFlat;
300 frame->AddrPC.Segment = 0;
301 frame->AddrPC.Offset = frame32.retaddr;
302 frame->AddrFrame.Mode = AddrModeFlat;
303 frame->AddrFrame.Segment = 0;
304 frame->AddrFrame.Offset = frame32.ebp;
305
306 frame->AddrStack.Mode = AddrModeFlat;
307 frame->AddrStack.Segment = 0;
308 frame->AddrReturn.Mode = AddrModeFlat;
309 frame->AddrReturn.Segment = 0;
310
311 next_switch = curr_switch;
312 tmp.Mode = AddrMode1616;
313 tmp.Segment = SELECTOROF(next_switch);
314 tmp.Offset = OFFSETOF(next_switch);
315 p = sw_xlat_addr(csw, &tmp);
316
317 if (!sw_read_mem(csw, p, &frame16, sizeof(frame16)))
318 {
319 WARN("Bad stack frame 0x%08x\n", p);
320 goto done_err;
321 }
322 curr_switch = (DWORD_PTR)frame16.frame32;
323 set_curr_mode(stm_32bit);
324 if (!sw_read_mem(csw, curr_switch, &ch, sizeof(ch)))
325 curr_switch = 0;
326 }
327 else
328 {
329 tmp.Mode = AddrMode1616;
330 tmp.Segment = SELECTOROF(next_switch);
331 tmp.Offset = OFFSETOF(next_switch);
332 p = sw_xlat_addr(csw, &tmp);
333
334 if (!sw_read_mem(csw, p, &frame16, sizeof(frame16)))
335 {
336 WARN("Bad stack frame 0x%08x\n", p);
337 goto done_err;
338 }
339
340 TRACE("Got a 16 bit stack switch:"
341 "\n\tframe32: %p"
342 "\n\tedx:%08x ecx:%08x ebp:%08x"
343 "\n\tds:%04x es:%04x fs:%04x gs:%04x"
344 "\n\tcall_from_ip:%08x module_cs:%04x relay=%08x"
345 "\n\tentry_ip:%04x entry_point:%08x"
346 "\n\tbp:%04x ip:%04x cs:%04x\n",
347 frame16.frame32,
348 frame16.edx, frame16.ecx, frame16.ebp,
349 frame16.ds, frame16.es, frame16.fs, frame16.gs,
350 frame16.callfrom_ip, frame16.module_cs, frame16.relay,
351 frame16.entry_ip, frame16.entry_point,
352 frame16.bp, frame16.ip, frame16.cs);
353
354 frame->AddrPC.Mode = AddrMode1616;
355 frame->AddrPC.Segment = frame16.cs;
356 frame->AddrPC.Offset = frame16.ip;
357
358 frame->AddrFrame.Mode = AddrMode1616;
359 frame->AddrFrame.Segment = SELECTOROF(next_switch);
360 frame->AddrFrame.Offset = frame16.bp;
361
362 frame->AddrStack.Mode = AddrMode1616;
363 frame->AddrStack.Segment = SELECTOROF(next_switch);
364
365 frame->AddrReturn.Mode = AddrMode1616;
366 frame->AddrReturn.Segment = frame16.cs;
367
368 next_switch = curr_switch;
369 if (!sw_read_mem(csw, next_switch, &frame32, sizeof(frame32)))
370 {
371 WARN("Bad stack frame %p\n", (void*)(DWORD_PTR)next_switch);
372 goto done_err;
373 }
374 curr_switch = (DWORD)frame32.frame16;
375 tmp.Mode = AddrMode1616;
376 tmp.Segment = SELECTOROF(curr_switch);
377 tmp.Offset = OFFSETOF(curr_switch);
378
379 if (!sw_read_mem(csw, sw_xlat_addr(csw, &tmp), &ch, sizeof(ch)))
380 curr_switch = 0;
381 set_curr_mode(stm_16bit);
382 }
383 }
384 else
385 {
386 if (curr_mode == stm_16bit)
387 {
388 frame->AddrPC = frame->AddrReturn;
389 frame->AddrStack.Offset = frame->AddrFrame.Offset + 2 * sizeof(WORD);
390 /* "pop up" previous BP value */
391 if (!frame->AddrFrame.Offset ||
392 !sw_read_mem(csw, sw_xlat_addr(csw, &frame->AddrFrame),
393 &val16, sizeof(WORD)))
394 goto done_err;
395 frame->AddrFrame.Offset = val16;
396 }
397 else
398 {
399 #ifdef __i386__
400 if (!fetch_next_frame32(csw, context, sw_xlat_addr(csw, &frame->AddrPC) - deltapc))
401 goto done_err;
402
403 frame->AddrStack.Mode = frame->AddrFrame.Mode = frame->AddrPC.Mode = AddrModeFlat;
404 frame->AddrStack.Offset = context->Esp;
405 frame->AddrFrame.Offset = context->Ebp;
406 if (frame->AddrReturn.Offset != context->Eip)
407 FIXME("new PC=%s different from Eip=%x\n",
408 wine_dbgstr_longlong(frame->AddrReturn.Offset), context->Eip);
409 frame->AddrPC.Offset = context->Eip;
410 #endif
411 }
412 }
413 }
414
415 if (curr_mode == stm_16bit)
416 {
417 unsigned int i;
418
419 p = sw_xlat_addr(csw, &frame->AddrFrame);
420 if (!sw_read_mem(csw, p + sizeof(WORD), &val16, sizeof(WORD)))
421 goto done_err;
422 frame->AddrReturn.Offset = val16;
423 /* get potential cs if a far call was used */
424 if (!sw_read_mem(csw, p + 2 * sizeof(WORD), &val16, sizeof(WORD)))
425 goto done_err;
426 if (frame->AddrFrame.Offset & 1)
427 frame->AddrReturn.Segment = val16; /* far call assumed */
428 else
429 {
430 /* not explicitly marked as far call,
431 * but check whether it could be anyway
432 */
433 if ((val16 & 7) == 7 && val16 != frame->AddrReturn.Segment)
434 {
435 LDT_ENTRY le;
436
437 if (GetThreadSelectorEntry(csw->hThread, val16, &le) &&
438 (le.HighWord.Bits.Type & 0x08)) /* code segment */
439 {
440 /* it is very uncommon to push a code segment cs as
441 * a parameter, so this should work in most cases
442 */
443 frame->AddrReturn.Segment = val16;
444 }
445 }
446 }
447 frame->AddrFrame.Offset &= ~1;
448 /* we "pop" parameters as 16 bit entities... of course, this won't
449 * work if the parameter is in fact bigger than 16bit, but
450 * there's no way to know that here
451 */
452 for (i = 0; i < sizeof(frame->Params) / sizeof(frame->Params[0]); i++)
453 {
454 sw_read_mem(csw, p + (2 + i) * sizeof(WORD), &val16, sizeof(val16));
455 frame->Params[i] = val16;
456 }
457 #ifdef __i386__
458 if (context)
459 {
460 #define SET(field, seg, reg) \
461 switch (frame->field.Mode) \
462 { \
463 case AddrModeFlat: context->reg = frame->field.Offset; break; \
464 case AddrMode1616: context->seg = frame->field.Segment; context->reg = frame->field.Offset; break; \
465 default: assert(0); \
466 }
467 SET(AddrStack, SegSs, Esp);
468 SET(AddrFrame, SegSs, Ebp);
469 SET(AddrReturn, SegCs, Eip);
470 #undef SET
471 }
472 #endif
473 }
474 else
475 {
476 unsigned int i;
477 #ifdef __i386__
478 CONTEXT newctx = *context;
479
480 if (!fetch_next_frame32(csw, &newctx, frame->AddrPC.Offset - deltapc))
481 goto done_err;
482 frame->AddrReturn.Mode = AddrModeFlat;
483 frame->AddrReturn.Offset = newctx.Eip;
484 #endif
485 for (i = 0; i < sizeof(frame->Params) / sizeof(frame->Params[0]); i++)
486 {
487 sw_read_mem(csw, frame->AddrFrame.Offset + (2 + i) * sizeof(DWORD), &val32, sizeof(val32));
488 frame->Params[i] = val32;
489 }
490 }
491
492 frame->Far = TRUE;
493 frame->Virtual = TRUE;
494 p = sw_xlat_addr(csw, &frame->AddrPC);
495 if (p && sw_module_base(csw, p))
496 frame->FuncTableEntry = sw_table_access(csw, p);
497 else
498 frame->FuncTableEntry = NULL;
499
500 inc_curr_count();
501 TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s cSwitch=%p nSwitch=%p FuncTable=%p\n",
502 wine_dbgstr_addr(&frame->AddrPC),
503 wine_dbgstr_addr(&frame->AddrFrame),
504 wine_dbgstr_addr(&frame->AddrReturn),
505 wine_dbgstr_addr(&frame->AddrStack),
506 curr_mode == stm_start ? "start" : (curr_mode == stm_16bit ? "16bit" : "32bit"),
507 wine_dbgstr_longlong(curr_count),
508 (void*)(DWORD_PTR)curr_switch, (void*)(DWORD_PTR)next_switch, frame->FuncTableEntry);
509
510 return TRUE;
511 done_err:
512 set_curr_mode(stm_done);
513 return FALSE;
514 }
515
516 static unsigned i386_map_dwarf_register(unsigned regno, BOOL eh_frame)
517 {
518 unsigned reg;
519
520 switch (regno)
521 {
522 case 0: reg = CV_REG_EAX; break;
523 case 1: reg = CV_REG_ECX; break;
524 case 2: reg = CV_REG_EDX; break;
525 case 3: reg = CV_REG_EBX; break;
526 case 4:
527 case 5:
528 #ifdef __APPLE__
529 /* On OS X, DWARF eh_frame uses a different mapping for the registers. It's
530 apparently the mapping as emitted by GCC, at least at some point in its history. */
531 if (eh_frame)
532 reg = (regno == 4) ? CV_REG_EBP : CV_REG_ESP;
533 else
534 #endif
535 reg = (regno == 4) ? CV_REG_ESP : CV_REG_EBP;
536 break;
537 case 6: reg = CV_REG_ESI; break;
538 case 7: reg = CV_REG_EDI; break;
539 case 8: reg = CV_REG_EIP; break;
540 case 9: reg = CV_REG_EFLAGS; break;
541 case 10: reg = CV_REG_CS; break;
542 case 11: reg = CV_REG_SS; break;
543 case 12: reg = CV_REG_DS; break;
544 case 13: reg = CV_REG_ES; break;
545 case 14: reg = CV_REG_FS; break;
546 case 15: reg = CV_REG_GS; break;
547 case 16: case 17: case 18: case 19:
548 case 20: case 21: case 22: case 23:
549 reg = CV_REG_ST0 + regno - 16; break;
550 case 24: reg = CV_REG_CTRL; break;
551 case 25: reg = CV_REG_STAT; break;
552 case 26: reg = CV_REG_TAG; break;
553 case 27: reg = CV_REG_FPCS; break;
554 case 28: reg = CV_REG_FPIP; break;
555 case 29: reg = CV_REG_FPDS; break;
556 case 30: reg = CV_REG_FPDO; break;
557 /*
558 reg: fop 31
559 */
560 case 32: case 33: case 34: case 35:
561 case 36: case 37: case 38: case 39:
562 reg = CV_REG_XMM0 + regno - 32; break;
563 case 40: reg = CV_REG_MXCSR; break;
564 default:
565 FIXME("Don't know how to map register %d\n", regno);
566 return 0;
567 }
568 return reg;
569 }
570
571 static void* i386_fetch_context_reg(CONTEXT* ctx, unsigned regno, unsigned* size)
572 {
573 #ifdef __i386__
574 switch (regno)
575 {
576 case CV_REG_EAX: *size = sizeof(ctx->Eax); return &ctx->Eax;
577 case CV_REG_EDX: *size = sizeof(ctx->Edx); return &ctx->Edx;
578 case CV_REG_ECX: *size = sizeof(ctx->Ecx); return &ctx->Ecx;
579 case CV_REG_EBX: *size = sizeof(ctx->Ebx); return &ctx->Ebx;
580 case CV_REG_ESI: *size = sizeof(ctx->Esi); return &ctx->Esi;
581 case CV_REG_EDI: *size = sizeof(ctx->Edi); return &ctx->Edi;
582 case CV_REG_EBP: *size = sizeof(ctx->Ebp); return &ctx->Ebp;
583 case CV_REG_ESP: *size = sizeof(ctx->Esp); return &ctx->Esp;
584 case CV_REG_EIP: *size = sizeof(ctx->Eip); return &ctx->Eip;
585
586 /* These are x87 floating point registers... They do not match a C type in
587 * the Linux ABI, so hardcode their 80-bitness. */
588 case CV_REG_ST0 + 0: *size = 10; return &ctx->FloatSave.RegisterArea[0*10];
589 case CV_REG_ST0 + 1: *size = 10; return &ctx->FloatSave.RegisterArea[1*10];
590 case CV_REG_ST0 + 2: *size = 10; return &ctx->FloatSave.RegisterArea[2*10];
591 case CV_REG_ST0 + 3: *size = 10; return &ctx->FloatSave.RegisterArea[3*10];
592 case CV_REG_ST0 + 4: *size = 10; return &ctx->FloatSave.RegisterArea[4*10];
593 case CV_REG_ST0 + 5: *size = 10; return &ctx->FloatSave.RegisterArea[5*10];
594 case CV_REG_ST0 + 6: *size = 10; return &ctx->FloatSave.RegisterArea[6*10];
595 case CV_REG_ST0 + 7: *size = 10; return &ctx->FloatSave.RegisterArea[7*10];
596
597 case CV_REG_CTRL: *size = sizeof(DWORD); return &ctx->FloatSave.ControlWord;
598 case CV_REG_STAT: *size = sizeof(DWORD); return &ctx->FloatSave.StatusWord;
599 case CV_REG_TAG: *size = sizeof(DWORD); return &ctx->FloatSave.TagWord;
600 case CV_REG_FPCS: *size = sizeof(DWORD); return &ctx->FloatSave.ErrorSelector;
601 case CV_REG_FPIP: *size = sizeof(DWORD); return &ctx->FloatSave.ErrorOffset;
602 case CV_REG_FPDS: *size = sizeof(DWORD); return &ctx->FloatSave.DataSelector;
603 case CV_REG_FPDO: *size = sizeof(DWORD); return &ctx->FloatSave.DataOffset;
604
605 case CV_REG_EFLAGS: *size = sizeof(ctx->EFlags); return &ctx->EFlags;
606 case CV_REG_ES: *size = sizeof(ctx->SegEs); return &ctx->SegEs;
607 case CV_REG_CS: *size = sizeof(ctx->SegCs); return &ctx->SegCs;
608 case CV_REG_SS: *size = sizeof(ctx->SegSs); return &ctx->SegSs;
609 case CV_REG_DS: *size = sizeof(ctx->SegDs); return &ctx->SegDs;
610 case CV_REG_FS: *size = sizeof(ctx->SegFs); return &ctx->SegFs;
611 case CV_REG_GS: *size = sizeof(ctx->SegGs); return &ctx->SegGs;
612
613 }
614 #endif
615 FIXME("Unknown register %x\n", regno);
616 return NULL;
617 }
618
619 static const char* i386_fetch_regname(unsigned regno)
620 {
621 switch (regno)
622 {
623 case CV_REG_EAX: return "eax";
624 case CV_REG_EDX: return "edx";
625 case CV_REG_ECX: return "ecx";
626 case CV_REG_EBX: return "ebx";
627 case CV_REG_ESI: return "esi";
628 case CV_REG_EDI: return "edi";
629 case CV_REG_EBP: return "ebp";
630 case CV_REG_ESP: return "esp";
631 case CV_REG_EIP: return "eip";
632
633 case CV_REG_ST0 + 0: return "st0";
634 case CV_REG_ST0 + 1: return "st1";
635 case CV_REG_ST0 + 2: return "st2";
636 case CV_REG_ST0 + 3: return "st3";
637 case CV_REG_ST0 + 4: return "st4";
638 case CV_REG_ST0 + 5: return "st5";
639 case CV_REG_ST0 + 6: return "st6";
640 case CV_REG_ST0 + 7: return "st7";
641
642 case CV_REG_EFLAGS: return "eflags";
643 case CV_REG_ES: return "es";
644 case CV_REG_CS: return "cs";
645 case CV_REG_SS: return "ss";
646 case CV_REG_DS: return "ds";
647 case CV_REG_FS: return "fs";
648 case CV_REG_GS: return "gs";
649
650 case CV_REG_CTRL: return "fpControl";
651 case CV_REG_STAT: return "fpStatus";
652 case CV_REG_TAG: return "fpTag";
653 case CV_REG_FPCS: return "fpCS";
654 case CV_REG_FPIP: return "fpIP";
655 case CV_REG_FPDS: return "fpDS";
656 case CV_REG_FPDO: return "fpData";
657
658 case CV_REG_XMM0 + 0: return "xmm0";
659 case CV_REG_XMM0 + 1: return "xmm1";
660 case CV_REG_XMM0 + 2: return "xmm2";
661 case CV_REG_XMM0 + 3: return "xmm3";
662 case CV_REG_XMM0 + 4: return "xmm4";
663 case CV_REG_XMM0 + 5: return "xmm5";
664 case CV_REG_XMM0 + 6: return "xmm6";
665 case CV_REG_XMM0 + 7: return "xmm7";
666
667 case CV_REG_MXCSR: return "MxCSR";
668 }
669 FIXME("Unknown register %x\n", regno);
670 return NULL;
671 }
672
673 static BOOL i386_fetch_minidump_thread(struct dump_context* dc, unsigned index, unsigned flags, const CONTEXT* ctx)
674 {
675 if (ctx->ContextFlags && (flags & ThreadWriteInstructionWindow))
676 {
677 /* FIXME: crop values across module boundaries, */
678 #ifdef __i386__
679 ULONG base = ctx->Eip <= 0x80 ? 0 : ctx->Eip - 0x80;
680 minidump_add_memory_block(dc, base, ctx->Eip + 0x80 - base, 0);
681 #endif
682 }
683
684 return TRUE;
685 }
686
687 static BOOL i386_fetch_minidump_module(struct dump_context* dc, unsigned index, unsigned flags)
688 {
689 /* FIXME: actually, we should probably take care of FPO data, unless it's stored in
690 * function table minidump stream
691 */
692 return FALSE;
693 }
694
695 DECLSPEC_HIDDEN struct cpu cpu_i386 = {
696 IMAGE_FILE_MACHINE_I386,
697 4,
698 CV_REG_EBP,
699 i386_get_addr,
700 i386_stack_walk,
701 NULL,
702 i386_map_dwarf_register,
703 i386_fetch_context_reg,
704 i386_fetch_regname,
705 i386_fetch_minidump_thread,
706 i386_fetch_minidump_module,
707 };
Windows API implementation