ReactOS  0.4.15-dev-1377-ga59cecd
cpu_x86_64.c File Reference
#include <assert.h>
#include "ntstatus.h"
#include "dbghelp_private.h"
#include "winternl.h"
#include "wine/debug.h"
Include dependency graph for cpu_x86_64.c:

Go to the source code of this file.

Classes

union  _UNWIND_CODE
 
struct  _UNWIND_INFO
 

Macros

#define NONAMELESSUNION
 
#define NONAMELESSSTRUCT
 
#define WIN32_NO_STATUS
 

Typedefs

typedef enum _UNWIND_OP_CODES UNWIND_CODE_OPS
 
typedef union _UNWIND_CODE UNWIND_CODE
 
typedef union _UNWIND_CODEPUNWIND_CODE
 
typedef struct _UNWIND_INFO UNWIND_INFO
 
typedef struct _UNWIND_INFOPUNWIND_INFO
 

Enumerations

enum  _UNWIND_OP_CODES {
  UWOP_PUSH_NONVOL = 0, UWOP_ALLOC_LARGE, UWOP_ALLOC_SMALL, UWOP_SET_FPREG,
  UWOP_SAVE_NONVOL, UWOP_SAVE_NONVOL_FAR, UWOP_SAVE_XMM128, UWOP_SAVE_XMM128_FAR,
  UWOP_PUSH_MACHFRAME
}
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (dbghelp)
 
static BOOL x86_64_get_addr (HANDLE hThread, const CONTEXT *ctx, enum cpu_addr ca, ADDRESS64 *addr)
 
static BOOL x86_64_stack_walk (struct cpu_stack_walk *csw, STACKFRAME64 *frame, union ctx *ctx)
 
static voidx86_64_find_runtime_function (struct module *module, DWORD64 addr)
 
static unsigned x86_64_map_dwarf_register (unsigned regno, const struct module *module, BOOL eh_frame)
 
static voidx86_64_fetch_context_reg (union ctx *pctx, unsigned regno, unsigned *size)
 
static const charx86_64_fetch_regname (unsigned regno)
 
static BOOL x86_64_fetch_minidump_thread (struct dump_context *dc, unsigned index, unsigned flags, const CONTEXT *ctx)
 
static BOOL x86_64_fetch_minidump_module (struct dump_context *dc, unsigned index, unsigned flags)
 

Variables

DECLSPEC_HIDDEN struct cpu cpu_x86_64
 

Macro Definition Documentation

◆ NONAMELESSSTRUCT

#define NONAMELESSSTRUCT

Definition at line 25 of file cpu_x86_64.c.

◆ NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 24 of file cpu_x86_64.c.

◆ WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 27 of file cpu_x86_64.c.

Typedef Documentation

◆ PUNWIND_CODE

typedef union _UNWIND_CODE * PUNWIND_CODE

◆ PUNWIND_INFO

◆ UNWIND_CODE

typedef union _UNWIND_CODE UNWIND_CODE

◆ UNWIND_CODE_OPS

◆ UNWIND_INFO

Enumeration Type Documentation

◆ _UNWIND_OP_CODES

Enumerator
UWOP_PUSH_NONVOL 
UWOP_ALLOC_LARGE 
UWOP_ALLOC_SMALL 
UWOP_SET_FPREG 
UWOP_SAVE_NONVOL 
UWOP_SAVE_NONVOL_FAR 
UWOP_SAVE_XMM128 
UWOP_SAVE_XMM128_FAR 
UWOP_PUSH_MACHFRAME 

Definition at line 36 of file cpu_x86_64.c.

Function Documentation

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( dbghelp  )

◆ x86_64_fetch_context_reg()

static void* x86_64_fetch_context_reg ( union ctx pctx,
unsigned  regno,
unsigned size 
)
static

Definition at line 781 of file cpu_x86_64.c.

