diff --git a/src/dbg_engine/dbg_engine.mdesk b/src/dbg_engine/dbg_engine.mdesk index 1e8491d0..496cf811 100644 --- a/src/dbg_engine/dbg_engine.mdesk +++ b/src/dbg_engine/dbg_engine.mdesk @@ -115,13 +115,13 @@ D_EntityKindTable: COUNT, } -@data(String8) ctrl_entity_kind_code_name_table: +@data(String8) d_entity_kind_code_name_table: { `{0}`, @expand(D_EntityKindTable a) `str8_lit_comp("$(a.code_name)")` } -@data(String8) ctrl_entity_kind_display_string_table: +@data(String8) d_entity_kind_display_string_table: { `{0}`, @expand(D_EntityKindTable a) `str8_lit_comp("$(a.display_name)")` @@ -179,25 +179,25 @@ D_ExceptionCodeKindTable: COUNT, } -@data(U32) ctrl_exception_code_kind_code_table: +@data(U32) d_exception_code_kind_code_table: { `0`; @expand(D_ExceptionCodeKindTable a) `$(a.code)`; } -@data(String8) ctrl_exception_code_kind_display_string_table: +@data(String8) d_exception_code_kind_display_string_table: { `{0}`; @expand(D_ExceptionCodeKindTable a) `str8_lit_comp("$(a.display_string)")`; } -@data(String8) ctrl_exception_code_kind_lowercase_code_string_table: +@data(String8) d_exception_code_kind_lowercase_code_string_table: { `{0}`; @expand(D_ExceptionCodeKindTable a) `str8_lit_comp("$(a.lower_name)")`; } -@data(B8) ctrl_exception_code_kind_default_enable_table: +@data(B8) d_exception_code_kind_default_enable_table: { `0`; @expand(D_ExceptionCodeKindTable a) `$(a.default)`; diff --git a/src/dbg_engine/dbg_engine_core.c b/src/dbg_engine/dbg_engine_core.c index fd61937d..b80b61a7 100644 --- a/src/dbg_engine/dbg_engine_core.c +++ b/src/dbg_engine/dbg_engine_core.c @@ -71,7 +71,7 @@ d_init(void) scratch_end(scratch); } d_ctrl_state->ctrl_thread_entity_ctx_rw_mutex = rw_mutex_alloc(); - d_ctrl_state->ctrl_thread_entity_store = ctrl_entity_ctx_rw_store_alloc(); + d_ctrl_state->ctrl_thread_entity_store = d_entity_ctx_rw_store_alloc(); d_ctrl_state->ctrl_thread_eval_cache = e_cache_alloc(); d_ctrl_state->ctrl_thread_msg_process_arena = arena_alloc(); d_ctrl_state->dmn_event_arena = arena_alloc(); @@ -79,13 +79,13 @@ d_init(void) d_ctrl_state->dbg_dir_arena = arena_alloc(); for(D_ExceptionCodeKind k = (D_ExceptionCodeKind)0; k < D_ExceptionCodeKind_COUNT; k = (D_ExceptionCodeKind)(k+1)) { - if(ctrl_exception_code_kind_default_enable_table[k]) + if(d_exception_code_kind_default_enable_table[k]) { d_ctrl_state->exception_code_filters[k/64] |= 1ull<<(k%64); } } d_ctrl_state->ctrl_thread_log = log_alloc(); - d_ctrl_state->ctrl_thread = thread_launch(ctrl_thread__entry_point, 0); + d_ctrl_state->ctrl_thread = thread_launch(d_ctrl_thread__entry_point, 0); } //- rjf: set up user state @@ -96,7 +96,7 @@ d_init(void) d_user_state->cmds_arena = arena_alloc(); d_user_state->output_log_key = c_key_make(c_root_alloc(), c_id_make(0, 0)); c_submit_data(d_user_state->output_log_key, 0, str8_zero()); - d_user_state->ctrl_entity_store = ctrl_entity_ctx_rw_store_alloc(); + d_user_state->ctrl_entity_store = d_entity_ctx_rw_store_alloc(); d_user_state->ctrl_stop_arena = arena_alloc(); d_user_state->ctrl_msg_arena = arena_alloc(); diff --git a/src/dbg_engine/dbg_engine_core.h b/src/dbg_engine/dbg_engine_core.h index c6f6ba71..68b68b92 100644 --- a/src/dbg_engine/dbg_engine_core.h +++ b/src/dbg_engine/dbg_engine_core.h @@ -179,14 +179,14 @@ struct D_EntityHashSlot D_EntityHashNode *last; }; -typedef struct CTRL_EntityStringChunkNode CTRL_EntityStringChunkNode; -struct CTRL_EntityStringChunkNode +typedef struct D_EntityStringChunkNode D_EntityStringChunkNode; +struct D_EntityStringChunkNode { - CTRL_EntityStringChunkNode *next; + D_EntityStringChunkNode *next; U64 size; }; -read_only global U64 ctrl_entity_string_bucket_chunk_sizes[] = +read_only global U64 d_entity_string_bucket_chunk_sizes[] = { 16, 64, @@ -215,7 +215,7 @@ struct D_EntityCtxRWStore D_EntityCtx ctx; D_Entity *free; D_EntityHashNode *hash_node_free; - CTRL_EntityStringChunkNode *free_string_chunks[ArrayCount(ctrl_entity_string_bucket_chunk_sizes)]; + D_EntityStringChunkNode *free_string_chunks[ArrayCount(d_entity_string_bucket_chunk_sizes)]; }; typedef struct D_EntityCtxLookupAccel D_EntityCtxLookupAccel; diff --git a/src/dbg_engine/dbg_engine_ctrl.c b/src/dbg_engine/dbg_engine_ctrl.c index ea9233d4..ef4fbd74 100644 --- a/src/dbg_engine/dbg_engine_ctrl.c +++ b/src/dbg_engine/dbg_engine_ctrl.c @@ -4,29 +4,16 @@ //////////////////////////////// //~ rjf: Basic Type Functions -#if !defined(XXH_IMPLEMENTATION) -# define XXH_IMPLEMENTATION -# define XXH_STATIC_LINKING_ONLY -# include "third_party/xxHash/xxhash.h" -#endif - internal U64 -ctrl_hash_from_string(String8 string) -{ - U64 result = XXH3_64bits_withSeed(string.str, string.size, 5381); - return result; -} - -internal U64 -ctrl_hash_from_handle(D_Handle handle) +d_hash_from_handle(D_Handle handle) { U64 buf[] = {handle.machine_id, handle.dmn_handle.u64[0]}; - U64 hash = ctrl_hash_from_string(str8((U8 *)buf, sizeof(buf))); + U64 hash = u64_hash_from_str8(str8((U8 *)buf, sizeof(buf))); return hash; } internal D_EventCause -ctrl_event_cause_from_dmn_event_kind(DMN_EventKind event_kind) +d_event_cause_from_dmn_event_kind(DMN_EventKind event_kind) { D_EventCause cause = D_EventCause_Null; switch(event_kind) @@ -41,7 +28,7 @@ ctrl_event_cause_from_dmn_event_kind(DMN_EventKind event_kind) } internal D_ExceptionKind -ctrl_exception_kind_from_dmn(DMN_ExceptionKind kind) +d_exception_kind_from_dmn(DMN_ExceptionKind kind) { D_ExceptionKind result = D_ExceptionKind_Null; switch(kind) @@ -56,7 +43,7 @@ ctrl_exception_kind_from_dmn(DMN_ExceptionKind kind) } internal D_TlsModel -ctrl_dynamic_linker_type_from_dmn(DMN_TlsModel type) +d_dynamic_linker_type_from_dmn(DMN_TlsModel type) { D_TlsModel result = D_TlsModel_Null; switch(type) @@ -70,7 +57,7 @@ ctrl_dynamic_linker_type_from_dmn(DMN_TlsModel type) } internal String8 -ctrl_string_from_event_kind(D_EventKind kind) +d_string_from_event_kind(D_EventKind kind) { String8 result = {0}; switch(kind) @@ -98,7 +85,7 @@ ctrl_string_from_event_kind(D_EventKind kind) } internal String8 -ctrl_string_from_msg_kind(D_MsgKind kind) +d_string_from_msg_kind(D_MsgKind kind) { String8 result = {0}; switch(kind) @@ -118,12 +105,12 @@ ctrl_string_from_msg_kind(D_MsgKind kind) } internal D_EntityKind -ctrl_entity_kind_from_string(String8 string) +d_entity_kind_from_string(String8 string) { D_EntityKind result = D_EntityKind_Null; for EachNonZeroEnumVal(D_EntityKind, k) { - if(str8_match(ctrl_entity_kind_code_name_table[k], string, 0)) + if(str8_match(d_entity_kind_code_name_table[k], string, 0)) { result = k; break; @@ -133,7 +120,7 @@ ctrl_entity_kind_from_string(String8 string) } internal DMN_TrapFlags -ctrl_dmn_trap_flags_from_user_breakpoint_flags(D_BreakpointFlags flags) +d_dmn_trap_flags_from_breakpoint_flags(D_BreakpointFlags flags) { DMN_TrapFlags result = 0; if(flags & D_BreakpointFlag_BreakOnWrite) { result |= DMN_TrapFlag_BreakOnWrite; } @@ -143,7 +130,7 @@ ctrl_dmn_trap_flags_from_user_breakpoint_flags(D_BreakpointFlags flags) } internal D_BreakpointFlags -ctrl_user_breakpoint_flags_from_dmn_trap_flags(DMN_TrapFlags flags) +d_breakpoint_flags_from_dmn_trap_flags(DMN_TrapFlags flags) { D_BreakpointFlags result = 0; if(flags & DMN_TrapFlag_BreakOnWrite) { result |= D_BreakpointFlag_BreakOnWrite; } @@ -156,21 +143,21 @@ ctrl_user_breakpoint_flags_from_dmn_trap_flags(DMN_TrapFlags flags) //~ rjf: Machine/Handle Pair Type Functions internal D_Handle -ctrl_handle_zero(void) +d_handle_zero(void) { D_Handle handle = {0}; return handle; } internal D_Handle -ctrl_handle_make(D_MachineID machine_id, DMN_Handle dmn_handle) +d_handle_make(D_MachineID machine_id, DMN_Handle dmn_handle) { D_Handle handle = {machine_id, dmn_handle}; return handle; } internal B32 -ctrl_handle_match(D_Handle a, D_Handle b) +d_handle_match(D_Handle a, D_Handle b) { B32 result = (a.machine_id == b.machine_id && dmn_handle_match(a.dmn_handle, b.dmn_handle)); @@ -178,7 +165,7 @@ ctrl_handle_match(D_Handle a, D_Handle b) } internal void -ctrl_handle_list_push(Arena *arena, D_HandleList *list, D_Handle *pair) +d_handle_list_push(Arena *arena, D_HandleList *list, D_Handle *pair) { D_HandleNode *n = push_array(arena, D_HandleNode, 1); MemoryCopyStruct(&n->v, pair); @@ -187,18 +174,18 @@ ctrl_handle_list_push(Arena *arena, D_HandleList *list, D_Handle *pair) } internal D_HandleList -ctrl_handle_list_copy(Arena *arena, D_HandleList *src) +d_handle_list_copy(Arena *arena, D_HandleList *src) { D_HandleList dst = {0}; for(D_HandleNode *n = src->first; n != 0; n = n->next) { - ctrl_handle_list_push(arena, &dst, &n->v); + d_handle_list_push(arena, &dst, &n->v); } return dst; } internal D_HandleArray -ctrl_handle_array_from_list(Arena *arena, D_HandleList *src) +d_handle_array_from_list(Arena *arena, D_HandleList *src) { D_HandleArray array = {0}; array.count = src->count; @@ -214,14 +201,14 @@ ctrl_handle_array_from_list(Arena *arena, D_HandleList *src) } internal String8 -ctrl_string_from_handle(Arena *arena, D_Handle handle) +d_string_from_handle(Arena *arena, D_Handle handle) { String8 result = push_str8f(arena, "$%I64x$%I64x", handle.machine_id, handle.dmn_handle.u64[0]); return result; } internal D_Handle -ctrl_handle_from_string(String8 string) +d_handle_from_string(String8 string) { D_Handle handle = {0}; { @@ -245,7 +232,7 @@ ctrl_handle_from_string(String8 string) //~ rjf: Trap Type Functions internal void -ctrl_trap_list_push(Arena *arena, D_TrapList *list, D_Trap *trap) +d_trap_list_push(Arena *arena, D_TrapList *list, D_Trap *trap) { D_TrapNode *node = push_array(arena, D_TrapNode, 1); MemoryCopyStruct(&node->v, trap); @@ -254,12 +241,12 @@ ctrl_trap_list_push(Arena *arena, D_TrapList *list, D_Trap *trap) } internal D_TrapList -ctrl_trap_list_copy(Arena *arena, D_TrapList *src) +d_trap_list_copy(Arena *arena, D_TrapList *src) { D_TrapList dst = {0}; for(D_TrapNode *src_n = src->first; src_n != 0; src_n = src_n->next) { - ctrl_trap_list_push(arena, &dst, &src_n->v); + d_trap_list_push(arena, &dst, &src_n->v); } return dst; } @@ -268,7 +255,7 @@ ctrl_trap_list_copy(Arena *arena, D_TrapList *src) //~ rjf: User Breakpoint Type Functions internal void -ctrl_user_breakpoint_list_push(Arena *arena, D_BreakpointList *list, D_Breakpoint *bp) +d_breakpoint_list_push(Arena *arena, D_BreakpointList *list, D_Breakpoint *bp) { D_BreakpointNode *n = push_array(arena, D_BreakpointNode, 1); MemoryCopyStruct(&n->v, bp); @@ -277,7 +264,7 @@ ctrl_user_breakpoint_list_push(Arena *arena, D_BreakpointList *list, D_Breakpoin } internal D_BreakpointList -ctrl_user_breakpoint_list_copy(Arena *arena, D_BreakpointList *src) +d_breakpoint_list_copy(Arena *arena, D_BreakpointList *src) { D_BreakpointList dst = {0}; for(D_BreakpointNode *src_n = src->first; src_n != 0; src_n = src_n->next) @@ -287,7 +274,7 @@ ctrl_user_breakpoint_list_copy(Arena *arena, D_BreakpointList *src) dst_bp.file_path = str8_copy(arena, src_n->v.file_path); dst_bp.vaddr_expr = str8_copy(arena, src_n->v.vaddr_expr); dst_bp.condition = str8_copy(arena, src_n->v.condition); - ctrl_user_breakpoint_list_push(arena, &dst, &dst_bp); + d_breakpoint_list_push(arena, &dst, &dst_bp); } return dst; } @@ -298,21 +285,21 @@ ctrl_user_breakpoint_list_copy(Arena *arena, D_BreakpointList *src) //- rjf: deep copying internal void -ctrl_msg_deep_copy(Arena *arena, D_Msg *dst, D_Msg *src) +d_msg_deep_copy(Arena *arena, D_Msg *dst, D_Msg *src) { MemoryCopyStruct(dst, src); dst->path = push_str8_copy(arena, src->path); dst->entry_points = str8_list_copy(arena, &src->entry_points); dst->cmd_line_string_list = str8_list_copy(arena, &src->cmd_line_string_list); dst->env_string_list = str8_list_copy(arena, &src->env_string_list); - dst->traps = ctrl_trap_list_copy(arena, &src->traps); - dst->user_bps = ctrl_user_breakpoint_list_copy(arena, &src->user_bps); + dst->traps = d_trap_list_copy(arena, &src->traps); + dst->user_bps = d_breakpoint_list_copy(arena, &src->user_bps); } //- rjf: list building internal D_Msg * -ctrl_msg_list_push(Arena *arena, D_MsgList *list) +d_msg_list_push(Arena *arena, D_MsgList *list) { D_MsgNode *n = push_array(arena, D_MsgNode, 1); SLLQueuePush(list->first, list->last, n); @@ -322,20 +309,20 @@ ctrl_msg_list_push(Arena *arena, D_MsgList *list) } internal D_MsgList -ctrl_msg_list_deep_copy(Arena *arena, D_MsgList *src) +d_msg_list_deep_copy(Arena *arena, D_MsgList *src) { D_MsgList dst = {0}; for(D_MsgNode *n = src->first; n != 0; n = n->next) { D_Msg *src_msg = &n->v; - D_Msg *dst_msg = ctrl_msg_list_push(arena, &dst); - ctrl_msg_deep_copy(arena, dst_msg, src_msg); + D_Msg *dst_msg = d_msg_list_push(arena, &dst); + d_msg_deep_copy(arena, dst_msg, src_msg); } return dst; } internal void -ctrl_msg_list_concat_in_place(D_MsgList *dst, D_MsgList *src) +d_msg_list_concat_in_place(D_MsgList *dst, D_MsgList *src) { if(dst->last && src->first) { @@ -353,7 +340,7 @@ ctrl_msg_list_concat_in_place(D_MsgList *dst, D_MsgList *src) //- rjf: serialization internal String8 -ctrl_serialized_string_from_msg_list(Arena *arena, D_MsgList *msgs) +d_serialized_string_from_msg_list(Arena *arena, D_MsgList *msgs) { Temp scratch = scratch_begin(&arena, 1); String8List msgs_srlzed = {0}; @@ -448,7 +435,7 @@ ctrl_serialized_string_from_msg_list(Arena *arena, D_MsgList *msgs) } internal D_MsgList -ctrl_msg_list_from_serialized_string(Arena *arena, String8 string) +d_msg_list_from_serialized_string(Arena *arena, String8 string) { D_MsgList msgs = {0}; { @@ -578,7 +565,7 @@ ctrl_msg_list_from_serialized_string(Arena *arena, String8 string) //- rjf: list building internal D_Event * -ctrl_event_list_push(Arena *arena, D_EventList *list) +d_event_list_push(Arena *arena, D_EventList *list) { D_EventNode *n = push_array(arena, D_EventNode, 1); SLLQueuePush(list->first, list->last, n); @@ -588,7 +575,7 @@ ctrl_event_list_push(Arena *arena, D_EventList *list) } internal void -ctrl_event_list_concat_in_place(D_EventList *dst, D_EventList *to_push) +d_event_list_concat_in_place(D_EventList *dst, D_EventList *to_push) { if(dst->last == 0) { @@ -606,7 +593,7 @@ ctrl_event_list_concat_in_place(D_EventList *dst, D_EventList *to_push) //- rjf: serialization internal String8 -ctrl_serialized_string_from_event(Arena *arena, D_Event *event, U64 max) +d_serialized_string_from_event(Arena *arena, D_Event *event, U64 max) { Temp scratch = scratch_begin(&arena, 1); String8List srl = {0}; @@ -644,7 +631,7 @@ ctrl_serialized_string_from_event(Arena *arena, D_Event *event, U64 max) } internal D_Event -ctrl_event_from_serialized_string(Arena *arena, String8 string) +d_event_from_serialized_string(Arena *arena, String8 string) { D_Event event = zero_struct; { @@ -683,7 +670,7 @@ ctrl_event_from_serialized_string(Arena *arena, String8 string) //- rjf: entity list data structures internal void -ctrl_entity_list_push(Arena *arena, D_EntityList *list, D_Entity *entity) +d_entity_list_push(Arena *arena, D_EntityList *list, D_Entity *entity) { D_EntityNode *n = push_array(arena, D_EntityNode, 1); n->v = entity; @@ -692,13 +679,13 @@ ctrl_entity_list_push(Arena *arena, D_EntityList *list, D_Entity *entity) } internal D_EntityList -ctrl_entity_list_from_handle_list(Arena *arena, D_EntityCtx *ctx, D_HandleList *list) +d_entity_list_from_handle_list(Arena *arena, D_EntityCtx *ctx, D_HandleList *list) { D_EntityList result = {0}; for(D_HandleNode *n = list->first; n != 0; n = n->next) { - D_Entity *entity = ctrl_entity_from_handle(ctx, n->v); - ctrl_entity_list_push(arena, &result, entity); + D_Entity *entity = d_entity_from_handle(ctx, n->v); + d_entity_list_push(arena, &result, entity); } return result; } @@ -706,7 +693,7 @@ ctrl_entity_list_from_handle_list(Arena *arena, D_EntityCtx *ctx, D_HandleList * //- rjf: entity array data structure internal D_EntityArray -ctrl_entity_array_from_list(Arena *arena, D_EntityList *list) +d_entity_array_from_list(Arena *arena, D_EntityList *list) { D_EntityArray result = {0}; result.count = list->count; @@ -722,18 +709,18 @@ ctrl_entity_array_from_list(Arena *arena, D_EntityList *list) //- rjf: entity context (entity group read-only) functions internal D_Entity * -ctrl_entity_from_handle(D_EntityCtx *ctx, D_Handle handle) +d_entity_from_handle(D_EntityCtx *ctx, D_Handle handle) { D_Entity *entity = &d_entity_nil; - if(!ctrl_handle_match(handle, ctrl_handle_zero())) + if(!d_handle_match(handle, d_handle_zero())) { - U64 hash = ctrl_hash_from_handle(handle); + U64 hash = d_hash_from_handle(handle); U64 slot_idx = hash%ctx->hash_slots_count; D_EntityHashSlot *slot = &ctx->hash_slots[slot_idx]; D_EntityHashNode *node = 0; for(D_EntityHashNode *n = slot->first; n != 0; n = n->next) { - if(ctrl_handle_match(n->entity->handle, handle)) + if(d_handle_match(n->entity->handle, handle)) { entity = n->entity; break; @@ -744,7 +731,7 @@ ctrl_entity_from_handle(D_EntityCtx *ctx, D_Handle handle) } internal D_Entity * -ctrl_entity_child_from_kind(D_Entity *parent, D_EntityKind kind) +d_entity_child_from_kind(D_Entity *parent, D_EntityKind kind) { D_Entity *result = &d_entity_nil; for(D_Entity *child = parent->first; @@ -761,7 +748,7 @@ ctrl_entity_child_from_kind(D_Entity *parent, D_EntityKind kind) } internal D_Entity * -ctrl_entity_ancestor_from_kind(D_Entity *entity, D_EntityKind kind) +d_entity_ancestor_from_kind(D_Entity *entity, D_EntityKind kind) { D_Entity *result = &d_entity_nil; for(D_Entity *p = entity->parent; p != &d_entity_nil; p = p->parent) @@ -776,7 +763,7 @@ ctrl_entity_ancestor_from_kind(D_Entity *entity, D_EntityKind kind) } internal D_Entity * -ctrl_process_from_entity(D_Entity *entity) +d_process_from_entity(D_Entity *entity) { D_Entity *result = &d_entity_nil; if(entity->kind == D_EntityKind_Process) @@ -785,13 +772,13 @@ ctrl_process_from_entity(D_Entity *entity) } else { - result = ctrl_entity_ancestor_from_kind(entity, D_EntityKind_Process); + result = d_entity_ancestor_from_kind(entity, D_EntityKind_Process); } return result; } internal D_Entity * -ctrl_module_from_process_vaddr(D_Entity *process, U64 vaddr) +d_module_from_process_vaddr(D_Entity *process, U64 vaddr) { D_Entity *result = &d_entity_nil; for(D_Entity *child = process->first; @@ -808,24 +795,24 @@ ctrl_module_from_process_vaddr(D_Entity *process, U64 vaddr) } internal DI_Key -ctrl_dbgi_key_from_module(D_Entity *module) +d_dbgi_key_from_module(D_Entity *module) { - D_Entity *debug_info_path = ctrl_entity_child_from_kind(module, D_EntityKind_DebugInfoPath); + D_Entity *debug_info_path = d_entity_child_from_kind(module, D_EntityKind_DebugInfoPath); DI_Key dbgi_key = di_key_from_path_timestamp(debug_info_path->string, debug_info_path->timestamp); return dbgi_key; } internal D_Entity * -ctrl_module_from_thread_candidates(D_EntityCtx *ctx, D_Entity *thread, D_EntityList *candidates) +d_module_from_thread_candidates(D_EntityCtx *ctx, D_Entity *thread, D_EntityList *candidates) { - D_Entity *process = ctrl_entity_ancestor_from_kind(thread, D_EntityKind_Process); - U64 thread_rip_vaddr = ctrl_rip_from_thread(ctx, thread->handle); - D_Entity *src_module = ctrl_module_from_process_vaddr(process, thread_rip_vaddr); + D_Entity *process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process); + U64 thread_rip_vaddr = d_rip_from_thread(ctx, thread->handle); + D_Entity *src_module = d_module_from_process_vaddr(process, thread_rip_vaddr); D_Entity *module = &d_entity_nil; for(D_EntityNode *n = candidates->first; n != 0; n = n->next) { D_Entity *candidate_module = n->v; - D_Entity *candidate_process = ctrl_entity_ancestor_from_kind(candidate_module, D_EntityKind_Process); + D_Entity *candidate_process = d_entity_ancestor_from_kind(candidate_module, D_EntityKind_Process); if(candidate_process == process) { module = candidate_module; @@ -839,42 +826,42 @@ ctrl_module_from_thread_candidates(D_EntityCtx *ctx, D_Entity *thread, D_EntityL } internal U64 -ctrl_vaddr_from_voff(D_Entity *module, U64 voff) +d_vaddr_from_voff(D_Entity *module, U64 voff) { U64 result = voff + module->vaddr_range.min; return result; } internal U64 -ctrl_voff_from_vaddr(D_Entity *module, U64 vaddr) +d_voff_from_vaddr(D_Entity *module, U64 vaddr) { U64 result = vaddr - module->vaddr_range.min; return result; } internal Rng1U64 -ctrl_vaddr_range_from_voff_range(D_Entity *module, Rng1U64 voff_range) +d_vaddr_range_from_voff_range(D_Entity *module, Rng1U64 voff_range) { U64 dim = dim_1u64(voff_range); - U64 min = ctrl_vaddr_from_voff(module, voff_range.min); + U64 min = d_vaddr_from_voff(module, voff_range.min); Rng1U64 result = {min, min+dim}; return result; } internal Rng1U64 -ctrl_voff_range_from_vaddr_range(D_Entity *module, Rng1U64 vaddr_range) +d_voff_range_from_vaddr_range(D_Entity *module, Rng1U64 vaddr_range) { U64 dim = dim_1u64(vaddr_range); - U64 min = ctrl_voff_from_vaddr(module, vaddr_range.min); + U64 min = d_voff_from_vaddr(module, vaddr_range.min); Rng1U64 result = {min, min+dim}; return result; } internal B32 -ctrl_entity_tree_is_frozen(D_Entity *root) +d_entity_tree_is_frozen(D_Entity *root) { B32 is_frozen = 1; - for(D_Entity *e = root; e != &d_entity_nil; e = ctrl_entity_rec_depth_first_pre(e, root).next) + for(D_Entity *e = root; e != &d_entity_nil; e = d_entity_rec_depth_first_pre(e, root).next) { if(e->kind == D_EntityKind_Thread && !e->is_frozen) { @@ -888,24 +875,24 @@ ctrl_entity_tree_is_frozen(D_Entity *root) //- rjf: entity ctx r/w store state functions internal D_EntityCtxRWStore * -ctrl_entity_ctx_rw_store_alloc(void) +d_entity_ctx_rw_store_alloc(void) { Arena *arena = arena_alloc(); D_EntityCtxRWStore *store = push_array(arena, D_EntityCtxRWStore, 1); store->arena = arena; store->ctx.hash_slots_count = 1024; store->ctx.hash_slots = push_array(arena, D_EntityHashSlot, store->ctx.hash_slots_count); - D_Entity *root = store->ctx.root = ctrl_entity_alloc(store, &d_entity_nil, D_EntityKind_Root, Arch_Null, ctrl_handle_zero(), 0); - D_Entity *local_machine = ctrl_entity_alloc(store, root, D_EntityKind_Machine, Arch_CURRENT, ctrl_handle_make(D_MachineID_Local, dmn_handle_zero()), 0); + D_Entity *root = store->ctx.root = d_entity_alloc(store, &d_entity_nil, D_EntityKind_Root, Arch_Null, d_handle_zero(), 0); + D_Entity *local_machine = d_entity_alloc(store, root, D_EntityKind_Machine, Arch_CURRENT, d_handle_make(D_MachineID_Local, dmn_handle_zero()), 0); Temp scratch = scratch_begin(0, 0); String8 local_machine_name = push_str8f(scratch.arena, "This PC (%S)", os_get_system_info()->machine_name); - ctrl_entity_equip_string(store, local_machine, local_machine_name); + d_entity_equip_string(store, local_machine, local_machine_name); scratch_end(scratch); return store; } internal void -ctrl_entity_ctx_rw_store_release(D_EntityCtxRWStore *store) +d_entity_ctx_rw_store_release(D_EntityCtxRWStore *store) { arena_release(store->arena); } @@ -913,14 +900,14 @@ ctrl_entity_ctx_rw_store_release(D_EntityCtxRWStore *store) //- rjf: string allocation/deletion internal U64 -ctrl_name_bucket_num_from_string_size(U64 size) +d_name_bucket_num_from_string_size(U64 size) { U64 bucket_num = 0; if(size > 0) { - for EachElement(idx, ctrl_entity_string_bucket_chunk_sizes) + for EachElement(idx, d_entity_string_bucket_chunk_sizes) { - if(size <= ctrl_entity_string_bucket_chunk_sizes[idx]) + if(size <= d_entity_string_bucket_chunk_sizes[idx]) { bucket_num = idx+1; break; @@ -931,19 +918,19 @@ ctrl_name_bucket_num_from_string_size(U64 size) } internal String8 -ctrl_entity_string_alloc(D_EntityCtxRWStore *store, String8 string) +d_entity_string_alloc(D_EntityCtxRWStore *store, String8 string) { //- rjf: allocate node - CTRL_EntityStringChunkNode *node = 0; + D_EntityStringChunkNode *node = 0; { - U64 bucket_num = ctrl_name_bucket_num_from_string_size(string.size); - if(bucket_num == ArrayCount(ctrl_entity_string_bucket_chunk_sizes)) + U64 bucket_num = d_name_bucket_num_from_string_size(string.size); + if(bucket_num == ArrayCount(d_entity_string_bucket_chunk_sizes)) { - CTRL_EntityStringChunkNode *best_node = 0; - CTRL_EntityStringChunkNode *best_node_prev = 0; + D_EntityStringChunkNode *best_node = 0; + D_EntityStringChunkNode *best_node_prev = 0; U64 best_node_size = max_U64; { - for(CTRL_EntityStringChunkNode *n = store->free_string_chunks[bucket_num-1], *prev = 0; n != 0; (prev = n, n = n->next)) + for(D_EntityStringChunkNode *n = store->free_string_chunks[bucket_num-1], *prev = 0; n != 0; (prev = n, n = n->next)) { if(n->size >= string.size && n->size < best_node_size) { @@ -968,7 +955,7 @@ ctrl_entity_string_alloc(D_EntityCtxRWStore *store, String8 string) else { U64 chunk_size = u64_up_to_pow2(string.size); - node = (CTRL_EntityStringChunkNode *)push_array(store->arena, U8, chunk_size); + node = (D_EntityStringChunkNode *)push_array(store->arena, U8, chunk_size); } } else if(bucket_num != 0) @@ -980,7 +967,7 @@ ctrl_entity_string_alloc(D_EntityCtxRWStore *store, String8 string) } else { - node = (CTRL_EntityStringChunkNode *)push_array(store->arena, U8, ctrl_entity_string_bucket_chunk_sizes[bucket_num-1]); + node = (D_EntityStringChunkNode *)push_array(store->arena, U8, d_entity_string_bucket_chunk_sizes[bucket_num-1]); } } } @@ -997,13 +984,13 @@ ctrl_entity_string_alloc(D_EntityCtxRWStore *store, String8 string) } internal void -ctrl_entity_string_release(D_EntityCtxRWStore *store, String8 string) +d_entity_string_release(D_EntityCtxRWStore *store, String8 string) { - U64 bucket_num = ctrl_name_bucket_num_from_string_size(string.size); - if(1 <= bucket_num && bucket_num <= ArrayCount(ctrl_entity_string_bucket_chunk_sizes)) + U64 bucket_num = d_name_bucket_num_from_string_size(string.size); + if(1 <= bucket_num && bucket_num <= ArrayCount(d_entity_string_bucket_chunk_sizes)) { U64 bucket_idx = bucket_num-1; - CTRL_EntityStringChunkNode *node = (CTRL_EntityStringChunkNode *)string.str; + D_EntityStringChunkNode *node = (D_EntityStringChunkNode *)string.str; SLLStackPush(store->free_string_chunks[bucket_idx], node); node->size = u64_up_to_pow2(string.size); } @@ -1012,7 +999,7 @@ ctrl_entity_string_release(D_EntityCtxRWStore *store, String8 string) //- rjf: entity construction/deletion internal D_Entity * -ctrl_entity_alloc(D_EntityCtxRWStore *store, D_Entity *parent, D_EntityKind kind, Arch arch, D_Handle handle, U64 id) +d_entity_alloc(D_EntityCtxRWStore *store, D_Entity *parent, D_EntityKind kind, Arch arch, D_Handle handle, U64 id) { D_Entity *entity = &d_entity_nil; { @@ -1046,13 +1033,13 @@ ctrl_entity_alloc(D_EntityCtxRWStore *store, D_Entity *parent, D_EntityKind kind // rjf: insert into hash map { - U64 hash = ctrl_hash_from_handle(handle); + U64 hash = d_hash_from_handle(handle); U64 slot_idx = hash%store->ctx.hash_slots_count; D_EntityHashSlot *slot = &store->ctx.hash_slots[slot_idx]; D_EntityHashNode *node = 0; for(D_EntityHashNode *n = slot->first; n != 0; n = n->next) { - if(ctrl_handle_match(n->entity->handle, handle)) + if(d_handle_match(n->entity->handle, handle)) { node = n; break; @@ -1083,7 +1070,7 @@ ctrl_entity_alloc(D_EntityCtxRWStore *store, D_Entity *parent, D_EntityKind kind } internal void -ctrl_entity_release(D_EntityCtxRWStore *store, D_Entity *entity) +d_entity_release(D_EntityCtxRWStore *store, D_Entity *entity) { // rjf: unhook root if(entity->parent != &d_entity_nil) @@ -1118,13 +1105,13 @@ ctrl_entity_release(D_EntityCtxRWStore *store, D_Entity *entity) // rjf: remove from hash map { - U64 hash = ctrl_hash_from_handle(t->e->handle); + U64 hash = d_hash_from_handle(t->e->handle); U64 slot_idx = hash%store->ctx.hash_slots_count; D_EntityHashSlot *slot = &store->ctx.hash_slots[slot_idx]; D_EntityHashNode *node = 0; for(D_EntityHashNode *n = slot->first; n != 0; n = n->next) { - if(ctrl_handle_match(n->entity->handle, t->e->handle)) + if(d_handle_match(n->entity->handle, t->e->handle)) { DLLRemove(slot->first, slot->last, n); SLLStackPush(store->hash_node_free, n); @@ -1144,19 +1131,19 @@ ctrl_entity_release(D_EntityCtxRWStore *store, D_Entity *entity) //- rjf: entity equipment internal void -ctrl_entity_equip_string(D_EntityCtxRWStore *store, D_Entity *entity, String8 string) +d_entity_equip_string(D_EntityCtxRWStore *store, D_Entity *entity, String8 string) { if(entity->string.size != 0) { - ctrl_entity_string_release(store, entity->string); + d_entity_string_release(store, entity->string); } - entity->string = ctrl_entity_string_alloc(store, string); + entity->string = d_entity_string_alloc(store, string); } //- rjf: accelerated entity context lookups internal D_EntityCtxLookupAccel * -ctrl_thread_entity_ctx_lookup_accel(void) +d_thread_entity_ctx_lookup_accel(void) { if(d_entity_ctx_lookup_accel == 0) { @@ -1172,52 +1159,52 @@ ctrl_thread_entity_ctx_lookup_accel(void) } internal D_EntityArray -ctrl_entity_array_from_kind(D_EntityCtx *ctx, D_EntityKind kind) +d_entity_array_from_kind(D_EntityCtx *ctx, D_EntityKind kind) { - D_EntityCtxLookupAccel *accel = ctrl_thread_entity_ctx_lookup_accel(); + D_EntityCtxLookupAccel *accel = d_thread_entity_ctx_lookup_accel(); if(accel->entity_kind_arrays_gens[kind] != ctx->entity_kind_alloc_gens[kind]) { Temp scratch = scratch_begin(0, 0); D_EntityList entities = {0}; for(D_Entity *e = ctx->root; e != &d_entity_nil; - e = ctrl_entity_rec_depth_first_pre(e, ctx->root).next) + e = d_entity_rec_depth_first_pre(e, ctx->root).next) { if(e->kind == kind) { - ctrl_entity_list_push(scratch.arena, &entities, e); + d_entity_list_push(scratch.arena, &entities, e); } } accel->entity_kind_arrays_gens[kind] = ctx->entity_kind_alloc_gens[kind]; arena_clear(accel->entity_kind_arrays_arenas[kind]); - accel->entity_kind_arrays[kind] = ctrl_entity_array_from_list(accel->entity_kind_arrays_arenas[kind], &entities); + accel->entity_kind_arrays[kind] = d_entity_array_from_list(accel->entity_kind_arrays_arenas[kind], &entities); scratch_end(scratch); } return accel->entity_kind_arrays[kind]; } internal D_EntityList -ctrl_modules_from_dbgi_key(Arena *arena, D_EntityCtx *ctx, DI_Key dbgi_key) +d_modules_from_dbgi_key(Arena *arena, D_EntityCtx *ctx, DI_Key dbgi_key) { D_EntityList list = {0}; - D_EntityArray all_modules = ctrl_entity_array_from_kind(ctx, D_EntityKind_Module); + D_EntityArray all_modules = d_entity_array_from_kind(ctx, D_EntityKind_Module); for EachIndex(idx, all_modules.count) { D_Entity *module = all_modules.v[idx]; - DI_Key module_dbgi_key = ctrl_dbgi_key_from_module(module); + DI_Key module_dbgi_key = d_dbgi_key_from_module(module); if(di_key_match(module_dbgi_key, dbgi_key)) { - ctrl_entity_list_push(arena, &list, module); + d_entity_list_push(arena, &list, module); } } return list; } internal D_Entity * -ctrl_thread_from_id(D_EntityCtx *ctx, U64 id) +d_thread_from_id(D_EntityCtx *ctx, U64 id) { D_Entity *thread = &d_entity_nil; - D_EntityArray threads = ctrl_entity_array_from_kind(ctx, D_EntityKind_Thread); + D_EntityArray threads = d_entity_array_from_kind(ctx, D_EntityKind_Thread); for EachIndex(idx, threads.count) { if(threads.v[idx]->id == id) @@ -1231,7 +1218,7 @@ ctrl_thread_from_id(D_EntityCtx *ctx, U64 id) //- rjf: entity tree iteration internal D_EntityRec -ctrl_entity_rec_depth_first(D_Entity *entity, D_Entity *subtree_root, U64 sib_off, U64 child_off) +d_entity_rec_depth_first(D_Entity *entity, D_Entity *subtree_root, U64 sib_off, U64 child_off) { D_EntityRec result = {0}; result.next = &d_entity_nil; @@ -1255,7 +1242,7 @@ ctrl_entity_rec_depth_first(D_Entity *entity, D_Entity *subtree_root, U64 sib_of //- rjf: applying events to entity caches internal void -ctrl_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list) +d_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list) { //- rjf: scan events & construct entities for(D_EventNode *n = list->first; n != 0; n = n->next) @@ -1268,18 +1255,18 @@ ctrl_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list) //- rjf: processes case D_EventKind_NewProc: { - D_Entity *machine = ctrl_entity_from_handle(&store->ctx, ctrl_handle_make(event->entity.machine_id, dmn_handle_zero())); + D_Entity *machine = d_entity_from_handle(&store->ctx, d_handle_make(event->entity.machine_id, dmn_handle_zero())); if(machine != &d_entity_nil) { - D_Entity *process = ctrl_entity_alloc(store, machine, D_EntityKind_Process, event->arch, event->entity, (U64)event->entity_id); + D_Entity *process = d_entity_alloc(store, machine, D_EntityKind_Process, event->arch, event->entity, (U64)event->entity_id); process->tls_model = event->tls_model; process->target_os = event->target_os; } }break; case D_EventKind_EndProc: { - D_Entity *process = ctrl_entity_from_handle(&store->ctx, event->entity); - ctrl_entity_release(store, process); + D_Entity *process = d_entity_from_handle(&store->ctx, event->entity); + d_entity_release(store, process); for(D_Entity *entry = store->ctx.root->first, *next = &d_entity_nil; entry != &d_entity_nil; entry = next) @@ -1287,7 +1274,7 @@ ctrl_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list) next = entry->next; if(entry->kind == D_EntityKind_EntryPoint && entry->id == process->id) { - ctrl_entity_release(store, entry); + d_entity_release(store, entry); } } }break; @@ -1295,79 +1282,79 @@ ctrl_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list) //- rjf: threads case D_EventKind_NewThread: { - D_Entity *process = ctrl_entity_from_handle(&store->ctx, event->parent); + D_Entity *process = d_entity_from_handle(&store->ctx, event->parent); if(process != &d_entity_nil) { - D_Entity *thread = ctrl_entity_alloc(store, process, D_EntityKind_Thread, event->arch, event->entity, (U64)event->entity_id); - D_Entity *first_thread = ctrl_entity_child_from_kind(process, D_EntityKind_Thread); + D_Entity *thread = d_entity_alloc(store, process, D_EntityKind_Thread, event->arch, event->entity, (U64)event->entity_id); + D_Entity *first_thread = d_entity_child_from_kind(process, D_EntityKind_Thread); if(first_thread == thread) { - ctrl_entity_equip_string(store, thread, str8_lit("main_thread")); + d_entity_equip_string(store, thread, str8_lit("main_thread")); } - D_EntityArray pending_thread_names = ctrl_entity_array_from_kind(&store->ctx, D_EntityKind_PendingThreadName); + D_EntityArray pending_thread_names = d_entity_array_from_kind(&store->ctx, D_EntityKind_PendingThreadName); for EachIndex(idx, pending_thread_names.count) { D_Entity *entity = pending_thread_names.v[idx]; if(entity->id == event->entity_id) { - ctrl_entity_equip_string(store, thread, entity->string); - ctrl_entity_release(store, entity); + d_entity_equip_string(store, thread, entity->string); + d_entity_release(store, entity); break; } } - D_EntityArray pending_thread_colors = ctrl_entity_array_from_kind(&store->ctx, D_EntityKind_PendingThreadColor); + D_EntityArray pending_thread_colors = d_entity_array_from_kind(&store->ctx, D_EntityKind_PendingThreadColor); for EachIndex(idx, pending_thread_colors.count) { D_Entity *entity = pending_thread_colors.v[idx]; if(entity->id == event->entity_id) { thread->rgba = entity->rgba; - ctrl_entity_release(store, entity); + d_entity_release(store, entity); break; } } thread->stack_base = event->stack_base; } - //ctrl_rip_from_thread(&store->ctx, event->entity); + //d_rip_from_thread(&store->ctx, event->entity); }break; case D_EventKind_EndThread: { - D_Entity *thread = ctrl_entity_from_handle(&store->ctx, event->entity); - ctrl_entity_release(store, thread); + D_Entity *thread = d_entity_from_handle(&store->ctx, event->entity); + d_entity_release(store, thread); }break; case D_EventKind_ThreadName: { - D_Entity *process = ctrl_entity_from_handle(&store->ctx, event->parent); + D_Entity *process = d_entity_from_handle(&store->ctx, event->parent); D_Entity *thread = &d_entity_nil; if(event->entity_id == 0) { - thread = ctrl_entity_from_handle(&store->ctx, event->entity); + thread = d_entity_from_handle(&store->ctx, event->entity); } else { - thread = ctrl_thread_from_id(&store->ctx, event->entity_id); + thread = d_thread_from_id(&store->ctx, event->entity_id); } if(thread != &d_entity_nil) { - ctrl_entity_equip_string(store, thread, event->string); + d_entity_equip_string(store, thread, event->string); } else if(process != &d_entity_nil) { - D_Entity *pending_name = ctrl_entity_alloc(store, process, D_EntityKind_PendingThreadName, Arch_Null, ctrl_handle_zero(), event->entity_id); - ctrl_entity_equip_string(store, pending_name, event->string); + D_Entity *pending_name = d_entity_alloc(store, process, D_EntityKind_PendingThreadName, Arch_Null, d_handle_zero(), event->entity_id); + d_entity_equip_string(store, pending_name, event->string); } }break; case D_EventKind_ThreadColor: { - D_Entity *process = ctrl_entity_from_handle(&store->ctx, event->parent); + D_Entity *process = d_entity_from_handle(&store->ctx, event->parent); D_Entity *thread = &d_entity_nil; if(event->entity_id == 0) { - thread = ctrl_entity_from_handle(&store->ctx, event->entity); + thread = d_entity_from_handle(&store->ctx, event->entity); } else { - thread = ctrl_thread_from_id(&store->ctx, event->entity_id); + thread = d_thread_from_id(&store->ctx, event->entity_id); } if(thread != &d_entity_nil) { @@ -1375,13 +1362,13 @@ ctrl_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list) } else if(process != &d_entity_nil) { - D_Entity *pending = ctrl_entity_alloc(store, process, D_EntityKind_PendingThreadColor, Arch_Null, ctrl_handle_zero(), event->entity_id); + D_Entity *pending = d_entity_alloc(store, process, D_EntityKind_PendingThreadColor, Arch_Null, d_handle_zero(), event->entity_id); pending->rgba = event->rgba; } }break; case D_EventKind_ThreadFrozen: { - D_Entity *thread = ctrl_entity_from_handle(&store->ctx, event->entity); + D_Entity *thread = d_entity_from_handle(&store->ctx, event->entity); if(thread != &d_entity_nil) { thread->is_frozen = 1; @@ -1389,7 +1376,7 @@ ctrl_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list) }break; case D_EventKind_ThreadThawed: { - D_Entity *thread = ctrl_entity_from_handle(&store->ctx, event->entity); + D_Entity *thread = d_entity_from_handle(&store->ctx, event->entity); if(thread != &d_entity_nil) { thread->is_frozen = 0; @@ -1400,35 +1387,35 @@ ctrl_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list) case D_EventKind_NewModule: { Temp scratch = scratch_begin(0, 0); - D_Entity *process = ctrl_entity_from_handle(&store->ctx, event->parent); - D_Entity *module = ctrl_entity_alloc(store, process, D_EntityKind_Module, event->arch, event->entity, event->vaddr_rng.min); - ctrl_entity_equip_string(store, module, event->string); + D_Entity *process = d_entity_from_handle(&store->ctx, event->parent); + D_Entity *module = d_entity_alloc(store, process, D_EntityKind_Module, event->arch, event->entity, event->vaddr_rng.min); + d_entity_equip_string(store, module, event->string); module->timestamp = event->timestamp; module->vaddr_range = event->vaddr_rng; module->tls_index = event->tls_index; module->tls_offset = event->tls_offset; - D_Entity *first_module = ctrl_entity_child_from_kind(process, D_EntityKind_Module); + D_Entity *first_module = d_entity_child_from_kind(process, D_EntityKind_Module); if(first_module == module) { - ctrl_entity_equip_string(store, process, str8_skip_last_slash(event->string)); + d_entity_equip_string(store, process, str8_skip_last_slash(event->string)); } scratch_end(scratch); }break; case D_EventKind_EndModule: { - D_Entity *module = ctrl_entity_from_handle(&store->ctx, event->entity); - ctrl_entity_release(store, module); + D_Entity *module = d_entity_from_handle(&store->ctx, event->entity); + d_entity_release(store, module); }break; case D_EventKind_ModuleDebugInfoPathChange: { Temp scratch = scratch_begin(0, 0); - D_Entity *module = ctrl_entity_from_handle(&store->ctx, event->entity); - D_Entity *debug_info_path = ctrl_entity_child_from_kind(module, D_EntityKind_DebugInfoPath); + D_Entity *module = d_entity_from_handle(&store->ctx, event->entity); + D_Entity *debug_info_path = d_entity_child_from_kind(module, D_EntityKind_DebugInfoPath); if(debug_info_path == &d_entity_nil) { - debug_info_path = ctrl_entity_alloc(store, module, D_EntityKind_DebugInfoPath, Arch_Null, ctrl_handle_zero(), 0); + debug_info_path = d_entity_alloc(store, module, D_EntityKind_DebugInfoPath, Arch_Null, d_handle_zero(), 0); } - ctrl_entity_equip_string(store, debug_info_path, path_normalized_from_string(scratch.arena, event->string)); + d_entity_equip_string(store, debug_info_path, path_normalized_from_string(scratch.arena, event->string)); debug_info_path->timestamp = event->timestamp; scratch_end(scratch); }break; @@ -1436,14 +1423,14 @@ ctrl_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list) //- rjf: dynamic, program-created breakpoints case D_EventKind_SetBreakpoint: { - D_Entity *process = ctrl_entity_from_handle(&store->ctx, event->parent); - D_Entity *bp = ctrl_entity_alloc(store, process, D_EntityKind_Breakpoint, Arch_Null, ctrl_handle_zero(), 0); + D_Entity *process = d_entity_from_handle(&store->ctx, event->parent); + D_Entity *bp = d_entity_alloc(store, process, D_EntityKind_Breakpoint, Arch_Null, d_handle_zero(), 0); bp->vaddr_range = event->vaddr_rng; bp->bp_flags = event->bp_flags; }break; case D_EventKind_UnsetBreakpoint: { - D_Entity *process = ctrl_entity_from_handle(&store->ctx, event->parent); + D_Entity *process = d_entity_from_handle(&store->ctx, event->parent); for(D_Entity *child = process->first; child != &d_entity_nil; child = child->next) { if(child->kind == D_EntityKind_Breakpoint && @@ -1451,7 +1438,7 @@ ctrl_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list) child->vaddr_range.max == event->vaddr_rng.max && child->bp_flags == event->bp_flags) { - ctrl_entity_release(store, child); + d_entity_release(store, child); break; } } @@ -1460,10 +1447,10 @@ ctrl_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list) //- rjf: address range annotations case D_EventKind_SetVAddrRangeNote: { - D_Entity *process = ctrl_entity_from_handle(&store->ctx, event->parent); - D_Entity *annotation = ctrl_entity_alloc(store, process, D_EntityKind_AddressRangeAnnotation, Arch_Null, ctrl_handle_zero(), 0); + D_Entity *process = d_entity_from_handle(&store->ctx, event->parent); + D_Entity *annotation = d_entity_alloc(store, process, D_EntityKind_AddressRangeAnnotation, Arch_Null, d_handle_zero(), 0); annotation->vaddr_range = event->vaddr_rng; - ctrl_entity_equip_string(store, annotation, event->string); + d_entity_equip_string(store, annotation, event->string); }break; } } @@ -1473,7 +1460,7 @@ ctrl_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list) //~ rjf: Wakeup Callback Registration internal void -ctrl_set_wakeup_hook(D_WakeupFunctionType *wakeup_hook) +d_set_wakeup_hook(D_WakeupFunctionType *wakeup_hook) { d_ctrl_state->wakeup_hook = wakeup_hook; } @@ -1484,13 +1471,13 @@ ctrl_set_wakeup_hook(D_WakeupFunctionType *wakeup_hook) //- rjf: thread register cache reading internal void * -ctrl_reg_block_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle handle) +d_reg_block_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle handle) { D_ThreadRegCache *cache = &d_ctrl_state->thread_reg_cache; - D_Entity *thread_entity = ctrl_entity_from_handle(ctx, handle); + D_Entity *thread_entity = d_entity_from_handle(ctx, handle); Arch arch = thread_entity->arch; U64 reg_block_size = regs_block_size_from_arch(arch); - U64 hash = ctrl_hash_from_handle(handle); + U64 hash = d_hash_from_handle(handle); U64 slot_idx = hash%cache->slots_count; U64 stripe_idx = slot_idx%cache->stripes_count; D_ThreadRegCacheSlot *slot = &cache->slots[slot_idx]; @@ -1502,7 +1489,7 @@ ctrl_reg_block_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle handle) D_ThreadRegCacheNode *node = 0; for(D_ThreadRegCacheNode *n = slot->first; n != 0; n = n->next) { - if(ctrl_handle_match(n->handle, handle)) + if(d_handle_match(n->handle, handle)) { node = n; break; @@ -1522,7 +1509,7 @@ ctrl_reg_block_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle handle) // rjf: copy from node if(node) { - U64 current_reg_gen = ctrl_reg_gen(); + U64 current_reg_gen = d_reg_gen(); B32 need_stale = 1; if(node->reg_gen != current_reg_gen && dmn_thread_read_reg_block(handle.dmn_handle, result)) @@ -1544,31 +1531,31 @@ ctrl_reg_block_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle handle) } internal U64 -ctrl_tls_root_vaddr_from_thread(D_EntityCtx *ctx, D_Handle handle) +d_tls_root_vaddr_from_thread(D_EntityCtx *ctx, D_Handle handle) { U64 result = dmn_tls_root_vaddr_from_thread(handle.dmn_handle); return result; } internal U64 -ctrl_rip_from_thread(D_EntityCtx *ctx, D_Handle handle) +d_rip_from_thread(D_EntityCtx *ctx, D_Handle handle) { Temp scratch = scratch_begin(0, 0); - D_Entity *thread_entity = ctrl_entity_from_handle(ctx, handle); + D_Entity *thread_entity = d_entity_from_handle(ctx, handle); Arch arch = thread_entity->arch; - void *block = ctrl_reg_block_from_thread(scratch.arena, ctx, handle); + void *block = d_reg_block_from_thread(scratch.arena, ctx, handle); U64 result = regs_rip_from_arch_block(arch, block); scratch_end(scratch); return result; } internal U64 -ctrl_rsp_from_thread(D_EntityCtx *ctx, D_Handle handle) +d_rsp_from_thread(D_EntityCtx *ctx, D_Handle handle) { Temp scratch = scratch_begin(0, 0); - D_Entity *thread_entity = ctrl_entity_from_handle(ctx, handle); + D_Entity *thread_entity = d_entity_from_handle(ctx, handle); Arch arch = thread_entity->arch; - void *block = ctrl_reg_block_from_thread(scratch.arena, ctx, handle); + void *block = d_reg_block_from_thread(scratch.arena, ctx, handle); U64 result = regs_rsp_from_arch_block(arch, block); scratch_end(scratch); return result; @@ -1577,7 +1564,7 @@ ctrl_rsp_from_thread(D_EntityCtx *ctx, D_Handle handle) //- rjf: thread register writing internal B32 -ctrl_thread_write_reg_block(D_Handle thread, void *block) +d_thread_write_reg_block(D_Handle thread, void *block) { // TODO(rjf): @callstacks immediately reflect this in the call stack cache B32 good = dmn_thread_write_reg_block(thread.dmn_handle, block); @@ -1594,18 +1581,18 @@ ctrl_thread_write_reg_block(D_Handle thread, void *block) //- rjf: cache lookups internal PE_IntelPdata * -ctrl_intel_pdata_from_module_voff(Arena *arena, D_Handle module_handle, U64 voff) +d_intel_pdata_from_module_voff(Arena *arena, D_Handle module_handle, U64 voff) { PE_IntelPdata *first_pdata = 0; { - U64 hash = ctrl_hash_from_handle(module_handle); + U64 hash = d_hash_from_handle(module_handle); U64 slot_idx = hash%d_ctrl_state->module_image_info_cache.slots_count; U64 stripe_idx = slot_idx%d_ctrl_state->module_image_info_cache.stripes_count; D_ModuleImageInfoCacheSlot *slot = &d_ctrl_state->module_image_info_cache.slots[slot_idx]; D_ModuleImageInfoCacheStripe *stripe = &d_ctrl_state->module_image_info_cache.stripes[stripe_idx]; MutexScopeR(stripe->rw_mutex) for(D_ModuleImageInfoCacheNode *n = slot->first; n != 0; n = n->next) { - if(ctrl_handle_match(n->module, module_handle)) + if(d_handle_match(n->module, module_handle)) { PE_IntelPdata *pdatas = n->pdatas; U64 pdatas_count = n->pdatas_count; @@ -1661,17 +1648,17 @@ ctrl_intel_pdata_from_module_voff(Arena *arena, D_Handle module_handle, U64 voff } internal U64 -ctrl_entry_point_voff_from_module(D_Handle module_handle) +d_entry_point_voff_from_module(D_Handle module_handle) { U64 result = 0; - U64 hash = ctrl_hash_from_handle(module_handle); + U64 hash = d_hash_from_handle(module_handle); U64 slot_idx = hash%d_ctrl_state->module_image_info_cache.slots_count; U64 stripe_idx = slot_idx%d_ctrl_state->module_image_info_cache.stripes_count; D_ModuleImageInfoCacheSlot *slot = &d_ctrl_state->module_image_info_cache.slots[slot_idx]; D_ModuleImageInfoCacheStripe *stripe = &d_ctrl_state->module_image_info_cache.stripes[stripe_idx]; MutexScopeR(stripe->rw_mutex) for(D_ModuleImageInfoCacheNode *n = slot->first; n != 0; n = n->next) { - if(ctrl_handle_match(n->module, module_handle)) + if(d_handle_match(n->module, module_handle)) { result = n->entry_point_voff; break; @@ -1681,17 +1668,17 @@ ctrl_entry_point_voff_from_module(D_Handle module_handle) } internal String8 -ctrl_initial_debug_info_path_from_module(Arena *arena, D_Handle module_handle) +d_initial_debug_info_path_from_module(Arena *arena, D_Handle module_handle) { String8 result = {0}; - U64 hash = ctrl_hash_from_handle(module_handle); + U64 hash = d_hash_from_handle(module_handle); U64 slot_idx = hash%d_ctrl_state->module_image_info_cache.slots_count; U64 stripe_idx = slot_idx%d_ctrl_state->module_image_info_cache.stripes_count; D_ModuleImageInfoCacheSlot *slot = &d_ctrl_state->module_image_info_cache.slots[slot_idx]; D_ModuleImageInfoCacheStripe *stripe = &d_ctrl_state->module_image_info_cache.stripes[stripe_idx]; MutexScopeR(stripe->rw_mutex) for(D_ModuleImageInfoCacheNode *n = slot->first; n != 0; n = n->next) { - if(ctrl_handle_match(n->module, module_handle)) + if(d_handle_match(n->module, module_handle)) { result = push_str8_copy(arena, n->initial_debug_info_path); break; @@ -1701,17 +1688,17 @@ ctrl_initial_debug_info_path_from_module(Arena *arena, D_Handle module_handle) } internal String8 -ctrl_raddbg_data_from_module(Arena *arena, D_Handle module_handle) +d_raddbg_data_from_module(Arena *arena, D_Handle module_handle) { String8 result = {0}; - U64 hash = ctrl_hash_from_handle(module_handle); + U64 hash = d_hash_from_handle(module_handle); U64 slot_idx = hash%d_ctrl_state->module_image_info_cache.slots_count; U64 stripe_idx = slot_idx%d_ctrl_state->module_image_info_cache.stripes_count; D_ModuleImageInfoCacheSlot *slot = &d_ctrl_state->module_image_info_cache.slots[slot_idx]; D_ModuleImageInfoCacheStripe *stripe = &d_ctrl_state->module_image_info_cache.stripes[stripe_idx]; MutexScopeR(stripe->rw_mutex) for(D_ModuleImageInfoCacheNode *n = slot->first; n != 0; n = n->next) { - if(ctrl_handle_match(n->module, module_handle)) + if(d_handle_match(n->module, module_handle)) { result = push_str8_copy(arena, n->raddbg_data); break; @@ -1721,56 +1708,22 @@ ctrl_raddbg_data_from_module(Arena *arena, D_Handle module_handle) } //////////////////////////////// -//~ Process Info Functions +//~ rjf: Unwinding Functions} -internal Arch -ctrl_arch_from_process_handle(D_Handle process_handle) -{ - D_EntityCtx *entity_ctx = &d_ctrl_state->ctrl_thread_entity_store->ctx; - D_Entity *process_entity = ctrl_entity_from_handle(entity_ctx, process_handle); - return process_entity->arch; -} +//- rjf: [dwarf] -//////////////////////////////// -//~ rjf: Unwinding Functions - -//- rjf: unwind deep copier - -internal D_Unwind -ctrl_unwind_deep_copy(Arena *arena, Arch arch, D_Unwind *src) -{ - D_Unwind dst = {0}; - { - dst.flags = src->flags; - dst.frames.count = src->frames.count; - dst.frames.v = push_array(arena, D_UnwindFrame, dst.frames.count); - MemoryCopy(dst.frames.v, src->frames.v, sizeof(dst.frames.v[0])*dst.frames.count); - U64 block_size = regs_block_size_from_arch(arch); - for(U64 idx = 0; idx < dst.frames.count; idx += 1) - { - dst.frames.v[idx].regs = push_array_no_zero(arena, U8, block_size); - MemoryCopy(dst.frames.v[idx].regs, src->frames.v[idx].regs, block_size); - } - } - return dst; -} - -//- DWARF - -typedef struct +typedef struct D_MemoryReadContextDwarfX64 D_MemoryReadContextDwarfX64; +struct D_MemoryReadContextDwarfX64 { D_Handle process_handle; U64 endt_us; -} CTRL_MemoryReadContextDwarfX64; +}; -internal -MACHINE_OP_MEM_READ(ctrl_machine_mem_read) +internal MACHINE_OP_MEM_READ(ctrl_machine_mem_read) { - CTRL_MemoryReadContextDwarfX64 *ctx = ud; - + D_MemoryReadContextDwarfX64 *ctx = ud; B32 is_stale = 0; - B32 is_read = ctrl_process_memory_read(ctx->process_handle, r1u64(addr, addr + buffer_size), &is_stale, buffer, ctx->endt_us); - + B32 is_read = d_process_memory_read(ctx->process_handle, r1u64(addr, addr + buffer_size), &is_stale, buffer, ctx->endt_us); MachineOpResult status = MachineOpResult_Fail; if(is_stale) { @@ -1780,17 +1733,17 @@ MACHINE_OP_MEM_READ(ctrl_machine_mem_read) { status = MachineOpResult_Ok; } - return status; } internal D_UnwindStepResult -ctrl_unwind_step_result_from_machine_op_result(MachineOpResult s) +d_unwind_step_result_from_machine_op_result(MachineOpResult s) { D_UnwindStepResult result = {0}; switch(s) { - case MachineOpResult_Null: {} break; + default:{result.flags |= D_UnwindFlag_Error;}break; + case MachineOpResult_Null:{}break; case MachineOpResult_Ok: { result.flags &= ~(D_UnwindFlag_Error|D_UnwindFlag_Stale); @@ -1804,13 +1757,12 @@ ctrl_unwind_step_result_from_machine_op_result(MachineOpResult s) result.flags &= ~D_UnwindFlag_Error; result.flags |= D_UnwindFlag_Stale; }break; - default: { InvalidPath; } break; } return result; } internal D_UnwindStepResult -ctrl_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle, D_Handle module_handle, Arch arch, void *regs, U64 endt_us, D_FrameUnwindContext *ctx_out) +d_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle, D_Handle module_handle, Arch arch, void *regs, U64 endt_us, D_FrameUnwindContext *ctx_out) { Temp scratch = scratch_begin(&arena, 1); D_UnwindStepResult result = { .flags = D_UnwindFlag_Error }; @@ -1822,14 +1774,14 @@ ctrl_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle EH_FrameHdr eh_frame_hdr = {0}; EH_PtrCtx eh_ptr_ctx = {0}; { - U64 hash = ctrl_hash_from_handle(module_handle); + U64 hash = d_hash_from_handle(module_handle); U64 slot_idx = hash % d_ctrl_state->module_image_info_cache.slots_count; U64 stripe_idx = slot_idx % d_ctrl_state->module_image_info_cache.stripes_count; D_ModuleImageInfoCacheSlot *slot = &d_ctrl_state->module_image_info_cache.slots[slot_idx]; D_ModuleImageInfoCacheStripe *stripe = &d_ctrl_state->module_image_info_cache.stripes[stripe_idx]; MutexScopeR(stripe->rw_mutex) for EachNode(n, D_ModuleImageInfoCacheNode, slot->first) { - if(ctrl_handle_match(n->module, module_handle)) + if(d_handle_match(n->module, module_handle)) { cfi_rebase = n->cfi_rebase; is_unwind_eh = n->is_unwind_eh; @@ -1865,11 +1817,11 @@ ctrl_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle { // parse FDE length U32 first_four_bytes = 0; - if(!ctrl_process_memory_read_struct(process_handle, fde_addr, &is_stale, &first_four_bytes, endt_us)) { goto eh_parse_exit; } + if(!d_process_memory_read_struct(process_handle, fde_addr, &is_stale, &first_four_bytes, endt_us)) { goto eh_parse_exit; } if(first_four_bytes == max_U32) { U64 length = 0; - if(!ctrl_process_memory_read_struct(process_handle, fde_addr + sizeof(first_four_bytes), &is_stale, &length, endt_us)) { goto eh_parse_exit; } + if(!d_process_memory_read_struct(process_handle, fde_addr + sizeof(first_four_bytes), &is_stale, &length, endt_us)) { goto eh_parse_exit; } fde_vrange = r1u64(fde_addr, fde_addr + sizeof(first_four_bytes) + length); fde_format = DW_Format_64Bit; } @@ -1881,7 +1833,7 @@ ctrl_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle // read out whole FDE void *fde_raw = push_array(scratch.arena, U8, dim_1u64(fde_vrange)); - if(!ctrl_process_memory_read(process_handle, fde_vrange, &is_stale, fde_raw, endt_us)) { goto eh_parse_exit; } + if(!d_process_memory_read(process_handle, fde_vrange, &is_stale, fde_raw, endt_us)) { goto eh_parse_exit; } fde_data = str8(fde_raw, dim_1u64(fde_vrange)); // compute CIE address @@ -1899,11 +1851,11 @@ ctrl_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle { // parse CIE length U32 first_four_bytes = 0; - if(!ctrl_process_memory_read_struct(process_handle, cie_addr, &is_stale, &first_four_bytes, endt_us)) { goto eh_parse_exit; } + if(!d_process_memory_read_struct(process_handle, cie_addr, &is_stale, &first_four_bytes, endt_us)) { goto eh_parse_exit; } if(first_four_bytes == max_U32) { U64 length = 0; - if(!ctrl_process_memory_read_struct(process_handle, cie_addr + sizeof(first_four_bytes), &is_stale, &length, endt_us)) { goto eh_parse_exit; } + if(!d_process_memory_read_struct(process_handle, cie_addr + sizeof(first_four_bytes), &is_stale, &length, endt_us)) { goto eh_parse_exit; } cie_vrange = r1u64(cie_addr, cie_addr + sizeof(first_four_bytes) + length); cie_format = DW_Format_64Bit; } @@ -1915,7 +1867,7 @@ ctrl_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle // read out whole CIE void *cie_raw = push_array(scratch.arena, U8, dim_1u64(cie_vrange)); - if(!ctrl_process_memory_read(process_handle, cie_vrange, &is_stale, cie_raw, endt_us)) { goto eh_parse_exit; } + if(!d_process_memory_read(process_handle, cie_vrange, &is_stale, cie_raw, endt_us)) { goto eh_parse_exit; } cie_data = str8(cie_raw, dim_1u64(cie_vrange)); } @@ -1970,7 +1922,7 @@ ctrl_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle case Arch_Null: break; case Arch_x64: { - CTRL_MemoryReadContextDwarfX64 *mem_read_ctx_x64 = push_array(scratch.arena, CTRL_MemoryReadContextDwarfX64, 1); + D_MemoryReadContextDwarfX64 *mem_read_ctx_x64 = push_array(scratch.arena, D_MemoryReadContextDwarfX64, 1); mem_read_ctx_x64->process_handle = process_handle; mem_read_ctx_x64->endt_us = endt_us; @@ -2002,7 +1954,7 @@ ctrl_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle } // translate unwind status code - result = ctrl_unwind_step_result_from_machine_op_result(unwind_status); + result = d_unwind_step_result_from_machine_op_result(unwind_status); } } } @@ -2012,7 +1964,7 @@ ctrl_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle } internal D_UnwindStepResult -ctrl_unwind_step__dwarf(D_Handle process_handle, Arch arch, void *regs, D_FrameUnwindContext *frame_ctx, U64 endt_us) +d_unwind_step__dwarf(D_Handle process_handle, Arch arch, void *regs, D_FrameUnwindContext *frame_ctx, U64 endt_us) { Temp scratch = scratch_begin(0, 0); @@ -2027,28 +1979,20 @@ ctrl_unwind_step__dwarf(D_Handle process_handle, Arch arch, void *regs, D_FrameU MachineOp_RegWrite *reg_write_func = 0; switch(arch) { - case Arch_Null: break; + default: + case Arch_Null:{}break; case Arch_x64: { - CTRL_MemoryReadContextDwarfX64 *mem_read_ctx_x64 = push_array(scratch.arena, CTRL_MemoryReadContextDwarfX64, 1); + D_MemoryReadContextDwarfX64 *mem_read_ctx_x64 = push_array(scratch.arena, D_MemoryReadContextDwarfX64, 1); mem_read_ctx_x64->process_handle = process_handle; mem_read_ctx_x64->endt_us = endt_us; - mem_read_ctx = mem_read_ctx_x64; reg_read_ctx = regs; reg_write_ctx = regs; - mem_read_func = ctrl_machine_mem_read; reg_read_func = regs_read_dwarf_x64; reg_write_func = regs_write_dwarf_x64; }break; - case Arch_x86: - case Arch_arm64: - case Arch_arm32: - { - NotImplemented; - }break; - default: { InvalidPath; }break; } // apply register rules to the context @@ -2069,7 +2013,7 @@ ctrl_unwind_step__dwarf(D_Handle process_handle, Arch arch, void *regs, D_FrameU } // translate unwind status code - result = ctrl_unwind_step_result_from_machine_op_result(unwind_status); + result = d_unwind_step_result_from_machine_op_result(unwind_status); scratch_end(scratch); return result; @@ -2078,7 +2022,7 @@ ctrl_unwind_step__dwarf(D_Handle process_handle, Arch arch, void *regs, D_FrameU //- rjf: [x64] internal REGS_Reg64 * -ctrl_unwind_reg_from_pe_gpr_reg__pe_x64(REGS_RegBlockX64 *regs, PE_UnwindGprRegX64 gpr_reg) +d_unwind_reg_from_pe_gpr_reg__pe_x64(REGS_RegBlockX64 *regs, PE_UnwindGprRegX64 gpr_reg) { local_persist REGS_Reg64 dummy = {0}; REGS_Reg64 *result = &dummy; @@ -2105,7 +2049,7 @@ ctrl_unwind_reg_from_pe_gpr_reg__pe_x64(REGS_RegBlockX64 *regs, PE_UnwindGprRegX } internal D_UnwindStepResult -ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 module_base_vaddr, REGS_RegBlockX64 *regs, U64 endt_us) +d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 module_base_vaddr, REGS_RegBlockX64 *regs, U64 endt_us) { B32 is_stale = 0; B32 is_good = 1; @@ -2119,7 +2063,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo ////////////////////////////// //- rjf: rip_voff -> first pdata // - PE_IntelPdata *first_pdata = ctrl_intel_pdata_from_module_voff(scratch.arena, module_handle, rip_voff); + PE_IntelPdata *first_pdata = d_intel_pdata_from_module_voff(scratch.arena, module_handle, rip_voff); ////////////////////////////// //- rjf: pdata -> detect if in epilog @@ -2144,7 +2088,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo U8 inst[4] = {0}; if(read_vaddr + sizeof(inst) <= read_vaddr_opl) { - inst_good = ctrl_process_memory_read(process_handle, r1u64(read_vaddr, read_vaddr+sizeof(inst)), &is_stale, inst, endt_us); + inst_good = d_process_memory_read(process_handle, r1u64(read_vaddr, read_vaddr+sizeof(inst)), &is_stale, inst, endt_us); inst_good = inst_good && !is_stale; } if(!inst_good) @@ -2225,7 +2169,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo U8 inst_byte = 0; if(read_vaddr + sizeof(inst_byte) <= read_vaddr_opl) { - inst_byte_good = ctrl_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &inst_byte, endt_us); + inst_byte_good = d_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &inst_byte, endt_us); } if(!inst_byte_good || is_stale) { @@ -2241,7 +2185,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo check_vaddr = read_vaddr + 1; if(read_vaddr + sizeof(check_inst_byte) <= read_vaddr_opl) { - check_inst_byte_good = ctrl_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &check_inst_byte, endt_us); + check_inst_byte_good = d_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &check_inst_byte, endt_us); } if(!check_inst_byte_good || is_stale) { @@ -2277,7 +2221,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo B32 imm_good = 0; if(read_vaddr + sizeof(imm) <= read_vaddr_opl) { - imm_good = ctrl_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &imm, endt_us); + imm_good = d_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &imm, endt_us); } if(!imm_good || is_stale) { @@ -2306,7 +2250,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo B32 next_inst_byte_good = 0; if(read_vaddr + sizeof(next_inst_byte) <= read_vaddr_opl) { - next_inst_byte_good = ctrl_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &next_inst_byte, endt_us); + next_inst_byte_good = d_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &next_inst_byte, endt_us); } if(next_inst_byte_good) { @@ -2335,7 +2279,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo //- rjf: read next instruction byte U8 inst_byte = 0; - is_good = is_good && ctrl_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &inst_byte, endt_us); + is_good = is_good && d_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &inst_byte, endt_us); is_good = is_good && !is_stale; read_vaddr += 1; @@ -2344,7 +2288,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo if((inst_byte & 0xF0) == 0x40) { rex = inst_byte & 0xF; // rex prefix - is_good = is_good && ctrl_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &inst_byte, endt_us); + is_good = is_good && d_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &inst_byte, endt_us); is_good = is_good && !is_stale; read_vaddr += 1; } @@ -2365,7 +2309,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo // rjf: read value at rsp U64 sp = regs->rsp.u64; U64 value = 0; - if(!ctrl_process_memory_read_struct(process_handle, sp, &is_stale, &value, endt_us) || + if(!d_process_memory_read_struct(process_handle, sp, &is_stale, &value, endt_us) || is_stale) { is_good = 0; @@ -2374,7 +2318,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo // rjf: modify registers PE_UnwindGprRegX64 gpr_reg = (inst_byte - 0x58) + (rex & 1)*8; - REGS_Reg64 *reg = ctrl_unwind_reg_from_pe_gpr_reg__pe_x64(regs, gpr_reg); + REGS_Reg64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, gpr_reg); reg->u64 = value; regs->rsp.u64 = sp + 8; @@ -2390,7 +2334,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo // rjf: read the 4-byte immediate S32 imm = 0; - if(!ctrl_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &imm, endt_us) || + if(!d_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &imm, endt_us) || is_stale) { is_good = 0; @@ -2413,7 +2357,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo // rjf: read the 4-byte immediate S8 imm = 0; - if(!ctrl_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &imm, endt_us) || + if(!d_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &imm, endt_us) || is_stale) { is_good = 0; @@ -2433,7 +2377,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo { // rjf: read source register U8 modrm = 0; - if(!ctrl_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &modrm, endt_us) || + if(!d_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &modrm, endt_us) || is_stale) { is_good = 0; @@ -2441,7 +2385,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo } read_vaddr += 1; PE_UnwindGprRegX64 gpr_reg = (modrm & 7) + (rex & 1)*8; - REGS_Reg64 *reg = ctrl_unwind_reg_from_pe_gpr_reg__pe_x64(regs, gpr_reg); + REGS_Reg64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, gpr_reg); U64 reg_value = reg->u64; // rjf: read immediate @@ -2451,7 +2395,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo if((modrm >> 6) == 1) { S8 imm8 = 0; - if(!ctrl_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &imm8, endt_us) || + if(!d_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &imm8, endt_us) || is_stale) { is_good = 0; @@ -2464,7 +2408,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo // rjf: read 4-byte immediate else { - if(!ctrl_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &imm, endt_us) || + if(!d_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &imm, endt_us) || is_stale) { is_good = 0; @@ -2487,7 +2431,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo // rjf: read new ip U64 sp = regs->rsp.u64; U64 new_ip = 0; - if(!ctrl_process_memory_read_struct(process_handle, sp, &is_stale, &new_ip, endt_us) || + if(!d_process_memory_read_struct(process_handle, sp, &is_stale, &new_ip, endt_us) || is_stale) { is_good = 0; @@ -2496,7 +2440,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo // rjf: read 2-byte immediate & advance stack pointer U16 imm = 0; - if(!ctrl_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &imm, endt_us) || + if(!d_process_memory_read_struct(process_handle, read_vaddr, &is_stale, &imm, endt_us) || is_stale) { is_good = 0; @@ -2519,7 +2463,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo // rjf: read new ip U64 sp = regs->rsp.u64; U64 new_ip = 0; - if(!ctrl_process_memory_read_struct(process_handle, sp, &is_stale, &new_ip, endt_us) || + if(!d_process_memory_read_struct(process_handle, sp, &is_stale, &new_ip, endt_us) || is_stale) { is_good = 0; @@ -2566,7 +2510,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo { U64 unwind_info_off = first_pdata->voff_unwind_info; PE_UnwindInfo unwind_info = {0}; - if(!ctrl_process_memory_read_struct(process_handle, module_base_vaddr+unwind_info_off, &is_stale, &unwind_info, endt_us) || + if(!d_process_memory_read_struct(process_handle, module_base_vaddr+unwind_info_off, &is_stale, &unwind_info, endt_us) || is_stale) { is_good = 0; @@ -2575,7 +2519,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo U64 frame_off_val = PE_UNWIND_INFO_OFF_FROM_FRAME(unwind_info.frame); if(frame_reg_id != 0) { - frame_reg = ctrl_unwind_reg_from_pe_gpr_reg__pe_x64(regs, frame_reg_id); + frame_reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, frame_reg_id); bad_frame_reg_info = (frame_reg == 0); // NOTE(rjf): frame_reg should never be 0 at this point, in valid exe } frame_off = frame_off_val; @@ -2590,11 +2534,11 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo B32 good_unwind_info = 1; U64 unwind_info_off = pdata->voff_unwind_info; PE_UnwindInfo unwind_info = {0}; - good_unwind_info = good_unwind_info && ctrl_process_memory_read_struct(process_handle, module_base_vaddr+unwind_info_off, &is_stale, &unwind_info, endt_us); + good_unwind_info = good_unwind_info && d_process_memory_read_struct(process_handle, module_base_vaddr+unwind_info_off, &is_stale, &unwind_info, endt_us); PE_UnwindCode *unwind_codes = push_array(scratch.arena, PE_UnwindCode, unwind_info.codes_num); - good_unwind_info = good_unwind_info && ctrl_process_memory_read(process_handle, r1u64(module_base_vaddr+unwind_info_off+sizeof(unwind_info), - module_base_vaddr+unwind_info_off+sizeof(unwind_info)+sizeof(PE_UnwindCode)*unwind_info.codes_num), - &is_stale, unwind_codes, endt_us); + good_unwind_info = good_unwind_info && d_process_memory_read(process_handle, r1u64(module_base_vaddr+unwind_info_off+sizeof(unwind_info), + module_base_vaddr+unwind_info_off+sizeof(unwind_info)+sizeof(PE_UnwindCode)*unwind_info.codes_num), + &is_stale, unwind_codes, endt_us); good_unwind_info = good_unwind_info && !is_stale; //- rjf: bad unwind info -> abort @@ -2649,7 +2593,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo // rjf: read value from stack pointer U64 rsp = regs->rsp.u64; U64 value = 0; - if(!ctrl_process_memory_read_struct(process_handle, rsp, &is_stale, &value, endt_us) || + if(!d_process_memory_read_struct(process_handle, rsp, &is_stale, &value, endt_us) || is_stale) { keep_parsing = 0; @@ -2661,7 +2605,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo U64 new_rsp = rsp + 8; // rjf: commit registers - REGS_Reg64 *reg = ctrl_unwind_reg_from_pe_gpr_reg__pe_x64(regs, op_info); + REGS_Reg64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, op_info); reg->u64 = value; regs->rsp.u64 = new_rsp; }break; @@ -2711,7 +2655,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo U64 off = code_ptr[1].u16*8; U64 addr = frame_base + off; U64 value = 0; - if(!ctrl_process_memory_read_struct(process_handle, addr, &is_stale, &value, endt_us) || + if(!d_process_memory_read_struct(process_handle, addr, &is_stale, &value, endt_us) || is_stale) { keep_parsing = 0; @@ -2720,7 +2664,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo } // rjf: commit to register - REGS_Reg64 *reg = ctrl_unwind_reg_from_pe_gpr_reg__pe_x64(regs, op_info); + REGS_Reg64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, op_info); reg->u64 = value; }break; @@ -2730,7 +2674,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo U64 off = code_ptr[1].u16 + ((U32)code_ptr[2].u16 << 16); U64 addr = frame_base + off; U64 value = 0; - if(!ctrl_process_memory_read_struct(process_handle, addr, &is_stale, &value, endt_us) || + if(!d_process_memory_read_struct(process_handle, addr, &is_stale, &value, endt_us) || is_stale) { keep_parsing = 0; @@ -2739,7 +2683,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo } // rjf: commit to register - REGS_Reg64 *reg = ctrl_unwind_reg_from_pe_gpr_reg__pe_x64(regs, op_info); + REGS_Reg64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, op_info); reg->u64 = value; }break; @@ -2761,7 +2705,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo U8 buf[16]; U64 off = code_ptr[1].u16*16; U64 addr = frame_base + off; - if(!ctrl_process_memory_read(process_handle, r1u64(addr, addr+sizeof(buf)), &is_stale, buf, endt_us)) + if(!d_process_memory_read(process_handle, r1u64(addr, addr+sizeof(buf)), &is_stale, buf, endt_us)) { keep_parsing = 0; is_good = 0; @@ -2779,7 +2723,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo U8 buf[16]; U64 off = code_ptr[1].u16 + ((U32)code_ptr[2].u16 << 16); U64 addr = frame_base + off; - if(!ctrl_process_memory_read(process_handle, r1u64(addr, addr+16), &is_stale, buf, endt_us) || + if(!d_process_memory_read(process_handle, r1u64(addr, addr+16), &is_stale, buf, endt_us) || is_stale) { keep_parsing = 0; @@ -2811,7 +2755,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo sp_adj += 8; } U64 ip_value = 0; - if(!ctrl_process_memory_read_struct(process_handle, sp_adj, &is_stale, &ip_value, endt_us) || + if(!d_process_memory_read_struct(process_handle, sp_adj, &is_stale, &ip_value, endt_us) || is_stale) { keep_parsing = 0; @@ -2820,7 +2764,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo } U64 sp_after_ip = sp_adj + 8; U16 ss_value = 0; - if(!ctrl_process_memory_read_struct(process_handle, sp_after_ip, &is_stale, &ss_value, endt_us) || + if(!d_process_memory_read_struct(process_handle, sp_after_ip, &is_stale, &ss_value, endt_us) || is_stale) { keep_parsing = 0; @@ -2829,7 +2773,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo } U64 sp_after_ss = sp_after_ip + 8; U64 rflags_value = 0; - if(!ctrl_process_memory_read_struct(process_handle, sp_after_ss, &is_stale, &rflags_value, endt_us) || + if(!d_process_memory_read_struct(process_handle, sp_after_ss, &is_stale, &rflags_value, endt_us) || is_stale) { keep_parsing = 0; @@ -2838,7 +2782,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo } U64 sp_after_rflags = sp_after_ss + 8; U64 sp_value = 0; - if(!ctrl_process_memory_read_struct(process_handle, sp_after_rflags, &is_stale, &sp_value, endt_us) || + if(!d_process_memory_read_struct(process_handle, sp_after_rflags, &is_stale, &sp_value, endt_us) || is_stale) { keep_parsing = 0; @@ -2872,7 +2816,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo U64 chained_pdata_off = unwind_info_off + sizeof(PE_UnwindInfo) + code_size; last_pdata = pdata; pdata = push_array(scratch.arena, PE_IntelPdata, 1); - if(!ctrl_process_memory_read_struct(process_handle, module_base_vaddr+chained_pdata_off, &is_stale, pdata, endt_us) || + if(!d_process_memory_read_struct(process_handle, module_base_vaddr+chained_pdata_off, &is_stale, pdata, endt_us) || is_stale) { is_good = 0; @@ -2890,7 +2834,7 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo // rjf: read rip from stack pointer U64 rsp = regs->rsp.u64; U64 new_rip = 0; - if(!ctrl_process_memory_read_struct(process_handle, rsp, &is_stale, &new_rip, endt_us) || + if(!d_process_memory_read_struct(process_handle, rsp, &is_stale, &new_rip, endt_us) || is_stale) { is_good = 0; @@ -2918,20 +2862,20 @@ ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 mo //- rjf: abstracted full unwind internal D_Unwind -ctrl_unwind_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle thread, U64 endt_us) +d_unwind_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle thread, U64 endt_us) { ProfBeginFunction(); Temp scratch = scratch_begin(&arena, 1); D_Unwind unwind = { .flags = D_UnwindFlag_Error }; //- rjf: unpack args - D_Entity *thread_entity = ctrl_entity_from_handle(ctx, thread); + D_Entity *thread_entity = d_entity_from_handle(ctx, thread); D_Entity *process_entity = thread_entity->parent; Arch arch = thread_entity->arch; U64 arch_reg_block_size = regs_block_size_from_arch(arch); //- rjf: grab initial register block - void *regs_block = ctrl_reg_block_from_thread(scratch.arena, ctx, thread); + void *regs_block = d_reg_block_from_thread(scratch.arena, ctx, thread); B32 regs_block_good = (arch != Arch_Null && regs_block != 0); //- rjf: loop & unwind @@ -2952,7 +2896,7 @@ ctrl_unwind_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle thread, U64 end } // rip -> module - D_Entity *module_entity = ctrl_module_from_process_vaddr(process_entity, rip); + D_Entity *module_entity = d_module_from_process_vaddr(process_entity, rip); // establish frame context D_FrameUnwindContext frame_ctx = {0}; @@ -2966,7 +2910,7 @@ ctrl_unwind_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle thread, U64 end }break; case OperatingSystem_Linux: { - frame_ctx_result = ctrl_establish_frame_unwind_context__dwarf(arena, process_entity->handle, module_entity->handle, arch, regs_block, endt_us, &frame_ctx); + frame_ctx_result = d_establish_frame_unwind_context__dwarf(arena, process_entity->handle, module_entity->handle, arch, regs_block, endt_us, &frame_ctx); }break; case OperatingSystem_Mac: { @@ -3001,13 +2945,13 @@ ctrl_unwind_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle thread, U64 end default:{}break; case Arch_x64: { - step_result = ctrl_unwind_step__pe_x64(process_entity->handle, module_entity->handle, module_entity->vaddr_range.min, regs_block, endt_us); + step_result = d_unwind_step__pe_x64(process_entity->handle, module_entity->handle, module_entity->vaddr_range.min, regs_block, endt_us); }break; } }break; case OperatingSystem_Linux: { - step_result = ctrl_unwind_step__dwarf(process_entity->handle, arch, regs_block, &frame_ctx, endt_us); + step_result = d_unwind_step__dwarf(process_entity->handle, arch, regs_block, &frame_ctx, endt_us); }break; } @@ -3041,7 +2985,7 @@ ctrl_unwind_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle thread, U64 end //~ rjf: Call Stack Building Functions internal D_CallStack -ctrl_call_stack_from_unwind(Arena *arena, D_Entity *process, D_Unwind *base_unwind) +d_call_stack_from_unwind(Arena *arena, D_Entity *process, D_Unwind *base_unwind) { Temp scratch = scratch_begin(&arena, 1); Access *access = access_open(); @@ -3064,9 +3008,9 @@ ctrl_call_stack_from_unwind(Arena *arena, D_Entity *process, D_Unwind *base_unwi // rjf: unpack D_UnwindFrame *src = &base_unwind->frames.v[base_frame_idx]; U64 rip_vaddr = regs_rip_from_arch_block(arch, src->regs); - D_Entity *module = ctrl_module_from_process_vaddr(process, rip_vaddr); - U64 rip_voff = ctrl_voff_from_vaddr(module, rip_vaddr); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + D_Entity *module = d_module_from_process_vaddr(process, rip_vaddr); + U64 rip_voff = d_voff_from_vaddr(module, rip_vaddr); + DI_Key dbgi_key = d_dbgi_key_from_module(module); RDI_Parsed *rdi = di_rdi_from_key(access, dbgi_key, 0, 0); RDI_Scope *scope = rdi_scope_from_voff(rdi, rip_voff); @@ -3137,7 +3081,7 @@ ctrl_call_stack_from_unwind(Arena *arena, D_Entity *process, D_Unwind *base_unwi } internal D_CallStackFrame * -ctrl_call_stack_frame_from_unwind_and_inline_depth(D_CallStack *call_stack, U64 unwind_count, U64 inline_depth) +d_call_stack_frame_from_unwind_and_inline_depth(D_CallStack *call_stack, U64 unwind_count, U64 inline_depth) { D_CallStackFrame *f = 0; { @@ -3166,7 +3110,7 @@ ctrl_call_stack_frame_from_unwind_and_inline_depth(D_CallStack *call_stack, U64 //~ rjf: Halting All Attached Processes internal void -ctrl_halt(void) +d_halt(void) { dmn_halt(0, 0); } @@ -3177,21 +3121,21 @@ ctrl_halt(void) //- rjf: generation counters internal U64 -ctrl_run_gen(void) +d_run_gen(void) { U64 result = ins_atomic_u64_eval(&d_ctrl_state->run_gen); return result; } internal U64 -ctrl_mem_gen(void) +d_mem_gen(void) { U64 result = ins_atomic_u64_eval(&d_ctrl_state->mem_gen); return result; } internal U64 -ctrl_reg_gen(void) +d_reg_gen(void) { U64 result = ins_atomic_u64_eval(&d_ctrl_state->reg_gen); return result; @@ -3200,13 +3144,13 @@ ctrl_reg_gen(void) //- rjf: name -> register/alias hash tables, for eval internal E_String2NumMap * -ctrl_string2reg_from_arch(Arch arch) +d_string2reg_from_arch(Arch arch) { return &d_ctrl_state->arch_string2reg_tables[arch]; } internal E_String2NumMap * -ctrl_string2alias_from_arch(Arch arch) +d_string2alias_from_arch(Arch arch) { return &d_ctrl_state->arch_string2alias_tables[arch]; } @@ -3217,10 +3161,10 @@ ctrl_string2alias_from_arch(Arch arch) //- rjf: user -> control thread communication internal B32 -ctrl_u2c_push_msgs(D_MsgList *msgs, U64 endt_us) +d_u2c_push_msgs(D_MsgList *msgs, U64 endt_us) { Temp scratch = scratch_begin(0, 0); - String8 msgs_srlzed_baked = ctrl_serialized_string_from_msg_list(scratch.arena, msgs); + String8 msgs_srlzed_baked = d_serialized_string_from_msg_list(scratch.arena, msgs); B32 good = 0; MutexScope(d_ctrl_state->u2c_ring_mutex) for(;;) { @@ -3249,7 +3193,7 @@ ctrl_u2c_push_msgs(D_MsgList *msgs, U64 endt_us) } internal D_MsgList -ctrl_u2c_pop_msgs(Arena *arena) +d_u2c_pop_msgs(Arena *arena) { Temp scratch = scratch_begin(&arena, 1); String8 msgs_srlzed_baked = {0}; @@ -3268,7 +3212,7 @@ ctrl_u2c_pop_msgs(Arena *arena) cond_var_wait(d_ctrl_state->u2c_ring_cv, d_ctrl_state->u2c_ring_mutex, max_U64); } cond_var_broadcast(d_ctrl_state->u2c_ring_cv); - D_MsgList msgs = ctrl_msg_list_from_serialized_string(arena, msgs_srlzed_baked); + D_MsgList msgs = d_msg_list_from_serialized_string(arena, msgs_srlzed_baked); scratch_end(scratch); return msgs; } @@ -3276,18 +3220,18 @@ ctrl_u2c_pop_msgs(Arena *arena) //- rjf: control -> user thread communication internal void -ctrl_c2u_push_events(D_EventList *events) +d_c2u_push_events(D_EventList *events) { - if(events->count != 0) ProfScope("ctrl_c2u_push_events") + if(events->count != 0) ProfScope("d_c2u_push_events") { MutexScopeW(d_ctrl_state->ctrl_thread_entity_ctx_rw_mutex) { - ctrl_entity_store_apply_events(d_ctrl_state->ctrl_thread_entity_store, events); + d_entity_store_apply_events(d_ctrl_state->ctrl_thread_entity_store, events); } for(D_EventNode *n = events->first; n != 0; n = n ->next) { Temp scratch = scratch_begin(0, 0); - String8 event_srlzed = ctrl_serialized_string_from_event(scratch.arena, &n->v, d_ctrl_state->c2u_ring_size-sizeof(U64)); + String8 event_srlzed = d_serialized_string_from_event(scratch.arena, &n->v, d_ctrl_state->c2u_ring_size-sizeof(U64)); MutexScope(d_ctrl_state->c2u_ring_mutex) for(;;) { U64 unconsumed_size = (d_ctrl_state->c2u_ring_write_pos-d_ctrl_state->c2u_ring_read_pos); @@ -3312,7 +3256,7 @@ ctrl_c2u_push_events(D_EventList *events) } internal D_EventList -ctrl_c2u_pop_events(Arena *arena) +d_c2u_pop_events(Arena *arena) { ProfBeginFunction(); Temp scratch = scratch_begin(&arena, 1); @@ -3328,8 +3272,8 @@ ctrl_c2u_pop_events(Arena *arena) event_srlzed.size = size_to_decode; event_srlzed.str = push_array_no_zero(scratch.arena, U8, event_srlzed.size); d_ctrl_state->c2u_ring_read_pos += ring_read(d_ctrl_state->c2u_ring_base, d_ctrl_state->c2u_ring_size, d_ctrl_state->c2u_ring_read_pos, event_srlzed.str, event_srlzed.size); - D_Event *new_event = ctrl_event_list_push(arena, &events); - *new_event = ctrl_event_from_serialized_string(arena, event_srlzed); + D_Event *new_event = d_event_list_push(arena, &events); + *new_event = d_event_from_serialized_string(arena, event_srlzed); } else { @@ -3345,7 +3289,7 @@ ctrl_c2u_pop_events(Arena *arena) //- rjf: entry point internal void -ctrl_thread__entry_point(void *p) +d_ctrl_thread__entry_point(void *p) { ThreadNameF("ctrl_thread"); ProfBeginFunction(); @@ -3360,7 +3304,7 @@ ctrl_thread__entry_point(void *p) log_scope_begin(); //- rjf: get next messages - D_MsgList msgs = ctrl_u2c_pop_msgs(scratch.arena); + D_MsgList msgs = d_u2c_pop_msgs(scratch.arena); //- rjf: process messages DMN_CtrlExclusiveAccessScope @@ -3370,7 +3314,7 @@ ctrl_thread__entry_point(void *p) { D_Msg *msg = &msg_n->v; { - log_infof("user2ctrl_msg:{kind:\"%S\"}\n", ctrl_string_from_msg_kind(msg->kind)); + log_infof("user2ctrl_msg:{kind:\"%S\"}\n", d_string_from_msg_kind(msg->kind)); } //- rjf: reset per-message state @@ -3451,13 +3395,13 @@ ctrl_thread__entry_point(void *p) case D_MsgKind_COUNT:{}break; //- rjf: target operations - case D_MsgKind_Launch: {ctrl_thread__launch (ctrl_ctx, msg);}break; - case D_MsgKind_Attach: {ctrl_thread__attach (ctrl_ctx, msg);}break; - case D_MsgKind_Kill: {ctrl_thread__kill (ctrl_ctx, msg);}break; - case D_MsgKind_KillAll: {ctrl_thread__kill_all (ctrl_ctx, msg);}break; - case D_MsgKind_Detach: {ctrl_thread__detach (ctrl_ctx, msg);}break; - case D_MsgKind_Run: {ctrl_thread__run (ctrl_ctx, msg);}break; - case D_MsgKind_SingleStep: {ctrl_thread__single_step (ctrl_ctx, msg);}break; + case D_MsgKind_Launch: {d_ctrl_thread__launch (ctrl_ctx, msg);}break; + case D_MsgKind_Attach: {d_ctrl_thread__attach (ctrl_ctx, msg);}break; + case D_MsgKind_Kill: {d_ctrl_thread__kill (ctrl_ctx, msg);}break; + case D_MsgKind_KillAll: {d_ctrl_thread__kill_all (ctrl_ctx, msg);}break; + case D_MsgKind_Detach: {d_ctrl_thread__detach (ctrl_ctx, msg);}break; + case D_MsgKind_Run: {d_ctrl_thread__run (ctrl_ctx, msg);}break; + case D_MsgKind_SingleStep: {d_ctrl_thread__single_step (ctrl_ctx, msg);}break; //- rjf: configuration case D_MsgKind_SetUserEntryPoints: @@ -3473,41 +3417,41 @@ ctrl_thread__entry_point(void *p) { D_EntityCtx *entity_ctx = &d_ctrl_state->ctrl_thread_entity_store->ctx; String8 path = msg->path; - D_Entity *module = ctrl_entity_from_handle(entity_ctx, msg->entity); - D_Entity *debug_info_path = ctrl_entity_child_from_kind(module, D_EntityKind_DebugInfoPath); + D_Entity *module = d_entity_from_handle(entity_ctx, msg->entity); + D_Entity *debug_info_path = d_entity_child_from_kind(module, D_EntityKind_DebugInfoPath); DI_Key old_dbgi_key = di_key_from_path_timestamp(debug_info_path->string, debug_info_path->timestamp); di_close(old_dbgi_key, 0); MutexScopeW(d_ctrl_state->ctrl_thread_entity_ctx_rw_mutex) { - ctrl_entity_equip_string(d_ctrl_state->ctrl_thread_entity_store, debug_info_path, path_normalized_from_string(scratch.arena, path)); + d_entity_equip_string(d_ctrl_state->ctrl_thread_entity_store, debug_info_path, path_normalized_from_string(scratch.arena, path)); } U64 new_dbgi_timestamp = os_properties_from_file_path(path).modified; debug_info_path->timestamp = new_dbgi_timestamp; DI_Key new_dbgi_key = di_key_from_path_timestamp(debug_info_path->string, new_dbgi_timestamp); di_open(new_dbgi_key); D_EventList evts = {0}; - D_Event *evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *evt = d_event_list_push(scratch.arena, &evts); evt->kind = D_EventKind_ModuleDebugInfoPathChange; evt->entity = msg->entity; evt->string = path; evt->timestamp = new_dbgi_timestamp; - ctrl_c2u_push_events(&evts); + d_c2u_push_events(&evts); }break; case D_MsgKind_FreezeThread: { D_EventList evts = {0}; - D_Event *evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *evt = d_event_list_push(scratch.arena, &evts); evt->kind = D_EventKind_ThreadFrozen; evt->entity = msg->entity; - ctrl_c2u_push_events(&evts); + d_c2u_push_events(&evts); }break; case D_MsgKind_ThawThread: { D_EventList evts = {0}; - D_Event *evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *evt = d_event_list_push(scratch.arena, &evts); evt->kind = D_EventKind_ThreadThawed; evt->entity = msg->entity; - ctrl_c2u_push_events(&evts); + d_c2u_push_events(&evts); }break; } } @@ -3521,20 +3465,20 @@ ctrl_thread__entry_point(void *p) ProfScope("update thread register cache") { D_EntityCtx *entity_ctx = &d_ctrl_state->ctrl_thread_entity_store->ctx; - D_EntityArray threads = ctrl_entity_array_from_kind(entity_ctx, D_EntityKind_Thread); + D_EntityArray threads = d_entity_array_from_kind(entity_ctx, D_EntityKind_Thread); REGS_RegBlockX64 *blocks = push_array(scratch.arena, REGS_RegBlockX64, threads.count); { for EachIndex(idx, threads.count) { Temp scratch = scratch_begin(0, 0); - ctrl_reg_block_from_thread(scratch.arena, entity_ctx, threads.v[idx]->handle); + d_reg_block_from_thread(scratch.arena, entity_ctx, threads.v[idx]->handle); scratch_end(scratch); } } } //- rjf: gather & output logs - ctrl_thread__end_and_flush_log(); + d_ctrl_thread__end_and_flush_log(); } scratch_end(scratch); @@ -3544,16 +3488,16 @@ ctrl_thread__entry_point(void *p) //- rjf: breakpoint resolution internal void -ctrl_thread__append_resolved_module_user_bp_traps(Arena *arena, D_EvalScope *eval_scope, D_Handle process, D_Handle module, D_BreakpointList *user_bps, DMN_TrapChunkList *traps_out) +d_ctrl_thread__append_resolved_module_user_bp_traps(Arena *arena, D_EvalScope *eval_scope, D_Handle process, D_Handle module, D_BreakpointList *user_bps, DMN_TrapChunkList *traps_out) { if(user_bps->first == 0) { return; } ProfBeginFunction(); Temp scratch = scratch_begin(&arena, 1); Access *access = eval_scope->access; D_EntityCtx *entity_ctx = &d_ctrl_state->ctrl_thread_entity_store->ctx; - D_Entity *module_entity = ctrl_entity_from_handle(entity_ctx, module); - D_Entity *debug_info_path_entity = ctrl_entity_child_from_kind(module_entity, D_EntityKind_DebugInfoPath); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module_entity); + D_Entity *module_entity = d_entity_from_handle(entity_ctx, module); + D_Entity *debug_info_path_entity = d_entity_child_from_kind(module_entity, D_EntityKind_DebugInfoPath); + DI_Key dbgi_key = d_dbgi_key_from_module(module_entity); RDI_Parsed *rdi = di_rdi_from_key(access, dbgi_key, 0, 0); U64 base_vaddr = module_entity->vaddr_range.min; for(D_BreakpointNode *n = user_bps->first; n != 0; n = n->next) @@ -3620,7 +3564,7 @@ ctrl_thread__append_resolved_module_user_bp_traps(Arena *arena, D_EvalScope *eva if(value.u64 != 0 || bp->flags != 0) { DMN_Trap trap = {process.dmn_handle, value.u64, (U64)bp}; - trap.flags = ctrl_dmn_trap_flags_from_user_breakpoint_flags(bp->flags); + trap.flags = d_dmn_trap_flags_from_breakpoint_flags(bp->flags); trap.size = bp->size; dmn_trap_chunk_list_push(arena, traps_out, 256, &trap); } @@ -3631,7 +3575,7 @@ ctrl_thread__append_resolved_module_user_bp_traps(Arena *arena, D_EvalScope *eva } internal void -ctrl_thread__append_resolved_process_user_bp_traps(Arena *arena, D_EvalScope *eval_scope, D_Handle process, D_BreakpointList *user_bps, DMN_TrapChunkList *traps_out) +d_ctrl_thread__append_resolved_process_user_bp_traps(Arena *arena, D_EvalScope *eval_scope, D_Handle process, D_BreakpointList *user_bps, DMN_TrapChunkList *traps_out) { for(D_BreakpointNode *n = user_bps->first; n != 0; n = n->next) { @@ -3643,7 +3587,7 @@ ctrl_thread__append_resolved_process_user_bp_traps(Arena *arena, D_EvalScope *ev if(value.u64 != 0 || bp->flags != 0) { DMN_Trap trap = {process.dmn_handle, value.u64, (U64)bp}; - trap.flags = ctrl_dmn_trap_flags_from_user_breakpoint_flags(bp->flags); + trap.flags = d_dmn_trap_flags_from_breakpoint_flags(bp->flags); trap.size = bp->size; dmn_trap_chunk_list_push(arena, traps_out, 256, &trap); } @@ -3652,7 +3596,7 @@ ctrl_thread__append_resolved_process_user_bp_traps(Arena *arena, D_EvalScope *ev } internal void -ctrl_thread__append_program_defined_bp_traps(Arena *arena, D_Entity *bp, DMN_TrapChunkList *traps_out) +d_ctrl_thread__append_program_defined_bp_traps(Arena *arena, D_Entity *bp, DMN_TrapChunkList *traps_out) { D_Entity *process = bp->parent; DMN_Trap trap = @@ -3660,7 +3604,7 @@ ctrl_thread__append_program_defined_bp_traps(Arena *arena, D_Entity *bp, DMN_Tra .process = process->handle.dmn_handle, .vaddr = bp->vaddr_range.min, .id = ((U64)bp|bit64), - .flags = ctrl_dmn_trap_flags_from_user_breakpoint_flags(bp->bp_flags), + .flags = d_dmn_trap_flags_from_breakpoint_flags(bp->bp_flags), .size = (U32)dim_1u64(bp->vaddr_range), }; dmn_trap_chunk_list_push(arena, traps_out, 256, &trap); @@ -3676,7 +3620,7 @@ MACHINE_OP_MEM_READ(ctrl_dmn_mem_read) } internal void -ctrl_thread__module_open(D_Handle process, D_Handle module, Rng1U64 vaddr_range, String8 path, Rng1U64 elf_phdr_vrange, U64 elf_phdr_entsize) +d_ctrl_thread__module_open(D_Handle process, D_Handle module, Rng1U64 vaddr_range, String8 path, Rng1U64 elf_phdr_vrange, U64 elf_phdr_entsize) { Temp scratch = scratch_begin(0,0); @@ -3975,7 +3919,9 @@ ctrl_thread__module_open(D_Handle process, D_Handle module, Rng1U64 vaddr_range, } // parse .eh_frame_hdr - Arch arch = ctrl_arch_from_process_handle(process); + D_EntityCtx *entity_ctx = &d_ctrl_state->ctrl_thread_entity_store->ctx; + D_Entity *process_entity = d_entity_from_handle(entity_ctx, process); + Arch arch = process_entity->arch; eh_ptr_ctx.pc_vaddr = eh_frame_hdr_vrange.min; eh_ptr_ctx.data_vaddr = eh_frame_hdr_vrange.min; eh_frame_hdr = eh_parse_frame_hdr(eh_frame_hdr_data, byte_size_from_arch(arch), &eh_ptr_ctx); @@ -4045,7 +3991,7 @@ ctrl_thread__module_open(D_Handle process, D_Handle module, Rng1U64 vaddr_range, //- rjf: insert info into cache // { - U64 hash = ctrl_hash_from_handle(module); + U64 hash = d_hash_from_handle(module); U64 slot_idx = hash%d_ctrl_state->module_image_info_cache.slots_count; U64 stripe_idx = slot_idx%d_ctrl_state->module_image_info_cache.stripes_count; D_ModuleImageInfoCacheSlot *slot = &d_ctrl_state->module_image_info_cache.slots[slot_idx]; @@ -4055,7 +4001,7 @@ ctrl_thread__module_open(D_Handle process, D_Handle module, Rng1U64 vaddr_range, D_ModuleImageInfoCacheNode *node = 0; for EachNode(n, D_ModuleImageInfoCacheNode, slot->first) { - if(ctrl_handle_match(n->module, module)) + if(d_handle_match(n->module, module)) { node = n; break; @@ -4085,14 +4031,14 @@ ctrl_thread__module_open(D_Handle process, D_Handle module, Rng1U64 vaddr_range, } internal void -ctrl_thread__module_close(D_Handle process, D_Handle module, Rng1U64 vaddr_range) +d_ctrl_thread__module_close(D_Handle process, D_Handle module, Rng1U64 vaddr_range) { ////////////////////////////// //- rjf: evict module image info from cache // U64 raddbg_attached_marker_voff = 0; { - U64 hash = ctrl_hash_from_handle(module); + U64 hash = d_hash_from_handle(module); U64 slot_idx = hash%d_ctrl_state->module_image_info_cache.slots_count; U64 stripe_idx = slot_idx%d_ctrl_state->module_image_info_cache.stripes_count; D_ModuleImageInfoCacheSlot *slot = &d_ctrl_state->module_image_info_cache.slots[slot_idx]; @@ -4102,7 +4048,7 @@ ctrl_thread__module_close(D_Handle process, D_Handle module, Rng1U64 vaddr_range D_ModuleImageInfoCacheNode *node = 0; for(D_ModuleImageInfoCacheNode *n = slot->first; n != 0; n = n->next) { - if(ctrl_handle_match(n->module, module)) + if(d_handle_match(n->module, module)) { node = n; break; @@ -4130,7 +4076,7 @@ ctrl_thread__module_close(D_Handle process, D_Handle module, Rng1U64 vaddr_range //- rjf: attached process running/event gathering internal DMN_Event * -ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN_RunCtrls *run_ctrls, D_Spoof *spoof) +d_ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN_RunCtrls *run_ctrls, D_Spoof *spoof) { ProfBeginFunction(); DMN_Event *event = push_array(arena, DMN_Event, 1); @@ -4184,7 +4130,7 @@ ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN { for(D_ExceptionCodeKind k = (D_ExceptionCodeKind)0; k < D_ExceptionCodeKind_COUNT; k = (D_ExceptionCodeKind)(k+1)) { - if(ctrl_exception_code_kind_code_table[k] == ev->code) + if(d_exception_code_kind_code_table[k] == ev->code) { code_kind = k; break; @@ -4208,7 +4154,7 @@ ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN (spoof == 0 || ev->instruction_pointer != spoof->new_ip_value)) { Access *access = access_open(); - D_Entity *process = ctrl_entity_from_handle(entity_ctx, ctrl_handle_make(D_MachineID_Local, ev->process)); + D_Entity *process = d_entity_from_handle(entity_ctx, d_handle_make(D_MachineID_Local, ev->process)); D_Entity *module = &d_entity_nil; for(D_Entity *child = process->first; child != &d_entity_nil; child = child->next) { @@ -4223,7 +4169,7 @@ ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN // rjf: determine base address of asan shadow space U64 asan_shadow_base_vaddr = 0; B32 asan_shadow_variable_exists_but_is_zero = 0; - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + DI_Key dbgi_key = d_dbgi_key_from_module(module); RDI_Parsed *rdi = di_rdi_from_key(access, dbgi_key, 1, max_U64); RDI_NameMap *unparsed_map = rdi_element_from_name_idx(rdi, NameMaps, RDI_NameMapKind_GlobalVariables); { @@ -4298,7 +4244,7 @@ ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN U64 size_of_spoof = 0; if(do_spoof) ProfScope("prep spoof") { - D_Entity *spoof_process = ctrl_entity_from_handle(entity_ctx, ctrl_handle_make(D_MachineID_Local, spoof->process)); + D_Entity *spoof_process = d_entity_from_handle(entity_ctx, d_handle_make(D_MachineID_Local, spoof->process)); Arch arch = spoof_process->arch; size_of_spoof = bit_size_from_arch(arch)/8; dmn_process_read(spoof_process->handle.dmn_handle, r1u64(spoof->vaddr, spoof->vaddr+size_of_spoof), &spoof_old_ip_value); @@ -4368,7 +4314,7 @@ ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN // simply been sent other debug events first if(spoof != 0) { - D_Entity *thread = ctrl_entity_from_handle(entity_ctx, ctrl_handle_make(D_MachineID_Local, spoof->thread)); + D_Entity *thread = d_entity_from_handle(entity_ctx, d_handle_make(D_MachineID_Local, spoof->thread)); Arch arch = thread->arch; void *regs_block = push_array(scratch.arena, U8, regs_block_size_from_arch(arch)); dmn_thread_read_reg_block(spoof->thread, regs_block); @@ -4376,7 +4322,7 @@ ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN if(spoof_thread_rip == spoof->new_ip_value) { regs_arch_block_write_rip(arch, regs_block, spoof_old_ip_value); - ctrl_thread_write_reg_block(ctrl_handle_make(D_MachineID_Local, spoof->thread), regs_block); + d_thread_write_reg_block(d_handle_make(D_MachineID_Local, spoof->thread), regs_block); } } @@ -4387,23 +4333,23 @@ ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN default:{}break; case DMN_EventKind_CreateProcess: { - D_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *out_evt = d_event_list_push(scratch.arena, &evts); out_evt->kind = D_EventKind_NewProc; out_evt->msg_id = msg->msg_id; - out_evt->entity = ctrl_handle_make(D_MachineID_Local, event->process); + out_evt->entity = d_handle_make(D_MachineID_Local, event->process); out_evt->arch = event->arch; out_evt->entity_id = event->code; - out_evt->tls_model = ctrl_dynamic_linker_type_from_dmn(event->tls_model); + out_evt->tls_model = d_dynamic_linker_type_from_dmn(event->tls_model); out_evt->target_os = OperatingSystem_CURRENT; // TODO: operating system of the remote target machine d_ctrl_state->process_counter += 1; }break; case DMN_EventKind_CreateThread: { - D_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *out_evt = d_event_list_push(scratch.arena, &evts); out_evt->kind = D_EventKind_NewThread; out_evt->msg_id = msg->msg_id; - out_evt->entity = ctrl_handle_make(D_MachineID_Local, event->thread); - out_evt->parent = ctrl_handle_make(D_MachineID_Local, event->process); + out_evt->entity = d_handle_make(D_MachineID_Local, event->thread); + out_evt->parent = d_handle_make(D_MachineID_Local, event->process); out_evt->arch = event->arch; out_evt->entity_id = event->code; out_evt->stack_base = dmn_stack_base_vaddr_from_thread(event->thread); @@ -4413,12 +4359,12 @@ ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN }break; case DMN_EventKind_LoadModule: { - D_Handle process_handle = ctrl_handle_make(D_MachineID_Local, event->process); - D_Handle module_handle = ctrl_handle_make(D_MachineID_Local, event->module); - D_Event *out_evt1 = ctrl_event_list_push(scratch.arena, &evts); + D_Handle process_handle = d_handle_make(D_MachineID_Local, event->process); + D_Handle module_handle = d_handle_make(D_MachineID_Local, event->module); + D_Event *out_evt1 = d_event_list_push(scratch.arena, &evts); String8 module_path = path_normalized_from_string(scratch.arena, event->string); U64 exe_timestamp = os_properties_from_file_path(module_path).modified; - ctrl_thread__module_open(process_handle, module_handle, r1u64(event->address, event->address+event->size), module_path, event->elf_phdr_vrange, event->elf_phdr_entsize); + d_ctrl_thread__module_open(process_handle, module_handle, r1u64(event->address, event->address+event->size), module_path, event->elf_phdr_vrange, event->elf_phdr_entsize); out_evt1->kind = D_EventKind_NewModule; out_evt1->msg_id = msg->msg_id; out_evt1->entity = module_handle; @@ -4431,8 +4377,8 @@ ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN out_evt1->string = module_path; out_evt1->tls_index = event->tls_index; out_evt1->tls_offset = event->tls_offset; - D_Event *out_evt2 = ctrl_event_list_push(scratch.arena, &evts); - String8 initial_debug_info_path = ctrl_initial_debug_info_path_from_module(scratch.arena, module_handle); + D_Event *out_evt2 = d_event_list_push(scratch.arena, &evts); + String8 initial_debug_info_path = d_initial_debug_info_path_from_module(scratch.arena, module_handle); U64 debug_info_timestamp = os_properties_from_file_path(initial_debug_info_path).modified; out_evt2->kind = D_EventKind_ModuleDebugInfoPathChange; out_evt2->msg_id = msg->msg_id; @@ -4445,35 +4391,35 @@ ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN }break; case DMN_EventKind_ExitProcess: { - D_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *out_evt = d_event_list_push(scratch.arena, &evts); out_evt->kind = D_EventKind_EndProc; out_evt->msg_id = msg->msg_id; - out_evt->entity = ctrl_handle_make(D_MachineID_Local, event->process); + out_evt->entity = d_handle_make(D_MachineID_Local, event->process); out_evt->u64_code = event->code; d_ctrl_state->process_counter -= 1; }break; case DMN_EventKind_ExitThread: { - D_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *out_evt = d_event_list_push(scratch.arena, &evts); out_evt->kind = D_EventKind_EndThread; out_evt->msg_id = msg->msg_id; - out_evt->entity = ctrl_handle_make(D_MachineID_Local, event->thread); + out_evt->entity = d_handle_make(D_MachineID_Local, event->thread); out_evt->entity_id = event->code; }break; case DMN_EventKind_UnloadModule: ProfScope("unload module %.*s", str8_varg(event->string)) { - D_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); - D_Handle module_handle = ctrl_handle_make(D_MachineID_Local, event->module); - D_Entity *module_ent = ctrl_entity_from_handle(entity_ctx, module_handle); - D_Entity *process_ent = ctrl_process_from_entity(module_ent); + D_Event *out_evt = d_event_list_push(scratch.arena, &evts); + D_Handle module_handle = d_handle_make(D_MachineID_Local, event->module); + D_Entity *module_ent = d_entity_from_handle(entity_ctx, module_handle); + D_Entity *process_ent = d_process_from_entity(module_ent); String8 module_path = event->string; - ctrl_thread__module_close(process_ent->handle, module_handle, module_ent->vaddr_range); + d_ctrl_thread__module_close(process_ent->handle, module_handle, module_ent->vaddr_range); out_evt->kind = D_EventKind_EndModule; out_evt->msg_id = msg->msg_id; out_evt->entity = module_handle; out_evt->string = module_path; - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module_ent); + DI_Key dbgi_key = d_dbgi_key_from_module(module_ent); di_close(dbgi_key, 0); }break; case DMN_EventKind_DebugString: @@ -4481,64 +4427,64 @@ ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN U64 num_strings = (event->string.size + d_ctrl_state->c2u_ring_max_string_size-1) / d_ctrl_state->c2u_ring_max_string_size; for(U64 string_idx = 0; string_idx < num_strings; string_idx += 1) { - D_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *out_evt = d_event_list_push(scratch.arena, &evts); out_evt->kind = D_EventKind_DebugString; out_evt->msg_id = msg->msg_id; - out_evt->entity = ctrl_handle_make(D_MachineID_Local, event->thread); - out_evt->parent = ctrl_handle_make(D_MachineID_Local, event->process); + out_evt->entity = d_handle_make(D_MachineID_Local, event->thread); + out_evt->parent = d_handle_make(D_MachineID_Local, event->process); out_evt->string = str8_substr(event->string, r1u64(string_idx*d_ctrl_state->c2u_ring_max_string_size, (string_idx+1)*d_ctrl_state->c2u_ring_max_string_size)); } }break; case DMN_EventKind_SetThreadName: { - D_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *out_evt = d_event_list_push(scratch.arena, &evts); out_evt->kind = D_EventKind_ThreadName; out_evt->msg_id = msg->msg_id; - out_evt->entity = ctrl_handle_make(D_MachineID_Local, event->thread); - out_evt->parent = ctrl_handle_make(D_MachineID_Local, event->process); + out_evt->entity = d_handle_make(D_MachineID_Local, event->thread); + out_evt->parent = d_handle_make(D_MachineID_Local, event->process); out_evt->string = event->string; out_evt->entity_id = event->code; }break; case DMN_EventKind_SetThreadColor: { - D_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *out_evt = d_event_list_push(scratch.arena, &evts); out_evt->kind = D_EventKind_ThreadColor; out_evt->msg_id = msg->msg_id; - out_evt->entity = ctrl_handle_make(D_MachineID_Local, event->thread); - out_evt->parent = ctrl_handle_make(D_MachineID_Local, event->process); + out_evt->entity = d_handle_make(D_MachineID_Local, event->thread); + out_evt->parent = d_handle_make(D_MachineID_Local, event->process); out_evt->entity_id = event->code; out_evt->rgba = event->user_data; }break; case DMN_EventKind_SetVAddrRangeNote: { - D_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *out_evt = d_event_list_push(scratch.arena, &evts); out_evt->kind = D_EventKind_SetVAddrRangeNote; - out_evt->parent = ctrl_handle_make(D_MachineID_Local, event->process); + out_evt->parent = d_handle_make(D_MachineID_Local, event->process); out_evt->msg_id = msg->msg_id; out_evt->vaddr_rng = r1u64(event->address, event->address + event->size); out_evt->string = event->string; }break; case DMN_EventKind_SetBreakpoint: { - D_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *out_evt = d_event_list_push(scratch.arena, &evts); out_evt->kind = D_EventKind_SetBreakpoint; - out_evt->entity = ctrl_handle_make(D_MachineID_Local, event->thread); - out_evt->parent = ctrl_handle_make(D_MachineID_Local, event->process); + out_evt->entity = d_handle_make(D_MachineID_Local, event->thread); + out_evt->parent = d_handle_make(D_MachineID_Local, event->process); out_evt->vaddr_rng = r1u64(event->address, event->address+event->size); - out_evt->bp_flags = ctrl_user_breakpoint_flags_from_dmn_trap_flags(event->flags); + out_evt->bp_flags = d_breakpoint_flags_from_dmn_trap_flags(event->flags); }break; case DMN_EventKind_UnsetBreakpoint: { // TODO(rjf): this needs to be reflected in the resolved trap list too!!!!!!!! - D_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *out_evt = d_event_list_push(scratch.arena, &evts); out_evt->kind = D_EventKind_UnsetBreakpoint; - out_evt->entity = ctrl_handle_make(D_MachineID_Local, event->thread); - out_evt->parent = ctrl_handle_make(D_MachineID_Local, event->process); + out_evt->entity = d_handle_make(D_MachineID_Local, event->thread); + out_evt->parent = d_handle_make(D_MachineID_Local, event->process); out_evt->vaddr_rng = r1u64(event->address, event->address+event->size); - out_evt->bp_flags = ctrl_user_breakpoint_flags_from_dmn_trap_flags(event->flags); + out_evt->bp_flags = d_breakpoint_flags_from_dmn_trap_flags(event->flags); }break; } - ctrl_c2u_push_events(&evts); + d_c2u_push_events(&evts); //- rjf: if this is the first process in a session, clear the debug directory // cache state @@ -4563,7 +4509,7 @@ ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN //- rjf: eval helpers internal U64 -ctrl_eval_space_gen(E_Space space) +d_ctrl_eval_space_gen(E_Space space) { U64 result = 0; switch(space.kind) @@ -4571,14 +4517,14 @@ ctrl_eval_space_gen(E_Space space) default:{}break; case D_EvalSpaceKind_Entity: { - result = ctrl_mem_gen(); + result = d_mem_gen(); }break; } return result; } internal B32 -ctrl_eval_space_read(E_Space space, void *out, Rng1U64 range) +d_ctrl_eval_space_read(E_Space space, void *out, Rng1U64 range) { B32 result = 0; switch(space.kind) @@ -4602,7 +4548,7 @@ ctrl_eval_space_read(E_Space space, void *out, Rng1U64 range) Temp scratch = scratch_begin(0, 0); D_EntityCtx *entity_ctx = &d_ctrl_state->ctrl_thread_entity_store->ctx; U64 regs_size = regs_block_size_from_arch(entity->arch); - void *regs = ctrl_reg_block_from_thread(scratch.arena, entity_ctx, entity->handle); + void *regs = d_reg_block_from_thread(scratch.arena, entity_ctx, entity->handle); Rng1U64 legal_range = r1u64(0, regs_size); Rng1U64 read_range = intersect_1u64(legal_range, range); U64 read_size = dim_1u64(read_range); @@ -4619,7 +4565,7 @@ ctrl_eval_space_read(E_Space space, void *out, Rng1U64 range) //- rjf: control thread eval scopes internal D_EvalScope * -ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Entity *thread) +d_ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Entity *thread) { ProfBeginFunction(); D_EntityCtx *entity_ctx = &d_ctrl_state->ctrl_thread_entity_store->ctx; @@ -4631,9 +4577,9 @@ ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Entity // Arch arch = thread->arch; U64 thread_rip_vaddr = dmn_rip_from_thread(thread->handle.dmn_handle); - D_Entity *process = ctrl_process_from_entity(thread); - D_Entity *module = ctrl_module_from_process_vaddr(process, thread_rip_vaddr); - U64 thread_rip_voff = ctrl_voff_from_vaddr(module, thread_rip_vaddr); + D_Entity *process = d_process_from_entity(thread); + D_Entity *module = d_module_from_process_vaddr(process, thread_rip_vaddr); + U64 thread_rip_voff = d_voff_from_vaddr(module, thread_rip_vaddr); ////////////////////////////// //- rjf: gather evaluation debug infos & modules @@ -4664,7 +4610,7 @@ ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Entity mod = mod->next) { if(mod->kind != D_EntityKind_Module) { continue; } - DI_Key dbgi_key = ctrl_dbgi_key_from_module(mod); + DI_Key dbgi_key = d_dbgi_key_from_module(mod); //- rjf: try to obtain this module's RDI RDI_Parsed *rdi = di_rdi_from_key(scope->access, dbgi_key, 0, 0); @@ -4681,13 +4627,13 @@ ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Entity else if(rdi == &rdi_parsed_nil) ProfScope("determine if RDI is necessary") { // rjf: find cached result - U64 hash = ctrl_hash_from_handle(mod->handle); + U64 hash = d_hash_from_handle(mod->handle); U64 slot_idx = hash%d_ctrl_state->module_req_cache_slots_count; D_ModuleReqCacheNode *slot = d_ctrl_state->module_req_cache_slots[slot_idx]; D_ModuleReqCacheNode *node = 0; for(D_ModuleReqCacheNode *n = slot; n != 0; n = n->next) { - if(ctrl_handle_match(n->module, mod->handle)) + if(d_handle_match(n->module, mod->handle)) { node = n; break; @@ -4703,7 +4649,7 @@ ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Entity // rjf: not cached -> compute & store else ProfScope("cache miss") { - D_Entity *debug_info_path = ctrl_entity_child_from_kind(mod, D_EntityKind_DebugInfoPath); + D_Entity *debug_info_path = d_entity_child_from_kind(mod, D_EntityKind_DebugInfoPath); OS_Handle file = os_file_open(OS_AccessFlag_Read|OS_AccessFlag_ShareRead, debug_info_path->string); ProfScope("determine if %.*s is necessary", str8_varg(debug_info_path->string)) { @@ -4814,8 +4760,8 @@ ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Entity ctx->primary_module = eval_modules_primary; //- rjf: fill space hooks - ctx->space_gen = ctrl_eval_space_gen; - ctx->space_read = ctrl_eval_space_read; + ctx->space_gen = d_ctrl_eval_space_gen; + ctx->space_read = d_ctrl_eval_space_read; } e_select_base_ctx(&scope->base_ctx); @@ -4824,8 +4770,8 @@ ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Entity // { E_IRCtx *ctx = &scope->ir_ctx; - ctx->regs_map = ctrl_string2reg_from_arch(arch); - ctx->reg_alias_map = ctrl_string2alias_from_arch(arch); + ctx->regs_map = d_string2reg_from_arch(arch); + ctx->reg_alias_map = d_string2alias_from_arch(arch); ctx->locals_map = e_push_locals_map_from_rdi_voff(arena, eval_dbg_infos_primary->rdi, thread_rip_voff); ctx->member_map = e_push_member_map_from_rdi_voff(arena, eval_dbg_infos_primary->rdi, thread_rip_voff); ctx->macro_map = push_array(arena, E_String2ExprMap, 1); @@ -4859,7 +4805,7 @@ ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Entity } internal void -ctrl_thread__eval_scope_end(D_EvalScope *scope) +d_ctrl_thread__eval_scope_end(D_EvalScope *scope) { access_close(scope->access); } @@ -4867,7 +4813,7 @@ ctrl_thread__eval_scope_end(D_EvalScope *scope) //- rjf: log flusher internal void -ctrl_thread__end_and_flush_log(void) +d_ctrl_thread__end_and_flush_log(void) { Temp scratch = scratch_begin(0, 0); LogScopeResult log = log_scope_end(scratch.arena); @@ -4875,10 +4821,10 @@ ctrl_thread__end_and_flush_log(void) if(log.strings[LogMsgKind_UserError].size != 0) { D_EventList evts = {0}; - D_Event *evt = ctrl_event_list_push(scratch.arena, &evts); + D_Event *evt = d_event_list_push(scratch.arena, &evts); evt->kind = D_EventKind_Error; evt->string = log.strings[LogMsgKind_UserError]; - ctrl_c2u_push_events(&evts); + d_c2u_push_events(&evts); } scratch_end(scratch); } @@ -4886,7 +4832,7 @@ ctrl_thread__end_and_flush_log(void) //- rjf: msg kind implementations internal void -ctrl_thread__launch(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) +d_ctrl_thread__launch(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { Temp scratch = scratch_begin(0, 0); @@ -4942,8 +4888,8 @@ ctrl_thread__launch(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) for(String8Node *n = msg->entry_points.first; n != 0; n = n->next) { String8 string = n->string; - D_Entity *entry = ctrl_entity_alloc(entity_ctx_rw_store, entity_ctx_rw_store->ctx.root, D_EntityKind_EntryPoint, Arch_Null, ctrl_handle_zero(), (U64)id); - ctrl_entity_equip_string(entity_ctx_rw_store, entry, string); + D_Entity *entry = d_entity_alloc(entity_ctx_rw_store, entity_ctx_rw_store->ctx.root, D_EntityKind_EntryPoint, Arch_Null, d_handle_zero(), (U64)id); + d_entity_equip_string(entity_ctx_rw_store, entry, string); } } @@ -4951,7 +4897,7 @@ ctrl_thread__launch(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) } internal void -ctrl_thread__attach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) +d_ctrl_thread__attach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); @@ -4968,7 +4914,7 @@ ctrl_thread__attach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) run_ctrls.run_entities_are_processes = 1; for(B32 done = 0; done == 0;) { - DMN_Event *event = ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, 0); + DMN_Event *event = d_ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, 0); switch(event->kind) { default:{}break; @@ -4992,12 +4938,12 @@ ctrl_thread__attach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) //- rjf: record stop { D_EventList evts = {0}; - D_Event *event = ctrl_event_list_push(scratch.arena, &evts); + D_Event *event = d_event_list_push(scratch.arena, &evts); event->kind = D_EventKind_Stopped; event->cause = D_EventCause_Finished; event->msg_id = msg->msg_id; event->entity_id = !!attach_successful * msg->entity_id; - ctrl_c2u_push_events(&evts); + d_c2u_push_events(&evts); } scratch_end(scratch); @@ -5005,7 +4951,7 @@ ctrl_thread__attach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) } internal void -ctrl_thread__kill(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) +d_ctrl_thread__kill(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); @@ -5026,7 +4972,7 @@ ctrl_thread__kill(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) run_ctrls.run_entity_count = 1; for(B32 done = 0; done == 0;) { - DMN_Event *event = ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, 0); + DMN_Event *event = d_ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, 0); switch(event->kind) { default:{}break; @@ -5044,7 +4990,7 @@ ctrl_thread__kill(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) //- rjf: record stop { D_EventList evts = {0}; - D_Event *event = ctrl_event_list_push(scratch.arena, &evts); + D_Event *event = d_event_list_push(scratch.arena, &evts); event->kind = D_EventKind_Stopped; event->cause = cause; event->msg_id = msg->msg_id; @@ -5052,7 +4998,7 @@ ctrl_thread__kill(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { event->entity = msg->entity; } - ctrl_c2u_push_events(&evts); + d_c2u_push_events(&evts); } scratch_end(scratch); @@ -5060,7 +5006,7 @@ ctrl_thread__kill(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) } internal void -ctrl_thread__kill_all(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) +d_ctrl_thread__kill_all(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); @@ -5068,7 +5014,7 @@ ctrl_thread__kill_all(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) D_EntityCtx *entity_ctx = &d_ctrl_state->ctrl_thread_entity_store->ctx; //- rjf: gather all currently existing processes - D_EntityArray initial_processes = ctrl_entity_array_from_kind(entity_ctx, D_EntityKind_Process); + D_EntityArray initial_processes = d_entity_array_from_kind(entity_ctx, D_EntityKind_Process); typedef struct Task Task; struct Task { @@ -5105,7 +5051,7 @@ ctrl_thread__kill_all(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) } // rjf: get next event - DMN_Event *event = ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, 0); + DMN_Event *event = d_ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, 0); // rjf: process event switch(event->kind) @@ -5113,7 +5059,7 @@ ctrl_thread__kill_all(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) default:{}break; case DMN_EventKind_CreateProcess: { - D_Entity *new_process = ctrl_entity_from_handle(entity_ctx, ctrl_handle_make(D_MachineID_Local, event->process)); + D_Entity *new_process = d_entity_from_handle(entity_ctx, d_handle_make(D_MachineID_Local, event->process)); Task *t = push_array(scratch.arena, Task, 1); t->process = new_process; DLLPushBack(first_task, last_task, t); @@ -5123,7 +5069,7 @@ ctrl_thread__kill_all(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) } // rjf: end if all processes are gone - D_EntityArray processes = ctrl_entity_array_from_kind(entity_ctx, D_EntityKind_Process); + D_EntityArray processes = d_entity_array_from_kind(entity_ctx, D_EntityKind_Process); if(processes.count == 0) { done = 1; @@ -5134,11 +5080,11 @@ ctrl_thread__kill_all(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) //- rjf: record stop { D_EventList evts = {0}; - D_Event *event = ctrl_event_list_push(scratch.arena, &evts); + D_Event *event = d_event_list_push(scratch.arena, &evts); event->kind = D_EventKind_Stopped; event->cause = cause; event->msg_id = msg->msg_id; - ctrl_c2u_push_events(&evts); + d_c2u_push_events(&evts); } scratch_end(scratch); @@ -5146,7 +5092,7 @@ ctrl_thread__kill_all(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) } internal void -ctrl_thread__detach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) +d_ctrl_thread__detach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); @@ -5165,7 +5111,7 @@ ctrl_thread__detach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) run_ctrls.run_entity_count = 1; for(B32 done = 0; done == 0;) { - DMN_Event *event = ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, 0); + DMN_Event *event = d_ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, 0); if(event->kind == DMN_EventKind_ExitProcess && dmn_handle_match(event->process, process)) { done = 1; @@ -5180,7 +5126,7 @@ ctrl_thread__detach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) //- rjf: record stop { D_EventList evts = {0}; - D_Event *event = ctrl_event_list_push(scratch.arena, &evts); + D_Event *event = d_event_list_push(scratch.arena, &evts); event->kind = D_EventKind_Stopped; event->cause = D_EventCause_Finished; event->msg_id = msg->msg_id; @@ -5188,7 +5134,7 @@ ctrl_thread__detach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { event->entity = msg->entity; } - ctrl_c2u_push_events(&evts); + d_c2u_push_events(&evts); } scratch_end(scratch); @@ -5196,7 +5142,7 @@ ctrl_thread__detach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) } internal void -ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) +d_ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); @@ -5205,17 +5151,17 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) D_EntityCtx *entity_ctx = &d_ctrl_state->ctrl_thread_entity_store->ctx; D_Handle target_thread = msg->entity; D_Handle target_process = msg->parent; - D_Entity *target_process_entity = ctrl_entity_from_handle(entity_ctx, target_process); + D_Entity *target_process_entity = d_entity_from_handle(entity_ctx, target_process); U64 spoof_ip_vaddr = 911; - log_infof("ctrl_thread__run:\n{\n"); + log_infof("d_ctrl_thread__run:\n{\n"); ////////////////////////////// //- rjf: gather all initial breakpoints // DMN_TrapChunkList user_traps = {0}; { - D_Entity *thread = ctrl_entity_from_handle(entity_ctx, target_thread); - D_EvalScope *eval_scope = ctrl_thread__eval_scope_begin(scratch.arena, &msg->user_bps, thread); + D_Entity *thread = d_entity_from_handle(entity_ctx, target_thread); + D_EvalScope *eval_scope = d_ctrl_thread__eval_scope_begin(scratch.arena, &msg->user_bps, thread); for(D_Entity *machine = entity_ctx->root->first; machine != &d_entity_nil; machine = machine->next) @@ -5229,21 +5175,21 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) for(D_Entity *module = process->first; module != &d_entity_nil; module = module->next) { if(module->kind != D_EntityKind_Module) { continue; } - ctrl_thread__append_resolved_module_user_bp_traps(scratch.arena, eval_scope, process->handle, module->handle, &msg->user_bps, &user_traps); + d_ctrl_thread__append_resolved_module_user_bp_traps(scratch.arena, eval_scope, process->handle, module->handle, &msg->user_bps, &user_traps); } // rjf: push process-declared breakpoins for(D_Entity *bp = process->first; bp != &d_entity_nil; bp = bp->next) { if(bp->kind != D_EntityKind_Breakpoint) { continue; } - ctrl_thread__append_program_defined_bp_traps(scratch.arena, bp, &user_traps); + d_ctrl_thread__append_program_defined_bp_traps(scratch.arena, bp, &user_traps); } // rjf: push virtual-address user breakpoints per-process - ctrl_thread__append_resolved_process_user_bp_traps(scratch.arena, eval_scope, process->handle, &msg->user_bps, &user_traps); + d_ctrl_thread__append_resolved_process_user_bp_traps(scratch.arena, eval_scope, process->handle, &msg->user_bps, &user_traps); } } - ctrl_thread__eval_scope_end(eval_scope); + d_ctrl_thread__eval_scope_end(eval_scope); } ////////////////////////////// @@ -5346,7 +5292,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { run_ctrls.single_step_thread = thread; } - DMN_Event *event = ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, 0); + DMN_Event *event = d_ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, 0); thread_post_rip = dmn_rip_from_thread(thread); switch(event->kind) { @@ -5391,7 +5337,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { if(thread->is_frozen) { - ctrl_entity_list_push(scratch.arena, &frozen_threads, thread); + d_entity_list_push(scratch.arena, &frozen_threads, thread); } } } @@ -5424,9 +5370,9 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) if(stop_event == 0) { D_EventList evts = {0}; - D_Event *event = ctrl_event_list_push(scratch.arena, &evts); + D_Event *event = d_event_list_push(scratch.arena, &evts); event->kind = D_EventKind_Started; - ctrl_c2u_push_events(&evts); + d_c2u_push_events(&evts); } ////////////////////////////// @@ -5483,7 +5429,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) //- rjf: get next run-related event // log_infof("get_next_event:\n{\n"); - DMN_Event *event = ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, run_spoof); + DMN_Event *event = d_ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, run_spoof); log_infof("}\n\n"); ////////////////////////// @@ -5491,7 +5437,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) // B32 launch_done_first_module = 0; B32 hard_stop = 0; - D_EventCause hard_stop_cause = ctrl_event_cause_from_dmn_event_kind(event->kind); + D_EventCause hard_stop_cause = d_event_cause_from_dmn_event_kind(event->kind); B32 use_stepping_logic = 0; switch(event->kind) { @@ -5512,10 +5458,10 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) }break; case DMN_EventKind_CreateProcess: { - D_EvalScope *eval_scope = ctrl_thread__eval_scope_begin(scratch.arena, &msg->user_bps, &d_entity_nil); + D_EvalScope *eval_scope = d_ctrl_thread__eval_scope_begin(scratch.arena, &msg->user_bps, &d_entity_nil); { DMN_TrapChunkList new_traps = {0}; - ctrl_thread__append_resolved_process_user_bp_traps(scratch.arena, eval_scope, ctrl_handle_make(D_MachineID_Local, event->process), &msg->user_bps, &new_traps); + d_ctrl_thread__append_resolved_process_user_bp_traps(scratch.arena, eval_scope, d_handle_make(D_MachineID_Local, event->process), &msg->user_bps, &new_traps); log_infof("step_rule: create_process -> resolve traps\n"); log_infof("new_traps:\n{\n"); for(DMN_TrapChunkNode *n = new_traps.first; n != 0; n = n->next) @@ -5530,15 +5476,15 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) dmn_trap_chunk_list_concat_shallow_copy(scratch.arena, &joined_traps, &new_traps); dmn_trap_chunk_list_concat_shallow_copy(scratch.arena, &user_traps, &new_traps); } - ctrl_thread__eval_scope_end(eval_scope); + d_ctrl_thread__eval_scope_end(eval_scope); }break; case DMN_EventKind_LoadModule: { - D_Entity *thread = ctrl_entity_from_handle(entity_ctx, ctrl_handle_make(D_MachineID_Local, event->thread)); - D_EvalScope *eval_scope = ctrl_thread__eval_scope_begin(scratch.arena, &msg->user_bps, thread); + D_Entity *thread = d_entity_from_handle(entity_ctx, d_handle_make(D_MachineID_Local, event->thread)); + D_EvalScope *eval_scope = d_ctrl_thread__eval_scope_begin(scratch.arena, &msg->user_bps, thread); { DMN_TrapChunkList new_traps = {0}; - ctrl_thread__append_resolved_module_user_bp_traps(scratch.arena, eval_scope, ctrl_handle_make(D_MachineID_Local, event->process), ctrl_handle_make(D_MachineID_Local, event->module), &msg->user_bps, &new_traps); + d_ctrl_thread__append_resolved_module_user_bp_traps(scratch.arena, eval_scope, d_handle_make(D_MachineID_Local, event->process), d_handle_make(D_MachineID_Local, event->module), &msg->user_bps, &new_traps); log_infof("step_rule: load_module -> resolve traps\n"); log_infof("new_traps:\n{\n"); for(DMN_TrapChunkNode *n = new_traps.first; n != 0; n = n->next) @@ -5553,19 +5499,19 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) dmn_trap_chunk_list_concat_shallow_copy(scratch.arena, &joined_traps, &new_traps); dmn_trap_chunk_list_concat_shallow_copy(scratch.arena, &user_traps, &new_traps); } - ctrl_thread__eval_scope_end(eval_scope); + d_ctrl_thread__eval_scope_end(eval_scope); }break; case DMN_EventKind_SetBreakpoint: { D_Entity *bp = &d_entity_nil; { - D_Entity *process = ctrl_entity_from_handle(entity_ctx, ctrl_handle_make(D_MachineID_Local, event->process)); + D_Entity *process = d_entity_from_handle(entity_ctx, d_handle_make(D_MachineID_Local, event->process)); for(D_Entity *child = process->first; child != &d_entity_nil; child = child->next) { if(child->kind == D_EntityKind_Breakpoint && child->vaddr_range.min == event->address && child->vaddr_range.max == event->address + event->size && - child->bp_flags == ctrl_user_breakpoint_flags_from_dmn_trap_flags(event->flags)) + child->bp_flags == d_breakpoint_flags_from_dmn_trap_flags(event->flags)) { bp = child; break; @@ -5575,7 +5521,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) if(bp != &d_entity_nil) { DMN_TrapChunkList new_traps = {0}; - ctrl_thread__append_program_defined_bp_traps(scratch.arena, bp, &new_traps); + d_ctrl_thread__append_program_defined_bp_traps(scratch.arena, bp, &new_traps); dmn_trap_chunk_list_concat_shallow_copy(scratch.arena, &joined_traps, &new_traps); dmn_trap_chunk_list_concat_shallow_copy(scratch.arena, &user_traps, &new_traps); } @@ -5591,10 +5537,10 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) Access *access = access_open(); //- rjf: unpack process/module info - D_Entity *process = ctrl_entity_from_handle(entity_ctx, ctrl_handle_make(D_MachineID_Local, event->process)); - D_Entity *module = ctrl_entity_child_from_kind(process, D_EntityKind_Module); + D_Entity *process = d_entity_from_handle(entity_ctx, d_handle_make(D_MachineID_Local, event->process)); + D_Entity *module = d_entity_child_from_kind(process, D_EntityKind_Module); U64 module_base_vaddr = module->vaddr_range.min; - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + DI_Key dbgi_key = d_dbgi_key_from_module(module); RDI_Parsed *rdi = di_rdi_from_key(access, dbgi_key, 1, max_U64); RDI_NameMap *unparsed_map = rdi_element_from_name_idx(rdi, NameMaps, RDI_NameMapKind_Procedures); RDI_ParsedNameMap map = {0}; @@ -5631,7 +5577,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) //- rjf: add traps for module-baked entry points, if specified if(!entries_found) { - String8 raddbg_data = ctrl_raddbg_data_from_module(scratch.arena, module->handle); + String8 raddbg_data = d_raddbg_data_from_module(scratch.arena, module->handle); U8 split_char = 0; String8List raddbg_data_text_parts = str8_split(scratch.arena, raddbg_data, &split_char, 1, 0); for(String8Node *text_n = raddbg_data_text_parts.first; text_n != 0; text_n = text_n->next) @@ -5757,7 +5703,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) //- rjf: add trap for PE header entry if(!entries_found) { - U64 voff = ctrl_entry_point_voff_from_module(module->handle); + U64 voff = d_entry_point_voff_from_module(module->handle); if(voff != 0) { DMN_Trap trap = {process->handle.dmn_handle, module_base_vaddr + voff}; @@ -5814,11 +5760,11 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) ////////////////////////// //- rjf: unpack info about thread attached to event // - D_Entity *thread = ctrl_entity_from_handle(entity_ctx, ctrl_handle_make(D_MachineID_Local, event->thread)); - D_Entity *process = ctrl_entity_from_handle(entity_ctx, ctrl_handle_make(D_MachineID_Local, event->process)); + D_Entity *thread = d_entity_from_handle(entity_ctx, d_handle_make(D_MachineID_Local, event->thread)); + D_Entity *process = d_entity_from_handle(entity_ctx, d_handle_make(D_MachineID_Local, event->process)); Arch arch = thread->arch; U64 thread_rip_vaddr = dmn_rip_from_thread(event->thread); - D_Entity *module = ctrl_module_from_process_vaddr(process, thread_rip_vaddr); + D_Entity *module = d_module_from_process_vaddr(process, thread_rip_vaddr); ////////////////////////// //- rjf: extract module-dependent info @@ -5929,7 +5875,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) // rjf: evaluate hit stop conditions if(conditions.node_count != 0) ProfScope("evaluate hit stop conditions") { - D_EvalScope *eval_scope = ctrl_thread__eval_scope_begin(temp.arena, &msg->user_bps, thread); + D_EvalScope *eval_scope = d_ctrl_thread__eval_scope_begin(temp.arena, &msg->user_bps, thread); for(String8Node *condition_n = conditions.first; condition_n != 0; condition_n = condition_n->next) { // rjf: evaluate @@ -5954,7 +5900,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) break; } } - ctrl_thread__eval_scope_end(eval_scope); + d_ctrl_thread__eval_scope_end(eval_scope); } // rjf: gather trap net hits @@ -5998,7 +5944,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { single_step_ctrls.single_step_thread = thread; } - DMN_Event *event = ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &single_step_ctrls, 0); + DMN_Event *event = d_ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &single_step_ctrls, 0); thread_post_rip = dmn_rip_from_thread(thread); switch(event->kind) { @@ -6011,12 +5957,12 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) cond_bp_single_step_stop = 1; single_step_done = 1; use_stepping_logic = 0; - cond_bp_single_step_stop_cause = ctrl_event_cause_from_dmn_event_kind(event->kind); + cond_bp_single_step_stop_cause = d_event_cause_from_dmn_event_kind(event->kind); }break; case DMN_EventKind_SingleStep: { single_step_done = dmn_handle_match(event->thread, thread); - cond_bp_single_step_stop_cause = ctrl_event_cause_from_dmn_event_kind(event->kind); + cond_bp_single_step_stop_cause = d_event_cause_from_dmn_event_kind(event->kind); }break; } } @@ -6086,7 +6032,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { single_step_ctrls.single_step_thread = target_thread.dmn_handle; } - DMN_Event *event = ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &single_step_ctrls, 0); + DMN_Event *event = d_ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &single_step_ctrls, 0); thread_post_rip = dmn_rip_from_thread(target_thread.dmn_handle); switch(event->kind) { @@ -6100,12 +6046,12 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) single_step_done = 1; use_stepping_logic = 0; use_trap_net_logic = 0; - single_step_stop_cause = ctrl_event_cause_from_dmn_event_kind(event->kind); + single_step_stop_cause = d_event_cause_from_dmn_event_kind(event->kind); }break; case DMN_EventKind_SingleStep: { single_step_done = dmn_handle_match(event->thread, target_thread.dmn_handle); - single_step_stop_cause = ctrl_event_cause_from_dmn_event_kind(event->kind); + single_step_stop_cause = d_event_cause_from_dmn_event_kind(event->kind); }break; } } @@ -6183,7 +6129,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { single_step_ctrls.single_step_thread = thread; } - DMN_Event *event = ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &single_step_ctrls, 0); + DMN_Event *event = d_ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &single_step_ctrls, 0); thread_post_rip = dmn_rip_from_thread(thread); switch(event->kind) { @@ -6195,12 +6141,12 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { step_past_trap_net_stop = 1; single_step_done = 1; - step_past_trap_net_stop_cause = ctrl_event_cause_from_dmn_event_kind(event->kind); + step_past_trap_net_stop_cause = d_event_cause_from_dmn_event_kind(event->kind); }break; case DMN_EventKind_SingleStep: { single_step_done = dmn_handle_match(event->thread, thread); - step_past_trap_net_stop_cause = ctrl_event_cause_from_dmn_event_kind(event->kind); + step_past_trap_net_stop_cause = d_event_cause_from_dmn_event_kind(event->kind); }break; } } @@ -6256,13 +6202,13 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) if(stop_event != 0) { D_EventList evts = {0}; - D_Event *event = ctrl_event_list_push(scratch.arena, &evts); + D_Event *event = d_event_list_push(scratch.arena, &evts); event->kind = D_EventKind_Stopped; event->cause = stop_cause; - event->entity = ctrl_handle_make(D_MachineID_Local, stop_event->thread); - event->parent = ctrl_handle_make(D_MachineID_Local, stop_event->process); + event->entity = d_handle_make(D_MachineID_Local, stop_event->thread); + event->parent = d_handle_make(D_MachineID_Local, stop_event->process); event->exception_code = stop_event->code; - event->exception_kind = ctrl_exception_kind_from_dmn(stop_event->exception_kind); + event->exception_kind = d_exception_kind_from_dmn(stop_event->exception_kind); event->vaddr_rng = r1u64(stop_event->address, stop_event->address); event->rip_vaddr = stop_event->instruction_pointer; if(stop_cause == D_EventCause_UserBreakpoint && stop_event->user_data != 0) @@ -6273,7 +6219,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) event->u64_code = user_bp->id; } } - ctrl_c2u_push_events(&evts); + d_c2u_push_events(&evts); } log_infof("}\n\n"); @@ -6282,7 +6228,7 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) } internal void -ctrl_thread__single_step(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) +d_ctrl_thread__single_step(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); @@ -6290,9 +6236,9 @@ ctrl_thread__single_step(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) //- rjf: record start { D_EventList evts = {0}; - D_Event *event = ctrl_event_list_push(scratch.arena, &evts); + D_Event *event = d_event_list_push(scratch.arena, &evts); event->kind = D_EventKind_Started; - ctrl_c2u_push_events(&evts); + d_c2u_push_events(&evts); } //- rjf: single step @@ -6314,7 +6260,7 @@ ctrl_thread__single_step(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) { run_ctrls.single_step_thread = msg->entity.dmn_handle; } - DMN_Event *event = ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, 0); + DMN_Event *event = d_ctrl_thread__next_dmn_event(scratch.arena, ctrl_ctx, msg, &run_ctrls, 0); thread_post_rip = dmn_rip_from_thread(msg->entity.dmn_handle); switch(event->kind) { @@ -6337,19 +6283,19 @@ ctrl_thread__single_step(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) //- rjf: record stop { D_EventList evts = {0}; - D_Event *event = ctrl_event_list_push(scratch.arena, &evts); + D_Event *event = d_event_list_push(scratch.arena, &evts); event->kind = D_EventKind_Stopped; event->cause = stop_cause; if(stop_event != 0) { - event->entity = ctrl_handle_make(D_MachineID_Local, stop_event->thread); - event->parent = ctrl_handle_make(D_MachineID_Local, stop_event->process); + event->entity = d_handle_make(D_MachineID_Local, stop_event->thread); + event->parent = d_handle_make(D_MachineID_Local, stop_event->process); event->exception_code = stop_event->code; - event->exception_kind = ctrl_exception_kind_from_dmn(stop_event->exception_kind); + event->exception_kind = d_exception_kind_from_dmn(stop_event->exception_kind); event->vaddr_rng = r1u64(stop_event->address, stop_event->address); event->rip_vaddr = stop_event->instruction_pointer; } - ctrl_c2u_push_events(&evts); + d_c2u_push_events(&evts); } scratch_end(scratch); @@ -6360,7 +6306,7 @@ ctrl_thread__single_step(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) //~ rjf: Process Memory Artifact Cache Hooks / Lookups internal AC_Artifact -ctrl_memory_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out) +d_memory_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out) { AC_Artifact artifact = {0}; { @@ -6388,7 +6334,7 @@ ctrl_memory_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 Arena *range_arena = 0; void *range_base = 0; U64 zero_terminated_size = 0; - U64 pre_read_mem_gen = ctrl_mem_gen(); + U64 pre_read_mem_gen = d_mem_gen(); B32 pre_run_state = ins_atomic_u64_eval(&d_ctrl_state->ctrl_thread_run_state); if(range_size != 0) { @@ -6457,7 +6403,7 @@ ctrl_memory_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 } } } - U64 post_read_mem_gen = ctrl_mem_gen(); + U64 post_read_mem_gen = d_mem_gen(); B32 post_run_state = ins_atomic_u64_eval(&d_ctrl_state->ctrl_thread_run_state); //- rjf: form content key @@ -6513,7 +6459,7 @@ ctrl_memory_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 } internal void -ctrl_memory_artifact_destroy(AC_Artifact artifact) +d_memory_artifact_destroy(AC_Artifact artifact) { C_Key key = {0}; MemoryCopyStruct(&key, &artifact); @@ -6521,7 +6467,7 @@ ctrl_memory_artifact_destroy(AC_Artifact artifact) } internal C_Key -ctrl_key_from_process_vaddr_range(D_Handle process, Rng1U64 vaddr_range, B32 zero_terminated, B32 wait_for_fresh, U64 endt_us, B32 *out_is_stale) +d_key_from_process_vaddr_range(D_Handle process, Rng1U64 vaddr_range, B32 zero_terminated, B32 wait_for_fresh, U64 endt_us, B32 *out_is_stale) { ProfBeginFunction(); #pragma pack(push, 1) @@ -6534,9 +6480,9 @@ ctrl_key_from_process_vaddr_range(D_Handle process, Rng1U64 vaddr_range, B32 zer #pragma pack(pop) String8 key = str8_struct(&key_data); Access *access = access_open(); - AC_Artifact artifact = ac_artifact_from_key(access, key, ctrl_memory_artifact_create, ctrl_memory_artifact_destroy, endt_us, + AC_Artifact artifact = ac_artifact_from_key(access, key, d_memory_artifact_create, d_memory_artifact_destroy, endt_us, .flags = AC_Flag_HighPriority | (wait_for_fresh ? AC_Flag_WaitForFresh : 0), - .gen = ctrl_mem_gen(), + .gen = d_mem_gen(), .slots_count = 2048, .stale_out = out_is_stale, .evict_threshold_us = 10000000); @@ -6550,7 +6496,7 @@ ctrl_key_from_process_vaddr_range(D_Handle process, Rng1U64 vaddr_range, B32 zer //- rjf: process memory reading helpers internal D_ProcessMemorySlice -ctrl_process_memory_slice_from_vaddr_range(Arena *arena, D_Handle process, Rng1U64 range, B32 wait_for_fresh, U64 endt_us) +d_process_memory_slice_from_vaddr_range(Arena *arena, D_Handle process, Rng1U64 range, B32 wait_for_fresh, U64 endt_us) { ProfBeginFunction(); D_ProcessMemorySlice result = {0}; @@ -6576,7 +6522,7 @@ ctrl_process_memory_slice_from_vaddr_range(Arena *arena, D_Handle process, Rng1U { U64 page_base_vaddr = page_range.min + page_idx*page_size; B32 page_is_stale = 0; - C_Key page_key = ctrl_key_from_process_vaddr_range(process, r1u64(page_base_vaddr, page_base_vaddr+page_size), 0, wait_for_fresh, endt_us, &page_is_stale); + C_Key page_key = d_key_from_process_vaddr_range(process, r1u64(page_base_vaddr, page_base_vaddr+page_size), 0, wait_for_fresh, endt_us, &page_is_stale); U128 page_hash = c_hash_from_key(page_key, 0); U128 page_last_hash = c_hash_from_key(page_key, 1); result.stale = (result.stale || page_is_stale); @@ -6693,11 +6639,11 @@ ctrl_process_memory_slice_from_vaddr_range(Arena *arena, D_Handle process, Rng1U } internal B32 -ctrl_process_memory_read(D_Handle process, Rng1U64 range, B32 *is_stale_out, void *out, U64 endt_us) +d_process_memory_read(D_Handle process, Rng1U64 range, B32 *is_stale_out, void *out, U64 endt_us) { Temp scratch = scratch_begin(0, 0); U64 needed_size = dim_1u64(range); - D_ProcessMemorySlice slice = ctrl_process_memory_slice_from_vaddr_range(scratch.arena, process, range, 0, endt_us); + D_ProcessMemorySlice slice = d_process_memory_slice_from_vaddr_range(scratch.arena, process, range, 0, endt_us); B32 good = (slice.data.size >= needed_size && !slice.any_byte_bad); if(good) { @@ -6714,7 +6660,7 @@ ctrl_process_memory_read(D_Handle process, Rng1U64 range, B32 *is_stale_out, voi //- rjf: process memory writing internal B32 -ctrl_process_write(D_Handle process, Rng1U64 range, void *src) +d_process_write(D_Handle process, Rng1U64 range, void *src) { ProfBeginFunction(); B32 result = dmn_process_write(process.dmn_handle, range, src); @@ -6736,7 +6682,7 @@ ctrl_process_write(D_Handle process, Rng1U64 range, void *src) for EachInRange(page_idx, page_range) { Temp scratch = scratch_begin(0, 0); - D_ProcessMemorySlice slice = ctrl_process_memory_slice_from_vaddr_range(scratch.arena, process, r1u64(page_idx*page_size, (page_idx+1)*page_size), 1, endt_us); + D_ProcessMemorySlice slice = d_process_memory_slice_from_vaddr_range(scratch.arena, process, r1u64(page_idx*page_size, (page_idx+1)*page_size), 1, endt_us); scratch_end(scratch); if(!slice.stale || os_now_microseconds() >= endt_us) { @@ -6753,7 +6699,7 @@ ctrl_process_write(D_Handle process, Rng1U64 range, void *src) //~ rjf: Call Stack Artifact Cache Hooks / Lookups internal AC_Artifact -ctrl_call_stack_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out) +d_call_stack_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out) { AC_Artifact artifact = {0}; { @@ -6776,17 +6722,17 @@ ctrl_call_stack_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, MemoryCopyArray(dst_ctx->entity_kind_counts, src_ctx->entity_kind_counts); MemoryCopyArray(dst_ctx->entity_kind_alloc_gens, src_ctx->entity_kind_alloc_gens); } - D_Entity *src_thread = ctrl_entity_from_handle(src_ctx, thread_handle); - D_Entity *src_process = ctrl_process_from_entity(src_thread); + D_Entity *src_thread = d_entity_from_handle(src_ctx, thread_handle); + D_Entity *src_process = d_process_from_entity(src_thread); { D_EntityRec rec = {0}; D_Entity *dst_parent = &d_entity_nil; for(D_Entity *src_e = src_process; src_e != &d_entity_nil; src_e = rec.next) { - rec = ctrl_entity_rec_depth_first_pre(src_e, src_process); + rec = d_entity_rec_depth_first_pre(src_e, src_process); // rjf: determine if we need this entity - B32 need_this_entity = (ctrl_handle_match(thread_handle, src_e->handle) || src_e->kind == D_EntityKind_Module || src_e->kind == D_EntityKind_Process || src_e->kind == D_EntityKind_DebugInfoPath); + B32 need_this_entity = (d_handle_match(thread_handle, src_e->handle) || src_e->kind == D_EntityKind_Module || src_e->kind == D_EntityKind_Process || src_e->kind == D_EntityKind_DebugInfoPath); // rjf: copy this entity D_Entity *dst_e = &d_entity_nil; @@ -6826,13 +6772,13 @@ ctrl_call_stack_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, // rjf: insert into hash map if(dst_e != &d_entity_nil) { - U64 hash = ctrl_hash_from_handle(dst_e->handle); + U64 hash = d_hash_from_handle(dst_e->handle); U64 slot_idx = hash%dst_ctx->hash_slots_count; D_EntityHashSlot *slot = &dst_ctx->hash_slots[slot_idx]; D_EntityHashNode *node = 0; for(D_EntityHashNode *n = slot->first; n != 0; n = n->next) { - if(ctrl_handle_match(n->entity->handle, dst_e->handle)) + if(d_handle_match(n->entity->handle, dst_e->handle)) { node = n; break; @@ -6861,7 +6807,7 @@ ctrl_call_stack_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, } //- rjf: compute call stack - D_Entity *thread = ctrl_entity_from_handle(entity_ctx, thread_handle); + D_Entity *thread = d_entity_from_handle(entity_ctx, thread_handle); B32 good = 1; B32 retry = 0; Arena *arena = 0; @@ -6871,27 +6817,27 @@ ctrl_call_stack_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, good = 0; arena = arena_alloc(); call_stack = push_array(arena, D_CallStack, 1); - D_Entity *process = ctrl_process_from_entity(thread); + D_Entity *process = d_process_from_entity(thread); U64 pre_reg_gen = 0; U64 post_reg_gen = 0; U64 pre_mem_gen = 0; U64 post_mem_gen = 0; D_Unwind unwind = {0}; { - pre_reg_gen = ctrl_reg_gen(); - pre_mem_gen = ctrl_mem_gen(); - unwind = ctrl_unwind_from_thread(arena, entity_ctx, thread_handle, os_now_microseconds()+5000); + pre_reg_gen = d_reg_gen(); + pre_mem_gen = d_mem_gen(); + unwind = d_unwind_from_thread(arena, entity_ctx, thread_handle, os_now_microseconds()+5000); if(!(unwind.flags & D_UnwindFlag_Stale)) { good = 1; - call_stack[0] = ctrl_call_stack_from_unwind(arena, process, &unwind); + call_stack[0] = d_call_stack_from_unwind(arena, process, &unwind); } if(unwind.flags & D_UnwindFlag_Stale) { retry = 1; } - post_reg_gen = ctrl_reg_gen(); - post_mem_gen = ctrl_mem_gen(); + post_reg_gen = d_reg_gen(); + post_mem_gen = d_mem_gen(); } if(pre_reg_gen != post_reg_gen || pre_mem_gen != post_mem_gen) { @@ -6926,7 +6872,7 @@ ctrl_call_stack_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, } internal void -ctrl_call_stack_artifact_destroy(AC_Artifact artifact) +d_call_stack_artifact_destroy(AC_Artifact artifact) { Arena *arena = (Arena *)artifact.u64[0]; if(arena != 0) @@ -6936,12 +6882,12 @@ ctrl_call_stack_artifact_destroy(AC_Artifact artifact) } internal D_CallStack -ctrl_call_stack_from_thread(Access *access, D_Handle thread_handle, B32 high_priority, U64 endt_us) +d_call_stack_from_thread(Access *access, D_Handle thread_handle, B32 high_priority, U64 endt_us) { D_CallStack result = {0}; { - AC_Artifact artifact = ac_artifact_from_key(access, str8_struct(&thread_handle), ctrl_call_stack_artifact_create, ctrl_call_stack_artifact_destroy, endt_us, - .gen = ctrl_mem_gen() + ctrl_reg_gen(), + AC_Artifact artifact = ac_artifact_from_key(access, str8_struct(&thread_handle), d_call_stack_artifact_create, d_call_stack_artifact_destroy, endt_us, + .gen = d_mem_gen() + d_reg_gen(), .evict_threshold_us = 10000000, .flags = high_priority ? AC_Flag_HighPriority : 0); if(artifact.u64[1] != 0) @@ -6956,7 +6902,7 @@ ctrl_call_stack_from_thread(Access *access, D_Handle thread_handle, B32 high_pri //~ rjf: Call Stack Tree Artifact Cache Hooks / Lookups internal AC_Artifact -ctrl_call_stack_tree_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out) +d_call_stack_tree_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out) { Temp scratch = scratch_begin(0, 0); Access *access = access_open(); @@ -6969,7 +6915,7 @@ ctrl_call_stack_tree_artifact_create(String8 key, B32 *cancel_signal, B32 *retry MutexScopeR(d_ctrl_state->ctrl_thread_entity_ctx_rw_mutex) { D_EntityCtx *ctx = &d_ctrl_state->ctrl_thread_entity_store->ctx; - D_EntityArray thread_entities = ctrl_entity_array_from_kind(ctx, D_EntityKind_Thread); + D_EntityArray thread_entities = d_entity_array_from_kind(ctx, D_EntityKind_Thread); threads_count = thread_entities.count; threads = push_array(scratch.arena, D_Handle, threads_count); threads_processes = push_array(scratch.arena, D_Handle, threads_count); @@ -6984,13 +6930,13 @@ ctrl_call_stack_tree_artifact_create(String8 key, B32 *cancel_signal, B32 *retry //- rjf: gather all callstacks B32 stale = 0; - U64 pre_mem_gen = ctrl_mem_gen(); - U64 pre_reg_gen = ctrl_reg_gen(); + U64 pre_mem_gen = d_mem_gen(); + U64 pre_reg_gen = d_reg_gen(); D_CallStack *call_stacks = push_array(scratch.arena, D_CallStack, threads_count); { for EachIndex(idx, threads_count) { - call_stacks[idx] = ctrl_call_stack_from_thread(access, threads[idx], 0, 0); + call_stacks[idx] = d_call_stack_from_thread(access, threads[idx], 0, 0); if(call_stacks[idx].concrete_frames_count == 0) { stale = 1; @@ -6998,8 +6944,8 @@ ctrl_call_stack_tree_artifact_create(String8 key, B32 *cancel_signal, B32 *retry } } } - U64 post_mem_gen = ctrl_mem_gen(); - U64 post_reg_gen = ctrl_reg_gen(); + U64 post_mem_gen = d_mem_gen(); + U64 post_reg_gen = d_reg_gen(); stale = (stale || pre_mem_gen != post_mem_gen || pre_reg_gen != post_reg_gen); //- rjf: build call stack tree @@ -7030,7 +6976,7 @@ ctrl_call_stack_tree_artifact_create(String8 key, B32 *cancel_signal, B32 *retry D_CallStackTreeNode *next_node = &d_call_stack_tree_node_nil; for(D_CallStackTreeNode *child = thread_node->first; child != &d_call_stack_tree_node_nil; child = child->next) { - if(ctrl_handle_match(child->process, process) && child->vaddr == vaddr && child->depth == depth) + if(d_handle_match(child->process, process) && child->vaddr == vaddr && child->depth == depth) { next_node = child; break; @@ -7049,7 +6995,7 @@ ctrl_call_stack_tree_artifact_create(String8 key, B32 *cancel_signal, B32 *retry } thread_node = next_node; } - ctrl_handle_list_push(arena, &thread_node->threads, &thread); + d_handle_list_push(arena, &thread_node->threads, &thread); for(D_CallStackTreeNode *n = thread_node; n != &d_call_stack_tree_node_nil; n = n->parent) { n->all_descendant_threads_count += 1; @@ -7076,7 +7022,7 @@ ctrl_call_stack_tree_artifact_create(String8 key, B32 *cancel_signal, B32 *retry } internal void -ctrl_call_stack_tree_artifact_destroy(AC_Artifact artifact) +d_call_stack_tree_artifact_destroy(AC_Artifact artifact) { Arena *arena = (Arena *)artifact.u64[0]; if(arena != 0) @@ -7086,11 +7032,11 @@ ctrl_call_stack_tree_artifact_destroy(AC_Artifact artifact) } internal D_CallStackTree -ctrl_call_stack_tree(Access *access, U64 endt_us) +d_call_stack_tree(Access *access, U64 endt_us) { D_CallStackTree result = {&d_call_stack_tree_node_nil}; { - AC_Artifact artifact = ac_artifact_from_key(access, str8_zero(), ctrl_call_stack_tree_artifact_create, ctrl_call_stack_tree_artifact_destroy, endt_us); + AC_Artifact artifact = ac_artifact_from_key(access, str8_zero(), d_call_stack_tree_artifact_create, d_call_stack_tree_artifact_destroy, endt_us); if(artifact.u64[1] != 0) { MemoryCopyStruct(&result, (D_CallStackTree *)artifact.u64[1]); diff --git a/src/dbg_engine/dbg_engine_ctrl.h b/src/dbg_engine/dbg_engine_ctrl.h index 97479724..8a5cc7ea 100644 --- a/src/dbg_engine/dbg_engine_ctrl.h +++ b/src/dbg_engine/dbg_engine_ctrl.h @@ -349,267 +349,258 @@ thread_static D_EntityCtxLookupAccel *d_entity_ctx_lookup_accel = 0; //////////////////////////////// //~ rjf: Basic Type Functions -internal U64 ctrl_hash_from_string(String8 string); -internal U64 ctrl_hash_from_handle(D_Handle handle); -internal D_EventCause ctrl_event_cause_from_dmn_event_kind(DMN_EventKind event_kind); -internal D_ExceptionKind ctrl_exception_kind_from_dmn(DMN_ExceptionKind kind); -internal D_TlsModel ctrl_dynamic_linker_type_from_dmn(DMN_TlsModel type); -internal String8 ctrl_string_from_event_kind(D_EventKind kind); -internal String8 ctrl_string_from_msg_kind(D_MsgKind kind); -internal D_EntityKind ctrl_entity_kind_from_string(String8 string); -internal DMN_TrapFlags ctrl_dmn_trap_flags_from_user_breakpoint_flags(D_BreakpointFlags flags); -internal D_BreakpointFlags ctrl_user_breakpoint_flags_from_dmn_trap_flags(DMN_TrapFlags flags); +internal U64 d_hash_from_handle(D_Handle handle); +internal D_EventCause d_event_cause_from_dmn_event_kind(DMN_EventKind event_kind); +internal D_ExceptionKind d_exception_kind_from_dmn(DMN_ExceptionKind kind); +internal D_TlsModel d_dynamic_linker_type_from_dmn(DMN_TlsModel type); +internal String8 d_string_from_event_kind(D_EventKind kind); +internal String8 d_string_from_msg_kind(D_MsgKind kind); +internal D_EntityKind d_entity_kind_from_string(String8 string); +internal DMN_TrapFlags d_dmn_trap_flags_from_breakpoint_flags(D_BreakpointFlags flags); +internal D_BreakpointFlags d_breakpoint_flags_from_dmn_trap_flags(DMN_TrapFlags flags); //////////////////////////////// //~ rjf: Handle Type Functions -internal D_Handle ctrl_handle_zero(void); -internal D_Handle ctrl_handle_make(D_MachineID machine_id, DMN_Handle dmn_handle); -internal B32 ctrl_handle_match(D_Handle a, D_Handle b); -internal void ctrl_handle_list_push(Arena *arena, D_HandleList *list, D_Handle *pair); -internal D_HandleList ctrl_handle_list_copy(Arena *arena, D_HandleList *src); -internal D_HandleArray ctrl_handle_array_from_list(Arena *arena, D_HandleList *src); -internal String8 ctrl_string_from_handle(Arena *arena, D_Handle handle); -internal D_Handle ctrl_handle_from_string(String8 string); +internal D_Handle d_handle_zero(void); +internal D_Handle d_handle_make(D_MachineID machine_id, DMN_Handle dmn_handle); +internal B32 d_handle_match(D_Handle a, D_Handle b); +internal void d_handle_list_push(Arena *arena, D_HandleList *list, D_Handle *pair); +internal D_HandleList d_handle_list_copy(Arena *arena, D_HandleList *src); +internal D_HandleArray d_handle_array_from_list(Arena *arena, D_HandleList *src); +internal String8 d_string_from_handle(Arena *arena, D_Handle handle); +internal D_Handle d_handle_from_string(String8 string); //////////////////////////////// //~ rjf: Trap Type Functions -internal void ctrl_trap_list_push(Arena *arena, D_TrapList *list, D_Trap *trap); -internal D_TrapList ctrl_trap_list_copy(Arena *arena, D_TrapList *src); +internal void d_trap_list_push(Arena *arena, D_TrapList *list, D_Trap *trap); +internal D_TrapList d_trap_list_copy(Arena *arena, D_TrapList *src); //////////////////////////////// //~ rjf: User Breakpoint Type Functions -internal void ctrl_user_breakpoint_list_push(Arena *arena, D_BreakpointList *list, D_Breakpoint *bp); -internal D_BreakpointList ctrl_user_breakpoint_list_copy(Arena *arena, D_BreakpointList *src); +internal void d_breakpoint_list_push(Arena *arena, D_BreakpointList *list, D_Breakpoint *bp); +internal D_BreakpointList d_breakpoint_list_copy(Arena *arena, D_BreakpointList *src); //////////////////////////////// //~ rjf: Message Type Functions //- rjf: deep copying -internal void ctrl_msg_deep_copy(Arena *arena, D_Msg *dst, D_Msg *src); +internal void d_msg_deep_copy(Arena *arena, D_Msg *dst, D_Msg *src); //- rjf: list building -internal D_Msg *ctrl_msg_list_push(Arena *arena, D_MsgList *list); -internal D_MsgList ctrl_msg_list_deep_copy(Arena *arena, D_MsgList *src); -internal void ctrl_msg_list_concat_in_place(D_MsgList *dst, D_MsgList *src); +internal D_Msg *d_msg_list_push(Arena *arena, D_MsgList *list); +internal D_MsgList d_msg_list_deep_copy(Arena *arena, D_MsgList *src); +internal void d_msg_list_concat_in_place(D_MsgList *dst, D_MsgList *src); //- rjf: serialization -internal String8 ctrl_serialized_string_from_msg_list(Arena *arena, D_MsgList *msgs); -internal D_MsgList ctrl_msg_list_from_serialized_string(Arena *arena, String8 string); +internal String8 d_serialized_string_from_msg_list(Arena *arena, D_MsgList *msgs); +internal D_MsgList d_msg_list_from_serialized_string(Arena *arena, String8 string); //////////////////////////////// //~ rjf: Event Type Functions //- rjf: list building -internal D_Event *ctrl_event_list_push(Arena *arena, D_EventList *list); -internal void ctrl_event_list_concat_in_place(D_EventList *dst, D_EventList *to_push); +internal D_Event *d_event_list_push(Arena *arena, D_EventList *list); +internal void d_event_list_concat_in_place(D_EventList *dst, D_EventList *to_push); //- rjf: serialization -internal String8 ctrl_serialized_string_from_event(Arena *arena, D_Event *event, U64 max); -internal D_Event ctrl_event_from_serialized_string(Arena *arena, String8 string); +internal String8 d_serialized_string_from_event(Arena *arena, D_Event *event, U64 max); +internal D_Event d_event_from_serialized_string(Arena *arena, String8 string); //////////////////////////////// //~ rjf: Entity Type Functions //- rjf: entity list data structures -internal void ctrl_entity_list_push(Arena *arena, D_EntityList *list, D_Entity *entity); -internal D_EntityList ctrl_entity_list_from_handle_list(Arena *arena, D_EntityCtx *ctx, D_HandleList *list); -#define ctrl_entity_list_first(list) ((list)->first ? (list)->first->v : &d_entity_nil) +internal void d_entity_list_push(Arena *arena, D_EntityList *list, D_Entity *entity); +internal D_EntityList d_entity_list_from_handle_list(Arena *arena, D_EntityCtx *ctx, D_HandleList *list); +#define d_entity_list_first(list) ((list)->first ? (list)->first->v : &d_entity_nil) //- rjf: entity array data structure -internal D_EntityArray ctrl_entity_array_from_list(Arena *arena, D_EntityList *list); -#define ctrl_entity_array_first(array) ((array)->count != 0 ? (array)->v[0] : &d_entity_nil) +internal D_EntityArray d_entity_array_from_list(Arena *arena, D_EntityList *list); +#define d_entity_array_first(array) ((array)->count != 0 ? (array)->v[0] : &d_entity_nil) //- rjf: entity context (entity group read-only) functions -internal D_Entity *ctrl_entity_from_handle(D_EntityCtx *ctx, D_Handle handle); -internal D_Entity *ctrl_entity_child_from_kind(D_Entity *parent, D_EntityKind kind); -internal D_Entity *ctrl_entity_ancestor_from_kind(D_Entity *entity, D_EntityKind kind); -internal D_Entity *ctrl_process_from_entity(D_Entity *entity); -internal D_Entity *ctrl_module_from_process_vaddr(D_Entity *process, U64 vaddr); -internal DI_Key ctrl_dbgi_key_from_module(D_Entity *module); -internal D_Entity *ctrl_module_from_thread_candidates(D_EntityCtx *ctx, D_Entity *thread, D_EntityList *candidates); -internal U64 ctrl_vaddr_from_voff(D_Entity *module, U64 voff); -internal U64 ctrl_voff_from_vaddr(D_Entity *module, U64 vaddr); -internal Rng1U64 ctrl_vaddr_range_from_voff_range(D_Entity *module, Rng1U64 voff_range); -internal Rng1U64 ctrl_voff_range_from_vaddr_range(D_Entity *module, Rng1U64 vaddr_range); -internal B32 ctrl_entity_tree_is_frozen(D_Entity *root); +internal D_Entity *d_entity_from_handle(D_EntityCtx *ctx, D_Handle handle); +internal D_Entity *d_entity_child_from_kind(D_Entity *parent, D_EntityKind kind); +internal D_Entity *d_entity_ancestor_from_kind(D_Entity *entity, D_EntityKind kind); +internal D_Entity *d_process_from_entity(D_Entity *entity); +internal D_Entity *d_module_from_process_vaddr(D_Entity *process, U64 vaddr); +internal DI_Key d_dbgi_key_from_module(D_Entity *module); +internal D_Entity *d_module_from_thread_candidates(D_EntityCtx *ctx, D_Entity *thread, D_EntityList *candidates); +internal U64 d_vaddr_from_voff(D_Entity *module, U64 voff); +internal U64 d_voff_from_vaddr(D_Entity *module, U64 vaddr); +internal Rng1U64 d_vaddr_range_from_voff_range(D_Entity *module, Rng1U64 voff_range); +internal Rng1U64 d_voff_range_from_vaddr_range(D_Entity *module, Rng1U64 vaddr_range); +internal B32 d_entity_tree_is_frozen(D_Entity *root); //- rjf: entity tree iteration -internal D_EntityRec ctrl_entity_rec_depth_first(D_Entity *entity, D_Entity *subtree_root, U64 sib_off, U64 child_off); -#define ctrl_entity_rec_depth_first_pre(entity, subtree_root) ctrl_entity_rec_depth_first((entity), (subtree_root), OffsetOf(D_Entity, next), OffsetOf(D_Entity, first)) -#define ctrl_entity_rec_depth_first_post(entity, subtree_root) ctrl_entity_rec_depth_first((entity), (subtree_root), OffsetOf(D_Entity, prev), OffsetOf(D_Entity, last)) +internal D_EntityRec d_entity_rec_depth_first(D_Entity *entity, D_Entity *subtree_root, U64 sib_off, U64 child_off); +#define d_entity_rec_depth_first_pre(entity, subtree_root) d_entity_rec_depth_first((entity), (subtree_root), OffsetOf(D_Entity, next), OffsetOf(D_Entity, first)) //- rjf: entity ctx r/w store state functions -internal D_EntityCtxRWStore *ctrl_entity_ctx_rw_store_alloc(void); -internal void ctrl_entity_ctx_rw_store_release(D_EntityCtxRWStore *store); +internal D_EntityCtxRWStore *d_entity_ctx_rw_store_alloc(void); +internal void d_entity_ctx_rw_store_release(D_EntityCtxRWStore *store); //- rjf: string allocation/deletion -internal U64 ctrl_name_bucket_num_from_string_size(U64 size); -internal String8 ctrl_entity_string_alloc(D_EntityCtxRWStore *store, String8 string); -internal void ctrl_entity_string_release(D_EntityCtxRWStore *store, String8 string); +internal U64 d_name_bucket_num_from_string_size(U64 size); +internal String8 d_entity_string_alloc(D_EntityCtxRWStore *store, String8 string); +internal void d_entity_string_release(D_EntityCtxRWStore *store, String8 string); //- rjf: entity construction/deletion -internal D_Entity *ctrl_entity_alloc(D_EntityCtxRWStore *store, D_Entity *parent, D_EntityKind kind, Arch arch, D_Handle handle, U64 id); -internal void ctrl_entity_release(D_EntityCtxRWStore *store, D_Entity *entity); +internal D_Entity *d_entity_alloc(D_EntityCtxRWStore *store, D_Entity *parent, D_EntityKind kind, Arch arch, D_Handle handle, U64 id); +internal void d_entity_release(D_EntityCtxRWStore *store, D_Entity *entity); //- rjf: entity equipment -internal void ctrl_entity_equip_string(D_EntityCtxRWStore *store, D_Entity *entity, String8 string); +internal void d_entity_equip_string(D_EntityCtxRWStore *store, D_Entity *entity, String8 string); //- rjf: accelerated entity context lookups -internal D_EntityCtxLookupAccel *ctrl_thread_entity_ctx_lookup_accel(void); -internal D_EntityArray ctrl_entity_array_from_kind(D_EntityCtx *ctx, D_EntityKind kind); -internal D_EntityList ctrl_modules_from_dbgi_key(Arena *arena, D_EntityCtx *ctx, DI_Key dbgi_key); -internal D_Entity *ctrl_thread_from_id(D_EntityCtx *ctx, U64 id); +internal D_EntityCtxLookupAccel *d_thread_entity_ctx_lookup_accel(void); +internal D_EntityArray d_entity_array_from_kind(D_EntityCtx *ctx, D_EntityKind kind); +internal D_EntityList d_modules_from_dbgi_key(Arena *arena, D_EntityCtx *ctx, DI_Key dbgi_key); +internal D_Entity *d_thread_from_id(D_EntityCtx *ctx, U64 id); //- rjf: applying events to entity caches -internal void ctrl_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list); +internal void d_entity_store_apply_events(D_EntityCtxRWStore *store, D_EventList *list); //////////////////////////////// //~ rjf: Wakeup Callback Registration -internal void ctrl_set_wakeup_hook(D_WakeupFunctionType *wakeup_hook); +internal void d_set_wakeup_hook(D_WakeupFunctionType *wakeup_hook); //////////////////////////////// //~ rjf: Thread Register Functions //- rjf: thread register cache reading -internal void *ctrl_reg_block_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle handle); -internal U64 ctrl_tls_root_vaddr_from_thread(D_EntityCtx *ctx, D_Handle handle); -internal U64 ctrl_rip_from_thread(D_EntityCtx *ctx, D_Handle handle); -internal U64 ctrl_rsp_from_thread(D_EntityCtx *ctx, D_Handle handle); +internal void *d_reg_block_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle handle); +internal U64 d_tls_root_vaddr_from_thread(D_EntityCtx *ctx, D_Handle handle); +internal U64 d_rip_from_thread(D_EntityCtx *ctx, D_Handle handle); +internal U64 d_rsp_from_thread(D_EntityCtx *ctx, D_Handle handle); //- rjf: thread register writing -internal B32 ctrl_thread_write_reg_block(D_Handle thread, void *block); +internal B32 d_thread_write_reg_block(D_Handle thread, void *block); //////////////////////////////// //~ rjf: Module Image Info Functions //- rjf: cache lookups -internal PE_IntelPdata *ctrl_intel_pdata_from_module_voff(Arena *arena, D_Handle module_handle, U64 voff); -internal U64 ctrl_entry_point_voff_from_module(D_Handle module_handle); -internal String8 ctrl_initial_debug_info_path_from_module(Arena *arena, D_Handle module_handle); -internal String8 ctrl_raddbg_data_from_module(Arena *arena, D_Handle module_handle); - -//////////////////////////////// -//~ Process Info Functions - -internal Arch ctrl_arch_from_process_handle(D_Handle process_handle); +internal PE_IntelPdata *d_intel_pdata_from_module_voff(Arena *arena, D_Handle module_handle, U64 voff); +internal U64 d_entry_point_voff_from_module(D_Handle module_handle); +internal String8 d_initial_debug_info_path_from_module(Arena *arena, D_Handle module_handle); +internal String8 d_raddbg_data_from_module(Arena *arena, D_Handle module_handle); //////////////////////////////// //~ rjf: Unwinding Functions -//- rjf: unwind deep copier -internal D_Unwind ctrl_unwind_deep_copy(Arena *arena, Arch arch, D_Unwind *src); - -//- DWARF -internal D_UnwindStepResult ctrl_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle, D_Handle module_handle, Arch arch, void *regs, U64 endt_us, D_FrameUnwindContext *ctx_out); -internal D_UnwindStepResult ctrl_unwind_step__dwarf(D_Handle process_handle, Arch arch, void *regs, D_FrameUnwindContext *frame_ctx, U64 endt_us); +//- rjf: [dwarf] +internal D_UnwindStepResult d_unwind_step_result_from_machine_op_result(MachineOpResult s); +internal D_UnwindStepResult d_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle, D_Handle module_handle, Arch arch, void *regs, U64 endt_us, D_FrameUnwindContext *ctx_out); +internal D_UnwindStepResult d_unwind_step__dwarf(D_Handle process_handle, Arch arch, void *regs, D_FrameUnwindContext *frame_ctx, U64 endt_us); //- rjf: [x64] -internal REGS_Reg64 *ctrl_unwind_reg_from_pe_gpr_reg__pe_x64(REGS_RegBlockX64 *regs, PE_UnwindGprRegX64 gpr_reg); -internal D_UnwindStepResult ctrl_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 module_base_vaddr, REGS_RegBlockX64 *regs, U64 endt_us); +internal REGS_Reg64 *d_unwind_reg_from_pe_gpr_reg__pe_x64(REGS_RegBlockX64 *regs, PE_UnwindGprRegX64 gpr_reg); +internal D_UnwindStepResult d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 module_base_vaddr, REGS_RegBlockX64 *regs, U64 endt_us); //- rjf: abstracted full unwind -internal D_Unwind ctrl_unwind_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle thread, U64 endt_us); +internal D_Unwind d_unwind_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle thread, U64 endt_us); //////////////////////////////// //~ rjf: Call Stack Building Functions -internal D_CallStack ctrl_call_stack_from_unwind(Arena *arena, D_Entity *process, D_Unwind *base_unwind); -internal D_CallStackFrame *ctrl_call_stack_frame_from_unwind_and_inline_depth(D_CallStack *call_stack, U64 unwind_count, U64 inline_depth); +internal D_CallStack d_call_stack_from_unwind(Arena *arena, D_Entity *process, D_Unwind *base_unwind); +internal D_CallStackFrame *d_call_stack_frame_from_unwind_and_inline_depth(D_CallStack *call_stack, U64 unwind_count, U64 inline_depth); //////////////////////////////// //~ rjf: Halting All Attached Processes -internal void ctrl_halt(void); +internal void d_halt(void); //////////////////////////////// //~ rjf: Shared Accessor Functions //- rjf: generation counters -internal U64 ctrl_run_gen(void); -internal U64 ctrl_mem_gen(void); -internal U64 ctrl_reg_gen(void); +internal U64 d_run_gen(void); +internal U64 d_mem_gen(void); +internal U64 d_reg_gen(void); //- rjf: name -> register/alias hash tables, for eval -internal E_String2NumMap *ctrl_string2reg_from_arch(Arch arch); -internal E_String2NumMap *ctrl_string2alias_from_arch(Arch arch); +internal E_String2NumMap *d_string2reg_from_arch(Arch arch); +internal E_String2NumMap *d_string2alias_from_arch(Arch arch); //////////////////////////////// //~ rjf: Control-Thread Functions //- rjf: user -> control thread communication -internal B32 ctrl_u2c_push_msgs(D_MsgList *msgs, U64 endt_us); -internal D_MsgList ctrl_u2c_pop_msgs(Arena *arena); +internal B32 d_u2c_push_msgs(D_MsgList *msgs, U64 endt_us); +internal D_MsgList d_u2c_pop_msgs(Arena *arena); //- rjf: control -> user thread communication -internal void ctrl_c2u_push_events(D_EventList *events); -internal D_EventList ctrl_c2u_pop_events(Arena *arena); +internal void d_c2u_push_events(D_EventList *events); +internal D_EventList d_c2u_pop_events(Arena *arena); //- rjf: entry point -internal void ctrl_thread__entry_point(void *p); +internal void d_ctrl_thread__entry_point(void *p); //- rjf: breakpoint resolution -internal void ctrl_thread__append_resolved_module_user_bp_traps(Arena *arena, D_EvalScope *eval_scope, D_Handle process, D_Handle module, D_BreakpointList *user_bps, DMN_TrapChunkList *traps_out); -internal void ctrl_thread__append_resolved_process_user_bp_traps(Arena *arena, D_EvalScope *eval_scope, D_Handle process, D_BreakpointList *user_bps, DMN_TrapChunkList *traps_out); -internal void ctrl_thread__append_program_defined_bp_traps(Arena *arena, D_Entity *bp, DMN_TrapChunkList *traps_out); +internal void d_ctrl_thread__append_resolved_module_user_bp_traps(Arena *arena, D_EvalScope *eval_scope, D_Handle process, D_Handle module, D_BreakpointList *user_bps, DMN_TrapChunkList *traps_out); +internal void d_ctrl_thread__append_resolved_process_user_bp_traps(Arena *arena, D_EvalScope *eval_scope, D_Handle process, D_BreakpointList *user_bps, DMN_TrapChunkList *traps_out); +internal void d_ctrl_thread__append_program_defined_bp_traps(Arena *arena, D_Entity *bp, DMN_TrapChunkList *traps_out); //- rjf: module lifetime open/close work -internal void ctrl_thread__module_open(D_Handle process, D_Handle module, Rng1U64 vaddr_range, String8 path, Rng1U64 elf_phdr_vrange, U64 elf_phdr_entsize); -internal void ctrl_thread__module_close(D_Handle process, D_Handle module, Rng1U64 vaddr_range); +internal void d_ctrl_thread__module_open(D_Handle process, D_Handle module, Rng1U64 vaddr_range, String8 path, Rng1U64 elf_phdr_vrange, U64 elf_phdr_entsize); +internal void d_ctrl_thread__module_close(D_Handle process, D_Handle module, Rng1U64 vaddr_range); //- rjf: attached process running/event gathering -internal DMN_Event *ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN_RunCtrls *run_ctrls, D_Spoof *spoof); +internal DMN_Event *d_ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, DMN_RunCtrls *run_ctrls, D_Spoof *spoof); //- rjf: eval helpers -internal U64 ctrl_eval_space_gen(E_Space space); -internal B32 ctrl_eval_space_read(E_Space space, void *out, Rng1U64 vaddr_range); +internal U64 d_ctrl_eval_space_gen(E_Space space); +internal B32 d_ctrl_eval_space_read(E_Space space, void *out, Rng1U64 vaddr_range); //- rjf: control thread eval scopes -internal D_EvalScope *ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Entity *thread); -internal void ctrl_thread__eval_scope_end(D_EvalScope *scope); +internal D_EvalScope *d_ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Entity *thread); +internal void d_ctrl_thread__eval_scope_end(D_EvalScope *scope); //- rjf: log flusher -internal void ctrl_thread__end_and_flush_log(void); +internal void d_ctrl_thread__end_and_flush_log(void); //- rjf: msg kind implementations -internal void ctrl_thread__launch(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); -internal void ctrl_thread__attach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); -internal void ctrl_thread__kill(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); -internal void ctrl_thread__kill_all(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); -internal void ctrl_thread__detach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); -internal void ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); -internal void ctrl_thread__single_step(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); +internal void d_ctrl_thread__launch(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); +internal void d_ctrl_thread__attach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); +internal void d_ctrl_thread__kill(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); +internal void d_ctrl_thread__kill_all(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); +internal void d_ctrl_thread__detach(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); +internal void d_ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); +internal void d_ctrl_thread__single_step(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg); //////////////////////////////// //~ rjf: Process Memory Artifact Cache Hooks / Lookups -internal AC_Artifact ctrl_memory_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out); -internal void ctrl_memory_artifact_destroy(AC_Artifact artifact); -internal C_Key ctrl_key_from_process_vaddr_range(D_Handle process, Rng1U64 vaddr_range, B32 zero_terminated, B32 wait_for_fresh, U64 endt_us, B32 *out_is_stale); +internal AC_Artifact d_memory_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out); +internal void d_memory_artifact_destroy(AC_Artifact artifact); +internal C_Key d_key_from_process_vaddr_range(D_Handle process, Rng1U64 vaddr_range, B32 zero_terminated, B32 wait_for_fresh, U64 endt_us, B32 *out_is_stale); //- rjf: process memory reading helpers -internal D_ProcessMemorySlice ctrl_process_memory_slice_from_vaddr_range(Arena *arena, D_Handle process, Rng1U64 range, B32 wait_for_fresh, U64 endt_us); -internal B32 ctrl_process_memory_read(D_Handle process, Rng1U64 range, B32 *is_stale_out, void *out, U64 endt_us); -#define ctrl_process_memory_read_struct(process, vaddr, is_stale_out, ptr, endt_us) ctrl_process_memory_read((process), r1u64((vaddr), (vaddr)+(sizeof(*(ptr)))), (is_stale_out), (ptr), (endt_us)) +internal D_ProcessMemorySlice d_process_memory_slice_from_vaddr_range(Arena *arena, D_Handle process, Rng1U64 range, B32 wait_for_fresh, U64 endt_us); +internal B32 d_process_memory_read(D_Handle process, Rng1U64 range, B32 *is_stale_out, void *out, U64 endt_us); +#define d_process_memory_read_struct(process, vaddr, is_stale_out, ptr, endt_us) d_process_memory_read((process), r1u64((vaddr), (vaddr)+(sizeof(*(ptr)))), (is_stale_out), (ptr), (endt_us)) //- rjf: process memory writing -internal B32 ctrl_process_write(D_Handle process, Rng1U64 range, void *src); +internal B32 d_process_write(D_Handle process, Rng1U64 range, void *src); //////////////////////////////// //~ rjf: Call Stack Artifact Cache Hooks / Lookups -internal AC_Artifact ctrl_call_stack_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out); -internal void ctrl_call_stack_artifact_destroy(AC_Artifact artifact); -internal D_CallStack ctrl_call_stack_from_thread(Access *access, D_Handle thread_handle, B32 high_priority, U64 endt_us); +internal AC_Artifact d_call_stack_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out); +internal void d_call_stack_artifact_destroy(AC_Artifact artifact); +internal D_CallStack d_call_stack_from_thread(Access *access, D_Handle thread_handle, B32 high_priority, U64 endt_us); //////////////////////////////// //~ rjf: Call Stack Tree Artifact Cache Hooks / Lookups -internal AC_Artifact ctrl_call_stack_tree_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out); -internal void ctrl_call_stack_tree_artifact_destroy(AC_Artifact artifact); -internal D_CallStackTree ctrl_call_stack_tree(Access *access, U64 endt_us); +internal AC_Artifact d_call_stack_tree_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out); +internal void d_call_stack_tree_artifact_destroy(AC_Artifact artifact); +internal D_CallStackTree d_call_stack_tree(Access *access, U64 endt_us); #endif // DBG_ENGINE_CTRL_H diff --git a/src/dbg_engine/dbg_engine_user.c b/src/dbg_engine/dbg_engine_user.c index 0d99412e..ab323399 100644 --- a/src/dbg_engine/dbg_engine_user.c +++ b/src/dbg_engine/dbg_engine_user.c @@ -292,15 +292,15 @@ d_trap_net_from_thread__step_over_inst(Arena *arena, D_Entity *thread) D_TrapNet result = {0}; // rjf: thread => unpacked info - D_Entity *process = ctrl_entity_ancestor_from_kind(thread, D_EntityKind_Process); + D_Entity *process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process); Arch arch = thread->arch; - U64 ip_vaddr = ctrl_rip_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle); + U64 ip_vaddr = d_rip_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle); // rjf: ip => machine code String8 machine_code = {0}; { Rng1U64 rng = r1u64(ip_vaddr, ip_vaddr+max_instruction_size_from_arch(arch)); - D_ProcessMemorySlice machine_code_slice = ctrl_process_memory_slice_from_vaddr_range(scratch.arena, process->handle, rng, 0, os_now_microseconds()+5000); + D_ProcessMemorySlice machine_code_slice = d_process_memory_slice_from_vaddr_range(scratch.arena, process->handle, rng, 0, os_now_microseconds()+5000); machine_code = machine_code_slice.data; } @@ -316,7 +316,7 @@ d_trap_net_from_thread__step_over_inst(Arena *arena, D_Entity *thread) if(inst.flags & DASM_InstFlag_Call || inst.flags & DASM_InstFlag_Repeats) { D_Trap trap = {D_TrapFlag_EndStepping, ip_vaddr+inst.size}; - ctrl_trap_list_push(arena, &result.traps, &trap); + d_trap_list_push(arena, &result.traps, &trap); } } @@ -333,10 +333,10 @@ d_trap_net_from_thread__step_over_line(Arena *arena, D_Entity *thread) // rjf: thread => info Arch arch = thread->arch; - U64 ip_vaddr = ctrl_rip_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle); - D_Entity *process = ctrl_entity_ancestor_from_kind(thread, D_EntityKind_Process); - D_Entity *module = ctrl_module_from_process_vaddr(process, ip_vaddr); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + U64 ip_vaddr = d_rip_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle); + D_Entity *process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process); + D_Entity *module = d_module_from_process_vaddr(process, ip_vaddr); + DI_Key dbgi_key = d_dbgi_key_from_module(module); log_infof("ip_vaddr: 0x%I64x\n", ip_vaddr); log_infof("dbgi_key: {0x%I64x, 0x%I64x}\n", dbgi_key.u64[0], dbgi_key.u64[1]); @@ -345,7 +345,7 @@ d_trap_net_from_thread__step_over_line(Arena *arena, D_Entity *thread) S64 line_num = 0; Rng1U64 line_vaddr_rng = {0}; { - U64 ip_voff = ctrl_voff_from_vaddr(module, ip_vaddr); + U64 ip_voff = d_voff_from_vaddr(module, ip_vaddr); D_LineList lines = d_lines_from_dbgi_key_voff(scratch.arena, dbgi_key, ip_voff); Rng1U64 line_voff_rng = {0}; if(lines.first != 0) @@ -353,7 +353,7 @@ d_trap_net_from_thread__step_over_line(Arena *arena, D_Entity *thread) line_voff_rng = lines.first->v.voff_range; file_path = lines.first->v.file_path; line_num = lines.first->v.pt.line; - line_vaddr_rng = ctrl_vaddr_range_from_voff_range(module, line_voff_rng); + line_vaddr_rng = d_vaddr_range_from_voff_range(module, line_voff_rng); log_infof("line: {%S:%I64i}\n", lines.first->v.file_path, lines.first->v.pt.line); } log_infof("voff_range: {0x%I64x, 0x%I64x}\n", line_voff_rng.min, line_voff_rng.max); @@ -367,7 +367,7 @@ d_trap_net_from_thread__step_over_line(Arena *arena, D_Entity *thread) for EachNode(n, D_LineNode, lines.first) { Rng1U64 voff_range = n->v.voff_range; - Rng1U64 vaddr_range = ctrl_vaddr_range_from_voff_range(module, voff_range); + Rng1U64 vaddr_range = d_vaddr_range_from_voff_range(module, voff_range); rng1u64_list_push(scratch.arena, &all_vaddr_ranges_on_same_line, vaddr_range); } } @@ -377,11 +377,11 @@ d_trap_net_from_thread__step_over_line(Arena *arena, D_Entity *thread) // MSVC exports line info at these line numbers when /JMC (Just My Code) debugging // is enabled. This is enabled by default normally. { - U64 opl_line_voff_rng = ctrl_voff_from_vaddr(module, line_vaddr_rng.max); + U64 opl_line_voff_rng = d_voff_from_vaddr(module, line_vaddr_rng.max); D_LineList lines = d_lines_from_dbgi_key_voff(scratch.arena, dbgi_key, opl_line_voff_rng); if(lines.first != 0 && (lines.first->v.pt.line == 0xf00f00 || lines.first->v.pt.line == 0xfeefee)) { - line_vaddr_rng.max = ctrl_vaddr_from_voff(module, lines.first->v.voff_range.max); + line_vaddr_rng.max = d_vaddr_from_voff(module, lines.first->v.voff_range.max); } } @@ -393,7 +393,7 @@ d_trap_net_from_thread__step_over_line(Arena *arena, D_Entity *thread) B32 good_machine_code = 0; if(good_line_info) { - D_ProcessMemorySlice machine_code_slice = ctrl_process_memory_slice_from_vaddr_range(scratch.arena, process->handle, line_vaddr_rng, 0, os_now_microseconds()+50000); + D_ProcessMemorySlice machine_code_slice = d_process_memory_slice_from_vaddr_range(scratch.arena, process->handle, line_vaddr_rng, 0, os_now_microseconds()+50000); machine_code = machine_code_slice.data; good_machine_code = (machine_code.size >= dim_1u64(line_vaddr_rng) && !machine_code_slice.any_byte_bad); LogInfoNamedBlockF("machine_code_slice") @@ -492,7 +492,7 @@ d_trap_net_from_thread__step_over_line(Arena *arena, D_Entity *thread) if(add) { D_Trap trap = {flags, trap_addr}; - ctrl_trap_list_push(arena, &result.traps, &trap); + d_trap_list_push(arena, &result.traps, &trap); } } @@ -515,7 +515,7 @@ d_trap_net_from_thread__step_over_line(Arena *arena, D_Entity *thread) if(!opl_in_line) { D_Trap trap = {D_TrapFlag_EndStepping, opl}; - ctrl_trap_list_push(arena, &result.traps, &trap); + d_trap_list_push(arena, &result.traps, &trap); } } } @@ -546,17 +546,17 @@ d_trap_net_from_thread__step_into_line(Arena *arena, D_Entity *thread) // rjf: thread => info Arch arch = thread->arch; - U64 ip_vaddr = ctrl_rip_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle); - D_Entity *process = ctrl_entity_ancestor_from_kind(thread, D_EntityKind_Process); - D_Entity *module = ctrl_module_from_process_vaddr(process, ip_vaddr); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + U64 ip_vaddr = d_rip_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle); + D_Entity *process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process); + D_Entity *module = d_module_from_process_vaddr(process, ip_vaddr); + DI_Key dbgi_key = d_dbgi_key_from_module(module); // rjf: ip => line info String8 file_path = {0}; S64 line_num = 0; Rng1U64 line_vaddr_rng = {0}; { - U64 ip_voff = ctrl_voff_from_vaddr(module, ip_vaddr); + U64 ip_voff = d_voff_from_vaddr(module, ip_vaddr); D_LineList lines = d_lines_from_dbgi_key_voff(scratch.arena, dbgi_key, ip_voff); Rng1U64 line_voff_rng = {0}; if(lines.first != 0) @@ -564,7 +564,7 @@ d_trap_net_from_thread__step_into_line(Arena *arena, D_Entity *thread) line_voff_rng = lines.first->v.voff_range; file_path = lines.first->v.file_path; line_num = lines.first->v.pt.line; - line_vaddr_rng = ctrl_vaddr_range_from_voff_range(module, line_voff_rng); + line_vaddr_rng = d_vaddr_range_from_voff_range(module, line_voff_rng); log_infof("line: {%S:%I64i}\n", lines.first->v.file_path, lines.first->v.pt.line); } log_infof("voff_range: {0x%I64x, 0x%I64x}\n", line_voff_rng.min, line_voff_rng.max); @@ -578,7 +578,7 @@ d_trap_net_from_thread__step_into_line(Arena *arena, D_Entity *thread) for EachNode(n, D_LineNode, lines.first) { Rng1U64 voff_range = n->v.voff_range; - Rng1U64 vaddr_range = ctrl_vaddr_range_from_voff_range(module, voff_range); + Rng1U64 vaddr_range = d_vaddr_range_from_voff_range(module, voff_range); rng1u64_list_push(scratch.arena, &all_vaddr_ranges_on_same_line, vaddr_range); } } @@ -588,11 +588,11 @@ d_trap_net_from_thread__step_into_line(Arena *arena, D_Entity *thread) // MSVC exports line info at these line numbers when /JMC (Just My Code) debugging // is enabled. This is enabled by default normally. { - U64 opl_line_voff_rng = ctrl_voff_from_vaddr(module, line_vaddr_rng.max); + U64 opl_line_voff_rng = d_voff_from_vaddr(module, line_vaddr_rng.max); D_LineList lines = d_lines_from_dbgi_key_voff(scratch.arena, dbgi_key, opl_line_voff_rng); if(lines.first != 0 && (lines.first->v.pt.line == 0xf00f00 || lines.first->v.pt.line == 0xfeefee)) { - line_vaddr_rng.max = ctrl_vaddr_from_voff(module, lines.first->v.voff_range.max); + line_vaddr_rng.max = d_vaddr_from_voff(module, lines.first->v.voff_range.max); } } @@ -604,7 +604,7 @@ d_trap_net_from_thread__step_into_line(Arena *arena, D_Entity *thread) B32 good_machine_code = 0; if(good_line_info) { - D_ProcessMemorySlice machine_code_slice = ctrl_process_memory_slice_from_vaddr_range(scratch.arena, process->handle, line_vaddr_rng, 0, os_now_microseconds()+5000); + D_ProcessMemorySlice machine_code_slice = d_process_memory_slice_from_vaddr_range(scratch.arena, process->handle, line_vaddr_rng, 0, os_now_microseconds()+5000); machine_code = machine_code_slice.data; good_machine_code = (machine_code.size >= dim_1u64(line_vaddr_rng) && !machine_code_slice.any_byte_bad); } @@ -649,9 +649,9 @@ d_trap_net_from_thread__step_into_line(Arena *arena, D_Entity *thread) point->jump_dest_vaddr != 0) { U64 jump_dest_vaddr = point->jump_dest_vaddr; - D_Entity *jump_dest_module = ctrl_module_from_process_vaddr(process, jump_dest_vaddr); - U64 jump_dest_voff = ctrl_voff_from_vaddr(jump_dest_module, jump_dest_vaddr); - DI_Key jump_dest_dbgi_key = ctrl_dbgi_key_from_module(jump_dest_module); + D_Entity *jump_dest_module = d_module_from_process_vaddr(process, jump_dest_vaddr); + U64 jump_dest_voff = d_voff_from_vaddr(jump_dest_module, jump_dest_vaddr); + DI_Key jump_dest_dbgi_key = d_dbgi_key_from_module(jump_dest_module); D_LineList lines = d_lines_from_dbgi_key_voff(scratch.arena, jump_dest_dbgi_key, jump_dest_voff); if(lines.count == 0) { @@ -701,7 +701,7 @@ d_trap_net_from_thread__step_into_line(Arena *arena, D_Entity *thread) if(add) { D_Trap trap = {flags, trap_addr}; - ctrl_trap_list_push(arena, &result.traps, &trap); + d_trap_list_push(arena, &result.traps, &trap); } } @@ -724,7 +724,7 @@ d_trap_net_from_thread__step_into_line(Arena *arena, D_Entity *thread) if(!opl_in_line) { D_Trap trap = {D_TrapFlag_EndStepping, opl}; - ctrl_trap_list_push(arena, &result.traps, &trap); + d_trap_list_push(arena, &result.traps, &trap); } } } @@ -1073,8 +1073,8 @@ d_tls_base_vaddr_from_process_root_rip(D_Entity *process, U64 root_vaddr, U64 ri Temp scratch = scratch_begin(0, 0); //- rjf: unpack module info - D_Entity *module = ctrl_module_from_process_vaddr(process, rip_vaddr); - U64 addr_size = byte_size_from_arch(process->arch); + D_Entity *module = d_module_from_process_vaddr(process, rip_vaddr); + U64 addr_size = byte_size_from_arch(process->arch); switch(process->tls_model) { @@ -1084,7 +1084,7 @@ d_tls_base_vaddr_from_process_root_rip(D_Entity *process, U64 root_vaddr, U64 ri // read thread local base pointer out of TEB U64 thread_local_base = root_vaddr; U64 tls_addr_array = 0; - D_ProcessMemorySlice tls_addr_array_slice = ctrl_process_memory_slice_from_vaddr_range(scratch.arena, process->handle, r1u64(thread_local_base, thread_local_base + addr_size), 0, 0); + D_ProcessMemorySlice tls_addr_array_slice = d_process_memory_slice_from_vaddr_range(scratch.arena, process->handle, r1u64(thread_local_base, thread_local_base + addr_size), 0, 0); String8 tls_array_vaddr_data = tls_addr_array_slice.data; if(tls_array_vaddr_data.size == addr_size) { @@ -1093,7 +1093,7 @@ d_tls_base_vaddr_from_process_root_rip(D_Entity *process, U64 root_vaddr, U64 ri // read thread local storage pointer (array of TLS pointers, one per module) U64 tls_ptr_vaddr = tls_array_vaddr + module->tls_index * addr_size; - D_ProcessMemorySlice result_slice = ctrl_process_memory_slice_from_vaddr_range(scratch.arena, process->handle, r1u64(tls_ptr_vaddr, tls_ptr_vaddr + addr_size), 0, 0); + D_ProcessMemorySlice result_slice = d_process_memory_slice_from_vaddr_range(scratch.arena, process->handle, r1u64(tls_ptr_vaddr, tls_ptr_vaddr + addr_size), 0, 0); String8 result_data = result_slice.data; if(result_data.size == addr_size) { @@ -1109,7 +1109,7 @@ d_tls_base_vaddr_from_process_root_rip(D_Entity *process, U64 root_vaddr, U64 ri U64 dtv_base = root_vaddr; U64 dtv_size = addr_size * 2; // union dtv { size_t counter; struct dtv_pointer { void *val, *to_free; }; }; U64 dtv_pointer_vaddr = dtv_base + module->tls_index * dtv_size; - D_ProcessMemorySlice dtv_pointer_slice = ctrl_process_memory_slice_from_vaddr_range(scratch.arena, process->handle, r1u64(dtv_pointer_vaddr, dtv_pointer_vaddr + dtv_size), 0, 0); + D_ProcessMemorySlice dtv_pointer_slice = d_process_memory_slice_from_vaddr_range(scratch.arena, process->handle, r1u64(dtv_pointer_vaddr, dtv_pointer_vaddr + dtv_size), 0, 0); String8 dtv_pointer_data = dtv_pointer_slice.data; if(dtv_pointer_data.size == dtv_size) { @@ -1182,11 +1182,11 @@ internal DI_KeyList d_push_active_dbgi_key_list(Arena *arena) { DI_KeyList dbgis = {0}; - D_EntityArray modules = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Module); + D_EntityArray modules = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Module); for EachIndex(idx, modules.count) { D_Entity *module = modules.v[idx]; - DI_Key key = ctrl_dbgi_key_from_module(module); + DI_Key key = d_dbgi_key_from_module(module); di_key_list_push(arena, &dbgis, key); } return dbgis; @@ -1207,12 +1207,12 @@ d_query_cached_rip_from_thread_unwind(D_Entity *thread, U64 unwind_count) U64 result = 0; if(unwind_count == 0) { - result = ctrl_rip_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle); + result = d_rip_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle); } else { Access *access = access_open(); - D_CallStack callstack = ctrl_call_stack_from_thread(access, thread->handle, 1, 0); + D_CallStack callstack = d_call_stack_from_thread(access, thread->handle, 1, 0); if(callstack.concrete_frames_count != 0) { result = regs_rip_from_arch_block(thread->arch, callstack.concrete_frames[unwind_count%callstack.concrete_frames_count]->regs); @@ -1227,7 +1227,7 @@ d_query_cached_cfa_from_thread_unwind(D_Entity *thread, U64 unwind_count) { U64 cfa = 0; Access *access = access_open(); - D_CallStack callstack = ctrl_call_stack_from_thread(access, thread->handle, 1, 0); + D_CallStack callstack = d_call_stack_from_thread(access, thread->handle, 1, 0); if(callstack.concrete_frames_count != 0) { cfa = callstack.concrete_frames[unwind_count%callstack.concrete_frames_count]->cfa; @@ -1259,7 +1259,7 @@ d_query_cached_tls_base_vaddr_from_process_root_rip(D_Entity *process, U64 root_ D_RunTLSBaseCacheNode *node = 0; for(D_RunTLSBaseCacheNode *n = slot->first; n != 0; n = n->hash_next) { - if(ctrl_handle_match(n->process, handle) && n->root_vaddr == root_vaddr && n->rip_vaddr == rip_vaddr) + if(d_handle_match(n->process, handle) && n->root_vaddr == root_vaddr && n->rip_vaddr == rip_vaddr) { node = n; break; @@ -1439,19 +1439,19 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P ProfScope("sync with ctrl thread") { //- rjf: grab next reggen/memgen - U64 new_mem_gen = ctrl_mem_gen(); - U64 new_reg_gen = ctrl_reg_gen(); + U64 new_mem_gen = d_mem_gen(); + U64 new_reg_gen = d_reg_gen(); //- rjf: consume & process events - events = ctrl_c2u_pop_events(arena); - ctrl_entity_store_apply_events(d_user_state->ctrl_entity_store, &events); + events = d_c2u_pop_events(arena); + d_entity_store_apply_events(d_user_state->ctrl_entity_store, &events); for(D_EventNode *event_n = events.first; event_n != 0; event_n = event_n->next) { D_Event *event = &event_n->v; log_infof("ctrl_event:\n{\n"); - log_infof("kind: \"%S\"\n", ctrl_string_from_event_kind(event->kind)); + log_infof("kind: \"%S\"\n", d_string_from_event_kind(event->kind)); log_infof("entity_id: %u\n", event->entity_id); switch(event->kind) { @@ -1492,7 +1492,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P case D_EventKind_NewProc: { // rjf: the first process? -> clear session output - D_EntityArray existing_processes = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); + D_EntityArray existing_processes = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); if(existing_processes.count == 1) { MTX_Op op = {r1u64(0, 0xffffffffffffffffull), str8_lit("[new session]\n")}; @@ -1556,7 +1556,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P // rjf: build data strings of all param data String8List strings = {0}; { - D_EntityArray threads = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Thread); + D_EntityArray threads = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Thread); for EachIndex(idx, threads.count) { D_Entity *thread = threads.v[idx]; @@ -1681,7 +1681,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P // rjf: push message to launch { - D_Msg *msg = ctrl_msg_list_push(scratch.arena, &ctrl_msgs); + D_Msg *msg = d_msg_list_push(scratch.arena, &ctrl_msgs); msg->kind = D_MsgKind_Launch; msg->path = working_directory; msg->cmd_line_string_list = cmdln_strings; @@ -1711,14 +1711,14 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P }break; case D_CmdKind_Kill: { - D_Entity *process = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->process); + D_Entity *process = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->process); if(process == &d_entity_nil) { log_user_error(str8_lit("Cannot kill; no process was specified.")); } else { - D_Msg *msg = ctrl_msg_list_push(scratch.arena, &ctrl_msgs); + D_Msg *msg = d_msg_list_push(scratch.arena, &ctrl_msgs); msg->kind = D_MsgKind_Kill; msg->exit_code = 1; msg->entity = process->handle; @@ -1727,21 +1727,21 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P }break; case D_CmdKind_KillAll: { - D_Msg *msg = ctrl_msg_list_push(scratch.arena, &ctrl_msgs); + D_Msg *msg = d_msg_list_push(scratch.arena, &ctrl_msgs); msg->kind = D_MsgKind_KillAll; msg->exit_code = 1; MemoryCopyArray(msg->exception_code_filters, exception_code_filters); }break; case D_CmdKind_Detach: { - D_Entity *process = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->process); + D_Entity *process = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->process); if(process == &d_entity_nil) { log_user_error(str8_lit("Cannot detach; no process specified.")); } else { - D_Msg *msg = ctrl_msg_list_push(scratch.arena, &ctrl_msgs); + D_Msg *msg = d_msg_list_push(scratch.arena, &ctrl_msgs); msg->kind = D_MsgKind_Detach; msg->entity = process->handle; MemoryCopyArray(msg->exception_code_filters, exception_code_filters); @@ -1750,7 +1750,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P case D_CmdKind_Continue: { B32 good_to_run = 0; - D_EntityArray threads = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Thread); + D_EntityArray threads = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Thread); if(threads.count > 0) { for EachIndex(idx, threads.count) @@ -1766,7 +1766,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P { need_run = 1; run_kind = D_RunKind_Run; - run_thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->thread); + run_thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->thread); } else { @@ -1780,7 +1780,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P case D_CmdKind_StepOverLine: case D_CmdKind_StepOut: { - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->thread); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->thread); if(thread == &d_entity_nil) { log_user_error(str8_lit("Must have a selected thread to step.")); @@ -1811,14 +1811,14 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P Access *access = access_open(); // rjf: thread => call stack - D_CallStack callstack = ctrl_call_stack_from_thread(access, thread->handle, 1, os_now_microseconds()+10000); + D_CallStack callstack = d_call_stack_from_thread(access, thread->handle, 1, os_now_microseconds()+10000); // rjf: use first unwind frame to generate trap if(callstack.concrete_frames_count > 1) { U64 vaddr = regs_rip_from_arch_block(thread->arch, callstack.concrete_frames[1]->regs); D_Trap trap = {D_TrapFlag_EndStepping|D_TrapFlag_IgnoreStackPointerCheck, vaddr}; - ctrl_trap_list_push(scratch.arena, &trap_net.traps, &trap); + d_trap_list_push(scratch.arena, &trap_net.traps, &trap); trap_net.good_read = 1; } else @@ -1861,24 +1861,24 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P case D_CmdKind_Halt: if(d_ctrl_targets_running()) { - ctrl_halt(); + d_halt(); }break; case D_CmdKind_SoftHaltRefresh: if(d_ctrl_targets_running()) { need_run = 1; run_kind = d_user_state->ctrl_last_run_kind; - run_thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, d_user_state->ctrl_last_run_thread_handle); + run_thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, d_user_state->ctrl_last_run_thread_handle); run_flags = d_user_state->ctrl_last_run_flags; run_traps = d_user_state->ctrl_last_run_traps; }break; case D_CmdKind_SetThreadIP: { - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->thread); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->thread); U64 vaddr = params->vaddr; - void *block = ctrl_reg_block_from_thread(scratch.arena, &d_user_state->ctrl_entity_store->ctx, thread->handle); + void *block = d_reg_block_from_thread(scratch.arena, &d_user_state->ctrl_entity_store->ctx, thread->handle); regs_arch_block_write_rip(thread->arch, block, vaddr); - B32 result = ctrl_thread_write_reg_block(thread->handle, block); + B32 result = d_thread_write_reg_block(thread->handle, block); (void)result; }break; @@ -1900,7 +1900,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P }break; case D_CmdKind_Run: { - D_EntityArray processes = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); + D_EntityArray processes = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); if(processes.count != 0) { d_cmd(D_CmdKind_Continue, .machine = params->machine, .process = params->process, .thread = params->thread); @@ -1912,7 +1912,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P }break; case D_CmdKind_Restart: { - D_EntityArray processes = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); + D_EntityArray processes = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); if(processes.count != 0) { d_cmd(D_CmdKind_KillAll); @@ -1922,7 +1922,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P case D_CmdKind_StepInto: case D_CmdKind_StepOver: { - D_EntityArray processes = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); + D_EntityArray processes = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); if(processes.count != 0) { D_CmdKind step_cmd_kind = (cmd->kind == D_CmdKind_StepInto @@ -1961,24 +1961,24 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P case D_CmdKind_FreezeLocalMachine: { D_MachineID machine_id = D_MachineID_Local; - d_cmd(D_CmdKind_FreezeMachine, .entity = ctrl_handle_make(machine_id, dmn_handle_zero())); + d_cmd(D_CmdKind_FreezeMachine, .entity = d_handle_make(machine_id, dmn_handle_zero())); }break; case D_CmdKind_ThawLocalMachine: { D_MachineID machine_id = D_MachineID_Local; - d_cmd(D_CmdKind_ThawMachine, .entity = ctrl_handle_make(machine_id, dmn_handle_zero())); + d_cmd(D_CmdKind_ThawMachine, .entity = d_handle_make(machine_id, dmn_handle_zero())); }break; case D_CmdKind_FreezeEntity: case D_CmdKind_ThawEntity: { B32 should_freeze = (cmd->kind == D_CmdKind_FreezeEntity); - D_Entity *root = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->entity); - for(D_Entity *e = root; e != &d_entity_nil; e = ctrl_entity_rec_depth_first_pre(e, root).next) + D_Entity *root = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->entity); + for(D_Entity *e = root; e != &d_entity_nil; e = d_entity_rec_depth_first_pre(e, root).next) { if(e->kind == D_EntityKind_Thread) { e->is_frozen = should_freeze; - D_Msg *msg = ctrl_msg_list_push(scratch.arena, &ctrl_msgs); + D_Msg *msg = d_msg_list_push(scratch.arena, &ctrl_msgs); msg->kind = (should_freeze ? D_MsgKind_FreezeThread : D_MsgKind_ThawThread); msg->entity = e->handle; } @@ -1987,7 +1987,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P { need_run = 1; run_kind = d_user_state->ctrl_last_run_kind; - run_thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, d_user_state->ctrl_last_run_thread_handle); + run_thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, d_user_state->ctrl_last_run_thread_handle); run_flags = d_user_state->ctrl_last_run_flags; run_traps = d_user_state->ctrl_last_run_traps; } @@ -1996,13 +1996,13 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P //- rjf: entity decoration case D_CmdKind_SetEntityColor: { - D_Entity *entity = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->entity); + D_Entity *entity = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->entity); entity->rgba = params->rgba; }break; case D_CmdKind_SetEntityName: { - D_Entity *entity = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->entity); - ctrl_entity_equip_string(d_user_state->ctrl_entity_store, entity, params->string); + D_Entity *entity = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->entity); + d_entity_equip_string(d_user_state->ctrl_entity_store, entity, params->string); }break; //- rjf: attaching @@ -2011,7 +2011,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P U32 pid = params->pid; if(pid != 0) { - D_Msg *msg = ctrl_msg_list_push(scratch.arena, &ctrl_msgs); + D_Msg *msg = d_msg_list_push(scratch.arena, &ctrl_msgs); msg->kind = D_MsgKind_Attach; msg->entity_id = pid; MemoryCopyArray(msg->exception_code_filters, exception_code_filters); @@ -2028,9 +2028,9 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P } // rjf: push & fill run message - D_Msg *msg = ctrl_msg_list_push(scratch.arena, &ctrl_msgs); + D_Msg *msg = d_msg_list_push(scratch.arena, &ctrl_msgs); { - D_Entity *process = ctrl_entity_ancestor_from_kind(run_thread, D_EntityKind_Process); + D_Entity *process = d_entity_ancestor_from_kind(run_thread, D_EntityKind_Process); msg->kind = (run_kind == D_RunKind_Run || run_kind == D_RunKind_Step) ? D_MsgKind_Run : D_MsgKind_SingleStep; msg->run_flags = run_flags; msg->entity = run_thread->handle; @@ -2059,21 +2059,21 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P D_Breakpoint dst_bp = {0}; MemoryCopyStruct(&dst_bp, bp); dst_bp.file_path = n->string; - ctrl_user_breakpoint_list_push(scratch.arena, &msg->user_bps, &dst_bp); + d_breakpoint_list_push(scratch.arena, &msg->user_bps, &dst_bp); } } // rjf: all other cases - just copy the breakpoint info else { - ctrl_user_breakpoint_list_push(scratch.arena, &msg->user_bps, bp); + d_breakpoint_list_push(scratch.arena, &msg->user_bps, bp); } } } } // rjf: copy run traps to scratch (needed, if run_traps can be `d_user_state->ctrl_last_run_traps`) - D_TrapList run_traps_copy = ctrl_trap_list_copy(scratch.arena, &run_traps); + D_TrapList run_traps_copy = d_trap_list_copy(scratch.arena, &run_traps); D_BreakpointArray run_extra_bps_copy = d_breakpoint_array_copy(scratch.arena, &run_extra_bps); // rjf: store last run info @@ -2082,7 +2082,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P d_user_state->ctrl_last_run_frame_idx = d_frame_index(); d_user_state->ctrl_last_run_thread_handle = run_thread->handle; d_user_state->ctrl_last_run_flags = run_flags; - d_user_state->ctrl_last_run_traps = ctrl_trap_list_copy(d_user_state->ctrl_last_run_arena, &run_traps_copy); + d_user_state->ctrl_last_run_traps = d_trap_list_copy(d_user_state->ctrl_last_run_arena, &run_traps_copy); d_user_state->ctrl_last_run_extra_bps = d_breakpoint_array_copy(d_user_state->ctrl_last_run_arena, &run_extra_bps_copy); d_user_state->ctrl_is_running = 1; } @@ -2111,16 +2111,16 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P // the next tick) // { - D_MsgList msgs_copy = ctrl_msg_list_deep_copy(d_user_state->ctrl_msg_arena, &ctrl_msgs); - ctrl_msg_list_concat_in_place(&d_user_state->ctrl_msgs, &msgs_copy); + D_MsgList msgs_copy = d_msg_list_deep_copy(d_user_state->ctrl_msg_arena, &ctrl_msgs); + d_msg_list_concat_in_place(&d_user_state->ctrl_msgs, &msgs_copy); if(d_user_state->ctrl_msgs.count != 0) { if(!d_user_state->ctrl_soft_halt_issued && d_user_state->ctrl_thread_run_state) { d_user_state->ctrl_soft_halt_issued = 1; - ctrl_halt(); + d_halt(); } - if(ctrl_u2c_push_msgs(&d_user_state->ctrl_msgs, os_now_microseconds()+100)) + if(d_u2c_push_msgs(&d_user_state->ctrl_msgs, os_now_microseconds()+100)) { MemoryZeroStruct(&d_user_state->ctrl_msgs); arena_clear(d_user_state->ctrl_msg_arena); diff --git a/src/dbg_engine/generated/dbg_engine.meta.c b/src/dbg_engine/generated/dbg_engine.meta.c index 09d20976..12e147c8 100644 --- a/src/dbg_engine/generated/dbg_engine.meta.c +++ b/src/dbg_engine/generated/dbg_engine.meta.c @@ -4,7 +4,7 @@ //- GENERATED CODE C_LINKAGE_BEGIN -String8 ctrl_entity_kind_code_name_table[12] = +String8 d_entity_kind_code_name_table[12] = { {0}, str8_lit_comp("root"), @@ -20,7 +20,7 @@ str8_lit_comp("breakpoint"), str8_lit_comp("address_range_annotation"), }; -String8 ctrl_entity_kind_display_string_table[12] = +String8 d_entity_kind_display_string_table[12] = { {0}, str8_lit_comp("Root"), @@ -36,7 +36,7 @@ str8_lit_comp("Breakpoint"), str8_lit_comp("AddressRangeAnnotation"), }; -U32 ctrl_exception_code_kind_code_table[38] = +U32 d_exception_code_kind_code_table[38] = { 0, 0x40010005, @@ -78,7 +78,7 @@ U32 ctrl_exception_code_kind_code_table[38] = 0x0000087a, }; -String8 ctrl_exception_code_kind_display_string_table[38] = +String8 d_exception_code_kind_display_string_table[38] = { {0}, str8_lit_comp("(Win32) Control-C"), @@ -120,7 +120,7 @@ str8_lit_comp("(Win32) Sanitizer Raw Access Violation"), str8_lit_comp("(Win32) DirectX Debug Layer"), }; -String8 ctrl_exception_code_kind_lowercase_code_string_table[38] = +String8 d_exception_code_kind_lowercase_code_string_table[38] = { {0}, str8_lit_comp("win32_ctrl_c"), @@ -162,7 +162,7 @@ str8_lit_comp("win32_sanitizer_raw_access_violation"), str8_lit_comp("win32_directx_debug_layer"), }; -B8 ctrl_exception_code_kind_default_enable_table[38] = +B8 d_exception_code_kind_default_enable_table[38] = { 0, 1, diff --git a/src/dbg_engine/generated/dbg_engine.meta.h b/src/dbg_engine/generated/dbg_engine.meta.h index 5635d3e9..93d86b91 100644 --- a/src/dbg_engine/generated/dbg_engine.meta.h +++ b/src/dbg_engine/generated/dbg_engine.meta.h @@ -126,12 +126,12 @@ struct {B32 *value_ptr; String8 name;} DEV_toggle_table[] = {&DEV_updating_indicator, str8_lit_comp("updating_indicator")}, }; C_LINKAGE_BEGIN -extern String8 ctrl_entity_kind_code_name_table[12]; -extern String8 ctrl_entity_kind_display_string_table[12]; -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]; +extern String8 d_entity_kind_code_name_table[12]; +extern String8 d_entity_kind_display_string_table[12]; +extern U32 d_exception_code_kind_code_table[38]; +extern String8 d_exception_code_kind_display_string_table[38]; +extern String8 d_exception_code_kind_lowercase_code_string_table[38]; +extern B8 d_exception_code_kind_default_enable_table[38]; C_LINKAGE_END diff --git a/src/eval/eval_types.c b/src/eval/eval_types.c index 246fe050..cea50704 100644 --- a/src/eval/eval_types.c +++ b/src/eval/eval_types.c @@ -2683,7 +2683,7 @@ e_list_gather_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U //- rjf: read next offset, advance B32 read_stale = 0; - B32 read_good = ctrl_process_memory_read(process, r1u64(off + member_element_off, off + member_element_off + member_size), &read_stale, &next_off, 0); + B32 read_good = d_process_memory_read(process, r1u64(off + member_element_off, off + member_element_off + member_size), &read_stale, &next_off, 0); if(read_stale) { retry = 1; diff --git a/src/raddbg/raddbg_core.c b/src/raddbg/raddbg_core.c index e0a46d04..5d13fd17 100644 --- a/src/raddbg/raddbg_core.c +++ b/src/raddbg/raddbg_core.c @@ -621,8 +621,8 @@ rd_color_from_ctrl_entity(D_Entity *entity) default:{}break; case D_EntityKind_Thread: { - D_Entity *process = ctrl_entity_ancestor_from_kind(entity, D_EntityKind_Process); - D_Entity *main_thread = ctrl_entity_child_from_kind(process, D_EntityKind_Thread); + D_Entity *process = d_entity_ancestor_from_kind(entity, D_EntityKind_Process); + D_Entity *main_thread = d_entity_child_from_kind(process, D_EntityKind_Thread); if(main_thread != entity) { result = ui_color_from_name(str8_lit("thread_1")); @@ -689,7 +689,7 @@ rd_ctrl_entity_from_eval_space(E_Space space) D_Handle handle; handle.machine_id = space.u64s[0]; handle.dmn_handle.u64[0] = space.u64s[1]; - entity = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, handle); + entity = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, handle); } return entity; } @@ -726,7 +726,7 @@ rd_eval_space_gen(E_Space space) { default: { - result = ctrl_eval_space_gen(space); + result = d_ctrl_eval_space_gen(space); }break; case RD_EvalSpaceKind_MetaCfg: case RD_EvalSpaceKind_MetaQuery: @@ -746,7 +746,7 @@ rd_eval_space_read(E_Space space, void *out, Rng1U64 range) { default: { - result = ctrl_eval_space_read(space, out, range); + result = d_ctrl_eval_space_read(space, out, range); }break; //- rjf: interior control entity reads (inside process address space or thread register block) @@ -758,7 +758,7 @@ rd_eval_space_read(E_Space space, void *out, Rng1U64 range) default:{}break; case D_EntityKind_Process: { - D_ProcessMemorySlice slice = ctrl_process_memory_slice_from_vaddr_range(scratch.arena, entity->handle, range, 0, rd_state->frame_eval_memread_endt_us); + D_ProcessMemorySlice slice = d_process_memory_slice_from_vaddr_range(scratch.arena, entity->handle, range, 0, rd_state->frame_eval_memread_endt_us); String8 data = slice.data; if(data.size == dim_1u64(range)) { @@ -769,7 +769,7 @@ rd_eval_space_read(E_Space space, void *out, Rng1U64 range) case D_EntityKind_Thread: { Access *access = access_open(); - D_CallStack call_stack = ctrl_call_stack_from_thread(access, entity->handle, 1, rd_state->frame_eval_memread_endt_us); + D_CallStack call_stack = d_call_stack_from_thread(access, entity->handle, 1, rd_state->frame_eval_memread_endt_us); U64 concrete_frame_idx = e_interpret_ctx->reg_unwind_count; if(concrete_frame_idx < call_stack.concrete_frames_count) { @@ -935,7 +935,7 @@ rd_eval_space_read(E_Space space, void *out, Rng1U64 range) String8 read_data = {0}; if(child_key.size != 0) { - MD_NodePtrList schemas = cfg_schemas_from_name(scratch.arena, rd_state->cfg_schema_table, ctrl_entity_kind_code_name_table[entity->kind]); + MD_NodePtrList schemas = cfg_schemas_from_name(scratch.arena, rd_state->cfg_schema_table, d_entity_kind_code_name_table[entity->kind]); MD_Node *child_schema = &md_nil_node; for(MD_NodePtrNode *n = schemas.first; n != 0 && child_schema == &md_nil_node; n = n->next) { @@ -948,7 +948,7 @@ rd_eval_space_read(E_Space space, void *out, Rng1U64 range) } else if(str8_match(child_schema->string, str8_lit("dbg"), 0)) { - read_data = ctrl_entity_child_from_kind(entity, D_EntityKind_DebugInfoPath)->string; + read_data = d_entity_child_from_kind(entity, D_EntityKind_DebugInfoPath)->string; } else if(str8_match(child_schema->string, str8_lit("vaddr_range"), 0)) { @@ -960,7 +960,7 @@ rd_eval_space_read(E_Space space, void *out, Rng1U64 range) } else if(str8_match(child_schema->string, str8_lit("active"), 0)) { - B32 is_frozen = ctrl_entity_tree_is_frozen(entity); + B32 is_frozen = d_entity_tree_is_frozen(entity); B32 is_active = !is_frozen; read_data = push_str8_copy(scratch.arena, str8_struct(&is_active)); } @@ -998,7 +998,7 @@ rd_eval_space_write(E_Space space, void *in, Rng1U64 range) default:{}break; case D_EntityKind_Process: { - result = ctrl_process_write(entity->handle, range, in); + result = d_process_write(entity->handle, range, in); }break; case D_EntityKind_Thread: { @@ -1007,9 +1007,9 @@ rd_eval_space_write(E_Space space, void *in, Rng1U64 range) Rng1U64 legal_range = r1u64(0, regs_size); Rng1U64 write_range = intersect_1u64(legal_range, range); U64 write_size = dim_1u64(write_range); - void *new_regs = ctrl_reg_block_from_thread(scratch.arena, &d_user_state->ctrl_entity_store->ctx, entity->handle); + void *new_regs = d_reg_block_from_thread(scratch.arena, &d_user_state->ctrl_entity_store->ctx, entity->handle); MemoryCopy((U8 *)new_regs + write_range.min, in, write_size); - result = ctrl_thread_write_reg_block(entity->handle, new_regs); + result = d_thread_write_reg_block(entity->handle, new_regs); scratch_end(scratch); }break; } @@ -1081,7 +1081,7 @@ rd_eval_space_write(E_Space space, void *in, Rng1U64 range) // rjf: perform write, based on child name in schema if(child_key.size != 0) { - MD_NodePtrList schemas = cfg_schemas_from_name(scratch.arena, rd_state->cfg_schema_table, ctrl_entity_kind_code_name_table[entity->kind]); + MD_NodePtrList schemas = cfg_schemas_from_name(scratch.arena, rd_state->cfg_schema_table, d_entity_kind_code_name_table[entity->kind]); MD_Node *child_schema = &md_nil_node; for(MD_NodePtrNode *n = schemas.first; n != 0 && child_schema == &md_nil_node; n = n->next) { @@ -1090,7 +1090,7 @@ rd_eval_space_write(E_Space space, void *in, Rng1U64 range) if(str8_match(child_schema->string, str8_lit("label"), 0)) { result = 1; - ctrl_entity_equip_string(d_user_state->ctrl_entity_store, entity, write_string); + d_entity_equip_string(d_user_state->ctrl_entity_store, entity, write_string); rd_cmd(D_CmdKind_SetEntityName, .ctrl_entity = entity->handle, .string = write_string); } else if(str8_match(child_schema->string, str8_lit("dbg"), 0)) @@ -1144,7 +1144,7 @@ rd_key_from_eval_space_range(E_Space space, Rng1U64 range, B32 zero_terminated) D_Entity *entity = rd_ctrl_entity_from_eval_space(space); if(entity->kind == D_EntityKind_Process) { - result = ctrl_key_from_process_vaddr_range(entity->handle, range, zero_terminated, 0, 0, 0); + result = d_key_from_process_vaddr_range(entity->handle, range, zero_terminated, 0, 0, 0); } }break; } @@ -1703,7 +1703,7 @@ rd_view_ui(Rng2F32 rect) UI_Padding(ui_pct(1, 0)) UI_Focus(UI_FocusKind_Null) { CFG_NodePtrList targets = cfg_node_top_level_list_from_string(scratch.arena, str8_lit("target")); - D_EntityArray processes = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); + D_EntityArray processes = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); //- rjf: icon & info UI_Padding(ui_em(2.f, 1.f)) UI_TagF("weak") @@ -2268,9 +2268,9 @@ rd_view_ui(Rng2F32 rect) { U64 vaddr = eval.value.u64; D_Entity *process = rd_ctrl_entity_from_eval_space(eval.space); - D_Entity *module = ctrl_module_from_process_vaddr(process, vaddr); - dbgi_key = ctrl_dbgi_key_from_module(module); - voff = ctrl_voff_from_vaddr(module, vaddr); + D_Entity *module = d_module_from_process_vaddr(process, vaddr); + dbgi_key = d_dbgi_key_from_module(module); + voff = d_voff_from_vaddr(module, vaddr); } else { @@ -2361,10 +2361,10 @@ rd_view_ui(Rng2F32 rect) String8 name = {0}; { U64 vaddr = eval.value.u64; - D_Entity *process = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->process); - D_Entity *module = ctrl_module_from_process_vaddr(process, vaddr); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); - U64 voff = ctrl_voff_from_vaddr(module, vaddr); + D_Entity *process = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->process); + D_Entity *module = d_module_from_process_vaddr(process, vaddr); + DI_Key dbgi_key = d_dbgi_key_from_module(module); + U64 voff = d_voff_from_vaddr(module, vaddr); { Access *access = access_open(); RDI_Parsed *rdi = di_rdi_from_key(access, dbgi_key, 1, 0); @@ -2432,7 +2432,7 @@ rd_view_ui(Rng2F32 rect) case RD_EvalSpaceKind_MetaCtrlEntity: { D_Entity *entity = rd_ctrl_entity_from_eval_space(eval.space); - rd_cmd(RD_CmdKind_PushQuery, .expr = push_str8f(scratch.arena, "query:control.%S", ctrl_string_from_handle(scratch.arena, entity->handle))); + rd_cmd(RD_CmdKind_PushQuery, .expr = push_str8f(scratch.arena, "query:control.%S", d_string_from_handle(scratch.arena, entity->handle))); }break; } if(did_cmd) @@ -3644,7 +3644,7 @@ rd_view_ui(Rng2F32 rect) D_Entity *space_entity = rd_ctrl_entity_from_eval_space(cell->eval.space); if(cell->eval.space.kind == D_EvalSpaceKind_Entity && space_entity->kind == D_EntityKind_Process) { - D_ProcessMemorySlice slice = ctrl_process_memory_slice_from_vaddr_range(scratch.arena, space_entity->handle, cell_vaddr_rng, 0, rd_state->frame_eval_memread_endt_us); + D_ProcessMemorySlice slice = d_process_memory_slice_from_vaddr_range(scratch.arena, space_entity->handle, cell_vaddr_rng, 0, rd_state->frame_eval_memread_endt_us); for(U64 idx = 0; idx < (slice.data.size+63)/64; idx += 1) { if(slice.byte_changed_flags[idx] != 0) @@ -3719,7 +3719,7 @@ rd_view_ui(Rng2F32 rect) rgba.w *= ui_anim(ui_key_from_stringf(ui_key_zero(), "###cfg_hover_t_%p", cfg), 1.f, .rate = entity_hover_t_rate); cell_background_color_override = rgba; } - else if(ctrl_handle_match(cell_info.entity->handle, rd_get_hover_regs()->ctrl_entity) && + else if(d_handle_match(cell_info.entity->handle, rd_get_hover_regs()->ctrl_entity) && rd_state->hover_regs_slot == RD_RegSlot_CtrlEntity) { D_Entity *entity = cell_info.entity; @@ -3854,7 +3854,7 @@ rd_view_ui(Rng2F32 rect) { UI_Box *box = ui_build_box_from_stringf(UI_BoxFlag_Clickable, "###%I64x_%I64x", cell_id, row_hash); sig = ui_signal_from_box(box); - if(ctrl_handle_match(row_info->callstack_thread->handle, rd_base_regs()->thread) && + if(d_handle_match(row_info->callstack_thread->handle, rd_base_regs()->thread) && row_info->callstack_unwind_index == rd_base_regs()->unwind_count && row_info->callstack_inline_depth == rd_base_regs()->inline_depth) { @@ -4332,13 +4332,13 @@ rd_view_ui(Rng2F32 rect) else if(cell->eval.space.kind == D_EvalSpaceKind_Entity) { D_Entity *entity = rd_ctrl_entity_from_eval_space(cell->eval.space); - D_Entity *process = ctrl_process_from_entity(entity); + D_Entity *process = d_process_from_entity(entity); if(process != &d_entity_nil) { U64 vaddr = cell->eval.value.u64; - D_Entity *module = ctrl_module_from_process_vaddr(process, vaddr); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); - U64 voff = ctrl_voff_from_vaddr(module, vaddr); + D_Entity *module = d_module_from_process_vaddr(process, vaddr); + DI_Key dbgi_key = d_dbgi_key_from_module(module); + U64 voff = d_voff_from_vaddr(module, vaddr); D_LineList lines = d_lines_from_dbgi_key_voff(scratch.arena, dbgi_key, voff); String8 file_path = {0}; TxtPt pt = {0}; @@ -4737,10 +4737,10 @@ rd_arch_from_eval(E_Eval eval) { // rjf: try implicitly from either `eval` itself, or from context D_Entity *ctrl_entity = rd_ctrl_entity_from_eval_space(eval.space); - D_Entity *process = ctrl_process_from_entity(ctrl_entity); + D_Entity *process = d_process_from_entity(ctrl_entity); if(process == &d_entity_nil) { - process = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->process); + process = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->process); } Arch arch = process->arch; if(arch == Arch_Null) @@ -5498,11 +5498,11 @@ rd_window_frame(void) //////////////////////// //- rjf: control entity tooltips // - case RD_RegSlot_Machine: {ctrl_entity = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, regs->machine); }goto ctrl_entity_tooltip; - case RD_RegSlot_Process: {ctrl_entity = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, regs->process); }goto ctrl_entity_tooltip; - case RD_RegSlot_Module: {ctrl_entity = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, regs->module); }goto ctrl_entity_tooltip; - case RD_RegSlot_Thread: {ctrl_entity = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, regs->thread); }goto ctrl_entity_tooltip; - case RD_RegSlot_CtrlEntity:{ctrl_entity = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, regs->ctrl_entity); }goto ctrl_entity_tooltip; + case RD_RegSlot_Machine: {ctrl_entity = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, regs->machine); }goto ctrl_entity_tooltip; + case RD_RegSlot_Process: {ctrl_entity = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, regs->process); }goto ctrl_entity_tooltip; + case RD_RegSlot_Module: {ctrl_entity = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, regs->module); }goto ctrl_entity_tooltip; + case RD_RegSlot_Thread: {ctrl_entity = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, regs->thread); }goto ctrl_entity_tooltip; + case RD_RegSlot_CtrlEntity:{ctrl_entity = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, regs->ctrl_entity); }goto ctrl_entity_tooltip; ctrl_entity_tooltip:; UI_Tooltip { @@ -5534,8 +5534,8 @@ rd_window_frame(void) if(ctrl_entity->kind == D_EntityKind_Module) UI_TagF("weak") { Access *access = access_open(); - D_Entity *dbg_info_entity = ctrl_entity_child_from_kind(ctrl_entity, D_EntityKind_DebugInfoPath); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(ctrl_entity); + D_Entity *dbg_info_entity = d_entity_child_from_kind(ctrl_entity, D_EntityKind_DebugInfoPath); + DI_Key dbgi_key = d_dbgi_key_from_module(ctrl_entity); RDI_Parsed *rdi = di_rdi_from_key(access, dbgi_key, 0, 0); if(rdi->raw_data_size != 0) { @@ -5558,15 +5558,15 @@ rd_window_frame(void) Access *access = access_open(); Vec4F32 code_color = ui_color_from_name(str8_lit("code_default")); Vec4F32 symbol_color = ui_color_from_name(str8_lit("code_symbol")); - D_Entity *process = ctrl_entity_ancestor_from_kind(ctrl_entity, D_EntityKind_Process); - B32 call_stack_high_priority = ctrl_handle_match(ctrl_entity->handle, rd_base_regs()->thread); - D_CallStack call_stack = ctrl_call_stack_from_thread(access, ctrl_entity->handle, call_stack_high_priority, call_stack_high_priority ? rd_state->frame_eval_memread_endt_us : 0); + D_Entity *process = d_entity_ancestor_from_kind(ctrl_entity, D_EntityKind_Process); + B32 call_stack_high_priority = d_handle_match(ctrl_entity->handle, rd_base_regs()->thread); + D_CallStack call_stack = d_call_stack_from_thread(access, ctrl_entity->handle, call_stack_high_priority, call_stack_high_priority ? rd_state->frame_eval_memread_endt_us : 0); if(call_stack.frames_count != 0) { ui_spacer(ui_em(1.5f, 1.f)); } EV_StringParams string_params = {EV_StringFlag_ReadOnlyDisplayRules|rd_state->eval_viz_base_string_flags, .radix = 16}; - String8 thread_handle_string = ctrl_string_from_handle(scratch.arena, ctrl_entity->handle); + String8 thread_handle_string = d_string_from_handle(scratch.arena, ctrl_entity->handle); for(U64 idx = 0; idx < 16; idx += 1) { E_Eval rip_eval = e_eval_from_stringf("query:control.%S.call_stack[%I64u]", thread_handle_string, idx); @@ -5767,8 +5767,8 @@ rd_window_frame(void) avg_ui_hash_chain_length = chain_length_sum / chain_count; } ui_labelf("Target Hz: %.2f", 1.f/rd_state->frame_dt); - ui_labelf("Ctrl Run Index: %I64u", ctrl_run_gen()); - ui_labelf("Ctrl Mem Gen Index: %I64u", ctrl_mem_gen()); + ui_labelf("Ctrl Run Index: %I64u", d_run_gen()); + ui_labelf("Ctrl Mem Gen Index: %I64u", d_mem_gen()); ui_labelf("Window %p", w); ui_set_next_pref_width(ui_children_sum(1)); ui_set_next_pref_height(ui_children_sum(1)); @@ -7037,7 +7037,7 @@ rd_window_frame(void) { Temp scratch = scratch_begin(0, 0); CFG_NodePtrList targets = cfg_node_top_level_list_from_string(scratch.arena, str8_lit("target")); - D_EntityArray processes = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); + D_EntityArray processes = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); B32 can_send_signal = !d_ctrl_targets_running(); typedef struct CenterButtonTask CenterButtonTask; struct CenterButtonTask @@ -9565,9 +9565,9 @@ rd_string_from_exception_code(U32 code) String8 string = {0}; for EachNonZeroEnumVal(D_ExceptionCodeKind, k) { - if(code == ctrl_exception_code_kind_code_table[k]) + if(code == d_exception_code_kind_code_table[k]) { - string = ctrl_exception_code_kind_display_string_table[k]; + string = d_exception_code_kind_display_string_table[k]; break; } } @@ -9577,7 +9577,7 @@ rd_string_from_exception_code(U32 code) internal DR_FStrList rd_stop_explanation_fstrs_from_ctrl_event(Arena *arena, D_Event *event) { - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, event->entity); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, event->entity); DR_FStrList thread_fstrs = rd_title_fstrs_from_ctrl_entity(arena, thread, 0); DR_FStrList fstrs = {0}; DR_FStrParams params = {ui_top_font(), ui_top_text_raster_flags(), ui_color_from_name(str8_lit("text")), ui_top_font_size()}; @@ -11102,14 +11102,14 @@ rd_frame(void) //- rjf: unpack basic evaluation context // ProfBegin("unpack eval-dependent info"); - D_Entity *process = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->process); - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); + D_Entity *process = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->process); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); Arch arch = thread->arch; U64 unwind_count = rd_regs()->unwind_count; U64 rip_vaddr = d_query_cached_rip_from_thread_unwind(thread, unwind_count); - D_Entity *module = ctrl_module_from_process_vaddr(process, rip_vaddr); - U64 rip_voff = ctrl_voff_from_vaddr(module, rip_vaddr); - U64 tls_root_vaddr = ctrl_tls_root_vaddr_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle); + D_Entity *module = d_module_from_process_vaddr(process, rip_vaddr); + U64 rip_voff = d_voff_from_vaddr(module, rip_vaddr); + U64 tls_root_vaddr = d_tls_root_vaddr_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle); ProfEnd(); //////////////////////////// @@ -11132,7 +11132,7 @@ rd_frame(void) //////////////////////////// //- rjf: produce all eval modules // - D_EntityArray all_modules = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Module); + D_EntityArray all_modules = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Module); U64 eval_modules_count = Max(1, all_modules.count); E_Module *eval_modules = push_array(scratch.arena, E_Module, eval_modules_count); E_Module *eval_modules_primary = &eval_modules[0]; @@ -11142,7 +11142,7 @@ rd_frame(void) for EachIndex(eval_module_idx, all_modules.count) { D_Entity *m = all_modules.v[eval_module_idx]; - DI_Key dbgi_key = ctrl_dbgi_key_from_module(m); + DI_Key dbgi_key = d_dbgi_key_from_module(m); // rjf: dbgi key -> eval dbg info num U32 dbg_info_num = 0; @@ -11163,7 +11163,7 @@ rd_frame(void) eval_modules[eval_module_idx].vaddr_range = m->vaddr_range; eval_modules[eval_module_idx].arch = m->arch; eval_modules[eval_module_idx].dbg_info_num = dbg_info_num; - eval_modules[eval_module_idx].space = rd_eval_space_from_ctrl_entity(ctrl_entity_ancestor_from_kind(m, D_EntityKind_Process), D_EvalSpaceKind_Entity); + eval_modules[eval_module_idx].space = rd_eval_space_from_ctrl_entity(d_entity_ancestor_from_kind(m, D_EntityKind_Process), D_EvalSpaceKind_Entity); if(module == m) { eval_modules_primary = &eval_modules[eval_module_idx]; @@ -11513,8 +11513,8 @@ rd_frame(void) for EachElement(idx, evallable_ctrl_names) { String8 name = evallable_ctrl_names[idx]; - D_EntityKind kind = ctrl_entity_kind_from_string(name); - D_EntityArray array = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, kind); + D_EntityKind kind = d_entity_kind_from_string(name); + D_EntityArray array = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, kind); E_TypeKey type_key = e_string2typekey_map_lookup(rd_state->meta_name2type_map, name); for EachIndex(idx, array.count) { @@ -11532,15 +11532,15 @@ rd_frame(void) { e_string2expr_map_insert(scratch.arena, macro_map, str8_lit("local_machine"), expr); } - if(kind == D_EntityKind_Thread && ctrl_handle_match(rd_base_regs()->thread, entity->handle)) + if(kind == D_EntityKind_Thread && d_handle_match(rd_base_regs()->thread, entity->handle)) { e_string2expr_map_insert(scratch.arena, macro_map, str8_lit("current_thread"), expr); } - if(kind == D_EntityKind_Process && ctrl_handle_match(rd_base_regs()->process, entity->handle)) + if(kind == D_EntityKind_Process && d_handle_match(rd_base_regs()->process, entity->handle)) { e_string2expr_map_insert(scratch.arena, macro_map, str8_lit("current_process"), expr); } - if(kind == D_EntityKind_Module && ctrl_handle_match(rd_base_regs()->module, entity->handle)) + if(kind == D_EntityKind_Module && d_handle_match(rd_base_regs()->module, entity->handle)) { e_string2expr_map_insert(scratch.arena, macro_map, str8_lit("current_module"), expr); } @@ -11880,13 +11880,13 @@ rd_frame(void) //- rjf: gather config from loaded modules // CFG_NodePtrList immediate_type_views = {0}; - D_EntityArray modules = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Module); + D_EntityArray modules = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Module); ProfScope("gather config from loaded modules") { for EachIndex(idx, modules.count) { D_Entity *module = modules.v[idx]; - String8 raddbg_data = ctrl_raddbg_data_from_module(scratch.arena, module->handle); + String8 raddbg_data = d_raddbg_data_from_module(scratch.arena, module->handle); U8 split_char = 0; String8List raddbg_data_text_parts = str8_split(scratch.arena, raddbg_data, &split_char, 1, 0); U64 cfg_idx = 0; @@ -11894,7 +11894,7 @@ rd_frame(void) { String8 text = text_n->string; CFG_NodePtrList cfgs = cfg_node_ptr_list_from_string(scratch.arena, rd_state->cfg, rd_state->cfg_schema_table, str8_zero(), text); - String8 module_name = ctrl_string_from_handle(scratch.arena, module->handle); + String8 module_name = d_string_from_handle(scratch.arena, module->handle); for(CFG_NodePtrNode *n = cfgs.first; n != 0; n = n->next, cfg_idx += 1) { CFG_Node *immediate_root = rd_immediate_cfg_from_keyf("module_%S_cfg_%I64x", module_name, cfg_idx); @@ -11984,8 +11984,8 @@ rd_frame(void) E_IRCtx *ir_ctx = push_array(scratch.arena, E_IRCtx, 1); { E_IRCtx *ctx = ir_ctx; - ctx->regs_map = ctrl_string2reg_from_arch(eval_base_ctx->primary_module->arch); - ctx->reg_alias_map = ctrl_string2alias_from_arch(eval_base_ctx->primary_module->arch); + ctx->regs_map = d_string2reg_from_arch(eval_base_ctx->primary_module->arch); + ctx->reg_alias_map = d_string2alias_from_arch(eval_base_ctx->primary_module->arch); ctx->locals_map = d_query_cached_locals_map_from_dbgi_key_voff(eval_base_ctx->primary_dbg_info->dbgi_key, rip_voff); ctx->member_map = d_query_cached_member_map_from_dbgi_key_voff(eval_base_ctx->primary_dbg_info->dbgi_key, rip_voff); ctx->macro_map = macro_map; @@ -12072,7 +12072,7 @@ rd_frame(void) case RD_CmdKind_Restart: { // rjf: reset hit counts - D_EntityArray processes = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); + D_EntityArray processes = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); if(processes.count == 0 || kind == RD_CmdKind_Restart) { CFG_NodePtrList bps = cfg_node_top_level_list_from_string(scratch.arena, str8_lit("breakpoint")); @@ -12292,7 +12292,7 @@ rd_frame(void) { // rjf: if control processes are live, but this is not force-confirmed, then // get confirmation from user - D_EntityArray processes = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); + D_EntityArray processes = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); UI_Key key = ui_key_from_string(ui_key_zero(), str8_lit("lossy_exit_confirmation")); if(processes.count != 0 && !rd_regs()->force_confirm && !ui_key_match(rd_state->popup_key, key)) { @@ -13679,19 +13679,19 @@ rd_frame(void) //- rjf: source <-> disasm case RD_CmdKind_GoToDisassembly: { - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); U64 vaddr = 0; for(D_LineNode *n = rd_regs()->lines.first; n != 0; n = n->next) { - D_EntityList modules = ctrl_modules_from_dbgi_key(scratch.arena, &d_user_state->ctrl_entity_store->ctx, n->v.dbgi_key); - D_Entity *module = ctrl_module_from_thread_candidates(&d_user_state->ctrl_entity_store->ctx, thread, &modules); + D_EntityList modules = d_modules_from_dbgi_key(scratch.arena, &d_user_state->ctrl_entity_store->ctx, n->v.dbgi_key); + D_Entity *module = d_module_from_thread_candidates(&d_user_state->ctrl_entity_store->ctx, thread, &modules); if(module != &d_entity_nil) { - vaddr = ctrl_vaddr_from_voff(module, n->v.voff_range.min); + vaddr = d_vaddr_from_voff(module, n->v.voff_range.min); break; } } - rd_cmd(RD_CmdKind_FindCodeLocation, .process = ctrl_entity_ancestor_from_kind(thread, D_EntityKind_Process)->handle, .vaddr = vaddr, .prefer_disasm = 1); + rd_cmd(RD_CmdKind_FindCodeLocation, .process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process)->handle, .vaddr = vaddr, .prefer_disasm = 1); }break; case RD_CmdKind_GoToSource: { @@ -13701,7 +13701,7 @@ rd_frame(void) .file_path = rd_regs()->lines.first->v.file_path, .cursor = rd_regs()->lines.first->v.pt, .vaddr = 0, - .process = ctrl_handle_zero(), + .process = d_handle_zero(), .prefer_disasm = 0); } }break; @@ -13967,15 +13967,15 @@ rd_frame(void) Access *access = access_open(); //- rjf: unpack thread info - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); U64 unwind_index = rd_regs()->unwind_count; U64 inline_depth = rd_regs()->inline_depth; U64 rip_vaddr = d_query_cached_rip_from_thread_unwind(thread, unwind_index); - D_Entity *process = ctrl_entity_ancestor_from_kind(thread, D_EntityKind_Process); - D_Entity *module = ctrl_module_from_process_vaddr(process, rip_vaddr); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + D_Entity *process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process); + D_Entity *module = d_module_from_process_vaddr(process, rip_vaddr); + DI_Key dbgi_key = d_dbgi_key_from_module(module); RDI_Parsed *rdi = di_rdi_from_key(access, dbgi_key, 0, 0); - U64 rip_voff = ctrl_voff_from_vaddr(module, rip_vaddr); + U64 rip_voff = d_voff_from_vaddr(module, rip_vaddr); D_LineList lines = d_lines_from_dbgi_key_voff(scratch.arena, dbgi_key, rip_voff); D_Line line = {0}; { @@ -14031,7 +14031,7 @@ rd_frame(void) }break; case RD_CmdKind_FindSelectedThread: { - D_Entity *selected_thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_base_regs()->thread); + D_Entity *selected_thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_base_regs()->thread); rd_cmd(RD_CmdKind_FindThread, .thread = selected_thread->handle, .unwind_count = rd_base_regs()->unwind_count, @@ -14140,9 +14140,9 @@ rd_frame(void) { D_Entity *process = &d_entity_nil; U64 vaddr = 0; - D_EntityList modules = ctrl_modules_from_dbgi_key(scratch.arena, &d_user_state->ctrl_entity_store->ctx, voff_dbgi_key); - D_Entity *module = ctrl_entity_list_first(&modules); - process = ctrl_entity_ancestor_from_kind(module, D_EntityKind_Process); + D_EntityList modules = d_modules_from_dbgi_key(scratch.arena, &d_user_state->ctrl_entity_store->ctx, voff_dbgi_key); + D_Entity *module = d_entity_list_first(&modules); + process = d_entity_ancestor_from_kind(module, D_EntityKind_Process); if(process != &d_entity_nil) { vaddr = module->vaddr_range.min + lines.first->v.voff_range.min; @@ -14220,8 +14220,8 @@ rd_frame(void) { file_path = rd_mapped_from_file_path(scratch.arena, rd_regs()->file_path); point = rd_regs()->cursor; - thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); - process = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->process); + thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); + process = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->process); vaddr = rd_regs()->vaddr; prefer_new_tab = rd_regs()->prefer_new_tab; if(file_path.size == 0) @@ -14237,9 +14237,9 @@ rd_frame(void) D_LineList lines = d_lines_from_file_path_line_num(scratch.arena, file_path, point.line); for(D_LineNode *n = lines.first; n != 0; n = n->next) { - D_EntityList modules = ctrl_modules_from_dbgi_key(scratch.arena, &d_user_state->ctrl_entity_store->ctx, n->v.dbgi_key); - D_Entity *module = ctrl_module_from_thread_candidates(&d_user_state->ctrl_entity_store->ctx, thread, &modules); - vaddr = ctrl_vaddr_from_voff(module, n->v.voff_range.min); + D_EntityList modules = d_modules_from_dbgi_key(scratch.arena, &d_user_state->ctrl_entity_store->ctx, n->v.dbgi_key); + D_Entity *module = d_module_from_thread_candidates(&d_user_state->ctrl_entity_store->ctx, thread, &modules); + vaddr = d_vaddr_from_voff(module, n->v.voff_range.min); break; } } @@ -15441,7 +15441,7 @@ rd_frame(void) }break; case RD_CmdKind_SetNextStatement: { - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); String8 file_path = rd_regs()->file_path; U64 new_rip_vaddr = rd_regs()->vaddr_range.min; if(file_path.size != 0) @@ -15449,11 +15449,11 @@ rd_frame(void) D_LineList *lines = &rd_regs()->lines; for(D_LineNode *n = lines->first; n != 0; n = n->next) { - D_EntityList modules = ctrl_modules_from_dbgi_key(scratch.arena, &d_user_state->ctrl_entity_store->ctx, n->v.dbgi_key); - D_Entity *module = ctrl_module_from_thread_candidates(&d_user_state->ctrl_entity_store->ctx, thread, &modules); + D_EntityList modules = d_modules_from_dbgi_key(scratch.arena, &d_user_state->ctrl_entity_store->ctx, n->v.dbgi_key); + D_Entity *module = d_module_from_thread_candidates(&d_user_state->ctrl_entity_store->ctx, thread, &modules); if(module != &d_entity_nil) { - new_rip_vaddr = ctrl_vaddr_from_voff(module, n->v.voff_range.min); + new_rip_vaddr = d_vaddr_from_voff(module, n->v.voff_range.min); break; } } @@ -15566,10 +15566,10 @@ rd_frame(void) }break; case RD_CmdKind_SelectThread: { - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); - D_Entity *process = ctrl_entity_ancestor_from_kind(thread, D_EntityKind_Process); - D_Entity *module = ctrl_module_from_process_vaddr(process, ctrl_rip_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle)); - D_Entity *machine = ctrl_entity_ancestor_from_kind(process, D_EntityKind_Machine); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); + D_Entity *process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process); + D_Entity *module = d_module_from_process_vaddr(process, d_rip_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle)); + D_Entity *machine = d_entity_ancestor_from_kind(process, D_EntityKind_Machine); rd_state->base_regs.v.unwind_count = 0; rd_state->base_regs.v.inline_depth = 0; rd_state->base_regs.v.thread = thread->handle; @@ -15581,12 +15581,12 @@ rd_frame(void) case RD_CmdKind_SelectUnwind: { Access *access = access_open(); - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_base_regs()->thread); - D_CallStack call_stack = ctrl_call_stack_from_thread(access, thread->handle, 1, os_now_microseconds()+10000); - D_CallStackFrame *frame = ctrl_call_stack_frame_from_unwind_and_inline_depth(&call_stack, rd_regs()->unwind_count, rd_regs()->inline_depth); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_base_regs()->thread); + D_CallStack call_stack = d_call_stack_from_thread(access, thread->handle, 1, os_now_microseconds()+10000); + D_CallStackFrame *frame = d_call_stack_frame_from_unwind_and_inline_depth(&call_stack, rd_regs()->unwind_count, rd_regs()->inline_depth); if(frame == 0) { - frame = ctrl_call_stack_frame_from_unwind_and_inline_depth(&call_stack, rd_regs()->unwind_count, 0); + frame = d_call_stack_frame_from_unwind_and_inline_depth(&call_stack, rd_regs()->unwind_count, 0); } if(frame) { @@ -15600,9 +15600,9 @@ rd_frame(void) case RD_CmdKind_DownOneFrame: { Access *access = access_open(); - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_base_regs()->thread); - D_CallStack call_stack = ctrl_call_stack_from_thread(access, thread->handle, 1, os_now_microseconds()+10000); - D_CallStackFrame *current_frame = ctrl_call_stack_frame_from_unwind_and_inline_depth(&call_stack, rd_regs()->unwind_count, rd_regs()->inline_depth); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_base_regs()->thread); + D_CallStack call_stack = d_call_stack_from_thread(access, thread->handle, 1, os_now_microseconds()+10000); + D_CallStackFrame *current_frame = d_call_stack_frame_from_unwind_and_inline_depth(&call_stack, rd_regs()->unwind_count, rd_regs()->inline_depth); D_CallStackFrame *next_frame = current_frame; if(current_frame != 0) switch(kind) { @@ -16304,7 +16304,7 @@ rd_frame(void) { for EachNonZeroEnumVal(D_ExceptionCodeKind, k) { - String8 name = ctrl_exception_code_kind_lowercase_code_string_table[k]; + String8 name = d_exception_code_kind_lowercase_code_string_table[k]; B32 setting = rd_setting_b32_from_name(name); if(setting) { @@ -16331,8 +16331,8 @@ rd_frame(void) default:{}break; case D_EventKind_NewModule: { - D_Entity *module = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, evt->entity); - D_Entity *debug_info_path = ctrl_entity_child_from_kind(module, D_EntityKind_DebugInfoPath); + D_Entity *module = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, evt->entity); + D_Entity *debug_info_path = d_entity_child_from_kind(module, D_EntityKind_DebugInfoPath); String8 new_path = debug_info_path->string; if(new_path.size != 0 && os_file_path_exists(new_path)) { @@ -16369,7 +16369,7 @@ rd_frame(void) case D_EventKind_EndProc: if(rd_state->quit_after_success) { - D_EntityArray processes = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); + D_EntityArray processes = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); if(evt->u64_code == 0 && processes.count == 0) { rd_cmd(RD_CmdKind_Exit); @@ -16382,12 +16382,12 @@ rd_frame(void) case D_EventKind_Stopped: { B32 need_refocus = (evt->cause != D_EventCause_InterruptedByHalt || !soft_halt_issued); - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, evt->entity); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, evt->entity); U64 vaddr = evt->rip_vaddr; - D_Entity *process = ctrl_entity_ancestor_from_kind(thread, D_EntityKind_Process); - D_Entity *module = ctrl_module_from_process_vaddr(process, vaddr); - U64 voff = ctrl_voff_from_vaddr(module, vaddr); - U64 test_cached_vaddr = ctrl_rip_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle); + D_Entity *process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process); + D_Entity *module = d_module_from_process_vaddr(process, vaddr); + U64 voff = d_voff_from_vaddr(module, vaddr); + U64 test_cached_vaddr = d_rip_from_thread(&d_user_state->ctrl_entity_store->ctx, thread->handle); // rjf: valid stop thread? -> select & snap if(need_refocus && thread != &d_entity_nil && evt->cause != D_EventCause_InterruptedByHalt) @@ -16396,7 +16396,7 @@ rd_frame(void) } // rjf: no stop-causing thread, but have selected thread? -> snap to selected - D_Entity *selected_thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_base_regs()->thread); + D_Entity *selected_thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_base_regs()->thread); if(need_refocus && (evt->cause == D_EventCause_InterruptedByHalt || thread == &d_entity_nil) && selected_thread != &d_entity_nil) { rd_cmd(RD_CmdKind_SelectThread, .thread = selected_thread->handle); @@ -16405,8 +16405,8 @@ rd_frame(void) // rjf: no stop-causing thread, but don't have selected thread? -> snap to first available thread if(need_refocus && thread == &d_entity_nil && selected_thread == &d_entity_nil) { - D_EntityArray threads = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Thread); - D_Entity *first_available_thread = ctrl_entity_array_first(&threads); + D_EntityArray threads = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Thread); + D_Entity *first_available_thread = d_entity_array_first(&threads); rd_cmd(RD_CmdKind_SelectThread, .thread = first_available_thread->handle); } @@ -16469,7 +16469,7 @@ rd_frame(void) ////////////////////////////// //- rjf: retry find-thread // - if(!ctrl_handle_match(ctrl_handle_zero(), find_thread_retry)) + if(!d_handle_match(d_handle_zero(), find_thread_retry)) { rd_cmd(RD_CmdKind_FindThread, .thread = find_thread_retry); } diff --git a/src/raddbg/raddbg_eval.c b/src/raddbg/raddbg_eval.c index 91c4fe58..710b5bbd 100644 --- a/src/raddbg/raddbg_eval.c +++ b/src/raddbg/raddbg_eval.c @@ -205,7 +205,7 @@ E_TYPE_EXPAND_RANGE_FUNCTION_DEF(locals) E_TYPE_EXPAND_INFO_FUNCTION_DEF(registers) { Temp scratch = scratch_begin(&arena, 1); - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); Arch arch = thread->arch; U64 reg_count = regs_reg_code_count_from_arch(arch); String8 *reg_strings = regs_reg_code_string_table_from_arch(arch); @@ -309,7 +309,7 @@ E_TYPE_ACCESS_FUNCTION_DEF(schema) } else if(entity != &d_entity_nil && str8_match(child_schema->string, str8_lit("dbg"), 0)) { - D_Entity *dbg = ctrl_entity_child_from_kind(entity, D_EntityKind_DebugInfoPath); + D_Entity *dbg = d_entity_child_from_kind(entity, D_EntityKind_DebugInfoPath); child_type_key = e_type_key_cons_array(e_type_key_basic(E_TypeKind_U8), dbg->string.size, type_flags|E_TypeFlag_IsPathText); } @@ -658,11 +658,11 @@ E_TYPE_ACCESS_FUNCTION_DEF(control) if(rhs->kind == E_ExprKind_LeafIdentifier && str8_match(str8_prefix(rhs->string, 1), str8_lit("$"), 0)) { - D_Handle handle = ctrl_handle_from_string(rhs->string); - D_Entity *entity = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, handle); + D_Handle handle = d_handle_from_string(rhs->string); + D_Entity *entity = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, handle); E_Space space = rd_eval_space_from_ctrl_entity(entity, RD_EvalSpaceKind_MetaCtrlEntity); result.root = e_irtree_set_space(arena, space, e_irtree_const_u(arena, 0)); - result.type_key = e_string2typekey_map_lookup(rd_state->meta_name2type_map, ctrl_entity_kind_code_name_table[entity->kind]); + result.type_key = e_string2typekey_map_lookup(rd_state->meta_name2type_map, d_entity_kind_code_name_table[entity->kind]); result.mode = E_Mode_Offset; } return result; @@ -957,10 +957,10 @@ E_TYPE_IREXT_FUNCTION_DEF(call_stack) D_Entity *entity = rd_ctrl_entity_from_eval_space(interp.space); if(entity->kind == D_EntityKind_Thread) { - B32 call_stack_high_priority = ctrl_handle_match(entity->handle, rd_base_regs()->thread); + B32 call_stack_high_priority = d_handle_match(entity->handle, rd_base_regs()->thread); accel->arch = entity->arch; - accel->process = ctrl_process_from_entity(entity)->handle; - accel->call_stack = ctrl_call_stack_from_thread(rd_state->frame_access, entity->handle, call_stack_high_priority, call_stack_high_priority ? rd_state->frame_eval_memread_endt_us : 0); + accel->process = d_process_from_entity(entity)->handle; + accel->call_stack = d_call_stack_from_thread(rd_state->frame_access, entity->handle, call_stack_high_priority, call_stack_high_priority ? rd_state->frame_eval_memread_endt_us : 0); } scratch_end(scratch); } @@ -978,7 +978,7 @@ E_TYPE_ACCESS_FUNCTION_DEF(call_stack) D_CallStack *call_stack = &accel->call_stack; if(0 <= rhs_value.u64 && rhs_value.u64 < call_stack->frames_count) { - D_Entity *process = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, accel->process); + D_Entity *process = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, accel->process); D_CallStackFrame *f = &call_stack->frames[rhs_value.u64]; result.root = e_irtree_set_space(arena, rd_eval_space_from_ctrl_entity(process, D_EvalSpaceKind_Entity), e_irtree_const_u(arena, regs_rip_from_arch_block(accel->arch, f->regs))); result.type_key = e_type_key_cons(.arch = process->arch, .kind = E_TypeKind_Ptr, .direct_key = e_type_key_basic(E_TypeKind_Function), .count = 1, .depth = f->inline_depth); @@ -1438,7 +1438,7 @@ E_TYPE_EXPAND_INFO_FUNCTION_DEF(unattached_processes) } else { - machines = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Machine); + machines = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Machine); } //- rjf: gather system processes from this machine @@ -1516,7 +1516,7 @@ E_TYPE_EXPAND_RANGE_FUNCTION_DEF(unattached_processes) for(U64 idx = idx_range.min; idx < idx_range.max; idx += 1, out_idx += 1) { D_Entity *machine = accel->machines[idx]; - String8 string = ctrl_string_from_handle(arena, machine->handle); + String8 string = d_string_from_handle(arena, machine->handle); evals_out[out_idx] = e_eval_wrapf(eval, "query:control.%S.unattached_processes.$%I64x$%I64x", string, accel->infos[idx].pid, e_id_from_string(accel->infos[idx].name)); } } @@ -1534,16 +1534,16 @@ E_TYPE_ACCESS_FUNCTION_DEF(ctrl_entities) case E_ExprKind_MemberAccess: { String8 rhs_name = expr->first->next->string; - D_Handle handle = ctrl_handle_from_string(rhs_name); - entity = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, handle); + D_Handle handle = d_handle_from_string(rhs_name); + entity = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, handle); }break; case E_ExprKind_ArrayIndex: { E_Type *type = e_type_from_key(lhs_irtree->type_key); - D_EntityKind kind = ctrl_entity_kind_from_string(rd_singular_from_code_name_plural(type->name)); + D_EntityKind kind = d_entity_kind_from_string(rd_singular_from_code_name_plural(type->name)); E_Value rhs_value = e_value_from_expr(expr->first->next); U64 rhs_idx = rhs_value.u64; - D_EntityArray entities = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, kind); + D_EntityArray entities = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, kind); if(0 <= rhs_idx && rhs_idx < entities.count) { entity = entities.v[rhs_idx]; @@ -1553,7 +1553,7 @@ E_TYPE_ACCESS_FUNCTION_DEF(ctrl_entities) if(entity != &d_entity_nil) { E_Space space = rd_eval_space_from_ctrl_entity(entity, RD_EvalSpaceKind_MetaCtrlEntity); - String8 name = ctrl_entity_kind_code_name_table[entity->kind]; + String8 name = d_entity_kind_code_name_table[entity->kind]; E_TypeKey type_key = e_string2typekey_map_lookup(rd_state->meta_name2type_map, name); result.root = e_irtree_set_space(arena, space, e_irtree_const_u(arena, 0)); result.type_key = type_key; @@ -1579,13 +1579,13 @@ E_TYPE_EXPAND_INFO_FUNCTION_DEF(ctrl_entities) E_TypeKey lhs_type_key = eval.irtree.type_key; E_Type *lhs_type = e_type_from_key(lhs_type_key); String8 name = rd_singular_from_code_name_plural(lhs_type->name); - D_EntityKind entity_kind = ctrl_entity_kind_from_string(name); + D_EntityKind entity_kind = d_entity_kind_from_string(name); //- rjf: gather array of all entities which fit the bill D_EntityArray array = {0}; if(scoping_entity == &d_entity_nil) { - array = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, entity_kind); + array = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, entity_kind); } else { @@ -1594,10 +1594,10 @@ E_TYPE_EXPAND_INFO_FUNCTION_DEF(ctrl_entities) { if(child->kind == entity_kind) { - ctrl_entity_list_push(scratch.arena, &list, child); + d_entity_list_push(scratch.arena, &list, child); } } - array = ctrl_entity_array_from_list(arena, &list); + array = d_entity_array_from_list(arena, &list); } //- rjf: filter the array @@ -1613,10 +1613,10 @@ E_TYPE_EXPAND_INFO_FUNCTION_DEF(ctrl_entities) FuzzyMatchRangeList matches = fuzzy_match_find(scratch.arena, filter, title_string); if(matches.count == matches.needle_part_count) { - ctrl_entity_list_push(scratch.arena, &list__filtered, entity); + d_entity_list_push(scratch.arena, &list__filtered, entity); } } - array__filtered = ctrl_entity_array_from_list(arena, &list__filtered); + array__filtered = d_entity_array_from_list(arena, &list__filtered); } //- rjf: list -> array & fill @@ -1639,7 +1639,7 @@ E_TYPE_EXPAND_RANGE_FUNCTION_DEF(ctrl_entities) { Temp scratch = scratch_begin(&arena, 1); D_Entity *entity = entities->v[out_idx + read_range.min]; - evals_out[out_idx] = e_eval_from_stringf("query:control.%S", ctrl_string_from_handle(scratch.arena, entity->handle)); + evals_out[out_idx] = e_eval_from_stringf("query:control.%S", d_string_from_handle(scratch.arena, entity->handle)); scratch_end(scratch); } } @@ -1675,7 +1675,7 @@ struct RD_CallStackTreeExpandAccel E_TYPE_EXPAND_INFO_FUNCTION_DEF(call_stack_tree) { Access *access = access_open(); - D_CallStackTree call_stack_tree = ctrl_call_stack_tree(access, 0); + D_CallStackTree call_stack_tree = d_call_stack_tree(access, 0); access_close(access); RD_CallStackTreeExpandAccel *accel = push_array(arena, RD_CallStackTreeExpandAccel, 1); accel->node = &d_call_stack_tree_node_nil; @@ -1703,7 +1703,7 @@ E_TYPE_EXPAND_INFO_FUNCTION_DEF(call_stack_tree) accel->children[idx] = n; } } - accel->threads = ctrl_handle_array_from_list(arena, &accel->node->threads); + accel->threads = d_handle_array_from_list(arena, &accel->node->threads); E_TypeExpandInfo result = {accel}; result.expr_count = accel->node->child_count + accel->threads.count; return result; @@ -1724,7 +1724,7 @@ E_TYPE_EXPAND_RANGE_FUNCTION_DEF(call_stack_tree) } else if(node->child_count <= idx && idx < node->child_count + accel->threads.count) { - eval = e_eval_from_stringf("query:control.%S", ctrl_string_from_handle(scratch.arena, accel->threads.v[idx - node->child_count])); + eval = e_eval_from_stringf("query:control.%S", d_string_from_handle(scratch.arena, accel->threads.v[idx - node->child_count])); } evals_out[idx] = eval; } diff --git a/src/raddbg/raddbg_main.c b/src/raddbg/raddbg_main.c index 7c3aa432..ed4e2576 100644 --- a/src/raddbg/raddbg_main.c +++ b/src/raddbg/raddbg_main.c @@ -545,7 +545,7 @@ entry_point(CmdLine *cmd_line) r_init(cmd_line); fnt_init(); rd_init(cmd_line); - ctrl_set_wakeup_hook(wakeup_hook_ctrl); + d_set_wakeup_hook(wakeup_hook_ctrl); } //- rjf: set up shared resources for ipc to this instance; launch IPC signaler thread diff --git a/src/raddbg/raddbg_views.c b/src/raddbg/raddbg_views.c index aaa7d91f..fb3fe45e 100644 --- a/src/raddbg/raddbg_views.c +++ b/src/raddbg/raddbg_views.c @@ -44,8 +44,8 @@ rd_code_view_build(Arena *arena, RD_CodeViewState *cv, RD_CodeViewBuildFlags fla F32 scroll_bar_dim = floor_f32(main_font_size*1.5f); Vec2F32 code_area_dim = v2f32(panel_box_dim.x - scroll_bar_dim, panel_box_dim.y - scroll_bar_dim); S64 num_possible_visible_lines = (S64)(code_area_dim.y/code_line_height)+1; - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); - D_Entity *process = ctrl_entity_ancestor_from_kind(thread, D_EntityKind_Process); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); + D_Entity *process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process); B32 do_line_numbers = rd_setting_b32_from_name(str8_lit("show_line_numbers")); ////////////////////////////// @@ -277,19 +277,19 @@ rd_code_view_build(Arena *arena, RD_CodeViewState *cv, RD_CodeViewBuildFlags fla // rjf: find live threads mapping to source code if(!dasm_lines) ProfScope("find live threads mapping to this file") { - D_Entity *selected_thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); - D_EntityArray threads = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Thread); + D_Entity *selected_thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); + D_EntityArray threads = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Thread); for EachIndex(idx, threads.count) { D_Entity *thread = threads.v[idx]; - D_Entity *process = ctrl_entity_ancestor_from_kind(thread, D_EntityKind_Process); + D_Entity *process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process); U64 unwind_count = (thread == selected_thread) ? rd_regs()->unwind_count : 0; U64 inline_depth = (thread == selected_thread) ? rd_regs()->inline_depth : 0; U64 rip_vaddr = d_query_cached_rip_from_thread_unwind(thread, unwind_count); U64 last_inst_on_unwound_rip_vaddr = rip_vaddr - !!unwind_count; - D_Entity *module = ctrl_module_from_process_vaddr(process, last_inst_on_unwound_rip_vaddr); - U64 rip_voff = ctrl_voff_from_vaddr(module, last_inst_on_unwound_rip_vaddr); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + D_Entity *module = d_module_from_process_vaddr(process, last_inst_on_unwound_rip_vaddr); + U64 rip_voff = d_voff_from_vaddr(module, last_inst_on_unwound_rip_vaddr); + DI_Key dbgi_key = d_dbgi_key_from_module(module); D_LineList lines = d_lines_from_dbgi_key_voff(scratch.arena, dbgi_key, rip_voff); for(D_LineNode *n = lines.first; n != 0; n = n->next) { @@ -302,7 +302,7 @@ rd_code_view_build(Arena *arena, RD_CodeViewState *cv, RD_CodeViewBuildFlags fla if(path_match_normalized(n->v.file_path, override_n->string)) { U64 slice_line_idx = n->v.pt.line-visible_line_num_range.min; - ctrl_entity_list_push(scratch.arena, &code_slice_params.line_ips[slice_line_idx], thread); + d_entity_list_push(scratch.arena, &code_slice_params.line_ips[slice_line_idx], thread); break; } } @@ -340,8 +340,8 @@ rd_code_view_build(Arena *arena, RD_CodeViewState *cv, RD_CodeViewBuildFlags fla if(!dasm_lines) ProfScope("find all src -> dasm info for source code") { String8 file_path = rd_regs()->file_path; - D_Entity *module = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->module); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + D_Entity *module = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->module); + DI_Key dbgi_key = d_dbgi_key_from_module(module); D_LineListArray lines_array = d_lines_array_from_dbgi_key_file_path_line_range(scratch.arena, dbgi_key, file_path, visible_line_num_range); if(lines_array.count != 0) { @@ -353,21 +353,21 @@ rd_code_view_build(Arena *arena, RD_CodeViewState *cv, RD_CodeViewBuildFlags fla // rjf: find live threads mapping to disasm if(dasm_lines) ProfScope("find live threads mapping to this disassembly") { - D_Entity *selected_thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); - D_EntityArray threads = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Thread); + D_Entity *selected_thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); + D_EntityArray threads = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Thread); for EachIndex(idx, threads.count) { D_Entity *thread = threads.v[idx]; U64 unwind_count = (thread == selected_thread) ? rd_regs()->unwind_count : 0; U64 rip_vaddr = d_query_cached_rip_from_thread_unwind(thread, unwind_count); - if(ctrl_entity_ancestor_from_kind(thread, D_EntityKind_Process) == process && contains_1u64(dasm_vaddr_range, rip_vaddr)) + if(d_entity_ancestor_from_kind(thread, D_EntityKind_Process) == process && contains_1u64(dasm_vaddr_range, rip_vaddr)) { U64 rip_off = rip_vaddr - dasm_vaddr_range.min; S64 line_num = dasm_line_array_idx_from_code_off__linear_scan(dasm_lines, rip_off)+1; if(contains_1s64(visible_line_num_range, line_num)) { U64 slice_line_idx = (line_num-visible_line_num_range.min); - ctrl_entity_list_push(scratch.arena, &code_slice_params.line_ips[slice_line_idx], thread); + d_entity_list_push(scratch.arena, &code_slice_params.line_ips[slice_line_idx], thread); } } } @@ -422,12 +422,12 @@ rd_code_view_build(Arena *arena, RD_CodeViewState *cv, RD_CodeViewBuildFlags fla // rjf: fill dasm -> src info if(dasm_lines) { - D_Entity *module = ctrl_module_from_process_vaddr(process, dasm_vaddr_range.min); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + D_Entity *module = d_module_from_process_vaddr(process, dasm_vaddr_range.min); + DI_Key dbgi_key = d_dbgi_key_from_module(module); for(S64 line_num = visible_line_num_range.min; line_num < visible_line_num_range.max; line_num += 1) { U64 vaddr = dasm_vaddr_range.min + dasm_line_array_code_off_from_idx(dasm_lines, line_num-1); - U64 voff = ctrl_voff_from_vaddr(module, vaddr); + U64 voff = d_voff_from_vaddr(module, vaddr); U64 slice_idx = line_num-visible_line_num_range.min; code_slice_params.line_vaddrs[slice_idx] = vaddr; code_slice_params.line_infos[slice_idx] = d_lines_from_dbgi_key_voff(scratch.arena, dbgi_key, voff); @@ -977,7 +977,7 @@ rd_watch_row_info_from_row(Arena *arena, EV_Row *row) } if(evalled_entity != &d_entity_nil) { - String8 top_level_name = ctrl_entity_kind_code_name_table[evalled_entity->kind]; + String8 top_level_name = d_entity_kind_code_name_table[evalled_entity->kind]; E_TypeKey top_level_type_key = e_string2typekey_map_lookup(rd_state->meta_name2type_map, top_level_name); is_top_level = (row->eval.value.u64 == 0 && e_type_key_match(top_level_type_key, row->eval.irtree.type_key)); } @@ -1002,13 +1002,13 @@ rd_watch_row_info_from_row(Arena *arena, EV_Row *row) case D_EntityKind_Process: if(row->eval.irtree.mode == E_Mode_Offset) { - info.module = ctrl_module_from_process_vaddr(row_ctrl_entity, row->eval.value.u64); + info.module = d_module_from_process_vaddr(row_ctrl_entity, row->eval.value.u64); }break; case D_EntityKind_Thread: if(row->eval.irtree.mode == E_Mode_Value) { - D_Entity *process = ctrl_process_from_entity(row_ctrl_entity); - info.module = ctrl_module_from_process_vaddr(process, d_query_cached_rip_from_thread(row_ctrl_entity)); + D_Entity *process = d_process_from_entity(row_ctrl_entity); + info.module = d_module_from_process_vaddr(process, d_query_cached_rip_from_thread(row_ctrl_entity)); }break; } } @@ -1024,8 +1024,8 @@ rd_watch_row_info_from_row(Arena *arena, EV_Row *row) Access *access = access_open(); info.callstack_thread = entity; U64 frame_num = ev_block_num_from_id(block, key.child_id); - B32 call_stack_high_priority = ctrl_handle_match(entity->handle, rd_base_regs()->thread); - D_CallStack call_stack = ctrl_call_stack_from_thread(access, entity->handle, call_stack_high_priority, call_stack_high_priority ? rd_state->frame_eval_memread_endt_us : 0); + B32 call_stack_high_priority = d_handle_match(entity->handle, rd_base_regs()->thread); + D_CallStack call_stack = d_call_stack_from_thread(access, entity->handle, call_stack_high_priority, call_stack_high_priority ? rd_state->frame_eval_memread_endt_us : 0); if(1 <= frame_num && frame_num <= call_stack.frames_count) { D_CallStackFrame *f = &call_stack.frames[frame_num-1]; @@ -1313,7 +1313,7 @@ rd_watch_row_info_from_row(Arena *arena, EV_Row *row) if(entity->kind == D_EntityKind_Thread) { RD_CmdKind cmd_kind = RD_CmdKind_SelectEntity; - if(ctrl_handle_match(entity->handle, rd_base_regs()->thread)) + if(d_handle_match(entity->handle, rd_base_regs()->thread)) { cmd_kind = RD_CmdKind_DeselectEntity; } @@ -1408,9 +1408,9 @@ rd_watch_row_info_from_row(Arena *arena, EV_Row *row) else if(info.callstack_thread != &d_entity_nil) { info.cell_style_key = str8_lit("call_stack_frame"); - D_Entity *process = ctrl_process_from_entity(info.callstack_thread); - D_Entity *module = ctrl_module_from_process_vaddr(process, info.callstack_vaddr); - E_Eval module_eval = e_eval_from_stringf("query:control.%S", ctrl_string_from_handle(scratch.arena, module->handle)); + D_Entity *process = d_process_from_entity(info.callstack_thread); + D_Entity *module = d_module_from_process_vaddr(process, info.callstack_vaddr); + E_Eval module_eval = e_eval_from_stringf("query:control.%S", d_string_from_handle(scratch.arena, module->handle)); CFG_Node *view = cfg_node_from_id(rd_regs()->view); CFG_Node *style = cfg_node_child_from_string(view, info.cell_style_key); CFG_Node *w_cfg = style->first; @@ -2099,8 +2099,8 @@ RD_VIEW_UI_FUNCTION_DEF(text) if(rd_regs()->lang_kind == TXT_LangKind_Null) { Access *access = access_open(); - D_Entity *module = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->module); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + D_Entity *module = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->module); + DI_Key dbgi_key = d_dbgi_key_from_module(module); RDI_Parsed *rdi = di_rdi_from_key(access, dbgi_key, 0, 0); if(rdi != &rdi_parsed_nil) { @@ -2223,8 +2223,8 @@ RD_VIEW_UI_FUNCTION_DEF(text) // if(rd_regs()->file_path.size != 0) { - D_Entity *module = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->module); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + D_Entity *module = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->module); + DI_Key dbgi_key = d_dbgi_key_from_module(module); rd_regs()->lines = d_lines_from_dbgi_key_file_path_line_num(rd_frame_arena(), dbgi_key, rd_regs()->file_path, rd_regs()->cursor.line); } @@ -2430,16 +2430,16 @@ RD_VIEW_UI_FUNCTION_DEF(disasm) E_Space auto_space = {0}; if(eval.expr == &e_expr_nil) { - if(dv->temp_look_vaddr != 0 && dv->temp_look_run_gen == ctrl_run_gen()) + if(dv->temp_look_vaddr != 0 && dv->temp_look_run_gen == d_run_gen()) { auto_selected = 1; - auto_space = rd_eval_space_from_ctrl_entity(ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, dv->temp_look_process), D_EvalSpaceKind_Entity); + auto_space = rd_eval_space_from_ctrl_entity(d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, dv->temp_look_process), D_EvalSpaceKind_Entity); eval = e_eval_from_stringf("(0x%I64x & (~(0x4000 - 1)))", dv->temp_look_vaddr); } else { auto_selected = 1; - auto_space = rd_eval_space_from_ctrl_entity(ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->process), D_EvalSpaceKind_Entity); + auto_space = rd_eval_space_from_ctrl_entity(d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->process), D_EvalSpaceKind_Entity); eval = e_eval_from_stringf("(reg:rip & (~(0x4000 - 1)))"); } } @@ -2468,7 +2468,7 @@ RD_VIEW_UI_FUNCTION_DEF(disasm) { dv->temp_look_process = cmd->regs->process; dv->temp_look_vaddr = cmd->regs->vaddr; - dv->temp_look_run_gen = ctrl_run_gen(); + dv->temp_look_run_gen = d_run_gen(); dv->goto_vaddr = cmd->regs->vaddr; }break; } @@ -2494,8 +2494,8 @@ RD_VIEW_UI_FUNCTION_DEF(disasm) case D_EntityKind_Process: { if(arch == Arch_Null) { arch = space_entity->arch; } - dasm_module = ctrl_module_from_process_vaddr(space_entity, range.min); - dbgi_key = ctrl_dbgi_key_from_module(dasm_module); + dasm_module = d_module_from_process_vaddr(space_entity, range.min); + dbgi_key = d_dbgi_key_from_module(dasm_module); base_vaddr = dasm_module->vaddr_range.min; }break; } @@ -2584,7 +2584,7 @@ RD_VIEW_UI_FUNCTION_DEF(disasm) rd_regs()->prefer_disasm = 1; rd_regs()->vaddr = range.min+off; rd_regs()->vaddr_range = r1u64(range.min+off, range.min+off); - rd_regs()->voff_range = ctrl_voff_range_from_vaddr_range(dasm_module, rd_regs()->vaddr_range); + rd_regs()->voff_range = d_voff_range_from_vaddr_range(dasm_module, rd_regs()->vaddr_range); rd_regs()->lines = d_lines_from_dbgi_key_voff(rd_frame_arena(), dbgi_key, rd_regs()->voff_range.min); } @@ -2680,7 +2680,7 @@ RD_VIEW_UI_FUNCTION_DEF(memory) Rng1U64 view_range = rd_space_range_from_eval(eval); if(eval.space.kind == 0) { - eval.space = rd_eval_space_from_ctrl_entity(ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->process), D_EvalSpaceKind_Entity); + eval.space = rd_eval_space_from_ctrl_entity(d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->process), D_EvalSpaceKind_Entity); view_range = rd_whole_range_from_eval_space(eval.space); } @@ -3223,7 +3223,7 @@ RD_VIEW_UI_FUNCTION_DEF(memory) D_Entity *entity = rd_ctrl_entity_from_eval_space(eval.space); if(entity->kind == D_EntityKind_Process) { - D_ProcessMemorySlice slice = ctrl_process_memory_slice_from_vaddr_range(scratch.arena, entity->handle, viz_range_bytes, 0, 0); + D_ProcessMemorySlice slice = d_process_memory_slice_from_vaddr_range(scratch.arena, entity->handle, viz_range_bytes, 0, 0); visible_memory_change_flags = slice.byte_changed_flags; visible_memory_bad_flags = slice.byte_bad_flags; } @@ -3258,9 +3258,9 @@ RD_VIEW_UI_FUNCTION_DEF(memory) AnnotationList *visible_memory_annotations = push_array(scratch.arena, AnnotationList, visible_memory_size); { Access *access = access_open(); - D_Entity *selected_thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); - D_Entity *selected_process = ctrl_entity_ancestor_from_kind(selected_thread, D_EntityKind_Process); - D_CallStack selected_call_stack = ctrl_call_stack_from_thread(access, selected_thread->handle, 1, 0); + D_Entity *selected_thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); + D_Entity *selected_process = d_entity_ancestor_from_kind(selected_thread, D_EntityKind_Process); + D_CallStack selected_call_stack = d_call_stack_from_thread(access, selected_thread->handle, 1, 0); D_Entity *eval_process = &d_entity_nil; if(eval.space.kind == D_EvalSpaceKind_Entity) { @@ -3309,9 +3309,9 @@ RD_VIEW_UI_FUNCTION_DEF(memory) Access *access = access_open(); U64 f_rip_vaddr = last_rip; last_rip = regs_rip_from_arch_block(selected_thread->arch, f->regs); - D_Entity *module = ctrl_module_from_process_vaddr(selected_process, f_rip_vaddr); - U64 f_rip_voff = ctrl_voff_from_vaddr(module, f_rip_vaddr); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + D_Entity *module = d_module_from_process_vaddr(selected_process, f_rip_vaddr); + U64 f_rip_voff = d_voff_from_vaddr(module, f_rip_vaddr); + DI_Key dbgi_key = d_dbgi_key_from_module(module); RDI_Parsed *rdi = di_rdi_from_key(access, dbgi_key, 0, 0); RDI_Symbol *procedure = rdi_procedure_from_voff(rdi, f_rip_voff); String8 procedure_name = {0}; @@ -3352,11 +3352,11 @@ RD_VIEW_UI_FUNCTION_DEF(memory) { next_vaddr = vaddr+1; Access *access = access_open(); - D_Entity *module = ctrl_module_from_process_vaddr(eval_process, vaddr); + D_Entity *module = d_module_from_process_vaddr(eval_process, vaddr); if(module != &d_entity_nil) { - U64 voff = ctrl_voff_from_vaddr(module, vaddr); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + U64 voff = d_voff_from_vaddr(module, vaddr); + DI_Key dbgi_key = d_dbgi_key_from_module(module); RDI_Parsed *rdi = di_rdi_from_key(access, dbgi_key, 0, 0); RDI_Symbol *procedure = rdi_procedure_from_voff(rdi, voff); RDI_Scope *root_scope = rdi_element_from_name_idx(rdi, Scopes, procedure->root_scope_idx); @@ -3364,7 +3364,7 @@ RD_VIEW_UI_FUNCTION_DEF(memory) { Rng1U64 voff_range = r1u64(rdi_first_voff_from_scope(rdi, root_scope), rdi_opl_voff_from_scope(rdi, root_scope)); - Rng1U64 vaddr_range = ctrl_vaddr_range_from_voff_range(module, voff_range); + Rng1U64 vaddr_range = d_vaddr_range_from_voff_range(module, voff_range); next_vaddr = vaddr_range.max; next_vaddr = Max(next_vaddr, vaddr+1); Rng1U64 vaddr_range_in_visible = intersect_1u64(vaddr_range, viz_range_bytes); diff --git a/src/raddbg/raddbg_widgets.c b/src/raddbg/raddbg_widgets.c index 586d2964..666effcb 100644 --- a/src/raddbg/raddbg_widgets.c +++ b/src/raddbg/raddbg_widgets.c @@ -108,7 +108,7 @@ rd_title_fstrs_from_cfg(Arena *arena, CFG_Node *cfg, B32 include_extras) CFG_Node *bp = cfg_node_from_id(stop_event.u64_code); if(bp == cfg) { - D_Entity *thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, stop_event.entity); + D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, stop_event.entity); Vec4F32 thread_color = rd_color_from_ctrl_entity(thread); if(thread_color.w == 0) { @@ -487,7 +487,7 @@ rd_title_fstrs_from_ctrl_entity(Arena *arena, D_Entity *entity, B32 include_extr if((entity->kind == D_EntityKind_Machine || entity->kind == D_EntityKind_Process || entity->kind == D_EntityKind_Thread) && - ctrl_entity_tree_is_frozen(entity)) + d_entity_tree_is_frozen(entity)) UI_TagF("bad") { dr_fstrs_push_new(arena, &result, ¶ms, rd_icon_kind_text_table[RD_IconKind_Locked], .font = rd_font_from_slot(RD_FontSlot_Icons), .raster_flags = rd_raster_flags_from_slot(RD_FontSlot_Icons), .color = ui_color_from_name(str8_lit("text"))); @@ -497,7 +497,7 @@ rd_title_fstrs_from_ctrl_entity(Arena *arena, D_Entity *entity, B32 include_extr //- rjf: push selected icon, if selected thread if(entity->kind == D_EntityKind_Thread) { - B32 is_selected = ctrl_handle_match(entity->handle, rd_base_regs()->thread); + B32 is_selected = d_handle_match(entity->handle, rd_base_regs()->thread); if(is_selected) { dr_fstrs_push_new(arena, &result, ¶ms, rd_icon_kind_text_table[RD_IconKind_RightArrow], .font = rd_font_from_slot(RD_FontSlot_Icons), .raster_flags = rd_raster_flags_from_slot(RD_FontSlot_Icons), .color = color); @@ -509,10 +509,10 @@ rd_title_fstrs_from_ctrl_entity(Arena *arena, D_Entity *entity, B32 include_extr if(entity->kind == D_EntityKind_Thread || entity->kind == D_EntityKind_Module) { - D_EntityArray processes = ctrl_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); + D_EntityArray processes = d_entity_array_from_kind(&d_user_state->ctrl_entity_store->ctx, D_EntityKind_Process); if(processes.count > 1) { - D_Entity *process = ctrl_entity_ancestor_from_kind(entity, D_EntityKind_Process); + D_Entity *process = d_entity_ancestor_from_kind(entity, D_EntityKind_Process); String8 process_name = rd_name_from_ctrl_entity(arena, process); Vec4F32 process_color = rd_color_from_ctrl_entity(process); if(process_color.w == 0) @@ -548,10 +548,10 @@ rd_title_fstrs_from_ctrl_entity(Arena *arena, D_Entity *entity, B32 include_extr Vec4F32 symbol_color = ui_color_from_name(str8_lit("code_symbol")); dr_fstrs_push_new(arena, &result, ¶ms, str8_lit(" ")); Access *access = access_open(); - D_Entity *process = ctrl_entity_ancestor_from_kind(entity, D_EntityKind_Process); + D_Entity *process = d_entity_ancestor_from_kind(entity, D_EntityKind_Process); Arch arch = entity->arch; - B32 call_stack_high_priority = ctrl_handle_match(entity->handle, rd_base_regs()->thread); - D_CallStack call_stack = ctrl_call_stack_from_thread(access, entity->handle, call_stack_high_priority, call_stack_high_priority ? rd_state->frame_eval_memread_endt_us : 0); + B32 call_stack_high_priority = d_handle_match(entity->handle, rd_base_regs()->thread); + D_CallStack call_stack = d_call_stack_from_thread(access, entity->handle, call_stack_high_priority, call_stack_high_priority ? rd_state->frame_eval_memread_endt_us : 0); B32 did_first_known = 0; for(U64 idx = 0, limit = 10; idx < call_stack.frames_count && idx < limit; @@ -559,11 +559,11 @@ rd_title_fstrs_from_ctrl_entity(Arena *arena, D_Entity *entity, B32 include_extr { D_CallStackFrame *f = &call_stack.frames[call_stack.frames_count - 1 - idx]; U64 rip_vaddr = regs_rip_from_arch_block(arch, f->regs); - D_Entity *module = ctrl_module_from_process_vaddr(process, rip_vaddr); - U64 rip_voff = ctrl_voff_from_vaddr(module, rip_vaddr); + D_Entity *module = d_module_from_process_vaddr(process, rip_vaddr); + U64 rip_voff = d_voff_from_vaddr(module, rip_vaddr); String8 name = {0}; { - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); + DI_Key dbgi_key = d_dbgi_key_from_module(module); RDI_Parsed *rdi = di_rdi_from_key(access, dbgi_key, 0, 0); if(rdi != &rdi_parsed_nil) { @@ -597,7 +597,7 @@ rd_title_fstrs_from_ctrl_entity(Arena *arena, D_Entity *entity, B32 include_extr if(entity->kind == D_EntityKind_Module && include_extras) { Access *access = access_open(); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(entity); + DI_Key dbgi_key = d_dbgi_key_from_module(entity); RDI_Parsed *rdi = di_rdi_from_key(access, dbgi_key, 0, 0); if(rdi->raw_data_size == 0) { @@ -1254,12 +1254,12 @@ rd_code_slice(RD_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe RD_CodeSliceSignal result = {0}; ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); - D_Entity *selected_thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); - D_Entity *selected_thread_process = ctrl_entity_ancestor_from_kind(selected_thread, D_EntityKind_Process); + D_Entity *selected_thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_regs()->thread); + D_Entity *selected_thread_process = d_entity_ancestor_from_kind(selected_thread, D_EntityKind_Process); U64 selected_thread_rip_unwind_vaddr = d_query_cached_rip_from_thread_unwind(selected_thread, rd_regs()->unwind_count); - D_Entity *selected_thread_module = ctrl_module_from_process_vaddr(selected_thread_process, selected_thread_rip_unwind_vaddr); + D_Entity *selected_thread_module = d_module_from_process_vaddr(selected_thread_process, selected_thread_rip_unwind_vaddr); D_Event stop_event = d_ctrl_last_stop_event(); - D_Entity *stopper_thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, stop_event.entity); + D_Entity *stopper_thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, stop_event.entity); B32 is_focused = ui_is_focus_active(); B32 ctrlified = (os_get_modifiers() & OS_Modifier_Ctrl); Vec4F32 code_line_bgs[] = @@ -1336,7 +1336,7 @@ rd_code_slice(RD_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe if(rd_state->drag_drop_regs_slot == RD_RegSlot_Thread) { drop_can_hit_lines = 1; - drop_thread = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_state->drag_drop_regs->thread); + drop_thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, rd_state->drag_drop_regs->thread); drop_color = rd_color_from_ctrl_entity(drop_thread); if(drop_color.w == 0) { @@ -1420,10 +1420,10 @@ rd_code_slice(RD_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe } U64 unwind_count = (thread == selected_thread) ? rd_regs()->unwind_count : 0; U64 thread_rip_vaddr = d_query_cached_rip_from_thread_unwind(thread, unwind_count); - D_Entity *process = ctrl_entity_ancestor_from_kind(thread, D_EntityKind_Process); - D_Entity *module = ctrl_module_from_process_vaddr(process, thread_rip_vaddr); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); - U64 thread_rip_voff = ctrl_voff_from_vaddr(module, thread_rip_vaddr); + D_Entity *process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process); + D_Entity *module = d_module_from_process_vaddr(process, thread_rip_vaddr); + DI_Key dbgi_key = d_dbgi_key_from_module(module); + U64 thread_rip_voff = d_voff_from_vaddr(module, thread_rip_vaddr); // rjf: thread info => color Vec4F32 color = rd_color_from_ctrl_entity(thread); @@ -1473,7 +1473,7 @@ rd_code_slice(RD_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe // rjf: custom draw { RD_Regs *hover_regs = rd_get_hover_regs(); - B32 is_hovering = (ctrl_handle_match(hover_regs->ctrl_entity, thread->handle) && + B32 is_hovering = (d_handle_match(hover_regs->ctrl_entity, thread->handle) && rd_state->hover_regs_slot == RD_RegSlot_CtrlEntity); RD_ThreadBoxDrawExtData *u = push_array(ui_build_arena(), RD_ThreadBoxDrawExtData, 1); u->thread_color = color; @@ -1520,7 +1520,7 @@ rd_code_slice(RD_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe { rd_cmd(RD_CmdKind_PushQuery, .ui_key = thread_box->key, - .expr = push_str8f(scratch.arena, "query:control.%S", ctrl_string_from_handle(scratch.arena, thread->handle))); + .expr = push_str8f(scratch.arena, "query:control.%S", d_string_from_handle(scratch.arena, thread->handle))); } if(ui_dragging(thread_sig) && !contains_2f32(thread_box->rect, ui_mouse())) { @@ -1576,10 +1576,10 @@ rd_code_slice(RD_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe } U64 unwind_count = (thread == selected_thread) ? rd_regs()->unwind_count : 0; U64 thread_rip_vaddr = d_query_cached_rip_from_thread_unwind(thread, unwind_count); - D_Entity *process = ctrl_entity_ancestor_from_kind(thread, D_EntityKind_Process); - D_Entity *module = ctrl_module_from_process_vaddr(process, thread_rip_vaddr); - DI_Key dbgi_key = ctrl_dbgi_key_from_module(module); - U64 thread_rip_voff = ctrl_voff_from_vaddr(module, thread_rip_vaddr); + D_Entity *process = d_entity_ancestor_from_kind(thread, D_EntityKind_Process); + D_Entity *module = d_module_from_process_vaddr(process, thread_rip_vaddr); + DI_Key dbgi_key = d_dbgi_key_from_module(module); + U64 thread_rip_voff = d_voff_from_vaddr(module, thread_rip_vaddr); // rjf: thread info => color Vec4F32 color = rd_color_from_ctrl_entity(thread); @@ -1629,7 +1629,7 @@ rd_code_slice(RD_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe // rjf: custom draw { RD_Regs *hover_regs = rd_get_hover_regs(); - B32 is_hovering = (ctrl_handle_match(hover_regs->ctrl_entity, thread->handle) && + B32 is_hovering = (d_handle_match(hover_regs->ctrl_entity, thread->handle) && rd_state->hover_regs_slot == RD_RegSlot_CtrlEntity); RD_ThreadBoxDrawExtData *u = push_array(ui_build_arena(), RD_ThreadBoxDrawExtData, 1); u->thread_color = color; @@ -1674,7 +1674,7 @@ rd_code_slice(RD_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe { rd_cmd(RD_CmdKind_PushQuery, .ui_key = thread_box->key, - .expr = push_str8f(scratch.arena, "query:control.%S", ctrl_string_from_handle(scratch.arena, thread->handle))); + .expr = push_str8f(scratch.arena, "query:control.%S", d_string_from_handle(scratch.arena, thread->handle))); } if(ui_dragging(thread_sig) && !contains_2f32(thread_box->rect, ui_mouse())) { @@ -2272,11 +2272,11 @@ rd_code_slice(RD_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe D_LineList *lines = ¶ms->line_infos[line_idx]; for(D_LineNode *n = lines->first; n != 0; n = n->next) { - D_EntityList modules = ctrl_modules_from_dbgi_key(scratch.arena, &d_user_state->ctrl_entity_store->ctx, n->v.dbgi_key); - D_Entity *module = ctrl_module_from_thread_candidates(&d_user_state->ctrl_entity_store->ctx, thread, &modules); + D_EntityList modules = d_modules_from_dbgi_key(scratch.arena, &d_user_state->ctrl_entity_store->ctx, n->v.dbgi_key); + D_Entity *module = d_module_from_thread_candidates(&d_user_state->ctrl_entity_store->ctx, thread, &modules); if(module != &d_entity_nil) { - new_rip_vaddr = ctrl_vaddr_from_voff(module, n->v.voff_range.min); + new_rip_vaddr = d_vaddr_from_voff(module, n->v.voff_range.min); break; } } @@ -2558,7 +2558,7 @@ rd_code_slice(RD_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe if(lines->first != 0 && (params->line_vaddrs[line_slice_idx] != 0 || lines->first->v.pt.line == mouse_pt.line)) { RD_RegsScope(.process = selected_thread_process->handle, - .vaddr_range = ctrl_vaddr_range_from_voff_range(selected_thread_module, lines->first->v.voff_range), + .vaddr_range = d_vaddr_range_from_voff_range(selected_thread_module, lines->first->v.voff_range), .module = selected_thread_module->handle, .dbgi_key = lines->first->v.dbgi_key, .voff_range = lines->first->v.voff_range) @@ -2659,8 +2659,8 @@ rd_code_slice(RD_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *prefe Rng1U64 hover_voff_range = hover_regs->voff_range; if(hover_voff_range.min == 0 && hover_voff_range.max == 0) { - D_Entity *module = ctrl_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, hover_regs->module); - hover_voff_range = ctrl_voff_range_from_vaddr_range(module, hover_regs->vaddr_range); + D_Entity *module = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, hover_regs->module); + hover_voff_range = d_voff_range_from_vaddr_range(module, hover_regs->vaddr_range); } ui_set_next_pref_height(ui_px(params->line_height_px*(dim_1s64(params->line_num_range)+1), 1.f)); UI_WidthFill