diff options
| author | Adam <you@example.com> | 2020-05-17 05:51:50 +0200 |
|---|---|---|
| committer | Adam <you@example.com> | 2020-05-17 05:51:50 +0200 |
| commit | e611b132f9b8abe35b362e5870b74bce94a1e58e (patch) | |
| tree | a5781d2ec0e085eeca33cf350cf878f2efea6fe5 /private/windbg/osdebug/include | |
| download | NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.tar NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.tar.gz NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.tar.bz2 NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.tar.lz NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.tar.xz NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.tar.zst NT4.0-e611b132f9b8abe35b362e5870b74bce94a1e58e.zip | |
Diffstat (limited to 'private/windbg/osdebug/include')
24 files changed, 8443 insertions, 0 deletions
diff --git a/private/windbg/osdebug/include/bpprotos.h b/private/windbg/osdebug/include/bpprotos.h new file mode 100644 index 000000000..532d6c97f --- /dev/null +++ b/private/windbg/osdebug/include/bpprotos.h @@ -0,0 +1,91 @@ +/*** + * + * Breakpoint Handler API + * + */ + +extern BPSTATUS PASCAL BPInit( void ); +extern BPSTATUS PASCAL BPTerm( void ); + +extern BPSTATUS PASCAL BPParse(HBPT FAR * pHbpt, char FAR * szBpt, char FAR * szMod, char FAR * szFile, HPID hPid); +extern BPSTATUS PASCAL BPBindHbpt( HBPT, CXF * ); + +extern BPSTATUS PASCAL BPAddToList( HBPT, int ); +extern BPSTATUS PASCAL BPChange( HBPT, int ); +extern BPSTATUS PASCAL BPDelete( HBPT ); +extern BPSTATUS PASCAL BPDeleteAll( VOID ); + +extern BPSTATUS PASCAL BPGetFinalHbpt( HBPT, HBPT FAR *); +extern BPSTATUS PASCAL BPNextHbpt( HBPT FAR *, UINT); +extern BPSTATUS PASCAL BPFormatHbpt( HBPT, char FAR *, UINT, UINT); + +extern BPSTATUS PASCAL BPCommit(void); +extern BPSTATUS PASCAL BPUnCommit(void); + +extern BPSTATUS PASCAL BPHighlightSourceFile( char *fname ); + +extern BPSTATUS PASCAL BPSetHpid(HBPT, HPID); +extern BPSTATUS PASCAL BPGetHpid(HBPT, HPID *); +extern BPSTATUS PASCAL BPGetIpid(HBPT, UINT *); +extern BPSTATUS PASCAL BPGetHtid(HBPT, HTID *); + +extern BPSTATUS PASCAL BPSetTmp(LPADDR, HPID, HTID, HBPT FAR *); +extern BPSTATUS PASCAL BPClearAllTmp(HPID, HTID); + +extern BPSTATUS PASCAL BPDisable(HBPT); +extern BPSTATUS PASCAL BPEnable(HBPT); + +extern BPSTATUS PASCAL BPHbptFromI(HBPT FAR *, UINT); + +extern BPSTATUS PASCAL BPHbptFromFileLine(char FAR *, UINT, HBPT FAR *); +extern BPSTATUS PASCAL BPHbptFromAddr(ADDR FAR *, HBPT FAR *); + +extern BPSTATUS PASCAL BPAddrFromHbpt(HBPT, ADDR FAR *); +extern BPSTATUS PASCAL BPIFromHbpt(UINT FAR *, HBPT); +extern BPSTATUS PASCAL BPFreeHbpt(HBPT); + +extern BPSTATUS PASCAL BPCheckHbpt(CXF, LPFNBPCALLBACK, HPID, HTID, DWORD); + +extern BPSTATUS PASCAL BPQueryBPTypeOfHbpt(HBPT, int FAR *); +extern BPSTATUS PASCAL BPQueryCmdOfHbpt(HBPT, char FAR *, UINT); +extern BPSTATUS PASCAL BPQueryLocationOfHbpt(HBPT, char FAR *, UINT); +extern BPSTATUS PASCAL BPQueryExprOfHbpt(HBPT, char FAR *, UINT); +extern BPSTATUS PASCAL BPQueryMemoryOfHbpt(HBPT, char FAR *, UINT); +extern BPSTATUS PASCAL BPQueryMemorySizeOfHbpt(HBPT, char FAR *, UINT); +extern BPSTATUS PASCAL BPQueryPassCntOfHbpt(HBPT, char FAR *, UINT); +extern BPSTATUS PASCAL BPQueryPassLeftOfHbpt(HBPT, char FAR *, UINT); +extern BPSTATUS PASCAL BPQueryProcessOfHbpt(HBPT, char FAR *, UINT); +extern BPSTATUS PASCAL BPQueryThreadOfHbpt(HBPT, char FAR *, UINT); +extern BPSTATUS PASCAL BPQueryMessageOfHbpt(HBPT, char FAR *, UINT); +extern BPSTATUS PASCAL BPUpdateMemory( ULONG ); +extern BPSTATUS PASCAL BPQueryHighlightLineOfHbpt( HBPT, UINT *); + +extern EESTATUS PASCAL BPADDRFromTM (PHTM, unsigned short FAR *, PADDR); + +extern LPSTR PASCAL BPShortenContext(LPSTR lpSrc, LPSTR lpDest); + +extern HMOD PASCAL BPFileNameToMod( char * FileName ); + +/* +** THe following are the set of callback routines used by the +** breakpoint engine +*/ + +#if 0 +extern BOOL PASCAL BPQuerySrcWinFls(FLS *); +#endif + +extern BOOL PASCAL BPCBBindHbpt( HBPT ); +extern BOOL PASCAL BPCBSetHighlight(char FAR *, UINT, BOOL, BOOL, WORD); +extern BOOL PASCAL BPCBSetUHighlight(char FAR *, UINT, BOOL, BOOL); +extern BOOL PASCAL BPCBGetSourceFromAddr(PADDR, char FAR *, int, int FAR *); + +extern BOOL PASCAL BPIsMarkedForDeletion( HBPT ); +extern BOOL PASCAL BPIsDisabled( HBPT ); +extern BOOL PASCAL BPIsInstantiated( HBPT ); +extern BOOL PASCAL BPUninstantiate( HBPT ); +extern BOOL PASCAL BPIsQuiet( HBPT ); +extern VOID PASCAL BPSetQuiet( HBPT ); +extern VOID PASCAL BPSegLoad( ULONG ); +extern BOOL PASCAL BPSymbolLoading( BOOL ); +extern BOOL PASCAL BPSymbolsMayBeAvailable( HBPT ); diff --git a/private/windbg/osdebug/include/bptypes.h b/private/windbg/osdebug/include/bptypes.h new file mode 100644 index 000000000..57f1fbd89 --- /dev/null +++ b/private/windbg/osdebug/include/bptypes.h @@ -0,0 +1,316 @@ +/*++ + +Copyright (c) 1992 Microsoft Corporation + +Module Name: + + Bptypes.h + +Abstract: + +Author: + + David J. Gilman (davegi) 04-May-1992 + +Environment: + + Win32, User Mode + +--*/ + +#if ! defined( _BPTYPES_ ) +#define _BPTYPES_ + +#include "eeapi.h" + +// Just to hide things +#define HBPI HLLE +#define hbpiNull hlleNull + +#define HBPT HLLE +#define hbptNull hlleNull + +typedef struct cpb FAR * _LPCBP; + +#ifdef LATER +// Types of breakpoints +#define BPCONTINUE 0 +#define BPBREAKPT 1 +#define BPTMP 2 +#define BPINTERNAL 3 +#define BPSKIPCALL 4 +#define BPDEADCHILD 5 +#define BPABORT 6 +#define BPUSERINT3 7 +#define BPDEADTHREAD 8 +#define BPNMI 9 + + +#define BRKPTOPCODE 0xCC +#define DPLBITS ((unsigned int) 0x3) + +#if DOS5 +#define SKIPBPUIFLAGS 7 +#else +#define SKIPBPUIFLAGS 3 +#endif // dos5 + +#endif // LATER + +#if 0 +typedef union bpf { + UINT flags; + struct { + UINT fBpCode : 1; // Is there a Code bp + UINT fBpData : 1; // Is there a watch/trace point + UINT fActive : 1; // Breakpoint is active + UINT fBPLoaded : 1; // is BRKPTOPCODE in the code + UINT fVirtual : 1; // This is a virtual bp + UINT fAmbig : 1; // This BP came from an ambiguous expression + UINT fPass : 1; // if a passcount was specified + UINT fUser : 1; // for use WITHIN a proc, up to you how to use + UINT fDlgActive : 1; // Dialog hold are for orignal fActive state + UINT fDlgMarkDel : 1; // This breakpoint has been marked for deletion + UINT fDlgMarkAdd : 1; // This breakpoint has been marked for addition + UINT BpType : 3; // The type of breakpoint +#if defined(WINDOWS3) || defined(DOS5) + UINT BpSubType : 2; +#endif + } f; +} BPF; + +#endif + +typedef union dpf { + UINT flags; + struct { + UINT fEmulate : 1; // If emulation is required + UINT fFuncBpSet : 1; // if a function breakpoint is set + UINT fTpFuncHit : 1; // When we hit a breakpoint set by tracepoint + UINT fFuncLoad : 1; // We must load the breakpoint value on function entry + UINT fEvalExpr : 1; // Is the expr not an lvalue + UINT fDataRange : 1; // if a datarange was specifed + UINT fBpRel : 1; // if a code range was specified + UINT fContext : 1; // if context checking is required + UINT fReg : 1; // if it is in a register + UINT fHighReg : 1; // if in the highbyte of reg + UINT fUser : 1; // for use WITHIN a proc, up to you how to use + UINT fHdwBrk : 1; // Is this a hardware bp + UINT HdwReg : 2; // The hardware reg used + } f; +} DPF; +typedef DPF FAR * PDPF; +#ifdef LATER + +#if defined(WINDOWS3) || defined(DOS5) +struct cbp; // for forward reference +#endif +#endif // LATER + +typedef struct dpi { + union { + struct { + ADDR DataAddr; // Data address to watch + } d; + struct { + ADDR BlkAddr; // the start address of the block + UOFFSET oEnd; // The end offset of the function + short oBp; // ofset from the bp + FRAME Frame; // the frame + } bp; + } u; + char * pValue; // pointer to the initial value + short iReg; // if in register, the reg index + USHORT cData; // Number of data items to watch + USHORT cbData; // Number of bytes in data item + HTM hTM; // a TM handle for the data breakpoint +} DPI; +typedef DPI * PDPI; + + +#if 0 + +typedef struct bpi { + BPF bpf; // flags + DPF dpf; // the data bp flags + int fLang; // the language type + unsigned char OpCode; // The orignal opcode + ADDR CodeAddr; // Code address of breakpoint + DPI * pdpi; // pointer to the DataBreakpoint +/* + * This defines a function callback mechanism which can be used to + * generalize the breakpoint facility. + * The messages and responses are defined earlier in this file. + */ + int (FAR *lpfnEval)(_LPCBP);// A breakpoint callback function + long lData; // User data + USHORT cPass; // Initial Pass count + USHORT cPassCur; // Current Pass count + char * pCmd; // Offset of the command to Execute + USHORT hprc; // The process this bp is associated with + USHORT hthd; // The tread to break at + // NULL breaks on all threads +// struct bpi * pbpiNext; +// struct bpi * pbpiBack; +} BPI; +typedef BPI * PBPI; +typedef BPI FAR * LPBPI; + +#endif // 0 + +#ifdef LATER + +#if defined(WINDOWS3) || defined(DOS5) +/* + * This defines a function callback mechanism which can be used to + * generalize the breakpoint facility. + * The messages and responses are defined earlier in this file. + */ +typedef struct cbp { + unsigned wMsg; // A message giving the reason for the call + unsigned wInstance; // BPBrkExec call count + char FAR * lpch; // A buffer for return info + HBPI hbpi; // Points to the parent bpi + } cbp; +#endif + +#endif // LATER + +typedef struct PBPD { + USHORT hthd; + USHORT BPType; + PCXF pCXF; + USHORT BPSegType; + char FAR * szCmd; + unsigned int fAmbig; + union { + ADDR Addr; + struct { + unsigned int cBPMax; + TML TMLT; + } u; + } u; + PDPI pDPI; + DPF DPF; + USHORT cPass; + char FAR * szOptCmd; + int iErr; + char SubType; + int (FAR *lpfnEval)(_LPCBP);// A possible callback function + long lData; // User data +} PBP; +typedef PBP FAR * PPBP; + +#ifdef LATER +typedef struct sfi { + int fLang; + ushort fEnable; + ushort hthd; +} sfi; + +// user global variable YUK! this should not be visable to the world! +// extern PBPI pbpiFirst; +extern int G_BPfEmulate; + +extern HLLI llbpi; +#endif // LATER + +extern UINT radix; +extern char fCaseSensitive; + + +#define BPCODEADDR 1001 +#define BPDATAADDR 1002 +#define BPLENGTH 1003 +#define BPPASSCNT 1004 +#define BADBKPTCMD 1005 +#define WMSGALL 1006 +#define WMSGTYPE 1007 +#define WMSGCLASS 1008 +#define WMSGBPCLASS 1009 +#define WMSGBPTYPE 1010 +#define WMSGDPCLASS 1011 +#define WMSGDPTYPE 1012 +#define WMSGBPALL 1013 +#define WMSGDPALL 1014 +#define BPSTCALLBACK 1015 +#define NOCODE 1019 +#define NOTLVALUE 1020 + + +/**********************************************************************/ + +#define MHOmfUnLock(a) + + +#define bptNext 1 +#define bptPrevious 2 +#define bptFirst 3 +#define bptLast 4 + +typedef enum { + BPNOERROR = 0, // No Error + BPBadDataSize = 1, + BPBadPassCount = 2, + BPBadCmdString = 3, + BPBadOption = 4, + BPBadAddrExpr = 5, + BPBadContextOp = 6, + BPOOMemory = 7, + BPError = 8, + BPBadBPHandle = 9, + BPNoMatch = 10, + BPAmbigous = 11, + BPNoBreakpoint = 12, + BPTmpBreakpoint = 13, + BPPassBreakpoint = 14, + BPBadExpression = 15, + BPOutOfSpace = 16, + BPBadThread = 17, + BPBadProcess = 18, + BPCancel = 19 +} BPSTATUS; + + +#define BPLOC 0 +#define BPLOCEXPRTRUE 1 +#define BPLOCEXPRCHGD 2 +#define BPEXPRTRUE 3 +#define BPEXPRCHGD 4 +#define BPWNDPROC 5 +#define BPWNDPROCEXPRTRUE 6 +#define BPWNDPROCEXPRCHGD 7 +#define BPWNDPROCMSGRCVD 8 + + +/* +** Define the states that a breakpoint can have. +*/ + +typedef enum { + bpstateNotSet = 1, /* Breakpoint is parsed */ + bpstateVirtual = 2, /* Breakpoint is parsed & Addr-ed */ + bpstateSet = 4, /* Breakpoint is parsed, Addr-ed & Set */ + bpstateSets = 7, /* */ + bpstateDisabled = 0, /* Breakpoint is Disabled */ + bpstateEnabled = 16, /* Breakpoint is Enabled */ + bpstateDeleted = 32 /* Breakpoint has been deleted */ +} BPSTATE; + + +/* +** BreakPoint Format Control Flags +*/ + +#define BPFCF_ITEM_COUNT 0x01 +#define BPFCF_ADD_DELETE 0x02 +#define BPFCF_WNDPROC 0x04 +#define BPFCF_WRKSPACE 0x08 + +/* +** +*/ + +typedef VOID (LOADDS PASCAL FAR * LPFNBPCALLBACK)(HBPT, BPSTATUS); + +#endif // _BPTYPES_ diff --git a/private/windbg/osdebug/include/cp.h b/private/windbg/osdebug/include/cp.h new file mode 100644 index 000000000..e02b056f6 --- /dev/null +++ b/private/windbg/osdebug/include/cp.h @@ -0,0 +1,51 @@ + +#define BADTYPECAST 101 +#define NOROOM 102 +#define GEXPRERR 105 + + +extern int FAR PASCAL CPCopyToken(LPSTR *lplps, LPSTR lpt); +extern int FAR PASCAL CPCopyString(LPSTR *lplps, LPSTR lpT, char chEscape, BOOL fQuote); +extern LPSTR FAR PASCAL CPAdvance(char FAR *, char FAR *); +extern LPSTR FAR PASCAL CPszToken(char FAR *, char FAR *); +extern LPSTR FAR PASCAL CPTrim(char FAR *, char); +extern int FAR PASCAL CPQueryChar(char FAR *, char FAR *); +extern int FAR PASCAL CPQueryQuoteIndex ( char FAR * szSrc ); +extern int FAR PASCAL CPGetCastNbr(char FAR *, USHORT, int, int, PCXF, char FAR *, char FAR *); +extern long FAR PASCAL CPGetNbr(char FAR *, int, int, PCXF, char FAR *, int FAR *); +extern long FAR PASCAL CPGetInt(char FAR *, int FAR *, int FAR *); +extern int FAR PASCAL CPGetAddress(char FAR *, int FAR *, ADDR FAR *, EERADIX, CXF FAR *, BOOL, BOOL); +extern LPSTR FAR PASCAL CPSkipWhitespace(char FAR *); + +extern int FAR PASCAL +CPGetFPNbr( + LPSTR lpExpr, + int cBits, + int nRadix, + int fCase, + PCXF pCxf, + LPSTR lpBuf, + LPSTR lpErr); + +extern int FAR PASCAL +CPGetRange( + LPSTR lpszExpr, + int FAR *lpcch, + LPADDR lpAddr1, + LPADDR lpAddr2, + EERADIX radix, + int cbDefault, + int cbSize, + CXF FAR *pcxf, + BOOL fCase, + BOOL fSpecial); + +typedef enum { + CPNOERROR, + CPNOARGS, + CPISOPENQUOTE, + CPISCLOSEQUOTE, + CPISOPENANDCLOSEQUOTE, + CPISDELIM, + CPNOTINQUOTETABLE +} CPRETURNS; diff --git a/private/windbg/osdebug/include/ctxptrs.h b/private/windbg/osdebug/include/ctxptrs.h new file mode 100644 index 000000000..1e1bb2dda --- /dev/null +++ b/private/windbg/osdebug/include/ctxptrs.h @@ -0,0 +1,97 @@ +#if defined( _NTMIPS_ ) || defined( _NTALPHA_ ) || defined( _NTPPC_ ) +#define _CTXPTRS_H_ +#endif + +#ifndef _CTXPTRS_H_ +#define _CTXPTRS_H_ + +#if !defined( _ALPHA_ ) && !defined (TARGET_ALPHA) + +typedef ULONG KNONVOLATILE_CONTEXT_POINTERS; +typedef PULONG PKNONVOLATILE_CONTEXT_POINTERS; + +#else + +// +// modified from ntalpha.h June 7, 1993. +// + +// +// Nonvolatile context pointer record. +// + +typedef struct _KNONVOLATILE_CONTEXT_POINTERS { + + PLARGE_INTEGER FloatingContext[1]; + PLARGE_INTEGER FltF1; + // Nonvolatile floating point registers start here. + PLARGE_INTEGER FltF2; + PLARGE_INTEGER FltF3; + PLARGE_INTEGER FltF4; + PLARGE_INTEGER FltF5; + PLARGE_INTEGER FltF6; + PLARGE_INTEGER FltF7; + PLARGE_INTEGER FltF8; + PLARGE_INTEGER FltF9; + PLARGE_INTEGER FltF10; + PLARGE_INTEGER FltF11; + PLARGE_INTEGER FltF12; + PLARGE_INTEGER FltF13; + PLARGE_INTEGER FltF14; + PLARGE_INTEGER FltF15; + PLARGE_INTEGER FltF16; + PLARGE_INTEGER FltF17; + PLARGE_INTEGER FltF18; + PLARGE_INTEGER FltF19; + PLARGE_INTEGER FltF20; + PLARGE_INTEGER FltF21; + PLARGE_INTEGER FltF22; + PLARGE_INTEGER FltF23; + PLARGE_INTEGER FltF24; + PLARGE_INTEGER FltF25; + PLARGE_INTEGER FltF26; + PLARGE_INTEGER FltF27; + PLARGE_INTEGER FltF28; + PLARGE_INTEGER FltF29; + PLARGE_INTEGER FltF30; + PLARGE_INTEGER FltF31; + + PLARGE_INTEGER IntegerContext[1]; + PLARGE_INTEGER IntT0; + PLARGE_INTEGER IntT1; + PLARGE_INTEGER IntT2; + PLARGE_INTEGER IntT3; + PLARGE_INTEGER IntT4; + PLARGE_INTEGER IntT5; + PLARGE_INTEGER IntT6; + PLARGE_INTEGER IntT7; + // Nonvolatile integer registers start here. + PLARGE_INTEGER IntS0; + PLARGE_INTEGER IntS1; + PLARGE_INTEGER IntS2; + PLARGE_INTEGER IntS3; + PLARGE_INTEGER IntS4; + PLARGE_INTEGER IntS5; + PLARGE_INTEGER IntFp; + PLARGE_INTEGER IntA0; + PLARGE_INTEGER IntA1; + PLARGE_INTEGER IntA2; + PLARGE_INTEGER IntA3; + PLARGE_INTEGER IntA4; + PLARGE_INTEGER IntA5; + PLARGE_INTEGER IntT8; + PLARGE_INTEGER IntT9; + PLARGE_INTEGER IntT10; + PLARGE_INTEGER IntT11; + PLARGE_INTEGER IntRa; + PLARGE_INTEGER IntT12; + PLARGE_INTEGER IntAt; + PLARGE_INTEGER IntGp; + PLARGE_INTEGER IntSp; + PLARGE_INTEGER IntZero; + +} KNONVOLATILE_CONTEXT_POINTERS, *PKNONVOLATILE_CONTEXT_POINTERS; + +#endif // !_ALPHA_ && !TARGET_ALPHA + +#endif // _CTXPTRS_H_ diff --git a/private/windbg/osdebug/include/cvexefmt.h b/private/windbg/osdebug/include/cvexefmt.h new file mode 100644 index 000000000..0b3286c18 --- /dev/null +++ b/private/windbg/osdebug/include/cvexefmt.h @@ -0,0 +1,364 @@ +/*** cvexefmt.h - format of CodeView information in exe + * + * Structures, constants, etc. for reading CodeView information + * from the executable. + * + */ + + +/*** The master copy of this file resides in the CodeView project. + * All Microsoft projects are required to use the master copy without + * modification. Modification of the master version or a copy + * without consultation with all parties concerned is extremely + * risky. + * + */ + + + + +// The following structures and constants describe the format of the +// CodeView Debug OMF for that will be accepted by CodeView 4.0 and +// later. These are executables with signatures of NB05, NB06 and NB07. +// There is some confusion about the signatures NB03 and NB04 so none +// of the utilites will accept executables with these signatures. + +// All of the structures described below must start on a long word boundary +// to maintain natural alignment. Pad space can be inserted during the +// write operation and the addresses adjusted without affecting the contents +// of the structures. + + +// Type of subsection entry. + +#define sstModule 0x120 +#define sstTypes 0x121 +#define sstPublic 0x122 +#define sstPublicSym 0x123 // publics as symbol (waiting for link) +#define sstSymbols 0x124 +#define sstAlignSym 0x125 +#define sstSrcLnSeg 0x126 // because link doesn't emit SrcModule +#define sstSrcModule 0x127 +#define sstLibraries 0x128 +#define sstGlobalSym 0x129 +#define sstGlobalPub 0x12a +#define sstGlobalTypes 0x12b +#define sstMPC 0x12c +#define sstSegMap 0x12d +#define sstSegName 0x12e +#define sstPreComp 0x12f // precompiled types +#define sstPreCompMap 0x130 // map precompiled types in global types +#define sstOffsetMap16 0x131 +#define sstOffsetMap32 0x132 +#define sstFileIndex 0x133 +#define sstStaticSym 0x134 + + + +typedef enum OMFHash { + OMFHASH_NONE, // no hashing + OMFHASH_SUMUC16, // upper case sum of chars in 16 bit table + OMFHASH_SUMUC32, // upper case sum of chars in 32 bit table + OMFHASH_ADDR16, // sorted by increasing address in 16 bit table + OMFHASH_ADDR32 // sorted by increasing address in 32 bit table +} OMFHASH; + +// CodeView Debug OMF signature. The signature at the end of the file is +// a negative offset from the end of the file to another signature. At +// the negative offset (base address) is another signature whose filepos +// field points to the first OMFDirHeader in a chain of directories. +// The NB05 signature is used by the link utility to indicated a completely +// unpacked file. The NB06 signature is used by ilink to indicate that the +// executable has had CodeView information from an incremental link appended +// to the executable. The NB07 signature is used by cvpack to indicate that +// the CodeView Debug OMF has been packed. CodeView will only process +// executables with the NB07 signature. + + +typedef struct OMFSignature { + char Signature[4]; // "NB05", "NB06" or "NB07" + long filepos; // offset in file +} OMFSignature; + + + +// directory information structure +// This structure contains the information describing the directory. +// It is pointed to by the signature at the base address or the directory +// link field of a preceeding directory. The directory entries immediately +// follow this structure. + + +typedef struct OMFDirHeader { + unsigned short cbDirHeader; // length of this structure + unsigned short cbDirEntry; // number of bytes in each directory entry + unsigned long cDir; // number of directorie entries + long lfoNextDir; // offset from base of next directory + unsigned long flags; // status flags +} OMFDirHeader; + + + + +// directory structure +// The data in this structure is used to reference the data for each +// subsection of the CodeView Debug OMF information. Tables that are +// not associated with a specific module will have a module index of +// oxffff. These tables are the global types table, the global symbol +// table, the global public table and the library table. + + +typedef struct OMFDirEntry { + unsigned short SubSection; // subsection type (sst...) + unsigned short iMod; // module index + long lfo; // large file offset of subsection + unsigned long cb; // number of bytes in subsection +} OMFDirEntry; + + + +// information decribing each segment in a module + +typedef struct OMFSegDesc { + unsigned short Seg; // segment index + unsigned short pad; // pad to maintain alignment + unsigned long Off; // offset of code in segment + unsigned long cbSeg; // number of bytes in segment +} OMFSegDesc; + + + + +// per module information +// There is one of these subsection entries for each module +// in the executable. The entry is generated by link/ilink. +// This table will probably require padding because of the +// variable length module name. + +typedef struct OMFModule { + unsigned short ovlNumber; // overlay number + unsigned short iLib; // library that the module was linked from + unsigned short cSeg; // count of number of segments in module + char Style[2]; // debugging style "CV" + OMFSegDesc SegInfo[1]; // describes segments in module + char Name[]; // length prefixed module name padded to + // long word boundary +} OMFModule; + + + +// Symbol hash table format +// This structure immediately preceeds the global publics table +// and global symbol tables. + +typedef struct OMFSymHash { + unsigned short symhash; // symbol hash function index + unsigned short addrhash; // address hash function index + unsigned long cbSymbol; // length of symbol information + unsigned long cbHSym; // length of symbol hash data + unsigned long cbHAddr; // length of address hashdata +} OMFSymHash; + + + +// Global types subsection format +// This structure immediately preceeds the global types table. +// The offsets in the typeOffset array are relative to the address +// of ctypes. Each type entry following the typeOffset array must +// begin on a long word boundary. + +typedef struct OMFTypeFlags { + unsigned long sig :8; + unsigned long unused :24; +} OMFTypeFlags; + + +typedef struct OMFGlobalTypes { + OMFTypeFlags flags; + unsigned long cTypes; // number of types + unsigned long typeOffset[]; // array of offsets to types +} OMFGlobalTypes; + + + + +// Precompiled types mapping table +// This table should be ignored by all consumers except the incremental +// packer. + + +typedef struct OMFPreCompMap { + unsigned short FirstType; // first precompiled type index + unsigned short cTypes; // number of precompiled types + unsigned long signature; // precompiled types signature + unsigned short pad; + CV_typ_t map[]; // mapping of precompiled types +} OMFPreCompMap; + + + + +// Source line to address mapping table. +// This table is generated by the link/ilink utility from line number +// information contained in the object file OMF data. This table contains +// only the code contribution for one segment from one source file. + + +typedef struct OMFSourceLine { + unsigned short Seg; // linker segment index + unsigned short cLnOff; // count of line/offset pairs + unsigned long offset[1]; // array of offsets in segment + unsigned short lineNbr[1]; // array of line lumber in source +} OMFSourceLine; + +typedef OMFSourceLine FAR * LPSL; + + +// Source file description +// This table is generated by the linker + + +typedef struct OMFSourceFile { + unsigned short cSeg; // number of segments from source file + unsigned short reserved; // reserved + unsigned long baseSrcLn[1]; // base of OMFSourceLine tables + // this array is followed by array + // of segment start/end pairs followed by + // an array of linker indices + // for each segment in the file + unsigned short cFName; // length of source file name + char Name; // name of file padded to long boundary +} OMFSourceFile; + +typedef OMFSourceFile FAR * LPSF; + + +// Source line to address mapping header structure +// This structure describes the number and location of the +// OMFAddrLine tables for a module. The offSrcLine entries are +// relative to the beginning of this structure. + + +typedef struct OMFSourceModule { + unsigned short cFile; // number of OMFSourceTables + unsigned short cSeg; // number of segments in module + unsigned long baseSrcFile[1]; // base of OMFSourceFile table + // this array is followed by array + // of segment start/end pairs followed + // by an array of linker indices + // for each segment in the module +} OMFSourceModule; + +typedef OMFSourceModule FAR * LPSM; + +// sstLibraries + +typedef struct OMFLibrary { + unsigned char cbLibs; // count of library names + char Libs[1]; // array of length prefixed lib names (first entry zero length) +} OMFLibrary; + + +// Pcode support. This subsection contains debug information generated +// by the MPC utility used to process Pcode executables. Currently +// it contains a mapping table from segment index (zero based) to +// frame paragraph. MPC converts segmented exe's to non-segmented +// exe's for DOS support. To avoid backpatching all CV info, this +// table is provided for the mapping. Additional info may be provided +// in the future for profiler support. + +typedef struct OMFMpcDebugInfo { + unsigned short cSeg; // number of segments in module + unsigned short mpSegFrame[1]; // map seg (zero based) to frame +} OMFMpcDebugInfo; + +// The following structures and constants describe the format of the +// CodeView Debug OMF for linkers that emit executables with the NB02 +// signature. Current utilities with the exception of cvpack and cvdump +// will not accept or emit executables with the NB02 signature. Cvdump +// will dump an unpacked executable with the NB02 signature. Cvpack will +// read an executable with the NB02 signature but the packed executable +// will be written with the table format, contents and signature of NB07. + + + + + +// subsection type constants + +#define SSTMODULE 0x101 // Basic info. about object module +#define SSTPUBLIC 0x102 // Public symbols +#define SSTTYPES 0x103 // Type information +#define SSTSYMBOLS 0x104 // Symbol Data +#define SSTSRCLINES 0x105 // Source line information +#define SSTLIBRARIES 0x106 // Names of all library files used +#define SSTIMPORTS 0x107 // Symbols for DLL fixups +#define SSTCOMPACTED 0x108 // Compacted types section +#define SSTSRCLNSEG 0x109 // Same as source lines, contains segment + + +typedef struct DirEntry{ + unsigned short SubSectionType; + unsigned short ModuleIndex; + long lfoStart; + unsigned short Size; +} DirEntry; + + +// information decribing each segment in a module + +typedef struct oldnsg { + unsigned short Seg; // segment index + unsigned short Off; // offset of code in segment + unsigned short cbSeg; // number of bytes in segment +} oldnsg; + + +// old subsection module information + +typedef struct oldsmd { + oldnsg SegInfo; // describes first segment in module + unsigned short ovlNbr; // overlay number + unsigned short iLib; + unsigned char cSeg; // Number of segments in module + char reserved; + unsigned char cbName[1]; // length prefixed name of module + oldnsg arnsg[]; // cSeg-1 structures exist for alloc text or comdat code +} oldsmd; + +typedef struct{ + unsigned short Seg; + unsigned long Off; + unsigned long cbSeg; +} oldnsg32; + +typedef struct { + oldnsg32 SegInfo; // describes first segment in module + unsigned short ovlNbr; // overlay number + unsigned short iLib; + unsigned char cSeg; // Number of segments in module + char reserved; + unsigned char cbName[1]; // length prefixed name of module + oldnsg32 arnsg[]; // cSeg-1 structures exist for alloc text or comdat code +} oldsmd32; + +// OMFSegMap - This table contains the mapping between the logical segment indices +// used in the symbol table and the physical segments where the program is loaded + +typedef struct OMFSegMapDesc { + unsigned short flags; // descriptor flags bit field. + unsigned short ovl; // the logical overlay number + unsigned short group; // group index into the descriptor array + unsigned short frame; // logical segment index - interpreted via flags + unsigned short iSegName; // segment or group name - index into sstSegName + unsigned short iClassName; // class name - index into sstSegName + unsigned long offset; // byte offset of the logical within the physical segment + unsigned long cbSeg; // byte count of the logical segment or group +} OMFSegMapDesc; + +typedef struct OMFSegMap { + unsigned short cSeg; // total number of segment descriptors + unsigned short cSegLog; // number of logical segment descriptors + OMFSegMapDesc rgDesc[0]; // array of segment descriptors +} OMFSegMap; + diff --git a/private/windbg/osdebug/include/cvinfo.h b/private/windbg/osdebug/include/cvinfo.h new file mode 100644 index 000000000..7f7dc138a --- /dev/null +++ b/private/windbg/osdebug/include/cvinfo.h @@ -0,0 +1,3221 @@ +/*** cvinfo.h - Generic CodeView information definitions + * + * Structures, constants, etc. for accessing and interpreting + * CodeView information. + * + */ + + +/*** The master copy of this file resides in the langapi project. + * All Microsoft projects are required to use the master copy without + * modification. Modification of the master version or a copy + * without consultation with all parties concerned is extremely + * risky. + * + * When this file is modified, the corresponding documentation file + * omfdeb.doc in the langapi project must be updated. + */ + +#ifndef _VC_VER_INC +#include "..\include\vcver.h" +#endif + +#ifndef _CV_INFO_INCLUDED +#define _CV_INFO_INCLUDED + +#ifdef __cplusplus +#pragma warning ( disable: 4200 ) +#endif + +#ifndef __INLINE +#ifdef __cplusplus +#define __INLINE inline +#else +#define __INLINE __inline +#endif +#endif + +#pragma pack ( push, 1 ) +typedef unsigned long CV_uoff32_t; +typedef long CV_off32_t; +typedef unsigned short CV_uoff16_t; +typedef short CV_off16_t; +typedef unsigned short CV_typ_t; + +#if !defined (CV_ZEROLEN) +#define CV_ZEROLEN +#endif + +#if !defined (FLOAT10) +#if defined(_M_I86) // 16 bit x86 supporting long double +typedef long double FLOAT10; +#else // 32 bit w/o long double support +typedef struct FLOAT10 +{ + char b[10]; +} FLOAT10; +#endif +#endif + + +#define CV_SIGNATURE_C6 0L // Actual signature is >64K +#define CV_SIGNATURE_C7 1L // First explicit signature +#define CV_SIGNATURE_RESERVED 2L // All signatures from 2 to 64K are reserved + +#define CV_MAXOFFSET 0xffffffff + +/** CodeView Symbol and Type OMF type information is broken up into two + * ranges. Type indices less than 0x1000 describe type information + * that is frequently used. Type indices above 0x1000 are used to + * describe more complex features such as functions, arrays and + * structures. + */ + + + + +/** Primitive types have predefined meaning that is encoded in the + * values of the various bit fields in the value. + * + * A CodeView primitive type is defined as: + * + * 1 1 + * 1 089 7654 3 210 + * r mode type r sub + * + * Where + * mode is the pointer mode + * type is a type indicator + * sub is a subtype enumeration + * r is a reserved field + * + * See Microsoft Symbol and Type OMF (Version 4.0) for more + * information. + */ + + +#define CV_MMASK 0x700 // mode mask +#define CV_TMASK 0x0f0 // type mask + +// can we use the reserved bit ?? +#define CV_SMASK 0x00f // subtype mask + +#define CV_MSHIFT 8 // primitive mode right shift count +#define CV_TSHIFT 4 // primitive type right shift count +#define CV_SSHIFT 0 // primitive subtype right shift count + +// macros to extract primitive mode, type and size + +#define CV_MODE(typ) (((typ) & CV_MMASK) >> CV_MSHIFT) +#define CV_TYPE(typ) (((typ) & CV_TMASK) >> CV_TSHIFT) +#define CV_SUBT(typ) (((typ) & CV_SMASK) >> CV_SSHIFT) + +// macros to insert new primitive mode, type and size + +#define CV_NEWMODE(typ, nm) ((CV_typ_t)(((typ) & ~CV_MMASK) | ((nm) << CV_MSHIFT))) +#define CV_NEWTYPE(typ, nt) (((typ) & ~CV_TMASK) | ((nt) << CV_TSHIFT)) +#define CV_NEWSUBT(typ, ns) (((typ) & ~CV_SMASK) | ((ns) << CV_SSHIFT)) + + + +// pointer mode enumeration values + +typedef enum CV_prmode_e { + CV_TM_DIRECT = 0, // mode is not a pointer + CV_TM_NPTR = 1, // mode is a near pointer + CV_TM_FPTR = 2, // mode is a far pointer + CV_TM_HPTR = 3, // mode is a huge pointer + CV_TM_NPTR32 = 4, // mode is a 32 bit near pointer + CV_TM_FPTR32 = 5, // mode is a 32 bit far pointer + CV_TM_NPTR64 = 6, // mode is a 64 bit near pointer + CV_TM_NPTR128 = 7 // mode is a 128 bit near pointer +} CV_prmode_e; + + + + +// type enumeration values + + +typedef enum CV_type_e { + CV_SPECIAL = 0x00, // special type size values + CV_SIGNED = 0x01, // signed integral size values + CV_UNSIGNED = 0x02, // unsigned integral size values + CV_BOOLEAN = 0x03, // Boolean size values + CV_REAL = 0x04, // real number size values + CV_COMPLEX = 0x05, // complex number size values + CV_SPECIAL2 = 0x06, // second set of special types + CV_INT = 0x07, // integral (int) values + CV_CVRESERVED = 0x0f +} CV_type_e; + + + + +// subtype enumeration values for CV_SPECIAL + + +typedef enum CV_special_e { + CV_SP_NOTYPE = 0x00, + CV_SP_ABS = 0x01, + CV_SP_SEGMENT = 0x02, + CV_SP_VOID = 0x03, + CV_SP_CURRENCY = 0x04, + CV_SP_NBASICSTR = 0x05, + CV_SP_FBASICSTR = 0x06, + CV_SP_NOTTRANS = 0x07 +} CV_special_e; + + + + +// subtype enumeration values for CV_SPECIAL2 + + +typedef enum CV_special2_e { + CV_S2_BIT = 0x00, + CV_S2_PASCHAR = 0x01 // Pascal CHAR +} CV_special2_e; + + + + + +// subtype enumeration values for CV_SIGNED, CV_UNSIGNED and CV_BOOLEAN + + +typedef enum CV_integral_e { + CV_IN_1BYTE = 0x00, + CV_IN_2BYTE = 0x01, + CV_IN_4BYTE = 0x02, + CV_IN_8BYTE = 0x03, + CV_IN_16BYTE = 0x04 +} CV_integral_e; + + + + + +// subtype enumeration values for CV_REAL and CV_COMPLEX + + +typedef enum CV_real_e { + CV_RC_REAL32 = 0x00, + CV_RC_REAL64 = 0x01, + CV_RC_REAL80 = 0x02, + CV_RC_REAL128 = 0x03, + CV_RC_REAL48 = 0x04 +} CV_real_e; + + + + +// subtype enumeration values for CV_INT (really int) + + +typedef enum CV_int_e { + CV_RI_CHAR = 0x00, + CV_RI_INT1 = 0x00, + CV_RI_WCHAR = 0x01, + CV_RI_UINT1 = 0x01, + CV_RI_INT2 = 0x02, + CV_RI_UINT2 = 0x03, + CV_RI_INT4 = 0x04, + CV_RI_UINT4 = 0x05, + CV_RI_INT8 = 0x06, + CV_RI_UINT8 = 0x07, + CV_RI_INT16 = 0x08, + CV_RI_UINT16 = 0x09 +} CV_int_e; + + + + +// macros to check the type of a primitive + +#define CV_TYP_IS_DIRECT(typ) (CV_MODE(typ) == CV_TM_DIRECT) +#define CV_TYP_IS_PTR(typ) (CV_MODE(typ) != CV_TM_DIRECT) +#define CV_TYP_IS_NPTR(typ) (CV_MODE(typ) == CV_TM_NPTR) +#define CV_TYP_IS_FPTR(typ) (CV_MODE(typ) == CV_TM_FPTR) +#define CV_TYP_IS_HPTR(typ) (CV_MODE(typ) == CV_TM_HPTR) +#define CV_TYP_IS_NPTR32(typ) (CV_MODE(typ) == CV_TM_NPTR32) +#define CV_TYP_IS_FPTR32(typ) (CV_MODE(typ) == CV_TM_FPTR32) + +#define CV_TYP_IS_SIGNED(typ) (((CV_TYPE(typ) == CV_SIGNED) && CV_TYP_IS_DIRECT(typ)) || \ + (typ == T_INT1) || \ + (typ == T_INT2) || \ + (typ == T_INT4) || \ + (typ == T_INT8) || \ + (typ == T_INT16) || \ + (typ == T_RCHAR)) + +#define CV_TYP_IS_UNSIGNED(typ) (((CV_TYPE(typ) == CV_UNSIGNED) && CV_TYP_IS_DIRECT(typ)) || \ + (typ == T_UINT1) || \ + (typ == T_UINT2) || \ + (typ == T_UINT4) || \ + (typ == T_UINT8) || \ + (typ == T_UINT16)) + +#define CV_TYP_IS_REAL(typ) ((CV_TYPE(typ) == CV_REAL) && CV_TYP_IS_DIRECT(typ)) + +#define CV_FIRST_NONPRIM 0x1000 +#define CV_IS_PRIMITIVE(typ) ((typ) < CV_FIRST_NONPRIM) +#define CV_TYP_IS_COMPLEX(typ) ((CV_TYPE(typ) == CV_COMPLEX) && CV_TYP_IS_DIRECT(typ)) + + + + +// selected values for type_index - for a more complete definition, see +// Microsoft Symbol and Type OMF document + + + + +// Special Types + + +#define T_NOTYPE 0x0000 // uncharacterized type (no type) +#define T_ABS 0x0001 // absolute symbol +#define T_SEGMENT 0x0002 // segment type +#define T_VOID 0x0003 // void +#define T_PVOID 0x0103 // near pointer to void +#define T_PFVOID 0x0203 // far pointer to void +#define T_PHVOID 0x0303 // huge pointer to void +#define T_32PVOID 0x0403 // 16:32 near pointer to void +#define T_32PFVOID 0x0503 // 16:32 far pointer to void +#define T_CURRENCY 0x0004 // BASIC 8 byte currency value +#define T_NBASICSTR 0x0005 // Near BASIC string +#define T_FBASICSTR 0x0006 // Far BASIC string +#define T_NOTTRANS 0x0007 // type not translated by cvpack +#define T_BIT 0x0060 // bit +#define T_PASCHAR 0x0061 // Pascal CHAR + + + +// Character types + + +#define T_CHAR 0x0010 // 8 bit signed +#define T_UCHAR 0x0020 // 8 bit unsigned +#define T_PCHAR 0x0110 // near pointer to 8 bit signed +#define T_PUCHAR 0x0120 // near pointer to 8 bit unsigned +#define T_PFCHAR 0x0210 // far pointer to 8 bit signed +#define T_PFUCHAR 0x0220 // far pointer to 8 bit unsigned +#define T_PHCHAR 0x0310 // huge pointer to 8 bit signed +#define T_PHUCHAR 0x0320 // huge pointer to 8 bit unsigned +#define T_32PCHAR 0x0410 // 16:32 near pointer to 8 bit signed +#define T_32PUCHAR 0x0420 // 16:32 near pointer to 8 bit unsigned +#define T_32PFCHAR 0x0510 // 16:32 far pointer to 8 bit signed +#define T_32PFUCHAR 0x0520 // 16:32 far pointer to 8 bit unsigned + + + + +// really a character types + +#define T_RCHAR 0x0070 // really a char +#define T_PRCHAR 0x0170 // 16:16 near pointer to a real char +#define T_PFRCHAR 0x0270 // 16:16 far pointer to a real char +#define T_PHRCHAR 0x0370 // 16:16 huge pointer to a real char +#define T_32PRCHAR 0x0470 // 16:32 near pointer to a real char +#define T_32PFRCHAR 0x0570 // 16:32 far pointer to a real char + + + + +// really a wide character types + +#define T_WCHAR 0x0071 // wide char +#define T_PWCHAR 0x0171 // 16:16 near pointer to a wide char +#define T_PFWCHAR 0x0271 // 16:16 far pointer to a wide char +#define T_PHWCHAR 0x0371 // 16:16 huge pointer to a wide char +#define T_32PWCHAR 0x0471 // 16:32 near pointer to a wide char +#define T_32PFWCHAR 0x0571 // 16:32 far pointer to a wide char + + +// 8 bit int types + + +#define T_INT1 0x0068 // 8 bit signed int +#define T_UINT1 0x0069 // 8 bit unsigned int +#define T_PINT1 0x0168 // near pointer to 8 bit signed int +#define T_PUINT1 0x0169 // near pointer to 8 bit unsigned int +#define T_PFINT1 0x0268 // far pointer to 8 bit signed int +#define T_PFUINT1 0x0269 // far pointer to 8 bit unsigned int +#define T_PHINT1 0x0368 // huge pointer to 8 bit signed int +#define T_PHUINT1 0x0369 // huge pointer to 8 bit unsigned int + +#define T_32PINT1 0x0468 // 16:32 near pointer to 8 bit signed int +#define T_32PUINT1 0x0469 // 16:32 near pointer to 8 bit unsigned int +#define T_32PFINT1 0x0568 // 16:32 far pointer to 8 bit signed int +#define T_32PFUINT1 0x0569 // 16:32 far pointer to 8 bit unsigned int + + +// 16 bit short types + + +#define T_SHORT 0x0011 // 16 bit signed +#define T_USHORT 0x0021 // 16 bit unsigned +#define T_PSHORT 0x0111 // near pointer to 16 bit signed +#define T_PUSHORT 0x0121 // near pointer to 16 bit unsigned +#define T_PFSHORT 0x0211 // far pointer to 16 bit signed +#define T_PFUSHORT 0x0221 // far pointer to 16 bit unsigned +#define T_PHSHORT 0x0311 // huge pointer to 16 bit signed +#define T_PHUSHORT 0x0321 // huge pointer to 16 bit unsigned + +#define T_32PSHORT 0x0411 // 16:32 near pointer to 16 bit signed +#define T_32PUSHORT 0x0421 // 16:32 near pointer to 16 bit unsigned +#define T_32PFSHORT 0x0511 // 16:32 far pointer to 16 bit signed +#define T_32PFUSHORT 0x0521 // 16:32 far pointer to 16 bit unsigned + + + + +// 16 bit int types + + +#define T_INT2 0x0072 // 16 bit signed int +#define T_UINT2 0x0073 // 16 bit unsigned int +#define T_PINT2 0x0172 // near pointer to 16 bit signed int +#define T_PUINT2 0x0173 // near pointer to 16 bit unsigned int +#define T_PFINT2 0x0272 // far pointer to 16 bit signed int +#define T_PFUINT2 0x0273 // far pointer to 16 bit unsigned int +#define T_PHINT2 0x0372 // huge pointer to 16 bit signed int +#define T_PHUINT2 0x0373 // huge pointer to 16 bit unsigned int + +#define T_32PINT2 0x0472 // 16:32 near pointer to 16 bit signed int +#define T_32PUINT2 0x0473 // 16:32 near pointer to 16 bit unsigned int +#define T_32PFINT2 0x0572 // 16:32 far pointer to 16 bit signed int +#define T_32PFUINT2 0x0573 // 16:32 far pointer to 16 bit unsigned int + + + + +// 32 bit long types + + +#define T_LONG 0x0012 // 32 bit signed +#define T_ULONG 0x0022 // 32 bit unsigned +#define T_PLONG 0x0112 // near pointer to 32 bit signed +#define T_PULONG 0x0122 // near pointer to 32 bit unsigned +#define T_PFLONG 0x0212 // far pointer to 32 bit signed +#define T_PFULONG 0x0222 // far pointer to 32 bit unsigned +#define T_PHLONG 0x0312 // huge pointer to 32 bit signed +#define T_PHULONG 0x0322 // huge pointer to 32 bit unsigned + +#define T_32PLONG 0x0412 // 16:32 near pointer to 32 bit signed +#define T_32PULONG 0x0422 // 16:32 near pointer to 32 bit unsigned +#define T_32PFLONG 0x0512 // 16:32 far pointer to 32 bit signed +#define T_32PFULONG 0x0522 // 16:32 far pointer to 32 bit unsigned + + + + +// 32 bit int types + + +#define T_INT4 0x0074 // 32 bit signed int +#define T_UINT4 0x0075 // 32 bit unsigned int +#define T_PINT4 0x0174 // near pointer to 32 bit signed int +#define T_PUINT4 0x0175 // near pointer to 32 bit unsigned int +#define T_PFINT4 0x0274 // far pointer to 32 bit signed int +#define T_PFUINT4 0x0275 // far pointer to 32 bit unsigned int +#define T_PHINT4 0x0374 // huge pointer to 32 bit signed int +#define T_PHUINT4 0x0375 // huge pointer to 32 bit unsigned int + +#define T_32PINT4 0x0474 // 16:32 near pointer to 32 bit signed int +#define T_32PUINT4 0x0475 // 16:32 near pointer to 32 bit unsigned int +#define T_32PFINT4 0x0574 // 16:32 far pointer to 32 bit signed int +#define T_32PFUINT4 0x0575 // 16:32 far pointer to 32 bit unsigned int + + + + +// 64 bit quad types + + +#define T_QUAD 0x0013 // 64 bit signed +#define T_UQUAD 0x0023 // 64 bit unsigned +#define T_PQUAD 0x0113 // near pointer to 64 bit signed +#define T_PUQUAD 0x0123 // near pointer to 64 bit unsigned +#define T_PFQUAD 0x0213 // far pointer to 64 bit signed +#define T_PFUQUAD 0x0223 // far pointer to 64 bit unsigned +#define T_PHQUAD 0x0313 // huge pointer to 64 bit signed +#define T_PHUQUAD 0x0323 // huge pointer to 64 bit unsigned +#define T_32PQUAD 0x0413 // 16:32 near pointer to 64 bit signed +#define T_32PUQUAD 0x0423 // 16:32 near pointer to 64 bit unsigned +#define T_32PFQUAD 0x0513 // 16:32 far pointer to 64 bit signed +#define T_32PFUQUAD 0x0523 // 16:32 far pointer to 64 bit unsigned + + + +// 64 bit int types + + +#define T_INT8 0x0076 // 64 bit signed int +#define T_UINT8 0x0077 // 64 bit unsigned int +#define T_PINT8 0x0176 // near pointer to 64 bit signed int +#define T_PUINT8 0x0177 // near pointer to 64 bit unsigned int +#define T_PFINT8 0x0276 // far pointer to 64 bit signed int +#define T_PFUINT8 0x0277 // far pointer to 64 bit unsigned int +#define T_PHINT8 0x0376 // huge pointer to 64 bit signed int +#define T_PHUINT8 0x0377 // huge pointer to 64 bit unsigned int + +#define T_32PINT8 0x0476 // 16:32 near pointer to 64 bit signed int +#define T_32PUINT8 0x0477 // 16:32 near pointer to 64 bit unsigned int +#define T_32PFINT8 0x0576 // 16:32 far pointer to 64 bit signed int +#define T_32PFUINT8 0x0577 // 16:32 far pointer to 64 bit unsigned int + + +// 128 bit octet types + + +#define T_OCT 0x0014 // 128 bit signed +#define T_UOCT 0x0024 // 128 bit unsigned +#define T_POCT 0x0114 // near pointer to 128 bit signed +#define T_PUOCT 0x0124 // near pointer to 128 bit unsigned +#define T_PFOCT 0x0214 // far pointer to 128 bit signed +#define T_PFUOCT 0x0224 // far pointer to 128 bit unsigned +#define T_PHOCT 0x0314 // huge pointer to 128 bit signed +#define T_PHUOCT 0x0324 // huge pointer to 128 bit unsigned + +#define T_32POCT 0x0414 // 16:32 near pointer to 128 bit signed +#define T_32PUOCT 0x0424 // 16:32 near pointer to 128 bit unsigned +#define T_32PFOCT 0x0514 // 16:32 far pointer to 128 bit signed +#define T_32PFUOCT 0x0524 // 16:32 far pointer to 128 bit unsigned + +// 128 bit int types + + +#define T_INT16 0x0078 // 128 bit signed int +#define T_UINT16 0x0079 // 128 bit unsigned int +#define T_PINT16 0x0178 // near pointer to 128 bit signed int +#define T_PUINT16 0x0179 // near pointer to 128 bit unsigned int +#define T_PFINT16 0x0278 // far pointer to 128 bit signed int +#define T_PFUINT16 0x0279 // far pointer to 128 bit unsigned int +#define T_PHINT16 0x0378 // huge pointer to 128 bit signed int +#define T_PHUINT16 0x0379 // huge pointer to 128 bit unsigned int + +#define T_32PINT16 0x0478 // 16:32 near pointer to 128 bit signed int +#define T_32PUINT16 0x0479 // 16:32 near pointer to 128 bit unsigned int +#define T_32PFINT16 0x0578 // 16:32 far pointer to 128 bit signed int +#define T_32PFUINT16 0x0579 // 16:32 far pointer to 128 bit unsigned int + + + + + +// 32 bit real types + + +#define T_REAL32 0x0040 // 32 bit real +#define T_PREAL32 0x0140 // near pointer to 32 bit real +#define T_PFREAL32 0x0240 // far pointer to 32 bit real +#define T_PHREAL32 0x0340 // huge pointer to 32 bit real +#define T_32PREAL32 0x0440 // 16:32 near pointer to 32 bit real +#define T_32PFREAL32 0x0540 // 16:32 far pointer to 32 bit real + + + +// 48 bit real types + + +#define T_REAL48 0x0044 // 48 bit real +#define T_PREAL48 0x0144 // near pointer to 48 bit real +#define T_PFREAL48 0x0244 // far pointer to 48 bit real +#define T_PHREAL48 0x0344 // huge pointer to 48 bit real +#define T_32PREAL48 0x0444 // 16:32 near pointer to 48 bit real +#define T_32PFREAL48 0x0544 // 16:32 far pointer to 48 bit real + + + + +// 64 bit real types + + +#define T_REAL64 0x0041 // 64 bit real +#define T_PREAL64 0x0141 // near pointer to 64 bit real +#define T_PFREAL64 0x0241 // far pointer to 64 bit real +#define T_PHREAL64 0x0341 // huge pointer to 64 bit real +#define T_32PREAL64 0x0441 // 16:32 near pointer to 64 bit real +#define T_32PFREAL64 0x0541 // 16:32 far pointer to 64 bit real + + + + +// 80 bit real types + + +#define T_REAL80 0x0042 // 80 bit real +#define T_PREAL80 0x0142 // near pointer to 80 bit real +#define T_PFREAL80 0x0242 // far pointer to 80 bit real +#define T_PHREAL80 0x0342 // huge pointer to 80 bit real +#define T_32PREAL80 0x0442 // 16:32 near pointer to 80 bit real +#define T_32PFREAL80 0x0542 // 16:32 far pointer to 80 bit real + + + + +// 128 bit real types + + +#define T_REAL128 0x0043 // 128 bit real +#define T_PREAL128 0x0143 // near pointer to 128 bit real +#define T_PFREAL128 0x0243 // far pointer to 128 bit real +#define T_PHREAL128 0x0343 // huge pointer to 128 bit real +#define T_32PREAL128 0x0443 // 16:32 near pointer to 128 bit real +#define T_32PFREAL128 0x0543 // 16:32 far pointer to 128 bit real + + + + +// 32 bit complex types + + +#define T_CPLX32 0x0050 // 32 bit complex +#define T_PCPLX32 0x0150 // near pointer to 32 bit complex +#define T_PFCPLX32 0x0250 // far pointer to 32 bit complex +#define T_PHCPLX32 0x0350 // huge pointer to 32 bit complex +#define T_32PCPLX32 0x0450 // 16:32 near pointer to 32 bit complex +#define T_32PFCPLX32 0x0550 // 16:32 far pointer to 32 bit complex + + + + +// 64 bit complex types + + +#define T_CPLX64 0x0051 // 64 bit complex +#define T_PCPLX64 0x0151 // near pointer to 64 bit complex +#define T_PFCPLX64 0x0251 // far pointer to 64 bit complex +#define T_PHCPLX64 0x0351 // huge pointer to 64 bit complex +#define T_32PCPLX64 0x0451 // 16:32 near pointer to 64 bit complex +#define T_32PFCPLX64 0x0551 // 16:32 far pointer to 64 bit complex + + + + +// 80 bit complex types + + +#define T_CPLX80 0x0052 // 80 bit complex +#define T_PCPLX80 0x0152 // near pointer to 80 bit complex +#define T_PFCPLX80 0x0252 // far pointer to 80 bit complex +#define T_PHCPLX80 0x0352 // huge pointer to 80 bit complex +#define T_32PCPLX80 0x0452 // 16:32 near pointer to 80 bit complex +#define T_32PFCPLX80 0x0552 // 16:32 far pointer to 80 bit complex + + + + +// 128 bit complex types + + +#define T_CPLX128 0x0053 // 128 bit complex +#define T_PCPLX128 0x0153 // near pointer to 128 bit complex +#define T_PFCPLX128 0x0253 // far pointer to 128 bit complex +#define T_PHCPLX128 0x0353 // huge pointer to 128 bit real +#define T_32PCPLX128 0x0453 // 16:32 near pointer to 128 bit complex +#define T_32PFCPLX128 0x0553 // 16:32 far pointer to 128 bit complex + + + + +// boolean types + + +#define T_BOOL08 0x0030 // 8 bit boolean +#define T_BOOL16 0x0031 // 16 bit boolean +#define T_BOOL32 0x0032 // 32 bit boolean +#define T_BOOL64 0x0033 // 64 bit boolean +#define T_PBOOL08 0x0130 // near pointer to 8 bit boolean +#define T_PBOOL16 0x0131 // near pointer to 16 bit boolean +#define T_PBOOL32 0x0132 // near pointer to 32 bit boolean +#define T_PBOOL64 0x0133 // near pointer to 64 bit boolean +#define T_PFBOOL08 0x0230 // far pointer to 8 bit boolean +#define T_PFBOOL16 0x0231 // far pointer to 16 bit boolean +#define T_PFBOOL32 0x0232 // far pointer to 32 bit boolean +#define T_PFBOOL64 0x0233 // far pointer to 64 bit boolean +#define T_PHBOOL08 0x0330 // huge pointer to 8 bit boolean +#define T_PHBOOL16 0x0331 // huge pointer to 16 bit boolean +#define T_PHBOOL32 0x0332 // huge pointer to 32 bit boolean +#define T_PHBOOL64 0x0333 // huge pointer to 64 bit boolean + +#define T_32PBOOL08 0x0430 // 16:32 near pointer to 8 bit boolean +#define T_32PFBOOL08 0x0530 // 16:32 far pointer to 8 bit boolean +#define T_32PBOOL16 0x0431 // 16:32 near pointer to 18 bit boolean +#define T_32PFBOOL16 0x0531 // 16:32 far pointer to 16 bit boolean +#define T_32PBOOL32 0x0432 // 16:32 near pointer to 32 bit boolean +#define T_32PFBOOL32 0x0532 // 16:32 far pointer to 32 bit boolean +#define T_32PBOOL64 0x0433 // 16:32 near pointer to 64 bit boolean +#define T_32PFBOOL64 0x0533 // 16:32 far pointer to 64 bit boolean + + +#define T_NCVPTR 0x01f0 // CV Internal type for created near pointers +#define T_FCVPTR 0x02f0 // CV Internal type for created far pointers +#define T_HCVPTR 0x03f0 // CV Internal type for created huge pointers +#define T_32NCVPTR 0x04f0 // CV Internal type for created near 32-bit pointers +#define T_32FCVPTR 0x05f0 // CV Internal type for created far 32-bit pointers +#define T_64NCVPTR 0x06f0 // CV Internal type for created near 64-bit pointers + +#define CV_IS_INTERNAL_PTR(typ) (CV_IS_PRIMITIVE(typ) && \ + CV_TYPE(typ) == CV_CVRESERVED && \ + CV_TYP_IS_PTR(typ)) + + +/** No leaf index can have a value of 0x0000. The leaf indices are + * separated into ranges depending upon the use of the type record. + * The second range is for the type records that are directly referenced + * in symbols. The first range is for type records that are not + * referenced by symbols but instead are referenced by other type + * records. All type records must have a starting leaf index in these + * first two ranges. The third range of leaf indices are used to build + * up complex lists such as the field list of a class type record. No + * type record can begin with one of the leaf indices. The fourth ranges + * of type indices are used to represent numeric data in a symbol or + * type record. These leaf indices are greater than 0x8000. At the + * point that type or symbol processor is expecting a numeric field, the + * next two bytes in the type record are examined. If the value is less + * than 0x8000, then the two bytes contain the numeric value. If the + * value is greater than 0x8000, then the data follows the leaf index in + * a format specified by the leaf index. The final range of leaf indices + * are used to force alignment of subfields within a complex type record.. + */ + + + + // leaf indices starting records but referenced from symbol records + +#define LF_MODIFIER 0x0001 +#define LF_POINTER 0x0002 +#define LF_ARRAY 0x0003 +#define LF_CLASS 0x0004 +#define LF_STRUCTURE 0x0005 +#define LF_UNION 0x0006 +#define LF_ENUM 0x0007 +#define LF_PROCEDURE 0x0008 +#define LF_MFUNCTION 0x0009 +#define LF_VTSHAPE 0x000a +#define LF_COBOL0 0x000b +#define LF_COBOL1 0x000c +#define LF_BARRAY 0x000d +#define LF_LABEL 0x000e +#define LF_NULL 0x000f +#define LF_NOTTRAN 0x0010 +#define LF_DIMARRAY 0x0011 +#define LF_VFTPATH 0x0012 +#define LF_PRECOMP 0x0013 // not referenced from symbol +#define LF_ENDPRECOMP 0x0014 // not referenced from symbol +#define LF_OEM 0x0015 // oem definable type string +#define LF_TYPESERVER 0x0016 // not referenced from symbol + + // leaf indices starting records but referenced only from type records + +#define LF_SKIP 0x0200 +#define LF_ARGLIST 0x0201 +#define LF_DEFARG 0x0202 +#define LF_LIST 0x0203 +#define LF_FIELDLIST 0x0204 +#define LF_DERIVED 0x0205 +#define LF_BITFIELD 0x0206 +#define LF_METHODLIST 0x0207 +#define LF_DIMCONU 0x0208 +#define LF_DIMCONLU 0x0209 +#define LF_DIMVARU 0x020a +#define LF_DIMVARLU 0x020b +#define LF_REFSYM 0x020c + +#define LF_BCLASS 0x0400 +#define LF_VBCLASS 0x0401 +#define LF_IVBCLASS 0x0402 +#define LF_ENUMERATE 0x0403 +#define LF_FRIENDFCN 0x0404 +#define LF_INDEX 0x0405 +#define LF_MEMBER 0x0406 +#define LF_STMEMBER 0x0407 +#define LF_METHOD 0x0408 +#define LF_NESTTYPE 0x0409 +#define LF_VFUNCTAB 0x040a +#define LF_FRIENDCLS 0x040b +#define LF_ONEMETHOD 0x040c +#define LF_VFUNCOFF 0x040d +#define LF_NESTTYPEEX 0x040e +#define LF_MEMBERMODIFY 0x040f + +#define LF_NUMERIC 0x8000 +#define LF_CHAR 0x8000 +#define LF_SHORT 0x8001 +#define LF_USHORT 0x8002 +#define LF_LONG 0x8003 +#define LF_ULONG 0x8004 +#define LF_REAL32 0x8005 +#define LF_REAL64 0x8006 +#define LF_REAL80 0x8007 +#define LF_REAL128 0x8008 +#define LF_QUADWORD 0x8009 +#define LF_UQUADWORD 0x800a +#define LF_REAL48 0x800b +#define LF_COMPLEX32 0x800c +#define LF_COMPLEX64 0x800d +#define LF_COMPLEX80 0x800e +#define LF_COMPLEX128 0x800f +#define LF_VARSTRING 0x8010 + +#define LF_OCTWORD 0x8017 +#define LF_UOCTWORD 0x8018 + +#define LF_PAD0 0xf0 +#define LF_PAD1 0xf1 +#define LF_PAD2 0xf2 +#define LF_PAD3 0xf3 +#define LF_PAD4 0xf4 +#define LF_PAD5 0xf5 +#define LF_PAD6 0xf6 +#define LF_PAD7 0xf7 +#define LF_PAD8 0xf8 +#define LF_PAD9 0xf9 +#define LF_PAD10 0xfa +#define LF_PAD11 0xfb +#define LF_PAD12 0xfc +#define LF_PAD13 0xfd +#define LF_PAD14 0xfe +#define LF_PAD15 0xff + +// end of leaf indices + + + + +// Type enum for pointer records +// Pointers can be one of the following types + + +typedef enum CV_ptrtype_e { + CV_PTR_NEAR = 0x00, // near pointer + CV_PTR_FAR = 0x01, // far pointer + CV_PTR_HUGE = 0x02, // huge pointer + CV_PTR_BASE_SEG = 0x03, // based on segment + CV_PTR_BASE_VAL = 0x04, // based on value of base + CV_PTR_BASE_SEGVAL = 0x05, // based on segment value of base + CV_PTR_BASE_ADDR = 0x06, // based on address of base + CV_PTR_BASE_SEGADDR = 0x07, // based on segment address of base + CV_PTR_BASE_TYPE = 0x08, // based on type + CV_PTR_BASE_SELF = 0x09, // based on self + CV_PTR_NEAR32 = 0x0a, // 16:32 near pointer + CV_PTR_FAR32 = 0x0b, // 16:32 far pointer + CV_PTR_UNUSEDPTR = 0x0c // first unused pointer type +} CV_ptrtype_e; + + + + + +// Mode enum for pointers +// Pointers can have one of the following modes + + +typedef enum CV_ptrmode_e { + CV_PTR_MODE_PTR = 0x00, // "normal" pointer + CV_PTR_MODE_REF = 0x01, // reference + CV_PTR_MODE_PMEM = 0x02, // pointer to data member + CV_PTR_MODE_PMFUNC = 0x03, // pointer to member function + CV_PTR_MODE_RESERVED= 0x04 // first unused pointer mode +} CV_ptrmode_e; + + + + +// Enumeration for function call type + + +typedef enum CV_call_e { + CV_CALL_NEAR_C = 0x00, // near right to left push, caller pops stack + CV_CALL_FAR_C = 0x01, // far right to left push, caller pops stack + CV_CALL_NEAR_PASCAL = 0x02, // near left to right push, callee pops stack + CV_CALL_FAR_PASCAL = 0x03, // far left to right push, callee pops stack + CV_CALL_NEAR_FAST = 0x04, // near left to right push with regs, callee pops stack + CV_CALL_FAR_FAST = 0x05, // far left to right push with regs, callee pops stack + CV_CALL_SKIPPED = 0x06, // skipped (unused) call index + CV_CALL_NEAR_STD = 0x07, // near standard call + CV_CALL_FAR_STD = 0x08, // far standard call + CV_CALL_NEAR_SYS = 0x09, // near sys call + CV_CALL_FAR_SYS = 0x0a, // far sys call + CV_CALL_THISCALL = 0x0b, // this call (this passed in register) + CV_CALL_MIPSCALL = 0x0c, // Mips call + CV_CALL_GENERIC = 0x0d, // Generic call sequence + CV_CALL_ALPHACALL = 0x0e, // Alpha call + CV_CALL_PPCCALL = 0x0f, // PPC call + CV_CALL_RESERVED = 0x10 // first unused call enumeration +} CV_call_e; + + + + +// Values for the access protection of class attributes + + +typedef enum CV_access_e { + CV_private = 1, + CV_protected = 2, + CV_public = 3 +} CV_access_e; + + + +// enumeration for method properties + +typedef enum CV_methodprop_e { + CV_MTvanilla = 0x00, + CV_MTvirtual = 0x01, + CV_MTstatic = 0x02, + CV_MTfriend = 0x03, + CV_MTintro = 0x04, + CV_MTpurevirt = 0x05, + CV_MTpureintro = 0x06 +} CV_methodprop_e; + + + + +// enumeration for virtual shape table entries + +typedef enum CV_VTS_desc_e { + CV_VTS_near = 0x00, + CV_VTS_far = 0x01, + CV_VTS_thin = 0x02, + CV_VTS_outer = 0x03, + CV_VTS_meta = 0x04, + CV_VTS_near32 = 0x05, + CV_VTS_far32 = 0x06, + CV_VTS_unused = 0x07 +} CV_VTS_desc_e; + + + + +// enumeration for LF_LABEL address modes + +typedef enum CV_LABEL_TYPE_e { + CV_LABEL_NEAR = 0, // near return + CV_LABEL_FAR = 4 // far return +} CV_LABEL_TYPE_e; + + + +// enumeration for LF_MODIFIER values + + +typedef struct CV_modifier_t { + unsigned short MOD_const :1; + unsigned short MOD_volatile :1; + unsigned short MOD_unaligned :1; + unsigned short MOD_unused :13; +} CV_modifier_t; + + +// bit field structure describing class/struct/union/enum properties + +typedef struct CV_prop_t { + unsigned short packed :1; // true if structure is packed + unsigned short ctor :1; // true if constructors or destructors present + unsigned short ovlops :1; // true if overloaded operators present + unsigned short isnested :1; // true if this is a nested class + unsigned short cnested :1; // true if this class contains nested types + unsigned short opassign :1; // true if overloaded assignment (=) + unsigned short opcast :1; // true if casting methods + unsigned short fwdref :1; // true if forward reference (incomplete defn) + unsigned short scoped :1; // scoped definition + unsigned short reserved :7; +} CV_prop_t; + + + + +// class field attribute + +typedef struct CV_fldattr_t { + unsigned short access :2; // access protection CV_access_t + unsigned short mprop :3; // method properties CV_methodprop_t + unsigned short pseudo :1; // compiler generated fcn and does not exist + unsigned short noinherit :1; // true if class cannot be inherited + unsigned short noconstruct :1; // true if class cannot be constructed + unsigned short compgenx :1; // compiler generated fcn and does exist + unsigned short unused :7; // unused +} CV_fldattr_t; + + + +// Structures to access to the type records + + +typedef struct TYPTYPE { + unsigned short len; + unsigned short leaf; + unsigned char data[CV_ZEROLEN]; +} TYPTYPE; // general types record + + +__INLINE char *NextType (char * pType) { + return (pType + ((TYPTYPE *)pType)->len + sizeof(unsigned short)); +} + +typedef enum CV_PMEMBER { + CV_PDM16_NONVIRT = 0x00, // 16:16 data no virtual fcn or base + CV_PDM16_VFCN = 0x01, // 16:16 data with virtual functions + CV_PDM16_VBASE = 0x02, // 16:16 data with virtual bases + CV_PDM32_NVVFCN = 0x03, // 16:32 data w/wo virtual functions + CV_PDM32_VBASE = 0x04, // 16:32 data with virtual bases + + CV_PMF16_NEARNVSA = 0x05, // 16:16 near method nonvirtual single address point + CV_PMF16_NEARNVMA = 0x06, // 16:16 near method nonvirtual multiple address points + CV_PMF16_NEARVBASE = 0x07, // 16:16 near method virtual bases + CV_PMF16_FARNVSA = 0x08, // 16:16 far method nonvirtual single address point + CV_PMF16_FARNVMA = 0x09, // 16:16 far method nonvirtual multiple address points + CV_PMF16_FARVBASE = 0x0a, // 16:16 far method virtual bases + + CV_PMF32_NVSA = 0x0b, // 16:32 method nonvirtual single address point + CV_PMF32_NVMA = 0x0c, // 16:32 method nonvirtual multiple address point + CV_PMF32_VBASE = 0x0d // 16:32 method virtual bases +} CV_PMEMBER; + + + +// memory representation of pointer to member. These representations are +// indexed by the enumeration above in the LF_POINTER record + + + + +// representation of a 16:16 pointer to data for a class with no +// virtual functions or virtual bases + + +struct CV_PDMR16_NONVIRT { + CV_off16_t mdisp; // displacement to data (NULL = -1) +}; + + + + +// representation of a 16:16 pointer to data for a class with virtual +// functions + + +struct CV_PMDR16_VFCN { + CV_off16_t mdisp; // displacement to data ( NULL = 0) +}; + + + + +// representation of a 16:16 pointer to data for a class with +// virtual bases + + +struct CV_PDMR16_VBASE { + CV_off16_t mdisp; // displacement to data + CV_off16_t pdisp; // this pointer displacement to vbptr + CV_off16_t vdisp; // displacement within vbase table + // NULL = (,,0xffff) +}; + + + + +// representation of a 16:32 near pointer to data for a class with +// or without virtual functions and no virtual bases + + +struct CV_PDMR32_NVVFCN { + CV_off32_t mdisp; // displacement to data (NULL = 0x80000000) +}; + + + + +// representation of a 16:32 near pointer to data for a class +// with virtual bases + + +struct CV_PDMR32_VBASE { + CV_off32_t mdisp; // displacement to data + CV_off32_t pdisp; // this pointer displacement + CV_off32_t vdisp; // vbase table displacement + // NULL = (,,0xffffffff) +}; + + + + +// representation of a 16:16 pointer to near member function for a +// class with no virtual functions or bases and a single address point + + +struct CV_PMFR16_NEARNVSA { + CV_uoff16_t off; // near address of function (NULL = 0) +}; + + + +// representation of a 16:16 near pointer to member functions of a +// class with no virtual bases and multiple address points + + +struct CV_PMFR16_NEARNVMA { + CV_uoff16_t off; // offset of function (NULL = 0,x) + signed short disp; +}; + + + + +// representation of a 16:16 near pointer to member function of a +// class with virtual bases + + +struct CV_PMFR16_NEARVBASE { + CV_uoff16_t off; // offset of function (NULL = 0,x,x,x) + CV_off16_t mdisp; // displacement to data + CV_off16_t pdisp; // this pointer displacement + CV_off16_t vdisp; // vbase table displacement +}; + + + + +// representation of a 16:16 pointer to far member function for a +// class with no virtual bases and a single address point + + +struct CV_PMFR16_FARNVSA { + CV_uoff16_t off; // offset of function (NULL = 0:0) + unsigned short seg; // segment of function +}; + + + + +// representation of a 16:16 far pointer to member functions of a +// class with no virtual bases and multiple address points + + +struct CV_PMFR16_FARNVMA { + CV_uoff16_t off; // offset of function (NULL = 0:0,x) + unsigned short seg; + signed short disp; +}; + + + + +// representation of a 16:16 far pointer to member function of a +// class with virtual bases + + +struct CV_PMFR16_FARVBASE { + CV_uoff16_t off; // offset of function (NULL = 0:0,x,x,x) + unsigned short seg; + CV_off16_t mdisp; // displacement to data + CV_off16_t pdisp; // this pointer displacement + CV_off16_t vdisp; // vbase table displacement + +}; + + + + +// representation of a 16:32 near pointer to member function for a +// class with no virtual bases and a single address point + + +struct CV_PMFR32_NVSA { + CV_uoff32_t off; // near address of function (NULL = 0L) +}; + + + + +// representation of a 16:32 near pointer to member function for a +// class with no virtual bases and multiple address points + + +struct CV_PMFR32_NVMA { + CV_uoff32_t off; // near address of function (NULL = 0L,x) + CV_off32_t disp; +}; + + + + +// representation of a 16:32 near pointer to member function for a +// class with virtual bases + + +struct CV_PMFR32_VBASE { + CV_uoff32_t off; // near address of function (NULL = 0L,x,x,x) + CV_off32_t mdisp; // displacement to data + CV_off32_t pdisp; // this pointer displacement + CV_off32_t vdisp; // vbase table displacement +}; + + + + + +// Easy leaf - used for generic casting to reference leaf field +// of a subfield of a complex list + +typedef struct lfEasy { + unsigned short leaf; // LF_... +} lfEasy; + + +/** The following type records are basically variant records of the + * above structure. The "unsigned short leaf" of the above structure and + * the "unsigned short leaf" of the following type definitions are the same + * symbol. When the OMF record is locked via the MHOMFLock API + * call, the address of the "unsigned short leaf" is returned + */ + + +// Type record for LF_MODIFIER + + +typedef struct lfModifier { + unsigned short leaf; // LF_MODIFIER + CV_modifier_t attr; // modifier attribute modifier_t + CV_typ_t type; // modified type +} lfModifier; + + + + +// type record for LF_POINTER + +#ifndef __cplusplus +typedef struct lfPointer { +#endif + struct lfPointerBody { + unsigned short leaf; // LF_POINTER + struct lfPointerAttr { + unsigned char ptrtype :5; // ordinal specifying pointer type (ptrtype-t) + unsigned char ptrmode :3; // ordinal specifying pointer mode (ptrmode_t) + unsigned char isflat32 :1; // true if 0:32 pointer + unsigned char isvolatile :1; // TRUE if volatile pointer + unsigned char isconst :1; // TRUE if const pointer + unsigned char isunaligned :1; // TRUE if unaligned pointer + unsigned char unused :4; + } attr; + CV_typ_t utype; // type index of the underlying type +#if (defined(__cplusplus) || defined(_MSC_VER)) // for C++ and MS compilers that support unnamed unions + }; +#else + } u; +#endif +#ifdef __cplusplus +typedef struct lfPointer : public lfPointerBody { +#endif + union { + struct { + CV_typ_t pmclass; // index of containing class for pointer to member + unsigned short pmenum; // enumeration specifying pm format + } pm; + unsigned short bseg; // base segment if PTR_BASE_SEG + unsigned char Sym[1]; // copy of base symbol record (including length) + struct { + CV_typ_t index; // type index if CV_PTR_BASE_TYPE + unsigned char name[1]; // name of base type + } btype; + } pbase; +} lfPointer; + + + + +// type record for LF_ARRAY + + +typedef struct lfArray { + unsigned short leaf; // LF_ARRAY + CV_typ_t elemtype; // type index of element type + CV_typ_t idxtype; // type index of indexing type + unsigned char data[CV_ZEROLEN]; // variable length data specifying + // size in bytes and name +} lfArray; + + + + +// type record for LF_CLASS, LF_STRUCTURE + + +typedef struct lfClass { + unsigned short leaf; // LF_CLASS, LF_STRUCT + unsigned short count; // count of number of elements in class + CV_typ_t field; // type index of LF_FIELD descriptor list + CV_prop_t property; // property attribute field (prop_t) + CV_typ_t derived; // type index of derived from list if not zero + CV_typ_t vshape; // type index of vshape table for this class + unsigned char data[CV_ZEROLEN]; // data describing length of structure in + // bytes and name +} lfClass; +typedef lfClass lfStructure; + + + + +// type record for LF_UNION + + +typedef struct lfUnion { + unsigned short leaf; // LF_UNION + unsigned short count; // count of number of elements in class + CV_typ_t field; // type index of LF_FIELD descriptor list + CV_prop_t property; // property attribute field + unsigned char data[CV_ZEROLEN]; // variable length data describing length of + // structure and name +} lfUnion; + + + + +// type record for LF_ENUM + + +typedef struct lfEnum { + unsigned short leaf; // LF_ENUM + unsigned short count; // count of number of elements in class + CV_typ_t utype; // underlying type of the enum + CV_typ_t field; // type index of LF_FIELD descriptor list + CV_prop_t property; // property attribute field + unsigned char Name[1]; // length prefixed name of enum +} lfEnum; + + + + +// Type record for LF_PROCEDURE + + +typedef struct lfProc { + unsigned short leaf; // LF_PROCEDURE + CV_typ_t rvtype; // type index of return value + unsigned char calltype; // calling convention (CV_call_t) + unsigned char reserved; // reserved for future use + unsigned short parmcount; // number of parameters + CV_typ_t arglist; // type index of argument list +} lfProc; + + + +// Type record for member function + + +typedef struct lfMFunc { + unsigned short leaf; // LF_MFUNCTION + CV_typ_t rvtype; // type index of return value + CV_typ_t classtype; // type index of containing class + CV_typ_t thistype; // type index of this pointer (model specific) + unsigned char calltype; // calling convention (call_t) + unsigned char reserved; // reserved for future use + unsigned short parmcount; // number of parameters + CV_typ_t arglist; // type index of argument list + long thisadjust; // this adjuster (long because pad required anyway) +} lfMFunc; + + + + +// type record for virtual function table shape + + +typedef struct lfVTShape { + unsigned short leaf; // LF_VTSHAPE + unsigned short count; // number of entries in vfunctable + unsigned char desc[CV_ZEROLEN]; // 4 bit (CV_VTS_desc) descriptors +} lfVTShape; + + + + +// type record for cobol0 + + +typedef struct lfCobol0 { + unsigned short leaf; // LF_COBOL0 + CV_typ_t type; // parent type record index + unsigned char data[CV_ZEROLEN]; +} lfCobol0; + + + + +// type record for cobol1 + + +typedef struct lfCobol1 { + unsigned short leaf; // LF_COBOL1 + unsigned char data[CV_ZEROLEN]; +} lfCobol1; + + + + +// type record for basic array + + +typedef struct lfBArray { + unsigned short leaf; // LF_BARRAY + CV_typ_t utype; // type index of underlying type +} lfBArray; + +// type record for assembler labels + + +typedef struct lfLabel { + unsigned short leaf; // LF_LABEL + unsigned short mode; // addressing mode of label +} lfLabel; + + + +// type record for dimensioned arrays + + +typedef struct lfDimArray { + unsigned short leaf; // LF_DIMARRAY + CV_typ_t utype; // underlying type of the array + CV_typ_t diminfo; // dimension information + unsigned char name[1]; // length prefixed name +} lfDimArray; + + + +// type record describing path to virtual function table + + +typedef struct lfVFTPath { + unsigned short leaf; // LF_VFTPATH + unsigned short count; // count of number of bases in path + CV_typ_t base[1]; // bases from root to leaf +} lfVFTPath; + + +// type record describing inclusion of precompiled types + + +typedef struct lfPreComp { + unsigned short leaf; // LF_PRECOMP + unsigned short start; // starting type index included + unsigned short count; // number of types in inclusion + unsigned long signature; // signature + unsigned char name[CV_ZEROLEN]; // length prefixed name of included type file +} lfPreComp; + + +// type record describing end of precompiled types that can be +// included by another file + + +typedef struct lfEndPreComp { + unsigned short leaf; // LF_ENDPRECOMP + unsigned long signature; // signature +} lfEndPreComp; + + + + + +// type record for OEM definable type strings + + +typedef struct lfOEM { + unsigned short leaf; // LF_OEM + unsigned short cvOEM; // MS assigned OEM identified + unsigned short recOEM; // OEM assigned type identifier + unsigned short count; // count of type indices to follow + CV_typ_t index[CV_ZEROLEN]; // array of type indices followed + // by OEM defined data +} lfOEM; + +#define OEM_MS_FORTRAN90 0xF090 +#define OEM_ODI 0x0010 +#define OEM_THOMSON_SOFTWARE 0x5453 +#define OEM_ODI_REC_BASELIST 0x0000 + + +// type record describing using of a type server + +typedef struct lfTypeServer { + unsigned short leaf; // LF_TYPESERVER + unsigned long signature; // signature + unsigned long age; // age of database used by this module + unsigned char name[CV_ZEROLEN]; // length prefixed name of PDB +} lfTypeServer; + +// description of type records that can be referenced from +// type records referenced by symbols + + + +// type record for skip record + + +typedef struct lfSkip { + unsigned short leaf; // LF_SKIP + CV_typ_t type; // next valid index + unsigned char data[CV_ZEROLEN]; // pad data +} lfSkip; + + + +// argument list leaf + + +typedef struct lfArgList { + unsigned short leaf; // LF_ARGLIST + unsigned short count; // number of arguments + CV_typ_t arg[CV_ZEROLEN]; // number of arguments +} lfArgList; + + + + +// derived class list leaf + + +typedef struct lfDerived { + unsigned short leaf; // LF_DERIVED + unsigned short count; // number of arguments + CV_typ_t drvdcls[CV_ZEROLEN]; // type indices of derived classes +} lfDerived; + + + + +// leaf for default arguments + + +typedef struct lfDefArg { + unsigned short leaf; // LF_DEFARG + CV_typ_t type; // type of resulting expression + unsigned char expr[CV_ZEROLEN]; // length prefixed expression string +} lfDefArg; + + + +// list leaf +// This list should no longer be used because the utilities cannot +// verify the contents of the list without knowing what type of list +// it is. New specific leaf indices should be used instead. + + +typedef struct lfList { + unsigned short leaf; // LF_LIST + char data[CV_ZEROLEN]; // data format specified by indexing type +} lfList; + + + + +// field list leaf +// This is the header leaf for a complex list of class and structure +// subfields. + + +typedef struct lfFieldList { + unsigned short leaf; // LF_FIELDLIST + char data[CV_ZEROLEN]; // field list sub lists +} lfFieldList; + + + + + + + +// type record for non-static methods and friends in overloaded method list + +typedef struct mlMethod { + CV_fldattr_t attr; // method attribute + CV_typ_t index; // index to type record for procedure + unsigned long vbaseoff[CV_ZEROLEN]; // offset in vfunctable if intro virtual +} mlMethod; + + +typedef struct lfMethodList { + unsigned short leaf; + unsigned char mList[CV_ZEROLEN]; // really a mlMethod type +} lfMethodList; + + + + + +// type record for LF_BITFIELD + + +typedef struct lfBitfield { + unsigned short leaf; // LF_BITFIELD + unsigned char length; + unsigned char position; + CV_typ_t type; // type of bitfield + +} lfBitfield; + + + + +// type record for dimensioned array with constant bounds + + +typedef struct lfDimCon { + unsigned short leaf; // LF_DIMCONU or LF_DIMCONLU + unsigned short rank; // number of dimensions + CV_typ_t typ; // type of index + unsigned char dim[CV_ZEROLEN]; // array of dimension information with + // either upper bounds or lower/upper bound +} lfDimCon; + + + + +// type record for dimensioned array with variable bounds + + +typedef struct lfDimVar { + unsigned short leaf; // LF_DIMVARU or LF_DIMVARLU + unsigned short rank; // number of dimensions + CV_typ_t typ; // type of index + unsigned char dim[CV_ZEROLEN]; // array of type indices for either + // variable upper bound or variable + // lower/upper bound. The referenced + // types must be LF_REFSYM or T_VOID +} lfDimVar; + + + + +// type record for referenced symbol + + +typedef struct lfRefSym { + unsigned short leaf; // LF_REFSYM + unsigned char Sym[1]; // copy of referenced symbol record + // (including length) +} lfRefSym; + + + + + +/** the following are numeric leaves. They are used to indicate the + * size of the following variable length data. When the numeric + * data is a single byte less than 0x8000, then the data is output + * directly. If the data is more the 0x8000 or is a negative value, + * then the data is preceeded by the proper index. + */ + + + +// signed character leaf + +typedef struct lfChar { + unsigned short leaf; // LF_CHAR + signed char val; // signed 8-bit value +} lfChar; + + + + +// signed short leaf + +typedef struct lfShort { + unsigned short leaf; // LF_SHORT + short val; // signed 16-bit value +} lfShort; + + + + +// unsigned short leaf + +typedef struct lfUShort { + unsigned short leaf; // LF_unsigned short + unsigned short val; // unsigned 16-bit value +} lfUShort; + + + + +// signed long leaf + +typedef struct lfLong { + unsigned short leaf; // LF_LONG + long val; // signed 32-bit value +} lfLong; + + + + +// unsigned long leaf + +typedef struct lfULong { + unsigned short leaf; // LF_ULONG + unsigned long val; // unsigned 32-bit value +} lfULong; + + + + +// signed quad leaf + +typedef struct lfQuad { + unsigned short leaf; // LF_QUAD + unsigned char val[8]; // signed 64-bit value +} lfQuad; + + + + +// unsigned quad leaf + +typedef struct lfUQuad { + unsigned short leaf; // LF_UQUAD + unsigned char val[8]; // unsigned 64-bit value +} lfUQuad; + + +// signed int128 leaf + +typedef struct lfOct { + unsigned short leaf; // LF_OCT + unsigned char val[16]; // signed 128-bit value +} lfOct; + +// unsigned int128 leaf + +typedef struct lfUOct { + unsigned short leaf; // LF_UOCT + unsigned char val[16]; // unsigned 128-bit value +} lfUOct; + + + + +// real 32-bit leaf + +typedef struct lfReal32 { + unsigned short leaf; // LF_REAL32 + float val; // 32-bit real value +} lfReal32; + + + + +// real 48-bit leaf + +typedef struct lfReal48 { + unsigned short leaf; // LF_REAL48 + unsigned char val[6]; // 48-bit real value +} lfReal48; + + + + +// real 64-bit leaf + +typedef struct lfReal64 { + unsigned short leaf; // LF_REAL64 + double val; // 64-bit real value +} lfReal64; + + + + +// real 80-bit leaf + +typedef struct lfReal80 { + unsigned short leaf; // LF_REAL80 + FLOAT10 val; // real 80-bit value +} lfReal80; + + + + +// real 128-bit leaf + +typedef struct lfReal128 { + unsigned short leaf; // LF_REAL128 + char val[16]; // real 128-bit value +} lfReal128; + + + + +// complex 32-bit leaf + +typedef struct lfCmplx32 { + unsigned short leaf; // LF_COMPLEX32 + float val_real; // real component + float val_imag; // imaginary component +} lfCmplx32; + + + + +// complex 64-bit leaf + +typedef struct lfCmplx64 { + unsigned short leaf; // LF_COMPLEX64 + double val_real; // real component + double val_imag; // imaginary component +} flCmplx64; + + + + +// complex 80-bit leaf + +typedef struct lfCmplx80 { + unsigned short leaf; // LF_COMPLEX80 + FLOAT10 val_real; // real component + FLOAT10 val_imag; // imaginary component +} lfCmplx80; + + + + +// complex 128-bit leaf + +typedef struct lfCmplx128 { + unsigned short leaf; // LF_COMPLEX128 + char val_real[16]; // real component + char val_imag[16]; // imaginary component +} lfCmplx128; + + + +// variable length numeric field + +typedef struct lfVarString { + unsigned short leaf; // LF_VARSTRING + unsigned short len; // length of value in bytes + unsigned char value[CV_ZEROLEN]; // value +} lfVarString; + +//*********************************************************************** + + +// index leaf - contains type index of another leaf +// a major use of this leaf is to allow the compilers to emit a +// long complex list (LF_FIELD) in smaller pieces. + +typedef struct lfIndex { + unsigned short leaf; // LF_INDEX + CV_typ_t index; // type index of referenced leaf +} lfIndex; + + +// subfield record for base class field + +typedef struct lfBClass { + unsigned short leaf; // LF_BCLASS + CV_typ_t index; // type index of base class + CV_fldattr_t attr; // attribute + unsigned char offset[CV_ZEROLEN]; // variable length offset of base within class +} lfBClass; + + + + + +// subfield record for direct and indirect virtual base class field + +typedef struct lfVBClass { + unsigned short leaf; // LF_VBCLASS | LV_IVBCLASS + CV_typ_t index; // type index of direct virtual base class + CV_typ_t vbptr; // type index of virtual base pointer + CV_fldattr_t attr; // attribute + unsigned char vbpoff[CV_ZEROLEN]; // virtual base pointer offset from address point + // followed by virtual base offset from vbtable +} lfVBClass; + + + + + +// subfield record for friend class + + +typedef struct lfFriendCls { + unsigned short leaf; // LF_FRIENDCLS + CV_typ_t index; // index to type record of friend class +} lfFriendCls; + + + + + +// subfield record for friend function + + +typedef struct lfFriendFcn { + unsigned short leaf; // LF_FRIENDFCN + CV_typ_t index; // index to type record of friend function + unsigned char Name[1]; // name of friend function +} lfFriendFcn; + + + +// subfield record for non-static data members + +typedef struct lfMember { + unsigned short leaf; // LF_MEMBER + CV_typ_t index; // index of type record for field + CV_fldattr_t attr; // attribute mask + unsigned char offset[CV_ZEROLEN]; // variable length offset of field followed + // by length prefixed name of field +} lfMember; + + + +// type record for static data members + +typedef struct lfSTMember { + unsigned short leaf; // LF_STMEMBER + CV_typ_t index; // index of type record for field + CV_fldattr_t attr; // attribute mask + unsigned char Name[1]; // length prefixed name of field +} lfSTMember; + + + +// subfield record for virtual function table pointer + +typedef struct lfVFuncTab { + unsigned short leaf; // LF_VFUNCTAB + CV_typ_t type; // type index of pointer +} lfVFuncTab; + + + +// subfield record for virtual function table pointer with offset + +typedef struct lfVFuncOff { + unsigned short leaf; // LF_VFUNCTAB + CV_typ_t type; // type index of pointer + CV_off32_t offset; // offset of virtual function table pointer +} lfVFuncOff; + + + +// subfield record for overloaded method list + + +typedef struct lfMethod { + unsigned short leaf; // LF_METHOD + unsigned short count; // number of occurances of function + CV_typ_t mList; // index to LF_METHODLIST record + unsigned char Name[1]; // length prefixed name of method +} lfMethod; + + + +// subfield record for nonoverloaded method + + +typedef struct lfOneMethod { + unsigned short leaf; // LF_ONEMETHOD + CV_fldattr_t attr; // method attribute + CV_typ_t index; // index to type record for procedure + unsigned long vbaseoff[CV_ZEROLEN]; // offset in vfunctable if + // intro virtual followed by + // length prefixed name of method +} lfOneMethod; + + +// subfield record for enumerate + +typedef struct lfEnumerate { + unsigned short leaf; // LF_ENUMERATE + CV_fldattr_t attr; // access + unsigned char value[CV_ZEROLEN]; // variable length value field followed + // by length prefixed name +} lfEnumerate; + + +// type record for nested (scoped) type definition + +typedef struct lfNestType { + unsigned short leaf; // LF_NESTTYPE + CV_typ_t index; // index of nested type definition + unsigned char Name[1]; // length prefixed type name +} lfNestType; + +// type record for nested (scoped) type definition, with attributes + +typedef struct lfNestTypeEx { + unsigned short leaf; // LF_NESTTYPEEX + CV_typ_t index; // index of nested type definition + CV_fldattr_t attr; // member access + unsigned char Name[1]; // length prefixed type name +} lfNestTypeEx; + +// type record for modifications to members + +typedef struct lfMemberModify { + unsigned short leaf; // LF_MEMBERMODIFY + CV_typ_t index; // index of base class type definition + CV_fldattr_t attr; // the new attributes + unsigned char Name[1]; // length prefixed member name +} lfMemberModify; + +// type record for pad leaf + +typedef struct lfPad { + unsigned char leaf; +} SYM_PAD; + + + +// Symbol definitions + +typedef enum SYM_ENUM_e { + S_COMPILE = 0x0001, // Compile flags symbol + S_REGISTER = 0x0002, // Register variable + S_CONSTANT = 0x0003, // constant symbol + S_UDT = 0x0004, // User defined type + S_SSEARCH = 0x0005, // Start Search + S_END = 0x0006, // Block, procedure, "with" or thunk end + S_SKIP = 0x0007, // Reserve symbol space in $$Symbols table + S_CVRESERVE = 0x0008, // Reserved symbol for CV internal use + S_OBJNAME = 0x0009, // path to object file name + S_ENDARG = 0x000a, // end of argument/return list + S_COBOLUDT = 0x000b, // special UDT for cobol that does not symbol pack + S_MANYREG = 0x000c, // multiple register variable + S_RETURN = 0x000d, // return description symbol + S_ENTRYTHIS = 0x000e, // description of this pointer on entry + + S_BPREL16 = 0x0100, // BP-relative + S_LDATA16 = 0x0101, // Module-local symbol + S_GDATA16 = 0x0102, // Global data symbol + S_PUB16 = 0x0103, // a public symbol + S_LPROC16 = 0x0104, // Local procedure start + S_GPROC16 = 0x0105, // Global procedure start + S_THUNK16 = 0x0106, // Thunk Start + S_BLOCK16 = 0x0107, // block start + S_WITH16 = 0x0108, // with start + S_LABEL16 = 0x0109, // code label + S_CEXMODEL16 = 0x010a, // change execution model + S_VFTABLE16 = 0x010b, // address of virtual function table + S_REGREL16 = 0x010c, // register relative address + + S_BPREL32 = 0x0200, // BP-relative + S_LDATA32 = 0x0201, // Module-local symbol + S_GDATA32 = 0x0202, // Global data symbol + S_PUB32 = 0x0203, // a public symbol (CV internal reserved) + S_LPROC32 = 0x0204, // Local procedure start + S_GPROC32 = 0x0205, // Global procedure start + S_THUNK32 = 0x0206, // Thunk Start + S_BLOCK32 = 0x0207, // block start + S_WITH32 = 0x0208, // with start + S_LABEL32 = 0x0209, // code label + S_CEXMODEL32 = 0x020a, // change execution model + S_VFTABLE32 = 0x020b, // address of virtual function table + S_REGREL32 = 0x020c, // register relative address + S_LTHREAD32 = 0x020d, // local thread storage + S_GTHREAD32 = 0x020e, // global thread storage + S_SLINK32 = 0x020f, // static link for MIPS EH implementation + + S_LPROCMIPS = 0x0300, // Local procedure start + S_GPROCMIPS = 0x0301, // Global procedure start + + S_PROCREF = 0x0400, // Reference to a procedure + S_DATAREF = 0x0401, // Reference to data + S_ALIGN = 0x0402, // Used for page alignment of symbols + S_LPROCREF = 0x0403 // Local Reference to a procedure +} SYM_ENUM_e; + + + + +// enum describing the compile flag source language + + +typedef enum CV_CFL_LANG { + CV_CFL_C = 0x00, + CV_CFL_CXX = 0x01, + CV_CFL_FORTRAN = 0x02, + CV_CFL_MASM = 0x03, + CV_CFL_PASCAL = 0x04, + CV_CFL_BASIC = 0x05, + CV_CFL_COBOL = 0x06, + CV_CFL_LINK = 0x07, + CV_CFL_CVTRES = 0x08, +} CV_CFL_LANG; + + + +// enum describing target processor + + +typedef enum CV_CPU_TYPE_e { + CV_CFL_8080 = 0x00, + CV_CFL_8086 = 0x01, + CV_CFL_80286 = 0x02, + CV_CFL_80386 = 0x03, + CV_CFL_80486 = 0x04, + CV_CFL_PENTIUM = 0x05, + CV_CFL_MIPSR4000 = 0x10, + CV_CFL_M68000 = 0x20, + CV_CFL_M68010 = 0x21, + CV_CFL_M68020 = 0x22, + CV_CFL_M68030 = 0x23, + CV_CFL_M68040 = 0x24, + CV_CFL_ALPHA = 0x30, + CV_CFL_PPC601 = 0x40, + CV_CFL_PPC603 = 0x41, + CV_CFL_PPC604 = 0x42, + CV_CFL_PPC620 = 0x43 + +} CV_CPU_TYPE_e; + + + + +// enum describing compile flag ambiant data model + + +typedef enum CV_CFL_DATA { + CV_CFL_DNEAR = 0x00, + CV_CFL_DFAR = 0x01, + CV_CFL_DHUGE = 0x02 +} CV_CFL_DATA; + + + + +// enum describing compile flag ambiant code model + + +typedef enum CV_CFL_CODE_e { + CV_CFL_CNEAR = 0x00, + CV_CFL_CFAR = 0x01, + CV_CFL_CHUGE = 0x02 +} CV_CFL_CODE_e; + + + + +// enum describing compile flag target floating point package + +typedef enum CV_CFL_FPKG_e { + CV_CFL_NDP = 0x00, + CV_CFL_EMU = 0x01, + CV_CFL_ALT = 0x02 +} CV_CFL_FPKG_e; + + +// enum describing function return method + + +typedef struct CV_PROCFLAGS { + union { + unsigned char bAll; + struct { + unsigned char CV_PFLAG_NOFPO:1; // frame pointer present + unsigned char CV_PFLAG_INT :1; // interrupt return + unsigned char CV_PFLAG_FAR :1; // far return + unsigned char CV_PFLAG_NEVER:1; // function does not return + unsigned char unused :4; // + }; + }; +} CV_PROCFLAGS; + + +// enum describing function data return method + +typedef enum CV_GENERIC_STYLE_e { + CV_GENERIC_VOID = 0x00, // void return type + CV_GENERIC_REG = 0x01, // return data is in registers + CV_GENERIC_ICAN = 0x02, // indirect caller allocated near + CV_GENERIC_ICAF = 0x03, // indirect caller allocated far + CV_GENERIC_IRAN = 0x04, // indirect returnee allocated near + CV_GENERIC_IRAF = 0x05, // indirect returnee allocated far + CV_GENERIC_UNUSED = 0x06 // first unused +} CV_GENERIC_STYLE_e; + + +typedef struct CV_GENERIC_FLAG { + unsigned short cstyle :1; // true push varargs right to left + unsigned short rsclean :1; // true if returnee stack cleanup + unsigned short unused :14; // unused +} CV_GENERIC_FLAG; + + + + + +typedef struct SYMTYPE { + unsigned short reclen; // Record length + unsigned short rectyp; // Record type + char data[CV_ZEROLEN]; +} SYMTYPE; + +__INLINE SYMTYPE *NextSym (SYMTYPE * pSym) { + return (SYMTYPE *) ((char *)pSym + pSym->reclen + sizeof(unsigned short)); +} + +// non-model specific symbol types + + + +typedef struct REGSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_REGISTER + CV_typ_t typind; // Type index + unsigned short reg; // register enumerate + unsigned char name[1]; // Length-prefixed name +} REGSYM; + + + +typedef struct MANYREGSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_MANYREG + CV_typ_t typind; // Type index + unsigned char count; // count of number of registers + unsigned char reg[1]; // count register enumerates followed by + // length-prefixed name. Registers are + // most significant first. +} MANYREGSYM; + + + +typedef struct CONSTSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_CONSTANT + CV_typ_t typind; // Type index (containing enum if enumerate) + unsigned short value; // numeric leaf containing value + unsigned char name[CV_ZEROLEN]; // Length-prefixed name +} CONSTSYM; + +typedef struct UDTSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_UDT | S_COBOLUDT + CV_typ_t typind; // Type index + unsigned char name[1]; // Length-prefixed name +} UDTSYM; + +typedef struct SEARCHSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_SSEARCH + unsigned long startsym; // offset of the procedure + unsigned short seg; // segment of symbol +} SEARCHSYM; + +typedef struct CFLAGSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_COMPILE + unsigned char machine; // target processor + struct { + unsigned char language :8; // language index + unsigned char pcode :1; // true if pcode present + unsigned char floatprec :2; // floating precision + unsigned char floatpkg :2; // float package + unsigned char ambdata :3; // ambiant data model + unsigned char ambcode :3; // ambiant code model + unsigned char mode32 :1; // true if compiled 32 bit mode + unsigned char pad :4; // reserved + } flags; + unsigned char ver[1]; // Length-prefixed compiler version string +} CFLAGSYM; + + + + + +typedef struct OBJNAMESYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_OBJNAME + unsigned long signature; // signature + unsigned char name[1]; // Length-prefixed name +} OBJNAMESYM; + + + + +typedef struct ENDARGSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_ENDARG +} ENDARGSYM; + + +typedef struct RETURNSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_RETURN + CV_GENERIC_FLAG flags; // flags + CV_GENERIC_STYLE_e style; // return style + // followed by return method data +} RETURNSYM; + + +typedef struct ENTRYTHISSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_ENTRYTHIS + unsigned char thissym; // symbol describing this pointer on entry +} ENTRYTHISSYM; + + +// symbol types for 16:16 memory model + + +typedef struct BPRELSYM16 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_BPREL16 + CV_off16_t off; // BP-relative offset + CV_typ_t typind; // Type index + unsigned char name[1]; // Length-prefixed name +} BPRELSYM16; + + + +typedef struct DATASYM16 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_LDATA or S_GDATA + CV_uoff16_t off; // offset of symbol + unsigned short seg; // segment of symbol + CV_typ_t typind; // Type index + unsigned char name[1]; // Length-prefixed name +} DATASYM16; +typedef DATASYM16 PUBSYM16; + + +typedef struct PROCSYM16 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_GPROC16 or S_LPROC16 + unsigned long pParent; // pointer to the parent + unsigned long pEnd; // pointer to this blocks end + unsigned long pNext; // pointer to next symbol + unsigned short len; // Proc length + unsigned short DbgStart; // Debug start offset + unsigned short DbgEnd; // Debug end offset + CV_uoff16_t off; // offset of symbol + unsigned short seg; // segment of symbol + CV_typ_t typind; // Type index + CV_PROCFLAGS flags; // Proc flags + unsigned char name[1]; // Length-prefixed name +} PROCSYM16; + + + + +typedef struct THUNKSYM16 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_THUNK + unsigned long pParent; // pointer to the parent + unsigned long pEnd; // pointer to this blocks end + unsigned long pNext; // pointer to next symbol + CV_uoff16_t off; // offset of symbol + unsigned short seg; // segment of symbol + unsigned short len; // length of thunk + unsigned char ord; // ordinal specifying type of thunk + unsigned char name[1]; // name of thunk + unsigned char variant[CV_ZEROLEN]; // variant portion of thunk +} THUNKSYM16; + +typedef enum { + THUNK_ORDINAL_NOTYPE, + THUNK_ORDINAL_ADJUSTOR, + THUNK_ORDINAL_VCALL, + THUNK_ORDINAL_PCODE +} THUNK_ORDINAL; + +typedef struct LABELSYM16 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_LABEL16 + CV_uoff16_t off; // offset of symbol + unsigned short seg; // segment of symbol + CV_PROCFLAGS flags; // flags + unsigned char name[1]; // Length-prefixed name +} LABELSYM16; + +typedef struct BLOCKSYM16 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_BLOCK16 + unsigned long pParent; // pointer to the parent + unsigned long pEnd; // pointer to this blocks end + unsigned short len; // Block length + CV_uoff16_t off; // offset of symbol + unsigned short seg; // segment of symbol + unsigned char name[1]; // Length-prefixed name +} BLOCKSYM16; + +typedef struct WITHSYM16 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_WITH16 + unsigned long pParent; // pointer to the parent + unsigned long pEnd; // pointer to this blocks end + unsigned short len; // Block length + CV_uoff16_t off; // offset of symbol + unsigned short seg; // segment of symbol + unsigned char expr[1]; // Length-prefixed expression +} WITHSYM16; + + + + +typedef enum CEXM_MODEL_e { + CEXM_MDL_table = 0x00, // not executable + CEXM_MDL_jumptable = 0x01, // Compiler generated jump table + CEXM_MDL_datapad = 0x02, // Data padding for alignment + CEXM_MDL_native = 0x20, // native (actually not-pcode) + CEXM_MDL_cobol = 0x21, // cobol + CEXM_MDL_codepad = 0x22, // Code padding for alignment + CEXM_MDL_code = 0x23, // code + CEXM_MDL_pcode = 0x40, // pcode + CEXM_MDL_pcode32Mac = 0x41, // macintosh 32 bit pcode + CEXM_MDL_pcode32MacNep = 0x42 // macintosh 32 bit pcode native entry point +} CEXM_MODEL_e; + +typedef enum CV_COBOL_e { + CV_COBOL_dontstop, + CV_COBOL_pfm, + CV_COBOL_false, + CV_COBOL_extcall +} CV_COBOL_e; + +typedef struct CEXMSYM16 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_CEXMODEL16 + CV_uoff16_t off; // offset of symbol + unsigned short seg; // segment of symbol + unsigned short model; // execution model + union var16 { + struct { + CV_uoff16_t pcdtable; // offset to pcode function table + CV_uoff16_t pcdspi; // offset to segment pcode information + } pcode; + struct { + unsigned short subtype; // see CV_COBOL_e above + unsigned short flag; + } cobol; + }; +} CEXMSYM16; + + + + +typedef struct VPATHSYM16 { + unsigned short reclen; // record length + unsigned short rectyp; // S_VFTPATH16 + CV_uoff16_t off; // offset of virtual function table + unsigned short seg; // segment of virtual function table + CV_typ_t root; // type index of the root of path + CV_typ_t path; // type index of the path record +} VPATHSYM16; + + + + +typedef struct REGREL16 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_REGREL16 + CV_uoff16_t off; // offset of symbol + unsigned short reg; // register index + CV_typ_t typind; // Type index + unsigned char name[1]; // Length-prefixed name +} REGREL16; + + + + + +typedef struct BPRELSYM32 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_BPREL32 + CV_off32_t off; // BP-relative offset + CV_typ_t typind; // Type index + unsigned char name[1]; // Length-prefixed name +} BPRELSYM32; + +typedef struct DATASYM32 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_LDATA32, S_GDATA32 or S_PUB32 + CV_uoff32_t off; + unsigned short seg; + CV_typ_t typind; // Type index + unsigned char name[1]; // Length-prefixed name +} DATASYM32; +typedef DATASYM32 PUBSYM32; + + + +typedef struct PROCSYM32 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_GPROC32 or S_LPROC32 + unsigned long pParent; // pointer to the parent + unsigned long pEnd; // pointer to this blocks end + unsigned long pNext; // pointer to next symbol + unsigned long len; // Proc length + unsigned long DbgStart; // Debug start offset + unsigned long DbgEnd; // Debug end offset + CV_uoff32_t off; + unsigned short seg; + CV_typ_t typind; // Type index + CV_PROCFLAGS flags; // Proc flags + unsigned char name[1]; // Length-prefixed name +} PROCSYM32; + + + + +typedef struct THUNKSYM32 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_THUNK32 + unsigned long pParent; // pointer to the parent + unsigned long pEnd; // pointer to this blocks end + unsigned long pNext; // pointer to next symbol + CV_uoff32_t off; + unsigned short seg; + unsigned short len; // length of thunk + unsigned char ord; // ordinal specifying type of thunk + unsigned char name[1]; // Length-prefixed name + unsigned char variant[CV_ZEROLEN]; // variant portion of thunk +} THUNKSYM32; + + + + +typedef struct LABELSYM32 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_LABEL32 + CV_uoff32_t off; + unsigned short seg; + CV_PROCFLAGS flags; // flags + unsigned char name[1]; // Length-prefixed name +} LABELSYM32; + + +typedef struct BLOCKSYM32 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_BLOCK32 + unsigned long pParent; // pointer to the parent + unsigned long pEnd; // pointer to this blocks end + unsigned long len; // Block length + CV_uoff32_t off; // Offset in code segment + unsigned short seg; // segment of label + unsigned char name[1]; // Length-prefixed name +} BLOCKSYM32; + + +typedef struct WITHSYM32 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_WITH32 + unsigned long pParent; // pointer to the parent + unsigned long pEnd; // pointer to this blocks end + unsigned long len; // Block length + CV_uoff32_t off; // Offset in code segment + unsigned short seg; // segment of label + unsigned char expr[1]; // Length-prefixed expression string +} WITHSYM32; + + + +typedef struct CEXMSYM32 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_CEXMODEL32 + CV_uoff32_t off; // offset of symbol + unsigned short seg; // segment of symbol + unsigned short model; // execution model + union var32 { + struct { + CV_uoff32_t pcdtable; // offset to pcode function table + CV_uoff32_t pcdspi; // offset to segment pcode information + } pcode; + struct { + unsigned short subtype; // see CV_COBOL_e above + unsigned short flag; + } cobol; + struct { + CV_uoff32_t calltableOff; // offset to function table + unsigned short calltableSeg; // segment of function table + } pcode32Mac; + }; +} CEXMSYM32; + + + +typedef struct VPATHSYM32 { + unsigned short reclen; // record length + unsigned short rectyp; // S_VFTPATH32 + CV_uoff32_t off; // offset of virtual function table + unsigned short seg; // segment of virtual function table + CV_typ_t root; // type index of the root of path + CV_typ_t path; // type index of the path record +} VPATHSYM32; + + + + + +typedef struct REGREL32 { + unsigned short reclen; // Record length + unsigned short rectyp; // S_REGREL32 + CV_uoff32_t off; // offset of symbol + unsigned short reg; // register index for symbol + CV_typ_t typind; // Type index + unsigned char name[1]; // Length-prefixed name +} REGREL32, *LPREGREL32; + + + +typedef struct THREADSYM32 { + unsigned short reclen; // record length + unsigned short rectyp; // S_LTHREAD32 | S_GTHREAD32 + CV_uoff32_t off; // offset into thread storage + unsigned short seg; // segment of thread storage + CV_typ_t typind; // type index + unsigned char name[1]; // length prefixed name +} THREADSYM32; + +typedef struct SLINK32 { + unsigned short reclen; // record length + unsigned short rectyp; // S_SLINK32 + unsigned long framesize; // frame size of parent procedure + CV_off32_t off; // signed offset where the static link was saved relative to the value of reg + unsigned short reg; +} SLINK32; + +typedef struct PROCSYMMIPS { + unsigned short reclen; // Record length + unsigned short rectyp; // S_GPROCMIPS or S_LPROCMIPS + unsigned long pParent; // pointer to the parent + unsigned long pEnd; // pointer to this blocks end + unsigned long pNext; // pointer to next symbol + unsigned long len; // Proc length + unsigned long DbgStart; // Debug start offset + unsigned long DbgEnd; // Debug end offset + unsigned long regSave; // int register save mask + unsigned long fpSave; // fp register save mask + CV_uoff32_t intOff; // int register save offset + CV_uoff32_t fpOff; // fp register save offset + CV_uoff32_t off; // Symbol offset + unsigned short seg; // Symbol segment + CV_typ_t typind; // Type index + unsigned char retReg; // Register return value is in + unsigned char frameReg; // Frame pointer register + unsigned char name[1]; // Length-prefixed name +} PROCSYMMIPS, *PROCPTRMIPS; + + +typedef struct REFSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_PROCREF or S_DATAREF + unsigned long sumName; // SUC of the name + unsigned long ibSym; // Offset of actual symbol in $$Symbols + unsigned short imod; // Module containing the actual symbol + unsigned short usFill; // align this record +} REFSYM; + +typedef struct ALIGNSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_PROCREF or S_DATAREF +} ALIGNSYM; + +// generic block definition symbols +// these are similar to the equivalent 16:16 or 16:32 symbols but +// only define the length, type and linkage fields + +typedef struct PROCSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_GPROC16 or S_LPROC16 + unsigned long pParent; // pointer to the parent + unsigned long pEnd; // pointer to this blocks end + unsigned long pNext; // pointer to next symbol +} PROCSYM; + + +typedef struct THUNKSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_THUNK + unsigned long pParent; // pointer to the parent + unsigned long pEnd; // pointer to this blocks end + unsigned long pNext; // pointer to next symbol +} THUNKSYM; + +typedef struct BLOCKSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_BLOCK16 + unsigned long pParent; // pointer to the parent + unsigned long pEnd; // pointer to this blocks end +} BLOCKSYM; + + +typedef struct WITHSYM { + unsigned short reclen; // Record length + unsigned short rectyp; // S_WITH16 + unsigned long pParent; // pointer to the parent + unsigned long pEnd; // pointer to this blocks end +} WITHSYM; + + +typedef enum CV_HREG_e { + // Register set for the Intel 80x86 and ix86 processor series + // (plus PCODE registers) + + CV_REG_NONE = 0, + CV_REG_AL = 1, + CV_REG_CL = 2, + CV_REG_DL = 3, + CV_REG_BL = 4, + CV_REG_AH = 5, + CV_REG_CH = 6, + CV_REG_DH = 7, + CV_REG_BH = 8, + CV_REG_AX = 9, + CV_REG_CX = 10, + CV_REG_DX = 11, + CV_REG_BX = 12, + CV_REG_SP = 13, + CV_REG_BP = 14, + CV_REG_SI = 15, + CV_REG_DI = 16, + CV_REG_EAX = 17, + CV_REG_ECX = 18, + CV_REG_EDX = 19, + CV_REG_EBX = 20, + CV_REG_ESP = 21, + CV_REG_EBP = 22, + CV_REG_ESI = 23, + CV_REG_EDI = 24, + CV_REG_ES = 25, + CV_REG_CS = 26, + CV_REG_SS = 27, + CV_REG_DS = 28, + CV_REG_FS = 29, + CV_REG_GS = 30, + CV_REG_IP = 31, + CV_REG_FLAGS = 32, + CV_REG_EIP = 33, + CV_REG_EFLAGS = 34, + CV_REG_TEMP = 40, // PCODE Temp + CV_REG_TEMPH = 41, // PCODE TempH + CV_REG_QUOTE = 42, // PCODE Quote + CV_REG_PCDR3 = 43, // PCODE reserved + CV_REG_PCDR4 = 44, // PCODE reserved + CV_REG_PCDR5 = 45, // PCODE reserved + CV_REG_PCDR6 = 46, // PCODE reserved + CV_REG_PCDR7 = 47, // PCODE reserved + CV_REG_CR0 = 80, // CR0 -- control registers + CV_REG_CR1 = 81, + CV_REG_CR2 = 82, + CV_REG_CR3 = 83, + CV_REG_CR4 = 84, // Pentium + CV_REG_DR0 = 90, // Debug register + CV_REG_DR1 = 91, + CV_REG_DR2 = 92, + CV_REG_DR3 = 93, + CV_REG_DR4 = 94, + CV_REG_DR5 = 95, + CV_REG_DR6 = 96, + CV_REG_DR7 = 97, + CV_REG_GDTR = 110, + CV_REG_GDTL = 111, + CV_REG_IDTR = 112, + CV_REG_IDTL = 113, + CV_REG_LDTR = 114, + CV_REG_TR = 115, + + CV_REG_PSEUDO1 = 116, + CV_REG_PSEUDO2 = 117, + CV_REG_PSEUDO3 = 118, + CV_REG_PSEUDO4 = 119, + CV_REG_PSEUDO5 = 120, + CV_REG_PSEUDO6 = 121, + CV_REG_PSEUDO7 = 122, + CV_REG_PSEUDO8 = 123, + CV_REG_PSEUDO9 = 124, + + CV_REG_ST0 = 128, + CV_REG_ST1 = 129, + CV_REG_ST2 = 130, + CV_REG_ST3 = 131, + CV_REG_ST4 = 132, + CV_REG_ST5 = 133, + CV_REG_ST6 = 134, + CV_REG_ST7 = 135, + CV_REG_CTRL = 136, + CV_REG_STAT = 137, + CV_REG_TAG = 138, + CV_REG_FPIP = 139, + CV_REG_FPCS = 140, + CV_REG_FPDO = 141, + CV_REG_FPDS = 142, + CV_REG_ISEM = 143, + CV_REG_FPEIP = 144, + CV_REG_FPEDO = 145, + + // registers for the 68K processors + + CV_R68_D0 = 0, + CV_R68_D1 = 1, + CV_R68_D2 = 2, + CV_R68_D3 = 3, + CV_R68_D4 = 4, + CV_R68_D5 = 5, + CV_R68_D6 = 6, + CV_R68_D7 = 7, + CV_R68_A0 = 8, + CV_R68_A1 = 9, + CV_R68_A2 = 10, + CV_R68_A3 = 11, + CV_R68_A4 = 12, + CV_R68_A5 = 13, + CV_R68_A6 = 14, + CV_R68_A7 = 15, + CV_R68_CCR = 16, + CV_R68_SR = 17, + CV_R68_USP = 18, + CV_R68_MSP = 19, + CV_R68_SFC = 20, + CV_R68_DFC = 21, + CV_R68_CACR = 22, + CV_R68_VBR = 23, + CV_R68_CAAR = 24, + CV_R68_ISP = 25, + CV_R68_PC = 26, + //reserved 27 + CV_R68_FPCR = 28, + CV_R68_FPSR = 29, + CV_R68_FPIAR = 30, + //reserved 31 + CV_R68_FP0 = 32, + CV_R68_FP1 = 33, + CV_R68_FP2 = 34, + CV_R68_FP3 = 35, + CV_R68_FP4 = 36, + CV_R68_FP5 = 37, + CV_R68_FP6 = 38, + CV_R68_FP7 = 39, + //reserved 40 + CV_R68_MMUSR030 = 41, + CV_R68_MMUSR = 42, + CV_R68_URP = 43, + CV_R68_DTT0 = 44, + CV_R68_DTT1 = 45, + CV_R68_ITT0 = 46, + CV_R68_ITT1 = 47, + //reserved 50 + CV_R68_PSR = 51, + CV_R68_PCSR = 52, + CV_R68_VAL = 53, + CV_R68_CRP = 54, + CV_R68_SRP = 55, + CV_R68_DRP = 56, + CV_R68_TC = 57, + CV_R68_AC = 58, + CV_R68_SCC = 59, + CV_R68_CAL = 60, + CV_R68_TT0 = 61, + CV_R68_TT1 = 62, + //reserved 63 + CV_R68_BAD0 = 64, + CV_R68_BAD1 = 65, + CV_R68_BAD2 = 66, + CV_R68_BAD3 = 67, + CV_R68_BAD4 = 68, + CV_R68_BAD5 = 69, + CV_R68_BAD6 = 70, + CV_R68_BAD7 = 71, + CV_R68_BAC0 = 72, + CV_R68_BAC1 = 73, + CV_R68_BAC2 = 74, + CV_R68_BAC3 = 75, + CV_R68_BAC4 = 76, + CV_R68_BAC5 = 77, + CV_R68_BAC6 = 78, + CV_R68_BAC7 = 79, + + // Register set for the MIPS 4000 + + CV_M4_NOREG = CV_REG_NONE, + + CV_M4_IntZERO = 10, /* CPU REGISTER */ + CV_M4_IntAT = 11, + CV_M4_IntV0 = 12, + CV_M4_IntV1 = 13, + CV_M4_IntA0 = 14, + CV_M4_IntA1 = 15, + CV_M4_IntA2 = 16, + CV_M4_IntA3 = 17, + CV_M4_IntT0 = 18, + CV_M4_IntT1 = 19, + CV_M4_IntT2 = 20, + CV_M4_IntT3 = 21, + CV_M4_IntT4 = 22, + CV_M4_IntT5 = 23, + CV_M4_IntT6 = 24, + CV_M4_IntT7 = 25, + CV_M4_IntS0 = 26, + CV_M4_IntS1 = 27, + CV_M4_IntS2 = 28, + CV_M4_IntS3 = 29, + CV_M4_IntS4 = 30, + CV_M4_IntS5 = 31, + CV_M4_IntS6 = 32, + CV_M4_IntS7 = 33, + CV_M4_IntT8 = 34, + CV_M4_IntT9 = 35, + CV_M4_IntKT0 = 36, + CV_M4_IntKT1 = 37, + CV_M4_IntGP = 38, + CV_M4_IntSP = 39, + CV_M4_IntS8 = 40, + CV_M4_IntRA = 41, + CV_M4_IntLO = 42, + CV_M4_IntHI = 43, + + CV_M4_Fir = 50, + CV_M4_Psr = 51, + + CV_M4_FltF0 = 60, /* Floating point registers */ + CV_M4_FltF1 = 61, + CV_M4_FltF2 = 62, + CV_M4_FltF3 = 63, + CV_M4_FltF4 = 64, + CV_M4_FltF5 = 65, + CV_M4_FltF6 = 66, + CV_M4_FltF7 = 67, + CV_M4_FltF8 = 68, + CV_M4_FltF9 = 69, + CV_M4_FltF10 = 70, + CV_M4_FltF11 = 71, + CV_M4_FltF12 = 72, + CV_M4_FltF13 = 73, + CV_M4_FltF14 = 74, + CV_M4_FltF15 = 75, + CV_M4_FltF16 = 76, + CV_M4_FltF17 = 77, + CV_M4_FltF18 = 78, + CV_M4_FltF19 = 79, + CV_M4_FltF20 = 80, + CV_M4_FltF21 = 81, + CV_M4_FltF22 = 82, + CV_M4_FltF23 = 83, + CV_M4_FltF24 = 84, + CV_M4_FltF25 = 85, + CV_M4_FltF26 = 86, + CV_M4_FltF27 = 87, + CV_M4_FltF28 = 88, + CV_M4_FltF29 = 89, + CV_M4_FltF30 = 90, + CV_M4_FltF31 = 91, + CV_M4_FltFsr = 92, + + + // Register set for the ALPHA AXP + + CV_ALPHA_NOREG = CV_REG_NONE, + + CV_ALPHA_FltF0 = 10, // Floating point registers + CV_ALPHA_FltF1 = 11, + CV_ALPHA_FltF2 = 12, + CV_ALPHA_FltF3 = 13, + CV_ALPHA_FltF4 = 14, + CV_ALPHA_FltF5 = 15, + CV_ALPHA_FltF6 = 16, + CV_ALPHA_FltF7 = 17, + CV_ALPHA_FltF8 = 18, + CV_ALPHA_FltF9 = 19, + CV_ALPHA_FltF10 = 20, + CV_ALPHA_FltF11 = 21, + CV_ALPHA_FltF12 = 22, + CV_ALPHA_FltF13 = 23, + CV_ALPHA_FltF14 = 24, + CV_ALPHA_FltF15 = 25, + CV_ALPHA_FltF16 = 26, + CV_ALPHA_FltF17 = 27, + CV_ALPHA_FltF18 = 28, + CV_ALPHA_FltF19 = 29, + CV_ALPHA_FltF20 = 30, + CV_ALPHA_FltF21 = 31, + CV_ALPHA_FltF22 = 32, + CV_ALPHA_FltF23 = 33, + CV_ALPHA_FltF24 = 34, + CV_ALPHA_FltF25 = 35, + CV_ALPHA_FltF26 = 36, + CV_ALPHA_FltF27 = 37, + CV_ALPHA_FltF28 = 38, + CV_ALPHA_FltF29 = 39, + CV_ALPHA_FltF30 = 40, + CV_ALPHA_FltF31 = 41, + + CV_ALPHA_IntV0 = 42, // Integer registers + CV_ALPHA_IntT0 = 43, + CV_ALPHA_IntT1 = 44, + CV_ALPHA_IntT2 = 45, + CV_ALPHA_IntT3 = 46, + CV_ALPHA_IntT4 = 47, + CV_ALPHA_IntT5 = 48, + CV_ALPHA_IntT6 = 49, + CV_ALPHA_IntT7 = 50, + CV_ALPHA_IntS0 = 51, + CV_ALPHA_IntS1 = 52, + CV_ALPHA_IntS2 = 53, + CV_ALPHA_IntS3 = 54, + CV_ALPHA_IntS4 = 55, + CV_ALPHA_IntS5 = 56, + CV_ALPHA_IntFP = 57, + CV_ALPHA_IntA0 = 58, + CV_ALPHA_IntA1 = 59, + CV_ALPHA_IntA2 = 60, + CV_ALPHA_IntA3 = 61, + CV_ALPHA_IntA4 = 62, + CV_ALPHA_IntA5 = 63, + CV_ALPHA_IntT8 = 64, + CV_ALPHA_IntT9 = 65, + CV_ALPHA_IntT10 = 66, + CV_ALPHA_IntT11 = 67, + CV_ALPHA_IntRA = 68, + CV_ALPHA_IntT12 = 69, + CV_ALPHA_IntAT = 70, + CV_ALPHA_IntGP = 71, + CV_ALPHA_IntSP = 72, + CV_ALPHA_IntZERO = 73, + + + CV_ALPHA_Fpcr = 74, // Control registers + CV_ALPHA_Fir = 75, + CV_ALPHA_Psr = 76, + CV_ALPHA_FltFsr = 77, + CV_ALPHA_SoftFpcr = 78, + + // Register Set for Motorola/IBM PowerPC + + /* + ** PowerPC General Registers ( User Level ) + */ + CV_PPC_GPR0 = 1, + CV_PPC_GPR1 = 2, + CV_PPC_GPR2 = 3, + CV_PPC_GPR3 = 4, + CV_PPC_GPR4 = 5, + CV_PPC_GPR5 = 6, + CV_PPC_GPR6 = 7, + CV_PPC_GPR7 = 8, + CV_PPC_GPR8 = 9, + CV_PPC_GPR9 = 10, + CV_PPC_GPR10 = 11, + CV_PPC_GPR11 = 12, + CV_PPC_GPR12 = 13, + CV_PPC_GPR13 = 14, + CV_PPC_GPR14 = 15, + CV_PPC_GPR15 = 16, + CV_PPC_GPR16 = 17, + CV_PPC_GPR17 = 18, + CV_PPC_GPR18 = 19, + CV_PPC_GPR19 = 20, + CV_PPC_GPR20 = 21, + CV_PPC_GPR21 = 22, + CV_PPC_GPR22 = 23, + CV_PPC_GPR23 = 24, + CV_PPC_GPR24 = 25, + CV_PPC_GPR25 = 26, + CV_PPC_GPR26 = 27, + CV_PPC_GPR27 = 28, + CV_PPC_GPR28 = 29, + CV_PPC_GPR29 = 30, + CV_PPC_GPR30 = 31, + CV_PPC_GPR31 = 32, + + /* + ** PowerPC Condition Register ( User Level ) + */ + CV_PPC_CR = 33, + CV_PPC_CR0 = 34, + CV_PPC_CR1 = 35, + CV_PPC_CR2 = 36, + CV_PPC_CR3 = 37, + CV_PPC_CR4 = 38, + CV_PPC_CR5 = 39, + CV_PPC_CR6 = 40, + CV_PPC_CR7 = 41, + + /* + ** PowerPC Floating Point Registers ( User Level ) + */ + CV_PPC_FPR0 = 42, + CV_PPC_FPR1 = 43, + CV_PPC_FPR2 = 44, + CV_PPC_FPR3 = 45, + CV_PPC_FPR4 = 46, + CV_PPC_FPR5 = 47, + CV_PPC_FPR6 = 48, + CV_PPC_FPR7 = 49, + CV_PPC_FPR8 = 50, + CV_PPC_FPR9 = 51, + CV_PPC_FPR10 = 52, + CV_PPC_FPR11 = 53, + CV_PPC_FPR12 = 54, + CV_PPC_FPR13 = 55, + CV_PPC_FPR14 = 56, + CV_PPC_FPR15 = 57, + CV_PPC_FPR16 = 58, + CV_PPC_FPR17 = 59, + CV_PPC_FPR18 = 60, + CV_PPC_FPR19 = 61, + CV_PPC_FPR20 = 62, + CV_PPC_FPR21 = 63, + CV_PPC_FPR22 = 64, + CV_PPC_FPR23 = 65, + CV_PPC_FPR24 = 66, + CV_PPC_FPR25 = 67, + CV_PPC_FPR26 = 68, + CV_PPC_FPR27 = 69, + CV_PPC_FPR28 = 70, + CV_PPC_FPR29 = 71, + CV_PPC_FPR30 = 72, + CV_PPC_FPR31 = 73, + + /* + ** PowerPC Floating Point Status and Control Register ( User Level ) + */ + CV_PPC_FPSCR = 74, + + /* + ** PowerPC Machine State Register ( Supervisor Level ) + */ + CV_PPC_MSR = 75, + + /* + ** PowerPC Segment Registers ( Supervisor Level ) + */ + CV_PPC_SR0 = 76, + CV_PPC_SR1 = 77, + CV_PPC_SR2 = 78, + CV_PPC_SR3 = 79, + CV_PPC_SR4 = 80, + CV_PPC_SR5 = 81, + CV_PPC_SR6 = 82, + CV_PPC_SR7 = 83, + CV_PPC_SR8 = 84, + CV_PPC_SR9 = 85, + CV_PPC_SR10 = 86, + CV_PPC_SR11 = 87, + CV_PPC_SR12 = 88, + CV_PPC_SR13 = 89, + CV_PPC_SR14 = 90, + CV_PPC_SR15 = 91, + + /* + ** For all of the special purpose registers add 100 to the SPR# that the + ** Motorola/IBM documentation gives with the exception of any imaginary + ** registers. + */ + + /* + ** PowerPC Special Purpose Registers ( User Level ) + */ + CV_PPC_PC = 99, // PC (imaginary register) + + CV_PPC_MQ = 100, // MPC601 + CV_PPC_XER = 101, + CV_PPC_RTCU = 104, // MPC601 + CV_PPC_RTCL = 105, // MPC601 + CV_PPC_LR = 108, + CV_PPC_CTR = 109, + + CV_PPC_COMPARE = 110, // part of XER (internal to the debugger only) + CV_PPC_COUNT = 111, // part of XER (internal to the debugger only) + + /* + ** PowerPC Special Purpose Registers ( Supervisor Level ) + */ + CV_PPC_DSISR = 118, + CV_PPC_DAR = 119, + CV_PPC_DEC = 122, + CV_PPC_SDR1 = 125, + CV_PPC_SRR0 = 126, + CV_PPC_SRR1 = 127, + CV_PPC_SPRG0 = 372, + CV_PPC_SPRG1 = 373, + CV_PPC_SPRG2 = 374, + CV_PPC_SPRG3 = 375, + CV_PPC_ASR = 280, // 64-bit implementations only + CV_PPC_EAR = 382, + CV_PPC_PVR = 287, + CV_PPC_BAT0U = 628, + CV_PPC_BAT0L = 629, + CV_PPC_BAT1U = 630, + CV_PPC_BAT1L = 631, + CV_PPC_BAT2U = 632, + CV_PPC_BAT2L = 633, + CV_PPC_BAT3U = 634, + CV_PPC_BAT3L = 635, + CV_PPC_DBAT0U = 636, + CV_PPC_DBAT0L = 637, + CV_PPC_DBAT1U = 638, + CV_PPC_DBAT1L = 639, + CV_PPC_DBAT2U = 640, + CV_PPC_DBAT2L = 641, + CV_PPC_DBAT3U = 642, + CV_PPC_DBAT3L = 643, + + /* + ** PowerPC Special Purpose Registers Implementation Dependent ( Supervisor Level ) + */ + + /* + ** Doesn't appear that IBM/Motorola has finished defining these. + */ + + CV_PPC_PMR0 = 1044, // MPC620, + CV_PPC_PMR1 = 1045, // MPC620, + CV_PPC_PMR2 = 1046, // MPC620, + CV_PPC_PMR3 = 1047, // MPC620, + CV_PPC_PMR4 = 1048, // MPC620, + CV_PPC_PMR5 = 1049, // MPC620, + CV_PPC_PMR6 = 1050, // MPC620, + CV_PPC_PMR7 = 1051, // MPC620, + CV_PPC_PMR8 = 1052, // MPC620, + CV_PPC_PMR9 = 1053, // MPC620, + CV_PPC_PMR10 = 1054, // MPC620, + CV_PPC_PMR11 = 1055, // MPC620, + CV_PPC_PMR12 = 1056, // MPC620, + CV_PPC_PMR13 = 1057, // MPC620, + CV_PPC_PMR14 = 1058, // MPC620, + CV_PPC_PMR15 = 1059, // MPC620, + + CV_PPC_DMISS = 1076, // MPC603 + CV_PPC_DCMP = 1077, // MPC603 + CV_PPC_HASH1 = 1078, // MPC603 + CV_PPC_HASH2 = 1079, // MPC603 + CV_PPC_IMISS = 1080, // MPC603 + CV_PPC_ICMP = 1081, // MPC603 + CV_PPC_RPA = 1082, // MPC603 + + CV_PPC_HID0 = 1108, // MPC601, MPC603, MPC620 + CV_PPC_HID1 = 1109, // MPC601 + CV_PPC_HID2 = 1110, // MPC601, MPC603, MPC620 ( IABR ) + CV_PPC_HID3 = 1111, // Not Defined + CV_PPC_HID4 = 1112, // Not Defined + CV_PPC_HID5 = 1113, // MPC601, MPC604, MPC620 ( DABR ) + CV_PPC_HID6 = 1114, // Not Defined + CV_PPC_HID7 = 1115, // Not Defined + CV_PPC_HID8 = 1116, // MPC620 ( BUSCSR ) + CV_PPC_HID9 = 1117, // MPC620 ( L2CSR ) + CV_PPC_HID10 = 1118, // Not Defined + CV_PPC_HID11 = 1119, // Not Defined + CV_PPC_HID12 = 1120, // Not Defined + CV_PPC_HID13 = 1121, // MPC604 ( HCR ) + CV_PPC_HID14 = 1122, // Not Defined + CV_PPC_HID15 = 1123 // MPC601, MPC604, MPC620 ( PIR ) + + +} CV_HREG_e; + +#pragma pack ( pop ) + +#endif /* CV_INFO_INCLUDED */ diff --git a/private/windbg/osdebug/include/cvtypes.h b/private/windbg/osdebug/include/cvtypes.h new file mode 100644 index 000000000..6f181db49 --- /dev/null +++ b/private/windbg/osdebug/include/cvtypes.h @@ -0,0 +1,295 @@ +#error Don't include cvtypes.h... Use cvtypes.hxx instead. + +/*++ + +Copyright (c) 1992 Microsoft Corporation + +Module Name: + + Cvtypes.h + +Abstract: + +Author: + + David J. Gilman (davegi) 05-Apr-1992 + +Environment: + + Win32, User Mode + +--*/ + +#if ! defined _CVTYPES_ +#define _CVTYPES_ + +#include "types.h" + +/* +** HDEP is a machine dependent size and passes as a general handle. +** HIND is a machine independent sized handle and is used for things +** which are passed between machines +** +*/ + +#ifdef STRICT + DECLARE_HANDLE(HDEP); + DECLARE_HANDLE(HIND); +#else + typedef HANDLE HDEP; + typedef HANDLE HIND; +#endif + + +typedef HDEP FAR * LPHDEP; +typedef HIND FAR * LPHIND; + + +/* HMEM should be avoided (HDEP should be used instead), but for now we'll +** define it for backwards compatibility. +*/ + +typedef HDEP HMEM; +typedef HMEM FAR * LPHMEM; + +/* These values are used in the SegType field of the Expression Evaluator's +** TI structure, and as the third parameter to the Symbol Handler's +** SHGetNearestHsym function. +*/ +#define EECODE 0x01 +#define EEDATA 0x02 +#define EEANYSEG 0xFFFF + +/* +** HPID +** HTID +** +*/ + +#ifdef STRICT +DECLARE_HANDLE(HPID); +DECLARE_HANDLE(HTID); +#else +typedef HIND HPID; +typedef HIND HTID; +#endif + +typedef USHORT SEGMENT; // 32-bit compiler doesn't like "_segment" +typedef ULONG UOFF32; +typedef USHORT UOFF16; +typedef LONG OFF32; +typedef SHORT OFF16; +#if defined (ADDR_16) + // we are operating as a 16:16 evaluator only + // the address packet will be defined as an offset and a 16 bit filler + typedef OFF16 SOFFSET; + typedef UOFF16 UOFFSET; + typedef UOFF16 OFFSET; +#else + typedef OFF32 SOFFSET; + typedef UOFF32 UOFFSET; + typedef UOFF32 OFFSET; +#endif + +// address definitions +// the address packet is always a 16:32 address. + +typedef struct { + UOFF32 off; + SEGMENT seg; +} address_t; + +#define SegAddrT(a) ((a).seg) +#define OffAddrT(a) ((a).off) + +#define AddrTInit(paddrT,segSet,offSet) \ + { \ + SegAddrT(*(paddrT)) = segSet; \ + OffAddrT(*(paddrT)) = offSet; \ + } + +typedef struct { + BYTE fFlat :1; // true if address is flat + BYTE fOff32 :1; // true if offset is 32 bits + BYTE fIsLI :1; // true if segment is linker index + BYTE fReal :1; // x86: is segment a real mode address + BYTE unused :4; // unused +} memmode_t; + +#define MODE_IS_FLAT(m) ((m).fFlat) +#define MODE_IS_OFF32(m) ((m).fOff32) +#define MODE_IS_LI(m) ((m).fIsLI) +#define MODE_IS_REAL(m) ((m).fReal) + +#define ModeInit(pmode,fFlat,fOff32,fLi,fRealSet) \ + { \ + MODE_IS_FLAT(*(pmode)) = fFlat; \ + MODE_IS_OFF32(*(pmode)) = fOff32; \ + MODE_IS_LI(*(pmode)) = fLi; \ + MODE_IS_REAL(*(pmode)) = fRealSet; \ + } + +#ifdef STRICT +DECLARE_HANDLE(HEMI); +#else +typedef HIND HEMI; // Executable Module Index +#endif + +typedef struct ADDR { + address_t addr; + HEMI emi; + memmode_t mode; +} ADDR; //* An address specifier +typedef ADDR FAR * PADDR; //* REVIEW: BUG: shouldn't be explicitly far +typedef ADDR FAR * LPADDR; + +#define addrAddr(a) ((a).addr) +#define emiAddr(a) ((a).emi) +#define modeAddr(a) ((a).mode) + +#define AddrInit(paddr,emiSet,segSet,offSet,fFlat,fOff32,fLi,fRealSet) \ + { \ + AddrTInit( &(addrAddr(*(paddr))), segSet, offSet ); \ + emiAddr(*(paddr)) = emiSet; \ + ModeInit( &(modeAddr(*(paddr))),fFlat,fOff32,fLi,fRealSet); \ + } + +#define ADDR_IS_FLAT(a) (MODE_IS_FLAT(modeAddr(a))) +#define ADDR_IS_OFF32(a) (MODE_IS_OFF32(modeAddr(a))) +#define ADDR_IS_LI(a) (MODE_IS_LI(modeAddr(a))) +#define ADDR_IS_REAL(a) (MODE_IS_REAL(modeAddr(a))) + +#define ADDRSEG16(a) { ADDR_IS_FLAT(a) = FALSE; ADDR_IS_OFF32(a) = FALSE; } +#define ADDRSEG32(a) { ADDR_IS_FLAT(a) = FALSE; ADDR_IS_OFF32(a) = TRUE; } +#define ADDRLIN32(a) { ADDR_IS_FLAT(a) = TRUE; ADDR_IS_OFF32(a) = TRUE; } + +#define GetAddrSeg(a) (SegAddrT(addrAddr(a))) +#define GetAddrOff(a) (OffAddrT(addrAddr(a))) +#define SetAddrSeg(a,s) (SegAddrT(addrAddr(*(a)))=s) +#define SetAddrOff(a,o) (OffAddrT(addrAddr(*(a)))=o) + +// Because an ADDR has some filler areas (in the mode and the address_t), +// it's bad to use memcmp two ADDRs to see if they're equal. Use this +// macro instead. (I deliberately left out the test for fAddr32(), because +// I think it's probably not necessary when comparing.) +#define FAddrsEq(a1, a2) \ + ( \ + GetAddrOff(a1) == GetAddrOff(a2) && \ + GetAddrSeg(a1) == GetAddrSeg(a2) && \ + ADDR_IS_LI(a1) == ADDR_IS_LI(a2) && \ + emiAddr(a1) == emiAddr(a2) \ + ) + +// address definitions +// the address packet is always a 16:32 address. + +typedef struct FRAME { + SEGMENT SS; + address_t BP; + SEGMENT DS; + memmode_t mode; + HPID PID; + HTID TID; +} FRAME; +typedef FRAME FAR *PFRAME; //* REVIEW: BUG: shouldn't be explicitly far + +#define addrFrameSS(a) ((a).SS) +#define addrFrameBP(a) ((a).BP) +#define GetFrameBPOff(a) ((a).BP.off) +#define GetFrameBPSeg(a) ((a).BP.seg) +#define SetFrameBPOff(a,o) ((a).BP.off = o) +#define SetFrameBPSeg(a,s) ((a).BP.seg = s) +#define FRAMEMODE(a) ((a).mode) +#define FRAMEPID(a) ((a).PID) +#define FRAMETID(a) ((a).TID) + +#define FrameFlat(a) MODE_IS_FLAT((a).mode) +#define FrameOff32(a) MODE_IS_OFF32((a).mode) +#define FrameReal(a) MODE_IS_REAL((a).mode) + + +/* +** A few public types related to the linked list manager +*/ + +typedef HDEP HLLI; //* A handle to a linked list +typedef HIND HLLE; //* A handle to a linked list entry + +typedef void (FAR PASCAL * LPFNKILLNODE)( LPV ); +typedef int (FAR PASCAL * LPFNFCMPNODE)( LPV, LPV, LONG ); + +typedef USHORT LLF; //* Linked List Flags +#define llfNull (LLF)0x0 +#define llfAscending (LLF)0x1 +#define llfDescending (LLF)0x2 + + +/* + * + */ + +typedef struct { + char b[10]; +} REAL10; + +typedef REAL10 FLOAT10; + +// +// copied from winnt.h: +// +#ifndef PAGE_NOACCESS + +#define PAGE_NOACCESS 0x01 +#define PAGE_READONLY 0x02 +#define PAGE_READWRITE 0x04 +#define PAGE_WRITECOPY 0x08 +#define PAGE_EXECUTE 0x10 +#define PAGE_EXECUTE_READ 0x20 +#define PAGE_EXECUTE_READWRITE 0x40 +#define PAGE_EXECUTE_WRITECOPY 0x80 +#define PAGE_GUARD 0x100 +#define PAGE_NOCACHE 0x200 + +#define MEM_COMMIT 0x1000 +#define MEM_RESERVE 0x2000 +#define MEM_FREE 0x10000 + +#define MEM_PRIVATE 0x20000 +#define MEM_MAPPED 0x40000 +//#define SEC_IMAGE 0x1000000 +//#define MEM_IMAGE SEC_IMAGE +#define MEM_IMAGE 0x1000000 + +#endif + +typedef struct _MEMINFO { + ADDR addr; + ADDR addrAllocBase; + UOFF32 uRegionSize; + DWORD dwProtect; + DWORD dwState; + DWORD dwType; +} MEMINFO; +typedef MEMINFO FAR * LPMEMINFO; + +/* +** Return values for mtrcEndian -- big or little endian -- which +** byte is [0] most or least significat byte +*/ +enum _END { + endBig, + endLittle +}; +typedef DWORD END; + +enum _MPT { + mptix86, + mptm68k, + mptdaxp, + mptmips, + mptmppc, + mptUnknown +}; +typedef DWORD MPT; + +#endif // _CVTYPES_ diff --git a/private/windbg/osdebug/include/cvtypes.hxx b/private/windbg/osdebug/include/cvtypes.hxx new file mode 100644 index 000000000..018ebf694 --- /dev/null +++ b/private/windbg/osdebug/include/cvtypes.hxx @@ -0,0 +1,264 @@ +// CVTYPES.H +// +// This file contains a common set of base type declarations +// between multiple CodeView projects. If you touch this in one +// project be sure to copy it to all other projects as well. + +#ifndef _VC_VER_INC +#include "..\include\vcver.h" +#endif + +#ifndef CV_PROJECT_BASE_TYPES +#define CV_PROJECT_BASE_TYPES + +#include "dbapiver.h" +#include "types.h" + +// HDEP is a machine dependent size and passes as a general handle. +// HIND is a machine independent sized handle and is used for things +// which are passed between machines + +#ifdef STRICT +DECLARE_HANDLE(HDEP); +DECLARE_HANDLE(HIND); +#else +typedef HANDLE HDEP; +typedef HANDLE HIND; +#endif + +typedef HDEP * LPHDEP; +typedef HIND * LPHIND; + +// HMEM should be avoided (HDEP should be used instead), but for now we'll +// define it for backwards compatibility. + +typedef HDEP HMEM; +typedef HMEM * LPHMEM; + +// These values are used in the SegType field of the Expression Evaluator's +// TI structure, and as the third parameter to the Symbol Handler's +// SHGetNearestHsym function. + +#define EECODE 0x01 +#define EEDATA 0x02 +#define EEANYSEG 0xFFFF + +#ifdef STRICT +DECLARE_HANDLE(HPID); +DECLARE_HANDLE(HTID); +#else +typedef HIND HPID; +typedef HIND HTID; +#endif + +typedef USHORT SEGMENT; // 32-bit compiler doesn't like "_segment" +typedef ULONG UOFF32; +typedef USHORT UOFF16; +typedef LONG OFF32; +typedef SHORT OFF16; + +typedef OFF32 SOFFSET; +typedef UOFF32 UOFFSET; +typedef UOFF32 OFFSET; +typedef UOFFSET *LPUOFFSET; + +// address definitions +// the address packet is always a 16:32 address. + +typedef struct { + UOFF32 off; + SEGMENT seg; +} address_t; + +#define SegAddrT(a) ((a).seg) +#define OffAddrT(a) ((a).off) + +#define AddrTInit(paddrT,segSet,offSet) \ + { \ + SegAddrT(*(paddrT)) = segSet; \ + OffAddrT(*(paddrT)) = offSet; \ + } + +typedef struct { + BYTE fFlat :1; // true if address is flat + BYTE fOff32 :1; // true if offset is 32 bits + BYTE fIsLI :1; // true if segment is linker index + BYTE fReal :1; // x86: is segment a real mode address + BYTE unused :4; // unused +} memmode_t; + +#define MODE_IS_FLAT(m) ((m).fFlat) +#define MODE_IS_OFF32(m) ((m).fOff32) +#define MODE_IS_LI(m) ((m).fIsLI) +#define MODE_IS_REAL(m) ((m).fReal) + +#define ModeInit(pmode,fFlat,fOff32,fLi,fRealSet) \ + { \ + MODE_IS_FLAT(*(pmode)) = fFlat; \ + MODE_IS_OFF32(*(pmode)) = fOff32; \ + MODE_IS_LI(*(pmode)) = fLi; \ + MODE_IS_REAL(*(pmode)) = fRealSet; \ + } + +#ifdef STRICT +DECLARE_HANDLE(HEMI); +#else +typedef HIND HEMI; // Executable Module Index +#endif + +typedef struct ADDR { + address_t addr; + HEMI emi; + memmode_t mode; +} ADDR; // An address specifier +typedef ADDR * PADDR; +typedef ADDR * LPADDR; + +#define addrAddr(a) ((a).addr) +#define emiAddr(a) ((a).emi) +#define modeAddr(a) ((a).mode) + +#define AddrInit(paddr,emiSet,segSet,offSet,fFlat,fOff32,fLi,fRealSet) \ + { \ + AddrTInit( &(addrAddr(*(paddr))), segSet, offSet ); \ + emiAddr(*(paddr)) = emiSet; \ + ModeInit( &(modeAddr(*(paddr))),fFlat,fOff32,fLi,fRealSet); \ + } + +#define ADDR_IS_FLAT(a) (MODE_IS_FLAT(modeAddr(a))) +#define ADDR_IS_OFF32(a) (MODE_IS_OFF32(modeAddr(a))) +#define ADDR_IS_LI(a) (MODE_IS_LI(modeAddr(a))) +#define ADDR_IS_REAL(a) (MODE_IS_REAL(modeAddr(a))) + +#define ADDRSEG16(a) {ADDR_IS_FLAT(a) = FALSE; ADDR_IS_OFF32(a) = FALSE;} +#define ADDRSEG32(a) {ADDR_IS_FLAT(a) = FALSE; ADDR_IS_OFF32(a) = TRUE;} +#define ADDRLIN32(a) {ADDR_IS_FLAT(a) = TRUE; ADDR_IS_OFF32(a) = TRUE;} + +#define GetAddrSeg(a) ((a).addr.seg) +#define GetAddrOff(a) ((a).addr.off) +#define SetAddrSeg(a,s) ((a)->addr.seg=s) +#define SetAddrOff(a,o) ((a)->addr.off=o) + +// Because an ADDR has some filler areas (in the mode and the address_t), +// it's bad to use memcmp two ADDRs to see if they're equal. Use this +// macro instead. (I deliberately left out the test for fAddr32(), because +// I think it's probably not necessary when comparing.) +#define FAddrsEq(a1, a2) \ + ( \ + GetAddrOff(a1) == GetAddrOff(a2) && \ + GetAddrSeg(a1) == GetAddrSeg(a2) && \ + ADDR_IS_LI(a1) == ADDR_IS_LI(a2) && \ + emiAddr(a1) == emiAddr(a2) \ + ) + +// address definitions +// the address packet is always a 16:32 address. + +typedef struct FRAME { + SEGMENT SS; + address_t BP; + SEGMENT DS; + memmode_t mode; + HPID PID; + HTID TID; + address_t SLP; // Static link pointer +} FRAME; +typedef FRAME *PFRAME; + +#define addrFrameSS(a) ((a).SS) +#define addrFrameBP(a) ((a).BP) +#define GetFrameBPOff(a) ((a).BP.off) +#define GetFrameBPSeg(a) ((a).BP.seg) +#define SetFrameBPOff(a,o) ((a).BP.off = o) +#define SetFrameBPSeg(a,s) ((a).BP.seg = s) +#define GetFrameSLPOff(a) ((a).SLP.off) +#define GetFrameSLPSeg(a) ((a).SLP.seg) +#define SetFrameSLPOff(a,o) ((a).SLP.off = o) +#define SetFrameSLPSeg(a,s) ((a).SLP.seg = s) +#define FRAMEMODE(a) ((a).mode) +#define FRAMEPID(a) ((a).PID) +#define FRAMETID(a) ((a).TID) + +#define FrameFlat(a) MODE_IS_FLAT((a).mode) +#define FrameOff32(a) MODE_IS_OFF32((a).mode) +#define FrameReal(a) MODE_IS_REAL((a).mode) + +// A few public types related to the linked list manager + +typedef HDEP HLLI; // A handle to a linked list +// typedef HDEP HLLE; // A handle to a linked list entry +typedef HIND HLLE; // A handle to a linked list entry + +typedef void (* LPFNKILLNODE)(PVOID); +typedef int (* LPFNFCMPNODE)(PVOID, PVOID, LONG ); + +typedef USHORT LLF; // Linked List Flags +#define llfNull (LLF)0x0 +#define llfAscending (LLF)0x1 +#define llfDescending (LLF)0x2 + +// EXPCALL indicates that a function should use whatever calling +// convention is preferable for exported functions. + +#define EXPCALL __stdcall + +// copied from winnt.h: + +#ifndef PAGE_NOACCESS + +#define PAGE_NOACCESS 0x01 +#define PAGE_READONLY 0x02 +#define PAGE_READWRITE 0x04 +#define PAGE_WRITECOPY 0x08 +#define PAGE_EXECUTE 0x10 +#define PAGE_EXECUTE_READ 0x20 +#define PAGE_EXECUTE_READWRITE 0x40 +#define PAGE_EXECUTE_WRITECOPY 0x80 +#define PAGE_GUARD 0x100 +#define PAGE_NOCACHE 0x200 + +#define MEM_COMMIT 0x1000 +#define MEM_RESERVE 0x2000 +#define MEM_FREE 0x10000 + +#define MEM_PRIVATE 0x20000 +#define MEM_MAPPED 0x40000 +#define MEM_IMAGE 0x1000000 + +#endif + +typedef struct _MEMINFO { + ADDR addr; + ADDR addrAllocBase; + UOFF32 uRegionSize; + DWORD dwProtect; + DWORD dwState; + DWORD dwType; +} MEMINFO; +typedef MEMINFO * LPMEMINFO; + +// Return values for mtrcEndian -- big or little endian -- which +// byte is [0] most or least significat byte + +enum _END { + endBig, + endLittle +}; +typedef DWORD END; + +// Return values for mtrcProcessorType + +enum _MPT { + mptix86 = 1, // Intel X86 + mptm68k = 2, // Mac 68K + mptdaxp = 3, // Alpha AXP + mptmips = 4, // MIPS + mptmppc = 5, // Mac PPC + mptntppc = 6, // NT PPC + mptUnknown +}; +typedef DWORD MPT; + +#include <dbgver.h> // For AVS definition and support functions + +#endif // CV_PROJECT_BASE_TYPES diff --git a/private/windbg/osdebug/include/dbapiver.h b/private/windbg/osdebug/include/dbapiver.h new file mode 100644 index 000000000..b80ffe313 --- /dev/null +++ b/private/windbg/osdebug/include/dbapiver.h @@ -0,0 +1,6 @@ +#ifndef _VC_VER_INC +#include "..\include\vcver.h" +#endif + +#define DBG_API_VERSION 6 +#define DBG_API_SUBVERSION 3 diff --git a/private/windbg/osdebug/include/dbgver.h b/private/windbg/osdebug/include/dbgver.h new file mode 100644 index 000000000..f26b94cf3 --- /dev/null +++ b/private/windbg/osdebug/include/dbgver.h @@ -0,0 +1,135 @@ +/*++ + +Copyright (c) 1992 Microsoft Corporation + +Module Name: + + dbgver.h + +Abstract: + +Author: + + Kent D. Forschmiedt (kentf) 25-Jan-1993 + +Environment: + + Win32, User Mode + +--*/ + +#if ! defined _DBGVER_ +#define _DBGVER_ + +/* +** DBG_API_VERSION is the major version number used to specify the +** api version of the debugger or debug dll. For release versions +** dlls will export this and debuggers will check against this +** version to verify that it can use the dll. +** +** For beta and debug versions, this number will be used in +** conjunction with minor and revision numbers (probably derived +** from SLM rmm & rup) to verify compatibility. +** +** Until the API has stabilized, we will most likely have to +** rev this version number for every major product release. +** +*/ + +#include <dbapiver.h> + +/* AVS - Api Version Structure: +** +** All debug dlls should be prepared to return a pointer to this +** structure conaining its vital statistics. The debugger should +** check first two characters of the dll's name against rgchType +** and the version numbers as described in the DBG_API_VERSION +** and show the user an error if any of these tests fail. +** +*/ + +typedef enum { + rlvtRelease, + rlvtBeta, + rlvtDebug +} RLVT; // ReLease Version Type + +typedef struct _AVS { + CHAR rgchType [ 2 ]; // Component name (EE,EM,TL,SH,DM) + WORD rlvt; // ReLease Version Type + BYTE iApiVer; // DBG_API_VERSION + BYTE iApiSubVer; // DBG_API_SUBVERSION + WORD iRup; // Revision number + WORD chBuild; // Build of revision # (a,b,c,d) + LSZ lszTitle; // User readable text describing the DLL + MPT mpt; // CPU binary is running on + WORD iRmj; // Major version number + WORD iRmm; // Minor version number +} AVS; // Api Version Structure +typedef AVS *LPAVS; + + +/* DBGVersionCheck: +** +** All debug dlls should provide this API and support the return +** of a pointer to the structure described above even before +** initialization takes place. +*/ + +#if defined(_M_IX86) +#define __dbgver_cpu__ mptix86 +#elif defined(_M_MRX000) +#define __dbgver_cpu__ mptmips +#elif defined(_M_ALPHA) +#define __dbgver_cpu__ mptdaxp +#elif defined(_M_PPC) +#define __dbgver_cpu__ mptntppc +#else +#error( "unknown host machine" ); +#endif + +#define DEBUG_VERSION(C1,C2,TITLE) \ +AVS Avs = { \ + { C1, C2 }, \ + rlvtDebug, \ + DBG_API_VERSION, \ + DBG_API_SUBVERSION, \ + 0, \ + '\0', \ + TITLE, \ + __dbgver_cpu__, \ + 0, \ + 0, \ + }; + +#define RELEASE_VERSION(C1,C2,TITLE) \ +AVS Avs = { \ + { C1, C2 }, \ + rlvtRelease, \ + DBG_API_VERSION, \ + DBG_API_SUBVERSION, \ + 0, \ + '\0', \ + TITLE, \ + __dbgver_cpu__, \ + 0, \ + 0, \ +}; + +#undef MINOR +#undef MAJOR + +#define DBGVERSIONPROCNAME "DBGVersionCheck" + +typedef LPAVS (*DBGVERSIONPROC)(VOID); +LPAVS WINDBGVersionCheck(VOID); +LPAVS DBGVersionCheck(VOID); + + +#define DBGVERSIONFUNCTION() \ + LPAVS WINDBGVersionCheck( void ) { return &Avs; } \ + LPAVS DBGVersionCheck( void ) { return &Avs; } + +#define DBGVERSIONCHECK() DBGVERSIONFUNCTION() + +#endif // _DBGVER_ diff --git a/private/windbg/osdebug/include/eeapi.h b/private/windbg/osdebug/include/eeapi.h new file mode 100644 index 000000000..cb19423de --- /dev/null +++ b/private/windbg/osdebug/include/eeapi.h @@ -0,0 +1,395 @@ +/*++ + +Copyright (c) 1992 Microsoft Corporation + +Module Name: + + Eeapi.h + +Abstract: + + This file contains all types and APIs that are defined by the + Expression Evaluator and are publicly accessible by other components. + +Author: + + David J. Gilman (davegi) 04-May-1992 + +Environment: + + Win32, User Mode + +Notes: + + The master copy of this file resides in the CodeView project. All + Microsoft projects are required to use the master copy without + modification. Modification of the master version or a copy without + consultation with all parties concerned is extremely risky. + + The projects known to use this version (1.00.00) are: + + Codeview + Sequoia + C/C++ expression evaluator + Cobol expression evaluator + QC/Windows + Pascal 2.0 expression evaluator + +--*/ + +#if ! defined( _EEAPI_ ) +#define _EEAPI_ + + +// ********************************************************************** +// * * +// * Initialization Structures * +// * * +// ********************************************************************** + +typedef struct { +void FAR * (LOADDS PASCAL *pMHlpvAlloc)( size_t ); +void (LOADDS PASCAL *pMHFreeLpv)(void FAR *); +HEXE (LOADDS PASCAL *pSHGetNextExe)(HEXE); +HEXE (LOADDS PASCAL *pSHHexeFromHmod)(HMOD); +HMOD (LOADDS PASCAL *pSHGetNextMod)(HEXE, HMOD); +PCXT (LOADDS PASCAL *pSHGetCxtFromHmod)(HMOD, PCXT); +PCXT (LOADDS PASCAL *pSHGetCxtFromHexe)(HEXE, PCXT); +PCXT (LOADDS PASCAL *pSHSetCxt)(LPADDR, PCXT); +PCXT (LOADDS PASCAL *pSHSetCxtMod)(LPADDR, PCXT); +HSYM (LOADDS PASCAL *pSHFindNameInGlobal)(HSYM, PCXT, LPSSTR, SHFLAG, PFNCMP, PCXT); +HSYM (LOADDS PASCAL *pSHFindNameInContext)(HSYM, PCXT, LPSSTR, SHFLAG, PFNCMP, PCXT); +HSYM (LOADDS PASCAL *pSHGoToParent)(PCXT, PCXT); +HSYM (LOADDS PASCAL *pSHHsymFromPcxt)(PCXT); +HSYM (LOADDS PASCAL *pSHNextHsym)(HMOD, HSYM); +PCXF (LOADDS PASCAL *pSHGetFuncCxf)(LPADDR, PCXF); +char FAR * (LOADDS PASCAL *pSHGetModName)(HMOD); +char FAR * (LOADDS PASCAL *pSHGetExeName)(HEXE); +char FAR * (LOADDS PASCAL *pSHGetModNameFromHexe)(HEXE); +char FAR * (LOADDS PASCAL *pSHGetSymFName)(HEXE); +HEXE (LOADDS PASCAL *pSHGethExeFromName)(char FAR *); +HEXE (LOADDS PASCAL *pSHGethExeFromModuleName)(char FAR *); +UOFF32 (LOADDS PASCAL *pSHGetNearestHsym)(LPADDR, HMOD, int, PHSYM); +SHFLAG (LOADDS PASCAL *pSHIsInProlog)(PCXT); +SHFLAG (LOADDS PASCAL *pSHIsAddrInCxt)(PCXT, LPADDR); +UINT (LOADDS PASCAL *pSHModelFromAddr)(PADDR,LPW,LPB,UOFFSET FAR *); + + +BOOL (LOADDS PASCAL *pSLLineFromAddr) ( LPADDR, unsigned short FAR *, SHOFF FAR *, SHOFF FAR * ); +BOOL (LOADDS PASCAL *pSLFLineToAddr) ( HSF, WORD, LPADDR, SHOFF FAR *, WORD FAR * ); +char FAR * (LOADDS PASCAL *pSLNameFromHsf) ( HSF ); +HMOD (LOADDS PASCAL *pSLHmodFromHsf) ( HEXE, HSF ); +HSF (LOADDS PASCAL *pSLHsfFromPcxt) ( PCXT ); +HSF (LOADDS PASCAL *pSLHsfFromFile) ( HMOD, char FAR * ); + +UOFF32 (LOADDS PASCAL *pPHGetNearestHsym)(LPADDR, HEXE, PHSYM); +HSYM (LOADDS PASCAL *pPHFindNameInPublics)(HSYM, HEXE, LPSSTR, SHFLAG, PFNCMP); +HTYPE (LOADDS PASCAL *pTHGetTypeFromIndex)(HMOD, THIDX); +HTYPE (LOADDS PASCAL *pTHGetNextType)(HMOD, HTYPE); +HDEP (LOADDS PASCAL *pMHMemAllocate)(UINT); +HDEP (LOADDS PASCAL *pMHMemReAlloc)(HDEP, UINT); +void (LOADDS PASCAL *pMHMemFree)(HDEP); +LPV (LOADDS PASCAL *pMHMemLock)(HDEP); +void (LOADDS PASCAL *pMHMemUnLock)(HDEP); +SHFLAG (LOADDS PASCAL *pMHIsMemLocked)(HDEP); +UINT (LOADDS PASCAL *pDHGetDebuggeeBytes)(ADDR, UINT, void FAR *); +UINT (LOADDS PASCAL *pDHPutDebuggeeBytes)(ADDR, UINT, void FAR *); +PSHREG (LOADDS PASCAL *pDHGetReg)(PSHREG, PCXT); +PSHREG (LOADDS PASCAL *pDHSetReg)(PSHREG, PCXT); +UINT (LOADDS PASCAL *pDHSetupExecute)(LPHDEP); +UINT (LOADDS PASCAL *pDHCleanUpExecute)(HDEP); +UINT (LOADDS PASCAL *pDHStartExecute)(HDEP, LPADDR, BOOL, SHCALL); +char FAR *pin386mode; +char FAR *pis_assign; +void (LOADDS PASCAL *passert)(LPCH,LPCH,UINT); +void (LOADDS PASCAL *pquit)(UINT); +ushort FAR *pArrayDefault; +SHFLAG (LOADDS PASCAL *pSHCompareRE)(char FAR *, char FAR *, BOOL); +SHFLAG (LOADDS PASCAL *pSHFixupAddr)(LPADDR); +SHFLAG (LOADDS PASCAL *pSHUnFixupAddr)(LPADDR); +SHFLAG (LOADDS PASCAL *pCVfnCmp)(HVOID, HVOID, char FAR *, SHFLAG); +SHFLAG (LOADDS PASCAL *pCVtdCmp)(HVOID, HVOID, char FAR *, SHFLAG); +SHFLAG (LOADDS PASCAL *pCVcsCmp)(HVOID, HVOID, char FAR *, SHFLAG); +BOOL (LOADDS PASCAL *pSYGetAddr)(PADDR, int); +DWORD (LOADDS PASCAL *pSYGetMemInfo)(LPMEMINFO); +BOOL (LOADDS PASCAL *pSHWantSymbols)(HEXE); +} CVF; // CodeView kernel Functions exported to the Expression Evaluator +typedef CVF FAR * PCVF; + +typedef struct { + short (CDECL *pintLoadDS)(); + char NEAR * (CDECL *pultoa)(ulong, char NEAR *, int); + char NEAR * (CDECL *pitoa)(int, char NEAR *, int); + char NEAR * (CDECL *pltoa)(long, char NEAR *, int); + int (CDECL *peprintf)(const char FAR *, char FAR *, char FAR *, int); + int (CDECL *psprintf)(char NEAR *, const char FAR *, ...); +} CRF; // C Runtime functions exported to the Expression Evaluator +typedef CRF FAR * PCRF; + +typedef struct CI { + char cbCI; + char Version; + CVF FAR * pStructCVAPI; + CRF FAR * pStructCRuntime; +} CI; +typedef CI FAR * PCI; + + +typedef struct HDR_TYPE { + ushort offname; + ushort lenname; + ushort offtrail; +} HDR_TYPE; +typedef HDR_TYPE FAR *PHDR_TYPE; + +// ********************************************************************** +// * * +// * the expr evaluator stuff * +// * * +// ********************************************************************** + +typedef HDEP HSYML; //* An hsym list +typedef HSYML FAR * PHSYML; //* A pointer to a hsym list +typedef uint EERADIX; +typedef EERADIX FAR * PEERADIX; +typedef uchar FAR * PEEFORMAT; +typedef ushort EESTATUS; +typedef HDEP EEHSTR; +typedef EEHSTR FAR * PEEHSTR; +typedef HDEP HTM; +typedef HTM FAR * PHTM; +typedef HDEP HTI; +typedef HTI FAR * PHTI; + + +typedef enum { + fmtAscii = 0, + fmtInt = 1, + fmtUInt = 2, + fmtFloat = 3, + fmtAddress = 4, + fmtUnicode = 5, + fmtBasis = 0x0f, + + fmtOverRide = 0x2000, // override logic to force radix + fmtZeroPad = 0x4000 +} FMTTYPE; + + +// Error return values +#define EENOERROR 0 +#define EENOMEMORY 1 +#define EEGENERAL 2 +#define EEBADADDR 3 +#define EEBADFORMAT 4 +#define EEOVERRUN 5 +#define EEOPTIONAL 6 // expression valid for optional form +#define EEDEFAULT 7 // argument was missing; default value was used +#define EECATASTROPHIC 0XFF + +typedef enum { + EEHORIZONTAL, + EEVERTICAL, + EEBPADDRESS +} EEDSP; // Display format specifier + +typedef enum { + EENOTEXP, + EEAGGREGATE, + EETYPE, + EEPOINTER, + EETYPENOTEXP +} EEPDTYP; +typedef EEPDTYP FAR *PEEPDTYP; + +typedef enum { + EEFMT_32 = 0x01, /* Display a 32-bit offset */ + EEFMT_SEG = 0x02, /* Display a segment */ + EEFMT_LOWER = 0x04, /* Use lowercase letters */ + EEFMT_REAL = 0x08 /* Real mode address */ +} EEFMTFLGS; + +typedef struct TML { + unsigned cTMListMax; + unsigned cTMListAct; + unsigned iTMError; + HDEP hTMList; +} TML; +typedef TML FAR *PTML; + +#define TMLISTCNT 20 // number of entries in TM list + + +typedef struct RI { + ushort fSegType :1; + ushort fAddr :1; + ushort fValue :1; + ushort fSzBits :1; + ushort fSzBytes :1; + ushort fLvalue :1; + ushort Type; +} RI; +typedef RI FAR * PRI; + +typedef struct TI { + RI fResponse; + struct { + ushort SegType :4; + ushort fLvalue :1; + ushort fAddrInReg :1; + ushort fBPRel :1; + ushort fFunction :1; + ushort fLData :1; // True if expression references local data + ushort fGData :1; // True if expression references global data + ushort fFmtStr :1; + } u; + union { + ADDR AI; + ushort hReg; // This is really a CV_HREG_e + } u2; + ulong cbValue; +#ifdef i386 + char Value[0]; +#else + char Value[1]; +#endif +} TI; +typedef TI FAR * PTI; + +typedef struct { + HSYM hSym; + CXT CXT; +} HCS; + +typedef struct { + CXT CXT; + ushort cHCS; +#ifdef i386 + HCS rgHCS[0]; +#else + HCS rgHCS[1]; +#endif +} CXTL; + +typedef HDEP HCXTL; +typedef HCXTL FAR * PHCXTL; +typedef CXTL FAR * PCXTL; + +// Structures for Get/Free HSYMList + +// Search request / response flags for Get/Free HSYMList + +#define HSYMR_lexical 0x0001 // lexical out to function scope +#define HSYMR_function 0x0002 // function scope +#define HSYMR_class 0x0004 // class scope +#define HSYMR_module 0x0008 // module scope +#define HSYMR_global 0x0010 // global symbol table scope +#define HSYMR_exe 0x0020 // all other module scope +#define HSYMR_public 0x0040 // public symbols +#define HSYMR_nocase 0x8000 // case insensitive +#define HSYMR_allscopes \ + HSYMR_lexical | \ + HSYMR_function | \ + HSYMR_class | \ + HSYMR_module | \ + HSYMR_global | \ + HSYMR_exe | \ + HSYMR_public + +// structure describing HSYM list for a context + +typedef struct HSL_LIST { + ushort request; // context that this block statisfies + struct { + ushort isused :1; // block contains data if true + ushort hascxt :1; // context packet has been stored + ushort complete :1; // block is complete if true + ushort isclass :1; // context is class if true + } status; + HSYM hThis; // handle of this pointer if class scope + ushort symbolcnt; // number of symbol handles in this block + CXT Cxt; // context for this block of symbols + HSYM hSym[]; // list of symbol handles +} HSL_LIST; +typedef HSL_LIST FAR *PHSL_LIST; + + +typedef struct HSL_HEAD { + ushort size; // number of bytes in buffer + ushort remaining; // remaining space in buffer + PHSL_LIST pHSLList; // pointer to current context list (EE internal) + struct { + ushort endsearch :1; // end of search reached if true + ushort fatal :1; // fatal error if true + } status; + ushort blockcnt; // number of CXT blocks in buffer + ushort symbolcnt; // number of symbol handles in buffer + HDEP restart; // handle of search restart information +} HSL_HEAD; +typedef HSL_HEAD FAR *PHSL_HEAD; + +typedef struct { +void (LOADDS PASCAL *pEEFreeStr)(EEHSTR); +EESTATUS (LOADDS PASCAL *pEEGetError)(PHTM, EESTATUS, PEEHSTR); +EESTATUS (LOADDS PASCAL *pEEParse)(char FAR *, EERADIX, SHFLAG, PHTM, uint FAR *); +EESTATUS (LOADDS PASCAL *pEEBindTM)(PHTM, PCXT, SHFLAG, SHFLAG,BOOL); +EESTATUS (LOADDS PASCAL *pEEvaluateTM)(PHTM, PFRAME, EEDSP); +EESTATUS (LOADDS PASCAL *pEEGetExprFromTM)(PHTM, PEERADIX, PEEHSTR, ushort FAR *); +EESTATUS (LOADDS PASCAL *pEEGetValueFromTM)(PHTM, EERADIX, PEEFORMAT, PEEHSTR); +EESTATUS (LOADDS PASCAL *pEEGetNameFromTM)(PHTM, PEEHSTR); +EESTATUS (LOADDS PASCAL *pEEGetTypeFromTM)(PHTM, EEHSTR, PEEHSTR, ulong); +EESTATUS (LOADDS PASCAL *pEEFormatCXTFromPCXT)(PCXT, PEEHSTR, BOOL); +void (LOADDS PASCAL *pEEFreeTM)(PHTM); +EESTATUS (LOADDS PASCAL *pEEParseBP)(char FAR *, EERADIX, SHFLAG, PCXF, PTML, ulong, uint FAR *, SHFLAG); +void (LOADDS PASCAL *pEEFreeTML)(PTML); +EESTATUS (LOADDS PASCAL *pEEInfoFromTM)(PHTM, PRI, PHTI); +void (LOADDS PASCAL *pEEFreeTI)(PHTI); +EESTATUS (LOADDS PASCAL *pEEGetCXTLFromTM)(PHTM, PHCXTL); +void (LOADDS PASCAL *pEEFreeCXTL)(PHCXTL); +EESTATUS (LOADDS PASCAL *pEEAssignTMToTM)(PHTM, PHTM); +EEPDTYP (LOADDS PASCAL *pEEIsExpandable)(PHTM); +SHFLAG (LOADDS PASCAL *pEEAreTypesEqual)(PHTM, PHTM); +EESTATUS (LOADDS PASCAL *pEEcChildrenTM)(PHTM, long FAR *, PSHFLAG); +EESTATUS (LOADDS PASCAL *pEEGetChildTM)(PHTM, long, PHTM, uint FAR *, SHFLAG, uint); +EESTATUS (LOADDS PASCAL *pEEDereferenceTM)(PHTM, PHTM, uint FAR *, SHFLAG); +EESTATUS (LOADDS PASCAL *pEEcParamTM)(PHTM, ushort FAR *, PSHFLAG); +EESTATUS (LOADDS PASCAL *pEEGetParmTM)(PHTM, uint, PHTM, uint FAR *, SHFLAG, uint); +EESTATUS (LOADDS PASCAL *pEEGetTMFromHSYM)(HSYM, PCXT, PHTM, uint FAR *, SHFLAG); +EESTATUS (LOADDS PASCAL *pEEFormatAddress)(SHSEG, SHOFF, char FAR *, uint, uint); +EESTATUS (LOADDS PASCAL *pEEGetHSYMList)(PHSYML, PCXT, ushort, uchar FAR *, SHFLAG); +void (LOADDS PASCAL *pEEFreeHSYMList)(PHSYML); +EESTATUS (LOADDS PASCAL *pEEFormatAddr)(LPADDR, char FAR *, uint, uint); +EESTATUS (LOADDS PASCAL *pEEUnFormatAddr)(LPADDR, char FAR *); +SHFLAG (LOADDS PASCAL *pfnCmp)(HVOID, HVOID, char FAR *, SHFLAG); +SHFLAG (LOADDS PASCAL *ptdCmp)(HVOID, HVOID, char FAR *, SHFLAG); +SHFLAG (LOADDS PASCAL *pcsCmp)(HVOID, HVOID, char FAR *, SHFLAG); +EESTATUS (LOADDS PASCAL *pEEFormatMemory)(char FAR *, uint, char FAR *, uint, FMTTYPE, uint); +EESTATUS (LOADDS PASCAL *pEEUnformatMemory)(uchar FAR *, char FAR *, uint, FMTTYPE, uint); +EESTATUS (LOADDS PASCAL *pEEFormatEnumerate)(uint, uint FAR *, uint FAR *, uint FAR *, + uint FAR *, uint FAR *, LPCH FAR *); +HTYPE (LOADDS PASCAL *pEEGetHtypeFromTM)(PHTM); +void (LOADDS PASCAL *pEESetSuffix)(char); + +} EXF; +typedef EXF FAR * PEXF; + +typedef struct EI { + char cbEI; + char Version; + PEXF pStructExprAPI; + char Language; + char FAR *IdCharacters; + char FAR *EETitle; + char FAR *EESuffixes; + char FAR *Assign; // length prefixed assignment operator +} EI; +typedef EI FAR * PEI; + +// FNEEINIT is the prototype for the EEInitializeExpr function +typedef VOID LOADDS PASCAL FAR FNEEINIT(PCI, PEI); +typedef VOID (PASCAL LOADDS FAR * LPFNEEINIT)(PCI, PEI); + +// This is the only EE function that's actually exported from the DLL +//FNEEINIT EEInitializeExpr; + +#endif // _EEAPI_ diff --git a/private/windbg/osdebug/include/emdm.h b/private/windbg/osdebug/include/emdm.h new file mode 100644 index 000000000..a58f712b3 --- /dev/null +++ b/private/windbg/osdebug/include/emdm.h @@ -0,0 +1,432 @@ +/**** EMDM.HMD - Common structures for Win32/NT EM and DM **** + * * + * * + * Copyright <C> 1990, Microsoft Corp * + * * + * Created: November 17, 1990 by David W. Gray * + * * + * Purpose: * + * * + * This file defines the types, enums, and constants that are common * + * for all execution models, both debugger and debuggee end. * + * * + ***************************************************************************/ + +#ifndef _EMDM +#define _EMDM + +//#if !defined(DOS32) || (defined(DOS32) && defined(DOS32DM)) +#include "cvinfo.h" +//#endif + +// Shared message structs for od/em/dm +#include "odmsg.h" + +// +// This is included to define a NONVOLATILE_CONTEXT_POINTERS structure +// of the appropriate size. The goal is to keep any machine-specific +// reference out of emdp.c here, but we need to know how much data to +// transfer to the thread context on the different architectures. +// + +#include "ctxptrs.h" + +#define MAXCACHE 16 +#define CACHESIZE 0x100 + + +typedef unsigned MTE; + +#ifdef TARGET32 +#define MAXBIGSEGS 3 +#endif + + +typedef enum { + dmfRemoteDied = -1, /* debugger quit */ + dmfCommError = -2, /* transport layer error */ + + dmfNull = 0, + + dmfBreakpoint, + dmfGetExceptionState, + dmfSetExceptionState, + + + dmfReadMem, + dmfReadReg, + dmfReadFrameReg, + dmfWriteMem, + dmfWriteReg, + dmfWriteFrameReg, + dmfGetFP, + dmfSetFP, + + dmfThreadStatus, + dmfProcessStatus, + + dmfGo, + dmfTerm, + dmfStop, + dmfFreeze, + dmfResume, + dmfSingleStep, + dmfRangeStep, + //dmfReturnStep, + dmfSelect, + dmfConnect, + dmfInit, + dmfUnInit, + dmfProgLoad, + dmfProgFree, + dmfInit32SegValues, + dmfCreatePid, + dmfDestroyPid, + dmfSelLim, + dmfSetMulti, + dmfClearMulti, + dmfDebugger, + dmfSync, + dmfIOCTL, + dmfSendChar, + //dmfGoToReturn, + dmfSetupExecute, + dmfStartExecute, + dmfCleanUpExecute, + dmfDebugActive, + dmfSetPath, + dmfQueryTlsBase, + dmfPollForDebugEvents, // WIN32S only + dmfPollMessageLoop, // WIN32S only + dmfGetPrompt, + dmfQuerySelector, + dmfVirtualQuery, + dmfOmapCheck, // Lego + dmfOmapToSrc, // Lego + dmfOmapFromSrc, // Lego + dmfReadRegEx, + dmfWriteRegEx, + dmfGetDmInfo, + dmfRemoteQuit, + dmfGetSections, + dmfLast +} _DMF; + +typedef LONG DMF; + + +typedef struct _DM_MSG { + union { + XOSD_ xosdRet; + DWORDLONG Alignment; + }; + char rgb[1]; +} DM_MSG, *LPDM_MSG; + +#define iflgMax 12 + + +#pragma pack(4) + +typedef struct _RST { + BOOL fStepOver; + BOOL fAllThreads; + BOOL fInitialBP; +#ifdef TARGET32 + CV_uoff32_t offStart; + CV_uoff32_t offEnd; + CV_uoff32_t offPC; +#else + ADDR addrStart; + ADDR addrEnd; + ADDR addrCSIP; +#endif +} RST; // Range STep Packet + +typedef struct _SETPTH { + BOOL Set; + char Path[1]; +} SETPTH; + +#pragma pack() + +// +// DM Misc info structure. +// +// Some of these correspond to the debug metrics exposed by OSDebug. +// These cover the differences between user and kernel mode, Win32, +// Win32s and Win32c, maybe Cairo, whatever other DMs might be handled +// by the Win32 EM. +// + +typedef struct _PROCESSOR { + MPT Type; + DWORD Level; + END Endian; +} PROCESSOR, FAR * LPPROCESSOR; + +typedef struct _DMINFO { + DWORD fAsync:1; // read/write mem and regs while running? + DWORD fHasThreads:1; // + DWORD fReturnStep:1; // step out of function? + DWORD fRemote:1; // target is not on debugger host + DWORD fAsyncStop:1; // OSDAsyncStop supported + DWORD fAlwaysFlat:1; // Addresses are always flat + DWORD fHasReload:1; // !reload support + + DWORD cbSpecialRegs; // size of private regs struct for dmfGetRegsEx + WORD MajorVersion; // + WORD MinorVersion; // + BPTS Breakpoints; // OSDebug breakpoints supported + PROCESSOR Processor; +} DMINFO; +typedef DMINFO FAR * LPDMINFO; + + +typedef RST *PRST; +typedef RST FAR *LPRST; + +typedef struct _GOP { + USHORT fBpt; + USHORT fAllThreads; + ADDR addr; +} GOP; // Go until this address + +typedef GOP *PGOP; +typedef GOP FAR *LPGOP; + +// DO NOT TAKE THIS OUT - *#&*@(#@*(& !!!!!!!!!!!!!!! + +#ifdef TARGET32 + +#define BP_INSTR 0 + +typedef struct _SBP { + HPID id; + BOOL fAddr; + ADDR addr; + DWORD Size; + DWORD BpType; +} SBP; + +typedef SBP FAR* LPSBP; + +#endif + +typedef struct _WPR { + BPR bpr; + SEGMENT segWP; + UOFFSET offWP; + WORD ireg; +} WPR; // WatchPoint Return +typedef WPR FAR *LPWPR; + +typedef struct _EHP { + DWORD iException; + BOOL fHandle; +} EHP; // Exception Handled Packet +typedef EHP FAR *LPEHP; + +typedef struct _TTR { + BPR bpr; + ULONG ulExitCode; +} TTR; // Thread (or Process) Term Return; +typedef TTR FAR *LPTTR; + +typedef struct _RSR { + WORD segCS; + UOFFSET offIP; + WORD segSS; + UOFFSET offBP; + WORD segCSNext; + UOFFSET offIPNext; +} RSR; // Range Step Return +typedef RSR FAR *LPRSR; + + +typedef struct _OBJD { + DWORD offset; + DWORD cb; + WORD wSel; + WORD wPad; +} OBJD, FAR * LPOBJD; + +typedef struct _MODULELOAD { + WORD mte; + WORD pad0; + LPVOID lpBaseOfDll; + DWORD dwSizeOfDll; + SEGMENT StartingSegment; + BOOL fRealMode; + BOOL fFlatMode; + BOOL fOffset32; + SEGMENT CSSel; + SEGMENT DSSel; + LONG cobj; + OBJD rgobjd[]; +} MODULELOAD; +typedef MODULELOAD FAR *LPMODULELOAD; + +typedef struct _RWP { + DWORD cb; + ADDR addr; + BYTE rgb[]; +} RWP; // Read Write Packet +typedef RWP *PRWP; +typedef RWP FAR *LPRWP; + + +typedef struct _NPP { + PID pid; + BOOL fReallyNew; +} NPP; // New Process Packet, used with dbcNewProc. See od.h for description + // of fReallyNew +typedef NPP FAR * LPNPP; + +typedef struct _WPP { + ADDR addr; + WORD cb; +} WPP; // Watch Point Packet +typedef WPP FAR *LPWPP; + +typedef struct _SLI { + WORD wSelector; + WORD wSegNo; + WORD mte; +} SLI, FAR * LPSLI; + +// Exception command packet +typedef struct _EXCMD { + EXCEPTION_CONTROL exc; + EXCEPTION_DESCRIPTION exd; +} EXCMD; +typedef EXCMD FAR * LPEXCMD; + + +// The DBCEs always come back in an RTP structure, which has additional +// info. The comments on the DBCEs below refer to the other fields of +// the RTP structure. +enum { + dbceAssignPID = dbcMax, // Tell the EM what PID is associated with + // a given HPID. At offset 0 of rtp.rgbVar[] + // is the PID. + dbceLoadBigSegTbl, // ?? + dbceCheckBpt, // Find out if EM wants us to single-step + // over a specified breakpoint. Upon return, + // rgbVar[0] is fStop to stop at this + // breakpoint; if fStop is FALSE, then + // rgbVar[1] is the byte with which to + // overwrite the INT 3. + dbceFinishedLoad, // Tell the EM we're done with a dmfProgLoad. + // rgbVar is empty. + dbceInstructionLen, // Ask the em how long the instruction is. + // rgbVar contains the cs:ip + dbceSegLoad, // WOW just loaded a segment + dbceSegMove, // Moved a segment + dbceModFree16, // Unload of a 16-bit DLL + dbceModFree32, // Unload of a 32-bit DLL + dbceGetOffsetFromSymbol, // - Call the expression evaluator + // wParam = nothing + // lParam = pointer to the expression + dbceGetSymbolFromOffset, // - Call the expression evaluator + // wParam = nothing + // lParam = pointer to the expression + dbceEnableCache, // - Enable/Disable the em's cache + // wParam = nothing + // lParam = TRUE/FALSE + dbceMax +} _DBCE; +typedef LONG DBCE; + +#pragma pack(1) + +// it is important that the rgbVar fields be aligned on a DWORD boundary + +typedef struct _DBB { + union { + DMF dmf; + DWORD dw0; + }; + HPID hpid; + HTID htid; + BYTE rgbVar[ ]; +} DBB; + + +typedef DBB *PDBB; +typedef DBB FAR *LPDBB; + +typedef struct _RTP { + union { + DBC dbc; // a DBC or a DBCE + DWORD dw0; + }; + HPID hpid; + HTID htid; + union { + WORD cb; // the length of rgbVar + DWORD dw1; + }; + BYTE rgbVar[ ]; // additional information - see the + // definitions of the DBCE and DBC codes +} RTP; + +#pragma pack() + +typedef RTP *PRTP; +typedef RTP FAR *LPRTP; + +typedef struct _RTRNSTP { + EXOP exop; + ADDR addrRA; // Address to return to + ADDR addrBase; // Address of what SP should be when returning +} RTRNSTP; // ReTuRN STeP packet +typedef RTRNSTP FAR *LPRTRNSTP; + + + + + + + + +#define lpregDbb(dbb) ( (LPREG) &dbb ) +#define lpfprDbb(dbb) ( (LPFPR) &dbb ) +#define lszDbb(dbb) ( (LSZ) &dbb ) + +#define addrDbb(dbb) (*( (LPADDR) &dbb )) +#define stpDbb(dbb) (*( (LPSTP) &dbb )) +#define rstDbb(dbb) (*( (LPRST) &dbb )) +#define gopDbb(dbb) (*( (LPGOP) &dbb )) +#define tstDbb(dbb) (*( (LPTST) &dbb )) +#define pstDbb(dbb) (*( (LPF) &dbb )) +#define rwpDbb(dbb) (*( (LPRWP) &dbb )) +#define fDbb(dbb) (*( (LPF) &dbb )) + + + +/**************************************************************************** + * * + * Packets returned from the debuggee execution model to the debugger * + * execution model. * + * * + ****************************************************************************/ + +#ifdef DOS32DM +#undef BOOL +#endif + +typedef struct _FRAME_INFO { + CONTEXT frameRegs; + KNONVOLATILE_CONTEXT_POINTERS frameRegPtrs; +} FRAME_INFO, * PFRAME_INFO; + + +#ifdef SMARTALIAS + +#define GetInvalid(w,i) ((w>>i)&1) +#define SetInvalid(w,i) w=((1<<i)|w) + +#endif + +#endif // _EMDM diff --git a/private/windbg/osdebug/include/heap.h b/private/windbg/osdebug/include/heap.h new file mode 100644 index 000000000..2052e0877 --- /dev/null +++ b/private/windbg/osdebug/include/heap.h @@ -0,0 +1,16 @@ + +#if USE_HEAP_CHECKING + +void +ValidateTheHeap( + char *fName, + unsigned long dwLine + ); + +#define ValidateHeap() ValidateTheHeap( __FILE__, __LINE__ ) + +#else + +#define ValidateHeap() + +#endif diff --git a/private/windbg/osdebug/include/ll.h b/private/windbg/osdebug/include/ll.h new file mode 100644 index 000000000..f971f906c --- /dev/null +++ b/private/windbg/osdebug/include/ll.h @@ -0,0 +1,9 @@ +/* +** This file can be used as a single include file to get all of +** the list manager types and prototypes. The files can also be +** included independently +** +*/ + +#include "lltypes.h" +#include "llproto.h" diff --git a/private/windbg/osdebug/include/llproto.h b/private/windbg/osdebug/include/llproto.h new file mode 100644 index 000000000..c1f54960b --- /dev/null +++ b/private/windbg/osdebug/include/llproto.h @@ -0,0 +1,70 @@ +/* +** This file contains the set of prototypes and defines which pass +** as functions for the list manager subsystem. +** +*/ + +#ifndef LL_PROTO_INCLUDED +#define LL_PROTO_INCLUDED 1 + + +/* +** Prototypes for the list manager system +*/ + +extern HLLI PASCAL LOADDS LLHlliInit( UINT, LLF, LPFNKILLNODE, LPFNFCMPNODE ); +extern HLLE PASCAL LOADDS LLHlleCreate( HLLI ); +extern void PASCAL LOADDS LLAddHlleToLl( HLLI, HLLE ); +extern void PASCAL LOADDS LLInsertHlleInLl( HLLI, HLLE, DWORD ); +extern BOOL PASCAL LLFDeleteHlleIndexed( HLLI, DWORD ); +extern BOOL PASCAL LLFDeleteLpvFromLl( HLLI, HLLE, LPV, DWORD ); +extern BOOL PASCAL LOADDS LLFDeleteHlleFromLl( HLLI, HLLE ); +extern HLLE PASCAL LOADDS LLHlleFindNext( HLLI, HLLE ); +extern LONG PASCAL LOADDS LLChlleDestroyLl( HLLI ); +extern HLLE PASCAL LOADDS LLHlleFindLpv( HLLI, HLLE, LPV, DWORD ); +extern DWORD PASCAL LOADDS LLChlleInLl( HLLI ); +extern LPV PASCAL LOADDS LLLpvFromHlle( HLLE ); +extern VOID PASCAL LOADDS LLUnlockHlle( HLLE ); +extern HLLE PASCAL LOADDS LLHlleGetLast( HLLI ); +extern void PASCAL LOADDS LLHlleAddToHeadOfLI( HLLI, HLLE ); +extern BOOL PASCAL LOADDS LLFRemoveHlleFromLl( HLLI, HLLE ); + + +#ifdef DBLLINK +extern HLLE PASCAL LOADDS LLHlleFindPrev( HLLI, HLLE ); +#endif // DBLLINK + +// +// FCheckHlli is for debug versions ONLY as an integrety check +// + +#ifdef DEBUGVER +extern BOOL PASCAL LLFCheckHlli( HLLI ); +#else // DEBUGVER +#define LLFCheckHlli(hlli) TRUE +#endif // DEBUGVER + +// +// Map memory manager to our source versions +// + +#define AllocHmem(cb) MMhAllocMb(MMDLLHEAP,CVMALLOCED,cb) // _fmalloc(cb) +#define FreeHmem(h) MMDeallocMb(h) // _ffree(h) +#define LockHmem(h) MMlpvLockMb(h) // (h) +#define UnlockHmem(h) MMbUnlockMb(h) // + +// +// This helps the codes appearance! +// + +#define UnlockHlle(hlle) UnlockHmem((HDEP) hlle) +#define UnlockHlli(hlli) UnlockHmem(hlli) + + +/* +** More help on code appearance +*/ + +#define LLHlleDestroy(hlle) MMDeallocateMb(h) + +#endif /* LL_PROTO_INCLUDED */ diff --git a/private/windbg/osdebug/include/lltypes.h b/private/windbg/osdebug/include/lltypes.h new file mode 100644 index 000000000..4083933f3 --- /dev/null +++ b/private/windbg/osdebug/include/lltypes.h @@ -0,0 +1,22 @@ +/* +** This file contains the basic types used by the list manager. +** +** It is assumed that these will not be passed across a transport +** layer from an EM to a DM or from a DM to an EM. These types are +** therefore defined in a machine dependent manner. +*/ + +#ifndef LL_TYPES_INCLUDED +#define LL_TYPES_INCLUDED 1 + +// +// Return values from lpfnCmpNode functions +// + +#define fCmpLT -1 +#define fCmpEQ 0 +#define fCmpGT 1 + +#define hlleNull (HLLE)NULL + +#endif /* LL_TYPES_INCLUDED */ diff --git a/private/windbg/osdebug/include/od.h b/private/windbg/osdebug/include/od.h new file mode 100644 index 000000000..619504f01 --- /dev/null +++ b/private/windbg/osdebug/include/od.h @@ -0,0 +1,1160 @@ +/*++ + +Copyright (c) 1992 Microsoft Corporation + +Module Name: + + Od.h + +Abstract: + +Author: + + David J. Gilman (davegi) 05-Apr-1992 + +Environment: + + Win32, User Mode + +--*/ + +#if ! defined _OD_ +#define _OD_ + +#include "shapi.hxx" +#include "odmsg.h" + +typedef enum { + xosdContinue = 1, + xosdNone = 0, + xosdQueueEmpty = -1, + xosdModLoad = -2, + xosdFindProc = -3, + xosdOSStruct = -4, + xosdSyntax = -5, + xosdInvalidProc = -6, + xosdInvalidThread = -7, + xosdInvalidTL = -8, + xosdInvalidEM = -9, + xosdNoProc = -10, + xosdProcRunning = -11, + xosdCreateDBGThread = -12, + xosdOutOfMemory = -13, + xosdInvalidBreakPoint = -14, + xosdBadAddress = -15, + xosdNoWatchPoints = -16, + xosdInvalidPID = -17, + xosdInvalidTID = -18, + xosdOutOfThreads = -19, + xosdOutOfProcs = -20, + xosdPtrace = -21, + xosdLoadChild = -22, + xosdRead = -23, + xosdWrite = -24, + xosdBadQueue = -25, + xosdEMInUse = -26, + xosd27 = -27, + xosdTLInUse = -28, + xosd29 = -29, + xosdFatal = -30, + xosdUnknown = -31, + xosdInvalidMTE = -32, + xosdInvalidSelector = -33, + xosdInvalidRegister = -34, + + xosdInvalidParameter = -35, + xosdOutOfStructures = -36, + xosdPathNotFound = -37, + xosdLineBusy = -38, + xosdBadLine = -39, + xosdBrokenLine = -40, + xosdInterrupt = -41, + xosdInvalidFunction = -42, + xosdLineNotConnected = -43, + xosdAccessDenied = -44, + xosdCannotMake = -45, + xosdFileNotFound = -46, + xosdInvalidAccess = -47, + xosdOpenFailed = -48, + xosdSharingBufferExeeded= -49, + xosdSharingViolation = -50, + xosdLine = -51, + xosdEndOfStack = -52, + xosdFPNotLoaded = -53, + + xosdQuit = -54, + xosdTooManyObjects = -55, + xosdGetModNameFail = -56, + xosdCannotConnect = -57, + xosdPunt = -58, + xosdNotFound = -59, + xosdIDError = -60, + xosdOverrun = -61, + xosdBadFormat = -62, + + xosdAsmTooFew = -63, + xosdAsmTooMany = -64, + xosdAsmSize = -65, + xosdAsmBadRange = -66, + xosdAsmOverFlow = -67, + xosdAsmSyntax = -68, + xosdAsmBadOpcode = -69, + xosdAsmExtraChars = -70, + xosdAsmOperand = -71, + xosdAsmBadSeg = -72, + xosdAsmBadReg = -73, + xosdAsmDivide = -74, + xosdAsmSymbol = -75, + xosdErrorMoreInfo = -76, + xosdUnsupported = -77, + xosdCannotDebug = -78, + xosdVDMRunning = -79, + xosdBadRemoteVersion = -80, + xosdBadVersion = -81, + xosdCantOpenComPort = -82, + xosdBadComParameters = -83, + xosdBadPipeServer = -84, + xosdBadPipeName = -85, + xosdNotRemote = -86, + xosdAttachDeadlock = -87 +} XOSD; + +typedef LONG XOSD_; + +typedef XOSD FAR *LPXOSD; + + +typedef struct _INF { + BOOL fReply; // Reply desired + DWORD fUniCode; // Unicode flag + BYTE buffer[]; // the string +} INF; // InfoAvail return +typedef INF * LPINF; + +typedef enum { + fctNone, + fctNear, + fctFar +} FCT; // Function Call Type for OSDGetCaller + +typedef enum { + emNative, + emNonNative +} EMTYPE; + +typedef enum { + stoNone = 0, + stoOneThread = 1, // Execute a single thread + stoInitialBP = 2, // Skip on initial breakpoint + stoQueryStep = 4 // Query before stepping into +} STO; // STep Options + +typedef enum { + dopNone = 0x00000000, + dopAddr = 0x00000001, // put address (w/ seg) in front of disassm + dopFlatAddr = 0x00000002, // put flat address (no seg) + dopOpcode = 0x00000004, // dump the Opcode + dopOperands = 0x00000008, // dump the Operands + dopRaw = 0x00000010, // dump the raw code bytes + dopEA = 0x00000020, // calculate the effective address + dopSym = 0x00000040, // output symbols + dopUpper = 0x00000080, // force upper case for all chars except syms + dopDemand = 0x00000100 // disasm window open only on user demand +} DOP; // Disassembly OPtions + + +typedef struct _SDI { + DOP dop; // Disassembly OPtions (see above) + ADDR addr; // The address to disassemble + BOOL fAssocNext; // This instruction is associated w/ the next one + BOOL fIsBranch; + BOOL fIsCall; + BOOL fJumpTable; + ADDR addrEA0; // First effective address + ADDR addrEA1; // Second effective address + ADDR addrEA2; // Third effective address + int cbEA0; // First effective address size + int cbEA1; // Second effective address size + int cbEA2; // Third effective address size + int ichAddr; + int ichBytes; + int ichOpcode; + int ichOperands; + int ichComment; + int ichEA0; + int ichEA1; + int ichEA2; + LPCH lpch; +} SDI; // Structured DiSsassembly +typedef SDI FAR *LPSDI; + +typedef HIND HTL; // handle to a transport layer +typedef HIND HEM; // handle to an execution model + +typedef HPID FAR *LPHPID; +typedef HTID FAR *LPHTID; +typedef HTL FAR *LPHTL; +typedef HEM FAR *LPHEM; + +typedef struct GIS { + BOOL fCanSetup; + CHAR rgchInfo [ 80 ]; +} GIS; // Get Info Struct for OSDTLGetInfo + +typedef GIS FAR * LPGIS; + + +/* +** Thread state structure +*/ + +typedef enum { + tstRunnable = 0, // Thread is not running but has been stopped due + // to a debug event on another thread in the + // current process, or hasn't run yet. + tstStopped = 1, // Thread is at a debug event (other than exception) + tstRunning = 2, // Thread is current in the scheduler queue + tstExiting = 3, // Thread is in the process of exiting + tstDead = 4, // Thread is no longer schedulable (may not exists for + tstRunMask = 0xf, + // all Ems + tstExcept1st = 0x10, // Thread is at first chance exception + tstExcept2nd = 0x20, // Thread is at second change exception + tstRip = 0x30, // Thread is in a RIP state + tstExceptionMask = 0xf0, + + tstFrozen = 0x100, // Thread has been frozen by Debugger + tstSuspended = 0x200, // Thread has been frozen by Other + tstBlocked = 0x300, // Thread is blocked on something (i.e. a semaphore) + tstSuspendMask= 0xf00, + + tstCritSec = 0x1000, // Thread is currently in a critical section + tstOtherMask = 0xf000 +} TSTATE; + + +// Process state bits +typedef enum { + pstRunning = 0, + pstStopped = 1, + pstExited = 2, + pstDead = 3 +} PSTATE; + + +#define IDSTRINGSIZE 10 +#define STATESTRINGSIZE 60 +typedef struct _PST { + DWORD dwProcessID; + DWORD dwProcessState; + char rgchProcessID[IDSTRINGSIZE]; + char rgchProcessState[STATESTRINGSIZE]; +} PST; +typedef PST FAR * LPPST; + +typedef struct _TST { + DWORD dwThreadID; + DWORD dwSuspendCount; + DWORD dwSuspendCountMax; + DWORD dwPriority; + DWORD dwPriorityMax; + DWORD dwState; + DWORD dwTeb; + char rgchThreadID[IDSTRINGSIZE]; + char rgchState[STATESTRINGSIZE]; + char rgchPriority[STATESTRINGSIZE]; +} TST; +typedef TST FAR * LPTST; + +XOSD PASCAL +OSDGetThreadStatus( + HPID hpid, + HTID htid, + LPTST lptst + ); + +XOSD PASCAL +OSDGetProcessStatus( + HPID hpid, + LPPST lppst + ); + +/* +** +*/ + +typedef enum { + osdGoXXX, // 00 - Run the debuggee + // wParam = nothing + // lParam = nothing + osdSingleStepXXX, // 01 - Single-step + // wParam = sto + // stoOneThread = Step only this thread + // stoInitialBP = Step over init break + // stoQueryStep = Query before stepinto + // lParam = nothing + osdStepOverXXX, // 02 - Single-step, step over calls and ints + // wParam = sto + // stoOneThread = Step only this thread + // stoInitialBP = Step over init break + // lParam = nothing + osdStopXXX, // 03 - Do an asynchronous stop of the process + // wParam = nothing + // lParam = nothing + osdFreeze, // 04 - Freeze thread indicated by HTID + // wParam = nothing + // lParam = nothing + osdThaw, // 05 - Thaw thread indicated by HTID + // wParam = nothing + // lParam = nothing + osdIOCTL, // 06 - Special debuggee controls + // wParam = command- and DM-dependent + // lParam = command- and DM-dependent + osdProcStatusXXX, // 07 - Query process status + // wParam = nothing + // lParam = LPBOOL, filled with fProcRunning + osdThreadStatusXXX, // 08 - Query thread status + // wParam = nothing + // lParam = LPTST (see emp.hmd) + osdReadBuf, // 09 - Read memory from address set on last + // OSDSetAddr(adrCurrent) call + // wParam = number of bytes to read + // lParam = pointer to buffer + osdWriteBuf, // 0A - Write memory to address set on last + // OSDSetAddr(adrCurrent) call + // wParam = number of bytes to write + // lParam = pointer to buffer + osdSetWatchPointXXX, // 0B - Set watchpoint at address set on last + // OSDSetAddr(adrCurrent) call (positive + // return value is a watchpoint number) + // wParam = length of watchpoint + // lParam = type and scope [specify] + osdRemoveWatchPointXXX, // 0C - Remove a watchpoint + // wParam = watchpoint number + // lParam = nothing + osdSetBreakPointXXX, // 0D - Set a breakpoint. + // wParam = fOneThread + // lParam = ptr to ADDR + osdRemoveBreakPointXXX, // 0E - Remove a breakpoint. + // wParam = fOneThread + // lParam = ptr to ADDR + osdRangeStepXXX, // 0F - Perform osdSingleStep until IP is outside + // range from starting IP to ADDR pointed to + // by lParam + // wParam = sto + // stoOneThread = Step only this thread + // stoInitialBP = Step over init break + // stoQueryStep = Query before stepinto + // lParam = ptr to ending ADDR + osdRangeOverXXX, // 10 - Perform osdStepOver until IP is outside + // range from starting IP to ADDR pointed to + // by lParam + // wParam = sto + // stoOneThread = Step only this thread + // stoInitialBP = Step over init break + // lParam = ptr to ending ADDR + osdHandleExceptionXXX, // 11 - Clear current exception on target and + // prepare debuggee for execution + // wParam = nothing + // lParam = nothing + osdGetLibNameXXX, // 12 - Query the name of a module (REVIEW: gone) + // wParam = ?? + // lParam = ?? + osdShowDebuggee, // 13 - Show debugger's or debuggee's screen + // wParam = TRUE for gee's, FALSE for ger's + // lParam = nothing + osdFixupAddr, // 14 - Map ADDR from un-fixed up to fixed up + // wParam = nothing + // lParam = ptr to ADDR + osdUnFixupAddr, // 15 - Map ADDR from fixed up to un-fixed up + // wParam = nothing + // lParam = ptr to ADDR + osdSetEmi, // 16 - Set EMI field of an ADDR + // wParam = nothing + // lParam = ptr to ADDR + osdEMSvcReqXXX, // 17 - [talk to Jon] + // wParam = ?? + // lParam = ?? + osdSendChar, // 18 - Send a character to the target OS + // wParam = ?? + // lParam = ?? + osdFreezeState, // 19 - Freeze or thaw the state of a process. + // wParam = TRUE - Freeze, FALSE - Thaw + // lParam = nothing + osdIsOverlayLoaded, // 1A - Check to see if overlay is loaded + // wParam = ?? + // lParam = point to addr to check + osdCompareAddrs, // 1B - Compare addresses + // + // lParam far pointer to rglpaddr[2]; + // + osdIgnoreExceptionXXX, // 1C - Ignore exception + // wParam = nothing + // lParam = nothing + osdMax // 1D +} OSD; // OSDebug commands for OSDPtrace + +enum _MTRC { + mtrcProcessorType, + mtrcProcessorLevel, + mtrcEndian, + mtrcThreads, + mtrcCRegs, + mtrcCFlags, + mtrcExtRegs, + mtrcExtFP, + mtrcExtMMU, + mtrcPidSize, + mtrcTidSize, + mtrcExceptionHandling, + mtrcAssembler, + mtrcAsync, + mtrcAsyncStop, + mtrcBreakPoints, + mtrcReturnStep, + mtrcShowDebuggee, + mtrcHardSoftMode, + mtrcRemote, + mtrcOleRpc, // Supports OLE Remote Procedure Call debugging? + mtrcNativeDebugger, // Supports low-level debugging (eg MacsBug) + mtrcOSVersion, + mtrcMultInstances +}; +typedef DWORD MTRC; + +enum { + adrCurrent = 1, // scratch address, e.g. for reading/writing memory + adrPC = 2, // program counter (e.g. CS:EIP) + adrBase = 3, // base pointer (e.g. SS:EBP) + adrStack = 4, // stack pointer (e.g. SS:ESP) + adrData = 5, // pointer to beginning of data (e.g. DS:0) +// adrBaseProlog = 6, // base pointer while PC is in prolog of a function(?) + adrTlsBase = 7 // Thread Local Storage base address +}; +typedef short ADR; // address passed to OSDGetAddr/OSDSetAddr + +/* +** Register types --- flags describing recommendations on +** register display +*/ + +enum { + rtProcessMask = 0x0f, // Mask for processor type bits + rtCPU = 0x01, // Central Processing Unit + rtFPU = 0x02, // Floating Point Unit + rtMMU = 0x03, // Memory Manager Unit + + rtGroupMask = 0xf0, // Which group register falls into + rtInvisible = 0x10, // Recommend no display + rtRegular = 0x20, // Recommend regular display + rtExtended = 0x40, // Recommend extended display + rtSpecial = 0x80, // Special registers... + + rtFmtTypeMask = 0xf00, // Mask of display formats + rtInteger = 0x100, // Unsigned integer format + rtFloat = 0x200, // Floating point format + rtAddress = 0x300, // Address format + + rtMiscMask = 0xf000, // misc info + rtPC = 0x1000, // this is the PC + rtFrame = 0x2000, // this reg affects the stack frame + rtNewLine = 0x4000 // print newline when listing +}; +typedef short RT; // Register Types + +#define rtFmtTypeShift 8 + + +/* +** Flag types -- flags describing recommendations on flag display +*/ + +enum { + ftInvisible = 0x01, + ftRegular = 0x02, + ftRegularExt= 0x04, + ftFP = 0x08, + ftFPExt = 0x10, + ftMMU = 0x20, + ftMMUExt = 0x40 +}; +typedef short FT; // Flag Types + +/* +** Register description: This structure contains the description for +** a register on the machine. Note that hReg must be used to get +** the value for this register but a different index is used to get +** this description structure. +*/ + +typedef struct { + char FAR * lpsz; /* Pointer into EM for registers name */ + RT rt; /* Register Type flags */ + UINT cbits; /* Number of bits in the register */ + USHORT hReg; /* Value to use with Read/Write Register*/ +} RD; // Register Description + +/* +** Flag Data description: This structure contains the description for +** a flag on the machine. Note that the hReg field contains the +** value to be used with Read/Write register to get the register which +** contains this flag. +*/ + +typedef struct { + char FAR * lpsz; /* Pointer into EM for flag name */ + RT ft; /* Flag Type flags */ + UINT cbits; /* Number of bits in the flag */ + USHORT hReg; /* register containning this flag */ +} FD; // Flag Data description +typedef XOSD (PASCAL LOADDS *LPFNSVC) ( DBC, HPID, HTID, DWORD, LONG ); +typedef XOSD (PASCAL LOADDS *TLFUNC) ( TLF, HPID, DWORD, LONG ); +typedef XOSD (PASCAL LOADDS *EMFUNC) ( EMF, HPID, HTID, DWORD, LONG ); + +typedef void (FAR CDECL LOADDS * LPFNCLDS)( void ); + +typedef struct { + void FAR * (PASCAL LOADDS * lpfnMHAlloc) ( UINT ); + void FAR * (PASCAL LOADDS * lpfnMHRealloc) ( void FAR *, UINT ); + void (PASCAL LOADDS * lpfnMHFree) ( void FAR * ); + + HDEP (PASCAL LOADDS * lpfnMMAllocHmem) ( UINT ); + void (PASCAL LOADDS * lpfnMMFreeHmem) ( HDEP ); + void FAR * (PASCAL LOADDS * lpfnMMLock) ( HDEP ); + VOID (PASCAL LOADDS * lpfnMMUnlock) ( HDEP ); + + HLLI (PASCAL LOADDS * LLInit) ( UINT, + LLF, + LPFNKILLNODE, + LPFNFCMPNODE ); + HLLE (PASCAL LOADDS * LLCreate) ( HLLI ); + void (PASCAL LOADDS * LLAdd) ( HLLI, HLLE ); + void (PASCAL LOADDS * LLInsert) ( HLLI, HLLE, DWORD ); + BOOL (PASCAL LOADDS * LLDelete) ( HLLI, HLLE ); + HLLE (PASCAL LOADDS * LLNext) ( HLLI, HLLE ); + LONG (PASCAL LOADDS * LLDestroy) ( HLLI ); + HLLE (PASCAL LOADDS * LLFind) ( HLLI, + HLLE, + VOID FAR *, + DWORD ); + LONG (PASCAL LOADDS * LLSize) ( HLLI ); + VOID FAR * (PASCAL LOADDS * LLLock) ( HLLE ); + VOID (PASCAL LOADDS * LLUnlock) ( HLLE ); + HLLE (PASCAL LOADDS * LLLast) ( HLLI ); + VOID (PASCAL LOADDS * LLAddHead) ( HLLI, HLLE ); + BOOL (PASCAL LOADDS * LLRemove) ( HLLI, HLLE ); + + int (PASCAL LOADDS * lpfnSHModelFromAddr)( PADDR, + WORD FAR *, + LPB, + UOFFSET FAR * ); + + int (PASCAL LOADDS * lpfnSHPublicNameToAddr)(PADDR, PADDR, char FAR *); + + LPSTR (PASCAL LOADDS * lpfnSHAddrToPublicName)(LPADDR, LPADDR); + + BOOL (PASCAL LOADDS * lpfnSHWantSymbols)(HEXE); + + LSZ (PASCAL LOADDS * lpfnSHGetSymbol) ( PADDR, + PADDR, + SOP, + LPODR + ); + BOOL (PASCAL LOADDS * lpfnSHGetPublicAddr)( PADDR, LSZ ); + VOID FAR * (PASCAL LOADDS * lpfnSHLpGSNGetTable)( HEXE ); + LPDEBUGDATA (PASCAL LOADDS * lpfnSHGetDebugData) ( HEXE ); + BOOL (PASCAL LOADDS * lpfnSHFindSymbol) ( LSZ, PADDR, LPASR ); + + // DWORD (PASCAL LOADDS * lpfnSHLocateSymbolFile)( LSZ, DWORD ); + + int (PASCAL LOADDS * lpfnLBPrintf) ( LPCH, LPCH, UINT ); + int (PASCAL LOADDS * lpfnLBQuit) ( UINT ); + + LPFNCLDS (CDECL LOADDS * lpfnSignal) ( int, LPFNCLDS ); + VOID (CDECL LOADDS * lpfnAbort) ( VOID ); + int (CDECL LOADDS * lpfnSpawnL) ( LPV FAR *, + int, + LSZ, + LSZ, ... ); + BOOL (PASCAL LOADDS * lpfnDHGetNumber) ( char FAR *, + int FAR *); + int FAR * lpPsp; + char FAR * lpchOsMajor; + +} DBF; // DeBugger callback Functions +typedef DBF FAR *LPDBF; + + +// +// Mesage mask values +// +#define MSG_TYPE_MOUSE 0x0001 +#define MSG_TYPE_WINDOW 0x0002 +#define MSG_TYPE_INPUT 0x0004 +#define MSG_TYPE_SYSTEM 0x0008 +#define MSG_TYPE_INIT 0x0010 +#define MSG_TYPE_CLIPBOARD 0x0020 +#define MSG_TYPE_DDE 0x0040 +#define MSG_TYPE_NONCLIENT 0x0080 +#define MSG_TYPE_OTHER 0x0100 + +typedef struct _FUNCTION_INFO { + ADDR AddrStart; + ADDR AddrEnd; + ADDR AddrPrologEnd; +} FUNCTION_INFO, *PFUNCTION_INFO; + +XOSD PASCAL OSDInit ( LPDBF ); +XOSD PASCAL OSDTerm ( VOID ); +XOSD PASCAL OSDCreatePID ( LPFNSVC, HEM, HTL, LPHPID ); +XOSD PASCAL OSDDestroyPID ( HPID ); +XOSD PASCAL OSDDestroyTID ( HTID ); +XOSD PASCAL OSDDisconnect ( HPID, HTID ); +XOSD PASCAL OSDPtrace ( OSD, UINT, VOID FAR *, HPID, HTID ); +XOSD PASCAL OSDProgramLoad ( HPID, LSZ, LSZ, ULONG ); +XOSD PASCAL OSDProgramFree ( HPID ); +XOSD PASCAL OSDAddEM ( EMFUNC, LPDBF, LPHEM, EMTYPE ); +XOSD PASCAL OSDDeleteEM ( HEM ); +XOSD PASCAL OSDAddTL ( TLFUNC, LPHTL, LPCH ); +XOSD PASCAL OSDDeleteTL ( HTL ); +XOSD PASCAL OSDDeinitTL ( TLFUNC ); +XOSD PASCAL OSDInitTL ( TLFUNC, LPDBF ); +XOSD PASCAL OSDTLGetInfo ( TLFUNC, LPGIS, UINT ); +XOSD PASCAL OSDTLSetup ( TLFUNC, LSZ, UINT, LPV ); +XOSD PASCAL OSDGetAddr ( HPID, HTID, ADR, PADDR ); +XOSD PASCAL OSDSetAddr ( HPID, HTID, ADR, PADDR ); +XOSD PASCAL OSDReadReg ( HPID, HTID, UINT, VOID FAR * ); +XOSD PASCAL OSDWriteReg ( HPID, HTID, UINT, VOID FAR * ); +XOSD PASCAL OSDReadFlag ( HPID, HTID, UINT, VOID FAR * ); +XOSD PASCAL OSDWriteFlag ( HPID, HTID, UINT, VOID FAR * ); +XOSD PASCAL OSDSetFrameContext(HPID, HTID, UINT, VOID FAR * ); +XOSD PASCAL OSDFrameReadReg ( HPID, HTID, UINT, VOID FAR * ); +XOSD PASCAL OSDFrameWriteReg ( HPID, HTID, UINT, VOID FAR * ); +XOSD PASCAL OSDGetRegDesc ( HPID, HTID, UINT, RD FAR * ); +XOSD PASCAL OSDGetFlagDesc ( HPID, HTID, UINT, FD FAR * ); +XOSD PASCAL OSDGetCurrentEM ( HPID, HTID, LPHEM ); +XOSD PASCAL OSDNativeOnly ( HPID, HTID, BOOL ); +XOSD PASCAL OSDUseEM ( HPID, HTID ); +XOSD PASCAL OSDDiscardEM ( HPID, HTID ); +XOSD PASCAL OSDGetDebugMetric( HPID, HTID, MTRC, LPV ); +XOSD PASCAL OSDUnassemble ( HPID, HTID, LPSDI ); +XOSD PASCAL OSDGetPrevInst ( HPID, HTID, PADDR ); +XOSD PASCAL OSDAssemble ( HPID, HTID, PADDR, LSZ ); +XOSD PASCAL OSDGetObjLength ( HPID, HTID, LPL, LPL, PADDR ); +XOSD PASCAL OSDGetFrame ( HPID, HTID, PADDR ); +XOSD PASCAL OSDGetCaller ( HPID, HTID, FCT, PADDR, PADDR ); +XOSD PASCAL OSDSaveRegs ( HPID, HTID, LPHIND ); +XOSD PASCAL OSDRestoreRegs ( HPID, HTID, HIND ); +XOSD PASCAL OSDIoctl ( HPID, HTID, UINT, UINT, LPV ); +XOSD PASCAL OSDRegisterEmi ( HPID, HTID, HEMI, LSZ ); +#ifdef KBDMON +XOSD PASCAL OSDKbdRecord ( HPID, HTID, BOOL ); +XOSD PASCAL OSDKbdPlay ( HPID, HTID, LSZ ); +#endif +XOSD PASCAL OSDIsStackSetup ( HPID, HTID, LPADDR ); +// XOSD PASCAL OSDTranslateMsg ( HPID, HTID, LPW, LPW, LSZ, LPW ); +XOSD PASCAL OSDGetMsgMap ( HPID, HTID, LPMSGMAP* ); +XOSD PASCAL OSDGetError ( HPID, HTID, LPW, LSZ, LSZ ); +XOSD PASCAL OSDSetupExecute ( HPID, HTID, LPHDEP ); +XOSD PASCAL OSDStartExecute ( HPID, HDEP, LPADDR, BOOL, BOOL); +XOSD PASCAL OSDCleanUpExecute ( HPID, HDEP ); +XOSD PASCAL OSDLoadDllAck ( HPID ); +XOSD PASCAL OSDUnLoadDllAck ( HPID, HEXE, BOOL ); +XOSD PASCAL OSDDebugActive ( HPID, DWORD, HANDLE, LPDWORD ); +XOSD PASCAL OSDStackWalkSetup ( HPID, HTID, BOOL, LPSTKSTR ); +XOSD PASCAL OSDStackWalkNext ( HPID, HTID, LPSTKSTR ); +XOSD PASCAL OSDStackWalkCleanup ( HPID, HTID, LPSTKSTR ); +XOSD PASCAL OSDSetFrame ( HPID, HTID, PFRAME ); +XOSD PASCAL OSDSetPath ( HPID, BOOL, LSZ ); +//XOSD PASCAL OSDSetBreakpoint ( HPID, HTID, WORD, LPBPARGS ); +//XOSD PASCAL OSDRemoveBreakpoint ( HPID, HTID, WORD, LPBPARGS ); +//XOSD PASCAL OSDBPAccept ( HPID, HTID, BOOL ); +XOSD PASCAL OSDGetPrompt ( HPID, LPPROMPTMSG ); +XOSD PASCAL OSDGetModuleList ( HPID, HTID, BOOL, LSZ, LPMODULE_LIST* ); +XOSD PASCAL OSDSendReply ( HPID, UINT, LPVOID ); +XOSD PASCAL OSDGetFunctionInfo ( HPID, PADDR, PFUNCTION_INFO ); + +enum { + ioctlNull = 0, + ioctlDumpLocalHeap, + ioctlDumpGlobalHeap, + ioctlDumpModuleList, + ioctlCrackLocalHmem, + ioctlCrackGlobalHmem, + ioctlKillApplication, + ioctlGetThreadHandle, // get the low level thread handle (NT) + ioctlGetProcessHandle, // Get the low level process handle (NT) + ioctlGetThreadContext, // get os+machine specific context structure + ioctlSetThreadContext, // set os+machine specific context structure + ioctlCustomCommand, // random user command for EM + ioctlGeneric // generic dm specific +}; + +typedef enum { + dbcCommError = -1, // -1 - Error occurred in transport layer + // + dbcInfoAvail = 0x100, // 100 - Display info the the user. + // wParam = nothing + // lParam = string to be dumped + dbcInfoReq, // 101 - DM needs a character. + // wParam = nothing + // lParam = nothing + dbcSuccess, // 102 - A command completed successfully. + // (REVIEW: remove?) + // wParam = ?? + // lParam = ?? + dbcError, // 103 - A command resulted in an error. + // wParam = nothing + // lParam = zero-terminated string to display + dbcSignal, // 104 - A signal has been received. + // wParam = nothing(??) + // lParam = nothing(??) + dbcException, // 105 - An exception occurred. + // wParam = exception code (REVIEW: UNDONE) + // lParam = nothing + dbcBpt, // 106 - A breakpoint was hit. + // wParam = nothing + // lParam = nothing + dbcWatchPoint, // 107 - A watchpoint was hit. + // wParam = watchpoint number that was hit + // lParam = nothing + dbcSingleStepXXX, // 108 - A single-step finished. + // wParam = nothing + // lParam = nothing + dbcRangeStepXXX, // 109 - A range-step finished. + // wParam = nothing + // lParam = nothing + dbcCoProcErr, // 10A - A coprocessor error occurred. + // wParam = nothing + // lParam = nothing + dbcAsyncStop, // 10B - An asynchronous stop occurred. + // wParam = nothing + // lParam = nothing + dbcNewProc, // 10C - A new process was created. + // wParam = new process's HPID + // lParam = fReallyNew: true if this process + // was just created false if it existed + // before but this is the first time the + // debugger has been told about it (e.g. in + // CVW if a bp is hit in a random process) + dbcCreateThread, // 10D - A thread was created. + // wParam = nothing + // lParam = nothing + dbcProcTerm, // 10E - A process terminated. May be followed by + // dbcDeleteProc if the HPID was created by + // OSDebug rather than by the debugger. The + // HPID is still valid until dbcDeleteProc + // is received. + // wParam = nothing + // lParam = process termination code (REVIEW: + // UNDONE) + dbcThreadTerm, // 10F - A thread terminated. Will be followed by + // dbcDeleteThread. The HTID is still valid + // until dbcDeleteThread is received. + // wParam = nothing + // lParam = nothing + dbcDeleteProc, // 110 - An HPID is no longer valid. Normally + // preceded by dbcProcTerm. + // wParam = nothing(??) + // lParam = nothing(??) + dbcDeleteThread, // 111 - An HTID is no longer valid. Normally + // preceded by dbcThreadTerm. + // wParam = nothing(??) + // lParam = nothing(??) + dbcModLoad, // 112 - A module was loaded. + // wParam = Module Table Entry (MTE) + // lParam = ptr to name of module + dbcModFree, // 113 - A module was freed. + // wParam = ?? + // lParam = ?? + dbcPageLoad, // 114 - A page load occurred. + // wParam = ?? + // lParam = ?? + dbcPageMove, // 115 - A page move occurred. + // wParam = ?? + // lParam = ?? + dbcPageUnload, // 116 - A page unload occurred. + // wParam = ?? + // lParam = ?? + dbcAliasFree, // 117 - ?? + // wParam = ?? + // lParam = ?? + dbcEmChange, // 118 - ?? + // wParam = ?? + // lParam = ?? + dbcCanStep, // 119 - ?? + // wParam = ?? + // lParam = ?? + dbcFlipScreen, // 11A - The debugger should return control of the + // user screen to the system. + // wParam = nothing + // lParam = nothing + dbcMOVEOverlay, // 11B - DOS M.O.V.E. overlay [un]load notification + // wParam = fLoad + // lParam = nothing + dbcThreadBlocked, // 11C - Single thread execution blocked + // wParam = nothing + // lParam = nothing + dbcKbdRecord, // 11D - recording keyboard message + // wParam = handle to pid of keyboard + // lParam = nothing + dbcSetSession, // 11E - set session index of process in hpid + // wParam = index of session (nonzero) + // lParam = nothing + dbcIoctlDone, // 11F - set session index of process in hpid + // wParam = index of session (nonzero) + // lParam = nothing + dbcThreadDestroy, // 120 - Destory the thread + dbcNtRip, // 121 - A RIP occurred + // wParam = sizeof(NT_RIP) + // lParam = pointer to NT_RIP + dbcExecuteDone, // 122 - Execute function call is done + // wParam = nothing + // lparam = handle of save area + dbcLastAddr, // 123 - Get last address in line + // wParam = nothing + // lparam = pointer to address + dbcChangedMemory, // 124 - Changed memory contents + // wParam = 0 + // lparam = size of memory block + // + dbcSegLoad, // 125 - Loaded selector + // wParam = 0 + // lparam = selector + // + dbcSegFree, // 126 - Freed selector + // wParam = 0 + // lparam = selector + // + dbcEntryPoint, // 127 - Program is stopped at entry point + // wParam = nothing + // lParam = nothing + dbcLoadComplete, // 128 - Static DLL loads are complete + // wParam = + // lParam = + dbcRemoteQuit, // 129 - The remote monitor has terminated + // wParam = nothing + // lParam = nothing + dbcCheckBpt, + + dbcStep, + + dbcMax // 12A +} _DBC; // DeBug Callback +typedef LONG DBC; + + +// +// Return values from dbcCanStep +// +typedef struct _CANSTEP { + DWORD Flags; + UOFF32 PrologOffset; +} CANSTEP; + +typedef CANSTEP FAR *LPCANSTEP; + +#define CANSTEP_NO 0x00000000 +#define CANSTEP_YES 0x00000001 +#define CANSTEP_THUNK 0x00000002 + + +typedef struct _CBP { + WORD wMessage; + HPID hpid; + HTID htid; + WORD wParam; + LONG lParam; +} CBP; // CallBack Parameters. Not used by OSDebug itself, + // but possibly handy for the debugger. +typedef CBP FAR *LPCBP; + + +#define hmemNull 0 +#define hpidNull 0 +#define htidNull 0 +#define htlNull 0 +#define hemNull 0 + +#define wNull 0 +#define lNull 0L + +// +// the kernel debugger reserves the first 255 subtypes +// +// the subtypes that are defined here are applicable to all +// dms that exist today. +// +#define IG_TRANSLATE_ADDRESS 256 +#define IG_WATCH_TIME 257 +#define IG_WATCH_TIME_STOP 258 +#define IG_WATCH_TIME_RECALL 259 +#define IG_WATCH_TIME_PROCS 260 +#define IG_DM_PARAMS 261 +#define IG_THREAD_INFO 262 +#define IG_TASK_LIST 263 +#define IG_RELOAD 264 +#define IG_PAGEIN 265 +#define IG_CHANGE_PROC 266 + + +typedef struct _IOCTLGENERIC { + DWORD ioctlSubType; + DWORD length; + char data[0]; +} IOCTLGENERIC, *PIOCTLGENERIC; + +typedef struct _TASK_LIST { + DWORD dwProcessId; + char ProcessName[16]; +} TASK_LIST, *PTASK_LIST; + + +XOSD FAR PASCAL +OSDGetMemInfo(HPID hpid, LPMEMINFO lpMemInfo); + + + + +// +// Breakpoints +// + +enum { + bptpExec, + bptpDataExec, + bptpDataC, + bptpDataW, + bptpDataR, + bptpRegC, + bptpRegW, + bptpRegR, + bptpMessage, + bptpMClass, + bptpInt, + bptpRange +}; +typedef DWORD BPTP; + +enum { + bpnsStop, + bpnsContinue, + bpnsCheck +}; +typedef DWORD BPNS; + +enum _BPTS { + bptsExec = 0x0001, + bptsDataC = 0x0002, + bptsDataW = 0x0004, + bptsDataR = 0x0008, + bptsRegC = 0x0010, + bptsRegW = 0x0020, + bptsRegR = 0x0040, + bptsMessage = 0x0080, + bptsMClass = 0x0100, + bptsRange = 0x0200, + bptsDataExec = 0x0400 +}; +typedef DWORD BPTS; + + +typedef struct _BPIS { + BPTP bptp; + BPNS bpns; + DWORD fOneThd; + HTID htid; + union { + struct { + ADDR addr; + } exec; + struct { + ADDR addr; + DWORD cb; + } data; + struct { + DWORD dwId; + } reg; + struct { + ADDR addr; + DWORD imsg; + DWORD cmsg; + } msg; + struct { + ADDR addr; + DWORD dwmask; + } mcls; + struct { + DWORD ipt; + } ipt; + struct { + ADDR addr; + DWORD cb; + } rng; + }; +} BPIS; +typedef BPIS FAR * LPBPIS; + +typedef struct _BPS { + DWORD cbpis; + DWORD cmsg; + DWORD fSet; + // BPIS rgbpis[]; + // DWORD rgdwMessage[]; + // XOSD rgxosd[]; + // DWORD rgdwNotification[]; +} BPS; +typedef BPS FAR * LPBPS; + +#define RgBpis(B) ((LPBPIS)(((LPBPS)(B)) + 1)) +#define DwMessage(B) ((LPDWORD)(RgBpis((B)) + ((LPBPS)(B))->cbpis)) +#define RgXosd(B) ((LPXOSD)(DwMessage((B)) + ((LPBPS)(B))->cmsg)) +#define DwNotification(B) ((LPDWORD)(RgXosd((B)) + ((LPBPS)(B))->cbpis)) +#define SizeofBPS(B) ( sizeof(BPS) + \ + (((LPBPS)(B))->cbpis * \ + (sizeof(BPIS) + sizeof(XOSD) + sizeof(DWORD))) + \ + (((LPBPS)(B))->cmsg * sizeof(DWORD)) ) + +XOSD PASCAL +OSDBreakpoint( + HPID hpid, + LPBPS lpbps + ); + + + + + + +// +// Exception handling +// + +// +// These are the actions which the debugger may take +// in response to an exception raised in the debuggee. +// +typedef enum _EXCEPTION_FILTER_DEFAULT { + efdIgnore, + efdNotify, + efdCommand, + efdStop +} EXCEPTION_FILTER_DEFAULT; +typedef EXCEPTION_FILTER_DEFAULT FAR * LPEXCEPTION_FILTER_DEFAULT; + +// +// commands understood by OSDGetExceptionState +// + +typedef enum _EXCEPTION_CONTROL { + exfFirst, + exfNext, + exfSpecified +} EXCEPTION_CONTROL; +typedef EXCEPTION_CONTROL FAR * LPEXCEPTION_CONTROL; + +// +// Exception information packet +// +#define EXCEPTION_STRING_SIZE 60 +typedef struct _EXCEPTION_DESCRIPTION { + DWORD dwExceptionCode; + EXCEPTION_FILTER_DEFAULT efd; + char rgchDescription[EXCEPTION_STRING_SIZE]; +} EXCEPTION_DESCRIPTION; +typedef EXCEPTION_DESCRIPTION FAR * LPEXCEPTION_DESCRIPTION; + +XOSD PASCAL +OSDGetExceptionState( + HPID hpid, + HTID htid, + LPEXCEPTION_DESCRIPTION lpExd, + EXCEPTION_CONTROL exf + ); + +XOSD PASCAL +OSDSetExceptionState ( + HPID hpid, + HTID htid, + LPEXCEPTION_DESCRIPTION lpExd + ); + + + +// +// Target execution control +// + +typedef struct _EXOP { + BYTE fSingleThread; + BYTE fStepOver; + BYTE fQueryStep; + BYTE fInitialBP; + BYTE fPassException; + BYTE fSetFocus; +} EXOP; +typedef EXOP FAR * LPEXOP; + + +// +// Range Step Struct +// +typedef struct _RSS { + LPADDR lpaddrMin; + LPADDR lpaddrMax; + LPEXOP lpExop; +} RSS; +typedef RSS FAR * LPRSS; + + +XOSD PASCAL +OSDGo( + HPID hpid, + HTID htid, + LPEXOP lpexop + ); + +XOSD PASCAL +OSDSingleStep( + HPID hpid, + HTID htid, + LPEXOP lpexop + ); + +XOSD PASCAL +OSDRangeStep( + HPID hpid, + HTID htid, + LPADDR lpaddrMin, + LPADDR lpaddrMax, + LPEXOP lpexop + ); + +XOSD PASCAL +OSDReturnStep( + HPID hpid, + HTID htid, + LPEXOP lpexop + ); + +XOSD PASCAL +OSDAsyncStop( + HPID hpid, + DWORD fSetFocus + ); + + + + + + + +typedef XOSD (FAR PASCAL LOADDS *TLFUNCTYPE) ( TLF, HPID, DWORD, LPARAM ); +typedef XOSD (FAR PASCAL LOADDS *DMTLFUNCTYPE) ( TLF, HPID, DWORD, LPARAM ); +typedef XOSD (FAR PASCAL LOADDS *TLCALLBACKTYPE) (HPID, DWORD, LPARAM ); +typedef XOSD (FAR PASCAL LOADDS *LPDMINIT) ( DMTLFUNCTYPE, LPVOID ); +typedef XOSD (FAR PASCAL LOADDS *LPDMFUNC) ( DWORD, LPBYTE ); +typedef DWORD (FAR PASCAL LOADDS *LPDMDLLINIT) ( LPDBF ); +typedef XOSD (FAR PASCAL LOADDS *LPUISERVERCB) ( TLCB, HPID, HTID, DWORD, LONG); + +#endif // _OD_ diff --git a/private/windbg/osdebug/include/odmsg.h b/private/windbg/osdebug/include/odmsg.h new file mode 100644 index 000000000..3d6105c29 --- /dev/null +++ b/private/windbg/osdebug/include/odmsg.h @@ -0,0 +1,244 @@ +#ifndef _ODMSG +#define _ODMSG + +// +// MSG Map structure +// +typedef struct _MSGINFO *LPMSGINFO; +typedef struct _MSGINFO { + UINT Msg; // Message number + LPSTR MsgText; // Message Text + DWORD MsgMask; // Message mask +} MSGINFO; + +// +// MSG Map structure +// +typedef struct _MSGMAP *LPMSGMAP; +typedef struct _MSGMAP { + DWORD Count; // Number of elements + LPMSGINFO MsgInfo; // Pointer to array +} MSGMAP; + + +// +// =============== Support for OSDGetModuleList =========== +// + +// +// Module list +// +typedef struct _MODULE_LIST *LPMODULE_LIST; +typedef struct _MODULE_LIST { + DWORD Count; +} MODULE_LIST; + + +// +// Module entry +// +typedef struct _MODULE_ENTRY *LPMODULE_ENTRY; +typedef struct _MODULE_ENTRY { + BOOL Flat; + BOOL Real; + DWORD Segment; + DWORD Selector; + DWORD Base; + DWORD Limit; + DWORD Type; + DWORD SectionCount; + HEXE hexe; +} MODULE_ENTRY; + + +#define FreeModuleList(m) free(m) +#define ModuleListCount(m) ((m)->Count) +#define FirstModuleEntry(m) ((LPMODULE_ENTRY)((m)+1)) +#define NextModuleEntry(e) ((e)+1) +#define NthModuleEntry(m,n) (FirstModuleEntry(m)+(n)) + +#define ModuleEntryFlat(e) ((e)->Flat) +#define ModuleEntryReal(e) ((e)->Real) +#define ModuleEntrySegment(e) ((e)->Segment) +#define ModuleEntrySelector(e) ((e)->Selector) +#define ModuleEntryBase(e) ((e)->Base) +#define ModuleEntryLimit(e) ((e)->Limit) +#define ModuleEntryType(e) ((e)->Type) +#define ModuleEntrySectionCount(e) ((e)->SectionCount) +#define ModuleEntryHexe(e) ((e)->hexe) + + + +// +// Module list request +// +typedef struct _MODULE_LIST_REQUEST *LPMODULE_LIST_REQUEST; +typedef struct _MODULE_LIST_REQUEST { + BOOL Flat; + LSZ Name; + LPMODULE_LIST *List; +} MODULE_LIST_REQUEST; + + +// +// ======================================================== +// + + +typedef struct _GOL { + LPL lplBase; + LPL lplLen; + LPADDR lpaddr; +} GOL; // Get Object Length Structure +typedef GOL FAR *LPGOL; + +typedef struct _GET { + LPW lpwErrNum; + LSZ lszErr; + LSZ lszErrText; +} GET; // get error text +typedef GET FAR *LPGET; + +typedef struct _GTM { + LPW lpwMsg; + LPW lpwType; + LSZ lszMsg; + LPW lpwMask; +} GTM; // get translated message +typedef GTM FAR *LPGTM; + +typedef struct _IOL { + UINT wFunction; + BYTE rgbVar[]; +} IOL; // Ioctl Structure +typedef IOL FAR *LPIOL; + +// packet used by OSDProgramLoad +typedef struct _PRL { + ULONG ulChildFlags; + WORD cbCmdLine; + WORD cbPad; + CHAR lszCmdLine[]; +} PRL; // PRogram Load structure +typedef PRL FAR * LPPRL; + +// Bit flags for ulChildFlags +#define ulfMultiProcess 0x00000001L // OS2, NT, and ?MAC? +#define ulfDebugRegisters 0x00000002L // Win and DOS (?MAC?) +#define ulfDisableNMI 0x00000004L // DOS (CV /N0) +#define ulfForceNMI 0x00000008L // DOS (CV /N1) +#define ulfDisableIBM 0x00000010L // DOS (CV /I0) +#define ulfForceIBM 0x00000020L // DOS (CV /I1) +#define ulfMinimizeApp 0x00000040L // Win32 +#define ulfNoActivate 0x00000080L // Win32 +#define ulfInheritHandles 0x00000100L // Win32 +#define ulfWowVdm 0x00000200L // Win32 + +/* + * This structure is used in commuicating a stop event to the EM. It + * contains the most basic of information about the stopped thread. + * A "frame" pointer, a program counter and bits describing the type + * of segment stopped in. + */ + +typedef struct _BPR { + DWORD dwNotify; /* tag to identify BP # */ + UOFFSET offEIP; /* Program Counter offset */ + UOFFSET offEBP; /* Frame pointer offset */ + UOFFSET offESP; /* Stack pointer offset */ + SEGMENT segCS; /* Program counter seletor */ + SEGMENT segSS; /* Frame & Stack pointer offset */ + BOOL fFlat:1; + BOOL fOff32:1; + BOOL fReal:1; +} BPR; // BreakPoint Return + +typedef BPR FAR *LPBPR; + +#ifdef WIN32 +typedef struct _EPR { + BPR bpr; + DWORD dwFirstChance; + DWORD ExceptionCode; + DWORD ExceptionFlags; + DWORD NumberParameters; + DWORD ExceptionInformation[]; +} EPR; // Exception Return +#else +typedef struct _EPR { + BPR; + WORD wException; +} EPR; // Exception Return +#endif +typedef EPR FAR *LPEPR; + +/* + * RIP reporting structure + */ + +typedef struct _NT_RIP { + BPR bpr; + ULONG ulErrorCode; + ULONG ulErrorLevel; +} NT_RIP; // RIP Return +typedef NT_RIP FAR *LPNT_RIP; + +/* + * Stack walking structure + * + */ + +typedef struct _STKSTR { + ADDR addrPC; // Program counter address + ADDR addrRetAddr; // Return Address + ADDR addrFrame; // Frame pointer address + ULONG ulParams[4]; // first 4 words off the stack + ULONG ul; // Space for EM/DM to use + PVOID pFpoData; // pointer to fpo data or null (PFPO_DATA) + BOOL fFar; // Far call +} STKSTR, * LPSTKSTR; + + +/* + * The following structure is used by the emfSetupExecute message + */ +typedef struct _EXECUTE_STRUCT { + ADDR addr; /* Starting address for function */ + HDEP lphdep; /* Handle of save area */ + BOOL fIgnoreEvents:1; /* Ignore events coming back? */ + BOOL fFar:1; /* Is the function a _far routine */ + HIND hindDm; /* This is the DMs handle */ +} EXECUTE_STRUCT; +typedef EXECUTE_STRUCT FAR * LPEXECUTE_STRUCT; + +/* + * this is used to debug an active process + */ +typedef struct _DBG_ACTIVE_STRUCT { + DWORD dwProcessId; + HANDLE hEventGo; + DWORD dwStatus; +} DBG_ACTIVE_STRUCT; +typedef DBG_ACTIVE_STRUCT FAR *LPDBG_ACTIVE_STRUCT; + +typedef struct _PROCESSLIST { + DWORD pid; + BYTE pname[]; +} PROCESSLIST; // ProcessList return +typedef PROCESSLIST * LPPROCESSLIST; + +typedef struct _PROMPTMSG { + DWORD len; + BYTE szPrompt[]; +} PROMPTMSG; // GetPrompt return +typedef PROMPTMSG * LPPROMPTMSG; + +typedef struct _DMSYM { + ADDR AddrSym; + DWORD Ra; + char fname[]; +} DMSYM; +typedef DMSYM *PDMSYM, *LPDMSYM; + + +#endif // _ODMS diff --git a/private/windbg/osdebug/include/osdem.h b/private/windbg/osdebug/include/osdem.h new file mode 100644 index 000000000..123959da4 --- /dev/null +++ b/private/windbg/osdebug/include/osdem.h @@ -0,0 +1,190 @@ +/**** OSDEM.H - Execution model api **** + * * + * * + * Copyright <C> 1990, Microsoft Corp * + * * + * Created: October 15, 1990 by David W. Gray * + * * + * Purpose: * + * * + * * + ***************************************************************************/ + +#ifndef _OSDEM +#define _OSDEM + +typedef enum { + emfFreeze = osdFreeze, + emfThaw = osdThaw, + emfIOCTL = osdIOCTL, + emfReadBuf = osdReadBuf, + emfWriteBuf = osdWriteBuf, + emfShowDebuggee = osdShowDebuggee, + emfFixupAddr = osdFixupAddr, + emfUnFixupAddr = osdUnFixupAddr, + emfSetEmi = osdSetEmi, + emfSendChar = osdSendChar, + emfFreezeState = osdFreezeState, + emfIsOverlayLoaded = osdIsOverlayLoaded, + emfCompareAddrs = osdCompareAddrs, + + + emfDUMMY = 0x30, + + +////////// OSDEBUG4 emfs, more or less /////////////// + + emfDebugPacket, + + emfRegisterDBF, + emfInit, + emfGetModel, + emfUnInit, +// emfAttach, +// emfDetach, + emfConnect, + emfDisconnect, + + emfCreatePid, + emfDestroyPid, + emfDestroyTid, + + emfSetMulti, + emfDebugger, + + emfProgramLoad, + emfDebugActive, + emfSetPath, + emfProgramFree, + + emfThreadStatus, + emfProcessStatus, +// emfFreezeThread, +// emfSetThreadPriority, + + emfGetExceptionState, + emfSetExceptionState, + + emfGetModuleList, + + emfGo, + emfSingleStep, + emfRangeStep, + emfReturnStep, + emfStop, + + emfBreakPoint, + + emfSetupExecute, + emfStartExecute, + emfCleanUpExecute, + + emfGetAddr, + emfSetAddr, +// emfFixupAddr, +// emfUnFixupAddr, +// emfSetEmi, + emfRegisterEmi, +// emfUnRegisterEmi, +// emfCompareAddrs, +// emfGetObjLength, +// emfGetMemoryInfo, + +// emfReadMemory, +// emfWriteMemory, + + emfGetRegStruct, + emfGetFlagStruct, + emfGetReg, + emfSetReg, + emfGetFlag, + emfSetFlag, +// emfSaveRegs, +// emfRestoreRegs, + + emfUnassemble, +// emfGetPrevInst, + emfAssemble, + +// emfGetFrame, + + emfMetric, + + emfGetMsgMap, +// emfGetMessageMaskMap, + +// emfInfoReply, +// emfContinue, + +// emfReadFile, +// emfWriteFile, + +// emfShowDebuggee, + emfGetProcessList, +// emfSystemService, +// emfSetDebugMode, + + +///////////////////////////////////////////////// + + emfIsStackSetup, + emfStackWalkSetup, + emfStackWalkNext, + emfStackWalkCleanup, + emfLoadDllAck, + emfUnLoadDllAck, + emfSetFrame, + emfGetPrompt, + emfSetFrameContext, + emfFrameRegValue, + emfFrameSetReg, + emfMiscReply, + emfGetMemInfo, + emfGetFunctionInfo, + emfMax +} _EMF; + +typedef DWORD EMF; + +typedef enum { + dbcoCreateThread = dbcMax, + dbcoNewProc, + dbcoMax +} _DBCO; // Debug CallBacks Osdebug specific +typedef LONG DBCO; + +typedef struct _EMCB { + XOSD (PASCAL LOADDS *lpfnCallBackDB) ( DBC, HPID, HTID, DWORD, DWORD, VOID FAR * ); + XOSD (PASCAL LOADDS *lpfnCallBackTL) ( TLF, HPID, DWORD, VOID FAR * ); + XOSD (PASCAL LOADDS *lpfnCallBackNT) ( EMF, HPID, HTID, DWORD, VOID FAR * ); + XOSD (PASCAL LOADDS *lpfnCallBackEM) ( EMF, HPID, HTID, DWORD, DWORD, VOID FAR * ); +} EMCB; // Execution Model CallBacks +typedef EMCB FAR *LPEMCB; + +typedef struct _REMI { + HEMI hemi; + LSZ lsz; +} REMI; // Register EMI structure +typedef REMI FAR * LPREMI; + +// M.O.V.E. notification types/defs + +#define fOvlLoad ((BYTE)0x06) +#define fOvlUnload ((BYTE)0x07) + +#pragma pack(1) +typedef struct _OVL7 { + BYTE bVersion; + BYTE cbOvl7; + BYTE fOvlOp; + unsigned short iovl; + WORD dbFrameBase; +} OVL7; +#pragma pack() +typedef OVL7 FAR *LPOVL7; + + +// get od/em/dm message structures +#include "odmsg.h" + +#endif // _OSDEM diff --git a/private/windbg/osdebug/include/shapi.h b/private/windbg/osdebug/include/shapi.h new file mode 100644 index 000000000..2414c361c --- /dev/null +++ b/private/windbg/osdebug/include/shapi.h @@ -0,0 +1,386 @@ +#error Don't include shapi.h... Use shapi.hxx instead. + +/** shapi.h - Public API to the Symbol Handler + * + * This file contains all types and APIs that are defined by + * the Symbol Handler and are publicly accessible by other + * components. + * + * Before including this file, you must include cvtypes.h. + */ + + +/*** The master copy of this file resides in the CodeView project. + * All Microsoft projects are required to use the master copy without + * modification. Modification of the master version or a copy + * without consultation with all parties concerned is extremely + * risky. + * + * The projects known to use this version (1.00.00) are: + * + * Codeview + * Sequoia + * C/C++ expression evaluator + * Cobol expression evaluator + * QC/Windows + * Pascal 2.0 expression evaluator + * Symbol Handler + * Stump (OSDebug) + */ + +#ifndef SH_API +#define SH_API + +#ifndef RC_INVOKED +#pragma pack (1) + +typedef enum { // Error returns from some SH functions + sheNone = 0, + sheNoSymbols = 1, // No CV info + sheFutureSymbols = 2, // NB08 to NB99 + sheMustRelink = 3, // NB00 to NB04 + sheNotPacked = 4, // NB05 to NB06 + sheOutOfMemory = 5, + sheCorruptOmf = 6, + sheFileOpen = 7, // Couldn't open file + sheSuppressSyms = 8, // Symbol loading was suppressed + sheDeferSyms = 9, // Symbol loading was defered + sheSymbolsConverted = 10, + sheBadTimeStamp = 11, + sheBadCheckSum = 12, + sheLastError // Must be last -- used by SHLszGetErrorText as limit +} SHE; + +enum { + sopNone = 0, + sopData = 1, + sopStack = 2 +}; +typedef short SOP; // Symbol OPtions + +typedef enum { + fcdNone, + fcdData, + fcdNear, + fcdFar +} FCD; // Function Call Distance (near/far/unknown) + +typedef enum { + astNone, + astAddress, + astRegister, + astBaseOff +} AST; // Assembler symbol return Types + +typedef struct _ASR { + AST ast; + union { + struct { + FCD fcd; + ADDR addr; + } u; + WORD ireg; + OFFSET off; + } u; +} ASR; // Assembler Symbol Return structure +typedef ASR FAR *LPASR; + +typedef HEMI SHEMI; +typedef unsigned int SHFLAG; //* A TRUE/FALSE flag var +typedef SHFLAG FAR * PSHFLAG; +typedef SEGMENT SHSEG; //* A segment/selector value +typedef UOFFSET SHOFF; //* An offset value + +typedef HDEP HTYPE; //* A handle to a type +typedef HDEP HSYM; //* A handle to a symbol +typedef HDEP HPROC; //* A handle to a procedure +typedef HDEP HBLK; //* A handle to a block. +typedef HDEP HSF; //* A handle to source file table + +#if defined (WIN32) && defined(STRICT) +DECLARE_HANDLE( HVOID ); +DECLARE_HANDLE( HMOD ); +DECLARE_HANDLE( HGRP ); +DECLARE_HANDLE( HEXE ); +DECLARE_HANDLE( HPDS ); +#else +typedef HIND HVOID; //* Generic handle type +typedef HIND HMOD; //* A module handle +typedef HIND HGRP; //* A group handle (sub group of module + //* currently either a seg or filename) +typedef HIND HEXE; //* An Executable file handle +typedef HIND HPDS; //* A handle to a process +#endif + +typedef HSYM FAR * PHSYM; + +typedef unsigned short THIDX; + +typedef struct CXT { + ADDR addr; + HMOD hMod; + HGRP hGrp; + HPROC hProc; + HBLK hBlk; + } CXT; //* General Symbol context pkt +typedef CXT FAR *PCXT; + +typedef struct CXF { + CXT cxt; + FRAME Frame; + } CXF; //* Symbol context pkt locked to a frame ptr +typedef CXF FAR *PCXF; + +typedef enum { + SHFar, + SHNear + } SHCALL; + +typedef struct SHREG { + unsigned short hReg; + union { + unsigned char Byte1; + struct { + unsigned short Byte2; + unsigned short Byte2High; + } a; + struct { + unsigned long Byte4; + unsigned long Byte4High; + } b; + double Byte8; + REAL10 Byte10; + } u; + } SHREG; +typedef SHREG FAR *PSHREG; + + + +// structure defining parameters of symbol to be searched for. The address +// of this structure is passed on the the EE's symbol compare routine. Any +// additional data required by the EE's routine must follow this structure. + +typedef struct _SSTR { // string with length byte and pointer to data + LPB lpName; // pointer to the string itself + unsigned char cb; // length byte + unsigned char searchmask; // mask to control symbol searching + unsigned short symtype; // symbol types to be checked + unsigned char FAR *pRE; // pointer to regular expression +} SSTR; +typedef SSTR FAR *LPSSTR; + +#define SSTR_proc 0x0001 // compare only procs with correct type +#define SSTR_data 0x0002 // compare only global data with correct type +#define SSTR_RE 0x0004 // compare using regular expression +#define SSTR_NoHash 0x0008 // do a linear search of the table +#define SSTR_symboltype 0x0010 // pass only symbols of symtype to the + // comparison function. + +#define SHpCXTFrompCXF(a) (&((a)->cxt)) +#define SHpFrameFrompCXF(a) (&(a)->Frame) +#define SHHMODFrompCXT(a) ((a)->hMod) +#define SHHPROCFrompCXT(a) ((a)->hProc) +#define SHHBLKFrompCXT(a) ((a)->hBlk) +#define SHpADDRFrompCXT(a) (&((a)->addr)) +#define SHPAddrFromPCxf(a) (SHpADDRFrompCXT(SHpCXTFrompCXF(a))) + +#define SHIsCXTMod(a) ((a)->hMod && !(a)->hProc && !(a)->hBlk) +#define SHIsCXTProc(a) ((a)->hMod && (a)->hProc && !(a)->hBlk) +#define SHIsCXTBlk(a) ((a)->hMod && (a)->hProc && (a)->hBlk) + +#define SHHGRPFrompCXT(a) ((a)->hGrp) + +typedef SHFLAG (PASCAL FAR *PFNCMP)(LPSSTR, LPV, LSZ, SHFLAG); + //* comparison prototype +typedef BOOL (PASCAL FAR *PFNVALIDATEEXE)(UINT, LPV, LPSTR); + +#define LPFNSYM PASCAL LOADDS FAR * +#define LPFNSYMC CDECL LOADDS FAR * + +typedef struct omap_tag { + DWORD rva; + DWORD rvaTo; +} OMAP, *LPOMAP; + +typedef struct { + DWORD Offset; + DWORD Size; + DWORD Flags; +} SECSTART, *LPSECSTART; + +typedef struct _tagDEBUGDATA { + LPVOID lpRtf; // Runtime function table - fpo or pdata + DWORD cRtf; // Count of rtf entries + LPOMAP lpOmapFrom; // Omap table - From Source + DWORD cOmapFrom; // Count of omap entries - From Source + LPOMAP lpOmapTo; // Omap table - To Source + DWORD cOmapTo; // Count of omap entries - To Source + LPSECSTART lpSecStart; // Original section table (pre-Lego) + SHE she; +} DEBUGDATA, *LPDEBUGDATA; + +typedef struct _KNF { + int cb; + + LPV (LPFNSYM lpfnMHAlloc) ( UINT ); + LPV (LPFNSYM lpfnMHRealloc) ( LPV, UINT ); + VOID (LPFNSYM lpfnMHFree) ( LPV ); + VOID _HUGE_ * (LPFNSYM lpfnMHAllocHuge) ( LONG, UINT ); + VOID (LPFNSYM lpfnMHFreeHuge) ( LPV ); + + HDEP (LPFNSYM lpfnMMAllocHmem) ( UINT ); + VOID (LPFNSYM lpfnMMFreeHmem) ( HDEP ); + LPV (LPFNSYM lpfnMMLock) ( HDEP ); + VOID (LPFNSYM lpfnMMUnlock) ( HDEP ); + + HLLI (LPFNSYM lpfnLLInit) ( UINT, LLF, LPFNKILLNODE, LPFNFCMPNODE ); + HLLE (LPFNSYM lpfnLLCreate) ( HLLI ); + VOID (LPFNSYM lpfnLLAdd) ( HLLI, HLLE ); + VOID (LPFNSYM lpfnLLAddHead) ( HLLI, HLLE ); + VOID (LPFNSYM lpfnLLInsert) ( HLLI, HLLE, ULONG ); + BOOL (LPFNSYM lpfnLLDelete) ( HLLI, HLLE ); + BOOL (LPFNSYM lpfnLLRemove) ( HLLI, HLLE ); + LONG (LPFNSYM lpfnLLDestroy) ( HLLI ); + HLLE (LPFNSYM lpfnLLNext) ( HLLI, HLLE ); + HLLE (LPFNSYM lpfnLLFind) ( HLLI, HLLE, LPV, ULONG ); + HLLE (LPFNSYM lpfnLLLast) ( HLLI ); + LONG (LPFNSYM lpfnLLSize) ( HLLI ); + LPV (LPFNSYM lpfnLLLock) ( HLLE ); + VOID (LPFNSYM lpfnLLUnlock) ( HLLE ); + + int (LPFNSYM lpfnLBPrintf) ( LPCH, LPCH, UINT ); + UINT (LPFNSYM lpfnLBQuit) ( UINT ); + + UINT (LPFNSYM lpfnSYOpen) ( LSZ ); + VOID (LPFNSYM lpfnSYClose) ( UINT ); + UINT (LPFNSYM lpfnSYReadFar) ( UINT, LPB, UINT ); + LONG (LPFNSYM lpfnSYSeek) ( UINT, LONG, UINT ); + UINT (LPFNSYM lpfnSYFixupAddr) ( PADDR ); + UINT (LPFNSYM lpfnSYUnFixupAddr)(PADDR ); + UINT (LPFNSYM lpfnSYProcessor) ( VOID ); + UINT (LPFNSYM lpfnSYFIsOverlayLoaded)( PADDR ); + + VOID (LPFNSYM lpfn_searchenv)( LSZ, LSZ, LSZ ); + UINT (LPFNSYMC lpfnsprintf)( LSZ, LSZ, ... ); + VOID (LPFNSYM lpfn_splitpath)( LSZ, LSZ, LSZ, LSZ, LSZ ); + LSZ (LPFNSYM lpfn_fullpath)( LSZ, LSZ, UINT ); + VOID (LPFNSYM lpfn_makepath)( LSZ, LSZ, LSZ, LSZ, LSZ ); + UINT (LPFNSYM lpfnstat)( LSZ, LPCH ); + VOID (LPFNSYM lpfnLBLog) ( LSZ); + LONG (LPFNSYM lpfnSYTell) ( UINT); + UINT (LPFNSYM lpfnSYFindExeFile) ( LSZ, LSZ, UINT, LPV, PFNVALIDATEEXE ); + VOID (LPFNSYM lpfnLoadedSymbols) ( SHE, HPID, LSZ ); + BOOL (LPFNSYM lpfnSYGetDefaultShe) ( LSZ, SHE * ); + + +} KNF; // codeview KeRnel Functions exported to the Symbol Handler +typedef KNF FAR *LPKNF; + +typedef struct _SHF { + int cb; + HPDS (LPFNSYM pSHCreateProcess) ( VOID ); + VOID (LPFNSYM pSHSetHpid) ( HPID ); + BOOL (LPFNSYM pSHDeleteProcess) ( HPDS ); + HPDS (LPFNSYM pSHChangeProcess) ( HPDS, BOOL ); + SHE (LPFNSYM pSHAddDll) ( LSZ, BOOL ); + SHE (LPFNSYM pSHAddDllsToProcess) ( VOID ); + SHE (LPFNSYM pSHLoadDll) ( LSZ, BOOL ); + VOID (LPFNSYM pSHUnloadDll) ( HEXE ); + UOFFSET (LPFNSYM pSHGetDebugStart) ( HSYM ); + LSZ (LPFNSYM pSHGetSymName) ( HSYM, LSZ ); + BOOL (LPFNSYM pSHAddrFromHsym) ( PADDR, HSYM ); + HMOD (LPFNSYM pSHHModGetNextGlobal) ( HEXE FAR *, HMOD ); + int (LPFNSYM pSHModelFromAddr) ( PADDR, LPW, LPB, UOFFSET FAR * ); + int (LPFNSYM pSHPublicNameToAddr) ( PADDR, PADDR, LSZ ); + LSZ (LPFNSYM pSHGetSymbol) ( PADDR, SOP, PADDR, LSZ, LPL ); + LSZ (LPFNSYM pSHGetModule) ( PADDR, LSZ ); + BOOL (LPFNSYM pSHGetPublicAddr) ( PADDR, LSZ ); + BOOL (LPFNSYM pSHIsLabel) ( HSYM ); + + VOID (LPFNSYM pSHSetDebuggeeDir) ( LSZ ); + VOID (LPFNSYM pSHSetUserDir) ( LSZ ); + BOOL (LPFNSYM pSHAddrToLabel) ( PADDR, LSZ ); + + int (LPFNSYM pSHGetSymLoc) ( HSYM, LSZ, UINT, PCXT ); + BOOL (LPFNSYM pSHFIsAddrNonVirtual) ( PADDR ); + BOOL (LPFNSYM pSHIsFarProc) ( HSYM ); + + HEXE (LPFNSYM pSHGetNextExe) ( HEXE ); + HEXE (LPFNSYM pSHHexeFromHmod) ( HMOD ); + HMOD (LPFNSYM pSHGetNextMod) ( HEXE, HMOD ); + PCXT (LPFNSYM pSHGetCxtFromHmod) ( HMOD, PCXT ); + PCXT (LPFNSYM pSHGetCxtFromHexe) ( HEXE, PCXT ); + PCXT (LPFNSYM pSHSetCxt) ( PADDR, PCXT ); + PCXT (LPFNSYM pSHSetCxtMod) ( PADDR, PCXT ); + HSYM (LPFNSYM pSHFindNameInGlobal) ( HSYM, + PCXT, + LPSSTR, + SHFLAG, + PFNCMP, + SHFLAG, + PCXT + ); + HSYM (LPFNSYM pSHFindNameInContext) ( HSYM, + PCXT, + LPSSTR, + SHFLAG, + PFNCMP, + SHFLAG, + PCXT + ); + HSYM (LPFNSYM pSHGoToParent) ( PCXT, PCXT ); + HSYM (LPFNSYM pSHHsymFromPcxt) ( PCXT ); + HSYM (LPFNSYM pSHNextHsym) ( HMOD, HSYM ); + PCXF (LPFNSYM pSHGetFuncCXF) ( PADDR, PCXF ); + LPCH (LPFNSYM pSHGetModName) ( HMOD ); + LPCH (LPFNSYM pSHGetExeName) ( HEXE ); + LPCH (LPFNSYM pSHGetModNameFromHexe) ( HEXE ); + LPCH (LPFNSYM pSHGetSymFName) ( HEXE ); + HEXE (LPFNSYM pSHGethExeFromName) ( LPCH ); + HEXE (LPFNSYM pSHGethExeFromModuleName) ( LPCH ); + UOFF32 (LPFNSYM pSHGetNearestHsym) ( PADDR, HMOD, int, PHSYM ); + SHFLAG (LPFNSYM pSHIsInProlog) ( PCXT ); + SHFLAG (LPFNSYM pSHIsAddrInCxt) ( PCXT, PADDR ); + SHFLAG (LPFNSYM pSHCompareRE) ( LPCH, LPCH, BOOL ); + BOOL (LPFNSYM pSHFindSymbol) ( LSZ, PADDR, LPASR ); + UOFF32 (LPFNSYM pPHGetNearestHsym) ( PADDR, HEXE, PHSYM ); + HSYM (LPFNSYM pPHFindNameInPublics) ( HSYM, + HEXE, + LPSSTR, + SHFLAG, + PFNCMP + ); + HTYPE (LPFNSYM pTHGetTypeFromIndex) ( HMOD, THIDX ); + HTYPE (LPFNSYM pTHGetNextType) ( HMOD, HTYPE ); + LPV (LPFNSYM pSHLpGSNGetTable) ( HEXE ); + LPDEBUGDATA (LPFNSYM pSHGetDebugData) ( HEXE ); + BOOL (LPFNSYM pSHCanDisplay) ( HSYM ); + + // Source Line handler API Exports + + BOOL (LPFNSYM pSLLineFromAddr) ( LPADDR, LPW, SHOFF FAR *, SHOFF FAR * ); + BOOL (LPFNSYM pSLFLineToAddr) ( HSF, WORD, LPADDR, SHOFF FAR * ,WORD FAR * ); + LPCH (LPFNSYM pSLNameFromHsf) ( HSF ); + LPCH (LPFNSYM pSLNameFromHmod) ( HMOD, WORD ); + BOOL (LPFNSYM pSLFQueryModSrc) ( HMOD ); + HMOD (LPFNSYM pSLHmodFromHsf) ( HEXE, HSF ); + HSF (LPFNSYM pSLHsfFromPcxt) ( PCXT ); + HSF (LPFNSYM pSLHsfFromFile) ( HMOD, LSZ ); + + LPV (LPFNSYM pMHOmfLock) ( HDEP ); + VOID (LPFNSYM pMHOmfUnLock) ( HDEP ); + LSZ (LPFNSYM pSHLszGetErrorText) ( SHE ); + BOOL (LPFNSYM pSHIsThunk) ( HSYM ); + BOOL (LPFNSYM pSHWantSymbols) ( HEXE ); +} SHF; // Symbol Handler Functions +typedef SHF FAR *LPSHF; + +typedef BOOL (*LPFNSHINIT)(LPSHF*,LPKNF); +typedef BOOL (*LPFNSHUNINIT)(VOID); +typedef BOOL (*LPFNSHSTARTBACKGROUND)(VOID); +typedef BOOL (*LPFNSHSTOPBACKGROUND)(VOID); + +#pragma pack () + +#endif //RC_INVOKED +#endif // SH_API diff --git a/private/windbg/osdebug/include/shapi.hxx b/private/windbg/osdebug/include/shapi.hxx new file mode 100644 index 000000000..5c40e4159 --- /dev/null +++ b/private/windbg/osdebug/include/shapi.hxx @@ -0,0 +1,411 @@ +// shapi.h - Public API to the Symbol Handler +// +// This file contains all types and APIs that are defined by +// the Symbol Handler and are publicly accessible by other +// components. +// +// Before including this file, you must include cvtypes.h. + + +// The master copy of this file resides in the CVINC project. +// All Microsoft projects are required to use the master copy without +// modification. Modification of the master version or a copy +// without consultation with all parties concerned is extremely +// risky. + +#ifndef _VC_VER_INC +#include "..\include\vcver.h" +#endif + +#if !defined(SH_API) && !defined(RC_INVOKED) +#define SH_API + +typedef enum { // Error returns from some SH functions + sheNone = 0, + sheNoSymbols = 1, // No CV info + sheFutureSymbols = 2, // NB08 to NB99 + sheMustRelink = 3, // NB00 to NB04 + sheNotPacked = 4, // NB05 to NB06 + sheOutOfMemory = 5, + sheCorruptOmf = 6, + sheFileOpen = 7, // Couldn't open file + sheSuppressSyms = 8, // Symbol loading was suppressed + sheDeferSyms = 9, // Symbol loading was defered + sheSymbolsConverted = 10, + sheBadTimeStamp = 11, + sheBadCheckSum = 12, + shePdbNotFound = 13, // Can't find/open pdb file + shePdbBadSig = 14, // internal pdb signature doesn't match sym handler + shePdbInvalidAge = 15, // pdb info doesn't match exe/dll + shePdbOldFormat = 16, // pdb format is obsolete + sheMax // marker for count of she's +} SHE; + +enum { + sopNone = 0, + sopData = 1, + sopStack = 2, + sopReg = 4, + sopLab = 8, + sopFcn = 16, + sopExact = 32 +}; +typedef short SOP; // Symbol OPtions + +typedef enum { + fstNone, + fstSymbol, + fstPublic +} FST; // Function Symbol Type + +typedef enum { + fcdUnknown, + fcdNear, + fcdFar, + fcdData +} FCD; // Function Call Distance (near/far/unknown) + +typedef enum { + fptUnknown, + fptPresent, + fptOmitted +} FPT; // Frame Pointer Type + +typedef struct _ODR { + FST fst; + FCD fcd; + FPT fpt; + WORD cbProlog; + DWORD dwDeltaOff; + LSZ lszName; +} ODR; // OSDebug Return type +typedef ODR *LPODR; + + +typedef enum { + astNone, + astAddress, + astRegister, + astBaseOff +} AST; // Assembler symbol return Types + +typedef struct _ASR { + AST ast; + union { + struct { + FCD fcd; + ADDR addr; + }; + WORD ireg; + OFFSET off; + }; +} ASR; // Assembler Symbol Return structure +typedef ASR *LPASR; + +typedef HEMI SHEMI; +typedef unsigned int SHFLAG; // A TRUE/FALSE flag var +typedef SHFLAG * PSHFLAG; +typedef SEGMENT SHSEG; // A segment/selector value +typedef UOFFSET SHOFF; // An offset value + +typedef void * HVOID; // Generic handle type +typedef HIND HMOD; // A module handle +typedef HIND HGRP; // A group handle (sub group of module + // currently either a seg or filename) +typedef HVOID HPROC; // A handle to a procedure +typedef HVOID HBLK; // A handle to a block. +typedef HVOID HSF; // A handle to source file table +typedef HIND HEXE; // An Executable file handle +typedef HVOID HTYPE; // A handle to a type +typedef HVOID HSYM; // A handle to a symbol +typedef HIND HPDS; // A handle to a process + +typedef HSYM * PHSYM; + +typedef unsigned short THIDX; + +typedef struct CXT { + ADDR addr; + HMOD hMod; + HGRP hGrp; + HPROC hProc; + HBLK hBlk; +} CXT; // General Symbol context pkt +typedef CXT *PCXT; + +typedef struct CXF { + CXT cxt; + FRAME Frame; +} CXF; // Symbol context pkt locked to a frame ptr +typedef CXF *PCXF; + +typedef enum { + SHFar, + SHNear +} SHCALL; + +typedef struct SHREG { + unsigned short hReg; + union { + unsigned char Byte1; + struct { + unsigned short Byte2; + unsigned short Byte2High; + }; + struct { + unsigned long Byte4; + unsigned long Byte4High; + }; + double Byte8; + FLOAT10 Byte10; + }; +} SHREG; +typedef SHREG *PSHREG; + +typedef struct _SLP { + ADDR addr; + SHOFF cb; +} SLP; // Source Line Pair (used by SLCAddrFromLine) +typedef SLP * LPSLP; + +// structure defining parameters of symbol to be searched for. The address +// of this structure is passed on the the EE's symbol compare routine. Any +// additional data required by the EE's routine must follow this structure. + +typedef struct _SSTR { // string with length byte and pointer to data + LPB lpName; // pointer to the string itself + unsigned char cb; // length byte + unsigned char searchmask; // mask to control symbol searching + unsigned short symtype; // symbol types to be checked + unsigned char * pRE; // pointer to regular expression +} SSTR; +typedef SSTR *LPSSTR; + +#define SSTR_proc 0x0001 // compare only procs with correct type +#define SSTR_data 0x0002 // compare only global data with correct type +#define SSTR_RE 0x0004 // compare using regular expression +#define SSTR_NoHash 0x0008 // do a linear search of the table +#define SSTR_symboltype 0x0010 // pass only symbols of symtype to the + // comparison function. + +#define SHpCXTFrompCXF(a) (&((a)->cxt)) +#define SHpFrameFrompCXF(a) (&(a)->Frame) +#define SHHMODFrompCXT(a) ((a)->hMod) +#define SHHPROCFrompCXT(a) ((a)->hProc) +#define SHHBLKFrompCXT(a) ((a)->hBlk) +#define SHpADDRFrompCXT(a) (&((a)->addr)) +#define SHPAddrFromPCxf(a) (SHpADDRFrompCXT(SHpCXTFrompCXF(a))) + +#define SHIsCXTMod(a) ((a)->hMod && !(a)->hProc && !(a)->hBlk) +#define SHIsCXTProc(a) ((a)->hMod && (a)->hProc && !(a)->hBlk) +#define SHIsCXTBlk(a) ((a)->hMod && (a)->hProc && (a)->hBlk) + +#define SHHGRPFrompCXT(a) ((a)->hGrp) + +// comparison prototype +typedef SHFLAG (*PFNCMP) (HVOID, HVOID, LSZ, SHFLAG); +typedef BOOL (*PFNVALIDATEEXE) (UINT, PVOID, LPSTR); + +#define LPFNSYM * +#define LPFNSYMC CDECL * + +typedef struct omap_tag { + DWORD rva; + DWORD rvaTo; +} OMAP, *LPOMAP; + +typedef struct { + DWORD Offset; + DWORD Size; + DWORD Flags; +} SECSTART, *LPSECSTART; + +typedef struct _tagDEBUGDATA { + union { + PIMAGE_RUNTIME_FUNCTION_ENTRY lpRtf; // Runtime function table - fpo or pdata + PFPO_DATA lpFpo; + }; + DWORD cRtf; // Count of rtf entries + LPOMAP lpOmapFrom; // Omap table - From Source + DWORD cOmapFrom; // Count of omap entries - From Source + LPOMAP lpOmapTo; // Omap table - To Source + DWORD cOmapTo; // Count of omap entries - To Source + LPSECSTART lpSecStart; // Original section table (pre-Lego) + SHE she; +} DEBUGDATA, *LPDEBUGDATA; + +typedef struct _KNF { + int cb; + + PVOID (LPFNSYM lpfnMHAlloc) (UINT); + PVOID (LPFNSYM lpfnMHRealloc) (PVOID, UINT); + VOID (LPFNSYM lpfnMHFree) (PVOID); + PVOID (LPFNSYM lpfnMHAllocHuge) (LONG, UINT); + VOID (LPFNSYM lpfnMHFreeHuge) (PVOID); + + HDEP (LPFNSYM lpfnMMAllocHmem) (UINT); + VOID (LPFNSYM lpfnMMFreeHmem) (HDEP); + PVOID (LPFNSYM lpfnMMLock) (HDEP); + VOID (LPFNSYM lpfnMMUnlock) (HDEP); + + HLLI (LPFNSYM lpfnLLInit) (UINT, LLF, LPFNKILLNODE, LPFNFCMPNODE); + HLLE (LPFNSYM lpfnLLCreate) (HLLI); + VOID (LPFNSYM lpfnLLAdd) (HLLI, HLLE); + VOID (LPFNSYM lpfnLLAddHead) (HLLI, HLLE); + VOID (LPFNSYM lpfnLLInsert) (HLLI, HLLE, DWORD); + BOOL (LPFNSYM lpfnLLDelete) (HLLI, HLLE); + BOOL (LPFNSYM lpfnLLRemove) (HLLI, HLLE); + DWORD (LPFNSYM lpfnLLDestroy) (HLLI); + HLLE (LPFNSYM lpfnLLNext) (HLLI, HLLE); + HLLE (LPFNSYM lpfnLLFind) (HLLI, HLLE, PVOID, DWORD); + HLLE (LPFNSYM lpfnLLLast) (HLLI); + DWORD (LPFNSYM lpfnLLSize) (HLLI); + PVOID (LPFNSYM lpfnLLLock) (HLLE); + VOID (LPFNSYM lpfnLLUnlock) (HLLE); + + BOOL (LPFNSYM lpfnLBPrintf) (LPCH, LPCH, UINT); + BOOL (LPFNSYM lpfnLBQuit) (UINT); + + UINT (LPFNSYM lpfnSYOpen) (LSZ); + VOID (LPFNSYM lpfnSYClose) (UINT); + UINT (LPFNSYM lpfnSYReadFar) (UINT, LPB, UINT); + LONG (LPFNSYM lpfnSYSeek) (UINT, LONG, UINT); + BOOL (LPFNSYM lpfnSYFixupAddr) (PADDR); + BOOL (LPFNSYM lpfnSYUnFixupAddr)(PADDR); + UINT (LPFNSYM lpfnSYProcessor) (DWORD); + +// Added/Changed for NT merge. + +// VOID (LPFNSYM lpfn_searchenv) (LSZ, LSZ, LSZ); +// UINT (LPFNSYMC lpfnsprintf) (LSZ, LSZ, ...); +// VOID (LPFNSYM lpfn_splitpath) (LSZ, LSZ, LSZ, LSZ, LSZ); +// LSZ (LPFNSYM lpfn_fullpath) (LSZ, LSZ, UINT); +// VOID (LPFNSYM lpfn_makepath) (LSZ, LSZ, LSZ, LSZ, LSZ); +// UINT (LPFNSYM lpfnstat) (LSZ, LPCH); + + LONG (LPFNSYM lpfnSYTell) (UINT); + UINT (LPFNSYM lpfnSYFindExeFile) (LSZ, LSZ, UINT, PVOID, PFNVALIDATEEXE); + VOID (LPFNSYM lpfnLoadedSymbols) (SHE, HPID, LSZ); + BOOL (LPFNSYM lpfnSYGetDefaultShe) (LSZ, SHE *); + +} KNF; // KerNel Functions exported to the Symbol Handler +typedef KNF *LPKNF; + +typedef struct _SHF { + int cb; + HPDS (LPFNSYM pSHCreateProcess) (VOID); + VOID (LPFNSYM pSHSetHpid) (HPID); + BOOL (LPFNSYM pSHDeleteProcess) (HPDS); + HPDS (LPFNSYM pSHChangeProcess) (HPDS); + SHE (LPFNSYM pSHAddDll) (LSZ, BOOL); // Changed for NT + SHE (LPFNSYM pSHAddDllsToProcess) (VOID); + SHE (LPFNSYM pSHLoadDll) (LSZ, BOOL); + VOID (LPFNSYM pSHUnloadDll) (HEXE); + UOFFSET (LPFNSYM pSHGetDebugStart) (HSYM); + LSZ (LPFNSYM pSHGetSymName) (HSYM, LSZ); + BOOL (LPFNSYM pSHAddrFromHsym) (PADDR, HSYM); // Changed for NT + HMOD (LPFNSYM pSHHModGetNextGlobal) (HEXE *, HMOD); + int (LPFNSYM pSHModelFromAddr) (PADDR, LPW, LPB, UOFFSET *); + int (LPFNSYM pSHPublicNameToAddr) (PADDR, PADDR, LSZ); + LSZ (LPFNSYM pSHGetSymbol) (LPADDR, LPADDR, SOP, LPODR); + BOOL (LPFNSYM pSHGetPublicAddr) (PADDR, LSZ); + BOOL (LPFNSYM pSHIsLabel) (HSYM); + + VOID (LPFNSYM pSHSetDebuggeeDir) (LSZ); +// VOID (LPFNSYM pSHSetUserDir) (LSZ); // Deleted for NT + BOOL (LPFNSYM pSHAddrToLabel) (PADDR, LSZ); + + int (LPFNSYM pSHGetSymLoc) (HSYM, LSZ, UINT, PCXT); + BOOL (LPFNSYM pSHFIsAddrNonVirtual) (PADDR); + BOOL (LPFNSYM pSHIsFarProc) (HSYM); + + HEXE (LPFNSYM pSHGetNextExe) (HEXE); + HEXE (LPFNSYM pSHHexeFromHmod) (HMOD); + HMOD (LPFNSYM pSHGetNextMod) (HEXE, HMOD); + PCXT (LPFNSYM pSHGetCxtFromHmod) (HMOD, PCXT); + PCXT (LPFNSYM pSHSetCxt) (PADDR, PCXT); + PCXT (LPFNSYM pSHSetCxtMod) (PADDR, PCXT); + HSYM (LPFNSYM pSHFindNameInGlobal) (HSYM, + PCXT, + LPSSTR, + SHFLAG, + PFNCMP, + PCXT + ); + HSYM (LPFNSYM pSHFindNameInContext) (HSYM, + PCXT, + LPSSTR, + SHFLAG, + PFNCMP, + PCXT + ); + HSYM (LPFNSYM pSHGoToParent) (PCXT, PCXT); + HSYM (LPFNSYM pSHHsymFromPcxt) (PCXT); + HSYM (LPFNSYM pSHNextHsym) (HMOD, HSYM); + PCXF (LPFNSYM pSHGetFuncCXF) (PADDR, PCXF); + LPCH (LPFNSYM pSHGetModName) (HMOD); + LPCH (LPFNSYM pSHGetExeName) (HEXE); + HEXE (LPFNSYM pSHGethExeFromName) (LPCH); + UOFF32 (LPFNSYM pSHGetNearestHsym) (PADDR, HMOD, int, PHSYM); + SHFLAG (LPFNSYM pSHIsInProlog) (PCXT); + SHFLAG (LPFNSYM pSHIsAddrInCxt) (PCXT, PADDR); + SHFLAG (LPFNSYM pSHCompareRE) (LPCH, LPCH, BOOL); + BOOL (LPFNSYM pSHFindSymbol) (LSZ, PADDR, LPASR); + UOFF32 (LPFNSYM pPHGetNearestHsym) (PADDR, HEXE, PHSYM); + HSYM (LPFNSYM pPHFindNameInPublics) (HSYM, HEXE, LPSSTR, SHFLAG, PFNCMP); + HTYPE (LPFNSYM pTHGetTypeFromIndex) (HMOD, THIDX); + HTYPE (LPFNSYM pTHGetNextType) (HMOD, HTYPE); + PVOID (LPFNSYM pSHLpGSNGetTable) (HEXE); + BOOL (LPFNSYM pSHCanDisplay) (HSYM); + + // Source Line handler API Exports + + BOOL (LPFNSYM pSLLineFromAddr) (LPADDR, LPW, SHOFF *, SHOFF *); + BOOL (LPFNSYM pSLFLineToAddr) (HSF, WORD, LPADDR, SHOFF *, WORD *); + LPCH (LPFNSYM pSLNameFromHsf) (HSF); + LPCH (LPFNSYM pSLNameFromHmod) (HMOD, WORD); + BOOL (LPFNSYM pSLFQueryModSrc) (HMOD); + HMOD (LPFNSYM pSLHmodFromHsf) (HEXE, HSF); + HSF (LPFNSYM pSLHsfFromPcxt) (PCXT); + HSF (LPFNSYM pSLHsfFromFile) (HMOD, LSZ); + + int (LPFNSYM pSLCAddrFromLine) (HEXE, HMOD, LSZ, WORD, LPSLP *); + VOID (LPFNSYM pSHFree) (PVOID); + VOID (LPFNSYM pSHUnloadSymbolHandler)(BOOL); +// REVIEW: piersh + SHE (LPFNSYM pSHGetExeTimeStamp) (LPSTR, ULONG *); + VOID (LPFNSYM pSHPdbNameFromExe) (LSZ, LSZ, UINT); + LPDEBUGDATA (LPFNSYM pSHGetDebugData) (HEXE); + BOOL (LPFNSYM pSHIsThunk) (HSYM); + HSYM (LPFNSYM pSHFindSymInExe) (HEXE, LPSSTR, BOOL); + HSYM (LPFNSYM pSHFindSLink32) (PCXT); + BOOL (LPFNSYM pSHIsDllLoaded) (HEXE); + +// Entries added for NT work. + + LSZ (LPFNSYM pSHGetModule) (PADDR, LSZ); + PCXT (LPFNSYM pSHGetCxtFromHexe) (HEXE, PCXT); + LPCH (LPFNSYM pSHGetModNameFromHexe) (HEXE); + LPCH (LPFNSYM pSHGetSymFName) (HEXE); + HEXE (LPFNSYM pSHGethExeFromModuleName) (LPCH); + LSZ (LPFNSYM pSHLszGetErrorText) (SHE); + BOOL (LPFNSYM pSHWantSymbols) (HEXE); + HSYM (LPFNSYM pSHFindNameInTypes) ( PCXT, LPSSTR, SHFLAG, PFNCMP, PCXT ); +} SHF; // Symbol Handler Functions +typedef SHF *LPSHF; + +// FNSHINIT is the prototype for the SHInit function + +typedef BOOL FNSHINIT(LPSHF *, LPKNF); + +typedef FNSHINIT * LPFNSHINIT; +typedef FNSHINIT * PFNSHINIT; + +typedef BOOL (* LPFNSHUNINIT)(VOID); +typedef BOOL (* LPFNSHSTARTBACKGROUND)(VOID); +typedef BOOL (* LPFNSHSTOPBACKGROUND)(VOID); + +// This is the only SH function that's actually exported from the DLL +FNSHINIT SHInit; + +#endif // SH_API diff --git a/private/windbg/osdebug/include/types.h b/private/windbg/osdebug/include/types.h new file mode 100644 index 000000000..c8b589a91 --- /dev/null +++ b/private/windbg/osdebug/include/types.h @@ -0,0 +1,257 @@ +/** types.h - Generic types + * + * This file contains generic types such as USHORT, ushort, + * WORD, etc., which are not directly related to CodeView. + * Every attempt is made to define them in such a way as they + * will not conflict with the standard header files such as + * windows.h and os2.h. + */ + + +/*** The master copy of this file resides in the CodeView project. + * All Microsoft projects are required to use the master copy without + * modification. Modification of the master version or a copy + * without consultation with all parties concerned is extremely + * risky. + * + * The projects known to use this file are: + * + * CodeView + * C/C++ expression evaluator + * Symbol Handler + * Stump (OSDebug) + */ + +#ifndef _TYPES_H_DEFINED +#define _TYPES_H_DEFINED + + +#ifdef HOST32 +#define _export + +#ifndef LOADDS +#define LOADDS +#endif + +#ifndef PASCAL +#define PASCAL +#endif + +#ifndef CDECL +#define CDECL +#endif + +#ifndef FASTCALL +#define FASTCALL +#endif + +#ifndef FAR +#define FAR +#endif + +#ifndef NEAR +#define NEAR +#endif + +#ifndef _HUGE +#define _HUGE +#endif + +#ifndef _HUGE_ +#define _HUGE_ +#endif + +/* +** This set of functions need to be expanded to deal with +** unicode and other problems. +*/ + +#define _fmemcmp memcmp +#define _fmemcpy memcpy +#define _fmemmove memmove +#define _fmemset memset +#define _fstrcat strcat +#define _fstrchr strchr +#define _fstrcpy strcpy +#define _fstricmp stricmp +#define _fstrlen strlen +#define _fstrncat strncat +#define _fstrncmp strncmp +#define _fstrncpy strncpy +#define _fstrnicmp strnicmp +#define _fstrstr strstr +#define _fstrupr strupr + +#else // !HOST32 + +#ifndef LOADDS +#define LOADDS _loadds +#endif + +#ifndef PASCAL +#define PASCAL _pascal +#endif + +#ifndef CDECL +#define CDECL _cdecl +#endif + +#ifndef FASTCALL +#define FASTCALL _fastcall +#endif + +#ifndef FAR +#define FAR _far +#endif + +#ifndef NEAR +#define NEAR _near +#endif + +#ifndef _HUGE +#define _HUGE _huge +#endif + +#ifndef _HUGE_ +#define _HUGE_ _huge +#endif +#endif // HOST32 + +#ifndef INTERRUPT +#define INTERRUPT _interrupt +#endif + +#ifndef LOCAL +#define LOCAL static +#endif + +#ifndef GLOBAL +#define GLOBAL +#endif + +// +// Things that come from either windows.h or os2.h +// + +#if !defined(LOWORD) && !defined(OS2_INCLUDED) + +#define VOID void + + typedef unsigned char BYTE; + + typedef int BOOL; + +#define LONG long + +#endif + +// +// Things that come from windows.h +// + +#if !defined(LOWORD) + + typedef unsigned int HANDLE; + + typedef char FAR * LPSTR; + + typedef unsigned short WORD; + typedef unsigned long DWORD; + +#endif + +// +// Things that come from os2.h +// + +#if !defined(OS2_INCLUDED) + +#define CHAR char + +#ifndef _WINDOWS_ + typedef unsigned char UCHAR; +#endif +#define SHORT short +#define INT int +#ifndef _WINDOWS_ + typedef unsigned short USHORT; + typedef unsigned int UINT; + typedef unsigned long ULONG; + typedef char * PCH; +#endif +#endif + +#if !defined(LOWORD) + +#define LOWORD(l) ((WORD)(l)) +#define HIWORD(l) ((WORD)(((DWORD)(l) >> 16) & 0xFFFF)) + +#endif + +#ifndef NULL +#define NULL ((void *) 0) +#endif + +#ifndef HNULL +#define HNULL 0 +#endif + +#if !defined(TRUE) || !defined(FALSE) +#undef TRUE +#undef FALSE + +#define FALSE 0 +#define TRUE 1 +#endif + +#if !defined(fTrue) || !defined(fFalse) +#undef fTrue +#undef fFalse + +#define fFalse 0 +#define fTrue 1 +#endif + +#ifndef min +#define min(a,b) (((a) < (b)) ? (a) : (b)) +#endif + +#ifndef max +#define max(a,b) (((a) > (b)) ? (a) : (b)) +#endif + +#ifndef Unreferenced +#define Unreferenced(a) ((void)a) +#endif + +typedef unsigned short ushort; +typedef unsigned char uchar; +typedef unsigned long ulong; +typedef unsigned int uint; + +typedef void * PV; +typedef void FAR * LPV; + +typedef char * SZ; +typedef char FAR * LSZ; +#ifndef _WINDOWS_ +typedef char FAR * LPCH; +#endif + +typedef BOOL FAR * LPF; +typedef BYTE FAR * LPB; +typedef WORD FAR * LPW; +typedef LONG FAR * LPL; +typedef ULONG FAR * LPUL; +typedef USHORT FAR *LPUS; + +typedef short SWORD; + +#ifdef HOST32 +typedef ULONG IWORD; +#else +typedef UINT IWORD; +#define WNDPROC FARPROC +#endif + +#endif // _TYPES_H_DEFINED diff --git a/private/windbg/osdebug/include/vcver.h b/private/windbg/osdebug/include/vcver.h new file mode 100644 index 000000000..bd3ee5124 --- /dev/null +++ b/private/windbg/osdebug/include/vcver.h @@ -0,0 +1,6 @@ +#ifndef _VC_VER_INC +#define _VC_VER_INC +#ifndef _VC_VER +#define _VC_VER 300 +#endif +#endif diff --git a/private/windbg/osdebug/include/version.h b/private/windbg/osdebug/include/version.h new file mode 100644 index 000000000..9b824fa6e --- /dev/null +++ b/private/windbg/osdebug/include/version.h @@ -0,0 +1,5 @@ +#define rmj 2 +#define rmm 0 +#define rup 4193 +#define szVerName "NT - Windbg" +#define szVerUser "KENTF2" |