782 {
783 #ifdef __x86_64__
784  CONTEXT *ctx = &pctx->ctx;
785 
786  switch (regno)
787  {
788  case CV_AMD64_RAX: *size = sizeof(ctx->Rax); return &ctx->Rax;
789  case CV_AMD64_RDX: *size = sizeof(ctx->Rdx); return &ctx->Rdx;
790  case CV_AMD64_RCX: *size = sizeof(ctx->Rcx); return &ctx->Rcx;
791  case CV_AMD64_RBX: *size = sizeof(ctx->Rbx); return &ctx->Rbx;
792  case CV_AMD64_RSI: *size = sizeof(ctx->Rsi); return &ctx->Rsi;
793  case CV_AMD64_RDI: *size = sizeof(ctx->Rdi); return &ctx->Rdi;
794  case CV_AMD64_RBP: *size = sizeof(ctx->Rbp); return &ctx->Rbp;
795  case CV_AMD64_RSP: *size = sizeof(ctx->Rsp); return &ctx->Rsp;
796  case CV_AMD64_R8: *size = sizeof(ctx->R8); return &ctx->R8;
797  case CV_AMD64_R9: *size = sizeof(ctx->R9); return &ctx->R9;
798  case CV_AMD64_R10: *size = sizeof(ctx->R10); return &ctx->R10;
799  case CV_AMD64_R11: *size = sizeof(ctx->R11); return &ctx->R11;
800  case CV_AMD64_R12: *size = sizeof(ctx->R12); return &ctx->R12;
801  case CV_AMD64_R13: *size = sizeof(ctx->R13); return &ctx->R13;
802  case CV_AMD64_R14: *size = sizeof(ctx->R14); return &ctx->R14;
803  case CV_AMD64_R15: *size = sizeof(ctx->R15); return &ctx->R15;
804  case CV_AMD64_RIP: *size = sizeof(ctx->Rip); return &ctx->Rip;
805 
806  case CV_AMD64_XMM0 + 0: *size = sizeof(ctx->u.s.Xmm0 ); return &ctx->u.s.Xmm0;
807  case CV_AMD64_XMM0 + 1: *size = sizeof(ctx->u.s.Xmm1 ); return &ctx->u.s.Xmm1;
808  case CV_AMD64_XMM0 + 2: *size = sizeof(ctx->u.s.Xmm2 ); return &ctx->u.s.Xmm2;
809  case CV_AMD64_XMM0 + 3: *size = sizeof(ctx->u.s.Xmm3 ); return &ctx->u.s.Xmm3;
810  case CV_AMD64_XMM0 + 4: *size = sizeof(ctx->u.s.Xmm4 ); return &ctx->u.s.Xmm4;
811  case CV_AMD64_XMM0 + 5: *size = sizeof(ctx->u.s.Xmm5 ); return &ctx->u.s.Xmm5;
812  case CV_AMD64_XMM0 + 6: *size = sizeof(ctx->u.s.Xmm6 ); return &ctx->u.s.Xmm6;
813  case CV_AMD64_XMM0 + 7: *size = sizeof(ctx->u.s.Xmm7 ); return &ctx->u.s.Xmm7;
814  case CV_AMD64_XMM8 + 0: *size = sizeof(ctx->u.s.Xmm8 ); return &ctx->u.s.Xmm8;
815  case CV_AMD64_XMM8 + 1: *size = sizeof(ctx->u.s.Xmm9 ); return &ctx->u.s.Xmm9;
816  case CV_AMD64_XMM8 + 2: *size = sizeof(ctx->u.s.Xmm10); return &ctx->u.s.Xmm10;
817  case CV_AMD64_XMM8 + 3: *size = sizeof(ctx->u.s.Xmm11); return &ctx->u.s.Xmm11;
818  case CV_AMD64_XMM8 + 4: *size = sizeof(ctx->u.s.Xmm12); return &ctx->u.s.Xmm12;
819  case CV_AMD64_XMM8 + 5: *size = sizeof(ctx->u.s.Xmm13); return &ctx->u.s.Xmm13;
820  case CV_AMD64_XMM8 + 6: *size = sizeof(ctx->u.s.Xmm14); return &ctx->u.s.Xmm14;
821  case CV_AMD64_XMM8 + 7: *size = sizeof(ctx->u.s.Xmm15); return &ctx->u.s.Xmm15;
822 
823  case CV_AMD64_ST0 + 0: *size = sizeof(ctx->u.s.Legacy[0]); return &ctx->u.s.Legacy[0];
824  case CV_AMD64_ST0 + 1: *size = sizeof(ctx->u.s.Legacy[1]); return &ctx->u.s.Legacy[1];
825  case CV_AMD64_ST0 + 2: *size = sizeof(ctx->u.s.Legacy[2]); return &ctx->u.s.Legacy[2];
826  case CV_AMD64_ST0 + 3: *size = sizeof(ctx->u.s.Legacy[3]); return &ctx->u.s.Legacy[3];
827  case CV_AMD64_ST0 + 4: *size = sizeof(ctx->u.s.Legacy[4]); return &ctx->u.s.Legacy[4];
828  case CV_AMD64_ST0 + 5: *size = sizeof(ctx->u.s.Legacy[5]); return &ctx->u.s.Legacy[5];
829  case CV_AMD64_ST0 + 6: *size = sizeof(ctx->u.s.Legacy[6]); return &ctx->u.s.Legacy[6];
830  case CV_AMD64_ST0 + 7: *size = sizeof(ctx->u.s.Legacy[7]); return &ctx->u.s.Legacy[7];
831 
832  case CV_AMD64_EFLAGS: *size = sizeof(ctx->EFlags); return &ctx->EFlags;
833  case CV_AMD64_ES: *size = sizeof(ctx->SegEs); return &ctx->SegEs;
834  case CV_AMD64_CS: *size = sizeof(ctx->SegCs); return &ctx->SegCs;
835  case CV_AMD64_SS: *size = sizeof(ctx->SegSs); return &ctx->SegSs;
836  case CV_AMD64_DS: *size = sizeof(ctx->SegDs); return &ctx->SegDs;
837  case CV_AMD64_FS: *size = sizeof(ctx->SegFs); return &ctx->SegFs;
838  case CV_AMD64_GS: *size = sizeof(ctx->SegGs); return &ctx->SegGs;
839 
840  }
841 #endif
842  FIXME("Unknown register %x\n", regno);
843  return NULL;
844 }
#define FIXME(fmt,...)
Definition: debug.h:111
GLsizeiptr size
Definition: glext.h:5919
CONTEXT ctx
#define NULL
Definition: types.h:112

