git.oblomov.eu Git - wine/blob - dlls/dbghelp/cpu_x86_64.c

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