1 #pragma once 2 3 #include <typedefs.h> 4 #include <guiddef.h> 5 #include <pecoff.h> 6 #include <wine/unicode.h> 7 8 #include <stdio.h> 9 #include <stdlib.h> 10 #include <wchar.h> 11 #include <ctype.h> 12 13 typedef HANDLE HWND; 14 15 #define min(x, y) (((x) < (y)) ? (x) : (y)) 16 #define max(x, y) (((x) > (y)) ? (x) : (y)) 17 18 #ifdef __i386__ 19 #define CDECL __cdecl 20 #else 21 #define CDECL 22 #endif 23 typedef PVOID IUnknown, IDispatch, IRecordInfo; 24 25 // windef.h 26 #define MAX_PATH 260 27 #define CALLBACK 28 typedef int (*FARPROC)(); 29 30 // bytesex.h 31 #define SWAPD(x) x 32 #define SWAPW(x) x 33 34 // Wine stuff 35 #define DECLSPEC_HIDDEN 36 #define WINE_DEFAULT_DEBUG_CHANNEL(x) 37 #define WINE_DECLARE_DEBUG_CHANNEL(x) 38 extern const char *wine_dbgstr_an( const char * s, int n ); 39 extern const char *wine_dbgstr_wn( const WCHAR *s, int n ); 40 extern const char *wine_dbg_sprintf( const char *format, ... ); 41 static __inline const char *wine_dbgstr_longlong( ULONGLONG ll ) 42 { 43 if (/*sizeof(ll) > sizeof(unsigned long) &&*/ ll >> 32) /* ULONGLONG is always > long in ReactOS */ 44 return wine_dbg_sprintf( "%lx%08lx", (unsigned long)(ll >> 32), (unsigned long)ll ); 45 else return wine_dbg_sprintf( "%lx", (unsigned long)ll ); 46 } 47 static __inline const char *debugstr_an( const char * s, int n ) { return wine_dbgstr_an( s, n ); } 48 static __inline const char *debugstr_wn( const WCHAR *s, int n ) { return wine_dbgstr_wn( s, n ); } 49 static __inline const char *debugstr_a( const char *s ) { return wine_dbgstr_an( s, -1 ); } 50 static __inline const char *debugstr_w( const WCHAR *s ) { return wine_dbgstr_wn( s, -1 ); } 51 static __inline const char *wine_dbgstr_w( const WCHAR *s ){return wine_dbgstr_wn( s, -1 );} 52 53 #if 0 54 #define WARN(fmt, ...) fprintf(stderr, "WARN %s: " fmt, __FUNCTION__, ##__VA_ARGS__) 55 #define FIXME(fmt, ...) fprintf(stderr, "FIXME %s: " fmt, __FUNCTION__, ##__VA_ARGS__) 56 #define TRACE(fmt, ...) fprintf(stderr, "TRACE %s: " fmt, __FUNCTION__, ##__VA_ARGS__) 57 #define ERR(fmt, ...) fprintf(stderr, "ERR %s: " fmt, __FUNCTION__, ##__VA_ARGS__) 58 #else 59 #define WARN(fmt, ...) 60 #define FIXME(fmt, ...) 61 #define TRACE(fmt, ...) 62 #define ERR(fmt, ...) 63 #endif 64 65 #define TRACE_ON(x) FALSE 66 #define TRACE_(x) TRACE 67 #define FIXME_(x) FIXME 68 const char *wine_dbg_sprintf( const char *format, ... ); 69 #define CP_UNIXCP CP_ACP 70 #define __TRY if(1) 71 #define __EXCEPT_PAGE_FAULT else 72 #define __ENDTRY 73 74 // basetsd.h 75 typedef ULONG_PTR KAFFINITY; 76 77 // excpt.h 78 typedef enum _EXCEPTION_DISPOSITION 79 { 80 ExceptionContinueExecution, 81 ExceptionContinueSearch, 82 ExceptionNestedException, 83 ExceptionCollidedUnwind, 84 } EXCEPTION_DISPOSITION; 85 86 // winerror.h 87 #define ERROR_ACCESS_DENIED 5 88 #define ERROR_INVALID_HANDLE 6 89 #define ERROR_OUTOFMEMORY 14 90 #define ERROR_NOT_SUPPORTED 50 91 #define ERROR_INVALID_PARAMETER 87 92 #define ERROR_CALL_NOT_IMPLEMENTED 120 93 #define ERROR_INVALID_NAME 123 94 #define ERROR_MOD_NOT_FOUND 126 95 #define ERROR_NO_MORE_ITEMS 259 96 #define ERROR_INVALID_ADDRESS 487 97 98 // winnls.h 99 #define CP_ACP 0 100 #define MultiByteToWideChar __MultiByteToWideChar 101 #define WideCharToMultiByte __WideCharToMultiByte 102 INT __MultiByteToWideChar( UINT page, DWORD flags, LPCSTR src, INT srclen, LPWSTR dst, INT dstlen ); 103 INT __WideCharToMultiByte( UINT page, DWORD flags, LPCWSTR src, INT srclen, LPSTR dst, INT dstlen, LPCSTR defchar, BOOL *used ); 104 105 // #define strlenW(s) wcslen((s)) 106 // #define strcpyW(d,s) wcscpy((d),(s)) 107 // #define strchrW(s,c) wcschr((s),(c)) 108 // #define strcatW(d,s) wcscat((d),(s)) 109 // #define strncmpiW(s1,s2,n) _wcsnicmp((s1),(s2),(n)) 110 // #define strcmpW(s1,s2) wcscmp((s1),(s2)) 111 // #define strcmpiW(s1,s2) _wcsicmp((s1),(s2)) 112 // #define tolowerW(n) towlower((n)) 113 // #define toupperW(n) towupper((n)) 114 115 // winnt.h 116 #define IMAGE_FILE_MACHINE_ARMNT 0x1c4 117 #define IMAGE_FILE_MACHINE_POWERPC 0x1f0 118 #define IMAGE_FILE_MACHINE_ARM64 0xaa64 119 #define DLL_PROCESS_DETACH 0 120 #define DLL_PROCESS_ATTACH 1 121 #define DLL_THREAD_ATTACH 2 122 #define DLL_THREAD_DETACH 3 123 #define HEAP_ZERO_MEMORY 8 124 #define GENERIC_READ 0x80000000 125 #define FILE_SHARE_READ 0x00000001 126 #define FILE_ATTRIBUTE_NORMAL 0x00000080 127 #define PAGE_READONLY 0x0002 128 #define SECTION_MAP_READ 4 129 #define IMAGE_DEBUG_TYPE_UNKNOWN 0 130 #define IMAGE_DEBUG_TYPE_COFF 1 131 #define IMAGE_DEBUG_TYPE_CODEVIEW 2 132 #define IMAGE_DEBUG_TYPE_FPO 3 133 #define IMAGE_DEBUG_TYPE_MISC 4 134 #define IMAGE_DEBUG_TYPE_EXCEPTION 5 135 #define IMAGE_DEBUG_TYPE_FIXUP 6 136 #define IMAGE_DEBUG_TYPE_OMAP_TO_SRC 7 137 #define IMAGE_DEBUG_TYPE_OMAP_FROM_SRC 8 138 #define IMAGE_SYM_CLASS_EXTERNAL 2 139 #define IMAGE_SYM_CLASS_FILE 103 140 #define IMAGE_DIRECTORY_ENTRY_EXPORT 0 141 #define IMAGE_DIRECTORY_ENTRY_DEBUG 6 142 #define IMAGE_DEBUG_MISC_EXENAME 1 143 #define IMAGE_SEPARATE_DEBUG_SIGNATURE 0x4944 144 typedef struct _IMAGE_EXPORT_DIRECTORY { 145 DWORD Characteristics; 146 DWORD TimeDateStamp; 147 WORD MajorVersion; 148 WORD MinorVersion; 149 DWORD Name; 150 DWORD Base; 151 DWORD NumberOfFunctions; 152 DWORD NumberOfNames; 153 DWORD AddressOfFunctions; 154 DWORD AddressOfNames; 155 DWORD AddressOfNameOrdinals; 156 } IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY; 157 typedef struct _IMAGE_DEBUG_MISC { 158 DWORD DataType; 159 DWORD Length; 160 BOOLEAN Unicode; 161 BYTE Reserved[3]; 162 BYTE Data[1]; 163 } IMAGE_DEBUG_MISC, *PIMAGE_DEBUG_MISC; 164 typedef struct _IMAGE_SEPARATE_DEBUG_HEADER { 165 WORD Signature; 166 WORD Flags; 167 WORD Machine; 168 WORD Characteristics; 169 DWORD TimeDateStamp; 170 DWORD CheckSum; 171 DWORD ImageBase; 172 DWORD SizeOfImage; 173 DWORD NumberOfSections; 174 DWORD ExportedNamesSize; 175 DWORD DebugDirectorySize; 176 DWORD SectionAlignment; 177 DWORD Reserved[2]; 178 } IMAGE_SEPARATE_DEBUG_HEADER, *PIMAGE_SEPARATE_DEBUG_HEADER; 179 typedef struct _SECURITY_ATTRIBUTES { 180 DWORD nLength; 181 LPVOID lpSecurityDescriptor; 182 BOOL bInheritHandle; 183 } SECURITY_ATTRIBUTES,*PSECURITY_ATTRIBUTES,*LPSECURITY_ATTRIBUTES; 184 typedef struct _IMAGE_DEBUG_DIRECTORY { 185 DWORD Characteristics; 186 DWORD TimeDateStamp; 187 WORD MajorVersion; 188 WORD MinorVersion; 189 DWORD Type; 190 DWORD SizeOfData; 191 DWORD AddressOfRawData; 192 DWORD PointerToRawData; 193 } IMAGE_DEBUG_DIRECTORY, *PIMAGE_DEBUG_DIRECTORY; 194 #define EXCEPTION_MAXIMUM_PARAMETERS 15 195 typedef struct _EXCEPTION_RECORD { 196 DWORD ExceptionCode; 197 DWORD ExceptionFlags; 198 struct _EXCEPTION_RECORD *ExceptionRecord; 199 PVOID ExceptionAddress; 200 DWORD NumberParameters; 201 ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; 202 } EXCEPTION_RECORD, *PEXCEPTION_RECORD; 203 #if defined(_X86_) 204 #define SIZE_OF_80387_REGISTERS 80 205 #define CONTEXT_i386 0x10000 206 #define CONTEXT_i486 0x10000 207 #define CONTEXT_CONTROL (CONTEXT_i386|0x00000001L) 208 #define CONTEXT_INTEGER (CONTEXT_i386|0x00000002L) 209 #define CONTEXT_SEGMENTS (CONTEXT_i386|0x00000004L) 210 #define CONTEXT_FLOATING_POINT (CONTEXT_i386|0x00000008L) 211 #define CONTEXT_DEBUG_REGISTERS (CONTEXT_i386|0x00000010L) 212 #define CONTEXT_EXTENDED_REGISTERS (CONTEXT_i386|0x00000020L) 213 #define CONTEXT_FULL (CONTEXT_CONTROL|CONTEXT_INTEGER|CONTEXT_SEGMENTS) 214 #define MAXIMUM_SUPPORTED_EXTENSION 512 215 216 #define EXCEPTION_READ_FAULT 0 217 #define EXCEPTION_WRITE_FAULT 1 218 #define EXCEPTION_EXECUTE_FAULT 8 219 220 typedef struct _FLOATING_SAVE_AREA { 221 DWORD ControlWord; 222 DWORD StatusWord; 223 DWORD TagWord; 224 DWORD ErrorOffset; 225 DWORD ErrorSelector; 226 DWORD DataOffset; 227 DWORD DataSelector; 228 BYTE RegisterArea[80]; 229 DWORD Cr0NpxState; 230 } FLOATING_SAVE_AREA, *PFLOATING_SAVE_AREA; 231 232 typedef struct _CONTEXT { 233 DWORD ContextFlags; 234 DWORD Dr0; 235 DWORD Dr1; 236 DWORD Dr2; 237 DWORD Dr3; 238 DWORD Dr6; 239 DWORD Dr7; 240 FLOATING_SAVE_AREA FloatSave; 241 DWORD SegGs; 242 DWORD SegFs; 243 DWORD SegEs; 244 DWORD SegDs; 245 DWORD Edi; 246 DWORD Esi; 247 DWORD Ebx; 248 DWORD Edx; 249 DWORD Ecx; 250 DWORD Eax; 251 DWORD Ebp; 252 DWORD Eip; 253 DWORD SegCs; 254 DWORD EFlags; 255 DWORD Esp; 256 DWORD SegSs; 257 BYTE ExtendedRegisters[MAXIMUM_SUPPORTED_EXTENSION]; 258 } CONTEXT, *PCONTEXT; 259 260 #else /* ARM? */ 261 262 /* The following flags control the contents of the CONTEXT structure. */ 263 264 #define CONTEXT_ARM 0x0200000 265 #define CONTEXT_CONTROL (CONTEXT_ARM | 0x00000001) 266 #define CONTEXT_INTEGER (CONTEXT_ARM | 0x00000002) 267 #define CONTEXT_FLOATING_POINT (CONTEXT_ARM | 0x00000004) 268 #define CONTEXT_DEBUG_REGISTERS (CONTEXT_ARM | 0x00000008) 269 270 #define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER) 271 272 #define EXCEPTION_READ_FAULT 0 273 #define EXCEPTION_WRITE_FAULT 1 274 #define EXCEPTION_EXECUTE_FAULT 8 275 276 typedef struct _RUNTIME_FUNCTION 277 { 278 DWORD BeginAddress; 279 union { 280 DWORD UnwindData; 281 struct { 282 DWORD Flag : 2; 283 DWORD FunctionLength : 11; 284 DWORD Ret : 2; 285 DWORD H : 1; 286 DWORD Reg : 3; 287 DWORD R : 1; 288 DWORD L : 1; 289 DWORD C : 1; 290 DWORD StackAdjust : 10; 291 } DUMMYSTRUCTNAME; 292 } DUMMYUNIONNAME; 293 } RUNTIME_FUNCTION, *PRUNTIME_FUNCTION; 294 295 #define UNWIND_HISTORY_TABLE_SIZE 12 296 typedef struct _UNWIND_HISTORY_TABLE_ENTRY 297 { 298 DWORD ImageBase; 299 PRUNTIME_FUNCTION FunctionEntry; 300 } UNWIND_HISTORY_TABLE_ENTRY, *PUNWIND_HISTORY_TABLE_ENTRY; 301 302 typedef struct _UNWIND_HISTORY_TABLE 303 { 304 DWORD Count; 305 BYTE LocalHint; 306 BYTE GlobalHint; 307 BYTE Search; 308 BYTE Once; 309 DWORD LowAddress; 310 DWORD HighAddress; 311 UNWIND_HISTORY_TABLE_ENTRY Entry[UNWIND_HISTORY_TABLE_SIZE]; 312 } UNWIND_HISTORY_TABLE, *PUNWIND_HISTORY_TABLE; 313 314 typedef struct _CONTEXT { 315 /* The flags values within this flag control the contents of 316 a CONTEXT record. 317 318 If the context record is used as an input parameter, then 319 for each portion of the context record controlled by a flag 320 whose value is set, it is assumed that that portion of the 321 context record contains valid context. If the context record 322 is being used to modify a thread's context, then only that 323 portion of the threads context will be modified. 324 325 If the context record is used as an IN OUT parameter to capture 326 the context of a thread, then only those portions of the thread's 327 context corresponding to set flags will be returned. 328 329 The context record is never used as an OUT only parameter. */ 330 331 ULONG ContextFlags; 332 333 /* This section is specified/returned if the ContextFlags word contains 334 the flag CONTEXT_INTEGER. */ 335 ULONG R0; 336 ULONG R1; 337 ULONG R2; 338 ULONG R3; 339 ULONG R4; 340 ULONG R5; 341 ULONG R6; 342 ULONG R7; 343 ULONG R8; 344 ULONG R9; 345 ULONG R10; 346 ULONG Fp; 347 ULONG Ip; 348 349 /* These are selected by CONTEXT_CONTROL */ 350 ULONG Sp; 351 ULONG Lr; 352 ULONG Pc; 353 ULONG Cpsr; 354 } CONTEXT; 355 356 BOOLEAN CDECL RtlAddFunctionTable(RUNTIME_FUNCTION*,DWORD,DWORD); 357 BOOLEAN CDECL RtlDeleteFunctionTable(RUNTIME_FUNCTION*); 358 PRUNTIME_FUNCTION WINAPI RtlLookupFunctionEntry(ULONG_PTR,DWORD*,UNWIND_HISTORY_TABLE*); 359 #endif 360 361 typedef 362 EXCEPTION_DISPOSITION 363 NTAPI 364 EXCEPTION_ROUTINE( 365 struct _EXCEPTION_RECORD *ExceptionRecord, 366 PVOID EstablisherFrame, 367 struct _CONTEXT *ContextRecord, 368 PVOID DispatcherContext); 369 typedef EXCEPTION_ROUTINE *PEXCEPTION_ROUTINE; 370 typedef struct _NT_TIB { 371 struct _EXCEPTION_REGISTRATION_RECORD *ExceptionList; 372 PVOID StackBase; 373 PVOID StackLimit; 374 PVOID SubSystemTib; 375 union { 376 PVOID FiberData; 377 DWORD Version; 378 } DUMMYUNIONNAME; 379 PVOID ArbitraryUserPointer; 380 struct _NT_TIB *Self; 381 } NT_TIB,*PNT_TIB; 382 383 // rtltypes.h 384 typedef struct _EXCEPTION_REGISTRATION_RECORD 385 { 386 struct _EXCEPTION_REGISTRATION_RECORD *Next; 387 PEXCEPTION_ROUTINE Handler; 388 } EXCEPTION_REGISTRATION_RECORD, *PEXCEPTION_REGISTRATION_RECORD; 389 390 // winbase.h 391 #define INVALID_HANDLE_VALUE (HANDLE)(-1) 392 #define HeapAlloc __HeapAlloc 393 #define HeapReAlloc __HeapReAlloc 394 #define HeapFree(x,y,z) free(z) 395 #define GetProcessHeap() 1 396 #define GetProcessId(x) 8 397 #define lstrcpynW __lstrcpynW 398 #define CloseHandle __CloseHandle 399 #define CreateFileA(a,b,c,d,e,f,g) fopen(a, "rb") 400 #define CreateFileW __CreateFileW 401 #define CreateFileMappingW(a,b,c,d,e,f) a 402 #define MapViewOfFile __MapViewOfFile 403 #define UnmapViewOfFile __UnmapViewOfFile 404 #define LoadLibraryW(x) 0 405 #define FreeLibrary(x) 0 406 #define lstrcpyW strcpyW // Forward this to wine unicode inline function 407 #define lstrlenW strlenW // ditto 408 #define lstrcpynA __lstrcpynA 409 #define SetLastError(x) 410 #define GetProcAddress(x,y) 0 411 #define GetEnvironmentVariableA(x, y, z) 0 412 #define GetEnvironmentVariableW(x, y, z) 0 413 #define GetCurrentDirectoryW(x, y) 0 414 #define GetFileSizeEx __GetFileSizeEx 415 #define ReadProcessMemory(a,b,c,d,e) 0 416 417 void* __HeapAlloc(int heap, int flags, size_t size); 418 void* __HeapReAlloc(int heap, DWORD d2, void *slab, SIZE_T newsize); 419 WCHAR* __lstrcpynW(WCHAR* lpString1, const WCHAR* lpString2, int iMaxLength); 420 BOOL __CloseHandle(HANDLE handle); 421 HANDLE __CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile); 422 void* __MapViewOfFile(HANDLE file,DWORD d1,DWORD d2,DWORD d3,SIZE_T s); 423 BOOL __UnmapViewOfFile(const void*); 424 LPSTR __lstrcpynA(LPSTR,LPCSTR,int); 425 BOOL __GetFileSizeEx(HANDLE,PLARGE_INTEGER); 426 #define OPEN_EXISTING 3 427 #define FILE_MAP_READ SECTION_MAP_READ 428 typedef struct _LDT_ENTRY { 429 WORD LimitLow; 430 WORD BaseLow; 431 union { 432 struct { 433 BYTE BaseMid; 434 BYTE Flags1; 435 BYTE Flags2; 436 BYTE BaseHi; 437 } Bytes; 438 struct { 439 DWORD BaseMid:8; 440 DWORD Type:5; 441 DWORD Dpl:2; 442 DWORD Pres:1; 443 DWORD LimitHi:4; 444 DWORD Sys:1; 445 DWORD Reserved_0:1; 446 DWORD Default_Big:1; 447 DWORD Granularity:1; 448 DWORD BaseHi:8; 449 } Bits; 450 } HighWord; 451 } LDT_ENTRY,*PLDT_ENTRY,*LPLDT_ENTRY; 452 453 // umtypes.h 454 typedef LONG KPRIORITY; 455 456 // winternl.h 457 #define RtlImageNtHeader __RtlImageNtHeader 458 #define RtlImageRvaToVa __RtlImageRvaToVa 459 #define RtlImageRvaToSection __RtlImageRvaToSection 460 #define RtlImageDirectoryEntryToData __RtlImageDirectoryEntryToData 461 462 #ifdef _MSC_VER 463 #define RtlUlongByteSwap(_x) _byteswap_ulong((_x)) 464 #else 465 #define RtlUlongByteSwap(_x) __builtin_bswap32((_x)) 466 #endif 467 468 PIMAGE_NT_HEADERS __RtlImageNtHeader(void *data); 469 PVOID __RtlImageRvaToVa (const IMAGE_NT_HEADERS* NtHeader, PVOID BaseAddress, ULONG Rva, PIMAGE_SECTION_HEADER *SectionHeader); 470 PVOID __RtlImageDirectoryEntryToData(PVOID BaseAddress, BOOLEAN MappedAsImage, USHORT Directory, PULONG Size); 471 472 typedef struct _CLIENT_ID 473 { 474 HANDLE UniqueProcess; 475 HANDLE UniqueThread; 476 } CLIENT_ID, *PCLIENT_ID; 477 #define GDI_BATCH_BUFFER_SIZE 0x136 478 typedef struct _GDI_TEB_BATCH 479 { 480 ULONG Offset; 481 HANDLE HDC; 482 ULONG Buffer[GDI_BATCH_BUFFER_SIZE]; 483 } GDI_TEB_BATCH, *PGDI_TEB_BATCH; 484 typedef struct _TEB 485 { 486 NT_TIB Tib; /* 000 */ 487 PVOID EnvironmentPointer; /* 01c */ 488 CLIENT_ID ClientId; /* 020 */ 489 PVOID ActiveRpcHandle; /* 028 */ 490 PVOID ThreadLocalStoragePointer; /* 02c */ 491 PVOID Peb; /* 030 */ 492 ULONG LastErrorValue; /* 034 */ 493 ULONG CountOfOwnedCriticalSections;/* 038 */ 494 PVOID CsrClientThread; /* 03c */ 495 PVOID Win32ThreadInfo; /* 040 */ 496 ULONG Win32ClientInfo[31]; /* 044 used for user32 private data in Wine */ 497 PVOID WOW32Reserved; /* 0c0 */ 498 ULONG CurrentLocale; /* 0c4 */ 499 ULONG FpSoftwareStatusRegister; /* 0c8 */ 500 PVOID SystemReserved1[54]; /* 0cc used for kernel32 private data in Wine */ 501 PVOID Spare1; /* 1a4 */ 502 LONG ExceptionCode; /* 1a8 */ 503 PVOID ActivationContextStackPointer; /* 1a8/02c8 */ 504 BYTE SpareBytes1[36]; /* 1ac */ 505 PVOID SystemReserved2[10]; /* 1d4 used for ntdll private data in Wine */ 506 GDI_TEB_BATCH GdiTebBatch; /* 1fc */ 507 ULONG gdiRgn; /* 6dc */ 508 ULONG gdiPen; /* 6e0 */ 509 ULONG gdiBrush; /* 6e4 */ 510 CLIENT_ID RealClientId; /* 6e8 */ 511 HANDLE GdiCachedProcessHandle; /* 6f0 */ 512 ULONG GdiClientPID; /* 6f4 */ 513 ULONG GdiClientTID; /* 6f8 */ 514 PVOID GdiThreadLocaleInfo; /* 6fc */ 515 PVOID UserReserved[5]; /* 700 */ 516 PVOID glDispatchTable[280]; /* 714 */ 517 ULONG glReserved1[26]; /* b74 */ 518 PVOID glReserved2; /* bdc */ 519 PVOID glSectionInfo; /* be0 */ 520 PVOID glSection; /* be4 */ 521 PVOID glTable; /* be8 */ 522 PVOID glCurrentRC; /* bec */ 523 PVOID glContext; /* bf0 */ 524 ULONG LastStatusValue; /* bf4 */ 525 UNICODE_STRING StaticUnicodeString; /* bf8 used by advapi32 */ 526 WCHAR StaticUnicodeBuffer[261]; /* c00 used by advapi32 */ 527 PVOID DeallocationStack; /* e0c */ 528 PVOID TlsSlots[64]; /* e10 */ 529 LIST_ENTRY TlsLinks; /* f10 */ 530 PVOID Vdm; /* f18 */ 531 PVOID ReservedForNtRpc; /* f1c */ 532 PVOID DbgSsReserved[2]; /* f20 */ 533 ULONG HardErrorDisabled; /* f28 */ 534 PVOID Instrumentation[16]; /* f2c */ 535 PVOID WinSockData; /* f6c */ 536 ULONG GdiBatchCount; /* f70 */ 537 ULONG Spare2; /* f74 */ 538 ULONG Spare3; /* f78 */ 539 ULONG Spare4; /* f7c */ 540 PVOID ReservedForOle; /* f80 */ 541 ULONG WaitingOnLoaderLock; /* f84 */ 542 PVOID Reserved5[3]; /* f88 */ 543 PVOID *TlsExpansionSlots; /* f94 */ 544 } TEB, *PTEB; 545 546 547 // winver.h 548 typedef struct tagVS_FIXEDFILEINFO { 549 DWORD dwSignature; 550 DWORD dwStrucVersion; 551 DWORD dwFileVersionMS; 552 DWORD dwFileVersionLS; 553 DWORD dwProductVersionMS; 554 DWORD dwProductVersionLS; 555 DWORD dwFileFlagsMask; 556 DWORD dwFileFlags; 557 DWORD dwFileOS; 558 DWORD dwFileType; 559 DWORD dwFileSubtype; 560 DWORD dwFileDateMS; 561 DWORD dwFileDateLS; 562 } VS_FIXEDFILEINFO; 563 564 565 // psapi.h 566 typedef struct _MODULEINFO { 567 LPVOID lpBaseOfDll; 568 DWORD SizeOfImage; 569 LPVOID EntryPoint; 570 } MODULEINFO,*LPMODULEINFO; 571 #define GetModuleFileNameExW(w, x, y, z) 0 572 573 // pstypes.h 574 typedef struct _THREAD_BASIC_INFORMATION 575 { 576 NTSTATUS ExitStatus; 577 PVOID TebBaseAddress; 578 CLIENT_ID ClientId; 579 KAFFINITY AffinityMask; 580 KPRIORITY Priority; 581 KPRIORITY BasePriority; 582 } THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION; 583 typedef enum _THREADINFOCLASS { 584 ThreadBasicInformation, 585 ThreadTimes, 586 ThreadPriority, 587 ThreadBasePriority, 588 ThreadAffinityMask, 589 ThreadImpersonationToken, 590 ThreadDescriptorTableEntry, 591 ThreadEnableAlignmentFaultFixup, 592 ThreadEventPair_Reusable, 593 ThreadQuerySetWin32StartAddress, 594 ThreadZeroTlsCell, 595 ThreadPerformanceCount, 596 ThreadAmILastThread, 597 ThreadIdealProcessor, 598 ThreadPriorityBoost, 599 ThreadSetTlsArrayAddress, 600 ThreadIsIoPending, 601 ThreadHideFromDebugger, 602 ThreadBreakOnTermination, 603 ThreadSwitchLegacyState, 604 ThreadIsTerminated, 605 ThreadLastSystemCall, 606 ThreadIoPriority, 607 ThreadCycleTime, 608 ThreadPagePriority, 609 ThreadActualBasePriority, 610 ThreadTebInformation, 611 ThreadCSwitchMon, 612 ThreadCSwitchPmu, 613 ThreadWow64Context, 614 ThreadGroupInformation, 615 ThreadUmsInformation, 616 ThreadCounterProfiling, 617 ThreadIdealProcessorEx, 618 MaxThreadInfoClass 619 } THREADINFOCLASS; 620 621 622 // dbghelp.h 623 typedef VOID IMAGEHLP_CONTEXT, *PIMAGEHLP_CONTEXT; 624 #define MAX_SYM_NAME 2000 625 #define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001 626 #define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002 627 #define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003 628 #define CBA_SYMBOLS_UNLOADED 0x00000004 629 #define CBA_DUPLICATE_SYMBOL 0x00000005 630 #define CBA_READ_MEMORY 0x00000006 631 #define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007 632 #define CBA_SET_OPTIONS 0x00000008 633 #define CBA_EVENT 0x00000010 634 #define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020 635 #define CBA_DEBUG_INFO 0x10000000 636 #define SYMOPT_CASE_INSENSITIVE 0x00000001 637 #define SYMOPT_UNDNAME 0x00000002 638 #define SYMOPT_DEFERRED_LOADS 0x00000004 639 #define SYMOPT_LOAD_LINES 0x00000010 640 #define SYMOPT_LOAD_ANYTHING 0x00000040 641 #define SYMOPT_PUBLICS_ONLY 0x00004000 642 #define SYMOPT_NO_PUBLICS 0x00008000 643 #define SYMOPT_AUTO_PUBLICS 0x00010000 644 #define SYMFLAG_VALUEPRESENT 0x00000001 645 #define SYMFLAG_REGISTER 0x00000008 646 #define SYMFLAG_REGREL 0x00000010 647 #define SYMFLAG_FRAMEREL 0x00000020 648 #define SYMFLAG_PARAMETER 0x00000040 649 #define SYMFLAG_LOCAL 0x00000080 650 #define SYMFLAG_CONSTANT 0x00000100 651 #define SYMFLAG_EXPORT 0x00000200 652 #define SYMFLAG_FORWARDER 0x00000400 653 #define SYMFLAG_FUNCTION 0x00000800 654 #define SYMFLAG_VIRTUAL 0x00001000 655 #define SYMFLAG_THUNK 0x00002000 656 #define SYMFLAG_TLSREL 0x00004000 657 #define SYMFLAG_SLOT 0x00008000 658 #define UNDNAME_COMPLETE (0x0000) 659 #define UNDNAME_NAME_ONLY (0x1000) 660 typedef struct _TI_FINDCHILDREN_PARAMS 661 { 662 ULONG Count; 663 ULONG Start; 664 ULONG ChildId[1]; 665 } TI_FINDCHILDREN_PARAMS; 666 #define SYMSEARCH_GLOBALSONLY 0x04 667 /* flags for SymLoadModuleEx */ 668 #define SLMFLAG_VIRTUAL 0x1 669 #define SLMFLAG_NO_SYMBOLS 0x4 670 typedef struct _DBGHELP_MODLOAD_DATA 671 { 672 DWORD ssize; 673 DWORD ssig; 674 PVOID data; 675 DWORD size; 676 DWORD flags; 677 } MODLOAD_DATA, *PMODLOAD_DATA; 678 typedef struct _SYMBOL_INFO 679 { 680 ULONG SizeOfStruct; 681 ULONG TypeIndex; 682 ULONG64 Reserved[2]; 683 ULONG Index; 684 ULONG Size; 685 ULONG64 ModBase; 686 ULONG Flags; 687 ULONG64 Value; 688 ULONG64 Address; 689 ULONG Register; 690 ULONG Scope; 691 ULONG Tag; 692 ULONG NameLen; 693 ULONG MaxNameLen; 694 CHAR Name[1]; 695 } SYMBOL_INFO, *PSYMBOL_INFO; 696 typedef enum 697 { 698 SymNone = 0, 699 SymCoff, 700 SymCv, 701 SymPdb, 702 SymExport, 703 SymDeferred, 704 SymSym, 705 SymDia, 706 SymVirtual, 707 NumSymTypes 708 } SYM_TYPE; 709 typedef struct _IMAGEHLP_MODULEW64 710 { 711 DWORD SizeOfStruct; 712 DWORD64 BaseOfImage; 713 DWORD ImageSize; 714 DWORD TimeDateStamp; 715 DWORD CheckSum; 716 DWORD NumSyms; 717 SYM_TYPE SymType; 718 WCHAR ModuleName[32]; 719 WCHAR ImageName[256]; 720 WCHAR LoadedImageName[256]; 721 WCHAR LoadedPdbName[256]; 722 DWORD CVSig; 723 WCHAR CVData[MAX_PATH*3]; 724 DWORD PdbSig; 725 GUID PdbSig70; 726 DWORD PdbAge; 727 BOOL PdbUnmatched; 728 BOOL DbgUnmatched; 729 BOOL LineNumbers; 730 BOOL GlobalSymbols; 731 BOOL TypeInfo; 732 BOOL SourceIndexed; 733 BOOL Publics; 734 } IMAGEHLP_MODULEW64, *PIMAGEHLP_MODULEW64; 735 typedef struct _IMAGEHLP_LINE64 736 { 737 DWORD SizeOfStruct; 738 PVOID Key; 739 DWORD LineNumber; 740 PCHAR FileName; 741 DWORD64 Address; 742 } IMAGEHLP_LINE64, *PIMAGEHLP_LINE64; 743 typedef struct _SRCCODEINFO 744 { 745 DWORD SizeOfStruct; 746 PVOID Key; 747 DWORD64 ModBase; 748 CHAR Obj[MAX_PATH+1]; 749 CHAR FileName[MAX_PATH+1]; 750 DWORD LineNumber; 751 DWORD64 Address; 752 } SRCCODEINFO, *PSRCCODEINFO; 753 typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO, PVOID); 754 typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO, ULONG, PVOID); 755 BOOL WINAPI SymInitialize(HANDLE hProcess, PCSTR UserSearchPath, BOOL fInvadeProcess); 756 BOOL WINAPI SymCleanup(HANDLE hProcess); 757 BOOL WINAPI SymAddSymbolW(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR name, DWORD64 addr, DWORD size, DWORD flags); 758 BOOL WINAPI SymGetModuleInfoW64(HANDLE hProcess, DWORD64 dwAddr, PIMAGEHLP_MODULEW64 ModuleInfo); 759 BOOL WINAPI SymMatchStringW(PCWSTR string, PCWSTR re, BOOL _case); 760 DWORD WINAPI SymLoadModule(HANDLE hProcess, HANDLE hFile, PCSTR ImageName, 761 PCSTR ModuleName, DWORD BaseOfDll, DWORD SizeOfDll); 762 DWORD64 WINAPI SymLoadModuleEx(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD, 763 PMODLOAD_DATA, DWORD); 764 DWORD64 WINAPI SymLoadModuleExW(HANDLE, HANDLE, PCWSTR, PCWSTR, DWORD64, DWORD, 765 PMODLOAD_DATA, DWORD); 766 DWORD64 WINAPI SymGetModuleBase64(HANDLE, DWORD64); 767 BOOL WINAPI SymUnloadModule(HANDLE hProcess, DWORD BaseOfDll); 768 PVOID WINAPI SymFunctionTableAccess(HANDLE, DWORD); 769 PVOID WINAPI SymFunctionTableAccess64(HANDLE, DWORD64); 770 BOOL WINAPI SymFromAddr(HANDLE hProcess, DWORD64 Address, DWORD64* Displacement, PSYMBOL_INFO Symbol); 771 BOOL WINAPI SymEnumLines(HANDLE hProcess, ULONG64 base, PCSTR compiland, PCSTR srcfile, PSYM_ENUMLINES_CALLBACK cb, PVOID user); 772 DWORD WINAPI SymSetOptions(DWORD opts); 773 BOOL WINAPI SymGetLineFromAddr64(HANDLE hProcess, DWORD64 dwAddr, PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line); 774 typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID); 775 #define FindExecutableImageExW __FindExecutableImageExW 776 HANDLE __FindExecutableImageExW(PCWSTR, PCWSTR, PWSTR, PFIND_EXE_FILE_CALLBACKW, PVOID); 777 DWORD WINAPI UnDecorateSymbolName(PCSTR, PSTR, DWORD, DWORD); 778 typedef enum _THREAD_WRITE_FLAGS 779 { 780 ThreadWriteThread = 0x0001, 781 ThreadWriteStack = 0x0002, 782 ThreadWriteContext = 0x0004, 783 ThreadWriteBackingStore = 0x0008, 784 ThreadWriteInstructionWindow = 0x0010, 785 ThreadWriteThreadData = 0x0020, 786 ThreadWriteThreadInfo = 0x0040 787 } THREAD_WRITE_FLAGS; 788 typedef enum 789 { 790 AddrMode1616, 791 AddrMode1632, 792 AddrModeReal, 793 AddrModeFlat 794 } ADDRESS_MODE; 795 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOADW64 796 { 797 DWORD SizeOfStruct; 798 DWORD64 BaseOfImage; 799 DWORD CheckSum; 800 DWORD TimeDateStamp; 801 WCHAR FileName[MAX_PATH + 1]; 802 BOOLEAN Reparse; 803 HANDLE hFile; 804 DWORD Flags; 805 } IMAGEHLP_DEFERRED_SYMBOL_LOADW64, *PIMAGEHLP_DEFERRED_SYMBOL_LOADW64; 806 typedef struct _tagADDRESS64 807 { 808 DWORD64 Offset; 809 WORD Segment; 810 ADDRESS_MODE Mode; 811 } ADDRESS64, *LPADDRESS64; 812 typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACKW)(PCWSTR, PVOID); 813 typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE, DWORD64); 814 typedef DWORD64 (CALLBACK *PGET_MODULE_BASE_ROUTINE64)(HANDLE, DWORD64); 815 typedef DWORD64 (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE, HANDLE, LPADDRESS64); 816 typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE, ULONG, ULONG64, ULONG64); 817 typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE64)(HANDLE, DWORD64, PVOID, DWORD, PDWORD); 818 typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PCSTR, DWORD64, PVOID); 819 typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)(PCWSTR, DWORD64, PVOID); 820 typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID); 821 typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(PCWSTR, DWORD64, ULONG, PVOID); 822 typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID); 823 typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PCWSTR, DWORD64, ULONG, PVOID); 824 825 BOOL WINAPI SymEnumerateModulesW64(HANDLE hProcess, PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback, PVOID UserContext); 826 827 typedef struct _tagADDRESS 828 { 829 DWORD Offset; 830 WORD Segment; 831 ADDRESS_MODE Mode; 832 } ADDRESS, *LPADDRESS; 833 834 typedef struct _IMAGEHLP_MODULE 835 { 836 DWORD SizeOfStruct; 837 DWORD BaseOfImage; 838 DWORD ImageSize; 839 DWORD TimeDateStamp; 840 DWORD CheckSum; 841 DWORD NumSyms; 842 SYM_TYPE SymType; 843 CHAR ModuleName[32]; 844 CHAR ImageName[256]; 845 CHAR LoadedImageName[256]; 846 } IMAGEHLP_MODULE, *PIMAGEHLP_MODULE; 847 typedef struct _IMAGEHLP_MODULEW 848 { 849 DWORD SizeOfStruct; 850 DWORD BaseOfImage; 851 DWORD ImageSize; 852 DWORD TimeDateStamp; 853 DWORD CheckSum; 854 DWORD NumSyms; 855 SYM_TYPE SymType; 856 WCHAR ModuleName[32]; 857 WCHAR ImageName[256]; 858 WCHAR LoadedImageName[256]; 859 } IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW; 860 typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PCSTR, ULONG, ULONG, PVOID); 861 typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE, ULONG, PVOID, PVOID); 862 typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE)(HANDLE, DWORD, PVOID, DWORD, PDWORD); 863 typedef DWORD (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE, HANDLE, LPADDRESS); 864 typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE, DWORD); 865 typedef DWORD (CALLBACK *PGET_MODULE_BASE_ROUTINE)(HANDLE, DWORD); 866 typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PCSTR, ULONG, PVOID); 867 typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PCSTR, ULONG, ULONG, PVOID); 868 typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PCWSTR, ULONG, ULONG, PVOID); 869 870 typedef struct _IMAGEHLP_MODULE64 871 { 872 DWORD SizeOfStruct; 873 DWORD64 BaseOfImage; 874 DWORD ImageSize; 875 DWORD TimeDateStamp; 876 DWORD CheckSum; 877 DWORD NumSyms; 878 SYM_TYPE SymType; 879 CHAR ModuleName[32]; 880 CHAR ImageName[256]; 881 CHAR LoadedImageName[256]; 882 CHAR LoadedPdbName[256]; 883 DWORD CVSig; 884 CHAR CVData[MAX_PATH*3]; 885 DWORD PdbSig; 886 GUID PdbSig70; 887 DWORD PdbAge; 888 BOOL PdbUnmatched; 889 BOOL DbgUnmatched; 890 BOOL LineNumbers; 891 BOOL GlobalSymbols; 892 BOOL TypeInfo; 893 BOOL SourceIndexed; 894 BOOL Publics; 895 } IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64; 896 typedef DWORD RVA; 897 typedef ULONG64 RVA64; 898 typedef enum _MINIDUMP_TYPE 899 { 900 MiniDumpNormal = 0x0000, 901 MiniDumpWithDataSegs = 0x0001, 902 MiniDumpWithFullMemory = 0x0002, 903 MiniDumpWithHandleData = 0x0004, 904 MiniDumpFilterMemory = 0x0008, 905 MiniDumpScanMemory = 0x0010, 906 MiniDumpWithUnloadedModules = 0x0020, 907 MiniDumpWithIndirectlyReferencedMemory = 0x0040, 908 MiniDumpFilterModulePaths = 0x0080, 909 MiniDumpWithProcessThreadData = 0x0100, 910 MiniDumpWithPrivateReadWriteMemory = 0x0200, 911 MiniDumpWithoutOptionalData = 0x0400, 912 MiniDumpWithFullMemoryInfo = 0x0800, 913 MiniDumpWithThreadInfo = 0x1000, 914 MiniDumpWithCodeSegs = 0x2000 915 } MINIDUMP_TYPE; 916 typedef struct _MINIDUMP_THREAD_CALLBACK 917 { 918 ULONG ThreadId; 919 HANDLE ThreadHandle; 920 CONTEXT Context; 921 ULONG SizeOfContext; 922 ULONG64 StackBase; 923 ULONG64 StackEnd; 924 } MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK; 925 typedef struct _MINIDUMP_THREAD_EX_CALLBACK 926 { 927 ULONG ThreadId; 928 HANDLE ThreadHandle; 929 CONTEXT Context; 930 ULONG SizeOfContext; 931 ULONG64 StackBase; 932 ULONG64 StackEnd; 933 ULONG64 BackingStoreBase; 934 ULONG64 BackingStoreEnd; 935 } MINIDUMP_THREAD_EX_CALLBACK, *PMINIDUMP_THREAD_EX_CALLBACK; 936 typedef struct _MINIDUMP_MODULE_CALLBACK 937 { 938 PWCHAR FullPath; 939 ULONG64 BaseOfImage; 940 ULONG SizeOfImage; 941 ULONG CheckSum; 942 ULONG TimeDateStamp; 943 VS_FIXEDFILEINFO VersionInfo; 944 PVOID CvRecord; 945 ULONG SizeOfCvRecord; 946 PVOID MiscRecord; 947 ULONG SizeOfMiscRecord; 948 } MINIDUMP_MODULE_CALLBACK, *PMINIDUMP_MODULE_CALLBACK; 949 typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK 950 { 951 ULONG ThreadId; 952 } MINIDUMP_INCLUDE_THREAD_CALLBACK, *PMINIDUMP_INCLUDE_THREAD_CALLBACK; 953 typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK 954 { 955 ULONG64 BaseOfImage; 956 } MINIDUMP_INCLUDE_MODULE_CALLBACK, *PMINIDUMP_INCLUDE_MODULE_CALLBACK; 957 typedef struct _MINIDUMP_CALLBACK_INPUT 958 { 959 ULONG ProcessId; 960 HANDLE ProcessHandle; 961 ULONG CallbackType; 962 union 963 { 964 MINIDUMP_THREAD_CALLBACK Thread; 965 MINIDUMP_THREAD_EX_CALLBACK ThreadEx; 966 MINIDUMP_MODULE_CALLBACK Module; 967 MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread; 968 MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule; 969 } DUMMYUNIONNAME; 970 } MINIDUMP_CALLBACK_INPUT, *PMINIDUMP_CALLBACK_INPUT; 971 typedef struct _MINIDUMP_CALLBACK_OUTPUT 972 { 973 union 974 { 975 ULONG ModuleWriteFlags; 976 ULONG ThreadWriteFlags; 977 struct 978 { 979 ULONG64 MemoryBase; 980 ULONG MemorySize; 981 } DUMMYSTRUCTNAME; 982 } DUMMYUNIONNAME; 983 } MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT; 984 typedef BOOL (WINAPI* MINIDUMP_CALLBACK_ROUTINE)(PVOID, const PMINIDUMP_CALLBACK_INPUT, PMINIDUMP_CALLBACK_OUTPUT); 985 typedef struct _MINIDUMP_CALLBACK_INFORMATION 986 { 987 MINIDUMP_CALLBACK_ROUTINE CallbackRoutine; 988 void* CallbackParam; 989 } MINIDUMP_CALLBACK_INFORMATION, *PMINIDUMP_CALLBACK_INFORMATION; 990 typedef struct _SYMBOL_INFOW 991 { 992 ULONG SizeOfStruct; 993 ULONG TypeIndex; 994 ULONG64 Reserved[2]; 995 ULONG Index; 996 ULONG Size; 997 ULONG64 ModBase; 998 ULONG Flags; 999 ULONG64 Value; 1000 ULONG64 Address; 1001 ULONG Register; 1002 ULONG Scope; 1003 ULONG Tag; 1004 ULONG NameLen; 1005 ULONG MaxNameLen; 1006 WCHAR Name[1]; 1007 } SYMBOL_INFOW, *PSYMBOL_INFOW; 1008 typedef struct _IMAGEHLP_STACK_FRAME 1009 { 1010 ULONG64 InstructionOffset; 1011 ULONG64 ReturnOffset; 1012 ULONG64 FrameOffset; 1013 ULONG64 StackOffset; 1014 ULONG64 BackingStoreOffset; 1015 ULONG64 FuncTableEntry; 1016 ULONG64 Params[4]; 1017 ULONG64 Reserved[5]; 1018 BOOL Virtual; 1019 ULONG Reserved2; 1020 } IMAGEHLP_STACK_FRAME, *PIMAGEHLP_STACK_FRAME; 1021 typedef struct _KDHELP64 1022 { 1023 DWORD64 Thread; 1024 DWORD ThCallbackStack; 1025 DWORD ThCallbackBStore; 1026 DWORD NextCallback; 1027 DWORD FramePointer; 1028 DWORD64 KiCallUserMode; 1029 DWORD64 KeUserCallbackDispatcher; 1030 DWORD64 SystemRangeStart; 1031 DWORD64 Reserved[8]; 1032 } KDHELP64, *PKDHELP64; 1033 typedef struct _STACKFRAME64 1034 { 1035 ADDRESS64 AddrPC; 1036 ADDRESS64 AddrReturn; 1037 ADDRESS64 AddrFrame; 1038 ADDRESS64 AddrStack; 1039 ADDRESS64 AddrBStore; 1040 PVOID FuncTableEntry; 1041 DWORD64 Params[4]; 1042 BOOL Far; 1043 BOOL Virtual; 1044 DWORD64 Reserved[3]; 1045 KDHELP64 KdHelp; 1046 } STACKFRAME64, *LPSTACKFRAME64; 1047 typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO 1048 { 1049 TI_GET_SYMTAG, 1050 TI_GET_SYMNAME, 1051 TI_GET_LENGTH, 1052 TI_GET_TYPE, 1053 TI_GET_TYPEID, 1054 TI_GET_BASETYPE, 1055 TI_GET_ARRAYINDEXTYPEID, 1056 TI_FINDCHILDREN, 1057 TI_GET_DATAKIND, 1058 TI_GET_ADDRESSOFFSET, 1059 TI_GET_OFFSET, 1060 TI_GET_VALUE, 1061 TI_GET_COUNT, 1062 TI_GET_CHILDRENCOUNT, 1063 TI_GET_BITPOSITION, 1064 TI_GET_VIRTUALBASECLASS, 1065 TI_GET_VIRTUALTABLESHAPEID, 1066 TI_GET_VIRTUALBASEPOINTEROFFSET, 1067 TI_GET_CLASSPARENTID, 1068 TI_GET_NESTED, 1069 TI_GET_SYMINDEX, 1070 TI_GET_LEXICALPARENT, 1071 TI_GET_ADDRESS, 1072 TI_GET_THISADJUST, 1073 TI_GET_UDTKIND, 1074 TI_IS_EQUIV_TO, 1075 TI_GET_CALLING_CONVENTION, 1076 } IMAGEHLP_SYMBOL_TYPE_INFO; 1077 typedef struct _SOURCEFILE 1078 { 1079 DWORD64 ModBase; 1080 PCHAR FileName; 1081 } SOURCEFILE, *PSOURCEFILE; 1082 typedef struct _SOURCEFILEW 1083 { 1084 DWORD64 ModBase; 1085 PWSTR FileName; 1086 } SOURCEFILEW, *PSOURCEFILEW; 1087 typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(PSOURCEFILE, PVOID); 1088 typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(PSOURCEFILEW, PVOID); 1089 typedef struct _SRCCODEINFOW 1090 { 1091 DWORD SizeOfStruct; 1092 PVOID Key; 1093 DWORD64 ModBase; 1094 WCHAR Obj[MAX_PATH+1]; 1095 WCHAR FileName[MAX_PATH+1]; 1096 DWORD LineNumber; 1097 DWORD64 Address; 1098 } SRCCODEINFOW, *PSRCCODEINFOW; 1099 typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACKW)(PSRCCODEINFOW, PVOID); 1100 typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(PSYMBOL_INFOW, ULONG, PVOID); 1101 #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) 1102 #define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64 1103 #define IMAGEHLP_SYMBOLW IMAGEHLP_SYMBOLW64 1104 #define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64 1105 #define PIMAGEHLP_SYMBOLW PIMAGEHLP_SYMBOLW64 1106 #else 1107 typedef struct _IMAGEHLP_SYMBOL 1108 { 1109 DWORD SizeOfStruct; 1110 DWORD Address; 1111 DWORD Size; 1112 DWORD Flags; 1113 DWORD MaxNameLength; 1114 CHAR Name[1]; 1115 } IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL; 1116 1117 typedef struct _IMAGEHLP_SYMBOLW 1118 { 1119 DWORD SizeOfStruct; 1120 DWORD Address; 1121 DWORD Size; 1122 DWORD Flags; 1123 DWORD MaxNameLength; 1124 WCHAR Name[1]; 1125 } IMAGEHLP_SYMBOLW, *PIMAGEHLP_SYMBOLW; 1126 #endif 1127 typedef struct _IMAGEHLP_SYMBOL64 1128 { 1129 DWORD SizeOfStruct; 1130 DWORD64 Address; 1131 DWORD Size; 1132 DWORD Flags; 1133 DWORD MaxNameLength; 1134 CHAR Name[1]; 1135 } IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64; 1136 typedef struct _IMAGEHLP_SYMBOLW64 1137 { 1138 DWORD SizeOfStruct; 1139 DWORD64 Address; 1140 DWORD Size; 1141 DWORD Flags; 1142 DWORD MaxNameLength; 1143 WCHAR Name[1]; 1144 } IMAGEHLP_SYMBOLW64, *PIMAGEHLP_SYMBOLW64; 1145 #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) 1146 #define IMAGEHLP_LINE IMAGEHLP_LINE64 1147 #define PIMAGEHLP_LINE PIMAGEHLP_LINE64 1148 #define IMAGEHLP_LINEW IMAGEHLP_LINEW64 1149 #define PIMAGEHLP_LINEW PIMAGEHLP_LINEW64 1150 #else 1151 typedef struct _IMAGEHLP_LINE 1152 { 1153 DWORD SizeOfStruct; 1154 PVOID Key; 1155 DWORD LineNumber; 1156 PCHAR FileName; 1157 DWORD Address; 1158 } IMAGEHLP_LINE, *PIMAGEHLP_LINE; 1159 1160 typedef struct _IMAGEHLP_LINEW 1161 { 1162 DWORD SizeOfStruct; 1163 PVOID Key; 1164 DWORD LineNumber; 1165 PWSTR FileName; 1166 DWORD Address; 1167 } IMAGEHLP_LINEW, *PIMAGEHLP_LINEW; 1168 #endif 1169 typedef struct _IMAGEHLP_LINEW64 1170 { 1171 DWORD SizeOfStruct; 1172 PVOID Key; 1173 DWORD LineNumber; 1174 PWSTR FileName; 1175 DWORD64 Address; 1176 } IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64; 1177 #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) 1178 #define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64 1179 #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 1180 #else 1181 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD 1182 { 1183 DWORD SizeOfStruct; 1184 DWORD BaseOfImage; 1185 DWORD CheckSum; 1186 DWORD TimeDateStamp; 1187 CHAR FileName[MAX_PATH]; 1188 BOOLEAN Reparse; 1189 HANDLE hFile; 1190 } IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD; 1191 #endif 1192 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 1193 { 1194 DWORD SizeOfStruct; 1195 DWORD64 BaseOfImage; 1196 DWORD CheckSum; 1197 DWORD TimeDateStamp; 1198 CHAR FileName[MAX_PATH]; 1199 BOOLEAN Reparse; 1200 HANDLE hFile; 1201 DWORD Flags; 1202 } IMAGEHLP_DEFERRED_SYMBOL_LOAD64, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD64; 1203 typedef struct API_VERSION 1204 { 1205 USHORT MajorVersion; 1206 USHORT MinorVersion; 1207 USHORT Revision; 1208 USHORT Reserved; 1209 } API_VERSION, *LPAPI_VERSION; 1210 1211 // cvconst.h 1212 /* symbols & types enumeration */ 1213 enum SymTagEnum 1214 { 1215 SymTagNull, 1216 SymTagExe, 1217 SymTagCompiland, 1218 SymTagCompilandDetails, 1219 SymTagCompilandEnv, 1220 SymTagFunction, 1221 SymTagBlock, 1222 SymTagData, 1223 SymTagAnnotation, 1224 SymTagLabel, 1225 SymTagPublicSymbol, 1226 SymTagUDT, 1227 SymTagEnum, 1228 SymTagFunctionType, 1229 SymTagPointerType, 1230 SymTagArrayType, 1231 SymTagBaseType, 1232 SymTagTypedef, 1233 SymTagBaseClass, 1234 SymTagFriend, 1235 SymTagFunctionArgType, 1236 SymTagFuncDebugStart, 1237 SymTagFuncDebugEnd, 1238 SymTagUsingNamespace, 1239 SymTagVTableShape, 1240 SymTagVTable, 1241 SymTagCustom, 1242 SymTagThunk, 1243 SymTagCustomType, 1244 SymTagManagedType, 1245 SymTagDimension, 1246 SymTagMax 1247 }; 1248 1249 enum BasicType 1250 { 1251 btNoType = 0, 1252 btVoid = 1, 1253 btChar = 2, 1254 btWChar = 3, 1255 btInt = 6, 1256 btUInt = 7, 1257 btFloat = 8, 1258 btBCD = 9, 1259 btBool = 10, 1260 btLong = 13, 1261 btULong = 14, 1262 btCurrency = 25, 1263 btDate = 26, 1264 btVariant = 27, 1265 btComplex = 28, 1266 btBit = 29, 1267 btBSTR = 30, 1268 btHresult = 31, 1269 }; 1270 1271 /* kind of UDT */ 1272 enum UdtKind 1273 { 1274 UdtStruct, 1275 UdtClass, 1276 UdtUnion 1277 }; 1278 1279 /* kind of SymTagData */ 1280 enum DataKind 1281 { 1282 DataIsUnknown, 1283 DataIsLocal, 1284 DataIsStaticLocal, 1285 DataIsParam, 1286 DataIsObjectPtr, 1287 DataIsFileStatic, 1288 DataIsGlobal, 1289 DataIsMember, 1290 DataIsStaticMember, 1291 DataIsConstant 1292 }; 1293 1294 /* values for registers (on different CPUs) */ 1295 enum CV_HREG_e 1296 { 1297 /* those values are common to all supported CPUs (and CPU independent) */ 1298 CV_ALLREG_ERR = 30000, 1299 CV_ALLREG_TEB = 30001, 1300 CV_ALLREG_TIMER = 30002, 1301 CV_ALLREG_EFAD1 = 30003, 1302 CV_ALLREG_EFAD2 = 30004, 1303 CV_ALLREG_EFAD3 = 30005, 1304 CV_ALLREG_VFRAME = 30006, 1305 CV_ALLREG_HANDLE = 30007, 1306 CV_ALLREG_PARAMS = 30008, 1307 CV_ALLREG_LOCALS = 30009, 1308 CV_ALLREG_TID = 30010, 1309 CV_ALLREG_ENV = 30011, 1310 CV_ALLREG_CMDLN = 30012, 1311 1312 /* Intel x86 CPU */ 1313 CV_REG_NONE = 0, 1314 CV_REG_AL = 1, 1315 CV_REG_CL = 2, 1316 CV_REG_DL = 3, 1317 CV_REG_BL = 4, 1318 CV_REG_AH = 5, 1319 CV_REG_CH = 6, 1320 CV_REG_DH = 7, 1321 CV_REG_BH = 8, 1322 CV_REG_AX = 9, 1323 CV_REG_CX = 10, 1324 CV_REG_DX = 11, 1325 CV_REG_BX = 12, 1326 CV_REG_SP = 13, 1327 CV_REG_BP = 14, 1328 CV_REG_SI = 15, 1329 CV_REG_DI = 16, 1330 CV_REG_EAX = 17, 1331 CV_REG_ECX = 18, 1332 CV_REG_EDX = 19, 1333 CV_REG_EBX = 20, 1334 CV_REG_ESP = 21, 1335 CV_REG_EBP = 22, 1336 CV_REG_ESI = 23, 1337 CV_REG_EDI = 24, 1338 CV_REG_ES = 25, 1339 CV_REG_CS = 26, 1340 CV_REG_SS = 27, 1341 CV_REG_DS = 28, 1342 CV_REG_FS = 29, 1343 CV_REG_GS = 30, 1344 CV_REG_IP = 31, 1345 CV_REG_FLAGS = 32, 1346 CV_REG_EIP = 33, 1347 CV_REG_EFLAGS = 34, 1348 1349 /* <pcode> */ 1350 CV_REG_TEMP = 40, 1351 CV_REG_TEMPH = 41, 1352 CV_REG_QUOTE = 42, 1353 CV_REG_PCDR3 = 43, /* this includes PCDR4 to PCDR7 */ 1354 CV_REG_CR0 = 80, /* this includes CR1 to CR4 */ 1355 CV_REG_DR0 = 90, /* this includes DR1 to DR7 */ 1356 /* </pcode> */ 1357 1358 CV_REG_GDTR = 110, 1359 CV_REG_GDTL = 111, 1360 CV_REG_IDTR = 112, 1361 CV_REG_IDTL = 113, 1362 CV_REG_LDTR = 114, 1363 CV_REG_TR = 115, 1364 1365 CV_REG_PSEUDO1 = 116, /* this includes Pseudo02 to Pseudo09 */ 1366 CV_REG_ST0 = 128, /* this includes ST1 to ST7 */ 1367 CV_REG_CTRL = 136, 1368 CV_REG_STAT = 137, 1369 CV_REG_TAG = 138, 1370 CV_REG_FPIP = 139, 1371 CV_REG_FPCS = 140, 1372 CV_REG_FPDO = 141, 1373 CV_REG_FPDS = 142, 1374 CV_REG_ISEM = 143, 1375 CV_REG_FPEIP = 144, 1376 CV_REG_FPEDO = 145, 1377 CV_REG_MM0 = 146, /* this includes MM1 to MM7 */ 1378 CV_REG_XMM0 = 154, /* this includes XMM1 to XMM7 */ 1379 CV_REG_XMM00 = 162, 1380 CV_REG_XMM0L = 194, /* this includes XMM1L to XMM7L */ 1381 CV_REG_XMM0H = 202, /* this includes XMM1H to XMM7H */ 1382 CV_REG_MXCSR = 211, 1383 CV_REG_EDXEAX = 212, 1384 CV_REG_EMM0L = 220, 1385 CV_REG_EMM0H = 228, 1386 CV_REG_MM00 = 236, 1387 CV_REG_MM01 = 237, 1388 CV_REG_MM10 = 238, 1389 CV_REG_MM11 = 239, 1390 CV_REG_MM20 = 240, 1391 CV_REG_MM21 = 241, 1392 CV_REG_MM30 = 242, 1393 CV_REG_MM31 = 243, 1394 CV_REG_MM40 = 244, 1395 CV_REG_MM41 = 245, 1396 CV_REG_MM50 = 246, 1397 CV_REG_MM51 = 247, 1398 CV_REG_MM60 = 248, 1399 CV_REG_MM61 = 249, 1400 CV_REG_MM70 = 250, 1401 CV_REG_MM71 = 251, 1402 1403 CV_REG_YMM0 = 252, /* this includes YMM1 to YMM7 */ 1404 CV_REG_YMM0H = 260, /* this includes YMM1H to YMM7H */ 1405 CV_REG_YMM0I0 = 268, /* this includes YMM0I1 to YMM0I3 */ 1406 CV_REG_YMM1I0 = 272, /* this includes YMM1I1 to YMM1I3 */ 1407 CV_REG_YMM2I0 = 276, /* this includes YMM2I1 to YMM2I3 */ 1408 CV_REG_YMM3I0 = 280, /* this includes YMM3I1 to YMM3I3 */ 1409 CV_REG_YMM4I0 = 284, /* this includes YMM4I1 to YMM4I3 */ 1410 CV_REG_YMM5I0 = 288, /* this includes YMM5I1 to YMM5I3 */ 1411 CV_REG_YMM6I0 = 292, /* this includes YMM6I1 to YMM6I3 */ 1412 CV_REG_YMM7I0 = 296, /* this includes YMM7I1 to YMM7I3 */ 1413 CV_REG_YMM0F0 = 300, /* this includes YMM0F1 to YMM0F7 */ 1414 CV_REG_YMM1F0 = 308, /* this includes YMM1F1 to YMM1F7 */ 1415 CV_REG_YMM2F0 = 316, /* this includes YMM2F1 to YMM2F7 */ 1416 CV_REG_YMM3F0 = 324, /* this includes YMM3F1 to YMM3F7 */ 1417 CV_REG_YMM4F0 = 332, /* this includes YMM4F1 to YMM4F7 */ 1418 CV_REG_YMM5F0 = 340, /* this includes YMM5F1 to YMM5F7 */ 1419 CV_REG_YMM6F0 = 348, /* this includes YMM6F1 to YMM6F7 */ 1420 CV_REG_YMM7F0 = 356, /* this includes YMM7F1 to YMM7F7 */ 1421 CV_REG_YMM0D0 = 364, /* this includes YMM0D1 to YMM0D3 */ 1422 CV_REG_YMM1D0 = 368, /* this includes YMM1D1 to YMM1D3 */ 1423 CV_REG_YMM2D0 = 372, /* this includes YMM2D1 to YMM2D3 */ 1424 CV_REG_YMM3D0 = 376, /* this includes YMM3D1 to YMM3D3 */ 1425 CV_REG_YMM4D0 = 380, /* this includes YMM4D1 to YMM4D3 */ 1426 CV_REG_YMM5D0 = 384, /* this includes YMM5D1 to YMM5D3 */ 1427 CV_REG_YMM6D0 = 388, /* this includes YMM6D1 to YMM6D3 */ 1428 CV_REG_YMM7D0 = 392, /* this includes YMM7D1 to YMM7D3 */ 1429 1430 /* Motorola 68K CPU */ 1431 CV_R68_D0 = 0, /* this includes D1 to D7 too */ 1432 CV_R68_A0 = 8, /* this includes A1 to A7 too */ 1433 CV_R68_CCR = 16, 1434 CV_R68_SR = 17, 1435 CV_R68_USP = 18, 1436 CV_R68_MSP = 19, 1437 CV_R68_SFC = 20, 1438 CV_R68_DFC = 21, 1439 CV_R68_CACR = 22, 1440 CV_R68_VBR = 23, 1441 CV_R68_CAAR = 24, 1442 CV_R68_ISP = 25, 1443 CV_R68_PC = 26, 1444 CV_R68_FPCR = 28, 1445 CV_R68_FPSR = 29, 1446 CV_R68_FPIAR = 30, 1447 CV_R68_FP0 = 32, /* this includes FP1 to FP7 */ 1448 CV_R68_MMUSR030 = 41, 1449 CV_R68_MMUSR = 42, 1450 CV_R68_URP = 43, 1451 CV_R68_DTT0 = 44, 1452 CV_R68_DTT1 = 45, 1453 CV_R68_ITT0 = 46, 1454 CV_R68_ITT1 = 47, 1455 CV_R68_PSR = 51, 1456 CV_R68_PCSR = 52, 1457 CV_R68_VAL = 53, 1458 CV_R68_CRP = 54, 1459 CV_R68_SRP = 55, 1460 CV_R68_DRP = 56, 1461 CV_R68_TC = 57, 1462 CV_R68_AC = 58, 1463 CV_R68_SCC = 59, 1464 CV_R68_CAL = 60, 1465 CV_R68_TT0 = 61, 1466 CV_R68_TT1 = 62, 1467 CV_R68_BAD0 = 64, /* this includes BAD1 to BAD7 */ 1468 CV_R68_BAC0 = 72, /* this includes BAC1 to BAC7 */ 1469 1470 /* MIPS 4000 CPU */ 1471 CV_M4_NOREG = CV_REG_NONE, 1472 CV_M4_IntZERO = 10, 1473 CV_M4_IntAT = 11, 1474 CV_M4_IntV0 = 12, 1475 CV_M4_IntV1 = 13, 1476 CV_M4_IntA0 = 14, /* this includes IntA1 to IntA3 */ 1477 CV_M4_IntT0 = 18, /* this includes IntT1 to IntT7 */ 1478 CV_M4_IntS0 = 26, /* this includes IntS1 to IntS7 */ 1479 CV_M4_IntT8 = 34, 1480 CV_M4_IntT9 = 35, 1481 CV_M4_IntKT0 = 36, 1482 CV_M4_IntKT1 = 37, 1483 CV_M4_IntGP = 38, 1484 CV_M4_IntSP = 39, 1485 CV_M4_IntS8 = 40, 1486 CV_M4_IntRA = 41, 1487 CV_M4_IntLO = 42, 1488 CV_M4_IntHI = 43, 1489 CV_M4_Fir = 50, 1490 CV_M4_Psr = 51, 1491 CV_M4_FltF0 = 60, /* this includes FltF1 to Flt31 */ 1492 CV_M4_FltFsr = 92, 1493 1494 /* Alpha AXP CPU */ 1495 CV_ALPHA_NOREG = CV_REG_NONE, 1496 CV_ALPHA_FltF0 = 10, /* this includes FltF1 to FltF31 */ 1497 CV_ALPHA_IntV0 = 42, 1498 CV_ALPHA_IntT0 = 43, /* this includes T1 to T7 */ 1499 CV_ALPHA_IntS0 = 51, /* this includes S1 to S5 */ 1500 CV_ALPHA_IntFP = 57, 1501 CV_ALPHA_IntA0 = 58, /* this includes A1 to A5 */ 1502 CV_ALPHA_IntT8 = 64, 1503 CV_ALPHA_IntT9 = 65, 1504 CV_ALPHA_IntT10 = 66, 1505 CV_ALPHA_IntT11 = 67, 1506 CV_ALPHA_IntRA = 68, 1507 CV_ALPHA_IntT12 = 69, 1508 CV_ALPHA_IntAT = 70, 1509 CV_ALPHA_IntGP = 71, 1510 CV_ALPHA_IntSP = 72, 1511 CV_ALPHA_IntZERO = 73, 1512 CV_ALPHA_Fpcr = 74, 1513 CV_ALPHA_Fir = 75, 1514 CV_ALPHA_Psr = 76, 1515 CV_ALPHA_FltFsr = 77, 1516 CV_ALPHA_SoftFpcr = 78, 1517 1518 /* Motorola & IBM PowerPC CPU */ 1519 CV_PPC_GPR0 = 1, /* this includes GPR1 to GPR31 */ 1520 CV_PPC_CR = 33, 1521 CV_PPC_CR0 = 34, /* this includes CR1 to CR7 */ 1522 CV_PPC_FPR0 = 42, /* this includes FPR1 to FPR31 */ 1523 1524 CV_PPC_FPSCR = 74, 1525 CV_PPC_MSR = 75, 1526 CV_PPC_SR0 = 76, /* this includes SR1 to SR15 */ 1527 CV_PPC_PC = 99, 1528 CV_PPC_MQ = 100, 1529 CV_PPC_XER = 101, 1530 CV_PPC_RTCU = 104, 1531 CV_PPC_RTCL = 105, 1532 CV_PPC_LR = 108, 1533 CV_PPC_CTR = 109, 1534 CV_PPC_COMPARE = 110, 1535 CV_PPC_COUNT = 111, 1536 CV_PPC_DSISR = 118, 1537 CV_PPC_DAR = 119, 1538 CV_PPC_DEC = 122, 1539 CV_PPC_SDR1 = 125, 1540 CV_PPC_SRR0 = 126, 1541 CV_PPC_SRR1 = 127, 1542 CV_PPC_SPRG0 = 372, /* this includes SPRG1 to SPRG3 */ 1543 CV_PPC_ASR = 280, 1544 CV_PPC_EAR = 382, 1545 CV_PPC_PVR = 287, 1546 CV_PPC_BAT0U = 628, 1547 CV_PPC_BAT0L = 629, 1548 CV_PPC_BAT1U = 630, 1549 CV_PPC_BAT1L = 631, 1550 CV_PPC_BAT2U = 632, 1551 CV_PPC_BAT2L = 633, 1552 CV_PPC_BAT3U = 634, 1553 CV_PPC_BAT3L = 635, 1554 CV_PPC_DBAT0U = 636, 1555 CV_PPC_DBAT0L = 637, 1556 CV_PPC_DBAT1U = 638, 1557 CV_PPC_DBAT1L = 639, 1558 CV_PPC_DBAT2U = 640, 1559 CV_PPC_DBAT2L = 641, 1560 CV_PPC_DBAT3U = 642, 1561 CV_PPC_DBAT3L = 643, 1562 CV_PPC_PMR0 = 1044, /* this includes PMR1 to PMR15 */ 1563 CV_PPC_DMISS = 1076, 1564 CV_PPC_DCMP = 1077, 1565 CV_PPC_HASH1 = 1078, 1566 CV_PPC_HASH2 = 1079, 1567 CV_PPC_IMISS = 1080, 1568 CV_PPC_ICMP = 1081, 1569 CV_PPC_RPA = 1082, 1570 CV_PPC_HID0 = 1108, /* this includes HID1 to HID15 */ 1571 1572 /* Java */ 1573 CV_JAVA_PC = 1, 1574 1575 /* Hitachi SH3 CPU */ 1576 CV_SH3_NOREG = CV_REG_NONE, 1577 CV_SH3_IntR0 = 10, /* this include R1 to R13 */ 1578 CV_SH3_IntFp = 24, 1579 CV_SH3_IntSp = 25, 1580 CV_SH3_Gbr = 38, 1581 CV_SH3_Pr = 39, 1582 CV_SH3_Mach = 40, 1583 CV_SH3_Macl = 41, 1584 CV_SH3_Pc = 50, 1585 CV_SH3_Sr = 51, 1586 CV_SH3_BarA = 60, 1587 CV_SH3_BasrA = 61, 1588 CV_SH3_BamrA = 62, 1589 CV_SH3_BbrA = 63, 1590 CV_SH3_BarB = 64, 1591 CV_SH3_BasrB = 65, 1592 CV_SH3_BamrB = 66, 1593 CV_SH3_BbrB = 67, 1594 CV_SH3_BdrB = 68, 1595 CV_SH3_BdmrB = 69, 1596 CV_SH3_Brcr = 70, 1597 CV_SH_Fpscr = 75, 1598 CV_SH_Fpul = 76, 1599 CV_SH_FpR0 = 80, /* this includes FpR1 to FpR15 */ 1600 CV_SH_XFpR0 = 96, /* this includes XFpR1 to XXFpR15 */ 1601 1602 /* ARM CPU */ 1603 CV_ARM_NOREG = CV_REG_NONE, 1604 CV_ARM_R0 = 10, /* this includes R1 to R12 */ 1605 CV_ARM_SP = 23, 1606 CV_ARM_LR = 24, 1607 CV_ARM_PC = 25, 1608 CV_ARM_CPSR = 26, 1609 CV_ARM_ACC0 = 27, 1610 CV_ARM_FPSCR = 40, 1611 CV_ARM_FPEXC = 41, 1612 CV_ARM_FS0 = 50, /* this includes FS1 to FS31 */ 1613 CV_ARM_FPEXTRA0 = 90, /* this includes FPEXTRA1 to FPEXTRA7 */ 1614 CV_ARM_WR0 = 128, /* this includes WR1 to WR15 */ 1615 CV_ARM_WCID = 144, 1616 CV_ARM_WCON = 145, 1617 CV_ARM_WCSSF = 146, 1618 CV_ARM_WCASF = 147, 1619 CV_ARM_WC4 = 148, 1620 CV_ARM_WC5 = 149, 1621 CV_ARM_WC6 = 150, 1622 CV_ARM_WC7 = 151, 1623 CV_ARM_WCGR0 = 152, /* this includes WCGR1 to WCGR3 */ 1624 CV_ARM_WC12 = 156, 1625 CV_ARM_WC13 = 157, 1626 CV_ARM_WC14 = 158, 1627 CV_ARM_WC15 = 159, 1628 CV_ARM_FS32 = 200, /* this includes FS33 to FS63 */ 1629 CV_ARM_ND0 = 300, /* this includes ND1 to ND31 */ 1630 CV_ARM_NQ0 = 400, /* this includes NQ1 to NQ15 */ 1631 1632 /* Intel IA64 CPU */ 1633 CV_IA64_NOREG = CV_REG_NONE, 1634 CV_IA64_Br0 = 512, /* this includes Br1 to Br7 */ 1635 CV_IA64_P0 = 704, /* this includes P1 to P63 */ 1636 CV_IA64_Preds = 768, 1637 CV_IA64_IntH0 = 832, /* this includes H1 to H15 */ 1638 CV_IA64_Ip = 1016, 1639 CV_IA64_Umask = 1017, 1640 CV_IA64_Cfm = 1018, 1641 CV_IA64_Psr = 1019, 1642 CV_IA64_Nats = 1020, 1643 CV_IA64_Nats2 = 1021, 1644 CV_IA64_Nats3 = 1022, 1645 CV_IA64_IntR0 = 1024, /* this includes R1 to R127 */ 1646 CV_IA64_FltF0 = 2048, /* this includes FltF1 to FltF127 */ 1647 /* some IA64 registers missing */ 1648 1649 /* TriCore CPU */ 1650 CV_TRI_NOREG = CV_REG_NONE, 1651 CV_TRI_D0 = 10, /* includes D1 to D15 */ 1652 CV_TRI_A0 = 26, /* includes A1 to A15 */ 1653 CV_TRI_E0 = 42, 1654 CV_TRI_E2 = 43, 1655 CV_TRI_E4 = 44, 1656 CV_TRI_E6 = 45, 1657 CV_TRI_E8 = 46, 1658 CV_TRI_E10 = 47, 1659 CV_TRI_E12 = 48, 1660 CV_TRI_E14 = 49, 1661 CV_TRI_EA0 = 50, 1662 CV_TRI_EA2 = 51, 1663 CV_TRI_EA4 = 52, 1664 CV_TRI_EA6 = 53, 1665 CV_TRI_EA8 = 54, 1666 CV_TRI_EA10 = 55, 1667 CV_TRI_EA12 = 56, 1668 CV_TRI_EA14 = 57, 1669 CV_TRI_PSW = 58, 1670 CV_TRI_PCXI = 59, 1671 CV_TRI_PC = 60, 1672 CV_TRI_FCX = 61, 1673 CV_TRI_LCX = 62, 1674 CV_TRI_ISP = 63, 1675 CV_TRI_ICR = 64, 1676 CV_TRI_BIV = 65, 1677 CV_TRI_BTV = 66, 1678 CV_TRI_SYSCON = 67, 1679 CV_TRI_DPRx_0 = 68, /* includes DPRx_1 to DPRx_3 */ 1680 CV_TRI_CPRx_0 = 68, /* includes CPRx_1 to CPRx_3 */ 1681 CV_TRI_DPMx_0 = 68, /* includes DPMx_1 to DPMx_3 */ 1682 CV_TRI_CPMx_0 = 68, /* includes CPMx_1 to CPMx_3 */ 1683 CV_TRI_DBGSSR = 72, 1684 CV_TRI_EXEVT = 73, 1685 CV_TRI_SWEVT = 74, 1686 CV_TRI_CREVT = 75, 1687 CV_TRI_TRnEVT = 76, 1688 CV_TRI_MMUCON = 77, 1689 CV_TRI_ASI = 78, 1690 CV_TRI_TVA = 79, 1691 CV_TRI_TPA = 80, 1692 CV_TRI_TPX = 81, 1693 CV_TRI_TFA = 82, 1694 1695 /* AM33 (and the likes) CPU */ 1696 CV_AM33_NOREG = CV_REG_NONE, 1697 CV_AM33_E0 = 10, /* this includes E1 to E7 */ 1698 CV_AM33_A0 = 20, /* this includes A1 to A3 */ 1699 CV_AM33_D0 = 30, /* this includes D1 to D3 */ 1700 CV_AM33_FS0 = 40, /* this includes FS1 to FS31 */ 1701 CV_AM33_SP = 80, 1702 CV_AM33_PC = 81, 1703 CV_AM33_MDR = 82, 1704 CV_AM33_MDRQ = 83, 1705 CV_AM33_MCRH = 84, 1706 CV_AM33_MCRL = 85, 1707 CV_AM33_MCVF = 86, 1708 CV_AM33_EPSW = 87, 1709 CV_AM33_FPCR = 88, 1710 CV_AM33_LIR = 89, 1711 CV_AM33_LAR = 90, 1712 1713 /* Mitsubishi M32R CPU */ 1714 CV_M32R_NOREG = CV_REG_NONE, 1715 CV_M32R_R0 = 10, /* this includes R1 to R11 */ 1716 CV_M32R_R12 = 22, 1717 CV_M32R_R13 = 23, 1718 CV_M32R_R14 = 24, 1719 CV_M32R_R15 = 25, 1720 CV_M32R_PSW = 26, 1721 CV_M32R_CBR = 27, 1722 CV_M32R_SPI = 28, 1723 CV_M32R_SPU = 29, 1724 CV_M32R_SPO = 30, 1725 CV_M32R_BPC = 31, 1726 CV_M32R_ACHI = 32, 1727 CV_M32R_ACLO = 33, 1728 CV_M32R_PC = 34, 1729 1730 /* AMD/Intel x86_64 CPU */ 1731 CV_AMD64_NONE = CV_REG_NONE, 1732 CV_AMD64_AL = CV_REG_AL, 1733 CV_AMD64_CL = CV_REG_CL, 1734 CV_AMD64_DL = CV_REG_DL, 1735 CV_AMD64_BL = CV_REG_BL, 1736 CV_AMD64_AH = CV_REG_AH, 1737 CV_AMD64_CH = CV_REG_CH, 1738 CV_AMD64_DH = CV_REG_DH, 1739 CV_AMD64_BH = CV_REG_BH, 1740 CV_AMD64_AX = CV_REG_AX, 1741 CV_AMD64_CX = CV_REG_CX, 1742 CV_AMD64_DX = CV_REG_DX, 1743 CV_AMD64_BX = CV_REG_BX, 1744 CV_AMD64_SP = CV_REG_SP, 1745 CV_AMD64_BP = CV_REG_BP, 1746 CV_AMD64_SI = CV_REG_SI, 1747 CV_AMD64_DI = CV_REG_DI, 1748 CV_AMD64_EAX = CV_REG_EAX, 1749 CV_AMD64_ECX = CV_REG_ECX, 1750 CV_AMD64_EDX = CV_REG_EDX, 1751 CV_AMD64_EBX = CV_REG_EBX, 1752 CV_AMD64_ESP = CV_REG_ESP, 1753 CV_AMD64_EBP = CV_REG_EBP, 1754 CV_AMD64_ESI = CV_REG_ESI, 1755 CV_AMD64_EDI = CV_REG_EDI, 1756 CV_AMD64_ES = CV_REG_ES, 1757 CV_AMD64_CS = CV_REG_CS, 1758 CV_AMD64_SS = CV_REG_SS, 1759 CV_AMD64_DS = CV_REG_DS, 1760 CV_AMD64_FS = CV_REG_FS, 1761 CV_AMD64_GS = CV_REG_GS, 1762 CV_AMD64_FLAGS = CV_REG_FLAGS, 1763 CV_AMD64_RIP = CV_REG_EIP, 1764 CV_AMD64_EFLAGS = CV_REG_EFLAGS, 1765 1766 /* <pcode> */ 1767 CV_AMD64_TEMP = CV_REG_TEMP, 1768 CV_AMD64_TEMPH = CV_REG_TEMPH, 1769 CV_AMD64_QUOTE = CV_REG_QUOTE, 1770 CV_AMD64_PCDR3 = CV_REG_PCDR3, /* this includes PCDR4 to PCDR7 */ 1771 CV_AMD64_CR0 = CV_REG_CR0, /* this includes CR1 to CR4 */ 1772 CV_AMD64_DR0 = CV_REG_DR0, /* this includes DR1 to DR7 */ 1773 /* </pcode> */ 1774 1775 CV_AMD64_GDTR = CV_REG_GDTR, 1776 CV_AMD64_GDTL = CV_REG_GDTL, 1777 CV_AMD64_IDTR = CV_REG_IDTR, 1778 CV_AMD64_IDTL = CV_REG_IDTL, 1779 CV_AMD64_LDTR = CV_REG_LDTR, 1780 CV_AMD64_TR = CV_REG_TR, 1781 1782 CV_AMD64_PSEUDO1 = CV_REG_PSEUDO1, /* this includes Pseudo02 to Pseudo09 */ 1783 CV_AMD64_ST0 = CV_REG_ST0, /* this includes ST1 to ST7 */ 1784 CV_AMD64_CTRL = CV_REG_CTRL, 1785 CV_AMD64_STAT = CV_REG_STAT, 1786 CV_AMD64_TAG = CV_REG_TAG, 1787 CV_AMD64_FPIP = CV_REG_FPIP, 1788 CV_AMD64_FPCS = CV_REG_FPCS, 1789 CV_AMD64_FPDO = CV_REG_FPDO, 1790 CV_AMD64_FPDS = CV_REG_FPDS, 1791 CV_AMD64_ISEM = CV_REG_ISEM, 1792 CV_AMD64_FPEIP = CV_REG_FPEIP, 1793 CV_AMD64_FPEDO = CV_REG_FPEDO, 1794 CV_AMD64_MM0 = CV_REG_MM0, /* this includes MM1 to MM7 */ 1795 CV_AMD64_XMM0 = CV_REG_XMM0, /* this includes XMM1 to XMM7 */ 1796 CV_AMD64_XMM00 = CV_REG_XMM00, 1797 CV_AMD64_XMM0L = CV_REG_XMM0L, /* this includes XMM1L to XMM7L */ 1798 CV_AMD64_XMM0H = CV_REG_XMM0H, /* this includes XMM1H to XMM7H */ 1799 CV_AMD64_MXCSR = CV_REG_MXCSR, 1800 CV_AMD64_EDXEAX = CV_REG_EDXEAX, 1801 CV_AMD64_EMM0L = CV_REG_EMM0L, 1802 CV_AMD64_EMM0H = CV_REG_EMM0H, 1803 CV_AMD64_MM00 = CV_REG_MM00, 1804 CV_AMD64_MM01 = CV_REG_MM01, 1805 CV_AMD64_MM10 = CV_REG_MM10, 1806 CV_AMD64_MM11 = CV_REG_MM11, 1807 CV_AMD64_MM20 = CV_REG_MM20, 1808 CV_AMD64_MM21 = CV_REG_MM21, 1809 CV_AMD64_MM30 = CV_REG_MM30, 1810 CV_AMD64_MM31 = CV_REG_MM31, 1811 CV_AMD64_MM40 = CV_REG_MM40, 1812 CV_AMD64_MM41 = CV_REG_MM41, 1813 CV_AMD64_MM50 = CV_REG_MM50, 1814 CV_AMD64_MM51 = CV_REG_MM51, 1815 CV_AMD64_MM60 = CV_REG_MM60, 1816 CV_AMD64_MM61 = CV_REG_MM61, 1817 CV_AMD64_MM70 = CV_REG_MM70, 1818 CV_AMD64_MM71 = CV_REG_MM71, 1819 1820 CV_AMD64_XMM8 = 252, /* this includes XMM9 to XMM15 */ 1821 1822 CV_AMD64_RAX = 328, 1823 CV_AMD64_RBX = 329, 1824 CV_AMD64_RCX = 330, 1825 CV_AMD64_RDX = 331, 1826 CV_AMD64_RSI = 332, 1827 CV_AMD64_RDI = 333, 1828 CV_AMD64_RBP = 334, 1829 CV_AMD64_RSP = 335, 1830 1831 CV_AMD64_R8 = 336, 1832 CV_AMD64_R9 = 337, 1833 CV_AMD64_R10 = 338, 1834 CV_AMD64_R11 = 339, 1835 CV_AMD64_R12 = 340, 1836 CV_AMD64_R13 = 341, 1837 CV_AMD64_R14 = 342, 1838 CV_AMD64_R15 = 343, 1839 1840 /* Wine extension */ 1841 CV_ARM64_NOREG = CV_REG_NONE, 1842 CV_ARM64_X0 = 10, /* this includes X0 to X30 */ 1843 CV_ARM64_SP = 41, 1844 CV_ARM64_PC = 42, 1845 CV_ARM64_PSTATE = 43, 1846 }; 1847 1848 typedef enum 1849 { 1850 THUNK_ORDINAL_NOTYPE, 1851 THUNK_ORDINAL_ADJUSTOR, 1852 THUNK_ORDINAL_VCALL, 1853 THUNK_ORDINAL_PCODE, 1854 THUNK_ORDINAL_LOAD 1855 } THUNK_ORDINAL; 1856 1857 typedef enum CV_call_e 1858 { 1859 CV_CALL_NEAR_C, 1860 CV_CALL_FAR_C, 1861 CV_CALL_NEAR_PASCAL, 1862 CV_CALL_FAR_PASCAL, 1863 CV_CALL_NEAR_FAST, 1864 CV_CALL_FAR_FAST, 1865 CV_CALL_SKIPPED, 1866 CV_CALL_NEAR_STD, 1867 CV_CALL_FAR_STD, 1868 CV_CALL_NEAR_SYS, 1869 CV_CALL_FAR_SYS, 1870 CV_CALL_THISCALL, 1871 CV_CALL_MIPSCALL, 1872 CV_CALL_GENERIC, 1873 CV_CALL_ALPHACALL, 1874 CV_CALL_PPCCALL, 1875 CV_CALL_SHCALL, 1876 CV_CALL_ARMCALL, 1877 CV_CALL_AM33CALL, 1878 CV_CALL_TRICALL, 1879 CV_CALL_SH5CALL, 1880 CV_CALL_M32RCALL, 1881 CV_CALL_RESERVED, 1882 } CV_call_e; 1883 1884 1885 // wtypes.h 1886 typedef LONG SCODE; 1887 typedef double DATE; 1888 typedef unsigned short VARTYPE; 1889 typedef union tagCY { 1890 struct { 1891 #ifdef WORDS_BIGENDIAN 1892 LONG Hi; 1893 ULONG Lo; 1894 #else 1895 ULONG Lo; 1896 LONG Hi; 1897 #endif 1898 } DUMMYSTRUCTNAME; 1899 LONGLONG int64; 1900 } CY; 1901 typedef struct tagDEC { 1902 USHORT wReserved; 1903 union { 1904 struct { 1905 BYTE scale; 1906 BYTE sign; 1907 } DUMMYSTRUCTNAME; 1908 USHORT signscale; 1909 } DUMMYUNIONNAME; 1910 ULONG Hi32; 1911 union { 1912 struct { 1913 #ifdef WORDS_BIGENDIAN 1914 ULONG Mid32; 1915 ULONG Lo32; 1916 #else 1917 ULONG Lo32; 1918 ULONG Mid32; 1919 #endif 1920 } DUMMYSTRUCTNAME1; 1921 ULONGLONG Lo64; 1922 } DUMMYUNIONNAME1; 1923 } DECIMAL; 1924 typedef short VARIANT_BOOL; 1925 typedef VARIANT_BOOL _VARIANT_BOOL; 1926 typedef WCHAR OLECHAR; 1927 typedef OLECHAR *BSTR; 1928 enum VARENUM { 1929 VT_EMPTY = 0, 1930 VT_NULL = 1, 1931 VT_I2 = 2, 1932 VT_I4 = 3, 1933 VT_R4 = 4, 1934 VT_R8 = 5, 1935 VT_CY = 6, 1936 VT_DATE = 7, 1937 VT_BSTR = 8, 1938 VT_DISPATCH = 9, 1939 VT_ERROR = 10, 1940 VT_BOOL = 11, 1941 VT_VARIANT = 12, 1942 VT_UNKNOWN = 13, 1943 VT_DECIMAL = 14, 1944 VT_I1 = 16, 1945 VT_UI1 = 17, 1946 VT_UI2 = 18, 1947 VT_UI4 = 19, 1948 VT_I8 = 20, 1949 VT_UI8 = 21, 1950 VT_INT = 22, 1951 VT_UINT = 23, 1952 VT_VOID = 24, 1953 VT_HRESULT = 25, 1954 VT_PTR = 26, 1955 VT_SAFEARRAY = 27, 1956 VT_CARRAY = 28, 1957 VT_USERDEFINED = 29, 1958 VT_LPSTR = 30, 1959 VT_LPWSTR = 31, 1960 VT_RECORD = 36, 1961 VT_INT_PTR = 37, 1962 VT_UINT_PTR = 38, 1963 VT_FILETIME = 64, 1964 VT_BLOB = 65, 1965 VT_STREAM = 66, 1966 VT_STORAGE = 67, 1967 VT_STREAMED_OBJECT = 68, 1968 VT_STORED_OBJECT = 69, 1969 VT_BLOB_OBJECT = 70, 1970 VT_CF = 71, 1971 VT_CLSID = 72, 1972 VT_VERSIONED_STREAM = 73, 1973 VT_BSTR_BLOB = 0xfff, 1974 VT_VECTOR = 0x1000, 1975 VT_ARRAY = 0x2000, 1976 VT_BYREF = 0x4000, 1977 VT_RESERVED = 0x8000, 1978 VT_ILLEGAL = 0xffff, 1979 VT_ILLEGALMASKED = 0xfff, 1980 VT_TYPEMASK = 0xfff 1981 }; 1982 1983 // oaidl.h 1984 typedef struct tagSAFEARRAYBOUND { 1985 ULONG cElements; 1986 LONG lLbound; 1987 } SAFEARRAYBOUND; 1988 typedef struct tagSAFEARRAY { 1989 USHORT cDims; 1990 USHORT fFeatures; 1991 ULONG cbElements; 1992 ULONG cLocks; 1993 PVOID pvData; 1994 SAFEARRAYBOUND rgsabound[1]; 1995 } SAFEARRAY; 1996 typedef SAFEARRAY *LPSAFEARRAY; 1997 1998 #if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION) 1999 #define __VARIANT_NAME_1 n1 2000 #define __VARIANT_NAME_2 n2 2001 #define __VARIANT_NAME_3 n3 2002 #define __VARIANT_NAME_4 brecVal 2003 #else 2004 #define __tagVARIANT 2005 #define __VARIANT_NAME_1 2006 #define __VARIANT_NAME_2 2007 #define __VARIANT_NAME_3 2008 #define __tagBRECORD 2009 #define __VARIANT_NAME_4 2010 #endif 2011 typedef struct tagVARIANT VARIANT; 2012 struct tagVARIANT { 2013 union { 2014 struct __tagVARIANT { 2015 VARTYPE vt; 2016 WORD wReserved1; 2017 WORD wReserved2; 2018 WORD wReserved3; 2019 union { 2020 signed char cVal; 2021 USHORT uiVal; 2022 ULONG ulVal; 2023 INT intVal; 2024 UINT uintVal; 2025 BYTE bVal; 2026 SHORT iVal; 2027 LONG lVal; 2028 FLOAT fltVal; 2029 DOUBLE dblVal; 2030 VARIANT_BOOL boolVal; 2031 SCODE scode; 2032 DATE date; 2033 BSTR bstrVal; 2034 CY cyVal; 2035 IUnknown *punkVal; 2036 IDispatch *pdispVal; 2037 SAFEARRAY *parray; 2038 LONGLONG llVal; 2039 ULONGLONG ullVal; 2040 signed char *pcVal; 2041 USHORT *puiVal; 2042 ULONG *pulVal; 2043 INT *pintVal; 2044 UINT *puintVal; 2045 BYTE *pbVal; 2046 SHORT *piVal; 2047 LONG *plVal; 2048 FLOAT *pfltVal; 2049 DOUBLE *pdblVal; 2050 VARIANT_BOOL *pboolVal; 2051 SCODE *pscode; 2052 DATE *pdate; 2053 BSTR *pbstrVal; 2054 VARIANT *pvarVal; 2055 PVOID byref; 2056 CY *pcyVal; 2057 DECIMAL *pdecVal; 2058 IUnknown **ppunkVal; 2059 IDispatch **ppdispVal; 2060 SAFEARRAY **pparray; 2061 LONGLONG *pllVal; 2062 ULONGLONG *pullVal; 2063 struct __tagBRECORD { 2064 PVOID pvRecord; 2065 IRecordInfo *pRecInfo; 2066 } __VARIANT_NAME_4; 2067 } __VARIANT_NAME_3; 2068 } __VARIANT_NAME_2; 2069 DECIMAL decVal; 2070 } __VARIANT_NAME_1; 2071 }; 2072 2073 typedef VARIANT *LPVARIANT; 2074 typedef VARIANT VARIANTARG; 2075 typedef VARIANTARG *LPVARIANTARG; 2076 2077 // wine/windef16.h 2078 typedef DWORD SEGPTR; 2079 2080 // wine/winbase16.h 2081 typedef struct _STACK32FRAME 2082 { 2083 DWORD restore_addr; /* 00 return address for restoring code selector */ 2084 DWORD codeselector; /* 04 code selector to restore */ 2085 EXCEPTION_REGISTRATION_RECORD frame; /* 08 Exception frame */ 2086 SEGPTR frame16; /* 10 16-bit frame from last CallFrom16() */ 2087 DWORD edi; /* 14 saved registers */ 2088 DWORD esi; /* 18 */ 2089 DWORD ebx; /* 1c */ 2090 DWORD ebp; /* 20 saved 32-bit frame pointer */ 2091 DWORD retaddr; /* 24 return address */ 2092 DWORD target; /* 28 target address / CONTEXT86 pointer */ 2093 DWORD nb_args; /* 2c number of 16-bit argument bytes */ 2094 } STACK32FRAME; 2095 2096 /* 16-bit stack layout after __wine_call_from_16() */ 2097 typedef struct _STACK16FRAME 2098 { 2099 STACK32FRAME *frame32; /* 00 32-bit frame from last CallTo16() */ 2100 DWORD edx; /* 04 saved registers */ 2101 DWORD ecx; /* 08 */ 2102 DWORD ebp; /* 0c */ 2103 WORD ds; /* 10 */ 2104 WORD es; /* 12 */ 2105 WORD fs; /* 14 */ 2106 WORD gs; /* 16 */ 2107 DWORD callfrom_ip; /* 18 callfrom tail IP */ 2108 DWORD module_cs; /* 1c module code segment */ 2109 DWORD relay; /* 20 relay function address */ 2110 WORD entry_ip; /* 22 entry point IP */ 2111 DWORD entry_point; /* 26 API entry point to call, reused as mutex count */ 2112 WORD bp; /* 2a 16-bit stack frame chain */ 2113 WORD ip; /* 2c return address */ 2114 WORD cs; /* 2e */ 2115 } STACK16FRAME; 2116