◆ x86_64_fetch_minidump_module()

static BOOL x86_64_fetch_minidump_module ( struct dump_context dc,
unsigned  index,
unsigned  flags 
)
static

Definition at line 920 of file cpu_x86_64.c.

921 {
922  /* FIXME: not sure about the flags... */
923  if (1)
924  {
925  /* FIXME: crop values across module boundaries, */
926 #ifdef __x86_64__
927  struct process* pcs;
928  struct module* module;
929  const RUNTIME_FUNCTION* rtf;
930  ULONG size;
931 
932  if (!(pcs = process_find_by_handle(dc->process->handle)) ||
933  !(module = module_find_by_addr(pcs, dc->modules[index].base, DMT_UNKNOWN)))
934  return FALSE;
936  if (rtf)
937  {
938  const RUNTIME_FUNCTION* end = (const RUNTIME_FUNCTION*)((const char*)rtf + size);
939  UNWIND_INFO ui;
940 
941  while (rtf + 1 < end)
942  {
943  while (rtf->UnwindData & 1) /* follow chained entry */
944  {
945  FIXME("RunTime_Function outside IMAGE_DIRECTORY_ENTRY_EXCEPTION unimplemented yet!\n");
946  return FALSE;
947  /* we need to read into the other process */
948  /* rtf = (RUNTIME_FUNCTION*)(module->module.BaseOfImage + (rtf->UnwindData & ~1)); */
949  }
950  if (read_process_memory(dc->process, dc->modules[index].base + rtf->UnwindData, &ui, sizeof(ui)))
951  minidump_add_memory_block(dc, dc->modules[index].base + rtf->UnwindData,
952  FIELD_OFFSET(UNWIND_INFO, UnwindCode) + ui.CountOfCodes * sizeof(UNWIND_CODE), 0);
953  rtf++;
954  }
955  }
956 #endif
957  }
958 
959  return TRUE;
960 }
HMODULE module
Definition: main.cpp:47
#define TRUE
Definition: types.h:120
struct process * process_find_by_handle(HANDLE hProcess)
Definition: dbghelp.c:99
UINT ui
Definition: oleauto.h:49
void minidump_add_memory_block(struct dump_context *dc, ULONG64 base, ULONG size, ULONG rva) DECLSPEC_HIDDEN
Definition: minidump.c:355
#define FALSE
Definition: types.h:117
#define FIXME(fmt,...)
Definition: debug.h:111
GLuint index
Definition: glext.h:6031
GLsizeiptr size
Definition: glext.h:5919
GLuint GLuint end
Definition: gl.h:1545
struct module * module_find_by_addr(const struct process *pcs, DWORD64 addr, enum module_type type) DECLSPEC_HIDDEN
Definition: module.c:420
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
unsigned int ULONG
Definition: retypes.h:1
static const WCHAR dc[]
static BOOL read_process_memory(const struct process *process, UINT64 addr, void *buf, size_t size)
#define IMAGE_DIRECTORY_ENTRY_EXCEPTION
Definition: pedump.c:262
const char * pe_map_directory(struct module *module, int dirno, DWORD *size) DECLSPEC_HIDDEN
Definition: pe_module.c:327

