From db737941d8a5278d28ad3170ff31ed526fc7531c Mon Sep 17 00:00:00 2001 From: Nikita Smith Date: Wed, 1 May 2024 16:54:15 -0700 Subject: [PATCH 01/21] codeview: inline binary annot format and decode helpers --- src/codeview/codeview.c | 68 +++++++++++++++++++++++++++++++++++++++++ src/codeview/codeview.h | 58 +++++++++++++++++++++++++++-------- 2 files changed, 113 insertions(+), 13 deletions(-) diff --git a/src/codeview/codeview.c b/src/codeview/codeview.c index ad1b528e..06b2d2c8 100644 --- a/src/codeview/codeview.c +++ b/src/codeview/codeview.c @@ -165,6 +165,74 @@ cv_f64_from_numeric(CV_NumericParsed *num){ return(result); } +//////////////////////////////// +//~ Inline Binary Annotation Helpers + +internal U64 +cv_decode_inline_annot_u32(String8 data, U64 offset, U32 *out_value) +{ + U32 value; + + U64 cursor = offset; + + U8 header = 0; + cursor += str8_deserial_read_struct(data, cursor, &header); + + // 1 byte + if((header & 0x80) == 0) + { + value = header; + } + // 2 bytes + else if((header & 0xC0) == 0x80) + { + Assert(cursor + sizeof(U8) * 2 <= data.size); + U8 second_byte; + cursor += str8_deserial_read_struct(data, cursor, &second_byte); + value = ((header & 0x3F) << 8) | second_byte; + } + // 4 bytes + else if((header & 0xE0) == 0xC0) + { + Assert(cursor + sizeof(U8) * 3 <= data.size); + U8 second_byte, third_byte, fourth_byte; + cursor += str8_deserial_read_struct(data, cursor, &second_byte); + cursor += str8_deserial_read_struct(data, cursor, &third_byte); + cursor += str8_deserial_read_struct(data, cursor, &fourth_byte); + value = (((U32)header & 0x1F) << 24) | ((U32)second_byte << 16) | ((U32)third_byte << 8) | (U32)fourth_byte; + } + // bad encode + else if((header & 0xE0) == 0xE0) + { + value = max_U32; + } + + *out_value = value; + + U64 read_size = cursor - offset; + return read_size; +} + +internal U64 +cv_decode_inline_annot_s32(String8 data, U64 offset, S32 *out_value) +{ + U32 value; + + U64 read_size = cv_decode_inline_annot_u32(data, offset, &value); + + if(value & 1) + { + value = -(value >> 1); + } + else + { + value = value >> 1; + } + + *out_value = (S32)value; + + return read_size; +} //////////////////////////////// //~ CodeView Sym Parser Functions diff --git a/src/codeview/codeview.h b/src/codeview/codeview.h index a037bee2..ff9f348e 100644 --- a/src/codeview/codeview.h +++ b/src/codeview/codeview.h @@ -1761,13 +1761,51 @@ struct CV_SymBuildInfo //- (SymKind: INLINESITE) +typedef U32 CV_InlineBinaryAnnotaiton; +typedef enum CV_InlineBinaryAnnotationenum +{ + CV_InlineBinaryAnnotation_Null, + CV_InlineBinaryAnnotation_CodeOffset, + CV_InlineBinaryAnnotation_ChangeCodeOffsetBase, + CV_InlineBinaryAnnotation_ChangeCodeOffset, + CV_InlineBinaryAnnotation_ChangeCodeLength, + CV_InlineBinaryAnnotation_ChnageFile, + CV_InlineBinaryAnnotation_ChangeLineOffset, + CV_InlineBinaryAnnotation_ChnageLineEndDelta, + CV_InlineBinaryAnnotation_ChangeRangeKind, + CV_InlineBinaryAnnotation_ChangeColumnStart, + CV_InlineBinaryAnnotation_ChangeColumnEndDelta, + CV_InlineBinaryAnnotation_ChangeCodeOffsetAndLineOffset, + CV_InlineBinaryAnnotation_ChangeCodeLengthAndCodeOffset, + CV_InlineBinaryAnnotaiton_ChangeColumnEnd +}; + +typedef U32 CV_InlineRangeKind; +typedef enum CV_InlnineRangeKindEnum +{ + CV_InlineRangeKind_Expr, + CV_InlineRangeKind_Stmt +}; + typedef struct CV_SymInlineSite CV_SymInlineSite; struct CV_SymInlineSite { U32 parent; U32 end; CV_ItemId inlinee; - // CV_BinaryAnnotation annotations (rest of data) + // U8 annotations[] (rest of data) +}; + +//- (SymKind: INLINESITE2) + +typedef struct CV_SymInlineSite2 CV_SymInlineSite2; +struct CV_SymInlineSite2 +{ + U32 parent_off; + U32 end_off; + CV_ItemId inlinee; + U32 invocations; + // U8 annotations[] (rest of data) }; //- (SymKind: INLINESITE_END) (empty) @@ -1835,18 +1873,6 @@ struct CV_SymPogoInfo U32 post_inline_static_inst_count; }; -//- (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) -}; - //- (SymKind: HEAPALLOCSITE) typedef struct CV_SymHeapAllocSite CV_SymHeapAllocSite; @@ -2905,6 +2931,12 @@ internal U64 cv_u64_from_numeric(CV_NumericParsed *num); internal S64 cv_s64_from_numeric(CV_NumericParsed *num); internal F64 cv_f64_from_numeric(CV_NumericParsed *num); +//////////////////////////////// +//~ Inline Binary Annotation Helpers + +internal U64 cv_decode_inline_annot_u32(String8 data, U64 offset, U32 *out_value); +internal U64 cv_decode_inline_annot_s32(String8 data, U64 offset, S32 *out_value); + //////////////////////////////// //~ CodeView Sym/Leaf Parser Functions From c767f03f327b616188651d040cb9a72e166b3d6c Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Sun, 26 May 2024 14:56:13 -0700 Subject: [PATCH 02/21] clean up & merge inline binary annotation decoders --- src/codeview/codeview.c | 77 ++++++++++++++++++++++------------------- src/codeview/codeview.h | 13 +++---- 2 files changed, 49 insertions(+), 41 deletions(-) diff --git a/src/codeview/codeview.c b/src/codeview/codeview.c index 06b2d2c8..f7a88fd0 100644 --- a/src/codeview/codeview.c +++ b/src/codeview/codeview.c @@ -171,44 +171,51 @@ cv_f64_from_numeric(CV_NumericParsed *num){ internal U64 cv_decode_inline_annot_u32(String8 data, U64 offset, U32 *out_value) { - U32 value; - U64 cursor = offset; - + + // rjf: read header U8 header = 0; cursor += str8_deserial_read_struct(data, cursor, &header); - - // 1 byte - if((header & 0x80) == 0) + + // rjf: decode value + U32 value = 0; { - value = header; + // 1 byte + if((header & 0x80) == 0) + { + value = header; + } + + // 2 bytes + else if((header & 0xC0) == 0x80 && cursor+2 <= data.size) + { + U8 second_byte; + cursor += str8_deserial_read_struct(data, cursor, &second_byte); + value = ((header & 0x3F) << 8) | second_byte; + } + + // 4 bytes + else if((header & 0xE0) == 0xC0 && cursor+3 <= data.size) + { + U8 second_byte, third_byte, fourth_byte; + cursor += str8_deserial_read_struct(data, cursor, &second_byte); + cursor += str8_deserial_read_struct(data, cursor, &third_byte); + cursor += str8_deserial_read_struct(data, cursor, &fourth_byte); + value = (((U32)header & 0x1F) << 24) | ((U32)second_byte << 16) | ((U32)third_byte << 8) | (U32)fourth_byte; + } + + // bad encode + else if((header & 0xE0) == 0xE0) + { + value = max_U32; + } } - // 2 bytes - else if((header & 0xC0) == 0x80) + + // rjf: output results + if(out_value) { - Assert(cursor + sizeof(U8) * 2 <= data.size); - U8 second_byte; - cursor += str8_deserial_read_struct(data, cursor, &second_byte); - value = ((header & 0x3F) << 8) | second_byte; + *out_value = value; } - // 4 bytes - else if((header & 0xE0) == 0xC0) - { - Assert(cursor + sizeof(U8) * 3 <= data.size); - U8 second_byte, third_byte, fourth_byte; - cursor += str8_deserial_read_struct(data, cursor, &second_byte); - cursor += str8_deserial_read_struct(data, cursor, &third_byte); - cursor += str8_deserial_read_struct(data, cursor, &fourth_byte); - value = (((U32)header & 0x1F) << 24) | ((U32)second_byte << 16) | ((U32)third_byte << 8) | (U32)fourth_byte; - } - // bad encode - else if((header & 0xE0) == 0xE0) - { - value = max_U32; - } - - *out_value = value; - U64 read_size = cursor - offset; return read_size; } @@ -217,9 +224,9 @@ internal U64 cv_decode_inline_annot_s32(String8 data, U64 offset, S32 *out_value) { U32 value; - + U64 read_size = cv_decode_inline_annot_u32(data, offset, &value); - + if(value & 1) { value = -(value >> 1); @@ -228,9 +235,9 @@ cv_decode_inline_annot_s32(String8 data, U64 offset, S32 *out_value) { value = value >> 1; } - + *out_value = (S32)value; - + return read_size; } diff --git a/src/codeview/codeview.h b/src/codeview/codeview.h index ff9f348e..5c3fe546 100644 --- a/src/codeview/codeview.h +++ b/src/codeview/codeview.h @@ -1761,8 +1761,8 @@ struct CV_SymBuildInfo //- (SymKind: INLINESITE) -typedef U32 CV_InlineBinaryAnnotaiton; -typedef enum CV_InlineBinaryAnnotationenum +typedef U32 CV_InlineBinaryAnnotation; +typedef enum CV_InlineBinaryAnnotationEnum { CV_InlineBinaryAnnotation_Null, CV_InlineBinaryAnnotation_CodeOffset, @@ -1778,14 +1778,16 @@ typedef enum CV_InlineBinaryAnnotationenum CV_InlineBinaryAnnotation_ChangeCodeOffsetAndLineOffset, CV_InlineBinaryAnnotation_ChangeCodeLengthAndCodeOffset, CV_InlineBinaryAnnotaiton_ChangeColumnEnd -}; +} +CV_InlineBinaryAnnotationEnum; typedef U32 CV_InlineRangeKind; -typedef enum CV_InlnineRangeKindEnum +typedef enum CV_InlineRangeKindEnum { CV_InlineRangeKind_Expr, CV_InlineRangeKind_Stmt -}; +} +CV_InlineRangeKindEnum; typedef struct CV_SymInlineSite CV_SymInlineSite; struct CV_SymInlineSite @@ -2917,7 +2919,6 @@ struct CV_TypeIdArray U64 count; }; - //////////////////////////////// //~ CodeView Common Functions From d2f9bdeefbd7b5bf10ad17740abe1a3ef6d20e76 Mon Sep 17 00:00:00 2001 From: Nikita Smith Date: Wed, 1 May 2024 17:06:12 -0700 Subject: [PATCH 03/21] codeview: new sub-section types --- src/codeview/codeview.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/codeview/codeview.h b/src/codeview/codeview.h index 5c3fe546..5bf4e76d 100644 --- a/src/codeview/codeview.h +++ b/src/codeview/codeview.h @@ -2664,7 +2664,9 @@ X(IlLines, 0xF9)\ X(FuncMDTokenMap, 0xFA)\ X(TypeMDTokenMap, 0xFB)\ X(MergedAssemblyInput, 0xFC)\ -X(CoffSymbolRVA, 0xFD) +X(CoffSymbolRVA, 0xFD)\ +X(XfgHashType, 0xFF)\ +X(XfgHashVirtual, 0x100) typedef U32 CV_C13_SubSectionKind; typedef enum From eea3c6b53cd86742cb0783787d0e710058fbcb9d Mon Sep 17 00:00:00 2001 From: Nikita Smith Date: Wed, 1 May 2024 17:11:29 -0700 Subject: [PATCH 04/21] codeview: struct defs for $$INLINEE_LINES --- src/codeview/codeview.h | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/codeview/codeview.h b/src/codeview/codeview.h index 5bf4e76d..ef3706d3 100644 --- a/src/codeview/codeview.h +++ b/src/codeview/codeview.h @@ -2772,6 +2772,26 @@ struct CV_C13_FrameData CV_C13_FrameDataFlags flags; }; +//- InlineLines sub-section + +typedef U32 CV_C13_InlineeLinesSig; +enum +{ + CV_C13_InlineeLinesSig_NORMAL, + CV_C13_InlineeLinesSig_EXTRA_FILES, +}; + +typedef struct CV_C13_InlineeSourceLineHeader CV_C13_InlineeSourceLineHeader; +struct CV_C13_InlineeSourceLineHeader +{ + CV_ItemId inlinee; // LF_FUNC_ID or LF_MFUNC_ID + U32 file_off; // offset into FileChksms sub-section + U32 first_source_ln; // base source line number for binary annotations + // if sig set to CV_C13_InlineeLinesSig_EXTRA_FILES + // U32 extra_file_count; + // U32 files[]; +}; + #pragma pack(pop) //////////////////////////////// From 6a32c197fa8b3ccdd2e487852b0fafefc2a1a329 Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Sun, 26 May 2024 15:07:38 -0700 Subject: [PATCH 05/21] rdi_dump: stringize source file's path --- src/codeview/codeview.h | 22 +++++++++++++--------- src/rdi_dump/rdi_dump.c | 5 +++++ 2 files changed, 18 insertions(+), 9 deletions(-) diff --git a/src/codeview/codeview.h b/src/codeview/codeview.h index ef3706d3..9c99b25a 100644 --- a/src/codeview/codeview.h +++ b/src/codeview/codeview.h @@ -1152,6 +1152,7 @@ struct CV_SymFrameproc }; //- (SymKind: ANNOTATION) + typedef struct CV_SymAnnotation CV_SymAnnotation; struct CV_SymAnnotation { @@ -1769,15 +1770,15 @@ typedef enum CV_InlineBinaryAnnotationEnum CV_InlineBinaryAnnotation_ChangeCodeOffsetBase, CV_InlineBinaryAnnotation_ChangeCodeOffset, CV_InlineBinaryAnnotation_ChangeCodeLength, - CV_InlineBinaryAnnotation_ChnageFile, + CV_InlineBinaryAnnotation_ChangeFile, CV_InlineBinaryAnnotation_ChangeLineOffset, - CV_InlineBinaryAnnotation_ChnageLineEndDelta, + CV_InlineBinaryAnnotation_ChangeLineEndDelta, CV_InlineBinaryAnnotation_ChangeRangeKind, CV_InlineBinaryAnnotation_ChangeColumnStart, CV_InlineBinaryAnnotation_ChangeColumnEndDelta, CV_InlineBinaryAnnotation_ChangeCodeOffsetAndLineOffset, CV_InlineBinaryAnnotation_ChangeCodeLengthAndCodeOffset, - CV_InlineBinaryAnnotaiton_ChangeColumnEnd + CV_InlineBinaryAnnotation_ChangeColumnEnd } CV_InlineBinaryAnnotationEnum; @@ -1826,7 +1827,7 @@ struct CV_SymFileStatic //- (SymKind: ARMSWITCHTABLE) typedef U16 CV_ArmSwitchKind; -typedef enum +typedef enum CV_ArmSwitchKindEnum { CV_ArmSwitchKind_INT1, CV_ArmSwitchKind_UINT1, @@ -1839,7 +1840,8 @@ typedef enum CV_ArmSwitchKind_UINT2SHL1, CV_ArmSwitchKind_INT1SSHL1, CV_ArmSwitchKind_INT2SSHL1, -} CV_ArmSwitchKindEnum; +} +CV_ArmSwitchKindEnum; typedef struct CV_SymArmSwitchTable CV_SymArmSwitchTable; struct CV_SymArmSwitchTable @@ -2669,12 +2671,13 @@ X(XfgHashType, 0xFF)\ X(XfgHashVirtual, 0x100) typedef U32 CV_C13_SubSectionKind; -typedef enum +typedef enum CV_C13_SubSectionKindEnum { #define X(N,c) CV_C13_SubSectionKind_##N = c, CV_C13_SubSectionKindXList(X) #undef X -} CV_C13_SubSectionKindEnum; +} +CV_C13_SubSectionKindEnum; typedef struct CV_C13_SubSectionHeader CV_C13_SubSectionHeader; struct CV_C13_SubSectionHeader @@ -2686,13 +2689,14 @@ struct CV_C13_SubSectionHeader //- FileChksms sub-section typedef U8 CV_C13_ChecksumKind; -typedef enum +typedef enum CV_C13_ChecksumKindEnum { CV_C13_ChecksumKind_Null, CV_C13_ChecksumKind_MD5, CV_C13_ChecksumKind_SHA1, CV_C13_ChecksumKind_SHA256, -} CV_C13_ChecksumKindEnum; +} +CV_C13_ChecksumKindEnum; typedef struct CV_C13_Checksum CV_C13_Checksum; struct CV_C13_Checksum diff --git a/src/rdi_dump/rdi_dump.c b/src/rdi_dump/rdi_dump.c index 92f96225..54372d81 100644 --- a/src/rdi_dump/rdi_dump.c +++ b/src/rdi_dump/rdi_dump.c @@ -240,6 +240,11 @@ rdi_stringize_source_file(Arena *arena, String8List *out, RDI_Parsed *parsed, RDI_ParsedLineMap line_map = {0}; rdi_line_map_from_source_file(parsed, source_file, &line_map); + // normal source path + String8 path = {0}; + path.str = rdi_string_from_idx(parsed, source_file->normal_full_path_string_idx, &path.size); + str8_list_pushf(arena, out, "%.*spath: \"%S\"\n", indent_level, rdi_stringize_spaces, path); + // stringize line map data str8_list_pushf(arena, out, "%.*slines:\n", indent_level, rdi_stringize_spaces); From f14686c6fb7e3de7ab69ee47c262059f7bca8890 Mon Sep 17 00:00:00 2001 From: Nikita Smith Date: Wed, 1 May 2024 16:54:15 -0700 Subject: [PATCH 06/21] codeview: inline binary annot format and decode helpers --- src/codeview/codeview.c | 68 +++++++++++++++++++++++++++++++++++++++++ src/codeview/codeview.h | 58 +++++++++++++++++++++++++++-------- 2 files changed, 113 insertions(+), 13 deletions(-) diff --git a/src/codeview/codeview.c b/src/codeview/codeview.c index ad1b528e..06b2d2c8 100644 --- a/src/codeview/codeview.c +++ b/src/codeview/codeview.c @@ -165,6 +165,74 @@ cv_f64_from_numeric(CV_NumericParsed *num){ return(result); } +//////////////////////////////// +//~ Inline Binary Annotation Helpers + +internal U64 +cv_decode_inline_annot_u32(String8 data, U64 offset, U32 *out_value) +{ + U32 value; + + U64 cursor = offset; + + U8 header = 0; + cursor += str8_deserial_read_struct(data, cursor, &header); + + // 1 byte + if((header & 0x80) == 0) + { + value = header; + } + // 2 bytes + else if((header & 0xC0) == 0x80) + { + Assert(cursor + sizeof(U8) * 2 <= data.size); + U8 second_byte; + cursor += str8_deserial_read_struct(data, cursor, &second_byte); + value = ((header & 0x3F) << 8) | second_byte; + } + // 4 bytes + else if((header & 0xE0) == 0xC0) + { + Assert(cursor + sizeof(U8) * 3 <= data.size); + U8 second_byte, third_byte, fourth_byte; + cursor += str8_deserial_read_struct(data, cursor, &second_byte); + cursor += str8_deserial_read_struct(data, cursor, &third_byte); + cursor += str8_deserial_read_struct(data, cursor, &fourth_byte); + value = (((U32)header & 0x1F) << 24) | ((U32)second_byte << 16) | ((U32)third_byte << 8) | (U32)fourth_byte; + } + // bad encode + else if((header & 0xE0) == 0xE0) + { + value = max_U32; + } + + *out_value = value; + + U64 read_size = cursor - offset; + return read_size; +} + +internal U64 +cv_decode_inline_annot_s32(String8 data, U64 offset, S32 *out_value) +{ + U32 value; + + U64 read_size = cv_decode_inline_annot_u32(data, offset, &value); + + if(value & 1) + { + value = -(value >> 1); + } + else + { + value = value >> 1; + } + + *out_value = (S32)value; + + return read_size; +} //////////////////////////////// //~ CodeView Sym Parser Functions diff --git a/src/codeview/codeview.h b/src/codeview/codeview.h index a037bee2..ff9f348e 100644 --- a/src/codeview/codeview.h +++ b/src/codeview/codeview.h @@ -1761,13 +1761,51 @@ struct CV_SymBuildInfo //- (SymKind: INLINESITE) +typedef U32 CV_InlineBinaryAnnotaiton; +typedef enum CV_InlineBinaryAnnotationenum +{ + CV_InlineBinaryAnnotation_Null, + CV_InlineBinaryAnnotation_CodeOffset, + CV_InlineBinaryAnnotation_ChangeCodeOffsetBase, + CV_InlineBinaryAnnotation_ChangeCodeOffset, + CV_InlineBinaryAnnotation_ChangeCodeLength, + CV_InlineBinaryAnnotation_ChnageFile, + CV_InlineBinaryAnnotation_ChangeLineOffset, + CV_InlineBinaryAnnotation_ChnageLineEndDelta, + CV_InlineBinaryAnnotation_ChangeRangeKind, + CV_InlineBinaryAnnotation_ChangeColumnStart, + CV_InlineBinaryAnnotation_ChangeColumnEndDelta, + CV_InlineBinaryAnnotation_ChangeCodeOffsetAndLineOffset, + CV_InlineBinaryAnnotation_ChangeCodeLengthAndCodeOffset, + CV_InlineBinaryAnnotaiton_ChangeColumnEnd +}; + +typedef U32 CV_InlineRangeKind; +typedef enum CV_InlnineRangeKindEnum +{ + CV_InlineRangeKind_Expr, + CV_InlineRangeKind_Stmt +}; + typedef struct CV_SymInlineSite CV_SymInlineSite; struct CV_SymInlineSite { U32 parent; U32 end; CV_ItemId inlinee; - // CV_BinaryAnnotation annotations (rest of data) + // U8 annotations[] (rest of data) +}; + +//- (SymKind: INLINESITE2) + +typedef struct CV_SymInlineSite2 CV_SymInlineSite2; +struct CV_SymInlineSite2 +{ + U32 parent_off; + U32 end_off; + CV_ItemId inlinee; + U32 invocations; + // U8 annotations[] (rest of data) }; //- (SymKind: INLINESITE_END) (empty) @@ -1835,18 +1873,6 @@ struct CV_SymPogoInfo U32 post_inline_static_inst_count; }; -//- (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) -}; - //- (SymKind: HEAPALLOCSITE) typedef struct CV_SymHeapAllocSite CV_SymHeapAllocSite; @@ -2905,6 +2931,12 @@ internal U64 cv_u64_from_numeric(CV_NumericParsed *num); internal S64 cv_s64_from_numeric(CV_NumericParsed *num); internal F64 cv_f64_from_numeric(CV_NumericParsed *num); +//////////////////////////////// +//~ Inline Binary Annotation Helpers + +internal U64 cv_decode_inline_annot_u32(String8 data, U64 offset, U32 *out_value); +internal U64 cv_decode_inline_annot_s32(String8 data, U64 offset, S32 *out_value); + //////////////////////////////// //~ CodeView Sym/Leaf Parser Functions From 86a99340168497bb2830ac2b4a5b8656eb4f2bbb Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Sun, 26 May 2024 14:56:13 -0700 Subject: [PATCH 07/21] clean up & merge inline binary annotation decoders --- src/codeview/codeview.c | 77 ++++++++++++++++++++++------------------- src/codeview/codeview.h | 13 +++---- 2 files changed, 49 insertions(+), 41 deletions(-) diff --git a/src/codeview/codeview.c b/src/codeview/codeview.c index 06b2d2c8..f7a88fd0 100644 --- a/src/codeview/codeview.c +++ b/src/codeview/codeview.c @@ -171,44 +171,51 @@ cv_f64_from_numeric(CV_NumericParsed *num){ internal U64 cv_decode_inline_annot_u32(String8 data, U64 offset, U32 *out_value) { - U32 value; - U64 cursor = offset; - + + // rjf: read header U8 header = 0; cursor += str8_deserial_read_struct(data, cursor, &header); - - // 1 byte - if((header & 0x80) == 0) + + // rjf: decode value + U32 value = 0; { - value = header; + // 1 byte + if((header & 0x80) == 0) + { + value = header; + } + + // 2 bytes + else if((header & 0xC0) == 0x80 && cursor+2 <= data.size) + { + U8 second_byte; + cursor += str8_deserial_read_struct(data, cursor, &second_byte); + value = ((header & 0x3F) << 8) | second_byte; + } + + // 4 bytes + else if((header & 0xE0) == 0xC0 && cursor+3 <= data.size) + { + U8 second_byte, third_byte, fourth_byte; + cursor += str8_deserial_read_struct(data, cursor, &second_byte); + cursor += str8_deserial_read_struct(data, cursor, &third_byte); + cursor += str8_deserial_read_struct(data, cursor, &fourth_byte); + value = (((U32)header & 0x1F) << 24) | ((U32)second_byte << 16) | ((U32)third_byte << 8) | (U32)fourth_byte; + } + + // bad encode + else if((header & 0xE0) == 0xE0) + { + value = max_U32; + } } - // 2 bytes - else if((header & 0xC0) == 0x80) + + // rjf: output results + if(out_value) { - Assert(cursor + sizeof(U8) * 2 <= data.size); - U8 second_byte; - cursor += str8_deserial_read_struct(data, cursor, &second_byte); - value = ((header & 0x3F) << 8) | second_byte; + *out_value = value; } - // 4 bytes - else if((header & 0xE0) == 0xC0) - { - Assert(cursor + sizeof(U8) * 3 <= data.size); - U8 second_byte, third_byte, fourth_byte; - cursor += str8_deserial_read_struct(data, cursor, &second_byte); - cursor += str8_deserial_read_struct(data, cursor, &third_byte); - cursor += str8_deserial_read_struct(data, cursor, &fourth_byte); - value = (((U32)header & 0x1F) << 24) | ((U32)second_byte << 16) | ((U32)third_byte << 8) | (U32)fourth_byte; - } - // bad encode - else if((header & 0xE0) == 0xE0) - { - value = max_U32; - } - - *out_value = value; - U64 read_size = cursor - offset; return read_size; } @@ -217,9 +224,9 @@ internal U64 cv_decode_inline_annot_s32(String8 data, U64 offset, S32 *out_value) { U32 value; - + U64 read_size = cv_decode_inline_annot_u32(data, offset, &value); - + if(value & 1) { value = -(value >> 1); @@ -228,9 +235,9 @@ cv_decode_inline_annot_s32(String8 data, U64 offset, S32 *out_value) { value = value >> 1; } - + *out_value = (S32)value; - + return read_size; } diff --git a/src/codeview/codeview.h b/src/codeview/codeview.h index ff9f348e..5c3fe546 100644 --- a/src/codeview/codeview.h +++ b/src/codeview/codeview.h @@ -1761,8 +1761,8 @@ struct CV_SymBuildInfo //- (SymKind: INLINESITE) -typedef U32 CV_InlineBinaryAnnotaiton; -typedef enum CV_InlineBinaryAnnotationenum +typedef U32 CV_InlineBinaryAnnotation; +typedef enum CV_InlineBinaryAnnotationEnum { CV_InlineBinaryAnnotation_Null, CV_InlineBinaryAnnotation_CodeOffset, @@ -1778,14 +1778,16 @@ typedef enum CV_InlineBinaryAnnotationenum CV_InlineBinaryAnnotation_ChangeCodeOffsetAndLineOffset, CV_InlineBinaryAnnotation_ChangeCodeLengthAndCodeOffset, CV_InlineBinaryAnnotaiton_ChangeColumnEnd -}; +} +CV_InlineBinaryAnnotationEnum; typedef U32 CV_InlineRangeKind; -typedef enum CV_InlnineRangeKindEnum +typedef enum CV_InlineRangeKindEnum { CV_InlineRangeKind_Expr, CV_InlineRangeKind_Stmt -}; +} +CV_InlineRangeKindEnum; typedef struct CV_SymInlineSite CV_SymInlineSite; struct CV_SymInlineSite @@ -2917,7 +2919,6 @@ struct CV_TypeIdArray U64 count; }; - //////////////////////////////// //~ CodeView Common Functions From 0750570081d83e86924cc3a5f94a10bd555a1dd6 Mon Sep 17 00:00:00 2001 From: Nikita Smith Date: Wed, 1 May 2024 17:06:12 -0700 Subject: [PATCH 08/21] codeview: new sub-section types --- src/codeview/codeview.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/codeview/codeview.h b/src/codeview/codeview.h index 5c3fe546..5bf4e76d 100644 --- a/src/codeview/codeview.h +++ b/src/codeview/codeview.h @@ -2664,7 +2664,9 @@ X(IlLines, 0xF9)\ X(FuncMDTokenMap, 0xFA)\ X(TypeMDTokenMap, 0xFB)\ X(MergedAssemblyInput, 0xFC)\ -X(CoffSymbolRVA, 0xFD) +X(CoffSymbolRVA, 0xFD)\ +X(XfgHashType, 0xFF)\ +X(XfgHashVirtual, 0x100) typedef U32 CV_C13_SubSectionKind; typedef enum From afb7aba039f5796547bc760425f549898a68d438 Mon Sep 17 00:00:00 2001 From: Nikita Smith Date: Wed, 1 May 2024 17:11:29 -0700 Subject: [PATCH 09/21] codeview: struct defs for $$INLINEE_LINES --- src/codeview/codeview.h | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/codeview/codeview.h b/src/codeview/codeview.h index 5bf4e76d..ef3706d3 100644 --- a/src/codeview/codeview.h +++ b/src/codeview/codeview.h @@ -2772,6 +2772,26 @@ struct CV_C13_FrameData CV_C13_FrameDataFlags flags; }; +//- InlineLines sub-section + +typedef U32 CV_C13_InlineeLinesSig; +enum +{ + CV_C13_InlineeLinesSig_NORMAL, + CV_C13_InlineeLinesSig_EXTRA_FILES, +}; + +typedef struct CV_C13_InlineeSourceLineHeader CV_C13_InlineeSourceLineHeader; +struct CV_C13_InlineeSourceLineHeader +{ + CV_ItemId inlinee; // LF_FUNC_ID or LF_MFUNC_ID + U32 file_off; // offset into FileChksms sub-section + U32 first_source_ln; // base source line number for binary annotations + // if sig set to CV_C13_InlineeLinesSig_EXTRA_FILES + // U32 extra_file_count; + // U32 files[]; +}; + #pragma pack(pop) //////////////////////////////// From cab8bdaf3809762cbce316462320809503bc4d47 Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Sun, 26 May 2024 15:07:38 -0700 Subject: [PATCH 10/21] rdi_dump: stringize source file's path --- src/codeview/codeview.h | 22 +++++++++++++--------- src/rdi_dump/rdi_dump.c | 5 +++++ 2 files changed, 18 insertions(+), 9 deletions(-) diff --git a/src/codeview/codeview.h b/src/codeview/codeview.h index ef3706d3..9c99b25a 100644 --- a/src/codeview/codeview.h +++ b/src/codeview/codeview.h @@ -1152,6 +1152,7 @@ struct CV_SymFrameproc }; //- (SymKind: ANNOTATION) + typedef struct CV_SymAnnotation CV_SymAnnotation; struct CV_SymAnnotation { @@ -1769,15 +1770,15 @@ typedef enum CV_InlineBinaryAnnotationEnum CV_InlineBinaryAnnotation_ChangeCodeOffsetBase, CV_InlineBinaryAnnotation_ChangeCodeOffset, CV_InlineBinaryAnnotation_ChangeCodeLength, - CV_InlineBinaryAnnotation_ChnageFile, + CV_InlineBinaryAnnotation_ChangeFile, CV_InlineBinaryAnnotation_ChangeLineOffset, - CV_InlineBinaryAnnotation_ChnageLineEndDelta, + CV_InlineBinaryAnnotation_ChangeLineEndDelta, CV_InlineBinaryAnnotation_ChangeRangeKind, CV_InlineBinaryAnnotation_ChangeColumnStart, CV_InlineBinaryAnnotation_ChangeColumnEndDelta, CV_InlineBinaryAnnotation_ChangeCodeOffsetAndLineOffset, CV_InlineBinaryAnnotation_ChangeCodeLengthAndCodeOffset, - CV_InlineBinaryAnnotaiton_ChangeColumnEnd + CV_InlineBinaryAnnotation_ChangeColumnEnd } CV_InlineBinaryAnnotationEnum; @@ -1826,7 +1827,7 @@ struct CV_SymFileStatic //- (SymKind: ARMSWITCHTABLE) typedef U16 CV_ArmSwitchKind; -typedef enum +typedef enum CV_ArmSwitchKindEnum { CV_ArmSwitchKind_INT1, CV_ArmSwitchKind_UINT1, @@ -1839,7 +1840,8 @@ typedef enum CV_ArmSwitchKind_UINT2SHL1, CV_ArmSwitchKind_INT1SSHL1, CV_ArmSwitchKind_INT2SSHL1, -} CV_ArmSwitchKindEnum; +} +CV_ArmSwitchKindEnum; typedef struct CV_SymArmSwitchTable CV_SymArmSwitchTable; struct CV_SymArmSwitchTable @@ -2669,12 +2671,13 @@ X(XfgHashType, 0xFF)\ X(XfgHashVirtual, 0x100) typedef U32 CV_C13_SubSectionKind; -typedef enum +typedef enum CV_C13_SubSectionKindEnum { #define X(N,c) CV_C13_SubSectionKind_##N = c, CV_C13_SubSectionKindXList(X) #undef X -} CV_C13_SubSectionKindEnum; +} +CV_C13_SubSectionKindEnum; typedef struct CV_C13_SubSectionHeader CV_C13_SubSectionHeader; struct CV_C13_SubSectionHeader @@ -2686,13 +2689,14 @@ struct CV_C13_SubSectionHeader //- FileChksms sub-section typedef U8 CV_C13_ChecksumKind; -typedef enum +typedef enum CV_C13_ChecksumKindEnum { CV_C13_ChecksumKind_Null, CV_C13_ChecksumKind_MD5, CV_C13_ChecksumKind_SHA1, CV_C13_ChecksumKind_SHA256, -} CV_C13_ChecksumKindEnum; +} +CV_C13_ChecksumKindEnum; typedef struct CV_C13_Checksum CV_C13_Checksum; struct CV_C13_Checksum diff --git a/src/rdi_dump/rdi_dump.c b/src/rdi_dump/rdi_dump.c index 92f96225..54372d81 100644 --- a/src/rdi_dump/rdi_dump.c +++ b/src/rdi_dump/rdi_dump.c @@ -240,6 +240,11 @@ rdi_stringize_source_file(Arena *arena, String8List *out, RDI_Parsed *parsed, RDI_ParsedLineMap line_map = {0}; rdi_line_map_from_source_file(parsed, source_file, &line_map); + // normal source path + String8 path = {0}; + path.str = rdi_string_from_idx(parsed, source_file->normal_full_path_string_idx, &path.size); + str8_list_pushf(arena, out, "%.*spath: \"%S\"\n", indent_level, rdi_stringize_spaces, path); + // stringize line map data str8_list_pushf(arena, out, "%.*slines:\n", indent_level, rdi_stringize_spaces); From 08750c23187c4f22168f2a7a9359afa6c09798fc Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Tue, 28 May 2024 21:31:56 -0700 Subject: [PATCH 11/21] initial pass of moving rdi definitions to metacode tables --- build.bat | 4 +- project.4coder | 2 +- src/rdi_format/generated/rdi_format.meta.c | 8 + src/rdi_format/generated/rdi_format.meta.h | 253 +++++++ src/rdi_format/rdi_format.mdesk | 766 +++++++++++++++++++++ 5 files changed, 1030 insertions(+), 3 deletions(-) create mode 100644 src/rdi_format/generated/rdi_format.meta.c create mode 100644 src/rdi_format/generated/rdi_format.meta.h create mode 100644 src/rdi_format/rdi_format.mdesk diff --git a/build.bat b/build.bat index 6a59fcd2..89eec163 100644 --- a/build.bat +++ b/build.bat @@ -60,8 +60,8 @@ if "%msvc%"=="1" set EHsc=/EHsc if "%clang%"=="1" set EHsc= if "%msvc%"=="1" set no_aslr=/DYNAMICBASE:NO if "%clang%"=="1" set no_aslr= -if "%msvc%"=="1" set rc=call rc -if "%clang%"=="1" set rc=call llvm-rc +if "%msvc%"=="1" set rc=call rc +if "%clang%"=="1" set rc=call llvm-rc :: --- Choose Compile/Link Lines ---------------------------------------------- if "%msvc%"=="1" set compile_debug=%cl_debug% diff --git a/project.4coder b/project.4coder index 9f070887..7637c9c2 100644 --- a/project.4coder +++ b/project.4coder @@ -47,7 +47,7 @@ commands = { .rjf_f1 = { - .win = "build raddbg telemetry", + .win = "build only_meta", .linux = "", .out = "*compilation*", .footer_panel = true, diff --git a/src/rdi_format/generated/rdi_format.meta.c b/src/rdi_format/generated/rdi_format.meta.c new file mode 100644 index 00000000..32e20884 --- /dev/null +++ b/src/rdi_format/generated/rdi_format.meta.c @@ -0,0 +1,8 @@ +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//- GENERATED CODE + +C_LINKAGE_BEGIN +C_LINKAGE_END + diff --git a/src/rdi_format/generated/rdi_format.meta.h b/src/rdi_format/generated/rdi_format.meta.h new file mode 100644 index 00000000..e7871be1 --- /dev/null +++ b/src/rdi_format/generated/rdi_format.meta.h @@ -0,0 +1,253 @@ +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//- GENERATED CODE + +#ifndef RDI_FORMAT_META_H +#define RDI_FORMAT_META_H + +typedef RDI_U32 RDI_DataSectionTag; +typedef enum RDI_DataSectionTagEnum +{ +RDI_DataSectionTag_NULL = 0x0000, +RDI_DataSectionTag_TopLevelInfo = 0x0001, +RDI_DataSectionTag_StringData = 0x0002, +RDI_DataSectionTag_StringTable = 0x0003, +RDI_DataSectionTag_IndexRuns = 0x0004, +RDI_DataSectionTag_BinarySections = 0x0005, +RDI_DataSectionTag_FilePathNodes = 0x0006, +RDI_DataSectionTag_SourceFiles = 0x0007, +RDI_DataSectionTag_Units = 0x0008, +RDI_DataSectionTag_UnitVmap = 0x0009, +RDI_DataSectionTag_TypeNodes = 0x000A, +RDI_DataSectionTag_UDTs = 0x000B, +RDI_DataSectionTag_Members = 0x000C, +RDI_DataSectionTag_EnumMembers = 0x000D, +RDI_DataSectionTag_GlobalVariables = 0x000E, +RDI_DataSectionTag_GlobalVmap = 0x000F, +RDI_DataSectionTag_ThreadVariables = 0x0010, +RDI_DataSectionTag_Procedures = 0x0011, +RDI_DataSectionTag_Scopes = 0x0012, +RDI_DataSectionTag_ScopeVoffData = 0x0013, +RDI_DataSectionTag_ScopeVmap = 0x0014, +RDI_DataSectionTag_Locals = 0x0015, +RDI_DataSectionTag_LocationBlocks = 0x0016, +RDI_DataSectionTag_LocationData = 0x0017, +RDI_DataSectionTag_NameMaps = 0x0018, +RDI_DataSectionTag_PRIMARY_COUNT = 0x0019, +RDI_DataSectionTag_SKIP = RDI_DataSectionTag_SECONDARY|0x0000, +RDI_DataSectionTag_LineInfoVoffs = RDI_DataSectionTag_SECONDARY|0x0001, +RDI_DataSectionTag_LineInfoData = RDI_DataSectionTag_SECONDARY|0x0002, +RDI_DataSectionTag_LineInfoColumns = RDI_DataSectionTag_SECONDARY|0x0003, +RDI_DataSectionTag_LineMapNumbers = RDI_DataSectionTag_SECONDARY|0x0004, +RDI_DataSectionTag_LineMapRanges = RDI_DataSectionTag_SECONDARY|0x0005, +RDI_DataSectionTag_LineMapVoffs = RDI_DataSectionTag_SECONDARY|0x0006, +RDI_DataSectionTag_NameMapBuckets = RDI_DataSectionTag_SECONDARY|0x0007, +RDI_DataSectionTag_NameMapNodes = RDI_DataSectionTag_SECONDARY|0x0008, +} RDI_DataSectionTagEnum; + +typedef RDI_U32 RDI_DataSectionEncoding; +typedef enum RDI_DataSectionEncodingEnum +{ +RDI_DataSectionEncoding_Unpacked = 0, +RDI_DataSectionEncoding_LZB = 1, +} RDI_DataSectionEncodingEnum; + +typedef RDI_U32 RDI_Arch; +typedef enum RDI_ArchEnum +{ +RDI_Arch_NULL = 0, +RDI_Arch_X86 = 1, +RDI_Arch_X64 = 2, +} RDI_ArchEnum; + +typedef enum RDI_RegCodeX86 +{ +RDI_RegCodeX86_nil = 0, +RDI_RegCodeX86_eax = 1, +RDI_RegCodeX86_ecx = 2, +RDI_RegCodeX86_edx = 3, +RDI_RegCodeX86_ebx = 4, +RDI_RegCodeX86_esp = 5, +RDI_RegCodeX86_ebp = 6, +RDI_RegCodeX86_esi = 7, +RDI_RegCodeX86_edi = 8, +RDI_RegCodeX86_fsbase = 9, +RDI_RegCodeX86_gsbase = 10, +RDI_RegCodeX86_eflags = 11, +RDI_RegCodeX86_eip = 12, +RDI_RegCodeX86_dr0 = 13, +RDI_RegCodeX86_dr1 = 14, +RDI_RegCodeX86_dr2 = 15, +RDI_RegCodeX86_dr3 = 16, +RDI_RegCodeX86_dr4 = 17, +RDI_RegCodeX86_dr5 = 18, +RDI_RegCodeX86_dr6 = 19, +RDI_RegCodeX86_dr7 = 20, +RDI_RegCodeX86_fpr0 = 21, +RDI_RegCodeX86_fpr1 = 22, +RDI_RegCodeX86_fpr2 = 23, +RDI_RegCodeX86_fpr3 = 24, +RDI_RegCodeX86_fpr4 = 25, +RDI_RegCodeX86_fpr5 = 26, +RDI_RegCodeX86_fpr6 = 27, +RDI_RegCodeX86_fpr7 = 28, +RDI_RegCodeX86_st0 = 29, +RDI_RegCodeX86_st1 = 30, +RDI_RegCodeX86_st2 = 31, +RDI_RegCodeX86_st3 = 32, +RDI_RegCodeX86_st4 = 33, +RDI_RegCodeX86_st5 = 34, +RDI_RegCodeX86_st6 = 35, +RDI_RegCodeX86_st7 = 36, +RDI_RegCodeX86_fcw = 37, +RDI_RegCodeX86_fsw = 38, +RDI_RegCodeX86_ftw = 39, +RDI_RegCodeX86_fop = 40, +RDI_RegCodeX86_fcs = 41, +RDI_RegCodeX86_fds = 42, +RDI_RegCodeX86_fip = 43, +RDI_RegCodeX86_fdp = 44, +RDI_RegCodeX86_mxcsr = 45, +RDI_RegCodeX86_mxcsr_mask = 46, +RDI_RegCodeX86_ss = 47, +RDI_RegCodeX86_cs = 48, +RDI_RegCodeX86_ds = 49, +RDI_RegCodeX86_es = 50, +RDI_RegCodeX86_fs = 51, +RDI_RegCodeX86_gs = 52, +RDI_RegCodeX86_ymm0 = 53, +RDI_RegCodeX86_ymm1 = 54, +RDI_RegCodeX86_ymm2 = 55, +RDI_RegCodeX86_ymm3 = 56, +RDI_RegCodeX86_ymm4 = 57, +RDI_RegCodeX86_ymm5 = 58, +RDI_RegCodeX86_ymm6 = 59, +RDI_RegCodeX86_ymm7 = 60, +} RDI_RegCodeX86; + +typedef enum RDI_RegCodeX64 +{ +RDI_RegCodeX64_nil = 0, +RDI_RegCodeX64_rax = 1, +RDI_RegCodeX64_rcx = 2, +RDI_RegCodeX64_rdx = 3, +RDI_RegCodeX64_rbx = 4, +RDI_RegCodeX64_rsp = 5, +RDI_RegCodeX64_rbp = 6, +RDI_RegCodeX64_rsi = 7, +RDI_RegCodeX64_rdi = 8, +RDI_RegCodeX64_r8 = 9, +RDI_RegCodeX64_r9 = 10, +RDI_RegCodeX64_r10 = 11, +RDI_RegCodeX64_r11 = 12, +RDI_RegCodeX64_r12 = 13, +RDI_RegCodeX64_r13 = 14, +RDI_RegCodeX64_r14 = 15, +RDI_RegCodeX64_r15 = 16, +RDI_RegCodeX64_es = 17, +RDI_RegCodeX64_cs = 18, +RDI_RegCodeX64_ss = 19, +RDI_RegCodeX64_ds = 20, +RDI_RegCodeX64_fs = 21, +RDI_RegCodeX64_gs = 22, +RDI_RegCodeX64_rip = 23, +RDI_RegCodeX64_rflags = 24, +RDI_RegCodeX64_dr0 = 25, +RDI_RegCodeX64_dr1 = 26, +RDI_RegCodeX64_dr2 = 27, +RDI_RegCodeX64_dr3 = 28, +RDI_RegCodeX64_dr4 = 29, +RDI_RegCodeX64_dr5 = 30, +RDI_RegCodeX64_dr6 = 31, +RDI_RegCodeX64_dr7 = 32, +RDI_RegCodeX64_st0 = 33, +RDI_RegCodeX64_st1 = 34, +RDI_RegCodeX64_st2 = 35, +RDI_RegCodeX64_st3 = 36, +RDI_RegCodeX64_st4 = 37, +RDI_RegCodeX64_st5 = 38, +RDI_RegCodeX64_st6 = 39, +RDI_RegCodeX64_st7 = 40, +RDI_RegCodeX64_fpr0 = 41, +RDI_RegCodeX64_fpr1 = 42, +RDI_RegCodeX64_fpr2 = 43, +RDI_RegCodeX64_fpr3 = 44, +RDI_RegCodeX64_fpr4 = 45, +RDI_RegCodeX64_fpr5 = 46, +RDI_RegCodeX64_fpr6 = 47, +RDI_RegCodeX64_fpr7 = 48, +RDI_RegCodeX64_ymm0 = 49, +RDI_RegCodeX64_ymm1 = 50, +RDI_RegCodeX64_ymm2 = 51, +RDI_RegCodeX64_ymm3 = 52, +RDI_RegCodeX64_ymm4 = 53, +RDI_RegCodeX64_ymm5 = 54, +RDI_RegCodeX64_ymm6 = 55, +RDI_RegCodeX64_ymm7 = 56, +RDI_RegCodeX64_ymm8 = 57, +RDI_RegCodeX64_ymm9 = 58, +RDI_RegCodeX64_ymm10 = 59, +RDI_RegCodeX64_ymm11 = 60, +RDI_RegCodeX64_ymm12 = 61, +RDI_RegCodeX64_ymm13 = 62, +RDI_RegCodeX64_ymm14 = 63, +RDI_RegCodeX64_ymm15 = 64, +RDI_RegCodeX64_mxcsr = 65, +RDI_RegCodeX64_fsbase = 66, +RDI_RegCodeX64_gsbase = 67, +RDI_RegCodeX64_fcw = 68, +RDI_RegCodeX64_fsw = 69, +RDI_RegCodeX64_ftw = 70, +RDI_RegCodeX64_fop = 71, +RDI_RegCodeX64_fcs = 72, +RDI_RegCodeX64_fds = 73, +RDI_RegCodeX64_fip = 74, +RDI_RegCodeX64_fdp = 75, +RDI_RegCodeX64_mxcsr_mask = 76, +} RDI_RegCodeX64; + +typedef RDI_U32 RDI_BinarySectionFlags; +typedef enum RDI_BinarySectionFlagsEnum +{ +RDI_BinarySectionFlags_Read = 1<<0, +RDI_BinarySectionFlags_Write = 1<<1, +RDI_BinarySectionFlags_Execute = 1<<2, +} RDI_BinarySectionFlagsEnum; + +typedef struct RDI_Header RDI_Header; +struct RDI_Header +{ +RDI_U64 magic; +RDI_U32 encoding_version; +RDI_U32 data_section_off; +RDI_U32 data_section_count; +}; + +typedef struct RDI_DataSection RDI_DataSection; +struct RDI_DataSection +{ +RDI_DataSectionTag tag; +RDI_DataSectionEncoding encoding; +}; + +typedef struct RDI_VMapEntry RDI_VMapEntry; +struct RDI_VMapEntry +{ +RDI_U64 voff; +RDI_U64 idx; +}; + +typedef struct RDI_TopLevelInfo RDI_TopLevelInfo; +struct RDI_TopLevelInfo +{ +RDI_Arch arch; +RDI_U32 exe_name_string_idx; +RDI_U64 exe_hash; +RDI_U64 voff_max; +}; + +C_LINKAGE_BEGIN +C_LINKAGE_END + +#endif // RDI_FORMAT_META_H diff --git a/src/rdi_format/rdi_format.mdesk b/src/rdi_format/rdi_format.mdesk new file mode 100644 index 00000000..ce881b2b --- /dev/null +++ b/src/rdi_format/rdi_format.mdesk @@ -0,0 +1,766 @@ +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//////////////////////////////// +//~ rjf: Format Header Tables + +@table(name type desc) +RDI_HeaderMemberTable: +{ + {magic RDI_U64 ""} + {encoding_version RDI_U32 ""} + {data_section_off RDI_U32 ""} + {data_section_count RDI_U32 ""} +} + +@struct RDI_Header: +{ + @expand(RDI_HeaderMemberTable a) `$(a.type) $(a.name)` +} + +//////////////////////////////// +//~ rjf: Format Data Section Tables + +@constant RDI_DataSectionTag_SECONDARY: 0x80000000 + +@table(name value desc) +RDI_DataSectionTable: +{ + {NULL 0x0000 ""} + {TopLevelInfo 0x0001 ""} + {StringData 0x0002 ""} + {StringTable 0x0003 ""} + {IndexRuns 0x0004 ""} + {BinarySections 0x0005 ""} + {FilePathNodes 0x0006 ""} + {SourceFiles 0x0007 ""} + {Units 0x0008 ""} + {UnitVmap 0x0009 ""} + {TypeNodes 0x000A ""} + {UDTs 0x000B ""} + {Members 0x000C ""} + {EnumMembers 0x000D ""} + {GlobalVariables 0x000E ""} + {GlobalVmap 0x000F ""} + {ThreadVariables 0x0010 ""} + {Procedures 0x0011 ""} + {Scopes 0x0012 ""} + {ScopeVoffData 0x0013 ""} + {ScopeVmap 0x0014 ""} + {Locals 0x0015 ""} + {LocationBlocks 0x0016 ""} + {LocationData 0x0017 ""} + {NameMaps 0x0018 ""} + {PRIMARY_COUNT 0x0019 ""} + {SKIP `RDI_DataSectionTag_SECONDARY|0x0000` ""} + {LineInfoVoffs `RDI_DataSectionTag_SECONDARY|0x0001` ""} + {LineInfoData `RDI_DataSectionTag_SECONDARY|0x0002` ""} + {LineInfoColumns `RDI_DataSectionTag_SECONDARY|0x0003` ""} + {LineMapNumbers `RDI_DataSectionTag_SECONDARY|0x0004` ""} + {LineMapRanges `RDI_DataSectionTag_SECONDARY|0x0005` ""} + {LineMapVoffs `RDI_DataSectionTag_SECONDARY|0x0006` ""} + {NameMapBuckets `RDI_DataSectionTag_SECONDARY|0x0007` ""} + {NameMapNodes `RDI_DataSectionTag_SECONDARY|0x0008` ""} +} + +@table(name value) +RDI_DataSectionEncodingTable: +{ + {Unpacked 0} + {LZB 1} +} + +@table(name type desc) +RDI_DataSectionMemberTable: +{ + {tag RDI_DataSectionTag ""} + {encoding RDI_DataSectionEncoding ""} +} + +@enum(RDI_U32) RDI_DataSectionTag: +{ + @expand(RDI_DataSectionTable a) `$(a.name .. =>20) = $(a.value)`, +} + +@enum(RDI_U32) RDI_DataSectionEncoding: +{ + @expand(RDI_DataSectionEncodingTable a) `$(a.name .. =>10) = $(a.value)`, +} + +@struct RDI_DataSection: +{ + @expand(RDI_DataSectionMemberTable a) `$(a.type) $(a.name)` +} + +//////////////////////////////// +//~ rjf: Common Type Tables + +@table(name type desc) +RDI_VMapEntryMemberTable: +{ + {voff RDI_U64 ""} + {idx RDI_U64 ""} +} + +@struct RDI_VMapEntry: +{ + @expand(RDI_VMapEntryMemberTable a) `$(a.type) $(a.name)` +} + +//////////////////////////////// +//~ rjf: Architecture Info Tables + +@table(name value addr_size) +RDI_ArchTable: +{ + {NULL 0 0} + {X86 1 4} + {X64 2 8} +} + +@table(name value) +RDI_RegCodeX86Table: +{ + {nil 0} + {eax 1} + {ecx 2} + {edx 3} + {ebx 4} + {esp 5} + {ebp 6} + {esi 7} + {edi 8} + {fsbase 9} + {gsbase 10} + {eflags 11} + {eip 12} + {dr0 13} + {dr1 14} + {dr2 15} + {dr3 16} + {dr4 17} + {dr5 18} + {dr6 19} + {dr7 20} + {fpr0 21} + {fpr1 22} + {fpr2 23} + {fpr3 24} + {fpr4 25} + {fpr5 26} + {fpr6 27} + {fpr7 28} + {st0 29} + {st1 30} + {st2 31} + {st3 32} + {st4 33} + {st5 34} + {st6 35} + {st7 36} + {fcw 37} + {fsw 38} + {ftw 39} + {fop 40} + {fcs 41} + {fds 42} + {fip 43} + {fdp 44} + {mxcsr 45} + {mxcsr_mask 46} + {ss 47} + {cs 48} + {ds 49} + {es 50} + {fs 51} + {gs 52} + {ymm0 53} + {ymm1 54} + {ymm2 55} + {ymm3 56} + {ymm4 57} + {ymm5 58} + {ymm6 59} + {ymm7 60} +} + +@table(name value) +RDI_RegCodeX64Table: +{ + {nil 0} + {rax 1} + {rcx 2} + {rdx 3} + {rbx 4} + {rsp 5} + {rbp 6} + {rsi 7} + {rdi 8} + {r8 9} + {r9 10} + {r10 11} + {r11 12} + {r12 13} + {r13 14} + {r14 15} + {r15 16} + {es 17} + {cs 18} + {ss 19} + {ds 20} + {fs 21} + {gs 22} + {rip 23} + {rflags 24} + {dr0 25} + {dr1 26} + {dr2 27} + {dr3 28} + {dr4 29} + {dr5 30} + {dr6 31} + {dr7 32} + {st0 33} + {st1 34} + {st2 35} + {st3 36} + {st4 37} + {st5 38} + {st6 39} + {st7 40} + {fpr0 41} + {fpr1 42} + {fpr2 43} + {fpr3 44} + {fpr4 45} + {fpr5 46} + {fpr6 47} + {fpr7 48} + {ymm0 49} + {ymm1 50} + {ymm2 51} + {ymm3 52} + {ymm4 53} + {ymm5 54} + {ymm6 55} + {ymm7 56} + {ymm8 57} + {ymm9 58} + {ymm10 59} + {ymm11 60} + {ymm12 61} + {ymm13 62} + {ymm14 63} + {ymm15 64} + {mxcsr 65} + {fsbase 66} + {gsbase 67} + {fcw 68} + {fsw 69} + {ftw 70} + {fop 71} + {fcs 72} + {fds 73} + {fip 74} + {fdp 75} + {mxcsr_mask 76} +} + +@enum(RDI_U32) RDI_Arch: +{ + @expand(RDI_ArchTable a) `$(a.name .. =>10) = $(a.value)` +} + +@enum RDI_RegCodeX86: +{ + @expand(RDI_RegCodeX86Table a) `$(a.name .. =>10) = $(a.value)` +} + +@enum RDI_RegCodeX64: +{ + @expand(RDI_RegCodeX64Table a) `$(a.name .. =>10) = $(a.value)` +} + +//////////////////////////////// +//~ rjf: Top-Level Info Type Tables + +@table(name type desc) +RDI_TopLevelInfoMemberTable: +{ + {arch RDI_Arch ""} + {exe_name_string_idx RDI_U32 ""} + {exe_hash RDI_U64 ""} + {voff_max RDI_U64 ""} +} + +@struct RDI_TopLevelInfo: +{ + @expand(RDI_TopLevelInfoMemberTable a) `$(a.type) $(a.name)` +} + +//////////////////////////////// +//~ rjf: Binary Section Info Type Tables + +@table(name value) +RDI_BinarySectionFlagTable: +{ + {Read `1<<0`} + {Write `1<<1`} + {Execute `1<<2`} +} + +@table(name type desc) +RDI_BinarySectionMemberTable: +{ + {name_string_idx RDI_U32 ""} + {flags RDI_BinarySectionFlags ""} + {voff_first RDI_U64 ""} + {voff_opl RDI_U64 ""} + {foff_first RDI_U64 ""} + {foff_opl RDI_U64 ""} +} + +@enum(RDI_U32) RDI_BinarySectionFlags: +{ + @expand(RDI_BinarySectionFlagTable a) `$(a.name .. =>10) = $(a.value)`; +} + +//////////////////////////////// +//~ rjf: File Path Tree Info Type Tables + +@table(name type desc) +RDI_FilePathNodeMemberTable: +{ + {name_string_idx RDI_U32 ""} + {parent_path_node RDI_U32 ""} + {first_child RDI_U32 ""} + {next_sibling RDI_U32 ""} + {source_file_idx RDI_U32 ""} +} + +@table(name type desc) +RDI_SourceFileMemberTable: +{ + {file_path_node_idx RDI_U32 ""} + {normal_full_path_string_idx RDI_U32 ""} + // usage of line map to go from a line number to an array of voffs + // (line_map_nums * line_number) -> (nil | index) + // (line_map_data * index) -> (range) + // (line_map_voff_data * range) -> (array(voff)) + {line_map_count RDI_U32 ""} + {line_map_nums_data_idx RDI_U32 ""} // U32[line_map_count] (sorted - not closed ranges) + {line_map_range_data_idx RDI_U32 ""} // U32[line_map_count + 1] (pairs form ranges) + {line_map_voff_data_idx RDI_U32 ""} // U64[...] (idx by line_map_range_data) +} + +//////////////////////////////// +//~ rjf: Unit Info Type Tables + +@table(name type desc) +RDI_UnitMemberTable: +{ + {unit_name_string_idx RDI_U32 ""} + {compiler_name_string_idx RDI_U32 ""} + {source_file_path_node RDI_U32 ""} + {object_file_path_node RDI_U32 ""} + {archive_file_path_node RDI_U32 ""} + {build_path_node RDI_U32 ""} + {language RDI_Language ""} + // usage of line info to go from voff to file & line number: + // (line_info_voffs * voff) -> (nil + index) + // (line_info_data * index) -> (RDI_Line = (file_idx * line_number)) + {line_info_voffs_data_idx RDI_U32 ""} // U64[line_info_count + 1] (sorted ranges) + {line_info_data_idx RDI_U32 ""} // RDI_Line[line_info_count] + {line_info_col_data_idx RDI_U32 ""} // RDI_Col[line_info_count] + {line_info_count RDI_U32 ""} +} + +//////////////////////////////// +//~ rjf: Line Info Type Tables + +@table(name type desc) +RDI_LineMemberTable: +{ + {file_idx RDI_U32 ""} + {line_num RDI_U32 ""} +} + +@table(name type desc) +RDI_ColumnMemberTable: +{ + {col_first RDI_U16 ""} + {col_opl RDI_U16 ""} +} + +//////////////////////////////// +//~ rjf: Language Info Tables + +@table(name value) +RDI_LanguageTable: +{ + {NULL 0} + {C 1} + {CPlusPlus 2} +} + +//////////////////////////////// +//~ rjf: Type Info Tables + +@table(name value size bookend1 bookend2) +RDI_TypeKindTable: +{ + {NULL 0x0000 0 } + //- + {Void 0x0001 0 FirstBuiltIn } + {Handle 0x0002 0xFFFFFFFF } + {Char8 0x0003 1 } + {Char16 0x0004 2 } + {Char32 0x0005 4 } + {UChar8 0x0006 1 } + {UChar16 0x0007 2 } + {UChar32 0x0008 4 } + {U8 0x0009 1 } + {U16 0x000A 2 } + {U32 0x000B 4 } + {U64 0x000C 8 } + {U128 0x000D 16 } + {U256 0x000E 32 } + {U512 0x000F 64 } + {S8 0x0010 1 } + {S16 0x0011 2 } + {S32 0x0012 4 } + {S64 0x0013 8 } + {S128 0x0014 16 } + {S256 0x0015 32 } + {S512 0x0016 64 } + {Bool 0x0017 1 } + {F16 0x0018 2 } + {F32 0x0019 4 } + {F32PP 0x001A 4 } + {F48 0x001B 6 } + {F64 0x001C 8 } + {F80 0x001D 10 } + {F128 0x001E 16 } + {ComplexF32 0x001F 8 } + {ComplexF64 0x0020 16 } + {ComplexF80 0x0021 20 } + {ComplexF128 0x0022 32 LastBuiltIn } + //- + {Modifier 0x1000 0 FirstConstructed } + {Ptr 0x1001 0 } + {LRef 0x1002 0 } + {RRef 0x1003 0 } + {Array 0x1004 0 } + {Function 0x1005 0 } + {Method 0x1006 0 } + {MemberPtr 0x1007 0 LastConstructed } + //- + {Struct 0x2000 0 FirstUserDefined FirstRecord } + {Class 0x2001 0 } + {Union 0x2002 0 LastRecord } + {Enum 0x2003 0 } + {Alias 0x2004 0 } + {IncompleteStruct 0x2005 0 FirstIncomplete } + {IncompleteUnion 0x2006 0 } + {IncompleteClass 0x2007 0 } + {IncompleteEnum 0x2008 0 LastIncomplete LastUserDefined} + //- + {Bitfield 0xF000 0 } + {Variadic 0xF001 0 } +} + +@table(name val) +RDI_TypeModifierFlagTable: +{ + {Const `1<<0`} + {Volatile `1<<1`} +} + +@table(name type desc) +RDI_TypeNodeMemberTable: +{ + {kind RDI_TypeKind ""} + {byte_size RDI_U32 ""} + {kind_info `RDI_U32[3]` ""} +} + +@table(name val) +RDI_UDTFlagTable: +{ + {EnumMembers `1<<0`} +} + +@table(name type desc) +RDI_UDTMemberTable: +{ + {self_type_idx RDI_U32 ""} + {flags RDI_UDTFlags ""} + {member_first RDI_U32 ""} + {member_count RDI_U32 ""} + {file_idx RDI_U32 ""} + {line RDI_U32 ""} + {col RDI_U32 ""} +} + +@table(name val) +RDI_MemberKindTable: +{ + {NULL 0x0000} + {DataField 0x0001} + {StaticData 0x0002} + {Method 0x0100} + {StaticMethod 0x0101} + {VirtualMethod 0x0102} + {VTablePtr 0x0200} + {Base 0x0201} + {VirtualBase 0x0202} + {NestedType 0x0300} +} + +@table(name type desc) +RDI_MemberMemberTable: +{ + {kind RDI_MemberKind ""} + {pad RDI_U16 ""} + {name_string_idx RDI_U32 ""} + {type_idx RDI_U32 ""} + {off RDI_U32 ""} +} + +@table(name type desc) +RDI_EnumMemberTable: +{ + {name_string_idx RDI_U32 ""} + {pad RDI_U32 ""} + {val RDI_U64 ""} +} + +//////////////////////////////// +//~ rjf: Symbol Info Tables + +@table(name val) +RDI_LinkFlagTable: +{ + {External `1<<0`} + {TypeScoped `1<<1`} + {ProcScoped `1<<2`} +} + +@table(name val) +RDI_LocalKindTable: +{ + {NULL 0x0} + {Parameter 0x1} + {Variable 0x2} +} + +@table(name val) +RDI_LocationKindTable: +{ + {NULL 0x0} + {AddrBytecodeStream 0x1} + {ValBytecodeStream 0x2} + {AddrRegisterPlusU16 0x3} + {AddrAddrRegisterPlusU16 0x4} + {ValRegister 0x5} +} + +@table(name type desc) +RDI_GlobalVariableMemberTable: +{ + {name_string_idx RDI_U32 ""} + {link_flags RDI_LinkFlags ""} + {voff RDI_U64 ""} + {type_idx RDI_U32 ""} + {container_idx RDI_U32 ""} +} + +@table(name type desc) +RDI_ThreadVariableMemberTable: +{ + {name_string_idx RDI_U32 ""} + {link_flags RDI_LinkFlags ""} + {tls_off RDI_U32 ""} + {type_idx RDI_U32 ""} + {container_idx RDI_U32 ""} +} + +@table(name type desc) +RDI_ProcedureMemberTable: +{ + {name_string_idx RDI_U32 ""} + {link_name_string_idx RDI_U32 ""} + {link_flags RDI_LinkFlags ""} + {type_idx RDI_U32 ""} + {root_scope_idx RDI_U32 ""} + {container_idx RDI_U32 ""} +} + +@table(name type desc) +RDI_ScopeMemberTable: +{ + {proc_idx RDI_U32 ""} + {parent_scope_idx RDI_U32 ""} + {first_child_scope_idx RDI_U32 ""} + {next_sibling_scope_idx RDI_U32 ""} + {voff_range_first RDI_U32 ""} + {voff_range_opl RDI_U32 ""} + {local_first RDI_U32 ""} + {local_count RDI_U32 ""} + {static_local_idx_run_first RDI_U32 ""} + {static_local_count RDI_U32 ""} +} + +@table(name type desc) +RDI_LocalMemberTable: +{ + {kind RDI_LocalKind ""} + {name_string_idx RDI_U32 ""} + {type_idx RDI_U32 ""} + {pad RDI_U32 ""} + {location_first RDI_U32 ""} + {location_opl RDI_U32 ""} +} + +@table(name type desc) +RDI_LocationBlockMemberTable: +{ + {scope_off_first RDI_U32} + {scope_off_opl RDI_U32} + {location_data_off RDI_U32} +} + +@table(name type desc) +RDI_LocationBytecodeStreamMemberTable: +{ + {kind RDI_LocationKind ""} + // [... 0] null terminated byte sequence RDI_EvalBytecodeStream +} + +@table(name type desc) +RDI_LocationRegisterPlusU16MemberTable: +{ + {kind RDI_LocationKind } + {register_code RDI_RegisterCode } + {offset RDI_U16 } +} + +@table(name type desc) +RDI_LocationRegister: +{ + {kind RDI_LocationKind } + {register_code RDI_RegisterCode } +} + +//////////////////////////////// +//~ rjf: Evaluation Bytecode Tables + +@table(name num_decodes num_pops num_pushes) +RDI_EvalOpTable: +{ + {Stop 0 0 0} + {Noop 0 0 0} + {Cond 1 1 0} + {Skip 1 0 0} + {MemRead 1 1 1} + {RegRead 4 0 1} + {RegReadDyn 0 1 1} + {FrameOff 1 0 1} + {ModuleOff 4 0 1} + {TLSOff 4 0 1} + {ObjectOff 0 0 0} + {CFA 0 0 0} + {ConstU8 1 0 1} + {ConstU16 2 0 1} + {ConstU32 4 0 1} + {ConstU64 8 0 1} + {Abs 1 1 1} + {Neg 1 1 1} + {Add 1 2 1} + {Sub 1 2 1} + {Mul 1 2 1} + {Div 1 2 1} + {Mod 1 2 1} + {LShift 1 2 1} + {RShift 1 2 1} + {BitAnd 1 2 1} + {BitOr 1 2 1} + {BitXor 1 2 1} + {BitNot 1 1 1} + {LogAnd 1 2 1} + {LogOr 1 2 1} + {LogNot 1 1 1} + {EqEq 1 2 1} + {NtEq 1 2 1} + {LsEq 1 2 1} + {GrEq 1 2 1} + {Less 1 2 1} + {Grtr 1 2 1} + {Trunc 1 1 1} + {TruncSigned 1 1 1} + {Convert 2 1 1} + {Pick 1 0 1} + {Pop 0 1 0} + {Insert 1 0 0} +} + +@table(name val) +RDI_EvalTypeGroupTable: +{ + {Other 0} + {U 1} + {S 2} + {F32 3} + {F64 4} +} + +@table(name val error_string) +RDI_EvalConversionKindTable: +{ + {Noop 0 "" } + {Legal 1 "" } + {OtherToOther 2 "Cannot convert between these types."} + {ToOther 3 "Cannot convert to this type." } + {FromOther 4 "Cannot convert this type." } +} + +//////////////////////////////// +//~ rjf: Name Map Tables + +@table(name val) +RDI_NameMapKindTable: +{ + {NULL 0} + {GlobalVariables 1} + {ThreadVariables 2} + {Procedures 3} + {Types 4} + {LinkNameProcedures 5} + {NormalSourcePaths 6} +} + +@table(name type desc) +RDI_NameMapMemberTable: +{ + {kind RDI_NameMapKind ""} + {bucket_data_idx RDI_U32 ""} + {node_data_idx RDI_U32 ""} +} + +@table(name type desc) +RDI_NameMapBucketMemberTable: +{ + {first_node RDI_U32 ""} + {node_count RDI_U32 ""} +} + +@table(name type desc) +RDI_NameMapNodeMemberTable: +{ + {string_idx RDI_U32 ""} + {match_count RDI_U32 ""} + // NOTE: if (match_count == 1) then this is the index of the matching item + // if (match_count > 1) then this is the first for an index run of all the matches + {match_idx_or_idx_run_first RDI_U32 ""} +} + From 35c1c463c8c6d874e50cdba439bd91e481efd2cd Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Fri, 31 May 2024 17:16:54 -0700 Subject: [PATCH 12/21] complete metacodification of rdi format info into tables --- project.4coder | 2 +- src/codeview/codeview.h | 2 +- src/codeview/generated/codeview.meta.c | 3 - src/codeview/generated/codeview.meta.h | 3 - src/ctrl/generated/ctrl.meta.h | 1 + src/demon/generated/demon.meta.h | 1 + src/df/core/generated/df_core.meta.h | 1 + src/df/gfx/df_views.c | 4 +- src/df/gfx/generated/df_gfx.meta.h | 1 + src/draw/generated/draw.meta.c | 3 - src/draw/generated/draw.meta.h | 3 - src/eval/eval_compiler.c | 16 +- src/eval/eval_machine.c | 2 +- src/eval/eval_parser.c | 40 +- src/eval/generated/eval.meta.h | 1 + src/lib_rdi_format/rdi_format.c | 6 +- src/lib_rdi_format/rdi_format.h | 36 +- src/lib_rdi_make/rdi_make.c | 32 +- src/lib_rdi_make/rdi_make.h | 2 +- src/metagen/metagen.c | 7 +- src/metagen/metagen.h | 7 + src/metagen/metagen_main.c | 177 +++- src/os/gfx/generated/os_gfx.meta.h | 1 + src/rdi_dump/rdi_dump.c | 42 +- src/rdi_dump/rdi_dump.h | 2 +- src/rdi_format/generated/rdi_format.c | 196 +++++ src/rdi_format/generated/rdi_format.h | 787 ++++++++++++++++++ src/rdi_format/generated/rdi_format.meta.c | 8 - src/rdi_format/generated/rdi_format.meta.h | 253 ------ src/rdi_format/rdi_format.mdesk | 595 +++++++++++-- src/rdi_format_local/rdi_format_local.c | 3 +- src/rdi_format_local/rdi_format_local.h | 3 +- src/rdi_from_pdb/rdi_from_pdb.c | 44 +- src/rdi_from_pdb/rdi_from_pdb.h | 6 +- src/regs/generated/regs.meta.h | 1 + src/regs/rdi/generated/regs_rdi.meta.c | 553 ++++++------ src/regs/rdi/generated/regs_rdi.meta.h | 3 - src/regs/rdi/regs_rdi.h | 4 +- src/regs/rdi/regs_rdi.mdesk | 14 +- .../d3d11/generated/render_d3d11.meta.h | 1 + src/render/generated/render.meta.h | 1 + src/type_graph/generated/type_graph.meta.h | 1 + src/ui/generated/ui.meta.c | 3 - src/ui/generated/ui.meta.h | 3 - 44 files changed, 2091 insertions(+), 783 deletions(-) create mode 100644 src/rdi_format/generated/rdi_format.c create mode 100644 src/rdi_format/generated/rdi_format.h delete mode 100644 src/rdi_format/generated/rdi_format.meta.c delete mode 100644 src/rdi_format/generated/rdi_format.meta.h diff --git a/project.4coder b/project.4coder index 7637c9c2..9f070887 100644 --- a/project.4coder +++ b/project.4coder @@ -47,7 +47,7 @@ commands = { .rjf_f1 = { - .win = "build only_meta", + .win = "build raddbg telemetry", .linux = "", .out = "*compilation*", .footer_panel = true, diff --git a/src/codeview/codeview.h b/src/codeview/codeview.h index 9c99b25a..015829d3 100644 --- a/src/codeview/codeview.h +++ b/src/codeview/codeview.h @@ -27,7 +27,7 @@ read_only global CV_TypeId cv_type_id_variadic = 0xFFFFFFFF; //////////////////////////////// //~ rjf: Registers -// X(NAME, CODE, (RDI_RegisterCode_X86) NAME, BYTE_POS, BYTE_SIZE) +// X(NAME, CODE, (RDI_RegCode_X86) NAME, BYTE_POS, BYTE_SIZE) #define CV_Reg_X86_XList(X) \ X(NONE, 0, nil, 0, 0)\ X(AL, 1, eax, 0, 1)\ diff --git a/src/codeview/generated/codeview.meta.c b/src/codeview/generated/codeview.meta.c index 2aaef62e..4e0abcfb 100644 --- a/src/codeview/generated/codeview.meta.c +++ b/src/codeview/generated/codeview.meta.c @@ -701,6 +701,3 @@ case CV_LeafKind_STRUCT2:{result = sizeof(CV_LeafStruct2);}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 index b30192a7..1cc2c6fd 100644 --- a/src/codeview/generated/codeview.meta.h +++ b/src/codeview/generated/codeview.meta.h @@ -517,7 +517,4 @@ internal String8 cv_type_name_from_basic_type(CV_BasicType v); internal String8 cv_string_from_leaf_kind(CV_LeafKind v); internal U64 cv_header_struct_size_from_sym_kind(CV_SymKind v); internal U64 cv_header_struct_size_from_leaf_kind(CV_LeafKind v); -C_LINKAGE_BEGIN -C_LINKAGE_END - #endif // CODEVIEW_META_H diff --git a/src/ctrl/generated/ctrl.meta.h b/src/ctrl/generated/ctrl.meta.h index 2d2abf32..06115815 100644 --- a/src/ctrl/generated/ctrl.meta.h +++ b/src/ctrl/generated/ctrl.meta.h @@ -54,6 +54,7 @@ extern U32 ctrl_exception_code_kind_code_table[38]; extern String8 ctrl_exception_code_kind_display_string_table[38]; extern String8 ctrl_exception_code_kind_lowercase_code_string_table[38]; extern B8 ctrl_exception_code_kind_default_enable_table[38]; + C_LINKAGE_END #endif // CTRL_META_H diff --git a/src/demon/generated/demon.meta.h b/src/demon/generated/demon.meta.h index 732deb06..24a6fa17 100644 --- a/src/demon/generated/demon.meta.h +++ b/src/demon/generated/demon.meta.h @@ -60,6 +60,7 @@ DMN_ExceptionKind_COUNT, C_LINKAGE_BEGIN extern String8 dmn_event_kind_string_table[17]; extern String8 dmn_exception_kind_string_table[5]; + C_LINKAGE_END #endif // DEMON_META_H diff --git a/src/df/core/generated/df_core.meta.h b/src/df/core/generated/df_core.meta.h index 1a63c7ef..c840bb48 100644 --- a/src/df/core/generated/df_core.meta.h +++ b/src/df/core/generated/df_core.meta.h @@ -1541,6 +1541,7 @@ extern DF_CoreCmdKind df_g_cfg_src_load_cmd_kind_table[4]; extern DF_CoreCmdKind df_g_cfg_src_write_cmd_kind_table[4]; extern DF_CoreCmdKind df_g_cfg_src_apply_cmd_kind_table[4]; extern String8 df_g_icon_kind_text_table[69]; + C_LINKAGE_END #endif // DF_CORE_META_H diff --git a/src/df/gfx/df_views.c b/src/df/gfx/df_views.c index 93a85a2e..ba2a7879 100644 --- a/src/df/gfx/df_views.c +++ b/src/df/gfx/df_views.c @@ -3270,7 +3270,7 @@ DF_VIEW_UI_FUNCTION_DEF(SymbolLister) for(U64 idx = 0; idx < rdis_count; idx += 1) { rdis[idx] = di_rdi_from_key(di_scope, &dbgi_keys.v[idx], endt_us); - graphs[idx] = tg_graph_begin(rdi_addr_size_from_arch(rdis[idx]->top_level_info->architecture), 256); + graphs[idx] = tg_graph_begin(rdi_addr_size_from_arch(rdis[idx]->top_level_info->arch), 256); } } @@ -4933,7 +4933,7 @@ DF_VIEW_UI_FUNCTION_DEF(CallStack) TG_Key type_key = tg_key_ext(tg_kind_from_rdi_type_kind(type_node->kind), procedure->type_idx); U64 name_size = 0; U8 *name_ptr = rdi_string_from_idx(rdi, procedure->name_string_idx, &name_size); - TG_Graph *graph = tg_graph_begin(rdi_addr_size_from_arch(rdi->top_level_info->architecture), 256); + TG_Graph *graph = tg_graph_begin(rdi_addr_size_from_arch(rdi->top_level_info->arch), 256); symbol_name = str8(name_ptr, name_size); symbol_type_string = tg_string_from_key(scratch.arena, graph, rdi, type_key); } diff --git a/src/df/gfx/generated/df_gfx.meta.h b/src/df/gfx/generated/df_gfx.meta.h index f80263f6..8e8cfd30 100644 --- a/src/df/gfx/generated/df_gfx.meta.h +++ b/src/df/gfx/generated/df_gfx.meta.h @@ -5002,6 +5002,7 @@ read_only global U8 df_g_icon_file_bytes__data[] = }; read_only global String8 df_g_icon_file_bytes = {df_g_icon_file_bytes__data, sizeof(df_g_icon_file_bytes__data)}; + C_LINKAGE_END #endif // DF_GFX_META_H diff --git a/src/draw/generated/draw.meta.c b/src/draw/generated/draw.meta.c index eee3e601..50ed1be1 100644 --- a/src/draw/generated/draw.meta.c +++ b/src/draw/generated/draw.meta.c @@ -15,6 +15,3 @@ internal R_Tex2DSampleKind d_top_tex2d_sample_kind(void) {D_StackTopImp internal Mat3x3F32 d_top_xform2d(void) {D_StackTopImpl(XForm2D, xform2d, Mat3x3F32);} internal Rng2F32 d_top_clip(void) {D_StackTopImpl(Clip, clip, Rng2F32);} internal F32 d_top_transparency(void) {D_StackTopImpl(Transparency, transparency, F32);} -C_LINKAGE_BEGIN -C_LINKAGE_END - diff --git a/src/draw/generated/draw.meta.h b/src/draw/generated/draw.meta.h index e465899d..caa7723e 100644 --- a/src/draw/generated/draw.meta.h +++ b/src/draw/generated/draw.meta.h @@ -46,7 +46,4 @@ internal F32 d_top_transparency(void); #define D_ClipScope(v) DeferLoop(d_push_clip(v), d_pop_clip()) #define D_TransparencyScope(v) DeferLoop(d_push_transparency(v), d_pop_transparency()) #endif -C_LINKAGE_BEGIN -C_LINKAGE_END - #endif // DRAW_META_H diff --git a/src/eval/eval_compiler.c b/src/eval/eval_compiler.c index d8adf413..143a2fd1 100644 --- a/src/eval/eval_compiler.c +++ b/src/eval/eval_compiler.c @@ -23,7 +23,7 @@ eval_bytecode_from_oplist(Arena *arena, EVAL_OpList *list){ default: { // compute bytecode advance - U8 ctrlbits = rdi_eval_opcode_ctrlbits[opcode]; + U8 ctrlbits = rdi_eval_op_ctrlbits_table[opcode]; U64 extra_byte_count = RDI_DECODEN_FROM_CTRLBITS(ctrlbits); U8 *next_ptr = ptr + 1 + extra_byte_count; @@ -63,7 +63,7 @@ eval_bytecode_from_oplist(Arena *arena, EVAL_OpList *list){ internal void eval_oplist_push_op(Arena *arena, EVAL_OpList *list, RDI_EvalOp opcode, U64 p){ - U8 ctrlbits = rdi_eval_opcode_ctrlbits[opcode]; + U8 ctrlbits = rdi_eval_op_ctrlbits_table[opcode]; U32 p_size = RDI_DECODEN_FROM_CTRLBITS(ctrlbits); EVAL_Op *node = push_array_no_zero(arena, EVAL_Op, 1); @@ -654,7 +654,7 @@ eval_irtree_convert_hi(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, EVAL_IRTr TG_Kind out_kind = tg_kind_from_key(out); U8 in_group = eval_type_group_from_kind(in_kind); U8 out_group = eval_type_group_from_kind(out_kind); - U32 conversion_rule = rdi_eval_conversion_rule(in_group, out_group); + U32 conversion_rule = rdi_eval_conversion_kind_from_typegroups(in_group, out_group); if(conversion_rule == RDI_EvalConversionKind_Legal) { result = eval_irtree_convert_lo(arena, result, out_group, in_group); @@ -1080,7 +1080,7 @@ eval_irtree_and_type_from_expr(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, E // analyze situation U8 in_group = eval_type_group_from_kind(c_restype_kind); U8 out_group = eval_type_group_from_kind(cast_type_kind); - RDI_EvalConversionKind conversion_rule = rdi_eval_conversion_rule(in_group, out_group); + RDI_EvalConversionKind conversion_rule = rdi_eval_conversion_kind_from_typegroups(in_group, out_group); // generate tree switch(conversion_rule) @@ -1107,7 +1107,7 @@ eval_irtree_and_type_from_expr(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, E { String8 text = str8_lit("(internal) unknown conversion rule"); if (conversion_rule < RDI_EvalConversionKind_COUNT){ - text.str = rdi_eval_conversion_message(conversion_rule, &text.size); + text.str = rdi_explanation_string_from_eval_conversion_kind(conversion_rule, &text.size); } eval_error(arena, eout, EVAL_ErrorKind_MalformedInput, expr->location, text); }break; @@ -1172,7 +1172,7 @@ eval_irtree_and_type_from_expr(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, E B32 can_generate = 0; RDI_EvalOp op = eval_opcode_from_expr_kind(kind); U8 c_group = eval_type_group_from_kind(c_restype_kind); - if (!rdi_eval_opcode_type_compatible(op, c_group)){ + if (!rdi_eval_op_typegroup_are_compatible(op, c_group)){ eval_errorf(arena, eout, EVAL_ErrorKind_MalformedInput, expr->location, "Cannot use this operator on this type."); } else{ @@ -1301,7 +1301,7 @@ eval_irtree_and_type_from_expr(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, E U8 cv_group = eval_type_group_from_kind(cv_type_kind); B32 can_generate = 0; - if (rdi_eval_opcode_type_compatible(op, cv_group)){ + if (rdi_eval_op_typegroup_are_compatible(op, cv_group)){ can_generate = 1; } else{ @@ -1620,7 +1620,7 @@ eval_oplist_from_irtree(Arena *arena, EVAL_IRTree *tree, EVAL_OpList *out){ } else{ // handle all children - U8 ctrlbits = rdi_eval_opcode_ctrlbits[op]; + U8 ctrlbits = rdi_eval_op_ctrlbits_table[op]; U64 child_count = RDI_POPN_FROM_CTRLBITS(ctrlbits); EVAL_IRTree**child = tree->children; for (U64 i = 0; i < child_count; i += 1, child += 1){ diff --git a/src/eval/eval_machine.c b/src/eval/eval_machine.c index 0a44e9f9..5678fb87 100644 --- a/src/eval/eval_machine.c +++ b/src/eval/eval_machine.c @@ -27,7 +27,7 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode) result.code = EVAL_ResultCode_BadOp; goto done; } - U8 ctrlbits = rdi_eval_opcode_ctrlbits[op]; + U8 ctrlbits = rdi_eval_op_ctrlbits_table[op]; ptr += 1; // decode diff --git a/src/eval/eval_parser.c b/src/eval/eval_parser.c index bd0379f7..f2bb4ceb 100644 --- a/src/eval/eval_parser.c +++ b/src/eval/eval_parser.c @@ -173,7 +173,7 @@ eval_push_member_map_from_rdi_voff(Arena *arena, RDI_Parsed *rdi, U64 voff) *map = eval_string2num_map_make(arena, 64); //- rjf: udt -> fill member map - if(udt != 0 && !(udt->flags & RDI_UserDefinedTypeFlag_EnumMembers) && rdi->members != 0) + if(udt != 0 && !(udt->flags & RDI_UDTFlag_EnumMembers) && rdi->members != 0) { U64 data_member_num = 1; for(U32 member_idx = udt->member_first; @@ -827,14 +827,14 @@ eval_parse_expr_from_text_tokens__prec(Arena *arena, EVAL_ParseCtx *ctx, String8 B32 mapped_identifier = 0; B32 identifier_type_is_possibly_dynamically_overridden = 0; B32 identifier_looks_like_type_expr = 0; - RDI_LocationKind loc_kind = RDI_LocationKind_NULL; - RDI_LocationRegister loc_reg = {0}; - RDI_LocationRegisterPlusU16 loc_reg_u16 = {0}; - String8 loc_bytecode = {0}; - REGS_RegCode reg_code = 0; - REGS_AliasCode alias_code = 0; - TG_Key type_key = zero_struct; - String8 local_lookup_string = token_string; + RDI_LocationKind loc_kind = RDI_LocationKind_NULL; + RDI_LocationReg loc_reg = {0}; + RDI_LocationRegPlusU16 loc_reg_u16 = {0}; + String8 loc_bytecode = {0}; + REGS_RegCode reg_code = 0; + REGS_AliasCode alias_code = 0; + TG_Key type_key = zero_struct; + String8 local_lookup_string = token_string; //- rjf: form namespaceified fallback versions of this lookup string String8List namespaceified_token_strings = {0}; @@ -911,18 +911,18 @@ eval_parse_expr_from_text_tokens__prec(Arena *arena, EVAL_ParseCtx *ctx, String8 { break; } - U8 ctrlbits = rdi_eval_opcode_ctrlbits[op]; + U8 ctrlbits = rdi_eval_op_ctrlbits_table[op]; U32 p_size = RDI_DECODEN_FROM_CTRLBITS(ctrlbits); bytecode_size += 1+p_size; } loc_bytecode = str8(bytecode_base, bytecode_size); }break; - case RDI_LocationKind_AddrRegisterPlusU16: - case RDI_LocationKind_AddrAddrRegisterPlusU16: + case RDI_LocationKind_AddrRegPlusU16: + case RDI_LocationKind_AddrAddrRegPlusU16: { MemoryCopy(&loc_reg_u16, (ctx->rdi->location_data + block->location_data_off), sizeof(loc_reg_u16)); }break; - case RDI_LocationKind_ValRegister: + case RDI_LocationKind_ValReg: { MemoryCopy(&loc_reg, (ctx->rdi->location_data + block->location_data_off), sizeof(loc_reg)); }break; @@ -1134,35 +1134,35 @@ eval_parse_expr_from_text_tokens__prec(Arena *arena, EVAL_ParseCtx *ctx, String8 { atom = eval_expr_leaf_bytecode(arena, token_string.str, type_key, loc_bytecode, EVAL_EvalMode_Value); }break; - case RDI_LocationKind_AddrRegisterPlusU16: + case RDI_LocationKind_AddrRegPlusU16: { EVAL_OpList oplist = {0}; U64 byte_size = bit_size_from_arch(ctx->arch)/8; - U64 regread_param = RDI_EncodeRegReadParam(loc_reg_u16.register_code, byte_size, 0); + U64 regread_param = RDI_EncodeRegReadParam(loc_reg_u16.reg_code, byte_size, 0); eval_oplist_push_op(arena, &oplist, RDI_EvalOp_RegRead, regread_param); eval_oplist_push_op(arena, &oplist, RDI_EvalOp_ConstU16, loc_reg_u16.offset); eval_oplist_push_op(arena, &oplist, RDI_EvalOp_Add, 0); atom = eval_expr_leaf_op_list(arena, token_string.str, type_key, &oplist, EVAL_EvalMode_Addr); }break; - case RDI_LocationKind_AddrAddrRegisterPlusU16: + case RDI_LocationKind_AddrAddrRegPlusU16: { EVAL_OpList oplist = {0}; U64 byte_size = bit_size_from_arch(ctx->arch)/8; - U64 regread_param = RDI_EncodeRegReadParam(loc_reg_u16.register_code, byte_size, 0); + U64 regread_param = RDI_EncodeRegReadParam(loc_reg_u16.reg_code, byte_size, 0); eval_oplist_push_op(arena, &oplist, RDI_EvalOp_RegRead, regread_param); eval_oplist_push_op(arena, &oplist, RDI_EvalOp_ConstU16, loc_reg_u16.offset); eval_oplist_push_op(arena, &oplist, RDI_EvalOp_Add, 0); eval_oplist_push_op(arena, &oplist, RDI_EvalOp_MemRead, bit_size_from_arch(ctx->arch)/8); atom = eval_expr_leaf_op_list(arena, token_string.str, type_key, &oplist, EVAL_EvalMode_Addr); }break; - case RDI_LocationKind_ValRegister: + case RDI_LocationKind_ValReg: { - REGS_RegCode regs_reg_code = regs_reg_code_from_arch_rdi_code(ctx->arch, loc_reg.register_code); + REGS_RegCode regs_reg_code = regs_reg_code_from_arch_rdi_code(ctx->arch, loc_reg.reg_code); REGS_Rng reg_rng = regs_reg_code_rng_table_from_architecture(ctx->arch)[regs_reg_code]; EVAL_OpList oplist = {0}; U64 byte_size = (U64)reg_rng.byte_size; U64 byte_pos = 0; - U64 regread_param = RDI_EncodeRegReadParam(loc_reg.register_code, byte_size, byte_pos); + U64 regread_param = RDI_EncodeRegReadParam(loc_reg.reg_code, byte_size, byte_pos); eval_oplist_push_op(arena, &oplist, RDI_EvalOp_RegRead, regread_param); atom = eval_expr_leaf_op_list(arena, token_string.str, type_key, &oplist, EVAL_EvalMode_Value); }break; diff --git a/src/eval/generated/eval.meta.h b/src/eval/generated/eval.meta.h index 4c90936c..64e54422 100644 --- a/src/eval/generated/eval.meta.h +++ b/src/eval/generated/eval.meta.h @@ -73,6 +73,7 @@ extern U8 eval_expr_kind_child_counts[40]; extern String8 eval_expr_kind_strings[40]; extern String8 eval_result_code_display_strings[11]; extern String8 eval_expr_op_strings[40]; + C_LINKAGE_END #endif // EVAL_META_H diff --git a/src/lib_rdi_format/rdi_format.c b/src/lib_rdi_format/rdi_format.c index 8d5ea8b8..f13c0ad1 100644 --- a/src/lib_rdi_format/rdi_format.c +++ b/src/lib_rdi_format/rdi_format.c @@ -43,7 +43,7 @@ rdi_addr_size_from_arch(RDI_Arch arch){ //- eval helpers RDI_PROC RDI_EvalConversionKind -rdi_eval_conversion_rule(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out){ +rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out){ RDI_EvalConversionKind result = 0; switch (in + (out << 8)){ #define Y(i,o) case ((RDI_EvalTypeGroup_##i) + ((RDI_EvalTypeGroup_##o) << 8)): @@ -58,7 +58,7 @@ rdi_eval_conversion_rule(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out){ } RDI_PROC RDI_U8* -rdi_eval_conversion_message(RDI_EvalConversionKind conversion_kind, RDI_U64 *lenout){ +rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind conversion_kind, RDI_U64 *lenout){ RDI_U8 *result = 0; switch (conversion_kind){ #define X(N,msg) \ @@ -70,7 +70,7 @@ case RDI_EvalConversionKind_##N: result = (RDI_U8*)msg; *lenout = sizeof(msg) - } RDI_PROC RDI_S32 -rdi_eval_opcode_type_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group){ +rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group){ RDI_S32 result = 0; switch (op){ case RDI_EvalOp_Neg: case RDI_EvalOp_Add: case RDI_EvalOp_Sub: diff --git a/src/lib_rdi_format/rdi_format.h b/src/lib_rdi_format/rdi_format.h index 23fd54d0..4977dec0 100644 --- a/src/lib_rdi_format/rdi_format.h +++ b/src/lib_rdi_format/rdi_format.h @@ -57,7 +57,7 @@ typedef enum RDI_ArchEnum{ } RDI_ArchEnum; -typedef RDI_U8 RDI_RegisterCode; +typedef RDI_U8 RDI_RegCode; // x86 registers #define RDI_RegisterCode_X86_XList(X) \ @@ -327,7 +327,7 @@ typedef struct RDI_VMapEntry{ //- top level info typedef struct RDI_TopLevelInfo{ - RDI_Arch architecture; + RDI_Arch arch; RDI_U32 exe_name_string_idx; RDI_U64 exe_hash; RDI_U64 voff_max; @@ -541,14 +541,14 @@ typedef struct RDI_TypeNode{ }; } RDI_TypeNode; -typedef RDI_U32 RDI_UserDefinedTypeFlags; +typedef RDI_U32 RDI_UDTFlags; enum{ - RDI_UserDefinedTypeFlag_EnumMembers = (1 << 0), + RDI_UDTFlag_EnumMembers = (1 << 0), }; typedef struct RDI_UDT{ RDI_U32 self_type_idx; - RDI_UserDefinedTypeFlags flags; + RDI_UDTFlags flags; // when EnumMembers flag is set, indexes into enum "enum_members" instead of "members" RDI_U32 member_first; @@ -697,9 +697,9 @@ typedef enum{ RDI_LocationKind_NULL, RDI_LocationKind_AddrBytecodeStream, RDI_LocationKind_ValBytecodeStream, - RDI_LocationKind_AddrRegisterPlusU16, - RDI_LocationKind_AddrAddrRegisterPlusU16, - RDI_LocationKind_ValRegister, + RDI_LocationKind_AddrRegPlusU16, + RDI_LocationKind_AddrAddrRegPlusU16, + RDI_LocationKind_ValReg, RDI_LocationKind_COUNT } RDI_LocationKindEnum; @@ -708,16 +708,16 @@ typedef struct RDI_LocationBytecodeStream{ // [... 0] null terminated byte sequence RDI_EvalBytecodeStream } RDI_LocationBytecodeStream; -typedef struct RDI_LocationRegisterPlusU16{ +typedef struct RDI_LocationRegPlusU16{ RDI_LocationKind kind; - RDI_RegisterCode register_code; + RDI_RegCode reg_code; RDI_U16 offset; -} RDI_LocationRegisterPlusU16; +} RDI_LocationRegPlusU16; -typedef struct RDI_LocationRegister{ +typedef struct RDI_LocationReg{ RDI_LocationKind kind; - RDI_RegisterCode register_code; -} RDI_LocationRegister; + RDI_RegCode reg_code; +} RDI_LocationReg; //- name map types #define RDI_NameMapXList(X)\ @@ -905,7 +905,7 @@ typedef enum RDI_EvalConversionKindEnum{ #define RDI_POPN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 4) & 0x3) #define RDI_PUSHN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 6) & 0x3) -static RDI_U8 rdi_eval_opcode_ctrlbits[] = { +static RDI_U8 rdi_eval_op_ctrlbits_table[] = { #define X(Name, decodeN, popN, pushN) RDI_EVAL_CTRLBITS(decodeN,popN,pushN), RDI_EvalOpXList(X) #undef X @@ -920,8 +920,8 @@ RDI_PROC RDI_U32 rdi_addr_size_from_arch(RDI_Arch arch); //- eval helpers -RDI_PROC RDI_EvalConversionKind rdi_eval_conversion_rule(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out); -RDI_PROC RDI_U8* rdi_eval_conversion_message(RDI_EvalConversionKind conversion_kind, RDI_U64 *lennout); -RDI_PROC RDI_S32 rdi_eval_opcode_type_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group); +RDI_PROC RDI_EvalConversionKind rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out); +RDI_PROC RDI_U8* rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind conversion_kind, RDI_U64 *lennout); +RDI_PROC RDI_S32 rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group); #endif // RDI_FORMAT_H diff --git a/src/lib_rdi_make/rdi_make.c b/src/lib_rdi_make/rdi_make.c index b3acd4da..ba144524 100644 --- a/src/lib_rdi_make/rdi_make.c +++ b/src/lib_rdi_make/rdi_make.c @@ -844,7 +844,7 @@ rdim_scope_push_local(RDIM_Arena *arena, RDIM_ScopeChunkList *scopes, RDIM_Scope RDI_PROC void rdim_bytecode_push_op(RDIM_Arena *arena, RDIM_EvalBytecode *bytecode, RDI_EvalOp op, RDI_U64 p) { - RDI_U8 ctrlbits = rdi_eval_opcode_ctrlbits[op]; + RDI_U8 ctrlbits = rdi_eval_op_ctrlbits_table[op]; RDI_U32 p_size = RDI_DECODEN_FROM_CTRLBITS(ctrlbits); RDIM_EvalBytecodeOp *node = rdim_push_array(arena, RDIM_EvalBytecodeOp, 1); @@ -945,8 +945,8 @@ RDI_PROC RDIM_Location * rdim_push_location_addr_reg_plus_u16(RDIM_Arena *arena, RDI_U8 reg_code, RDI_U16 offset) { RDIM_Location *result = rdim_push_array(arena, RDIM_Location, 1); - result->kind = RDI_LocationKind_AddrRegisterPlusU16; - result->register_code = reg_code; + result->kind = RDI_LocationKind_AddrRegPlusU16; + result->reg_code = reg_code; result->offset = offset; return result; } @@ -955,8 +955,8 @@ RDI_PROC RDIM_Location * rdim_push_location_addr_addr_reg_plus_u16(RDIM_Arena *arena, RDI_U8 reg_code, RDI_U16 offset) { RDIM_Location *result = rdim_push_array(arena, RDIM_Location, 1); - result->kind = RDI_LocationKind_AddrAddrRegisterPlusU16; - result->register_code = reg_code; + result->kind = RDI_LocationKind_AddrAddrRegPlusU16; + result->reg_code = reg_code; result->offset = offset; return result; } @@ -965,8 +965,8 @@ RDI_PROC RDIM_Location * rdim_push_location_val_reg(RDIM_Arena *arena, RDI_U8 reg_code) { RDIM_Location *result = rdim_push_array(arena, RDIM_Location, 1); - result->kind = RDI_LocationKind_ValRegister; - result->register_code = reg_code; + result->kind = RDI_LocationKind_ValReg; + result->reg_code = reg_code; return result; } @@ -2140,7 +2140,7 @@ rdim_bake_top_level_info_section_list_from_params(RDIM_Arena *arena, RDIM_BakeSt RDIM_BakeSectionList sections = {0}; RDI_TopLevelInfo *dst_tli = rdim_push_array(arena, RDI_TopLevelInfo, 1); RDIM_TopLevelInfo *src_tli = ¶ms->top_level_info; - dst_tli->architecture = src_tli->arch; + dst_tli->arch = src_tli->arch; dst_tli->exe_name_string_idx = rdim_bake_idx_from_string(strings, src_tli->exe_name); dst_tli->exe_hash = src_tli->exe_hash; dst_tli->voff_max = src_tli->voff_max; @@ -2827,7 +2827,7 @@ rdim_bake_udt_section_list_from_params(RDIM_Arena *arena, RDIM_BakeStringMapTigh //- rjf: fill enum members else if(src_udt->enum_val_count != 0) { - dst_udt->flags |= RDI_UserDefinedTypeFlag_EnumMembers; + dst_udt->flags |= RDI_UDTFlag_EnumMembers; dst_udt->member_first = dst_enum_member_idx; dst_udt->member_count = src_udt->enum_val_count; for(RDIM_UDTEnumVal *src_member = src_udt->first_enum_val; @@ -3160,22 +3160,22 @@ rdim_bake_scope_section_list_from_params(RDIM_Arena *arena, RDIM_BakeStringMapTi }break; // rjf: simple addr+off cases - case RDI_LocationKind_AddrRegisterPlusU16: - case RDI_LocationKind_AddrAddrRegisterPlusU16: + case RDI_LocationKind_AddrRegPlusU16: + case RDI_LocationKind_AddrAddrRegPlusU16: { - RDI_LocationRegisterPlusU16 loc = {0}; + RDI_LocationRegPlusU16 loc = {0}; loc.kind = src_location->kind; - loc.register_code = src_location->register_code; + loc.reg_code = src_location->reg_code; loc.offset = src_location->offset; rdim_str8_list_push(scratch.arena, &location_data_blobs, rdim_str8_copy(scratch.arena, rdim_str8_struct(&loc))); }break; // rjf: register cases - case RDI_LocationKind_ValRegister: + case RDI_LocationKind_ValReg: { - RDI_LocationRegister loc = {0}; + RDI_LocationReg loc = {0}; loc.kind = src_location->kind; - loc.register_code = src_location->register_code; + loc.reg_code = src_location->reg_code; rdim_str8_list_push(scratch.arena, &location_data_blobs, rdim_str8_copy(scratch.arena, rdim_str8_struct(&loc))); }break; } diff --git a/src/lib_rdi_make/rdi_make.h b/src/lib_rdi_make/rdi_make.h index 3a497e43..c12c2a0e 100644 --- a/src/lib_rdi_make/rdi_make.h +++ b/src/lib_rdi_make/rdi_make.h @@ -668,7 +668,7 @@ typedef struct RDIM_Location RDIM_Location; struct RDIM_Location { RDI_LocationKind kind; - RDI_U8 register_code; + RDI_U8 reg_code; RDI_U16 offset; RDIM_EvalBytecode bytecode; }; diff --git a/src/metagen/metagen.c b/src/metagen/metagen.c index 5da28126..dae1bdbf 100644 --- a/src/metagen/metagen.c +++ b/src/metagen/metagen.c @@ -1026,7 +1026,12 @@ mg_string_list_from_table_gen(Arena *arena, MG_Map grid_name_map, MG_Map grid_co { String8List result = {0}; Temp scratch = scratch_begin(&arena, 1); - for(MD_EachNode(strexpr_node, gen->first)) + if(md_node_is_nil(gen->first) && gen->string.size != 0) + { + str8_list_push(arena, &result, gen->string); + str8_list_push(arena, &result, str8_lit("\n")); + } + else for(MD_EachNode(strexpr_node, gen->first)) { // rjf: build task list MG_TableExpandTask *first_task = 0; diff --git a/src/metagen/metagen.h b/src/metagen/metagen.h index d15fbe74..1026eb39 100644 --- a/src/metagen/metagen.h +++ b/src/metagen/metagen.h @@ -212,14 +212,21 @@ typedef struct MG_Layer MG_Layer; struct MG_Layer { String8 key; + B32 is_library; + String8 h_name_override; + String8 c_name_override; String8List enums; String8List structs; String8List h_functions; String8List h_tables; String8List h_catchall; + String8List h_header; + String8List h_footer; String8List c_functions; String8List c_tables; String8List c_catchall; + String8List c_header; + String8List c_footer; }; typedef struct MG_LayerNode MG_LayerNode; diff --git a/src/metagen/metagen_main.c b/src/metagen/metagen_main.c index 7ad38268..2f85ec09 100644 --- a/src/metagen/metagen_main.c +++ b/src/metagen/metagen_main.c @@ -149,6 +149,83 @@ int main(int argument_count, char **arguments) } } + ////////////////////////////// + //- rjf: gather layer options + // + for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) + { + MD_Node *file = n->v.root; + String8 layer_key = mg_layer_key_from_path(file->string); + MG_Layer *layer = mg_layer_from_key(layer_key); + for(MD_EachNode(node, file->first)) + { + if(md_node_has_tag(node, str8_lit("option"), 0)) + { + if(str8_match(node->string, str8_lit("library"), 0)) + { + layer->is_library = 1; + } + } + } + } + + ////////////////////////////// + //- rjf: gather hand-written h/c names & decorations + // + for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) + { + MD_Node *file = n->v.root; + String8 layer_key = mg_layer_key_from_path(file->string); + MG_Layer *layer = mg_layer_from_key(layer_key); + for(MD_EachNode(node, file->first)) + { + if(md_node_has_tag(node, str8_lit("h_name"), 0)) + { + layer->h_name_override = node->string; + } + if(md_node_has_tag(node, str8_lit("c_name"), 0)) + { + layer->c_name_override = node->string; + } + if(md_node_has_tag(node, str8_lit("h_header"), 0)) + { + 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) + { + str8_list_push(mg_arena, &layer->h_header, n->string); + str8_list_push(mg_arena, &layer->h_header, str8_lit("\n")); + } + } + if(md_node_has_tag(node, str8_lit("h_footer"), 0)) + { + 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) + { + str8_list_push(mg_arena, &layer->h_footer, n->string); + str8_list_push(mg_arena, &layer->h_footer, str8_lit("\n")); + } + } + if(md_node_has_tag(node, str8_lit("c_header"), 0)) + { + 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) + { + str8_list_push(mg_arena, &layer->c_header, n->string); + str8_list_push(mg_arena, &layer->c_header, str8_lit("\n")); + } + } + if(md_node_has_tag(node, str8_lit("c_footer"), 0)) + { + 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) + { + str8_list_push(mg_arena, &layer->c_footer, n->string); + str8_list_push(mg_arena, &layer->c_footer, str8_lit("\n")); + } + } + } + } + ////////////////////////////// //- rjf: generate enums // @@ -160,31 +237,37 @@ int main(int argument_count, char **arguments) MD_Node *tag = md_tag_from_string(node, str8_lit("enum"), 0); if(!md_node_is_nil(tag)) { + String8 enum_name = node->string; + String8 enum_member_prefix = enum_name; + if(str8_match(str8_postfix(enum_name, 5), str8_lit("Flags"), 0)) + { + enum_member_prefix = str8_chop(enum_name, 1); + } String8 enum_base_type_name = 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); if(enum_base_type_name.size == 0) { - str8_list_pushf(mg_arena, &layer->enums, "typedef enum %S\n{\n", node->string); + str8_list_pushf(mg_arena, &layer->enums, "typedef enum %S\n{\n", enum_name); } else { - str8_list_pushf(mg_arena, &layer->enums, "typedef %S %S;\n", enum_base_type_name, node->string); - str8_list_pushf(mg_arena, &layer->enums, "typedef enum %SEnum\n{\n", node->string); + str8_list_pushf(mg_arena, &layer->enums, "typedef %S %S;\n", enum_base_type_name, enum_name); + str8_list_pushf(mg_arena, &layer->enums, "typedef enum %SEnum\n{\n", enum_name); } 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->enums, "%S_%S,\n", node->string, escaped); + str8_list_pushf(mg_arena, &layer->enums, "%S_%S,\n", enum_member_prefix, escaped); } if(enum_base_type_name.size == 0) { - str8_list_pushf(mg_arena, &layer->enums, "} %S;\n\n", node->string); + str8_list_pushf(mg_arena, &layer->enums, "} %S;\n\n", enum_name); } else { - str8_list_pushf(mg_arena, &layer->enums, "} %SEnum;\n\n", node->string); + str8_list_pushf(mg_arena, &layer->enums, "} %SEnum;\n\n", enum_name); } } } @@ -301,7 +384,8 @@ int main(int argument_count, char **arguments) 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) { - String8 escaped = mg_escaped_from_str8(mg_arena, n->string); + String8 trimmed = str8_skip_chop_whitespace(n->string); + String8 escaped = mg_escaped_from_str8(mg_arena, trimmed); str8_list_push(mg_arena, out, escaped); str8_list_push(mg_arena, out, str8_lit("\n")); } @@ -425,13 +509,28 @@ int main(int argument_count, char **arguments) String8 layer_key_filename_upper = upper_from_str8(mg_arena, layer_key_filename); String8 h_path = push_str8f(mg_arena, "%S/%S.meta.h", layer_generated_folder, layer_key_filename); String8 c_path = push_str8f(mg_arena, "%S/%S.meta.c", layer_generated_folder, layer_key_filename); + if(layer->h_name_override.size != 0) + { + h_path = push_str8f(mg_arena, "%S/%S", layer_generated_folder, str8_skip_last_slash(layer->h_name_override)); + } + if(layer->c_name_override.size != 0) + { + c_path = push_str8f(mg_arena, "%S/%S", layer_generated_folder, str8_skip_last_slash(layer->c_name_override)); + } { FILE *h = fopen((char *)h_path.str, "w"); fprintf(h, "// Copyright (c) 2024 Epic Games Tools\n"); fprintf(h, "// Licensed under the MIT license (https://opensource.org/license/mit/)\n\n"); - fprintf(h, "//- GENERATED CODE\n\n"); - fprintf(h, "#ifndef %.*s_META_H\n", str8_varg(layer_key_filename_upper)); - fprintf(h, "#define %.*s_META_H\n\n", str8_varg(layer_key_filename_upper)); + if(layer->h_header.first == 0) + { + fprintf(h, "//- GENERATED CODE\n\n"); + fprintf(h, "#ifndef %.*s_META_H\n", str8_varg(layer_key_filename_upper)); + fprintf(h, "#define %.*s_META_H\n\n", str8_varg(layer_key_filename_upper)); + } + else for(String8Node *n = layer->h_header.first; n != 0; n = n->next) + { + fwrite(n->string.str, n->string.size, 1, h); + } for(String8Node *n = layer->enums.first; n != 0; n = n->next) { fwrite(n->string.str, n->string.size, 1, h); @@ -448,34 +547,74 @@ int main(int argument_count, char **arguments) { fwrite(n->string.str, n->string.size, 1, h); } - fprintf(h, "C_LINKAGE_BEGIN\n"); - for(String8Node *n = layer->h_tables.first; n != 0; n = n->next) + if(layer->h_tables.first != 0) + { + if(!layer->is_library) + { + fprintf(h, "C_LINKAGE_BEGIN\n"); + } + for(String8Node *n = layer->h_tables.first; n != 0; n = n->next) + { + fwrite(n->string.str, n->string.size, 1, h); + } + fprintf(h, "\n"); + if(!layer->is_library) + { + fprintf(h, "C_LINKAGE_END\n\n"); + } + } + if(layer->h_footer.first == 0) + { + fprintf(h, "#endif // %.*s_META_H\n", str8_varg(layer_key_filename_upper)); + } + else for(String8Node *n = layer->h_footer.first; n != 0; n = n->next) { fwrite(n->string.str, n->string.size, 1, h); } - fprintf(h, "C_LINKAGE_END\n\n"); - fprintf(h, "#endif // %.*s_META_H\n", str8_varg(layer_key_filename_upper)); fclose(h); } { FILE *c = fopen((char *)c_path.str, "w"); fprintf(c, "// Copyright (c) 2024 Epic Games Tools\n"); fprintf(c, "// Licensed under the MIT license (https://opensource.org/license/mit/)\n\n"); - fprintf(c, "//- GENERATED CODE\n\n"); + if(layer->c_header.first == 0) + { + fprintf(c, "//- GENERATED CODE\n\n"); + } + else for(String8Node *n = layer->c_header.first; n != 0; n = n->next) + { + fwrite(n->string.str, n->string.size, 1, c); + } for(String8Node *n = layer->c_catchall.first; n != 0; n = n->next) { fwrite(n->string.str, n->string.size, 1, c); } + if(layer->c_tables.first != 0) + { + if(!layer->is_library) + { + fprintf(c, "C_LINKAGE_BEGIN\n"); + } + for(String8Node *n = layer->c_tables.first; n != 0; n = n->next) + { + fwrite(n->string.str, n->string.size, 1, c); + } + if(!layer->is_library) + { + fprintf(c, "C_LINKAGE_END\n\n"); + } + } for(String8Node *n = layer->c_functions.first; n != 0; n = n->next) { fwrite(n->string.str, n->string.size, 1, c); } - fprintf(c, "C_LINKAGE_BEGIN\n"); - for(String8Node *n = layer->c_tables.first; n != 0; n = n->next) + if(layer->c_footer.first != 0) { - fwrite(n->string.str, n->string.size, 1, c); + for(String8Node *n = layer->c_footer.first; n != 0; n = n->next) + { + fwrite(n->string.str, n->string.size, 1, c); + } } - fprintf(c, "C_LINKAGE_END\n\n"); fclose(c); } } diff --git a/src/os/gfx/generated/os_gfx.meta.h b/src/os/gfx/generated/os_gfx.meta.h index ffa90e62..f5b9a603 100644 --- a/src/os/gfx/generated/os_gfx.meta.h +++ b/src/os/gfx/generated/os_gfx.meta.h @@ -157,6 +157,7 @@ OS_Key_COUNT, C_LINKAGE_BEGIN extern String8 os_g_key_display_string_table[143]; extern String8 os_g_key_cfg_string_table[143]; + C_LINKAGE_END #endif // OS_GFX_META_H diff --git a/src/rdi_dump/rdi_dump.c b/src/rdi_dump/rdi_dump.c index 54372d81..b847c4be 100644 --- a/src/rdi_dump/rdi_dump.c +++ b/src/rdi_dump/rdi_dump.c @@ -113,12 +113,12 @@ rdi_stringize_type_modifier_flags(Arena *arena, String8List *out, } internal void -rdi_stringize_user_defined_type_flags(Arena *arena, String8List *out, - RDI_UserDefinedTypeFlags flags){ +rdi_stringize_udt_flags(Arena *arena, String8List *out, + RDI_UDTFlags flags){ if (flags == 0){ str8_list_push(arena, out, str8_lit("0")); } - if (flags & RDI_UserDefinedTypeFlag_EnumMembers){ + if (flags & RDI_UDTFlag_EnumMembers){ str8_list_push(arena, out, str8_lit("EnumMembers ")); } } @@ -452,7 +452,7 @@ rdi_stringize_udt(Arena *arena, String8List *out, RDI_Parsed *parsed, indent_level, rdi_stringize_spaces, udt->self_type_idx); str8_list_pushf(arena, out, "%.*sflags=", indent_level, rdi_stringize_spaces); - rdi_stringize_user_defined_type_flags(arena, out, udt->flags); + rdi_stringize_udt_flags(arena, out, udt->flags); str8_list_push(arena, out, str8_lit("\n")); if (udt->file_idx != 0){ @@ -462,7 +462,7 @@ rdi_stringize_udt(Arena *arena, String8List *out, RDI_Parsed *parsed, } // enum members - if (udt->flags & RDI_UserDefinedTypeFlag_EnumMembers){ + if (udt->flags & RDI_UDTFlag_EnumMembers){ U32 first_raw = udt->member_first; U32 opl_raw = first_raw + udt->member_count; U32 opl = ClampTop(opl_raw, member_bundle->enum_member_count); @@ -712,38 +712,38 @@ rdi_stringize_scope(Arena *arena, String8List *out, RDI_Parsed *parsed, str8_list_pushf(arena, out, "\n"); }break; - case RDI_LocationKind_AddrRegisterPlusU16: + case RDI_LocationKind_AddrRegPlusU16: { - if (loc_base_ptr + sizeof(RDI_LocationRegisterPlusU16) > loc_data_opl){ - str8_list_pushf(arena, out, "AddrRegisterPlusU16( )\n"); + if (loc_base_ptr + sizeof(RDI_LocationRegPlusU16) > loc_data_opl){ + str8_list_pushf(arena, out, "AddrRegPlusU16( )\n"); } else{ - RDI_LocationRegisterPlusU16 *loc = (RDI_LocationRegisterPlusU16*)loc_base_ptr; - str8_list_pushf(arena, out, "AddrRegisterPlusU16(reg: %u, off: %u)\n", - loc->register_code, loc->offset); + RDI_LocationRegPlusU16 *loc = (RDI_LocationRegPlusU16*)loc_base_ptr; + str8_list_pushf(arena, out, "AddrRegPlusU16(reg: %u, off: %u)\n", + loc->reg_code, loc->offset); } }break; - case RDI_LocationKind_AddrAddrRegisterPlusU16: + case RDI_LocationKind_AddrAddrRegPlusU16: { - if (loc_base_ptr + sizeof(RDI_LocationRegisterPlusU16) > loc_data_opl){ - str8_list_pushf(arena, out, "AddrAddrRegisterPlusU16( )\n"); + if (loc_base_ptr + sizeof(RDI_LocationRegPlusU16) > loc_data_opl){ + str8_list_pushf(arena, out, "AddrAddrRegPlusU16( )\n"); } else{ - RDI_LocationRegisterPlusU16 *loc = (RDI_LocationRegisterPlusU16*)loc_base_ptr; + RDI_LocationRegPlusU16 *loc = (RDI_LocationRegPlusU16*)loc_base_ptr; str8_list_pushf(arena, out, "AddrAddrRegisterPlusU16(reg: %u, off: %u)\n", - loc->register_code, loc->offset); + loc->reg_code, loc->offset); } }break; - case RDI_LocationKind_ValRegister: + case RDI_LocationKind_ValReg: { - if (loc_base_ptr + sizeof(RDI_LocationRegister) > loc_data_opl){ - str8_list_pushf(arena, out, "ValRegister( )\n"); + if (loc_base_ptr + sizeof(RDI_LocationReg) > loc_data_opl){ + str8_list_pushf(arena, out, "ValReg( )\n"); } else{ - RDI_LocationRegister *loc = (RDI_LocationRegister*)loc_base_ptr; - str8_list_pushf(arena, out, "ValRegister(reg: %u)\n", loc->register_code); + RDI_LocationReg *loc = (RDI_LocationReg*)loc_base_ptr; + str8_list_pushf(arena, out, "ValReg(reg: %u)\n", loc->reg_code); } }break; } diff --git a/src/rdi_dump/rdi_dump.h b/src/rdi_dump/rdi_dump.h index 473093d9..8af9fa62 100644 --- a/src/rdi_dump/rdi_dump.h +++ b/src/rdi_dump/rdi_dump.h @@ -53,7 +53,7 @@ internal String8 rdi_string_from_local_kind(RDI_LocalKind local_kind); internal void rdi_stringize_binary_section_flags(Arena *arena, String8List *out, RDI_BinarySectionFlags flags); internal void rdi_stringize_type_modifier_flags(Arena *arena, String8List *out, RDI_TypeModifierFlags flags); -internal void rdi_stringize_user_defined_type_flags(Arena *arena, String8List *out, RDI_UserDefinedTypeFlags flags); +internal void rdi_stringize_udt_flags(Arena *arena, String8List *out, RDI_UDTFlags flags); internal void rdi_stringize_link_flags(Arena *arena, String8List *out, RDI_LinkFlags flags); //////////////////////////////// diff --git a/src/rdi_format/generated/rdi_format.c b/src/rdi_format/generated/rdi_format.c new file mode 100644 index 00000000..b2a5be27 --- /dev/null +++ b/src/rdi_format/generated/rdi_format.c @@ -0,0 +1,196 @@ +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//////////////////////////////////////////////////////////////// +//~ RAD Debug Info, (R)AD(D)BG(I) Format Library +// +// Defines standard RDI debug information format types and +// functions. + +#ifndef RDI_FORMAT_C +#define RDI_FORMAT_C + +RDI_U8 rdi_eval_op_ctrlbits_table[45] = +{ +RDI_EVAL_CTRLBITS(0, 0, 0), +RDI_EVAL_CTRLBITS(0, 0, 0), +RDI_EVAL_CTRLBITS(1, 1, 0), +RDI_EVAL_CTRLBITS(1, 0, 0), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(4, 0, 1), +RDI_EVAL_CTRLBITS(0, 1, 1), +RDI_EVAL_CTRLBITS(1, 0, 1), +RDI_EVAL_CTRLBITS(4, 0, 1), +RDI_EVAL_CTRLBITS(4, 0, 1), +RDI_EVAL_CTRLBITS(0, 0, 0), +RDI_EVAL_CTRLBITS(0, 0, 0), +RDI_EVAL_CTRLBITS(1, 0, 1), +RDI_EVAL_CTRLBITS(2, 0, 1), +RDI_EVAL_CTRLBITS(4, 0, 1), +RDI_EVAL_CTRLBITS(8, 0, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(2, 1, 1), +RDI_EVAL_CTRLBITS(1, 0, 1), +RDI_EVAL_CTRLBITS(0, 1, 0), +RDI_EVAL_CTRLBITS(1, 0, 0), +RDI_EVAL_CTRLBITS(0, 0, 0), +}; + +struct {RDI_EvalConversionKind dst_typegroups[RDI_EvalTypeGroup_COUNT];} rdi_eval_typegroup_conversion_kind_matrix[6] = +{ +{{RDI_EvalConversionKind_OtherToOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther}}, +{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal}}, +{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal}}, +{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal}}, +{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Noop}}, +{{RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop}}, +}; + +struct {RDI_U8 *str; RDI_U64 size;} rdi_eval_conversion_kind_message_string_table[6] = +{ +{(RDI_U8 *)"Other", sizeof("Other")}, +{(RDI_U8 *)"U", sizeof("U")}, +{(RDI_U8 *)"S", sizeof("S")}, +{(RDI_U8 *)"F32", sizeof("F32")}, +{(RDI_U8 *)"F64", sizeof("F64")}, +{(RDI_U8 *)"COUNT", sizeof("COUNT")}, +}; + +RDI_PROC RDI_U64 +rdi_hash(RDI_U8 *ptr, RDI_U64 size) +{ + RDI_U64 result = 5381; + RDI_U8 *opl = ptr + size; + for(;ptr < opl; ptr += 1) + { + result = ((result << 5) + result) + *ptr; + } + return result; +} + +RDI_PROC RDI_U32 +rdi_size_from_basic_type_kind(RDI_TypeKind kind) +{ +RDI_U32 result = 0; +switch(kind) +{ +default:{}break; +case RDI_TypeKind_Handle:{result = 0xFFFFFFFF;}break; +case RDI_TypeKind_Char8:{result = 1;}break; +case RDI_TypeKind_Char16:{result = 2;}break; +case RDI_TypeKind_Char32:{result = 4;}break; +case RDI_TypeKind_UChar8:{result = 1;}break; +case RDI_TypeKind_UChar16:{result = 2;}break; +case RDI_TypeKind_UChar32:{result = 4;}break; +case RDI_TypeKind_U8:{result = 1;}break; +case RDI_TypeKind_U16:{result = 2;}break; +case RDI_TypeKind_U32:{result = 4;}break; +case RDI_TypeKind_U64:{result = 8;}break; +case RDI_TypeKind_U128:{result = 16;}break; +case RDI_TypeKind_U256:{result = 32;}break; +case RDI_TypeKind_U512:{result = 64;}break; +case RDI_TypeKind_S8:{result = 1;}break; +case RDI_TypeKind_S16:{result = 2;}break; +case RDI_TypeKind_S32:{result = 4;}break; +case RDI_TypeKind_S64:{result = 8;}break; +case RDI_TypeKind_S128:{result = 16;}break; +case RDI_TypeKind_S256:{result = 32;}break; +case RDI_TypeKind_S512:{result = 64;}break; +case RDI_TypeKind_Bool:{result = 1;}break; +case RDI_TypeKind_F16:{result = 2;}break; +case RDI_TypeKind_F32:{result = 4;}break; +case RDI_TypeKind_F32PP:{result = 4;}break; +case RDI_TypeKind_F48:{result = 6;}break; +case RDI_TypeKind_F64:{result = 8;}break; +case RDI_TypeKind_F80:{result = 10;}break; +case RDI_TypeKind_F128:{result = 16;}break; +case RDI_TypeKind_ComplexF32:{result = 8;}break; +case RDI_TypeKind_ComplexF64:{result = 16;}break; +case RDI_TypeKind_ComplexF80:{result = 20;}break; +case RDI_TypeKind_ComplexF128:{result = 32;}break; +} +return result; +} + +RDI_PROC RDI_U32 +rdi_addr_size_from_arch(RDI_Arch arch) +{ +RDI_U32 result = 0; +switch(arch) +{ +default:{}break; +case RDI_Arch_X86:{result = 4;}break; +case RDI_Arch_X64:{result = 8;}break; +} +return result; +} + +RDI_PROC RDI_EvalConversionKind +rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out) +{ + RDI_EvalConversionKind k = rdi_eval_typegroup_conversion_kind_matrix[in].dst_typegroups[out]; + return k; +} + +RDI_PROC RDI_U8 * +rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out) +{ + *size_out = rdi_eval_conversion_kind_message_string_table[kind].size; + return rdi_eval_conversion_kind_message_string_table[kind].str; +} + +RDI_PROC RDI_S32 +rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group) +{ + RDI_S32 result = 0; + switch(op) + { + case RDI_EvalOp_Neg: case RDI_EvalOp_Add: case RDI_EvalOp_Sub: + case RDI_EvalOp_Mul: case RDI_EvalOp_Div: + case RDI_EvalOp_EqEq:case RDI_EvalOp_NtEq: + case RDI_EvalOp_LsEq:case RDI_EvalOp_GrEq: + case RDI_EvalOp_Less:case RDI_EvalOp_Grtr: + { + if(group != RDI_EvalTypeGroup_Other) + { + result = 1; + } + }break; + case RDI_EvalOp_Mod:case RDI_EvalOp_LShift:case RDI_EvalOp_RShift: + case RDI_EvalOp_BitNot:case RDI_EvalOp_BitAnd:case RDI_EvalOp_BitXor: + case RDI_EvalOp_BitOr:case RDI_EvalOp_LogNot:case RDI_EvalOp_LogAnd: + case RDI_EvalOp_LogOr: + { + if(group == RDI_EvalTypeGroup_S || group == RDI_EvalTypeGroup_U) + { + result = 1; + } + }break; + } + return result; +} + +#endif // RDI_FORMAT_C diff --git a/src/rdi_format/generated/rdi_format.h b/src/rdi_format/generated/rdi_format.h new file mode 100644 index 00000000..ab14b260 --- /dev/null +++ b/src/rdi_format/generated/rdi_format.h @@ -0,0 +1,787 @@ +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//////////////////////////////////////////////////////////////// +//~ RAD Debug Info, (R)AD(D)BG(I) Format Library +// +// Defines standard RDI debug information format types and +// functions. + +#ifndef RDI_FORMAT_H +#define RDI_FORMAT_H + +//////////////////////////////////////////////////////////////// +//~ Overridable Procedure Decoration + +#if !defined(RDI_PROC) +# define RDI_PROC static +#endif + +//////////////////////////////////////////////////////////////// +//~ Overridable Basic Integer Types + +#if !defined(RDI_U8) +# define RDI_U8 RDI_U8 +# define RDI_U16 RDI_U16 +# define RDI_U32 RDI_U32 +# define RDI_U64 RDI_U64 +# define RDI_S8 RDI_S8 +# define RDI_S16 RDI_S16 +# define RDI_S32 RDI_S32 +# define RDI_S64 RDI_S64 +#include +typedef uint8_t RDI_U8; +typedef uint16_t RDI_U16; +typedef uint32_t RDI_U32; +typedef uint64_t RDI_U64; +typedef int8_t RDI_S8; +typedef int16_t RDI_S16; +typedef int32_t RDI_S32; +typedef int64_t RDI_S64; +#endif + +//////////////////////////////////////////////////////////////// +//~ Format Constants + +// \"raddbg\0\0\" +#define RDI_MAGIC_CONSTANT 0x0000676264646172 +#define RDI_ENCODING_VERSION 1 + +//////////////////////////////////////////////////////////////// +//~ Format Types & Functions + +typedef RDI_U32 RDI_DataSectionTag; +typedef enum RDI_DataSectionTagEnum +{ +RDI_DataSectionTag_NULL = 0x0000, +RDI_DataSectionTag_TopLevelInfo = 0x0001, +RDI_DataSectionTag_StringData = 0x0002, +RDI_DataSectionTag_StringTable = 0x0003, +RDI_DataSectionTag_IndexRuns = 0x0004, +RDI_DataSectionTag_BinarySections = 0x0005, +RDI_DataSectionTag_FilePathNodes = 0x0006, +RDI_DataSectionTag_SourceFiles = 0x0007, +RDI_DataSectionTag_Units = 0x0008, +RDI_DataSectionTag_UnitVmap = 0x0009, +RDI_DataSectionTag_TypeNodes = 0x000A, +RDI_DataSectionTag_UDTs = 0x000B, +RDI_DataSectionTag_Members = 0x000C, +RDI_DataSectionTag_EnumMembers = 0x000D, +RDI_DataSectionTag_GlobalVariables = 0x000E, +RDI_DataSectionTag_GlobalVmap = 0x000F, +RDI_DataSectionTag_ThreadVariables = 0x0010, +RDI_DataSectionTag_Procedures = 0x0011, +RDI_DataSectionTag_Scopes = 0x0012, +RDI_DataSectionTag_ScopeVoffData = 0x0013, +RDI_DataSectionTag_ScopeVmap = 0x0014, +RDI_DataSectionTag_Locals = 0x0015, +RDI_DataSectionTag_LocationBlocks = 0x0016, +RDI_DataSectionTag_LocationData = 0x0017, +RDI_DataSectionTag_NameMaps = 0x0018, +RDI_DataSectionTag_PRIMARY_COUNT = 0x0019, +RDI_DataSectionTag_SECONDARY = 0x80000000, +RDI_DataSectionTag_SKIP = RDI_DataSectionTag_SECONDARY|0x0000, +RDI_DataSectionTag_LineInfoVoffs = RDI_DataSectionTag_SECONDARY|0x0001, +RDI_DataSectionTag_LineInfoData = RDI_DataSectionTag_SECONDARY|0x0002, +RDI_DataSectionTag_LineInfoColumns = RDI_DataSectionTag_SECONDARY|0x0003, +RDI_DataSectionTag_LineMapNumbers = RDI_DataSectionTag_SECONDARY|0x0004, +RDI_DataSectionTag_LineMapRanges = RDI_DataSectionTag_SECONDARY|0x0005, +RDI_DataSectionTag_LineMapVoffs = RDI_DataSectionTag_SECONDARY|0x0006, +RDI_DataSectionTag_NameMapBuckets = RDI_DataSectionTag_SECONDARY|0x0007, +RDI_DataSectionTag_NameMapNodes = RDI_DataSectionTag_SECONDARY|0x0008, +} RDI_DataSectionTagEnum; + +typedef RDI_U32 RDI_DataSectionEncoding; +typedef enum RDI_DataSectionEncodingEnum +{ +RDI_DataSectionEncoding_Unpacked = 0, +RDI_DataSectionEncoding_LZB = 1, +} RDI_DataSectionEncodingEnum; + +typedef RDI_U32 RDI_Arch; +typedef enum RDI_ArchEnum +{ +RDI_Arch_NULL = 0, +RDI_Arch_X86 = 1, +RDI_Arch_X64 = 2, +} RDI_ArchEnum; + +typedef RDI_U8 RDI_RegCode; +typedef enum RDI_RegCodeEnum +{ +RDI_RegCode_nil, +} RDI_RegCodeEnum; + +typedef RDI_U8 RDI_RegCodeX86; +typedef enum RDI_RegCodeX86Enum +{ +RDI_RegCodeX86_nil = 0, +RDI_RegCodeX86_eax = 1, +RDI_RegCodeX86_ecx = 2, +RDI_RegCodeX86_edx = 3, +RDI_RegCodeX86_ebx = 4, +RDI_RegCodeX86_esp = 5, +RDI_RegCodeX86_ebp = 6, +RDI_RegCodeX86_esi = 7, +RDI_RegCodeX86_edi = 8, +RDI_RegCodeX86_fsbase = 9, +RDI_RegCodeX86_gsbase = 10, +RDI_RegCodeX86_eflags = 11, +RDI_RegCodeX86_eip = 12, +RDI_RegCodeX86_dr0 = 13, +RDI_RegCodeX86_dr1 = 14, +RDI_RegCodeX86_dr2 = 15, +RDI_RegCodeX86_dr3 = 16, +RDI_RegCodeX86_dr4 = 17, +RDI_RegCodeX86_dr5 = 18, +RDI_RegCodeX86_dr6 = 19, +RDI_RegCodeX86_dr7 = 20, +RDI_RegCodeX86_fpr0 = 21, +RDI_RegCodeX86_fpr1 = 22, +RDI_RegCodeX86_fpr2 = 23, +RDI_RegCodeX86_fpr3 = 24, +RDI_RegCodeX86_fpr4 = 25, +RDI_RegCodeX86_fpr5 = 26, +RDI_RegCodeX86_fpr6 = 27, +RDI_RegCodeX86_fpr7 = 28, +RDI_RegCodeX86_st0 = 29, +RDI_RegCodeX86_st1 = 30, +RDI_RegCodeX86_st2 = 31, +RDI_RegCodeX86_st3 = 32, +RDI_RegCodeX86_st4 = 33, +RDI_RegCodeX86_st5 = 34, +RDI_RegCodeX86_st6 = 35, +RDI_RegCodeX86_st7 = 36, +RDI_RegCodeX86_fcw = 37, +RDI_RegCodeX86_fsw = 38, +RDI_RegCodeX86_ftw = 39, +RDI_RegCodeX86_fop = 40, +RDI_RegCodeX86_fcs = 41, +RDI_RegCodeX86_fds = 42, +RDI_RegCodeX86_fip = 43, +RDI_RegCodeX86_fdp = 44, +RDI_RegCodeX86_mxcsr = 45, +RDI_RegCodeX86_mxcsr_mask = 46, +RDI_RegCodeX86_ss = 47, +RDI_RegCodeX86_cs = 48, +RDI_RegCodeX86_ds = 49, +RDI_RegCodeX86_es = 50, +RDI_RegCodeX86_fs = 51, +RDI_RegCodeX86_gs = 52, +RDI_RegCodeX86_ymm0 = 53, +RDI_RegCodeX86_ymm1 = 54, +RDI_RegCodeX86_ymm2 = 55, +RDI_RegCodeX86_ymm3 = 56, +RDI_RegCodeX86_ymm4 = 57, +RDI_RegCodeX86_ymm5 = 58, +RDI_RegCodeX86_ymm6 = 59, +RDI_RegCodeX86_ymm7 = 60, +} RDI_RegCodeX86Enum; + +typedef RDI_U8 RDI_RegCodeX64; +typedef enum RDI_RegCodeX64Enum +{ +RDI_RegCodeX64_nil = 0, +RDI_RegCodeX64_rax = 1, +RDI_RegCodeX64_rcx = 2, +RDI_RegCodeX64_rdx = 3, +RDI_RegCodeX64_rbx = 4, +RDI_RegCodeX64_rsp = 5, +RDI_RegCodeX64_rbp = 6, +RDI_RegCodeX64_rsi = 7, +RDI_RegCodeX64_rdi = 8, +RDI_RegCodeX64_r8 = 9, +RDI_RegCodeX64_r9 = 10, +RDI_RegCodeX64_r10 = 11, +RDI_RegCodeX64_r11 = 12, +RDI_RegCodeX64_r12 = 13, +RDI_RegCodeX64_r13 = 14, +RDI_RegCodeX64_r14 = 15, +RDI_RegCodeX64_r15 = 16, +RDI_RegCodeX64_es = 17, +RDI_RegCodeX64_cs = 18, +RDI_RegCodeX64_ss = 19, +RDI_RegCodeX64_ds = 20, +RDI_RegCodeX64_fs = 21, +RDI_RegCodeX64_gs = 22, +RDI_RegCodeX64_rip = 23, +RDI_RegCodeX64_rflags = 24, +RDI_RegCodeX64_dr0 = 25, +RDI_RegCodeX64_dr1 = 26, +RDI_RegCodeX64_dr2 = 27, +RDI_RegCodeX64_dr3 = 28, +RDI_RegCodeX64_dr4 = 29, +RDI_RegCodeX64_dr5 = 30, +RDI_RegCodeX64_dr6 = 31, +RDI_RegCodeX64_dr7 = 32, +RDI_RegCodeX64_st0 = 33, +RDI_RegCodeX64_st1 = 34, +RDI_RegCodeX64_st2 = 35, +RDI_RegCodeX64_st3 = 36, +RDI_RegCodeX64_st4 = 37, +RDI_RegCodeX64_st5 = 38, +RDI_RegCodeX64_st6 = 39, +RDI_RegCodeX64_st7 = 40, +RDI_RegCodeX64_fpr0 = 41, +RDI_RegCodeX64_fpr1 = 42, +RDI_RegCodeX64_fpr2 = 43, +RDI_RegCodeX64_fpr3 = 44, +RDI_RegCodeX64_fpr4 = 45, +RDI_RegCodeX64_fpr5 = 46, +RDI_RegCodeX64_fpr6 = 47, +RDI_RegCodeX64_fpr7 = 48, +RDI_RegCodeX64_ymm0 = 49, +RDI_RegCodeX64_ymm1 = 50, +RDI_RegCodeX64_ymm2 = 51, +RDI_RegCodeX64_ymm3 = 52, +RDI_RegCodeX64_ymm4 = 53, +RDI_RegCodeX64_ymm5 = 54, +RDI_RegCodeX64_ymm6 = 55, +RDI_RegCodeX64_ymm7 = 56, +RDI_RegCodeX64_ymm8 = 57, +RDI_RegCodeX64_ymm9 = 58, +RDI_RegCodeX64_ymm10 = 59, +RDI_RegCodeX64_ymm11 = 60, +RDI_RegCodeX64_ymm12 = 61, +RDI_RegCodeX64_ymm13 = 62, +RDI_RegCodeX64_ymm14 = 63, +RDI_RegCodeX64_ymm15 = 64, +RDI_RegCodeX64_mxcsr = 65, +RDI_RegCodeX64_fsbase = 66, +RDI_RegCodeX64_gsbase = 67, +RDI_RegCodeX64_fcw = 68, +RDI_RegCodeX64_fsw = 69, +RDI_RegCodeX64_ftw = 70, +RDI_RegCodeX64_fop = 71, +RDI_RegCodeX64_fcs = 72, +RDI_RegCodeX64_fds = 73, +RDI_RegCodeX64_fip = 74, +RDI_RegCodeX64_fdp = 75, +RDI_RegCodeX64_mxcsr_mask = 76, +} RDI_RegCodeX64Enum; + +typedef RDI_U32 RDI_BinarySectionFlags; +typedef enum RDI_BinarySectionFlagsEnum +{ +RDI_BinarySectionFlag_Read = 1<<0, +RDI_BinarySectionFlag_Write = 1<<1, +RDI_BinarySectionFlag_Execute = 1<<2, +} RDI_BinarySectionFlagsEnum; + +typedef RDI_U32 RDI_Language; +typedef enum RDI_LanguageEnum +{ +RDI_Language_NULL = 0, +RDI_Language_C = 1, +RDI_Language_CPlusPlus = 2, +RDI_Language_COUNT = 3, +} RDI_LanguageEnum; + +typedef RDI_U16 RDI_TypeKind; +typedef enum RDI_TypeKindEnum +{ +RDI_TypeKind_NULL = 0x0000, +RDI_TypeKind_Void = 0x0001, +RDI_TypeKind_Handle = 0x0002, +RDI_TypeKind_Char8 = 0x0003, +RDI_TypeKind_Char16 = 0x0004, +RDI_TypeKind_Char32 = 0x0005, +RDI_TypeKind_UChar8 = 0x0006, +RDI_TypeKind_UChar16 = 0x0007, +RDI_TypeKind_UChar32 = 0x0008, +RDI_TypeKind_U8 = 0x0009, +RDI_TypeKind_U16 = 0x000A, +RDI_TypeKind_U32 = 0x000B, +RDI_TypeKind_U64 = 0x000C, +RDI_TypeKind_U128 = 0x000D, +RDI_TypeKind_U256 = 0x000E, +RDI_TypeKind_U512 = 0x000F, +RDI_TypeKind_S8 = 0x0010, +RDI_TypeKind_S16 = 0x0011, +RDI_TypeKind_S32 = 0x0012, +RDI_TypeKind_S64 = 0x0013, +RDI_TypeKind_S128 = 0x0014, +RDI_TypeKind_S256 = 0x0015, +RDI_TypeKind_S512 = 0x0016, +RDI_TypeKind_Bool = 0x0017, +RDI_TypeKind_F16 = 0x0018, +RDI_TypeKind_F32 = 0x0019, +RDI_TypeKind_F32PP = 0x001A, +RDI_TypeKind_F48 = 0x001B, +RDI_TypeKind_F64 = 0x001C, +RDI_TypeKind_F80 = 0x001D, +RDI_TypeKind_F128 = 0x001E, +RDI_TypeKind_ComplexF32 = 0x001F, +RDI_TypeKind_ComplexF64 = 0x0020, +RDI_TypeKind_ComplexF80 = 0x0021, +RDI_TypeKind_ComplexF128 = 0x0022, +RDI_TypeKind_Modifier = 0x1000, +RDI_TypeKind_Ptr = 0x1001, +RDI_TypeKind_LRef = 0x1002, +RDI_TypeKind_RRef = 0x1003, +RDI_TypeKind_Array = 0x1004, +RDI_TypeKind_Function = 0x1005, +RDI_TypeKind_Method = 0x1006, +RDI_TypeKind_MemberPtr = 0x1007, +RDI_TypeKind_Struct = 0x2000, +RDI_TypeKind_Class = 0x2001, +RDI_TypeKind_Union = 0x2002, +RDI_TypeKind_Enum = 0x2003, +RDI_TypeKind_Alias = 0x2004, +RDI_TypeKind_IncompleteStruct = 0x2005, +RDI_TypeKind_IncompleteUnion = 0x2006, +RDI_TypeKind_IncompleteClass = 0x2007, +RDI_TypeKind_IncompleteEnum = 0x2008, +RDI_TypeKind_Bitfield = 0xF000, +RDI_TypeKind_Variadic = 0xF001, +RDI_TypeKind_FirstBuiltIn = RDI_TypeKind_Void, +RDI_TypeKind_LastBuiltIn = RDI_TypeKind_ComplexF128, +RDI_TypeKind_FirstConstructed = RDI_TypeKind_Modifier, +RDI_TypeKind_LastConstructed = RDI_TypeKind_MemberPtr, +RDI_TypeKind_FirstUserDefined = RDI_TypeKind_Struct, +RDI_TypeKind_LastRecord = RDI_TypeKind_Union, +RDI_TypeKind_FirstIncomplete = RDI_TypeKind_IncompleteStruct, +RDI_TypeKind_LastIncomplete = RDI_TypeKind_IncompleteEnum, +RDI_TypeKind_FirstRecord = RDI_TypeKind_Struct, +RDI_TypeKind_LastUserDefined = RDI_TypeKind_IncompleteEnum, +} RDI_TypeKindEnum; + +typedef RDI_U16 RDI_TypeModifierFlags; +typedef enum RDI_TypeModifierFlagsEnum +{ +RDI_TypeModifierFlag_Const = 1<<0, +RDI_TypeModifierFlag_Volatile = 1<<1, +} RDI_TypeModifierFlagsEnum; + +typedef RDI_U32 RDI_UDTFlags; +typedef enum RDI_UDTFlagsEnum +{ +RDI_UDTFlag_EnumMembers = 1<<0, +} RDI_UDTFlagsEnum; + +typedef RDI_U16 RDI_MemberKind; +typedef enum RDI_MemberKindEnum +{ +RDI_MemberKind_NULL = 0x0000, +RDI_MemberKind_DataField = 0x0001, +RDI_MemberKind_StaticData = 0x0002, +RDI_MemberKind_Method = 0x0100, +RDI_MemberKind_StaticMethod = 0x0101, +RDI_MemberKind_VirtualMethod = 0x0102, +RDI_MemberKind_VTablePtr = 0x0200, +RDI_MemberKind_Base = 0x0201, +RDI_MemberKind_VirtualBase = 0x0202, +RDI_MemberKind_NestedType = 0x0300, +} RDI_MemberKindEnum; + +typedef RDI_U32 RDI_LinkFlags; +typedef enum RDI_LinkFlagsEnum +{ +RDI_LinkFlag_External = 1<<0, +RDI_LinkFlag_TypeScoped = 1<<1, +RDI_LinkFlag_ProcScoped = 1<<2, +} RDI_LinkFlagsEnum; + +typedef RDI_U32 RDI_LocalKind; +typedef enum RDI_LocalKindEnum +{ +RDI_LocalKind_NULL = 0x0, +RDI_LocalKind_Parameter = 0x1, +RDI_LocalKind_Variable = 0x2, +} RDI_LocalKindEnum; + +typedef RDI_U8 RDI_LocationKind; +typedef enum RDI_LocationKindEnum +{ +RDI_LocationKind_NULL = 0x0, +RDI_LocationKind_AddrBytecodeStream = 0x1, +RDI_LocationKind_ValBytecodeStream = 0x2, +RDI_LocationKind_AddrRegPlusU16 = 0x3, +RDI_LocationKind_AddrAddrRegPlusU16 = 0x4, +RDI_LocationKind_ValReg = 0x5, +} RDI_LocationKindEnum; + +typedef RDI_U8 RDI_EvalOp; +typedef enum RDI_EvalOpEnum +{ +RDI_EvalOp_Stop = 0, +RDI_EvalOp_Noop = 1, +RDI_EvalOp_Cond = 2, +RDI_EvalOp_Skip = 3, +RDI_EvalOp_MemRead = 4, +RDI_EvalOp_RegRead = 5, +RDI_EvalOp_RegReadDyn = 6, +RDI_EvalOp_FrameOff = 7, +RDI_EvalOp_ModuleOff = 8, +RDI_EvalOp_TLSOff = 9, +RDI_EvalOp_ObjectOff = 10, +RDI_EvalOp_CFA = 11, +RDI_EvalOp_ConstU8 = 12, +RDI_EvalOp_ConstU16 = 13, +RDI_EvalOp_ConstU32 = 14, +RDI_EvalOp_ConstU64 = 15, +RDI_EvalOp_Abs = 16, +RDI_EvalOp_Neg = 17, +RDI_EvalOp_Add = 18, +RDI_EvalOp_Sub = 19, +RDI_EvalOp_Mul = 20, +RDI_EvalOp_Div = 21, +RDI_EvalOp_Mod = 22, +RDI_EvalOp_LShift = 23, +RDI_EvalOp_RShift = 24, +RDI_EvalOp_BitAnd = 25, +RDI_EvalOp_BitOr = 26, +RDI_EvalOp_BitXor = 27, +RDI_EvalOp_BitNot = 28, +RDI_EvalOp_LogAnd = 29, +RDI_EvalOp_LogOr = 30, +RDI_EvalOp_LogNot = 31, +RDI_EvalOp_EqEq = 32, +RDI_EvalOp_NtEq = 33, +RDI_EvalOp_LsEq = 34, +RDI_EvalOp_GrEq = 35, +RDI_EvalOp_Less = 36, +RDI_EvalOp_Grtr = 37, +RDI_EvalOp_Trunc = 38, +RDI_EvalOp_TruncSigned = 39, +RDI_EvalOp_Convert = 40, +RDI_EvalOp_Pick = 41, +RDI_EvalOp_Pop = 42, +RDI_EvalOp_Insert = 43, +RDI_EvalOp_COUNT = 44, +} RDI_EvalOpEnum; + +typedef RDI_U8 RDI_EvalTypeGroup; +typedef enum RDI_EvalTypeGroupEnum +{ +RDI_EvalTypeGroup_Other = 0, +RDI_EvalTypeGroup_U = 1, +RDI_EvalTypeGroup_S = 2, +RDI_EvalTypeGroup_F32 = 3, +RDI_EvalTypeGroup_F64 = 4, +RDI_EvalTypeGroup_COUNT = 5, +} RDI_EvalTypeGroupEnum; + +typedef RDI_U8 RDI_EvalConversionKind; +typedef enum RDI_EvalConversionKindEnum +{ +RDI_EvalConversionKind_Noop = 0, +RDI_EvalConversionKind_Legal = 1, +RDI_EvalConversionKind_OtherToOther = 2, +RDI_EvalConversionKind_ToOther = 3, +RDI_EvalConversionKind_FromOther = 4, +RDI_EvalConversionKind_COUNT = 5, +} RDI_EvalConversionKindEnum; + +typedef RDI_U32 RDI_NameMapKind; +typedef enum RDI_NameMapKindEnum +{ +RDI_NameMapKind_NULL = 0, +RDI_NameMapKind_GlobalVariables = 1, +RDI_NameMapKind_ThreadVariables = 2, +RDI_NameMapKind_Procedures = 3, +RDI_NameMapKind_Types = 4, +RDI_NameMapKind_LinkNameProcedures = 5, +RDI_NameMapKind_NormalSourcePaths = 6, +RDI_NameMapKind_COUNT = 7, +} RDI_NameMapKindEnum; + +#define RDI_EVAL_CTRLBITS(decodeN,popN,pushN) ((decodeN) | ((popN) << 4) | ((pushN) << 6)) +#define RDI_DECODEN_FROM_CTRLBITS(ctrlbits) ((ctrlbits) & 0xf) +#define RDI_POPN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 4) & 0x3) +#define RDI_PUSHN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 6) & 0x3) +#define RDI_EncodeRegReadParam(reg,bytesize,bytepos) ((reg)|((bytesize)<<8)|((bytepos)<<16)) + +typedef struct RDI_Header RDI_Header; +struct RDI_Header +{ +RDI_U64 magic; +RDI_U32 encoding_version; +RDI_U32 data_section_off; +RDI_U32 data_section_count; +}; + +typedef struct RDI_DataSection RDI_DataSection; +struct RDI_DataSection +{ +RDI_DataSectionTag tag; +RDI_DataSectionEncoding encoding; +RDI_U64 off; +RDI_U64 encoded_size; +RDI_U64 unpacked_size; +}; + +typedef struct RDI_VMapEntry RDI_VMapEntry; +struct RDI_VMapEntry +{ +RDI_U64 voff; +RDI_U64 idx; +}; + +typedef struct RDI_TopLevelInfo RDI_TopLevelInfo; +struct RDI_TopLevelInfo +{ +RDI_Arch arch; +RDI_U32 exe_name_string_idx; +RDI_U64 exe_hash; +RDI_U64 voff_max; +}; + +typedef struct RDI_BinarySection RDI_BinarySection; +struct RDI_BinarySection +{ +RDI_U32 name_string_idx; +RDI_BinarySectionFlags flags; +RDI_U64 voff_first; +RDI_U64 voff_opl; +RDI_U64 foff_first; +RDI_U64 foff_opl; +}; + +typedef struct RDI_FilePathNode RDI_FilePathNode; +struct RDI_FilePathNode +{ +RDI_U32 name_string_idx; +RDI_U32 parent_path_node; +RDI_U32 first_child; +RDI_U32 next_sibling; +RDI_U32 source_file_idx; +}; + +typedef struct RDI_SourceFile RDI_SourceFile; +struct RDI_SourceFile +{ +RDI_U32 file_path_node_idx; +RDI_U32 normal_full_path_string_idx; +RDI_U32 line_map_count; +RDI_U32 line_map_nums_data_idx; +RDI_U32 line_map_range_data_idx; +RDI_U32 line_map_voff_data_idx; +}; + +typedef struct RDI_Unit RDI_Unit; +struct RDI_Unit +{ +RDI_U32 unit_name_string_idx; +RDI_U32 compiler_name_string_idx; +RDI_U32 source_file_path_node; +RDI_U32 object_file_path_node; +RDI_U32 archive_file_path_node; +RDI_U32 build_path_node; +RDI_Language language; +RDI_U32 line_info_voffs_data_idx; +RDI_U32 line_info_data_idx; +RDI_U32 line_info_col_data_idx; +RDI_U32 line_info_count; +}; + +typedef struct RDI_Line RDI_Line; +struct RDI_Line +{ +RDI_U32 file_idx; +RDI_U32 line_num; +}; + +typedef struct RDI_Column RDI_Column; +struct RDI_Column +{ +RDI_U16 col_first; +RDI_U16 col_opl; +}; + +typedef struct RDI_TypeNode RDI_TypeNode; +struct RDI_TypeNode +{ +RDI_TypeKind kind; +RDI_U16 flags; +RDI_U32 byte_size; + + union + { + // kind is 'built-in' + struct + { + RDI_U32 name_string_idx; + } built_in; + + // kind is 'constructed' + struct + { + RDI_U32 direct_type_idx; + RDI_U32 count; + union{ + // when kind is 'Function' or 'Method' + RDI_U32 param_idx_run_first; + // when kind is 'MemberPtr' + RDI_U32 owner_type_idx; + }; + } constructed; + + // kind is 'user defined' + struct + { + RDI_U32 name_string_idx; + RDI_U32 direct_type_idx; + RDI_U32 udt_idx; + } user_defined; + + // (kind = Bitfield) + struct + { + RDI_U32 direct_type_idx; + RDI_U32 off; + RDI_U32 size; + } bitfield; + } + ; +}; + +typedef struct RDI_UDT RDI_UDT; +struct RDI_UDT +{ +RDI_U32 self_type_idx; +RDI_UDTFlags flags; +RDI_U32 member_first; +RDI_U32 member_count; +RDI_U32 file_idx; +RDI_U32 line; +RDI_U32 col; +}; + +typedef struct RDI_Member RDI_Member; +struct RDI_Member +{ +RDI_MemberKind kind; +RDI_U16 pad; +RDI_U32 name_string_idx; +RDI_U32 type_idx; +RDI_U32 off; +}; + +typedef struct RDI_EnumMember RDI_EnumMember; +struct RDI_EnumMember +{ +RDI_U32 name_string_idx; +RDI_U32 pad; +RDI_U64 val; +}; + +typedef struct RDI_GlobalVariable RDI_GlobalVariable; +struct RDI_GlobalVariable +{ +RDI_U32 name_string_idx; +RDI_LinkFlags link_flags; +RDI_U64 voff; +RDI_U32 type_idx; +RDI_U32 container_idx; +}; + +typedef struct RDI_ThreadVariable RDI_ThreadVariable; +struct RDI_ThreadVariable +{ +RDI_U32 name_string_idx; +RDI_LinkFlags link_flags; +RDI_U32 tls_off; +RDI_U32 type_idx; +RDI_U32 container_idx; +}; + +typedef struct RDI_Procedure RDI_Procedure; +struct RDI_Procedure +{ +RDI_U32 name_string_idx; +RDI_U32 link_name_string_idx; +RDI_LinkFlags link_flags; +RDI_U32 type_idx; +RDI_U32 root_scope_idx; +RDI_U32 container_idx; +}; + +typedef struct RDI_Scope RDI_Scope; +struct RDI_Scope +{ +RDI_U32 proc_idx; +RDI_U32 parent_scope_idx; +RDI_U32 first_child_scope_idx; +RDI_U32 next_sibling_scope_idx; +RDI_U32 voff_range_first; +RDI_U32 voff_range_opl; +RDI_U32 local_first; +RDI_U32 local_count; +RDI_U32 static_local_idx_run_first; +RDI_U32 static_local_count; +}; + +typedef struct RDI_Local RDI_Local; +struct RDI_Local +{ +RDI_LocalKind kind; +RDI_U32 name_string_idx; +RDI_U32 type_idx; +RDI_U32 pad; +RDI_U32 location_first; +RDI_U32 location_opl; +}; + +typedef struct RDI_LocationBlock RDI_LocationBlock; +struct RDI_LocationBlock +{ +RDI_U32 scope_off_first; +RDI_U32 scope_off_opl; +RDI_U32 location_data_off; +}; + +typedef struct RDI_LocationBytecodeStream RDI_LocationBytecodeStream; +struct RDI_LocationBytecodeStream +{ +RDI_LocationKind kind; +}; + +typedef struct RDI_LocationRegPlusU16 RDI_LocationRegPlusU16; +struct RDI_LocationRegPlusU16 +{ +RDI_LocationKind kind; +RDI_RegCode reg_code; +RDI_U16 offset; +}; + +typedef struct RDI_LocationReg RDI_LocationReg; +struct RDI_LocationReg +{ +RDI_LocationKind kind; +RDI_RegCode reg_code; +}; + +typedef struct RDI_NameMap RDI_NameMap; +struct RDI_NameMap +{ +RDI_NameMapKind kind; +RDI_U32 bucket_data_idx; +RDI_U32 node_data_idx; +}; + +typedef struct RDI_NameMapBucket RDI_NameMapBucket; +struct RDI_NameMapBucket +{ +RDI_U32 first_node; +RDI_U32 node_count; +}; + +typedef struct RDI_NameMapNode RDI_NameMapNode; +struct RDI_NameMapNode +{ +RDI_U32 string_idx; +RDI_U32 match_count; +RDI_U32 match_idx_or_idx_run_first; +}; + +RDI_PROC RDI_U64 rdi_hash(RDI_U8 *ptr, RDI_U64 size); +RDI_PROC RDI_U32 rdi_size_from_basic_type_kind(RDI_TypeKind kind); +RDI_PROC RDI_U32 rdi_addr_size_from_arch(RDI_Arch arch); +RDI_PROC RDI_EvalConversionKind rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out); +RDI_PROC RDI_U8 *rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out); +RDI_PROC RDI_S32 rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group); + +extern RDI_U8 rdi_eval_op_ctrlbits_table[45]; + +#endif // RDI_FORMAT_H diff --git a/src/rdi_format/generated/rdi_format.meta.c b/src/rdi_format/generated/rdi_format.meta.c deleted file mode 100644 index 32e20884..00000000 --- a/src/rdi_format/generated/rdi_format.meta.c +++ /dev/null @@ -1,8 +0,0 @@ -// Copyright (c) 2024 Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//- GENERATED CODE - -C_LINKAGE_BEGIN -C_LINKAGE_END - diff --git a/src/rdi_format/generated/rdi_format.meta.h b/src/rdi_format/generated/rdi_format.meta.h deleted file mode 100644 index e7871be1..00000000 --- a/src/rdi_format/generated/rdi_format.meta.h +++ /dev/null @@ -1,253 +0,0 @@ -// Copyright (c) 2024 Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//- GENERATED CODE - -#ifndef RDI_FORMAT_META_H -#define RDI_FORMAT_META_H - -typedef RDI_U32 RDI_DataSectionTag; -typedef enum RDI_DataSectionTagEnum -{ -RDI_DataSectionTag_NULL = 0x0000, -RDI_DataSectionTag_TopLevelInfo = 0x0001, -RDI_DataSectionTag_StringData = 0x0002, -RDI_DataSectionTag_StringTable = 0x0003, -RDI_DataSectionTag_IndexRuns = 0x0004, -RDI_DataSectionTag_BinarySections = 0x0005, -RDI_DataSectionTag_FilePathNodes = 0x0006, -RDI_DataSectionTag_SourceFiles = 0x0007, -RDI_DataSectionTag_Units = 0x0008, -RDI_DataSectionTag_UnitVmap = 0x0009, -RDI_DataSectionTag_TypeNodes = 0x000A, -RDI_DataSectionTag_UDTs = 0x000B, -RDI_DataSectionTag_Members = 0x000C, -RDI_DataSectionTag_EnumMembers = 0x000D, -RDI_DataSectionTag_GlobalVariables = 0x000E, -RDI_DataSectionTag_GlobalVmap = 0x000F, -RDI_DataSectionTag_ThreadVariables = 0x0010, -RDI_DataSectionTag_Procedures = 0x0011, -RDI_DataSectionTag_Scopes = 0x0012, -RDI_DataSectionTag_ScopeVoffData = 0x0013, -RDI_DataSectionTag_ScopeVmap = 0x0014, -RDI_DataSectionTag_Locals = 0x0015, -RDI_DataSectionTag_LocationBlocks = 0x0016, -RDI_DataSectionTag_LocationData = 0x0017, -RDI_DataSectionTag_NameMaps = 0x0018, -RDI_DataSectionTag_PRIMARY_COUNT = 0x0019, -RDI_DataSectionTag_SKIP = RDI_DataSectionTag_SECONDARY|0x0000, -RDI_DataSectionTag_LineInfoVoffs = RDI_DataSectionTag_SECONDARY|0x0001, -RDI_DataSectionTag_LineInfoData = RDI_DataSectionTag_SECONDARY|0x0002, -RDI_DataSectionTag_LineInfoColumns = RDI_DataSectionTag_SECONDARY|0x0003, -RDI_DataSectionTag_LineMapNumbers = RDI_DataSectionTag_SECONDARY|0x0004, -RDI_DataSectionTag_LineMapRanges = RDI_DataSectionTag_SECONDARY|0x0005, -RDI_DataSectionTag_LineMapVoffs = RDI_DataSectionTag_SECONDARY|0x0006, -RDI_DataSectionTag_NameMapBuckets = RDI_DataSectionTag_SECONDARY|0x0007, -RDI_DataSectionTag_NameMapNodes = RDI_DataSectionTag_SECONDARY|0x0008, -} RDI_DataSectionTagEnum; - -typedef RDI_U32 RDI_DataSectionEncoding; -typedef enum RDI_DataSectionEncodingEnum -{ -RDI_DataSectionEncoding_Unpacked = 0, -RDI_DataSectionEncoding_LZB = 1, -} RDI_DataSectionEncodingEnum; - -typedef RDI_U32 RDI_Arch; -typedef enum RDI_ArchEnum -{ -RDI_Arch_NULL = 0, -RDI_Arch_X86 = 1, -RDI_Arch_X64 = 2, -} RDI_ArchEnum; - -typedef enum RDI_RegCodeX86 -{ -RDI_RegCodeX86_nil = 0, -RDI_RegCodeX86_eax = 1, -RDI_RegCodeX86_ecx = 2, -RDI_RegCodeX86_edx = 3, -RDI_RegCodeX86_ebx = 4, -RDI_RegCodeX86_esp = 5, -RDI_RegCodeX86_ebp = 6, -RDI_RegCodeX86_esi = 7, -RDI_RegCodeX86_edi = 8, -RDI_RegCodeX86_fsbase = 9, -RDI_RegCodeX86_gsbase = 10, -RDI_RegCodeX86_eflags = 11, -RDI_RegCodeX86_eip = 12, -RDI_RegCodeX86_dr0 = 13, -RDI_RegCodeX86_dr1 = 14, -RDI_RegCodeX86_dr2 = 15, -RDI_RegCodeX86_dr3 = 16, -RDI_RegCodeX86_dr4 = 17, -RDI_RegCodeX86_dr5 = 18, -RDI_RegCodeX86_dr6 = 19, -RDI_RegCodeX86_dr7 = 20, -RDI_RegCodeX86_fpr0 = 21, -RDI_RegCodeX86_fpr1 = 22, -RDI_RegCodeX86_fpr2 = 23, -RDI_RegCodeX86_fpr3 = 24, -RDI_RegCodeX86_fpr4 = 25, -RDI_RegCodeX86_fpr5 = 26, -RDI_RegCodeX86_fpr6 = 27, -RDI_RegCodeX86_fpr7 = 28, -RDI_RegCodeX86_st0 = 29, -RDI_RegCodeX86_st1 = 30, -RDI_RegCodeX86_st2 = 31, -RDI_RegCodeX86_st3 = 32, -RDI_RegCodeX86_st4 = 33, -RDI_RegCodeX86_st5 = 34, -RDI_RegCodeX86_st6 = 35, -RDI_RegCodeX86_st7 = 36, -RDI_RegCodeX86_fcw = 37, -RDI_RegCodeX86_fsw = 38, -RDI_RegCodeX86_ftw = 39, -RDI_RegCodeX86_fop = 40, -RDI_RegCodeX86_fcs = 41, -RDI_RegCodeX86_fds = 42, -RDI_RegCodeX86_fip = 43, -RDI_RegCodeX86_fdp = 44, -RDI_RegCodeX86_mxcsr = 45, -RDI_RegCodeX86_mxcsr_mask = 46, -RDI_RegCodeX86_ss = 47, -RDI_RegCodeX86_cs = 48, -RDI_RegCodeX86_ds = 49, -RDI_RegCodeX86_es = 50, -RDI_RegCodeX86_fs = 51, -RDI_RegCodeX86_gs = 52, -RDI_RegCodeX86_ymm0 = 53, -RDI_RegCodeX86_ymm1 = 54, -RDI_RegCodeX86_ymm2 = 55, -RDI_RegCodeX86_ymm3 = 56, -RDI_RegCodeX86_ymm4 = 57, -RDI_RegCodeX86_ymm5 = 58, -RDI_RegCodeX86_ymm6 = 59, -RDI_RegCodeX86_ymm7 = 60, -} RDI_RegCodeX86; - -typedef enum RDI_RegCodeX64 -{ -RDI_RegCodeX64_nil = 0, -RDI_RegCodeX64_rax = 1, -RDI_RegCodeX64_rcx = 2, -RDI_RegCodeX64_rdx = 3, -RDI_RegCodeX64_rbx = 4, -RDI_RegCodeX64_rsp = 5, -RDI_RegCodeX64_rbp = 6, -RDI_RegCodeX64_rsi = 7, -RDI_RegCodeX64_rdi = 8, -RDI_RegCodeX64_r8 = 9, -RDI_RegCodeX64_r9 = 10, -RDI_RegCodeX64_r10 = 11, -RDI_RegCodeX64_r11 = 12, -RDI_RegCodeX64_r12 = 13, -RDI_RegCodeX64_r13 = 14, -RDI_RegCodeX64_r14 = 15, -RDI_RegCodeX64_r15 = 16, -RDI_RegCodeX64_es = 17, -RDI_RegCodeX64_cs = 18, -RDI_RegCodeX64_ss = 19, -RDI_RegCodeX64_ds = 20, -RDI_RegCodeX64_fs = 21, -RDI_RegCodeX64_gs = 22, -RDI_RegCodeX64_rip = 23, -RDI_RegCodeX64_rflags = 24, -RDI_RegCodeX64_dr0 = 25, -RDI_RegCodeX64_dr1 = 26, -RDI_RegCodeX64_dr2 = 27, -RDI_RegCodeX64_dr3 = 28, -RDI_RegCodeX64_dr4 = 29, -RDI_RegCodeX64_dr5 = 30, -RDI_RegCodeX64_dr6 = 31, -RDI_RegCodeX64_dr7 = 32, -RDI_RegCodeX64_st0 = 33, -RDI_RegCodeX64_st1 = 34, -RDI_RegCodeX64_st2 = 35, -RDI_RegCodeX64_st3 = 36, -RDI_RegCodeX64_st4 = 37, -RDI_RegCodeX64_st5 = 38, -RDI_RegCodeX64_st6 = 39, -RDI_RegCodeX64_st7 = 40, -RDI_RegCodeX64_fpr0 = 41, -RDI_RegCodeX64_fpr1 = 42, -RDI_RegCodeX64_fpr2 = 43, -RDI_RegCodeX64_fpr3 = 44, -RDI_RegCodeX64_fpr4 = 45, -RDI_RegCodeX64_fpr5 = 46, -RDI_RegCodeX64_fpr6 = 47, -RDI_RegCodeX64_fpr7 = 48, -RDI_RegCodeX64_ymm0 = 49, -RDI_RegCodeX64_ymm1 = 50, -RDI_RegCodeX64_ymm2 = 51, -RDI_RegCodeX64_ymm3 = 52, -RDI_RegCodeX64_ymm4 = 53, -RDI_RegCodeX64_ymm5 = 54, -RDI_RegCodeX64_ymm6 = 55, -RDI_RegCodeX64_ymm7 = 56, -RDI_RegCodeX64_ymm8 = 57, -RDI_RegCodeX64_ymm9 = 58, -RDI_RegCodeX64_ymm10 = 59, -RDI_RegCodeX64_ymm11 = 60, -RDI_RegCodeX64_ymm12 = 61, -RDI_RegCodeX64_ymm13 = 62, -RDI_RegCodeX64_ymm14 = 63, -RDI_RegCodeX64_ymm15 = 64, -RDI_RegCodeX64_mxcsr = 65, -RDI_RegCodeX64_fsbase = 66, -RDI_RegCodeX64_gsbase = 67, -RDI_RegCodeX64_fcw = 68, -RDI_RegCodeX64_fsw = 69, -RDI_RegCodeX64_ftw = 70, -RDI_RegCodeX64_fop = 71, -RDI_RegCodeX64_fcs = 72, -RDI_RegCodeX64_fds = 73, -RDI_RegCodeX64_fip = 74, -RDI_RegCodeX64_fdp = 75, -RDI_RegCodeX64_mxcsr_mask = 76, -} RDI_RegCodeX64; - -typedef RDI_U32 RDI_BinarySectionFlags; -typedef enum RDI_BinarySectionFlagsEnum -{ -RDI_BinarySectionFlags_Read = 1<<0, -RDI_BinarySectionFlags_Write = 1<<1, -RDI_BinarySectionFlags_Execute = 1<<2, -} RDI_BinarySectionFlagsEnum; - -typedef struct RDI_Header RDI_Header; -struct RDI_Header -{ -RDI_U64 magic; -RDI_U32 encoding_version; -RDI_U32 data_section_off; -RDI_U32 data_section_count; -}; - -typedef struct RDI_DataSection RDI_DataSection; -struct RDI_DataSection -{ -RDI_DataSectionTag tag; -RDI_DataSectionEncoding encoding; -}; - -typedef struct RDI_VMapEntry RDI_VMapEntry; -struct RDI_VMapEntry -{ -RDI_U64 voff; -RDI_U64 idx; -}; - -typedef struct RDI_TopLevelInfo RDI_TopLevelInfo; -struct RDI_TopLevelInfo -{ -RDI_Arch arch; -RDI_U32 exe_name_string_idx; -RDI_U64 exe_hash; -RDI_U64 voff_max; -}; - -C_LINKAGE_BEGIN -C_LINKAGE_END - -#endif // RDI_FORMAT_META_H diff --git a/src/rdi_format/rdi_format.mdesk b/src/rdi_format/rdi_format.mdesk index ce881b2b..ddc1332b 100644 --- a/src/rdi_format/rdi_format.mdesk +++ b/src/rdi_format/rdi_format.mdesk @@ -1,6 +1,90 @@ // Copyright (c) 2024 Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) +//////////////////////////////// +//~ rjf: Generated File Format + +@option library + +@h_name "rdi_format.h" +@c_name "rdi_format.c" + +@h_header +{ + "////////////////////////////////////////////////////////////////"; + "//~ RAD Debug Info, (R)AD(D)BG(I) Format Library"; + "//"; + "// Defines standard RDI debug information format types and"; + "// functions."; + ""; + "#ifndef RDI_FORMAT_H"; + "#define RDI_FORMAT_H"; + ""; + "////////////////////////////////////////////////////////////////"; + "//~ Overridable Procedure Decoration"; + ""; + "#if !defined(RDI_PROC)"; + "# define RDI_PROC static"; + "#endif"; + ""; + "////////////////////////////////////////////////////////////////"; + "//~ Overridable Basic Integer Types"; + ""; + "#if !defined(RDI_U8)"; + "# define RDI_U8 RDI_U8"; + "# define RDI_U16 RDI_U16"; + "# define RDI_U32 RDI_U32"; + "# define RDI_U64 RDI_U64"; + "# define RDI_S8 RDI_S8"; + "# define RDI_S16 RDI_S16"; + "# define RDI_S32 RDI_S32"; + "# define RDI_S64 RDI_S64"; + "#include "; + "typedef uint8_t RDI_U8;"; + "typedef uint16_t RDI_U16;"; + "typedef uint32_t RDI_U32;"; + "typedef uint64_t RDI_U64;"; + "typedef int8_t RDI_S8;"; + "typedef int16_t RDI_S16;"; + "typedef int32_t RDI_S32;"; + "typedef int64_t RDI_S64;"; + "#endif"; + ""; + "////////////////////////////////////////////////////////////////"; + "//~ Format Constants"; + ""; + "// \"raddbg\0\0\""; + "#define RDI_MAGIC_CONSTANT 0x0000676264646172"; + "#define RDI_ENCODING_VERSION 1"; + ""; + "////////////////////////////////////////////////////////////////"; + "//~ Format Types & Functions"; + ""; +} + +@h_footer +{ + "#endif // RDI_FORMAT_H"; +} + +@c_header +{ + "////////////////////////////////////////////////////////////////"; + "//~ RAD Debug Info, (R)AD(D)BG(I) Format Library"; + "//"; + "// Defines standard RDI debug information format types and"; + "// functions."; + ""; + "#ifndef RDI_FORMAT_C"; + "#define RDI_FORMAT_C"; + ""; +} + +@c_footer +{ + "#endif // RDI_FORMAT_C"; +} + //////////////////////////////// //~ rjf: Format Header Tables @@ -52,6 +136,7 @@ RDI_DataSectionTable: {LocationData 0x0017 ""} {NameMaps 0x0018 ""} {PRIMARY_COUNT 0x0019 ""} + {SECONDARY 0x80000000 ""} {SKIP `RDI_DataSectionTag_SECONDARY|0x0000` ""} {LineInfoVoffs `RDI_DataSectionTag_SECONDARY|0x0001` ""} {LineInfoData `RDI_DataSectionTag_SECONDARY|0x0002` ""} @@ -73,8 +158,11 @@ RDI_DataSectionEncodingTable: @table(name type desc) RDI_DataSectionMemberTable: { - {tag RDI_DataSectionTag ""} - {encoding RDI_DataSectionEncoding ""} + {tag RDI_DataSectionTag ""} + {encoding RDI_DataSectionEncoding ""} + {off RDI_U64 ""} + {encoded_size RDI_U64 ""} + {unpacked_size RDI_U64 ""} } @enum(RDI_U32) RDI_DataSectionTag: @@ -271,12 +359,14 @@ RDI_RegCodeX64Table: @expand(RDI_ArchTable a) `$(a.name .. =>10) = $(a.value)` } -@enum RDI_RegCodeX86: +@enum(RDI_U8) RDI_RegCode: {nil} + +@enum(RDI_U8) RDI_RegCodeX86: { @expand(RDI_RegCodeX86Table a) `$(a.name .. =>10) = $(a.value)` } -@enum RDI_RegCodeX64: +@enum(RDI_U8) RDI_RegCodeX64: { @expand(RDI_RegCodeX64Table a) `$(a.name .. =>10) = $(a.value)` } @@ -325,6 +415,11 @@ RDI_BinarySectionMemberTable: @expand(RDI_BinarySectionFlagTable a) `$(a.name .. =>10) = $(a.value)`; } +@struct RDI_BinarySection: +{ + @expand(RDI_BinarySectionMemberTable a) `$(a.type) $(a.name)` +} + //////////////////////////////// //~ rjf: File Path Tree Info Type Tables @@ -353,6 +448,16 @@ RDI_SourceFileMemberTable: {line_map_voff_data_idx RDI_U32 ""} // U64[...] (idx by line_map_range_data) } +@struct RDI_FilePathNode: +{ + @expand(RDI_FilePathNodeMemberTable a) `$(a.type) $(a.name)` +} + +@struct RDI_SourceFile: +{ + @expand(RDI_SourceFileMemberTable a) `$(a.type) $(a.name)` +} + //////////////////////////////// //~ rjf: Unit Info Type Tables @@ -375,6 +480,11 @@ RDI_UnitMemberTable: {line_info_count RDI_U32 ""} } +@struct RDI_Unit: +{ + @expand(RDI_UnitMemberTable a) `$(a.type) $(a.name)` +} + //////////////////////////////// //~ rjf: Line Info Type Tables @@ -392,6 +502,16 @@ RDI_ColumnMemberTable: {col_opl RDI_U16 ""} } +@struct RDI_Line: +{ + @expand(RDI_LineMemberTable a) `$(a.type) $(a.name)` +} + +@struct RDI_Column: +{ + @expand(RDI_ColumnMemberTable a) `$(a.type) $(a.name)` +} + //////////////////////////////// //~ rjf: Language Info Tables @@ -401,6 +521,12 @@ RDI_LanguageTable: {NULL 0} {C 1} {CPlusPlus 2} + {COUNT 3} +} + +@enum(RDI_U32) RDI_Language: +{ + @expand(RDI_LanguageTable a) `$(a.name .. =>10) = $(a.value)` } //////////////////////////////// @@ -469,22 +595,22 @@ RDI_TypeKindTable: {Variadic 0xF001 0 } } -@table(name val) +@table(name value) RDI_TypeModifierFlagTable: { {Const `1<<0`} {Volatile `1<<1`} } -@table(name type desc) +@table(name type_lhs type_rhs desc) RDI_TypeNodeMemberTable: { - {kind RDI_TypeKind ""} - {byte_size RDI_U32 ""} - {kind_info `RDI_U32[3]` ""} + {kind RDI_TypeKind `` ""} + {flags RDI_U16 `` ""} + {byte_size RDI_U32 `` ""} } -@table(name val) +@table(name value) RDI_UDTFlagTable: { {EnumMembers `1<<0`} @@ -502,7 +628,7 @@ RDI_UDTMemberTable: {col RDI_U32 ""} } -@table(name val) +@table(name value) RDI_MemberKindTable: { {NULL 0x0000} @@ -535,10 +661,91 @@ RDI_EnumMemberTable: {val RDI_U64 ""} } +@enum(RDI_U16) RDI_TypeKind: +{ + @expand(RDI_TypeKindTable a) `$(a.name .. =>20) = $(a.value)`; + @expand(RDI_TypeKindTable a) `$(a.bookend1 != "" -> a.bookend1 .. =>20 .. " = RDI_TypeKind_" .. a.name)`; + @expand(RDI_TypeKindTable a) `$(a.bookend2 != "" -> a.bookend2 .. =>20 .. " = RDI_TypeKind_" .. a.name)`; +} + +@enum(RDI_U16) RDI_TypeModifierFlags: +{ + @expand(RDI_TypeModifierFlagTable a) `$(a.name .. =>20) = $(a.value)`, +} + +@struct RDI_TypeNode: +{ + @expand(RDI_TypeNodeMemberTable a) `$(a.type_lhs) $(a.name)$(a.type_rhs)` + ``` + union + { + // kind is 'built-in' + struct + { + RDI_U32 name_string_idx; + } built_in; + + // kind is 'constructed' + struct + { + RDI_U32 direct_type_idx; + RDI_U32 count; + union{ + // when kind is 'Function' or 'Method' + RDI_U32 param_idx_run_first; + // when kind is 'MemberPtr' + RDI_U32 owner_type_idx; + }; + } constructed; + + // kind is 'user defined' + struct + { + RDI_U32 name_string_idx; + RDI_U32 direct_type_idx; + RDI_U32 udt_idx; + } user_defined; + + // (kind = Bitfield) + struct + { + RDI_U32 direct_type_idx; + RDI_U32 off; + RDI_U32 size; + } bitfield; + } + ``` +} + +@enum(RDI_U32) RDI_UDTFlags: +{ + @expand(RDI_UDTFlagTable a) `$(a.name .. =>20) = $(a.value)` +} + +@struct RDI_UDT: +{ + @expand(RDI_UDTMemberTable a) `$(a.type) $(a.name)` +} + +@enum(RDI_U16) RDI_MemberKind: +{ + @expand(RDI_MemberKindTable a) `$(a.name .. =>25) = $(a.value)` +} + +@struct RDI_Member: +{ + @expand(RDI_MemberMemberTable a) `$(a.type) $(a.name)` +} + +@struct RDI_EnumMember: +{ + @expand(RDI_EnumMemberTable a) `$(a.type) $(a.name)` +} + //////////////////////////////// //~ rjf: Symbol Info Tables -@table(name val) +@table(name value) RDI_LinkFlagTable: { {External `1<<0`} @@ -546,7 +753,7 @@ RDI_LinkFlagTable: {ProcScoped `1<<2`} } -@table(name val) +@table(name value) RDI_LocalKindTable: { {NULL 0x0} @@ -554,15 +761,15 @@ RDI_LocalKindTable: {Variable 0x2} } -@table(name val) +@table(name value) RDI_LocationKindTable: { {NULL 0x0} {AddrBytecodeStream 0x1} {ValBytecodeStream 0x2} - {AddrRegisterPlusU16 0x3} - {AddrAddrRegisterPlusU16 0x4} - {ValRegister 0x5} + {AddrRegPlusU16 0x3} + {AddrAddrRegPlusU16 0x4} + {ValReg 0x5} } @table(name type desc) @@ -638,83 +845,147 @@ RDI_LocationBytecodeStreamMemberTable: } @table(name type desc) -RDI_LocationRegisterPlusU16MemberTable: +RDI_LocationRegPlusU16MemberTable: { {kind RDI_LocationKind } - {register_code RDI_RegisterCode } + {reg_code RDI_RegCode } {offset RDI_U16 } } @table(name type desc) -RDI_LocationRegister: +RDI_LocationRegMemberTable: { {kind RDI_LocationKind } - {register_code RDI_RegisterCode } + {reg_code RDI_RegCode } +} + +@enum(RDI_U32) RDI_LinkFlags: +{ + @expand(RDI_LinkFlagTable a) `$(a.name .. =>20) = $(a.value)` +} + +@enum(RDI_U32) RDI_LocalKind: +{ + @expand(RDI_LocalKindTable a) `$(a.name .. =>20) = $(a.value)` +} + +@enum(RDI_U8) RDI_LocationKind: +{ + @expand(RDI_LocationKindTable a) `$(a.name .. =>20) = $(a.value)` +} + +@struct RDI_GlobalVariable: +{ + @expand(RDI_GlobalVariableMemberTable a) `$(a.type) $(a.name)` +} + +@struct RDI_ThreadVariable: +{ + @expand(RDI_ThreadVariableMemberTable a) `$(a.type) $(a.name)` +} + +@struct RDI_Procedure: +{ + @expand(RDI_ProcedureMemberTable a) `$(a.type) $(a.name)` +} + +@struct RDI_Scope: +{ + @expand(RDI_ScopeMemberTable a) `$(a.type) $(a.name)` +} + +@struct RDI_Local: +{ + @expand(RDI_LocalMemberTable a) `$(a.type) $(a.name)` +} + +@struct RDI_LocationBlock: +{ + @expand(RDI_LocationBlockMemberTable a) `$(a.type) $(a.name)` +} + +@struct RDI_LocationBytecodeStream: +{ + @expand(RDI_LocationBytecodeStreamMemberTable a) `$(a.type) $(a.name)` +} + +@struct RDI_LocationRegPlusU16: +{ + @expand(RDI_LocationRegPlusU16MemberTable a) `$(a.type) $(a.name)` +} + +@struct RDI_LocationReg: +{ + @expand(RDI_LocationRegMemberTable a) `$(a.type) $(a.name)` } //////////////////////////////// //~ rjf: Evaluation Bytecode Tables -@table(name num_decodes num_pops num_pushes) +@table(name value num_decodes num_pops num_pushes) RDI_EvalOpTable: { - {Stop 0 0 0} - {Noop 0 0 0} - {Cond 1 1 0} - {Skip 1 0 0} - {MemRead 1 1 1} - {RegRead 4 0 1} - {RegReadDyn 0 1 1} - {FrameOff 1 0 1} - {ModuleOff 4 0 1} - {TLSOff 4 0 1} - {ObjectOff 0 0 0} - {CFA 0 0 0} - {ConstU8 1 0 1} - {ConstU16 2 0 1} - {ConstU32 4 0 1} - {ConstU64 8 0 1} - {Abs 1 1 1} - {Neg 1 1 1} - {Add 1 2 1} - {Sub 1 2 1} - {Mul 1 2 1} - {Div 1 2 1} - {Mod 1 2 1} - {LShift 1 2 1} - {RShift 1 2 1} - {BitAnd 1 2 1} - {BitOr 1 2 1} - {BitXor 1 2 1} - {BitNot 1 1 1} - {LogAnd 1 2 1} - {LogOr 1 2 1} - {LogNot 1 1 1} - {EqEq 1 2 1} - {NtEq 1 2 1} - {LsEq 1 2 1} - {GrEq 1 2 1} - {Less 1 2 1} - {Grtr 1 2 1} - {Trunc 1 1 1} - {TruncSigned 1 1 1} - {Convert 2 1 1} - {Pick 1 0 1} - {Pop 0 1 0} - {Insert 1 0 0} + {Stop 0 0 0 0} + {Noop 1 0 0 0} + {Cond 2 1 1 0} + {Skip 3 1 0 0} + {MemRead 4 1 1 1} + {RegRead 5 4 0 1} + {RegReadDyn 6 0 1 1} + {FrameOff 7 1 0 1} + {ModuleOff 8 4 0 1} + {TLSOff 9 4 0 1} + {ObjectOff 10 0 0 0} + {CFA 11 0 0 0} + {ConstU8 12 1 0 1} + {ConstU16 13 2 0 1} + {ConstU32 14 4 0 1} + {ConstU64 15 8 0 1} + {Abs 16 1 1 1} + {Neg 17 1 1 1} + {Add 18 1 2 1} + {Sub 19 1 2 1} + {Mul 20 1 2 1} + {Div 21 1 2 1} + {Mod 22 1 2 1} + {LShift 23 1 2 1} + {RShift 24 1 2 1} + {BitAnd 25 1 2 1} + {BitOr 26 1 2 1} + {BitXor 27 1 2 1} + {BitNot 28 1 1 1} + {LogAnd 29 1 2 1} + {LogOr 30 1 2 1} + {LogNot 31 1 1 1} + {EqEq 32 1 2 1} + {NtEq 33 1 2 1} + {LsEq 34 1 2 1} + {GrEq 35 1 2 1} + {Less 36 1 2 1} + {Grtr 37 1 2 1} + {Trunc 38 1 1 1} + {TruncSigned 39 1 1 1} + {Convert 40 2 1 1} + {Pick 41 1 0 1} + {Pop 42 0 1 0} + {Insert 43 1 0 0} + {COUNT 44 0 0 0} } -@table(name val) +// NOTE(rjf): "ck" -> "conversion kind, when converted to type group", used in square matrix form +// e.g. x:0, y:0 means other -> other, x:3, y:1 means uint -> f32, etc. +@table(name value ck0 ck1 ck2 ck3 ck4) RDI_EvalTypeGroupTable: { - {Other 0} - {U 1} - {S 2} - {F32 3} - {F64 4} + {Other 0 OtherToOther FromOther FromOther FromOther FromOther } + {U 1 ToOther Noop Noop Legal Legal } + {S 2 ToOther Noop Noop Legal Legal } + {F32 3 ToOther Legal Legal Noop Legal } + {F64 4 ToOther Legal Legal Legal Noop } + {COUNT 5 Noop Noop Noop Noop Noop } } -@table(name val error_string) +@table(name value error_string) RDI_EvalConversionKindTable: { {Noop 0 "" } @@ -722,12 +993,54 @@ RDI_EvalConversionKindTable: {OtherToOther 2 "Cannot convert between these types."} {ToOther 3 "Cannot convert to this type." } {FromOther 4 "Cannot convert this type." } + {COUNT 5 "" } +} + +@enum(RDI_U8) RDI_EvalOp: +{ + @expand(RDI_EvalOpTable a) `$(a.name .. =>20) = $(a.value)` +} + +@enum(RDI_U8) RDI_EvalTypeGroup: +{ + @expand(RDI_EvalTypeGroupTable a) `$(a.name .. =>20) = $(a.value)` +} + +@enum(RDI_U8) RDI_EvalConversionKind: +{ + @expand(RDI_EvalConversionKindTable a) `$(a.name .. =>20) = $(a.value)` +} + +@gen(enums) +``` +#define RDI_EVAL_CTRLBITS(decodeN,popN,pushN) ((decodeN) | ((popN) << 4) | ((pushN) << 6)) +#define RDI_DECODEN_FROM_CTRLBITS(ctrlbits) ((ctrlbits) & 0xf) +#define RDI_POPN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 4) & 0x3) +#define RDI_PUSHN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 6) & 0x3) +#define RDI_EncodeRegReadParam(reg,bytesize,bytepos) ((reg)|((bytesize)<<8)|((bytepos)<<16)) +``` + +@data(RDI_U8) rdi_eval_op_ctrlbits_table: +{ + @expand(RDI_EvalOpTable a) `RDI_EVAL_CTRLBITS($(a.num_decodes), $(a.num_pops), $(a.num_pushes))`; +} + +@data(`struct {RDI_EvalConversionKind dst_typegroups[RDI_EvalTypeGroup_COUNT];}`) @c_file +rdi_eval_typegroup_conversion_kind_matrix: +{ + @expand(RDI_EvalTypeGroupTable a) `{{RDI_EvalConversionKind_$(a.ck0), RDI_EvalConversionKind_$(a.ck1), RDI_EvalConversionKind_$(a.ck2), RDI_EvalConversionKind_$(a.ck3), RDI_EvalConversionKind_$(a.ck4)}}` +} + +@data(`struct {RDI_U8 *str; RDI_U64 size;}`) @c_file +rdi_eval_conversion_kind_message_string_table: +{ + @expand(RDI_EvalTypeGroupTable a) `{(RDI_U8 *)"$(a.error_string)", sizeof("$(a.error_string)")}` } //////////////////////////////// //~ rjf: Name Map Tables -@table(name val) +@table(name value) RDI_NameMapKindTable: { {NULL 0} @@ -737,6 +1050,7 @@ RDI_NameMapKindTable: {Types 4} {LinkNameProcedures 5} {NormalSourcePaths 6} + {COUNT 7} } @table(name type desc) @@ -764,3 +1078,136 @@ RDI_NameMapNodeMemberTable: {match_idx_or_idx_run_first RDI_U32 ""} } +@enum(RDI_U32) RDI_NameMapKind: +{ + @expand(RDI_NameMapKindTable a) `$(a.name .. =>20) = $(a.value)` +} + +@struct RDI_NameMap: +{ + @expand(RDI_NameMapMemberTable a) `$(a.type) $(a.val)` +} + +@struct RDI_NameMapBucket: +{ + @expand(RDI_NameMapBucketMemberTable a) `$(a.type) $(a.val)` +} + +@struct RDI_NameMapNode: +{ + @expand(RDI_NameMapNodeMemberTable a) `$(a.type) $(a.val)` +} + +//////////////////////////////// +//~ rjf: Functions + +@gen(functions) +``` +RDI_PROC RDI_U64 rdi_hash(RDI_U8 *ptr, RDI_U64 size); +RDI_PROC RDI_U32 rdi_size_from_basic_type_kind(RDI_TypeKind kind); +RDI_PROC RDI_U32 rdi_addr_size_from_arch(RDI_Arch arch); +RDI_PROC RDI_EvalConversionKind rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out); +RDI_PROC RDI_U8 *rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out); +RDI_PROC RDI_S32 rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group); +``` + +@gen(functions) @c_file +``` +RDI_PROC RDI_U64 +rdi_hash(RDI_U8 *ptr, RDI_U64 size) +{ + RDI_U64 result = 5381; + RDI_U8 *opl = ptr + size; + for(;ptr < opl; ptr += 1) + { + result = ((result << 5) + result) + *ptr; + } + return result; +} +``` + +@gen(functions) @c_file +{ + `RDI_PROC RDI_U32`; + `rdi_size_from_basic_type_kind(RDI_TypeKind kind)`; + `{`; + `RDI_U32 result = 0;`; + `switch(kind)`; + `{`; + `default:{}break;`; + @expand(RDI_TypeKindTable a) `$(a.size != 0 -> " case RDI_TypeKind_" .. a.name .. ":{result = " .. a.size .. ";}break;")`, + `}`; + `return result;`; + `}`; + ``; +} + +@gen(functions) @c_file +{ + `RDI_PROC RDI_U32`; + `rdi_addr_size_from_arch(RDI_Arch arch)`; + `{`; + `RDI_U32 result = 0;`; + `switch(arch)`; + `{`; + `default:{}break;`; + @expand(RDI_ArchTable a) `$(a.addr_size != 0 -> " case RDI_Arch_" .. a.name .. ":{result = " .. a.addr_size .. ";}break;")`; + `}`; + `return result;`; + `}`; + ``; +} + +@gen(functions) @c_file +``` +RDI_PROC RDI_EvalConversionKind +rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out) +{ + RDI_EvalConversionKind k = rdi_eval_typegroup_conversion_kind_matrix[in].dst_typegroups[out]; + return k; +} +``` + +@gen(functions) @c_file +``` +RDI_PROC RDI_U8 * +rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out) +{ + *size_out = rdi_eval_conversion_kind_message_string_table[kind].size; + return rdi_eval_conversion_kind_message_string_table[kind].str; +} +``` + +@gen(functions) @c_file +``` +RDI_PROC RDI_S32 +rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group) +{ + RDI_S32 result = 0; + switch(op) + { + case RDI_EvalOp_Neg: case RDI_EvalOp_Add: case RDI_EvalOp_Sub: + case RDI_EvalOp_Mul: case RDI_EvalOp_Div: + case RDI_EvalOp_EqEq:case RDI_EvalOp_NtEq: + case RDI_EvalOp_LsEq:case RDI_EvalOp_GrEq: + case RDI_EvalOp_Less:case RDI_EvalOp_Grtr: + { + if(group != RDI_EvalTypeGroup_Other) + { + result = 1; + } + }break; + case RDI_EvalOp_Mod:case RDI_EvalOp_LShift:case RDI_EvalOp_RShift: + case RDI_EvalOp_BitNot:case RDI_EvalOp_BitAnd:case RDI_EvalOp_BitXor: + case RDI_EvalOp_BitOr:case RDI_EvalOp_LogNot:case RDI_EvalOp_LogAnd: + case RDI_EvalOp_LogOr: + { + if(group == RDI_EvalTypeGroup_S || group == RDI_EvalTypeGroup_U) + { + result = 1; + } + }break; + } + return result; +} +``` diff --git a/src/rdi_format_local/rdi_format_local.c b/src/rdi_format_local/rdi_format_local.c index 6fae2eb3..e860c025 100644 --- a/src/rdi_format_local/rdi_format_local.c +++ b/src/rdi_format_local/rdi_format_local.c @@ -1,7 +1,8 @@ // Copyright (c) 2024 Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) -#include "lib_rdi_format/rdi_format.c" +//#include "lib_rdi_format/rdi_format.c" +#include "rdi_format/generated/rdi_format.c" #include "lib_rdi_format/rdi_format_parse.c" internal void diff --git a/src/rdi_format_local/rdi_format_local.h b/src/rdi_format_local/rdi_format_local.h index 48f7eea3..3042e452 100644 --- a/src/rdi_format_local/rdi_format_local.h +++ b/src/rdi_format_local/rdi_format_local.h @@ -4,7 +4,8 @@ #ifndef RDI_FORMAT_LOCAL_H #define RDI_FORMAT_LOCAL_H -#include "lib_rdi_format/rdi_format.h" +//#include "lib_rdi_format/rdi_format.h" +#include "rdi_format/generated/rdi_format.h" #include "lib_rdi_format/rdi_format_parse.h" internal void rdi_decompress_parsed(U8 *decompressed_data, U64 decompressed_size, RDI_Parsed *og_rdi); diff --git a/src/rdi_from_pdb/rdi_from_pdb.c b/src/rdi_from_pdb/rdi_from_pdb.c index 8ea57171..9c5632b4 100644 --- a/src/rdi_from_pdb/rdi_from_pdb.c +++ b/src/rdi_from_pdb/rdi_from_pdb.c @@ -241,17 +241,17 @@ p2r_rdi_arch_from_cv_arch(CV_Arch cv_arch) return(result); } -internal RDI_RegisterCode +internal RDI_RegCode p2r_rdi_reg_code_from_cv_reg_code(RDI_Arch arch, CV_Reg reg_code) { - RDI_RegisterCode result = 0; + RDI_RegCode result = 0; switch(arch) { case RDI_Arch_X86: { switch(reg_code) { -#define X(CVN,C,RDN,BP,BZ) case C: result = RDI_RegisterCode_X86_##RDN; break; +#define X(CVN,C,RDN,BP,BZ) case C: result = RDI_RegCodeX86_##RDN; break; CV_Reg_X86_XList(X) #undef X } @@ -260,7 +260,7 @@ p2r_rdi_reg_code_from_cv_reg_code(RDI_Arch arch, CV_Reg reg_code) { switch(reg_code) { -#define X(CVN,C,RDN,BP,BZ) case C: result = RDI_RegisterCode_X64_##RDN; break; +#define X(CVN,C,RDN,BP,BZ) case C: result = RDI_RegCodeX64_##RDN; break; CV_Reg_X64_XList(X) #undef X } @@ -376,7 +376,7 @@ p2r_rdi_type_kind_from_cv_basic_type(CV_BasicType basic_type) //~ rjf: Location Info Building Helpers internal RDIM_Location * -p2r_location_from_addr_reg_off(Arena *arena, RDI_Arch arch, RDI_RegisterCode reg_code, U32 reg_byte_size, U32 reg_byte_pos, S64 offset, B32 extra_indirection) +p2r_location_from_addr_reg_off(Arena *arena, RDI_Arch arch, RDI_RegCode reg_code, U32 reg_byte_size, U32 reg_byte_pos, S64 offset, B32 extra_indirection) { RDIM_Location *result = 0; if(0 <= offset && offset <= (S64)max_U16) @@ -423,10 +423,10 @@ p2r_cv_encoded_fp_reg_from_frameproc(CV_SymFrameproc *frameproc, B32 param_base) return result; } -internal RDI_RegisterCode +internal RDI_RegCode p2r_reg_code_from_arch_encoded_fp_reg(RDI_Arch arch, CV_EncodedFramePtrReg encoded_reg) { - RDI_RegisterCode result = 0; + RDI_RegCode result = 0; switch(arch) { case RDI_Arch_X86: @@ -440,11 +440,11 @@ p2r_reg_code_from_arch_encoded_fp_reg(RDI_Arch arch, CV_EncodedFramePtrReg encod }break; case CV_EncodedFramePtrReg_FramePtr: { - result = RDI_RegisterCode_X86_ebp; + result = RDI_RegCodeX86_ebp; }break; case CV_EncodedFramePtrReg_BasePtr: { - result = RDI_RegisterCode_X86_ebx; + result = RDI_RegCodeX86_ebx; }break; } }break; @@ -454,15 +454,15 @@ p2r_reg_code_from_arch_encoded_fp_reg(RDI_Arch arch, CV_EncodedFramePtrReg encod { case CV_EncodedFramePtrReg_StackPtr: { - result = RDI_RegisterCode_X64_rsp; + result = RDI_RegCodeX64_rsp; }break; case CV_EncodedFramePtrReg_FramePtr: { - result = RDI_RegisterCode_X64_rbp; + result = RDI_RegCodeX64_rbp; }break; case CV_EncodedFramePtrReg_BasePtr: { - result = RDI_RegisterCode_X64_r13; + result = RDI_RegCodeX64_r13; }break; } }break; @@ -2207,13 +2207,13 @@ internal TS_TASK_FUNCTION_DEF(p2r_symbol_stream_convert_task__entry_point) } // rjf: get raddbg register code - RDI_RegisterCode register_code = p2r_rdi_reg_code_from_cv_reg_code(in->arch, cv_reg); + RDI_RegCode reg_code = p2r_rdi_reg_code_from_cv_reg_code(in->arch, cv_reg); // TODO(rjf): real byte_size & byte_pos from cv_reg goes here U32 byte_size = 8; U32 byte_pos = 0; // rjf: set location case - RDIM_Location *loc = p2r_location_from_addr_reg_off(arena, in->arch, register_code, byte_size, byte_pos, (S64)(S32)var_off, extra_indirection_to_value); + RDIM_Location *loc = p2r_location_from_addr_reg_off(arena, in->arch, reg_code, byte_size, byte_pos, (S64)(S32)var_off, extra_indirection_to_value); RDIM_Rng1U64 voff_range = {0, max_U64}; rdim_location_set_push_case(arena, &sym_scopes, &local->locset, voff_range, loc); } @@ -2327,10 +2327,10 @@ internal TS_TASK_FUNCTION_DEF(p2r_symbol_stream_convert_task__entry_point) COFF_SectionHeader *range_section = (0 < range->sec && range->sec <= in->coff_sections->count) ? &in->coff_sections->sections[range->sec-1] : 0; CV_LvarAddrGap *gaps = (CV_LvarAddrGap*)(defrange_register+1); U64 gap_count = ((U8*)sym_data_opl - (U8*)gaps) / sizeof(*gaps); - RDI_RegisterCode register_code = p2r_rdi_reg_code_from_cv_reg_code(in->arch, cv_reg); + RDI_RegCode reg_code = p2r_rdi_reg_code_from_cv_reg_code(in->arch, cv_reg); // rjf: build location - RDIM_Location *location = rdim_push_location_val_reg(arena, register_code); + RDIM_Location *location = rdim_push_location_val_reg(arena, reg_code); // rjf: emit locations over ranges p2r_location_over_lvar_addr_range(arena, &sym_scopes, defrange_target, location, range, range_section, gaps, gap_count); @@ -2369,7 +2369,7 @@ internal TS_TASK_FUNCTION_DEF(p2r_symbol_stream_convert_task__entry_point) // rjf: select frame pointer register CV_EncodedFramePtrReg encoded_fp_reg = p2r_cv_encoded_fp_reg_from_frameproc(frameproc, defrange_target_is_param); - RDI_RegisterCode fp_register_code = p2r_reg_code_from_arch_encoded_fp_reg(in->arch, encoded_fp_reg); + RDI_RegCode fp_register_code = p2r_reg_code_from_arch_encoded_fp_reg(in->arch, encoded_fp_reg); // rjf: build location B32 extra_indirection = 0; @@ -2399,7 +2399,7 @@ internal TS_TASK_FUNCTION_DEF(p2r_symbol_stream_convert_task__entry_point) COFF_SectionHeader *range_section = (0 < range->sec && range->sec <= in->coff_sections->count) ? &in->coff_sections->sections[range->sec-1] : 0; CV_LvarAddrGap *gaps = (CV_LvarAddrGap*)(defrange_subfield_register + 1); U64 gap_count = ((U8*)sym_data_opl - (U8*)gaps) / sizeof(*gaps); - RDI_RegisterCode register_code = p2r_rdi_reg_code_from_cv_reg_code(in->arch, cv_reg); + RDI_RegCode reg_code = p2r_rdi_reg_code_from_cv_reg_code(in->arch, cv_reg); // rjf: skip "subfield" location info - currently not supported if(defrange_subfield_register->field_offset != 0) @@ -2408,7 +2408,7 @@ internal TS_TASK_FUNCTION_DEF(p2r_symbol_stream_convert_task__entry_point) } // rjf: build location - RDIM_Location *location = rdim_push_location_val_reg(arena, register_code); + RDIM_Location *location = rdim_push_location_val_reg(arena, reg_code); // rjf: emit locations over ranges p2r_location_over_lvar_addr_range(arena, &sym_scopes, defrange_target, location, range, range_section, gaps, gap_count); @@ -2441,7 +2441,7 @@ internal TS_TASK_FUNCTION_DEF(p2r_symbol_stream_convert_task__entry_point) // rjf: unpack sym CV_SymDefrangeFramepointerRelFullScope *defrange_fprel_full_scope = (CV_SymDefrangeFramepointerRelFullScope*)sym_header_struct_base; CV_EncodedFramePtrReg encoded_fp_reg = p2r_cv_encoded_fp_reg_from_frameproc(frameproc, defrange_target_is_param); - RDI_RegisterCode fp_register_code = p2r_reg_code_from_arch_encoded_fp_reg(in->arch, encoded_fp_reg); + RDI_RegCode fp_register_code = p2r_reg_code_from_arch_encoded_fp_reg(in->arch, encoded_fp_reg); // rjf: build location B32 extra_indirection = 0; @@ -2468,7 +2468,7 @@ internal TS_TASK_FUNCTION_DEF(p2r_symbol_stream_convert_task__entry_point) // rjf: unpack sym CV_SymDefrangeRegisterRel *defrange_register_rel = (CV_SymDefrangeRegisterRel*)sym_header_struct_base; CV_Reg cv_reg = defrange_register_rel->reg; - RDI_RegisterCode register_code = p2r_rdi_reg_code_from_cv_reg_code(in->arch, cv_reg); + RDI_RegCode reg_code = p2r_rdi_reg_code_from_cv_reg_code(in->arch, cv_reg); CV_LvarAddrRange *range = &defrange_register_rel->range; COFF_SectionHeader *range_section = (0 < range->sec && range->sec <= in->coff_sections->count) ? &in->coff_sections->sections[range->sec-1] : 0; CV_LvarAddrGap *gaps = (CV_LvarAddrGap*)(defrange_register_rel + 1); @@ -2480,7 +2480,7 @@ internal TS_TASK_FUNCTION_DEF(p2r_symbol_stream_convert_task__entry_point) U32 byte_pos = 0; B32 extra_indirection_to_value = 0; S64 var_off = defrange_register_rel->reg_off; - RDIM_Location *location = p2r_location_from_addr_reg_off(arena, in->arch, register_code, byte_size, byte_pos, var_off, extra_indirection_to_value); + RDIM_Location *location = p2r_location_from_addr_reg_off(arena, in->arch, reg_code, byte_size, byte_pos, var_off, extra_indirection_to_value); // rjf: emit locations over ranges p2r_location_over_lvar_addr_range(arena, &sym_scopes, defrange_target, location, range, range_section, gaps, gap_count); diff --git a/src/rdi_from_pdb/rdi_from_pdb.h b/src/rdi_from_pdb/rdi_from_pdb.h index 088d4521..27b9ff39 100644 --- a/src/rdi_from_pdb/rdi_from_pdb.h +++ b/src/rdi_from_pdb/rdi_from_pdb.h @@ -522,16 +522,16 @@ internal RDI_BinarySectionFlags p2r_rdi_binary_section_flags_from_coff_section_f //~ rjf: CodeView => RDI Canonical Conversions internal RDI_Arch p2r_rdi_arch_from_cv_arch(CV_Arch arch); -internal RDI_RegisterCode p2r_rdi_reg_code_from_cv_reg_code(RDI_Arch arch, CV_Reg reg_code); +internal RDI_RegCode p2r_rdi_reg_code_from_cv_reg_code(RDI_Arch arch, CV_Reg reg_code); internal RDI_Language p2r_rdi_language_from_cv_language(CV_Language language); internal RDI_TypeKind p2r_rdi_type_kind_from_cv_basic_type(CV_BasicType basic_type); //////////////////////////////// //~ rjf: Location Info Building Helpers -internal RDIM_Location *p2r_location_from_addr_reg_off(Arena *arena, RDI_Arch arch, RDI_RegisterCode reg_code, U32 reg_byte_size, U32 reg_byte_pos, S64 offset, B32 extra_indirection); +internal RDIM_Location *p2r_location_from_addr_reg_off(Arena *arena, RDI_Arch arch, RDI_RegCode reg_code, U32 reg_byte_size, U32 reg_byte_pos, S64 offset, B32 extra_indirection); internal CV_EncodedFramePtrReg p2r_cv_encoded_fp_reg_from_frameproc(CV_SymFrameproc *frameproc, B32 param_base); -internal RDI_RegisterCode p2r_reg_code_from_arch_encoded_fp_reg(RDI_Arch arch, CV_EncodedFramePtrReg encoded_reg); +internal RDI_RegCode p2r_reg_code_from_arch_encoded_fp_reg(RDI_Arch arch, CV_EncodedFramePtrReg encoded_reg); internal void p2r_location_over_lvar_addr_range(Arena *arena, RDIM_ScopeChunkList *scopes, RDIM_LocationSet *locset, RDIM_Location *location, CV_LvarAddrRange *range, COFF_SectionHeader *section, CV_LvarAddrGap *gaps, U64 gap_count); //////////////////////////////// diff --git a/src/regs/generated/regs.meta.h b/src/regs/generated/regs.meta.h index 88eb256a..234efdf1 100644 --- a/src/regs/generated/regs.meta.h +++ b/src/regs/generated/regs.meta.h @@ -439,6 +439,7 @@ extern String8 regs_g_reg_code_x86_string_table[61]; extern String8 regs_g_alias_code_x86_string_table[36]; extern REGS_Rng regs_g_reg_code_x86_rng_table[61]; extern REGS_Slice regs_g_alias_code_x86_slice_table[36]; + C_LINKAGE_END #endif // REGS_META_H diff --git a/src/regs/rdi/generated/regs_rdi.meta.c b/src/regs/rdi/generated/regs_rdi.meta.c index 763da2aa..dac55385 100644 --- a/src/regs/rdi/generated/regs_rdi.meta.c +++ b/src/regs/rdi/generated/regs_rdi.meta.c @@ -3,9 +3,9 @@ //- GENERATED CODE -internal RDI_RegisterCode regs_rdi_code_from_arch_reg_code(Architecture arch, REGS_RegCode code) +internal RDI_RegCode regs_rdi_code_from_arch_reg_code(Architecture arch, REGS_RegCode code) { -RDI_RegisterCode result = 0; +RDI_RegCode result = 0; switch(arch) { default:{}break; @@ -14,82 +14,82 @@ case Architecture_x64: switch(code) { default:{}break; -case REGS_RegCodeX64_rax:{result = RDI_RegisterCode_X64_rax;}break; -case REGS_RegCodeX64_rcx:{result = RDI_RegisterCode_X64_rcx;}break; -case REGS_RegCodeX64_rdx:{result = RDI_RegisterCode_X64_rdx;}break; -case REGS_RegCodeX64_rbx:{result = RDI_RegisterCode_X64_rbx;}break; -case REGS_RegCodeX64_rsp:{result = RDI_RegisterCode_X64_rsp;}break; -case REGS_RegCodeX64_rbp:{result = RDI_RegisterCode_X64_rbp;}break; -case REGS_RegCodeX64_rsi:{result = RDI_RegisterCode_X64_rsi;}break; -case REGS_RegCodeX64_rdi:{result = RDI_RegisterCode_X64_rdi;}break; -case REGS_RegCodeX64_r8:{result = RDI_RegisterCode_X64_r8;}break; -case REGS_RegCodeX64_r9:{result = RDI_RegisterCode_X64_r9;}break; -case REGS_RegCodeX64_r10:{result = RDI_RegisterCode_X64_r10;}break; -case REGS_RegCodeX64_r11:{result = RDI_RegisterCode_X64_r11;}break; -case REGS_RegCodeX64_r12:{result = RDI_RegisterCode_X64_r12;}break; -case REGS_RegCodeX64_r13:{result = RDI_RegisterCode_X64_r13;}break; -case REGS_RegCodeX64_r14:{result = RDI_RegisterCode_X64_r14;}break; -case REGS_RegCodeX64_r15:{result = RDI_RegisterCode_X64_r15;}break; -case REGS_RegCodeX64_fsbase:{result = RDI_RegisterCode_X64_fsbase;}break; -case REGS_RegCodeX64_gsbase:{result = RDI_RegisterCode_X64_gsbase;}break; -case REGS_RegCodeX64_rip:{result = RDI_RegisterCode_X64_rip;}break; -case REGS_RegCodeX64_rflags:{result = RDI_RegisterCode_X64_rflags;}break; -case REGS_RegCodeX64_dr0:{result = RDI_RegisterCode_X64_dr0;}break; -case REGS_RegCodeX64_dr1:{result = RDI_RegisterCode_X64_dr1;}break; -case REGS_RegCodeX64_dr2:{result = RDI_RegisterCode_X64_dr2;}break; -case REGS_RegCodeX64_dr3:{result = RDI_RegisterCode_X64_dr3;}break; -case REGS_RegCodeX64_dr4:{result = RDI_RegisterCode_X64_dr4;}break; -case REGS_RegCodeX64_dr5:{result = RDI_RegisterCode_X64_dr5;}break; -case REGS_RegCodeX64_dr6:{result = RDI_RegisterCode_X64_dr6;}break; -case REGS_RegCodeX64_dr7:{result = RDI_RegisterCode_X64_dr7;}break; -case REGS_RegCodeX64_fpr0:{result = RDI_RegisterCode_X64_fpr0;}break; -case REGS_RegCodeX64_fpr1:{result = RDI_RegisterCode_X64_fpr1;}break; -case REGS_RegCodeX64_fpr2:{result = RDI_RegisterCode_X64_fpr2;}break; -case REGS_RegCodeX64_fpr3:{result = RDI_RegisterCode_X64_fpr3;}break; -case REGS_RegCodeX64_fpr4:{result = RDI_RegisterCode_X64_fpr4;}break; -case REGS_RegCodeX64_fpr5:{result = RDI_RegisterCode_X64_fpr5;}break; -case REGS_RegCodeX64_fpr6:{result = RDI_RegisterCode_X64_fpr6;}break; -case REGS_RegCodeX64_fpr7:{result = RDI_RegisterCode_X64_fpr7;}break; -case REGS_RegCodeX64_st0:{result = RDI_RegisterCode_X64_st0;}break; -case REGS_RegCodeX64_st1:{result = RDI_RegisterCode_X64_st1;}break; -case REGS_RegCodeX64_st2:{result = RDI_RegisterCode_X64_st2;}break; -case REGS_RegCodeX64_st3:{result = RDI_RegisterCode_X64_st3;}break; -case REGS_RegCodeX64_st4:{result = RDI_RegisterCode_X64_st4;}break; -case REGS_RegCodeX64_st5:{result = RDI_RegisterCode_X64_st5;}break; -case REGS_RegCodeX64_st6:{result = RDI_RegisterCode_X64_st6;}break; -case REGS_RegCodeX64_st7:{result = RDI_RegisterCode_X64_st7;}break; -case REGS_RegCodeX64_fcw:{result = RDI_RegisterCode_X64_fcw;}break; -case REGS_RegCodeX64_fsw:{result = RDI_RegisterCode_X64_fsw;}break; -case REGS_RegCodeX64_ftw:{result = RDI_RegisterCode_X64_ftw;}break; -case REGS_RegCodeX64_fop:{result = RDI_RegisterCode_X64_fop;}break; -case REGS_RegCodeX64_fcs:{result = RDI_RegisterCode_X64_fcs;}break; -case REGS_RegCodeX64_fds:{result = RDI_RegisterCode_X64_fds;}break; -case REGS_RegCodeX64_fip:{result = RDI_RegisterCode_X64_fip;}break; -case REGS_RegCodeX64_fdp:{result = RDI_RegisterCode_X64_fdp;}break; -case REGS_RegCodeX64_mxcsr:{result = RDI_RegisterCode_X64_mxcsr;}break; -case REGS_RegCodeX64_mxcsr_mask:{result = RDI_RegisterCode_X64_mxcsr_mask;}break; -case REGS_RegCodeX64_ss:{result = RDI_RegisterCode_X64_ss;}break; -case REGS_RegCodeX64_cs:{result = RDI_RegisterCode_X64_cs;}break; -case REGS_RegCodeX64_ds:{result = RDI_RegisterCode_X64_ds;}break; -case REGS_RegCodeX64_es:{result = RDI_RegisterCode_X64_es;}break; -case REGS_RegCodeX64_fs:{result = RDI_RegisterCode_X64_fs;}break; -case REGS_RegCodeX64_gs:{result = RDI_RegisterCode_X64_gs;}break; -case REGS_RegCodeX64_ymm0:{result = RDI_RegisterCode_X64_ymm0;}break; -case REGS_RegCodeX64_ymm1:{result = RDI_RegisterCode_X64_ymm1;}break; -case REGS_RegCodeX64_ymm2:{result = RDI_RegisterCode_X64_ymm2;}break; -case REGS_RegCodeX64_ymm3:{result = RDI_RegisterCode_X64_ymm3;}break; -case REGS_RegCodeX64_ymm4:{result = RDI_RegisterCode_X64_ymm4;}break; -case REGS_RegCodeX64_ymm5:{result = RDI_RegisterCode_X64_ymm5;}break; -case REGS_RegCodeX64_ymm6:{result = RDI_RegisterCode_X64_ymm6;}break; -case REGS_RegCodeX64_ymm7:{result = RDI_RegisterCode_X64_ymm7;}break; -case REGS_RegCodeX64_ymm8:{result = RDI_RegisterCode_X64_ymm8;}break; -case REGS_RegCodeX64_ymm9:{result = RDI_RegisterCode_X64_ymm9;}break; -case REGS_RegCodeX64_ymm10:{result = RDI_RegisterCode_X64_ymm10;}break; -case REGS_RegCodeX64_ymm11:{result = RDI_RegisterCode_X64_ymm11;}break; -case REGS_RegCodeX64_ymm12:{result = RDI_RegisterCode_X64_ymm12;}break; -case REGS_RegCodeX64_ymm13:{result = RDI_RegisterCode_X64_ymm13;}break; -case REGS_RegCodeX64_ymm14:{result = RDI_RegisterCode_X64_ymm14;}break; -case REGS_RegCodeX64_ymm15:{result = RDI_RegisterCode_X64_ymm15;}break; +case REGS_RegCodeX64_rax:{result = RDI_RegCodeX64_rax;}break; +case REGS_RegCodeX64_rcx:{result = RDI_RegCodeX64_rcx;}break; +case REGS_RegCodeX64_rdx:{result = RDI_RegCodeX64_rdx;}break; +case REGS_RegCodeX64_rbx:{result = RDI_RegCodeX64_rbx;}break; +case REGS_RegCodeX64_rsp:{result = RDI_RegCodeX64_rsp;}break; +case REGS_RegCodeX64_rbp:{result = RDI_RegCodeX64_rbp;}break; +case REGS_RegCodeX64_rsi:{result = RDI_RegCodeX64_rsi;}break; +case REGS_RegCodeX64_rdi:{result = RDI_RegCodeX64_rdi;}break; +case REGS_RegCodeX64_r8:{result = RDI_RegCodeX64_r8;}break; +case REGS_RegCodeX64_r9:{result = RDI_RegCodeX64_r9;}break; +case REGS_RegCodeX64_r10:{result = RDI_RegCodeX64_r10;}break; +case REGS_RegCodeX64_r11:{result = RDI_RegCodeX64_r11;}break; +case REGS_RegCodeX64_r12:{result = RDI_RegCodeX64_r12;}break; +case REGS_RegCodeX64_r13:{result = RDI_RegCodeX64_r13;}break; +case REGS_RegCodeX64_r14:{result = RDI_RegCodeX64_r14;}break; +case REGS_RegCodeX64_r15:{result = RDI_RegCodeX64_r15;}break; +case REGS_RegCodeX64_fsbase:{result = RDI_RegCodeX64_fsbase;}break; +case REGS_RegCodeX64_gsbase:{result = RDI_RegCodeX64_gsbase;}break; +case REGS_RegCodeX64_rip:{result = RDI_RegCodeX64_rip;}break; +case REGS_RegCodeX64_rflags:{result = RDI_RegCodeX64_rflags;}break; +case REGS_RegCodeX64_dr0:{result = RDI_RegCodeX64_dr0;}break; +case REGS_RegCodeX64_dr1:{result = RDI_RegCodeX64_dr1;}break; +case REGS_RegCodeX64_dr2:{result = RDI_RegCodeX64_dr2;}break; +case REGS_RegCodeX64_dr3:{result = RDI_RegCodeX64_dr3;}break; +case REGS_RegCodeX64_dr4:{result = RDI_RegCodeX64_dr4;}break; +case REGS_RegCodeX64_dr5:{result = RDI_RegCodeX64_dr5;}break; +case REGS_RegCodeX64_dr6:{result = RDI_RegCodeX64_dr6;}break; +case REGS_RegCodeX64_dr7:{result = RDI_RegCodeX64_dr7;}break; +case REGS_RegCodeX64_fpr0:{result = RDI_RegCodeX64_fpr0;}break; +case REGS_RegCodeX64_fpr1:{result = RDI_RegCodeX64_fpr1;}break; +case REGS_RegCodeX64_fpr2:{result = RDI_RegCodeX64_fpr2;}break; +case REGS_RegCodeX64_fpr3:{result = RDI_RegCodeX64_fpr3;}break; +case REGS_RegCodeX64_fpr4:{result = RDI_RegCodeX64_fpr4;}break; +case REGS_RegCodeX64_fpr5:{result = RDI_RegCodeX64_fpr5;}break; +case REGS_RegCodeX64_fpr6:{result = RDI_RegCodeX64_fpr6;}break; +case REGS_RegCodeX64_fpr7:{result = RDI_RegCodeX64_fpr7;}break; +case REGS_RegCodeX64_st0:{result = RDI_RegCodeX64_st0;}break; +case REGS_RegCodeX64_st1:{result = RDI_RegCodeX64_st1;}break; +case REGS_RegCodeX64_st2:{result = RDI_RegCodeX64_st2;}break; +case REGS_RegCodeX64_st3:{result = RDI_RegCodeX64_st3;}break; +case REGS_RegCodeX64_st4:{result = RDI_RegCodeX64_st4;}break; +case REGS_RegCodeX64_st5:{result = RDI_RegCodeX64_st5;}break; +case REGS_RegCodeX64_st6:{result = RDI_RegCodeX64_st6;}break; +case REGS_RegCodeX64_st7:{result = RDI_RegCodeX64_st7;}break; +case REGS_RegCodeX64_fcw:{result = RDI_RegCodeX64_fcw;}break; +case REGS_RegCodeX64_fsw:{result = RDI_RegCodeX64_fsw;}break; +case REGS_RegCodeX64_ftw:{result = RDI_RegCodeX64_ftw;}break; +case REGS_RegCodeX64_fop:{result = RDI_RegCodeX64_fop;}break; +case REGS_RegCodeX64_fcs:{result = RDI_RegCodeX64_fcs;}break; +case REGS_RegCodeX64_fds:{result = RDI_RegCodeX64_fds;}break; +case REGS_RegCodeX64_fip:{result = RDI_RegCodeX64_fip;}break; +case REGS_RegCodeX64_fdp:{result = RDI_RegCodeX64_fdp;}break; +case REGS_RegCodeX64_mxcsr:{result = RDI_RegCodeX64_mxcsr;}break; +case REGS_RegCodeX64_mxcsr_mask:{result = RDI_RegCodeX64_mxcsr_mask;}break; +case REGS_RegCodeX64_ss:{result = RDI_RegCodeX64_ss;}break; +case REGS_RegCodeX64_cs:{result = RDI_RegCodeX64_cs;}break; +case REGS_RegCodeX64_ds:{result = RDI_RegCodeX64_ds;}break; +case REGS_RegCodeX64_es:{result = RDI_RegCodeX64_es;}break; +case REGS_RegCodeX64_fs:{result = RDI_RegCodeX64_fs;}break; +case REGS_RegCodeX64_gs:{result = RDI_RegCodeX64_gs;}break; +case REGS_RegCodeX64_ymm0:{result = RDI_RegCodeX64_ymm0;}break; +case REGS_RegCodeX64_ymm1:{result = RDI_RegCodeX64_ymm1;}break; +case REGS_RegCodeX64_ymm2:{result = RDI_RegCodeX64_ymm2;}break; +case REGS_RegCodeX64_ymm3:{result = RDI_RegCodeX64_ymm3;}break; +case REGS_RegCodeX64_ymm4:{result = RDI_RegCodeX64_ymm4;}break; +case REGS_RegCodeX64_ymm5:{result = RDI_RegCodeX64_ymm5;}break; +case REGS_RegCodeX64_ymm6:{result = RDI_RegCodeX64_ymm6;}break; +case REGS_RegCodeX64_ymm7:{result = RDI_RegCodeX64_ymm7;}break; +case REGS_RegCodeX64_ymm8:{result = RDI_RegCodeX64_ymm8;}break; +case REGS_RegCodeX64_ymm9:{result = RDI_RegCodeX64_ymm9;}break; +case REGS_RegCodeX64_ymm10:{result = RDI_RegCodeX64_ymm10;}break; +case REGS_RegCodeX64_ymm11:{result = RDI_RegCodeX64_ymm11;}break; +case REGS_RegCodeX64_ymm12:{result = RDI_RegCodeX64_ymm12;}break; +case REGS_RegCodeX64_ymm13:{result = RDI_RegCodeX64_ymm13;}break; +case REGS_RegCodeX64_ymm14:{result = RDI_RegCodeX64_ymm14;}break; +case REGS_RegCodeX64_ymm15:{result = RDI_RegCodeX64_ymm15;}break; } }break; case Architecture_x86: @@ -97,72 +97,72 @@ case Architecture_x86: switch(code) { default:{}break; -case REGS_RegCodeX86_eax:{result = RDI_RegisterCode_X86_eax;}break; -case REGS_RegCodeX86_ecx:{result = RDI_RegisterCode_X86_ecx;}break; -case REGS_RegCodeX86_edx:{result = RDI_RegisterCode_X86_edx;}break; -case REGS_RegCodeX86_ebx:{result = RDI_RegisterCode_X86_ebx;}break; -case REGS_RegCodeX86_esp:{result = RDI_RegisterCode_X86_esp;}break; -case REGS_RegCodeX86_ebp:{result = RDI_RegisterCode_X86_ebp;}break; -case REGS_RegCodeX86_esi:{result = RDI_RegisterCode_X86_esi;}break; -case REGS_RegCodeX86_edi:{result = RDI_RegisterCode_X86_edi;}break; -case REGS_RegCodeX86_fsbase:{result = RDI_RegisterCode_X86_fsbase;}break; -case REGS_RegCodeX86_gsbase:{result = RDI_RegisterCode_X86_gsbase;}break; -case REGS_RegCodeX86_eflags:{result = RDI_RegisterCode_X86_eflags;}break; -case REGS_RegCodeX86_eip:{result = RDI_RegisterCode_X86_eip;}break; -case REGS_RegCodeX86_dr0:{result = RDI_RegisterCode_X86_dr0;}break; -case REGS_RegCodeX86_dr1:{result = RDI_RegisterCode_X86_dr1;}break; -case REGS_RegCodeX86_dr2:{result = RDI_RegisterCode_X86_dr2;}break; -case REGS_RegCodeX86_dr3:{result = RDI_RegisterCode_X86_dr3;}break; -case REGS_RegCodeX86_dr4:{result = RDI_RegisterCode_X86_dr4;}break; -case REGS_RegCodeX86_dr5:{result = RDI_RegisterCode_X86_dr5;}break; -case REGS_RegCodeX86_dr6:{result = RDI_RegisterCode_X86_dr6;}break; -case REGS_RegCodeX86_dr7:{result = RDI_RegisterCode_X86_dr7;}break; -case REGS_RegCodeX86_fpr0:{result = RDI_RegisterCode_X86_fpr0;}break; -case REGS_RegCodeX86_fpr1:{result = RDI_RegisterCode_X86_fpr1;}break; -case REGS_RegCodeX86_fpr2:{result = RDI_RegisterCode_X86_fpr2;}break; -case REGS_RegCodeX86_fpr3:{result = RDI_RegisterCode_X86_fpr3;}break; -case REGS_RegCodeX86_fpr4:{result = RDI_RegisterCode_X86_fpr4;}break; -case REGS_RegCodeX86_fpr5:{result = RDI_RegisterCode_X86_fpr5;}break; -case REGS_RegCodeX86_fpr6:{result = RDI_RegisterCode_X86_fpr6;}break; -case REGS_RegCodeX86_fpr7:{result = RDI_RegisterCode_X86_fpr7;}break; -case REGS_RegCodeX86_st0:{result = RDI_RegisterCode_X86_st0;}break; -case REGS_RegCodeX86_st1:{result = RDI_RegisterCode_X86_st1;}break; -case REGS_RegCodeX86_st2:{result = RDI_RegisterCode_X86_st2;}break; -case REGS_RegCodeX86_st3:{result = RDI_RegisterCode_X86_st3;}break; -case REGS_RegCodeX86_st4:{result = RDI_RegisterCode_X86_st4;}break; -case REGS_RegCodeX86_st5:{result = RDI_RegisterCode_X86_st5;}break; -case REGS_RegCodeX86_st6:{result = RDI_RegisterCode_X86_st6;}break; -case REGS_RegCodeX86_st7:{result = RDI_RegisterCode_X86_st7;}break; -case REGS_RegCodeX86_fcw:{result = RDI_RegisterCode_X86_fcw;}break; -case REGS_RegCodeX86_fsw:{result = RDI_RegisterCode_X86_fsw;}break; -case REGS_RegCodeX86_ftw:{result = RDI_RegisterCode_X86_ftw;}break; -case REGS_RegCodeX86_fop:{result = RDI_RegisterCode_X86_fop;}break; -case REGS_RegCodeX86_fcs:{result = RDI_RegisterCode_X86_fcs;}break; -case REGS_RegCodeX86_fds:{result = RDI_RegisterCode_X86_fds;}break; -case REGS_RegCodeX86_fip:{result = RDI_RegisterCode_X86_fip;}break; -case REGS_RegCodeX86_fdp:{result = RDI_RegisterCode_X86_fdp;}break; -case REGS_RegCodeX86_mxcsr:{result = RDI_RegisterCode_X86_mxcsr;}break; -case REGS_RegCodeX86_mxcsr_mask:{result = RDI_RegisterCode_X86_mxcsr_mask;}break; -case REGS_RegCodeX86_ss:{result = RDI_RegisterCode_X86_ss;}break; -case REGS_RegCodeX86_cs:{result = RDI_RegisterCode_X86_cs;}break; -case REGS_RegCodeX86_ds:{result = RDI_RegisterCode_X86_ds;}break; -case REGS_RegCodeX86_es:{result = RDI_RegisterCode_X86_es;}break; -case REGS_RegCodeX86_fs:{result = RDI_RegisterCode_X86_fs;}break; -case REGS_RegCodeX86_gs:{result = RDI_RegisterCode_X86_gs;}break; -case REGS_RegCodeX86_ymm0:{result = RDI_RegisterCode_X86_ymm0;}break; -case REGS_RegCodeX86_ymm1:{result = RDI_RegisterCode_X86_ymm1;}break; -case REGS_RegCodeX86_ymm2:{result = RDI_RegisterCode_X86_ymm2;}break; -case REGS_RegCodeX86_ymm3:{result = RDI_RegisterCode_X86_ymm3;}break; -case REGS_RegCodeX86_ymm4:{result = RDI_RegisterCode_X86_ymm4;}break; -case REGS_RegCodeX86_ymm5:{result = RDI_RegisterCode_X86_ymm5;}break; -case REGS_RegCodeX86_ymm6:{result = RDI_RegisterCode_X86_ymm6;}break; -case REGS_RegCodeX86_ymm7:{result = RDI_RegisterCode_X86_ymm7;}break; +case REGS_RegCodeX86_eax:{result = RDI_RegCodeX86_eax;}break; +case REGS_RegCodeX86_ecx:{result = RDI_RegCodeX86_ecx;}break; +case REGS_RegCodeX86_edx:{result = RDI_RegCodeX86_edx;}break; +case REGS_RegCodeX86_ebx:{result = RDI_RegCodeX86_ebx;}break; +case REGS_RegCodeX86_esp:{result = RDI_RegCodeX86_esp;}break; +case REGS_RegCodeX86_ebp:{result = RDI_RegCodeX86_ebp;}break; +case REGS_RegCodeX86_esi:{result = RDI_RegCodeX86_esi;}break; +case REGS_RegCodeX86_edi:{result = RDI_RegCodeX86_edi;}break; +case REGS_RegCodeX86_fsbase:{result = RDI_RegCodeX86_fsbase;}break; +case REGS_RegCodeX86_gsbase:{result = RDI_RegCodeX86_gsbase;}break; +case REGS_RegCodeX86_eflags:{result = RDI_RegCodeX86_eflags;}break; +case REGS_RegCodeX86_eip:{result = RDI_RegCodeX86_eip;}break; +case REGS_RegCodeX86_dr0:{result = RDI_RegCodeX86_dr0;}break; +case REGS_RegCodeX86_dr1:{result = RDI_RegCodeX86_dr1;}break; +case REGS_RegCodeX86_dr2:{result = RDI_RegCodeX86_dr2;}break; +case REGS_RegCodeX86_dr3:{result = RDI_RegCodeX86_dr3;}break; +case REGS_RegCodeX86_dr4:{result = RDI_RegCodeX86_dr4;}break; +case REGS_RegCodeX86_dr5:{result = RDI_RegCodeX86_dr5;}break; +case REGS_RegCodeX86_dr6:{result = RDI_RegCodeX86_dr6;}break; +case REGS_RegCodeX86_dr7:{result = RDI_RegCodeX86_dr7;}break; +case REGS_RegCodeX86_fpr0:{result = RDI_RegCodeX86_fpr0;}break; +case REGS_RegCodeX86_fpr1:{result = RDI_RegCodeX86_fpr1;}break; +case REGS_RegCodeX86_fpr2:{result = RDI_RegCodeX86_fpr2;}break; +case REGS_RegCodeX86_fpr3:{result = RDI_RegCodeX86_fpr3;}break; +case REGS_RegCodeX86_fpr4:{result = RDI_RegCodeX86_fpr4;}break; +case REGS_RegCodeX86_fpr5:{result = RDI_RegCodeX86_fpr5;}break; +case REGS_RegCodeX86_fpr6:{result = RDI_RegCodeX86_fpr6;}break; +case REGS_RegCodeX86_fpr7:{result = RDI_RegCodeX86_fpr7;}break; +case REGS_RegCodeX86_st0:{result = RDI_RegCodeX86_st0;}break; +case REGS_RegCodeX86_st1:{result = RDI_RegCodeX86_st1;}break; +case REGS_RegCodeX86_st2:{result = RDI_RegCodeX86_st2;}break; +case REGS_RegCodeX86_st3:{result = RDI_RegCodeX86_st3;}break; +case REGS_RegCodeX86_st4:{result = RDI_RegCodeX86_st4;}break; +case REGS_RegCodeX86_st5:{result = RDI_RegCodeX86_st5;}break; +case REGS_RegCodeX86_st6:{result = RDI_RegCodeX86_st6;}break; +case REGS_RegCodeX86_st7:{result = RDI_RegCodeX86_st7;}break; +case REGS_RegCodeX86_fcw:{result = RDI_RegCodeX86_fcw;}break; +case REGS_RegCodeX86_fsw:{result = RDI_RegCodeX86_fsw;}break; +case REGS_RegCodeX86_ftw:{result = RDI_RegCodeX86_ftw;}break; +case REGS_RegCodeX86_fop:{result = RDI_RegCodeX86_fop;}break; +case REGS_RegCodeX86_fcs:{result = RDI_RegCodeX86_fcs;}break; +case REGS_RegCodeX86_fds:{result = RDI_RegCodeX86_fds;}break; +case REGS_RegCodeX86_fip:{result = RDI_RegCodeX86_fip;}break; +case REGS_RegCodeX86_fdp:{result = RDI_RegCodeX86_fdp;}break; +case REGS_RegCodeX86_mxcsr:{result = RDI_RegCodeX86_mxcsr;}break; +case REGS_RegCodeX86_mxcsr_mask:{result = RDI_RegCodeX86_mxcsr_mask;}break; +case REGS_RegCodeX86_ss:{result = RDI_RegCodeX86_ss;}break; +case REGS_RegCodeX86_cs:{result = RDI_RegCodeX86_cs;}break; +case REGS_RegCodeX86_ds:{result = RDI_RegCodeX86_ds;}break; +case REGS_RegCodeX86_es:{result = RDI_RegCodeX86_es;}break; +case REGS_RegCodeX86_fs:{result = RDI_RegCodeX86_fs;}break; +case REGS_RegCodeX86_gs:{result = RDI_RegCodeX86_gs;}break; +case REGS_RegCodeX86_ymm0:{result = RDI_RegCodeX86_ymm0;}break; +case REGS_RegCodeX86_ymm1:{result = RDI_RegCodeX86_ymm1;}break; +case REGS_RegCodeX86_ymm2:{result = RDI_RegCodeX86_ymm2;}break; +case REGS_RegCodeX86_ymm3:{result = RDI_RegCodeX86_ymm3;}break; +case REGS_RegCodeX86_ymm4:{result = RDI_RegCodeX86_ymm4;}break; +case REGS_RegCodeX86_ymm5:{result = RDI_RegCodeX86_ymm5;}break; +case REGS_RegCodeX86_ymm6:{result = RDI_RegCodeX86_ymm6;}break; +case REGS_RegCodeX86_ymm7:{result = RDI_RegCodeX86_ymm7;}break; } }break; } return result; } -internal REGS_RegCode regs_reg_code_from_arch_rdi_code(Architecture arch, RDI_RegisterCode code) +internal REGS_RegCode regs_reg_code_from_arch_rdi_code(Architecture arch, RDI_RegCode code) { REGS_RegCode result = 0; switch(arch) @@ -173,82 +173,82 @@ case Architecture_x64: switch(code) { default:{}break; -case RDI_RegisterCode_X64_rax:{result = REGS_RegCodeX64_rax;}break; -case RDI_RegisterCode_X64_rcx:{result = REGS_RegCodeX64_rcx;}break; -case RDI_RegisterCode_X64_rdx:{result = REGS_RegCodeX64_rdx;}break; -case RDI_RegisterCode_X64_rbx:{result = REGS_RegCodeX64_rbx;}break; -case RDI_RegisterCode_X64_rsp:{result = REGS_RegCodeX64_rsp;}break; -case RDI_RegisterCode_X64_rbp:{result = REGS_RegCodeX64_rbp;}break; -case RDI_RegisterCode_X64_rsi:{result = REGS_RegCodeX64_rsi;}break; -case RDI_RegisterCode_X64_rdi:{result = REGS_RegCodeX64_rdi;}break; -case RDI_RegisterCode_X64_r8:{result = REGS_RegCodeX64_r8;}break; -case RDI_RegisterCode_X64_r9:{result = REGS_RegCodeX64_r9;}break; -case RDI_RegisterCode_X64_r10:{result = REGS_RegCodeX64_r10;}break; -case RDI_RegisterCode_X64_r11:{result = REGS_RegCodeX64_r11;}break; -case RDI_RegisterCode_X64_r12:{result = REGS_RegCodeX64_r12;}break; -case RDI_RegisterCode_X64_r13:{result = REGS_RegCodeX64_r13;}break; -case RDI_RegisterCode_X64_r14:{result = REGS_RegCodeX64_r14;}break; -case RDI_RegisterCode_X64_r15:{result = REGS_RegCodeX64_r15;}break; -case RDI_RegisterCode_X64_fsbase:{result = REGS_RegCodeX64_fsbase;}break; -case RDI_RegisterCode_X64_gsbase:{result = REGS_RegCodeX64_gsbase;}break; -case RDI_RegisterCode_X64_rip:{result = REGS_RegCodeX64_rip;}break; -case RDI_RegisterCode_X64_rflags:{result = REGS_RegCodeX64_rflags;}break; -case RDI_RegisterCode_X64_dr0:{result = REGS_RegCodeX64_dr0;}break; -case RDI_RegisterCode_X64_dr1:{result = REGS_RegCodeX64_dr1;}break; -case RDI_RegisterCode_X64_dr2:{result = REGS_RegCodeX64_dr2;}break; -case RDI_RegisterCode_X64_dr3:{result = REGS_RegCodeX64_dr3;}break; -case RDI_RegisterCode_X64_dr4:{result = REGS_RegCodeX64_dr4;}break; -case RDI_RegisterCode_X64_dr5:{result = REGS_RegCodeX64_dr5;}break; -case RDI_RegisterCode_X64_dr6:{result = REGS_RegCodeX64_dr6;}break; -case RDI_RegisterCode_X64_dr7:{result = REGS_RegCodeX64_dr7;}break; -case RDI_RegisterCode_X64_fpr0:{result = REGS_RegCodeX64_fpr0;}break; -case RDI_RegisterCode_X64_fpr1:{result = REGS_RegCodeX64_fpr1;}break; -case RDI_RegisterCode_X64_fpr2:{result = REGS_RegCodeX64_fpr2;}break; -case RDI_RegisterCode_X64_fpr3:{result = REGS_RegCodeX64_fpr3;}break; -case RDI_RegisterCode_X64_fpr4:{result = REGS_RegCodeX64_fpr4;}break; -case RDI_RegisterCode_X64_fpr5:{result = REGS_RegCodeX64_fpr5;}break; -case RDI_RegisterCode_X64_fpr6:{result = REGS_RegCodeX64_fpr6;}break; -case RDI_RegisterCode_X64_fpr7:{result = REGS_RegCodeX64_fpr7;}break; -case RDI_RegisterCode_X64_st0:{result = REGS_RegCodeX64_st0;}break; -case RDI_RegisterCode_X64_st1:{result = REGS_RegCodeX64_st1;}break; -case RDI_RegisterCode_X64_st2:{result = REGS_RegCodeX64_st2;}break; -case RDI_RegisterCode_X64_st3:{result = REGS_RegCodeX64_st3;}break; -case RDI_RegisterCode_X64_st4:{result = REGS_RegCodeX64_st4;}break; -case RDI_RegisterCode_X64_st5:{result = REGS_RegCodeX64_st5;}break; -case RDI_RegisterCode_X64_st6:{result = REGS_RegCodeX64_st6;}break; -case RDI_RegisterCode_X64_st7:{result = REGS_RegCodeX64_st7;}break; -case RDI_RegisterCode_X64_fcw:{result = REGS_RegCodeX64_fcw;}break; -case RDI_RegisterCode_X64_fsw:{result = REGS_RegCodeX64_fsw;}break; -case RDI_RegisterCode_X64_ftw:{result = REGS_RegCodeX64_ftw;}break; -case RDI_RegisterCode_X64_fop:{result = REGS_RegCodeX64_fop;}break; -case RDI_RegisterCode_X64_fcs:{result = REGS_RegCodeX64_fcs;}break; -case RDI_RegisterCode_X64_fds:{result = REGS_RegCodeX64_fds;}break; -case RDI_RegisterCode_X64_fip:{result = REGS_RegCodeX64_fip;}break; -case RDI_RegisterCode_X64_fdp:{result = REGS_RegCodeX64_fdp;}break; -case RDI_RegisterCode_X64_mxcsr:{result = REGS_RegCodeX64_mxcsr;}break; -case RDI_RegisterCode_X64_mxcsr_mask:{result = REGS_RegCodeX64_mxcsr_mask;}break; -case RDI_RegisterCode_X64_ss:{result = REGS_RegCodeX64_ss;}break; -case RDI_RegisterCode_X64_cs:{result = REGS_RegCodeX64_cs;}break; -case RDI_RegisterCode_X64_ds:{result = REGS_RegCodeX64_ds;}break; -case RDI_RegisterCode_X64_es:{result = REGS_RegCodeX64_es;}break; -case RDI_RegisterCode_X64_fs:{result = REGS_RegCodeX64_fs;}break; -case RDI_RegisterCode_X64_gs:{result = REGS_RegCodeX64_gs;}break; -case RDI_RegisterCode_X64_ymm0:{result = REGS_RegCodeX64_ymm0;}break; -case RDI_RegisterCode_X64_ymm1:{result = REGS_RegCodeX64_ymm1;}break; -case RDI_RegisterCode_X64_ymm2:{result = REGS_RegCodeX64_ymm2;}break; -case RDI_RegisterCode_X64_ymm3:{result = REGS_RegCodeX64_ymm3;}break; -case RDI_RegisterCode_X64_ymm4:{result = REGS_RegCodeX64_ymm4;}break; -case RDI_RegisterCode_X64_ymm5:{result = REGS_RegCodeX64_ymm5;}break; -case RDI_RegisterCode_X64_ymm6:{result = REGS_RegCodeX64_ymm6;}break; -case RDI_RegisterCode_X64_ymm7:{result = REGS_RegCodeX64_ymm7;}break; -case RDI_RegisterCode_X64_ymm8:{result = REGS_RegCodeX64_ymm8;}break; -case RDI_RegisterCode_X64_ymm9:{result = REGS_RegCodeX64_ymm9;}break; -case RDI_RegisterCode_X64_ymm10:{result = REGS_RegCodeX64_ymm10;}break; -case RDI_RegisterCode_X64_ymm11:{result = REGS_RegCodeX64_ymm11;}break; -case RDI_RegisterCode_X64_ymm12:{result = REGS_RegCodeX64_ymm12;}break; -case RDI_RegisterCode_X64_ymm13:{result = REGS_RegCodeX64_ymm13;}break; -case RDI_RegisterCode_X64_ymm14:{result = REGS_RegCodeX64_ymm14;}break; -case RDI_RegisterCode_X64_ymm15:{result = REGS_RegCodeX64_ymm15;}break; +case RDI_RegCodeX64_rax:{result = REGS_RegCodeX64_rax;}break; +case RDI_RegCodeX64_rcx:{result = REGS_RegCodeX64_rcx;}break; +case RDI_RegCodeX64_rdx:{result = REGS_RegCodeX64_rdx;}break; +case RDI_RegCodeX64_rbx:{result = REGS_RegCodeX64_rbx;}break; +case RDI_RegCodeX64_rsp:{result = REGS_RegCodeX64_rsp;}break; +case RDI_RegCodeX64_rbp:{result = REGS_RegCodeX64_rbp;}break; +case RDI_RegCodeX64_rsi:{result = REGS_RegCodeX64_rsi;}break; +case RDI_RegCodeX64_rdi:{result = REGS_RegCodeX64_rdi;}break; +case RDI_RegCodeX64_r8:{result = REGS_RegCodeX64_r8;}break; +case RDI_RegCodeX64_r9:{result = REGS_RegCodeX64_r9;}break; +case RDI_RegCodeX64_r10:{result = REGS_RegCodeX64_r10;}break; +case RDI_RegCodeX64_r11:{result = REGS_RegCodeX64_r11;}break; +case RDI_RegCodeX64_r12:{result = REGS_RegCodeX64_r12;}break; +case RDI_RegCodeX64_r13:{result = REGS_RegCodeX64_r13;}break; +case RDI_RegCodeX64_r14:{result = REGS_RegCodeX64_r14;}break; +case RDI_RegCodeX64_r15:{result = REGS_RegCodeX64_r15;}break; +case RDI_RegCodeX64_fsbase:{result = REGS_RegCodeX64_fsbase;}break; +case RDI_RegCodeX64_gsbase:{result = REGS_RegCodeX64_gsbase;}break; +case RDI_RegCodeX64_rip:{result = REGS_RegCodeX64_rip;}break; +case RDI_RegCodeX64_rflags:{result = REGS_RegCodeX64_rflags;}break; +case RDI_RegCodeX64_dr0:{result = REGS_RegCodeX64_dr0;}break; +case RDI_RegCodeX64_dr1:{result = REGS_RegCodeX64_dr1;}break; +case RDI_RegCodeX64_dr2:{result = REGS_RegCodeX64_dr2;}break; +case RDI_RegCodeX64_dr3:{result = REGS_RegCodeX64_dr3;}break; +case RDI_RegCodeX64_dr4:{result = REGS_RegCodeX64_dr4;}break; +case RDI_RegCodeX64_dr5:{result = REGS_RegCodeX64_dr5;}break; +case RDI_RegCodeX64_dr6:{result = REGS_RegCodeX64_dr6;}break; +case RDI_RegCodeX64_dr7:{result = REGS_RegCodeX64_dr7;}break; +case RDI_RegCodeX64_fpr0:{result = REGS_RegCodeX64_fpr0;}break; +case RDI_RegCodeX64_fpr1:{result = REGS_RegCodeX64_fpr1;}break; +case RDI_RegCodeX64_fpr2:{result = REGS_RegCodeX64_fpr2;}break; +case RDI_RegCodeX64_fpr3:{result = REGS_RegCodeX64_fpr3;}break; +case RDI_RegCodeX64_fpr4:{result = REGS_RegCodeX64_fpr4;}break; +case RDI_RegCodeX64_fpr5:{result = REGS_RegCodeX64_fpr5;}break; +case RDI_RegCodeX64_fpr6:{result = REGS_RegCodeX64_fpr6;}break; +case RDI_RegCodeX64_fpr7:{result = REGS_RegCodeX64_fpr7;}break; +case RDI_RegCodeX64_st0:{result = REGS_RegCodeX64_st0;}break; +case RDI_RegCodeX64_st1:{result = REGS_RegCodeX64_st1;}break; +case RDI_RegCodeX64_st2:{result = REGS_RegCodeX64_st2;}break; +case RDI_RegCodeX64_st3:{result = REGS_RegCodeX64_st3;}break; +case RDI_RegCodeX64_st4:{result = REGS_RegCodeX64_st4;}break; +case RDI_RegCodeX64_st5:{result = REGS_RegCodeX64_st5;}break; +case RDI_RegCodeX64_st6:{result = REGS_RegCodeX64_st6;}break; +case RDI_RegCodeX64_st7:{result = REGS_RegCodeX64_st7;}break; +case RDI_RegCodeX64_fcw:{result = REGS_RegCodeX64_fcw;}break; +case RDI_RegCodeX64_fsw:{result = REGS_RegCodeX64_fsw;}break; +case RDI_RegCodeX64_ftw:{result = REGS_RegCodeX64_ftw;}break; +case RDI_RegCodeX64_fop:{result = REGS_RegCodeX64_fop;}break; +case RDI_RegCodeX64_fcs:{result = REGS_RegCodeX64_fcs;}break; +case RDI_RegCodeX64_fds:{result = REGS_RegCodeX64_fds;}break; +case RDI_RegCodeX64_fip:{result = REGS_RegCodeX64_fip;}break; +case RDI_RegCodeX64_fdp:{result = REGS_RegCodeX64_fdp;}break; +case RDI_RegCodeX64_mxcsr:{result = REGS_RegCodeX64_mxcsr;}break; +case RDI_RegCodeX64_mxcsr_mask:{result = REGS_RegCodeX64_mxcsr_mask;}break; +case RDI_RegCodeX64_ss:{result = REGS_RegCodeX64_ss;}break; +case RDI_RegCodeX64_cs:{result = REGS_RegCodeX64_cs;}break; +case RDI_RegCodeX64_ds:{result = REGS_RegCodeX64_ds;}break; +case RDI_RegCodeX64_es:{result = REGS_RegCodeX64_es;}break; +case RDI_RegCodeX64_fs:{result = REGS_RegCodeX64_fs;}break; +case RDI_RegCodeX64_gs:{result = REGS_RegCodeX64_gs;}break; +case RDI_RegCodeX64_ymm0:{result = REGS_RegCodeX64_ymm0;}break; +case RDI_RegCodeX64_ymm1:{result = REGS_RegCodeX64_ymm1;}break; +case RDI_RegCodeX64_ymm2:{result = REGS_RegCodeX64_ymm2;}break; +case RDI_RegCodeX64_ymm3:{result = REGS_RegCodeX64_ymm3;}break; +case RDI_RegCodeX64_ymm4:{result = REGS_RegCodeX64_ymm4;}break; +case RDI_RegCodeX64_ymm5:{result = REGS_RegCodeX64_ymm5;}break; +case RDI_RegCodeX64_ymm6:{result = REGS_RegCodeX64_ymm6;}break; +case RDI_RegCodeX64_ymm7:{result = REGS_RegCodeX64_ymm7;}break; +case RDI_RegCodeX64_ymm8:{result = REGS_RegCodeX64_ymm8;}break; +case RDI_RegCodeX64_ymm9:{result = REGS_RegCodeX64_ymm9;}break; +case RDI_RegCodeX64_ymm10:{result = REGS_RegCodeX64_ymm10;}break; +case RDI_RegCodeX64_ymm11:{result = REGS_RegCodeX64_ymm11;}break; +case RDI_RegCodeX64_ymm12:{result = REGS_RegCodeX64_ymm12;}break; +case RDI_RegCodeX64_ymm13:{result = REGS_RegCodeX64_ymm13;}break; +case RDI_RegCodeX64_ymm14:{result = REGS_RegCodeX64_ymm14;}break; +case RDI_RegCodeX64_ymm15:{result = REGS_RegCodeX64_ymm15;}break; } }break; case Architecture_x86: @@ -256,71 +256,68 @@ case Architecture_x86: switch(code) { default:{}break; -case RDI_RegisterCode_X86_eax:{result = REGS_RegCodeX86_eax;}break; -case RDI_RegisterCode_X86_ecx:{result = REGS_RegCodeX86_ecx;}break; -case RDI_RegisterCode_X86_edx:{result = REGS_RegCodeX86_edx;}break; -case RDI_RegisterCode_X86_ebx:{result = REGS_RegCodeX86_ebx;}break; -case RDI_RegisterCode_X86_esp:{result = REGS_RegCodeX86_esp;}break; -case RDI_RegisterCode_X86_ebp:{result = REGS_RegCodeX86_ebp;}break; -case RDI_RegisterCode_X86_esi:{result = REGS_RegCodeX86_esi;}break; -case RDI_RegisterCode_X86_edi:{result = REGS_RegCodeX86_edi;}break; -case RDI_RegisterCode_X86_fsbase:{result = REGS_RegCodeX86_fsbase;}break; -case RDI_RegisterCode_X86_gsbase:{result = REGS_RegCodeX86_gsbase;}break; -case RDI_RegisterCode_X86_eflags:{result = REGS_RegCodeX86_eflags;}break; -case RDI_RegisterCode_X86_eip:{result = REGS_RegCodeX86_eip;}break; -case RDI_RegisterCode_X86_dr0:{result = REGS_RegCodeX86_dr0;}break; -case RDI_RegisterCode_X86_dr1:{result = REGS_RegCodeX86_dr1;}break; -case RDI_RegisterCode_X86_dr2:{result = REGS_RegCodeX86_dr2;}break; -case RDI_RegisterCode_X86_dr3:{result = REGS_RegCodeX86_dr3;}break; -case RDI_RegisterCode_X86_dr4:{result = REGS_RegCodeX86_dr4;}break; -case RDI_RegisterCode_X86_dr5:{result = REGS_RegCodeX86_dr5;}break; -case RDI_RegisterCode_X86_dr6:{result = REGS_RegCodeX86_dr6;}break; -case RDI_RegisterCode_X86_dr7:{result = REGS_RegCodeX86_dr7;}break; -case RDI_RegisterCode_X86_fpr0:{result = REGS_RegCodeX86_fpr0;}break; -case RDI_RegisterCode_X86_fpr1:{result = REGS_RegCodeX86_fpr1;}break; -case RDI_RegisterCode_X86_fpr2:{result = REGS_RegCodeX86_fpr2;}break; -case RDI_RegisterCode_X86_fpr3:{result = REGS_RegCodeX86_fpr3;}break; -case RDI_RegisterCode_X86_fpr4:{result = REGS_RegCodeX86_fpr4;}break; -case RDI_RegisterCode_X86_fpr5:{result = REGS_RegCodeX86_fpr5;}break; -case RDI_RegisterCode_X86_fpr6:{result = REGS_RegCodeX86_fpr6;}break; -case RDI_RegisterCode_X86_fpr7:{result = REGS_RegCodeX86_fpr7;}break; -case RDI_RegisterCode_X86_st0:{result = REGS_RegCodeX86_st0;}break; -case RDI_RegisterCode_X86_st1:{result = REGS_RegCodeX86_st1;}break; -case RDI_RegisterCode_X86_st2:{result = REGS_RegCodeX86_st2;}break; -case RDI_RegisterCode_X86_st3:{result = REGS_RegCodeX86_st3;}break; -case RDI_RegisterCode_X86_st4:{result = REGS_RegCodeX86_st4;}break; -case RDI_RegisterCode_X86_st5:{result = REGS_RegCodeX86_st5;}break; -case RDI_RegisterCode_X86_st6:{result = REGS_RegCodeX86_st6;}break; -case RDI_RegisterCode_X86_st7:{result = REGS_RegCodeX86_st7;}break; -case RDI_RegisterCode_X86_fcw:{result = REGS_RegCodeX86_fcw;}break; -case RDI_RegisterCode_X86_fsw:{result = REGS_RegCodeX86_fsw;}break; -case RDI_RegisterCode_X86_ftw:{result = REGS_RegCodeX86_ftw;}break; -case RDI_RegisterCode_X86_fop:{result = REGS_RegCodeX86_fop;}break; -case RDI_RegisterCode_X86_fcs:{result = REGS_RegCodeX86_fcs;}break; -case RDI_RegisterCode_X86_fds:{result = REGS_RegCodeX86_fds;}break; -case RDI_RegisterCode_X86_fip:{result = REGS_RegCodeX86_fip;}break; -case RDI_RegisterCode_X86_fdp:{result = REGS_RegCodeX86_fdp;}break; -case RDI_RegisterCode_X86_mxcsr:{result = REGS_RegCodeX86_mxcsr;}break; -case RDI_RegisterCode_X86_mxcsr_mask:{result = REGS_RegCodeX86_mxcsr_mask;}break; -case RDI_RegisterCode_X86_ss:{result = REGS_RegCodeX86_ss;}break; -case RDI_RegisterCode_X86_cs:{result = REGS_RegCodeX86_cs;}break; -case RDI_RegisterCode_X86_ds:{result = REGS_RegCodeX86_ds;}break; -case RDI_RegisterCode_X86_es:{result = REGS_RegCodeX86_es;}break; -case RDI_RegisterCode_X86_fs:{result = REGS_RegCodeX86_fs;}break; -case RDI_RegisterCode_X86_gs:{result = REGS_RegCodeX86_gs;}break; -case RDI_RegisterCode_X86_ymm0:{result = REGS_RegCodeX86_ymm0;}break; -case RDI_RegisterCode_X86_ymm1:{result = REGS_RegCodeX86_ymm1;}break; -case RDI_RegisterCode_X86_ymm2:{result = REGS_RegCodeX86_ymm2;}break; -case RDI_RegisterCode_X86_ymm3:{result = REGS_RegCodeX86_ymm3;}break; -case RDI_RegisterCode_X86_ymm4:{result = REGS_RegCodeX86_ymm4;}break; -case RDI_RegisterCode_X86_ymm5:{result = REGS_RegCodeX86_ymm5;}break; -case RDI_RegisterCode_X86_ymm6:{result = REGS_RegCodeX86_ymm6;}break; -case RDI_RegisterCode_X86_ymm7:{result = REGS_RegCodeX86_ymm7;}break; +case RDI_RegCodeX86_eax:{result = REGS_RegCodeX86_eax;}break; +case RDI_RegCodeX86_ecx:{result = REGS_RegCodeX86_ecx;}break; +case RDI_RegCodeX86_edx:{result = REGS_RegCodeX86_edx;}break; +case RDI_RegCodeX86_ebx:{result = REGS_RegCodeX86_ebx;}break; +case RDI_RegCodeX86_esp:{result = REGS_RegCodeX86_esp;}break; +case RDI_RegCodeX86_ebp:{result = REGS_RegCodeX86_ebp;}break; +case RDI_RegCodeX86_esi:{result = REGS_RegCodeX86_esi;}break; +case RDI_RegCodeX86_edi:{result = REGS_RegCodeX86_edi;}break; +case RDI_RegCodeX86_fsbase:{result = REGS_RegCodeX86_fsbase;}break; +case RDI_RegCodeX86_gsbase:{result = REGS_RegCodeX86_gsbase;}break; +case RDI_RegCodeX86_eflags:{result = REGS_RegCodeX86_eflags;}break; +case RDI_RegCodeX86_eip:{result = REGS_RegCodeX86_eip;}break; +case RDI_RegCodeX86_dr0:{result = REGS_RegCodeX86_dr0;}break; +case RDI_RegCodeX86_dr1:{result = REGS_RegCodeX86_dr1;}break; +case RDI_RegCodeX86_dr2:{result = REGS_RegCodeX86_dr2;}break; +case RDI_RegCodeX86_dr3:{result = REGS_RegCodeX86_dr3;}break; +case RDI_RegCodeX86_dr4:{result = REGS_RegCodeX86_dr4;}break; +case RDI_RegCodeX86_dr5:{result = REGS_RegCodeX86_dr5;}break; +case RDI_RegCodeX86_dr6:{result = REGS_RegCodeX86_dr6;}break; +case RDI_RegCodeX86_dr7:{result = REGS_RegCodeX86_dr7;}break; +case RDI_RegCodeX86_fpr0:{result = REGS_RegCodeX86_fpr0;}break; +case RDI_RegCodeX86_fpr1:{result = REGS_RegCodeX86_fpr1;}break; +case RDI_RegCodeX86_fpr2:{result = REGS_RegCodeX86_fpr2;}break; +case RDI_RegCodeX86_fpr3:{result = REGS_RegCodeX86_fpr3;}break; +case RDI_RegCodeX86_fpr4:{result = REGS_RegCodeX86_fpr4;}break; +case RDI_RegCodeX86_fpr5:{result = REGS_RegCodeX86_fpr5;}break; +case RDI_RegCodeX86_fpr6:{result = REGS_RegCodeX86_fpr6;}break; +case RDI_RegCodeX86_fpr7:{result = REGS_RegCodeX86_fpr7;}break; +case RDI_RegCodeX86_st0:{result = REGS_RegCodeX86_st0;}break; +case RDI_RegCodeX86_st1:{result = REGS_RegCodeX86_st1;}break; +case RDI_RegCodeX86_st2:{result = REGS_RegCodeX86_st2;}break; +case RDI_RegCodeX86_st3:{result = REGS_RegCodeX86_st3;}break; +case RDI_RegCodeX86_st4:{result = REGS_RegCodeX86_st4;}break; +case RDI_RegCodeX86_st5:{result = REGS_RegCodeX86_st5;}break; +case RDI_RegCodeX86_st6:{result = REGS_RegCodeX86_st6;}break; +case RDI_RegCodeX86_st7:{result = REGS_RegCodeX86_st7;}break; +case RDI_RegCodeX86_fcw:{result = REGS_RegCodeX86_fcw;}break; +case RDI_RegCodeX86_fsw:{result = REGS_RegCodeX86_fsw;}break; +case RDI_RegCodeX86_ftw:{result = REGS_RegCodeX86_ftw;}break; +case RDI_RegCodeX86_fop:{result = REGS_RegCodeX86_fop;}break; +case RDI_RegCodeX86_fcs:{result = REGS_RegCodeX86_fcs;}break; +case RDI_RegCodeX86_fds:{result = REGS_RegCodeX86_fds;}break; +case RDI_RegCodeX86_fip:{result = REGS_RegCodeX86_fip;}break; +case RDI_RegCodeX86_fdp:{result = REGS_RegCodeX86_fdp;}break; +case RDI_RegCodeX86_mxcsr:{result = REGS_RegCodeX86_mxcsr;}break; +case RDI_RegCodeX86_mxcsr_mask:{result = REGS_RegCodeX86_mxcsr_mask;}break; +case RDI_RegCodeX86_ss:{result = REGS_RegCodeX86_ss;}break; +case RDI_RegCodeX86_cs:{result = REGS_RegCodeX86_cs;}break; +case RDI_RegCodeX86_ds:{result = REGS_RegCodeX86_ds;}break; +case RDI_RegCodeX86_es:{result = REGS_RegCodeX86_es;}break; +case RDI_RegCodeX86_fs:{result = REGS_RegCodeX86_fs;}break; +case RDI_RegCodeX86_gs:{result = REGS_RegCodeX86_gs;}break; +case RDI_RegCodeX86_ymm0:{result = REGS_RegCodeX86_ymm0;}break; +case RDI_RegCodeX86_ymm1:{result = REGS_RegCodeX86_ymm1;}break; +case RDI_RegCodeX86_ymm2:{result = REGS_RegCodeX86_ymm2;}break; +case RDI_RegCodeX86_ymm3:{result = REGS_RegCodeX86_ymm3;}break; +case RDI_RegCodeX86_ymm4:{result = REGS_RegCodeX86_ymm4;}break; +case RDI_RegCodeX86_ymm5:{result = REGS_RegCodeX86_ymm5;}break; +case RDI_RegCodeX86_ymm6:{result = REGS_RegCodeX86_ymm6;}break; +case RDI_RegCodeX86_ymm7:{result = REGS_RegCodeX86_ymm7;}break; } }break; } return result; } -C_LINKAGE_BEGIN -C_LINKAGE_END - diff --git a/src/regs/rdi/generated/regs_rdi.meta.h b/src/regs/rdi/generated/regs_rdi.meta.h index 30461e08..3eb7229e 100644 --- a/src/regs/rdi/generated/regs_rdi.meta.h +++ b/src/regs/rdi/generated/regs_rdi.meta.h @@ -6,7 +6,4 @@ #ifndef REGS_RDI_META_H #define REGS_RDI_META_H -C_LINKAGE_BEGIN -C_LINKAGE_END - #endif // REGS_RDI_META_H diff --git a/src/regs/rdi/regs_rdi.h b/src/regs/rdi/regs_rdi.h index 72a52ce6..c75002d0 100644 --- a/src/regs/rdi/regs_rdi.h +++ b/src/regs/rdi/regs_rdi.h @@ -4,7 +4,7 @@ #ifndef REGS_RDI_H #define REGS_RDI_H -internal RDI_RegisterCode regs_rdi_code_from_arch_reg_code(Architecture arch, REGS_RegCode code); -internal REGS_RegCode regs_reg_code_from_arch_rdi_code(Architecture arch, RDI_RegisterCode reg); +internal RDI_RegCode regs_rdi_code_from_arch_reg_code(Architecture arch, REGS_RegCode code); +internal REGS_RegCode regs_reg_code_from_arch_rdi_code(Architecture arch, RDI_RegCode reg); #endif //REGS_RDI_H diff --git a/src/regs/rdi/regs_rdi.mdesk b/src/regs/rdi/regs_rdi.mdesk index aad0e4ad..9c407eed 100644 --- a/src/regs/rdi/regs_rdi.mdesk +++ b/src/regs/rdi/regs_rdi.mdesk @@ -6,9 +6,9 @@ @gen @c_file { - `internal RDI_RegisterCode regs_rdi_code_from_arch_reg_code(Architecture arch, REGS_RegCode code)`; + `internal RDI_RegCode regs_rdi_code_from_arch_reg_code(Architecture arch, REGS_RegCode code)`; `{`; - `RDI_RegisterCode result = 0;`; + `RDI_RegCode result = 0;`; `switch(arch)`; `{`; `default:{}break;`; @@ -17,7 +17,7 @@ `switch(code)` `{`; `default:{}break;`; - @expand(REGS_RegTableX64 a) `case REGS_RegCodeX64_$(a.name):{result = RDI_RegisterCode_X64_$(a.name);}break;`; + @expand(REGS_RegTableX64 a) `case REGS_RegCodeX64_$(a.name):{result = RDI_RegCodeX64_$(a.name);}break;`; `}`; `}break;`; `case Architecture_x86:`; @@ -25,7 +25,7 @@ `switch(code)` `{`; `default:{}break;`; - @expand(REGS_RegTableX86 a) `case REGS_RegCodeX86_$(a.name):{result = RDI_RegisterCode_X86_$(a.name);}break;`; + @expand(REGS_RegTableX86 a) `case REGS_RegCodeX86_$(a.name):{result = RDI_RegCodeX86_$(a.name);}break;`; `}`; `}break;`; `}`; @@ -35,7 +35,7 @@ @gen @c_file { - `internal REGS_RegCode regs_reg_code_from_arch_rdi_code(Architecture arch, RDI_RegisterCode code)`; + `internal REGS_RegCode regs_reg_code_from_arch_rdi_code(Architecture arch, RDI_RegCode code)`; `{`; `REGS_RegCode result = 0;`; `switch(arch)`; @@ -46,7 +46,7 @@ `switch(code)` `{`; `default:{}break;`; - @expand(REGS_RegTableX64 a) `case RDI_RegisterCode_X64_$(a.name):{result = REGS_RegCodeX64_$(a.name);}break;`; + @expand(REGS_RegTableX64 a) `case RDI_RegCodeX64_$(a.name):{result = REGS_RegCodeX64_$(a.name);}break;`; `}`; `}break;`; `case Architecture_x86:`; @@ -54,7 +54,7 @@ `switch(code)` `{`; `default:{}break;`; - @expand(REGS_RegTableX86 a) `case RDI_RegisterCode_X86_$(a.name):{result = REGS_RegCodeX86_$(a.name);}break;`; + @expand(REGS_RegTableX86 a) `case RDI_RegCodeX86_$(a.name):{result = REGS_RegCodeX86_$(a.name);}break;`; `}`; `}break;`; `}`; diff --git a/src/render/d3d11/generated/render_d3d11.meta.h b/src/render/d3d11/generated/render_d3d11.meta.h index b56b7e29..01656c80 100644 --- a/src/render/d3d11/generated/render_d3d11.meta.h +++ b/src/render/d3d11/generated/render_d3d11.meta.h @@ -462,6 +462,7 @@ str8_lit_comp( "" ); + C_LINKAGE_END #endif // RENDER_D3D11_META_H diff --git a/src/render/generated/render.meta.h b/src/render/generated/render.meta.h index 5c4081e6..411e900e 100644 --- a/src/render/generated/render.meta.h +++ b/src/render/generated/render.meta.h @@ -59,6 +59,7 @@ extern String8 r_tex2d_kind_display_string_table[1]; extern String8 r_tex2d_sample_kind_display_string_table[2]; extern String8 r_pass_kind_display_string_table[3]; extern U8 r_pass_kind_batch_table[3]; + C_LINKAGE_END #endif // RENDER_META_H diff --git a/src/type_graph/generated/type_graph.meta.h b/src/type_graph/generated/type_graph.meta.h index 8a4021b2..b273f677 100644 --- a/src/type_graph/generated/type_graph.meta.h +++ b/src/type_graph/generated/type_graph.meta.h @@ -78,6 +78,7 @@ TG_Kind_LastIncomplete = TG_Kind_IncompleteEnum, C_LINKAGE_BEGIN extern U8 tg_kind_basic_byte_size_table[54]; extern String8 tg_kind_basic_string_table[54]; + C_LINKAGE_END #endif // TYPE_GRAPH_META_H diff --git a/src/ui/generated/ui.meta.c b/src/ui/generated/ui.meta.c index ad2a8149..690f55f7 100644 --- a/src/ui/generated/ui.meta.c +++ b/src/ui/generated/ui.meta.c @@ -191,6 +191,3 @@ internal F32 ui_set_next_corner_radius_11(F32 v) { UI_StackSetNextImpl(ui_state, internal F32 ui_set_next_blur_size(F32 v) { UI_StackSetNextImpl(ui_state, BlurSize, blur_size, F32, v) } internal F32 ui_set_next_text_padding(F32 v) { UI_StackSetNextImpl(ui_state, TextPadding, text_padding, F32, v) } internal UI_TextAlign ui_set_next_text_alignment(UI_TextAlign v) { UI_StackSetNextImpl(ui_state, TextAlignment, text_alignment, UI_TextAlign, v) } -C_LINKAGE_BEGIN -C_LINKAGE_END - diff --git a/src/ui/generated/ui.meta.h b/src/ui/generated/ui.meta.h index e60de2bc..f49e8463 100644 --- a/src/ui/generated/ui.meta.h +++ b/src/ui/generated/ui.meta.h @@ -361,7 +361,4 @@ internal F32 ui_set_next_corner_radius_11(F32 v); internal F32 ui_set_next_blur_size(F32 v); internal F32 ui_set_next_text_padding(F32 v); internal UI_TextAlign ui_set_next_text_alignment(UI_TextAlign v); -C_LINKAGE_BEGIN -C_LINKAGE_END - #endif // UI_META_H From de56231f4a61ea300e2d073f86d8596df9f27b8f Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Fri, 31 May 2024 17:29:25 -0700 Subject: [PATCH 13/21] generation folder output override in metaprogram --- src/metagen/metagen.h | 1 + src/metagen/metagen_main.c | 24 ++++++++----------- .../{generated => lib}/rdi_format.c | 0 .../{generated => lib}/rdi_format.h | 0 src/rdi_format/rdi_format.mdesk | 2 +- 5 files changed, 12 insertions(+), 15 deletions(-) rename src/rdi_format/{generated => lib}/rdi_format.c (100%) rename src/rdi_format/{generated => lib}/rdi_format.h (100%) diff --git a/src/metagen/metagen.h b/src/metagen/metagen.h index 1026eb39..339397c1 100644 --- a/src/metagen/metagen.h +++ b/src/metagen/metagen.h @@ -213,6 +213,7 @@ struct MG_Layer { String8 key; B32 is_library; + String8 gen_folder_name; String8 h_name_override; String8 c_name_override; String8List enums; diff --git a/src/metagen/metagen_main.c b/src/metagen/metagen_main.c index 2f85ec09..2a75ca63 100644 --- a/src/metagen/metagen_main.c +++ b/src/metagen/metagen_main.c @@ -166,19 +166,10 @@ int main(int argument_count, char **arguments) layer->is_library = 1; } } - } - } - - ////////////////////////////// - //- rjf: gather hand-written h/c names & decorations - // - for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) - { - MD_Node *file = n->v.root; - String8 layer_key = mg_layer_key_from_path(file->string); - MG_Layer *layer = mg_layer_from_key(layer_key); - for(MD_EachNode(node, file->first)) - { + if(md_node_has_tag(node, str8_lit("gen_folder"), 0)) + { + layer->gen_folder_name = node->string; + } if(md_node_has_tag(node, str8_lit("h_name"), 0)) { layer->h_name_override = node->string; @@ -499,7 +490,12 @@ int main(int argument_count, char **arguments) for(MG_LayerNode *n = slot->first; n != 0; n = n->next) { MG_Layer *layer = &n->v; - String8 layer_generated_folder = push_str8f(mg_arena, "%S/%S/generated", code_dir_path, layer->key); + String8 gen_folder = str8_lit("generated"); + if(layer->gen_folder_name.size != 0) + { + gen_folder = layer->gen_folder_name; + } + String8 layer_generated_folder = push_str8f(mg_arena, "%S/%S/%S", code_dir_path, layer->key, gen_folder); if(os_make_directory(layer_generated_folder)) { String8List layer_key_parts = str8_split_path(mg_arena, layer->key); diff --git a/src/rdi_format/generated/rdi_format.c b/src/rdi_format/lib/rdi_format.c similarity index 100% rename from src/rdi_format/generated/rdi_format.c rename to src/rdi_format/lib/rdi_format.c diff --git a/src/rdi_format/generated/rdi_format.h b/src/rdi_format/lib/rdi_format.h similarity index 100% rename from src/rdi_format/generated/rdi_format.h rename to src/rdi_format/lib/rdi_format.h diff --git a/src/rdi_format/rdi_format.mdesk b/src/rdi_format/rdi_format.mdesk index ddc1332b..8a560b4f 100644 --- a/src/rdi_format/rdi_format.mdesk +++ b/src/rdi_format/rdi_format.mdesk @@ -5,7 +5,7 @@ //~ rjf: Generated File Format @option library - +@gen_folder "lib" @h_name "rdi_format.h" @c_name "rdi_format.c" From d66bbdc6a791494b048f2963e74470eba96e4eef Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Sat, 1 Jun 2024 10:16:38 -0700 Subject: [PATCH 14/21] further progress on metacode-driven generation of rdi headers; metaprogram xlist generation; getting rdi_dump up-to-speed --- src/metagen/metagen_main.c | 25 +++ src/rdi_dump/rdi_dump.c | 134 +++++++------- src/rdi_dump/rdi_dump.h | 12 +- src/rdi_format/lib/rdi_format.c | 14 +- src/rdi_format/lib/rdi_format.h | 228 +++++++++++++++++++++++- src/rdi_format/rdi_format.mdesk | 103 +++++++++-- src/rdi_format_local/rdi_format_local.c | 2 +- src/rdi_format_local/rdi_format_local.h | 2 +- 8 files changed, 428 insertions(+), 92 deletions(-) diff --git a/src/metagen/metagen_main.c b/src/metagen/metagen_main.c index 2a75ca63..1f3f5401 100644 --- a/src/metagen/metagen_main.c +++ b/src/metagen/metagen_main.c @@ -264,6 +264,31 @@ int main(int argument_count, char **arguments) } } + ////////////////////////////// + //- rjf: generate xlists + // + 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("xlist"), 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 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->enums, "#define %S \\\n", node->string); + 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->enums, "X(%S)\\\n", escaped); + } + str8_list_push(mg_arena, &layer->enums, str8_lit("\n")); + } + } + } + ////////////////////////////// //- rjf: generate structs // diff --git a/src/rdi_dump/rdi_dump.c b/src/rdi_dump/rdi_dump.c index b847c4be..efa88363 100644 --- a/src/rdi_dump/rdi_dump.c +++ b/src/rdi_dump/rdi_dump.c @@ -5,77 +5,87 @@ //~ rjf: RDI Enum -> String Functions internal String8 -rdi_string_from_data_section_tag(RDI_DataSectionTag tag){ - String8 result = {0}; - switch (tag){ -#define X(N,C) case C: result = str8_lit(#N); break; -#define Y(N) - RDI_DataSectionTagXList(X,Y) -#undef X -#undef Y - } - return(result); -} - -internal String8 -rdi_string_from_arch(RDI_Arch arch){ - String8 result = {0}; - switch (arch){ - default: result = str8_lit(""); break; - case RDI_Arch_X86: result = str8_lit("x86"); break; - case RDI_Arch_X64: result = str8_lit("x64"); break; - } - return(result); -} - -internal String8 -rdi_string_from_language(RDI_Language language){ - String8 result = {0}; - switch (language){ -#define X(name,code) case code: result = str8_lit(#name); break; - RDI_LanguageXList(X) +rdi_string_from_data_section_tag(RDI_DataSectionTag v) +{ + String8 result = str8_lit(""); + switch(v) + { + default:{}break; +#define X(name) case RDI_DataSectionTag_##name:{result = str8_lit(#name);}break; + RDI_DataSectionTag_XList #undef X } - return(result); + return result; } internal String8 -rdi_string_from_type_kind(RDI_TypeKind type_kind){ - String8 result = {0}; - switch (type_kind){ - default: result = str8_lit(""); break; -#define X(name,code) case code: result = str8_lit(#name); break; -#define XZ(name,code,size) X(name,code) -#define Y(a,n) - RDI_TypeKindXList(X,XZ,Y) -#undef X -#undef XZ -#undef Y - } - return(result); -} - -internal String8 -rdi_string_from_member_kind(RDI_MemberKind member_kind){ - String8 result = {0}; - switch (member_kind){ - default: result = str8_lit(""); break; -#define X(N,C) case C: result = str8_lit(#N); break; - RDI_MemberKindXList(X) +rdi_string_from_arch(RDI_Arch v) +{ + String8 result = str8_lit(""); + switch(v) + { + default:{}break; +#define X(name) case RDI_Arch_##name:{result = str8_lit(#name);}break; + RDI_Arch_XList #undef X } - return(result); + return result; } internal String8 -rdi_string_from_local_kind(RDI_LocalKind local_kind){ - String8 result = {0}; - switch (local_kind){ - default: result = str8_lit(""); break; - case RDI_LocalKind_Parameter: result = str8_lit("Parameter"); break; - case RDI_LocalKind_Variable: result = str8_lit("Variable"); break; +rdi_string_from_language(RDI_Language v) +{ + String8 result = str8_lit(""); + switch(v) + { + default:{}break; +#define X(name) case RDI_Language_##name:{result = str8_lit(#name);}break; + RDI_Language_XList +#undef X } - return(result); + return result; +} + +internal String8 +rdi_string_from_type_kind(RDI_TypeKind v) +{ + String8 result = str8_lit(""); + switch(v) + { + default:{}break; +#define X(name) case RDI_TypeKind_##name:{result = str8_lit(#name);}break; + RDI_TypeKind_XList +#undef X + } + return result; +} + +internal String8 +rdi_string_from_member_kind(RDI_MemberKind v) +{ + String8 result = str8_lit(""); + switch(v) + { + default:{}break; +#define X(name) case RDI_MemberKind_##name:{result = str8_lit(#name);}break; + RDI_MemberKind_XList +#undef X + } + return result; +} + +internal String8 +rdi_string_from_local_kind(RDI_LocalKind v) +{ + String8 result = str8_lit(""); + switch(v) + { + default:{}break; +#define X(name) case RDI_LocalKind_##name:{result = str8_lit(#name);}break; + RDI_LocalKind_XList +#undef X + } + return result; } //////////////////////////////// @@ -160,11 +170,11 @@ rdi_stringize_data_sections(Arena *arena, String8List *out, RDI_Parsed *parsed, internal void rdi_stringize_top_level_info(Arena *arena, String8List *out, RDI_Parsed *parsed, RDI_TopLevelInfo *tli, U32 indent_level){ - String8 arch_str = rdi_string_from_arch(tli->architecture); + String8 arch_str = rdi_string_from_arch(tli->arch); String8 exe_name = {0}; exe_name.str = rdi_string_from_idx(parsed, tli->exe_name_string_idx, &exe_name.size); - str8_list_pushf(arena, out, "%.*sarchitecture=%.*s\n", + str8_list_pushf(arena, out, "%.*sarch=%.*s\n", indent_level, rdi_stringize_spaces, str8_varg(arch_str)); str8_list_pushf(arena, out, "%.*sexe_name='%.*s'\n", indent_level, rdi_stringize_spaces, str8_varg(exe_name)); diff --git a/src/rdi_dump/rdi_dump.h b/src/rdi_dump/rdi_dump.h index 8af9fa62..69eb49d3 100644 --- a/src/rdi_dump/rdi_dump.h +++ b/src/rdi_dump/rdi_dump.h @@ -41,12 +41,12 @@ struct RDI_ScopeBundle //////////////////////////////// //~ rjf: RDI Enum -> String Functions -internal String8 rdi_string_from_data_section_tag(RDI_DataSectionTag tag); -internal String8 rdi_string_from_arch(RDI_Arch arch); -internal String8 rdi_string_from_language(RDI_Language language); -internal String8 rdi_string_from_type_kind(RDI_TypeKind type_kind); -internal String8 rdi_string_from_member_kind(RDI_MemberKind member_kind); -internal String8 rdi_string_from_local_kind(RDI_LocalKind local_kind); +internal String8 rdi_string_from_data_section_tag(RDI_DataSectionTag v); +internal String8 rdi_string_from_arch(RDI_Arch v); +internal String8 rdi_string_from_language(RDI_Language v); +internal String8 rdi_string_from_type_kind(RDI_TypeKind v); +internal String8 rdi_string_from_member_kind(RDI_MemberKind v); +internal String8 rdi_string_from_local_kind(RDI_LocalKind v); //////////////////////////////// //~ rjf: RDI Flags -> String Functions diff --git a/src/rdi_format/lib/rdi_format.c b/src/rdi_format/lib/rdi_format.c index b2a5be27..545c2c7a 100644 --- a/src/rdi_format/lib/rdi_format.c +++ b/src/rdi_format/lib/rdi_format.c @@ -155,13 +155,6 @@ rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup return k; } -RDI_PROC RDI_U8 * -rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out) -{ - *size_out = rdi_eval_conversion_kind_message_string_table[kind].size; - return rdi_eval_conversion_kind_message_string_table[kind].str; -} - RDI_PROC RDI_S32 rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group) { @@ -193,4 +186,11 @@ rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group) return result; } +RDI_PROC RDI_U8 * +rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out) +{ + *size_out = rdi_eval_conversion_kind_message_string_table[kind].size; + return rdi_eval_conversion_kind_message_string_table[kind].str; +} + #endif // RDI_FORMAT_C diff --git a/src/rdi_format/lib/rdi_format.h b/src/rdi_format/lib/rdi_format.h index ab14b260..71e28f83 100644 --- a/src/rdi_format/lib/rdi_format.h +++ b/src/rdi_format/lib/rdi_format.h @@ -80,7 +80,6 @@ RDI_DataSectionTag_LocationData = 0x0017, RDI_DataSectionTag_NameMaps = 0x0018, RDI_DataSectionTag_PRIMARY_COUNT = 0x0019, RDI_DataSectionTag_SECONDARY = 0x80000000, -RDI_DataSectionTag_SKIP = RDI_DataSectionTag_SECONDARY|0x0000, RDI_DataSectionTag_LineInfoVoffs = RDI_DataSectionTag_SECONDARY|0x0001, RDI_DataSectionTag_LineInfoData = RDI_DataSectionTag_SECONDARY|0x0002, RDI_DataSectionTag_LineInfoColumns = RDI_DataSectionTag_SECONDARY|0x0003, @@ -486,6 +485,229 @@ RDI_NameMapKind_NormalSourcePaths = 6, RDI_NameMapKind_COUNT = 7, } RDI_NameMapKindEnum; +#define RDI_DataSectionTag_XList \ +X(NULL)\ +X(TopLevelInfo)\ +X(StringData)\ +X(StringTable)\ +X(IndexRuns)\ +X(BinarySections)\ +X(FilePathNodes)\ +X(SourceFiles)\ +X(Units)\ +X(UnitVmap)\ +X(TypeNodes)\ +X(UDTs)\ +X(Members)\ +X(EnumMembers)\ +X(GlobalVariables)\ +X(GlobalVmap)\ +X(ThreadVariables)\ +X(Procedures)\ +X(Scopes)\ +X(ScopeVoffData)\ +X(ScopeVmap)\ +X(Locals)\ +X(LocationBlocks)\ +X(LocationData)\ +X(NameMaps)\ +X(PRIMARY_COUNT)\ +X(SECONDARY)\ +X(LineInfoVoffs)\ +X(LineInfoData)\ +X(LineInfoColumns)\ +X(LineMapNumbers)\ +X(LineMapRanges)\ +X(LineMapVoffs)\ +X(NameMapBuckets)\ +X(NameMapNodes)\ + +#define RDI_DataSectionEncoding_XList \ +X(Unpacked)\ +X(LZB)\ + +#define RDI_Arch_XList \ +X(NULL)\ +X(X86)\ +X(X64)\ + +#define RDI_BinarySectionFlags_XList \ +X(NULL)\ +X(X86)\ +X(X64)\ + +#define RDI_Language_XList \ +X(NULL)\ +X(C)\ +X(CPlusPlus)\ +X(COUNT)\ + +#define RDI_TypeKind_XList \ +X(NULL)\ +X(Void)\ +X(Handle)\ +X(Char8)\ +X(Char16)\ +X(Char32)\ +X(UChar8)\ +X(UChar16)\ +X(UChar32)\ +X(U8)\ +X(U16)\ +X(U32)\ +X(U64)\ +X(U128)\ +X(U256)\ +X(U512)\ +X(S8)\ +X(S16)\ +X(S32)\ +X(S64)\ +X(S128)\ +X(S256)\ +X(S512)\ +X(Bool)\ +X(F16)\ +X(F32)\ +X(F32PP)\ +X(F48)\ +X(F64)\ +X(F80)\ +X(F128)\ +X(ComplexF32)\ +X(ComplexF64)\ +X(ComplexF80)\ +X(ComplexF128)\ +X(Modifier)\ +X(Ptr)\ +X(LRef)\ +X(RRef)\ +X(Array)\ +X(Function)\ +X(Method)\ +X(MemberPtr)\ +X(Struct)\ +X(Class)\ +X(Union)\ +X(Enum)\ +X(Alias)\ +X(IncompleteStruct)\ +X(IncompleteUnion)\ +X(IncompleteClass)\ +X(IncompleteEnum)\ +X(Bitfield)\ +X(Variadic)\ + +#define RDI_TypeModifierFlags_XList \ +X(Const)\ +X(Volatile)\ + +#define RDI_UDTFlag_XList \ +X(EnumMembers)\ + +#define RDI_MemberKind_XList \ +X(NULL)\ +X(DataField)\ +X(StaticData)\ +X(Method)\ +X(StaticMethod)\ +X(VirtualMethod)\ +X(VTablePtr)\ +X(Base)\ +X(VirtualBase)\ +X(NestedType)\ + +#define RDI_LinkFlags_XList \ +X(External)\ +X(TypeScoped)\ +X(ProcScoped)\ + +#define RDI_LocalKind_XList \ +X(NULL)\ +X(Parameter)\ +X(Variable)\ + +#define RDI_LocationKind_XList \ +X(NULL)\ +X(AddrBytecodeStream)\ +X(ValBytecodeStream)\ +X(AddrRegPlusU16)\ +X(AddrAddrRegPlusU16)\ +X(ValReg)\ + +#define RDI_EvalOp_XList \ +X(Stop)\ +X(Noop)\ +X(Cond)\ +X(Skip)\ +X(MemRead)\ +X(RegRead)\ +X(RegReadDyn)\ +X(FrameOff)\ +X(ModuleOff)\ +X(TLSOff)\ +X(ObjectOff)\ +X(CFA)\ +X(ConstU8)\ +X(ConstU16)\ +X(ConstU32)\ +X(ConstU64)\ +X(Abs)\ +X(Neg)\ +X(Add)\ +X(Sub)\ +X(Mul)\ +X(Div)\ +X(Mod)\ +X(LShift)\ +X(RShift)\ +X(BitAnd)\ +X(BitOr)\ +X(BitXor)\ +X(BitNot)\ +X(LogAnd)\ +X(LogOr)\ +X(LogNot)\ +X(EqEq)\ +X(NtEq)\ +X(LsEq)\ +X(GrEq)\ +X(Less)\ +X(Grtr)\ +X(Trunc)\ +X(TruncSigned)\ +X(Convert)\ +X(Pick)\ +X(Pop)\ +X(Insert)\ +X(COUNT)\ + +#define RDI_EvalTypeGroup_XList \ +X(Other)\ +X(U)\ +X(S)\ +X(F32)\ +X(F64)\ +X(COUNT)\ + +#define RDI_EvalConversionKind_XList \ +X(Noop)\ +X(Legal)\ +X(OtherToOther)\ +X(ToOther)\ +X(FromOther)\ +X(COUNT)\ + +#define RDI_NameMapKind_XList \ +X(NULL)\ +X(GlobalVariables)\ +X(ThreadVariables)\ +X(Procedures)\ +X(Types)\ +X(LinkNameProcedures)\ +X(NormalSourcePaths)\ +X(COUNT)\ + #define RDI_EVAL_CTRLBITS(decodeN,popN,pushN) ((decodeN) | ((popN) << 4) | ((pushN) << 6)) #define RDI_DECODEN_FROM_CTRLBITS(ctrlbits) ((ctrlbits) & 0xf) #define RDI_POPN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 4) & 0x3) @@ -779,8 +1001,8 @@ RDI_PROC RDI_U64 rdi_hash(RDI_U8 *ptr, RDI_U64 size); RDI_PROC RDI_U32 rdi_size_from_basic_type_kind(RDI_TypeKind kind); RDI_PROC RDI_U32 rdi_addr_size_from_arch(RDI_Arch arch); RDI_PROC RDI_EvalConversionKind rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out); -RDI_PROC RDI_U8 *rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out); -RDI_PROC RDI_S32 rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group); +RDI_PROC RDI_S32 rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group); +RDI_PROC RDI_U8 *rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out); extern RDI_U8 rdi_eval_op_ctrlbits_table[45]; diff --git a/src/rdi_format/rdi_format.mdesk b/src/rdi_format/rdi_format.mdesk index 8a560b4f..ed078778 100644 --- a/src/rdi_format/rdi_format.mdesk +++ b/src/rdi_format/rdi_format.mdesk @@ -137,7 +137,6 @@ RDI_DataSectionTable: {NameMaps 0x0018 ""} {PRIMARY_COUNT 0x0019 ""} {SECONDARY 0x80000000 ""} - {SKIP `RDI_DataSectionTag_SECONDARY|0x0000` ""} {LineInfoVoffs `RDI_DataSectionTag_SECONDARY|0x0001` ""} {LineInfoData `RDI_DataSectionTag_SECONDARY|0x0002` ""} {LineInfoColumns `RDI_DataSectionTag_SECONDARY|0x0003` ""} @@ -175,6 +174,16 @@ RDI_DataSectionMemberTable: @expand(RDI_DataSectionEncodingTable a) `$(a.name .. =>10) = $(a.value)`, } +@xlist RDI_DataSectionTag_XList: +{ + @expand(RDI_DataSectionTable a) `$(a.name)`; +} + +@xlist RDI_DataSectionEncoding_XList: +{ + @expand(RDI_DataSectionEncodingTable a) `$(a.name)`; +} + @struct RDI_DataSection: { @expand(RDI_DataSectionMemberTable a) `$(a.type) $(a.name)` @@ -359,6 +368,11 @@ RDI_RegCodeX64Table: @expand(RDI_ArchTable a) `$(a.name .. =>10) = $(a.value)` } +@xlist RDI_Arch_XList: +{ + @expand(RDI_ArchTable a) `$(a.name)`; +} + @enum(RDI_U8) RDI_RegCode: {nil} @enum(RDI_U8) RDI_RegCodeX86: @@ -415,6 +429,11 @@ RDI_BinarySectionMemberTable: @expand(RDI_BinarySectionFlagTable a) `$(a.name .. =>10) = $(a.value)`; } +@xlist RDI_BinarySectionFlags_XList: +{ + @expand(RDI_ArchTable a) `$(a.name)`; +} + @struct RDI_BinarySection: { @expand(RDI_BinarySectionMemberTable a) `$(a.type) $(a.name)` @@ -529,6 +548,11 @@ RDI_LanguageTable: @expand(RDI_LanguageTable a) `$(a.name .. =>10) = $(a.value)` } +@xlist RDI_Language_XList: +{ + @expand(RDI_LanguageTable a) `$(a.name)`; +} + //////////////////////////////// //~ rjf: Type Info Tables @@ -673,6 +697,16 @@ RDI_EnumMemberTable: @expand(RDI_TypeModifierFlagTable a) `$(a.name .. =>20) = $(a.value)`, } +@xlist RDI_TypeKind_XList: +{ + @expand(RDI_TypeKindTable a) `$(a.name)`; +} + +@xlist RDI_TypeModifierFlags_XList: +{ + @expand(RDI_TypeModifierFlagTable a) `$(a.name)`; +} + @struct RDI_TypeNode: { @expand(RDI_TypeNodeMemberTable a) `$(a.type_lhs) $(a.name)$(a.type_rhs)` @@ -722,6 +756,11 @@ RDI_EnumMemberTable: @expand(RDI_UDTFlagTable a) `$(a.name .. =>20) = $(a.value)` } +@xlist RDI_UDTFlag_XList: +{ + @expand(RDI_UDTFlagTable a) `$(a.name)`; +} + @struct RDI_UDT: { @expand(RDI_UDTMemberTable a) `$(a.type) $(a.name)` @@ -732,6 +771,11 @@ RDI_EnumMemberTable: @expand(RDI_MemberKindTable a) `$(a.name .. =>25) = $(a.value)` } +@xlist RDI_MemberKind_XList: +{ + @expand(RDI_MemberKindTable a) `$(a.name)`; +} + @struct RDI_Member: { @expand(RDI_MemberMemberTable a) `$(a.type) $(a.name)` @@ -874,6 +918,21 @@ RDI_LocationRegMemberTable: @expand(RDI_LocationKindTable a) `$(a.name .. =>20) = $(a.value)` } +@xlist RDI_LinkFlags_XList: +{ + @expand(RDI_LinkFlagTable a) `$(a.name)`; +} + +@xlist RDI_LocalKind_XList: +{ + @expand(RDI_LocalKindTable a) `$(a.name)`; +} + +@xlist RDI_LocationKind_XList: +{ + @expand(RDI_LocationKindTable a) `$(a.name)`; +} + @struct RDI_GlobalVariable: { @expand(RDI_GlobalVariableMemberTable a) `$(a.type) $(a.name)` @@ -1011,6 +1070,21 @@ RDI_EvalConversionKindTable: @expand(RDI_EvalConversionKindTable a) `$(a.name .. =>20) = $(a.value)` } +@xlist RDI_EvalOp_XList: +{ + @expand(RDI_EvalOpTable a) `$(a.name)`; +} + +@xlist RDI_EvalTypeGroup_XList: +{ + @expand(RDI_EvalTypeGroupTable a) `$(a.name)`; +} + +@xlist RDI_EvalConversionKind_XList: +{ + @expand(RDI_EvalConversionKindTable a) `$(a.name)`; +} + @gen(enums) ``` #define RDI_EVAL_CTRLBITS(decodeN,popN,pushN) ((decodeN) | ((popN) << 4) | ((pushN) << 6)) @@ -1083,6 +1157,11 @@ RDI_NameMapNodeMemberTable: @expand(RDI_NameMapKindTable a) `$(a.name .. =>20) = $(a.value)` } +@xlist RDI_NameMapKind_XList: +{ + @expand(RDI_NameMapKindTable a) `$(a.name)`; +} + @struct RDI_NameMap: { @expand(RDI_NameMapMemberTable a) `$(a.type) $(a.val)` @@ -1107,8 +1186,8 @@ RDI_PROC RDI_U64 rdi_hash(RDI_U8 *ptr, RDI_U64 size); RDI_PROC RDI_U32 rdi_size_from_basic_type_kind(RDI_TypeKind kind); RDI_PROC RDI_U32 rdi_addr_size_from_arch(RDI_Arch arch); RDI_PROC RDI_EvalConversionKind rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out); -RDI_PROC RDI_U8 *rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out); RDI_PROC RDI_S32 rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group); +RDI_PROC RDI_U8 *rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out); ``` @gen(functions) @c_file @@ -1168,16 +1247,6 @@ rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup } ``` -@gen(functions) @c_file -``` -RDI_PROC RDI_U8 * -rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out) -{ - *size_out = rdi_eval_conversion_kind_message_string_table[kind].size; - return rdi_eval_conversion_kind_message_string_table[kind].str; -} -``` - @gen(functions) @c_file ``` RDI_PROC RDI_S32 @@ -1211,3 +1280,13 @@ rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group) return result; } ``` + +@gen(functions) @c_file +``` +RDI_PROC RDI_U8 * +rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out) +{ + *size_out = rdi_eval_conversion_kind_message_string_table[kind].size; + return rdi_eval_conversion_kind_message_string_table[kind].str; +} +``` diff --git a/src/rdi_format_local/rdi_format_local.c b/src/rdi_format_local/rdi_format_local.c index e860c025..5b6f41be 100644 --- a/src/rdi_format_local/rdi_format_local.c +++ b/src/rdi_format_local/rdi_format_local.c @@ -2,7 +2,7 @@ // Licensed under the MIT license (https://opensource.org/license/mit/) //#include "lib_rdi_format/rdi_format.c" -#include "rdi_format/generated/rdi_format.c" +#include "rdi_format/lib/rdi_format.c" #include "lib_rdi_format/rdi_format_parse.c" internal void diff --git a/src/rdi_format_local/rdi_format_local.h b/src/rdi_format_local/rdi_format_local.h index 3042e452..e89b41db 100644 --- a/src/rdi_format_local/rdi_format_local.h +++ b/src/rdi_format_local/rdi_format_local.h @@ -5,7 +5,7 @@ #define RDI_FORMAT_LOCAL_H //#include "lib_rdi_format/rdi_format.h" -#include "rdi_format/generated/rdi_format.h" +#include "rdi_format/lib/rdi_format.h" #include "lib_rdi_format/rdi_format_parse.h" internal void rdi_decompress_parsed(U8 *decompressed_data, U64 decompressed_size, RDI_Parsed *og_rdi); From a8b02f9791a3b13fbe5f6ed3c920f699ef8f2c88 Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Sat, 1 Jun 2024 11:30:51 -0700 Subject: [PATCH 15/21] clean up metaprogram multiline string line endings; fix rdi_from_pdb build --- src/metagen/metagen.c | 2 +- .../rdi_breakpad_from_pdb_main.c | 5 +- src/rdi_format/lib/rdi_format.c | 392 ++-- src/rdi_format/lib/rdi_format.h | 2018 ++++++++--------- src/rdi_from_pdb/rdi_from_pdb_main.c | 4 +- 5 files changed, 1210 insertions(+), 1211 deletions(-) diff --git a/src/metagen/metagen.c b/src/metagen/metagen.c index dae1bdbf..51d9f06c 100644 --- a/src/metagen/metagen.c +++ b/src/metagen/metagen.c @@ -137,7 +137,7 @@ mg_escaped_from_str8(Arena *arena, String8 string) U64 start = 0; for(U64 idx = 0; idx <= string.size; idx += 1) { - if(idx == string.size || string.str[idx] == '\\') + if(idx == string.size || string.str[idx] == '\\' || string.str[idx] == '\r') { String8 str = str8_substr(string, r1u64(start, idx)); if(str.size != 0) diff --git a/src/rdi_breakpad_from_pdb/rdi_breakpad_from_pdb_main.c b/src/rdi_breakpad_from_pdb/rdi_breakpad_from_pdb_main.c index 134c7048..bc35b289 100644 --- a/src/rdi_breakpad_from_pdb/rdi_breakpad_from_pdb_main.c +++ b/src/rdi_breakpad_from_pdb/rdi_breakpad_from_pdb_main.c @@ -12,14 +12,13 @@ //~ rjf: Includes //- rjf: [lib] -#include "lib_rdi_format/rdi_format.h" +#include "rdi_format/lib/rdi_format.h" +#include "rdi_format/lib/rdi_format.c" #include "lib_rdi_format/rdi_format_parse.h" -#include "lib_rdi_format/rdi_format.c" #include "lib_rdi_format/rdi_format_parse.c" #include "third_party/rad_lzb_simple/rad_lzb_simple.h" #include "third_party/rad_lzb_simple/rad_lzb_simple.c" - //- rjf: [h] #include "base/base_inc.h" #include "os/os_inc.h" diff --git a/src/rdi_format/lib/rdi_format.c b/src/rdi_format/lib/rdi_format.c index 545c2c7a..ef9eea1b 100644 --- a/src/rdi_format/lib/rdi_format.c +++ b/src/rdi_format/lib/rdi_format.c @@ -1,196 +1,196 @@ -// Copyright (c) 2024 Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//////////////////////////////////////////////////////////////// -//~ RAD Debug Info, (R)AD(D)BG(I) Format Library -// -// Defines standard RDI debug information format types and -// functions. - -#ifndef RDI_FORMAT_C -#define RDI_FORMAT_C - -RDI_U8 rdi_eval_op_ctrlbits_table[45] = -{ -RDI_EVAL_CTRLBITS(0, 0, 0), -RDI_EVAL_CTRLBITS(0, 0, 0), -RDI_EVAL_CTRLBITS(1, 1, 0), -RDI_EVAL_CTRLBITS(1, 0, 0), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(4, 0, 1), -RDI_EVAL_CTRLBITS(0, 1, 1), -RDI_EVAL_CTRLBITS(1, 0, 1), -RDI_EVAL_CTRLBITS(4, 0, 1), -RDI_EVAL_CTRLBITS(4, 0, 1), -RDI_EVAL_CTRLBITS(0, 0, 0), -RDI_EVAL_CTRLBITS(0, 0, 0), -RDI_EVAL_CTRLBITS(1, 0, 1), -RDI_EVAL_CTRLBITS(2, 0, 1), -RDI_EVAL_CTRLBITS(4, 0, 1), -RDI_EVAL_CTRLBITS(8, 0, 1), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(2, 1, 1), -RDI_EVAL_CTRLBITS(1, 0, 1), -RDI_EVAL_CTRLBITS(0, 1, 0), -RDI_EVAL_CTRLBITS(1, 0, 0), -RDI_EVAL_CTRLBITS(0, 0, 0), -}; - -struct {RDI_EvalConversionKind dst_typegroups[RDI_EvalTypeGroup_COUNT];} rdi_eval_typegroup_conversion_kind_matrix[6] = -{ -{{RDI_EvalConversionKind_OtherToOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther}}, -{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal}}, -{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal}}, -{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal}}, -{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Noop}}, -{{RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop}}, -}; - -struct {RDI_U8 *str; RDI_U64 size;} rdi_eval_conversion_kind_message_string_table[6] = -{ -{(RDI_U8 *)"Other", sizeof("Other")}, -{(RDI_U8 *)"U", sizeof("U")}, -{(RDI_U8 *)"S", sizeof("S")}, -{(RDI_U8 *)"F32", sizeof("F32")}, -{(RDI_U8 *)"F64", sizeof("F64")}, -{(RDI_U8 *)"COUNT", sizeof("COUNT")}, -}; - -RDI_PROC RDI_U64 -rdi_hash(RDI_U8 *ptr, RDI_U64 size) -{ - RDI_U64 result = 5381; - RDI_U8 *opl = ptr + size; - for(;ptr < opl; ptr += 1) - { - result = ((result << 5) + result) + *ptr; - } - return result; -} - -RDI_PROC RDI_U32 -rdi_size_from_basic_type_kind(RDI_TypeKind kind) -{ -RDI_U32 result = 0; -switch(kind) -{ -default:{}break; -case RDI_TypeKind_Handle:{result = 0xFFFFFFFF;}break; -case RDI_TypeKind_Char8:{result = 1;}break; -case RDI_TypeKind_Char16:{result = 2;}break; -case RDI_TypeKind_Char32:{result = 4;}break; -case RDI_TypeKind_UChar8:{result = 1;}break; -case RDI_TypeKind_UChar16:{result = 2;}break; -case RDI_TypeKind_UChar32:{result = 4;}break; -case RDI_TypeKind_U8:{result = 1;}break; -case RDI_TypeKind_U16:{result = 2;}break; -case RDI_TypeKind_U32:{result = 4;}break; -case RDI_TypeKind_U64:{result = 8;}break; -case RDI_TypeKind_U128:{result = 16;}break; -case RDI_TypeKind_U256:{result = 32;}break; -case RDI_TypeKind_U512:{result = 64;}break; -case RDI_TypeKind_S8:{result = 1;}break; -case RDI_TypeKind_S16:{result = 2;}break; -case RDI_TypeKind_S32:{result = 4;}break; -case RDI_TypeKind_S64:{result = 8;}break; -case RDI_TypeKind_S128:{result = 16;}break; -case RDI_TypeKind_S256:{result = 32;}break; -case RDI_TypeKind_S512:{result = 64;}break; -case RDI_TypeKind_Bool:{result = 1;}break; -case RDI_TypeKind_F16:{result = 2;}break; -case RDI_TypeKind_F32:{result = 4;}break; -case RDI_TypeKind_F32PP:{result = 4;}break; -case RDI_TypeKind_F48:{result = 6;}break; -case RDI_TypeKind_F64:{result = 8;}break; -case RDI_TypeKind_F80:{result = 10;}break; -case RDI_TypeKind_F128:{result = 16;}break; -case RDI_TypeKind_ComplexF32:{result = 8;}break; -case RDI_TypeKind_ComplexF64:{result = 16;}break; -case RDI_TypeKind_ComplexF80:{result = 20;}break; -case RDI_TypeKind_ComplexF128:{result = 32;}break; -} -return result; -} - -RDI_PROC RDI_U32 -rdi_addr_size_from_arch(RDI_Arch arch) -{ -RDI_U32 result = 0; -switch(arch) -{ -default:{}break; -case RDI_Arch_X86:{result = 4;}break; -case RDI_Arch_X64:{result = 8;}break; -} -return result; -} - -RDI_PROC RDI_EvalConversionKind -rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out) -{ - RDI_EvalConversionKind k = rdi_eval_typegroup_conversion_kind_matrix[in].dst_typegroups[out]; - return k; -} - -RDI_PROC RDI_S32 -rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group) -{ - RDI_S32 result = 0; - switch(op) - { - case RDI_EvalOp_Neg: case RDI_EvalOp_Add: case RDI_EvalOp_Sub: - case RDI_EvalOp_Mul: case RDI_EvalOp_Div: - case RDI_EvalOp_EqEq:case RDI_EvalOp_NtEq: - case RDI_EvalOp_LsEq:case RDI_EvalOp_GrEq: - case RDI_EvalOp_Less:case RDI_EvalOp_Grtr: - { - if(group != RDI_EvalTypeGroup_Other) - { - result = 1; - } - }break; - case RDI_EvalOp_Mod:case RDI_EvalOp_LShift:case RDI_EvalOp_RShift: - case RDI_EvalOp_BitNot:case RDI_EvalOp_BitAnd:case RDI_EvalOp_BitXor: - case RDI_EvalOp_BitOr:case RDI_EvalOp_LogNot:case RDI_EvalOp_LogAnd: - case RDI_EvalOp_LogOr: - { - if(group == RDI_EvalTypeGroup_S || group == RDI_EvalTypeGroup_U) - { - result = 1; - } - }break; - } - return result; -} - -RDI_PROC RDI_U8 * -rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out) -{ - *size_out = rdi_eval_conversion_kind_message_string_table[kind].size; - return rdi_eval_conversion_kind_message_string_table[kind].str; -} - -#endif // RDI_FORMAT_C +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//////////////////////////////////////////////////////////////// +//~ RAD Debug Info, (R)AD(D)BG(I) Format Library +// +// Defines standard RDI debug information format types and +// functions. + +#ifndef RDI_FORMAT_C +#define RDI_FORMAT_C + +RDI_U8 rdi_eval_op_ctrlbits_table[45] = +{ +RDI_EVAL_CTRLBITS(0, 0, 0), +RDI_EVAL_CTRLBITS(0, 0, 0), +RDI_EVAL_CTRLBITS(1, 1, 0), +RDI_EVAL_CTRLBITS(1, 0, 0), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(4, 0, 1), +RDI_EVAL_CTRLBITS(0, 1, 1), +RDI_EVAL_CTRLBITS(1, 0, 1), +RDI_EVAL_CTRLBITS(4, 0, 1), +RDI_EVAL_CTRLBITS(4, 0, 1), +RDI_EVAL_CTRLBITS(0, 0, 0), +RDI_EVAL_CTRLBITS(0, 0, 0), +RDI_EVAL_CTRLBITS(1, 0, 1), +RDI_EVAL_CTRLBITS(2, 0, 1), +RDI_EVAL_CTRLBITS(4, 0, 1), +RDI_EVAL_CTRLBITS(8, 0, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(2, 1, 1), +RDI_EVAL_CTRLBITS(1, 0, 1), +RDI_EVAL_CTRLBITS(0, 1, 0), +RDI_EVAL_CTRLBITS(1, 0, 0), +RDI_EVAL_CTRLBITS(0, 0, 0), +}; + +struct {RDI_EvalConversionKind dst_typegroups[RDI_EvalTypeGroup_COUNT];} rdi_eval_typegroup_conversion_kind_matrix[6] = +{ +{{RDI_EvalConversionKind_OtherToOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther}}, +{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal}}, +{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal}}, +{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal}}, +{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Noop}}, +{{RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop}}, +}; + +struct {RDI_U8 *str; RDI_U64 size;} rdi_eval_conversion_kind_message_string_table[6] = +{ +{(RDI_U8 *)"Other", sizeof("Other")}, +{(RDI_U8 *)"U", sizeof("U")}, +{(RDI_U8 *)"S", sizeof("S")}, +{(RDI_U8 *)"F32", sizeof("F32")}, +{(RDI_U8 *)"F64", sizeof("F64")}, +{(RDI_U8 *)"COUNT", sizeof("COUNT")}, +}; + +RDI_PROC RDI_U64 +rdi_hash(RDI_U8 *ptr, RDI_U64 size) +{ + RDI_U64 result = 5381; + RDI_U8 *opl = ptr + size; + for(;ptr < opl; ptr += 1) + { + result = ((result << 5) + result) + *ptr; + } + return result; +} + +RDI_PROC RDI_U32 +rdi_size_from_basic_type_kind(RDI_TypeKind kind) +{ +RDI_U32 result = 0; +switch(kind) +{ +default:{}break; +case RDI_TypeKind_Handle:{result = 0xFFFFFFFF;}break; +case RDI_TypeKind_Char8:{result = 1;}break; +case RDI_TypeKind_Char16:{result = 2;}break; +case RDI_TypeKind_Char32:{result = 4;}break; +case RDI_TypeKind_UChar8:{result = 1;}break; +case RDI_TypeKind_UChar16:{result = 2;}break; +case RDI_TypeKind_UChar32:{result = 4;}break; +case RDI_TypeKind_U8:{result = 1;}break; +case RDI_TypeKind_U16:{result = 2;}break; +case RDI_TypeKind_U32:{result = 4;}break; +case RDI_TypeKind_U64:{result = 8;}break; +case RDI_TypeKind_U128:{result = 16;}break; +case RDI_TypeKind_U256:{result = 32;}break; +case RDI_TypeKind_U512:{result = 64;}break; +case RDI_TypeKind_S8:{result = 1;}break; +case RDI_TypeKind_S16:{result = 2;}break; +case RDI_TypeKind_S32:{result = 4;}break; +case RDI_TypeKind_S64:{result = 8;}break; +case RDI_TypeKind_S128:{result = 16;}break; +case RDI_TypeKind_S256:{result = 32;}break; +case RDI_TypeKind_S512:{result = 64;}break; +case RDI_TypeKind_Bool:{result = 1;}break; +case RDI_TypeKind_F16:{result = 2;}break; +case RDI_TypeKind_F32:{result = 4;}break; +case RDI_TypeKind_F32PP:{result = 4;}break; +case RDI_TypeKind_F48:{result = 6;}break; +case RDI_TypeKind_F64:{result = 8;}break; +case RDI_TypeKind_F80:{result = 10;}break; +case RDI_TypeKind_F128:{result = 16;}break; +case RDI_TypeKind_ComplexF32:{result = 8;}break; +case RDI_TypeKind_ComplexF64:{result = 16;}break; +case RDI_TypeKind_ComplexF80:{result = 20;}break; +case RDI_TypeKind_ComplexF128:{result = 32;}break; +} +return result; +} + +RDI_PROC RDI_U32 +rdi_addr_size_from_arch(RDI_Arch arch) +{ +RDI_U32 result = 0; +switch(arch) +{ +default:{}break; +case RDI_Arch_X86:{result = 4;}break; +case RDI_Arch_X64:{result = 8;}break; +} +return result; +} + +RDI_PROC RDI_EvalConversionKind +rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out) +{ + RDI_EvalConversionKind k = rdi_eval_typegroup_conversion_kind_matrix[in].dst_typegroups[out]; + return k; +} + +RDI_PROC RDI_S32 +rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group) +{ + RDI_S32 result = 0; + switch(op) + { + case RDI_EvalOp_Neg: case RDI_EvalOp_Add: case RDI_EvalOp_Sub: + case RDI_EvalOp_Mul: case RDI_EvalOp_Div: + case RDI_EvalOp_EqEq:case RDI_EvalOp_NtEq: + case RDI_EvalOp_LsEq:case RDI_EvalOp_GrEq: + case RDI_EvalOp_Less:case RDI_EvalOp_Grtr: + { + if(group != RDI_EvalTypeGroup_Other) + { + result = 1; + } + }break; + case RDI_EvalOp_Mod:case RDI_EvalOp_LShift:case RDI_EvalOp_RShift: + case RDI_EvalOp_BitNot:case RDI_EvalOp_BitAnd:case RDI_EvalOp_BitXor: + case RDI_EvalOp_BitOr:case RDI_EvalOp_LogNot:case RDI_EvalOp_LogAnd: + case RDI_EvalOp_LogOr: + { + if(group == RDI_EvalTypeGroup_S || group == RDI_EvalTypeGroup_U) + { + result = 1; + } + }break; + } + return result; +} + +RDI_PROC RDI_U8 * +rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out) +{ + *size_out = rdi_eval_conversion_kind_message_string_table[kind].size; + return rdi_eval_conversion_kind_message_string_table[kind].str; +} + +#endif // RDI_FORMAT_C diff --git a/src/rdi_format/lib/rdi_format.h b/src/rdi_format/lib/rdi_format.h index 71e28f83..ddd1cf7e 100644 --- a/src/rdi_format/lib/rdi_format.h +++ b/src/rdi_format/lib/rdi_format.h @@ -1,1009 +1,1009 @@ -// Copyright (c) 2024 Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//////////////////////////////////////////////////////////////// -//~ RAD Debug Info, (R)AD(D)BG(I) Format Library -// -// Defines standard RDI debug information format types and -// functions. - -#ifndef RDI_FORMAT_H -#define RDI_FORMAT_H - -//////////////////////////////////////////////////////////////// -//~ Overridable Procedure Decoration - -#if !defined(RDI_PROC) -# define RDI_PROC static -#endif - -//////////////////////////////////////////////////////////////// -//~ Overridable Basic Integer Types - -#if !defined(RDI_U8) -# define RDI_U8 RDI_U8 -# define RDI_U16 RDI_U16 -# define RDI_U32 RDI_U32 -# define RDI_U64 RDI_U64 -# define RDI_S8 RDI_S8 -# define RDI_S16 RDI_S16 -# define RDI_S32 RDI_S32 -# define RDI_S64 RDI_S64 -#include -typedef uint8_t RDI_U8; -typedef uint16_t RDI_U16; -typedef uint32_t RDI_U32; -typedef uint64_t RDI_U64; -typedef int8_t RDI_S8; -typedef int16_t RDI_S16; -typedef int32_t RDI_S32; -typedef int64_t RDI_S64; -#endif - -//////////////////////////////////////////////////////////////// -//~ Format Constants - -// \"raddbg\0\0\" -#define RDI_MAGIC_CONSTANT 0x0000676264646172 -#define RDI_ENCODING_VERSION 1 - -//////////////////////////////////////////////////////////////// -//~ Format Types & Functions - -typedef RDI_U32 RDI_DataSectionTag; -typedef enum RDI_DataSectionTagEnum -{ -RDI_DataSectionTag_NULL = 0x0000, -RDI_DataSectionTag_TopLevelInfo = 0x0001, -RDI_DataSectionTag_StringData = 0x0002, -RDI_DataSectionTag_StringTable = 0x0003, -RDI_DataSectionTag_IndexRuns = 0x0004, -RDI_DataSectionTag_BinarySections = 0x0005, -RDI_DataSectionTag_FilePathNodes = 0x0006, -RDI_DataSectionTag_SourceFiles = 0x0007, -RDI_DataSectionTag_Units = 0x0008, -RDI_DataSectionTag_UnitVmap = 0x0009, -RDI_DataSectionTag_TypeNodes = 0x000A, -RDI_DataSectionTag_UDTs = 0x000B, -RDI_DataSectionTag_Members = 0x000C, -RDI_DataSectionTag_EnumMembers = 0x000D, -RDI_DataSectionTag_GlobalVariables = 0x000E, -RDI_DataSectionTag_GlobalVmap = 0x000F, -RDI_DataSectionTag_ThreadVariables = 0x0010, -RDI_DataSectionTag_Procedures = 0x0011, -RDI_DataSectionTag_Scopes = 0x0012, -RDI_DataSectionTag_ScopeVoffData = 0x0013, -RDI_DataSectionTag_ScopeVmap = 0x0014, -RDI_DataSectionTag_Locals = 0x0015, -RDI_DataSectionTag_LocationBlocks = 0x0016, -RDI_DataSectionTag_LocationData = 0x0017, -RDI_DataSectionTag_NameMaps = 0x0018, -RDI_DataSectionTag_PRIMARY_COUNT = 0x0019, -RDI_DataSectionTag_SECONDARY = 0x80000000, -RDI_DataSectionTag_LineInfoVoffs = RDI_DataSectionTag_SECONDARY|0x0001, -RDI_DataSectionTag_LineInfoData = RDI_DataSectionTag_SECONDARY|0x0002, -RDI_DataSectionTag_LineInfoColumns = RDI_DataSectionTag_SECONDARY|0x0003, -RDI_DataSectionTag_LineMapNumbers = RDI_DataSectionTag_SECONDARY|0x0004, -RDI_DataSectionTag_LineMapRanges = RDI_DataSectionTag_SECONDARY|0x0005, -RDI_DataSectionTag_LineMapVoffs = RDI_DataSectionTag_SECONDARY|0x0006, -RDI_DataSectionTag_NameMapBuckets = RDI_DataSectionTag_SECONDARY|0x0007, -RDI_DataSectionTag_NameMapNodes = RDI_DataSectionTag_SECONDARY|0x0008, -} RDI_DataSectionTagEnum; - -typedef RDI_U32 RDI_DataSectionEncoding; -typedef enum RDI_DataSectionEncodingEnum -{ -RDI_DataSectionEncoding_Unpacked = 0, -RDI_DataSectionEncoding_LZB = 1, -} RDI_DataSectionEncodingEnum; - -typedef RDI_U32 RDI_Arch; -typedef enum RDI_ArchEnum -{ -RDI_Arch_NULL = 0, -RDI_Arch_X86 = 1, -RDI_Arch_X64 = 2, -} RDI_ArchEnum; - -typedef RDI_U8 RDI_RegCode; -typedef enum RDI_RegCodeEnum -{ -RDI_RegCode_nil, -} RDI_RegCodeEnum; - -typedef RDI_U8 RDI_RegCodeX86; -typedef enum RDI_RegCodeX86Enum -{ -RDI_RegCodeX86_nil = 0, -RDI_RegCodeX86_eax = 1, -RDI_RegCodeX86_ecx = 2, -RDI_RegCodeX86_edx = 3, -RDI_RegCodeX86_ebx = 4, -RDI_RegCodeX86_esp = 5, -RDI_RegCodeX86_ebp = 6, -RDI_RegCodeX86_esi = 7, -RDI_RegCodeX86_edi = 8, -RDI_RegCodeX86_fsbase = 9, -RDI_RegCodeX86_gsbase = 10, -RDI_RegCodeX86_eflags = 11, -RDI_RegCodeX86_eip = 12, -RDI_RegCodeX86_dr0 = 13, -RDI_RegCodeX86_dr1 = 14, -RDI_RegCodeX86_dr2 = 15, -RDI_RegCodeX86_dr3 = 16, -RDI_RegCodeX86_dr4 = 17, -RDI_RegCodeX86_dr5 = 18, -RDI_RegCodeX86_dr6 = 19, -RDI_RegCodeX86_dr7 = 20, -RDI_RegCodeX86_fpr0 = 21, -RDI_RegCodeX86_fpr1 = 22, -RDI_RegCodeX86_fpr2 = 23, -RDI_RegCodeX86_fpr3 = 24, -RDI_RegCodeX86_fpr4 = 25, -RDI_RegCodeX86_fpr5 = 26, -RDI_RegCodeX86_fpr6 = 27, -RDI_RegCodeX86_fpr7 = 28, -RDI_RegCodeX86_st0 = 29, -RDI_RegCodeX86_st1 = 30, -RDI_RegCodeX86_st2 = 31, -RDI_RegCodeX86_st3 = 32, -RDI_RegCodeX86_st4 = 33, -RDI_RegCodeX86_st5 = 34, -RDI_RegCodeX86_st6 = 35, -RDI_RegCodeX86_st7 = 36, -RDI_RegCodeX86_fcw = 37, -RDI_RegCodeX86_fsw = 38, -RDI_RegCodeX86_ftw = 39, -RDI_RegCodeX86_fop = 40, -RDI_RegCodeX86_fcs = 41, -RDI_RegCodeX86_fds = 42, -RDI_RegCodeX86_fip = 43, -RDI_RegCodeX86_fdp = 44, -RDI_RegCodeX86_mxcsr = 45, -RDI_RegCodeX86_mxcsr_mask = 46, -RDI_RegCodeX86_ss = 47, -RDI_RegCodeX86_cs = 48, -RDI_RegCodeX86_ds = 49, -RDI_RegCodeX86_es = 50, -RDI_RegCodeX86_fs = 51, -RDI_RegCodeX86_gs = 52, -RDI_RegCodeX86_ymm0 = 53, -RDI_RegCodeX86_ymm1 = 54, -RDI_RegCodeX86_ymm2 = 55, -RDI_RegCodeX86_ymm3 = 56, -RDI_RegCodeX86_ymm4 = 57, -RDI_RegCodeX86_ymm5 = 58, -RDI_RegCodeX86_ymm6 = 59, -RDI_RegCodeX86_ymm7 = 60, -} RDI_RegCodeX86Enum; - -typedef RDI_U8 RDI_RegCodeX64; -typedef enum RDI_RegCodeX64Enum -{ -RDI_RegCodeX64_nil = 0, -RDI_RegCodeX64_rax = 1, -RDI_RegCodeX64_rcx = 2, -RDI_RegCodeX64_rdx = 3, -RDI_RegCodeX64_rbx = 4, -RDI_RegCodeX64_rsp = 5, -RDI_RegCodeX64_rbp = 6, -RDI_RegCodeX64_rsi = 7, -RDI_RegCodeX64_rdi = 8, -RDI_RegCodeX64_r8 = 9, -RDI_RegCodeX64_r9 = 10, -RDI_RegCodeX64_r10 = 11, -RDI_RegCodeX64_r11 = 12, -RDI_RegCodeX64_r12 = 13, -RDI_RegCodeX64_r13 = 14, -RDI_RegCodeX64_r14 = 15, -RDI_RegCodeX64_r15 = 16, -RDI_RegCodeX64_es = 17, -RDI_RegCodeX64_cs = 18, -RDI_RegCodeX64_ss = 19, -RDI_RegCodeX64_ds = 20, -RDI_RegCodeX64_fs = 21, -RDI_RegCodeX64_gs = 22, -RDI_RegCodeX64_rip = 23, -RDI_RegCodeX64_rflags = 24, -RDI_RegCodeX64_dr0 = 25, -RDI_RegCodeX64_dr1 = 26, -RDI_RegCodeX64_dr2 = 27, -RDI_RegCodeX64_dr3 = 28, -RDI_RegCodeX64_dr4 = 29, -RDI_RegCodeX64_dr5 = 30, -RDI_RegCodeX64_dr6 = 31, -RDI_RegCodeX64_dr7 = 32, -RDI_RegCodeX64_st0 = 33, -RDI_RegCodeX64_st1 = 34, -RDI_RegCodeX64_st2 = 35, -RDI_RegCodeX64_st3 = 36, -RDI_RegCodeX64_st4 = 37, -RDI_RegCodeX64_st5 = 38, -RDI_RegCodeX64_st6 = 39, -RDI_RegCodeX64_st7 = 40, -RDI_RegCodeX64_fpr0 = 41, -RDI_RegCodeX64_fpr1 = 42, -RDI_RegCodeX64_fpr2 = 43, -RDI_RegCodeX64_fpr3 = 44, -RDI_RegCodeX64_fpr4 = 45, -RDI_RegCodeX64_fpr5 = 46, -RDI_RegCodeX64_fpr6 = 47, -RDI_RegCodeX64_fpr7 = 48, -RDI_RegCodeX64_ymm0 = 49, -RDI_RegCodeX64_ymm1 = 50, -RDI_RegCodeX64_ymm2 = 51, -RDI_RegCodeX64_ymm3 = 52, -RDI_RegCodeX64_ymm4 = 53, -RDI_RegCodeX64_ymm5 = 54, -RDI_RegCodeX64_ymm6 = 55, -RDI_RegCodeX64_ymm7 = 56, -RDI_RegCodeX64_ymm8 = 57, -RDI_RegCodeX64_ymm9 = 58, -RDI_RegCodeX64_ymm10 = 59, -RDI_RegCodeX64_ymm11 = 60, -RDI_RegCodeX64_ymm12 = 61, -RDI_RegCodeX64_ymm13 = 62, -RDI_RegCodeX64_ymm14 = 63, -RDI_RegCodeX64_ymm15 = 64, -RDI_RegCodeX64_mxcsr = 65, -RDI_RegCodeX64_fsbase = 66, -RDI_RegCodeX64_gsbase = 67, -RDI_RegCodeX64_fcw = 68, -RDI_RegCodeX64_fsw = 69, -RDI_RegCodeX64_ftw = 70, -RDI_RegCodeX64_fop = 71, -RDI_RegCodeX64_fcs = 72, -RDI_RegCodeX64_fds = 73, -RDI_RegCodeX64_fip = 74, -RDI_RegCodeX64_fdp = 75, -RDI_RegCodeX64_mxcsr_mask = 76, -} RDI_RegCodeX64Enum; - -typedef RDI_U32 RDI_BinarySectionFlags; -typedef enum RDI_BinarySectionFlagsEnum -{ -RDI_BinarySectionFlag_Read = 1<<0, -RDI_BinarySectionFlag_Write = 1<<1, -RDI_BinarySectionFlag_Execute = 1<<2, -} RDI_BinarySectionFlagsEnum; - -typedef RDI_U32 RDI_Language; -typedef enum RDI_LanguageEnum -{ -RDI_Language_NULL = 0, -RDI_Language_C = 1, -RDI_Language_CPlusPlus = 2, -RDI_Language_COUNT = 3, -} RDI_LanguageEnum; - -typedef RDI_U16 RDI_TypeKind; -typedef enum RDI_TypeKindEnum -{ -RDI_TypeKind_NULL = 0x0000, -RDI_TypeKind_Void = 0x0001, -RDI_TypeKind_Handle = 0x0002, -RDI_TypeKind_Char8 = 0x0003, -RDI_TypeKind_Char16 = 0x0004, -RDI_TypeKind_Char32 = 0x0005, -RDI_TypeKind_UChar8 = 0x0006, -RDI_TypeKind_UChar16 = 0x0007, -RDI_TypeKind_UChar32 = 0x0008, -RDI_TypeKind_U8 = 0x0009, -RDI_TypeKind_U16 = 0x000A, -RDI_TypeKind_U32 = 0x000B, -RDI_TypeKind_U64 = 0x000C, -RDI_TypeKind_U128 = 0x000D, -RDI_TypeKind_U256 = 0x000E, -RDI_TypeKind_U512 = 0x000F, -RDI_TypeKind_S8 = 0x0010, -RDI_TypeKind_S16 = 0x0011, -RDI_TypeKind_S32 = 0x0012, -RDI_TypeKind_S64 = 0x0013, -RDI_TypeKind_S128 = 0x0014, -RDI_TypeKind_S256 = 0x0015, -RDI_TypeKind_S512 = 0x0016, -RDI_TypeKind_Bool = 0x0017, -RDI_TypeKind_F16 = 0x0018, -RDI_TypeKind_F32 = 0x0019, -RDI_TypeKind_F32PP = 0x001A, -RDI_TypeKind_F48 = 0x001B, -RDI_TypeKind_F64 = 0x001C, -RDI_TypeKind_F80 = 0x001D, -RDI_TypeKind_F128 = 0x001E, -RDI_TypeKind_ComplexF32 = 0x001F, -RDI_TypeKind_ComplexF64 = 0x0020, -RDI_TypeKind_ComplexF80 = 0x0021, -RDI_TypeKind_ComplexF128 = 0x0022, -RDI_TypeKind_Modifier = 0x1000, -RDI_TypeKind_Ptr = 0x1001, -RDI_TypeKind_LRef = 0x1002, -RDI_TypeKind_RRef = 0x1003, -RDI_TypeKind_Array = 0x1004, -RDI_TypeKind_Function = 0x1005, -RDI_TypeKind_Method = 0x1006, -RDI_TypeKind_MemberPtr = 0x1007, -RDI_TypeKind_Struct = 0x2000, -RDI_TypeKind_Class = 0x2001, -RDI_TypeKind_Union = 0x2002, -RDI_TypeKind_Enum = 0x2003, -RDI_TypeKind_Alias = 0x2004, -RDI_TypeKind_IncompleteStruct = 0x2005, -RDI_TypeKind_IncompleteUnion = 0x2006, -RDI_TypeKind_IncompleteClass = 0x2007, -RDI_TypeKind_IncompleteEnum = 0x2008, -RDI_TypeKind_Bitfield = 0xF000, -RDI_TypeKind_Variadic = 0xF001, -RDI_TypeKind_FirstBuiltIn = RDI_TypeKind_Void, -RDI_TypeKind_LastBuiltIn = RDI_TypeKind_ComplexF128, -RDI_TypeKind_FirstConstructed = RDI_TypeKind_Modifier, -RDI_TypeKind_LastConstructed = RDI_TypeKind_MemberPtr, -RDI_TypeKind_FirstUserDefined = RDI_TypeKind_Struct, -RDI_TypeKind_LastRecord = RDI_TypeKind_Union, -RDI_TypeKind_FirstIncomplete = RDI_TypeKind_IncompleteStruct, -RDI_TypeKind_LastIncomplete = RDI_TypeKind_IncompleteEnum, -RDI_TypeKind_FirstRecord = RDI_TypeKind_Struct, -RDI_TypeKind_LastUserDefined = RDI_TypeKind_IncompleteEnum, -} RDI_TypeKindEnum; - -typedef RDI_U16 RDI_TypeModifierFlags; -typedef enum RDI_TypeModifierFlagsEnum -{ -RDI_TypeModifierFlag_Const = 1<<0, -RDI_TypeModifierFlag_Volatile = 1<<1, -} RDI_TypeModifierFlagsEnum; - -typedef RDI_U32 RDI_UDTFlags; -typedef enum RDI_UDTFlagsEnum -{ -RDI_UDTFlag_EnumMembers = 1<<0, -} RDI_UDTFlagsEnum; - -typedef RDI_U16 RDI_MemberKind; -typedef enum RDI_MemberKindEnum -{ -RDI_MemberKind_NULL = 0x0000, -RDI_MemberKind_DataField = 0x0001, -RDI_MemberKind_StaticData = 0x0002, -RDI_MemberKind_Method = 0x0100, -RDI_MemberKind_StaticMethod = 0x0101, -RDI_MemberKind_VirtualMethod = 0x0102, -RDI_MemberKind_VTablePtr = 0x0200, -RDI_MemberKind_Base = 0x0201, -RDI_MemberKind_VirtualBase = 0x0202, -RDI_MemberKind_NestedType = 0x0300, -} RDI_MemberKindEnum; - -typedef RDI_U32 RDI_LinkFlags; -typedef enum RDI_LinkFlagsEnum -{ -RDI_LinkFlag_External = 1<<0, -RDI_LinkFlag_TypeScoped = 1<<1, -RDI_LinkFlag_ProcScoped = 1<<2, -} RDI_LinkFlagsEnum; - -typedef RDI_U32 RDI_LocalKind; -typedef enum RDI_LocalKindEnum -{ -RDI_LocalKind_NULL = 0x0, -RDI_LocalKind_Parameter = 0x1, -RDI_LocalKind_Variable = 0x2, -} RDI_LocalKindEnum; - -typedef RDI_U8 RDI_LocationKind; -typedef enum RDI_LocationKindEnum -{ -RDI_LocationKind_NULL = 0x0, -RDI_LocationKind_AddrBytecodeStream = 0x1, -RDI_LocationKind_ValBytecodeStream = 0x2, -RDI_LocationKind_AddrRegPlusU16 = 0x3, -RDI_LocationKind_AddrAddrRegPlusU16 = 0x4, -RDI_LocationKind_ValReg = 0x5, -} RDI_LocationKindEnum; - -typedef RDI_U8 RDI_EvalOp; -typedef enum RDI_EvalOpEnum -{ -RDI_EvalOp_Stop = 0, -RDI_EvalOp_Noop = 1, -RDI_EvalOp_Cond = 2, -RDI_EvalOp_Skip = 3, -RDI_EvalOp_MemRead = 4, -RDI_EvalOp_RegRead = 5, -RDI_EvalOp_RegReadDyn = 6, -RDI_EvalOp_FrameOff = 7, -RDI_EvalOp_ModuleOff = 8, -RDI_EvalOp_TLSOff = 9, -RDI_EvalOp_ObjectOff = 10, -RDI_EvalOp_CFA = 11, -RDI_EvalOp_ConstU8 = 12, -RDI_EvalOp_ConstU16 = 13, -RDI_EvalOp_ConstU32 = 14, -RDI_EvalOp_ConstU64 = 15, -RDI_EvalOp_Abs = 16, -RDI_EvalOp_Neg = 17, -RDI_EvalOp_Add = 18, -RDI_EvalOp_Sub = 19, -RDI_EvalOp_Mul = 20, -RDI_EvalOp_Div = 21, -RDI_EvalOp_Mod = 22, -RDI_EvalOp_LShift = 23, -RDI_EvalOp_RShift = 24, -RDI_EvalOp_BitAnd = 25, -RDI_EvalOp_BitOr = 26, -RDI_EvalOp_BitXor = 27, -RDI_EvalOp_BitNot = 28, -RDI_EvalOp_LogAnd = 29, -RDI_EvalOp_LogOr = 30, -RDI_EvalOp_LogNot = 31, -RDI_EvalOp_EqEq = 32, -RDI_EvalOp_NtEq = 33, -RDI_EvalOp_LsEq = 34, -RDI_EvalOp_GrEq = 35, -RDI_EvalOp_Less = 36, -RDI_EvalOp_Grtr = 37, -RDI_EvalOp_Trunc = 38, -RDI_EvalOp_TruncSigned = 39, -RDI_EvalOp_Convert = 40, -RDI_EvalOp_Pick = 41, -RDI_EvalOp_Pop = 42, -RDI_EvalOp_Insert = 43, -RDI_EvalOp_COUNT = 44, -} RDI_EvalOpEnum; - -typedef RDI_U8 RDI_EvalTypeGroup; -typedef enum RDI_EvalTypeGroupEnum -{ -RDI_EvalTypeGroup_Other = 0, -RDI_EvalTypeGroup_U = 1, -RDI_EvalTypeGroup_S = 2, -RDI_EvalTypeGroup_F32 = 3, -RDI_EvalTypeGroup_F64 = 4, -RDI_EvalTypeGroup_COUNT = 5, -} RDI_EvalTypeGroupEnum; - -typedef RDI_U8 RDI_EvalConversionKind; -typedef enum RDI_EvalConversionKindEnum -{ -RDI_EvalConversionKind_Noop = 0, -RDI_EvalConversionKind_Legal = 1, -RDI_EvalConversionKind_OtherToOther = 2, -RDI_EvalConversionKind_ToOther = 3, -RDI_EvalConversionKind_FromOther = 4, -RDI_EvalConversionKind_COUNT = 5, -} RDI_EvalConversionKindEnum; - -typedef RDI_U32 RDI_NameMapKind; -typedef enum RDI_NameMapKindEnum -{ -RDI_NameMapKind_NULL = 0, -RDI_NameMapKind_GlobalVariables = 1, -RDI_NameMapKind_ThreadVariables = 2, -RDI_NameMapKind_Procedures = 3, -RDI_NameMapKind_Types = 4, -RDI_NameMapKind_LinkNameProcedures = 5, -RDI_NameMapKind_NormalSourcePaths = 6, -RDI_NameMapKind_COUNT = 7, -} RDI_NameMapKindEnum; - -#define RDI_DataSectionTag_XList \ -X(NULL)\ -X(TopLevelInfo)\ -X(StringData)\ -X(StringTable)\ -X(IndexRuns)\ -X(BinarySections)\ -X(FilePathNodes)\ -X(SourceFiles)\ -X(Units)\ -X(UnitVmap)\ -X(TypeNodes)\ -X(UDTs)\ -X(Members)\ -X(EnumMembers)\ -X(GlobalVariables)\ -X(GlobalVmap)\ -X(ThreadVariables)\ -X(Procedures)\ -X(Scopes)\ -X(ScopeVoffData)\ -X(ScopeVmap)\ -X(Locals)\ -X(LocationBlocks)\ -X(LocationData)\ -X(NameMaps)\ -X(PRIMARY_COUNT)\ -X(SECONDARY)\ -X(LineInfoVoffs)\ -X(LineInfoData)\ -X(LineInfoColumns)\ -X(LineMapNumbers)\ -X(LineMapRanges)\ -X(LineMapVoffs)\ -X(NameMapBuckets)\ -X(NameMapNodes)\ - -#define RDI_DataSectionEncoding_XList \ -X(Unpacked)\ -X(LZB)\ - -#define RDI_Arch_XList \ -X(NULL)\ -X(X86)\ -X(X64)\ - -#define RDI_BinarySectionFlags_XList \ -X(NULL)\ -X(X86)\ -X(X64)\ - -#define RDI_Language_XList \ -X(NULL)\ -X(C)\ -X(CPlusPlus)\ -X(COUNT)\ - -#define RDI_TypeKind_XList \ -X(NULL)\ -X(Void)\ -X(Handle)\ -X(Char8)\ -X(Char16)\ -X(Char32)\ -X(UChar8)\ -X(UChar16)\ -X(UChar32)\ -X(U8)\ -X(U16)\ -X(U32)\ -X(U64)\ -X(U128)\ -X(U256)\ -X(U512)\ -X(S8)\ -X(S16)\ -X(S32)\ -X(S64)\ -X(S128)\ -X(S256)\ -X(S512)\ -X(Bool)\ -X(F16)\ -X(F32)\ -X(F32PP)\ -X(F48)\ -X(F64)\ -X(F80)\ -X(F128)\ -X(ComplexF32)\ -X(ComplexF64)\ -X(ComplexF80)\ -X(ComplexF128)\ -X(Modifier)\ -X(Ptr)\ -X(LRef)\ -X(RRef)\ -X(Array)\ -X(Function)\ -X(Method)\ -X(MemberPtr)\ -X(Struct)\ -X(Class)\ -X(Union)\ -X(Enum)\ -X(Alias)\ -X(IncompleteStruct)\ -X(IncompleteUnion)\ -X(IncompleteClass)\ -X(IncompleteEnum)\ -X(Bitfield)\ -X(Variadic)\ - -#define RDI_TypeModifierFlags_XList \ -X(Const)\ -X(Volatile)\ - -#define RDI_UDTFlag_XList \ -X(EnumMembers)\ - -#define RDI_MemberKind_XList \ -X(NULL)\ -X(DataField)\ -X(StaticData)\ -X(Method)\ -X(StaticMethod)\ -X(VirtualMethod)\ -X(VTablePtr)\ -X(Base)\ -X(VirtualBase)\ -X(NestedType)\ - -#define RDI_LinkFlags_XList \ -X(External)\ -X(TypeScoped)\ -X(ProcScoped)\ - -#define RDI_LocalKind_XList \ -X(NULL)\ -X(Parameter)\ -X(Variable)\ - -#define RDI_LocationKind_XList \ -X(NULL)\ -X(AddrBytecodeStream)\ -X(ValBytecodeStream)\ -X(AddrRegPlusU16)\ -X(AddrAddrRegPlusU16)\ -X(ValReg)\ - -#define RDI_EvalOp_XList \ -X(Stop)\ -X(Noop)\ -X(Cond)\ -X(Skip)\ -X(MemRead)\ -X(RegRead)\ -X(RegReadDyn)\ -X(FrameOff)\ -X(ModuleOff)\ -X(TLSOff)\ -X(ObjectOff)\ -X(CFA)\ -X(ConstU8)\ -X(ConstU16)\ -X(ConstU32)\ -X(ConstU64)\ -X(Abs)\ -X(Neg)\ -X(Add)\ -X(Sub)\ -X(Mul)\ -X(Div)\ -X(Mod)\ -X(LShift)\ -X(RShift)\ -X(BitAnd)\ -X(BitOr)\ -X(BitXor)\ -X(BitNot)\ -X(LogAnd)\ -X(LogOr)\ -X(LogNot)\ -X(EqEq)\ -X(NtEq)\ -X(LsEq)\ -X(GrEq)\ -X(Less)\ -X(Grtr)\ -X(Trunc)\ -X(TruncSigned)\ -X(Convert)\ -X(Pick)\ -X(Pop)\ -X(Insert)\ -X(COUNT)\ - -#define RDI_EvalTypeGroup_XList \ -X(Other)\ -X(U)\ -X(S)\ -X(F32)\ -X(F64)\ -X(COUNT)\ - -#define RDI_EvalConversionKind_XList \ -X(Noop)\ -X(Legal)\ -X(OtherToOther)\ -X(ToOther)\ -X(FromOther)\ -X(COUNT)\ - -#define RDI_NameMapKind_XList \ -X(NULL)\ -X(GlobalVariables)\ -X(ThreadVariables)\ -X(Procedures)\ -X(Types)\ -X(LinkNameProcedures)\ -X(NormalSourcePaths)\ -X(COUNT)\ - -#define RDI_EVAL_CTRLBITS(decodeN,popN,pushN) ((decodeN) | ((popN) << 4) | ((pushN) << 6)) -#define RDI_DECODEN_FROM_CTRLBITS(ctrlbits) ((ctrlbits) & 0xf) -#define RDI_POPN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 4) & 0x3) -#define RDI_PUSHN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 6) & 0x3) -#define RDI_EncodeRegReadParam(reg,bytesize,bytepos) ((reg)|((bytesize)<<8)|((bytepos)<<16)) - -typedef struct RDI_Header RDI_Header; -struct RDI_Header -{ -RDI_U64 magic; -RDI_U32 encoding_version; -RDI_U32 data_section_off; -RDI_U32 data_section_count; -}; - -typedef struct RDI_DataSection RDI_DataSection; -struct RDI_DataSection -{ -RDI_DataSectionTag tag; -RDI_DataSectionEncoding encoding; -RDI_U64 off; -RDI_U64 encoded_size; -RDI_U64 unpacked_size; -}; - -typedef struct RDI_VMapEntry RDI_VMapEntry; -struct RDI_VMapEntry -{ -RDI_U64 voff; -RDI_U64 idx; -}; - -typedef struct RDI_TopLevelInfo RDI_TopLevelInfo; -struct RDI_TopLevelInfo -{ -RDI_Arch arch; -RDI_U32 exe_name_string_idx; -RDI_U64 exe_hash; -RDI_U64 voff_max; -}; - -typedef struct RDI_BinarySection RDI_BinarySection; -struct RDI_BinarySection -{ -RDI_U32 name_string_idx; -RDI_BinarySectionFlags flags; -RDI_U64 voff_first; -RDI_U64 voff_opl; -RDI_U64 foff_first; -RDI_U64 foff_opl; -}; - -typedef struct RDI_FilePathNode RDI_FilePathNode; -struct RDI_FilePathNode -{ -RDI_U32 name_string_idx; -RDI_U32 parent_path_node; -RDI_U32 first_child; -RDI_U32 next_sibling; -RDI_U32 source_file_idx; -}; - -typedef struct RDI_SourceFile RDI_SourceFile; -struct RDI_SourceFile -{ -RDI_U32 file_path_node_idx; -RDI_U32 normal_full_path_string_idx; -RDI_U32 line_map_count; -RDI_U32 line_map_nums_data_idx; -RDI_U32 line_map_range_data_idx; -RDI_U32 line_map_voff_data_idx; -}; - -typedef struct RDI_Unit RDI_Unit; -struct RDI_Unit -{ -RDI_U32 unit_name_string_idx; -RDI_U32 compiler_name_string_idx; -RDI_U32 source_file_path_node; -RDI_U32 object_file_path_node; -RDI_U32 archive_file_path_node; -RDI_U32 build_path_node; -RDI_Language language; -RDI_U32 line_info_voffs_data_idx; -RDI_U32 line_info_data_idx; -RDI_U32 line_info_col_data_idx; -RDI_U32 line_info_count; -}; - -typedef struct RDI_Line RDI_Line; -struct RDI_Line -{ -RDI_U32 file_idx; -RDI_U32 line_num; -}; - -typedef struct RDI_Column RDI_Column; -struct RDI_Column -{ -RDI_U16 col_first; -RDI_U16 col_opl; -}; - -typedef struct RDI_TypeNode RDI_TypeNode; -struct RDI_TypeNode -{ -RDI_TypeKind kind; -RDI_U16 flags; -RDI_U32 byte_size; - - union - { - // kind is 'built-in' - struct - { - RDI_U32 name_string_idx; - } built_in; - - // kind is 'constructed' - struct - { - RDI_U32 direct_type_idx; - RDI_U32 count; - union{ - // when kind is 'Function' or 'Method' - RDI_U32 param_idx_run_first; - // when kind is 'MemberPtr' - RDI_U32 owner_type_idx; - }; - } constructed; - - // kind is 'user defined' - struct - { - RDI_U32 name_string_idx; - RDI_U32 direct_type_idx; - RDI_U32 udt_idx; - } user_defined; - - // (kind = Bitfield) - struct - { - RDI_U32 direct_type_idx; - RDI_U32 off; - RDI_U32 size; - } bitfield; - } - ; -}; - -typedef struct RDI_UDT RDI_UDT; -struct RDI_UDT -{ -RDI_U32 self_type_idx; -RDI_UDTFlags flags; -RDI_U32 member_first; -RDI_U32 member_count; -RDI_U32 file_idx; -RDI_U32 line; -RDI_U32 col; -}; - -typedef struct RDI_Member RDI_Member; -struct RDI_Member -{ -RDI_MemberKind kind; -RDI_U16 pad; -RDI_U32 name_string_idx; -RDI_U32 type_idx; -RDI_U32 off; -}; - -typedef struct RDI_EnumMember RDI_EnumMember; -struct RDI_EnumMember -{ -RDI_U32 name_string_idx; -RDI_U32 pad; -RDI_U64 val; -}; - -typedef struct RDI_GlobalVariable RDI_GlobalVariable; -struct RDI_GlobalVariable -{ -RDI_U32 name_string_idx; -RDI_LinkFlags link_flags; -RDI_U64 voff; -RDI_U32 type_idx; -RDI_U32 container_idx; -}; - -typedef struct RDI_ThreadVariable RDI_ThreadVariable; -struct RDI_ThreadVariable -{ -RDI_U32 name_string_idx; -RDI_LinkFlags link_flags; -RDI_U32 tls_off; -RDI_U32 type_idx; -RDI_U32 container_idx; -}; - -typedef struct RDI_Procedure RDI_Procedure; -struct RDI_Procedure -{ -RDI_U32 name_string_idx; -RDI_U32 link_name_string_idx; -RDI_LinkFlags link_flags; -RDI_U32 type_idx; -RDI_U32 root_scope_idx; -RDI_U32 container_idx; -}; - -typedef struct RDI_Scope RDI_Scope; -struct RDI_Scope -{ -RDI_U32 proc_idx; -RDI_U32 parent_scope_idx; -RDI_U32 first_child_scope_idx; -RDI_U32 next_sibling_scope_idx; -RDI_U32 voff_range_first; -RDI_U32 voff_range_opl; -RDI_U32 local_first; -RDI_U32 local_count; -RDI_U32 static_local_idx_run_first; -RDI_U32 static_local_count; -}; - -typedef struct RDI_Local RDI_Local; -struct RDI_Local -{ -RDI_LocalKind kind; -RDI_U32 name_string_idx; -RDI_U32 type_idx; -RDI_U32 pad; -RDI_U32 location_first; -RDI_U32 location_opl; -}; - -typedef struct RDI_LocationBlock RDI_LocationBlock; -struct RDI_LocationBlock -{ -RDI_U32 scope_off_first; -RDI_U32 scope_off_opl; -RDI_U32 location_data_off; -}; - -typedef struct RDI_LocationBytecodeStream RDI_LocationBytecodeStream; -struct RDI_LocationBytecodeStream -{ -RDI_LocationKind kind; -}; - -typedef struct RDI_LocationRegPlusU16 RDI_LocationRegPlusU16; -struct RDI_LocationRegPlusU16 -{ -RDI_LocationKind kind; -RDI_RegCode reg_code; -RDI_U16 offset; -}; - -typedef struct RDI_LocationReg RDI_LocationReg; -struct RDI_LocationReg -{ -RDI_LocationKind kind; -RDI_RegCode reg_code; -}; - -typedef struct RDI_NameMap RDI_NameMap; -struct RDI_NameMap -{ -RDI_NameMapKind kind; -RDI_U32 bucket_data_idx; -RDI_U32 node_data_idx; -}; - -typedef struct RDI_NameMapBucket RDI_NameMapBucket; -struct RDI_NameMapBucket -{ -RDI_U32 first_node; -RDI_U32 node_count; -}; - -typedef struct RDI_NameMapNode RDI_NameMapNode; -struct RDI_NameMapNode -{ -RDI_U32 string_idx; -RDI_U32 match_count; -RDI_U32 match_idx_or_idx_run_first; -}; - -RDI_PROC RDI_U64 rdi_hash(RDI_U8 *ptr, RDI_U64 size); -RDI_PROC RDI_U32 rdi_size_from_basic_type_kind(RDI_TypeKind kind); -RDI_PROC RDI_U32 rdi_addr_size_from_arch(RDI_Arch arch); -RDI_PROC RDI_EvalConversionKind rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out); -RDI_PROC RDI_S32 rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group); -RDI_PROC RDI_U8 *rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out); - -extern RDI_U8 rdi_eval_op_ctrlbits_table[45]; - -#endif // RDI_FORMAT_H +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//////////////////////////////////////////////////////////////// +//~ RAD Debug Info, (R)AD(D)BG(I) Format Library +// +// Defines standard RDI debug information format types and +// functions. + +#ifndef RDI_FORMAT_H +#define RDI_FORMAT_H + +//////////////////////////////////////////////////////////////// +//~ Overridable Procedure Decoration + +#if !defined(RDI_PROC) +# define RDI_PROC static +#endif + +//////////////////////////////////////////////////////////////// +//~ Overridable Basic Integer Types + +#if !defined(RDI_U8) +# define RDI_U8 RDI_U8 +# define RDI_U16 RDI_U16 +# define RDI_U32 RDI_U32 +# define RDI_U64 RDI_U64 +# define RDI_S8 RDI_S8 +# define RDI_S16 RDI_S16 +# define RDI_S32 RDI_S32 +# define RDI_S64 RDI_S64 +#include +typedef uint8_t RDI_U8; +typedef uint16_t RDI_U16; +typedef uint32_t RDI_U32; +typedef uint64_t RDI_U64; +typedef int8_t RDI_S8; +typedef int16_t RDI_S16; +typedef int32_t RDI_S32; +typedef int64_t RDI_S64; +#endif + +//////////////////////////////////////////////////////////////// +//~ Format Constants + +// \"raddbg\0\0\" +#define RDI_MAGIC_CONSTANT 0x0000676264646172 +#define RDI_ENCODING_VERSION 1 + +//////////////////////////////////////////////////////////////// +//~ Format Types & Functions + +typedef RDI_U32 RDI_DataSectionTag; +typedef enum RDI_DataSectionTagEnum +{ +RDI_DataSectionTag_NULL = 0x0000, +RDI_DataSectionTag_TopLevelInfo = 0x0001, +RDI_DataSectionTag_StringData = 0x0002, +RDI_DataSectionTag_StringTable = 0x0003, +RDI_DataSectionTag_IndexRuns = 0x0004, +RDI_DataSectionTag_BinarySections = 0x0005, +RDI_DataSectionTag_FilePathNodes = 0x0006, +RDI_DataSectionTag_SourceFiles = 0x0007, +RDI_DataSectionTag_Units = 0x0008, +RDI_DataSectionTag_UnitVmap = 0x0009, +RDI_DataSectionTag_TypeNodes = 0x000A, +RDI_DataSectionTag_UDTs = 0x000B, +RDI_DataSectionTag_Members = 0x000C, +RDI_DataSectionTag_EnumMembers = 0x000D, +RDI_DataSectionTag_GlobalVariables = 0x000E, +RDI_DataSectionTag_GlobalVmap = 0x000F, +RDI_DataSectionTag_ThreadVariables = 0x0010, +RDI_DataSectionTag_Procedures = 0x0011, +RDI_DataSectionTag_Scopes = 0x0012, +RDI_DataSectionTag_ScopeVoffData = 0x0013, +RDI_DataSectionTag_ScopeVmap = 0x0014, +RDI_DataSectionTag_Locals = 0x0015, +RDI_DataSectionTag_LocationBlocks = 0x0016, +RDI_DataSectionTag_LocationData = 0x0017, +RDI_DataSectionTag_NameMaps = 0x0018, +RDI_DataSectionTag_PRIMARY_COUNT = 0x0019, +RDI_DataSectionTag_SECONDARY = 0x80000000, +RDI_DataSectionTag_LineInfoVoffs = RDI_DataSectionTag_SECONDARY|0x0001, +RDI_DataSectionTag_LineInfoData = RDI_DataSectionTag_SECONDARY|0x0002, +RDI_DataSectionTag_LineInfoColumns = RDI_DataSectionTag_SECONDARY|0x0003, +RDI_DataSectionTag_LineMapNumbers = RDI_DataSectionTag_SECONDARY|0x0004, +RDI_DataSectionTag_LineMapRanges = RDI_DataSectionTag_SECONDARY|0x0005, +RDI_DataSectionTag_LineMapVoffs = RDI_DataSectionTag_SECONDARY|0x0006, +RDI_DataSectionTag_NameMapBuckets = RDI_DataSectionTag_SECONDARY|0x0007, +RDI_DataSectionTag_NameMapNodes = RDI_DataSectionTag_SECONDARY|0x0008, +} RDI_DataSectionTagEnum; + +typedef RDI_U32 RDI_DataSectionEncoding; +typedef enum RDI_DataSectionEncodingEnum +{ +RDI_DataSectionEncoding_Unpacked = 0, +RDI_DataSectionEncoding_LZB = 1, +} RDI_DataSectionEncodingEnum; + +typedef RDI_U32 RDI_Arch; +typedef enum RDI_ArchEnum +{ +RDI_Arch_NULL = 0, +RDI_Arch_X86 = 1, +RDI_Arch_X64 = 2, +} RDI_ArchEnum; + +typedef RDI_U8 RDI_RegCode; +typedef enum RDI_RegCodeEnum +{ +RDI_RegCode_nil, +} RDI_RegCodeEnum; + +typedef RDI_U8 RDI_RegCodeX86; +typedef enum RDI_RegCodeX86Enum +{ +RDI_RegCodeX86_nil = 0, +RDI_RegCodeX86_eax = 1, +RDI_RegCodeX86_ecx = 2, +RDI_RegCodeX86_edx = 3, +RDI_RegCodeX86_ebx = 4, +RDI_RegCodeX86_esp = 5, +RDI_RegCodeX86_ebp = 6, +RDI_RegCodeX86_esi = 7, +RDI_RegCodeX86_edi = 8, +RDI_RegCodeX86_fsbase = 9, +RDI_RegCodeX86_gsbase = 10, +RDI_RegCodeX86_eflags = 11, +RDI_RegCodeX86_eip = 12, +RDI_RegCodeX86_dr0 = 13, +RDI_RegCodeX86_dr1 = 14, +RDI_RegCodeX86_dr2 = 15, +RDI_RegCodeX86_dr3 = 16, +RDI_RegCodeX86_dr4 = 17, +RDI_RegCodeX86_dr5 = 18, +RDI_RegCodeX86_dr6 = 19, +RDI_RegCodeX86_dr7 = 20, +RDI_RegCodeX86_fpr0 = 21, +RDI_RegCodeX86_fpr1 = 22, +RDI_RegCodeX86_fpr2 = 23, +RDI_RegCodeX86_fpr3 = 24, +RDI_RegCodeX86_fpr4 = 25, +RDI_RegCodeX86_fpr5 = 26, +RDI_RegCodeX86_fpr6 = 27, +RDI_RegCodeX86_fpr7 = 28, +RDI_RegCodeX86_st0 = 29, +RDI_RegCodeX86_st1 = 30, +RDI_RegCodeX86_st2 = 31, +RDI_RegCodeX86_st3 = 32, +RDI_RegCodeX86_st4 = 33, +RDI_RegCodeX86_st5 = 34, +RDI_RegCodeX86_st6 = 35, +RDI_RegCodeX86_st7 = 36, +RDI_RegCodeX86_fcw = 37, +RDI_RegCodeX86_fsw = 38, +RDI_RegCodeX86_ftw = 39, +RDI_RegCodeX86_fop = 40, +RDI_RegCodeX86_fcs = 41, +RDI_RegCodeX86_fds = 42, +RDI_RegCodeX86_fip = 43, +RDI_RegCodeX86_fdp = 44, +RDI_RegCodeX86_mxcsr = 45, +RDI_RegCodeX86_mxcsr_mask = 46, +RDI_RegCodeX86_ss = 47, +RDI_RegCodeX86_cs = 48, +RDI_RegCodeX86_ds = 49, +RDI_RegCodeX86_es = 50, +RDI_RegCodeX86_fs = 51, +RDI_RegCodeX86_gs = 52, +RDI_RegCodeX86_ymm0 = 53, +RDI_RegCodeX86_ymm1 = 54, +RDI_RegCodeX86_ymm2 = 55, +RDI_RegCodeX86_ymm3 = 56, +RDI_RegCodeX86_ymm4 = 57, +RDI_RegCodeX86_ymm5 = 58, +RDI_RegCodeX86_ymm6 = 59, +RDI_RegCodeX86_ymm7 = 60, +} RDI_RegCodeX86Enum; + +typedef RDI_U8 RDI_RegCodeX64; +typedef enum RDI_RegCodeX64Enum +{ +RDI_RegCodeX64_nil = 0, +RDI_RegCodeX64_rax = 1, +RDI_RegCodeX64_rcx = 2, +RDI_RegCodeX64_rdx = 3, +RDI_RegCodeX64_rbx = 4, +RDI_RegCodeX64_rsp = 5, +RDI_RegCodeX64_rbp = 6, +RDI_RegCodeX64_rsi = 7, +RDI_RegCodeX64_rdi = 8, +RDI_RegCodeX64_r8 = 9, +RDI_RegCodeX64_r9 = 10, +RDI_RegCodeX64_r10 = 11, +RDI_RegCodeX64_r11 = 12, +RDI_RegCodeX64_r12 = 13, +RDI_RegCodeX64_r13 = 14, +RDI_RegCodeX64_r14 = 15, +RDI_RegCodeX64_r15 = 16, +RDI_RegCodeX64_es = 17, +RDI_RegCodeX64_cs = 18, +RDI_RegCodeX64_ss = 19, +RDI_RegCodeX64_ds = 20, +RDI_RegCodeX64_fs = 21, +RDI_RegCodeX64_gs = 22, +RDI_RegCodeX64_rip = 23, +RDI_RegCodeX64_rflags = 24, +RDI_RegCodeX64_dr0 = 25, +RDI_RegCodeX64_dr1 = 26, +RDI_RegCodeX64_dr2 = 27, +RDI_RegCodeX64_dr3 = 28, +RDI_RegCodeX64_dr4 = 29, +RDI_RegCodeX64_dr5 = 30, +RDI_RegCodeX64_dr6 = 31, +RDI_RegCodeX64_dr7 = 32, +RDI_RegCodeX64_st0 = 33, +RDI_RegCodeX64_st1 = 34, +RDI_RegCodeX64_st2 = 35, +RDI_RegCodeX64_st3 = 36, +RDI_RegCodeX64_st4 = 37, +RDI_RegCodeX64_st5 = 38, +RDI_RegCodeX64_st6 = 39, +RDI_RegCodeX64_st7 = 40, +RDI_RegCodeX64_fpr0 = 41, +RDI_RegCodeX64_fpr1 = 42, +RDI_RegCodeX64_fpr2 = 43, +RDI_RegCodeX64_fpr3 = 44, +RDI_RegCodeX64_fpr4 = 45, +RDI_RegCodeX64_fpr5 = 46, +RDI_RegCodeX64_fpr6 = 47, +RDI_RegCodeX64_fpr7 = 48, +RDI_RegCodeX64_ymm0 = 49, +RDI_RegCodeX64_ymm1 = 50, +RDI_RegCodeX64_ymm2 = 51, +RDI_RegCodeX64_ymm3 = 52, +RDI_RegCodeX64_ymm4 = 53, +RDI_RegCodeX64_ymm5 = 54, +RDI_RegCodeX64_ymm6 = 55, +RDI_RegCodeX64_ymm7 = 56, +RDI_RegCodeX64_ymm8 = 57, +RDI_RegCodeX64_ymm9 = 58, +RDI_RegCodeX64_ymm10 = 59, +RDI_RegCodeX64_ymm11 = 60, +RDI_RegCodeX64_ymm12 = 61, +RDI_RegCodeX64_ymm13 = 62, +RDI_RegCodeX64_ymm14 = 63, +RDI_RegCodeX64_ymm15 = 64, +RDI_RegCodeX64_mxcsr = 65, +RDI_RegCodeX64_fsbase = 66, +RDI_RegCodeX64_gsbase = 67, +RDI_RegCodeX64_fcw = 68, +RDI_RegCodeX64_fsw = 69, +RDI_RegCodeX64_ftw = 70, +RDI_RegCodeX64_fop = 71, +RDI_RegCodeX64_fcs = 72, +RDI_RegCodeX64_fds = 73, +RDI_RegCodeX64_fip = 74, +RDI_RegCodeX64_fdp = 75, +RDI_RegCodeX64_mxcsr_mask = 76, +} RDI_RegCodeX64Enum; + +typedef RDI_U32 RDI_BinarySectionFlags; +typedef enum RDI_BinarySectionFlagsEnum +{ +RDI_BinarySectionFlag_Read = 1<<0, +RDI_BinarySectionFlag_Write = 1<<1, +RDI_BinarySectionFlag_Execute = 1<<2, +} RDI_BinarySectionFlagsEnum; + +typedef RDI_U32 RDI_Language; +typedef enum RDI_LanguageEnum +{ +RDI_Language_NULL = 0, +RDI_Language_C = 1, +RDI_Language_CPlusPlus = 2, +RDI_Language_COUNT = 3, +} RDI_LanguageEnum; + +typedef RDI_U16 RDI_TypeKind; +typedef enum RDI_TypeKindEnum +{ +RDI_TypeKind_NULL = 0x0000, +RDI_TypeKind_Void = 0x0001, +RDI_TypeKind_Handle = 0x0002, +RDI_TypeKind_Char8 = 0x0003, +RDI_TypeKind_Char16 = 0x0004, +RDI_TypeKind_Char32 = 0x0005, +RDI_TypeKind_UChar8 = 0x0006, +RDI_TypeKind_UChar16 = 0x0007, +RDI_TypeKind_UChar32 = 0x0008, +RDI_TypeKind_U8 = 0x0009, +RDI_TypeKind_U16 = 0x000A, +RDI_TypeKind_U32 = 0x000B, +RDI_TypeKind_U64 = 0x000C, +RDI_TypeKind_U128 = 0x000D, +RDI_TypeKind_U256 = 0x000E, +RDI_TypeKind_U512 = 0x000F, +RDI_TypeKind_S8 = 0x0010, +RDI_TypeKind_S16 = 0x0011, +RDI_TypeKind_S32 = 0x0012, +RDI_TypeKind_S64 = 0x0013, +RDI_TypeKind_S128 = 0x0014, +RDI_TypeKind_S256 = 0x0015, +RDI_TypeKind_S512 = 0x0016, +RDI_TypeKind_Bool = 0x0017, +RDI_TypeKind_F16 = 0x0018, +RDI_TypeKind_F32 = 0x0019, +RDI_TypeKind_F32PP = 0x001A, +RDI_TypeKind_F48 = 0x001B, +RDI_TypeKind_F64 = 0x001C, +RDI_TypeKind_F80 = 0x001D, +RDI_TypeKind_F128 = 0x001E, +RDI_TypeKind_ComplexF32 = 0x001F, +RDI_TypeKind_ComplexF64 = 0x0020, +RDI_TypeKind_ComplexF80 = 0x0021, +RDI_TypeKind_ComplexF128 = 0x0022, +RDI_TypeKind_Modifier = 0x1000, +RDI_TypeKind_Ptr = 0x1001, +RDI_TypeKind_LRef = 0x1002, +RDI_TypeKind_RRef = 0x1003, +RDI_TypeKind_Array = 0x1004, +RDI_TypeKind_Function = 0x1005, +RDI_TypeKind_Method = 0x1006, +RDI_TypeKind_MemberPtr = 0x1007, +RDI_TypeKind_Struct = 0x2000, +RDI_TypeKind_Class = 0x2001, +RDI_TypeKind_Union = 0x2002, +RDI_TypeKind_Enum = 0x2003, +RDI_TypeKind_Alias = 0x2004, +RDI_TypeKind_IncompleteStruct = 0x2005, +RDI_TypeKind_IncompleteUnion = 0x2006, +RDI_TypeKind_IncompleteClass = 0x2007, +RDI_TypeKind_IncompleteEnum = 0x2008, +RDI_TypeKind_Bitfield = 0xF000, +RDI_TypeKind_Variadic = 0xF001, +RDI_TypeKind_FirstBuiltIn = RDI_TypeKind_Void, +RDI_TypeKind_LastBuiltIn = RDI_TypeKind_ComplexF128, +RDI_TypeKind_FirstConstructed = RDI_TypeKind_Modifier, +RDI_TypeKind_LastConstructed = RDI_TypeKind_MemberPtr, +RDI_TypeKind_FirstUserDefined = RDI_TypeKind_Struct, +RDI_TypeKind_LastRecord = RDI_TypeKind_Union, +RDI_TypeKind_FirstIncomplete = RDI_TypeKind_IncompleteStruct, +RDI_TypeKind_LastIncomplete = RDI_TypeKind_IncompleteEnum, +RDI_TypeKind_FirstRecord = RDI_TypeKind_Struct, +RDI_TypeKind_LastUserDefined = RDI_TypeKind_IncompleteEnum, +} RDI_TypeKindEnum; + +typedef RDI_U16 RDI_TypeModifierFlags; +typedef enum RDI_TypeModifierFlagsEnum +{ +RDI_TypeModifierFlag_Const = 1<<0, +RDI_TypeModifierFlag_Volatile = 1<<1, +} RDI_TypeModifierFlagsEnum; + +typedef RDI_U32 RDI_UDTFlags; +typedef enum RDI_UDTFlagsEnum +{ +RDI_UDTFlag_EnumMembers = 1<<0, +} RDI_UDTFlagsEnum; + +typedef RDI_U16 RDI_MemberKind; +typedef enum RDI_MemberKindEnum +{ +RDI_MemberKind_NULL = 0x0000, +RDI_MemberKind_DataField = 0x0001, +RDI_MemberKind_StaticData = 0x0002, +RDI_MemberKind_Method = 0x0100, +RDI_MemberKind_StaticMethod = 0x0101, +RDI_MemberKind_VirtualMethod = 0x0102, +RDI_MemberKind_VTablePtr = 0x0200, +RDI_MemberKind_Base = 0x0201, +RDI_MemberKind_VirtualBase = 0x0202, +RDI_MemberKind_NestedType = 0x0300, +} RDI_MemberKindEnum; + +typedef RDI_U32 RDI_LinkFlags; +typedef enum RDI_LinkFlagsEnum +{ +RDI_LinkFlag_External = 1<<0, +RDI_LinkFlag_TypeScoped = 1<<1, +RDI_LinkFlag_ProcScoped = 1<<2, +} RDI_LinkFlagsEnum; + +typedef RDI_U32 RDI_LocalKind; +typedef enum RDI_LocalKindEnum +{ +RDI_LocalKind_NULL = 0x0, +RDI_LocalKind_Parameter = 0x1, +RDI_LocalKind_Variable = 0x2, +} RDI_LocalKindEnum; + +typedef RDI_U8 RDI_LocationKind; +typedef enum RDI_LocationKindEnum +{ +RDI_LocationKind_NULL = 0x0, +RDI_LocationKind_AddrBytecodeStream = 0x1, +RDI_LocationKind_ValBytecodeStream = 0x2, +RDI_LocationKind_AddrRegPlusU16 = 0x3, +RDI_LocationKind_AddrAddrRegPlusU16 = 0x4, +RDI_LocationKind_ValReg = 0x5, +} RDI_LocationKindEnum; + +typedef RDI_U8 RDI_EvalOp; +typedef enum RDI_EvalOpEnum +{ +RDI_EvalOp_Stop = 0, +RDI_EvalOp_Noop = 1, +RDI_EvalOp_Cond = 2, +RDI_EvalOp_Skip = 3, +RDI_EvalOp_MemRead = 4, +RDI_EvalOp_RegRead = 5, +RDI_EvalOp_RegReadDyn = 6, +RDI_EvalOp_FrameOff = 7, +RDI_EvalOp_ModuleOff = 8, +RDI_EvalOp_TLSOff = 9, +RDI_EvalOp_ObjectOff = 10, +RDI_EvalOp_CFA = 11, +RDI_EvalOp_ConstU8 = 12, +RDI_EvalOp_ConstU16 = 13, +RDI_EvalOp_ConstU32 = 14, +RDI_EvalOp_ConstU64 = 15, +RDI_EvalOp_Abs = 16, +RDI_EvalOp_Neg = 17, +RDI_EvalOp_Add = 18, +RDI_EvalOp_Sub = 19, +RDI_EvalOp_Mul = 20, +RDI_EvalOp_Div = 21, +RDI_EvalOp_Mod = 22, +RDI_EvalOp_LShift = 23, +RDI_EvalOp_RShift = 24, +RDI_EvalOp_BitAnd = 25, +RDI_EvalOp_BitOr = 26, +RDI_EvalOp_BitXor = 27, +RDI_EvalOp_BitNot = 28, +RDI_EvalOp_LogAnd = 29, +RDI_EvalOp_LogOr = 30, +RDI_EvalOp_LogNot = 31, +RDI_EvalOp_EqEq = 32, +RDI_EvalOp_NtEq = 33, +RDI_EvalOp_LsEq = 34, +RDI_EvalOp_GrEq = 35, +RDI_EvalOp_Less = 36, +RDI_EvalOp_Grtr = 37, +RDI_EvalOp_Trunc = 38, +RDI_EvalOp_TruncSigned = 39, +RDI_EvalOp_Convert = 40, +RDI_EvalOp_Pick = 41, +RDI_EvalOp_Pop = 42, +RDI_EvalOp_Insert = 43, +RDI_EvalOp_COUNT = 44, +} RDI_EvalOpEnum; + +typedef RDI_U8 RDI_EvalTypeGroup; +typedef enum RDI_EvalTypeGroupEnum +{ +RDI_EvalTypeGroup_Other = 0, +RDI_EvalTypeGroup_U = 1, +RDI_EvalTypeGroup_S = 2, +RDI_EvalTypeGroup_F32 = 3, +RDI_EvalTypeGroup_F64 = 4, +RDI_EvalTypeGroup_COUNT = 5, +} RDI_EvalTypeGroupEnum; + +typedef RDI_U8 RDI_EvalConversionKind; +typedef enum RDI_EvalConversionKindEnum +{ +RDI_EvalConversionKind_Noop = 0, +RDI_EvalConversionKind_Legal = 1, +RDI_EvalConversionKind_OtherToOther = 2, +RDI_EvalConversionKind_ToOther = 3, +RDI_EvalConversionKind_FromOther = 4, +RDI_EvalConversionKind_COUNT = 5, +} RDI_EvalConversionKindEnum; + +typedef RDI_U32 RDI_NameMapKind; +typedef enum RDI_NameMapKindEnum +{ +RDI_NameMapKind_NULL = 0, +RDI_NameMapKind_GlobalVariables = 1, +RDI_NameMapKind_ThreadVariables = 2, +RDI_NameMapKind_Procedures = 3, +RDI_NameMapKind_Types = 4, +RDI_NameMapKind_LinkNameProcedures = 5, +RDI_NameMapKind_NormalSourcePaths = 6, +RDI_NameMapKind_COUNT = 7, +} RDI_NameMapKindEnum; + +#define RDI_DataSectionTag_XList \ +X(NULL)\ +X(TopLevelInfo)\ +X(StringData)\ +X(StringTable)\ +X(IndexRuns)\ +X(BinarySections)\ +X(FilePathNodes)\ +X(SourceFiles)\ +X(Units)\ +X(UnitVmap)\ +X(TypeNodes)\ +X(UDTs)\ +X(Members)\ +X(EnumMembers)\ +X(GlobalVariables)\ +X(GlobalVmap)\ +X(ThreadVariables)\ +X(Procedures)\ +X(Scopes)\ +X(ScopeVoffData)\ +X(ScopeVmap)\ +X(Locals)\ +X(LocationBlocks)\ +X(LocationData)\ +X(NameMaps)\ +X(PRIMARY_COUNT)\ +X(SECONDARY)\ +X(LineInfoVoffs)\ +X(LineInfoData)\ +X(LineInfoColumns)\ +X(LineMapNumbers)\ +X(LineMapRanges)\ +X(LineMapVoffs)\ +X(NameMapBuckets)\ +X(NameMapNodes)\ + +#define RDI_DataSectionEncoding_XList \ +X(Unpacked)\ +X(LZB)\ + +#define RDI_Arch_XList \ +X(NULL)\ +X(X86)\ +X(X64)\ + +#define RDI_BinarySectionFlags_XList \ +X(NULL)\ +X(X86)\ +X(X64)\ + +#define RDI_Language_XList \ +X(NULL)\ +X(C)\ +X(CPlusPlus)\ +X(COUNT)\ + +#define RDI_TypeKind_XList \ +X(NULL)\ +X(Void)\ +X(Handle)\ +X(Char8)\ +X(Char16)\ +X(Char32)\ +X(UChar8)\ +X(UChar16)\ +X(UChar32)\ +X(U8)\ +X(U16)\ +X(U32)\ +X(U64)\ +X(U128)\ +X(U256)\ +X(U512)\ +X(S8)\ +X(S16)\ +X(S32)\ +X(S64)\ +X(S128)\ +X(S256)\ +X(S512)\ +X(Bool)\ +X(F16)\ +X(F32)\ +X(F32PP)\ +X(F48)\ +X(F64)\ +X(F80)\ +X(F128)\ +X(ComplexF32)\ +X(ComplexF64)\ +X(ComplexF80)\ +X(ComplexF128)\ +X(Modifier)\ +X(Ptr)\ +X(LRef)\ +X(RRef)\ +X(Array)\ +X(Function)\ +X(Method)\ +X(MemberPtr)\ +X(Struct)\ +X(Class)\ +X(Union)\ +X(Enum)\ +X(Alias)\ +X(IncompleteStruct)\ +X(IncompleteUnion)\ +X(IncompleteClass)\ +X(IncompleteEnum)\ +X(Bitfield)\ +X(Variadic)\ + +#define RDI_TypeModifierFlags_XList \ +X(Const)\ +X(Volatile)\ + +#define RDI_UDTFlag_XList \ +X(EnumMembers)\ + +#define RDI_MemberKind_XList \ +X(NULL)\ +X(DataField)\ +X(StaticData)\ +X(Method)\ +X(StaticMethod)\ +X(VirtualMethod)\ +X(VTablePtr)\ +X(Base)\ +X(VirtualBase)\ +X(NestedType)\ + +#define RDI_LinkFlags_XList \ +X(External)\ +X(TypeScoped)\ +X(ProcScoped)\ + +#define RDI_LocalKind_XList \ +X(NULL)\ +X(Parameter)\ +X(Variable)\ + +#define RDI_LocationKind_XList \ +X(NULL)\ +X(AddrBytecodeStream)\ +X(ValBytecodeStream)\ +X(AddrRegPlusU16)\ +X(AddrAddrRegPlusU16)\ +X(ValReg)\ + +#define RDI_EvalOp_XList \ +X(Stop)\ +X(Noop)\ +X(Cond)\ +X(Skip)\ +X(MemRead)\ +X(RegRead)\ +X(RegReadDyn)\ +X(FrameOff)\ +X(ModuleOff)\ +X(TLSOff)\ +X(ObjectOff)\ +X(CFA)\ +X(ConstU8)\ +X(ConstU16)\ +X(ConstU32)\ +X(ConstU64)\ +X(Abs)\ +X(Neg)\ +X(Add)\ +X(Sub)\ +X(Mul)\ +X(Div)\ +X(Mod)\ +X(LShift)\ +X(RShift)\ +X(BitAnd)\ +X(BitOr)\ +X(BitXor)\ +X(BitNot)\ +X(LogAnd)\ +X(LogOr)\ +X(LogNot)\ +X(EqEq)\ +X(NtEq)\ +X(LsEq)\ +X(GrEq)\ +X(Less)\ +X(Grtr)\ +X(Trunc)\ +X(TruncSigned)\ +X(Convert)\ +X(Pick)\ +X(Pop)\ +X(Insert)\ +X(COUNT)\ + +#define RDI_EvalTypeGroup_XList \ +X(Other)\ +X(U)\ +X(S)\ +X(F32)\ +X(F64)\ +X(COUNT)\ + +#define RDI_EvalConversionKind_XList \ +X(Noop)\ +X(Legal)\ +X(OtherToOther)\ +X(ToOther)\ +X(FromOther)\ +X(COUNT)\ + +#define RDI_NameMapKind_XList \ +X(NULL)\ +X(GlobalVariables)\ +X(ThreadVariables)\ +X(Procedures)\ +X(Types)\ +X(LinkNameProcedures)\ +X(NormalSourcePaths)\ +X(COUNT)\ + +#define RDI_EVAL_CTRLBITS(decodeN,popN,pushN) ((decodeN) | ((popN) << 4) | ((pushN) << 6)) +#define RDI_DECODEN_FROM_CTRLBITS(ctrlbits) ((ctrlbits) & 0xf) +#define RDI_POPN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 4) & 0x3) +#define RDI_PUSHN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 6) & 0x3) +#define RDI_EncodeRegReadParam(reg,bytesize,bytepos) ((reg)|((bytesize)<<8)|((bytepos)<<16)) + +typedef struct RDI_Header RDI_Header; +struct RDI_Header +{ +RDI_U64 magic; +RDI_U32 encoding_version; +RDI_U32 data_section_off; +RDI_U32 data_section_count; +}; + +typedef struct RDI_DataSection RDI_DataSection; +struct RDI_DataSection +{ +RDI_DataSectionTag tag; +RDI_DataSectionEncoding encoding; +RDI_U64 off; +RDI_U64 encoded_size; +RDI_U64 unpacked_size; +}; + +typedef struct RDI_VMapEntry RDI_VMapEntry; +struct RDI_VMapEntry +{ +RDI_U64 voff; +RDI_U64 idx; +}; + +typedef struct RDI_TopLevelInfo RDI_TopLevelInfo; +struct RDI_TopLevelInfo +{ +RDI_Arch arch; +RDI_U32 exe_name_string_idx; +RDI_U64 exe_hash; +RDI_U64 voff_max; +}; + +typedef struct RDI_BinarySection RDI_BinarySection; +struct RDI_BinarySection +{ +RDI_U32 name_string_idx; +RDI_BinarySectionFlags flags; +RDI_U64 voff_first; +RDI_U64 voff_opl; +RDI_U64 foff_first; +RDI_U64 foff_opl; +}; + +typedef struct RDI_FilePathNode RDI_FilePathNode; +struct RDI_FilePathNode +{ +RDI_U32 name_string_idx; +RDI_U32 parent_path_node; +RDI_U32 first_child; +RDI_U32 next_sibling; +RDI_U32 source_file_idx; +}; + +typedef struct RDI_SourceFile RDI_SourceFile; +struct RDI_SourceFile +{ +RDI_U32 file_path_node_idx; +RDI_U32 normal_full_path_string_idx; +RDI_U32 line_map_count; +RDI_U32 line_map_nums_data_idx; +RDI_U32 line_map_range_data_idx; +RDI_U32 line_map_voff_data_idx; +}; + +typedef struct RDI_Unit RDI_Unit; +struct RDI_Unit +{ +RDI_U32 unit_name_string_idx; +RDI_U32 compiler_name_string_idx; +RDI_U32 source_file_path_node; +RDI_U32 object_file_path_node; +RDI_U32 archive_file_path_node; +RDI_U32 build_path_node; +RDI_Language language; +RDI_U32 line_info_voffs_data_idx; +RDI_U32 line_info_data_idx; +RDI_U32 line_info_col_data_idx; +RDI_U32 line_info_count; +}; + +typedef struct RDI_Line RDI_Line; +struct RDI_Line +{ +RDI_U32 file_idx; +RDI_U32 line_num; +}; + +typedef struct RDI_Column RDI_Column; +struct RDI_Column +{ +RDI_U16 col_first; +RDI_U16 col_opl; +}; + +typedef struct RDI_TypeNode RDI_TypeNode; +struct RDI_TypeNode +{ +RDI_TypeKind kind; +RDI_U16 flags; +RDI_U32 byte_size; + + union + { + // kind is 'built-in' + struct + { + RDI_U32 name_string_idx; + } built_in; + + // kind is 'constructed' + struct + { + RDI_U32 direct_type_idx; + RDI_U32 count; + union{ + // when kind is 'Function' or 'Method' + RDI_U32 param_idx_run_first; + // when kind is 'MemberPtr' + RDI_U32 owner_type_idx; + }; + } constructed; + + // kind is 'user defined' + struct + { + RDI_U32 name_string_idx; + RDI_U32 direct_type_idx; + RDI_U32 udt_idx; + } user_defined; + + // (kind = Bitfield) + struct + { + RDI_U32 direct_type_idx; + RDI_U32 off; + RDI_U32 size; + } bitfield; + } + ; +}; + +typedef struct RDI_UDT RDI_UDT; +struct RDI_UDT +{ +RDI_U32 self_type_idx; +RDI_UDTFlags flags; +RDI_U32 member_first; +RDI_U32 member_count; +RDI_U32 file_idx; +RDI_U32 line; +RDI_U32 col; +}; + +typedef struct RDI_Member RDI_Member; +struct RDI_Member +{ +RDI_MemberKind kind; +RDI_U16 pad; +RDI_U32 name_string_idx; +RDI_U32 type_idx; +RDI_U32 off; +}; + +typedef struct RDI_EnumMember RDI_EnumMember; +struct RDI_EnumMember +{ +RDI_U32 name_string_idx; +RDI_U32 pad; +RDI_U64 val; +}; + +typedef struct RDI_GlobalVariable RDI_GlobalVariable; +struct RDI_GlobalVariable +{ +RDI_U32 name_string_idx; +RDI_LinkFlags link_flags; +RDI_U64 voff; +RDI_U32 type_idx; +RDI_U32 container_idx; +}; + +typedef struct RDI_ThreadVariable RDI_ThreadVariable; +struct RDI_ThreadVariable +{ +RDI_U32 name_string_idx; +RDI_LinkFlags link_flags; +RDI_U32 tls_off; +RDI_U32 type_idx; +RDI_U32 container_idx; +}; + +typedef struct RDI_Procedure RDI_Procedure; +struct RDI_Procedure +{ +RDI_U32 name_string_idx; +RDI_U32 link_name_string_idx; +RDI_LinkFlags link_flags; +RDI_U32 type_idx; +RDI_U32 root_scope_idx; +RDI_U32 container_idx; +}; + +typedef struct RDI_Scope RDI_Scope; +struct RDI_Scope +{ +RDI_U32 proc_idx; +RDI_U32 parent_scope_idx; +RDI_U32 first_child_scope_idx; +RDI_U32 next_sibling_scope_idx; +RDI_U32 voff_range_first; +RDI_U32 voff_range_opl; +RDI_U32 local_first; +RDI_U32 local_count; +RDI_U32 static_local_idx_run_first; +RDI_U32 static_local_count; +}; + +typedef struct RDI_Local RDI_Local; +struct RDI_Local +{ +RDI_LocalKind kind; +RDI_U32 name_string_idx; +RDI_U32 type_idx; +RDI_U32 pad; +RDI_U32 location_first; +RDI_U32 location_opl; +}; + +typedef struct RDI_LocationBlock RDI_LocationBlock; +struct RDI_LocationBlock +{ +RDI_U32 scope_off_first; +RDI_U32 scope_off_opl; +RDI_U32 location_data_off; +}; + +typedef struct RDI_LocationBytecodeStream RDI_LocationBytecodeStream; +struct RDI_LocationBytecodeStream +{ +RDI_LocationKind kind; +}; + +typedef struct RDI_LocationRegPlusU16 RDI_LocationRegPlusU16; +struct RDI_LocationRegPlusU16 +{ +RDI_LocationKind kind; +RDI_RegCode reg_code; +RDI_U16 offset; +}; + +typedef struct RDI_LocationReg RDI_LocationReg; +struct RDI_LocationReg +{ +RDI_LocationKind kind; +RDI_RegCode reg_code; +}; + +typedef struct RDI_NameMap RDI_NameMap; +struct RDI_NameMap +{ +RDI_NameMapKind kind; +RDI_U32 bucket_data_idx; +RDI_U32 node_data_idx; +}; + +typedef struct RDI_NameMapBucket RDI_NameMapBucket; +struct RDI_NameMapBucket +{ +RDI_U32 first_node; +RDI_U32 node_count; +}; + +typedef struct RDI_NameMapNode RDI_NameMapNode; +struct RDI_NameMapNode +{ +RDI_U32 string_idx; +RDI_U32 match_count; +RDI_U32 match_idx_or_idx_run_first; +}; + +RDI_PROC RDI_U64 rdi_hash(RDI_U8 *ptr, RDI_U64 size); +RDI_PROC RDI_U32 rdi_size_from_basic_type_kind(RDI_TypeKind kind); +RDI_PROC RDI_U32 rdi_addr_size_from_arch(RDI_Arch arch); +RDI_PROC RDI_EvalConversionKind rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out); +RDI_PROC RDI_S32 rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group); +RDI_PROC RDI_U8 *rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out); + +extern RDI_U8 rdi_eval_op_ctrlbits_table[45]; + +#endif // RDI_FORMAT_H diff --git a/src/rdi_from_pdb/rdi_from_pdb_main.c b/src/rdi_from_pdb/rdi_from_pdb_main.c index 75eb0723..b813dcc2 100644 --- a/src/rdi_from_pdb/rdi_from_pdb_main.c +++ b/src/rdi_from_pdb/rdi_from_pdb_main.c @@ -15,8 +15,8 @@ //~ rjf: Includes //- rjf: [lib] -#include "lib_rdi_format/rdi_format.h" -#include "lib_rdi_format/rdi_format.c" +#include "rdi_format/lib/rdi_format.h" +#include "rdi_format/lib/rdi_format.c" #include "third_party/rad_lzb_simple/rad_lzb_simple.h" #include "third_party/rad_lzb_simple/rad_lzb_simple.c" From 01a21af955364894e2129f635e6da9c4a4fa919a Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Sat, 1 Jun 2024 11:57:44 -0700 Subject: [PATCH 16/21] lld no_aslr --- build.bat | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.bat b/build.bat index 89eec163..84cb941b 100644 --- a/build.bat +++ b/build.bat @@ -59,7 +59,7 @@ if "%clang%"=="1" set only_compile=-c if "%msvc%"=="1" set EHsc=/EHsc if "%clang%"=="1" set EHsc= if "%msvc%"=="1" set no_aslr=/DYNAMICBASE:NO -if "%clang%"=="1" set no_aslr= +if "%clang%"=="1" set no_aslr=-Wl,/DYNAMICBASE:NO if "%msvc%"=="1" set rc=call rc if "%clang%"=="1" set rc=call llvm-rc From 82c1badcdc26b12b27be6dd67e8bdfc3ebaa8028 Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Sat, 1 Jun 2024 12:05:51 -0700 Subject: [PATCH 17/21] reorganize generated & handwritten library (relocatable) rad debug info format files; separate from codebase-local tools for managing or internally including the libraries --- src/lib_rdi_format/rdi_format.c | 211 +- src/lib_rdi_format/rdi_format.h | 1724 +++++++++-------- src/metagen/metagen_main.c | 11 +- src/rdi_format/lib/rdi_format.c | 196 -- src/rdi_format/lib/rdi_format.h | 1009 ---------- src/rdi_format/rdi_format.mdesk | 2 +- .../rdi_format_local.c | 0 .../rdi_format_local.h | 0 8 files changed, 1067 insertions(+), 2086 deletions(-) delete mode 100644 src/rdi_format/lib/rdi_format.c delete mode 100644 src/rdi_format/lib/rdi_format.h rename src/{rdi_format_local => rdi_format}/rdi_format_local.c (100%) rename src/{rdi_format_local => rdi_format}/rdi_format_local.h (100%) diff --git a/src/lib_rdi_format/rdi_format.c b/src/lib_rdi_format/rdi_format.c index f13c0ad1..ef9eea1b 100644 --- a/src/lib_rdi_format/rdi_format.c +++ b/src/lib_rdi_format/rdi_format.c @@ -1,85 +1,174 @@ // Copyright (c) 2024 Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) -//////////////////////////////// -// Functions +//////////////////////////////////////////////////////////////// +//~ RAD Debug Info, (R)AD(D)BG(I) Format Library +// +// Defines standard RDI debug information format types and +// functions. + +#ifndef RDI_FORMAT_C +#define RDI_FORMAT_C + +RDI_U8 rdi_eval_op_ctrlbits_table[45] = +{ +RDI_EVAL_CTRLBITS(0, 0, 0), +RDI_EVAL_CTRLBITS(0, 0, 0), +RDI_EVAL_CTRLBITS(1, 1, 0), +RDI_EVAL_CTRLBITS(1, 0, 0), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(4, 0, 1), +RDI_EVAL_CTRLBITS(0, 1, 1), +RDI_EVAL_CTRLBITS(1, 0, 1), +RDI_EVAL_CTRLBITS(4, 0, 1), +RDI_EVAL_CTRLBITS(4, 0, 1), +RDI_EVAL_CTRLBITS(0, 0, 0), +RDI_EVAL_CTRLBITS(0, 0, 0), +RDI_EVAL_CTRLBITS(1, 0, 1), +RDI_EVAL_CTRLBITS(2, 0, 1), +RDI_EVAL_CTRLBITS(4, 0, 1), +RDI_EVAL_CTRLBITS(8, 0, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 2, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(1, 1, 1), +RDI_EVAL_CTRLBITS(2, 1, 1), +RDI_EVAL_CTRLBITS(1, 0, 1), +RDI_EVAL_CTRLBITS(0, 1, 0), +RDI_EVAL_CTRLBITS(1, 0, 0), +RDI_EVAL_CTRLBITS(0, 0, 0), +}; + +struct {RDI_EvalConversionKind dst_typegroups[RDI_EvalTypeGroup_COUNT];} rdi_eval_typegroup_conversion_kind_matrix[6] = +{ +{{RDI_EvalConversionKind_OtherToOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther}}, +{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal}}, +{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal}}, +{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal}}, +{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Noop}}, +{{RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop}}, +}; + +struct {RDI_U8 *str; RDI_U64 size;} rdi_eval_conversion_kind_message_string_table[6] = +{ +{(RDI_U8 *)"Other", sizeof("Other")}, +{(RDI_U8 *)"U", sizeof("U")}, +{(RDI_U8 *)"S", sizeof("S")}, +{(RDI_U8 *)"F32", sizeof("F32")}, +{(RDI_U8 *)"F64", sizeof("F64")}, +{(RDI_U8 *)"COUNT", sizeof("COUNT")}, +}; RDI_PROC RDI_U64 -rdi_hash(RDI_U8 *ptr, RDI_U64 size){ +rdi_hash(RDI_U8 *ptr, RDI_U64 size) +{ RDI_U64 result = 5381; RDI_U8 *opl = ptr + size; - for (; ptr < opl; ptr += 1){ + for(;ptr < opl; ptr += 1) + { result = ((result << 5) + result) + *ptr; } - return(result); + return result; } RDI_PROC RDI_U32 -rdi_size_from_basic_type_kind(RDI_TypeKind kind){ - RDI_U32 result = 0; - switch (kind){ -#define X(N,C) -#define XZ(N,C,Z) case C: result = Z; break; -#define Y(A,N) - RDI_TypeKindXList(X,XZ,Y) -#undef X -#undef XZ -#undef Y - } - return(result); +rdi_size_from_basic_type_kind(RDI_TypeKind kind) +{ +RDI_U32 result = 0; +switch(kind) +{ +default:{}break; +case RDI_TypeKind_Handle:{result = 0xFFFFFFFF;}break; +case RDI_TypeKind_Char8:{result = 1;}break; +case RDI_TypeKind_Char16:{result = 2;}break; +case RDI_TypeKind_Char32:{result = 4;}break; +case RDI_TypeKind_UChar8:{result = 1;}break; +case RDI_TypeKind_UChar16:{result = 2;}break; +case RDI_TypeKind_UChar32:{result = 4;}break; +case RDI_TypeKind_U8:{result = 1;}break; +case RDI_TypeKind_U16:{result = 2;}break; +case RDI_TypeKind_U32:{result = 4;}break; +case RDI_TypeKind_U64:{result = 8;}break; +case RDI_TypeKind_U128:{result = 16;}break; +case RDI_TypeKind_U256:{result = 32;}break; +case RDI_TypeKind_U512:{result = 64;}break; +case RDI_TypeKind_S8:{result = 1;}break; +case RDI_TypeKind_S16:{result = 2;}break; +case RDI_TypeKind_S32:{result = 4;}break; +case RDI_TypeKind_S64:{result = 8;}break; +case RDI_TypeKind_S128:{result = 16;}break; +case RDI_TypeKind_S256:{result = 32;}break; +case RDI_TypeKind_S512:{result = 64;}break; +case RDI_TypeKind_Bool:{result = 1;}break; +case RDI_TypeKind_F16:{result = 2;}break; +case RDI_TypeKind_F32:{result = 4;}break; +case RDI_TypeKind_F32PP:{result = 4;}break; +case RDI_TypeKind_F48:{result = 6;}break; +case RDI_TypeKind_F64:{result = 8;}break; +case RDI_TypeKind_F80:{result = 10;}break; +case RDI_TypeKind_F128:{result = 16;}break; +case RDI_TypeKind_ComplexF32:{result = 8;}break; +case RDI_TypeKind_ComplexF64:{result = 16;}break; +case RDI_TypeKind_ComplexF80:{result = 20;}break; +case RDI_TypeKind_ComplexF128:{result = 32;}break; +} +return result; } RDI_PROC RDI_U32 -rdi_addr_size_from_arch(RDI_Arch arch){ - RDI_U32 result = 0; - switch (arch){ -#define X(N,C,Z) case C: result = Z; break; - RDI_ArchXList(X) -#undef X - } - return(result); +rdi_addr_size_from_arch(RDI_Arch arch) +{ +RDI_U32 result = 0; +switch(arch) +{ +default:{}break; +case RDI_Arch_X86:{result = 4;}break; +case RDI_Arch_X64:{result = 8;}break; +} +return result; } - -//- eval helpers RDI_PROC RDI_EvalConversionKind -rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out){ - RDI_EvalConversionKind result = 0; - switch (in + (out << 8)){ -#define Y(i,o) case ((RDI_EvalTypeGroup_##i) + ((RDI_EvalTypeGroup_##o) << 8)): -#define Xb(c) -#define Xe(c) result = RDI_EvalConversionKind_##c; break; - RDI_EvalConversionKindFromTypeGroupPairMap(Y,Xb,Xe) -#undef Xe -#undef Xb -#undef Y - } - return(result); -} - -RDI_PROC RDI_U8* -rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind conversion_kind, RDI_U64 *lenout){ - RDI_U8 *result = 0; - switch (conversion_kind){ -#define X(N,msg) \ -case RDI_EvalConversionKind_##N: result = (RDI_U8*)msg; *lenout = sizeof(msg) - 1; break; - RDI_EvalConversionKindXList(X) -#undef X - } - return(result); +rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out) +{ + RDI_EvalConversionKind k = rdi_eval_typegroup_conversion_kind_matrix[in].dst_typegroups[out]; + return k; } RDI_PROC RDI_S32 -rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group){ +rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group) +{ RDI_S32 result = 0; - switch (op){ + switch(op) + { case RDI_EvalOp_Neg: case RDI_EvalOp_Add: case RDI_EvalOp_Sub: case RDI_EvalOp_Mul: case RDI_EvalOp_Div: case RDI_EvalOp_EqEq:case RDI_EvalOp_NtEq: case RDI_EvalOp_LsEq:case RDI_EvalOp_GrEq: case RDI_EvalOp_Less:case RDI_EvalOp_Grtr: { - if (group != RDI_EvalTypeGroup_Other){ + if(group != RDI_EvalTypeGroup_Other) + { result = 1; } }break; @@ -88,10 +177,20 @@ rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group){ case RDI_EvalOp_BitOr:case RDI_EvalOp_LogNot:case RDI_EvalOp_LogAnd: case RDI_EvalOp_LogOr: { - if (group == RDI_EvalTypeGroup_S || group == RDI_EvalTypeGroup_U){ + if(group == RDI_EvalTypeGroup_S || group == RDI_EvalTypeGroup_U) + { result = 1; } }break; } - return(result); + return result; } + +RDI_PROC RDI_U8 * +rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out) +{ + *size_out = rdi_eval_conversion_kind_message_string_table[kind].size; + return rdi_eval_conversion_kind_message_string_table[kind].str; +} + +#endif // RDI_FORMAT_C diff --git a/src/lib_rdi_format/rdi_format.h b/src/lib_rdi_format/rdi_format.h index 4977dec0..ddd1cf7e 100644 --- a/src/lib_rdi_format/rdi_format.h +++ b/src/lib_rdi_format/rdi_format.h @@ -2,7 +2,7 @@ // Licensed under the MIT license (https://opensource.org/license/mit/) //////////////////////////////////////////////////////////////// -// RAD Debug Info, (R)AD(D)BG(I) Format Library +//~ RAD Debug Info, (R)AD(D)BG(I) Format Library // // Defines standard RDI debug information format types and // functions. @@ -11,14 +11,14 @@ #define RDI_FORMAT_H //////////////////////////////////////////////////////////////// -// Overridable procedure decoration +//~ Overridable Procedure Decoration #if !defined(RDI_PROC) # define RDI_PROC static #endif //////////////////////////////////////////////////////////////// -// Overridable integer types +//~ Overridable Basic Integer Types #if !defined(RDI_U8) # define RDI_U8 RDI_U8 @@ -29,7 +29,6 @@ # define RDI_S16 RDI_S16 # define RDI_S32 RDI_S32 # define RDI_S64 RDI_S64 - #include typedef uint8_t RDI_U8; typedef uint16_t RDI_U16; @@ -42,479 +41,794 @@ typedef int64_t RDI_S64; #endif //////////////////////////////////////////////////////////////// -// Architecture Constants +//~ Format Constants -#define RDI_ArchXList(X)\ -X(NULL, 0, 0)\ -X(X86, 1, 4)\ -X(X64, 2, 8) - -typedef RDI_U32 RDI_Arch; -typedef enum RDI_ArchEnum{ -#define X(N,C,Z) RDI_Arch_##N = C, - RDI_ArchXList(X) -#undef X -} RDI_ArchEnum; - - -typedef RDI_U8 RDI_RegCode; - -// x86 registers -#define RDI_RegisterCode_X86_XList(X) \ -X(nil, 0) \ -X(eax, 1) \ -X(ecx, 2) \ -X(edx, 3) \ -X(ebx, 4) \ -X(esp, 5) \ -X(ebp, 6) \ -X(esi, 7) \ -X(edi, 8) \ -X(fsbase, 9) \ -X(gsbase, 10) \ -X(eflags, 11) \ -X(eip, 12) \ -X(dr0, 13) \ -X(dr1, 14) \ -X(dr2, 15) \ -X(dr3, 16) \ -X(dr4, 17) \ -X(dr5, 18) \ -X(dr6, 19) \ -X(dr7, 20) \ -X(fpr0, 21) \ -X(fpr1, 22) \ -X(fpr2, 23) \ -X(fpr3, 24) \ -X(fpr4, 25) \ -X(fpr5, 26) \ -X(fpr6, 27) \ -X(fpr7, 28) \ -X(st0, 29) \ -X(st1, 30) \ -X(st2, 31) \ -X(st3, 32) \ -X(st4, 33) \ -X(st5, 34) \ -X(st6, 35) \ -X(st7, 36) \ -X(fcw, 37) \ -X(fsw, 38) \ -X(ftw, 39) \ -X(fop, 40) \ -X(fcs, 41) \ -X(fds, 42) \ -X(fip, 43) \ -X(fdp, 44) \ -X(mxcsr, 45) \ -X(mxcsr_mask, 46) \ -X(ss, 47) \ -X(cs, 48) \ -X(ds, 49) \ -X(es, 50) \ -X(fs, 51) \ -X(gs, 52) \ -X(ymm0, 53) \ -X(ymm1, 54) \ -X(ymm2, 55) \ -X(ymm3, 56) \ -X(ymm4, 57) \ -X(ymm5, 58) \ -X(ymm6, 59) \ -X(ymm7, 60) \ -X(COUNT, 61) - -typedef enum RDI_RegisterCode_X86_Enum{ -#define X(N,C) RDI_RegisterCode_X86_##N = C, - RDI_RegisterCode_X86_XList(X) -#undef X -} RDI_RegisterCode_X86_Enum; - -// x64 registers -#define RDI_RegisterCode_X64_XList(X) \ -X(nil, 0) \ -X(rax, 1) \ -X(rcx, 2) \ -X(rdx, 3) \ -X(rbx, 4) \ -X(rsp, 5) \ -X(rbp, 6) \ -X(rsi, 7) \ -X(rdi, 8) \ -X(r8, 9) \ -X(r9, 10) \ -X(r10, 11) \ -X(r11, 12) \ -X(r12, 13) \ -X(r13, 14) \ -X(r14, 15) \ -X(r15, 16) \ -X(es, 17) \ -X(cs, 18) \ -X(ss, 19) \ -X(ds, 20) \ -X(fs, 21) \ -X(gs, 22) \ -X(rip, 23) \ -X(rflags, 24) \ -X(dr0, 25) \ -X(dr1, 26) \ -X(dr2, 27) \ -X(dr3, 28) \ -X(dr4, 29) \ -X(dr5, 30) \ -X(dr6, 31) \ -X(dr7, 32) \ -X(st0, 33) \ -X(st1, 34) \ -X(st2, 35) \ -X(st3, 36) \ -X(st4, 37) \ -X(st5, 38) \ -X(st6, 39) \ -X(st7, 40) \ -X(fpr0, 41) \ -X(fpr1, 42) \ -X(fpr2, 43) \ -X(fpr3, 44) \ -X(fpr4, 45) \ -X(fpr5, 46) \ -X(fpr6, 47) \ -X(fpr7, 48) \ -X(ymm0, 49) \ -X(ymm1, 50) \ -X(ymm2, 51) \ -X(ymm3, 52) \ -X(ymm4, 53) \ -X(ymm5, 54) \ -X(ymm6, 55) \ -X(ymm7, 56) \ -X(ymm8, 57) \ -X(ymm9, 58) \ -X(ymm10, 59) \ -X(ymm11, 60) \ -X(ymm12, 61) \ -X(ymm13, 62) \ -X(ymm14, 63) \ -X(ymm15, 64) \ -X(mxcsr, 65) \ -X(fsbase, 66) \ -X(gsbase, 67) \ -X(fcw, 68) \ -X(fsw, 69) \ -X(ftw, 70) \ -X(fop, 71) \ -X(fcs, 72) \ -X(fds, 73) \ -X(fip, 74) \ -X(fdp, 75) \ -X(mxcsr_mask, 76) \ -X(COUNT, 77) - -typedef enum RDI_RegisterCode_X64_Enum{ -#define X(N,C) RDI_RegisterCode_X64_##N = C, - RDI_RegisterCode_X64_XList(X) -#undef X -} RDI_RegisterCode_X64_Enum; - - -//////////////////////////////////////////////////////////////// -// Format types - -// "raddbg\0\0" +// \"raddbg\0\0\" #define RDI_MAGIC_CONSTANT 0x0000676264646172 #define RDI_ENCODING_VERSION 1 -#define RDI_LanguageXList(X) \ -X(NULL, 0) \ -X(C, 1) \ -X(CPlusPlus, 2) - -typedef RDI_U32 RDI_Language; -typedef enum RDI_LanguageEnum{ -#define X(N,C) RDI_Language_##N = C, - RDI_LanguageXList(X) -#undef X -} RDI_LanguageEnum; - -typedef struct RDI_Header{ - // identification - RDI_U64 magic; - RDI_U32 encoding_version; - - // data sections - RDI_U32 data_section_off; - RDI_U32 data_section_count; -} RDI_Header; - - -//- data sections - -#define RDI_DataSectionTag_SECONDARY 0x80000000 - -#define RDI_DataSectionTagXList(X,Y) \ -X(NULL, 0x0000)\ -X(TopLevelInfo, 0x0001)\ -X(StringData, 0x0002)\ -X(StringTable, 0x0003)\ -X(IndexRuns, 0x0004)\ -X(BinarySections, 0x0005)\ -X(FilePathNodes, 0x0006)\ -X(SourceFiles, 0x0007)\ -X(Units, 0x0008)\ -X(UnitVmap, 0x0009)\ -X(TypeNodes, 0x000A)\ -X(UDTs, 0x000B)\ -X(Members, 0x000C)\ -X(EnumMembers, 0x000D)\ -X(GlobalVariables, 0x000E)\ -X(GlobalVmap, 0x000F)\ -X(ThreadVariables, 0x0010)\ -X(Procedures, 0x0011)\ -X(Scopes, 0x0012)\ -X(ScopeVoffData, 0x0013)\ -X(ScopeVmap, 0x0014)\ -X(Locals, 0x0015)\ -X(LocationBlocks, 0x0016)\ -X(LocationData, 0x0017)\ -X(NameMaps, 0x0018)\ -Y(PRIMARY_COUNT)\ -X(SKIP, RDI_DataSectionTag_SECONDARY|0x0000)\ -X(LineInfoVoffs, RDI_DataSectionTag_SECONDARY|0x0001)\ -X(LineInfoData, RDI_DataSectionTag_SECONDARY|0x0002)\ -X(LineInfoColumns, RDI_DataSectionTag_SECONDARY|0x0003)\ -X(LineMapNumbers, RDI_DataSectionTag_SECONDARY|0x0004)\ -X(LineMapRanges, RDI_DataSectionTag_SECONDARY|0x0005)\ -X(LineMapVoffs, RDI_DataSectionTag_SECONDARY|0x0006)\ -X(NameMapBuckets, RDI_DataSectionTag_SECONDARY|0x0007)\ -X(NameMapNodes, RDI_DataSectionTag_SECONDARY|0x0008) +//////////////////////////////////////////////////////////////// +//~ Format Types & Functions typedef RDI_U32 RDI_DataSectionTag; -typedef enum RDI_DataSectionTagEnum{ -#define X(N,C) RDI_DataSectionTag_##N = C, -#define Y(N) RDI_DataSectionTag_##N, - RDI_DataSectionTagXList(X,Y) -#undef X -#undef Y +typedef enum RDI_DataSectionTagEnum +{ +RDI_DataSectionTag_NULL = 0x0000, +RDI_DataSectionTag_TopLevelInfo = 0x0001, +RDI_DataSectionTag_StringData = 0x0002, +RDI_DataSectionTag_StringTable = 0x0003, +RDI_DataSectionTag_IndexRuns = 0x0004, +RDI_DataSectionTag_BinarySections = 0x0005, +RDI_DataSectionTag_FilePathNodes = 0x0006, +RDI_DataSectionTag_SourceFiles = 0x0007, +RDI_DataSectionTag_Units = 0x0008, +RDI_DataSectionTag_UnitVmap = 0x0009, +RDI_DataSectionTag_TypeNodes = 0x000A, +RDI_DataSectionTag_UDTs = 0x000B, +RDI_DataSectionTag_Members = 0x000C, +RDI_DataSectionTag_EnumMembers = 0x000D, +RDI_DataSectionTag_GlobalVariables = 0x000E, +RDI_DataSectionTag_GlobalVmap = 0x000F, +RDI_DataSectionTag_ThreadVariables = 0x0010, +RDI_DataSectionTag_Procedures = 0x0011, +RDI_DataSectionTag_Scopes = 0x0012, +RDI_DataSectionTag_ScopeVoffData = 0x0013, +RDI_DataSectionTag_ScopeVmap = 0x0014, +RDI_DataSectionTag_Locals = 0x0015, +RDI_DataSectionTag_LocationBlocks = 0x0016, +RDI_DataSectionTag_LocationData = 0x0017, +RDI_DataSectionTag_NameMaps = 0x0018, +RDI_DataSectionTag_PRIMARY_COUNT = 0x0019, +RDI_DataSectionTag_SECONDARY = 0x80000000, +RDI_DataSectionTag_LineInfoVoffs = RDI_DataSectionTag_SECONDARY|0x0001, +RDI_DataSectionTag_LineInfoData = RDI_DataSectionTag_SECONDARY|0x0002, +RDI_DataSectionTag_LineInfoColumns = RDI_DataSectionTag_SECONDARY|0x0003, +RDI_DataSectionTag_LineMapNumbers = RDI_DataSectionTag_SECONDARY|0x0004, +RDI_DataSectionTag_LineMapRanges = RDI_DataSectionTag_SECONDARY|0x0005, +RDI_DataSectionTag_LineMapVoffs = RDI_DataSectionTag_SECONDARY|0x0006, +RDI_DataSectionTag_NameMapBuckets = RDI_DataSectionTag_SECONDARY|0x0007, +RDI_DataSectionTag_NameMapNodes = RDI_DataSectionTag_SECONDARY|0x0008, } RDI_DataSectionTagEnum; - -#define RDI_DataSectionEncodingXList(X) \ -X(Unpacked, 0)\ -X(LZB, 1) - typedef RDI_U32 RDI_DataSectionEncoding; -typedef enum RDI_DataSectionEncodingEnum{ -#define X(N,C) RDI_DataSectionEncoding_##N = C, - RDI_DataSectionEncodingXList(X) -#undef X +typedef enum RDI_DataSectionEncodingEnum +{ +RDI_DataSectionEncoding_Unpacked = 0, +RDI_DataSectionEncoding_LZB = 1, } RDI_DataSectionEncodingEnum; -typedef struct RDI_DataSection{ - RDI_DataSectionTag tag; - RDI_DataSectionEncoding encoding; - RDI_U64 off; - RDI_U64 encoded_size; - RDI_U64 unpacked_size; -} RDI_DataSection; +typedef RDI_U32 RDI_Arch; +typedef enum RDI_ArchEnum +{ +RDI_Arch_NULL = 0, +RDI_Arch_X86 = 1, +RDI_Arch_X64 = 2, +} RDI_ArchEnum; +typedef RDI_U8 RDI_RegCode; +typedef enum RDI_RegCodeEnum +{ +RDI_RegCode_nil, +} RDI_RegCodeEnum; -//- common types -typedef struct RDI_VMapEntry{ - RDI_U64 voff; - RDI_U64 idx; -} RDI_VMapEntry; +typedef RDI_U8 RDI_RegCodeX86; +typedef enum RDI_RegCodeX86Enum +{ +RDI_RegCodeX86_nil = 0, +RDI_RegCodeX86_eax = 1, +RDI_RegCodeX86_ecx = 2, +RDI_RegCodeX86_edx = 3, +RDI_RegCodeX86_ebx = 4, +RDI_RegCodeX86_esp = 5, +RDI_RegCodeX86_ebp = 6, +RDI_RegCodeX86_esi = 7, +RDI_RegCodeX86_edi = 8, +RDI_RegCodeX86_fsbase = 9, +RDI_RegCodeX86_gsbase = 10, +RDI_RegCodeX86_eflags = 11, +RDI_RegCodeX86_eip = 12, +RDI_RegCodeX86_dr0 = 13, +RDI_RegCodeX86_dr1 = 14, +RDI_RegCodeX86_dr2 = 15, +RDI_RegCodeX86_dr3 = 16, +RDI_RegCodeX86_dr4 = 17, +RDI_RegCodeX86_dr5 = 18, +RDI_RegCodeX86_dr6 = 19, +RDI_RegCodeX86_dr7 = 20, +RDI_RegCodeX86_fpr0 = 21, +RDI_RegCodeX86_fpr1 = 22, +RDI_RegCodeX86_fpr2 = 23, +RDI_RegCodeX86_fpr3 = 24, +RDI_RegCodeX86_fpr4 = 25, +RDI_RegCodeX86_fpr5 = 26, +RDI_RegCodeX86_fpr6 = 27, +RDI_RegCodeX86_fpr7 = 28, +RDI_RegCodeX86_st0 = 29, +RDI_RegCodeX86_st1 = 30, +RDI_RegCodeX86_st2 = 31, +RDI_RegCodeX86_st3 = 32, +RDI_RegCodeX86_st4 = 33, +RDI_RegCodeX86_st5 = 34, +RDI_RegCodeX86_st6 = 35, +RDI_RegCodeX86_st7 = 36, +RDI_RegCodeX86_fcw = 37, +RDI_RegCodeX86_fsw = 38, +RDI_RegCodeX86_ftw = 39, +RDI_RegCodeX86_fop = 40, +RDI_RegCodeX86_fcs = 41, +RDI_RegCodeX86_fds = 42, +RDI_RegCodeX86_fip = 43, +RDI_RegCodeX86_fdp = 44, +RDI_RegCodeX86_mxcsr = 45, +RDI_RegCodeX86_mxcsr_mask = 46, +RDI_RegCodeX86_ss = 47, +RDI_RegCodeX86_cs = 48, +RDI_RegCodeX86_ds = 49, +RDI_RegCodeX86_es = 50, +RDI_RegCodeX86_fs = 51, +RDI_RegCodeX86_gs = 52, +RDI_RegCodeX86_ymm0 = 53, +RDI_RegCodeX86_ymm1 = 54, +RDI_RegCodeX86_ymm2 = 55, +RDI_RegCodeX86_ymm3 = 56, +RDI_RegCodeX86_ymm4 = 57, +RDI_RegCodeX86_ymm5 = 58, +RDI_RegCodeX86_ymm6 = 59, +RDI_RegCodeX86_ymm7 = 60, +} RDI_RegCodeX86Enum; -//- top level info -typedef struct RDI_TopLevelInfo{ - RDI_Arch arch; - RDI_U32 exe_name_string_idx; - RDI_U64 exe_hash; - RDI_U64 voff_max; -} RDI_TopLevelInfo; +typedef RDI_U8 RDI_RegCodeX64; +typedef enum RDI_RegCodeX64Enum +{ +RDI_RegCodeX64_nil = 0, +RDI_RegCodeX64_rax = 1, +RDI_RegCodeX64_rcx = 2, +RDI_RegCodeX64_rdx = 3, +RDI_RegCodeX64_rbx = 4, +RDI_RegCodeX64_rsp = 5, +RDI_RegCodeX64_rbp = 6, +RDI_RegCodeX64_rsi = 7, +RDI_RegCodeX64_rdi = 8, +RDI_RegCodeX64_r8 = 9, +RDI_RegCodeX64_r9 = 10, +RDI_RegCodeX64_r10 = 11, +RDI_RegCodeX64_r11 = 12, +RDI_RegCodeX64_r12 = 13, +RDI_RegCodeX64_r13 = 14, +RDI_RegCodeX64_r14 = 15, +RDI_RegCodeX64_r15 = 16, +RDI_RegCodeX64_es = 17, +RDI_RegCodeX64_cs = 18, +RDI_RegCodeX64_ss = 19, +RDI_RegCodeX64_ds = 20, +RDI_RegCodeX64_fs = 21, +RDI_RegCodeX64_gs = 22, +RDI_RegCodeX64_rip = 23, +RDI_RegCodeX64_rflags = 24, +RDI_RegCodeX64_dr0 = 25, +RDI_RegCodeX64_dr1 = 26, +RDI_RegCodeX64_dr2 = 27, +RDI_RegCodeX64_dr3 = 28, +RDI_RegCodeX64_dr4 = 29, +RDI_RegCodeX64_dr5 = 30, +RDI_RegCodeX64_dr6 = 31, +RDI_RegCodeX64_dr7 = 32, +RDI_RegCodeX64_st0 = 33, +RDI_RegCodeX64_st1 = 34, +RDI_RegCodeX64_st2 = 35, +RDI_RegCodeX64_st3 = 36, +RDI_RegCodeX64_st4 = 37, +RDI_RegCodeX64_st5 = 38, +RDI_RegCodeX64_st6 = 39, +RDI_RegCodeX64_st7 = 40, +RDI_RegCodeX64_fpr0 = 41, +RDI_RegCodeX64_fpr1 = 42, +RDI_RegCodeX64_fpr2 = 43, +RDI_RegCodeX64_fpr3 = 44, +RDI_RegCodeX64_fpr4 = 45, +RDI_RegCodeX64_fpr5 = 46, +RDI_RegCodeX64_fpr6 = 47, +RDI_RegCodeX64_fpr7 = 48, +RDI_RegCodeX64_ymm0 = 49, +RDI_RegCodeX64_ymm1 = 50, +RDI_RegCodeX64_ymm2 = 51, +RDI_RegCodeX64_ymm3 = 52, +RDI_RegCodeX64_ymm4 = 53, +RDI_RegCodeX64_ymm5 = 54, +RDI_RegCodeX64_ymm6 = 55, +RDI_RegCodeX64_ymm7 = 56, +RDI_RegCodeX64_ymm8 = 57, +RDI_RegCodeX64_ymm9 = 58, +RDI_RegCodeX64_ymm10 = 59, +RDI_RegCodeX64_ymm11 = 60, +RDI_RegCodeX64_ymm12 = 61, +RDI_RegCodeX64_ymm13 = 62, +RDI_RegCodeX64_ymm14 = 63, +RDI_RegCodeX64_ymm15 = 64, +RDI_RegCodeX64_mxcsr = 65, +RDI_RegCodeX64_fsbase = 66, +RDI_RegCodeX64_gsbase = 67, +RDI_RegCodeX64_fcw = 68, +RDI_RegCodeX64_fsw = 69, +RDI_RegCodeX64_ftw = 70, +RDI_RegCodeX64_fop = 71, +RDI_RegCodeX64_fcs = 72, +RDI_RegCodeX64_fds = 73, +RDI_RegCodeX64_fip = 74, +RDI_RegCodeX64_fdp = 75, +RDI_RegCodeX64_mxcsr_mask = 76, +} RDI_RegCodeX64Enum; -//- binary sections typedef RDI_U32 RDI_BinarySectionFlags; -typedef enum RDI_BinarySectionFlagsEnum{ - RDI_BinarySectionFlag_Read = (1 << 0), - RDI_BinarySectionFlag_Write = (1 << 1), - RDI_BinarySectionFlag_Execute = (1 << 2) +typedef enum RDI_BinarySectionFlagsEnum +{ +RDI_BinarySectionFlag_Read = 1<<0, +RDI_BinarySectionFlag_Write = 1<<1, +RDI_BinarySectionFlag_Execute = 1<<2, } RDI_BinarySectionFlagsEnum; -typedef struct RDI_BinarySection{ - RDI_U32 name_string_idx; - RDI_BinarySectionFlags flags; - RDI_U64 voff_first; - RDI_U64 voff_opl; - RDI_U64 foff_first; - RDI_U64 foff_opl; -} RDI_BinarySection; - -//- file & file system info -typedef struct RDI_FilePathNode{ - RDI_U32 name_string_idx; - RDI_U32 parent_path_node; - RDI_U32 first_child; - RDI_U32 next_sibling; - RDI_U32 source_file_idx; -} RDI_FilePathNode; - -typedef struct RDI_SourceFile{ - RDI_U32 file_path_node_idx; - - RDI_U32 normal_full_path_string_idx; - - // usage of line map to go from a line number to an array of voffs - // (line_map_nums * line_number) -> (nil | index) - // (line_map_data * index) -> (range) - // (line_map_voff_data * range) -> (array(voff)) - - RDI_U32 line_map_count; - RDI_U32 line_map_nums_data_idx; // U32[line_map_count] (sorted - not closed ranges) - RDI_U32 line_map_range_data_idx; // U32[line_map_count + 1] (pairs form ranges) - RDI_U32 line_map_voff_data_idx; // U64[...] (idx by line_map_range_data) -} RDI_SourceFile; - - -//- units & line info -typedef struct RDI_Unit{ - RDI_U32 unit_name_string_idx; - RDI_U32 compiler_name_string_idx; - RDI_U32 source_file_path_node; - RDI_U32 object_file_path_node; - RDI_U32 archive_file_path_node; - RDI_U32 build_path_node; - RDI_Language language; - - // usage of line info to go from voff to file & line number: - // (line_info_voffs * voff) -> (nil + index) - // (line_info_data * index) -> (RDI_Line = (file_idx * line_number)) - - RDI_U32 line_info_voffs_data_idx; // U64[line_info_count + 1] (sorted ranges) - RDI_U32 line_info_data_idx; // RDI_Line[line_info_count] - RDI_U32 line_info_col_data_idx; // RDI_Col[line_info_count] - RDI_U32 line_info_count; -} RDI_Unit; - -typedef struct RDI_Line{ - RDI_U32 file_idx; - RDI_U32 line_num; -} RDI_Line; - -typedef struct RDI_Column{ - RDI_U16 col_first; - RDI_U16 col_opl; -} RDI_Column; - - -//- type info - -// X(name,code) - defines a primary code -// XZ(name,code size) - defines a primary code & associates a size -// Y(alias_name,name) - defines an alias for bookends -#define RDI_TypeKindXList(X,XZ,Y)\ -X(NULL, 0x0000) \ -\ -XZ(Void, 0x0001, 0) Y(FirstBuiltIn, Void) \ -XZ(Handle, 0x0002, 0xFFFFFFFF) \ -XZ(Char8, 0x0003, 1)\ -XZ(Char16, 0x0004, 2) \ -XZ(Char32, 0x0005, 4) \ -XZ(UChar8, 0x0006, 1) \ -XZ(UChar16, 0x0007, 2) \ -XZ(UChar32, 0x0008, 4) \ -XZ(U8, 0x0009, 1) \ -XZ(U16, 0x000A, 2) \ -XZ(U32, 0x000B, 4) \ -XZ(U64, 0x000C, 8) \ -XZ(U128, 0x000D, 16) \ -XZ(U256, 0x000E, 32) \ -XZ(U512, 0x000F, 64) \ -XZ(S8, 0x0010, 1) \ -XZ(S16, 0x0011, 2) \ -XZ(S32, 0x0012, 4) \ -XZ(S64, 0x0013, 8) \ -XZ(S128, 0x0014, 16) \ -XZ(S256, 0x0015, 32) \ -XZ(S512, 0x0016, 64) \ -XZ(Bool, 0x0017, 1) \ -XZ(F16, 0x0018, 2) \ -XZ(F32, 0x0019, 4) \ -XZ(F32PP, 0x001A, 4) \ -XZ(F48, 0x001B, 6) \ -XZ(F64, 0x001C, 8) \ -XZ(F80, 0x001D, 10) \ -XZ(F128, 0x001E, 16) \ -XZ(ComplexF32, 0x001F, 8) \ -XZ(ComplexF64, 0x0020, 16) \ -XZ(ComplexF80, 0x0021, 20) \ -XZ(ComplexF128, 0x0022, 32) Y(LastBuiltIn, ComplexF128) \ -\ -X(Modifier, 0x1000) Y(FirstConstructed, Modifier) \ -X(Ptr, 0x1001) \ -X(LRef, 0x1002) \ -X(RRef, 0x1003) \ -X(Array, 0x1004) \ -X(Function, 0x1005) \ -X(Method, 0x1006) \ -X(MemberPtr, 0x1007) Y(LastConstructed, MemberPtr) \ -\ -X(Struct, 0x2000) Y(FirstUserDefined, Struct) Y(FirstRecord, Struct) \ -X(Class, 0x2001) \ -X(Union, 0x2002) Y(LastRecord, Union) \ -X(Enum, 0x2003) \ -X(Alias, 0x2004) \ -X(IncompleteStruct, 0x2005) Y(FirstIncomplete, IncompleteStruct) \ -X(IncompleteUnion, 0x2006) \ -X(IncompleteClass, 0x2007) \ -X(IncompleteEnum, 0x2008) Y(LastIncomplete, IncompleteEnum) \ -Y(LastUserDefined, IncompleteEnum) \ -\ -X(Bitfield, 0xF000) \ -X(Variadic, 0xF001) +typedef RDI_U32 RDI_Language; +typedef enum RDI_LanguageEnum +{ +RDI_Language_NULL = 0, +RDI_Language_C = 1, +RDI_Language_CPlusPlus = 2, +RDI_Language_COUNT = 3, +} RDI_LanguageEnum; typedef RDI_U16 RDI_TypeKind; -typedef enum RDI_TypeKindEnum{ - -#define X(name,code) RDI_TypeKind_##name = code, -#define XZ(name,code,size) X(name,code) -#define Y(alias_name,name) RDI_TypeKind_##alias_name = RDI_TypeKind_##name, - RDI_TypeKindXList(X,XZ,Y) -#undef X -#undef XZ -#undef Y - +typedef enum RDI_TypeKindEnum +{ +RDI_TypeKind_NULL = 0x0000, +RDI_TypeKind_Void = 0x0001, +RDI_TypeKind_Handle = 0x0002, +RDI_TypeKind_Char8 = 0x0003, +RDI_TypeKind_Char16 = 0x0004, +RDI_TypeKind_Char32 = 0x0005, +RDI_TypeKind_UChar8 = 0x0006, +RDI_TypeKind_UChar16 = 0x0007, +RDI_TypeKind_UChar32 = 0x0008, +RDI_TypeKind_U8 = 0x0009, +RDI_TypeKind_U16 = 0x000A, +RDI_TypeKind_U32 = 0x000B, +RDI_TypeKind_U64 = 0x000C, +RDI_TypeKind_U128 = 0x000D, +RDI_TypeKind_U256 = 0x000E, +RDI_TypeKind_U512 = 0x000F, +RDI_TypeKind_S8 = 0x0010, +RDI_TypeKind_S16 = 0x0011, +RDI_TypeKind_S32 = 0x0012, +RDI_TypeKind_S64 = 0x0013, +RDI_TypeKind_S128 = 0x0014, +RDI_TypeKind_S256 = 0x0015, +RDI_TypeKind_S512 = 0x0016, +RDI_TypeKind_Bool = 0x0017, +RDI_TypeKind_F16 = 0x0018, +RDI_TypeKind_F32 = 0x0019, +RDI_TypeKind_F32PP = 0x001A, +RDI_TypeKind_F48 = 0x001B, +RDI_TypeKind_F64 = 0x001C, +RDI_TypeKind_F80 = 0x001D, +RDI_TypeKind_F128 = 0x001E, +RDI_TypeKind_ComplexF32 = 0x001F, +RDI_TypeKind_ComplexF64 = 0x0020, +RDI_TypeKind_ComplexF80 = 0x0021, +RDI_TypeKind_ComplexF128 = 0x0022, +RDI_TypeKind_Modifier = 0x1000, +RDI_TypeKind_Ptr = 0x1001, +RDI_TypeKind_LRef = 0x1002, +RDI_TypeKind_RRef = 0x1003, +RDI_TypeKind_Array = 0x1004, +RDI_TypeKind_Function = 0x1005, +RDI_TypeKind_Method = 0x1006, +RDI_TypeKind_MemberPtr = 0x1007, +RDI_TypeKind_Struct = 0x2000, +RDI_TypeKind_Class = 0x2001, +RDI_TypeKind_Union = 0x2002, +RDI_TypeKind_Enum = 0x2003, +RDI_TypeKind_Alias = 0x2004, +RDI_TypeKind_IncompleteStruct = 0x2005, +RDI_TypeKind_IncompleteUnion = 0x2006, +RDI_TypeKind_IncompleteClass = 0x2007, +RDI_TypeKind_IncompleteEnum = 0x2008, +RDI_TypeKind_Bitfield = 0xF000, +RDI_TypeKind_Variadic = 0xF001, +RDI_TypeKind_FirstBuiltIn = RDI_TypeKind_Void, +RDI_TypeKind_LastBuiltIn = RDI_TypeKind_ComplexF128, +RDI_TypeKind_FirstConstructed = RDI_TypeKind_Modifier, +RDI_TypeKind_LastConstructed = RDI_TypeKind_MemberPtr, +RDI_TypeKind_FirstUserDefined = RDI_TypeKind_Struct, +RDI_TypeKind_LastRecord = RDI_TypeKind_Union, +RDI_TypeKind_FirstIncomplete = RDI_TypeKind_IncompleteStruct, +RDI_TypeKind_LastIncomplete = RDI_TypeKind_IncompleteEnum, +RDI_TypeKind_FirstRecord = RDI_TypeKind_Struct, +RDI_TypeKind_LastUserDefined = RDI_TypeKind_IncompleteEnum, } RDI_TypeKindEnum; typedef RDI_U16 RDI_TypeModifierFlags; -enum{ - RDI_TypeModifierFlag_Const = (1 << 0), - RDI_TypeModifierFlag_Volatile = (1 << 1), +typedef enum RDI_TypeModifierFlagsEnum +{ +RDI_TypeModifierFlag_Const = 1<<0, +RDI_TypeModifierFlag_Volatile = 1<<1, +} RDI_TypeModifierFlagsEnum; + +typedef RDI_U32 RDI_UDTFlags; +typedef enum RDI_UDTFlagsEnum +{ +RDI_UDTFlag_EnumMembers = 1<<0, +} RDI_UDTFlagsEnum; + +typedef RDI_U16 RDI_MemberKind; +typedef enum RDI_MemberKindEnum +{ +RDI_MemberKind_NULL = 0x0000, +RDI_MemberKind_DataField = 0x0001, +RDI_MemberKind_StaticData = 0x0002, +RDI_MemberKind_Method = 0x0100, +RDI_MemberKind_StaticMethod = 0x0101, +RDI_MemberKind_VirtualMethod = 0x0102, +RDI_MemberKind_VTablePtr = 0x0200, +RDI_MemberKind_Base = 0x0201, +RDI_MemberKind_VirtualBase = 0x0202, +RDI_MemberKind_NestedType = 0x0300, +} RDI_MemberKindEnum; + +typedef RDI_U32 RDI_LinkFlags; +typedef enum RDI_LinkFlagsEnum +{ +RDI_LinkFlag_External = 1<<0, +RDI_LinkFlag_TypeScoped = 1<<1, +RDI_LinkFlag_ProcScoped = 1<<2, +} RDI_LinkFlagsEnum; + +typedef RDI_U32 RDI_LocalKind; +typedef enum RDI_LocalKindEnum +{ +RDI_LocalKind_NULL = 0x0, +RDI_LocalKind_Parameter = 0x1, +RDI_LocalKind_Variable = 0x2, +} RDI_LocalKindEnum; + +typedef RDI_U8 RDI_LocationKind; +typedef enum RDI_LocationKindEnum +{ +RDI_LocationKind_NULL = 0x0, +RDI_LocationKind_AddrBytecodeStream = 0x1, +RDI_LocationKind_ValBytecodeStream = 0x2, +RDI_LocationKind_AddrRegPlusU16 = 0x3, +RDI_LocationKind_AddrAddrRegPlusU16 = 0x4, +RDI_LocationKind_ValReg = 0x5, +} RDI_LocationKindEnum; + +typedef RDI_U8 RDI_EvalOp; +typedef enum RDI_EvalOpEnum +{ +RDI_EvalOp_Stop = 0, +RDI_EvalOp_Noop = 1, +RDI_EvalOp_Cond = 2, +RDI_EvalOp_Skip = 3, +RDI_EvalOp_MemRead = 4, +RDI_EvalOp_RegRead = 5, +RDI_EvalOp_RegReadDyn = 6, +RDI_EvalOp_FrameOff = 7, +RDI_EvalOp_ModuleOff = 8, +RDI_EvalOp_TLSOff = 9, +RDI_EvalOp_ObjectOff = 10, +RDI_EvalOp_CFA = 11, +RDI_EvalOp_ConstU8 = 12, +RDI_EvalOp_ConstU16 = 13, +RDI_EvalOp_ConstU32 = 14, +RDI_EvalOp_ConstU64 = 15, +RDI_EvalOp_Abs = 16, +RDI_EvalOp_Neg = 17, +RDI_EvalOp_Add = 18, +RDI_EvalOp_Sub = 19, +RDI_EvalOp_Mul = 20, +RDI_EvalOp_Div = 21, +RDI_EvalOp_Mod = 22, +RDI_EvalOp_LShift = 23, +RDI_EvalOp_RShift = 24, +RDI_EvalOp_BitAnd = 25, +RDI_EvalOp_BitOr = 26, +RDI_EvalOp_BitXor = 27, +RDI_EvalOp_BitNot = 28, +RDI_EvalOp_LogAnd = 29, +RDI_EvalOp_LogOr = 30, +RDI_EvalOp_LogNot = 31, +RDI_EvalOp_EqEq = 32, +RDI_EvalOp_NtEq = 33, +RDI_EvalOp_LsEq = 34, +RDI_EvalOp_GrEq = 35, +RDI_EvalOp_Less = 36, +RDI_EvalOp_Grtr = 37, +RDI_EvalOp_Trunc = 38, +RDI_EvalOp_TruncSigned = 39, +RDI_EvalOp_Convert = 40, +RDI_EvalOp_Pick = 41, +RDI_EvalOp_Pop = 42, +RDI_EvalOp_Insert = 43, +RDI_EvalOp_COUNT = 44, +} RDI_EvalOpEnum; + +typedef RDI_U8 RDI_EvalTypeGroup; +typedef enum RDI_EvalTypeGroupEnum +{ +RDI_EvalTypeGroup_Other = 0, +RDI_EvalTypeGroup_U = 1, +RDI_EvalTypeGroup_S = 2, +RDI_EvalTypeGroup_F32 = 3, +RDI_EvalTypeGroup_F64 = 4, +RDI_EvalTypeGroup_COUNT = 5, +} RDI_EvalTypeGroupEnum; + +typedef RDI_U8 RDI_EvalConversionKind; +typedef enum RDI_EvalConversionKindEnum +{ +RDI_EvalConversionKind_Noop = 0, +RDI_EvalConversionKind_Legal = 1, +RDI_EvalConversionKind_OtherToOther = 2, +RDI_EvalConversionKind_ToOther = 3, +RDI_EvalConversionKind_FromOther = 4, +RDI_EvalConversionKind_COUNT = 5, +} RDI_EvalConversionKindEnum; + +typedef RDI_U32 RDI_NameMapKind; +typedef enum RDI_NameMapKindEnum +{ +RDI_NameMapKind_NULL = 0, +RDI_NameMapKind_GlobalVariables = 1, +RDI_NameMapKind_ThreadVariables = 2, +RDI_NameMapKind_Procedures = 3, +RDI_NameMapKind_Types = 4, +RDI_NameMapKind_LinkNameProcedures = 5, +RDI_NameMapKind_NormalSourcePaths = 6, +RDI_NameMapKind_COUNT = 7, +} RDI_NameMapKindEnum; + +#define RDI_DataSectionTag_XList \ +X(NULL)\ +X(TopLevelInfo)\ +X(StringData)\ +X(StringTable)\ +X(IndexRuns)\ +X(BinarySections)\ +X(FilePathNodes)\ +X(SourceFiles)\ +X(Units)\ +X(UnitVmap)\ +X(TypeNodes)\ +X(UDTs)\ +X(Members)\ +X(EnumMembers)\ +X(GlobalVariables)\ +X(GlobalVmap)\ +X(ThreadVariables)\ +X(Procedures)\ +X(Scopes)\ +X(ScopeVoffData)\ +X(ScopeVmap)\ +X(Locals)\ +X(LocationBlocks)\ +X(LocationData)\ +X(NameMaps)\ +X(PRIMARY_COUNT)\ +X(SECONDARY)\ +X(LineInfoVoffs)\ +X(LineInfoData)\ +X(LineInfoColumns)\ +X(LineMapNumbers)\ +X(LineMapRanges)\ +X(LineMapVoffs)\ +X(NameMapBuckets)\ +X(NameMapNodes)\ + +#define RDI_DataSectionEncoding_XList \ +X(Unpacked)\ +X(LZB)\ + +#define RDI_Arch_XList \ +X(NULL)\ +X(X86)\ +X(X64)\ + +#define RDI_BinarySectionFlags_XList \ +X(NULL)\ +X(X86)\ +X(X64)\ + +#define RDI_Language_XList \ +X(NULL)\ +X(C)\ +X(CPlusPlus)\ +X(COUNT)\ + +#define RDI_TypeKind_XList \ +X(NULL)\ +X(Void)\ +X(Handle)\ +X(Char8)\ +X(Char16)\ +X(Char32)\ +X(UChar8)\ +X(UChar16)\ +X(UChar32)\ +X(U8)\ +X(U16)\ +X(U32)\ +X(U64)\ +X(U128)\ +X(U256)\ +X(U512)\ +X(S8)\ +X(S16)\ +X(S32)\ +X(S64)\ +X(S128)\ +X(S256)\ +X(S512)\ +X(Bool)\ +X(F16)\ +X(F32)\ +X(F32PP)\ +X(F48)\ +X(F64)\ +X(F80)\ +X(F128)\ +X(ComplexF32)\ +X(ComplexF64)\ +X(ComplexF80)\ +X(ComplexF128)\ +X(Modifier)\ +X(Ptr)\ +X(LRef)\ +X(RRef)\ +X(Array)\ +X(Function)\ +X(Method)\ +X(MemberPtr)\ +X(Struct)\ +X(Class)\ +X(Union)\ +X(Enum)\ +X(Alias)\ +X(IncompleteStruct)\ +X(IncompleteUnion)\ +X(IncompleteClass)\ +X(IncompleteEnum)\ +X(Bitfield)\ +X(Variadic)\ + +#define RDI_TypeModifierFlags_XList \ +X(Const)\ +X(Volatile)\ + +#define RDI_UDTFlag_XList \ +X(EnumMembers)\ + +#define RDI_MemberKind_XList \ +X(NULL)\ +X(DataField)\ +X(StaticData)\ +X(Method)\ +X(StaticMethod)\ +X(VirtualMethod)\ +X(VTablePtr)\ +X(Base)\ +X(VirtualBase)\ +X(NestedType)\ + +#define RDI_LinkFlags_XList \ +X(External)\ +X(TypeScoped)\ +X(ProcScoped)\ + +#define RDI_LocalKind_XList \ +X(NULL)\ +X(Parameter)\ +X(Variable)\ + +#define RDI_LocationKind_XList \ +X(NULL)\ +X(AddrBytecodeStream)\ +X(ValBytecodeStream)\ +X(AddrRegPlusU16)\ +X(AddrAddrRegPlusU16)\ +X(ValReg)\ + +#define RDI_EvalOp_XList \ +X(Stop)\ +X(Noop)\ +X(Cond)\ +X(Skip)\ +X(MemRead)\ +X(RegRead)\ +X(RegReadDyn)\ +X(FrameOff)\ +X(ModuleOff)\ +X(TLSOff)\ +X(ObjectOff)\ +X(CFA)\ +X(ConstU8)\ +X(ConstU16)\ +X(ConstU32)\ +X(ConstU64)\ +X(Abs)\ +X(Neg)\ +X(Add)\ +X(Sub)\ +X(Mul)\ +X(Div)\ +X(Mod)\ +X(LShift)\ +X(RShift)\ +X(BitAnd)\ +X(BitOr)\ +X(BitXor)\ +X(BitNot)\ +X(LogAnd)\ +X(LogOr)\ +X(LogNot)\ +X(EqEq)\ +X(NtEq)\ +X(LsEq)\ +X(GrEq)\ +X(Less)\ +X(Grtr)\ +X(Trunc)\ +X(TruncSigned)\ +X(Convert)\ +X(Pick)\ +X(Pop)\ +X(Insert)\ +X(COUNT)\ + +#define RDI_EvalTypeGroup_XList \ +X(Other)\ +X(U)\ +X(S)\ +X(F32)\ +X(F64)\ +X(COUNT)\ + +#define RDI_EvalConversionKind_XList \ +X(Noop)\ +X(Legal)\ +X(OtherToOther)\ +X(ToOther)\ +X(FromOther)\ +X(COUNT)\ + +#define RDI_NameMapKind_XList \ +X(NULL)\ +X(GlobalVariables)\ +X(ThreadVariables)\ +X(Procedures)\ +X(Types)\ +X(LinkNameProcedures)\ +X(NormalSourcePaths)\ +X(COUNT)\ + +#define RDI_EVAL_CTRLBITS(decodeN,popN,pushN) ((decodeN) | ((popN) << 4) | ((pushN) << 6)) +#define RDI_DECODEN_FROM_CTRLBITS(ctrlbits) ((ctrlbits) & 0xf) +#define RDI_POPN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 4) & 0x3) +#define RDI_PUSHN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 6) & 0x3) +#define RDI_EncodeRegReadParam(reg,bytesize,bytepos) ((reg)|((bytesize)<<8)|((bytepos)<<16)) + +typedef struct RDI_Header RDI_Header; +struct RDI_Header +{ +RDI_U64 magic; +RDI_U32 encoding_version; +RDI_U32 data_section_off; +RDI_U32 data_section_count; }; -// IMPORTANT NOTE: All type nodes in a valid raddbg are *topologically sorted*. -// That means any time a type node refers to another type node, the type node -// it refers to has an index less than or equal to the index of the node that -// is doing the referring. It is never the case that a type node depends on a -// node that comes later in the type node array. -// This restriction does not apply to the members of a type that are -// attached through a "UDT" though. +typedef struct RDI_DataSection RDI_DataSection; +struct RDI_DataSection +{ +RDI_DataSectionTag tag; +RDI_DataSectionEncoding encoding; +RDI_U64 off; +RDI_U64 encoded_size; +RDI_U64 unpacked_size; +}; -typedef struct RDI_TypeNode{ - RDI_TypeKind kind; - // when kind is 'Modifier' -> RDI_TypeModifierFlags - RDI_U16 flags; - - RDI_U32 byte_size; - - union{ +typedef struct RDI_VMapEntry RDI_VMapEntry; +struct RDI_VMapEntry +{ +RDI_U64 voff; +RDI_U64 idx; +}; + +typedef struct RDI_TopLevelInfo RDI_TopLevelInfo; +struct RDI_TopLevelInfo +{ +RDI_Arch arch; +RDI_U32 exe_name_string_idx; +RDI_U64 exe_hash; +RDI_U64 voff_max; +}; + +typedef struct RDI_BinarySection RDI_BinarySection; +struct RDI_BinarySection +{ +RDI_U32 name_string_idx; +RDI_BinarySectionFlags flags; +RDI_U64 voff_first; +RDI_U64 voff_opl; +RDI_U64 foff_first; +RDI_U64 foff_opl; +}; + +typedef struct RDI_FilePathNode RDI_FilePathNode; +struct RDI_FilePathNode +{ +RDI_U32 name_string_idx; +RDI_U32 parent_path_node; +RDI_U32 first_child; +RDI_U32 next_sibling; +RDI_U32 source_file_idx; +}; + +typedef struct RDI_SourceFile RDI_SourceFile; +struct RDI_SourceFile +{ +RDI_U32 file_path_node_idx; +RDI_U32 normal_full_path_string_idx; +RDI_U32 line_map_count; +RDI_U32 line_map_nums_data_idx; +RDI_U32 line_map_range_data_idx; +RDI_U32 line_map_voff_data_idx; +}; + +typedef struct RDI_Unit RDI_Unit; +struct RDI_Unit +{ +RDI_U32 unit_name_string_idx; +RDI_U32 compiler_name_string_idx; +RDI_U32 source_file_path_node; +RDI_U32 object_file_path_node; +RDI_U32 archive_file_path_node; +RDI_U32 build_path_node; +RDI_Language language; +RDI_U32 line_info_voffs_data_idx; +RDI_U32 line_info_data_idx; +RDI_U32 line_info_col_data_idx; +RDI_U32 line_info_count; +}; + +typedef struct RDI_Line RDI_Line; +struct RDI_Line +{ +RDI_U32 file_idx; +RDI_U32 line_num; +}; + +typedef struct RDI_Column RDI_Column; +struct RDI_Column +{ +RDI_U16 col_first; +RDI_U16 col_opl; +}; + +typedef struct RDI_TypeNode RDI_TypeNode; +struct RDI_TypeNode +{ +RDI_TypeKind kind; +RDI_U16 flags; +RDI_U32 byte_size; + + union + { // kind is 'built-in' - struct{ + struct + { RDI_U32 name_string_idx; } built_in; // kind is 'constructed' - struct{ + struct + { RDI_U32 direct_type_idx; RDI_U32 count; union{ @@ -526,402 +840,170 @@ typedef struct RDI_TypeNode{ } constructed; // kind is 'user defined' - struct{ + struct + { RDI_U32 name_string_idx; RDI_U32 direct_type_idx; RDI_U32 udt_idx; } user_defined; // (kind = Bitfield) - struct{ + struct + { RDI_U32 direct_type_idx; RDI_U32 off; RDI_U32 size; } bitfield; - }; -} RDI_TypeNode; - -typedef RDI_U32 RDI_UDTFlags; -enum{ - RDI_UDTFlag_EnumMembers = (1 << 0), + } + ; }; -typedef struct RDI_UDT{ - RDI_U32 self_type_idx; - RDI_UDTFlags flags; - - // when EnumMembers flag is set, indexes into enum "enum_members" instead of "members" - RDI_U32 member_first; - RDI_U32 member_count; - - RDI_U32 file_idx; - RDI_U32 line; - RDI_U32 col; -} RDI_UDT; - -#define RDI_MemberKindXList(X) \ -X(NULL, 0x0000) \ -X(DataField, 0x0001) \ -X(StaticData, 0x0002) \ -X(Method, 0x0100) \ -X(StaticMethod, 0x0101) \ -X(VirtualMethod, 0x0102) \ -X(VTablePtr, 0x0200) \ -X(Base, 0x0201) \ -X(VirtualBase, 0x0202) \ -X(NestedType, 0x0300) - -typedef RDI_U16 RDI_MemberKind; -typedef enum RDI_MemberKindEnum{ -#define X(N,C) RDI_MemberKind_##N = C, - RDI_MemberKindXList(X) -#undef X -} RDI_MemberKindEnum; - -// TODO(allen): need a way to equip methods and some virtual methods -// with procedure symbol information. I'm thinking a seperate data -// array of (MemberIdx,ProcSymbolIdx) sorted by MemberIdx. Or just a -// parallel array. Putting them right into this struct looks like it -// would complicate the converters because we tend to want an API -// like 'associate_method_to_proc' that can be used *after* both the -// method and proc are known, rather than one that forces us to know -// the association when constructing the member data. -typedef struct RDI_Member{ - RDI_MemberKind kind; - RDI_U16 __unused__; - - RDI_U32 name_string_idx; - RDI_U32 type_idx; - RDI_U32 off; -} RDI_Member; - -typedef struct RDI_EnumMember{ - RDI_U32 name_string_idx; - RDI_U32 __unused__; - RDI_U64 val; -} RDI_EnumMember; - - -//- symbol info -typedef RDI_U32 RDI_LinkFlags; -enum{ - RDI_LinkFlag_External = (1 << 0), - // NOTE: Scope flags are mutually exclusive. - // A symbol is either global scoped, type scoped, or procedure scoped. - RDI_LinkFlag_TypeScoped = (1 << 1), - RDI_LinkFlag_ProcScoped = (1 << 2), +typedef struct RDI_UDT RDI_UDT; +struct RDI_UDT +{ +RDI_U32 self_type_idx; +RDI_UDTFlags flags; +RDI_U32 member_first; +RDI_U32 member_count; +RDI_U32 file_idx; +RDI_U32 line; +RDI_U32 col; }; -typedef struct RDI_GlobalVariable{ - RDI_U32 name_string_idx; - // NOTE: "global variables" can be scoped in *any* way. The scope flags here refer to - // *namespace* scoping. "global variables" are all in the data section of the - // final exe/dll type file, so they are "global" in the life-time sense of the - // word. In the namespace sense of the word, they can be scoped globally, by type, - // or by procedure. - RDI_LinkFlags link_flags; - RDI_U64 voff; - RDI_U32 type_idx; - - // container_idx: UDT for "TypeScoped", Procedure for "ProcScoped" - RDI_U32 container_idx; -} RDI_GlobalVariable; - -typedef struct RDI_ThreadVariable{ - RDI_U32 name_string_idx; - // NOTE: See the note in GlobalVariable regarding scoping. The same concept applies here. - RDI_LinkFlags link_flags; - RDI_U32 tls_off; - RDI_U32 type_idx; - - // container_idx: UDT for "TypeScoped", Procedure for "ProcScoped" - RDI_U32 container_idx; -} RDI_ThreadVariable; - -typedef struct RDI_Procedure{ - RDI_U32 name_string_idx; - RDI_U32 link_name_string_idx; - // NOTE: See the note in GlobalVariable regarding scoping. The same concept applies here. - RDI_LinkFlags link_flags; - RDI_U32 type_idx; - RDI_U32 root_scope_idx; - - // container_idx: UDT for "TypeScoped", Procedure for "ProcScoped" - RDI_U32 container_idx; -} RDI_Procedure; - -typedef struct RDI_Scope{ - RDI_U32 proc_idx; - RDI_U32 parent_scope_idx; - RDI_U32 first_child_scope_idx; - RDI_U32 next_sibling_scope_idx; - - RDI_U32 voff_range_first; - RDI_U32 voff_range_opl; - - // indexes into "locals" - RDI_U32 local_first; - RDI_U32 local_count; - - RDI_U32 static_local_idx_run_first; - RDI_U32 static_local_count; - - // TODO(allen): attach less common scope-relevant info -} RDI_Scope; - -typedef RDI_U32 RDI_LocalKind; -typedef enum{ - RDI_LocalKind_NULL, - RDI_LocalKind_Parameter, - RDI_LocalKind_Variable, - RDI_LocalKind_COUNT -} RDI_LocalKindEnum; - -typedef struct RDI_Local{ - RDI_LocalKind kind; - RDI_U32 name_string_idx; - RDI_U64 type_idx; - // indexes into "location_blocks" - RDI_U32 location_first; - RDI_U32 location_opl; -} RDI_Local; - -typedef struct RDI_LocationBlock{ - RDI_U32 scope_off_first; - RDI_U32 scope_off_opl; - RDI_U32 location_data_off; -} RDI_LocationBlock; - -typedef RDI_U8 RDI_LocationKind; -typedef enum{ - RDI_LocationKind_NULL, - RDI_LocationKind_AddrBytecodeStream, - RDI_LocationKind_ValBytecodeStream, - RDI_LocationKind_AddrRegPlusU16, - RDI_LocationKind_AddrAddrRegPlusU16, - RDI_LocationKind_ValReg, - RDI_LocationKind_COUNT -} RDI_LocationKindEnum; - -typedef struct RDI_LocationBytecodeStream{ - RDI_LocationKind kind; - // [... 0] null terminated byte sequence RDI_EvalBytecodeStream -} RDI_LocationBytecodeStream; - -typedef struct RDI_LocationRegPlusU16{ - RDI_LocationKind kind; - RDI_RegCode reg_code; - RDI_U16 offset; -} RDI_LocationRegPlusU16; - -typedef struct RDI_LocationReg{ - RDI_LocationKind kind; - RDI_RegCode reg_code; -} RDI_LocationReg; - -//- name map types -#define RDI_NameMapXList(X)\ -X(NULL, 0)\ -X(GlobalVariables, 1)\ -X(ThreadVariables, 2)\ -X(Procedures, 3)\ -X(Types, 4)\ -X(LinkNameProcedures, 5)\ -X(NormalSourcePaths, 6) - -typedef RDI_U32 RDI_NameMapKind; -typedef enum RDI_NameMapKindEnum{ -#define X(N,C) RDI_NameMapKind_##N = C, - RDI_NameMapXList(X) -#undef X - - RDI_NameMapKind_COUNT -} RDI_NameMapKindEnum; - -// TODO(allen): documentation here for the hashing and probing strategy for this table - -typedef struct RDI_NameMap{ - RDI_NameMapKind kind; - RDI_U32 bucket_data_idx; - RDI_U32 node_data_idx; -} RDI_NameMap; - -typedef struct RDI_NameMapBucket{ - RDI_U32 first_node; - RDI_U32 node_count; -} RDI_NameMapBucket; - -typedef struct RDI_NameMapNode{ - RDI_U32 string_idx; - RDI_U32 match_count; - // NOTE: if (match_count == 1) then this is the index of the matching item - // if (match_count > 1) then this is the first for an index run of all the matches - RDI_U32 match_idx_or_idx_run_first; -} RDI_NameMapNode; - - -//////////////////////////////// -// Eval Bytecode - -// (Name, decodeN, popN, pushN) -#define RDI_EvalOpXList(X)\ -X(Stop, 0, 0, 0)\ -X(Noop, 0, 0, 0)\ -X(Cond, 1, 1, 0)\ -X(Skip, 1, 0, 0)\ -X(MemRead, 1, 1, 1)\ -X(RegRead, 4, 0, 1)\ -X(RegReadDyn, 0, 1, 1)\ -X(FrameOff, 1, 0, 1)\ -X(ModuleOff, 4, 0, 1)\ -X(TLSOff, 4, 0, 1)\ -X(ObjectOff, 0, 0, 0)\ -X(CFA, 0, 0, 0)\ -X(ConstU8, 1, 0, 1)\ -X(ConstU16, 2, 0, 1)\ -X(ConstU32, 4, 0, 1)\ -X(ConstU64, 8, 0, 1)\ -X(Abs, 1, 1, 1)\ -X(Neg, 1, 1, 1)\ -X(Add, 1, 2, 1)\ -X(Sub, 1, 2, 1)\ -X(Mul, 1, 2, 1)\ -X(Div, 1, 2, 1)\ -X(Mod, 1, 2, 1)\ -X(LShift, 1, 2, 1)\ -X(RShift, 1, 2, 1)\ -X(BitAnd, 1, 2, 1)\ -X(BitOr, 1, 2, 1)\ -X(BitXor, 1, 2, 1)\ -X(BitNot, 1, 1, 1)\ -X(LogAnd, 1, 2, 1)\ -X(LogOr, 1, 2, 1)\ -X(LogNot, 1, 1, 1)\ -X(EqEq, 1, 2, 1)\ -X(NtEq, 1, 2, 1)\ -X(LsEq, 1, 2, 1)\ -X(GrEq, 1, 2, 1)\ -X(Less, 1, 2, 1)\ -X(Grtr, 1, 2, 1)\ -X(Trunc, 1, 1, 1)\ -X(TruncSigned, 1, 1, 1)\ -X(Convert, 2, 1, 1)\ -X(Pick, 1, 0, 1)\ -X(Pop, 0, 1, 0)\ -X(Insert, 1, 0, 0) - -// (Name) -#define RDI_EvalTypeGroupXList(X)\ -X(Other)\ -X(U)\ -X(S)\ -X(F32)\ -X(F64) - -// (Name, error-message) -#define RDI_EvalConversionKindXList(X)\ -X(Noop, "")\ -X(Legal, "")\ -X(OtherToOther, "cannot convert between these types")\ -X(ToOther, "cannot convert to this type")\ -X(FromOther, "cannot convert this type") - -// Xb(EvalTypeGroup) Y(TypeKind) Xe(EvalTypeGroup) -#define RDI_EvalTypeGroupFromKindMap(Y,Xb,Xe)\ -\ -Xb(U) Y(U8) Y(U16) Y(U32) Y(U64) Y(Bool) Y(Ptr) Y(Enum)\ -Xe(U)\ -\ -Xb(S) Y(S8) Y(S16) Y(S32) Y(S64)\ -Xe(S)\ -\ -Xb(F32) Y(F32)\ -Xe(F32)\ -\ -Xb(F64) Y(F64)\ -Xe(F64) - -// Xb(EvalConversionKind) Y(EvalTypeGroup, EvalTypeGroup) Xe(EvalConversionKind) -#define RDI_EvalConversionKindFromTypeGroupPairMap(Y,Xb,Xe)\ -\ -Xb(Noop) Y(U, U) Y(S, S) Y(F32, F32) Y(F64, F64) Y(U, S) Y(S, U)\ -Xe(Noop)\ -\ -Xb(Legal)\ -Y(U, F32) Y(S, F32) Y(F32, U) Y(F32, S)\ -Y(U, F64) Y(S, F64) Y(F64, U) Y(F64, S)\ -Y(F32, F64) Y(F64, F32)\ -Xe(Legal)\ -\ -Xb(OtherToOther) Y(Other, Other)\ -Xe(OtherToOther)\ -\ -Xb(ToOther) Y(U, Other) Y(S, Other) Y(F32, Other) Y(F64, Other)\ -Xe(ToOther)\ -\ -Xb(FromOther) Y(Other, U) Y(Other, S) Y(Other, F32) Y(Other, F64)\ -Xe(FromOther) - -// eval interpretation macros -#define RDI_EncodeRegReadParam(reg,bytesize,bytepos) ((reg)|((bytesize)<<8)|((bytepos)<<16)) - - -// eval enums -typedef RDI_U8 RDI_EvalOp; - -typedef enum RDI_EvalOpEnum{ -#define X(N,dec,pop,push) RDI_EvalOp_##N, - RDI_EvalOpXList(X) -#undef X - - RDI_EvalOp_COUNT -} RDI_EvalOpEnum; - - -typedef RDI_U8 RDI_EvalTypeGroup; - -typedef enum RDI_EvalTypeGroupEnum{ -#define X(N) RDI_EvalTypeGroup_##N, - RDI_EvalTypeGroupXList(X) -#undef X - RDI_EvalTypeGroup_COUNT, -} RDI_EvalTypeGroupEnum; - - -typedef RDI_U8 RDI_EvalConversionKind; - -typedef enum RDI_EvalConversionKindEnum{ -#define X(N,msg) RDI_EvalConversionKind_##N, - RDI_EvalConversionKindXList(X) -#undef X - RDI_EvalConversionKind_COUNT, -} RDI_EvalConversionKindEnum; - - -//- eval data tables - -#define RDI_EVAL_CTRLBITS(decodeN,popN,pushN) ((decodeN) | ((popN) << 4) | ((pushN) << 6)) -#define RDI_DECODEN_FROM_CTRLBITS(ctrlbits) ((ctrlbits) & 0xf) -#define RDI_POPN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 4) & 0x3) -#define RDI_PUSHN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 6) & 0x3) - -static RDI_U8 rdi_eval_op_ctrlbits_table[] = { -#define X(Name, decodeN, popN, pushN) RDI_EVAL_CTRLBITS(decodeN,popN,pushN), - RDI_EvalOpXList(X) -#undef X +typedef struct RDI_Member RDI_Member; +struct RDI_Member +{ +RDI_MemberKind kind; +RDI_U16 pad; +RDI_U32 name_string_idx; +RDI_U32 type_idx; +RDI_U32 off; }; -//////////////////////////////// -// Functions +typedef struct RDI_EnumMember RDI_EnumMember; +struct RDI_EnumMember +{ +RDI_U32 name_string_idx; +RDI_U32 pad; +RDI_U64 val; +}; + +typedef struct RDI_GlobalVariable RDI_GlobalVariable; +struct RDI_GlobalVariable +{ +RDI_U32 name_string_idx; +RDI_LinkFlags link_flags; +RDI_U64 voff; +RDI_U32 type_idx; +RDI_U32 container_idx; +}; + +typedef struct RDI_ThreadVariable RDI_ThreadVariable; +struct RDI_ThreadVariable +{ +RDI_U32 name_string_idx; +RDI_LinkFlags link_flags; +RDI_U32 tls_off; +RDI_U32 type_idx; +RDI_U32 container_idx; +}; + +typedef struct RDI_Procedure RDI_Procedure; +struct RDI_Procedure +{ +RDI_U32 name_string_idx; +RDI_U32 link_name_string_idx; +RDI_LinkFlags link_flags; +RDI_U32 type_idx; +RDI_U32 root_scope_idx; +RDI_U32 container_idx; +}; + +typedef struct RDI_Scope RDI_Scope; +struct RDI_Scope +{ +RDI_U32 proc_idx; +RDI_U32 parent_scope_idx; +RDI_U32 first_child_scope_idx; +RDI_U32 next_sibling_scope_idx; +RDI_U32 voff_range_first; +RDI_U32 voff_range_opl; +RDI_U32 local_first; +RDI_U32 local_count; +RDI_U32 static_local_idx_run_first; +RDI_U32 static_local_count; +}; + +typedef struct RDI_Local RDI_Local; +struct RDI_Local +{ +RDI_LocalKind kind; +RDI_U32 name_string_idx; +RDI_U32 type_idx; +RDI_U32 pad; +RDI_U32 location_first; +RDI_U32 location_opl; +}; + +typedef struct RDI_LocationBlock RDI_LocationBlock; +struct RDI_LocationBlock +{ +RDI_U32 scope_off_first; +RDI_U32 scope_off_opl; +RDI_U32 location_data_off; +}; + +typedef struct RDI_LocationBytecodeStream RDI_LocationBytecodeStream; +struct RDI_LocationBytecodeStream +{ +RDI_LocationKind kind; +}; + +typedef struct RDI_LocationRegPlusU16 RDI_LocationRegPlusU16; +struct RDI_LocationRegPlusU16 +{ +RDI_LocationKind kind; +RDI_RegCode reg_code; +RDI_U16 offset; +}; + +typedef struct RDI_LocationReg RDI_LocationReg; +struct RDI_LocationReg +{ +RDI_LocationKind kind; +RDI_RegCode reg_code; +}; + +typedef struct RDI_NameMap RDI_NameMap; +struct RDI_NameMap +{ +RDI_NameMapKind kind; +RDI_U32 bucket_data_idx; +RDI_U32 node_data_idx; +}; + +typedef struct RDI_NameMapBucket RDI_NameMapBucket; +struct RDI_NameMapBucket +{ +RDI_U32 first_node; +RDI_U32 node_count; +}; + +typedef struct RDI_NameMapNode RDI_NameMapNode; +struct RDI_NameMapNode +{ +RDI_U32 string_idx; +RDI_U32 match_count; +RDI_U32 match_idx_or_idx_run_first; +}; RDI_PROC RDI_U64 rdi_hash(RDI_U8 *ptr, RDI_U64 size); RDI_PROC RDI_U32 rdi_size_from_basic_type_kind(RDI_TypeKind kind); RDI_PROC RDI_U32 rdi_addr_size_from_arch(RDI_Arch arch); - -//- eval helpers - RDI_PROC RDI_EvalConversionKind rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out); -RDI_PROC RDI_U8* rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind conversion_kind, RDI_U64 *lennout); RDI_PROC RDI_S32 rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group); +RDI_PROC RDI_U8 *rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out); + +extern RDI_U8 rdi_eval_op_ctrlbits_table[45]; #endif // RDI_FORMAT_H diff --git a/src/metagen/metagen_main.c b/src/metagen/metagen_main.c index 1f3f5401..1ff486e8 100644 --- a/src/metagen/metagen_main.c +++ b/src/metagen/metagen_main.c @@ -515,12 +515,17 @@ int main(int argument_count, char **arguments) for(MG_LayerNode *n = slot->first; n != 0; n = n->next) { MG_Layer *layer = &n->v; - String8 gen_folder = str8_lit("generated"); + String8 layer_generated_folder = {0}; if(layer->gen_folder_name.size != 0) { - gen_folder = layer->gen_folder_name; + String8 gen_folder = layer->gen_folder_name; + layer_generated_folder = push_str8f(mg_arena, "%S/%S", code_dir_path, gen_folder); + } + else + { + String8 gen_folder = str8_lit("generated"); + layer_generated_folder = push_str8f(mg_arena, "%S/%S/%S", code_dir_path, layer->key, gen_folder); } - String8 layer_generated_folder = push_str8f(mg_arena, "%S/%S/%S", code_dir_path, layer->key, gen_folder); if(os_make_directory(layer_generated_folder)) { String8List layer_key_parts = str8_split_path(mg_arena, layer->key); diff --git a/src/rdi_format/lib/rdi_format.c b/src/rdi_format/lib/rdi_format.c deleted file mode 100644 index ef9eea1b..00000000 --- a/src/rdi_format/lib/rdi_format.c +++ /dev/null @@ -1,196 +0,0 @@ -// Copyright (c) 2024 Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//////////////////////////////////////////////////////////////// -//~ RAD Debug Info, (R)AD(D)BG(I) Format Library -// -// Defines standard RDI debug information format types and -// functions. - -#ifndef RDI_FORMAT_C -#define RDI_FORMAT_C - -RDI_U8 rdi_eval_op_ctrlbits_table[45] = -{ -RDI_EVAL_CTRLBITS(0, 0, 0), -RDI_EVAL_CTRLBITS(0, 0, 0), -RDI_EVAL_CTRLBITS(1, 1, 0), -RDI_EVAL_CTRLBITS(1, 0, 0), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(4, 0, 1), -RDI_EVAL_CTRLBITS(0, 1, 1), -RDI_EVAL_CTRLBITS(1, 0, 1), -RDI_EVAL_CTRLBITS(4, 0, 1), -RDI_EVAL_CTRLBITS(4, 0, 1), -RDI_EVAL_CTRLBITS(0, 0, 0), -RDI_EVAL_CTRLBITS(0, 0, 0), -RDI_EVAL_CTRLBITS(1, 0, 1), -RDI_EVAL_CTRLBITS(2, 0, 1), -RDI_EVAL_CTRLBITS(4, 0, 1), -RDI_EVAL_CTRLBITS(8, 0, 1), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 2, 1), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(1, 1, 1), -RDI_EVAL_CTRLBITS(2, 1, 1), -RDI_EVAL_CTRLBITS(1, 0, 1), -RDI_EVAL_CTRLBITS(0, 1, 0), -RDI_EVAL_CTRLBITS(1, 0, 0), -RDI_EVAL_CTRLBITS(0, 0, 0), -}; - -struct {RDI_EvalConversionKind dst_typegroups[RDI_EvalTypeGroup_COUNT];} rdi_eval_typegroup_conversion_kind_matrix[6] = -{ -{{RDI_EvalConversionKind_OtherToOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther, RDI_EvalConversionKind_FromOther}}, -{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal}}, -{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal}}, -{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Legal}}, -{{RDI_EvalConversionKind_ToOther, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Legal, RDI_EvalConversionKind_Noop}}, -{{RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop, RDI_EvalConversionKind_Noop}}, -}; - -struct {RDI_U8 *str; RDI_U64 size;} rdi_eval_conversion_kind_message_string_table[6] = -{ -{(RDI_U8 *)"Other", sizeof("Other")}, -{(RDI_U8 *)"U", sizeof("U")}, -{(RDI_U8 *)"S", sizeof("S")}, -{(RDI_U8 *)"F32", sizeof("F32")}, -{(RDI_U8 *)"F64", sizeof("F64")}, -{(RDI_U8 *)"COUNT", sizeof("COUNT")}, -}; - -RDI_PROC RDI_U64 -rdi_hash(RDI_U8 *ptr, RDI_U64 size) -{ - RDI_U64 result = 5381; - RDI_U8 *opl = ptr + size; - for(;ptr < opl; ptr += 1) - { - result = ((result << 5) + result) + *ptr; - } - return result; -} - -RDI_PROC RDI_U32 -rdi_size_from_basic_type_kind(RDI_TypeKind kind) -{ -RDI_U32 result = 0; -switch(kind) -{ -default:{}break; -case RDI_TypeKind_Handle:{result = 0xFFFFFFFF;}break; -case RDI_TypeKind_Char8:{result = 1;}break; -case RDI_TypeKind_Char16:{result = 2;}break; -case RDI_TypeKind_Char32:{result = 4;}break; -case RDI_TypeKind_UChar8:{result = 1;}break; -case RDI_TypeKind_UChar16:{result = 2;}break; -case RDI_TypeKind_UChar32:{result = 4;}break; -case RDI_TypeKind_U8:{result = 1;}break; -case RDI_TypeKind_U16:{result = 2;}break; -case RDI_TypeKind_U32:{result = 4;}break; -case RDI_TypeKind_U64:{result = 8;}break; -case RDI_TypeKind_U128:{result = 16;}break; -case RDI_TypeKind_U256:{result = 32;}break; -case RDI_TypeKind_U512:{result = 64;}break; -case RDI_TypeKind_S8:{result = 1;}break; -case RDI_TypeKind_S16:{result = 2;}break; -case RDI_TypeKind_S32:{result = 4;}break; -case RDI_TypeKind_S64:{result = 8;}break; -case RDI_TypeKind_S128:{result = 16;}break; -case RDI_TypeKind_S256:{result = 32;}break; -case RDI_TypeKind_S512:{result = 64;}break; -case RDI_TypeKind_Bool:{result = 1;}break; -case RDI_TypeKind_F16:{result = 2;}break; -case RDI_TypeKind_F32:{result = 4;}break; -case RDI_TypeKind_F32PP:{result = 4;}break; -case RDI_TypeKind_F48:{result = 6;}break; -case RDI_TypeKind_F64:{result = 8;}break; -case RDI_TypeKind_F80:{result = 10;}break; -case RDI_TypeKind_F128:{result = 16;}break; -case RDI_TypeKind_ComplexF32:{result = 8;}break; -case RDI_TypeKind_ComplexF64:{result = 16;}break; -case RDI_TypeKind_ComplexF80:{result = 20;}break; -case RDI_TypeKind_ComplexF128:{result = 32;}break; -} -return result; -} - -RDI_PROC RDI_U32 -rdi_addr_size_from_arch(RDI_Arch arch) -{ -RDI_U32 result = 0; -switch(arch) -{ -default:{}break; -case RDI_Arch_X86:{result = 4;}break; -case RDI_Arch_X64:{result = 8;}break; -} -return result; -} - -RDI_PROC RDI_EvalConversionKind -rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out) -{ - RDI_EvalConversionKind k = rdi_eval_typegroup_conversion_kind_matrix[in].dst_typegroups[out]; - return k; -} - -RDI_PROC RDI_S32 -rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group) -{ - RDI_S32 result = 0; - switch(op) - { - case RDI_EvalOp_Neg: case RDI_EvalOp_Add: case RDI_EvalOp_Sub: - case RDI_EvalOp_Mul: case RDI_EvalOp_Div: - case RDI_EvalOp_EqEq:case RDI_EvalOp_NtEq: - case RDI_EvalOp_LsEq:case RDI_EvalOp_GrEq: - case RDI_EvalOp_Less:case RDI_EvalOp_Grtr: - { - if(group != RDI_EvalTypeGroup_Other) - { - result = 1; - } - }break; - case RDI_EvalOp_Mod:case RDI_EvalOp_LShift:case RDI_EvalOp_RShift: - case RDI_EvalOp_BitNot:case RDI_EvalOp_BitAnd:case RDI_EvalOp_BitXor: - case RDI_EvalOp_BitOr:case RDI_EvalOp_LogNot:case RDI_EvalOp_LogAnd: - case RDI_EvalOp_LogOr: - { - if(group == RDI_EvalTypeGroup_S || group == RDI_EvalTypeGroup_U) - { - result = 1; - } - }break; - } - return result; -} - -RDI_PROC RDI_U8 * -rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out) -{ - *size_out = rdi_eval_conversion_kind_message_string_table[kind].size; - return rdi_eval_conversion_kind_message_string_table[kind].str; -} - -#endif // RDI_FORMAT_C diff --git a/src/rdi_format/lib/rdi_format.h b/src/rdi_format/lib/rdi_format.h deleted file mode 100644 index ddd1cf7e..00000000 --- a/src/rdi_format/lib/rdi_format.h +++ /dev/null @@ -1,1009 +0,0 @@ -// Copyright (c) 2024 Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//////////////////////////////////////////////////////////////// -//~ RAD Debug Info, (R)AD(D)BG(I) Format Library -// -// Defines standard RDI debug information format types and -// functions. - -#ifndef RDI_FORMAT_H -#define RDI_FORMAT_H - -//////////////////////////////////////////////////////////////// -//~ Overridable Procedure Decoration - -#if !defined(RDI_PROC) -# define RDI_PROC static -#endif - -//////////////////////////////////////////////////////////////// -//~ Overridable Basic Integer Types - -#if !defined(RDI_U8) -# define RDI_U8 RDI_U8 -# define RDI_U16 RDI_U16 -# define RDI_U32 RDI_U32 -# define RDI_U64 RDI_U64 -# define RDI_S8 RDI_S8 -# define RDI_S16 RDI_S16 -# define RDI_S32 RDI_S32 -# define RDI_S64 RDI_S64 -#include -typedef uint8_t RDI_U8; -typedef uint16_t RDI_U16; -typedef uint32_t RDI_U32; -typedef uint64_t RDI_U64; -typedef int8_t RDI_S8; -typedef int16_t RDI_S16; -typedef int32_t RDI_S32; -typedef int64_t RDI_S64; -#endif - -//////////////////////////////////////////////////////////////// -//~ Format Constants - -// \"raddbg\0\0\" -#define RDI_MAGIC_CONSTANT 0x0000676264646172 -#define RDI_ENCODING_VERSION 1 - -//////////////////////////////////////////////////////////////// -//~ Format Types & Functions - -typedef RDI_U32 RDI_DataSectionTag; -typedef enum RDI_DataSectionTagEnum -{ -RDI_DataSectionTag_NULL = 0x0000, -RDI_DataSectionTag_TopLevelInfo = 0x0001, -RDI_DataSectionTag_StringData = 0x0002, -RDI_DataSectionTag_StringTable = 0x0003, -RDI_DataSectionTag_IndexRuns = 0x0004, -RDI_DataSectionTag_BinarySections = 0x0005, -RDI_DataSectionTag_FilePathNodes = 0x0006, -RDI_DataSectionTag_SourceFiles = 0x0007, -RDI_DataSectionTag_Units = 0x0008, -RDI_DataSectionTag_UnitVmap = 0x0009, -RDI_DataSectionTag_TypeNodes = 0x000A, -RDI_DataSectionTag_UDTs = 0x000B, -RDI_DataSectionTag_Members = 0x000C, -RDI_DataSectionTag_EnumMembers = 0x000D, -RDI_DataSectionTag_GlobalVariables = 0x000E, -RDI_DataSectionTag_GlobalVmap = 0x000F, -RDI_DataSectionTag_ThreadVariables = 0x0010, -RDI_DataSectionTag_Procedures = 0x0011, -RDI_DataSectionTag_Scopes = 0x0012, -RDI_DataSectionTag_ScopeVoffData = 0x0013, -RDI_DataSectionTag_ScopeVmap = 0x0014, -RDI_DataSectionTag_Locals = 0x0015, -RDI_DataSectionTag_LocationBlocks = 0x0016, -RDI_DataSectionTag_LocationData = 0x0017, -RDI_DataSectionTag_NameMaps = 0x0018, -RDI_DataSectionTag_PRIMARY_COUNT = 0x0019, -RDI_DataSectionTag_SECONDARY = 0x80000000, -RDI_DataSectionTag_LineInfoVoffs = RDI_DataSectionTag_SECONDARY|0x0001, -RDI_DataSectionTag_LineInfoData = RDI_DataSectionTag_SECONDARY|0x0002, -RDI_DataSectionTag_LineInfoColumns = RDI_DataSectionTag_SECONDARY|0x0003, -RDI_DataSectionTag_LineMapNumbers = RDI_DataSectionTag_SECONDARY|0x0004, -RDI_DataSectionTag_LineMapRanges = RDI_DataSectionTag_SECONDARY|0x0005, -RDI_DataSectionTag_LineMapVoffs = RDI_DataSectionTag_SECONDARY|0x0006, -RDI_DataSectionTag_NameMapBuckets = RDI_DataSectionTag_SECONDARY|0x0007, -RDI_DataSectionTag_NameMapNodes = RDI_DataSectionTag_SECONDARY|0x0008, -} RDI_DataSectionTagEnum; - -typedef RDI_U32 RDI_DataSectionEncoding; -typedef enum RDI_DataSectionEncodingEnum -{ -RDI_DataSectionEncoding_Unpacked = 0, -RDI_DataSectionEncoding_LZB = 1, -} RDI_DataSectionEncodingEnum; - -typedef RDI_U32 RDI_Arch; -typedef enum RDI_ArchEnum -{ -RDI_Arch_NULL = 0, -RDI_Arch_X86 = 1, -RDI_Arch_X64 = 2, -} RDI_ArchEnum; - -typedef RDI_U8 RDI_RegCode; -typedef enum RDI_RegCodeEnum -{ -RDI_RegCode_nil, -} RDI_RegCodeEnum; - -typedef RDI_U8 RDI_RegCodeX86; -typedef enum RDI_RegCodeX86Enum -{ -RDI_RegCodeX86_nil = 0, -RDI_RegCodeX86_eax = 1, -RDI_RegCodeX86_ecx = 2, -RDI_RegCodeX86_edx = 3, -RDI_RegCodeX86_ebx = 4, -RDI_RegCodeX86_esp = 5, -RDI_RegCodeX86_ebp = 6, -RDI_RegCodeX86_esi = 7, -RDI_RegCodeX86_edi = 8, -RDI_RegCodeX86_fsbase = 9, -RDI_RegCodeX86_gsbase = 10, -RDI_RegCodeX86_eflags = 11, -RDI_RegCodeX86_eip = 12, -RDI_RegCodeX86_dr0 = 13, -RDI_RegCodeX86_dr1 = 14, -RDI_RegCodeX86_dr2 = 15, -RDI_RegCodeX86_dr3 = 16, -RDI_RegCodeX86_dr4 = 17, -RDI_RegCodeX86_dr5 = 18, -RDI_RegCodeX86_dr6 = 19, -RDI_RegCodeX86_dr7 = 20, -RDI_RegCodeX86_fpr0 = 21, -RDI_RegCodeX86_fpr1 = 22, -RDI_RegCodeX86_fpr2 = 23, -RDI_RegCodeX86_fpr3 = 24, -RDI_RegCodeX86_fpr4 = 25, -RDI_RegCodeX86_fpr5 = 26, -RDI_RegCodeX86_fpr6 = 27, -RDI_RegCodeX86_fpr7 = 28, -RDI_RegCodeX86_st0 = 29, -RDI_RegCodeX86_st1 = 30, -RDI_RegCodeX86_st2 = 31, -RDI_RegCodeX86_st3 = 32, -RDI_RegCodeX86_st4 = 33, -RDI_RegCodeX86_st5 = 34, -RDI_RegCodeX86_st6 = 35, -RDI_RegCodeX86_st7 = 36, -RDI_RegCodeX86_fcw = 37, -RDI_RegCodeX86_fsw = 38, -RDI_RegCodeX86_ftw = 39, -RDI_RegCodeX86_fop = 40, -RDI_RegCodeX86_fcs = 41, -RDI_RegCodeX86_fds = 42, -RDI_RegCodeX86_fip = 43, -RDI_RegCodeX86_fdp = 44, -RDI_RegCodeX86_mxcsr = 45, -RDI_RegCodeX86_mxcsr_mask = 46, -RDI_RegCodeX86_ss = 47, -RDI_RegCodeX86_cs = 48, -RDI_RegCodeX86_ds = 49, -RDI_RegCodeX86_es = 50, -RDI_RegCodeX86_fs = 51, -RDI_RegCodeX86_gs = 52, -RDI_RegCodeX86_ymm0 = 53, -RDI_RegCodeX86_ymm1 = 54, -RDI_RegCodeX86_ymm2 = 55, -RDI_RegCodeX86_ymm3 = 56, -RDI_RegCodeX86_ymm4 = 57, -RDI_RegCodeX86_ymm5 = 58, -RDI_RegCodeX86_ymm6 = 59, -RDI_RegCodeX86_ymm7 = 60, -} RDI_RegCodeX86Enum; - -typedef RDI_U8 RDI_RegCodeX64; -typedef enum RDI_RegCodeX64Enum -{ -RDI_RegCodeX64_nil = 0, -RDI_RegCodeX64_rax = 1, -RDI_RegCodeX64_rcx = 2, -RDI_RegCodeX64_rdx = 3, -RDI_RegCodeX64_rbx = 4, -RDI_RegCodeX64_rsp = 5, -RDI_RegCodeX64_rbp = 6, -RDI_RegCodeX64_rsi = 7, -RDI_RegCodeX64_rdi = 8, -RDI_RegCodeX64_r8 = 9, -RDI_RegCodeX64_r9 = 10, -RDI_RegCodeX64_r10 = 11, -RDI_RegCodeX64_r11 = 12, -RDI_RegCodeX64_r12 = 13, -RDI_RegCodeX64_r13 = 14, -RDI_RegCodeX64_r14 = 15, -RDI_RegCodeX64_r15 = 16, -RDI_RegCodeX64_es = 17, -RDI_RegCodeX64_cs = 18, -RDI_RegCodeX64_ss = 19, -RDI_RegCodeX64_ds = 20, -RDI_RegCodeX64_fs = 21, -RDI_RegCodeX64_gs = 22, -RDI_RegCodeX64_rip = 23, -RDI_RegCodeX64_rflags = 24, -RDI_RegCodeX64_dr0 = 25, -RDI_RegCodeX64_dr1 = 26, -RDI_RegCodeX64_dr2 = 27, -RDI_RegCodeX64_dr3 = 28, -RDI_RegCodeX64_dr4 = 29, -RDI_RegCodeX64_dr5 = 30, -RDI_RegCodeX64_dr6 = 31, -RDI_RegCodeX64_dr7 = 32, -RDI_RegCodeX64_st0 = 33, -RDI_RegCodeX64_st1 = 34, -RDI_RegCodeX64_st2 = 35, -RDI_RegCodeX64_st3 = 36, -RDI_RegCodeX64_st4 = 37, -RDI_RegCodeX64_st5 = 38, -RDI_RegCodeX64_st6 = 39, -RDI_RegCodeX64_st7 = 40, -RDI_RegCodeX64_fpr0 = 41, -RDI_RegCodeX64_fpr1 = 42, -RDI_RegCodeX64_fpr2 = 43, -RDI_RegCodeX64_fpr3 = 44, -RDI_RegCodeX64_fpr4 = 45, -RDI_RegCodeX64_fpr5 = 46, -RDI_RegCodeX64_fpr6 = 47, -RDI_RegCodeX64_fpr7 = 48, -RDI_RegCodeX64_ymm0 = 49, -RDI_RegCodeX64_ymm1 = 50, -RDI_RegCodeX64_ymm2 = 51, -RDI_RegCodeX64_ymm3 = 52, -RDI_RegCodeX64_ymm4 = 53, -RDI_RegCodeX64_ymm5 = 54, -RDI_RegCodeX64_ymm6 = 55, -RDI_RegCodeX64_ymm7 = 56, -RDI_RegCodeX64_ymm8 = 57, -RDI_RegCodeX64_ymm9 = 58, -RDI_RegCodeX64_ymm10 = 59, -RDI_RegCodeX64_ymm11 = 60, -RDI_RegCodeX64_ymm12 = 61, -RDI_RegCodeX64_ymm13 = 62, -RDI_RegCodeX64_ymm14 = 63, -RDI_RegCodeX64_ymm15 = 64, -RDI_RegCodeX64_mxcsr = 65, -RDI_RegCodeX64_fsbase = 66, -RDI_RegCodeX64_gsbase = 67, -RDI_RegCodeX64_fcw = 68, -RDI_RegCodeX64_fsw = 69, -RDI_RegCodeX64_ftw = 70, -RDI_RegCodeX64_fop = 71, -RDI_RegCodeX64_fcs = 72, -RDI_RegCodeX64_fds = 73, -RDI_RegCodeX64_fip = 74, -RDI_RegCodeX64_fdp = 75, -RDI_RegCodeX64_mxcsr_mask = 76, -} RDI_RegCodeX64Enum; - -typedef RDI_U32 RDI_BinarySectionFlags; -typedef enum RDI_BinarySectionFlagsEnum -{ -RDI_BinarySectionFlag_Read = 1<<0, -RDI_BinarySectionFlag_Write = 1<<1, -RDI_BinarySectionFlag_Execute = 1<<2, -} RDI_BinarySectionFlagsEnum; - -typedef RDI_U32 RDI_Language; -typedef enum RDI_LanguageEnum -{ -RDI_Language_NULL = 0, -RDI_Language_C = 1, -RDI_Language_CPlusPlus = 2, -RDI_Language_COUNT = 3, -} RDI_LanguageEnum; - -typedef RDI_U16 RDI_TypeKind; -typedef enum RDI_TypeKindEnum -{ -RDI_TypeKind_NULL = 0x0000, -RDI_TypeKind_Void = 0x0001, -RDI_TypeKind_Handle = 0x0002, -RDI_TypeKind_Char8 = 0x0003, -RDI_TypeKind_Char16 = 0x0004, -RDI_TypeKind_Char32 = 0x0005, -RDI_TypeKind_UChar8 = 0x0006, -RDI_TypeKind_UChar16 = 0x0007, -RDI_TypeKind_UChar32 = 0x0008, -RDI_TypeKind_U8 = 0x0009, -RDI_TypeKind_U16 = 0x000A, -RDI_TypeKind_U32 = 0x000B, -RDI_TypeKind_U64 = 0x000C, -RDI_TypeKind_U128 = 0x000D, -RDI_TypeKind_U256 = 0x000E, -RDI_TypeKind_U512 = 0x000F, -RDI_TypeKind_S8 = 0x0010, -RDI_TypeKind_S16 = 0x0011, -RDI_TypeKind_S32 = 0x0012, -RDI_TypeKind_S64 = 0x0013, -RDI_TypeKind_S128 = 0x0014, -RDI_TypeKind_S256 = 0x0015, -RDI_TypeKind_S512 = 0x0016, -RDI_TypeKind_Bool = 0x0017, -RDI_TypeKind_F16 = 0x0018, -RDI_TypeKind_F32 = 0x0019, -RDI_TypeKind_F32PP = 0x001A, -RDI_TypeKind_F48 = 0x001B, -RDI_TypeKind_F64 = 0x001C, -RDI_TypeKind_F80 = 0x001D, -RDI_TypeKind_F128 = 0x001E, -RDI_TypeKind_ComplexF32 = 0x001F, -RDI_TypeKind_ComplexF64 = 0x0020, -RDI_TypeKind_ComplexF80 = 0x0021, -RDI_TypeKind_ComplexF128 = 0x0022, -RDI_TypeKind_Modifier = 0x1000, -RDI_TypeKind_Ptr = 0x1001, -RDI_TypeKind_LRef = 0x1002, -RDI_TypeKind_RRef = 0x1003, -RDI_TypeKind_Array = 0x1004, -RDI_TypeKind_Function = 0x1005, -RDI_TypeKind_Method = 0x1006, -RDI_TypeKind_MemberPtr = 0x1007, -RDI_TypeKind_Struct = 0x2000, -RDI_TypeKind_Class = 0x2001, -RDI_TypeKind_Union = 0x2002, -RDI_TypeKind_Enum = 0x2003, -RDI_TypeKind_Alias = 0x2004, -RDI_TypeKind_IncompleteStruct = 0x2005, -RDI_TypeKind_IncompleteUnion = 0x2006, -RDI_TypeKind_IncompleteClass = 0x2007, -RDI_TypeKind_IncompleteEnum = 0x2008, -RDI_TypeKind_Bitfield = 0xF000, -RDI_TypeKind_Variadic = 0xF001, -RDI_TypeKind_FirstBuiltIn = RDI_TypeKind_Void, -RDI_TypeKind_LastBuiltIn = RDI_TypeKind_ComplexF128, -RDI_TypeKind_FirstConstructed = RDI_TypeKind_Modifier, -RDI_TypeKind_LastConstructed = RDI_TypeKind_MemberPtr, -RDI_TypeKind_FirstUserDefined = RDI_TypeKind_Struct, -RDI_TypeKind_LastRecord = RDI_TypeKind_Union, -RDI_TypeKind_FirstIncomplete = RDI_TypeKind_IncompleteStruct, -RDI_TypeKind_LastIncomplete = RDI_TypeKind_IncompleteEnum, -RDI_TypeKind_FirstRecord = RDI_TypeKind_Struct, -RDI_TypeKind_LastUserDefined = RDI_TypeKind_IncompleteEnum, -} RDI_TypeKindEnum; - -typedef RDI_U16 RDI_TypeModifierFlags; -typedef enum RDI_TypeModifierFlagsEnum -{ -RDI_TypeModifierFlag_Const = 1<<0, -RDI_TypeModifierFlag_Volatile = 1<<1, -} RDI_TypeModifierFlagsEnum; - -typedef RDI_U32 RDI_UDTFlags; -typedef enum RDI_UDTFlagsEnum -{ -RDI_UDTFlag_EnumMembers = 1<<0, -} RDI_UDTFlagsEnum; - -typedef RDI_U16 RDI_MemberKind; -typedef enum RDI_MemberKindEnum -{ -RDI_MemberKind_NULL = 0x0000, -RDI_MemberKind_DataField = 0x0001, -RDI_MemberKind_StaticData = 0x0002, -RDI_MemberKind_Method = 0x0100, -RDI_MemberKind_StaticMethod = 0x0101, -RDI_MemberKind_VirtualMethod = 0x0102, -RDI_MemberKind_VTablePtr = 0x0200, -RDI_MemberKind_Base = 0x0201, -RDI_MemberKind_VirtualBase = 0x0202, -RDI_MemberKind_NestedType = 0x0300, -} RDI_MemberKindEnum; - -typedef RDI_U32 RDI_LinkFlags; -typedef enum RDI_LinkFlagsEnum -{ -RDI_LinkFlag_External = 1<<0, -RDI_LinkFlag_TypeScoped = 1<<1, -RDI_LinkFlag_ProcScoped = 1<<2, -} RDI_LinkFlagsEnum; - -typedef RDI_U32 RDI_LocalKind; -typedef enum RDI_LocalKindEnum -{ -RDI_LocalKind_NULL = 0x0, -RDI_LocalKind_Parameter = 0x1, -RDI_LocalKind_Variable = 0x2, -} RDI_LocalKindEnum; - -typedef RDI_U8 RDI_LocationKind; -typedef enum RDI_LocationKindEnum -{ -RDI_LocationKind_NULL = 0x0, -RDI_LocationKind_AddrBytecodeStream = 0x1, -RDI_LocationKind_ValBytecodeStream = 0x2, -RDI_LocationKind_AddrRegPlusU16 = 0x3, -RDI_LocationKind_AddrAddrRegPlusU16 = 0x4, -RDI_LocationKind_ValReg = 0x5, -} RDI_LocationKindEnum; - -typedef RDI_U8 RDI_EvalOp; -typedef enum RDI_EvalOpEnum -{ -RDI_EvalOp_Stop = 0, -RDI_EvalOp_Noop = 1, -RDI_EvalOp_Cond = 2, -RDI_EvalOp_Skip = 3, -RDI_EvalOp_MemRead = 4, -RDI_EvalOp_RegRead = 5, -RDI_EvalOp_RegReadDyn = 6, -RDI_EvalOp_FrameOff = 7, -RDI_EvalOp_ModuleOff = 8, -RDI_EvalOp_TLSOff = 9, -RDI_EvalOp_ObjectOff = 10, -RDI_EvalOp_CFA = 11, -RDI_EvalOp_ConstU8 = 12, -RDI_EvalOp_ConstU16 = 13, -RDI_EvalOp_ConstU32 = 14, -RDI_EvalOp_ConstU64 = 15, -RDI_EvalOp_Abs = 16, -RDI_EvalOp_Neg = 17, -RDI_EvalOp_Add = 18, -RDI_EvalOp_Sub = 19, -RDI_EvalOp_Mul = 20, -RDI_EvalOp_Div = 21, -RDI_EvalOp_Mod = 22, -RDI_EvalOp_LShift = 23, -RDI_EvalOp_RShift = 24, -RDI_EvalOp_BitAnd = 25, -RDI_EvalOp_BitOr = 26, -RDI_EvalOp_BitXor = 27, -RDI_EvalOp_BitNot = 28, -RDI_EvalOp_LogAnd = 29, -RDI_EvalOp_LogOr = 30, -RDI_EvalOp_LogNot = 31, -RDI_EvalOp_EqEq = 32, -RDI_EvalOp_NtEq = 33, -RDI_EvalOp_LsEq = 34, -RDI_EvalOp_GrEq = 35, -RDI_EvalOp_Less = 36, -RDI_EvalOp_Grtr = 37, -RDI_EvalOp_Trunc = 38, -RDI_EvalOp_TruncSigned = 39, -RDI_EvalOp_Convert = 40, -RDI_EvalOp_Pick = 41, -RDI_EvalOp_Pop = 42, -RDI_EvalOp_Insert = 43, -RDI_EvalOp_COUNT = 44, -} RDI_EvalOpEnum; - -typedef RDI_U8 RDI_EvalTypeGroup; -typedef enum RDI_EvalTypeGroupEnum -{ -RDI_EvalTypeGroup_Other = 0, -RDI_EvalTypeGroup_U = 1, -RDI_EvalTypeGroup_S = 2, -RDI_EvalTypeGroup_F32 = 3, -RDI_EvalTypeGroup_F64 = 4, -RDI_EvalTypeGroup_COUNT = 5, -} RDI_EvalTypeGroupEnum; - -typedef RDI_U8 RDI_EvalConversionKind; -typedef enum RDI_EvalConversionKindEnum -{ -RDI_EvalConversionKind_Noop = 0, -RDI_EvalConversionKind_Legal = 1, -RDI_EvalConversionKind_OtherToOther = 2, -RDI_EvalConversionKind_ToOther = 3, -RDI_EvalConversionKind_FromOther = 4, -RDI_EvalConversionKind_COUNT = 5, -} RDI_EvalConversionKindEnum; - -typedef RDI_U32 RDI_NameMapKind; -typedef enum RDI_NameMapKindEnum -{ -RDI_NameMapKind_NULL = 0, -RDI_NameMapKind_GlobalVariables = 1, -RDI_NameMapKind_ThreadVariables = 2, -RDI_NameMapKind_Procedures = 3, -RDI_NameMapKind_Types = 4, -RDI_NameMapKind_LinkNameProcedures = 5, -RDI_NameMapKind_NormalSourcePaths = 6, -RDI_NameMapKind_COUNT = 7, -} RDI_NameMapKindEnum; - -#define RDI_DataSectionTag_XList \ -X(NULL)\ -X(TopLevelInfo)\ -X(StringData)\ -X(StringTable)\ -X(IndexRuns)\ -X(BinarySections)\ -X(FilePathNodes)\ -X(SourceFiles)\ -X(Units)\ -X(UnitVmap)\ -X(TypeNodes)\ -X(UDTs)\ -X(Members)\ -X(EnumMembers)\ -X(GlobalVariables)\ -X(GlobalVmap)\ -X(ThreadVariables)\ -X(Procedures)\ -X(Scopes)\ -X(ScopeVoffData)\ -X(ScopeVmap)\ -X(Locals)\ -X(LocationBlocks)\ -X(LocationData)\ -X(NameMaps)\ -X(PRIMARY_COUNT)\ -X(SECONDARY)\ -X(LineInfoVoffs)\ -X(LineInfoData)\ -X(LineInfoColumns)\ -X(LineMapNumbers)\ -X(LineMapRanges)\ -X(LineMapVoffs)\ -X(NameMapBuckets)\ -X(NameMapNodes)\ - -#define RDI_DataSectionEncoding_XList \ -X(Unpacked)\ -X(LZB)\ - -#define RDI_Arch_XList \ -X(NULL)\ -X(X86)\ -X(X64)\ - -#define RDI_BinarySectionFlags_XList \ -X(NULL)\ -X(X86)\ -X(X64)\ - -#define RDI_Language_XList \ -X(NULL)\ -X(C)\ -X(CPlusPlus)\ -X(COUNT)\ - -#define RDI_TypeKind_XList \ -X(NULL)\ -X(Void)\ -X(Handle)\ -X(Char8)\ -X(Char16)\ -X(Char32)\ -X(UChar8)\ -X(UChar16)\ -X(UChar32)\ -X(U8)\ -X(U16)\ -X(U32)\ -X(U64)\ -X(U128)\ -X(U256)\ -X(U512)\ -X(S8)\ -X(S16)\ -X(S32)\ -X(S64)\ -X(S128)\ -X(S256)\ -X(S512)\ -X(Bool)\ -X(F16)\ -X(F32)\ -X(F32PP)\ -X(F48)\ -X(F64)\ -X(F80)\ -X(F128)\ -X(ComplexF32)\ -X(ComplexF64)\ -X(ComplexF80)\ -X(ComplexF128)\ -X(Modifier)\ -X(Ptr)\ -X(LRef)\ -X(RRef)\ -X(Array)\ -X(Function)\ -X(Method)\ -X(MemberPtr)\ -X(Struct)\ -X(Class)\ -X(Union)\ -X(Enum)\ -X(Alias)\ -X(IncompleteStruct)\ -X(IncompleteUnion)\ -X(IncompleteClass)\ -X(IncompleteEnum)\ -X(Bitfield)\ -X(Variadic)\ - -#define RDI_TypeModifierFlags_XList \ -X(Const)\ -X(Volatile)\ - -#define RDI_UDTFlag_XList \ -X(EnumMembers)\ - -#define RDI_MemberKind_XList \ -X(NULL)\ -X(DataField)\ -X(StaticData)\ -X(Method)\ -X(StaticMethod)\ -X(VirtualMethod)\ -X(VTablePtr)\ -X(Base)\ -X(VirtualBase)\ -X(NestedType)\ - -#define RDI_LinkFlags_XList \ -X(External)\ -X(TypeScoped)\ -X(ProcScoped)\ - -#define RDI_LocalKind_XList \ -X(NULL)\ -X(Parameter)\ -X(Variable)\ - -#define RDI_LocationKind_XList \ -X(NULL)\ -X(AddrBytecodeStream)\ -X(ValBytecodeStream)\ -X(AddrRegPlusU16)\ -X(AddrAddrRegPlusU16)\ -X(ValReg)\ - -#define RDI_EvalOp_XList \ -X(Stop)\ -X(Noop)\ -X(Cond)\ -X(Skip)\ -X(MemRead)\ -X(RegRead)\ -X(RegReadDyn)\ -X(FrameOff)\ -X(ModuleOff)\ -X(TLSOff)\ -X(ObjectOff)\ -X(CFA)\ -X(ConstU8)\ -X(ConstU16)\ -X(ConstU32)\ -X(ConstU64)\ -X(Abs)\ -X(Neg)\ -X(Add)\ -X(Sub)\ -X(Mul)\ -X(Div)\ -X(Mod)\ -X(LShift)\ -X(RShift)\ -X(BitAnd)\ -X(BitOr)\ -X(BitXor)\ -X(BitNot)\ -X(LogAnd)\ -X(LogOr)\ -X(LogNot)\ -X(EqEq)\ -X(NtEq)\ -X(LsEq)\ -X(GrEq)\ -X(Less)\ -X(Grtr)\ -X(Trunc)\ -X(TruncSigned)\ -X(Convert)\ -X(Pick)\ -X(Pop)\ -X(Insert)\ -X(COUNT)\ - -#define RDI_EvalTypeGroup_XList \ -X(Other)\ -X(U)\ -X(S)\ -X(F32)\ -X(F64)\ -X(COUNT)\ - -#define RDI_EvalConversionKind_XList \ -X(Noop)\ -X(Legal)\ -X(OtherToOther)\ -X(ToOther)\ -X(FromOther)\ -X(COUNT)\ - -#define RDI_NameMapKind_XList \ -X(NULL)\ -X(GlobalVariables)\ -X(ThreadVariables)\ -X(Procedures)\ -X(Types)\ -X(LinkNameProcedures)\ -X(NormalSourcePaths)\ -X(COUNT)\ - -#define RDI_EVAL_CTRLBITS(decodeN,popN,pushN) ((decodeN) | ((popN) << 4) | ((pushN) << 6)) -#define RDI_DECODEN_FROM_CTRLBITS(ctrlbits) ((ctrlbits) & 0xf) -#define RDI_POPN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 4) & 0x3) -#define RDI_PUSHN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 6) & 0x3) -#define RDI_EncodeRegReadParam(reg,bytesize,bytepos) ((reg)|((bytesize)<<8)|((bytepos)<<16)) - -typedef struct RDI_Header RDI_Header; -struct RDI_Header -{ -RDI_U64 magic; -RDI_U32 encoding_version; -RDI_U32 data_section_off; -RDI_U32 data_section_count; -}; - -typedef struct RDI_DataSection RDI_DataSection; -struct RDI_DataSection -{ -RDI_DataSectionTag tag; -RDI_DataSectionEncoding encoding; -RDI_U64 off; -RDI_U64 encoded_size; -RDI_U64 unpacked_size; -}; - -typedef struct RDI_VMapEntry RDI_VMapEntry; -struct RDI_VMapEntry -{ -RDI_U64 voff; -RDI_U64 idx; -}; - -typedef struct RDI_TopLevelInfo RDI_TopLevelInfo; -struct RDI_TopLevelInfo -{ -RDI_Arch arch; -RDI_U32 exe_name_string_idx; -RDI_U64 exe_hash; -RDI_U64 voff_max; -}; - -typedef struct RDI_BinarySection RDI_BinarySection; -struct RDI_BinarySection -{ -RDI_U32 name_string_idx; -RDI_BinarySectionFlags flags; -RDI_U64 voff_first; -RDI_U64 voff_opl; -RDI_U64 foff_first; -RDI_U64 foff_opl; -}; - -typedef struct RDI_FilePathNode RDI_FilePathNode; -struct RDI_FilePathNode -{ -RDI_U32 name_string_idx; -RDI_U32 parent_path_node; -RDI_U32 first_child; -RDI_U32 next_sibling; -RDI_U32 source_file_idx; -}; - -typedef struct RDI_SourceFile RDI_SourceFile; -struct RDI_SourceFile -{ -RDI_U32 file_path_node_idx; -RDI_U32 normal_full_path_string_idx; -RDI_U32 line_map_count; -RDI_U32 line_map_nums_data_idx; -RDI_U32 line_map_range_data_idx; -RDI_U32 line_map_voff_data_idx; -}; - -typedef struct RDI_Unit RDI_Unit; -struct RDI_Unit -{ -RDI_U32 unit_name_string_idx; -RDI_U32 compiler_name_string_idx; -RDI_U32 source_file_path_node; -RDI_U32 object_file_path_node; -RDI_U32 archive_file_path_node; -RDI_U32 build_path_node; -RDI_Language language; -RDI_U32 line_info_voffs_data_idx; -RDI_U32 line_info_data_idx; -RDI_U32 line_info_col_data_idx; -RDI_U32 line_info_count; -}; - -typedef struct RDI_Line RDI_Line; -struct RDI_Line -{ -RDI_U32 file_idx; -RDI_U32 line_num; -}; - -typedef struct RDI_Column RDI_Column; -struct RDI_Column -{ -RDI_U16 col_first; -RDI_U16 col_opl; -}; - -typedef struct RDI_TypeNode RDI_TypeNode; -struct RDI_TypeNode -{ -RDI_TypeKind kind; -RDI_U16 flags; -RDI_U32 byte_size; - - union - { - // kind is 'built-in' - struct - { - RDI_U32 name_string_idx; - } built_in; - - // kind is 'constructed' - struct - { - RDI_U32 direct_type_idx; - RDI_U32 count; - union{ - // when kind is 'Function' or 'Method' - RDI_U32 param_idx_run_first; - // when kind is 'MemberPtr' - RDI_U32 owner_type_idx; - }; - } constructed; - - // kind is 'user defined' - struct - { - RDI_U32 name_string_idx; - RDI_U32 direct_type_idx; - RDI_U32 udt_idx; - } user_defined; - - // (kind = Bitfield) - struct - { - RDI_U32 direct_type_idx; - RDI_U32 off; - RDI_U32 size; - } bitfield; - } - ; -}; - -typedef struct RDI_UDT RDI_UDT; -struct RDI_UDT -{ -RDI_U32 self_type_idx; -RDI_UDTFlags flags; -RDI_U32 member_first; -RDI_U32 member_count; -RDI_U32 file_idx; -RDI_U32 line; -RDI_U32 col; -}; - -typedef struct RDI_Member RDI_Member; -struct RDI_Member -{ -RDI_MemberKind kind; -RDI_U16 pad; -RDI_U32 name_string_idx; -RDI_U32 type_idx; -RDI_U32 off; -}; - -typedef struct RDI_EnumMember RDI_EnumMember; -struct RDI_EnumMember -{ -RDI_U32 name_string_idx; -RDI_U32 pad; -RDI_U64 val; -}; - -typedef struct RDI_GlobalVariable RDI_GlobalVariable; -struct RDI_GlobalVariable -{ -RDI_U32 name_string_idx; -RDI_LinkFlags link_flags; -RDI_U64 voff; -RDI_U32 type_idx; -RDI_U32 container_idx; -}; - -typedef struct RDI_ThreadVariable RDI_ThreadVariable; -struct RDI_ThreadVariable -{ -RDI_U32 name_string_idx; -RDI_LinkFlags link_flags; -RDI_U32 tls_off; -RDI_U32 type_idx; -RDI_U32 container_idx; -}; - -typedef struct RDI_Procedure RDI_Procedure; -struct RDI_Procedure -{ -RDI_U32 name_string_idx; -RDI_U32 link_name_string_idx; -RDI_LinkFlags link_flags; -RDI_U32 type_idx; -RDI_U32 root_scope_idx; -RDI_U32 container_idx; -}; - -typedef struct RDI_Scope RDI_Scope; -struct RDI_Scope -{ -RDI_U32 proc_idx; -RDI_U32 parent_scope_idx; -RDI_U32 first_child_scope_idx; -RDI_U32 next_sibling_scope_idx; -RDI_U32 voff_range_first; -RDI_U32 voff_range_opl; -RDI_U32 local_first; -RDI_U32 local_count; -RDI_U32 static_local_idx_run_first; -RDI_U32 static_local_count; -}; - -typedef struct RDI_Local RDI_Local; -struct RDI_Local -{ -RDI_LocalKind kind; -RDI_U32 name_string_idx; -RDI_U32 type_idx; -RDI_U32 pad; -RDI_U32 location_first; -RDI_U32 location_opl; -}; - -typedef struct RDI_LocationBlock RDI_LocationBlock; -struct RDI_LocationBlock -{ -RDI_U32 scope_off_first; -RDI_U32 scope_off_opl; -RDI_U32 location_data_off; -}; - -typedef struct RDI_LocationBytecodeStream RDI_LocationBytecodeStream; -struct RDI_LocationBytecodeStream -{ -RDI_LocationKind kind; -}; - -typedef struct RDI_LocationRegPlusU16 RDI_LocationRegPlusU16; -struct RDI_LocationRegPlusU16 -{ -RDI_LocationKind kind; -RDI_RegCode reg_code; -RDI_U16 offset; -}; - -typedef struct RDI_LocationReg RDI_LocationReg; -struct RDI_LocationReg -{ -RDI_LocationKind kind; -RDI_RegCode reg_code; -}; - -typedef struct RDI_NameMap RDI_NameMap; -struct RDI_NameMap -{ -RDI_NameMapKind kind; -RDI_U32 bucket_data_idx; -RDI_U32 node_data_idx; -}; - -typedef struct RDI_NameMapBucket RDI_NameMapBucket; -struct RDI_NameMapBucket -{ -RDI_U32 first_node; -RDI_U32 node_count; -}; - -typedef struct RDI_NameMapNode RDI_NameMapNode; -struct RDI_NameMapNode -{ -RDI_U32 string_idx; -RDI_U32 match_count; -RDI_U32 match_idx_or_idx_run_first; -}; - -RDI_PROC RDI_U64 rdi_hash(RDI_U8 *ptr, RDI_U64 size); -RDI_PROC RDI_U32 rdi_size_from_basic_type_kind(RDI_TypeKind kind); -RDI_PROC RDI_U32 rdi_addr_size_from_arch(RDI_Arch arch); -RDI_PROC RDI_EvalConversionKind rdi_eval_conversion_kind_from_typegroups(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out); -RDI_PROC RDI_S32 rdi_eval_op_typegroup_are_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group); -RDI_PROC RDI_U8 *rdi_explanation_string_from_eval_conversion_kind(RDI_EvalConversionKind kind, RDI_U64 *size_out); - -extern RDI_U8 rdi_eval_op_ctrlbits_table[45]; - -#endif // RDI_FORMAT_H diff --git a/src/rdi_format/rdi_format.mdesk b/src/rdi_format/rdi_format.mdesk index ed078778..89f284be 100644 --- a/src/rdi_format/rdi_format.mdesk +++ b/src/rdi_format/rdi_format.mdesk @@ -5,7 +5,7 @@ //~ rjf: Generated File Format @option library -@gen_folder "lib" +@gen_folder "lib_rdi_format" @h_name "rdi_format.h" @c_name "rdi_format.c" diff --git a/src/rdi_format_local/rdi_format_local.c b/src/rdi_format/rdi_format_local.c similarity index 100% rename from src/rdi_format_local/rdi_format_local.c rename to src/rdi_format/rdi_format_local.c diff --git a/src/rdi_format_local/rdi_format_local.h b/src/rdi_format/rdi_format_local.h similarity index 100% rename from src/rdi_format_local/rdi_format_local.h rename to src/rdi_format/rdi_format_local.h From 448baf68a83bafd3bb6543a17c6b1720808ab241 Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Sat, 1 Jun 2024 12:07:55 -0700 Subject: [PATCH 18/21] adjust builds to new rdi library setup --- src/raddbg/raddbg_main.cpp | 8 ++++---- src/rdi_breakpad_from_pdb/rdi_breakpad_from_pdb_main.c | 4 ++-- src/rdi_dump/rdi_dump_main.c | 4 ++-- src/rdi_format/rdi_format_local.c | 3 +-- src/rdi_format/rdi_format_local.h | 3 +-- src/rdi_from_pdb/rdi_from_pdb_main.c | 8 ++++---- src/{rdi_make_local => rdi_make}/rdi_make_local.c | 0 src/{rdi_make_local => rdi_make}/rdi_make_local.h | 0 8 files changed, 14 insertions(+), 16 deletions(-) rename src/{rdi_make_local => rdi_make}/rdi_make_local.c (100%) rename src/{rdi_make_local => rdi_make}/rdi_make_local.h (100%) diff --git a/src/raddbg/raddbg_main.cpp b/src/raddbg/raddbg_main.cpp index 85f5830a..d9892de7 100644 --- a/src/raddbg/raddbg_main.cpp +++ b/src/raddbg/raddbg_main.cpp @@ -30,8 +30,8 @@ #include "os/os_inc.h" #include "task_system/task_system.h" #include "ico/ico.h" -#include "rdi_format_local/rdi_format_local.h" -#include "rdi_make_local/rdi_make_local.h" +#include "rdi_format/rdi_format_local.h" +#include "rdi_make/rdi_make_local.h" #include "mdesk/mdesk.h" #include "hash_store/hash_store.h" #include "file_stream/file_stream.h" @@ -70,8 +70,8 @@ #include "os/os_inc.c" #include "task_system/task_system.c" #include "ico/ico.c" -#include "rdi_format_local/rdi_format_local.c" -#include "rdi_make_local/rdi_make_local.c" +#include "rdi_format/rdi_format_local.c" +#include "rdi_make/rdi_make_local.c" #include "mdesk/mdesk.c" #include "hash_store/hash_store.c" #include "file_stream/file_stream.c" diff --git a/src/rdi_breakpad_from_pdb/rdi_breakpad_from_pdb_main.c b/src/rdi_breakpad_from_pdb/rdi_breakpad_from_pdb_main.c index bc35b289..d0b14071 100644 --- a/src/rdi_breakpad_from_pdb/rdi_breakpad_from_pdb_main.c +++ b/src/rdi_breakpad_from_pdb/rdi_breakpad_from_pdb_main.c @@ -12,8 +12,8 @@ //~ rjf: Includes //- rjf: [lib] -#include "rdi_format/lib/rdi_format.h" -#include "rdi_format/lib/rdi_format.c" +#include "lib_rdi_format/rdi_format.h" +#include "lib_rdi_format/rdi_format.c" #include "lib_rdi_format/rdi_format_parse.h" #include "lib_rdi_format/rdi_format_parse.c" #include "third_party/rad_lzb_simple/rad_lzb_simple.h" diff --git a/src/rdi_dump/rdi_dump_main.c b/src/rdi_dump/rdi_dump_main.c index 3764759c..20f77361 100644 --- a/src/rdi_dump/rdi_dump_main.c +++ b/src/rdi_dump/rdi_dump_main.c @@ -21,13 +21,13 @@ //- rjf: [h] #include "base/base_inc.h" #include "os/os_inc.h" -#include "rdi_format_local/rdi_format_local.h" +#include "rdi_format/rdi_format_local.h" #include "rdi_dump.h" //- rjf: [c] #include "base/base_inc.c" #include "os/os_inc.c" -#include "rdi_format_local/rdi_format_local.c" +#include "rdi_format/rdi_format_local.c" #include "rdi_dump.c" //////////////////////////////// diff --git a/src/rdi_format/rdi_format_local.c b/src/rdi_format/rdi_format_local.c index 5b6f41be..6fae2eb3 100644 --- a/src/rdi_format/rdi_format_local.c +++ b/src/rdi_format/rdi_format_local.c @@ -1,8 +1,7 @@ // Copyright (c) 2024 Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) -//#include "lib_rdi_format/rdi_format.c" -#include "rdi_format/lib/rdi_format.c" +#include "lib_rdi_format/rdi_format.c" #include "lib_rdi_format/rdi_format_parse.c" internal void diff --git a/src/rdi_format/rdi_format_local.h b/src/rdi_format/rdi_format_local.h index e89b41db..48f7eea3 100644 --- a/src/rdi_format/rdi_format_local.h +++ b/src/rdi_format/rdi_format_local.h @@ -4,8 +4,7 @@ #ifndef RDI_FORMAT_LOCAL_H #define RDI_FORMAT_LOCAL_H -//#include "lib_rdi_format/rdi_format.h" -#include "rdi_format/lib/rdi_format.h" +#include "lib_rdi_format/rdi_format.h" #include "lib_rdi_format/rdi_format_parse.h" internal void rdi_decompress_parsed(U8 *decompressed_data, U64 decompressed_size, RDI_Parsed *og_rdi); diff --git a/src/rdi_from_pdb/rdi_from_pdb_main.c b/src/rdi_from_pdb/rdi_from_pdb_main.c index b813dcc2..e3c72c9a 100644 --- a/src/rdi_from_pdb/rdi_from_pdb_main.c +++ b/src/rdi_from_pdb/rdi_from_pdb_main.c @@ -15,8 +15,8 @@ //~ rjf: Includes //- rjf: [lib] -#include "rdi_format/lib/rdi_format.h" -#include "rdi_format/lib/rdi_format.c" +#include "lib_rdi_format/rdi_format.h" +#include "lib_rdi_format/rdi_format.c" #include "third_party/rad_lzb_simple/rad_lzb_simple.h" #include "third_party/rad_lzb_simple/rad_lzb_simple.c" @@ -24,7 +24,7 @@ #include "base/base_inc.h" #include "os/os_inc.h" #include "task_system/task_system.h" -#include "rdi_make_local/rdi_make_local.h" +#include "rdi_make/rdi_make_local.h" #include "coff/coff.h" #include "codeview/codeview.h" #include "codeview/codeview_stringize.h" @@ -37,7 +37,7 @@ #include "base/base_inc.c" #include "os/os_inc.c" #include "task_system/task_system.c" -#include "rdi_make_local/rdi_make_local.c" +#include "rdi_make/rdi_make_local.c" #include "coff/coff.c" #include "codeview/codeview.c" #include "codeview/codeview_stringize.c" diff --git a/src/rdi_make_local/rdi_make_local.c b/src/rdi_make/rdi_make_local.c similarity index 100% rename from src/rdi_make_local/rdi_make_local.c rename to src/rdi_make/rdi_make_local.c diff --git a/src/rdi_make_local/rdi_make_local.h b/src/rdi_make/rdi_make_local.h similarity index 100% rename from src/rdi_make_local/rdi_make_local.h rename to src/rdi_make/rdi_make_local.h From 02e1b8cf00d932c9ad11e899c501729703ad8bdc Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Sat, 1 Jun 2024 18:20:13 -0700 Subject: [PATCH 19/21] move font provider directwrite backend to using martins' auto-generated dwrite c declarations, get it almost off C++ entirely --- .../dwrite/font_provider_dwrite.cpp | 83 ++++---- .../dwrite/font_provider_dwrite.h | 188 +++++++++++++++++- .../dwrite/font_provider_dwrite_main.cpp | 3 + .../rdi_breakpad_from_pdb_main.c | 3 + 4 files changed, 234 insertions(+), 43 deletions(-) diff --git a/src/font_provider/dwrite/font_provider_dwrite.cpp b/src/font_provider/dwrite/font_provider_dwrite.cpp index b5980863..0ed0b7fb 100644 --- a/src/font_provider/dwrite/font_provider_dwrite.cpp +++ b/src/font_provider/dwrite/font_provider_dwrite.cpp @@ -1,3 +1,6 @@ +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + //////////////////////////////// //~ rjf: Globals @@ -169,47 +172,47 @@ fp_init(void) } //- rjf: make dwrite factory - error = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), (IUnknown **)&fp_dwrite_state->factory); + error = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, &IID_IDWriteFactory, (void **)&fp_dwrite_state->factory); //- rjf: register static data font "loader" interface - error = fp_dwrite_state->factory->RegisterFontFileLoader((IDWriteFontFileLoader *)&fp_dwrite_static_data_font_file_loader); + error = IDWriteFactory_RegisterFontFileLoader(fp_dwrite_state->factory, (IDWriteFontFileLoader *)&fp_dwrite_static_data_font_file_loader); //- rjf: make base rendering params - error = fp_dwrite_state->factory->CreateRenderingParams(&fp_dwrite_state->base_rendering_params); + error = IDWriteFactory_CreateRenderingParams(fp_dwrite_state->factory, &fp_dwrite_state->base_rendering_params); //- rjf: make sharp rendering params { FLOAT gamma = 1.f; - FLOAT enhanced_contrast = fp_dwrite_state->base_rendering_params->GetEnhancedContrast(); + FLOAT enhanced_contrast = IDWriteRenderingParams_GetEnhancedContrast(fp_dwrite_state->base_rendering_params); // FLOAT clear_type_level = fp_dwrite_state->base_rendering_params->GetClearTypeLevel(); - error = fp_dwrite_state->factory->CreateCustomRenderingParams(gamma, - enhanced_contrast, - 2.f, - DWRITE_PIXEL_GEOMETRY_FLAT, - DWRITE_RENDERING_MODE_GDI_NATURAL, - &fp_dwrite_state->rendering_params[FP_RasterMode_Sharp]); + error = IDWriteFactory_CreateCustomRenderingParams(fp_dwrite_state->factory, gamma, + enhanced_contrast, + 2.f, + DWRITE_PIXEL_GEOMETRY_FLAT, + DWRITE_RENDERING_MODE_GDI_NATURAL, + &fp_dwrite_state->rendering_params[FP_RasterMode_Sharp]); } //- rjf: make smooth rendering params { FLOAT gamma = 1.f; - FLOAT enhanced_contrast = fp_dwrite_state->base_rendering_params->GetEnhancedContrast(); + FLOAT enhanced_contrast = IDWriteRenderingParams_GetEnhancedContrast(fp_dwrite_state->base_rendering_params); // FLOAT clear_type_level = fp_dwrite_state->base_rendering_params->GetClearTypeLevel(); - error = fp_dwrite_state->factory->CreateCustomRenderingParams(gamma, - enhanced_contrast, - 2.f, - DWRITE_PIXEL_GEOMETRY_FLAT, - DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC, - &fp_dwrite_state->rendering_params[FP_RasterMode_Smooth]); + error = IDWriteFactory_CreateCustomRenderingParams(fp_dwrite_state->factory, gamma, + enhanced_contrast, + 2.f, + DWRITE_PIXEL_GEOMETRY_FLAT, + DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC, + &fp_dwrite_state->rendering_params[FP_RasterMode_Smooth]); } //- rjf: make dwrite gdi interop - error = fp_dwrite_state->factory->GetGdiInterop(&fp_dwrite_state->gdi_interop); + error = IDWriteFactory_GetGdiInterop(fp_dwrite_state->factory, &fp_dwrite_state->gdi_interop); //- rjf: build render target for rasterization fp_dwrite_state->bitmap_render_target_dim = v2s32(2048, 256); - error = fp_dwrite_state->gdi_interop->CreateBitmapRenderTarget(0, fp_dwrite_state->bitmap_render_target_dim.x, fp_dwrite_state->bitmap_render_target_dim.y, &fp_dwrite_state->bitmap_render_target); - fp_dwrite_state->bitmap_render_target->SetPixelsPerDip(1.0); + error = IDWriteGdiInterop_CreateBitmapRenderTarget(fp_dwrite_state->gdi_interop, 0, fp_dwrite_state->bitmap_render_target_dim.x, fp_dwrite_state->bitmap_render_target_dim.y, &fp_dwrite_state->bitmap_render_target); + IDWriteBitmapRenderTarget_SetPixelsPerDip(fp_dwrite_state->bitmap_render_target, 1.0); ProfEnd(); } @@ -223,10 +226,10 @@ fp_font_open(String8 path) HRESULT error = 0; //- rjf: open font file reference - error = fp_dwrite_state->factory->CreateFontFileReference((WCHAR *)path16.str, 0, &font.file); + error = IDWriteFactory_CreateFontFileReference(fp_dwrite_state->factory, (WCHAR *)path16.str, 0, &font.file); //- rjf: open font face - error = fp_dwrite_state->factory->CreateFontFace(DWRITE_FONT_FACE_TYPE_TRUETYPE, 1, &font.file, 0, DWRITE_FONT_SIMULATIONS_NONE, &font.face); + error = IDWriteFactory_CreateFontFace(fp_dwrite_state->factory, DWRITE_FONT_FACE_TYPE_TRUETYPE, 1, &font.file, 0, DWRITE_FONT_SIMULATIONS_NONE, &font.face); //- rjf: handlify & return FP_Handle handle = fp_dwrite_handle_from_font(font); @@ -244,10 +247,10 @@ fp_font_open_from_static_data_string(String8 *data_ptr) HRESULT error = 0; //- rjf: open font file reference - error = fp_dwrite_state->factory->CreateCustomFontFileReference(&data_ptr, sizeof(String8 *), (IDWriteFontFileLoader *)&fp_dwrite_static_data_font_file_loader, &font.file); + error = IDWriteFactory_CreateCustomFontFileReference(fp_dwrite_state->factory, &data_ptr, sizeof(String8 *), (IDWriteFontFileLoader *)&fp_dwrite_static_data_font_file_loader, &font.file); //- rjf: open font face - error = fp_dwrite_state->factory->CreateFontFace(DWRITE_FONT_FACE_TYPE_TRUETYPE, 1, &font.file, 0, DWRITE_FONT_SIMULATIONS_NONE, &font.face); + error = IDWriteFactory_CreateFontFace(fp_dwrite_state->factory, DWRITE_FONT_FACE_TYPE_TRUETYPE, 1, &font.file, 0, DWRITE_FONT_SIMULATIONS_NONE, &font.face); //- rjf: handlify & return FP_Handle handle = fp_dwrite_handle_from_font(font); @@ -263,11 +266,11 @@ fp_font_close(FP_Handle handle) FP_DWrite_Font font = fp_dwrite_font_from_handle(handle); if(font.face != 0) { - font.face->Release(); + IDWriteFontFace_Release(font.face); } if(font.file != 0) { - font.file->Release(); + IDWriteFontFile_Release(font.file); } ProfEnd(); } @@ -280,7 +283,7 @@ fp_metrics_from_font(FP_Handle handle) DWRITE_FONT_METRICS metrics = {0}; if(font.face != 0) { - font.face->GetMetrics(&metrics); + IDWriteFontFace_GetMetrics(font.face, &metrics); } FP_Metrics result = {0}; { @@ -309,7 +312,7 @@ fp_raster(Arena *arena, FP_Handle font_handle, F32 size, FP_RasterMode mode, Str DWRITE_FONT_METRICS font_metrics = {0}; if(font.face != 0) { - font.face->GetMetrics(&font_metrics); + IDWriteFontFace_GetMetrics(font.face, &font_metrics); } F32 design_units_per_em = (F32)font_metrics.designUnitsPerEm; @@ -317,7 +320,7 @@ fp_raster(Arena *arena, FP_Handle font_handle, F32 size, FP_RasterMode mode, Str U16 *glyph_indices = push_array_no_zero(scratch.arena, U16, string32.size); if(font.face != 0) { - error = font.face->GetGlyphIndices(string32.str, string32.size, glyph_indices); + error = IDWriteFontFace_GetGlyphIndices(font.face, string32.str, string32.size, glyph_indices); } //- rjf: get metrics info @@ -325,7 +328,7 @@ fp_raster(Arena *arena, FP_Handle font_handle, F32 size, FP_RasterMode mode, Str DWRITE_GLYPH_METRICS *glyphs_metrics = push_array_no_zero(scratch.arena, DWRITE_GLYPH_METRICS, glyphs_count); if(font.face != 0) { - error = font.face->GetGdiCompatibleGlyphMetrics((96.f/72.f)*size, 1.f, 0, 1, glyph_indices, glyphs_count, glyphs_metrics, 0); + error = IDWriteFontFace_GetGdiCompatibleGlyphMetrics(font.face, (96.f/72.f)*size, 1.f, 0, 1, glyph_indices, glyphs_count, glyphs_metrics, 0); } //- rjf: derive info from metrics @@ -352,15 +355,15 @@ fp_raster(Arena *arena, FP_Handle font_handle, F32 size, FP_RasterMode mode, Str IDWriteBitmapRenderTarget *render_target = 0; if(font.face != 0) { - error = fp_dwrite_state->gdi_interop->CreateBitmapRenderTarget(0, atlas_dim.x, atlas_dim.y, &render_target); - render_target->SetPixelsPerDip(1.0); + error = IDWriteGdiInterop_CreateBitmapRenderTarget(fp_dwrite_state->gdi_interop, 0, atlas_dim.x, atlas_dim.y, &render_target); + IDWriteBitmapRenderTarget_SetPixelsPerDip(render_target, 1.f); } //- rjf: get bitmap & clear HDC dc = 0; if(font.face != 0) { - dc = render_target->GetMemoryDC(); + dc = IDWriteBitmapRenderTarget_GetMemoryDC(render_target); HGDIOBJ original = SelectObject(dc, GetStockObject(DC_PEN)); SetDCPenColor(dc, bg_color); SelectObject(dc, GetStockObject(DC_BRUSH)); @@ -388,12 +391,12 @@ fp_raster(Arena *arena, FP_Handle font_handle, F32 size, FP_RasterMode mode, Str RECT bounding_box = {0}; if(font.face != 0) { - error = render_target->DrawGlyphRun(draw_p.x, draw_p.y, - DWRITE_MEASURING_MODE_NATURAL, - &glyph_run, - fp_dwrite_state->rendering_params[mode], - fg_color, - &bounding_box); + error = IDWriteBitmapRenderTarget_DrawGlyphRun(render_target, draw_p.x, draw_p.y, + DWRITE_MEASURING_MODE_NATURAL, + &glyph_run, + fp_dwrite_state->rendering_params[mode], + fg_color, + &bounding_box); } //- rjf: get bitmap @@ -446,7 +449,7 @@ fp_raster(Arena *arena, FP_Handle font_handle, F32 size, FP_RasterMode mode, Str result.atlas_dim = v2s16(0, 0); } } - render_target->Release(); + IDWriteBitmapRenderTarget_Release(render_target); } scratch_end(scratch); ProfEnd(); diff --git a/src/font_provider/dwrite/font_provider_dwrite.h b/src/font_provider/dwrite/font_provider_dwrite.h index 437bef4e..c8c4d1e9 100644 --- a/src/font_provider/dwrite/font_provider_dwrite.h +++ b/src/font_provider/dwrite/font_provider_dwrite.h @@ -1,13 +1,195 @@ -/* date = November 2nd 2022 11:31 am */ +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) #ifndef FONT_PROVIDER_DWRITE_H #define FONT_PROVIDER_DWRITE_H -#include - #pragma comment(lib, "gdi32.lib") #pragma comment(lib, "dwrite.lib") +// #include + +//////////////////////////////// +//~ rjf: (C) DirectWrite Definitions +// +// (courtesy of mmozeiko, Martins Mozeiko, https://github.com/mmozeiko/c_d2d_dwrite) +// +// This is free and unencumbered software released into the public domain. +// +// Anyone is free to copy, modify, publish, use, compile, sell, or +// distribute this software, either in source code form or as a compiled +// binary, for any purpose, commercial or non-commercial, and by any +// means. +// +// In jurisdictions that recognize copyright laws, the author or authors +// of this software dedicate any and all copyright interest in the +// software to the public domain. We make this dedication for the benefit +// of the public at large and to the detriment of our heirs and +// successors. We intend this dedication to be an overt act of +// relinquishment in perpetuity of all present and future rights to this +// software under copyright law. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +// For more information, please refer to + +#include +#include +#include + +//- rjf: enums + +typedef enum DWRITE_FACTORY_TYPE { + DWRITE_FACTORY_TYPE_SHARED = 0, + DWRITE_FACTORY_TYPE_ISOLATED = 1, +} DWRITE_FACTORY_TYPE; + +typedef enum DWRITE_PIXEL_GEOMETRY { + DWRITE_PIXEL_GEOMETRY_FLAT = 0, + DWRITE_PIXEL_GEOMETRY_RGB = 1, + DWRITE_PIXEL_GEOMETRY_BGR = 2, +} DWRITE_PIXEL_GEOMETRY; + +typedef enum DWRITE_RENDERING_MODE { + DWRITE_RENDERING_MODE_DEFAULT = 0, + DWRITE_RENDERING_MODE_ALIASED = 1, + DWRITE_RENDERING_MODE_GDI_CLASSIC = 2, + DWRITE_RENDERING_MODE_GDI_NATURAL = 3, + DWRITE_RENDERING_MODE_NATURAL = 4, + DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC = 5, + DWRITE_RENDERING_MODE_OUTLINE = 6, + DWRITE_RENDERING_MODE_CLEARTYPE_GDI_CLASSIC = 2, + DWRITE_RENDERING_MODE_CLEARTYPE_GDI_NATURAL = 3, + DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL = 4, + DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC = 5, +} DWRITE_RENDERING_MODE; + +typedef enum DWRITE_FONT_SIMULATIONS { + DWRITE_FONT_SIMULATIONS_NONE = 0, + DWRITE_FONT_SIMULATIONS_BOLD = 1, + DWRITE_FONT_SIMULATIONS_OBLIQUE = 2, +} DWRITE_FONT_SIMULATIONS; + +typedef enum DWRITE_FONT_FACE_TYPE { + DWRITE_FONT_FACE_TYPE_CFF = 0, + DWRITE_FONT_FACE_TYPE_TRUETYPE = 1, + DWRITE_FONT_FACE_TYPE_OPENTYPE_COLLECTION = 2, + DWRITE_FONT_FACE_TYPE_TYPE1 = 3, + DWRITE_FONT_FACE_TYPE_VECTOR = 4, + DWRITE_FONT_FACE_TYPE_BITMAP = 5, + DWRITE_FONT_FACE_TYPE_UNKNOWN = 6, + DWRITE_FONT_FACE_TYPE_RAW_CFF = 7, + DWRITE_FONT_FACE_TYPE_TRUETYPE_COLLECTION = 2, +} DWRITE_FONT_FACE_TYPE; + +//- rjf: interfaces + +typedef struct IDWriteFactory { struct { void* tbl[]; }* v; } IDWriteFactory; +typedef struct IDWriteFactory1 { struct { void* tbl[]; }* v; } IDWriteFactory1; +typedef struct IDWriteFactory2 { struct { void* tbl[]; }* v; } IDWriteFactory2; +typedef struct IDWriteRenderingParams { struct { void* tbl[]; }* v; } IDWriteRenderingParams; +typedef struct IDWriteRenderingParams1 { struct { void* tbl[]; }* v; } IDWriteRenderingParams1; +typedef struct IDWriteRenderingParams2 { struct { void* tbl[]; }* v; } IDWriteRenderingParams2; +typedef struct IDWriteFontFileLoader { struct { void* tbl[]; }* v; } IDWriteFontFileLoader; +typedef struct IDWriteFontFileStream { struct { void* tbl[]; }* v; } IDWriteFontFileStream; +typedef struct IDWriteFontFile { struct { void* tbl[]; }* v; } IDWriteFontFile; +typedef struct IDWriteFontFace { struct { void* tbl[]; }* v; } IDWriteFontFace; +typedef struct IDWriteFontFace1 { struct { void* tbl[]; }* v; } IDWriteFontFace1; +typedef struct IDWriteFontFace2 { struct { void* tbl[]; }* v; } IDWriteFontFace2; +typedef struct IDWriteGdiInterop { struct { void* tbl[]; }* v; } IDWriteGdiInterop; +typedef struct IDWriteBitmapRenderTarget { struct { void* tbl[]; }* v; } IDWriteBitmapRenderTarget; +typedef struct IDWriteBitmapRenderTarget1 { struct { void* tbl[]; }* v; } IDWriteBitmapRenderTarget1; + +//- rjf: structs + +typedef struct DWRITE_GLYPH_METRICS { + INT32 leftSideBearing; + UINT32 advanceWidth; + INT32 rightSideBearing; + INT32 topSideBearing; + UINT32 advanceHeight; + INT32 bottomSideBearing; + INT32 verticalOriginY; +} DWRITE_GLYPH_METRICS; + +typedef struct DWRITE_GLYPH_OFFSET { + FLOAT advanceOffset; + FLOAT ascenderOffset; +} DWRITE_GLYPH_OFFSET; + +typedef struct DWRITE_GLYPH_RUN { + IDWriteFontFace* fontFace; + FLOAT fontEmSize; + UINT32 glyphCount; + UINT16* glyphIndices; + FLOAT* glyphAdvances; + DWRITE_GLYPH_OFFSET* glyphOffsets; + BOOL isSideways; + UINT32 bidiLevel; +} DWRITE_GLYPH_RUN; + +typedef struct DWRITE_FONT_METRICS { + UINT16 designUnitsPerEm; + UINT16 ascent; + UINT16 descent; + INT16 lineGap; + UINT16 capHeight; + UINT16 xHeight; + INT16 underlinePosition; + UINT16 underlineThickness; + INT16 strikethroughPosition; + UINT16 strikethroughThickness; +} DWRITE_FONT_METRICS; + +typedef struct DWRITE_MATRIX { + FLOAT m11; + FLOAT m12; + FLOAT m21; + FLOAT m22; + FLOAT dx; + FLOAT dy; +} DWRITE_MATRIX; + +//- rjf: GUIDs + +DEFINE_GUID(IID_IDWriteFactory, 0xb859ee5a, 0xd838, 0x4b5b, 0xa2, 0xe8, 0x1a, 0xdc, 0x7d, 0x93, 0xdb, 0x48); +DEFINE_GUID(IID_IDWriteFactory1, 0x30572f99, 0xdac6, 0x41db, 0xa1, 0x6e, 0x04, 0x86, 0x30, 0x7e, 0x60, 0x6a); +DEFINE_GUID(IID_IDWriteFactory2, 0x0439fc60, 0xca44, 0x4994, 0x8d, 0xee, 0x3a, 0x9a, 0xf7, 0xb7, 0x32, 0xec); + +//- rjf: functions + +EXTERN_C HRESULT DECLSPEC_IMPORT WINAPI DWriteCreateFactory (DWRITE_FACTORY_TYPE factoryType, const GUID* iid, void** factory) WIN_NOEXCEPT; + +//- rjf: methods + +static inline HRESULT IDWriteFactory_RegisterFontFileLoader (IDWriteFactory* this_, IDWriteFontFileLoader* fontFileLoader) { return ((HRESULT (WINAPI*)(IDWriteFactory*, IDWriteFontFileLoader*))this_->v->tbl[13])(this_, fontFileLoader); } +static inline HRESULT IDWriteFactory_CreateRenderingParams (IDWriteFactory* this_, IDWriteRenderingParams** renderingParams) { return ((HRESULT (WINAPI*)(IDWriteFactory*, IDWriteRenderingParams**))this_->v->tbl[10])(this_, renderingParams); } +static inline HRESULT IDWriteFactory_CreateCustomRenderingParams (IDWriteFactory* this_, FLOAT gamma, FLOAT enhancedContrast, FLOAT clearTypeLevel, DWRITE_PIXEL_GEOMETRY pixelGeometry, DWRITE_RENDERING_MODE renderingMode, IDWriteRenderingParams** renderingParams) { return ((HRESULT (WINAPI*)(IDWriteFactory*, FLOAT, FLOAT, FLOAT, DWRITE_PIXEL_GEOMETRY, DWRITE_RENDERING_MODE, IDWriteRenderingParams**))this_->v->tbl[12])(this_, gamma, enhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); } +static inline HRESULT IDWriteFactory_GetGdiInterop (IDWriteFactory* this_, IDWriteGdiInterop** gdiInterop) { return ((HRESULT (WINAPI*)(IDWriteFactory*, IDWriteGdiInterop**))this_->v->tbl[17])(this_, gdiInterop); } +static inline HRESULT IDWriteFactory_CreateCustomFontFileReference (IDWriteFactory* this_, const void* fontFileReferenceKey, UINT32 fontFileReferenceKeySize, IDWriteFontFileLoader* fontFileLoader, IDWriteFontFile** fontFile) { return ((HRESULT (WINAPI*)(IDWriteFactory*, const void*, UINT32, IDWriteFontFileLoader*, IDWriteFontFile**))this_->v->tbl[8])(this_, fontFileReferenceKey, fontFileReferenceKeySize, fontFileLoader, fontFile); } +static inline FLOAT IDWriteRenderingParams_GetEnhancedContrast (IDWriteRenderingParams* this__) { return ((FLOAT (WINAPI*)(IDWriteRenderingParams*))this__->v->tbl[4])(this__); } +static inline HRESULT IDWriteGdiInterop_CreateBitmapRenderTarget (IDWriteGdiInterop* this_, HDC hdc, UINT32 width, UINT32 height, IDWriteBitmapRenderTarget** renderTarget) { return ((HRESULT (WINAPI*)(IDWriteGdiInterop*, HDC, UINT32, UINT32, IDWriteBitmapRenderTarget**))this_->v->tbl[7])(this_, hdc, width, height, renderTarget); } +static inline HRESULT IDWriteBitmapRenderTarget_SetPixelsPerDip (IDWriteBitmapRenderTarget* this_, FLOAT pixelsPerDip) { return ((HRESULT (WINAPI*)(IDWriteBitmapRenderTarget*, FLOAT))this_->v->tbl[6])(this_, pixelsPerDip); } +static inline HDC IDWriteBitmapRenderTarget_GetMemoryDC (IDWriteBitmapRenderTarget* this_) { return ((HDC (WINAPI*)(IDWriteBitmapRenderTarget*))this_->v->tbl[4])(this_); } +static inline HRESULT IDWriteBitmapRenderTarget_DrawGlyphRun (IDWriteBitmapRenderTarget* this_, FLOAT baselineOriginX, FLOAT baselineOriginY, DWRITE_MEASURING_MODE measuringMode, const DWRITE_GLYPH_RUN* glyphRun, IDWriteRenderingParams* renderingParams, COLORREF textColor, RECT* blackBoxRect) { return ((HRESULT (WINAPI*)(IDWriteBitmapRenderTarget*, FLOAT, FLOAT, DWRITE_MEASURING_MODE, const DWRITE_GLYPH_RUN*, IDWriteRenderingParams*, COLORREF, RECT*))this_->v->tbl[3])(this_, baselineOriginX, baselineOriginY, measuringMode, glyphRun, renderingParams, textColor, blackBoxRect); } +static inline HRESULT IDWriteFactory_CreateFontFileReference (IDWriteFactory* this_, const WCHAR* filePath, const FILETIME* lastWriteTime, IDWriteFontFile** fontFile) { return ((HRESULT (WINAPI*)(IDWriteFactory*, const WCHAR*, const FILETIME*, IDWriteFontFile**))this_->v->tbl[7])(this_, filePath, lastWriteTime, fontFile); } +static inline HRESULT IDWriteFactory_CreateFontFace (IDWriteFactory* this_, DWRITE_FONT_FACE_TYPE fontFaceType, UINT32 numberOfFiles, IDWriteFontFile** fontFiles, UINT32 faceIndex, DWRITE_FONT_SIMULATIONS fontFaceSimulationFlags, IDWriteFontFace** fontFace) { return ((HRESULT (WINAPI*)(IDWriteFactory*, DWRITE_FONT_FACE_TYPE, UINT32, IDWriteFontFile**, UINT32, DWRITE_FONT_SIMULATIONS, IDWriteFontFace**))this_->v->tbl[9])(this_, fontFaceType, numberOfFiles, fontFiles, faceIndex, fontFaceSimulationFlags, fontFace); } +static inline UINT32 IDWriteFontFace_Release (IDWriteFontFace* this_) { return ((UINT32 (WINAPI*)(IDWriteFontFace*))this_->v->tbl[2])(this_); } +static inline void IDWriteFontFace_GetMetrics (IDWriteFontFace* this_, DWRITE_FONT_METRICS* fontFaceMetrics) { ((void (WINAPI*)(IDWriteFontFace*, DWRITE_FONT_METRICS*))this_->v->tbl[8])(this_, fontFaceMetrics); } +static inline UINT32 IDWriteFontFile_Release (IDWriteFontFile* this_) { return ((UINT32 (WINAPI*)(IDWriteFontFile*))this_->v->tbl[2])(this_); } +static inline HRESULT IDWriteFontFace_GetGlyphIndices (IDWriteFontFace* this_, const UINT32* codePoints, UINT32 codePointCount, UINT16* glyphIndices) { return ((HRESULT (WINAPI*)(IDWriteFontFace*, const UINT32*, UINT32, UINT16*))this_->v->tbl[11])(this_, codePoints, codePointCount, glyphIndices); } +static inline HRESULT IDWriteFontFace_GetGdiCompatibleGlyphMetrics (IDWriteFontFace* this_, FLOAT emSize, FLOAT pixelsPerDip, const DWRITE_MATRIX* transform, BOOL useGdiNatural, const UINT16* glyphIndices, UINT32 glyphCount, DWRITE_GLYPH_METRICS* glyphMetrics, BOOL isSideways) { return ((HRESULT (WINAPI*)(IDWriteFontFace*, FLOAT, FLOAT, const DWRITE_MATRIX*, BOOL, const UINT16*, UINT32, DWRITE_GLYPH_METRICS*, BOOL))this_->v->tbl[17])(this_, emSize, pixelsPerDip, transform, useGdiNatural, glyphIndices, glyphCount, glyphMetrics, isSideways); } +static inline UINT32 IDWriteBitmapRenderTarget_Release (IDWriteBitmapRenderTarget* this_) { return ((UINT32 (WINAPI*)(IDWriteBitmapRenderTarget*))this_->v->tbl[2])(this_); } + +//////////////////////////////// +//~ rjf: Font Provider Implementation Types + //- rjf: font file loader interface types struct FP_DWrite_FontFileLoaderVTable diff --git a/src/font_provider/dwrite/font_provider_dwrite_main.cpp b/src/font_provider/dwrite/font_provider_dwrite_main.cpp index 4ebbb9b2..1f5d20b5 100644 --- a/src/font_provider/dwrite/font_provider_dwrite_main.cpp +++ b/src/font_provider/dwrite/font_provider_dwrite_main.cpp @@ -1,3 +1,6 @@ +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + #define BUILD_SUPPLEMENTARY_UNIT 1 #include "base/base_inc.h" diff --git a/src/rdi_breakpad_from_pdb/rdi_breakpad_from_pdb_main.c b/src/rdi_breakpad_from_pdb/rdi_breakpad_from_pdb_main.c index d0b14071..26d043cd 100644 --- a/src/rdi_breakpad_from_pdb/rdi_breakpad_from_pdb_main.c +++ b/src/rdi_breakpad_from_pdb/rdi_breakpad_from_pdb_main.c @@ -1,3 +1,6 @@ +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + //////////////////////////////// //~ rjf: Build Options From 3c0831ec094d9877371d68315a7ade52f822d727 Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Sat, 1 Jun 2024 18:21:29 -0700 Subject: [PATCH 20/21] font provider dwrite c++ -> c --- ...provider_dwrite.cpp => font_provider_dwrite.c} | 0 .../dwrite/font_provider_dwrite_main.cpp | 15 --------------- src/font_provider/font_provider_inc.c | 10 ++++------ src/font_provider/font_provider_inc.h | 10 ++++------ 4 files changed, 8 insertions(+), 27 deletions(-) rename src/font_provider/dwrite/{font_provider_dwrite.cpp => font_provider_dwrite.c} (100%) delete mode 100644 src/font_provider/dwrite/font_provider_dwrite_main.cpp diff --git a/src/font_provider/dwrite/font_provider_dwrite.cpp b/src/font_provider/dwrite/font_provider_dwrite.c similarity index 100% rename from src/font_provider/dwrite/font_provider_dwrite.cpp rename to src/font_provider/dwrite/font_provider_dwrite.c diff --git a/src/font_provider/dwrite/font_provider_dwrite_main.cpp b/src/font_provider/dwrite/font_provider_dwrite_main.cpp deleted file mode 100644 index 1f5d20b5..00000000 --- a/src/font_provider/dwrite/font_provider_dwrite_main.cpp +++ /dev/null @@ -1,15 +0,0 @@ -// Copyright (c) 2024 Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -#define BUILD_SUPPLEMENTARY_UNIT 1 - -#include "base/base_inc.h" -#include "os/os_inc.h" -#include "font_provider/font_provider.h" - -#include "font_provider_dwrite.h" -#include "font_provider_dwrite.cpp" - -#include "base/base_inc.c" -#include "os/os_inc.c" -#include "font_provider/font_provider.c" diff --git a/src/font_provider/font_provider_inc.c b/src/font_provider/font_provider_inc.c index 92f0554c..f2dc49ae 100644 --- a/src/font_provider/font_provider_inc.c +++ b/src/font_provider/font_provider_inc.c @@ -3,10 +3,8 @@ #include "font_provider.c" -#if LANG_CPP -# if FP_BACKEND == FP_BACKEND_DWRITE -# include "dwrite/font_provider_dwrite.cpp" -# else -# error Font provider backend not specified. -# endif +#if FP_BACKEND == FP_BACKEND_DWRITE +# include "dwrite/font_provider_dwrite.c" +#else +# error Font provider backend not specified. #endif diff --git a/src/font_provider/font_provider_inc.h b/src/font_provider/font_provider_inc.h index 3abf829e..a79c66fc 100644 --- a/src/font_provider/font_provider_inc.h +++ b/src/font_provider/font_provider_inc.h @@ -24,12 +24,10 @@ //////////////////////////////// //~ rjf: Backend Includes -#if LANG_CPP -# if FP_BACKEND == FP_BACKEND_DWRITE -# include "dwrite/font_provider_dwrite.h" -# else -# error Font provider backend not specified. -# endif +#if FP_BACKEND == FP_BACKEND_DWRITE +# include "dwrite/font_provider_dwrite.h" +#else +# error Font provider backend not specified. #endif #endif // FONT_PROVIDER_INC_H From b192e38d12491559c59d75fe9a309576d1d2c4fa Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Sat, 1 Jun 2024 19:21:43 -0700 Subject: [PATCH 21/21] d3d11 render backend c++ -> c; raddbg build c++ -> c --- build.bat | 2 +- src/df/core/df_core.h | 2 +- src/df/gfx/df_gfx.c | 2 +- src/df/gfx/df_gfx.h | 6 +- .../dwrite/font_provider_dwrite.h | 7 + src/raddbg/{raddbg_main.cpp => raddbg_main.c} | 0 .../d3d11/generated/render_d3d11.meta.c | 24 +- .../{render_d3d11.cpp => render_d3d11.c} | 378 +++++++++--------- src/render/d3d11/render_d3d11.h | 9 + src/render/d3d11/render_d3d11.mdesk | 8 +- src/render/d3d11/render_d3d11_main.cpp | 16 - src/render/render_inc.c | 14 +- src/render/render_inc.h | 14 +- 13 files changed, 239 insertions(+), 243 deletions(-) rename src/raddbg/{raddbg_main.cpp => raddbg_main.c} (100%) rename src/render/d3d11/{render_d3d11.cpp => render_d3d11.c} (71%) delete mode 100644 src/render/d3d11/render_d3d11_main.cpp diff --git a/build.bat b/build.bat index 84cb941b..41f8ecb9 100644 --- a/build.bat +++ b/build.bat @@ -98,7 +98,7 @@ if not "%no_meta%"=="1" ( :: --- Build Everything (@build_targets) -------------------------------------- pushd build -if "%raddbg%"=="1" %compile% %gfx% ..\src\raddbg\raddbg_main.cpp %compile_link% %out%raddbg.exe || exit /b 1 +if "%raddbg%"=="1" %compile% %gfx% ..\src\raddbg\raddbg_main.c %compile_link% %out%raddbg.exe || exit /b 1 if "%rdi_from_pdb%"=="1" %compile% ..\src\rdi_from_pdb\rdi_from_pdb_main.c %compile_link% %out%rdi_from_pdb.exe || exit /b 1 if "%rdi_from_dwarf%"=="1" %compile% ..\src\rdi_from_dwarf\rdi_from_dwarf.c %compile_link% %out%rdi_from_dwarf.exe || exit /b 1 if "%rdi_dump%"=="1" %compile% ..\src\rdi_dump\rdi_dump_main.c %compile_link% %out%rdi_dump.exe || exit /b 1 diff --git a/src/df/core/df_core.h b/src/df/core/df_core.h index 9eeb8fd4..1a5e032d 100644 --- a/src/df/core/df_core.h +++ b/src/df/core/df_core.h @@ -1571,7 +1571,7 @@ internal DF_Entity *df_log_from_entity(DF_Entity *entity); internal void df_push_ctrl_msg(CTRL_Msg *msg); //- rjf: control thread running -internal void df_ctrl_run(DF_RunKind run, DF_Entity *target, DF_Entity *run_thread, CTRL_RunFlags flags, CTRL_TrapList *run_traps); +internal void df_ctrl_run(DF_RunKind run, DF_Entity *run_thread, CTRL_RunFlags flags, CTRL_TrapList *run_traps); //- rjf: stopped info from the control thread internal CTRL_Event df_ctrl_last_stop_event(void); diff --git a/src/df/gfx/df_gfx.c b/src/df/gfx/df_gfx.c index d0b8ae1a..99931256 100644 --- a/src/df/gfx/df_gfx.c +++ b/src/df/gfx/df_gfx.c @@ -7971,7 +7971,7 @@ df_window_update_and_render(Arena *arena, DF_Window *ws, DF_CmdList *cmds) // rhp: disabled overlay color blends from plain background and inactive panel overlay Vec4F32 bg = df_rgba_from_theme_color(DF_ThemeColor_PlainBackground); Vec4F32 ov = df_rgba_from_theme_color(DF_ThemeColor_InactivePanelOverlay); - Vec4F32 color = {}; + Vec4F32 color = {0}; color.x = bg.x * bg.w + ov.x * ov.w * (1.0f - bg.w); color.y = bg.y * bg.w + ov.y * ov.w * (1.0f - bg.w); color.z = bg.z * bg.w + ov.z * ov.w * (1.0f - bg.w); diff --git a/src/df/gfx/df_gfx.h b/src/df/gfx/df_gfx.h index 3a724f90..1a91dc25 100644 --- a/src/df/gfx/df_gfx.h +++ b/src/df/gfx/df_gfx.h @@ -69,9 +69,9 @@ struct DF_KeyMapSlot //////////////////////////////// //~ rjf: View Functions -struct DF_View; -struct DF_Panel; -struct DF_Window; +typedef struct DF_View DF_View; +typedef struct DF_Panel DF_Panel; +typedef struct DF_Window DF_Window; #define DF_VIEW_SETUP_FUNCTION_SIG(name) void name(DF_Window *ws, struct DF_View *view, DF_CfgNode *cfg_root) #define DF_VIEW_SETUP_FUNCTION_NAME(name) df_view_setup_##name diff --git a/src/font_provider/dwrite/font_provider_dwrite.h b/src/font_provider/dwrite/font_provider_dwrite.h index c8c4d1e9..973104fe 100644 --- a/src/font_provider/dwrite/font_provider_dwrite.h +++ b/src/font_provider/dwrite/font_provider_dwrite.h @@ -192,6 +192,7 @@ static inline UINT32 IDWriteBitmapRenderTarget_Releas //- rjf: font file loader interface types +typedef struct FP_DWrite_FontFileLoaderVTable FP_DWrite_FontFileLoaderVTable; struct FP_DWrite_FontFileLoaderVTable { HRESULT (*QueryInterface)(void *obj, REFIID riid, void *ptr_to_object); @@ -200,6 +201,7 @@ struct FP_DWrite_FontFileLoaderVTable HRESULT (*CreateStreamFromKey)(struct FP_DWrite_FontFileLoader *loader, void const *font_file_ref_key, UINT32 font_file_ref_key_size, IDWriteFontFileStream **stream_out); }; +typedef struct FP_DWrite_FontFileLoader FP_DWrite_FontFileLoader; struct FP_DWrite_FontFileLoader { FP_DWrite_FontFileLoaderVTable *lpVtbl; @@ -207,6 +209,7 @@ struct FP_DWrite_FontFileLoader //- rjf: font file stream interface types +typedef struct FP_DWrite_FontFileStreamVTable FP_DWrite_FontFileStreamVTable; struct FP_DWrite_FontFileStreamVTable { HRESULT (*QueryInterface)(void *obj, REFIID riid, void *ptr_to_object); @@ -218,12 +221,14 @@ struct FP_DWrite_FontFileStreamVTable HRESULT (*GetLastWriteTime)(struct FP_DWrite_FontFileStream *obj, UINT64 *time_out); }; +typedef struct FP_DWrite_FontFileStream FP_DWrite_FontFileStream; struct FP_DWrite_FontFileStream { FP_DWrite_FontFileStreamVTable *lpVtbl; String8 *data; }; +typedef struct FP_DWrite_FontFileStreamNode FP_DWrite_FontFileStreamNode; struct FP_DWrite_FontFileStreamNode { FP_DWrite_FontFileStreamNode *next; @@ -233,6 +238,7 @@ struct FP_DWrite_FontFileStreamNode //- rjf: state & underlying handle types +typedef struct FP_DWrite_State FP_DWrite_State; struct FP_DWrite_State { Arena *arena; @@ -247,6 +253,7 @@ struct FP_DWrite_State FP_DWrite_FontFileStreamNode *free_stream_node; }; +typedef struct FP_DWrite_Font FP_DWrite_Font; struct FP_DWrite_Font { IDWriteFontFile *file; diff --git a/src/raddbg/raddbg_main.cpp b/src/raddbg/raddbg_main.c similarity index 100% rename from src/raddbg/raddbg_main.cpp rename to src/raddbg/raddbg_main.c diff --git a/src/render/d3d11/generated/render_d3d11.meta.c b/src/render/d3d11/generated/render_d3d11.meta.c index 08a2c9e0..f365b3f0 100644 --- a/src/render/d3d11/generated/render_d3d11.meta.c +++ b/src/render/d3d11/generated/render_d3d11.meta.c @@ -4,13 +4,13 @@ //- GENERATED CODE C_LINKAGE_BEGIN -String8 r_d3d11_g_vshad_kind_source_table[5] = +String8* r_d3d11_g_vshad_kind_source_table[5] = { -r_d3d11_g_rect_shader_src, -r_d3d11_g_blur_shader_src, -r_d3d11_g_mesh_shader_src, -r_d3d11_g_geo3dcomposite_shader_src, -r_d3d11_g_finalize_shader_src, +&r_d3d11_g_rect_shader_src, +&r_d3d11_g_blur_shader_src, +&r_d3d11_g_mesh_shader_src, +&r_d3d11_g_geo3dcomposite_shader_src, +&r_d3d11_g_finalize_shader_src, }; String8 r_d3d11_g_vshad_kind_source_name_table[5] = @@ -40,13 +40,13 @@ ArrayCount(r_d3d11_g_mesh_ilay_elements) , 0, }; -String8 r_d3d11_g_pshad_kind_source_table[5] = +String8* r_d3d11_g_pshad_kind_source_table[5] = { -r_d3d11_g_rect_shader_src, -r_d3d11_g_blur_shader_src, -r_d3d11_g_mesh_shader_src, -r_d3d11_g_geo3dcomposite_shader_src, -r_d3d11_g_finalize_shader_src, +&r_d3d11_g_rect_shader_src, +&r_d3d11_g_blur_shader_src, +&r_d3d11_g_mesh_shader_src, +&r_d3d11_g_geo3dcomposite_shader_src, +&r_d3d11_g_finalize_shader_src, }; String8 r_d3d11_g_pshad_kind_source_name_table[5] = diff --git a/src/render/d3d11/render_d3d11.cpp b/src/render/d3d11/render_d3d11.c similarity index 71% rename from src/render/d3d11/render_d3d11.cpp rename to src/render/d3d11/render_d3d11.c index 708d1a59..50288498 100644 --- a/src/render/d3d11/render_d3d11.cpp +++ b/src/render/d3d11/render_d3d11.c @@ -114,7 +114,7 @@ r_d3d11_instance_buffer_from_size(U64 size) desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; } - HRESULT error = r_d3d11_state->device->CreateBuffer(&desc, 0, &buffer); + HRESULT error = r_d3d11_state->device->lpVtbl->CreateBuffer(r_d3d11_state->device, &desc, 0, &buffer); } // rjf: push buffer to flush list @@ -213,24 +213,24 @@ r_init(CmdLine *cmdln) if(cmd_line_has_flag(cmdln, str8_lit("d3d11_debug"))) { ID3D11InfoQueue *info = 0; - error = r_d3d11_state->base_device->QueryInterface(__uuidof(ID3D11InfoQueue), (void **)(&info)); + error = r_d3d11_state->base_device->lpVtbl->QueryInterface(r_d3d11_state->base_device, &IID_ID3D11InfoQueue, (void **)(&info)); if(SUCCEEDED(error)) { - error = info->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, TRUE); - error = info->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, TRUE); - info->Release(); + error = info->lpVtbl->SetBreakOnSeverity(info, D3D11_MESSAGE_SEVERITY_CORRUPTION, TRUE); + error = info->lpVtbl->SetBreakOnSeverity(info, D3D11_MESSAGE_SEVERITY_ERROR, TRUE); + info->lpVtbl->Release(info); } } #endif //- rjf: get main device - error = r_d3d11_state->base_device->QueryInterface(__uuidof(ID3D11Device1), (void **)(&r_d3d11_state->device)); - error = r_d3d11_state->base_device_ctx->QueryInterface(__uuidof(ID3D11DeviceContext1), (void **)(&r_d3d11_state->device_ctx)); + error = r_d3d11_state->base_device->lpVtbl->QueryInterface(r_d3d11_state->base_device, &IID_ID3D11Device1, (void **)(&r_d3d11_state->device)); + error = r_d3d11_state->base_device_ctx->lpVtbl->QueryInterface(r_d3d11_state->base_device_ctx, &IID_ID3D11DeviceContext1, (void **)(&r_d3d11_state->device_ctx)); //- rjf: get dxgi device/adapter/factory - error = r_d3d11_state->device->QueryInterface(__uuidof(IDXGIDevice1), (void **)(&r_d3d11_state->dxgi_device)); - error = r_d3d11_state->dxgi_device->GetAdapter(&r_d3d11_state->dxgi_adapter); - error = r_d3d11_state->dxgi_adapter->GetParent(__uuidof(IDXGIFactory2), (void **)(&r_d3d11_state->dxgi_factory)); + error = r_d3d11_state->device->lpVtbl->QueryInterface(r_d3d11_state->device, &IID_IDXGIDevice1, (void **)(&r_d3d11_state->dxgi_device)); + error = r_d3d11_state->dxgi_device->lpVtbl->GetAdapter(r_d3d11_state->dxgi_device, &r_d3d11_state->dxgi_adapter); + error = r_d3d11_state->dxgi_adapter->lpVtbl->GetParent(r_d3d11_state->dxgi_adapter, &IID_IDXGIFactory2, (void **)(&r_d3d11_state->dxgi_factory)); //- rjf: create main rasterizer { @@ -240,7 +240,7 @@ r_init(CmdLine *cmdln) desc.CullMode = D3D11_CULL_BACK; desc.ScissorEnable = 1; } - error = r_d3d11_state->device->CreateRasterizerState1(&desc, &r_d3d11_state->main_rasterizer); + error = r_d3d11_state->device->lpVtbl->CreateRasterizerState1(r_d3d11_state->device, &desc, &r_d3d11_state->main_rasterizer); } //- rjf: create main blend state @@ -256,7 +256,7 @@ r_init(CmdLine *cmdln) desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; } - error = r_d3d11_state->device->CreateBlendState(&desc, &r_d3d11_state->main_blend_state); + error = r_d3d11_state->device->lpVtbl->CreateBlendState(r_d3d11_state->device, &desc, &r_d3d11_state->main_blend_state); } { @@ -265,7 +265,7 @@ r_init(CmdLine *cmdln) desc.RenderTarget[0].BlendEnable = FALSE; desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; } - error = r_d3d11_state->device->CreateBlendState(&desc, &r_d3d11_state->no_blend_state); + error = r_d3d11_state->device->lpVtbl->CreateBlendState(r_d3d11_state->device, &desc, &r_d3d11_state->no_blend_state); } //- rjf: create nearest-neighbor sampler @@ -278,7 +278,7 @@ r_init(CmdLine *cmdln) desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; desc.ComparisonFunc = D3D11_COMPARISON_NEVER; } - error = r_d3d11_state->device->CreateSamplerState(&desc, &r_d3d11_state->samplers[R_Tex2DSampleKind_Nearest]); + error = r_d3d11_state->device->lpVtbl->CreateSamplerState(r_d3d11_state->device, &desc, &r_d3d11_state->samplers[R_Tex2DSampleKind_Nearest]); } //- rjf: create bilinear sampler @@ -291,7 +291,7 @@ r_init(CmdLine *cmdln) desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; desc.ComparisonFunc = D3D11_COMPARISON_NEVER; } - error = r_d3d11_state->device->CreateSamplerState(&desc, &r_d3d11_state->samplers[R_Tex2DSampleKind_Linear]); + error = r_d3d11_state->device->lpVtbl->CreateSamplerState(r_d3d11_state->device, &desc, &r_d3d11_state->samplers[R_Tex2DSampleKind_Linear]); } //- rjf: create noop depth/stencil state @@ -302,7 +302,7 @@ r_init(CmdLine *cmdln) desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; desc.DepthFunc = D3D11_COMPARISON_LESS; } - error = r_d3d11_state->device->CreateDepthStencilState(&desc, &r_d3d11_state->noop_depth_stencil); + error = r_d3d11_state->device->lpVtbl->CreateDepthStencilState(r_d3d11_state->device, &desc, &r_d3d11_state->noop_depth_stencil); } //- rjf: create plain depth/stencil state @@ -313,7 +313,7 @@ r_init(CmdLine *cmdln) desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; desc.DepthFunc = D3D11_COMPARISON_LESS; } - error = r_d3d11_state->device->CreateDepthStencilState(&desc, &r_d3d11_state->plain_depth_stencil); + error = r_d3d11_state->device->lpVtbl->CreateDepthStencilState(r_d3d11_state->device, &desc, &r_d3d11_state->plain_depth_stencil); } //- rjf: create buffers @@ -325,7 +325,7 @@ r_init(CmdLine *cmdln) desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; } - error = r_d3d11_state->device->CreateBuffer(&desc, 0, &r_d3d11_state->instance_scratch_buffer_64kb); + error = r_d3d11_state->device->lpVtbl->CreateBuffer(r_d3d11_state->device, &desc, 0, &r_d3d11_state->instance_scratch_buffer_64kb); } //- rjf: build vertex shaders & input layouts @@ -333,7 +333,7 @@ r_init(CmdLine *cmdln) kind < R_D3D11_VShadKind_COUNT; kind = (R_D3D11_VShadKind)(kind+1)) { - String8 source = r_d3d11_g_vshad_kind_source_table[kind]; + String8 source = *r_d3d11_g_vshad_kind_source_table[kind]; String8 source_name = r_d3d11_g_vshad_kind_source_name_table[kind]; D3D11_INPUT_ELEMENT_DESC *ilay_elements = r_d3d11_g_vshad_kind_elements_ptr_table[kind]; U64 ilay_elements_count = r_d3d11_g_vshad_kind_elements_count_table[kind]; @@ -357,13 +357,13 @@ r_init(CmdLine *cmdln) String8 errors = {0}; if(FAILED(error)) { - errors = str8((U8 *)vshad_source_errors->GetBufferPointer(), - (U64)vshad_source_errors->GetBufferSize()); + errors = str8((U8 *)vshad_source_errors->lpVtbl->GetBufferPointer(vshad_source_errors), + (U64)vshad_source_errors->lpVtbl->GetBufferSize(vshad_source_errors)); os_graphical_message(1, str8_lit("Vertex Shader Compilation Failure"), errors); } else { - error = r_d3d11_state->device->CreateVertexShader(vshad_source_blob->GetBufferPointer(), vshad_source_blob->GetBufferSize(), 0, &vshad); + error = r_d3d11_state->device->lpVtbl->CreateVertexShader(r_d3d11_state->device, vshad_source_blob->lpVtbl->GetBufferPointer(vshad_source_blob), vshad_source_blob->lpVtbl->GetBufferSize(vshad_source_blob), 0, &vshad); } } @@ -371,13 +371,13 @@ r_init(CmdLine *cmdln) ID3D11InputLayout *ilay = 0; if(ilay_elements != 0) { - error = r_d3d11_state->device->CreateInputLayout(ilay_elements, ilay_elements_count, - vshad_source_blob->GetBufferPointer(), - vshad_source_blob->GetBufferSize(), - &ilay); + error = r_d3d11_state->device->lpVtbl->CreateInputLayout(r_d3d11_state->device, ilay_elements, ilay_elements_count, + vshad_source_blob->lpVtbl->GetBufferPointer(vshad_source_blob), + vshad_source_blob->lpVtbl->GetBufferSize(vshad_source_blob), + &ilay); } - vshad_source_blob->Release(); + vshad_source_blob->lpVtbl->Release(vshad_source_blob); // rjf: store r_d3d11_state->vshads[kind] = vshad; @@ -389,7 +389,7 @@ r_init(CmdLine *cmdln) kind < R_D3D11_PShadKind_COUNT; kind = (R_D3D11_PShadKind)(kind+1)) { - String8 source = r_d3d11_g_pshad_kind_source_table[kind]; + String8 source = *r_d3d11_g_pshad_kind_source_table[kind]; String8 source_name = r_d3d11_g_pshad_kind_source_name_table[kind]; // rjf: compile pixel shader @@ -411,17 +411,17 @@ r_init(CmdLine *cmdln) String8 errors = {0}; if(FAILED(error)) { - errors = str8((U8 *)pshad_source_errors->GetBufferPointer(), - (U64)pshad_source_errors->GetBufferSize()); + errors = str8((U8 *)pshad_source_errors->lpVtbl->GetBufferPointer(pshad_source_errors), + (U64)pshad_source_errors->lpVtbl->GetBufferSize(pshad_source_errors)); os_graphical_message(1, str8_lit("Pixel Shader Compilation Failure"), errors); } else { - error = r_d3d11_state->device->CreatePixelShader(pshad_source_blob->GetBufferPointer(), pshad_source_blob->GetBufferSize(), 0, &pshad); + error = r_d3d11_state->device->lpVtbl->CreatePixelShader(r_d3d11_state->device, pshad_source_blob->lpVtbl->GetBufferPointer(pshad_source_blob), pshad_source_blob->lpVtbl->GetBufferSize(pshad_source_blob), 0, &pshad); } } - pshad_source_blob->Release(); + pshad_source_blob->lpVtbl->Release(pshad_source_blob); // rjf: store r_d3d11_state->pshads[kind] = pshad; @@ -443,7 +443,7 @@ r_init(CmdLine *cmdln) desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; } - r_d3d11_state->device->CreateBuffer(&desc, 0, &buffer); + r_d3d11_state->device->lpVtbl->CreateBuffer(r_d3d11_state->device, &desc, 0, &buffer); } r_d3d11_state->uniform_type_kind_buffers[kind] = buffer; } @@ -515,7 +515,7 @@ r_window_equip(OS_Handle handle) swapchain_desc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED; swapchain_desc.Flags = 0; } - HRESULT error = r_d3d11_state->dxgi_factory->CreateSwapChainForHwnd(r_d3d11_state->device, hwnd, &swapchain_desc, 0, 0, &window->swapchain); + HRESULT error = r_d3d11_state->dxgi_factory->lpVtbl->CreateSwapChainForHwnd(r_d3d11_state->dxgi_factory, (IUnknown *)r_d3d11_state->device, hwnd, &swapchain_desc, 0, 0, &window->swapchain); if(FAILED(error)) { char buffer[256] = {0}; @@ -524,11 +524,11 @@ r_window_equip(OS_Handle handle) os_exit_process(1); } - r_d3d11_state->dxgi_factory->MakeWindowAssociation(hwnd, DXGI_MWA_NO_ALT_ENTER); + r_d3d11_state->dxgi_factory->lpVtbl->MakeWindowAssociation(r_d3d11_state->dxgi_factory, hwnd, DXGI_MWA_NO_ALT_ENTER); //- rjf: create framebuffer & view - window->swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void **)(&window->framebuffer)); - r_d3d11_state->device->CreateRenderTargetView(window->framebuffer, 0, &window->framebuffer_rtv); + window->swapchain->lpVtbl->GetBuffer(window->swapchain, 0, &IID_ID3D11Texture2D, (void **)(&window->framebuffer)); + r_d3d11_state->device->lpVtbl->CreateRenderTargetView(r_d3d11_state->device, (ID3D11Resource *)window->framebuffer, 0, &window->framebuffer_rtv); result = r_d3d11_handle_from_window(window); } @@ -543,15 +543,15 @@ r_window_unequip(OS_Handle handle, R_Handle equip_handle) OS_MutexScopeW(r_d3d11_state->device_rw_mutex) { R_D3D11_Window *window = r_d3d11_window_from_handle(equip_handle); - window->stage_color_srv->Release(); - window->stage_color_rtv->Release(); - window->stage_color->Release(); - window->stage_scratch_color_srv->Release(); - window->stage_scratch_color_rtv->Release(); - window->stage_scratch_color->Release(); - window->framebuffer_rtv->Release(); - window->framebuffer->Release(); - window->swapchain->Release(); + window->stage_color_srv->lpVtbl->Release(window->stage_color_srv); + window->stage_color_rtv->lpVtbl->Release(window->stage_color_rtv); + window->stage_color->lpVtbl->Release(window->stage_color); + window->stage_scratch_color_srv->lpVtbl->Release(window->stage_scratch_color_srv); + window->stage_scratch_color_rtv->lpVtbl->Release(window->stage_scratch_color_rtv); + window->stage_scratch_color->lpVtbl->Release(window->stage_scratch_color); + window->framebuffer_rtv->lpVtbl->Release(window->framebuffer_rtv); + window->framebuffer->lpVtbl->Release(window->framebuffer); + window->swapchain->lpVtbl->Release(window->swapchain); window->generation += 1; SLLStackPush(r_d3d11_state->first_free_window, window); } @@ -633,10 +633,10 @@ r_tex2d_alloc(R_ResourceKind kind, Vec2S32 size, R_Tex2DFormat format, void *dat texture_desc.BindFlags = D3D11_BIND_SHADER_RESOURCE; texture_desc.CPUAccessFlags = cpu_access_flags; } - r_d3d11_state->device->CreateTexture2D(&texture_desc, initial_data, &texture->texture); + r_d3d11_state->device->lpVtbl->CreateTexture2D(r_d3d11_state->device, &texture_desc, initial_data, &texture->texture); //- rjf: create texture srv - r_d3d11_state->device->CreateShaderResourceView(texture->texture, 0, &texture->view); + r_d3d11_state->device->lpVtbl->CreateShaderResourceView(r_d3d11_state->device, (ID3D11Resource *)texture->texture, 0, &texture->view); //- rjf: fill basics { @@ -698,7 +698,7 @@ r_fill_tex2d_region(R_Handle handle, Rng2S32 subrect, void *data) (UINT)subrect.x0, (UINT)subrect.y0, 0, (UINT)subrect.x1, (UINT)subrect.y1, 1, }; - r_d3d11_state->device_ctx->UpdateSubresource(texture->texture, 0, &dst_box, data, dim.x*bytes_per_pixel, 0); + r_d3d11_state->device_ctx->lpVtbl->UpdateSubresource(r_d3d11_state->device_ctx, (ID3D11Resource *)texture->texture, 0, &dst_box, data, dim.x*bytes_per_pixel, 0); } ProfEnd(); } @@ -754,7 +754,7 @@ r_buffer_alloc(R_ResourceKind kind, U64 size, void *data) desc.BindFlags = D3D11_BIND_VERTEX_BUFFER|D3D11_BIND_INDEX_BUFFER; desc.CPUAccessFlags = cpu_access_flags; } - r_d3d11_state->device->CreateBuffer(&desc, initial_data, &buffer->buffer); + r_d3d11_state->device->lpVtbl->CreateBuffer(r_d3d11_state->device, &desc, initial_data, &buffer->buffer); //- rjf: fill basics { @@ -797,15 +797,15 @@ r_end_frame(void) { for(R_D3D11_FlushBuffer *buffer = r_d3d11_state->first_buffer_to_flush; buffer != 0; buffer = buffer->next) { - buffer->buffer->Release(); + buffer->buffer->lpVtbl->Release(buffer->buffer); } for(R_D3D11_Tex2D *tex = r_d3d11_state->first_to_free_tex2d, *next = 0; tex != 0; tex = next) { next = tex->next; - tex->view->Release(); - tex->texture->Release(); + tex->view->lpVtbl->Release(tex->view); + tex->texture->lpVtbl->Release(tex->texture); tex->generation += 1; SLLStackPush(r_d3d11_state->first_free_tex2d, tex); } @@ -814,7 +814,7 @@ r_end_frame(void) buf = next) { next = buf->next; - buf->buffer->Release(); + buf->buffer->lpVtbl->Release(buf->buffer); buf->generation += 1; SLLStackPush(r_d3d11_state->first_free_buffer, buf); } @@ -847,108 +847,108 @@ r_window_begin_frame(OS_Handle window, R_Handle window_equip) wnd->last_resolution = resolution; // rjf: release screen-sized render target resources, if there - if(wnd->stage_scratch_color_srv){wnd->stage_scratch_color_srv->Release();} - if(wnd->stage_scratch_color_rtv){wnd->stage_scratch_color_rtv->Release();} - if(wnd->stage_scratch_color) {wnd->stage_scratch_color->Release();} - if(wnd->stage_color_srv) {wnd->stage_color_srv->Release();} - if(wnd->stage_color_rtv) {wnd->stage_color_rtv->Release();} - if(wnd->stage_color) {wnd->stage_color->Release();} - if(wnd->geo3d_color_srv) {wnd->geo3d_color_srv->Release();} - if(wnd->geo3d_color_rtv) {wnd->geo3d_color_rtv->Release();} - if(wnd->geo3d_color) {wnd->geo3d_color->Release();} - if(wnd->geo3d_depth_srv) {wnd->geo3d_depth_srv->Release();} - if(wnd->geo3d_depth_dsv) {wnd->geo3d_depth_dsv->Release();} - if(wnd->geo3d_depth) {wnd->geo3d_depth->Release();} + if(wnd->stage_scratch_color_srv){wnd->stage_scratch_color_srv->lpVtbl->Release(wnd->stage_scratch_color_srv);} + if(wnd->stage_scratch_color_rtv){wnd->stage_scratch_color_rtv->lpVtbl->Release(wnd->stage_scratch_color_rtv);} + if(wnd->stage_scratch_color) {wnd->stage_scratch_color->lpVtbl->Release(wnd->stage_scratch_color);} + if(wnd->stage_color_srv) {wnd->stage_color_srv->lpVtbl->Release(wnd->stage_color_srv);} + if(wnd->stage_color_rtv) {wnd->stage_color_rtv->lpVtbl->Release(wnd->stage_color_rtv);} + if(wnd->stage_color) {wnd->stage_color->lpVtbl->Release(wnd->stage_color);} + if(wnd->geo3d_color_srv) {wnd->geo3d_color_srv->lpVtbl->Release(wnd->geo3d_color_srv);} + if(wnd->geo3d_color_rtv) {wnd->geo3d_color_rtv->lpVtbl->Release(wnd->geo3d_color_rtv);} + if(wnd->geo3d_color) {wnd->geo3d_color->lpVtbl->Release(wnd->geo3d_color);} + if(wnd->geo3d_depth_srv) {wnd->geo3d_depth_srv->lpVtbl->Release(wnd->geo3d_depth_srv);} + if(wnd->geo3d_depth_dsv) {wnd->geo3d_depth_dsv->lpVtbl->Release(wnd->geo3d_depth_dsv);} + if(wnd->geo3d_depth) {wnd->geo3d_depth->lpVtbl->Release(wnd->geo3d_depth);} // rjf: resize swapchain & main framebuffer - wnd->framebuffer_rtv->Release(); - wnd->framebuffer->Release(); - wnd->swapchain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); - wnd->swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void **)(&wnd->framebuffer)); - r_d3d11_state->device->CreateRenderTargetView(wnd->framebuffer, 0, &wnd->framebuffer_rtv); + wnd->framebuffer_rtv->lpVtbl->Release(wnd->framebuffer_rtv); + wnd->framebuffer->lpVtbl->Release(wnd->framebuffer); + wnd->swapchain->lpVtbl->ResizeBuffers(wnd->swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + wnd->swapchain->lpVtbl->GetBuffer(wnd->swapchain, 0, &IID_ID3D11Texture2D, (void **)(&wnd->framebuffer)); + r_d3d11_state->device->lpVtbl->CreateRenderTargetView(r_d3d11_state->device, (ID3D11Resource *)wnd->framebuffer, 0, &wnd->framebuffer_rtv); // rjf: create stage color targets { - D3D11_TEXTURE2D_DESC color_desc = {}; + D3D11_TEXTURE2D_DESC color_desc = zero_struct; { - wnd->framebuffer->GetDesc(&color_desc); + wnd->framebuffer->lpVtbl->GetDesc(wnd->framebuffer, &color_desc); color_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; color_desc.BindFlags = D3D11_BIND_RENDER_TARGET|D3D11_BIND_SHADER_RESOURCE; } - D3D11_RENDER_TARGET_VIEW_DESC rtv_desc = {}; + D3D11_RENDER_TARGET_VIEW_DESC rtv_desc = zero_struct; { rtv_desc.Format = color_desc.Format; rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; } - D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc = {}; + D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc = zero_struct; { srv_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; srv_desc.Texture2D.MipLevels = -1; } - r_d3d11_state->device->CreateTexture2D(&color_desc, 0, &wnd->stage_color); - r_d3d11_state->device->CreateRenderTargetView(wnd->stage_color, &rtv_desc, &wnd->stage_color_rtv); - r_d3d11_state->device->CreateShaderResourceView(wnd->stage_color, &srv_desc, &wnd->stage_color_srv); - r_d3d11_state->device->CreateTexture2D(&color_desc, 0, &wnd->stage_scratch_color); - r_d3d11_state->device->CreateRenderTargetView(wnd->stage_scratch_color, &rtv_desc, &wnd->stage_scratch_color_rtv); - r_d3d11_state->device->CreateShaderResourceView(wnd->stage_scratch_color, &srv_desc, &wnd->stage_scratch_color_srv); + r_d3d11_state->device->lpVtbl->CreateTexture2D(r_d3d11_state->device, &color_desc, 0, &wnd->stage_color); + r_d3d11_state->device->lpVtbl->CreateRenderTargetView(r_d3d11_state->device, (ID3D11Resource *)wnd->stage_color, &rtv_desc, &wnd->stage_color_rtv); + r_d3d11_state->device->lpVtbl->CreateShaderResourceView(r_d3d11_state->device, (ID3D11Resource *)wnd->stage_color, &srv_desc, &wnd->stage_color_srv); + r_d3d11_state->device->lpVtbl->CreateTexture2D(r_d3d11_state->device, &color_desc, 0, &wnd->stage_scratch_color); + r_d3d11_state->device->lpVtbl->CreateRenderTargetView(r_d3d11_state->device, (ID3D11Resource *)wnd->stage_scratch_color, &rtv_desc, &wnd->stage_scratch_color_rtv); + r_d3d11_state->device->lpVtbl->CreateShaderResourceView(r_d3d11_state->device, (ID3D11Resource *)wnd->stage_scratch_color, &srv_desc, &wnd->stage_scratch_color_srv); } // rjf: create geo3d targets { - D3D11_TEXTURE2D_DESC color_desc = {}; + D3D11_TEXTURE2D_DESC color_desc = zero_struct; { - wnd->framebuffer->GetDesc(&color_desc); + wnd->framebuffer->lpVtbl->GetDesc(wnd->framebuffer, &color_desc); color_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; color_desc.BindFlags = D3D11_BIND_RENDER_TARGET|D3D11_BIND_SHADER_RESOURCE; } - D3D11_RENDER_TARGET_VIEW_DESC color_rtv_desc = {}; + D3D11_RENDER_TARGET_VIEW_DESC color_rtv_desc = zero_struct; { color_rtv_desc.Format = color_desc.Format; color_rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; } - D3D11_SHADER_RESOURCE_VIEW_DESC color_srv_desc = {}; + D3D11_SHADER_RESOURCE_VIEW_DESC color_srv_desc = zero_struct; { color_srv_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; color_srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; color_srv_desc.Texture2D.MipLevels = -1; } - D3D11_TEXTURE2D_DESC depth_desc = {}; + D3D11_TEXTURE2D_DESC depth_desc = zero_struct; { - wnd->framebuffer->GetDesc(&depth_desc); + wnd->framebuffer->lpVtbl->GetDesc(wnd->framebuffer, &depth_desc); depth_desc.Format = DXGI_FORMAT_R24G8_TYPELESS; depth_desc.BindFlags = D3D11_BIND_DEPTH_STENCIL|D3D11_BIND_SHADER_RESOURCE; } - D3D11_DEPTH_STENCIL_VIEW_DESC depth_dsv_desc = {}; + D3D11_DEPTH_STENCIL_VIEW_DESC depth_dsv_desc = zero_struct; { depth_dsv_desc.Flags = 0; depth_dsv_desc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; depth_dsv_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; depth_dsv_desc.Texture2D.MipSlice = 0; } - D3D11_SHADER_RESOURCE_VIEW_DESC depth_srv_desc = {}; + D3D11_SHADER_RESOURCE_VIEW_DESC depth_srv_desc = zero_struct; { depth_srv_desc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; depth_srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; depth_srv_desc.Texture2D.MostDetailedMip = 0; depth_srv_desc.Texture2D.MipLevels = -1; } - r_d3d11_state->device->CreateTexture2D(&color_desc, 0, &wnd->geo3d_color); - r_d3d11_state->device->CreateRenderTargetView(wnd->geo3d_color, &color_rtv_desc, &wnd->geo3d_color_rtv); - r_d3d11_state->device->CreateShaderResourceView(wnd->geo3d_color, &color_srv_desc, &wnd->geo3d_color_srv); - r_d3d11_state->device->CreateTexture2D(&depth_desc, 0, &wnd->geo3d_depth); - r_d3d11_state->device->CreateDepthStencilView(wnd->geo3d_depth, &depth_dsv_desc, &wnd->geo3d_depth_dsv); - r_d3d11_state->device->CreateShaderResourceView(wnd->geo3d_depth, &depth_srv_desc, &wnd->geo3d_depth_srv); + r_d3d11_state->device->lpVtbl->CreateTexture2D(r_d3d11_state->device, &color_desc, 0, &wnd->geo3d_color); + r_d3d11_state->device->lpVtbl->CreateRenderTargetView(r_d3d11_state->device, (ID3D11Resource *)wnd->geo3d_color, &color_rtv_desc, &wnd->geo3d_color_rtv); + r_d3d11_state->device->lpVtbl->CreateShaderResourceView(r_d3d11_state->device, (ID3D11Resource *)wnd->geo3d_color, &color_srv_desc, &wnd->geo3d_color_srv); + r_d3d11_state->device->lpVtbl->CreateTexture2D(r_d3d11_state->device, &depth_desc, 0, &wnd->geo3d_depth); + r_d3d11_state->device->lpVtbl->CreateDepthStencilView(r_d3d11_state->device, (ID3D11Resource *)wnd->geo3d_depth, &depth_dsv_desc, &wnd->geo3d_depth_dsv); + r_d3d11_state->device->lpVtbl->CreateShaderResourceView(r_d3d11_state->device, (ID3D11Resource *)wnd->geo3d_depth, &depth_srv_desc, &wnd->geo3d_depth_srv); } } //- rjf: clear framebuffers Vec4F32 clear_color = {0, 0, 0, 0}; - d_ctx->ClearRenderTargetView(wnd->framebuffer_rtv, clear_color.v); - d_ctx->ClearRenderTargetView(wnd->stage_color_rtv, clear_color.v); + d_ctx->lpVtbl->ClearRenderTargetView(d_ctx, wnd->framebuffer_rtv, clear_color.v); + d_ctx->lpVtbl->ClearRenderTargetView(d_ctx, wnd->stage_color_rtv, clear_color.v); if(resize_done) { - d_ctx->Flush(); + d_ctx->lpVtbl->Flush(d_ctx); } } ProfEnd(); @@ -972,25 +972,25 @@ r_window_end_frame(OS_Handle window, R_Handle window_equip) ID3D11PixelShader *pshad = r_d3d11_state->pshads[R_D3D11_PShadKind_Finalize]; // rjf: setup output merger - d_ctx->OMSetRenderTargets(1, &wnd->framebuffer_rtv, 0); - d_ctx->OMSetDepthStencilState(r_d3d11_state->noop_depth_stencil, 0); - d_ctx->OMSetBlendState(r_d3d11_state->main_blend_state, 0, 0xffffffff); + d_ctx->lpVtbl->OMSetRenderTargets(d_ctx, 1, &wnd->framebuffer_rtv, 0); + d_ctx->lpVtbl->OMSetDepthStencilState(d_ctx, r_d3d11_state->noop_depth_stencil, 0); + d_ctx->lpVtbl->OMSetBlendState(d_ctx, r_d3d11_state->main_blend_state, 0, 0xffffffff); // rjf: set up rasterizer Vec2S32 resolution = wnd->last_resolution; D3D11_VIEWPORT viewport = { 0.0f, 0.0f, (F32)resolution.x, (F32)resolution.y, 0.0f, 1.0f }; - d_ctx->RSSetViewports(1, &viewport); - d_ctx->RSSetState(r_d3d11_state->main_rasterizer); + d_ctx->lpVtbl->RSSetViewports(d_ctx, 1, &viewport); + d_ctx->lpVtbl->RSSetState(d_ctx, (ID3D11RasterizerState *)r_d3d11_state->main_rasterizer); // rjf: setup input assembly - d_ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); - d_ctx->IASetInputLayout(0); + d_ctx->lpVtbl->IASetPrimitiveTopology(d_ctx, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); + d_ctx->lpVtbl->IASetInputLayout(d_ctx, 0); // rjf: setup shaders - d_ctx->VSSetShader(vshad, 0, 0); - d_ctx->PSSetShader(pshad, 0, 0); - d_ctx->PSSetShaderResources(0, 1, &wnd->stage_color_srv); - d_ctx->PSSetSamplers(0, 1, &sampler); + d_ctx->lpVtbl->VSSetShader(d_ctx, vshad, 0, 0); + d_ctx->lpVtbl->PSSetShader(d_ctx, pshad, 0, 0); + d_ctx->lpVtbl->PSSetShaderResources(d_ctx, 0, 1, &wnd->stage_color_srv); + d_ctx->lpVtbl->PSSetSamplers(d_ctx, 0, 1, &sampler); // rjf: setup scissor rect { @@ -999,17 +999,17 @@ r_window_end_frame(OS_Handle window, R_Handle window_equip) rect.right = (LONG)wnd->last_resolution.x; rect.top = 0; rect.bottom = (LONG)wnd->last_resolution.y; - d_ctx->RSSetScissorRects(1, &rect); + d_ctx->lpVtbl->RSSetScissorRects(d_ctx, 1, &rect); } // rjf: draw - d_ctx->Draw(4, 0); + d_ctx->lpVtbl->Draw(d_ctx, 4, 0); } //////////////////////////// //- rjf: present // - HRESULT error = wnd->swapchain->Present(1, 0); + HRESULT error = wnd->swapchain->lpVtbl->Present(wnd->swapchain, 1, 0); if(FAILED(error)) { char buffer[256] = {0}; @@ -1017,7 +1017,7 @@ r_window_end_frame(OS_Handle window, R_Handle window_equip) os_graphical_message(1, str8_lit("Fatal Error"), str8_cstring(buffer)); os_exit_process(1); } - d_ctx->ClearState(); + d_ctx->lpVtbl->ClearState(d_ctx); } ProfEnd(); } @@ -1058,8 +1058,8 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) //- rjf: set up rasterizer Vec2S32 resolution = wnd->last_resolution; D3D11_VIEWPORT viewport = { 0.0f, 0.0f, (F32)resolution.x, (F32)resolution.y, 0.0f, 1.0f }; - d_ctx->RSSetViewports(1, &viewport); - d_ctx->RSSetState(r_d3d11_state->main_rasterizer); + d_ctx->lpVtbl->RSSetViewports(d_ctx, 1, &viewport); + d_ctx->lpVtbl->RSSetState(d_ctx, (ID3D11RasterizerState *)r_d3d11_state->main_rasterizer); //- rjf: draw each batch group for(R_BatchGroup2DNode *group_n = rect_batch_groups->first; group_n != 0; group_n = group_n->next) @@ -1078,7 +1078,7 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) ID3D11Buffer *buffer = r_d3d11_instance_buffer_from_size(batches->byte_count); { D3D11_MAPPED_SUBRESOURCE sub_rsrc = {0}; - r_d3d11_state->device_ctx->Map(buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &sub_rsrc); + d_ctx->lpVtbl->Map(d_ctx, (ID3D11Resource *)buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &sub_rsrc); U8 *dst_ptr = (U8 *)sub_rsrc.pData; U64 off = 0; for(R_BatchNode *batch_n = batches->first; batch_n != 0; batch_n = batch_n->next) @@ -1086,7 +1086,7 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) MemoryCopy(dst_ptr+off, batch_n->v.v, batch_n->v.byte_count); off += batch_n->v.byte_count; } - r_d3d11_state->device_ctx->Unmap(buffer, 0); + d_ctx->lpVtbl->Unmap(d_ctx, (ID3D11Resource *)buffer, 0); } // rjf: get texture @@ -1132,30 +1132,30 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) } { D3D11_MAPPED_SUBRESOURCE sub_rsrc = {0}; - r_d3d11_state->device_ctx->Map(uniforms_buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &sub_rsrc); + d_ctx->lpVtbl->Map(d_ctx, (ID3D11Resource *)uniforms_buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &sub_rsrc); MemoryCopy((U8 *)sub_rsrc.pData, &uniforms, sizeof(uniforms)); - r_d3d11_state->device_ctx->Unmap(uniforms_buffer, 0); + d_ctx->lpVtbl->Unmap(d_ctx, (ID3D11Resource *)uniforms_buffer, 0); } // rjf: setup output merger - d_ctx->OMSetRenderTargets(1, &wnd->stage_color_rtv, 0); - d_ctx->OMSetDepthStencilState(r_d3d11_state->noop_depth_stencil, 0); - d_ctx->OMSetBlendState(r_d3d11_state->main_blend_state, 0, 0xffffffff); + d_ctx->lpVtbl->OMSetRenderTargets(d_ctx, 1, &wnd->stage_color_rtv, 0); + d_ctx->lpVtbl->OMSetDepthStencilState(d_ctx, r_d3d11_state->noop_depth_stencil, 0); + d_ctx->lpVtbl->OMSetBlendState(d_ctx, r_d3d11_state->main_blend_state, 0, 0xffffffff); // rjf: setup input assembly U32 stride = batches->bytes_per_inst; U32 offset = 0; - d_ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); - d_ctx->IASetInputLayout(ilay); - d_ctx->IASetVertexBuffers(0, 1, &buffer, &stride, &offset); + d_ctx->lpVtbl->IASetPrimitiveTopology(d_ctx, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); + d_ctx->lpVtbl->IASetInputLayout(d_ctx, ilay); + d_ctx->lpVtbl->IASetVertexBuffers(d_ctx, 0, 1, &buffer, &stride, &offset); // rjf: setup shaders - d_ctx->VSSetShader(vshad, 0, 0); - d_ctx->VSSetConstantBuffers(0, 1, &uniforms_buffer); - d_ctx->PSSetShader(pshad, 0, 0); - d_ctx->PSSetConstantBuffers(0, 1, &uniforms_buffer); - d_ctx->PSSetShaderResources(0, 1, &texture->view); - d_ctx->PSSetSamplers(0, 1, &sampler); + d_ctx->lpVtbl->VSSetShader(d_ctx, vshad, 0, 0); + d_ctx->lpVtbl->VSSetConstantBuffers(d_ctx, 0, 1, &uniforms_buffer); + d_ctx->lpVtbl->PSSetShader(d_ctx, pshad, 0, 0); + d_ctx->lpVtbl->PSSetConstantBuffers(d_ctx, 0, 1, &uniforms_buffer); + d_ctx->lpVtbl->PSSetShaderResources(d_ctx, 0, 1, &texture->view); + d_ctx->lpVtbl->PSSetSamplers(d_ctx, 0, 1, &sampler); // rjf: setup scissor rect { @@ -1184,11 +1184,11 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) rect.bottom = (LONG)clip.y1; } } - d_ctx->RSSetScissorRects(1, &rect); + d_ctx->lpVtbl->RSSetScissorRects(d_ctx, 1, &rect); } // rjf: draw - d_ctx->DrawInstanced(4, batches->byte_count / batches->bytes_per_inst, 0, 0); + d_ctx->lpVtbl->DrawInstanced(d_ctx, 4, batches->byte_count / batches->bytes_per_inst, 0, 0); } }break; @@ -1204,24 +1204,24 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) ID3D11Buffer *uniforms_buffer = r_d3d11_state->uniform_type_kind_buffers[R_D3D11_VShadKind_Blur]; // rjf: setup output merger - d_ctx->OMSetDepthStencilState(r_d3d11_state->noop_depth_stencil, 0); - d_ctx->OMSetBlendState(r_d3d11_state->no_blend_state, 0, 0xffffffff); + d_ctx->lpVtbl->OMSetDepthStencilState(d_ctx, r_d3d11_state->noop_depth_stencil, 0); + d_ctx->lpVtbl->OMSetBlendState(d_ctx, r_d3d11_state->no_blend_state, 0, 0xffffffff); // rjf: set up viewport Vec2S32 resolution = wnd->last_resolution; D3D11_VIEWPORT viewport = { 0.0f, 0.0f, (F32)resolution.x, (F32)resolution.y, 0.0f, 1.0f }; - d_ctx->RSSetViewports(1, &viewport); - d_ctx->RSSetState(r_d3d11_state->main_rasterizer); + d_ctx->lpVtbl->RSSetViewports(d_ctx, 1, &viewport); + d_ctx->lpVtbl->RSSetState(d_ctx, (ID3D11RasterizerState *)r_d3d11_state->main_rasterizer); // rjf: setup input assembly - d_ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); - d_ctx->IASetInputLayout(0); + d_ctx->lpVtbl->IASetPrimitiveTopology(d_ctx, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); + d_ctx->lpVtbl->IASetInputLayout(d_ctx, 0); // rjf: setup shaders - d_ctx->VSSetShader(vshad, 0, 0); - d_ctx->VSSetConstantBuffers(0, 1, &uniforms_buffer); - d_ctx->PSSetShader(pshad, 0, 0); - d_ctx->PSSetSamplers(0, 1, &sampler); + d_ctx->lpVtbl->VSSetShader(d_ctx, vshad, 0, 0); + d_ctx->lpVtbl->VSSetConstantBuffers(d_ctx, 0, 1, &uniforms_buffer); + d_ctx->lpVtbl->PSSetShader(d_ctx, pshad, 0, 0); + d_ctx->lpVtbl->PSSetSamplers(d_ctx, 0, 1, &sampler); // rjf: setup scissor rect { @@ -1230,7 +1230,7 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) rect.right = (LONG)wnd->last_resolution.x; rect.top = 0; rect.bottom = (LONG)wnd->last_resolution.y; - d_ctx->RSSetScissorRects(1, &rect); + d_ctx->lpVtbl->RSSetScissorRects(d_ctx, 1, &rect); } // rjf: set up uniforms @@ -1297,12 +1297,12 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) MemoryCopyArray(uniforms.passes[Axis2_Y].corner_radii.v, params->corner_radii); D3D11_MAPPED_SUBRESOURCE sub_rsrc = {0}; - r_d3d11_state->device_ctx->Map(uniforms_buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &sub_rsrc); + d_ctx->lpVtbl->Map(d_ctx, (ID3D11Resource *)uniforms_buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &sub_rsrc); MemoryCopy((U8 *)sub_rsrc.pData, &uniforms, sizeof(uniforms)); - r_d3d11_state->device_ctx->Unmap(uniforms_buffer, 0); + d_ctx->lpVtbl->Unmap(d_ctx, (ID3D11Resource *)uniforms_buffer, 0); } - ID3D11Buffer* uniforms_buffers[] = { uniforms_buffer, uniforms_buffer }; + ID3D11Buffer *uniforms_buffers[] = { uniforms_buffer, uniforms_buffer }; U32 uniform_offset[Axis2_COUNT][2] = { @@ -1320,18 +1320,18 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) ID3D11ShaderResourceView* srv = 0; // horizontal pass - d_ctx->OMSetRenderTargets(1, &wnd->stage_scratch_color_rtv, 0); - d_ctx->PSSetConstantBuffers1(0, ArrayCount(uniforms_buffers), uniforms_buffers, uniform_offset[Axis2_X], uniform_count[Axis2_X]); - d_ctx->PSSetShaderResources(0, 1, &wnd->stage_color_srv); - d_ctx->Draw(4, 0); - d_ctx->PSSetShaderResources(0, 1, &srv); + d_ctx->lpVtbl->OMSetRenderTargets(d_ctx, 1, &wnd->stage_scratch_color_rtv, 0); + d_ctx->lpVtbl->PSSetConstantBuffers1(d_ctx, 0, ArrayCount(uniforms_buffers), uniforms_buffers, uniform_offset[Axis2_X], uniform_count[Axis2_X]); + d_ctx->lpVtbl->PSSetShaderResources(d_ctx, 0, 1, &wnd->stage_color_srv); + d_ctx->lpVtbl->Draw(d_ctx, 4, 0); + d_ctx->lpVtbl->PSSetShaderResources(d_ctx, 0, 1, &srv); // vertical pass - d_ctx->OMSetRenderTargets(1, &wnd->stage_color_rtv, 0); - d_ctx->PSSetConstantBuffers1(0, ArrayCount(uniforms_buffers), uniforms_buffers, uniform_offset[Axis2_Y], uniform_count[Axis2_Y]); - d_ctx->PSSetShaderResources(0, 1, &wnd->stage_scratch_color_srv); - d_ctx->Draw(4, 0); - d_ctx->PSSetShaderResources(0, 1, &srv); + d_ctx->lpVtbl->OMSetRenderTargets(d_ctx, 1, &wnd->stage_color_rtv, 0); + d_ctx->lpVtbl->PSSetConstantBuffers1(d_ctx, 0, ArrayCount(uniforms_buffers), uniforms_buffers, uniform_offset[Axis2_Y], uniform_count[Axis2_Y]); + d_ctx->lpVtbl->PSSetShaderResources(d_ctx, 0, 1, &wnd->stage_scratch_color_srv); + d_ctx->lpVtbl->Draw(d_ctx, 4, 0); + d_ctx->lpVtbl->PSSetShaderResources(d_ctx, 0, 1, &srv); }break; @@ -1347,14 +1347,14 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) //- rjf: set up rasterizer Vec2F32 viewport_dim = dim_2f32(params->viewport); D3D11_VIEWPORT viewport = { params->viewport.x0, params->viewport.y0, viewport_dim.x, viewport_dim.y, 0.f, 1.f }; - d_ctx->RSSetViewports(1, &viewport); - d_ctx->RSSetState(r_d3d11_state->main_rasterizer); + d_ctx->lpVtbl->RSSetViewports(d_ctx, 1, &viewport); + d_ctx->lpVtbl->RSSetState(d_ctx, (ID3D11RasterizerState *)r_d3d11_state->main_rasterizer); //- rjf: clear render targets { Vec4F32 bg_color = v4f32(0, 0, 0, 0); - d_ctx->ClearRenderTargetView(wnd->geo3d_color_rtv, bg_color.v); - d_ctx->ClearDepthStencilView(wnd->geo3d_depth_dsv, D3D11_CLEAR_DEPTH, 1.f, 0); + d_ctx->lpVtbl->ClearRenderTargetView(d_ctx, wnd->geo3d_color_rtv, bg_color.v); + d_ctx->lpVtbl->ClearDepthStencilView(d_ctx, wnd->geo3d_depth_dsv, D3D11_CLEAR_DEPTH, 1.f, 0); } //- rjf: draw mesh batches @@ -1366,9 +1366,9 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) ID3D11Buffer *uniforms_buffer = r_d3d11_state->uniform_type_kind_buffers[R_D3D11_VShadKind_Mesh]; // rjf: setup output merger - d_ctx->OMSetRenderTargets(1, &wnd->geo3d_color_rtv, wnd->geo3d_depth_dsv); - d_ctx->OMSetDepthStencilState(r_d3d11_state->plain_depth_stencil, 0); - d_ctx->OMSetBlendState(r_d3d11_state->main_blend_state, 0, 0xffffffff); + d_ctx->lpVtbl->OMSetRenderTargets(d_ctx, 1, &wnd->geo3d_color_rtv, wnd->geo3d_depth_dsv); + d_ctx->lpVtbl->OMSetDepthStencilState(d_ctx, r_d3d11_state->plain_depth_stencil, 0); + d_ctx->lpVtbl->OMSetBlendState(d_ctx, r_d3d11_state->main_blend_state, 0, 0xffffffff); // rjf: draw all batches for(U64 slot_idx = 0; slot_idx < mesh_group_map->slots_count; slot_idx += 1) @@ -1384,10 +1384,10 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) // rjf: setup input assembly U32 stride = 11 * sizeof(F32); U32 offset = 0; - d_ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); - d_ctx->IASetInputLayout(ilay); - d_ctx->IASetVertexBuffers(0, 1, &mesh_vertices->buffer, &stride, &offset); - d_ctx->IASetIndexBuffer(mesh_indices->buffer, DXGI_FORMAT_R32_UINT, 0); + d_ctx->lpVtbl->IASetPrimitiveTopology(d_ctx, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + d_ctx->lpVtbl->IASetInputLayout(d_ctx, ilay); + d_ctx->lpVtbl->IASetVertexBuffers(d_ctx, 0, 1, &mesh_vertices->buffer, &stride, &offset); + d_ctx->lpVtbl->IASetIndexBuffer(d_ctx, mesh_indices->buffer, DXGI_FORMAT_R32_UINT, 0); // rjf: setup uniforms buffer R_D3D11_Uniforms_Mesh uniforms = {0}; @@ -1396,17 +1396,17 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) } { D3D11_MAPPED_SUBRESOURCE sub_rsrc = {0}; - r_d3d11_state->device_ctx->Map(uniforms_buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &sub_rsrc); + d_ctx->lpVtbl->Map(d_ctx, (ID3D11Resource *)uniforms_buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &sub_rsrc); MemoryCopy((U8 *)sub_rsrc.pData, &uniforms, sizeof(uniforms)); - r_d3d11_state->device_ctx->Unmap(uniforms_buffer, 0); + d_ctx->lpVtbl->Unmap(d_ctx, (ID3D11Resource *)uniforms_buffer, 0); } // rjf: setup shaders - d_ctx->VSSetShader(vshad, 0, 0); - d_ctx->VSSetConstantBuffers(0, 1, &uniforms_buffer); - d_ctx->PSSetShader(pshad, 0, 0); - d_ctx->PSSetConstantBuffers(0, 1, &uniforms_buffer); + d_ctx->lpVtbl->VSSetShader(d_ctx, vshad, 0, 0); + d_ctx->lpVtbl->VSSetConstantBuffers(d_ctx, 0, 1, &uniforms_buffer); + d_ctx->lpVtbl->PSSetShader(d_ctx, pshad, 0, 0); + d_ctx->lpVtbl->PSSetConstantBuffers(d_ctx, 0, 1, &uniforms_buffer); // rjf: setup scissor rect { @@ -1417,11 +1417,11 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) rect.top = 0; rect.bottom = (LONG)wnd->last_resolution.y; } - d_ctx->RSSetScissorRects(1, &rect); + d_ctx->lpVtbl->RSSetScissorRects(d_ctx, 1, &rect); } // rjf: draw - d_ctx->DrawIndexed(mesh_indices->size/sizeof(U32), 0, 0); + d_ctx->lpVtbl->DrawIndexed(d_ctx, mesh_indices->size/sizeof(U32), 0, 0); } } } @@ -1433,25 +1433,25 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) ID3D11PixelShader *pshad = r_d3d11_state->pshads[R_D3D11_PShadKind_Geo3DComposite]; // rjf: setup output merger - d_ctx->OMSetRenderTargets(1, &wnd->stage_color_rtv, 0); - d_ctx->OMSetDepthStencilState(r_d3d11_state->noop_depth_stencil, 0); - d_ctx->OMSetBlendState(r_d3d11_state->main_blend_state, 0, 0xffffffff); + d_ctx->lpVtbl->OMSetRenderTargets(d_ctx, 1, &wnd->stage_color_rtv, 0); + d_ctx->lpVtbl->OMSetDepthStencilState(d_ctx, r_d3d11_state->noop_depth_stencil, 0); + d_ctx->lpVtbl->OMSetBlendState(d_ctx, r_d3d11_state->main_blend_state, 0, 0xffffffff); // rjf: set up rasterizer Vec2S32 resolution = wnd->last_resolution; D3D11_VIEWPORT viewport = { 0.0f, 0.0f, (F32)resolution.x, (F32)resolution.y, 0.0f, 1.0f }; - d_ctx->RSSetViewports(1, &viewport); - d_ctx->RSSetState(r_d3d11_state->main_rasterizer); + d_ctx->lpVtbl->RSSetViewports(d_ctx, 1, &viewport); + d_ctx->lpVtbl->RSSetState(d_ctx, (ID3D11RasterizerState *)r_d3d11_state->main_rasterizer); // rjf: setup input assembly - d_ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); - d_ctx->IASetInputLayout(0); + d_ctx->lpVtbl->IASetPrimitiveTopology(d_ctx, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); + d_ctx->lpVtbl->IASetInputLayout(d_ctx, 0); // rjf: setup shaders - d_ctx->VSSetShader(vshad, 0, 0); - d_ctx->PSSetShader(pshad, 0, 0); - d_ctx->PSSetShaderResources(0, 1, &wnd->geo3d_color_srv); - d_ctx->PSSetSamplers(0, 1, &sampler); + d_ctx->lpVtbl->VSSetShader(d_ctx, vshad, 0, 0); + d_ctx->lpVtbl->PSSetShader(d_ctx, pshad, 0, 0); + d_ctx->lpVtbl->PSSetShaderResources(d_ctx, 0, 1, &wnd->geo3d_color_srv); + d_ctx->lpVtbl->PSSetSamplers(d_ctx, 0, 1, &sampler); // rjf: setup scissor rect { @@ -1478,11 +1478,11 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) rect.top = (LONG)clip.y0; rect.bottom = (LONG)clip.y1; } - d_ctx->RSSetScissorRects(1, &rect); + d_ctx->lpVtbl->RSSetScissorRects(d_ctx, 1, &rect); } // rjf: draw - d_ctx->Draw(4, 0); + d_ctx->lpVtbl->Draw(d_ctx, 4, 0); } }break; } diff --git a/src/render/d3d11/render_d3d11.h b/src/render/d3d11/render_d3d11.h index 47d14d93..8fd89503 100644 --- a/src/render/d3d11/render_d3d11.h +++ b/src/render/d3d11/render_d3d11.h @@ -20,6 +20,7 @@ //////////////////////////////// //~ rjf: C-side Shader Types +typedef struct R_D3D11_Uniforms_Rect R_D3D11_Uniforms_Rect; struct R_D3D11_Uniforms_Rect { Vec2F32 viewport_size; @@ -32,6 +33,7 @@ struct R_D3D11_Uniforms_Rect Vec2F32 xform_scale; }; +typedef struct R_D3D11_Uniforms_BlurPass R_D3D11_Uniforms_BlurPass; struct R_D3D11_Uniforms_BlurPass { Rng2F32 rect; @@ -43,12 +45,14 @@ struct R_D3D11_Uniforms_BlurPass }; StaticAssert(sizeof(R_D3D11_Uniforms_BlurPass) % 256 == 0, NotAligned); // constant count/offset must be aligned to 256 bytes +typedef struct R_D3D11_Uniforms_Blur R_D3D11_Uniforms_Blur; struct R_D3D11_Uniforms_Blur { R_D3D11_Uniforms_BlurPass passes[Axis2_COUNT]; Vec4F32 kernel[32]; }; +typedef struct R_D3D11_Uniforms_Mesh R_D3D11_Uniforms_Mesh; struct R_D3D11_Uniforms_Mesh { Mat4x4F32 xform; @@ -57,6 +61,7 @@ struct R_D3D11_Uniforms_Mesh //////////////////////////////// //~ rjf: Main State Types +typedef struct R_D3D11_Tex2D R_D3D11_Tex2D; struct R_D3D11_Tex2D { R_D3D11_Tex2D *next; @@ -68,6 +73,7 @@ struct R_D3D11_Tex2D R_Tex2DFormat format; }; +typedef struct R_D3D11_Buffer R_D3D11_Buffer; struct R_D3D11_Buffer { R_D3D11_Buffer *next; @@ -77,6 +83,7 @@ struct R_D3D11_Buffer U64 size; }; +typedef struct R_D3D11_Window R_D3D11_Window; struct R_D3D11_Window { R_D3D11_Window *next; @@ -107,12 +114,14 @@ struct R_D3D11_Window Vec2S32 last_resolution; }; +typedef struct R_D3D11_FlushBuffer R_D3D11_FlushBuffer; struct R_D3D11_FlushBuffer { R_D3D11_FlushBuffer *next; ID3D11Buffer *buffer; }; +typedef struct R_D3D11_State R_D3D11_State; struct R_D3D11_State { // rjf: state diff --git a/src/render/d3d11/render_d3d11.mdesk b/src/render/d3d11/render_d3d11.mdesk index ac7d953c..133e6b3b 100644 --- a/src/render/d3d11/render_d3d11.mdesk +++ b/src/render/d3d11/render_d3d11.mdesk @@ -480,10 +480,10 @@ ps_main(Vertex2Pixel v2p) : SV_TARGET COUNT, } -@c_file @data(String8) +@c_file @data(`String8*`) r_d3d11_g_vshad_kind_source_table: { - @expand(R_D3D11_VShadTable a) `$(a.source)`; + @expand(R_D3D11_VShadTable a) `&$(a.source)`; } @c_file @data(String8) @@ -504,10 +504,10 @@ r_d3d11_g_vshad_kind_elements_count_table: @expand(R_D3D11_VShadTable a) `$(a.ilay_table != 0 -> "ArrayCount("..a.ilay_table..")") $(a.ilay_table == 0 -> "0")`; } -@c_file @data(String8) +@c_file @data(`String8*`) r_d3d11_g_pshad_kind_source_table: { - @expand(R_D3D11_PShadTable a) `$(a.source)`; + @expand(R_D3D11_PShadTable a) `&$(a.source)`; } @c_file @data(String8) diff --git a/src/render/d3d11/render_d3d11_main.cpp b/src/render/d3d11/render_d3d11_main.cpp deleted file mode 100644 index 1a9e6b0d..00000000 --- a/src/render/d3d11/render_d3d11_main.cpp +++ /dev/null @@ -1,16 +0,0 @@ -// Copyright (c) 2024 Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -#define BUILD_SUPPLEMENTARY_UNIT 1 -#define OS_FEATURE_GRAPHICAL 1 - -#include "base/base_inc.h" -#include "os/os_inc.h" -#include "render/render_core.h" - -#include "render_d3d11.h" -#include "render_d3d11.cpp" - -#include "base/base_inc.c" -#include "os/os_inc.c" -#include "render/render_core.c" diff --git a/src/render/render_inc.c b/src/render/render_inc.c index aa928881..f85761b5 100644 --- a/src/render/render_inc.c +++ b/src/render/render_inc.c @@ -3,12 +3,10 @@ #include "render_core.c" -#if LANG_CPP -# if R_BACKEND == R_BACKEND_STUB -# include "stub/render_stub.c" -# elif R_BACKEND == R_BACKEND_D3D11 -# include "d3d11/render_d3d11.cpp" -# else -# error Renderer backend not specified. -# endif +#if R_BACKEND == R_BACKEND_STUB +# include "stub/render_stub.c" +#elif R_BACKEND == R_BACKEND_D3D11 +# include "d3d11/render_d3d11.c" +#else +# error Renderer backend not specified. #endif diff --git a/src/render/render_inc.h b/src/render/render_inc.h index a91ae834..95ab1a2f 100644 --- a/src/render/render_inc.h +++ b/src/render/render_inc.h @@ -25,14 +25,12 @@ //////////////////////////////// //~ rjf: Backend Includes -#if LANG_CPP -# if R_BACKEND == R_BACKEND_STUB -# include "stub/render_stub.h" -# elif R_BACKEND == R_BACKEND_D3D11 -# include "d3d11/render_d3d11.h" -# else -# error Renderer backend not specified. -# endif +#if R_BACKEND == R_BACKEND_STUB +# include "stub/render_stub.h" +#elif R_BACKEND == R_BACKEND_D3D11 +# include "d3d11/render_d3d11.h" +#else +# error Renderer backend not specified. #endif #endif // RENDER_INC_H