From f50b54cff7e24ed7bf565ebb00f75b33ef5b68f2 Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Fri, 31 May 2024 17:16:54 -0700 Subject: [PATCH] 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 07717234..4ddcd837 100644 --- a/src/df/gfx/df_views.c +++ b/src/df/gfx/df_views.c @@ -3273,7 +3273,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); } } @@ -4936,7 +4936,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 92416fec..bbfeca81 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