◆ x86_64_fetch_minidump_thread()

static BOOL x86_64_fetch_minidump_thread ( struct dump_context dc,
unsigned  index,
unsigned  flags,
const CONTEXT ctx 
)
static

Definition at line 906 of file cpu_x86_64.c.

907 {
908  if (ctx->ContextFlags && (flags & ThreadWriteInstructionWindow))
909  {
910  /* FIXME: crop values across module boundaries, */
911 #ifdef __x86_64__
912  ULONG64 base = ctx->Rip <= 0x80 ? 0 : ctx->Rip - 0x80;
913  minidump_add_memory_block(dc, base, ctx->Rip + 0x80 - base, 0);
914 #endif
915  }
916 
917  return TRUE;
918 }
#define TRUE
Definition: types.h:120
void minidump_add_memory_block(struct dump_context *dc, ULONG64 base, ULONG size, ULONG rva) DECLSPEC_HIDDEN
Definition: minidump.c:355
GLbitfield flags
Definition: glext.h:7161
unsigned __int64 ULONG64
Definition: imports.h:198
static const WCHAR dc[]

◆ x86_64_fetch_regname()

static const char* x86_64_fetch_regname ( unsigned  regno)
static

Definition at line 846 of file cpu_x86_64.c.

847 {
848  switch (regno)
849  {
850  case CV_AMD64_RAX: return "rax";
851  case CV_AMD64_RDX: return "rdx";
852  case CV_AMD64_RCX: return "rcx";
853  case CV_AMD64_RBX: return "rbx";
854  case CV_AMD64_RSI: return "rsi";
855  case CV_AMD64_RDI: return "rdi";
856  case CV_AMD64_RBP: return "rbp";
857  case CV_AMD64_RSP: return "rsp";
858  case CV_AMD64_R8: return "r8";
859  case CV_AMD64_R9: return "r9";
860  case CV_AMD64_R10: return "r10";
861  case CV_AMD64_R11: return "r11";
862  case CV_AMD64_R12: return "r12";
863  case CV_AMD64_R13: return "r13";
864  case CV_AMD64_R14: return "r14";
865  case CV_AMD64_R15: return "r15";
866  case CV_AMD64_RIP: return "rip";
867 
868  case CV_AMD64_XMM0 + 0: return "xmm0";
869  case CV_AMD64_XMM0 + 1: return "xmm1";
870  case CV_AMD64_XMM0 + 2: return "xmm2";
871  case CV_AMD64_XMM0 + 3: return "xmm3";
872  case CV_AMD64_XMM0 + 4: return "xmm4";
873  case CV_AMD64_XMM0 + 5: return "xmm5";
874  case CV_AMD64_XMM0 + 6: return "xmm6";
875  case CV_AMD64_XMM0 + 7: return "xmm7";
876  case CV_AMD64_XMM8 + 0: return "xmm8";
877  case CV_AMD64_XMM8 + 1: return "xmm9";
878  case CV_AMD64_XMM8 + 2: return "xmm10";
879  case CV_AMD64_XMM8 + 3: return "xmm11";
880  case CV_AMD64_XMM8 + 4: return "xmm12";
881  case CV_AMD64_XMM8 + 5: return "xmm13";
882  case CV_AMD64_XMM8 + 6: return "xmm14";
883  case CV_AMD64_XMM8 + 7: return "xmm15";
884 
885  case CV_AMD64_ST0 + 0: return "st0";
886  case CV_AMD64_ST0 + 1: return "st1";
887  case CV_AMD64_ST0 + 2: return "st2";
888  case CV_AMD64_ST0 + 3: return "st3";
889  case CV_AMD64_ST0 + 4: return "st4";
890  case CV_AMD64_ST0 + 5: return "st5";
891  case CV_AMD64_ST0 + 6: return "st6";
892  case CV_AMD64_ST0 + 7: return "st7";
893 
894  case CV_AMD64_EFLAGS: return "eflags";
895  case CV_AMD64_ES: return "es";
896  case CV_AMD64_CS: return "cs";
897  case CV_AMD64_SS: return "ss";
898  case CV_AMD64_DS: return "ds";
899  case CV_AMD64_FS: return "fs";
900  case CV_AMD64_GS: return "gs";
901  }
902  FIXME("Unknown register %x\n", regno);
903  return NULL;
904 }
#define FIXME(fmt,...)
Definition: debug.h:111
#define NULL
Definition: types.h:112

