From 608055e44795958f2e8e1735ff77a453ca6013bc Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Tue, 13 Feb 2024 13:27:02 -0800 Subject: [PATCH] metagen: simplify catchall generations; move some codeview enums into metacode; generate enum->string code --- src/base/base_ins.h | 4 +- src/codeview/codeview.c | 5 + src/codeview/codeview.h | 1745 ++++++++++++------------ src/codeview/codeview.mdesk | 478 +++++++ src/codeview/codeview_stringize.c | 55 +- src/codeview/codeview_stringize.h | 4 - src/codeview/generated/codeview.meta.c | 454 ++++++ src/codeview/generated/codeview.meta.h | 461 +++++++ src/df/core/df_core.mdesk | 8 +- src/df/gfx/df_gfx.mdesk | 4 +- src/draw/draw.mdesk | 14 +- src/metagen/metagen_main.c | 47 +- src/regs/raddbgi/regs_raddbgi.mdesk | 4 +- src/regs/regs.mdesk | 18 +- src/ui/ui.mdesk | 18 +- 15 files changed, 2323 insertions(+), 996 deletions(-) create mode 100644 src/codeview/generated/codeview.meta.c create mode 100644 src/codeview/generated/codeview.meta.h diff --git a/src/base/base_ins.h b/src/base/base_ins.h index 9f8d3202..6908e7cd 100644 --- a/src/base/base_ins.h +++ b/src/base/base_ins.h @@ -15,11 +15,11 @@ # include # if ARCH_X64 -# define ins_atomic_u64_eval(x) InterlockedAdd((volatile LONG *)(x), 0) +# define ins_atomic_u64_eval(x) InterlockedAdd64((volatile __int64 *)(x), 0) # define ins_atomic_u64_inc_eval(x) InterlockedIncrement64((volatile __int64 *)(x)) # define ins_atomic_u64_dec_eval(x) InterlockedDecrement64((volatile __int64 *)(x)) # define ins_atomic_u64_eval_assign(x,c) InterlockedExchange64((volatile __int64 *)(x),(c)) -# define ins_atomic_u64_add_eval(x,c) InterlockedAdd((volatile LONG *)(x), c) +# define ins_atomic_u64_add_eval(x,c) InterlockedAdd64((volatile __int64 *)(x), c) # define ins_atomic_u32_eval_assign(x,c) InterlockedExchange((volatile LONG *)(x),(c)) # define ins_atomic_u32_eval_cond_assign(x,k,c) InterlockedCompareExchange((volatile LONG *)(x),(k),(c)) # define ins_atomic_ptr_eval_assign(x,c) (void*)ins_atomic_u64_eval_assign((volatile __int64 *)(x), (__int64)(c)) diff --git a/src/codeview/codeview.c b/src/codeview/codeview.c index e7425434..ad1b528e 100644 --- a/src/codeview/codeview.c +++ b/src/codeview/codeview.c @@ -1,6 +1,11 @@ // Copyright (c) 2024 Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) +//////////////////////////////// +//~ Generated Code + +#include "generated/codeview.meta.c" + //////////////////////////////// //~ CodeView Common Functions diff --git a/src/codeview/codeview.h b/src/codeview/codeview.h index 1e4a1d37..5aedc31a 100644 --- a/src/codeview/codeview.h +++ b/src/codeview/codeview.h @@ -9,7 +9,7 @@ // https://github.com/microsoft/microsoft-pdb/blob/master/include/cvinfo.h //////////////////////////////// -//~ CodeView Format Shared Types +//~ rjf: CodeView Format Shared Types typedef U32 CV_TypeId; typedef U32 CV_ItemId; @@ -19,139 +19,13 @@ typedef U16 CV_Reg; read_only global CV_TypeId cv_type_id_variadic = 0xFFFFFFFF; -#define CV_NumericKindXList(X) \ -X(CHAR, 0x8000)\ -X(SHORT, 0x8001)\ -X(USHORT, 0x8002)\ -X(LONG, 0x8003)\ -X(ULONG, 0x8004)\ -X(FLOAT32, 0x8005)\ -X(FLOAT64, 0x8006)\ -X(FLOAT80, 0x8007)\ -X(FLOAT128, 0x8008)\ -X(QUADWORD, 0x8009)\ -X(UQUADWORD, 0x800a)\ -X(FLOAT48, 0x800b)\ -X(COMPLEX32, 0x800c)\ -X(COMPLEX64, 0x800d)\ -X(COMPLEX80, 0x800e)\ -X(COMPLEX128, 0x800f)\ -X(VARSTRING, 0x8010)\ -X(OCTWORD, 0x8017)\ -X(UOCTWORD, 0x8018)\ -X(DECIMAL, 0x8019)\ -X(DATE, 0x801a)\ -X(UTF8STRING, 0x801b)\ -X(FLOAT16, 0x801c) +//////////////////////////////// +//~ rjf: Generated Code -typedef U16 CV_NumericKind; -typedef enum{ -#define X(N,c) CV_NumericKind_##N = c, - CV_NumericKindXList(X) -#undef X -} CV_NumericKindEnum; - -#define CV_ArchXList(X) \ -X(8080, 0x00)\ -X(8086, 0x01)\ -X(80286, 0x02)\ -X(80386, 0x03)\ -X(80486, 0x04)\ -X(PENTIUM, 0x05)\ -X(PENTIUMII, 0x06)\ -X(PENTIUMIII, 0x07)\ -X(MIPS, 0x10)\ -X(MIPS16, 0x11)\ -X(MIPS32, 0x12)\ -X(MIPS64, 0x13)\ -X(MIPSI, 0x14)\ -X(MIPSII, 0x15)\ -X(MIPSIII, 0x16)\ -X(MIPSIV, 0x17)\ -X(MIPSV, 0x18)\ -X(M68000, 0x20)\ -X(M68010, 0x21)\ -X(M68020, 0x22)\ -X(M68030, 0x23)\ -X(M68040, 0x24)\ -X(ALPHA, 0x30)\ -X(ALPHA_21164, 0x31)\ -X(ALPHA_21164A, 0x32)\ -X(ALPHA_21264, 0x33)\ -X(ALPHA_21364, 0x34)\ -X(PPC601, 0x40)\ -X(PPC603, 0x41)\ -X(PPC604, 0x42)\ -X(PPC620, 0x43)\ -X(PPCFP, 0x44)\ -X(PPCBE, 0x45)\ -X(SH3, 0x50)\ -X(SH3E, 0x51)\ -X(SH3DSP, 0x52)\ -X(SH4, 0x53)\ -X(SHMEDIA, 0x54)\ -X(ARM3, 0x60)\ -X(ARM4, 0x61)\ -X(ARM4T, 0x62)\ -X(ARM5, 0x63)\ -X(ARM5T, 0x64)\ -X(ARM6, 0x65)\ -X(ARM_XMAC, 0x66)\ -X(ARM_WMMX, 0x67)\ -X(ARM7, 0x68)\ -X(OMNI, 0x70)\ -X(IA64_1, 0x80)\ -X(IA64_2, 0x81)\ -X(CEE, 0x90)\ -X(AM33, 0xA0)\ -X(M32R, 0xB0)\ -X(TRICORE, 0xC0)\ -X(X64, 0xD0)\ -X(EBC, 0xE0)\ -X(THUMB, 0xF0)\ -X(ARMNT, 0xF4)\ -X(ARM64, 0xF6)\ -X(D3D11_SHADER, 0x100) - -#define CV_Arch_IA64 CV_Arch_IA64_1 - -typedef U16 CV_Arch; -typedef enum{ -#define X(N,c) CV_Arch_##N = c, - CV_ArchXList(X) -#undef X -} CV_ArchEnum; -#define CV_Arch_PENTIUMPRO CV_Arch_PENTIUMII -#define CV_Arch_MIPSR4000 CV_Arch_MIPS -#define CV_Arch_ALPHA_21064 CV_Arch_ALPHA -#define CV_Arch_AMD64 CV_Arch_X64 - - -typedef U16 CV_Reg; - - -#define CV_AllRegXList(X) \ -X(ERR, 30000)\ -X(TEB, 30001)\ -X(TIMER, 30002)\ -X(EFAD1, 30003)\ -X(EFAD2, 30004)\ -X(EFAD3, 30005)\ -X(VFRAME, 30006)\ -X(HANDLE, 30007)\ -X(PARAMS, 30008)\ -X(LOCALS, 30009)\ -X(TID, 30010)\ -X(ENV, 30011)\ -X(CMDLN, 30012) - -typedef U16 CV_AllReg; -typedef enum{ -#define X(N,c) CV_AllReg_##N = c, - CV_AllRegXList(X) -#undef X -} CV_AllRegEnum; +#include "generated/codeview.meta.h" +//////////////////////////////// +//~ rjf: Registers // X(NAME, CODE, (RADDBGI_RegsiterCode_X86) NAME, BYTE_POS, BYTE_SIZE) #define CV_Reg_X86_XList(X) \ @@ -400,11 +274,13 @@ X(YMM7D2, 394, ymm7, 16, 8)\ X(YMM7D3, 395, ymm7, 24, 8) typedef U16 CV_Regx86; -typedef enum{ +typedef enum CV_Regx86Enum +{ #define X(CVN,C,RDN,BP,BZ) CV_Regx86_##CVN = C, CV_Reg_X86_XList(X) #undef X -} CV_Regx86Enum; +} +CV_Regx86Enum; // X(NAME, CODE, (RADDBGI_RegsiterCode_X64) NAME, BYTE_POS, BYTE_SIZE) #define CV_Reg_X64_XList(X) \ @@ -1027,11 +903,13 @@ X(YMM15D2, 686, ymm15, 16, 8)\ X(YMM15D3, 687, ymm15, 24, 8) typedef U16 CV_Regx64; -typedef enum{ +typedef enum CV_Regx64Enum +{ #define X(CVN,C,RDN,BP,BZ) CV_Regx64_##CVN = C, CV_Reg_X64_XList(X) #undef X -} CV_Regx64Enum; +} +CV_Regx64Enum; #define CV_SignatureXList(X) \ @@ -1042,11 +920,13 @@ X(C13, 4)\ X(RESERVED, 5) typedef U16 CV_Signature; -typedef enum{ +typedef enum CV_SignatureEnum +{ #define X(N,c) CV_Signature_##N = c, CV_SignatureXList(X) #undef X -} CV_SignatureEnum; +} +CV_SignatureEnum; #define CV_LanguageXList(X) \ @@ -1069,231 +949,31 @@ X(MSIL, 0x0F)\ X(HLSL, 0x10) typedef U16 CV_Language; -typedef enum{ +typedef enum CV_LanguageEnum +{ #define X(N,c) CV_Language_##N = c, CV_LanguageXList(X) #undef X -} CV_LanguageEnum; - - +} +CV_LanguageEnum; //////////////////////////////// -//~ CodeView Format "Sym" and "Leaf" Header Type +//~ rjf: CodeView Format "Sym" and "Leaf" Header Type -typedef struct CV_RecHeader{ +typedef struct CV_RecHeader CV_RecHeader; +struct CV_RecHeader +{ U16 size; U16 kind; -} CV_RecHeader; - +}; //////////////////////////////// -//~ CodeView Format "Sym" Types -// (per-compilation-unit info, variables, procedures, etc.) - -#define CV_SymKindXList(X) \ -X(COMPILE, 0x0001)\ -X(REGISTER_16t, 0x0002)\ -X(CONSTANT_16t, 0x0003)\ -X(UDT_16t, 0x0004)\ -X(SSEARCH, 0x0005)\ -X(END, 0x0006)\ -X(SKIP, 0x0007)\ -X(CVRESERVE, 0x0008)\ -X(OBJNAME_ST, 0x0009)\ -X(ENDARG, 0x000a)\ -X(COBOLUDT_16t, 0x000b)\ -X(MANYREG_16t, 0x000c)\ -X(RETURN, 0x000d)\ -X(ENTRYTHIS, 0x000e)\ -X(BPREL16, 0x0100)\ -X(LDATA16, 0x0101)\ -X(GDATA16, 0x0102)\ -X(PUB16, 0x0103)\ -X(LPROC16, 0x0104)\ -X(GPROC16, 0x0105)\ -X(THUNK16, 0x0106)\ -X(BLOCK16, 0x0107)\ -X(WITH16, 0x0108)\ -X(LABEL16, 0x0109)\ -X(CEXMODEL16, 0x010a)\ -X(VFTABLE16, 0x010b)\ -X(REGREL16, 0x010c)\ -X(BPREL32_16t, 0x0200)\ -X(LDATA32_16t, 0x0201)\ -X(GDATA32_16t, 0x0202)\ -X(PUB32_16t, 0x0203)\ -X(LPROC32_16t, 0x0204)\ -X(GPROC32_16t, 0x0205)\ -X(THUNK32_ST, 0x0206)\ -X(BLOCK32_ST, 0x0207)\ -X(WITH32_ST, 0x0208)\ -X(LABEL32_ST, 0x0209)\ -X(CEXMODEL32, 0x020a)\ -X(VFTABLE32_16t, 0x020b)\ -X(REGREL32_16t, 0x020c)\ -X(LTHREAD32_16t, 0x020d)\ -X(GTHREAD32_16t, 0x020e)\ -X(SLINK32, 0x020f)\ -X(LPROCMIPS_16t, 0x0300)\ -X(GPROCMIPS_16t, 0x0301)\ -X(PROCREF_ST, 0x0400)\ -X(DATAREF_ST, 0x0401)\ -X(ALIGN, 0x0402)\ -X(LPROCREF_ST, 0x0403)\ -X(OEM, 0x0404)\ -X(TI16_MAX, 0x1000)\ -X(CONSTANT_ST, 0x1002)\ -X(UDT_ST, 0x1003)\ -X(COBOLUDT_ST, 0x1004)\ -X(MANYREG_ST, 0x1005)\ -X(BPREL32_ST, 0x1006)\ -X(LDATA32_ST, 0x1007)\ -X(GDATA32_ST, 0x1008)\ -X(PUB32_ST, 0x1009)\ -X(LPROC32_ST, 0x100a)\ -X(GPROC32_ST, 0x100b)\ -X(VFTABLE32, 0x100c)\ -X(REGREL32_ST, 0x100d)\ -X(LTHREAD32_ST, 0x100e)\ -X(GTHREAD32_ST, 0x100f)\ -X(LPROCMIPS_ST, 0x1010)\ -X(GPROCMIPS_ST, 0x1011)\ -X(FRAMEPROC, 0x1012)\ -X(COMPILE2_ST, 0x1013)\ -X(MANYREG2_ST, 0x1014)\ -X(LPROCIA64_ST, 0x1015)\ -X(GPROCIA64_ST, 0x1016)\ -X(LOCALSLOT_ST, 0x1017)\ -X(PARAMSLOT_ST, 0x1018)\ -X(ANNOTATION, 0x1019)\ -X(GMANPROC_ST, 0x101a)\ -X(LMANPROC_ST, 0x101b)\ -X(RESERVED1, 0x101c)\ -X(RESERVED2, 0x101d)\ -X(RESERVED3, 0x101e)\ -X(RESERVED4, 0x101f)\ -X(LMANDATA_ST, 0x1020)\ -X(GMANDATA_ST, 0x1021)\ -X(MANFRAMEREL_ST, 0x1022)\ -X(MANREGISTER_ST, 0x1023)\ -X(MANSLOT_ST, 0x1024)\ -X(MANMANYREG_ST, 0x1025)\ -X(MANREGREL_ST, 0x1026)\ -X(MANMANYREG2_ST, 0x1027)\ -X(MANTYPREF, 0x1028)\ -X(UNAMESPACE_ST, 0x1029)\ -X(ST_MAX, 0x1100)\ -X(OBJNAME, 0x1101)\ -X(THUNK32, 0x1102)\ -X(BLOCK32, 0x1103)\ -X(WITH32, 0x1104)\ -X(LABEL32, 0x1105)\ -X(REGISTER, 0x1106)\ -X(CONSTANT, 0x1107)\ -X(UDT, 0x1108)\ -X(COBOLUDT, 0x1109)\ -X(MANYREG, 0x110a)\ -X(BPREL32, 0x110b)\ -X(LDATA32, 0x110c)\ -X(GDATA32, 0x110d)\ -X(PUB32, 0x110e)\ -X(LPROC32, 0x110f)\ -X(GPROC32, 0x1110)\ -X(REGREL32, 0x1111)\ -X(LTHREAD32, 0x1112)\ -X(GTHREAD32, 0x1113)\ -X(LPROCMIPS, 0x1114)\ -X(GPROCMIPS, 0x1115)\ -X(COMPILE2, 0x1116)\ -X(MANYREG2, 0x1117)\ -X(LPROCIA64, 0x1118)\ -X(GPROCIA64, 0x1119)\ -X(LOCALSLOT, 0x111a)\ -X(PARAMSLOT, 0x111b)\ -X(LMANDATA, 0x111c)\ -X(GMANDATA, 0x111d)\ -X(MANFRAMEREL, 0x111e)\ -X(MANREGISTER, 0x111f)\ -X(MANSLOT, 0x1120)\ -X(MANMANYREG, 0x1121)\ -X(MANREGREL, 0x1122)\ -X(MANMANYREG2, 0x1123)\ -X(UNAMESPACE, 0x1124)\ -X(PROCREF, 0x1125)\ -X(DATAREF, 0x1126)\ -X(LPROCREF, 0x1127)\ -X(ANNOTATIONREF, 0x1128)\ -X(TOKENREF, 0x1129)\ -X(GMANPROC, 0x112a)\ -X(LMANPROC, 0x112b)\ -X(TRAMPOLINE, 0x112c)\ -X(MANCONSTANT, 0x112d)\ -X(ATTR_FRAMEREL, 0x112e)\ -X(ATTR_REGISTER, 0x112f)\ -X(ATTR_REGREL, 0x1130)\ -X(ATTR_MANYREG, 0x1131)\ -X(SEPCODE, 0x1132)\ -X(DEFRANGE_2005, 0x1134)\ -X(DEFRANGE2_2005, 0x1135)\ -X(SECTION, 0x1136)\ -X(COFFGROUP, 0x1137)\ -X(EXPORT, 0x1138)\ -X(CALLSITEINFO, 0x1139)\ -X(FRAMECOOKIE, 0x113a)\ -X(DISCARDED, 0x113b)\ -X(COMPILE3, 0x113c)\ -X(ENVBLOCK, 0x113d)\ -X(LOCAL, 0x113e)\ -X(DEFRANGE, 0x113f)\ -X(DEFRANGE_SUBFIELD, 0x1140)\ -X(DEFRANGE_REGISTER, 0x1141)\ -X(DEFRANGE_FRAMEPOINTER_REL, 0x1142)\ -X(DEFRANGE_SUBFIELD_REGISTER, 0x1143)\ -X(DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE, 0x1144)\ -X(DEFRANGE_REGISTER_REL, 0x1145)\ -X(LPROC32_ID, 0x1146)\ -X(GPROC32_ID, 0x1147)\ -X(LPROCMIPS_ID, 0x1148)\ -X(GPROCMIPS_ID, 0x1149)\ -X(LPROCIA64_ID, 0x114a)\ -X(GPROCIA64_ID, 0x114b)\ -X(BUILDINFO, 0x114c)\ -X(INLINESITE, 0x114d)\ -X(INLINESITE_END, 0x114e)\ -X(PROC_ID_END, 0x114f)\ -X(DEFRANGE_HLSL, 0x1150)\ -X(GDATA_HLSL, 0x1151)\ -X(LDATA_HLSL, 0x1152)\ -X(FILESTATIC, 0x1153)\ -X(LPROC32_DPC, 0x1155)\ -X(LPROC32_DPC_ID, 0x1156)\ -X(DEFRANGE_DPC_PTR_TAG, 0x1157)\ -X(DPC_SYM_TAG_MAP, 0x1158)\ -X(ARMSWITCHTABLE, 0x1159)\ -X(CALLEES, 0x115a)\ -X(CALLERS, 0x115b)\ -X(POGODATA, 0x115c)\ -X(INLINESITE2, 0x115d)\ -X(HEAPALLOCSITE, 0x115e)\ -X(MOD_TYPEREF, 0x115f)\ -X(REF_MINIPDB, 0x1160)\ -X(PDBMAP, 0x1161)\ -X(GDATA_HLSL32, 0x1162)\ -X(LDATA_HLSL32, 0x1163)\ -X(GDATA_HLSL32_EX, 0x1164)\ -X(LDATA_HLSL32_EX, 0x1165)\ -X(FASTLINK, 0x1167)\ -X(INLINEES, 0x1168) - -typedef U16 CV_SymKind; -typedef enum{ -#define X(N,c) CV_SymKind_##N = c, - CV_SymKindXList(X) -#undef X -} CV_SymKindEnum; +//~ rjf: CodeView Format "Sym" Types +// (per-compilation-unit info, variables, procedures, etc.) typedef U8 CV_ProcFlags; -enum{ +enum +{ CV_ProcFlag_NoFPO = (1 << 0), CV_ProcFlag_IntReturn = (1 << 1), CV_ProcFlag_FarReturn = (1 << 2), @@ -1305,7 +985,8 @@ enum{ }; typedef U16 CV_LocalFlags; -enum{ +enum +{ CV_LocalFlag_Param = (1 << 0), CV_LocalFlag_AddrTaken = (1 << 1), CV_LocalFlag_Compgen = (1 << 2), @@ -1319,13 +1000,16 @@ enum{ CV_LocalFlag_Static = (1 << 10), }; -typedef struct CV_LocalVarAttr{ +typedef struct CV_LocalVarAttr CV_LocalVarAttr; +struct CV_LocalVarAttr +{ U32 off; U16 seg; CV_LocalFlags flags; -} CV_LocalVarAttr; +}; + +//- (SymKind: COMPILE) -// (SymKind: COMPILE) typedef U32 CV_CompileFlags; #define CV_CompileFlags_ExtractLanguage(f) (((f) )&0xFF) #define CV_CompileFlags_ExtractFloatPrec(f) (((f)>> 8)&0x03) @@ -1334,23 +1018,30 @@ typedef U32 CV_CompileFlags; #define CV_CompileFlags_ExtractAmbientCode(f) (((f)>>15)&0x07) #define CV_CompileFlags_ExtractMode(f) (((f)>>18)&0x01) -typedef struct CV_SymCompile{ +typedef struct CV_SymCompile CV_SymCompile; +struct CV_SymCompile +{ U8 machine; CV_CompileFlags flags; // U8[] ver_str (null terminated) -} CV_SymCompile; +}; -// (SymKind: SSEARCH) -typedef struct CV_SymStartSearch{ +//- (SymKind: SSEARCH) + +typedef struct CV_SymStartSearch CV_SymStartSearch; +struct CV_SymStartSearch +{ U32 start_symbol; U16 segment; -} CV_SymStartSearch; +}; -// (SymKind: END) (empty) +//- (SymKind: END) (empty) + +//- (SymKind: RETURN) -// (SymKind: RETURN) typedef U8 CV_GenericStyle; -typedef enum{ +typedef enum CV_GenericStyleEnum +{ CV_GenericStyle_VOID, CV_GenericStyle_REG, // "return data is in register" CV_GenericStyle_ICAN, // "indirect caller allocated near" @@ -1358,52 +1049,69 @@ typedef enum{ CV_GenericStyle_IRAN, // "indirect returnee allocated near" CV_GenericStyle_IRAF, // "indirect returnee allocated far" CV_GenericStyle_UNUSED, -} CV_GenericStyleEnum; +} +CV_GenericStyleEnum; typedef U16 CV_GenericFlags; -enum{ +enum +{ CV_GenericFlags_CSTYLE = (1 << 0), CV_GenericFlags_RSCLEAN = (1 << 1), // "returnee stack cleanup" }; -typedef struct CV_Return{ +typedef struct CV_Return CV_Return; +struct CV_Return +{ CV_GenericFlags flags; CV_GenericStyle style; -} CV_Return; +}; -// (SymKind: SLINK32) -typedef struct CV_SymSLink32{ +//- (SymKind: SLINK32) + +typedef struct CV_SymSLink32 CV_SymSLink32; +struct CV_SymSLink32 +{ U32 frame_size; U32 offset; U16 reg; -} CV_SymSLink32; +}; -// (SymKind: OEM) -typedef struct CV_SymOEM{ +//- (SymKind: OEM) + +typedef struct CV_SymOEM CV_SymOEM; +struct CV_SymOEM +{ COFF_Guid id; CV_TypeId itype; // padding align(4) -} CV_SymOEM; +}; -// (SymKind: VFTABLE32) -typedef struct CV_SymVPath32{ +//- (SymKind: VFTABLE32) + +typedef struct CV_SymVPath32 CV_SymVPath32; +struct CV_SymVPath32 +{ CV_TypeId root; CV_TypeId path; U32 off; U16 seg; } CV_SymVPath32; -// (SymKind: FRAMEPROC) +//- (SymKind: FRAMEPROC) + typedef U8 CV_EncodedFramePtrReg; -typedef enum{ +typedef enum CV_EncodedFramePtrRegEnum +{ CV_EncodedFramePtrReg_None, CV_EncodedFramePtrReg_StackPtr, CV_EncodedFramePtrReg_FramePtr, CV_EncodedFramePtrReg_BasePtr, -} CV_EncodedFramePtrRegEnum; +} +CV_EncodedFramePtrRegEnum; typedef U32 CV_FrameprocFlags; -enum{ +enum +{ CV_FrameprocFlag_UsesAlloca = (1 << 0), CV_FrameprocFlag_UsesSetJmp = (1 << 1), CV_FrameprocFlag_UsesLongJmp = (1 << 2), @@ -1426,11 +1134,12 @@ enum{ CV_FrameprocFlag_HasCFG = (1 << 21), CV_FrameprocFlag_HasCFW = (1 << 22), }; - #define CV_FrameprocFlags_ExtractLocalBasePointer(f) (((f) >> 14)&3) #define CV_FrameprocFlags_ExtractParamBasePointer(f) (((f) >> 16)&3) -typedef struct CV_SymFrameproc{ +typedef struct CV_SymFrameproc CV_SymFrameproc; +struct CV_SymFrameproc +{ U32 frame_size; U32 pad_size; U32 pad_off; @@ -1438,25 +1147,32 @@ typedef struct CV_SymFrameproc{ U32 eh_off; CV_SectionIndex eh_sec; CV_FrameprocFlags flags; -} CV_SymFrameproc; +}; -// (SymKind: ANNOTATION) -typedef struct CV_SymAnnotation{ +//- (SymKind: ANNOTATION) +typedef struct CV_SymAnnotation CV_SymAnnotation; +struct CV_SymAnnotation +{ U32 off; U16 seg; U16 count; // U8[] annotation (null terminated) -} CV_SymAnnotation; +}; -// (SymKind: OBJNAME) -typedef struct CV_SymObjname{ +//- (SymKind: OBJNAME) + +typedef struct CV_SymObjname CV_SymObjname; +struct CV_SymObjname +{ U32 sig; // U8[] name (null terminated) -} CV_SymObjname; +}; + +//- (SymKind: THUNK32) -// (SymKind: THUNK32) typedef U8 CV_ThunkOrdinal; -typedef enum{ +typedef enum CV_ThunkOrdinalEnum +{ CV_ThunkOrdinal_NoType, CV_ThunkOrdinal_Adjustor, CV_ThunkOrdinal_VCall, @@ -1464,9 +1180,12 @@ typedef enum{ CV_ThunkOrdinal_Load, CV_ThunkOrdinal_TrampIncremental, CV_ThunkOrdinal_TrampBranchIsland, -} CV_ThunkOrdinalEnum; +} +CV_ThunkOrdinalEnum; -typedef struct CV_SymThunk32{ +typedef struct CV_SymThunk32 CV_SymThunk32; +struct CV_SymThunk32 +{ U32 parent; U32 end; U32 next; @@ -1476,86 +1195,117 @@ typedef struct CV_SymThunk32{ CV_ThunkOrdinal ord; // U8[] name (null terminated) // U8[] variant (null terminated) -} CV_SymThunk32; +}; -// (SymKind: BLOCK32) -typedef struct CV_SymBlock32{ +//- (SymKind: BLOCK32) + +typedef struct CV_SymBlock32 CV_SymBlock32; +struct CV_SymBlock32 +{ U32 parent; U32 end; U32 len; U32 off; U16 sec; // U8[] name (null terminated) -} CV_SymBlock32; +}; -// (SymKind: LABEL32) -typedef struct CV_SymLabel32{ +//- (SymKind: LABEL32) + +typedef struct CV_SymLabel32 CV_SymLabel32; +struct CV_SymLabel32 +{ U32 off; U16 sec; CV_ProcFlags flags; // U8[] name (null terminated) -} CV_SymLabel32; +}; -// (SymKind: REGISTER) -typedef struct CV_SymRegister{ +//- (SymKind: REGISTER) + +typedef struct CV_SymRegister CV_SymRegister; +struct CV_SymRegister +{ CV_TypeId itype; U16 reg; // U8[] name (null terminated) -} CV_SymRegister; +}; -// (SymKind: CONSTANT) -typedef struct CV_SymConstant{ +//- (SymKind: CONSTANT) + +typedef struct CV_SymConstant CV_SymConstant; +struct CV_SymConstant +{ CV_TypeId itype; // CV_Numeric num // U8[] name (null terminated) -} CV_SymConstant; +}; -// (SymKind: UDT) -typedef struct CV_SymUDT{ +//- (SymKind: UDT) + +typedef struct CV_SymUDT CV_SymUDT; +struct CV_SymUDT +{ CV_TypeId itype; // U8[] name (null terminated) -} CV_SymUDT; +}; -// (SymKind: MANYREG) -typedef struct CV_SymManyreg{ +//- (SymKind: MANYREG) + +typedef struct CV_SymManyreg CV_SymManyreg; +struct CV_SymManyreg +{ CV_TypeId itype; U8 count; // U8[count] regs; -} CV_SymManyreg; +}; -// (SymKind: BPREL32) -typedef struct CV_SymBPRel32{ +//- (SymKind: BPREL32) + +typedef struct CV_SymBPRel32 CV_SymBPRel32; +struct CV_SymBPRel32 +{ U32 off; CV_TypeId itype; // U8[] name (null terminated) -} CV_SymBPRel32; +}; -// (SymKind: LDATA32, GDATA32) -typedef struct CV_SymData32{ +//- (SymKind: LDATA32, GDATA32) + +typedef struct CV_SymData32 CV_SymData32; +struct CV_SymData32 +{ CV_TypeId itype; U32 off; CV_SectionIndex sec; // U8[] name (null terminated) -} CV_SymData32; - -// (SymKind: PUB32) -typedef U32 CV_PubFlags; -enum{ - CV_PubFlag_Code = (1 << 0), - CV_PubFlag_Function = (1 << 1), - CV_PubFlag_ManagedCode = (1 << 2), - CV_PubFlag_MSIL = (1 << 3), }; -typedef struct CV_SymPub32{ +//- (SymKind: PUB32) + +typedef U32 CV_PubFlags; +enum +{ + CV_PubFlag_Code = (1 << 0), + CV_PubFlag_Function = (1 << 1), + CV_PubFlag_ManagedCode = (1 << 2), + CV_PubFlag_MSIL = (1 << 3), +}; + +typedef struct CV_SymPub32 CV_SymPub32; +struct CV_SymPub32 +{ CV_PubFlags flags; U32 off; CV_SectionIndex sec; // U8[] name (null terminated) -} CV_SymPub32; +}; -// (SymKind: LPROC32, GPROC32) -typedef struct CV_SymProc32{ +//- (SymKind: LPROC32, GPROC32) + +typedef struct CV_SymProc32 CV_SymProc32; +struct CV_SymProc32 +{ U32 parent; U32 end; U32 next; @@ -1567,25 +1317,32 @@ typedef struct CV_SymProc32{ U16 sec; CV_ProcFlags flags; // U8[] name (null terminated) -} CV_SymProc32; +}; -// (SymKind: REGREL32) -typedef struct CV_SymRegrel32{ +//- (SymKind: REGREL32) + +typedef struct CV_SymRegrel32 CV_SymRegrel32; +struct CV_SymRegrel32 +{ U32 reg_off; CV_TypeId itype; CV_Reg reg; // U8[] name (null terminated) -} CV_SymRegrel32; +}; -// (SymKind: LTHREAD32, GTHREAD32) -typedef struct CV_SymThread32{ +//- (SymKind: LTHREAD32, GTHREAD32) + +typedef struct CV_SymThread32 CV_SymThread32; +struct CV_SymThread32 +{ CV_TypeId itype; U32 tls_off; U16 tls_seg; // U8[] name (null terminated) -} CV_SymThread32; +}; + +//- (SymKind: COMPILE2) -// (SymKind: COMPILE2) typedef U32 CV_Compile2Flags; #define CV_Compile2Flags_ExtractLanguage(f) (((f) )&0xFF) #define CV_Compile2Flags_ExtractEditAndContinue(f) (((f)>> 8)&0x01) @@ -1598,7 +1355,9 @@ typedef U32 CV_Compile2Flags; #define CV_Compile2Flags_ExtractCVTCIL(f) (((f)>>15)&0x01) #define CV_Compile2Flags_ExtractMSILModule(f) (((f)>>16)&0x01) -typedef struct CV_SymCompile2{ +typedef struct CV_SymCompile2 CV_SymCompile2; +struct CV_SymCompile2 +{ CV_Compile2Flags flags; CV_Arch machine; U16 ver_fe_major; @@ -1608,58 +1367,80 @@ typedef struct CV_SymCompile2{ U16 ver_minor; U16 ver_build; // U8[] ver_str (null terminated) -} CV_SymCompile2; +}; -// (SymKind: MANYREG2) -typedef struct CV_SymManyreg2{ +//- (SymKind: MANYREG2) + +typedef struct CV_SymManyreg2 CV_SymManyreg2; +struct CV_SymManyreg2 +{ CV_TypeId itype; U16 count; // U16[count] regs; -} CV_SymManyreg2; +}; -// (SymKind: LOCALSLOT) -typedef struct CV_SymSlot{ +//- (SymKind: LOCALSLOT) + +typedef struct CV_SymSlot CV_SymSlot; +struct CV_SymSlot +{ U32 slot_index; CV_TypeId itype; // U8[] name (null terminated) -} CV_SymSlot; +}; -// (SymKind: MANFRAMEREL, ATTR_FRAMEREL) -typedef struct CV_SymAttrFrameRel{ +//- (SymKind: MANFRAMEREL, ATTR_FRAMEREL) + +typedef struct CV_SymAttrFrameRel CV_SymAttrFrameRel; +struct CV_SymAttrFrameRel +{ U32 off; CV_TypeId itype; CV_LocalVarAttr attr; // U8[] name (null terminated) -} CV_SymAttrFrameRel; +}; -// (SymKind: MANREGISTER, ATTR_REGISTER) -typedef struct CV_SymAttrReg{ +//- (SymKind: MANREGISTER, ATTR_REGISTER) + +typedef struct CV_SymAttrReg CV_SymAttrReg; +struct CV_SymAttrReg +{ CV_TypeId itype; CV_LocalVarAttr attr; U16 reg; // U8[] name (null terminated) -} CV_SymAttrReg; +}; -// (SymKind: MANMANYREG, ATTR_MANYREG) -typedef struct CV_SymAttrManyReg{ +//- (SymKind: MANMANYREG, ATTR_MANYREG) + + +typedef struct CV_SymAttrManyReg CV_SymAttrManyReg; +struct CV_SymAttrManyReg +{ CV_TypeId itype; CV_LocalVarAttr attr; U8 count; // U8[count] regs // U8[] name (null terminated) -} CV_SymAttrManyReg; +}; -// (SymKind: MANREGREL, ATTR_REGREL) -typedef struct CV_SymAttrRegRel{ +//- (SymKind: MANREGREL, ATTR_REGREL) + +typedef struct CV_SymAttrRegRel CV_SymAttrRegRel; +struct CV_SymAttrRegRel +{ U32 off; CV_TypeId itype; U16 reg; CV_LocalVarAttr attr; // U8[] name (null terminated) -} CV_SymAttrRegRel; +}; -// (SymKind: UNAMESPACE) -typedef struct CV_SymUNamespace{ +//- (SymKind: UNAMESPACE) + +typedef struct CV_SymUNamespace CV_SymUNamespace; +struct CV_SymUNamespace +{ // *** "dummy" is the first character of name - it should not be skipped! // *** It is placed here so the C compiler will accept this struct. // *** The actual fixed size part of this record has a size of zero. @@ -1667,40 +1448,52 @@ typedef struct CV_SymUNamespace{ U8 dummy; // U8[] name (null terminated) -} CV_SymUNamespace; +}; -// (SymKind: PROCREF, DATAREF, LPROCREF) -typedef struct CV_SymRef2{ +//- (SymKind: PROCREF, DATAREF, LPROCREF) + +typedef struct CV_SymRef2 CV_SymRef2; +struct CV_SymRef2 +{ U32 suc_name; U32 sym_off; CV_ModIndex imod; // U8[] name (null terminated) -} CV_SymRef2; +}; + +//- (SymKind: TRAMPOLINE) -// (SymKind: TRAMPOLINE) typedef U16 CV_TrampolineKind; -typedef enum{ +typedef enum CV_TrampolineKindEnum +{ CV_TrampolineKind_Incremental, CV_TrampolineKind_BranchIsland, -} CV_TrampolineKindEnum; +} +CV_TrampolineKindEnum; -typedef struct CV_SymTrampoline{ +typedef struct CV_SymTrampoline CV_SymTrampoline; +struct CV_SymTrampoline +{ CV_TrampolineKind kind; U16 thunk_size; U32 thunk_sec_off; U32 target_sec_off; CV_SectionIndex thunk_sec; CV_SectionIndex target_sec; -} CV_SymTrampoline; +}; + +//- (SymKind: SEPCODE) -// (SymKind: SEPCODE) typedef U32 CV_SepcodeFlags; -enum{ +enum +{ CV_SepcodeFlag_IsLexicalScope = (1 << 0), CV_SepcodeFlag_ReturnsToParent = (1 << 1), }; -typedef struct CV_SymSepcode{ +typedef struct CV_SymSepcode CV_SymSepcode; +struct CV_SymSepcode +{ U32 parent; U32 end; U32 len; @@ -1709,10 +1502,13 @@ typedef struct CV_SymSepcode{ U32 sec_parent_off; U16 sec; U16 sec_parent; -} CV_SymSepcode; +}; -// (SymKind: SECTION) -typedef struct CV_SymSection{ +//- (SymKind: SECTION) + +typedef struct CV_SymSection CV_SymSection; +struct CV_SymSection +{ U16 sec_index; U8 align; U8 pad; @@ -1720,20 +1516,25 @@ typedef struct CV_SymSection{ U32 size; U32 characteristics; // U8[] name (null terminated) -} CV_SymSection; +}; -// (SymKind: COFFGROUP) -typedef struct CV_SymCoffGroup{ +//- (SymKind: COFFGROUP) + +typedef struct CV_SymCoffGroup CV_SymCoffGroup; +struct CV_SymCoffGroup +{ U32 size; U32 characteristics; U32 off; U16 sec; // U8[] name (null terminated) -} CV_SymCoffGroup; +}; + +//- (SymKind: EXPORT) -// (SymKind: EXPORT) typedef U16 CV_ExportFlags; -enum{ +enum +{ CV_ExportFlag_Constant = (1 << 0), CV_ExportFlag_Data = (1 << 1), CV_ExportFlag_Private = (1 << 2), @@ -1742,52 +1543,68 @@ enum{ CV_ExportFlag_Forwarder = (1 << 5), }; -typedef struct CV_SymExport{ +typedef struct CV_SymExport CV_SymExport; +struct CV_SymExport +{ U16 ordinal; CV_ExportFlags flags; // U8[] name (null terminated) -} CV_SymExport; +}; -// (SymKind: CALLSITEINFO) -typedef struct CV_SymCallSiteInfo{ +//- (SymKind: CALLSITEINFO) + +typedef struct CV_SymCallSiteInfo CV_SymCallSiteInfo; +struct CV_SymCallSiteInfo +{ U32 off; U16 sec; U16 pad; CV_TypeId itype; -} CV_SymCallSiteInfo; +}; + +//- (SymKind: FRAMECOOKIE) -// (SymKind: FRAMECOOKIE) typedef U8 CV_FrameCookieKind; -typedef enum{ +typedef enum CV_FrameCookieKindEnum +{ CV_FrameCookieKind_Copy, CV_FrameCookieKind_XorSP, CV_FrameCookieKind_XorBP, CV_FrameCookieKind_XorR13, -} CV_FrameCookieKindEnum; +} +CV_FrameCookieKindEnum; -typedef struct CV_SymFrameCookie{ +typedef struct CV_SymFrameCookie CV_SymFrameCookie; +struct CV_SymFrameCookie +{ U32 off; CV_Reg reg; CV_FrameCookieKind kind; U8 flags; -} CV_SymFrameCookie; +}; + +//- (SymKind: DISCARDED) -// (SymKind: DISCARDED) typedef U8 CV_DiscardedKind; -typedef enum{ +typedef enum CV_DiscardedKindEnum +{ CV_DiscardedKind_Unknown, CV_DiscardedKind_NotSelected, CV_DiscardedKind_NotReferenced, -} CV_DiscardedKindEnum; +} +CV_DiscardedKindEnum; -typedef struct CV_SymDiscarded{ +typedef struct CV_SymDiscarded CV_SymDiscarded; +struct CV_SymDiscarded +{ CV_DiscardedKind kind; U32 file_id; U32 file_ln; // U8[] data (rest of data) -} CV_SymDiscarded; +}; + +//- (SymKind: COMPILE3) -// (SymKind: COMPILE3) typedef U32 CV_Compile3Flags; #define CV_Compile3Flags_ExtractLanguage(f) (((f) )&0xFF) #define CV_Compile3Flags_ExtractEditAndContinue(f) (((f)>> 9)&0x01) @@ -1803,7 +1620,9 @@ typedef U32 CV_Compile3Flags; #define CV_Compile3Flags_ExtractPGO(f) (((f)>>19)&0x01) #define CV_Compile3Flags_ExtractEXP(f) (((f)>>20)&0x01) -typedef struct CV_SymCompile3{ +typedef struct CV_SymCompile3 CV_SymCompile3; +struct CV_SymCompile3 +{ CV_Compile3Flags flags; CV_Arch machine; U16 ver_fe_major; @@ -1815,117 +1634,158 @@ typedef struct CV_SymCompile3{ U16 ver_build; U16 ver_qfe; // U8[] ver_str (null terminated) -} CV_SymCompile3; +}; -// (SymKind: ENVBLOCK) -typedef struct CV_SymEnvBlock{ +//- (SymKind: ENVBLOCK) + +typedef struct CV_SymEnvBlock CV_SymEnvBlock; +struct CV_SymEnvBlock +{ U8 flags; // U8[][] rgsz (sequence null terminated strings) -} CV_SymEnvBlock; +}; -// (SymKind: LOCAL) -typedef struct CV_SymLocal{ +//- (SymKind: LOCAL) + +typedef struct CV_SymLocal CV_SymLocal; +struct CV_SymLocal +{ CV_TypeId itype; CV_LocalFlags flags; // U8[] name (null terminated) -} CV_SymLocal; +}; //- DEFRANGE -typedef struct CV_LvarAddrRange{ +typedef struct CV_LvarAddrRange CV_LvarAddrRange; +struct CV_LvarAddrRange +{ U32 off; U16 sec; U16 len; -} CV_LvarAddrRange; +}; -typedef struct CV_LvarAddrGap{ +typedef struct CV_LvarAddrGap CV_LvarAddrGap; +struct CV_LvarAddrGap +{ U16 off; U16 len; -} CV_LvarAddrGap; +}; typedef U16 CV_RangeAttribs; -enum{ +enum +{ CV_RangeAttrib_Maybe = (1 << 0), }; -// (SymKind: DEFRANGE_SUBFIELD) -typedef struct CV_SymDefrangeSubfield{ +//- (SymKind: DEFRANGE_SUBFIELD) + +typedef struct CV_SymDefrangeSubfield CV_SymDefrangeSubfield; +struct CV_SymDefrangeSubfield +{ U32 program; U32 off_in_parent; CV_LvarAddrRange range; // CV_LvarAddrGap[] gaps (rest of data) -} CV_SymDefrangeSubfield; +}; -// (SymKind: DEFRANGE_REGISTER) -typedef struct CV_SymDefrangeRegister{ +//- (SymKind: DEFRANGE_REGISTER) + +typedef struct CV_SymDefrangeRegister CV_SymDefrangeRegister; +struct CV_SymDefrangeRegister +{ CV_Reg reg; CV_RangeAttribs attribs; CV_LvarAddrRange range; // CV_LvarAddrGap[] gaps (rest of data) -} CV_SymDefrangeRegister; +}; -// (SymKind: DEFRANGE_FRAMEPOINTER_REL) -typedef struct CV_SymDefrangeFramepointerRel{ +//- (SymKind: DEFRANGE_FRAMEPOINTER_REL) + +typedef struct CV_SymDefrangeFramepointerRel CV_SymDefrangeFramepointerRel; +struct CV_SymDefrangeFramepointerRel +{ S32 off; CV_LvarAddrRange range; // CV_LvarAddrGap[] gaps (rest of data) -} CV_SymDefrangeFramepointerRel; +}; -// (SymKind: DEFRANGE_SUBFIELD_REGISTER) -typedef struct CV_SymDefrangeSubfieldRegister{ +//- (SymKind: DEFRANGE_SUBFIELD_REGISTER) + +typedef struct CV_SymDefrangeSubfieldRegister CV_SymDefrangeSubfieldRegister; +struct CV_SymDefrangeSubfieldRegister +{ CV_Reg reg; CV_RangeAttribs attribs; U32 field_offset; CV_LvarAddrRange range; // CV_LvarAddrGap[] gaps (rest of data) -} CV_SymDefrangeSubfieldRegister; +}; -// (SymKind: DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE) -typedef struct CV_SymDefrangeFramepointerRelFullScope{ +//- (SymKind: DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE) + +typedef struct CV_SymDefrangeFramepointerRelFullScope CV_SymDefrangeFramepointerRelFullScope; +struct CV_SymDefrangeFramepointerRelFullScope +{ S32 off; -} CV_SymDefrangeFramepointerRelFullScope; +}; + +//- (SymKind: DEFRANGE_REGISTER_REL) -// (SymKind: DEFRANGE_REGISTER_REL) typedef U16 CV_DefrangeRegisterRelFlags; -enum{ +enum +{ CV_DefrangeRegisterRelFlag_SpilledOutUDTMember = (1 << 0), }; #define CV_DefrangeRegisterRelFlag_ExtractOffsetParent(f) (((f)>>4)&0xFFF) -typedef struct CV_SymDefrangeRegisterRel{ +typedef struct CV_SymDefrangeRegisterRel CV_SymDefrangeRegisterRel; +struct CV_SymDefrangeRegisterRel +{ CV_Reg reg; CV_DefrangeRegisterRelFlags flags; S32 reg_off; CV_LvarAddrRange range; // CV_LvarAddGap[] gaps (rest of data) -} CV_SymDefrangeRegisterRel; +}; -// (SymKind: BUILDINFO) -typedef struct CV_SymBuildInfo{ +//- (SymKind: BUILDINFO) + +typedef struct CV_SymBuildInfo CV_SymBuildInfo; +struct CV_SymBuildInfo +{ CV_ItemId id; -} CV_SymBuildInfo; +}; -// (SymKind: INLINESITE) -typedef struct CV_SymInlineSite{ +//- (SymKind: INLINESITE) + +typedef struct CV_SymInlineSite CV_SymInlineSite; +struct CV_SymInlineSite +{ U32 parent; U32 end; CV_ItemId inlinee; // CV_BinaryAnnotation annotations (rest of data) -} CV_SymInlineSite; +}; -// (SymKind: INLINESITE_END) (empty) +//- (SymKind: INLINESITE_END) (empty) -// (SymKind: FILESTATIC) -typedef struct CV_SymFileStatic{ +//- (SymKind: FILESTATIC) + +typedef struct CV_SymFileStatic CV_SymFileStatic; +struct CV_SymFileStatic +{ CV_TypeId itype; U32 mod_offset; CV_LocalFlags flags; // U8[] name (null terminated) -} CV_SymFileStatic; +}; + +//- (SymKind: ARMSWITCHTABLE) -// (SymKind: ARMSWITCHTABLE) typedef U16 CV_ArmSwitchKind; -typedef enum{ +typedef enum +{ CV_ArmSwitchKind_INT1, CV_ArmSwitchKind_UINT1, CV_ArmSwitchKind_INT2, @@ -1939,7 +1799,9 @@ typedef enum{ CV_ArmSwitchKind_INT2SSHL1, } CV_ArmSwitchKindEnum; -typedef struct CV_SymArmSwitchTable{ +typedef struct CV_SymArmSwitchTable CV_SymArmSwitchTable; +struct CV_SymArmSwitchTable +{ U32 off_base; U16 sec_base; CV_ArmSwitchKind kind; @@ -1948,43 +1810,57 @@ typedef struct CV_SymArmSwitchTable{ U16 sec_branch; U16 sec_table; U32 entry_count; -} CV_SymArmSwitchTable; +}; -// (SymKind: CALLEES, CALLERS) -typedef struct CV_SymFunctionList{ +//- (SymKind: CALLEES, CALLERS) + +typedef struct CV_SymFunctionList CV_SymFunctionList; +struct CV_SymFunctionList +{ U32 count; // CV_TypeId[count] funcs // U32[clamp(count, rest_of_data/4)] invocations -} CV_SymFunctionList; +}; -// (SymKind: POGODATA) -typedef struct CV_SymPogoInfo{ +//- (SymKind: POGODATA) + +typedef struct CV_SymPogoInfo CV_SymPogoInfo; +struct CV_SymPogoInfo +{ U32 invocations; U64 dynamic_inst_count; U32 static_inst_count; U32 post_inline_static_inst_count; -} CV_SymPogoInfo; +}; -// (SymKind: INLINESITE2) -typedef struct CV_SymInlineSite2{ +//- (SymKind: INLINESITE2) + +typedef struct CV_SymInlineSite2 CV_SymInlineSite2; +struct CV_SymInlineSite2 +{ U32 parent_off; U32 end_off; CV_ItemId inlinee; U32 invocations; // CV_BinaryAnnotation annotations (rest of data) -} CV_SymInlineSite2; +}; -// (SymKind: HEAPALLOCSITE) -typedef struct CV_SymHeapAllocSite{ +//- (SymKind: HEAPALLOCSITE) + +typedef struct CV_SymHeapAllocSite CV_SymHeapAllocSite; +struct CV_SymHeapAllocSite +{ U32 off; U16 sec; U16 call_inst_len; CV_TypeId itype; -} CV_SymHeapAllocSite; +}; + +//- (SymKind: MOD_TYPEREF) -// (SymKind: MOD_TYPEREF) typedef U32 CV_ModTypeRefFlags; -enum{ +enum +{ CV_ModTypeRefFlag_None = (1 << 0), CV_ModTypeRefFlag_RefTMPCT = (1 << 1), CV_ModTypeRefFlag_OwnTMPCT = (1 << 2), @@ -1993,16 +1869,20 @@ enum{ CV_ModTypeRefFlag_RefTM = (1 << 5), }; -typedef struct CV_SymModTypeRef{ +typedef struct CV_SymModTypeRef CV_SymModTypeRef; +struct CV_SymModTypeRef +{ CV_ModTypeRefFlags flags; // contain stream number or module index depending on flags (undocumented) U32 word0; U32 word1; -} CV_SymModTypeRef; +}; + +//- (SymKind: REF_MINIPDB) -// (SymKind: REF_MINIPDB) typedef U16 CV_RefMiniPdbFlags; -enum{ +enum +{ CV_RefMiniPdbFlag_Local = (1 << 0), CV_RefMiniPdbFlag_Data = (1 << 1), CV_RefMiniPdbFlag_UDT = (1 << 2), @@ -2010,16 +1890,20 @@ enum{ CV_RefMiniPdbFlag_Const = (1 << 4), }; -typedef struct CV_SymRefMiniPdb{ +typedef struct CV_SymRefMiniPdb CV_SymRefMiniPdb; +struct CV_SymRefMiniPdb +{ U32 data; CV_ModIndex imod; CV_RefMiniPdbFlags flags; // U8[] name (null terminated) -} CV_SymRefMiniPdb; +}; + +//- (SymKind: FASTLINK) -// (SymKind: FASTLINK) typedef U16 CV_FastLinkFlags; -enum{ +enum +{ CV_FastLinkFlag_IsGlobalData = (1 << 0), CV_FastLinkFlag_IsData = (1 << 1), CV_FastLinkFlag_IsUDT = (1 << 2), @@ -2029,159 +1913,27 @@ enum{ CV_FastLinkFlag_IsNamespace = (1 << 6), }; -typedef struct CV_SymFastLink{ +typedef struct CV_SymFastLink CV_SymFastLink; +struct CV_SymFastLink +{ CV_TypeId itype; CV_FastLinkFlags flags; // U8[] name (null terminated) -} CV_SymFastLink; +}; -// (SymKind: INLINEES) -typedef struct CV_SymInlinees{ +//- (SymKind: INLINEES) + +typedef struct CV_SymInlinees CV_SymInlinees; +struct CV_SymInlinees +{ U32 count; // U32[count] desc; -} CV_SymInlinees; - +}; //////////////////////////////// //~ CodeView Format "Leaf" Types // (type info) -#define CV_LeafKindXList(X) \ -X(MODIFIER_16t, 0x0001)\ -X(POINTER_16t, 0x0002)\ -X(ARRAY_16t, 0x0003)\ -X(CLASS_16t, 0x0004)\ -X(STRUCTURE_16t, 0x0005)\ -X(UNION_16t, 0x0006)\ -X(ENUM_16t, 0x0007)\ -X(PROCEDURE_16t, 0x0008)\ -X(MFUNCTION_16t, 0x0009)\ -X(VTSHAPE, 0x000a)\ -X(COBOL0_16t, 0x000b)\ -X(COBOL1, 0x000c)\ -X(BARRAY_16t, 0x000d)\ -X(LABEL, 0x000e)\ -X(NULL, 0x000f)\ -X(NOTTRAN, 0x0010)\ -X(DIMARRAY_16t, 0x0011)\ -X(VFTPATH_16t, 0x0012)\ -X(PRECOMP_16t, 0x0013)\ -X(ENDPRECOMP, 0x0014)\ -X(OEM_16t, 0x0015)\ -X(TYPESERVER_ST, 0x0016)\ -X(SKIP_16t, 0x0200)\ -X(ARGLIST_16t, 0x0201)\ -X(DEFARG_16t, 0x0202)\ -X(LIST, 0x0203)\ -X(FIELDLIST_16t, 0x0204)\ -X(DERIVED_16t, 0x0205)\ -X(BITFIELD_16t, 0x0206)\ -X(METHODLIST_16t, 0x0207)\ -X(DIMCONU_16t, 0x0208)\ -X(DIMCONLU_16t, 0x0209)\ -X(DIMVARU_16t, 0x020a)\ -X(DIMVARLU_16t, 0x020b)\ -X(REFSYM, 0x020c)\ -X(BCLASS_16t, 0x0400)\ -X(VBCLASS_16t, 0x0401)\ -X(IVBCLASS_16t, 0x0402)\ -X(ENUMERATE_ST, 0x0403)\ -X(FRIENDFCN_16t, 0x0404)\ -X(INDEX_16t, 0x0405)\ -X(MEMBER_16t, 0x0406)\ -X(STMEMBER_16t, 0x0407)\ -X(METHOD_16t, 0x0408)\ -X(NESTTYPE_16t, 0x0409)\ -X(VFUNCTAB_16t, 0x040a)\ -X(FRIENDCLS_16t, 0x040b)\ -X(ONEMETHOD_16t, 0x040c)\ -X(VFUNCOFF_16t, 0x040d)\ -X(TI16_MAX, 0x1000)\ -X(MODIFIER, 0x1001)\ -X(POINTER, 0x1002)\ -X(ARRAY_ST, 0x1003)\ -X(CLASS_ST, 0x1004)\ -X(STRUCTURE_ST, 0x1005)\ -X(UNION_ST, 0x1006)\ -X(ENUM_ST, 0x1007)\ -X(PROCEDURE, 0x1008)\ -X(MFUNCTION, 0x1009)\ -X(COBOL0, 0x100a)\ -X(BARRAY, 0x100b)\ -X(DIMARRAY_ST, 0x100c)\ -X(VFTPATH, 0x100d)\ -X(PRECOMP_ST, 0x100e)\ -X(OEM, 0x100f)\ -X(ALIAS_ST, 0x1010)\ -X(OEM2, 0x1011)\ -X(SKIP, 0x1200)\ -X(ARGLIST, 0x1201)\ -X(DEFARG_ST, 0x1202)\ -X(FIELDLIST, 0x1203)\ -X(DERIVED, 0x1204)\ -X(BITFIELD, 0x1205)\ -X(METHODLIST, 0x1206)\ -X(DIMCONU, 0x1207)\ -X(DIMCONLU, 0x1208)\ -X(DIMVARU, 0x1209)\ -X(DIMVARLU, 0x120a)\ -X(BCLASS, 0x1400)\ -X(VBCLASS, 0x1401)\ -X(IVBCLASS, 0x1402)\ -X(FRIENDFCN_ST, 0x1403)\ -X(INDEX, 0x1404)\ -X(MEMBER_ST, 0x1405)\ -X(STMEMBER_ST, 0x1406)\ -X(METHOD_ST, 0x1407)\ -X(NESTTYPE_ST, 0x1408)\ -X(VFUNCTAB, 0x1409)\ -X(FRIENDCLS, 0x140a)\ -X(ONEMETHOD_ST, 0x140b)\ -X(VFUNCOFF, 0x140c)\ -X(NESTTYPEEX_ST, 0x140d)\ -X(MEMBERMODIFY_ST, 0x140e)\ -X(MANAGED_ST, 0x140f)\ -X(ST_MAX, 0x1500)\ -X(TYPESERVER, 0x1501)\ -X(ENUMERATE, 0x1502)\ -X(ARRAY, 0x1503)\ -X(CLASS, 0x1504)\ -X(STRUCTURE, 0x1505)\ -X(UNION, 0x1506)\ -X(ENUM, 0x1507)\ -X(DIMARRAY, 0x1508)\ -X(PRECOMP, 0x1509)\ -X(ALIAS, 0x150a)\ -X(DEFARG, 0x150b)\ -X(FRIENDFCN, 0x150c)\ -X(MEMBER, 0x150d)\ -X(STMEMBER, 0x150e)\ -X(METHOD, 0x150f)\ -X(NESTTYPE, 0x1510)\ -X(ONEMETHOD, 0x1511)\ -X(NESTTYPEEX, 0x1512)\ -X(MEMBERMODIFY, 0x1513)\ -X(MANAGED, 0x1514)\ -X(TYPESERVER2, 0x1515)\ -X(STRIDED_ARRAY, 0x1516)\ -X(HLSL, 0x1517)\ -X(MODIFIER_EX, 0x1518)\ -X(INTERFACE, 0x1519)\ -X(BINTERFACE, 0x151a)\ -X(VECTOR, 0x151b)\ -X(MATRIX, 0x151c)\ -X(VFTABLE, 0x151d)\ -/* ONGOING REVERSE ENGINEERING */ \ -X(CLASS2, 0x1608)\ -X(STRUCT2, 0x1609) - -typedef U16 CV_LeafKind; -typedef enum{ -#define X(N,c) CV_LeafKind_##N = c, - CV_LeafKindXList(X) -#undef X -} CV_LeafKindEnum; - #define CV_LeafIDKindXList(X) \ X(FUNC_ID, 0x1601)\ X(MFUNC_ID, 0x1602)\ @@ -2192,11 +1944,13 @@ X(UDT_SRC_LINE, 0x1606)\ X(UDT_MOD_SRC_LINE, 0x1607) typedef U16 CV_LeafIDKind; -typedef enum{ +typedef enum CV_LeafIDKindEnum +{ #define X(N,c) CV_LeafIDKind_##N = c, CV_LeafIDKindXList(X) #undef X -} CV_LeafIDKindEnum; +} +CV_LeafIDKindEnum; #define CV_BasicTypeXList(X) \ X(NOTYPE, 0x00)\ @@ -2254,11 +2008,13 @@ X(CHAR8, 0x7c)\ X(PTR, 0xf0) typedef U8 CV_BasicType; -typedef enum{ +typedef enum CV_BasicTypeEnum +{ #define X(N,c) CV_BasicType_##N = c, CV_BasicTypeXList(X) #undef X -} CV_BasicTypeEnum; +} +CV_BasicTypeEnum; #define CV_TypeId_Variadic 0 @@ -2272,7 +2028,8 @@ X(16_32BIT, 0x5)\ X(64BIT, 0x6) typedef U8 CV_BasicPointerKind; -typedef enum{ +typedef enum +{ #define X(N,c) CV_BasicPointerKind_##N = c, CV_BasicPointerKindXList(X) #undef X @@ -2282,23 +2039,28 @@ typedef enum{ #define CV_BasicPointerKindFromTypeId(x) (((x)>>8)&0xFF) typedef U8 CV_HFAKind; -typedef enum{ +typedef enum CV_HFAKindEnum +{ CV_HFAKind_None, CV_HFAKind_Float, CV_HFAKind_Double, CV_HFAKind_Other -} CV_HFAKindEnum; +} +CV_HFAKindEnum; typedef U8 CV_MoComUDTKind; -typedef enum{ +typedef enum CV_MoComUDTKindEnum +{ CV_MoComUDTKind_None, CV_MoComUDTKind_Ref, CV_MoComUDTKind_Value, CV_MoComUDTKind_Interface -} CV_MoComUDTKindEnum; +} +CV_MoComUDTKindEnum; typedef U16 CV_TypeProps; -enum{ +enum +{ CV_TypeProp_Packed = (1 << 0), CV_TypeProp_HasConstructorsDestructors = (1 << 1), CV_TypeProp_OverloadedOperators = (1 << 2), @@ -2319,7 +2081,8 @@ enum{ #define CV_TypeProps_ExtractMOCOM(f) (((f)>>14)&0x3) typedef U8 CV_PointerKind; -typedef enum{ +typedef enum CV_PointerKindEnum +{ CV_PointerKind_Near, // 16 bit CV_PointerKind_Far, // 16:16 bit CV_PointerKind_Huge, // 16:16 bit @@ -2333,19 +2096,23 @@ typedef enum{ CV_PointerKind_Near32, // 32 bit CV_PointerKind_Far32, // 16:32 bit CV_PointerKind_64, // 64 bit -} CV_PointerKindEnum; +} +CV_PointerKindEnum; typedef U8 CV_PointerMode; -typedef enum{ +typedef enum CV_PointerModeEnum +{ CV_PointerMode_Ptr, CV_PointerMode_LRef, CV_PointerMode_PtrMem, CV_PointerMode_PtrMethod, CV_PointerMode_RRef, -} CV_PointerModeEnum; +} +CV_PointerModeEnum; typedef U16 CV_MemberPointerKind; -typedef enum{ +typedef enum CV_MemberPointerKindEnum +{ CV_MemberPointerKind_Undef, CV_MemberPointerKind_DataSingle, CV_MemberPointerKind_DataMultiple, @@ -2355,10 +2122,12 @@ typedef enum{ CV_MemberPointerKind_FuncMultiple, CV_MemberPointerKind_FuncVirtual, CV_MemberPointerKind_FuncGeneral, -} CV_MemberPointerKindEnum; +} +CV_MemberPointerKindEnum; typedef U32 CV_VirtualTableShape; -typedef enum{ +typedef enum CV_VirtualTableShapeEnum +{ CV_VirtualTableShape_Near, // 16 bit ptr CV_VirtualTableShape_Far, // 16:16 bit ptr CV_VirtualTableShape_Thin, // ??? @@ -2366,10 +2135,12 @@ typedef enum{ CV_VirtualTableShape_Meta, // far pointer to metaclass descriptor entry[-2] CV_VirtualTableShape_Near32, // 32 bit ptr CV_VirtualTableShape_Far32, // ??? -} CV_VirtualTableShapeEnum; +} +CV_VirtualTableShapeEnum; typedef U8 CV_MethodProp; -enum{ +enum +{ CV_MethodProp_Vanilla, CV_MethodProp_Virtual, CV_MethodProp_Static, @@ -2380,15 +2151,18 @@ enum{ }; typedef U8 CV_MemberAccess; -typedef enum{ +typedef enum CV_MemberAccessEnum +{ CV_MemberAccess_Null, CV_MemberAccess_Private, CV_MemberAccess_Protected, CV_MemberAccess_Public -} CV_MemberAccessEnum; +} +CV_MemberAccessEnum; typedef U16 CV_FieldAttribs; -enum{ +enum +{ // Access: 0,1 // MethodProp: [2:4] CV_FieldAttrib_Pseudo = (1 << 5), @@ -2401,20 +2175,24 @@ enum{ #define CV_FieldAttribs_ExtractMethodProp(f) (((f)>>2)&0x7) typedef U16 CV_LabelKind; -typedef enum{ +typedef enum CV_LabelKindEnum +{ CV_LabelKind_Near = 0, CV_LabelKind_Far = 4, -} CV_LabelKindEnum; +} +CV_LabelKindEnum; typedef U8 CV_FunctionAttribs; -enum{ +enum +{ CV_FunctionAttrib_CxxReturnUDT = (1 << 0), CV_FunctionAttrib_Constructor = (1 << 1), CV_FunctionAttrib_ConstructorVBase = (1 << 2), }; typedef U8 CV_CallKind; -typedef enum{ +typedef enum CV_CallKindEnum +{ CV_CallKind_NearC, CV_CallKind_FarC, CV_CallKind_NearPascal, @@ -2440,62 +2218,87 @@ typedef enum{ CV_CallKind_Clr, CV_CallKind_Inline, CV_CallKind_NearVector, -} CV_CallKindEnum; +} +CV_CallKindEnum; -// (LeafKind: PRECOMP) -typedef struct CV_LeafPreComp{ +//- (LeafKind: PRECOMP) + +typedef struct CV_LeafPreComp CV_LeafPreComp; +struct CV_LeafPreComp +{ U32 start_index; U32 count; U32 signature; // U8[] name (null terminated) -} CV_LeafPreComp; +}; -// (LeafKind: TYPESERVER) -typedef struct CV_LeafTypeServer{ +//- (LeafKind: TYPESERVER) + +typedef struct CV_LeafTypeServer CV_LeafTypeServer; +struct CV_LeafTypeServer +{ U32 sig; U32 age; // U8[] name (null terminated) -} CV_LeafTypeServer; +}; -// (LeafKind: TYPESERVER2) -typedef struct CV_LeafTypeServer2{ +//- (LeafKind: TYPESERVER2) + +typedef struct CV_LeafTypeServer2 CV_LeafTypeServer2; +struct CV_LeafTypeServer2 +{ COFF_Guid sig70; U32 age; // U8[] name (null terminated) -} CV_LeafTypeServer2; +}; -// (LeafKind: SKIP) -typedef struct CV_LeafSkip{ +//- (LeafKind: SKIP) + +typedef struct CV_LeafSkip CV_LeafSkip; +struct CV_LeafSkip +{ CV_TypeId itype; -} CV_LeafSkip; +}; -// (LeafKind: VTSHAPE) -typedef struct CV_LeafVTShape{ +//- (LeafKind: VTSHAPE) + +typedef struct CV_LeafVTShape CV_LeafVTShape; +struct CV_LeafVTShape +{ U16 count; // U4[count] shapes (CV_VirtualTableShape) -} CV_LeafVTShape; +}; -// (LeafKind: LABEL) -typedef struct CV_LeafLabel{ +//- (LeafKind: LABEL) + +typedef struct CV_LeafLabel CV_LeafLabel; +struct CV_LeafLabel +{ CV_LabelKind kind; -} CV_LeafLabel; +}; + +//- (LeafKind: MODIFIER) -// (LeafKind: MODIFIER) typedef U16 CV_ModifierFlags; -enum{ +enum +{ CV_ModifierFlag_Const = (1 << 0), CV_ModifierFlag_Volatile = (1 << 1), CV_ModifierFlag_Unaligned = (1 << 2), }; -typedef struct CV_LeafModifier{ +typedef struct CV_LeafModifier CV_LeafModifier; +struct CV_LeafModifier +{ CV_TypeId itype; CV_ModifierFlags flags; -} CV_LeafModifier; +}; + +//- (LeafKind: POINTER) -// (LeafKind: POINTER) typedef U32 CV_PointerAttribs; -enum{ +enum +{ // Kind: [0:4] // Mode: [5:7] CV_PointerAttrib_IsFlat = (1 << 8), @@ -2513,22 +2316,30 @@ enum{ #define CV_PointerAttribs_ExtractMode(a) (((a)>>5)&0x7) #define CV_PointerAttribs_ExtractSize(a) (((a)>>13)&0x3F) -typedef struct CV_LeafPointer{ +typedef struct CV_LeafPointer CV_LeafPointer; +struct CV_LeafPointer +{ CV_TypeId itype; CV_PointerAttribs attribs; -} CV_LeafPointer; +}; -// (LeafKind: PROCEDURE) -typedef struct CV_LeafProcedure{ +//- (LeafKind: PROCEDURE) + +typedef struct CV_LeafProcedure CV_LeafProcedure; +struct CV_LeafProcedure +{ CV_TypeId ret_itype; CV_CallKind call_kind; CV_FunctionAttribs attribs; U16 arg_count; CV_TypeId arg_itype; -} CV_LeafProcedure; +}; -// (LeafKind: MFUNCTION) -typedef struct CV_LeafMFunction{ +//- (LeafKind: MFUNCTION) + +typedef struct CV_LeafMFunction CV_LeafMFunction; +struct CV_LeafMFunction +{ CV_TypeId ret_itype; CV_TypeId class_itype; CV_TypeId this_itype; @@ -2537,45 +2348,63 @@ typedef struct CV_LeafMFunction{ U16 arg_count; CV_TypeId arg_itype; S32 this_adjust; -} CV_LeafMFunction; +}; -// (LeafKind: ARGLIST) -typedef struct CV_LeafArgList{ +//- (LeafKind: ARGLIST) + +typedef struct CV_LeafArgList CV_LeafArgList; +struct CV_LeafArgList +{ U32 count; // CV_TypeId[count] itypes; -} CV_LeafArgList; +}; -// (LeafKind: BITFIELD) -typedef struct CV_LeafBitField{ +//- (LeafKind: BITFIELD) + +typedef struct CV_LeafBitField CV_LeafBitField; +struct CV_LeafBitField +{ CV_TypeId itype; U8 len; U8 pos; -} CV_LeafBitField; +}; + +//- (LeafKind: METHODLIST) -// (LeafKind: METHODLIST) // ("jagged" array of these vvvvvvvv) -typedef struct CV_LeafMethodListMember{ +typedef struct CV_LeafMethodListMember CV_LeafMethodListMember; +struct CV_LeafMethodListMember +{ CV_FieldAttribs attribs; U16 pad; CV_TypeId itype; // U32 vbaseoff (when Intro or PureIntro) -} CV_LeafMethodListMember; +}; -// (LeafKind: INDEX) -typedef struct CV_LeafIndex{ +//- (LeafKind: INDEX) + +typedef struct CV_LeafIndex CV_LeafIndex; +struct CV_LeafIndex +{ U16 pad; CV_TypeId itype; -} CV_LeafIndex; +}; -// (LeafKind: ARRAY) -typedef struct CV_LeafArray{ +//- (LeafKind: ARRAY) + +typedef struct CV_LeafArray CV_LeafArray; +struct CV_LeafArray +{ CV_TypeId entry_itype; CV_TypeId index_itype; // CV_Numeric count -} CV_LeafArray; +}; -// (LeafKind: CLASS, STRUCTURE, INTERFACE) -typedef struct CV_LeafStruct{ +//- (LeafKind: CLASS, STRUCTURE, INTERFACE) + +typedef struct CV_LeafStruct CV_LeafStruct; +struct CV_LeafStruct +{ U16 count; CV_TypeProps props; CV_TypeId field_itype; @@ -2584,131 +2413,182 @@ typedef struct CV_LeafStruct{ // CV_Numeric size // U8[] name (null terminated) // U8[] unique_name (null terminated) -} CV_LeafStruct; +}; -// (LeafKind: UNION) -typedef struct CV_LeafUnion{ +//- (LeafKind: UNION) + +typedef struct CV_LeafUnion CV_LeafUnion; +struct CV_LeafUnion +{ U16 count; CV_TypeProps props; CV_TypeId field_itype; // CV_Numeric size // U8[] name (null terminated) // U8[] unique_name (null terminated) -} CV_LeafUnion; +}; -// (LeafKind: ENUM) -typedef struct CV_LeafEnum{ +//- (LeafKind: ENUM) + +typedef struct CV_LeafEnum CV_LeafEnum; +struct CV_LeafEnum +{ U16 count; CV_TypeProps props; CV_TypeId base_itype; CV_TypeId field_itype; // U8[] name (null terminated) // U8[] unique_name (null terminated) -} CV_LeafEnum; +}; -// (LeafKind: ALIAS) -typedef struct CV_LeafAlias{ +//- (LeafKind: ALIAS) + +typedef struct CV_LeafAlias CV_LeafAlias; +struct CV_LeafAlias +{ CV_TypeId itype; // U8[] name (null terminated) -} CV_LeafAlias; +}; -// (LeafKind: MEMBER) -typedef struct CV_LeafMember{ +//- (LeafKind: MEMBER) + +typedef struct CV_LeafMember CV_LeafMember; +struct CV_LeafMember +{ CV_FieldAttribs attribs; CV_TypeId itype; // CV_Numeric offset // U8[] name (null terminated) -} CV_LeafMember; +}; -// (LeafKind: STMEMBER) -typedef struct CV_LeafStMember{ +//- (LeafKind: STMEMBER) + +typedef struct CV_LeafStMember CV_LeafStMember; +struct CV_LeafStMember +{ CV_FieldAttribs attribs; CV_TypeId itype; // U8[] name (null terminated) -} CV_LeafStMember; +}; -// (LeafKind: METHOD) -typedef struct CV_LeafMethod{ +//- (LeafKind: METHOD) + +typedef struct CV_LeafMethod CV_LeafMethod; +struct CV_LeafMethod +{ U16 count; CV_TypeId list_itype; // U8[] name (null terminated) -} CV_LeafMethod; +}; -// (LeafKind: ONEMETHOD) -typedef struct CV_LeafOneMethod{ +//- (LeafKind: ONEMETHOD) + +typedef struct CV_LeafOneMethod CV_LeafOneMethod; +struct CV_LeafOneMethod +{ CV_FieldAttribs attribs; CV_TypeId itype; // U32 vbaseoff (when Intro or PureIntro) // U8[] name (null terminated) -} CV_LeafOneMethod; +}; -// (LeafKind: ENUMERATE) -typedef struct CV_LeafEnumerate{ +//- (LeafKind: ENUMERATE) + +typedef struct CV_LeafEnumerate CV_LeafEnumerate; +struct CV_LeafEnumerate +{ CV_FieldAttribs attribs; // CV_Numeric val // U8[] name (null terminated) -} CV_LeafEnumerate; +}; -// (LeafKind: NESTTYPE) -typedef struct CV_LeafNestType{ +//- (LeafKind: NESTTYPE) + +typedef struct CV_LeafNestType CV_LeafNestType; +struct CV_LeafNestType +{ U16 pad; CV_TypeId itype; // U8[] name (null terminated) -} CV_LeafNestType; +}; -// (LeafKind: NESTTYPEEX) -typedef struct CV_LeafNestTypeEx{ +//- (LeafKind: NESTTYPEEX) + +typedef struct CV_LeafNestTypeEx CV_LeafNestTypeEx; +struct CV_LeafNestTypeEx +{ CV_FieldAttribs attribs; CV_TypeId itype; // U8[] name (null terminated) -} CV_LeafNestTypeEx; +}; -// (LeafKind: BCLASS) -typedef struct CV_LeafBClass{ +//- (LeafKind: BCLASS) + +typedef struct CV_LeafBClass CV_LeafBClass; +struct CV_LeafBClass +{ CV_FieldAttribs attribs; CV_TypeId itype; // CV_Numeric offset -} CV_LeafBClass; +}; -// (LeafKind: VBCLASS, IVBCLASS) -typedef struct CV_LeafVBClass{ +//- (LeafKind: VBCLASS, IVBCLASS) + +typedef struct CV_LeafVBClass CV_LeafVBClass; +struct CV_LeafVBClass +{ CV_FieldAttribs attribs; CV_TypeId itype; CV_TypeId vbptr_itype; // CV_Numeric vbptr_off // CV_Numeric vtable_off -} CV_LeafVBClass; +}; -// (LeafKind: VFUNCTAB) -typedef struct CV_LeafVFuncTab{ +//- (LeafKind: VFUNCTAB) + +typedef struct CV_LeafVFuncTab CV_LeafVFuncTab; +struct CV_LeafVFuncTab +{ U16 pad; CV_TypeId itype; -} CV_LeafVFuncTab; +}; -// (LeafKind: VFUNCOFF) -typedef struct CV_LeafVFuncOff{ +//- (LeafKind: VFUNCOFF) + +typedef struct CV_LeafVFuncOff CV_LeafVFuncOff; +struct CV_LeafVFuncOff +{ U16 pad; CV_TypeId itype; U32 off; -} CV_LeafVFuncOff; +}; -// (LeafKind: VFTABLE) -typedef struct CV_LeafVFTable{ +//- (LeafKind: VFTABLE) + +typedef struct CV_LeafVFTable CV_LeafVFTable; +struct CV_LeafVFTable +{ CV_TypeId owner_itype; CV_TypeId base_table_itype; U32 offset_in_object_layout; U32 names_len; // U8[] names (multiple null terminated strings) -} CV_LeafVFTable; +}; -// (LeafKind: VFTPATH) -typedef struct CV_LeafVFPath{ +//- (LeafKind: VFTPATH) + +typedef struct CV_LeafVFPath CV_LeafVFPath; +struct CV_LeafVFPath +{ U32 count; // CV_TypeId[count] base; -} CV_LeafVFPath; +}; -// (LeafKind: CLASS2, STRUCT2) -typedef struct CV_LeafStruct2{ +//- (LeafKind: CLASS2, STRUCT2) + +typedef struct CV_LeafStruct2 CV_LeafStruct2; +struct CV_LeafStruct2 +{ // NOTE: still reverse engineering this - if you find docs please help! CV_TypeProps props; U16 unknown1; @@ -2719,63 +2599,85 @@ typedef struct CV_LeafStruct2{ // CV_Numeric size // U8[] name (null terminated) // U8[] unique_name (null terminated) -} CV_LeafStruct2; +}; -// (LeafIDKind: FUNC_ID) -typedef struct CV_LeafFuncId{ +//- (LeafIDKind: FUNC_ID) + +typedef struct CV_LeafFuncId CV_LeafFuncId; +struct CV_LeafFuncId +{ CV_ItemId scope_string_id; CV_TypeId itype; // U8[] name (null terminated) -} CV_LeafFuncId; +}; -// (LeafIDKind: MFUNC_ID) -typedef struct CV_LeafMFuncId{ +//- (LeafIDKind: MFUNC_ID) + +typedef struct CV_LeafMFuncId CV_LeafMFuncId; +struct CV_LeafMFuncId +{ CV_TypeId owner_itype; CV_TypeId itype; // U8[] name (null terminated) -} CV_LeafMFuncId; +}; -// (LeafIDKind: STRING_ID) -typedef struct CV_LeafStringId{ +//- (LeafIDKind: STRING_ID) + +typedef struct CV_LeafStringId CV_LeafStringId; +struct CV_LeafStringId +{ CV_ItemId substr_list_id; // U8[] string (null terminated) -} CV_LeafStringId; +}; -// (LeafIDKind: BUILDINFO) -typedef enum{ +//- (LeafIDKind: BUILDINFO) + +typedef enum CV_BuildInfoIndexEnum +{ CV_BuildInfoIndex_BuildDirectory = 0, CV_BuildInfoIndex_CompilerExecutable = 1, CV_BuildInfoIndex_TargetSourceFile = 2, CV_BuildInfoIndex_CombinedPdb = 3, CV_BuildInfoIndex_CompileArguments = 4, -} CV_BuildInfoIndexEnum; +} +CV_BuildInfoIndexEnum; -typedef struct CV_LeafBuildInfo{ +typedef struct CV_LeafBuildInfo CV_LeafBuildInfo; +struct CV_LeafBuildInfo +{ U16 count; // CV_ItemId[count] items -} CV_LeafBuildInfo; +}; -// (LeafIDKind: SUBSTR_LIST) -typedef struct CV_LeafSubstrList{ +//- (LeafIDKind: SUBSTR_LIST) + +typedef struct CV_LeafSubstrList CV_LeafSubstrList; +struct CV_LeafSubstrList +{ U32 count; // CV_ItemId[count] items -} CV_LeafSubstrList; +}; -// (LeafIDKind: UDT_SRC_LINE) -typedef struct CV_LeafUDTSrcLine{ +//- (LeafIDKind: UDT_SRC_LINE) + +typedef struct CV_LeafUDTSrcLine CV_LeafUDTSrcLine; +struct CV_LeafUDTSrcLine +{ CV_TypeId udt_itype; CV_ItemId src_string_id; U32 line; -} CV_LeafUDTSrcLine; +}; -// (LeafIDKind: UDT_MOD_SRC_LINE) -typedef struct CV_LeafUDTModSrcLine{ +//- (LeafIDKind: UDT_MOD_SRC_LINE) + +typedef struct CV_LeafUDTModSrcLine CV_LeafUDTModSrcLine; +struct CV_LeafUDTModSrcLine +{ CV_TypeId udt_itype; CV_ItemId src_string_id; U32 line; CV_ModIndex imod; -} CV_LeafUDTModSrcLine; - +}; //////////////////////////////// //~ CodeView Format C13 Line Info Types @@ -2798,80 +2700,98 @@ X(MergedAssemblyInput, 0xFC)\ X(CoffSymbolRVA, 0xFD) typedef U32 CV_C13_SubSectionKind; -typedef enum{ +typedef enum +{ #define X(N,c) CV_C13_SubSectionKind_##N = c, CV_C13_SubSectionKindXList(X) #undef X } CV_C13_SubSectionKindEnum; -typedef struct CV_C13_SubSectionHeader{ +typedef struct CV_C13_SubSectionHeader CV_C13_SubSectionHeader; +struct CV_C13_SubSectionHeader +{ CV_C13_SubSectionKind kind; U32 size; -} CV_C13_SubSectionHeader; +}; //- FileChksms sub-section typedef U8 CV_C13_ChecksumKind; -typedef enum{ +typedef enum +{ CV_C13_ChecksumKind_Null, CV_C13_ChecksumKind_MD5, CV_C13_ChecksumKind_SHA1, CV_C13_ChecksumKind_SHA256, } CV_C13_ChecksumKindEnum; -typedef struct CV_C13_Checksum{ +typedef struct CV_C13_Checksum CV_C13_Checksum; +struct CV_C13_Checksum +{ U32 name_off; U8 len; CV_C13_ChecksumKind kind; -} CV_C13_Checksum; +}; //- Lines sub-section typedef U16 CV_C13_SubSecLinesFlags; -enum{ +enum +{ CV_C13_SubSecLinesFlag_HasColumns = (1 << 0) }; -typedef struct CV_C13_SubSecLinesHeader{ +typedef struct CV_C13_SubSecLinesHeader CV_C13_SubSecLinesHeader; +struct CV_C13_SubSecLinesHeader +{ U32 sec_off; CV_SectionIndex sec; CV_C13_SubSecLinesFlags flags; U32 len; -} CV_C13_SubSecLinesHeader; +}; -typedef struct CV_C13_File{ +typedef struct CV_C13_File CV_C13_File; +struct CV_C13_File +{ U32 file_off; U32 num_lines; U32 block_size; // CV_C13_Line[num_lines] lines; // CV_C13_Column[num_lines] columns; (if HasColumns) -} CV_C13_File; +}; typedef U32 CV_C13_LineFlags; #define CV_C13_LineFlags_ExtractLineNumber(f) ((f)&0xFFFFFF) #define CV_C13_LineFlags_ExtractDeltaToEnd(f) (((f)>>24)&0x7F) #define CV_C13_LineFlags_ExtractStatement(f) (((f)>>31)&0x1) -typedef struct CV_C13_Line{ +typedef struct CV_C13_Line CV_C13_Line; +struct CV_C13_Line +{ U32 off; CV_C13_LineFlags flags; -} CV_C13_Line; +}; -typedef struct CV_C13_Column{ +typedef struct CV_C13_Column CV_C13_Column; +struct CV_C13_Column +{ U16 start; U16 end; -} CV_C13_Column; +}; //- FrameData sub-section typedef U32 CV_C13_FrameDataFlags; -enum{ +enum +{ CV_C13_FrameDataFlag_HasStructuredExceptionHandling = (1 << 0), CV_C13_FrameDataFlag_HasExceptionHandling = (1 << 1), CV_C13_FrameDataFlag_HasIsFuncStart = (1 << 2), }; -typedef struct CV_C13_FrameData{ +typedef struct CV_C13_FrameData CV_C13_FrameData; +struct CV_C13_FrameData +{ U32 start_voff; U32 code_size; U32 local_size; @@ -2881,7 +2801,7 @@ typedef struct CV_C13_FrameData{ U16 prolog_size; U16 saved_reg_size; CV_C13_FrameDataFlags flags; -} CV_C13_FrameData; +}; #pragma pack(pop) @@ -2894,45 +2814,59 @@ typedef struct CV_C13_FrameData{ // case (x < 0x8000): kind=U16 val=x // case (x >= 0x8000): kind=x val=buf -typedef struct CV_NumericParsed{ +typedef struct CV_NumericParsed CV_NumericParsed; +struct CV_NumericParsed +{ CV_NumericKind kind; U8 *val; U64 encoded_size; -} CV_NumericParsed; +}; -typedef struct CV_RecRange{ +typedef struct CV_RecRange CV_RecRange; +struct CV_RecRange +{ U32 off; CV_RecHeader hdr; -} CV_RecRange; +}; #define CV_REC_RANGE_CHUNK_SIZE 511 -typedef struct CV_RecRangeChunk{ +typedef struct CV_RecRangeChunk CV_RecRangeChunk; +struct CV_RecRangeChunk +{ struct CV_RecRangeChunk *next; CV_RecRange ranges[CV_REC_RANGE_CHUNK_SIZE]; -} CV_RecRangeChunk; +}; -typedef struct CV_RecRangeStream{ +typedef struct CV_RecRangeStream CV_RecRangeStream; +struct CV_RecRangeStream +{ CV_RecRangeChunk *first_chunk; CV_RecRangeChunk *last_chunk; U64 total_count; -} CV_RecRangeStream; +}; -typedef struct CV_RecRangeArray{ +typedef struct CV_RecRangeArray CV_RecRangeArray; +struct CV_RecRangeArray +{ CV_RecRange *ranges; U64 count; -} CV_RecRangeArray; +}; //////////////////////////////// //~ CodeView Sym Parser Types -typedef struct CV_SymTopLevelInfo{ +typedef struct CV_SymTopLevelInfo CV_SymTopLevelInfo; +struct CV_SymTopLevelInfo +{ CV_Arch arch; CV_Language language; String8 compiler_name; -} CV_SymTopLevelInfo; +}; -typedef struct CV_SymParsed{ +typedef struct CV_SymParsed CV_SymParsed; +struct CV_SymParsed +{ // source information String8 data; U64 sym_align; @@ -2942,13 +2876,15 @@ typedef struct CV_SymParsed{ // top-level info derived from the syms CV_SymTopLevelInfo info; -} CV_SymParsed; +}; //////////////////////////////// //~ CodeView Leaf Parser Types -typedef struct CV_LeafParsed{ +typedef struct CV_LeafParsed CV_LeafParsed; +struct CV_LeafParsed +{ // source information String8 data; CV_TypeId itype_first; @@ -2956,12 +2892,14 @@ typedef struct CV_LeafParsed{ // leaf index derived from source CV_RecRangeArray leaf_ranges; -} CV_LeafParsed; +}; //////////////////////////////// //~ CodeView C13 Info Parser Types -typedef struct CV_C13LinesParsed{ +typedef struct CV_C13LinesParsed CV_C13LinesParsed; +struct CV_C13LinesParsed +{ // raw info U32 sec_idx; U32 file_off; @@ -2973,7 +2911,7 @@ typedef struct CV_C13LinesParsed{ U32 *line_nums; // [line_count] U16 *col_nums; // [2*line_count] U32 line_count; -} CV_C13LinesParsed; +}; typedef struct CV_C13LinesParsedNode CV_C13LinesParsedNode; struct CV_C13LinesParsedNode @@ -2982,32 +2920,37 @@ struct CV_C13LinesParsedNode CV_C13LinesParsed v; }; -typedef struct CV_C13SubSectionNode{ +typedef struct CV_C13SubSectionNode CV_C13SubSectionNode; +struct CV_C13SubSectionNode +{ struct CV_C13SubSectionNode *next; CV_C13_SubSectionKind kind; U32 off; U32 size; CV_C13LinesParsedNode *lines_first; CV_C13LinesParsedNode *lines_last; -} CV_C13SubSectionNode; +}; -typedef struct CV_C13Parsed{ +typedef struct CV_C13Parsed CV_C13Parsed; +struct CV_C13Parsed +{ CV_C13SubSectionNode *first_sub_section; CV_C13SubSectionNode *last_sub_section; U64 sub_section_count; // accelerator CV_C13SubSectionNode *file_chksms_sub_section; -} CV_C13Parsed; - +}; //////////////////////////////// //~ CodeView Compound Types -typedef struct CV_TypeIdArray{ +typedef struct CV_TypeIdArray CV_TypeIdArray; +struct CV_TypeIdArray +{ CV_TypeId *itypes; U64 count; -} CV_TypeIdArray; +}; //////////////////////////////// diff --git a/src/codeview/codeview.mdesk b/src/codeview/codeview.mdesk index e4864c5b..f05316c3 100644 --- a/src/codeview/codeview.mdesk +++ b/src/codeview/codeview.mdesk @@ -1,3 +1,5 @@ +//////////////////////////////// +//~ rjf: CV Numerics @table(name val) CV_NumericKindTable: @@ -26,3 +28,479 @@ CV_NumericKindTable: {UTF8STRING 0x801b} {FLOAT16 0x801c} } + +@enum(U16) CV_NumericKind: +{ + @expand(CV_NumericKindTable a) `$(a.name) = $(a.val)` +} + +@enum2string_switch(CV_NumericKind) +cv_string_from_numeric_kind: +{ + @expand(CV_NumericKindTable a) `case CV_NumericKind_$(a.name):{result = str8_lit("$(a.name)");}break`; +} + +//////////////////////////////// +//~ rjf: CV Architectures + +@table(name val) +CV_ArchTable: +{ + {8080 0x00} + {8086 0x01} + {80286 0x02} + {80386 0x03} + {80486 0x04} + {PENTIUM 0x05} + {PENTIUMII 0x06} + {PENTIUMIII 0x07} + {MIPS 0x10} + {MIPS16 0x11} + {MIPS32 0x12} + {MIPS64 0x13} + {MIPSI 0x14} + {MIPSII 0x15} + {MIPSIII 0x16} + {MIPSIV 0x17} + {MIPSV 0x18} + {M68000 0x20} + {M68010 0x21} + {M68020 0x22} + {M68030 0x23} + {M68040 0x24} + {ALPHA 0x30} + {ALPHA_21164 0x31} + {ALPHA_21164A 0x32} + {ALPHA_21264 0x33} + {ALPHA_21364 0x34} + {PPC601 0x40} + {PPC603 0x41} + {PPC604 0x42} + {PPC620 0x43} + {PPCFP 0x44} + {PPCBE 0x45} + {SH3 0x50} + {SH3E 0x51} + {SH3DSP 0x52} + {SH4 0x53} + {SHMEDIA 0x54} + {ARM3 0x60} + {ARM4 0x61} + {ARM4T 0x62} + {ARM5 0x63} + {ARM5T 0x64} + {ARM6 0x65} + {ARM_XMAC 0x66} + {ARM_WMMX 0x67} + {ARM7 0x68} + {OMNI 0x70} + {IA64_1 0x80} + {IA64_2 0x81} + {CEE 0x90} + {AM33 0xA0} + {M32R 0xB0} + {TRICORE 0xC0} + {X64 0xD0} + {EBC 0xE0} + {THUMB 0xF0} + {ARMNT 0xF4} + {ARM64 0xF6} + {D3D11_SHADER 0x100} +} + +@enum(U16) CV_Arch: +{ + @expand(CV_ArchTable a) `$(a.name) = $(a.val)`, + `IA64 = CV_Arch_IA64_1`, + `PENTIUMPRO = CV_Arch_PENTIUMII`, + `MIPSR4000 = CV_Arch_MIPS`, + `ALPHA_21064 = CV_Arch_ALPHA`, + `AMD64 = CV_Arch_X64`, +} + +@enum2string_switch(CV_Arch) +cv_string_from_arch: +{ + @expand(CV_ArchTable a) `case CV_Arch_$(a.name):{result = str8_lit("$(a.name)");}break`; +} + +//////////////////////////////// +//~ rjf: CV Registers + +@table(name val) CV_AllRegTable: +{ + {ERR 30000} + {TEB 30001} + {TIMER 30002} + {EFAD1 30003} + {EFAD2 30004} + {EFAD3 30005} + {VFRAME 30006} + {HANDLE 30007} + {PARAMS 30008} + {LOCALS 30009} + {TID 30010} + {ENV 30011} + {CMDLN 30012} +} + +@enum(U16) CV_AllReg: +{ + @expand(CV_AllRegTable a) `$(a.name) = $(a.val)` +} + +//////////////////////////////// +//~ rjf: CV Sym Kinds + +@table(name val) CV_SymKindTable: +{ + {COMPILE 0x0001} + {REGISTER_16t 0x0002} + {CONSTANT_16t 0x0003} + {UDT_16t 0x0004} + {SSEARCH 0x0005} + {END 0x0006} + {SKIP 0x0007} + {CVRESERVE 0x0008} + {OBJNAME_ST 0x0009} + {ENDARG 0x000a} + {COBOLUDT_16t 0x000b} + {MANYREG_16t 0x000c} + {RETURN 0x000d} + {ENTRYTHIS 0x000e} + {BPREL16 0x0100} + {LDATA16 0x0101} + {GDATA16 0x0102} + {PUB16 0x0103} + {LPROC16 0x0104} + {GPROC16 0x0105} + {THUNK16 0x0106} + {BLOCK16 0x0107} + {WITH16 0x0108} + {LABEL16 0x0109} + {CEXMODEL16 0x010a} + {VFTABLE16 0x010b} + {REGREL16 0x010c} + {BPREL32_16t 0x0200} + {LDATA32_16t 0x0201} + {GDATA32_16t 0x0202} + {PUB32_16t 0x0203} + {LPROC32_16t 0x0204} + {GPROC32_16t 0x0205} + {THUNK32_ST 0x0206} + {BLOCK32_ST 0x0207} + {WITH32_ST 0x0208} + {LABEL32_ST 0x0209} + {CEXMODEL32 0x020a} + {VFTABLE32_16t 0x020b} + {REGREL32_16t 0x020c} + {LTHREAD32_16t 0x020d} + {GTHREAD32_16t 0x020e} + {SLINK32 0x020f} + {LPROCMIPS_16t 0x0300} + {GPROCMIPS_16t 0x0301} + {PROCREF_ST 0x0400} + {DATAREF_ST 0x0401} + {ALIGN 0x0402} + {LPROCREF_ST 0x0403} + {OEM 0x0404} + {TI16_MAX 0x1000} + {CONSTANT_ST 0x1002} + {UDT_ST 0x1003} + {COBOLUDT_ST 0x1004} + {MANYREG_ST 0x1005} + {BPREL32_ST 0x1006} + {LDATA32_ST 0x1007} + {GDATA32_ST 0x1008} + {PUB32_ST 0x1009} + {LPROC32_ST 0x100a} + {GPROC32_ST 0x100b} + {VFTABLE32 0x100c} + {REGREL32_ST 0x100d} + {LTHREAD32_ST 0x100e} + {GTHREAD32_ST 0x100f} + {LPROCMIPS_ST 0x1010} + {GPROCMIPS_ST 0x1011} + {FRAMEPROC 0x1012} + {COMPILE2_ST 0x1013} + {MANYREG2_ST 0x1014} + {LPROCIA64_ST 0x1015} + {GPROCIA64_ST 0x1016} + {LOCALSLOT_ST 0x1017} + {PARAMSLOT_ST 0x1018} + {ANNOTATION 0x1019} + {GMANPROC_ST 0x101a} + {LMANPROC_ST 0x101b} + {RESERVED1 0x101c} + {RESERVED2 0x101d} + {RESERVED3 0x101e} + {RESERVED4 0x101f} + {LMANDATA_ST 0x1020} + {GMANDATA_ST 0x1021} + {MANFRAMEREL_ST 0x1022} + {MANREGISTER_ST 0x1023} + {MANSLOT_ST 0x1024} + {MANMANYREG_ST 0x1025} + {MANREGREL_ST 0x1026} + {MANMANYREG2_ST 0x1027} + {MANTYPREF 0x1028} + {UNAMESPACE_ST 0x1029} + {ST_MAX 0x1100} + {OBJNAME 0x1101} + {THUNK32 0x1102} + {BLOCK32 0x1103} + {WITH32 0x1104} + {LABEL32 0x1105} + {REGISTER 0x1106} + {CONSTANT 0x1107} + {UDT 0x1108} + {COBOLUDT 0x1109} + {MANYREG 0x110a} + {BPREL32 0x110b} + {LDATA32 0x110c} + {GDATA32 0x110d} + {PUB32 0x110e} + {LPROC32 0x110f} + {GPROC32 0x1110} + {REGREL32 0x1111} + {LTHREAD32 0x1112} + {GTHREAD32 0x1113} + {LPROCMIPS 0x1114} + {GPROCMIPS 0x1115} + {COMPILE2 0x1116} + {MANYREG2 0x1117} + {LPROCIA64 0x1118} + {GPROCIA64 0x1119} + {LOCALSLOT 0x111a} + {PARAMSLOT 0x111b} + {LMANDATA 0x111c} + {GMANDATA 0x111d} + {MANFRAMEREL 0x111e} + {MANREGISTER 0x111f} + {MANSLOT 0x1120} + {MANMANYREG 0x1121} + {MANREGREL 0x1122} + {MANMANYREG2 0x1123} + {UNAMESPACE 0x1124} + {PROCREF 0x1125} + {DATAREF 0x1126} + {LPROCREF 0x1127} + {ANNOTATIONREF 0x1128} + {TOKENREF 0x1129} + {GMANPROC 0x112a} + {LMANPROC 0x112b} + {TRAMPOLINE 0x112c} + {MANCONSTANT 0x112d} + {ATTR_FRAMEREL 0x112e} + {ATTR_REGISTER 0x112f} + {ATTR_REGREL 0x1130} + {ATTR_MANYREG 0x1131} + {SEPCODE 0x1132} + {DEFRANGE_2005 0x1134} + {DEFRANGE2_2005 0x1135} + {SECTION 0x1136} + {COFFGROUP 0x1137} + {EXPORT 0x1138} + {CALLSITEINFO 0x1139} + {FRAMECOOKIE 0x113a} + {DISCARDED 0x113b} + {COMPILE3 0x113c} + {ENVBLOCK 0x113d} + {LOCAL 0x113e} + {DEFRANGE 0x113f} + {DEFRANGE_SUBFIELD 0x1140} + {DEFRANGE_REGISTER 0x1141} + {DEFRANGE_FRAMEPOINTER_REL 0x1142} + {DEFRANGE_SUBFIELD_REGISTER 0x1143} + {DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE 0x1144} + {DEFRANGE_REGISTER_REL 0x1145} + {LPROC32_ID 0x1146} + {GPROC32_ID 0x1147} + {LPROCMIPS_ID 0x1148} + {GPROCMIPS_ID 0x1149} + {LPROCIA64_ID 0x114a} + {GPROCIA64_ID 0x114b} + {BUILDINFO 0x114c} + {INLINESITE 0x114d} + {INLINESITE_END 0x114e} + {PROC_ID_END 0x114f} + {DEFRANGE_HLSL 0x1150} + {GDATA_HLSL 0x1151} + {LDATA_HLSL 0x1152} + {FILESTATIC 0x1153} + {LPROC32_DPC 0x1155} + {LPROC32_DPC_ID 0x1156} + {DEFRANGE_DPC_PTR_TAG 0x1157} + {DPC_SYM_TAG_MAP 0x1158} + {ARMSWITCHTABLE 0x1159} + {CALLEES 0x115a} + {CALLERS 0x115b} + {POGODATA 0x115c} + {INLINESITE2 0x115d} + {HEAPALLOCSITE 0x115e} + {MOD_TYPEREF 0x115f} + {REF_MINIPDB 0x1160} + {PDBMAP 0x1161} + {GDATA_HLSL32 0x1162} + {LDATA_HLSL32 0x1163} + {GDATA_HLSL32_EX 0x1164} + {LDATA_HLSL32_EX 0x1165} + {FASTLINK 0x1167} + {INLINEES 0x1168} +} + +@enum(U16) CV_SymKind: +{ + @expand(CV_SymKindTable a) `$(a.name) = $(a.val)` +} + +@enum2string_switch(CV_SymKind) +cv_string_from_sym_kind: +{ + @expand(CV_SymKindTable a) `case CV_SymKind_$(a.name):{result = str8_lit("$(a.name)");}break`; +} + +//////////////////////////////// +//~ rjf: CV Leaf + +@table(name val) +CV_LeafKindTable: +{ + {MODIFIER_16t 0x0001} + {POINTER_16t 0x0002} + {ARRAY_16t 0x0003} + {CLASS_16t 0x0004} + {STRUCTURE_16t 0x0005} + {UNION_16t 0x0006} + {ENUM_16t 0x0007} + {PROCEDURE_16t 0x0008} + {MFUNCTION_16t 0x0009} + {VTSHAPE 0x000a} + {COBOL0_16t 0x000b} + {COBOL1 0x000c} + {BARRAY_16t 0x000d} + {LABEL 0x000e} + {NULL 0x000f} + {NOTTRAN 0x0010} + {DIMARRAY_16t 0x0011} + {VFTPATH_16t 0x0012} + {PRECOMP_16t 0x0013} + {ENDPRECOMP 0x0014} + {OEM_16t 0x0015} + {TYPESERVER_ST 0x0016} + {SKIP_16t 0x0200} + {ARGLIST_16t 0x0201} + {DEFARG_16t 0x0202} + {LIST 0x0203} + {FIELDLIST_16t 0x0204} + {DERIVED_16t 0x0205} + {BITFIELD_16t 0x0206} + {METHODLIST_16t 0x0207} + {DIMCONU_16t 0x0208} + {DIMCONLU_16t 0x0209} + {DIMVARU_16t 0x020a} + {DIMVARLU_16t 0x020b} + {REFSYM 0x020c} + {BCLASS_16t 0x0400} + {VBCLASS_16t 0x0401} + {IVBCLASS_16t 0x0402} + {ENUMERATE_ST 0x0403} + {FRIENDFCN_16t 0x0404} + {INDEX_16t 0x0405} + {MEMBER_16t 0x0406} + {STMEMBER_16t 0x0407} + {METHOD_16t 0x0408} + {NESTTYPE_16t 0x0409} + {VFUNCTAB_16t 0x040a} + {FRIENDCLS_16t 0x040b} + {ONEMETHOD_16t 0x040c} + {VFUNCOFF_16t 0x040d} + {TI16_MAX 0x1000} + {MODIFIER 0x1001} + {POINTER 0x1002} + {ARRAY_ST 0x1003} + {CLASS_ST 0x1004} + {STRUCTURE_ST 0x1005} + {UNION_ST 0x1006} + {ENUM_ST 0x1007} + {PROCEDURE 0x1008} + {MFUNCTION 0x1009} + {COBOL0 0x100a} + {BARRAY 0x100b} + {DIMARRAY_ST 0x100c} + {VFTPATH 0x100d} + {PRECOMP_ST 0x100e} + {OEM 0x100f} + {ALIAS_ST 0x1010} + {OEM2 0x1011} + {SKIP 0x1200} + {ARGLIST 0x1201} + {DEFARG_ST 0x1202} + {FIELDLIST 0x1203} + {DERIVED 0x1204} + {BITFIELD 0x1205} + {METHODLIST 0x1206} + {DIMCONU 0x1207} + {DIMCONLU 0x1208} + {DIMVARU 0x1209} + {DIMVARLU 0x120a} + {BCLASS 0x1400} + {VBCLASS 0x1401} + {IVBCLASS 0x1402} + {FRIENDFCN_ST 0x1403} + {INDEX 0x1404} + {MEMBER_ST 0x1405} + {STMEMBER_ST 0x1406} + {METHOD_ST 0x1407} + {NESTTYPE_ST 0x1408} + {VFUNCTAB 0x1409} + {FRIENDCLS 0x140a} + {ONEMETHOD_ST 0x140b} + {VFUNCOFF 0x140c} + {NESTTYPEEX_ST 0x140d} + {MEMBERMODIFY_ST 0x140e} + {MANAGED_ST 0x140f} + {ST_MAX 0x1500} + {TYPESERVER 0x1501} + {ENUMERATE 0x1502} + {ARRAY 0x1503} + {CLASS 0x1504} + {STRUCTURE 0x1505} + {UNION 0x1506} + {ENUM 0x1507} + {DIMARRAY 0x1508} + {PRECOMP 0x1509} + {ALIAS 0x150a} + {DEFARG 0x150b} + {FRIENDFCN 0x150c} + {MEMBER 0x150d} + {STMEMBER 0x150e} + {METHOD 0x150f} + {NESTTYPE 0x1510} + {ONEMETHOD 0x1511} + {NESTTYPEEX 0x1512} + {MEMBERMODIFY 0x1513} + {MANAGED 0x1514} + {TYPESERVER2 0x1515} + {STRIDED_ARRAY 0x1516} + {HLSL 0x1517} + {MODIFIER_EX 0x1518} + {INTERFACE 0x1519} + {BINTERFACE 0x151a} + {VECTOR 0x151b} + {MATRIX 0x151c} + {VFTABLE 0x151d} + {CLASS2 0x1608} + {STRUCT2 0x1609} +} + +@enum(U16) CV_LeafKind: +{ + @expand(CV_LeafKindTable a) `$(a.name) = $(a.val)`; +} + +@enum2string_switch(CV_LeafKind) +cv_string_from_leaf_kind: +{ + @expand(CV_LeafKindTable a) `case CV_LeafKind_$(a.name):{result = str8_lit("$(a.name)");}break`; +} diff --git a/src/codeview/codeview_stringize.c b/src/codeview/codeview_stringize.c index 70ee4628..983b078e 100644 --- a/src/codeview/codeview_stringize.c +++ b/src/codeview/codeview_stringize.c @@ -48,17 +48,6 @@ cv_stringize_lvar_addr_gap_list(Arena *arena, String8List *out, void *first, voi } } -internal String8 -cv_string_from_sym_kind(CV_SymKind kind){ - String8 result = str8_lit("UNRECOGNIZED_SYM_KIND"); - switch (kind){ -#define X(N,c) case CV_SymKind_##N: result = str8_lit(#N); break; - CV_SymKindXList(X) -#undef X - } - return(result); -} - internal String8 cv_string_from_basic_type(CV_BasicType basic_type){ String8 result = str8_lit("UNRECOGNIZED_BASIC_TYPE"); @@ -70,33 +59,6 @@ cv_string_from_basic_type(CV_BasicType basic_type){ return(result); } -internal String8 -cv_string_from_leaf_kind(CV_LeafKind kind){ - String8 result = str8_lit("UNRECOGNIZED_LEAF_KIND"); - switch (kind){ -#define X(N,c) case CV_LeafKind_##N: result = str8_lit(#N); break; - CV_LeafKindXList(X) -#undef X - -#define X(N,c) case CV_LeafIDKind_##N: result = str8_lit(#N); break; - CV_LeafIDKindXList(X) -#undef X - } - return(result); -} - -internal String8 -cv_string_from_numeric_kind(CV_NumericKind kind){ - String8 result = str8_lit("UNRECOGNIZED_NUMERIC_KIND"); - switch (kind){ - case 0: str8_lit("PARSE_ERROR"); break; -#define X(N,c) case CV_NumericKind_##N: result = str8_lit(#N); break; - CV_NumericKindXList(X) -#undef X - } - return(result); -} - internal String8 cv_string_from_c13_sub_section_kind(CV_C13_SubSectionKind kind){ String8 result = str8_lit("UNRECOGNIZED_C13_SUB_SECTION_KIND"); @@ -109,17 +71,6 @@ cv_string_from_c13_sub_section_kind(CV_C13_SubSectionKind kind){ return(result); } -internal String8 -cv_string_from_machine(CV_Arch arch){ - String8 result = {0}; - switch (arch){ -#define X(N,c) case CV_Arch_##N: result = str8_lit(#N); break; - CV_ArchXList(X) -#undef X - } - return(result); -} - internal String8 cv_string_from_reg(CV_Arch arch, CV_Reg reg){ String8 result = {0}; @@ -417,7 +368,7 @@ cv_stringize_sym_range(Arena *arena, String8List *out, CV_SymCompile *compile = (CV_SymCompile*)first; // machine - String8 machine = cv_string_from_machine(compile->machine); + String8 machine = cv_string_from_arch(compile->machine); str8_list_pushf(arena, out, " machine=%.*s\n", str8_varg(machine)); @@ -742,7 +693,7 @@ cv_stringize_sym_range(Arena *arena, String8List *out, str8_list_pushf(arena, out, " flags=%x\n", compile2->flags); // machine - String8 machine = cv_string_from_machine(compile2->machine); + String8 machine = cv_string_from_arch(compile2->machine); str8_list_pushf(arena, out, " machine=%.*s\n", str8_varg(machine)); @@ -906,7 +857,7 @@ cv_stringize_sym_range(Arena *arena, String8List *out, str8_list_pushf(arena, out, " flags=%x\n", compile3->flags); // machine - String8 machine = cv_string_from_machine(compile3->machine); + String8 machine = cv_string_from_arch(compile3->machine); str8_list_pushf(arena, out, " machine=%.*s\n", str8_varg(machine)); diff --git a/src/codeview/codeview_stringize.h b/src/codeview/codeview_stringize.h index 4e3d3ce3..b37cd904 100644 --- a/src/codeview/codeview_stringize.h +++ b/src/codeview/codeview_stringize.h @@ -26,12 +26,8 @@ internal void cv_stringize_lvar_addr_gap(Arena *arena, String8List *out, CV_Lvar internal void cv_stringize_lvar_addr_gap_list(Arena *arena, String8List *out, void *first, void *opl); -internal String8 cv_string_from_sym_kind(CV_SymKind kind); internal String8 cv_string_from_basic_type(CV_BasicType basic_type); -internal String8 cv_string_from_leaf_kind(CV_LeafKind kind); -internal String8 cv_string_from_numeric_kind(CV_NumericKind kind); internal String8 cv_string_from_c13_sub_section_kind(CV_C13_SubSectionKind kind); -internal String8 cv_string_from_machine(CV_Arch arch); internal String8 cv_string_from_reg(CV_Arch arch, CV_Reg reg); internal String8 cv_string_from_pointer_kind(CV_PointerKind ptr_kind); internal String8 cv_string_from_pointer_mode(CV_PointerMode ptr_mode); diff --git a/src/codeview/generated/codeview.meta.c b/src/codeview/generated/codeview.meta.c new file mode 100644 index 00000000..6db9136c --- /dev/null +++ b/src/codeview/generated/codeview.meta.c @@ -0,0 +1,454 @@ +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//- GENERATED CODE + +internal String8 +cv_string_from_numeric_kind(CV_NumericKind v) +{ +String8 result = str8_lit(""); +switch(v) +{ +default:{}break; +case CV_NumericKind_CHAR:{result = str8_lit("CHAR");}break; +case CV_NumericKind_SHORT:{result = str8_lit("SHORT");}break; +case CV_NumericKind_USHORT:{result = str8_lit("USHORT");}break; +case CV_NumericKind_LONG:{result = str8_lit("LONG");}break; +case CV_NumericKind_ULONG:{result = str8_lit("ULONG");}break; +case CV_NumericKind_FLOAT32:{result = str8_lit("FLOAT32");}break; +case CV_NumericKind_FLOAT64:{result = str8_lit("FLOAT64");}break; +case CV_NumericKind_FLOAT80:{result = str8_lit("FLOAT80");}break; +case CV_NumericKind_FLOAT128:{result = str8_lit("FLOAT128");}break; +case CV_NumericKind_QUADWORD:{result = str8_lit("QUADWORD");}break; +case CV_NumericKind_UQUADWORD:{result = str8_lit("UQUADWORD");}break; +case CV_NumericKind_FLOAT48:{result = str8_lit("FLOAT48");}break; +case CV_NumericKind_COMPLEX32:{result = str8_lit("COMPLEX32");}break; +case CV_NumericKind_COMPLEX64:{result = str8_lit("COMPLEX64");}break; +case CV_NumericKind_COMPLEX80:{result = str8_lit("COMPLEX80");}break; +case CV_NumericKind_COMPLEX128:{result = str8_lit("COMPLEX128");}break; +case CV_NumericKind_VARSTRING:{result = str8_lit("VARSTRING");}break; +case CV_NumericKind_OCTWORD:{result = str8_lit("OCTWORD");}break; +case CV_NumericKind_UOCTWORD:{result = str8_lit("UOCTWORD");}break; +case CV_NumericKind_DECIMAL:{result = str8_lit("DECIMAL");}break; +case CV_NumericKind_DATE:{result = str8_lit("DATE");}break; +case CV_NumericKind_UTF8STRING:{result = str8_lit("UTF8STRING");}break; +case CV_NumericKind_FLOAT16:{result = str8_lit("FLOAT16");}break; +} +return result; +} + +internal String8 +cv_string_from_arch(CV_Arch v) +{ +String8 result = str8_lit(""); +switch(v) +{ +default:{}break; +case CV_Arch_8080:{result = str8_lit("8080");}break; +case CV_Arch_8086:{result = str8_lit("8086");}break; +case CV_Arch_80286:{result = str8_lit("80286");}break; +case CV_Arch_80386:{result = str8_lit("80386");}break; +case CV_Arch_80486:{result = str8_lit("80486");}break; +case CV_Arch_PENTIUM:{result = str8_lit("PENTIUM");}break; +case CV_Arch_PENTIUMII:{result = str8_lit("PENTIUMII");}break; +case CV_Arch_PENTIUMIII:{result = str8_lit("PENTIUMIII");}break; +case CV_Arch_MIPS:{result = str8_lit("MIPS");}break; +case CV_Arch_MIPS16:{result = str8_lit("MIPS16");}break; +case CV_Arch_MIPS32:{result = str8_lit("MIPS32");}break; +case CV_Arch_MIPS64:{result = str8_lit("MIPS64");}break; +case CV_Arch_MIPSI:{result = str8_lit("MIPSI");}break; +case CV_Arch_MIPSII:{result = str8_lit("MIPSII");}break; +case CV_Arch_MIPSIII:{result = str8_lit("MIPSIII");}break; +case CV_Arch_MIPSIV:{result = str8_lit("MIPSIV");}break; +case CV_Arch_MIPSV:{result = str8_lit("MIPSV");}break; +case CV_Arch_M68000:{result = str8_lit("M68000");}break; +case CV_Arch_M68010:{result = str8_lit("M68010");}break; +case CV_Arch_M68020:{result = str8_lit("M68020");}break; +case CV_Arch_M68030:{result = str8_lit("M68030");}break; +case CV_Arch_M68040:{result = str8_lit("M68040");}break; +case CV_Arch_ALPHA:{result = str8_lit("ALPHA");}break; +case CV_Arch_ALPHA_21164:{result = str8_lit("ALPHA_21164");}break; +case CV_Arch_ALPHA_21164A:{result = str8_lit("ALPHA_21164A");}break; +case CV_Arch_ALPHA_21264:{result = str8_lit("ALPHA_21264");}break; +case CV_Arch_ALPHA_21364:{result = str8_lit("ALPHA_21364");}break; +case CV_Arch_PPC601:{result = str8_lit("PPC601");}break; +case CV_Arch_PPC603:{result = str8_lit("PPC603");}break; +case CV_Arch_PPC604:{result = str8_lit("PPC604");}break; +case CV_Arch_PPC620:{result = str8_lit("PPC620");}break; +case CV_Arch_PPCFP:{result = str8_lit("PPCFP");}break; +case CV_Arch_PPCBE:{result = str8_lit("PPCBE");}break; +case CV_Arch_SH3:{result = str8_lit("SH3");}break; +case CV_Arch_SH3E:{result = str8_lit("SH3E");}break; +case CV_Arch_SH3DSP:{result = str8_lit("SH3DSP");}break; +case CV_Arch_SH4:{result = str8_lit("SH4");}break; +case CV_Arch_SHMEDIA:{result = str8_lit("SHMEDIA");}break; +case CV_Arch_ARM3:{result = str8_lit("ARM3");}break; +case CV_Arch_ARM4:{result = str8_lit("ARM4");}break; +case CV_Arch_ARM4T:{result = str8_lit("ARM4T");}break; +case CV_Arch_ARM5:{result = str8_lit("ARM5");}break; +case CV_Arch_ARM5T:{result = str8_lit("ARM5T");}break; +case CV_Arch_ARM6:{result = str8_lit("ARM6");}break; +case CV_Arch_ARM_XMAC:{result = str8_lit("ARM_XMAC");}break; +case CV_Arch_ARM_WMMX:{result = str8_lit("ARM_WMMX");}break; +case CV_Arch_ARM7:{result = str8_lit("ARM7");}break; +case CV_Arch_OMNI:{result = str8_lit("OMNI");}break; +case CV_Arch_IA64_1:{result = str8_lit("IA64_1");}break; +case CV_Arch_IA64_2:{result = str8_lit("IA64_2");}break; +case CV_Arch_CEE:{result = str8_lit("CEE");}break; +case CV_Arch_AM33:{result = str8_lit("AM33");}break; +case CV_Arch_M32R:{result = str8_lit("M32R");}break; +case CV_Arch_TRICORE:{result = str8_lit("TRICORE");}break; +case CV_Arch_X64:{result = str8_lit("X64");}break; +case CV_Arch_EBC:{result = str8_lit("EBC");}break; +case CV_Arch_THUMB:{result = str8_lit("THUMB");}break; +case CV_Arch_ARMNT:{result = str8_lit("ARMNT");}break; +case CV_Arch_ARM64:{result = str8_lit("ARM64");}break; +case CV_Arch_D3D11_SHADER:{result = str8_lit("D3D11_SHADER");}break; +} +return result; +} + +internal String8 +cv_string_from_sym_kind(CV_SymKind v) +{ +String8 result = str8_lit(""); +switch(v) +{ +default:{}break; +case CV_SymKind_COMPILE:{result = str8_lit("COMPILE");}break; +case CV_SymKind_REGISTER_16t:{result = str8_lit("REGISTER_16t");}break; +case CV_SymKind_CONSTANT_16t:{result = str8_lit("CONSTANT_16t");}break; +case CV_SymKind_UDT_16t:{result = str8_lit("UDT_16t");}break; +case CV_SymKind_SSEARCH:{result = str8_lit("SSEARCH");}break; +case CV_SymKind_END:{result = str8_lit("END");}break; +case CV_SymKind_SKIP:{result = str8_lit("SKIP");}break; +case CV_SymKind_CVRESERVE:{result = str8_lit("CVRESERVE");}break; +case CV_SymKind_OBJNAME_ST:{result = str8_lit("OBJNAME_ST");}break; +case CV_SymKind_ENDARG:{result = str8_lit("ENDARG");}break; +case CV_SymKind_COBOLUDT_16t:{result = str8_lit("COBOLUDT_16t");}break; +case CV_SymKind_MANYREG_16t:{result = str8_lit("MANYREG_16t");}break; +case CV_SymKind_RETURN:{result = str8_lit("RETURN");}break; +case CV_SymKind_ENTRYTHIS:{result = str8_lit("ENTRYTHIS");}break; +case CV_SymKind_BPREL16:{result = str8_lit("BPREL16");}break; +case CV_SymKind_LDATA16:{result = str8_lit("LDATA16");}break; +case CV_SymKind_GDATA16:{result = str8_lit("GDATA16");}break; +case CV_SymKind_PUB16:{result = str8_lit("PUB16");}break; +case CV_SymKind_LPROC16:{result = str8_lit("LPROC16");}break; +case CV_SymKind_GPROC16:{result = str8_lit("GPROC16");}break; +case CV_SymKind_THUNK16:{result = str8_lit("THUNK16");}break; +case CV_SymKind_BLOCK16:{result = str8_lit("BLOCK16");}break; +case CV_SymKind_WITH16:{result = str8_lit("WITH16");}break; +case CV_SymKind_LABEL16:{result = str8_lit("LABEL16");}break; +case CV_SymKind_CEXMODEL16:{result = str8_lit("CEXMODEL16");}break; +case CV_SymKind_VFTABLE16:{result = str8_lit("VFTABLE16");}break; +case CV_SymKind_REGREL16:{result = str8_lit("REGREL16");}break; +case CV_SymKind_BPREL32_16t:{result = str8_lit("BPREL32_16t");}break; +case CV_SymKind_LDATA32_16t:{result = str8_lit("LDATA32_16t");}break; +case CV_SymKind_GDATA32_16t:{result = str8_lit("GDATA32_16t");}break; +case CV_SymKind_PUB32_16t:{result = str8_lit("PUB32_16t");}break; +case CV_SymKind_LPROC32_16t:{result = str8_lit("LPROC32_16t");}break; +case CV_SymKind_GPROC32_16t:{result = str8_lit("GPROC32_16t");}break; +case CV_SymKind_THUNK32_ST:{result = str8_lit("THUNK32_ST");}break; +case CV_SymKind_BLOCK32_ST:{result = str8_lit("BLOCK32_ST");}break; +case CV_SymKind_WITH32_ST:{result = str8_lit("WITH32_ST");}break; +case CV_SymKind_LABEL32_ST:{result = str8_lit("LABEL32_ST");}break; +case CV_SymKind_CEXMODEL32:{result = str8_lit("CEXMODEL32");}break; +case CV_SymKind_VFTABLE32_16t:{result = str8_lit("VFTABLE32_16t");}break; +case CV_SymKind_REGREL32_16t:{result = str8_lit("REGREL32_16t");}break; +case CV_SymKind_LTHREAD32_16t:{result = str8_lit("LTHREAD32_16t");}break; +case CV_SymKind_GTHREAD32_16t:{result = str8_lit("GTHREAD32_16t");}break; +case CV_SymKind_SLINK32:{result = str8_lit("SLINK32");}break; +case CV_SymKind_LPROCMIPS_16t:{result = str8_lit("LPROCMIPS_16t");}break; +case CV_SymKind_GPROCMIPS_16t:{result = str8_lit("GPROCMIPS_16t");}break; +case CV_SymKind_PROCREF_ST:{result = str8_lit("PROCREF_ST");}break; +case CV_SymKind_DATAREF_ST:{result = str8_lit("DATAREF_ST");}break; +case CV_SymKind_ALIGN:{result = str8_lit("ALIGN");}break; +case CV_SymKind_LPROCREF_ST:{result = str8_lit("LPROCREF_ST");}break; +case CV_SymKind_OEM:{result = str8_lit("OEM");}break; +case CV_SymKind_TI16_MAX:{result = str8_lit("TI16_MAX");}break; +case CV_SymKind_CONSTANT_ST:{result = str8_lit("CONSTANT_ST");}break; +case CV_SymKind_UDT_ST:{result = str8_lit("UDT_ST");}break; +case CV_SymKind_COBOLUDT_ST:{result = str8_lit("COBOLUDT_ST");}break; +case CV_SymKind_MANYREG_ST:{result = str8_lit("MANYREG_ST");}break; +case CV_SymKind_BPREL32_ST:{result = str8_lit("BPREL32_ST");}break; +case CV_SymKind_LDATA32_ST:{result = str8_lit("LDATA32_ST");}break; +case CV_SymKind_GDATA32_ST:{result = str8_lit("GDATA32_ST");}break; +case CV_SymKind_PUB32_ST:{result = str8_lit("PUB32_ST");}break; +case CV_SymKind_LPROC32_ST:{result = str8_lit("LPROC32_ST");}break; +case CV_SymKind_GPROC32_ST:{result = str8_lit("GPROC32_ST");}break; +case CV_SymKind_VFTABLE32:{result = str8_lit("VFTABLE32");}break; +case CV_SymKind_REGREL32_ST:{result = str8_lit("REGREL32_ST");}break; +case CV_SymKind_LTHREAD32_ST:{result = str8_lit("LTHREAD32_ST");}break; +case CV_SymKind_GTHREAD32_ST:{result = str8_lit("GTHREAD32_ST");}break; +case CV_SymKind_LPROCMIPS_ST:{result = str8_lit("LPROCMIPS_ST");}break; +case CV_SymKind_GPROCMIPS_ST:{result = str8_lit("GPROCMIPS_ST");}break; +case CV_SymKind_FRAMEPROC:{result = str8_lit("FRAMEPROC");}break; +case CV_SymKind_COMPILE2_ST:{result = str8_lit("COMPILE2_ST");}break; +case CV_SymKind_MANYREG2_ST:{result = str8_lit("MANYREG2_ST");}break; +case CV_SymKind_LPROCIA64_ST:{result = str8_lit("LPROCIA64_ST");}break; +case CV_SymKind_GPROCIA64_ST:{result = str8_lit("GPROCIA64_ST");}break; +case CV_SymKind_LOCALSLOT_ST:{result = str8_lit("LOCALSLOT_ST");}break; +case CV_SymKind_PARAMSLOT_ST:{result = str8_lit("PARAMSLOT_ST");}break; +case CV_SymKind_ANNOTATION:{result = str8_lit("ANNOTATION");}break; +case CV_SymKind_GMANPROC_ST:{result = str8_lit("GMANPROC_ST");}break; +case CV_SymKind_LMANPROC_ST:{result = str8_lit("LMANPROC_ST");}break; +case CV_SymKind_RESERVED1:{result = str8_lit("RESERVED1");}break; +case CV_SymKind_RESERVED2:{result = str8_lit("RESERVED2");}break; +case CV_SymKind_RESERVED3:{result = str8_lit("RESERVED3");}break; +case CV_SymKind_RESERVED4:{result = str8_lit("RESERVED4");}break; +case CV_SymKind_LMANDATA_ST:{result = str8_lit("LMANDATA_ST");}break; +case CV_SymKind_GMANDATA_ST:{result = str8_lit("GMANDATA_ST");}break; +case CV_SymKind_MANFRAMEREL_ST:{result = str8_lit("MANFRAMEREL_ST");}break; +case CV_SymKind_MANREGISTER_ST:{result = str8_lit("MANREGISTER_ST");}break; +case CV_SymKind_MANSLOT_ST:{result = str8_lit("MANSLOT_ST");}break; +case CV_SymKind_MANMANYREG_ST:{result = str8_lit("MANMANYREG_ST");}break; +case CV_SymKind_MANREGREL_ST:{result = str8_lit("MANREGREL_ST");}break; +case CV_SymKind_MANMANYREG2_ST:{result = str8_lit("MANMANYREG2_ST");}break; +case CV_SymKind_MANTYPREF:{result = str8_lit("MANTYPREF");}break; +case CV_SymKind_UNAMESPACE_ST:{result = str8_lit("UNAMESPACE_ST");}break; +case CV_SymKind_ST_MAX:{result = str8_lit("ST_MAX");}break; +case CV_SymKind_OBJNAME:{result = str8_lit("OBJNAME");}break; +case CV_SymKind_THUNK32:{result = str8_lit("THUNK32");}break; +case CV_SymKind_BLOCK32:{result = str8_lit("BLOCK32");}break; +case CV_SymKind_WITH32:{result = str8_lit("WITH32");}break; +case CV_SymKind_LABEL32:{result = str8_lit("LABEL32");}break; +case CV_SymKind_REGISTER:{result = str8_lit("REGISTER");}break; +case CV_SymKind_CONSTANT:{result = str8_lit("CONSTANT");}break; +case CV_SymKind_UDT:{result = str8_lit("UDT");}break; +case CV_SymKind_COBOLUDT:{result = str8_lit("COBOLUDT");}break; +case CV_SymKind_MANYREG:{result = str8_lit("MANYREG");}break; +case CV_SymKind_BPREL32:{result = str8_lit("BPREL32");}break; +case CV_SymKind_LDATA32:{result = str8_lit("LDATA32");}break; +case CV_SymKind_GDATA32:{result = str8_lit("GDATA32");}break; +case CV_SymKind_PUB32:{result = str8_lit("PUB32");}break; +case CV_SymKind_LPROC32:{result = str8_lit("LPROC32");}break; +case CV_SymKind_GPROC32:{result = str8_lit("GPROC32");}break; +case CV_SymKind_REGREL32:{result = str8_lit("REGREL32");}break; +case CV_SymKind_LTHREAD32:{result = str8_lit("LTHREAD32");}break; +case CV_SymKind_GTHREAD32:{result = str8_lit("GTHREAD32");}break; +case CV_SymKind_LPROCMIPS:{result = str8_lit("LPROCMIPS");}break; +case CV_SymKind_GPROCMIPS:{result = str8_lit("GPROCMIPS");}break; +case CV_SymKind_COMPILE2:{result = str8_lit("COMPILE2");}break; +case CV_SymKind_MANYREG2:{result = str8_lit("MANYREG2");}break; +case CV_SymKind_LPROCIA64:{result = str8_lit("LPROCIA64");}break; +case CV_SymKind_GPROCIA64:{result = str8_lit("GPROCIA64");}break; +case CV_SymKind_LOCALSLOT:{result = str8_lit("LOCALSLOT");}break; +case CV_SymKind_PARAMSLOT:{result = str8_lit("PARAMSLOT");}break; +case CV_SymKind_LMANDATA:{result = str8_lit("LMANDATA");}break; +case CV_SymKind_GMANDATA:{result = str8_lit("GMANDATA");}break; +case CV_SymKind_MANFRAMEREL:{result = str8_lit("MANFRAMEREL");}break; +case CV_SymKind_MANREGISTER:{result = str8_lit("MANREGISTER");}break; +case CV_SymKind_MANSLOT:{result = str8_lit("MANSLOT");}break; +case CV_SymKind_MANMANYREG:{result = str8_lit("MANMANYREG");}break; +case CV_SymKind_MANREGREL:{result = str8_lit("MANREGREL");}break; +case CV_SymKind_MANMANYREG2:{result = str8_lit("MANMANYREG2");}break; +case CV_SymKind_UNAMESPACE:{result = str8_lit("UNAMESPACE");}break; +case CV_SymKind_PROCREF:{result = str8_lit("PROCREF");}break; +case CV_SymKind_DATAREF:{result = str8_lit("DATAREF");}break; +case CV_SymKind_LPROCREF:{result = str8_lit("LPROCREF");}break; +case CV_SymKind_ANNOTATIONREF:{result = str8_lit("ANNOTATIONREF");}break; +case CV_SymKind_TOKENREF:{result = str8_lit("TOKENREF");}break; +case CV_SymKind_GMANPROC:{result = str8_lit("GMANPROC");}break; +case CV_SymKind_LMANPROC:{result = str8_lit("LMANPROC");}break; +case CV_SymKind_TRAMPOLINE:{result = str8_lit("TRAMPOLINE");}break; +case CV_SymKind_MANCONSTANT:{result = str8_lit("MANCONSTANT");}break; +case CV_SymKind_ATTR_FRAMEREL:{result = str8_lit("ATTR_FRAMEREL");}break; +case CV_SymKind_ATTR_REGISTER:{result = str8_lit("ATTR_REGISTER");}break; +case CV_SymKind_ATTR_REGREL:{result = str8_lit("ATTR_REGREL");}break; +case CV_SymKind_ATTR_MANYREG:{result = str8_lit("ATTR_MANYREG");}break; +case CV_SymKind_SEPCODE:{result = str8_lit("SEPCODE");}break; +case CV_SymKind_DEFRANGE_2005:{result = str8_lit("DEFRANGE_2005");}break; +case CV_SymKind_DEFRANGE2_2005:{result = str8_lit("DEFRANGE2_2005");}break; +case CV_SymKind_SECTION:{result = str8_lit("SECTION");}break; +case CV_SymKind_COFFGROUP:{result = str8_lit("COFFGROUP");}break; +case CV_SymKind_EXPORT:{result = str8_lit("EXPORT");}break; +case CV_SymKind_CALLSITEINFO:{result = str8_lit("CALLSITEINFO");}break; +case CV_SymKind_FRAMECOOKIE:{result = str8_lit("FRAMECOOKIE");}break; +case CV_SymKind_DISCARDED:{result = str8_lit("DISCARDED");}break; +case CV_SymKind_COMPILE3:{result = str8_lit("COMPILE3");}break; +case CV_SymKind_ENVBLOCK:{result = str8_lit("ENVBLOCK");}break; +case CV_SymKind_LOCAL:{result = str8_lit("LOCAL");}break; +case CV_SymKind_DEFRANGE:{result = str8_lit("DEFRANGE");}break; +case CV_SymKind_DEFRANGE_SUBFIELD:{result = str8_lit("DEFRANGE_SUBFIELD");}break; +case CV_SymKind_DEFRANGE_REGISTER:{result = str8_lit("DEFRANGE_REGISTER");}break; +case CV_SymKind_DEFRANGE_FRAMEPOINTER_REL:{result = str8_lit("DEFRANGE_FRAMEPOINTER_REL");}break; +case CV_SymKind_DEFRANGE_SUBFIELD_REGISTER:{result = str8_lit("DEFRANGE_SUBFIELD_REGISTER");}break; +case CV_SymKind_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE:{result = str8_lit("DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE");}break; +case CV_SymKind_DEFRANGE_REGISTER_REL:{result = str8_lit("DEFRANGE_REGISTER_REL");}break; +case CV_SymKind_LPROC32_ID:{result = str8_lit("LPROC32_ID");}break; +case CV_SymKind_GPROC32_ID:{result = str8_lit("GPROC32_ID");}break; +case CV_SymKind_LPROCMIPS_ID:{result = str8_lit("LPROCMIPS_ID");}break; +case CV_SymKind_GPROCMIPS_ID:{result = str8_lit("GPROCMIPS_ID");}break; +case CV_SymKind_LPROCIA64_ID:{result = str8_lit("LPROCIA64_ID");}break; +case CV_SymKind_GPROCIA64_ID:{result = str8_lit("GPROCIA64_ID");}break; +case CV_SymKind_BUILDINFO:{result = str8_lit("BUILDINFO");}break; +case CV_SymKind_INLINESITE:{result = str8_lit("INLINESITE");}break; +case CV_SymKind_INLINESITE_END:{result = str8_lit("INLINESITE_END");}break; +case CV_SymKind_PROC_ID_END:{result = str8_lit("PROC_ID_END");}break; +case CV_SymKind_DEFRANGE_HLSL:{result = str8_lit("DEFRANGE_HLSL");}break; +case CV_SymKind_GDATA_HLSL:{result = str8_lit("GDATA_HLSL");}break; +case CV_SymKind_LDATA_HLSL:{result = str8_lit("LDATA_HLSL");}break; +case CV_SymKind_FILESTATIC:{result = str8_lit("FILESTATIC");}break; +case CV_SymKind_LPROC32_DPC:{result = str8_lit("LPROC32_DPC");}break; +case CV_SymKind_LPROC32_DPC_ID:{result = str8_lit("LPROC32_DPC_ID");}break; +case CV_SymKind_DEFRANGE_DPC_PTR_TAG:{result = str8_lit("DEFRANGE_DPC_PTR_TAG");}break; +case CV_SymKind_DPC_SYM_TAG_MAP:{result = str8_lit("DPC_SYM_TAG_MAP");}break; +case CV_SymKind_ARMSWITCHTABLE:{result = str8_lit("ARMSWITCHTABLE");}break; +case CV_SymKind_CALLEES:{result = str8_lit("CALLEES");}break; +case CV_SymKind_CALLERS:{result = str8_lit("CALLERS");}break; +case CV_SymKind_POGODATA:{result = str8_lit("POGODATA");}break; +case CV_SymKind_INLINESITE2:{result = str8_lit("INLINESITE2");}break; +case CV_SymKind_HEAPALLOCSITE:{result = str8_lit("HEAPALLOCSITE");}break; +case CV_SymKind_MOD_TYPEREF:{result = str8_lit("MOD_TYPEREF");}break; +case CV_SymKind_REF_MINIPDB:{result = str8_lit("REF_MINIPDB");}break; +case CV_SymKind_PDBMAP:{result = str8_lit("PDBMAP");}break; +case CV_SymKind_GDATA_HLSL32:{result = str8_lit("GDATA_HLSL32");}break; +case CV_SymKind_LDATA_HLSL32:{result = str8_lit("LDATA_HLSL32");}break; +case CV_SymKind_GDATA_HLSL32_EX:{result = str8_lit("GDATA_HLSL32_EX");}break; +case CV_SymKind_LDATA_HLSL32_EX:{result = str8_lit("LDATA_HLSL32_EX");}break; +case CV_SymKind_FASTLINK:{result = str8_lit("FASTLINK");}break; +case CV_SymKind_INLINEES:{result = str8_lit("INLINEES");}break; +} +return result; +} + +internal String8 +cv_string_from_leaf_kind(CV_LeafKind v) +{ +String8 result = str8_lit(""); +switch(v) +{ +default:{}break; +case CV_LeafKind_MODIFIER_16t:{result = str8_lit("MODIFIER_16t");}break; +case CV_LeafKind_POINTER_16t:{result = str8_lit("POINTER_16t");}break; +case CV_LeafKind_ARRAY_16t:{result = str8_lit("ARRAY_16t");}break; +case CV_LeafKind_CLASS_16t:{result = str8_lit("CLASS_16t");}break; +case CV_LeafKind_STRUCTURE_16t:{result = str8_lit("STRUCTURE_16t");}break; +case CV_LeafKind_UNION_16t:{result = str8_lit("UNION_16t");}break; +case CV_LeafKind_ENUM_16t:{result = str8_lit("ENUM_16t");}break; +case CV_LeafKind_PROCEDURE_16t:{result = str8_lit("PROCEDURE_16t");}break; +case CV_LeafKind_MFUNCTION_16t:{result = str8_lit("MFUNCTION_16t");}break; +case CV_LeafKind_VTSHAPE:{result = str8_lit("VTSHAPE");}break; +case CV_LeafKind_COBOL0_16t:{result = str8_lit("COBOL0_16t");}break; +case CV_LeafKind_COBOL1:{result = str8_lit("COBOL1");}break; +case CV_LeafKind_BARRAY_16t:{result = str8_lit("BARRAY_16t");}break; +case CV_LeafKind_LABEL:{result = str8_lit("LABEL");}break; +case CV_LeafKind_NULL:{result = str8_lit("NULL");}break; +case CV_LeafKind_NOTTRAN:{result = str8_lit("NOTTRAN");}break; +case CV_LeafKind_DIMARRAY_16t:{result = str8_lit("DIMARRAY_16t");}break; +case CV_LeafKind_VFTPATH_16t:{result = str8_lit("VFTPATH_16t");}break; +case CV_LeafKind_PRECOMP_16t:{result = str8_lit("PRECOMP_16t");}break; +case CV_LeafKind_ENDPRECOMP:{result = str8_lit("ENDPRECOMP");}break; +case CV_LeafKind_OEM_16t:{result = str8_lit("OEM_16t");}break; +case CV_LeafKind_TYPESERVER_ST:{result = str8_lit("TYPESERVER_ST");}break; +case CV_LeafKind_SKIP_16t:{result = str8_lit("SKIP_16t");}break; +case CV_LeafKind_ARGLIST_16t:{result = str8_lit("ARGLIST_16t");}break; +case CV_LeafKind_DEFARG_16t:{result = str8_lit("DEFARG_16t");}break; +case CV_LeafKind_LIST:{result = str8_lit("LIST");}break; +case CV_LeafKind_FIELDLIST_16t:{result = str8_lit("FIELDLIST_16t");}break; +case CV_LeafKind_DERIVED_16t:{result = str8_lit("DERIVED_16t");}break; +case CV_LeafKind_BITFIELD_16t:{result = str8_lit("BITFIELD_16t");}break; +case CV_LeafKind_METHODLIST_16t:{result = str8_lit("METHODLIST_16t");}break; +case CV_LeafKind_DIMCONU_16t:{result = str8_lit("DIMCONU_16t");}break; +case CV_LeafKind_DIMCONLU_16t:{result = str8_lit("DIMCONLU_16t");}break; +case CV_LeafKind_DIMVARU_16t:{result = str8_lit("DIMVARU_16t");}break; +case CV_LeafKind_DIMVARLU_16t:{result = str8_lit("DIMVARLU_16t");}break; +case CV_LeafKind_REFSYM:{result = str8_lit("REFSYM");}break; +case CV_LeafKind_BCLASS_16t:{result = str8_lit("BCLASS_16t");}break; +case CV_LeafKind_VBCLASS_16t:{result = str8_lit("VBCLASS_16t");}break; +case CV_LeafKind_IVBCLASS_16t:{result = str8_lit("IVBCLASS_16t");}break; +case CV_LeafKind_ENUMERATE_ST:{result = str8_lit("ENUMERATE_ST");}break; +case CV_LeafKind_FRIENDFCN_16t:{result = str8_lit("FRIENDFCN_16t");}break; +case CV_LeafKind_INDEX_16t:{result = str8_lit("INDEX_16t");}break; +case CV_LeafKind_MEMBER_16t:{result = str8_lit("MEMBER_16t");}break; +case CV_LeafKind_STMEMBER_16t:{result = str8_lit("STMEMBER_16t");}break; +case CV_LeafKind_METHOD_16t:{result = str8_lit("METHOD_16t");}break; +case CV_LeafKind_NESTTYPE_16t:{result = str8_lit("NESTTYPE_16t");}break; +case CV_LeafKind_VFUNCTAB_16t:{result = str8_lit("VFUNCTAB_16t");}break; +case CV_LeafKind_FRIENDCLS_16t:{result = str8_lit("FRIENDCLS_16t");}break; +case CV_LeafKind_ONEMETHOD_16t:{result = str8_lit("ONEMETHOD_16t");}break; +case CV_LeafKind_VFUNCOFF_16t:{result = str8_lit("VFUNCOFF_16t");}break; +case CV_LeafKind_TI16_MAX:{result = str8_lit("TI16_MAX");}break; +case CV_LeafKind_MODIFIER:{result = str8_lit("MODIFIER");}break; +case CV_LeafKind_POINTER:{result = str8_lit("POINTER");}break; +case CV_LeafKind_ARRAY_ST:{result = str8_lit("ARRAY_ST");}break; +case CV_LeafKind_CLASS_ST:{result = str8_lit("CLASS_ST");}break; +case CV_LeafKind_STRUCTURE_ST:{result = str8_lit("STRUCTURE_ST");}break; +case CV_LeafKind_UNION_ST:{result = str8_lit("UNION_ST");}break; +case CV_LeafKind_ENUM_ST:{result = str8_lit("ENUM_ST");}break; +case CV_LeafKind_PROCEDURE:{result = str8_lit("PROCEDURE");}break; +case CV_LeafKind_MFUNCTION:{result = str8_lit("MFUNCTION");}break; +case CV_LeafKind_COBOL0:{result = str8_lit("COBOL0");}break; +case CV_LeafKind_BARRAY:{result = str8_lit("BARRAY");}break; +case CV_LeafKind_DIMARRAY_ST:{result = str8_lit("DIMARRAY_ST");}break; +case CV_LeafKind_VFTPATH:{result = str8_lit("VFTPATH");}break; +case CV_LeafKind_PRECOMP_ST:{result = str8_lit("PRECOMP_ST");}break; +case CV_LeafKind_OEM:{result = str8_lit("OEM");}break; +case CV_LeafKind_ALIAS_ST:{result = str8_lit("ALIAS_ST");}break; +case CV_LeafKind_OEM2:{result = str8_lit("OEM2");}break; +case CV_LeafKind_SKIP:{result = str8_lit("SKIP");}break; +case CV_LeafKind_ARGLIST:{result = str8_lit("ARGLIST");}break; +case CV_LeafKind_DEFARG_ST:{result = str8_lit("DEFARG_ST");}break; +case CV_LeafKind_FIELDLIST:{result = str8_lit("FIELDLIST");}break; +case CV_LeafKind_DERIVED:{result = str8_lit("DERIVED");}break; +case CV_LeafKind_BITFIELD:{result = str8_lit("BITFIELD");}break; +case CV_LeafKind_METHODLIST:{result = str8_lit("METHODLIST");}break; +case CV_LeafKind_DIMCONU:{result = str8_lit("DIMCONU");}break; +case CV_LeafKind_DIMCONLU:{result = str8_lit("DIMCONLU");}break; +case CV_LeafKind_DIMVARU:{result = str8_lit("DIMVARU");}break; +case CV_LeafKind_DIMVARLU:{result = str8_lit("DIMVARLU");}break; +case CV_LeafKind_BCLASS:{result = str8_lit("BCLASS");}break; +case CV_LeafKind_VBCLASS:{result = str8_lit("VBCLASS");}break; +case CV_LeafKind_IVBCLASS:{result = str8_lit("IVBCLASS");}break; +case CV_LeafKind_FRIENDFCN_ST:{result = str8_lit("FRIENDFCN_ST");}break; +case CV_LeafKind_INDEX:{result = str8_lit("INDEX");}break; +case CV_LeafKind_MEMBER_ST:{result = str8_lit("MEMBER_ST");}break; +case CV_LeafKind_STMEMBER_ST:{result = str8_lit("STMEMBER_ST");}break; +case CV_LeafKind_METHOD_ST:{result = str8_lit("METHOD_ST");}break; +case CV_LeafKind_NESTTYPE_ST:{result = str8_lit("NESTTYPE_ST");}break; +case CV_LeafKind_VFUNCTAB:{result = str8_lit("VFUNCTAB");}break; +case CV_LeafKind_FRIENDCLS:{result = str8_lit("FRIENDCLS");}break; +case CV_LeafKind_ONEMETHOD_ST:{result = str8_lit("ONEMETHOD_ST");}break; +case CV_LeafKind_VFUNCOFF:{result = str8_lit("VFUNCOFF");}break; +case CV_LeafKind_NESTTYPEEX_ST:{result = str8_lit("NESTTYPEEX_ST");}break; +case CV_LeafKind_MEMBERMODIFY_ST:{result = str8_lit("MEMBERMODIFY_ST");}break; +case CV_LeafKind_MANAGED_ST:{result = str8_lit("MANAGED_ST");}break; +case CV_LeafKind_ST_MAX:{result = str8_lit("ST_MAX");}break; +case CV_LeafKind_TYPESERVER:{result = str8_lit("TYPESERVER");}break; +case CV_LeafKind_ENUMERATE:{result = str8_lit("ENUMERATE");}break; +case CV_LeafKind_ARRAY:{result = str8_lit("ARRAY");}break; +case CV_LeafKind_CLASS:{result = str8_lit("CLASS");}break; +case CV_LeafKind_STRUCTURE:{result = str8_lit("STRUCTURE");}break; +case CV_LeafKind_UNION:{result = str8_lit("UNION");}break; +case CV_LeafKind_ENUM:{result = str8_lit("ENUM");}break; +case CV_LeafKind_DIMARRAY:{result = str8_lit("DIMARRAY");}break; +case CV_LeafKind_PRECOMP:{result = str8_lit("PRECOMP");}break; +case CV_LeafKind_ALIAS:{result = str8_lit("ALIAS");}break; +case CV_LeafKind_DEFARG:{result = str8_lit("DEFARG");}break; +case CV_LeafKind_FRIENDFCN:{result = str8_lit("FRIENDFCN");}break; +case CV_LeafKind_MEMBER:{result = str8_lit("MEMBER");}break; +case CV_LeafKind_STMEMBER:{result = str8_lit("STMEMBER");}break; +case CV_LeafKind_METHOD:{result = str8_lit("METHOD");}break; +case CV_LeafKind_NESTTYPE:{result = str8_lit("NESTTYPE");}break; +case CV_LeafKind_ONEMETHOD:{result = str8_lit("ONEMETHOD");}break; +case CV_LeafKind_NESTTYPEEX:{result = str8_lit("NESTTYPEEX");}break; +case CV_LeafKind_MEMBERMODIFY:{result = str8_lit("MEMBERMODIFY");}break; +case CV_LeafKind_MANAGED:{result = str8_lit("MANAGED");}break; +case CV_LeafKind_TYPESERVER2:{result = str8_lit("TYPESERVER2");}break; +case CV_LeafKind_STRIDED_ARRAY:{result = str8_lit("STRIDED_ARRAY");}break; +case CV_LeafKind_HLSL:{result = str8_lit("HLSL");}break; +case CV_LeafKind_MODIFIER_EX:{result = str8_lit("MODIFIER_EX");}break; +case CV_LeafKind_INTERFACE:{result = str8_lit("INTERFACE");}break; +case CV_LeafKind_BINTERFACE:{result = str8_lit("BINTERFACE");}break; +case CV_LeafKind_VECTOR:{result = str8_lit("VECTOR");}break; +case CV_LeafKind_MATRIX:{result = str8_lit("MATRIX");}break; +case CV_LeafKind_VFTABLE:{result = str8_lit("VFTABLE");}break; +case CV_LeafKind_CLASS2:{result = str8_lit("CLASS2");}break; +case CV_LeafKind_STRUCT2:{result = str8_lit("STRUCT2");}break; +} +return result; +} + +C_LINKAGE_BEGIN +C_LINKAGE_END + diff --git a/src/codeview/generated/codeview.meta.h b/src/codeview/generated/codeview.meta.h new file mode 100644 index 00000000..a04b4f8c --- /dev/null +++ b/src/codeview/generated/codeview.meta.h @@ -0,0 +1,461 @@ +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//- GENERATED CODE + +#ifndef CODEVIEW_META_H +#define CODEVIEW_META_H + +typedef U16 CV_NumericKind; +typedef enum CV_NumericKindEnum +{ +CV_NumericKind_CHAR = 0x8000, +CV_NumericKind_SHORT = 0x8001, +CV_NumericKind_USHORT = 0x8002, +CV_NumericKind_LONG = 0x8003, +CV_NumericKind_ULONG = 0x8004, +CV_NumericKind_FLOAT32 = 0x8005, +CV_NumericKind_FLOAT64 = 0x8006, +CV_NumericKind_FLOAT80 = 0x8007, +CV_NumericKind_FLOAT128 = 0x8008, +CV_NumericKind_QUADWORD = 0x8009, +CV_NumericKind_UQUADWORD = 0x800a, +CV_NumericKind_FLOAT48 = 0x800b, +CV_NumericKind_COMPLEX32 = 0x800c, +CV_NumericKind_COMPLEX64 = 0x800d, +CV_NumericKind_COMPLEX80 = 0x800e, +CV_NumericKind_COMPLEX128 = 0x800f, +CV_NumericKind_VARSTRING = 0x8010, +CV_NumericKind_OCTWORD = 0x8017, +CV_NumericKind_UOCTWORD = 0x8018, +CV_NumericKind_DECIMAL = 0x8019, +CV_NumericKind_DATE = 0x801a, +CV_NumericKind_UTF8STRING = 0x801b, +CV_NumericKind_FLOAT16 = 0x801c, +} CV_NumericKindEnum; + +typedef U16 CV_Arch; +typedef enum CV_ArchEnum +{ +CV_Arch_8080 = 0x00, +CV_Arch_8086 = 0x01, +CV_Arch_80286 = 0x02, +CV_Arch_80386 = 0x03, +CV_Arch_80486 = 0x04, +CV_Arch_PENTIUM = 0x05, +CV_Arch_PENTIUMII = 0x06, +CV_Arch_PENTIUMIII = 0x07, +CV_Arch_MIPS = 0x10, +CV_Arch_MIPS16 = 0x11, +CV_Arch_MIPS32 = 0x12, +CV_Arch_MIPS64 = 0x13, +CV_Arch_MIPSI = 0x14, +CV_Arch_MIPSII = 0x15, +CV_Arch_MIPSIII = 0x16, +CV_Arch_MIPSIV = 0x17, +CV_Arch_MIPSV = 0x18, +CV_Arch_M68000 = 0x20, +CV_Arch_M68010 = 0x21, +CV_Arch_M68020 = 0x22, +CV_Arch_M68030 = 0x23, +CV_Arch_M68040 = 0x24, +CV_Arch_ALPHA = 0x30, +CV_Arch_ALPHA_21164 = 0x31, +CV_Arch_ALPHA_21164A = 0x32, +CV_Arch_ALPHA_21264 = 0x33, +CV_Arch_ALPHA_21364 = 0x34, +CV_Arch_PPC601 = 0x40, +CV_Arch_PPC603 = 0x41, +CV_Arch_PPC604 = 0x42, +CV_Arch_PPC620 = 0x43, +CV_Arch_PPCFP = 0x44, +CV_Arch_PPCBE = 0x45, +CV_Arch_SH3 = 0x50, +CV_Arch_SH3E = 0x51, +CV_Arch_SH3DSP = 0x52, +CV_Arch_SH4 = 0x53, +CV_Arch_SHMEDIA = 0x54, +CV_Arch_ARM3 = 0x60, +CV_Arch_ARM4 = 0x61, +CV_Arch_ARM4T = 0x62, +CV_Arch_ARM5 = 0x63, +CV_Arch_ARM5T = 0x64, +CV_Arch_ARM6 = 0x65, +CV_Arch_ARM_XMAC = 0x66, +CV_Arch_ARM_WMMX = 0x67, +CV_Arch_ARM7 = 0x68, +CV_Arch_OMNI = 0x70, +CV_Arch_IA64_1 = 0x80, +CV_Arch_IA64_2 = 0x81, +CV_Arch_CEE = 0x90, +CV_Arch_AM33 = 0xA0, +CV_Arch_M32R = 0xB0, +CV_Arch_TRICORE = 0xC0, +CV_Arch_X64 = 0xD0, +CV_Arch_EBC = 0xE0, +CV_Arch_THUMB = 0xF0, +CV_Arch_ARMNT = 0xF4, +CV_Arch_ARM64 = 0xF6, +CV_Arch_D3D11_SHADER = 0x100, +CV_Arch_IA64 = CV_Arch_IA64_1, +CV_Arch_PENTIUMPRO = CV_Arch_PENTIUMII, +CV_Arch_MIPSR4000 = CV_Arch_MIPS, +CV_Arch_ALPHA_21064 = CV_Arch_ALPHA, +CV_Arch_AMD64 = CV_Arch_X64, +} CV_ArchEnum; + +typedef U16 CV_AllReg; +typedef enum CV_AllRegEnum +{ +CV_AllReg_ERR = 30000, +CV_AllReg_TEB = 30001, +CV_AllReg_TIMER = 30002, +CV_AllReg_EFAD1 = 30003, +CV_AllReg_EFAD2 = 30004, +CV_AllReg_EFAD3 = 30005, +CV_AllReg_VFRAME = 30006, +CV_AllReg_HANDLE = 30007, +CV_AllReg_PARAMS = 30008, +CV_AllReg_LOCALS = 30009, +CV_AllReg_TID = 30010, +CV_AllReg_ENV = 30011, +CV_AllReg_CMDLN = 30012, +} CV_AllRegEnum; + +typedef U16 CV_SymKind; +typedef enum CV_SymKindEnum +{ +CV_SymKind_COMPILE = 0x0001, +CV_SymKind_REGISTER_16t = 0x0002, +CV_SymKind_CONSTANT_16t = 0x0003, +CV_SymKind_UDT_16t = 0x0004, +CV_SymKind_SSEARCH = 0x0005, +CV_SymKind_END = 0x0006, +CV_SymKind_SKIP = 0x0007, +CV_SymKind_CVRESERVE = 0x0008, +CV_SymKind_OBJNAME_ST = 0x0009, +CV_SymKind_ENDARG = 0x000a, +CV_SymKind_COBOLUDT_16t = 0x000b, +CV_SymKind_MANYREG_16t = 0x000c, +CV_SymKind_RETURN = 0x000d, +CV_SymKind_ENTRYTHIS = 0x000e, +CV_SymKind_BPREL16 = 0x0100, +CV_SymKind_LDATA16 = 0x0101, +CV_SymKind_GDATA16 = 0x0102, +CV_SymKind_PUB16 = 0x0103, +CV_SymKind_LPROC16 = 0x0104, +CV_SymKind_GPROC16 = 0x0105, +CV_SymKind_THUNK16 = 0x0106, +CV_SymKind_BLOCK16 = 0x0107, +CV_SymKind_WITH16 = 0x0108, +CV_SymKind_LABEL16 = 0x0109, +CV_SymKind_CEXMODEL16 = 0x010a, +CV_SymKind_VFTABLE16 = 0x010b, +CV_SymKind_REGREL16 = 0x010c, +CV_SymKind_BPREL32_16t = 0x0200, +CV_SymKind_LDATA32_16t = 0x0201, +CV_SymKind_GDATA32_16t = 0x0202, +CV_SymKind_PUB32_16t = 0x0203, +CV_SymKind_LPROC32_16t = 0x0204, +CV_SymKind_GPROC32_16t = 0x0205, +CV_SymKind_THUNK32_ST = 0x0206, +CV_SymKind_BLOCK32_ST = 0x0207, +CV_SymKind_WITH32_ST = 0x0208, +CV_SymKind_LABEL32_ST = 0x0209, +CV_SymKind_CEXMODEL32 = 0x020a, +CV_SymKind_VFTABLE32_16t = 0x020b, +CV_SymKind_REGREL32_16t = 0x020c, +CV_SymKind_LTHREAD32_16t = 0x020d, +CV_SymKind_GTHREAD32_16t = 0x020e, +CV_SymKind_SLINK32 = 0x020f, +CV_SymKind_LPROCMIPS_16t = 0x0300, +CV_SymKind_GPROCMIPS_16t = 0x0301, +CV_SymKind_PROCREF_ST = 0x0400, +CV_SymKind_DATAREF_ST = 0x0401, +CV_SymKind_ALIGN = 0x0402, +CV_SymKind_LPROCREF_ST = 0x0403, +CV_SymKind_OEM = 0x0404, +CV_SymKind_TI16_MAX = 0x1000, +CV_SymKind_CONSTANT_ST = 0x1002, +CV_SymKind_UDT_ST = 0x1003, +CV_SymKind_COBOLUDT_ST = 0x1004, +CV_SymKind_MANYREG_ST = 0x1005, +CV_SymKind_BPREL32_ST = 0x1006, +CV_SymKind_LDATA32_ST = 0x1007, +CV_SymKind_GDATA32_ST = 0x1008, +CV_SymKind_PUB32_ST = 0x1009, +CV_SymKind_LPROC32_ST = 0x100a, +CV_SymKind_GPROC32_ST = 0x100b, +CV_SymKind_VFTABLE32 = 0x100c, +CV_SymKind_REGREL32_ST = 0x100d, +CV_SymKind_LTHREAD32_ST = 0x100e, +CV_SymKind_GTHREAD32_ST = 0x100f, +CV_SymKind_LPROCMIPS_ST = 0x1010, +CV_SymKind_GPROCMIPS_ST = 0x1011, +CV_SymKind_FRAMEPROC = 0x1012, +CV_SymKind_COMPILE2_ST = 0x1013, +CV_SymKind_MANYREG2_ST = 0x1014, +CV_SymKind_LPROCIA64_ST = 0x1015, +CV_SymKind_GPROCIA64_ST = 0x1016, +CV_SymKind_LOCALSLOT_ST = 0x1017, +CV_SymKind_PARAMSLOT_ST = 0x1018, +CV_SymKind_ANNOTATION = 0x1019, +CV_SymKind_GMANPROC_ST = 0x101a, +CV_SymKind_LMANPROC_ST = 0x101b, +CV_SymKind_RESERVED1 = 0x101c, +CV_SymKind_RESERVED2 = 0x101d, +CV_SymKind_RESERVED3 = 0x101e, +CV_SymKind_RESERVED4 = 0x101f, +CV_SymKind_LMANDATA_ST = 0x1020, +CV_SymKind_GMANDATA_ST = 0x1021, +CV_SymKind_MANFRAMEREL_ST = 0x1022, +CV_SymKind_MANREGISTER_ST = 0x1023, +CV_SymKind_MANSLOT_ST = 0x1024, +CV_SymKind_MANMANYREG_ST = 0x1025, +CV_SymKind_MANREGREL_ST = 0x1026, +CV_SymKind_MANMANYREG2_ST = 0x1027, +CV_SymKind_MANTYPREF = 0x1028, +CV_SymKind_UNAMESPACE_ST = 0x1029, +CV_SymKind_ST_MAX = 0x1100, +CV_SymKind_OBJNAME = 0x1101, +CV_SymKind_THUNK32 = 0x1102, +CV_SymKind_BLOCK32 = 0x1103, +CV_SymKind_WITH32 = 0x1104, +CV_SymKind_LABEL32 = 0x1105, +CV_SymKind_REGISTER = 0x1106, +CV_SymKind_CONSTANT = 0x1107, +CV_SymKind_UDT = 0x1108, +CV_SymKind_COBOLUDT = 0x1109, +CV_SymKind_MANYREG = 0x110a, +CV_SymKind_BPREL32 = 0x110b, +CV_SymKind_LDATA32 = 0x110c, +CV_SymKind_GDATA32 = 0x110d, +CV_SymKind_PUB32 = 0x110e, +CV_SymKind_LPROC32 = 0x110f, +CV_SymKind_GPROC32 = 0x1110, +CV_SymKind_REGREL32 = 0x1111, +CV_SymKind_LTHREAD32 = 0x1112, +CV_SymKind_GTHREAD32 = 0x1113, +CV_SymKind_LPROCMIPS = 0x1114, +CV_SymKind_GPROCMIPS = 0x1115, +CV_SymKind_COMPILE2 = 0x1116, +CV_SymKind_MANYREG2 = 0x1117, +CV_SymKind_LPROCIA64 = 0x1118, +CV_SymKind_GPROCIA64 = 0x1119, +CV_SymKind_LOCALSLOT = 0x111a, +CV_SymKind_PARAMSLOT = 0x111b, +CV_SymKind_LMANDATA = 0x111c, +CV_SymKind_GMANDATA = 0x111d, +CV_SymKind_MANFRAMEREL = 0x111e, +CV_SymKind_MANREGISTER = 0x111f, +CV_SymKind_MANSLOT = 0x1120, +CV_SymKind_MANMANYREG = 0x1121, +CV_SymKind_MANREGREL = 0x1122, +CV_SymKind_MANMANYREG2 = 0x1123, +CV_SymKind_UNAMESPACE = 0x1124, +CV_SymKind_PROCREF = 0x1125, +CV_SymKind_DATAREF = 0x1126, +CV_SymKind_LPROCREF = 0x1127, +CV_SymKind_ANNOTATIONREF = 0x1128, +CV_SymKind_TOKENREF = 0x1129, +CV_SymKind_GMANPROC = 0x112a, +CV_SymKind_LMANPROC = 0x112b, +CV_SymKind_TRAMPOLINE = 0x112c, +CV_SymKind_MANCONSTANT = 0x112d, +CV_SymKind_ATTR_FRAMEREL = 0x112e, +CV_SymKind_ATTR_REGISTER = 0x112f, +CV_SymKind_ATTR_REGREL = 0x1130, +CV_SymKind_ATTR_MANYREG = 0x1131, +CV_SymKind_SEPCODE = 0x1132, +CV_SymKind_DEFRANGE_2005 = 0x1134, +CV_SymKind_DEFRANGE2_2005 = 0x1135, +CV_SymKind_SECTION = 0x1136, +CV_SymKind_COFFGROUP = 0x1137, +CV_SymKind_EXPORT = 0x1138, +CV_SymKind_CALLSITEINFO = 0x1139, +CV_SymKind_FRAMECOOKIE = 0x113a, +CV_SymKind_DISCARDED = 0x113b, +CV_SymKind_COMPILE3 = 0x113c, +CV_SymKind_ENVBLOCK = 0x113d, +CV_SymKind_LOCAL = 0x113e, +CV_SymKind_DEFRANGE = 0x113f, +CV_SymKind_DEFRANGE_SUBFIELD = 0x1140, +CV_SymKind_DEFRANGE_REGISTER = 0x1141, +CV_SymKind_DEFRANGE_FRAMEPOINTER_REL = 0x1142, +CV_SymKind_DEFRANGE_SUBFIELD_REGISTER = 0x1143, +CV_SymKind_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE = 0x1144, +CV_SymKind_DEFRANGE_REGISTER_REL = 0x1145, +CV_SymKind_LPROC32_ID = 0x1146, +CV_SymKind_GPROC32_ID = 0x1147, +CV_SymKind_LPROCMIPS_ID = 0x1148, +CV_SymKind_GPROCMIPS_ID = 0x1149, +CV_SymKind_LPROCIA64_ID = 0x114a, +CV_SymKind_GPROCIA64_ID = 0x114b, +CV_SymKind_BUILDINFO = 0x114c, +CV_SymKind_INLINESITE = 0x114d, +CV_SymKind_INLINESITE_END = 0x114e, +CV_SymKind_PROC_ID_END = 0x114f, +CV_SymKind_DEFRANGE_HLSL = 0x1150, +CV_SymKind_GDATA_HLSL = 0x1151, +CV_SymKind_LDATA_HLSL = 0x1152, +CV_SymKind_FILESTATIC = 0x1153, +CV_SymKind_LPROC32_DPC = 0x1155, +CV_SymKind_LPROC32_DPC_ID = 0x1156, +CV_SymKind_DEFRANGE_DPC_PTR_TAG = 0x1157, +CV_SymKind_DPC_SYM_TAG_MAP = 0x1158, +CV_SymKind_ARMSWITCHTABLE = 0x1159, +CV_SymKind_CALLEES = 0x115a, +CV_SymKind_CALLERS = 0x115b, +CV_SymKind_POGODATA = 0x115c, +CV_SymKind_INLINESITE2 = 0x115d, +CV_SymKind_HEAPALLOCSITE = 0x115e, +CV_SymKind_MOD_TYPEREF = 0x115f, +CV_SymKind_REF_MINIPDB = 0x1160, +CV_SymKind_PDBMAP = 0x1161, +CV_SymKind_GDATA_HLSL32 = 0x1162, +CV_SymKind_LDATA_HLSL32 = 0x1163, +CV_SymKind_GDATA_HLSL32_EX = 0x1164, +CV_SymKind_LDATA_HLSL32_EX = 0x1165, +CV_SymKind_FASTLINK = 0x1167, +CV_SymKind_INLINEES = 0x1168, +} CV_SymKindEnum; + +typedef U16 CV_LeafKind; +typedef enum CV_LeafKindEnum +{ +CV_LeafKind_MODIFIER_16t = 0x0001, +CV_LeafKind_POINTER_16t = 0x0002, +CV_LeafKind_ARRAY_16t = 0x0003, +CV_LeafKind_CLASS_16t = 0x0004, +CV_LeafKind_STRUCTURE_16t = 0x0005, +CV_LeafKind_UNION_16t = 0x0006, +CV_LeafKind_ENUM_16t = 0x0007, +CV_LeafKind_PROCEDURE_16t = 0x0008, +CV_LeafKind_MFUNCTION_16t = 0x0009, +CV_LeafKind_VTSHAPE = 0x000a, +CV_LeafKind_COBOL0_16t = 0x000b, +CV_LeafKind_COBOL1 = 0x000c, +CV_LeafKind_BARRAY_16t = 0x000d, +CV_LeafKind_LABEL = 0x000e, +CV_LeafKind_NULL = 0x000f, +CV_LeafKind_NOTTRAN = 0x0010, +CV_LeafKind_DIMARRAY_16t = 0x0011, +CV_LeafKind_VFTPATH_16t = 0x0012, +CV_LeafKind_PRECOMP_16t = 0x0013, +CV_LeafKind_ENDPRECOMP = 0x0014, +CV_LeafKind_OEM_16t = 0x0015, +CV_LeafKind_TYPESERVER_ST = 0x0016, +CV_LeafKind_SKIP_16t = 0x0200, +CV_LeafKind_ARGLIST_16t = 0x0201, +CV_LeafKind_DEFARG_16t = 0x0202, +CV_LeafKind_LIST = 0x0203, +CV_LeafKind_FIELDLIST_16t = 0x0204, +CV_LeafKind_DERIVED_16t = 0x0205, +CV_LeafKind_BITFIELD_16t = 0x0206, +CV_LeafKind_METHODLIST_16t = 0x0207, +CV_LeafKind_DIMCONU_16t = 0x0208, +CV_LeafKind_DIMCONLU_16t = 0x0209, +CV_LeafKind_DIMVARU_16t = 0x020a, +CV_LeafKind_DIMVARLU_16t = 0x020b, +CV_LeafKind_REFSYM = 0x020c, +CV_LeafKind_BCLASS_16t = 0x0400, +CV_LeafKind_VBCLASS_16t = 0x0401, +CV_LeafKind_IVBCLASS_16t = 0x0402, +CV_LeafKind_ENUMERATE_ST = 0x0403, +CV_LeafKind_FRIENDFCN_16t = 0x0404, +CV_LeafKind_INDEX_16t = 0x0405, +CV_LeafKind_MEMBER_16t = 0x0406, +CV_LeafKind_STMEMBER_16t = 0x0407, +CV_LeafKind_METHOD_16t = 0x0408, +CV_LeafKind_NESTTYPE_16t = 0x0409, +CV_LeafKind_VFUNCTAB_16t = 0x040a, +CV_LeafKind_FRIENDCLS_16t = 0x040b, +CV_LeafKind_ONEMETHOD_16t = 0x040c, +CV_LeafKind_VFUNCOFF_16t = 0x040d, +CV_LeafKind_TI16_MAX = 0x1000, +CV_LeafKind_MODIFIER = 0x1001, +CV_LeafKind_POINTER = 0x1002, +CV_LeafKind_ARRAY_ST = 0x1003, +CV_LeafKind_CLASS_ST = 0x1004, +CV_LeafKind_STRUCTURE_ST = 0x1005, +CV_LeafKind_UNION_ST = 0x1006, +CV_LeafKind_ENUM_ST = 0x1007, +CV_LeafKind_PROCEDURE = 0x1008, +CV_LeafKind_MFUNCTION = 0x1009, +CV_LeafKind_COBOL0 = 0x100a, +CV_LeafKind_BARRAY = 0x100b, +CV_LeafKind_DIMARRAY_ST = 0x100c, +CV_LeafKind_VFTPATH = 0x100d, +CV_LeafKind_PRECOMP_ST = 0x100e, +CV_LeafKind_OEM = 0x100f, +CV_LeafKind_ALIAS_ST = 0x1010, +CV_LeafKind_OEM2 = 0x1011, +CV_LeafKind_SKIP = 0x1200, +CV_LeafKind_ARGLIST = 0x1201, +CV_LeafKind_DEFARG_ST = 0x1202, +CV_LeafKind_FIELDLIST = 0x1203, +CV_LeafKind_DERIVED = 0x1204, +CV_LeafKind_BITFIELD = 0x1205, +CV_LeafKind_METHODLIST = 0x1206, +CV_LeafKind_DIMCONU = 0x1207, +CV_LeafKind_DIMCONLU = 0x1208, +CV_LeafKind_DIMVARU = 0x1209, +CV_LeafKind_DIMVARLU = 0x120a, +CV_LeafKind_BCLASS = 0x1400, +CV_LeafKind_VBCLASS = 0x1401, +CV_LeafKind_IVBCLASS = 0x1402, +CV_LeafKind_FRIENDFCN_ST = 0x1403, +CV_LeafKind_INDEX = 0x1404, +CV_LeafKind_MEMBER_ST = 0x1405, +CV_LeafKind_STMEMBER_ST = 0x1406, +CV_LeafKind_METHOD_ST = 0x1407, +CV_LeafKind_NESTTYPE_ST = 0x1408, +CV_LeafKind_VFUNCTAB = 0x1409, +CV_LeafKind_FRIENDCLS = 0x140a, +CV_LeafKind_ONEMETHOD_ST = 0x140b, +CV_LeafKind_VFUNCOFF = 0x140c, +CV_LeafKind_NESTTYPEEX_ST = 0x140d, +CV_LeafKind_MEMBERMODIFY_ST = 0x140e, +CV_LeafKind_MANAGED_ST = 0x140f, +CV_LeafKind_ST_MAX = 0x1500, +CV_LeafKind_TYPESERVER = 0x1501, +CV_LeafKind_ENUMERATE = 0x1502, +CV_LeafKind_ARRAY = 0x1503, +CV_LeafKind_CLASS = 0x1504, +CV_LeafKind_STRUCTURE = 0x1505, +CV_LeafKind_UNION = 0x1506, +CV_LeafKind_ENUM = 0x1507, +CV_LeafKind_DIMARRAY = 0x1508, +CV_LeafKind_PRECOMP = 0x1509, +CV_LeafKind_ALIAS = 0x150a, +CV_LeafKind_DEFARG = 0x150b, +CV_LeafKind_FRIENDFCN = 0x150c, +CV_LeafKind_MEMBER = 0x150d, +CV_LeafKind_STMEMBER = 0x150e, +CV_LeafKind_METHOD = 0x150f, +CV_LeafKind_NESTTYPE = 0x1510, +CV_LeafKind_ONEMETHOD = 0x1511, +CV_LeafKind_NESTTYPEEX = 0x1512, +CV_LeafKind_MEMBERMODIFY = 0x1513, +CV_LeafKind_MANAGED = 0x1514, +CV_LeafKind_TYPESERVER2 = 0x1515, +CV_LeafKind_STRIDED_ARRAY = 0x1516, +CV_LeafKind_HLSL = 0x1517, +CV_LeafKind_MODIFIER_EX = 0x1518, +CV_LeafKind_INTERFACE = 0x1519, +CV_LeafKind_BINTERFACE = 0x151a, +CV_LeafKind_VECTOR = 0x151b, +CV_LeafKind_MATRIX = 0x151c, +CV_LeafKind_VFTABLE = 0x151d, +CV_LeafKind_CLASS2 = 0x1608, +CV_LeafKind_STRUCT2 = 0x1609, +} CV_LeafKindEnum; + +internal String8 cv_string_from_numeric_kind(CV_NumericKind v); +internal String8 cv_string_from_arch(CV_Arch v); +internal String8 cv_string_from_sym_kind(CV_SymKind v); +internal String8 cv_string_from_leaf_kind(CV_LeafKind v); +C_LINKAGE_BEGIN +C_LINKAGE_END + +#endif // CODEVIEW_META_H diff --git a/src/df/core/df_core.mdesk b/src/df/core/df_core.mdesk index 05ffc66c..c34dcd9a 100644 --- a/src/df/core/df_core.mdesk +++ b/src/df/core/df_core.mdesk @@ -1796,7 +1796,7 @@ DF_DevToggleTable: //- rjf: core view rule function prototypes -@table_gen +@gen { @expand(DF_CoreViewRuleTable a) `$(a.er == "x" -> "DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_DEF(" .. a.name_lower .. ");")`; @expand(DF_CoreViewRuleTable a) `$(a.vb == "x" -> "DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_DEF(" .. a.name_lower .. ");")`; @@ -1827,7 +1827,7 @@ DF_DevToggleTable: //- rjf: instruction metadata table -@table_gen +@gen { ``; `struct{String8 mnemonic; String8 summary;} df_g_inst_table_x64[] =`; @@ -1839,12 +1839,12 @@ DF_DevToggleTable: //- rjf: developer toggles -@table_gen +@gen { @expand(DF_DevToggleTable a) `global B32 DEV_$(a.name) = 0;` } -@table_gen +@gen { `struct {B32 *value_ptr; String8 name;} DEV_toggle_table[] =`; `{`; diff --git a/src/df/gfx/df_gfx.mdesk b/src/df/gfx/df_gfx.mdesk index bccbe663..ba56a42d 100644 --- a/src/df/gfx/df_gfx.mdesk +++ b/src/df/gfx/df_gfx.mdesk @@ -518,7 +518,7 @@ DF_ThemePresetColorTable: //- rjf: view hook forward declares -@table_gen +@gen { @expand(DF_GfxViewTable a) `DF_VIEW_SETUP_FUNCTION_DEF($(a.name));`; @expand(DF_GfxViewTable a) `DF_VIEW_STRING_FROM_STATE_FUNCTION_DEF($(a.name));`; @@ -528,7 +528,7 @@ DF_ThemePresetColorTable: //- rjf: gfx view rule function forward declares -@table_gen +@gen { ``; @expand(DF_GfxViewRuleTable a) diff --git a/src/draw/draw.mdesk b/src/draw/draw.mdesk index bba9861e..cc4be4f2 100644 --- a/src/draw/draw.mdesk +++ b/src/draw/draw.mdesk @@ -10,31 +10,31 @@ D_StackTable: {Transparency transparency F32 `0` } } -@table_gen +@gen { @expand(D_StackTable a) `typedef struct D_$(a.name)Node D_$(a.name)Node; struct D_$(a.name)Node {D_$(a.name)Node *next; $(a.type) v;};`; } -@table_gen +@gen { `#define D_BucketStackDecls struct{\\`; @expand(D_StackTable a) `D_$(a.name)Node *top_$(a.name_lower);\\`; `}`; } -@table_gen +@gen { @expand(D_StackTable a) `read_only global D_$(a.name)Node d_nil_$(a.name_lower) = {0, $(a.default_init)};`; } -@table_gen +@gen { `#define D_BucketStackInits(b) do{\\`; @expand(D_StackTable a) `(b)->top_$(a.name_lower) = &d_nil_$(a.name_lower);\\`; `}while(0)`; } -@table_gen +@gen { `#if 0`; @expand(D_StackTable a) `internal $(a.type) $(=>35) d_push_$(a.name_lower)($(a.type) v);`; @@ -43,14 +43,14 @@ D_StackTable: `#endif`; } -@table_gen @c_file +@gen @c_file { @expand(D_StackTable a) `internal $(a.type) $(=>35) d_push_$(a.name_lower)($(a.type) v) {D_StackPushImpl($(a.name), $(a.name_lower), $(a.type), v);}`; @expand(D_StackTable a) `internal $(a.type) $(=>35) d_pop_$(a.name_lower)(void) {D_StackPopImpl($(a.name), $(a.name_lower), $(a.type));}`; @expand(D_StackTable a) `internal $(a.type) $(=>35) d_top_$(a.name_lower)(void) {D_StackTopImpl($(a.name), $(a.name_lower), $(a.type));}`; } -@table_gen +@gen { `#if 0`; @expand(D_StackTable a) `#define D_$(a.name)Scope(v) $(=>35) DeferLoop(d_push_$(a.name_lower)(v), d_pop_$(a.name_lower)())`; diff --git a/src/metagen/metagen_main.c b/src/metagen/metagen_main.c index 077cca34..1ab89502 100644 --- a/src/metagen/metagen_main.c +++ b/src/metagen/metagen_main.c @@ -211,7 +211,7 @@ int main(int argument_count, char **arguments) } ////////////////////////////// - //- rjf: generate table data tables + //- rjf: generate data tables // for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) { @@ -241,19 +241,58 @@ int main(int argument_count, char **arguments) } ////////////////////////////// - //- rjf: generate table catch-all generations + //- rjf: generate enum -> string mapping functions // for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) { MD_Node *file = n->v.root; for(MD_EachNode(node, file->first)) { - MD_Node *tag = md_tag_from_string(node, str8_lit("table_gen"), 0); + MD_Node *tag = md_tag_from_string(node, str8_lit("enum2string_switch"), 0); + if(!md_node_is_nil(tag)) + { + String8 enum_type = tag->first->string; + String8 layer_key = mg_layer_key_from_path(file->string); + MG_Layer *layer = mg_layer_from_key(layer_key); + String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node); + str8_list_pushf(mg_arena, &layer->h_functions, "internal String8 %S(%S v);\n", node->string, enum_type); + str8_list_pushf(mg_arena, &layer->c_functions, "internal String8\n%S(%S v)\n{\n", node->string, enum_type); + str8_list_pushf(mg_arena, &layer->c_functions, "String8 result = str8_lit(\"\");\n", enum_type); + str8_list_pushf(mg_arena, &layer->c_functions, "switch(v)\n"); + str8_list_pushf(mg_arena, &layer->c_functions, "{\n"); + str8_list_pushf(mg_arena, &layer->c_functions, "default:{}break;\n"); + for(String8Node *n = gen_strings.first; n != 0; n = n->next) + { + String8 escaped = mg_escaped_from_str8(mg_arena, n->string); + str8_list_pushf(mg_arena, &layer->c_functions, "%S;\n", escaped); + } + str8_list_pushf(mg_arena, &layer->c_functions, "}\n"); + str8_list_pushf(mg_arena, &layer->c_functions, "return result;\n"); + str8_list_pushf(mg_arena, &layer->c_functions, "}\n\n"); + } + } + } + + ////////////////////////////// + //- rjf: generate catch-all generations + // + for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) + { + MD_Node *file = n->v.root; + for(MD_EachNode(node, file->first)) + { + MD_Node *tag = md_tag_from_string(node, str8_lit("gen"), 0); if(!md_node_is_nil(tag)) { String8 layer_key = mg_layer_key_from_path(file->string); MG_Layer *layer = mg_layer_from_key(layer_key); - String8List *out = md_node_has_tag(node, str8_lit("c_file"), 0) ? &layer->c_catchall : &layer->h_catchall; + B32 prefer_c_file = md_node_has_tag(node, str8_lit("c_file"), 0); + String8List *out = prefer_c_file ? &layer->c_catchall : &layer->h_catchall; + if(tag->first->string.size == 0){} + else if(str8_match(tag->first->string, str8_lit("enums"), 0)) { out = &layer->enums; } + else if(str8_match(tag->first->string, str8_lit("structs"), 0)) { out = &layer->structs; } + else if(str8_match(tag->first->string, str8_lit("functions"), 0)) { out = prefer_c_file ? &layer->c_functions : &layer->h_functions; } + else if(str8_match(tag->first->string, str8_lit("tables"), 0)) { out = prefer_c_file ? &layer->c_tables : &layer->h_tables; } String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node); for(String8Node *n = gen_strings.first; n != 0; n = n->next) { diff --git a/src/regs/raddbgi/regs_raddbgi.mdesk b/src/regs/raddbgi/regs_raddbgi.mdesk index a70a5011..1059f06f 100644 --- a/src/regs/raddbgi/regs_raddbgi.mdesk +++ b/src/regs/raddbgi/regs_raddbgi.mdesk @@ -4,7 +4,7 @@ //////////////////////////////// //~ rjf: RADDBG Converter Helper Implementation Generators -@table_gen @c_file +@gen @c_file { `internal RADDBGI_RegisterCode regs_raddbgi_code_from_arch_reg_code(Architecture arch, REGS_RegCode code)`; `{`; @@ -33,7 +33,7 @@ `}`; } -@table_gen @c_file +@gen @c_file { `internal REGS_RegCode regs_reg_code_from_arch_raddbgi_code(Architecture arch, RADDBGI_RegisterCode code)`; `{`; diff --git a/src/regs/regs.mdesk b/src/regs/regs.mdesk index 2a0499f6..6370a1d4 100644 --- a/src/regs/regs.mdesk +++ b/src/regs/regs.mdesk @@ -417,7 +417,7 @@ regs_g_reg_code_x86_usage_kind_table: //////////////////////////////// //~ rjf: Architecture-Dynamic Helper Implementation Generators -@c_file @table_gen +@c_file @gen { `internal U64 regs_block_size_from_architecture(Architecture arch)`; `{`; @@ -431,7 +431,7 @@ regs_g_reg_code_x86_usage_kind_table: `}`; } -@c_file @table_gen +@c_file @gen { `internal U64 regs_reg_code_count_from_architecture(Architecture arch)`; `{`; @@ -445,7 +445,7 @@ regs_g_reg_code_x86_usage_kind_table: `}`; } -@c_file @table_gen +@c_file @gen { `internal U64 regs_alias_code_count_from_architecture(Architecture arch)`; `{`; @@ -459,7 +459,7 @@ regs_g_reg_code_x86_usage_kind_table: `}`; } -@c_file @table_gen +@c_file @gen { `internal String8 *regs_reg_code_string_table_from_architecture(Architecture arch)`; `{`; @@ -473,7 +473,7 @@ regs_g_reg_code_x86_usage_kind_table: `}`; } -@c_file @table_gen +@c_file @gen { `internal String8 *regs_alias_code_string_table_from_architecture(Architecture arch)`; `{`; @@ -487,7 +487,7 @@ regs_g_reg_code_x86_usage_kind_table: `}`; } -@c_file @table_gen +@c_file @gen { `internal REGS_Rng *regs_reg_code_rng_table_from_architecture(Architecture arch)`; `{`; @@ -501,7 +501,7 @@ regs_g_reg_code_x86_usage_kind_table: `}`; } -@c_file @table_gen +@c_file @gen { `internal REGS_Slice *regs_alias_code_slice_table_from_architecture(Architecture arch)`; `{`; @@ -515,7 +515,7 @@ regs_g_reg_code_x86_usage_kind_table: `}`; } -@c_file @table_gen +@c_file @gen { `internal REGS_UsageKind *regs_reg_code_usage_kind_table_from_architecture(Architecture arch)`; `{`; @@ -529,7 +529,7 @@ regs_g_reg_code_x86_usage_kind_table: `}`; } -@c_file @table_gen +@c_file @gen { `internal REGS_UsageKind *regs_alias_code_usage_kind_table_from_architecture(Architecture arch)`; `{`; diff --git a/src/ui/ui.mdesk b/src/ui/ui.mdesk index 61c179fb..f94bfdaf 100644 --- a/src/ui/ui.mdesk +++ b/src/ui/ui.mdesk @@ -63,14 +63,14 @@ UI_StackTable: //- rjf: declaring stack node types -@table_gen +@gen { @expand(UI_StackTable a) `typedef struct UI_$(a.name)Node UI_$(a.name)Node; struct UI_$(a.name)Node{UI_$(a.name)Node *next; $(a.type) v;};` } //- rjf: declaring all default stack tops -@table_gen +@gen { `#define UI_DeclStackNils \\`; `struct\\`; @@ -81,7 +81,7 @@ UI_StackTable: //- rjf: initializing all default stack tops -@table_gen +@gen { `#define UI_InitStackNils(state) \\`; @expand(UI_StackTable a) `state->$(a.name_lower)_nil_stack_top.v = $(a.default);\\`; @@ -90,7 +90,7 @@ UI_StackTable: //- rjf: declaring all stack nodes & free lists -@table_gen +@gen { `#define UI_DeclStacks \\`; `struct\\`; @@ -101,7 +101,7 @@ UI_StackTable: //- rjf: initing all stack nodes -@table_gen +@gen { `#define UI_InitStacks(state) \\`; @expand(UI_StackTable a) `state->$(a.name_lower)_stack.top = &state->$(a.name_lower)_nil_stack_top; state->$(a.name_lower)_stack.bottom_val = $(a.default); state->$(a.name_lower)_stack.free = 0; state->$(a.name_lower)_stack.auto_pop = 0;\\`; @@ -110,7 +110,7 @@ UI_StackTable: //- rjf: auto-popping all stacks -@table_gen +@gen { `#define UI_AutoPopStacks(state) \\` @expand(UI_StackTable a) @@ -120,7 +120,7 @@ UI_StackTable: //- rjf: decls for the stack function operation headers -@table_gen +@gen { @expand(UI_StackTable a) `internal $(a.type) $(=>35) ui_top_$(a.name_lower)(void);` @@ -136,7 +136,7 @@ UI_StackTable: //- rjf: defer-loop helpers -@table_gen @c_file +@gen @c_file { `#if 0`; @expand(UI_StackTable a) @@ -146,7 +146,7 @@ UI_StackTable: //- rjf: decls for the stack operation implementations -@table_gen @c_file +@gen @c_file { @expand(UI_StackTable a) `internal $(a.type) ui_top_$(a.name_lower)(void) { UI_StackTopImpl(ui_state, $(a.name), $(a.name_lower)) }`;