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