◆ x86_64_find_runtime_function()

static void* x86_64_find_runtime_function ( struct module module,
DWORD64  addr 
)
static

Definition at line 697 of file cpu_x86_64.c.

698 {
699 #ifdef __x86_64__
700  RUNTIME_FUNCTION* rtf;
701  ULONG size;
702  int min, max;
703 
705  if (rtf) for (min = 0, max = size / sizeof(*rtf); min <= max; )
706  {
707  int pos = (min + max) / 2;
708  if (addr < module->module.BaseOfImage + rtf[pos].BeginAddress) max = pos - 1;
709  else if (addr >= module->module.BaseOfImage + rtf[pos].EndAddress) min = pos + 1;
710  else
711  {
712  rtf += pos;
713  while (rtf->UnwindData & 1) /* follow chained entry */
714  {
715  FIXME("RunTime_Function outside IMAGE_DIRECTORY_ENTRY_EXCEPTION unimplemented yet!\n");
716  return NULL;
717  /* we need to read into the other process */
718  /* rtf = (RUNTIME_FUNCTION*)(module->module.BaseOfImage + (rtf->UnwindData & ~1)); */
719  }
720  return rtf;
721  }
722  }
723 #endif
724  return NULL;
725 }
#define max(a, b)
Definition: svc.c:63
DWORD64 BaseOfImage
Definition: compat.h:929
#define FIXME(fmt,...)
Definition: debug.h:111
GLsizeiptr size
Definition: glext.h:5919
GLenum const GLvoid * addr
Definition: glext.h:9621
#define min(a, b)
Definition: monoChain.cc:55
#define NULL
Definition: types.h:112
unsigned int ULONG
Definition: retypes.h:1
IMAGEHLP_MODULEW64 module
#define IMAGE_DIRECTORY_ENTRY_EXCEPTION
Definition: pedump.c:262
const char * pe_map_directory(struct module *module, int dirno, DWORD *size) DECLSPEC_HIDDEN
Definition: pe_module.c:327

◆ x86_64_get_addr()

static BOOL x86_64_get_addr ( HANDLE  hThread,
const CONTEXT ctx,
enum cpu_addr  ca,
ADDRESS64 addr 
)
static

Definition at line 79 of file cpu_x86_64.c.

81 {
82  addr->Mode = AddrModeFlat;
83  switch (ca)
84  {
85 #ifdef __x86_64__
86  case cpu_addr_pc: addr->Segment = ctx->SegCs; addr->Offset = ctx->Rip; return TRUE;
87  case cpu_addr_stack: addr->Segment = ctx->SegSs; addr->Offset = ctx->Rsp; return TRUE;
88  case cpu_addr_frame: addr->Segment = ctx->SegSs; addr->Offset = ctx->Rbp; return TRUE;
89 #endif
90  default: addr->Mode = -1;
91  return FALSE;
92  }
93 }
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
GLenum const GLvoid * addr
Definition: glext.h:9621
static const WCHAR ca[]
Definition: main.c:455

◆ x86_64_map_dwarf_register()

static unsigned x86_64_map_dwarf_register ( unsigned  regno,
const struct module module,
BOOL  eh_frame 
)
static

Definition at line 727 of file cpu_x86_64.c.

