?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cmd: DIR command outputs free space for the path.
[wine.git] / dlls / dbghelp / cpu_x86_64.c
blobc653c5fa9dd817d5cd9f76d94ff2ace84e8c7627
1 /*
2 * File cpu_x86_64.c
3 *
4 * Copyright (C) 1999, 2005 Alexandre Julliard
5 * Copyright (C) 2009, 2011 Eric Pouech.
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <assert.h>
23
24 #include "ntstatus.h"
25 #define WIN32_NO_STATUS
26 #include "dbghelp_private.h"
27 #include "winternl.h"
28 #include "wine/debug.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
31
32 /* x86-64 unwind information, for PE modules, as described on MSDN */
33
34 typedef enum _UNWIND_OP_CODES
35 {
36 UWOP_PUSH_NONVOL = 0,
37 UWOP_ALLOC_LARGE,
38 UWOP_ALLOC_SMALL,
39 UWOP_SET_FPREG,
40 UWOP_SAVE_NONVOL,
41 UWOP_SAVE_NONVOL_FAR,
42 UWOP_EPILOG,
43 UWOP_SAVE_XMM128 = 8,
44 UWOP_SAVE_XMM128_FAR,
45 UWOP_PUSH_MACHFRAME
46 } UNWIND_CODE_OPS;
47
48 typedef union _UNWIND_CODE
49 {
50 struct
51 {
52 BYTE CodeOffset;
53 BYTE UnwindOp : 4;
54 BYTE OpInfo : 4;
55 };
56 USHORT FrameOffset;
57 } UNWIND_CODE, *PUNWIND_CODE;
58
59 typedef struct _UNWIND_INFO
60 {
61 BYTE Version : 3;
62 BYTE Flags : 5;
63 BYTE SizeOfProlog;
64 BYTE CountOfCodes;
65 BYTE FrameRegister : 4;
66 BYTE FrameOffset : 4;
67 UNWIND_CODE UnwindCode[1]; /* actually CountOfCodes (aligned) */
68 /*
69 * union
70 * {
71 * OPTIONAL ULONG ExceptionHandler;
72 * OPTIONAL ULONG FunctionEntry;
73 * };
74 * OPTIONAL ULONG ExceptionData[];
75 */
76 } UNWIND_INFO, *PUNWIND_INFO;
77
78 static BOOL x86_64_get_addr(HANDLE hThread, const CONTEXT* ctx,
79 enum cpu_addr ca, ADDRESS64* addr)
80 {
81 addr->Mode = AddrModeFlat;
82 switch (ca)
83 {
84 #ifdef __x86_64__
85 case cpu_addr_pc: addr->Segment = ctx->SegCs; addr->Offset = ctx->Rip; return TRUE;
86 case cpu_addr_stack: addr->Segment = ctx->SegSs; addr->Offset = ctx->Rsp; return TRUE;
87 case cpu_addr_frame: addr->Segment = ctx->SegSs; addr->Offset = ctx->Rbp; return TRUE;
88 #endif
89 default: addr->Mode = -1;
90 return FALSE;
91 }
92 }
93
94 #ifdef __x86_64__
95
96 enum st_mode {stm_start, stm_64bit, stm_done};
97
98 /* indexes in Reserved array */
99 #define __CurrentMode 0
100 #define __CurrentCount 1
101 /* #define __ 2 (unused) */
102
103 #define curr_mode (frame->Reserved[__CurrentMode])
104 #define curr_count (frame->Reserved[__CurrentCount])
105 /* #define ??? (frame->Reserved[__]) (unused) */
106
107 union handler_data
108 {
109 RUNTIME_FUNCTION chain;
110 ULONG handler;
111 };
112
113 static void dump_unwind_info(struct cpu_stack_walk* csw, ULONG64 base, RUNTIME_FUNCTION *function)
114 {
115 static const char * const reg_names[16] =
116 { "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
117 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" };
118
119 union handler_data handler_data;
120 char buffer[sizeof(UNWIND_INFO) + 256 * sizeof(UNWIND_CODE)];
121 UNWIND_INFO* info = (UNWIND_INFO*)buffer;
122 unsigned int i, count;
123 RUNTIME_FUNCTION snext;
124 ULONG64 addr;
125
126 TRACE("**** func %lx-%lx\n", function->BeginAddress, function->EndAddress);
127 for (;;)
128 {
129 if (function->UnwindData & 1)
130 {
131 if (!sw_read_mem(csw, base + function->UnwindData, &snext, sizeof(snext)))
132 {
133 TRACE("Couldn't unwind RUNTIME_INFO at %Ix\n", base + function->UnwindData);
134 return;
135 }
136 TRACE("unwind info for function %p-%p chained to function %p-%p\n",
137 (char*)base + function->BeginAddress, (char*)base + function->EndAddress,
138 (char*)base + snext.BeginAddress, (char*)base + snext.EndAddress);
139 function = &snext;
140 continue;
141 }
142 addr = base + function->UnwindData;
143 if (!sw_read_mem(csw, addr, info, FIELD_OFFSET(UNWIND_INFO, UnwindCode)) ||
144 !sw_read_mem(csw, addr + FIELD_OFFSET(UNWIND_INFO, UnwindCode),
145 info->UnwindCode, info->CountOfCodes * sizeof(UNWIND_CODE)))
146 {
147 FIXME("couldn't read memory for UNWIND_INFO at %Ix\n", addr);
148 return;
149 }
150 TRACE("unwind info at %p flags %x prolog 0x%x bytes function %p-%p\n",
151 (char*)addr, info->Flags, info->SizeOfProlog,
152 (char*)base + function->BeginAddress, (char*)base + function->EndAddress);
153
154 if (info->FrameRegister)
155 TRACE(" frame register %s offset 0x%x(%%rsp)\n",
156 reg_names[info->FrameRegister], info->FrameOffset * 16);
157
158 for (i = 0; i < info->CountOfCodes; i++)
159 {
160 TRACE(" 0x%x: ", info->UnwindCode[i].CodeOffset);
161 switch (info->UnwindCode[i].UnwindOp)
162 {
163 case UWOP_PUSH_NONVOL:
164 TRACE("pushq %%%s\n", reg_names[info->UnwindCode[i].OpInfo]);
165 break;
166 case UWOP_ALLOC_LARGE:
167 if (info->UnwindCode[i].OpInfo)
168 {
169 count = *(DWORD*)&info->UnwindCode[i+1];
170 i += 2;
171 }
172 else
173 {
174 count = *(USHORT*)&info->UnwindCode[i+1] * 8;
175 i++;
176 }
177 TRACE("subq $0x%x,%%rsp\n", count);
178 break;
179 case UWOP_ALLOC_SMALL:
180 count = (info->UnwindCode[i].OpInfo + 1) * 8;
181 TRACE("subq $0x%x,%%rsp\n", count);
182 break;
183 case UWOP_SET_FPREG:
184 TRACE("leaq 0x%x(%%rsp),%s\n",
185 info->FrameOffset * 16, reg_names[info->FrameRegister]);
186 break;
187 case UWOP_SAVE_NONVOL:
188 count = *(USHORT*)&info->UnwindCode[i+1] * 8;
189 TRACE("movq %%%s,0x%x(%%rsp)\n", reg_names[info->UnwindCode[i].OpInfo], count);
190 i++;
191 break;
192 case UWOP_SAVE_NONVOL_FAR:
193 count = *(DWORD*)&info->UnwindCode[i+1];
194 TRACE("movq %%%s,0x%x(%%rsp)\n", reg_names[info->UnwindCode[i].OpInfo], count);
195 i += 2;
196 break;
197 case UWOP_SAVE_XMM128:
198 count = *(USHORT*)&info->UnwindCode[i+1] * 16;
199 TRACE("movaps %%xmm%u,0x%x(%%rsp)\n", info->UnwindCode[i].OpInfo, count);
200 i++;
201 break;
202 case UWOP_SAVE_XMM128_FAR:
203 count = *(DWORD*)&info->UnwindCode[i+1];
204 TRACE("movaps %%xmm%u,0x%x(%%rsp)\n", info->UnwindCode[i].OpInfo, count);
205 i += 2;
206 break;
207 case UWOP_PUSH_MACHFRAME:
208 TRACE("PUSH_MACHFRAME %u\n", info->UnwindCode[i].OpInfo);
209 break;
210 case UWOP_EPILOG:
211 if (info->Version == 2)
212 {
213 unsigned int offset;
214 if (info->UnwindCode[i].OpInfo)
215 offset = info->UnwindCode[i].CodeOffset;
216 else
217 offset = (info->UnwindCode[i+1].OpInfo << 8) + info->UnwindCode[i+1].CodeOffset;
218 TRACE("UWOP_EPILOG %u offset %u\n", info->UnwindCode[i].OpInfo, offset);
219 i += 1;
220 break;
221 }
222 /* Fall through */
223 default:
224 FIXME("unknown code %u\n", info->UnwindCode[i].UnwindOp);
225 break;
226 }
227 }
228
229 addr += FIELD_OFFSET(UNWIND_INFO, UnwindCode) +
230 ((info->CountOfCodes + 1) & ~1) * sizeof(UNWIND_CODE);
231 if (info->Flags & UNW_FLAG_CHAININFO)
232 {
233 if (!sw_read_mem(csw, addr, &handler_data, sizeof(handler_data.chain)))
234 {
235 FIXME("couldn't read memory for handler_data.chain\n");
236 return;
237 }
238 TRACE(" chained to function %p-%p\n",
239 (char*)base + handler_data.chain.BeginAddress,
240 (char*)base + handler_data.chain.EndAddress);
241 function = &handler_data.chain;
242 continue;
243 }
244 if (info->Flags & (UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER))
245 {
246 if (!sw_read_mem(csw, addr, &handler_data, sizeof(handler_data.handler)))
247 {
248 FIXME("couldn't read memory for handler_data.handler\n");
249 return;
250 }
251 TRACE(" handler %p data at %p\n",
252 (char*)base + handler_data.handler, (char*)addr + sizeof(handler_data.handler));
253 }
254 break;
255 }
256 }
257
258 /* highly derived from dlls/ntdll/signal_x86_64.c */
259 static ULONG64 get_int_reg(CONTEXT *context, int reg)
260 {
261 return *(&context->Rax + reg);
262 }
263
264 static void set_int_reg(CONTEXT *context, int reg, ULONG64 val)
265 {
266 *(&context->Rax + reg) = val;
267 }
268
269 static void set_float_reg(CONTEXT *context, int reg, M128A val)
270 {
271 *(&context->Xmm0 + reg) = val;
272 }
273
274 static int get_opcode_size(UNWIND_CODE op)
275 {
276 switch (op.UnwindOp)
277 {
278 case UWOP_ALLOC_LARGE:
279 return 2 + (op.OpInfo != 0);
280 case UWOP_SAVE_NONVOL:
281 case UWOP_SAVE_XMM128:
282 return 2;
283 case UWOP_SAVE_NONVOL_FAR:
284 case UWOP_SAVE_XMM128_FAR:
285 return 3;
286 default:
287 return 1;
288 }
289 }
290
291 static BOOL is_inside_epilog(struct cpu_stack_walk* csw, DWORD64 pc,
292 DWORD64 base, const RUNTIME_FUNCTION *function )
293 {
294 BYTE op0, op1, op2;
295 LONG val32;
296
297 if (!sw_read_mem(csw, pc, &op0, 1)) return FALSE;
298
299 /* add or lea must be the first instruction, and it must have a rex.W prefix */
300 if ((op0 & 0xf8) == 0x48)
301 {
302 if (!sw_read_mem(csw, pc + 1, &op1, 1)) return FALSE;
303 switch (op1)
304 {
305 case 0x81: /* add $nnnn,%rsp */
306 if (!sw_read_mem(csw, pc + 2, &op2, 1)) return FALSE;
307 if (op0 == 0x48 && op2 == 0xc4)
308 {
309 pc += 7;
310 break;
311 }
312 return FALSE;
313 case 0x83: /* add $n,%rsp */
314 if (!sw_read_mem(csw, pc + 2, &op2, 1)) return FALSE;
315 if (op0 == 0x48 && op2 == 0xc4)
316 {
317 pc += 4;
318 break;
319 }
320 return FALSE;
321 case 0x8d: /* lea n(reg),%rsp */
322 if (!sw_read_mem(csw, pc + 2, &op2, 1)) return FALSE;
323 if (op0 & 0x06) return FALSE; /* rex.RX must be cleared */
324 if (((op2 >> 3) & 7) != 4) return FALSE; /* dest reg mus be %rsp */
325 if ((op2 & 7) == 4) return FALSE; /* no SIB byte allowed */
326 if ((op2 >> 6) == 1) /* 8-bit offset */
327 {
328 pc += 4;
329 break;
330 }
331 if ((op2 >> 6) == 2) /* 32-bit offset */
332 {
333 pc += 7;
334 break;
335 }
336 return FALSE;
337 }
338 }
339
340 /* now check for various pop instructions */
341 for (;;)
342 {
343 if (!sw_read_mem(csw, pc, &op0, 1)) return FALSE;
344 if ((op0 & 0xf0) == 0x40) /* rex prefix */
345 {
346 if (!sw_read_mem(csw, ++pc, &op0, 1)) return FALSE;
347 }
348
349 switch (op0)
350 {
351 case 0x58: /* pop %rax/%r8 */
352 case 0x59: /* pop %rcx/%r9 */
353 case 0x5a: /* pop %rdx/%r10 */
354 case 0x5b: /* pop %rbx/%r11 */
355 case 0x5c: /* pop %rsp/%r12 */
356 case 0x5d: /* pop %rbp/%r13 */
357 case 0x5e: /* pop %rsi/%r14 */
358 case 0x5f: /* pop %rdi/%r15 */
359 pc++;
360 continue;
361 case 0xc2: /* ret $nn */
362 case 0xc3: /* ret */
363 return TRUE;
364 case 0xe9: /* jmp nnnn */
365 if (!sw_read_mem(csw, pc + 1, &val32, sizeof(LONG))) return FALSE;
366 pc += 5 + val32;
367 if (pc - base >= function->BeginAddress && pc - base < function->EndAddress)
368 continue;
369 break;
370 case 0xeb: /* jmp n */
371 if (!sw_read_mem(csw, pc + 1, &op1, 1)) return FALSE;
372 pc += 2 + (signed char)op1;
373 if (pc - base >= function->BeginAddress && pc - base < function->EndAddress)
374 continue;
375 break;
376 case 0xf3: /* rep; ret (for amd64 prediction bug) */
377 if (!sw_read_mem(csw, pc + 1, &op1, 1)) return FALSE;
378 return op1 == 0xc3;
379 }
380 return FALSE;
381 }
382 }
383
384 static BOOL interpret_epilog(struct cpu_stack_walk* csw, ULONG64 pc, CONTEXT *context )
385 {
386 BYTE insn, val8;
387 WORD val16;
388 LONG val32;
389 DWORD64 val64;
390
391 for (;;)
392 {
393 BYTE rex = 0;
394
395 if (!sw_read_mem(csw, pc, &insn, 1)) return FALSE;
396 if ((insn & 0xf0) == 0x40)
397 {
398 rex = insn & 0x0f; /* rex prefix */
399 if (!sw_read_mem(csw, ++pc, &insn, 1)) return FALSE;
400 }
401
402 switch (insn)
403 {
404 case 0x58: /* pop %rax/r8 */
405 case 0x59: /* pop %rcx/r9 */
406 case 0x5a: /* pop %rdx/r10 */
407 case 0x5b: /* pop %rbx/r11 */
408 case 0x5c: /* pop %rsp/r12 */
409 case 0x5d: /* pop %rbp/r13 */
410 case 0x5e: /* pop %rsi/r14 */
411 case 0x5f: /* pop %rdi/r15 */
412 if (!sw_read_mem(csw, context->Rsp, &val64, sizeof(DWORD64))) return FALSE;
413 set_int_reg(context, insn - 0x58 + (rex & 1) * 8, val64);
414 context->Rsp += sizeof(ULONG64);
415 pc++;
416 continue;
417 case 0x81: /* add $nnnn,%rsp */
418 if (!sw_read_mem(csw, pc + 2, &val32, sizeof(LONG))) return FALSE;
419 context->Rsp += val32;
420 pc += 2 + sizeof(LONG);
421 continue;
422 case 0x83: /* add $n,%rsp */
423 if (!sw_read_mem(csw, pc + 2, &val8, sizeof(BYTE))) return FALSE;
424 context->Rsp += (signed char)val8;
425 pc += 3;
426 continue;
427 case 0x8d:
428 if (!sw_read_mem(csw, pc + 1, &insn, sizeof(BYTE))) return FALSE;
429 if ((insn >> 6) == 1) /* lea n(reg),%rsp */
430 {
431 if (!sw_read_mem(csw, pc + 2, &val8, sizeof(BYTE))) return FALSE;
432 context->Rsp = get_int_reg( context, (insn & 7) + (rex & 1) * 8 ) + (signed char)val8;
433 pc += 3;
434 }
435 else /* lea nnnn(reg),%rsp */
436 {
437 if (!sw_read_mem(csw, pc + 2, &val32, sizeof(LONG))) return FALSE;
438 context->Rsp = get_int_reg( context, (insn & 7) + (rex & 1) * 8 ) + val32;
439 pc += 2 + sizeof(LONG);
440 }
441 continue;
442 case 0xc2: /* ret $nn */
443 if (!sw_read_mem(csw, context->Rsp, &val64, sizeof(DWORD64))) return FALSE;
444 if (!sw_read_mem(csw, pc + 1, &val16, sizeof(WORD))) return FALSE;
445 context->Rip = val64;
446 context->Rsp += sizeof(ULONG64) + val16;
447 return TRUE;
448 case 0xc3: /* ret */
449 case 0xf3: /* rep; ret */
450 if (!sw_read_mem(csw, context->Rsp, &val64, sizeof(DWORD64))) return FALSE;
451 context->Rip = val64;
452 context->Rsp += sizeof(ULONG64);
453 return TRUE;
454 case 0xe9: /* jmp nnnn */
455 if (!sw_read_mem(csw, pc + 1, &val32, sizeof(LONG))) return FALSE;
456 pc += 5 + val32;
457 continue;
458 case 0xeb: /* jmp n */
459 if (!sw_read_mem(csw, pc + 1, &val8, sizeof(BYTE))) return FALSE;
460 pc += 2 + (signed char)val8;
461 continue;
462 }
463 FIXME("unsupported insn %x\n", insn);
464 return FALSE;
465 }
466 }
467
468 static BOOL default_unwind(struct cpu_stack_walk* csw, CONTEXT* context)
469 {
470 if (!sw_read_mem(csw, context->Rsp, &context->Rip, sizeof(DWORD64)))
471 {
472 WARN("Cannot read new frame offset %I64x\n", context->Rsp);
473 return FALSE;
474 }
475 context->Rsp += sizeof(DWORD64);
476 return TRUE;
477 }
478
479 static BOOL interpret_function_table_entry(struct cpu_stack_walk* csw,
480 CONTEXT* context, RUNTIME_FUNCTION* function, DWORD64 base)
481 {
482 char buffer[sizeof(UNWIND_INFO) + 256 * sizeof(UNWIND_CODE)];
483 UNWIND_INFO* info = (UNWIND_INFO*)buffer;
484 unsigned i;
485 DWORD64 newframe, prolog_offset, off, value;
486 M128A floatvalue;
487 union handler_data handler_data;
488 BOOL mach_frame = FALSE;
489
490 /* FIXME: we have some assumptions here */
491 assert(context);
492 dump_unwind_info(csw, sw_module_base(csw, context->Rip), function);
493 newframe = context->Rsp;
494 for (;;)
495 {
496 if (!sw_read_mem(csw, base + function->UnwindData, info, sizeof(*info)) ||
497 !sw_read_mem(csw, base + function->UnwindData + FIELD_OFFSET(UNWIND_INFO, UnwindCode),
498 info->UnwindCode, info->CountOfCodes * sizeof(UNWIND_CODE)))
499 {
500 WARN("Couldn't read unwind_code at %Ix\n", base + function->UnwindData);
501 return FALSE;
502 }
503
504 if (info->Version != 1 && info->Version != 2)
505 {
506 WARN("unknown unwind info version %u at %Ix\n", info->Version, base + function->UnwindData);
507 return FALSE;
508 }
509
510 if (info->FrameRegister)
511 newframe = get_int_reg(context, info->FrameRegister) - info->FrameOffset * 16;
512
513 /* check if in prolog */
514 if (context->Rip >= base + function->BeginAddress &&
515 context->Rip < base + function->BeginAddress + info->SizeOfProlog)
516 {
517 prolog_offset = context->Rip - base - function->BeginAddress;
518 }
519 else
520 {
521 prolog_offset = ~0;
522 if (is_inside_epilog(csw, context->Rip, base, function))
523 {
524 interpret_epilog(csw, context->Rip, context);
525 return TRUE;
526 }
527 }
528
529 for (i = 0; i < info->CountOfCodes; i += get_opcode_size(info->UnwindCode[i]))
530 {
531 if (prolog_offset < info->UnwindCode[i].CodeOffset) continue; /* skip it */
532
533 switch (info->UnwindCode[i].UnwindOp)
534 {
535 case UWOP_PUSH_NONVOL: /* pushq %reg */
536 if (!sw_read_mem(csw, context->Rsp, &value, sizeof(DWORD64))) return FALSE;
537 set_int_reg(context, info->UnwindCode[i].OpInfo, value);
538 context->Rsp += sizeof(ULONG64);
539 break;
540 case UWOP_ALLOC_LARGE: /* subq $nn,%rsp */
541 if (info->UnwindCode[i].OpInfo) context->Rsp += *(DWORD*)&info->UnwindCode[i+1];
542 else context->Rsp += *(USHORT*)&info->UnwindCode[i+1] * 8;
543 break;
544 case UWOP_ALLOC_SMALL: /* subq $n,%rsp */
545 context->Rsp += (info->UnwindCode[i].OpInfo + 1) * 8;
546 break;
547 case UWOP_SET_FPREG: /* leaq nn(%rsp),%framereg */
548 context->Rsp = newframe;
549 break;
550 case UWOP_SAVE_NONVOL: /* movq %reg,n(%rsp) */
551 off = newframe + *(USHORT*)&info->UnwindCode[i+1] * 8;
552 if (!sw_read_mem(csw, off, &value, sizeof(DWORD64))) return FALSE;
553 set_int_reg(context, info->UnwindCode[i].OpInfo, value);
554 break;
555 case UWOP_SAVE_NONVOL_FAR: /* movq %reg,nn(%rsp) */
556 off = newframe + *(DWORD*)&info->UnwindCode[i+1];
557 if (!sw_read_mem(csw, off, &value, sizeof(DWORD64))) return FALSE;
558 set_int_reg(context, info->UnwindCode[i].OpInfo, value);
559 break;
560 case UWOP_SAVE_XMM128: /* movaps %xmmreg,n(%rsp) */
561 off = newframe + *(USHORT*)&info->UnwindCode[i+1] * 16;
562 if (!sw_read_mem(csw, off, &floatvalue, sizeof(M128A))) return FALSE;
563 set_float_reg(context, info->UnwindCode[i].OpInfo, floatvalue);
564 break;
565 case UWOP_SAVE_XMM128_FAR: /* movaps %xmmreg,nn(%rsp) */
566 off = newframe + *(DWORD*)&info->UnwindCode[i+1];
567 if (!sw_read_mem(csw, off, &floatvalue, sizeof(M128A))) return FALSE;
568 set_float_reg(context, info->UnwindCode[i].OpInfo, floatvalue);
569 break;
570 case UWOP_PUSH_MACHFRAME:
571 if (info->Flags & UNW_FLAG_CHAININFO)
572 {
573 FIXME("PUSH_MACHFRAME with chained unwind info.\n");
574 break;
575 }
576 if (i + get_opcode_size(info->UnwindCode[i]) < info->CountOfCodes)
577 {
578 FIXME("PUSH_MACHFRAME is not the last opcode.\n");
579 break;
580 }
581
582 if (info->UnwindCode[i].OpInfo)
583 context->Rsp += 0x8;
584
585 if (!sw_read_mem(csw, context->Rsp, &context->Rip, sizeof(DWORD64))) return FALSE;
586 if (!sw_read_mem(csw, context->Rsp + 24, &context->Rsp, sizeof(DWORD64))) return FALSE;
587 mach_frame = TRUE;
588 break;
589 default:
590 FIXME("unknown code %u\n", info->UnwindCode[i].UnwindOp);
591 break;
592 }
593 }
594 if (!(info->Flags & UNW_FLAG_CHAININFO)) break;
595 if (!sw_read_mem(csw, base + function->UnwindData + FIELD_OFFSET(UNWIND_INFO, UnwindCode) +
596 ((info->CountOfCodes + 1) & ~1) * sizeof(UNWIND_CODE),
597 &handler_data, sizeof(handler_data))) return FALSE;
598 function = &handler_data.chain; /* restart with the chained info */
599 }
600 return mach_frame ? TRUE : default_unwind(csw, context);
601 }
602
603 /* fetch_next_frame()
604 *
605 * modify (at least) context.{rip, rsp, rbp} using unwind information
606 * either out of PE exception handlers, debug info (dwarf), or simple stack unwind
607 */
608 static BOOL fetch_next_frame(struct cpu_stack_walk *csw, union ctx *pcontext,
609 DWORD_PTR curr_pc, void** prtf)
610 {
611 DWORD64 cfa;
612 RUNTIME_FUNCTION* rtf;
613 DWORD64 base;
614 CONTEXT *context = &pcontext->ctx;
615
616 if (!curr_pc || !(base = sw_module_base(csw, curr_pc))) return FALSE;
617 rtf = sw_table_access(csw, curr_pc);
618 if (prtf) *prtf = rtf;
619 if (rtf)
620 {
621 return interpret_function_table_entry(csw, context, rtf, base);
622 }
623 else if (dwarf2_virtual_unwind(csw, curr_pc, pcontext, &cfa))
624 {
625 context->Rsp = cfa;
626 TRACE("next function rip=%016Ix\n", context->Rip);
627 TRACE(" rax=%016Ix rbx=%016Ix rcx=%016Ix rdx=%016Ix\n",
628 context->Rax, context->Rbx, context->Rcx, context->Rdx);
629 TRACE(" rsi=%016Ix rdi=%016Ix rbp=%016Ix rsp=%016Ix\n",
630 context->Rsi, context->Rdi, context->Rbp, context->Rsp);
631 TRACE(" r8=%016Ix r9=%016Ix r10=%016Ix r11=%016Ix\n",
632 context->R8, context->R9, context->R10, context->R11);
633 TRACE(" r12=%016Ix r13=%016Ix r14=%016Ix r15=%016Ix\n",
634 context->R12, context->R13, context->R14, context->R15);
635 return TRUE;
636 }
637 else
638 return default_unwind(csw, context);
639 }
640
641 static BOOL x86_64_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame,
642 union ctx *context)
643 {
644 unsigned deltapc = curr_count <= 1 ? 0 : 1;
645
646 /* sanity check */
647 if (curr_mode >= stm_done) return FALSE;
648 assert(!csw->is32);
649
650 TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%I64u\n",
651 wine_dbgstr_addr(&frame->AddrPC),
652 wine_dbgstr_addr(&frame->AddrFrame),
653 wine_dbgstr_addr(&frame->AddrReturn),
654 wine_dbgstr_addr(&frame->AddrStack),
655 curr_mode == stm_start ? "start" : "64bit",
656 curr_count);
657
658 if (curr_mode == stm_start)
659 {
660 if ((frame->AddrPC.Mode == AddrModeFlat) &&
661 (frame->AddrFrame.Mode != AddrModeFlat))
662 {
663 WARN("Bad AddrPC.Mode / AddrFrame.Mode combination\n");
664 goto done_err;
665 }
666
667 /* Init done */
668 curr_mode = stm_64bit;
669 frame->AddrReturn.Mode = frame->AddrStack.Mode = AddrModeFlat;
670 /* don't set up AddrStack on first call. Either the caller has set it up, or
671 * we will get it in the next frame
672 */
673 memset(&frame->AddrBStore, 0, sizeof(frame->AddrBStore));
674 }
675 else
676 {
677 if (context->ctx.Rsp != frame->AddrStack.Offset) FIXME("inconsistent Stack Pointer\n");
678 if (context->ctx.Rip != frame->AddrPC.Offset) FIXME("inconsistent Instruction Pointer\n");
679
680 if (frame->AddrReturn.Offset == 0) goto done_err;
681 if (!fetch_next_frame(csw, context, frame->AddrPC.Offset - deltapc, &frame->FuncTableEntry))
682 goto done_err;
683 deltapc = 1;
684 }
685
686 memset(&frame->Params, 0, sizeof(frame->Params));
687
688 /* set frame information */
689 frame->AddrStack.Offset = context->ctx.Rsp;
690 frame->AddrFrame.Offset = context->ctx.Rbp;
691 frame->AddrPC.Offset = context->ctx.Rip;
692 if (1)
693 {
694 union ctx newctx = *context;
695
696 if (!fetch_next_frame(csw, &newctx, frame->AddrPC.Offset - deltapc, NULL))
697 goto done_err;
698 frame->AddrReturn.Mode = AddrModeFlat;
699 frame->AddrReturn.Offset = newctx.ctx.Rip;
700 }
701
702 frame->Far = TRUE;
703 frame->Virtual = TRUE;
704 curr_count++;
705
706 TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%I64u FuncTable=%p\n",
707 wine_dbgstr_addr(&frame->AddrPC),
708 wine_dbgstr_addr(&frame->AddrFrame),
709 wine_dbgstr_addr(&frame->AddrReturn),
710 wine_dbgstr_addr(&frame->AddrStack),
711 curr_mode == stm_start ? "start" : "64bit",
712 curr_count,
713 frame->FuncTableEntry);
714
715 return TRUE;
716 done_err:
717 curr_mode = stm_done;
718 return FALSE;
719 }
720 #else
721 static BOOL x86_64_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame,
722 union ctx *ctx)
723 {
724 return FALSE;
725 }
726 #endif
727
728 static void* x86_64_find_runtime_function(struct module* module, DWORD64 addr)
729 {
730 #ifdef __x86_64__
731 RUNTIME_FUNCTION* rtf;
732 ULONG size;
733 int min, max;
734
735 rtf = (RUNTIME_FUNCTION*)pe_map_directory(module, IMAGE_DIRECTORY_ENTRY_EXCEPTION, &size);
736 if (rtf) for (min = 0, max = size / sizeof(*rtf); min <= max; )
737 {
738 int pos = (min + max) / 2;
739 if (addr < module->module.BaseOfImage + rtf[pos].BeginAddress) max = pos - 1;
740 else if (addr >= module->module.BaseOfImage + rtf[pos].EndAddress) min = pos + 1;
741 else
742 {
743 rtf += pos;
744 while (rtf->UnwindData & 1) /* follow chained entry */
745 {
746 FIXME("RunTime_Function outside IMAGE_DIRECTORY_ENTRY_EXCEPTION unimplemented yet!\n");
747 return NULL;
748 /* we need to read into the other process */
749 /* rtf = (RUNTIME_FUNCTION*)(module->module.BaseOfImage + (rtf->UnwindData & ~1)); */
750 }
751 return rtf;
752 }
753 }
754 #endif
755 return NULL;
756 }
757
758 static unsigned x86_64_map_dwarf_register(unsigned regno, const struct module* module, BOOL eh_frame)
759 {
760 unsigned reg;
761
762 if (regno >= 17 && regno <= 24)
763 reg = CV_AMD64_XMM0 + regno - 17;
764 else if (regno >= 25 && regno <= 32)
765 reg = CV_AMD64_XMM8 + regno - 25;
766 else if (regno >= 33 && regno <= 40)
767 reg = CV_AMD64_ST0 + regno - 33;
768 else switch (regno)
769 {
770 case 0: reg = CV_AMD64_RAX; break;
771 case 1: reg = CV_AMD64_RDX; break;
772 case 2: reg = CV_AMD64_RCX; break;
773 case 3: reg = CV_AMD64_RBX; break;
774 case 4: reg = CV_AMD64_RSI; break;
775 case 5: reg = CV_AMD64_RDI; break;
776 case 6: reg = CV_AMD64_RBP; break;
777 case 7: reg = CV_AMD64_RSP; break;
778 case 8: reg = CV_AMD64_R8; break;
779 case 9: reg = CV_AMD64_R9; break;
780 case 10: reg = CV_AMD64_R10; break;
781 case 11: reg = CV_AMD64_R11; break;
782 case 12: reg = CV_AMD64_R12; break;
783 case 13: reg = CV_AMD64_R13; break;
784 case 14: reg = CV_AMD64_R14; break;
785 case 15: reg = CV_AMD64_R15; break;
786 case 16: reg = CV_AMD64_RIP; break;
787 case 49: reg = CV_AMD64_EFLAGS; break;
788 case 50: reg = CV_AMD64_ES; break;
789 case 51: reg = CV_AMD64_CS; break;
790 case 52: reg = CV_AMD64_SS; break;
791 case 53: reg = CV_AMD64_DS; break;
792 case 54: reg = CV_AMD64_FS; break;
793 case 55: reg = CV_AMD64_GS; break;
794 case 62: reg = CV_AMD64_TR; break;
795 case 63: reg = CV_AMD64_LDTR; break;
796 case 64: reg = CV_AMD64_MXCSR; break;
797 case 65: reg = CV_AMD64_CTRL; break;
798 case 66: reg = CV_AMD64_STAT; break;
799 /*
800 * 56-57 reserved
801 * 58 %fs.base
802 * 59 %gs.base
803 * 60-61 reserved
804 */
805 default:
806 FIXME("Don't know how to map register %d\n", regno);
807 return 0;
808 }
809 return reg;
810 }
811
812 static void *x86_64_fetch_context_reg(union ctx *pctx, unsigned regno, unsigned *size)
813 {
814 #ifdef __x86_64__
815 CONTEXT *ctx = &pctx->ctx;
816
817 switch (regno)
818 {
819 case CV_AMD64_RAX: *size = sizeof(ctx->Rax); return &ctx->Rax;
820 case CV_AMD64_RDX: *size = sizeof(ctx->Rdx); return &ctx->Rdx;
821 case CV_AMD64_RCX: *size = sizeof(ctx->Rcx); return &ctx->Rcx;
822 case CV_AMD64_RBX: *size = sizeof(ctx->Rbx); return &ctx->Rbx;
823 case CV_AMD64_RSI: *size = sizeof(ctx->Rsi); return &ctx->Rsi;
824 case CV_AMD64_RDI: *size = sizeof(ctx->Rdi); return &ctx->Rdi;
825 case CV_AMD64_RBP: *size = sizeof(ctx->Rbp); return &ctx->Rbp;
826 case CV_AMD64_RSP: *size = sizeof(ctx->Rsp); return &ctx->Rsp;
827 case CV_AMD64_R8: *size = sizeof(ctx->R8); return &ctx->R8;
828 case CV_AMD64_R9: *size = sizeof(ctx->R9); return &ctx->R9;
829 case CV_AMD64_R10: *size = sizeof(ctx->R10); return &ctx->R10;
830 case CV_AMD64_R11: *size = sizeof(ctx->R11); return &ctx->R11;
831 case CV_AMD64_R12: *size = sizeof(ctx->R12); return &ctx->R12;
832 case CV_AMD64_R13: *size = sizeof(ctx->R13); return &ctx->R13;
833 case CV_AMD64_R14: *size = sizeof(ctx->R14); return &ctx->R14;
834 case CV_AMD64_R15: *size = sizeof(ctx->R15); return &ctx->R15;
835 case CV_AMD64_RIP: *size = sizeof(ctx->Rip); return &ctx->Rip;
836
837 case CV_AMD64_XMM0 + 0: *size = sizeof(ctx->Xmm0 ); return &ctx->Xmm0;
838 case CV_AMD64_XMM0 + 1: *size = sizeof(ctx->Xmm1 ); return &ctx->Xmm1;
839 case CV_AMD64_XMM0 + 2: *size = sizeof(ctx->Xmm2 ); return &ctx->Xmm2;
840 case CV_AMD64_XMM0 + 3: *size = sizeof(ctx->Xmm3 ); return &ctx->Xmm3;
841 case CV_AMD64_XMM0 + 4: *size = sizeof(ctx->Xmm4 ); return &ctx->Xmm4;
842 case CV_AMD64_XMM0 + 5: *size = sizeof(ctx->Xmm5 ); return &ctx->Xmm5;
843 case CV_AMD64_XMM0 + 6: *size = sizeof(ctx->Xmm6 ); return &ctx->Xmm6;
844 case CV_AMD64_XMM0 + 7: *size = sizeof(ctx->Xmm7 ); return &ctx->Xmm7;
845 case CV_AMD64_XMM8 + 0: *size = sizeof(ctx->Xmm8 ); return &ctx->Xmm8;
846 case CV_AMD64_XMM8 + 1: *size = sizeof(ctx->Xmm9 ); return &ctx->Xmm9;
847 case CV_AMD64_XMM8 + 2: *size = sizeof(ctx->Xmm10); return &ctx->Xmm10;
848 case CV_AMD64_XMM8 + 3: *size = sizeof(ctx->Xmm11); return &ctx->Xmm11;
849 case CV_AMD64_XMM8 + 4: *size = sizeof(ctx->Xmm12); return &ctx->Xmm12;
850 case CV_AMD64_XMM8 + 5: *size = sizeof(ctx->Xmm13); return &ctx->Xmm13;
851 case CV_AMD64_XMM8 + 6: *size = sizeof(ctx->Xmm14); return &ctx->Xmm14;
852 case CV_AMD64_XMM8 + 7: *size = sizeof(ctx->Xmm15); return &ctx->Xmm15;
853
854 case CV_AMD64_ST0 + 0: *size = sizeof(ctx->Legacy[0]); return &ctx->Legacy[0];
855 case CV_AMD64_ST0 + 1: *size = sizeof(ctx->Legacy[1]); return &ctx->Legacy[1];
856 case CV_AMD64_ST0 + 2: *size = sizeof(ctx->Legacy[2]); return &ctx->Legacy[2];
857 case CV_AMD64_ST0 + 3: *size = sizeof(ctx->Legacy[3]); return &ctx->Legacy[3];
858 case CV_AMD64_ST0 + 4: *size = sizeof(ctx->Legacy[4]); return &ctx->Legacy[4];
859 case CV_AMD64_ST0 + 5: *size = sizeof(ctx->Legacy[5]); return &ctx->Legacy[5];
860 case CV_AMD64_ST0 + 6: *size = sizeof(ctx->Legacy[6]); return &ctx->Legacy[6];
861 case CV_AMD64_ST0 + 7: *size = sizeof(ctx->Legacy[7]); return &ctx->Legacy[7];
862
863 case CV_AMD64_EFLAGS: *size = sizeof(ctx->EFlags); return &ctx->EFlags;
864 case CV_AMD64_ES: *size = sizeof(ctx->SegEs); return &ctx->SegEs;
865 case CV_AMD64_CS: *size = sizeof(ctx->SegCs); return &ctx->SegCs;
866 case CV_AMD64_SS: *size = sizeof(ctx->SegSs); return &ctx->SegSs;
867 case CV_AMD64_DS: *size = sizeof(ctx->SegDs); return &ctx->SegDs;
868 case CV_AMD64_FS: *size = sizeof(ctx->SegFs); return &ctx->SegFs;
869 case CV_AMD64_GS: *size = sizeof(ctx->SegGs); return &ctx->SegGs;
870
871 }
872 #endif
873 FIXME("Unknown register %x\n", regno);
874 return NULL;
875 }
876
877 static const char* x86_64_fetch_regname(unsigned regno)
878 {
879 switch (regno)
880 {
881 case CV_AMD64_RAX: return "rax";
882 case CV_AMD64_RDX: return "rdx";
883 case CV_AMD64_RCX: return "rcx";
884 case CV_AMD64_RBX: return "rbx";
885 case CV_AMD64_RSI: return "rsi";
886 case CV_AMD64_RDI: return "rdi";
887 case CV_AMD64_RBP: return "rbp";
888 case CV_AMD64_RSP: return "rsp";
889 case CV_AMD64_R8: return "r8";
890 case CV_AMD64_R9: return "r9";
891 case CV_AMD64_R10: return "r10";
892 case CV_AMD64_R11: return "r11";
893 case CV_AMD64_R12: return "r12";
894 case CV_AMD64_R13: return "r13";
895 case CV_AMD64_R14: return "r14";
896 case CV_AMD64_R15: return "r15";
897 case CV_AMD64_RIP: return "rip";
898
899 case CV_AMD64_XMM0 + 0: return "xmm0";
900 case CV_AMD64_XMM0 + 1: return "xmm1";
901 case CV_AMD64_XMM0 + 2: return "xmm2";
902 case CV_AMD64_XMM0 + 3: return "xmm3";
903 case CV_AMD64_XMM0 + 4: return "xmm4";
904 case CV_AMD64_XMM0 + 5: return "xmm5";
905 case CV_AMD64_XMM0 + 6: return "xmm6";
906 case CV_AMD64_XMM0 + 7: return "xmm7";
907 case CV_AMD64_XMM8 + 0: return "xmm8";
908 case CV_AMD64_XMM8 + 1: return "xmm9";
909 case CV_AMD64_XMM8 + 2: return "xmm10";
910 case CV_AMD64_XMM8 + 3: return "xmm11";
911 case CV_AMD64_XMM8 + 4: return "xmm12";
912 case CV_AMD64_XMM8 + 5: return "xmm13";
913 case CV_AMD64_XMM8 + 6: return "xmm14";
914 case CV_AMD64_XMM8 + 7: return "xmm15";
915
916 case CV_AMD64_ST0 + 0: return "st0";
917 case CV_AMD64_ST0 + 1: return "st1";
918 case CV_AMD64_ST0 + 2: return "st2";
919 case CV_AMD64_ST0 + 3: return "st3";
920 case CV_AMD64_ST0 + 4: return "st4";
921 case CV_AMD64_ST0 + 5: return "st5";
922 case CV_AMD64_ST0 + 6: return "st6";
923 case CV_AMD64_ST0 + 7: return "st7";
924
925 case CV_AMD64_EFLAGS: return "eflags";
926 case CV_AMD64_ES: return "es";
927 case CV_AMD64_CS: return "cs";
928 case CV_AMD64_SS: return "ss";
929 case CV_AMD64_DS: return "ds";
930 case CV_AMD64_FS: return "fs";
931 case CV_AMD64_GS: return "gs";
932 }
933 FIXME("Unknown register %x\n", regno);
934 return NULL;
935 }
936
937 static BOOL x86_64_fetch_minidump_thread(struct dump_context* dc, unsigned index, unsigned flags, const CONTEXT* ctx)
938 {
939 if (ctx->ContextFlags && (flags & ThreadWriteInstructionWindow))
940 {
941 /* FIXME: crop values across module boundaries, */
942 #ifdef __x86_64__
943 ULONG64 base = ctx->Rip <= 0x80 ? 0 : ctx->Rip - 0x80;
944 minidump_add_memory_block(dc, base, ctx->Rip + 0x80 - base, 0);
945 #endif
946 }
947
948 return TRUE;
949 }
950
951 static BOOL x86_64_fetch_minidump_module(struct dump_context* dc, unsigned index, unsigned flags)
952 {
953 /* FIXME: not sure about the flags... */
954 if (1)
955 {
956 /* FIXME: crop values across module boundaries, */
957 #ifdef __x86_64__
958 struct process* pcs;
959 struct module* module;
960 const RUNTIME_FUNCTION* rtf;
961 ULONG size;
962
963 if (!(pcs = process_find_by_handle(dc->process->handle)) ||
964 !(module = module_find_by_addr(pcs, dc->modules[index].base, DMT_UNKNOWN)))
965 return FALSE;
966 rtf = (const RUNTIME_FUNCTION*)pe_map_directory(module, IMAGE_DIRECTORY_ENTRY_EXCEPTION, &size);
967 if (rtf)
968 {
969 const RUNTIME_FUNCTION* end = (const RUNTIME_FUNCTION*)((const char*)rtf + size);
970 UNWIND_INFO ui;
971
972 while (rtf + 1 < end)
973 {
974 while (rtf->UnwindData & 1) /* follow chained entry */
975 {
976 FIXME("RunTime_Function outside IMAGE_DIRECTORY_ENTRY_EXCEPTION unimplemented yet!\n");
977 return FALSE;
978 /* we need to read into the other process */
979 /* rtf = (RUNTIME_FUNCTION*)(module->module.BaseOfImage + (rtf->UnwindData & ~1)); */
980 }
981 if (read_process_memory(dc->process, dc->modules[index].base + rtf->UnwindData, &ui, sizeof(ui)))
982 minidump_add_memory_block(dc, dc->modules[index].base + rtf->UnwindData,
983 FIELD_OFFSET(UNWIND_INFO, UnwindCode) + ui.CountOfCodes * sizeof(UNWIND_CODE), 0);
984 rtf++;
985 }
986 }
987 #endif
988 }
989
990 return TRUE;
991 }
992
993 DECLSPEC_HIDDEN struct cpu cpu_x86_64 = {
994 IMAGE_FILE_MACHINE_AMD64,
995 8,
996 CV_AMD64_RSP,
997 x86_64_get_addr,
998 x86_64_stack_walk,
999 x86_64_find_runtime_function,
1000 x86_64_map_dwarf_register,
1001 x86_64_fetch_context_reg,
1002 x86_64_fetch_regname,
1003 x86_64_fetch_minidump_thread,
1004 x86_64_fetch_minidump_module,
1005 };
Windows API implementation