728 {
729  unsigned reg;
730 
731  if (regno >= 17 && regno <= 24)
732  reg = CV_AMD64_XMM0 + regno - 17;
733  else if (regno >= 25 && regno <= 32)
734  reg = CV_AMD64_XMM8 + regno - 25;
735  else if (regno >= 33 && regno <= 40)
736  reg = CV_AMD64_ST0 + regno - 33;
737  else switch (regno)
738  {
739  case 0: reg = CV_AMD64_RAX; break;
740  case 1: reg = CV_AMD64_RDX; break;
741  case 2: reg = CV_AMD64_RCX; break;
742  case 3: reg = CV_AMD64_RBX; break;
743  case 4: reg = CV_AMD64_RSI; break;
744  case 5: reg = CV_AMD64_RDI; break;
745  case 6: reg = CV_AMD64_RBP; break;
746  case 7: reg = CV_AMD64_RSP; break;
747  case 8: reg = CV_AMD64_R8; break;
748  case 9: reg = CV_AMD64_R9; break;
749  case 10: reg = CV_AMD64_R10; break;
750  case 11: reg = CV_AMD64_R11; break;
751  case 12: reg = CV_AMD64_R12; break;
752  case 13: reg = CV_AMD64_R13; break;
753  case 14: reg = CV_AMD64_R14; break;
754  case 15: reg = CV_AMD64_R15; break;
755  case 16: reg = CV_AMD64_RIP; break;
756  case 49: reg = CV_AMD64_EFLAGS; break;
757  case 50: reg = CV_AMD64_ES; break;
758  case 51: reg = CV_AMD64_CS; break;
759  case 52: reg = CV_AMD64_SS; break;
760  case 53: reg = CV_AMD64_DS; break;
761  case 54: reg = CV_AMD64_FS; break;
762  case 55: reg = CV_AMD64_GS; break;
763  case 62: reg = CV_AMD64_TR; break;
764  case 63: reg = CV_AMD64_LDTR; break;
765  case 64: reg = CV_AMD64_MXCSR; break;
766  case 65: reg = CV_AMD64_CTRL; break;
767  case 66: reg = CV_AMD64_STAT; break;
768 /*
769  * 56-57 reserved
770  * 58 %fs.base
771  * 59 %gs.base
772  * 60-61 reserved
773  */
774  default:
775  FIXME("Don't know how to map register %d\n", regno);
776  return 0;
777  }
778  return reg;
779 }
#define FIXME(fmt,...)
Definition: debug.h:111
static int reg
Definition: i386-dis.c:1283

◆ x86_64_stack_walk()

static BOOL x86_64_stack_walk ( struct cpu_stack_walk csw,
STACKFRAME64 frame,
union ctx ctx 
)
static

Definition at line 690 of file cpu_x86_64.c.

692 {
693  return FALSE;
694 }
#define FALSE
Definition: types.h:117

Variable Documentation

◆ cpu_x86_64

Initial value:
= {
8,
}
#define IMAGE_FILE_MACHINE_AMD64
Definition: ntimage.h:17
static const char * x86_64_fetch_regname(unsigned regno)
Definition: cpu_x86_64.c:846
static unsigned x86_64_map_dwarf_register(unsigned regno, const struct module *module, BOOL eh_frame)
Definition: cpu_x86_64.c:727
static BOOL x86_64_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame, union ctx *ctx)
Definition: cpu_x86_64.c:690
static BOOL x86_64_get_addr(HANDLE hThread, const CONTEXT *ctx, enum cpu_addr ca, ADDRESS64 *addr)
Definition: cpu_x86_64.c:79
static void * x86_64_find_runtime_function(struct module *module, DWORD64 addr)
Definition: cpu_x86_64.c:697
static void * x86_64_fetch_context_reg(union ctx *pctx, unsigned regno, unsigned *size)
Definition: cpu_x86_64.c:781
static BOOL x86_64_fetch_minidump_module(struct dump_context *dc, unsigned index, unsigned flags)
Definition: cpu_x86_64.c:920
static BOOL x86_64_fetch_minidump_thread(struct dump_context *dc, unsigned index, unsigned flags, const CONTEXT *ctx)
Definition: cpu_x86_64.c:906

Definition at line 962 of file cpu_x86_64.c.