diff --git a/build.bat b/build.bat index 7aead3f9..b9ed9538 100644 --- a/build.bat +++ b/build.bat @@ -144,7 +144,6 @@ if "%radlink%"=="1" set didbuild=1 && %compile% ..\src\linker if "%radbin%"=="1" set didbuild=1 && %compile% ..\src\radbin\radbin_main.c %compile_link% %out%radbin.exe || exit /b 1 if "%raddump%"=="1" set didbuild=1 && %compile% ..\src\raddump\raddump_main.c %compile_link% %out%raddump.exe || exit /b 1 if "%ryan_scratch%"=="1" set didbuild=1 && %compile% ..\src\scratch\ryan_scratch.c %compile_link% %out%ryan_scratch.exe || exit /b 1 -if "%eval_scratch%"=="1" set didbuild=1 && %compile% ..\src\scratch\eval_scratch.c %compile_link% %out%eval_scratch.exe || exit /b 1 if "%textperf%"=="1" set didbuild=1 && %compile% ..\src\scratch\textperf.c %compile_link% %out%textperf.exe || exit /b 1 if "%convertperf%"=="1" set didbuild=1 && %compile% ..\src\scratch\convertperf.c %compile_link% %out%convertperf.exe || exit /b 1 if "%debugstringperf%"=="1" set didbuild=1 && %compile% ..\src\scratch\debugstringperf.c %compile_link% %out%debugstringperf.exe || exit /b 1 diff --git a/project.4coder b/project.4coder index 8292e83f..bed46ee1 100644 --- a/project.4coder +++ b/project.4coder @@ -49,13 +49,13 @@ commands = // .f1 = { .win = "raddbg_stable --ipc kill_all && build raddbg", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, // .f1 = { .win = "raddbg_stable --ipc kill_all && build raddbg debug telemetry", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, // .f1 = { .win = "raddbg_stable --ipc kill_all && build radbin", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, - .f1 = { .win = "build radbin", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, + .f1 = { .win = "build raddbg", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, //- rjf: [raddbg wsl] // .f1 = { .win = "wsl ./build.sh raddbg", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, //- rjf: [scratch] - .f2 = { .win = "wsl ./build.sh raddbg", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, + .f2 = { .win = "build radbin", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, //- rjf: [textperf] // .f1 = { .win = "raddbg_stable --ipc kill_all && build no_meta telemetry textperf && raddbg_stable --ipc bring_to_front && raddbg_stable --ipc run", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, @@ -67,7 +67,8 @@ commands = // .f1 = { .win = "raddbg_stable --ipc kill_all && build radbin", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, //- rjf: running target - .f3 = { .win = "raddbg_stable --ipc run", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, + .f3 = { .win = "build torture", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, + // .f3 = { .win = "raddbg_stable --ipc run", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, // .f3 = { .win = "wsl ./build/raddbg", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, // .f3 = { .win = "pushd build && raddbg --user:dev.raddbg_user && popd", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, // .f3 = { .win = "C:/devel/raddebugger/build/raddbg.exe --capture --user:C:/devel/raddebugger/build/local_dev.raddbg_user --project:C:/devel/raddebugger/build/local_dev.raddbg_project", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, diff --git a/src/arch/arch.c b/src/arch/arch.c new file mode 100644 index 00000000..1a31d949 --- /dev/null +++ b/src/arch/arch.c @@ -0,0 +1,168 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//////////////////////////////// +//~ rjf: Abstracted Architecture Functions + +internal ARCH_Info * +arch_info_from_arch(Arch arch) +{ + ARCH_Info *result = &arch_info_nil; + switch(arch) + { + default:{}break; +#if defined(X64_H) + case Arch_x64: + { + local_persist read_only ARCH_Info info = + { + .reg_block_size = sizeof(X64_RegBlock), + .instruction_pointer_reg_code = X64_RegCode_rip, + .stack_pointer_reg_code = X64_RegCode_rsp, + .reg_code_count = X64_RegCode_COUNT, + .reg_code_rng_table = x64_reg_code_rng_table, + .reg_code_name_table = x64_reg_code_name_table, + .reg_code_base_table = x64_reg_code_base_table, + .reg_code_is_vector_table = x64_reg_code_is_vector_table, + }; + result = &info; + }break; +#endif + } + return result; +} + +internal ARCH_RegCode +arch_reg_code_from_name(ARCH_Info *arch_info, String8 name) +{ + ARCH_RegCode result = 0; + for EachIndex(code, arch_info->reg_code_count) + { + if(str8_match(arch_info->reg_code_name_table[code], name, 0)) + { + result = code; + break; + } + } + return result; +} + +internal ARCH_RegCode +arch_reg_code_from_rdi(Arch arch, RDI_RegCode code) +{ + ARCH_RegCode result = 0; + { + ARCH_Info *arch_info = arch_info_from_arch(arch); + U8 *rdi_from_reg_code_table = arch_rdi_from_reg_code_table_from_arch(arch); + for EachIndex(c, arch_info->reg_code_count) + { + if(rdi_from_reg_code_table[c] == code) + { + result = c; + break; + } + } + } + return result; +} + +internal ARCH_RegCode +arch_reg_code_from_dw(Arch arch, DW_Reg code) +{ + ARCH_RegCode result = 0; + { + ARCH_Info *arch_info = arch_info_from_arch(arch); + U8 *dw_from_reg_code_table = arch_dw_from_reg_code_table_from_arch(arch); + for EachIndex(c, arch_info->reg_code_count) + { + if(dw_from_reg_code_table[c] == code) + { + result = c; + break; + } + } + } + return result; +} + +internal B32 +arch_reg_block_read_range(ARCH_Info *arch_info, void *block, Rng1U16 range, void *dst) +{ + B32 result = 0; + { + Rng1U16 legal_range = r1u16(0, arch_info->reg_block_size); + Rng1U16 try_range = range; + Rng1U16 read_range = intersect_1u16(legal_range, try_range); + U64 read_size = dim_1u16(read_range); + if(read_size != 0) + { + MemoryCopy(dst, (U8 *)block + read_range.min, read_size); + result = 1; + } + } + return result; +} + +internal B32 +arch_reg_block_write_range(ARCH_Info *arch_info, void *block, Rng1U16 range, void *src) +{ + B32 result = 0; + Rng1U16 legal_range = r1u16(0, arch_info->reg_block_size); + Rng1U16 try_range = range; + Rng1U16 write_range = intersect_1u16(legal_range, try_range); + U64 write_size = dim_1u16(write_range); + if(write_size != 0) + { + MemoryCopy((U8 *)block + write_range.min, src, write_size); + result = 1; + } + return result; +} + +internal U64 +arch_ip_from_reg_block(ARCH_Info *arch_info, void *block) +{ + U64 result = 0; + ARCH_RegCode reg_code = arch_info->instruction_pointer_reg_code; + if(reg_code < arch_info->reg_code_count) + { + arch_reg_block_read_range(arch_info, block, arch_info->reg_code_rng_table[reg_code], &result); + } + return result; +} + +internal U64 +arch_sp_from_reg_block(ARCH_Info *arch_info, void *block) +{ + U64 result = 0; + ARCH_RegCode reg_code = arch_info->stack_pointer_reg_code; + if(reg_code < arch_info->reg_code_count) + { + arch_reg_block_read_range(arch_info, block, arch_info->reg_code_rng_table[reg_code], &result); + } + return result; +} + +internal B32 +arch_reg_block_write_ip(ARCH_Info *arch_info, void *block, U64 ip) +{ + B32 result = 0; + ARCH_RegCode reg_code = arch_info->instruction_pointer_reg_code; + if(reg_code < arch_info->reg_code_count) + { + result = arch_reg_block_write_range(arch_info, block, arch_info->reg_code_rng_table[reg_code], &ip); + } + return result; +} + +internal B32 +arch_reg_block_write_sp(ARCH_Info *arch_info, void *block, U64 sp) +{ + B32 result = 0; + ARCH_RegCode reg_code = arch_info->stack_pointer_reg_code; + if(reg_code < arch_info->reg_code_count) + { + result = arch_reg_block_write_range(arch_info, block, arch_info->reg_code_rng_table[reg_code], &sp); + } + return result; +} diff --git a/src/arch/arch.h b/src/arch/arch.h new file mode 100644 index 00000000..e9e945b9 --- /dev/null +++ b/src/arch/arch.h @@ -0,0 +1,47 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef ARCH_H +#define ARCH_H + +//////////////////////////////// +//~ rjf: Abstraction Backend Info + +typedef U8 ARCH_RegCode; + +typedef struct ARCH_Info ARCH_Info; +struct ARCH_Info +{ + U16 reg_block_size; + ARCH_RegCode instruction_pointer_reg_code; + ARCH_RegCode stack_pointer_reg_code; + U16 reg_code_count; + Rng1U16 *reg_code_rng_table; + String8 *reg_code_name_table; + U8 *reg_code_base_table; + B8 *reg_code_is_vector_table; +}; + +//////////////////////////////// +//~ rjf: Globals + +global read_only Rng1U16 arch_reg_code_rng_nil = {0}; +global read_only String8 arch_reg_code_name_nil = {0}; +global read_only U8 arch_reg_code_u8_nil = 0; +global read_only ARCH_Info arch_info_nil = {0, 0, 0, 0, &arch_reg_code_rng_nil, &arch_reg_code_name_nil, &arch_reg_code_u8_nil, &arch_reg_code_u8_nil}; + +//////////////////////////////// +//~ rjf: Abstracted Architecture Functions + +internal ARCH_Info *arch_info_from_arch(Arch arch); +internal ARCH_RegCode arch_reg_code_from_name(ARCH_Info *arch_info, String8 name); +internal ARCH_RegCode arch_reg_code_from_rdi(Arch arch, RDI_RegCode code); +internal ARCH_RegCode arch_reg_code_from_dw(Arch arch, DW_Reg code); +internal B32 arch_reg_block_read_range(ARCH_Info *arch_info, void *block, Rng1U16 range, void *dst); +internal B32 arch_reg_block_write_range(ARCH_Info *arch_info, void *block, Rng1U16 range, void *src); +internal U64 arch_ip_from_reg_block(ARCH_Info *arch_info, void *block); +internal U64 arch_sp_from_reg_block(ARCH_Info *arch_info, void *block); +internal B32 arch_reg_block_write_ip(ARCH_Info *arch_info, void *block, U64 ip); +internal B32 arch_reg_block_write_sp(ARCH_Info *arch_info, void *block, U64 sp); + +#endif // REGS_H diff --git a/src/arch/arch_inc.c b/src/arch/arch_inc.c new file mode 100644 index 00000000..e07d1b7c --- /dev/null +++ b/src/arch/arch_inc.c @@ -0,0 +1,10 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#include "arch/arch.c" +#if defined(DWARF_H) +# include "arch/dwarf/arch_dwarf.c" +#endif +#if defined(RDI_H) +# include "arch/rdi/arch_rdi.c" +#endif diff --git a/src/arch/arch_inc.h b/src/arch/arch_inc.h new file mode 100644 index 00000000..0155cfc4 --- /dev/null +++ b/src/arch/arch_inc.h @@ -0,0 +1,15 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef ARCH_INC_H +#define ARCH_INC_H + +#include "arch/arch.h" +#if defined(DWARF_H) +# include "arch/dwarf/arch_dwarf.h" +#endif +#if defined(RDI_H) +# include "arch/rdi/arch_rdi.h" +#endif + +#endif // ARCH_INC_H diff --git a/src/arch/dwarf/arch_dwarf.c b/src/arch/dwarf/arch_dwarf.c new file mode 100644 index 00000000..91c19792 --- /dev/null +++ b/src/arch/dwarf/arch_dwarf.c @@ -0,0 +1,19 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +internal U8 * +arch_dw_from_reg_code_table_from_arch(Arch arch) +{ + U8 *result = &arch_reg_code_u8_nil; + switch(arch) + { + default:{}break; +#if defined(X64_H) + case Arch_x64: + { + result = dw_reg_code_from_x64_table; + }break; +#endif + } + return result; +} diff --git a/src/arch/dwarf/arch_dwarf.h b/src/arch/dwarf/arch_dwarf.h new file mode 100644 index 00000000..574bdeab --- /dev/null +++ b/src/arch/dwarf/arch_dwarf.h @@ -0,0 +1,9 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef ARCH_DWARF_H +#define ARCH_DWARF_H + +internal U8 *arch_dw_from_reg_code_table_from_arch(Arch arch); + +#endif // ARCH_DWARF_H diff --git a/src/arch/rdi/arch_rdi.c b/src/arch/rdi/arch_rdi.c new file mode 100644 index 00000000..2f3b6c7b --- /dev/null +++ b/src/arch/rdi/arch_rdi.c @@ -0,0 +1,19 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +internal U8 * +arch_rdi_from_reg_code_table_from_arch(Arch arch) +{ + U8 *result = &arch_reg_code_u8_nil; + switch(arch) + { + default:{}break; +#if defined(X64_H) + case Arch_x64: + { + result = rdi_reg_code_from_x64_table; + }break; +#endif + } + return result; +} diff --git a/src/arch/rdi/arch_rdi.h b/src/arch/rdi/arch_rdi.h new file mode 100644 index 00000000..dc09eb18 --- /dev/null +++ b/src/arch/rdi/arch_rdi.h @@ -0,0 +1,9 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef ARCH_RDI_H +#define ARCH_RDI_H + +internal U8 *arch_rdi_from_reg_code_table_from_arch(Arch arch); + +#endif // ARCH_RDI_H diff --git a/src/artifact_cache/artifact_cache.c b/src/artifact_cache/artifact_cache.c index 2ae211a8..3dd24a2d 100644 --- a/src/artifact_cache/artifact_cache.c +++ b/src/artifact_cache/artifact_cache.c @@ -108,7 +108,7 @@ ac_artifact_from_key_(Access *access, String8 key, AC_ArtifactParams *params, U6 { RWMutexScope(stripe->rw_mutex, 1) for(;;) { - B32 out_of_time = (os_now_microseconds() >= endt_us); + B32 out_of_time = (now_time_us() >= endt_us); // rjf: find node in cache AC_Node *node = 0; @@ -141,7 +141,7 @@ ac_artifact_from_key_(Access *access, String8 key, AC_ArtifactParams *params, U6 node->working_count = 1; node->evict_threshold_us = params->evict_threshold_us; } - node->access_pt.last_time_touched_us = os_now_microseconds(); + node->access_pt.last_time_touched_us = now_time_us(); node->access_pt.last_update_idx_touched = update_tick_idx(); // rjf: request @@ -602,7 +602,7 @@ ac_cancel_thread_entry_point(void *p) { for(;;) { - os_sleep_milliseconds(50); + sleep_ms(50); semaphore_take(ac_shared->cancel_thread_semaphore, max_U64); { for EachIndex(cache_slot_idx, ac_shared->cache_slots_count) diff --git a/src/base/base_arena.c b/src/base/base_arena.c index c9e76289..626a66fd 100644 --- a/src/base/base_arena.c +++ b/src/base/base_arena.c @@ -19,24 +19,24 @@ arena_alloc_(ArenaParams *params) // rjf: round up reserve/commit sizes if(params->flags & ArenaFlag_LargePages) { - reserve_size = AlignPow2(reserve_size, os_get_system_info()->large_page_size); - commit_size = AlignPow2(commit_size, os_get_system_info()->large_page_size); + reserve_size = AlignPow2(reserve_size, get_system_info()->large_page_size); + commit_size = AlignPow2(commit_size, get_system_info()->large_page_size); } else { - reserve_size = AlignPow2(reserve_size, os_get_system_info()->page_size); - commit_size = AlignPow2(commit_size, os_get_system_info()->page_size); + reserve_size = AlignPow2(reserve_size, get_system_info()->page_size); + commit_size = AlignPow2(commit_size, get_system_info()->page_size); } if(params->flags & ArenaFlag_LargePages) { - base = os_reserve_large(reserve_size); - os_commit_large(base, commit_size); + base = reserve_memory_large(reserve_size); + commit_memory_large(base, commit_size); } else { - base = os_reserve(reserve_size); - os_commit(base, commit_size); + base = reserve_memory(reserve_size); + commit_memory(base, commit_size); } AsanPoisonMemoryRegion(base, commit_size); // TODO(rjf): we need to reintroduce this later when we have the ability to remove annotations... @@ -52,7 +52,7 @@ arena_alloc_(ArenaParams *params) if(Unlikely(base == 0)) { os_graphical_message(1, str8_lit("Fatal Allocation Failure"), str8_lit("Unexpected memory allocation failure.")); - os_abort(1); + abort_self(1); } #endif @@ -90,7 +90,7 @@ arena_release(Arena *arena) for(Arena *n = arena->current, *prev = 0; n != 0; n = prev) { prev = n->prev; - os_release(n, n->res); + release_memory(n, n->res); } } @@ -179,11 +179,11 @@ arena_push(Arena *arena, U64 size, U64 align, B32 zero) U8 *cmt_ptr = (U8 *)current + current->cmt; if(current->flags & ArenaFlag_LargePages) { - os_commit_large(cmt_ptr, cmt_size); + commit_memory_large(cmt_ptr, cmt_size); } else { - os_commit(cmt_ptr, cmt_size); + commit_memory(cmt_ptr, cmt_size); } AsanPoisonMemoryRegion(cmt_ptr, cmt_size); current->cmt = cmt_pst_clamped; @@ -213,7 +213,7 @@ arena_push(Arena *arena, U64 size, U64 align, B32 zero) if(Unlikely(result == 0)) { os_graphical_message(1, str8_lit("Fatal Allocation Failure"), str8_lit("Unexpected memory allocation failure.")); - os_abort(1); + abort_self(1); } #endif @@ -246,7 +246,7 @@ arena_pop_to(Arena *arena, U64 pos) for(Arena *prev = 0; current->base_pos >= big_pos; current = prev) { prev = current->prev; - os_release(current, current->res); + release_memory(current, current->res); } #endif arena->current = current; diff --git a/src/base/base_core.h b/src/base/base_core.h index 7b9b585a..2536e38f 100644 --- a/src/base/base_core.h +++ b/src/base/base_core.h @@ -471,6 +471,8 @@ union U128 U16 u16[8]; U32 u32[4]; U64 u64[2]; + F32 f32[4]; + F64 f64[2]; }; typedef union U256 U256; union U256 @@ -480,6 +482,8 @@ union U256 U32 u32[8]; U64 u64[4]; U128 u128[2]; + F32 f32[8]; + F64 f64[4]; }; typedef union U512 U512; union U512 @@ -490,8 +494,19 @@ union U512 U64 u64[8]; U128 u128[4]; U256 u256[2]; + F32 f32[16]; + F64 f64[8]; }; +#pragma pack(push, 1) +typedef struct U80 U80; +struct U80 +{ + U64 int1_frac63; + U16 sign1_exp15; +}; +#pragma pack(pop) + //////////////////////////////// //~ rjf: Basic Type Structures @@ -653,6 +668,21 @@ Compiler; # define Compiler_CURRENT Compiler_Null #endif +//////////////////////////////// +//~ rjf: Access Flags + +typedef U32 AccessFlags; +enum +{ + AccessFlag_Read = (1<<0), + AccessFlag_Write = (1<<1), + AccessFlag_Execute = (1<<2), + AccessFlag_Append = (1<<3), + AccessFlag_ShareRead = (1<<4), + AccessFlag_ShareWrite = (1<<5), + AccessFlag_Inherited = (1<<6), +}; + //////////////////////////////// //~ rjf: Text 2D Coordinates & Ranges @@ -1044,6 +1074,21 @@ internal DateTime date_time_from_dense_time(DenseTime time); internal DateTime date_time_from_micro_seconds(U64 time); internal DateTime date_time_from_unix_time(U64 unix_time); +//////////////////////////////// +//~ rjf: @per_os_impl Platform Time Functions + +internal U64 now_time_us(void); +internal U32 now_time_unix(void); +internal DateTime now_time_universal(void); +internal DateTime universal_from_local_time(DateTime *dt); +internal DateTime local_from_universal_time(DateTime *dt); +internal void sleep_ms(U32 ms); + +//////////////////////////////// +//~ rjf: @per_os_impl Platform GUID Functions + +internal Guid make_guid(void); + //////////////////////////////// //~ rjf: Non-Fancy Ring Buffer Reads/Writes diff --git a/src/base/base_dynamic_libraries.c b/src/base/base_dynamic_libraries.c new file mode 100644 index 00000000..ae447aab --- /dev/null +++ b/src/base/base_dynamic_libraries.c @@ -0,0 +1,2 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) diff --git a/src/base/base_dynamic_libraries.h b/src/base/base_dynamic_libraries.h new file mode 100644 index 00000000..d87a600b --- /dev/null +++ b/src/base/base_dynamic_libraries.h @@ -0,0 +1,20 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef BASE_DYNAMIC_LIBARIES_H +#define BASE_DYNAMIC_LIBARIES_H + +typedef struct Library Library; +struct Library +{ + U64 u64[1]; +}; + +//////////////////////////////// +//~ rjf: @per_os_impl Dynamically-Loaded Libraries + +internal Library library_open(String8 path); +internal void library_close(Library lib); +internal VoidProc *library_load_proc(Library lib, String8 name); + +#endif // BASE_DYNAMIC_LIBARIES_H diff --git a/src/base/base_entry_point.c b/src/base/base_entry_point.c index 5869281a..327e0a33 100644 --- a/src/base/base_entry_point.c +++ b/src/base/base_entry_point.c @@ -11,6 +11,9 @@ global B32 async_loop_again_high_priority = 0; global B32 global_async_exit = 0; thread_static B32 is_async_thread = 0; +// NOTE(rjf): defined by target +internal void entry_point(CmdLine *cmdline); + internal void main_thread_base_entry_point(int arguments_count, char **arguments) { @@ -100,7 +103,7 @@ main_thread_base_entry_point(int arguments_count, char **arguments) #if defined(DBG_ENGINE_CORE_H) num_main_threads += 1; #endif - U64 num_async_threads = os_get_system_info()->logical_processor_count; + U64 num_async_threads = get_system_info()->logical_processor_count; U64 num_main_threads_clamped = Min(num_async_threads, num_main_threads); num_async_threads -= num_main_threads_clamped; String8 num_async_threads_string = cmd_line_string(&cmdline, str8_lit("async_thread_count")); @@ -192,7 +195,7 @@ async_thread_entry_point(void *params) { if(!ins_atomic_u32_eval(&async_loop_again)) { - MutexScope(async_tick_start_mutex) cond_var_wait(async_tick_start_cond_var, async_tick_start_mutex, os_now_microseconds()+1000000); + MutexScope(async_tick_start_mutex) cond_var_wait(async_tick_start_cond_var, async_tick_start_mutex, now_time_us()+1000000); } ins_atomic_u32_eval_assign(&async_loop_again, 0); ins_atomic_u32_eval_assign(&async_loop_again_high_priority, 0); diff --git a/src/base/base_files.c b/src/base/base_files.c new file mode 100644 index 00000000..9a500f81 --- /dev/null +++ b/src/base/base_files.c @@ -0,0 +1,169 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//////////////////////////////// +//~ rjf: Handle Type Functions + +internal File +file_zero(void) +{ + File f = {0}; + return f; +} + +internal B32 +file_match(File a, File b) +{ + B32 result = MemoryMatchStruct(&a, &b); + return result; +} + +//////////////////////////////// +//~ rjf: Filesystem Helpers (Helpers, Implemented Once) + +internal String8 +data_from_file_path(Arena *arena, String8 path) +{ + File file = file_open(AccessFlag_Read|AccessFlag_ShareRead, path); + FileProperties props = properties_from_file(file); + String8 data = string_from_file_range(arena, file, r1u64(0, props.size)); + file_close(file); + return data; +} + +internal B32 +write_data_to_file_path(String8 path, String8 data) +{ + B32 good = 0; + File file = file_open(AccessFlag_Write, path); + if(!file_match(file, file_zero())) + { + U64 bytes_written = file_write(file, r1u64(0, data.size), data.str); + good = (bytes_written == data.size); + file_close(file); + } + return good; +} + +internal B32 +write_data_list_to_file_path(String8 path, String8List list) +{ + B32 good = 0; + File file = file_open(AccessFlag_Write, path); + if(!file_match(file, file_zero())) + { + Temp scratch = scratch_begin(0, 0); + U64 write_buffer_size = KB(64); + U8 *write_buffer = push_array_no_zero(scratch.arena, U8, write_buffer_size); + U64 write_buffer_write_pos = 0; + U64 write_buffer_read_pos = 0; + U64 file_off = 0; + { + for(String8Node *n = list.first; n != 0; n = n->next) + { + for(U64 n_off = 0; n_off < n->string.size;) + { + U64 write_buffer_unconsumed_size = (write_buffer_write_pos - write_buffer_read_pos); + U64 write_buffer_available_size = (write_buffer_size - write_buffer_unconsumed_size); + if(write_buffer_available_size == 0) + { + U64 file_write_size = file_write(file, r1u64(file_off, file_off+write_buffer_size), write_buffer); + if(file_write_size != write_buffer_size) + { + goto dbl_break; + } + file_off += write_buffer_size; + write_buffer_read_pos += write_buffer_size; + } + else + { + U64 bytes_to_copy = Min(write_buffer_available_size, n->string.size - n_off); + write_buffer_write_pos += ring_write(write_buffer, write_buffer_size, write_buffer_write_pos, n->string.str + n_off, bytes_to_copy); + n_off += bytes_to_copy; + } + } + } + if(write_buffer_write_pos > write_buffer_read_pos) + { + U64 file_write_size = file_write(file, r1u64(file_off, file_off + (write_buffer_write_pos-write_buffer_read_pos)), write_buffer); + file_off += file_write_size; + } + } + dbl_break:; + good = (file_off == list.total_size); + file_close(file); + scratch_end(scratch); + } + return good; +} + +internal B32 +append_data_to_file_path(String8 path, String8 data) +{ + B32 good = 0; + if(data.size != 0) + { + File file = file_open(AccessFlag_Write|AccessFlag_Append, path); + if(!file_match(file, file_zero())) + { + U64 pos = properties_from_file(file).size; + U64 bytes_written = file_write(file, r1u64(pos, pos+data.size), data.str); + good = (bytes_written == data.size); + file_close(file); + } + } + return good; +} + +internal FileID +id_from_file_path(String8 path) +{ + File file = file_open(AccessFlag_Read|AccessFlag_ShareRead, path); + FileID id = id_from_file(file); + file_close(file); + return id; +} + +internal S64 +file_id_compare(FileID a, FileID b) +{ + S64 cmp = MemoryCompare((void*)&a.v[0], (void*)&b.v[0], sizeof(a.v)); + return cmp; +} + +internal String8 +string_from_file_range(Arena *arena, File file, Rng1U64 range) +{ + U64 pre_pos = arena_pos(arena); + String8 result; + result.size = dim_1u64(range); + result.str = push_array_no_zero(arena, U8, result.size); + U64 actual_read_size = file_read(file, range, result.str); + if(actual_read_size < result.size) + { + arena_pop_to(arena, pre_pos + actual_read_size); + result.size = actual_read_size; + } + return result; +} + +internal String8 +file_read_cstring(Arena *arena, File file, U64 off) +{ + Temp scratch = scratch_begin(&arena, 1); + String8List block_list = {0}; + for(U64 cursor = off, stride = 256;; cursor += stride) + { + U8 *raw_block = push_array_no_zero(scratch.arena, U8, stride); + U64 read_size = file_read(file, r1u64(cursor, cursor + stride), raw_block); + String8 block = str8_cstring_capped(raw_block, raw_block+read_size); + str8_list_push(scratch.arena, &block_list, block); + if(read_size != stride || (block.size+1 <= read_size && block.str[block.size] == 0)) + { + break; + } + } + String8 result = str8_list_join(arena, &block_list, 0); + scratch_end(scratch); + return result; +} diff --git a/src/base/base_files.h b/src/base/base_files.h new file mode 100644 index 00000000..4ead7246 --- /dev/null +++ b/src/base/base_files.h @@ -0,0 +1,102 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef BASE_FILES_H +#define BASE_FILES_H + +typedef U32 FileIterFlags; +enum +{ + FileIterFlag_SkipFolders = (1 << 0), + FileIterFlag_SkipFiles = (1 << 1), + FileIterFlag_SkipHiddenFiles = (1 << 2), + FileIterFlag_Done = (1 << 31), +}; + +typedef struct FileIter FileIter; +struct FileIter +{ + FileIterFlags flags; + U8 memory[800]; +}; + +typedef struct FileInfo FileInfo; +struct FileInfo +{ + String8 name; + FileProperties props; +}; + +// nick: on-disk file identifier +typedef struct FileID FileID; +struct FileID +{ + U64 v[3]; +}; + +typedef struct File File; +struct File +{ + U64 u64[1]; +}; + +typedef struct FileMap FileMap; +struct FileMap +{ + U64 u64[1]; +}; + +//////////////////////////////// +//~ rjf: Handle Type Functions + +internal File file_zero(void); +internal B32 file_match(File a, File b); + +//////////////////////////////// +//~ rjf: Filesystem Helpers (Helpers, Implemented Once) + +internal String8 data_from_file_path(Arena *arena, String8 path); +internal B32 write_data_to_file_path(String8 path, String8 data); +internal B32 write_data_list_to_file_path(String8 path, String8List list); +internal B32 append_data_to_file_path(String8 path, String8 data); +internal FileID id_from_file_path(String8 path); +internal S64 file_id_compare(FileID a, FileID b); +internal String8 string_from_file_range(Arena *arena, File file, Rng1U64 range); +internal String8 file_read_cstring(Arena *arena, File file, U64 off); + +//////////////////////////////// +//~ rjf: @per_os_impl File System (Implemented Per-OS) + +//- rjf: files +internal File file_open(AccessFlags flags, String8 path); +internal void file_close(File file); +internal U64 file_read(File file, Rng1U64 rng, void *out_data); +#define file_read_struct(f, off, ptr) file_read((f), r1u64((off), (off)+sizeof(*(ptr))), (ptr)) +internal U64 file_write(File file, Rng1U64 rng, void *data); +internal B32 file_set_times(File file, DateTime time); +internal FileProperties properties_from_file(File file); +internal FileID id_from_file(File file); +internal B32 file_reserve_size(File file, U64 size); +internal B32 delete_file_at_path(String8 path); +internal B32 copy_file_path(String8 dst, String8 src); +internal B32 move_file_path(String8 dst, String8 src); +internal String8 full_path_from_path(Arena *arena, String8 path); +internal B32 file_path_exists(String8 path); +internal B32 folder_path_exists(String8 path); +internal FileProperties properties_from_file_path(String8 path); + +//- rjf: file maps +internal FileMap file_map_open(AccessFlags flags, File file); +internal void file_map_close(FileMap map); +internal void * file_map_view_open(FileMap map, AccessFlags flags, Rng1U64 range); +internal void file_map_view_close(FileMap map, void *ptr, Rng1U64 range); + +//- rjf: directory iteration +internal FileIter *file_iter_begin(Arena *arena, String8 path, FileIterFlags flags); +internal B32 file_iter_next(Arena *arena, FileIter *iter, FileInfo *info_out); +internal void file_iter_end(FileIter *iter); + +//- rjf: directory creation +internal B32 make_directory(String8 path); + +#endif // BASE_FILES_H diff --git a/src/base/base_inc.c b/src/base/base_inc.c index 84444597..683806aa 100644 --- a/src/base/base_inc.c +++ b/src/base/base_inc.c @@ -9,14 +9,28 @@ #include "base_core.c" #include "base_profile.c" +#include "base_memory.c" #include "base_arena.c" #include "base_math.c" #include "base_strings.c" #include "base_hash.c" +#include "base_system.c" #include "base_threads.c" #include "base_thread_context.c" +#include "base_files.c" +#include "base_shared_memory.c" +#include "base_processes.c" +#include "base_dynamic_libraries.c" #include "base_command_line.c" #include "base_markup.c" #include "base_meta.c" #include "base_log.c" #include "base_entry_point.c" + +#if OS_WINDOWS +# include "win32/base/win32_base.c" +#elif OS_LINUX +# include "linux/base/linux_base.c" +#else +# error Operating system backend not found for base layer. +#endif diff --git a/src/base/base_inc.h b/src/base/base_inc.h index 1647d03a..adaac62d 100644 --- a/src/base/base_inc.h +++ b/src/base/base_inc.h @@ -11,16 +11,30 @@ #include "base_core.h" #include "base_profile.h" +#include "base_memory.h" #include "base_arena.h" #include "base_math.h" #include "base_strings.h" #include "base_hash.h" +#include "base_system.h" #include "base_threads.h" #include "base_thread_context.h" +#include "base_files.h" +#include "base_shared_memory.h" +#include "base_processes.h" +#include "base_dynamic_libraries.h" #include "base_command_line.h" #include "base_markup.h" #include "base_meta.h" #include "base_log.h" #include "base_entry_point.h" +#if OS_WINDOWS +# include "win32/base/win32_base.h" +#elif OS_LINUX +# include "linux/base/linux_base.h" +#else +# error Operating system backend not found for base layer. +#endif + #endif // BASE_INC_H diff --git a/src/base/base_markup.c b/src/base/base_markup.c index 0efbaab8..29202cab 100644 --- a/src/base/base_markup.c +++ b/src/base/base_markup.c @@ -1,21 +1,2 @@ // Copyright (c) Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) - -internal void -set_thread_name(String8 string) -{ - ProfThreadName("%.*s", str8_varg(string)); - os_set_thread_name(string); -} - -internal void -set_thread_namef(char *fmt, ...) -{ - Temp scratch = scratch_begin(0, 0); - va_list args; - va_start(args, fmt); - String8 string = push_str8fv(scratch.arena, fmt, args); - set_thread_name(string); - va_end(args); - scratch_end(scratch); -} diff --git a/src/base/base_markup.h b/src/base/base_markup.h index 4389d9b1..1d451d2b 100644 --- a/src/base/base_markup.h +++ b/src/base/base_markup.h @@ -15,8 +15,6 @@ # define LAYER_COLOR 0x404040ff #endif -internal void set_thread_name(String8 string); -internal void set_thread_namef(char *fmt, ...); #define ThreadNameF(...) (set_thread_namef(__VA_ARGS__), raddbg_thread_color_u32(LAYER_COLOR)) #endif // BASE_MARKUP_H diff --git a/src/base/base_math.c b/src/base/base_math.c index 9eabae08..c80a5360 100644 --- a/src/base/base_math.c +++ b/src/base/base_math.c @@ -407,6 +407,26 @@ transpose_4x4f32(Mat4x4F32 mat) //////////////////////////////// //~ rjf: Range Ops +internal Rng1U8 rng_1u8(U8 min, U8 max) {Rng1U8 r = {min, max}; if(r.min > r.max) { Swap(U8, r.min, r.max); } return r;} +internal Rng1U8 shift_1u8(Rng1U8 r, U8 x) {r.min += x; r.max += x; return r;} +internal Rng1U8 pad_1u8(Rng1U8 r, U8 x) {r.min -= x; r.max += x; return r;} +internal U8 center_1u8(Rng1U8 r) {U8 c = (r.min+r.max)/2; return c;} +internal B32 contains_1u8(Rng1U8 r, U8 x) {B32 c = (r.min <= x && x < r.max); return c;} +internal U8 dim_1u8(Rng1U8 r) {U8 c = ((r.max > r.min) ? (r.max - r.min) : 0); return c;} +internal Rng1U8 union_1u8(Rng1U8 a, Rng1U8 b) {Rng1U8 c = {Min(a.min, b.min), Max(a.max, b.max)}; return c;} +internal Rng1U8 intersect_1u8(Rng1U8 a, Rng1U8 b) {Rng1U8 c = {Max(a.min, b.min), Min(a.max, b.max)}; return c;} +internal U8 clamp_1u8(Rng1U8 r, U8 v) {v = Clamp(r.min, v, r.max); return v;} + +internal Rng1U16 rng_1u16(U16 min, U16 max) {Rng1U16 r = {min, max}; if(r.min > r.max) { Swap(U16, r.min, r.max); } return r;} +internal Rng1U16 shift_1u16(Rng1U16 r, U16 x) {r.min += x; r.max += x; return r;} +internal Rng1U16 pad_1u16(Rng1U16 r, U16 x) {r.min -= x; r.max += x; return r;} +internal U16 center_1u16(Rng1U16 r) {U16 c = (r.min+r.max)/2; return c;} +internal B32 contains_1u16(Rng1U16 r, U16 x) {B32 c = (r.min <= x && x < r.max); return c;} +internal U16 dim_1u16(Rng1U16 r) {U16 c = ((r.max > r.min) ? (r.max - r.min) : 0); return c;} +internal Rng1U16 union_1u16(Rng1U16 a, Rng1U16 b) {Rng1U16 c = {Min(a.min, b.min), Max(a.max, b.max)}; return c;} +internal Rng1U16 intersect_1u16(Rng1U16 a, Rng1U16 b) {Rng1U16 c = {Max(a.min, b.min), Min(a.max, b.max)}; return c;} +internal U16 clamp_1u16(Rng1U16 r, U16 v) {v = Clamp(r.min, v, r.max); return v;} + internal Rng1U32 rng_1u32(U32 min, U32 max) {Rng1U32 r = {min, max}; if(r.min > r.max) { Swap(U32, r.min, r.max); } return r;} internal Rng1U32 shift_1u32(Rng1U32 r, U32 x) {r.min += x; r.max += x; return r;} internal Rng1U32 pad_1u32(Rng1U32 r, U32 x) {r.min -= x; r.max += x; return r;} diff --git a/src/base/base_math.h b/src/base/base_math.h index 43604127..ef219305 100644 --- a/src/base/base_math.h +++ b/src/base/base_math.h @@ -177,6 +177,28 @@ struct Mat4x4F32 //- rjf: 1-range +typedef union Rng1U8 Rng1U8; +union Rng1U8 +{ + struct + { + U8 min; + U8 max; + }; + U8 v[2]; +}; + +typedef union Rng1U16 Rng1U16; +union Rng1U16 +{ + struct + { + U16 min; + U16 max; + }; + U16 v[2]; +}; + typedef union Rng1U32 Rng1U32; union Rng1U32 { @@ -546,6 +568,28 @@ internal Mat4x4F32 transpose_4x4f32(Mat4x4F32 mat); //////////////////////////////// //~ rjf: Range Ops +#define r1u8(min, max) rng_1u8((min), (max)) +internal Rng1U8 rng_1u8(U8 min, U8 max); +internal Rng1U8 shift_1u8(Rng1U8 r, U8 x); +internal Rng1U8 pad_1u8(Rng1U8 r, U8 x); +internal U8 center_1u8(Rng1U8 r); +internal B32 contains_1u8(Rng1U8 r, U8 x); +internal U8 dim_1u8(Rng1U8 r); +internal Rng1U8 union_1u8(Rng1U8 a, Rng1U8 b); +internal Rng1U8 intersect_1u8(Rng1U8 a, Rng1U8 b); +internal U8 clamp_1u8(Rng1U8 r, U8 v); + +#define r1u16(min, max) rng_1u16((min), (max)) +internal Rng1U16 rng_1u16(U16 min, U16 max); +internal Rng1U16 shift_1u16(Rng1U16 r, U16 x); +internal Rng1U16 pad_1u16(Rng1U16 r, U16 x); +internal U16 center_1u16(Rng1U16 r); +internal B32 contains_1u16(Rng1U16 r, U16 x); +internal U16 dim_1u16(Rng1U16 r); +internal Rng1U16 union_1u16(Rng1U16 a, Rng1U16 b); +internal Rng1U16 intersect_1u16(Rng1U16 a, Rng1U16 b); +internal U16 clamp_1u16(Rng1U16 r, U16 v); + #define r1u32(min, max) rng_1u32((min), (max)) internal Rng1U32 rng_1u32(U32 min, U32 max); internal Rng1U32 shift_1u32(Rng1U32 r, U32 x); diff --git a/src/base/base_memory.c b/src/base/base_memory.c new file mode 100644 index 00000000..ae447aab --- /dev/null +++ b/src/base/base_memory.c @@ -0,0 +1,2 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) diff --git a/src/base/base_memory.h b/src/base/base_memory.h new file mode 100644 index 00000000..e6f58271 --- /dev/null +++ b/src/base/base_memory.h @@ -0,0 +1,26 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef BASE_MEMORY_H +#define BASE_MEMORY_H + +typedef struct SharedMemory SharedMemory; +struct SharedMemory +{ + U64 u64[1]; +}; + +//////////////////////////////// +//~ rjf: @per_os_impl Platform Memory Allocation + +//- rjf: basic +internal void *reserve_memory(U64 size); +internal B32 commit_memory(void *ptr, U64 size); +internal void decommit_memory(void *ptr, U64 size); +internal void release_memory(void *ptr, U64 size); + +//- rjf: large pages +internal void *reserve_memory_large(U64 size); +internal B32 commit_memory_large(void *ptr, U64 size); + +#endif // BASE_MEMORY_H diff --git a/src/base/base_processes.c b/src/base/base_processes.c new file mode 100644 index 00000000..40c4d4d7 --- /dev/null +++ b/src/base/base_processes.c @@ -0,0 +1,115 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//////////////////////////////// +//~ rjf: Handle Type Functions + +internal Process +process_zero(void) +{ + Process p = {0}; + return p; +} + +internal B32 +process_match(Process a, Process b) +{ + B32 result = MemoryMatchStruct(&a, &b); + return result; +} + +internal void +process_list_push(Arena *arena, ProcessList *list, Process p) +{ + ProcessNode *n = push_array(arena, ProcessNode, 1); + SLLQueuePush(list->first, list->last, n); + n->v = p; + list->count += 1; +} + +//////////////////////////////// +//~ rjf: Process Launcher Helpers + +internal Process +launch_cmd_line(String8 string) +{ + Temp scratch = scratch_begin(0, 0); + U8 split_chars[] = {' '}; + String8List parts = str8_split(scratch.arena, string, split_chars, ArrayCount(split_chars), 0); + Process process = {0}; + if(parts.node_count != 0) + { + // rjf: unpack exe part + String8 exe = parts.first->string; + String8 exe_folder = str8_chop_last_slash(exe); + if(exe_folder.size == 0) + { + exe_folder = get_current_path(scratch.arena); + } + + // rjf: find stdout delimiter + String8Node *stdout_delimiter_n = 0; + for(String8Node *n = parts.first; n != 0; n = n->next) + { + if(str8_match(n->string, str8_lit(">"), 0)) + { + stdout_delimiter_n = n; + break; + } + } + + // rjf: read stdout path + String8 stdout_path = {0}; + if(stdout_delimiter_n && stdout_delimiter_n->next) + { + stdout_path = stdout_delimiter_n->next->string; + } + + // rjf: open stdout handle + File stdout_handle = {0}; + if(stdout_path.size != 0) + { + File file = file_open(AccessFlag_Write|AccessFlag_Read, stdout_path); + file_close(file); + stdout_handle = file_open(AccessFlag_Write|AccessFlag_Append|AccessFlag_ShareRead|AccessFlag_ShareWrite|AccessFlag_Inherited, stdout_path); + } + + // rjf: form command line + String8List cmdline = {0}; + for(String8Node *n = parts.first; n != stdout_delimiter_n && n != 0; n = n->next) + { + str8_list_push(scratch.arena, &cmdline, n->string); + } + + // rjf: launch + ProcessLaunchParams params = {0}; + params.cmd_line = cmdline; + params.path = exe_folder; + params.inherit_env = 1; + params.stdout_file = stdout_handle; + process = process_launch(¶ms); + + // rjf: close stdout handle + { + if(stdout_path.size != 0) + { + file_close(stdout_handle); + } + } + } + scratch_end(scratch); + return process; +} + +internal Process +launch_cmd_linef(char *fmt, ...) +{ + Temp scratch = scratch_begin(0, 0); + va_list args; + va_start(args, fmt); + String8 string = str8fv(scratch.arena, fmt, args); + Process result = launch_cmd_line(string); + va_end(args); + scratch_end(scratch); + return result; +} diff --git a/src/base/base_processes.h b/src/base/base_processes.h new file mode 100644 index 00000000..a2d1bdee --- /dev/null +++ b/src/base/base_processes.h @@ -0,0 +1,87 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef BASE_PROCESSES_H +#define BASE_PROCESSES_H + +typedef struct ProcessInfo ProcessInfo; +struct ProcessInfo +{ + U32 pid; + B32 large_pages_allowed; + String8 binary_path; + String8 initial_path; + String8 user_program_data_path; + String8List module_load_paths; + String8List environment; +}; + +typedef struct Process Process; +struct Process +{ + U64 u64[1]; +}; + +typedef struct ProcessNode ProcessNode; +struct ProcessNode +{ + ProcessNode *next; + Process v; +}; + +typedef struct ProcessList ProcessList; +struct ProcessList +{ + ProcessNode *first; + ProcessNode *last; + U64 count; +}; + +typedef struct ProcessLaunchParams ProcessLaunchParams; +struct ProcessLaunchParams +{ + String8List cmd_line; + String8 path; + String8List env; + B32 inherit_env; + B32 debug_subprocesses; + B32 consoleless; + File stdout_file; + File stderr_file; + File stdin_file; +}; + +//////////////////////////////// +//~ rjf: Handle Type Functions + +internal Process process_zero(void); +internal B32 process_match(Process a, Process b); +internal void process_list_push(Arena *arena, ProcessList *list, Process p); + +//////////////////////////////// +//~ rjf: Process Launcher Helpers + +internal Process launch_cmd_line(String8 string); +internal Process launch_cmd_linef(char *fmt, ...); + +//////////////////////////////// +//~ rjf: @per_os_impl Aborting + +internal void abort_self(S32 exit_code); + +//////////////////////////////// +//~ rjf: @per_os_impl Process Info + +internal ProcessInfo *get_process_info(void); +internal String8 get_current_path(Arena *arena); +internal U32 get_process_start_time_unix(void); + +//////////////////////////////// +//~ rjf: @per_os_impl Child Processes + +internal Process process_launch(ProcessLaunchParams *params); +internal B32 process_join(Process process, U64 endt_us, U64 *exit_code_out); +internal void process_detach(Process process); +internal B32 process_kill(Process process); + +#endif // BASE_PROCESSES_H diff --git a/src/base/base_profile.c b/src/base/base_profile.c index 2216a282..c614f08e 100644 --- a/src/base/base_profile.c +++ b/src/base/base_profile.c @@ -24,7 +24,7 @@ spall_begin(char *fmt, ...) va_list args; va_start(args, fmt); String8 string = push_str8fv(scratch.arena, fmt, args); - spall_buffer_begin_ex(&spall_profile, &spall_buffer, string.str, string.size, os_now_microseconds(), spall_tid, spall_pid); + spall_buffer_begin_ex(&spall_profile, &spall_buffer, string.str, string.size, now_time_us(), spall_tid, spall_pid); va_end(args); scratch_end(scratch); } diff --git a/src/base/base_profile.h b/src/base/base_profile.h index 6ef4a046..ed11cfa2 100644 --- a/src/base/base_profile.h +++ b/src/base/base_profile.h @@ -79,7 +79,7 @@ thread_static U32 spall_pid = 0; internal inline void spall_begin(char *fmt, ...); # define ProfBegin(...) (spall_capturing ? (spall_begin(__VA_ARGS__), 0) : 0) # define ProfBeginDynamic(...) (spall_capturing ? (spall_begin(__VA_ARGS__), 0) : 0) -# define ProfEnd(...) (spall_capturing ? (spall_buffer_end_ex(&spall_profile, &spall_buffer, os_now_microseconds(), spall_tid, spall_pid)), 0 : 0) +# define ProfEnd(...) (spall_capturing ? (spall_buffer_end_ex(&spall_profile, &spall_buffer, now_time_us(), spall_tid, spall_pid)), 0 : 0) # define ProfTick(...) # define ProfIsCapturing(...) (!!spall_capturing) # define ProfBeginCapture(...) (spall_capturing = 1) diff --git a/src/base/base_shared_memory.c b/src/base/base_shared_memory.c new file mode 100644 index 00000000..ae447aab --- /dev/null +++ b/src/base/base_shared_memory.c @@ -0,0 +1,2 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) diff --git a/src/base/base_shared_memory.h b/src/base/base_shared_memory.h new file mode 100644 index 00000000..7d9f1498 --- /dev/null +++ b/src/base/base_shared_memory.h @@ -0,0 +1,16 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef BASE_SHARED_MEMORY_H +#define BASE_SHARED_MEMORY_H + +//////////////////////////////// +//~ rjf: @os_hooks Shared Memory + +internal SharedMemory shared_memory_alloc(U64 size, String8 name); +internal SharedMemory shared_memory_open(String8 name); +internal void shared_memory_close(SharedMemory handle); +internal void * shared_memory_view_open(SharedMemory handle, Rng1U64 range); +internal void shared_memory_view_close(SharedMemory handle, void *ptr, Rng1U64 range); + +#endif // BASE_SHARED_MEMORY_H diff --git a/src/base/base_system.c b/src/base/base_system.c new file mode 100644 index 00000000..ae447aab --- /dev/null +++ b/src/base/base_system.c @@ -0,0 +1,2 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) diff --git a/src/base/base_system.h b/src/base/base_system.h new file mode 100644 index 00000000..2907c881 --- /dev/null +++ b/src/base/base_system.h @@ -0,0 +1,22 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef BASE_SYSTEM_H +#define BASE_SYSTEM_H + +typedef struct SystemInfo SystemInfo; +struct SystemInfo +{ + U32 logical_processor_count; + U64 page_size; + U64 large_page_size; + U64 allocation_granularity; + String8 machine_name; +}; + +//////////////////////////////// +//~ rjf: @per_os_impl System Info + +internal SystemInfo *get_system_info(void); + +#endif // BASE_SYSTEM_H diff --git a/src/base/base_thread_context.c b/src/base/base_thread_context.c index b8d87170..a6a8dfc2 100644 --- a/src/base/base_thread_context.c +++ b/src/base/base_thread_context.c @@ -108,7 +108,7 @@ tctx_lane_barrier_wait(void *broadcast_ptr, U64 broadcast_size, U64 broadcast_sr } // rjf: all cases: barrier - os_barrier_wait(tctx->lane_ctx.barrier); + barrier_wait(tctx->lane_ctx.barrier); // rjf: doing broadcast -> copy from broadcast memory on destination lanes if(broadcast_ptr != 0 && lane_idx() != broadcast_src_lane_idx) @@ -119,7 +119,7 @@ tctx_lane_barrier_wait(void *broadcast_ptr, U64 broadcast_size, U64 broadcast_sr // rjf: doing broadcast -> barrier on all lanes if(broadcast_ptr != 0) { - os_barrier_wait(tctx->lane_ctx.barrier); + barrier_wait(tctx->lane_ctx.barrier); } ProfEnd(); @@ -202,7 +202,7 @@ internal void access_touch(Access *access, AccessPt *pt, CondVar cv) { ins_atomic_u64_inc_eval(&pt->access_refcount); - ins_atomic_u64_eval_assign(&pt->last_time_touched_us, os_now_microseconds()); + ins_atomic_u64_eval_assign(&pt->last_time_touched_us, now_time_us()); ins_atomic_u64_eval_assign(&pt->last_update_idx_touched, update_tick_idx()); Touch *touch = tctx_thread_local->free_touch; if(touch != 0) @@ -228,7 +228,7 @@ access_pt_is_expired_(AccessPt *pt, AccessPtExpireParams *params) U64 last_time_touched_us = ins_atomic_u64_eval(&pt->last_time_touched_us); U64 last_update_idx_touched = ins_atomic_u64_eval(&pt->last_update_idx_touched); B32 result = (access_refcount == 0 && - last_time_touched_us + params->time <= os_now_microseconds() && + last_time_touched_us + params->time <= now_time_us() && last_update_idx_touched + params->update_idxs <= update_tick_idx()); return result; } diff --git a/src/base/base_threads.c b/src/base/base_threads.c index 50c6e370..c8b4c1eb 100644 --- a/src/base/base_threads.c +++ b/src/base/base_threads.c @@ -1,70 +1,6 @@ // Copyright (c) Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) -//////////////////////////////// -//~ rjf: Thread Functions - -internal Thread -thread_launch(ThreadEntryPointFunctionType *f, void *p) -{ - Thread thread = os_thread_launch(f, p); - return thread; -} - -internal B32 -thread_join(Thread thread, U64 endt_us) -{ - B32 result = os_thread_join(thread, endt_us); - return result; -} - -internal void -thread_detach(Thread thread) -{ - os_thread_detach(thread); -} - -//////////////////////////////// -//~ rjf: Synchronization Primitive Functions - -//- rjf: recursive mutexes - -internal Mutex mutex_alloc(void) {return os_mutex_alloc();} -internal void mutex_release(Mutex mutex) {os_mutex_release(mutex);} -internal void mutex_take(Mutex mutex) {os_mutex_take(mutex);} -internal void mutex_drop(Mutex mutex) {os_mutex_drop(mutex);} - -//- rjf: reader/writer mutexes - -internal RWMutex rw_mutex_alloc(void) {return os_rw_mutex_alloc();} -internal void rw_mutex_release(RWMutex mutex) {os_rw_mutex_release(mutex);} -internal void rw_mutex_take(RWMutex mutex, B32 write_mode) {os_rw_mutex_take(mutex, write_mode);} -internal void rw_mutex_drop(RWMutex mutex, B32 write_mode) {os_rw_mutex_drop(mutex, write_mode);} - -//- rjf: condition variables - -internal CondVar cond_var_alloc(void) {return os_cond_var_alloc();} -internal void cond_var_release(CondVar cv) {os_cond_var_release(cv);} -internal B32 cond_var_wait(CondVar cv, Mutex mutex, U64 endt_us) {return os_cond_var_wait(cv, mutex, endt_us);} -internal B32 cond_var_wait_rw(CondVar cv, RWMutex mutex_rw, B32 write_mode, U64 endt_us) {return os_cond_var_wait_rw(cv, mutex_rw, write_mode, endt_us);} -internal void cond_var_signal(CondVar cv) {os_cond_var_signal(cv);} -internal void cond_var_broadcast(CondVar cv) {os_cond_var_broadcast(cv);} - -//- rjf: cross-process semaphores - -internal Semaphore semaphore_alloc(U32 initial_count, U32 max_count, String8 name) {return os_semaphore_alloc(initial_count, max_count, name);} -internal void semaphore_release(Semaphore semaphore) {os_semaphore_release(semaphore);} -internal Semaphore semaphore_open(String8 name) {return os_semaphore_open(name);} -internal void semaphore_close(Semaphore semaphore) {os_semaphore_close(semaphore);} -internal B32 semaphore_take(Semaphore semaphore, U64 endt_us) {return os_semaphore_take(semaphore, endt_us);} -internal void semaphore_drop(Semaphore semaphore) {os_semaphore_drop(semaphore);} - -//- rjf: barriers - -internal Barrier barrier_alloc(U64 count) {return os_barrier_alloc(count);} -internal void barrier_release(Barrier barrier) {os_barrier_release(barrier);} -internal void barrier_wait(Barrier barrier) {os_barrier_wait(barrier);} - //////////////////////////////// //~ rjf: Table Stripe Functions @@ -72,7 +8,7 @@ internal StripeArray stripe_array_alloc(Arena *arena) { StripeArray array = {0}; - array.count = os_get_system_info()->logical_processor_count; + array.count = get_system_info()->logical_processor_count; array.v = push_array(arena, Stripe, array.count); for EachIndex(idx, array.count) { @@ -100,3 +36,25 @@ stripe_from_slot_idx(StripeArray *stripes, U64 slot_idx) Stripe *stripe = &stripes->v[slot_idx%stripes->count]; return stripe; } + +//////////////////////////////// +//~ rjf: Thread Info Helpers + +internal void +set_thread_name(String8 string) +{ + ProfThreadName("%.*s", str8_varg(string)); + set_platform_thread_name(string); +} + +internal void +set_thread_namef(char *fmt, ...) +{ + Temp scratch = scratch_begin(0, 0); + va_list args; + va_start(args, fmt); + String8 string = push_str8fv(scratch.arena, fmt, args); + set_thread_name(string); + va_end(args); + scratch_end(scratch); +} diff --git a/src/base/base_threads.h b/src/base/base_threads.h index 330efb00..f179a219 100644 --- a/src/base/base_threads.h +++ b/src/base/base_threads.h @@ -67,14 +67,33 @@ struct StripeArray }; //////////////////////////////// -//~ rjf: Thread Functions +//~ rjf: Table Stripe Functions + +internal StripeArray stripe_array_alloc(Arena *arena); +internal void stripe_array_release(StripeArray *stripes); +internal Stripe *stripe_from_slot_idx(StripeArray *stripes, U64 slot_idx); + +//////////////////////////////// +//~ rjf: Thread Info Helpers + +internal void set_thread_name(String8 string); +internal void set_thread_namef(char *fmt, ...); + +//////////////////////////////// +//~ rjf: @per_os_impl Current Thread Info + +internal U32 tid(void); +internal void set_platform_thread_name(String8 name); + +//////////////////////////////// +//~ rjf: @per_os_impl Thread Functions internal Thread thread_launch(ThreadEntryPointFunctionType *f, void *p); internal B32 thread_join(Thread thread, U64 endt_us); internal void thread_detach(Thread thread); //////////////////////////////// -//~ rjf: Synchronization Primitive Functions +//~ rjf: @per_os_impl Synchronization Primitive Functions //- rjf: recursive mutexes internal Mutex mutex_alloc(void); @@ -124,10 +143,8 @@ internal void barrier_wait(Barrier barrier); #define MutexScopeRWPromote(mutex) DeferLoop((rw_mutex_drop_r(mutex), rw_mutex_take_w(mutex)), (rw_mutex_drop_w(mutex), rw_mutex_take_r(mutex))) //////////////////////////////// -//~ rjf: Table Stripe Functions +//~ rjf: @per_os_impl Safe Calls -internal StripeArray stripe_array_alloc(Arena *arena); -internal void stripe_array_release(StripeArray *stripes); -internal Stripe *stripe_from_slot_idx(StripeArray *stripes, U64 slot_idx); +internal void safe_call(ThreadEntryPointFunctionType *func, ThreadEntryPointFunctionType *fail_handler, void *ptr); #endif // BASE_THREADS_H diff --git a/src/content/content.c b/src/content/content.c index 04a3b6bb..6ff6c6f0 100644 --- a/src/content/content.c +++ b/src/content/content.c @@ -46,7 +46,7 @@ c_init(void) c_shared = push_array(arena, C_Shared, 1); c_shared->arena = arena; c_shared->blob_slots_count = 16384; - c_shared->blob_stripes_count = Min(c_shared->blob_slots_count, os_get_system_info()->logical_processor_count); + c_shared->blob_stripes_count = Min(c_shared->blob_slots_count, get_system_info()->logical_processor_count); c_shared->blob_slots = push_array(arena, C_BlobSlot, c_shared->blob_slots_count); c_shared->blob_stripes = push_array(arena, C_Stripe, c_shared->blob_stripes_count); c_shared->blob_stripes_free_nodes = push_array(arena, C_BlobNode *, c_shared->blob_stripes_count); @@ -58,7 +58,7 @@ c_init(void) stripe->cv = cond_var_alloc(); } c_shared->key_slots_count = 4096; - c_shared->key_stripes_count = Min(c_shared->key_slots_count, os_get_system_info()->logical_processor_count); + c_shared->key_stripes_count = Min(c_shared->key_slots_count, get_system_info()->logical_processor_count); c_shared->key_slots = push_array(arena, C_KeySlot, c_shared->key_slots_count); c_shared->key_stripes = push_array(arena, C_Stripe, c_shared->key_stripes_count); c_shared->key_stripes_free_nodes = push_array(arena, C_KeyNode *, c_shared->key_stripes_count); @@ -70,7 +70,7 @@ c_init(void) stripe->cv = cond_var_alloc(); } c_shared->root_slots_count = 4096; - c_shared->root_stripes_count = Min(c_shared->root_slots_count, os_get_system_info()->logical_processor_count); + c_shared->root_stripes_count = Min(c_shared->root_slots_count, get_system_info()->logical_processor_count); c_shared->root_slots = push_array(arena, C_RootSlot, c_shared->root_slots_count); c_shared->root_stripes = push_array(arena, C_Stripe, c_shared->root_stripes_count); c_shared->root_stripes_free_nodes = push_array(arena, C_RootNode *, c_shared->root_stripes_count); diff --git a/src/dbg_engine/dbg_engine_core.c b/src/dbg_engine/dbg_engine_core.c index b80b61a7..4606be04 100644 --- a/src/dbg_engine/dbg_engine_core.c +++ b/src/dbg_engine/dbg_engine_core.c @@ -17,26 +17,20 @@ d_init(void) Arena *arena = arena_alloc(); d_ctrl_state = push_array(arena, D_CtrlState, 1); d_ctrl_state->arena = arena; - for(Arch arch = (Arch)0; arch < Arch_COUNT; arch = (Arch)(arch+1)) + for EachEnumVal(Arch, arch) { - String8 *reg_names = regs_reg_code_string_table_from_arch(arch); - U64 reg_count = regs_reg_code_count_from_arch(arch); - String8 *alias_names = regs_alias_code_string_table_from_arch(arch); - U64 alias_count = regs_alias_code_count_from_arch(arch); + ARCH_Info *arch_info = arch_info_from_arch(arch); + U64 reg_count = arch_info->reg_code_count; + String8 *reg_names = arch_info->reg_code_name_table; d_ctrl_state->arch_string2reg_tables[arch] = e_string2num_map_make(d_ctrl_state->arena, 256); - d_ctrl_state->arch_string2alias_tables[arch] = e_string2num_map_make(d_ctrl_state->arena, 256); for(U64 idx = 1; idx < reg_count; idx += 1) { e_string2num_map_insert(d_ctrl_state->arena, &d_ctrl_state->arch_string2reg_tables[arch], reg_names[idx], idx); } - for(U64 idx = 1; idx < alias_count; idx += 1) - { - e_string2num_map_insert(d_ctrl_state->arena, &d_ctrl_state->arch_string2alias_tables[arch], alias_names[idx], idx); - } } d_ctrl_state->thread_reg_cache.slots_count = 1024; d_ctrl_state->thread_reg_cache.slots = push_array(arena, D_ThreadRegCacheSlot, d_ctrl_state->thread_reg_cache.slots_count); - d_ctrl_state->thread_reg_cache.stripes_count = os_get_system_info()->logical_processor_count; + d_ctrl_state->thread_reg_cache.stripes_count = get_system_info()->logical_processor_count; d_ctrl_state->thread_reg_cache.stripes = push_array(arena, D_ThreadRegCacheStripe, d_ctrl_state->thread_reg_cache.stripes_count); for(U64 idx = 0; idx < d_ctrl_state->thread_reg_cache.stripes_count; idx += 1) { @@ -45,7 +39,7 @@ d_init(void) } d_ctrl_state->module_image_info_cache.slots_count = 1024; d_ctrl_state->module_image_info_cache.slots = push_array(arena, D_ModuleImageInfoCacheSlot, d_ctrl_state->module_image_info_cache.slots_count); - d_ctrl_state->module_image_info_cache.stripes_count = os_get_system_info()->logical_processor_count; + d_ctrl_state->module_image_info_cache.stripes_count = get_system_info()->logical_processor_count; d_ctrl_state->module_image_info_cache.stripes = push_array(arena, D_ModuleImageInfoCacheStripe, d_ctrl_state->module_image_info_cache.stripes_count); for(U64 idx = 0; idx < d_ctrl_state->module_image_info_cache.stripes_count; idx += 1) { @@ -63,11 +57,11 @@ d_init(void) d_ctrl_state->c2u_ring_cv = cond_var_alloc(); { Temp scratch = scratch_begin(0, 0); - String8 user_program_data_path = os_get_process_info()->user_program_data_path; + String8 user_program_data_path = get_process_info()->user_program_data_path; String8 user_data_folder = push_str8f(scratch.arena, "%S/raddbg/logs", user_program_data_path); - os_make_directory(user_data_folder); + make_directory(user_data_folder); d_ctrl_state->ctrl_thread_log_path = push_str8f(d_ctrl_state->arena, "%S/ctrl_thread.raddbg_log", user_data_folder); - os_write_data_to_file_path(d_ctrl_state->ctrl_thread_log_path, str8_zero()); + write_data_to_file_path(d_ctrl_state->ctrl_thread_log_path, str8_zero()); scratch_end(scratch); } d_ctrl_state->ctrl_thread_entity_ctx_rw_mutex = rw_mutex_alloc(); diff --git a/src/dbg_engine/dbg_engine_ctrl.c b/src/dbg_engine/dbg_engine_ctrl.c index ef4fbd74..08523c24 100644 --- a/src/dbg_engine/dbg_engine_ctrl.c +++ b/src/dbg_engine/dbg_engine_ctrl.c @@ -885,7 +885,7 @@ d_entity_ctx_rw_store_alloc(void) 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); + String8 local_machine_name = push_str8f(scratch.arena, "This PC (%S)", get_system_info()->machine_name); d_entity_equip_string(store, local_machine, local_machine_name); scratch_end(scratch); return store; @@ -1476,7 +1476,8 @@ 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 = d_entity_from_handle(ctx, handle); Arch arch = thread_entity->arch; - U64 reg_block_size = regs_block_size_from_arch(arch); + ARCH_Info *arch_info = arch_info_from_arch(arch); + U64 reg_block_size = arch_info->reg_block_size; U64 hash = d_hash_from_handle(handle); U64 slot_idx = hash%cache->slots_count; U64 stripe_idx = slot_idx%cache->stripes_count; @@ -1543,8 +1544,9 @@ d_rip_from_thread(D_EntityCtx *ctx, D_Handle handle) Temp scratch = scratch_begin(0, 0); D_Entity *thread_entity = d_entity_from_handle(ctx, handle); Arch arch = thread_entity->arch; + ARCH_Info *arch_info = arch_info_from_arch(arch); void *block = d_reg_block_from_thread(scratch.arena, ctx, handle); - U64 result = regs_rip_from_arch_block(arch, block); + U64 result = arch_ip_from_reg_block(arch_info, block); scratch_end(scratch); return result; } @@ -1555,8 +1557,9 @@ d_rsp_from_thread(D_EntityCtx *ctx, D_Handle handle) Temp scratch = scratch_begin(0, 0); D_Entity *thread_entity = d_entity_from_handle(ctx, handle); Arch arch = thread_entity->arch; + ARCH_Info *arch_info = arch_info_from_arch(arch); void *block = d_reg_block_from_thread(scratch.arena, ctx, handle); - U64 result = regs_rsp_from_arch_block(arch, block); + U64 result = arch_sp_from_reg_block(arch_info, block); scratch_end(scratch); return result; } @@ -1708,7 +1711,7 @@ d_raddbg_data_from_module(Arena *arena, D_Handle module_handle) } //////////////////////////////// -//~ rjf: Unwinding Functions} +//~ rjf: Unwinding Functions //- rjf: [dwarf] @@ -1716,7 +1719,7 @@ typedef struct D_MemoryReadContextDwarfX64 D_MemoryReadContextDwarfX64; struct D_MemoryReadContextDwarfX64 { D_Handle process_handle; - U64 endt_us; + U64 endt_us; }; internal MACHINE_OP_MEM_READ(ctrl_machine_mem_read) @@ -1765,6 +1768,7 @@ 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) { Temp scratch = scratch_begin(&arena, 1); + ARCH_Info *arch_info = arch_info_from_arch(arch); D_UnwindStepResult result = { .flags = D_UnwindFlag_Error }; // gather context for virtual stack unwinder @@ -1774,11 +1778,11 @@ d_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle, D EH_FrameHdr eh_frame_hdr = {0}; EH_PtrCtx eh_ptr_ctx = {0}; { - 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]; + 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(d_handle_match(n->module, module_handle)) @@ -1794,7 +1798,7 @@ d_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle, D } // grab IP - U64 ip = regs_rip_from_arch_block(arch, regs); + U64 ip = arch_ip_from_reg_block(arch_info, regs); // use .eh_frame_hdr to quickly locate nearest FDE U64 fde_addr = eh_find_nearest_fde(eh_frame_hdr, &eh_ptr_ctx, ip); @@ -1914,9 +1918,7 @@ d_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle, D { // setup machine ops void *mem_read_ctx = 0; - void *reg_read_ctx = 0; MachineOp_MemRead *mem_read_func = 0; - MachineOp_RegRead *reg_read_func = 0; switch(arch) { case Arch_Null: break; @@ -1925,12 +1927,8 @@ d_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle, D 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; - mem_read_func = ctrl_machine_mem_read; - reg_read_func = regs_read_dwarf_x64; }break; case Arch_x86: case Arch_arm64: @@ -1943,7 +1941,7 @@ d_establish_frame_unwind_context__dwarf(Arena *arena, D_Handle process_handle, D // compute CFA for the row U64 cfa = 0; - MachineOpResult unwind_status = dw_compute_cfa(arch, cfi_row, mem_read_func, mem_read_ctx, reg_read_func, reg_read_ctx, &cfa); + MachineOpResult unwind_status = dw_compute_cfa(arch, cfi_row, regs, mem_read_func, mem_read_ctx, &cfa); // on success fill out output if(unwind_status == MachineOpResult_Ok) @@ -1990,26 +1988,17 @@ d_unwind_step__dwarf(D_Handle process_handle, Arch arch, void *regs, D_FrameUnwi 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; } // apply register rules to the context - MachineOpResult unwind_status = dw_cfi_apply_register_rules(arch, - frame_ctx->cfa, - frame_ctx->cfi_row, - mem_read_func, - mem_read_ctx, - reg_read_func, - reg_read_ctx, - reg_write_func, - reg_write_ctx); + MachineOpResult unwind_status = dw_cfi_apply_register_rules(arch, frame_ctx->cfa, frame_ctx->cfi_row, regs, mem_read_func, mem_read_ctx); // last frame typically has undefined rule for IP if(frame_ctx->cfi_row->regs[frame_ctx->ret_addr_reg].rule == DW_CFI_RegisterRule_Undefined) { - regs_arch_block_write_rip(arch, regs, 0); + ARCH_Info *arch_info = arch_info_from_arch(arch); + arch_reg_block_write_ip(arch_info, regs, 0); } // translate unwind status code @@ -2021,11 +2010,11 @@ d_unwind_step__dwarf(D_Handle process_handle, Arch arch, void *regs, D_FrameUnwi //- rjf: [x64] -internal REGS_Reg64 * -d_unwind_reg_from_pe_gpr_reg__pe_x64(REGS_RegBlockX64 *regs, PE_UnwindGprRegX64 gpr_reg) +internal U64 * +d_unwind_reg_from_pe_gpr_reg__pe_x64(X64_RegBlock *regs, PE_UnwindGprRegX64 gpr_reg) { - local_persist REGS_Reg64 dummy = {0}; - REGS_Reg64 *result = &dummy; + local_persist U64 dummy = {0}; + U64 *result = &dummy; switch(gpr_reg) { case PE_UnwindGprRegX64_RAX:{result = ®s->rax;}break; @@ -2049,7 +2038,7 @@ d_unwind_reg_from_pe_gpr_reg__pe_x64(REGS_RegBlockX64 *regs, PE_UnwindGprRegX64 } 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) +d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 module_base_vaddr, X64_RegBlock *regs, U64 endt_us) { B32 is_stale = 0; B32 is_good = 1; @@ -2058,7 +2047,7 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul ////////////////////////////// //- rjf: unpack parameters // - U64 rip_voff = regs->rip.u64 - module_base_vaddr; + U64 rip_voff = regs->rip - module_base_vaddr; ////////////////////////////// //- rjf: rip_voff -> first pdata @@ -2079,7 +2068,7 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul //- rjf: set up parsing state B32 is_epilog = 0; B32 keep_parsing = 1; - U64 read_vaddr = regs->rip.u64; + U64 read_vaddr = regs->rip; U64 read_vaddr_opl = read_vaddr + 256; //- rjf: check first instruction @@ -2271,7 +2260,7 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul // if(first_pdata && has_pdata_and_in_epilog) ProfScope("pdata & in epilog -> epilog unwind") { - U64 read_vaddr = regs->rip.u64; + U64 read_vaddr = regs->rip; for(B32 keep_parsing = 1;keep_parsing != 0;) { //- rjf: assume no more parsing after this instruction @@ -2307,7 +2296,7 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul case 0x5F: { // rjf: read value at rsp - U64 sp = regs->rsp.u64; + U64 sp = regs->rsp; U64 value = 0; if(!d_process_memory_read_struct(process_handle, sp, &is_stale, &value, endt_us) || is_stale) @@ -2318,9 +2307,9 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul // rjf: modify registers PE_UnwindGprRegX64 gpr_reg = (inst_byte - 0x58) + (rex & 1)*8; - REGS_Reg64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, gpr_reg); - reg->u64 = value; - regs->rsp.u64 = sp + 8; + U64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, gpr_reg); + reg[0] = value; + regs->rsp = sp + 8; // rjf: not a final instruction, so keep mparsing keep_parsing = 1; @@ -2343,7 +2332,7 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul read_vaddr += 4; // rjf: update stack pointer - regs->rsp.u64 = (U64)(regs->rsp.u64 + imm); + regs->rsp = (U64)(regs->rsp + imm); // rjf: not a final instruction; keep parsing keep_parsing = 1; @@ -2366,7 +2355,7 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul read_vaddr += 1; // rjf: update stack pointer - regs->rsp.u64 = (U64)(regs->rsp.u64 + imm); + regs->rsp = (U64)(regs->rsp + imm); // rjf: not a final instruction; keep parsing keep_parsing = 1; @@ -2385,8 +2374,8 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul } read_vaddr += 1; PE_UnwindGprRegX64 gpr_reg = (modrm & 7) + (rex & 1)*8; - REGS_Reg64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, gpr_reg); - U64 reg_value = reg->u64; + U64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, gpr_reg); + U64 reg_value = reg[0]; // rjf: read immediate S32 imm = 0; @@ -2419,7 +2408,7 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul } // rjf: update stack pointer - regs->rsp.u64 = (U64)(reg_value + imm); + regs->rsp = (U64)(reg_value + imm); // rjf: not a final instruction; keep parsing keep_parsing = 1; @@ -2429,7 +2418,7 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul case 0xC2: { // rjf: read new ip - U64 sp = regs->rsp.u64; + U64 sp = regs->rsp; U64 new_ip = 0; if(!d_process_memory_read_struct(process_handle, sp, &is_stale, &new_ip, endt_us) || is_stale) @@ -2449,8 +2438,8 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul U64 new_sp = sp + 8 + imm; // rjf: commit registers - regs->rip.u64 = new_ip; - regs->rsp.u64 = new_sp; + regs->rip = new_ip; + regs->rsp = new_sp; }break; // rjf: ret / rep; ret @@ -2461,7 +2450,7 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul case 0xC3: { // rjf: read new ip - U64 sp = regs->rsp.u64; + U64 sp = regs->rsp; U64 new_ip = 0; if(!d_process_memory_read_struct(process_handle, sp, &is_stale, &new_ip, endt_us) || is_stale) @@ -2474,8 +2463,8 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul U64 new_sp = sp + 8; // rjf: commit registers - regs->rip.u64 = new_ip; - regs->rsp.u64 = new_sp; + regs->rip = new_ip; + regs->rsp = new_sp; }break; // rjf: jmp nnnn @@ -2505,7 +2494,7 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul { //- rjf: get frame reg B32 bad_frame_reg_info = 0; - REGS_Reg64 *frame_reg = 0; + U64 *frame_reg = 0; U64 frame_off = 0; { U64 unwind_info_off = first_pdata->voff_unwind_info; @@ -2549,10 +2538,10 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul } //- rjf: unpack frame base - U64 frame_base = regs->rsp.u64; + U64 frame_base = regs->rsp; if(frame_reg != 0) { - U64 raw_frame_base = frame_reg->u64; + U64 raw_frame_base = frame_reg[0]; U64 adjusted_frame_base = raw_frame_base - frame_off*16; frame_base = adjusted_frame_base; } @@ -2591,7 +2580,7 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul case PE_UnwindOpCode_PUSH_NONVOL: { // rjf: read value from stack pointer - U64 rsp = regs->rsp.u64; + U64 rsp = regs->rsp; U64 value = 0; if(!d_process_memory_read_struct(process_handle, rsp, &is_stale, &value, endt_us) || is_stale) @@ -2605,9 +2594,9 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul U64 new_rsp = rsp + 8; // rjf: commit registers - REGS_Reg64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, op_info); - reg->u64 = value; - regs->rsp.u64 = new_rsp; + U64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, op_info); + reg[0] = value; + regs->rsp = new_rsp; }break; case PE_UnwindOpCode_ALLOC_LARGE: @@ -2630,23 +2619,23 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul } // rjf: advance stack pointer - U64 rsp = regs->rsp.u64; + U64 rsp = regs->rsp; U64 new_rsp = rsp + size; // rjf: advance stack pointer - regs->rsp.u64 = new_rsp; + regs->rsp = new_rsp; }break; case PE_UnwindOpCode_ALLOC_SMALL: { // rjf: advance stack pointer - regs->rsp.u64 += op_info*8 + 8; + regs->rsp += op_info*8 + 8; }break; case PE_UnwindOpCode_SET_FPREG: { // rjf: put stack pointer back to the frame base - regs->rsp.u64 = frame_base; + regs->rsp = frame_base; }break; case PE_UnwindOpCode_SAVE_NONVOL: @@ -2664,8 +2653,8 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul } // rjf: commit to register - REGS_Reg64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, op_info); - reg->u64 = value; + U64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, op_info); + reg[0] = value; }break; case PE_UnwindOpCode_SAVE_NONVOL_FAR: @@ -2683,8 +2672,8 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul } // rjf: commit to register - REGS_Reg64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, op_info); - reg->u64 = value; + U64 *reg = d_unwind_reg_from_pe_gpr_reg__pe_x64(regs, op_info); + reg[0] = value; }break; case PE_UnwindOpCode_EPILOG: @@ -2748,7 +2737,7 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul } // rjf: read values - U64 sp_og = regs->rsp.u64; + U64 sp_og = regs->rsp; U64 sp_adj = sp_og; if(op_info == 1) { @@ -2791,10 +2780,10 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul } // rjf: commit registers - regs->rip.u64 = ip_value; - regs->ss.u16 = ss_value; - regs->rflags.u64 = rflags_value; - regs->rsp.u64 = sp_value; + regs->rip = ip_value; + regs->ss = ss_value; + regs->rflags = rflags_value; + regs->rsp = sp_value; // rjf: mark machine frame xdata_unwind_did_machframe = 1; @@ -2832,7 +2821,7 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul if(!first_pdata || (!has_pdata_and_in_epilog && !xdata_unwind_did_machframe)) ProfScope("no pdata, or didn't do machframe in xdata unwind -> unwind by reading stack pointer") { // rjf: read rip from stack pointer - U64 rsp = regs->rsp.u64; + U64 rsp = regs->rsp; U64 new_rip = 0; if(!d_process_memory_read_struct(process_handle, rsp, &is_stale, &new_rip, endt_us) || is_stale) @@ -2844,8 +2833,8 @@ d_unwind_step__pe_x64(D_Handle process_handle, D_Handle module_handle, U64 modul if(is_good) { U64 new_rsp = rsp + 8; - regs->rip.u64 = new_rip; - regs->rsp.u64 = new_rsp; + regs->rip = new_rip; + regs->rsp = new_rsp; } } @@ -2872,7 +2861,8 @@ d_unwind_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle thread, U64 endt_u 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); + ARCH_Info *arch_info = arch_info_from_arch(arch); + U64 arch_reg_block_size = arch_info->reg_block_size; //- rjf: grab initial register block void *regs_block = d_reg_block_from_thread(scratch.arena, ctx, thread); @@ -2886,8 +2876,9 @@ d_unwind_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle thread, U64 endt_u { for(unwind.flags = 0;;) { - U64 rip = regs_rip_from_arch_block(arch, regs_block); - U64 rsp = regs_rsp_from_arch_block(arch, regs_block); + ARCH_Info *arch_info = arch_info_from_arch(arch); + U64 rip = arch_ip_from_reg_block(arch_info, regs_block); + U64 rsp = arch_sp_from_reg_block(arch_info, regs_block); // rjf: cancel on zero rip (except the top frame) if(rip == 0 && frame_node_count > 0) @@ -2958,7 +2949,7 @@ d_unwind_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle thread, U64 endt_u // stop unwinding on errors or stale data unwind.flags |= step_result.flags; if(unwind.flags & (D_UnwindFlag_Stale|D_UnwindFlag_Error) || - (regs_rsp_from_arch_block(arch, regs_block) == rsp && regs_rip_from_arch_block(arch, regs_block) == rip)) + (arch_sp_from_reg_block(arch_info, regs_block) == rsp && arch_ip_from_reg_block(arch_info, regs_block) == rip)) { break; } @@ -3006,8 +2997,9 @@ d_call_stack_from_unwind(Arena *arena, D_Entity *process, D_Unwind *base_unwind) for(U64 base_frame_idx = 0; base_frame_idx < base_unwind->frames.count; base_frame_idx += 1) { // rjf: unpack + ARCH_Info *arch_info = arch_info_from_arch(arch); D_UnwindFrame *src = &base_unwind->frames.v[base_frame_idx]; - U64 rip_vaddr = regs_rip_from_arch_block(arch, src->regs); + U64 rip_vaddr = arch_ip_from_reg_block(arch_info, src->regs); 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); @@ -3149,12 +3141,6 @@ d_string2reg_from_arch(Arch arch) return &d_ctrl_state->arch_string2reg_tables[arch]; } -internal E_String2NumMap * -d_string2alias_from_arch(Arch arch) -{ - return &d_ctrl_state->arch_string2alias_tables[arch]; -} - //////////////////////////////// //~ rjf: Control-Thread Functions @@ -3178,7 +3164,7 @@ d_u2c_push_msgs(D_MsgList *msgs, U64 endt_us) good = 1; break; } - if(os_now_microseconds() >= endt_us) + if(now_time_us() >= endt_us) { break; } @@ -3243,7 +3229,7 @@ d_c2u_push_events(D_EventList *events) d_ctrl_state->c2u_ring_write_pos += ring_write(d_ctrl_state->c2u_ring_base, d_ctrl_state->c2u_ring_size, d_ctrl_state->c2u_ring_write_pos, event_srlzed.str, event_srlzed.size); break; } - cond_var_wait(d_ctrl_state->c2u_ring_cv, d_ctrl_state->c2u_ring_mutex, os_now_microseconds()+100); + cond_var_wait(d_ctrl_state->c2u_ring_cv, d_ctrl_state->c2u_ring_mutex, now_time_us()+100); } cond_var_broadcast(d_ctrl_state->c2u_ring_cv); if(d_ctrl_state->wakeup_hook != 0) @@ -3425,7 +3411,7 @@ d_ctrl_thread__entry_point(void *p) { 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; + U64 new_dbgi_timestamp = 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); @@ -3466,7 +3452,7 @@ d_ctrl_thread__entry_point(void *p) { D_EntityCtx *entity_ctx = &d_ctrl_state->ctrl_thread_entity_store->ctx; D_EntityArray threads = d_entity_array_from_kind(entity_ctx, D_EntityKind_Thread); - REGS_RegBlockX64 *blocks = push_array(scratch.arena, REGS_RegBlockX64, threads.count); + X64_RegBlock *blocks = push_array(scratch.arena, X64_RegBlock, threads.count); { for EachIndex(idx, threads.count) { @@ -3978,7 +3964,7 @@ d_ctrl_thread__module_open(D_Handle process, D_Handle module, Rng1U64 vaddr_rang for(String8Node *n = dbg_path_candidates.first; n != 0; n = n->next) { String8 candidate_path = n->string; - FileProperties props = os_properties_from_file_path(candidate_path); + FileProperties props = properties_from_file_path(candidate_path); if(props.modified != 0 && props.size != 0) { initial_debug_info_path = push_str8_copy(arena, path_normalized_from_string(scratch.arena, candidate_path)); @@ -4316,12 +4302,14 @@ d_ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, D { 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)); + ARCH_Info *arch_info = arch_info_from_arch(arch); + U64 arch_reg_block_size = arch_info->reg_block_size; + void *regs_block = push_array(scratch.arena, U8, arch_reg_block_size); dmn_thread_read_reg_block(spoof->thread, regs_block); - U64 spoof_thread_rip = regs_rip_from_arch_block(arch, regs_block); + U64 spoof_thread_rip = arch_ip_from_reg_block(arch_info, regs_block); if(spoof_thread_rip == spoof->new_ip_value) { - regs_arch_block_write_rip(arch, regs_block, spoof_old_ip_value); + arch_reg_block_write_ip(arch_info, regs_block, spoof_old_ip_value); d_thread_write_reg_block(d_handle_make(D_MachineID_Local, spoof->thread), regs_block); } } @@ -4363,7 +4351,7 @@ d_ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, D 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; + U64 exe_timestamp = properties_from_file_path(module_path).modified; 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; @@ -4379,7 +4367,7 @@ d_ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, D_Msg *msg, D out_evt1->tls_offset = event->tls_offset; 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; + U64 debug_info_timestamp = properties_from_file_path(initial_debug_info_path).modified; out_evt2->kind = D_EventKind_ModuleDebugInfoPathChange; out_evt2->msg_id = msg->msg_id; out_evt2->entity = module_handle; @@ -4547,7 +4535,8 @@ d_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); + ARCH_Info *arch_info = arch_info_from_arch(entity->arch); + U64 regs_size = arch_info->reg_block_size; 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); @@ -4650,7 +4639,7 @@ d_ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Enti else ProfScope("cache miss") { 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); + File file = file_open(AccessFlag_Read|AccessFlag_ShareRead, debug_info_path->string); ProfScope("determine if %.*s is necessary", str8_varg(debug_info_path->string)) { //- rjf: determine if file is PDB @@ -4658,7 +4647,7 @@ d_ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Enti if(!file_is_pdb) { U8 msf70_magic_maybe[sizeof(msf_msf70_magic)] = {0}; - os_file_read(file, r1u64(0, sizeof(msf70_magic_maybe)), msf70_magic_maybe); + file_read(file, r1u64(0, sizeof(msf70_magic_maybe)), msf70_magic_maybe); if(MemoryMatch(msf70_magic_maybe, msf_msf70_magic, sizeof(msf70_magic_maybe))) { file_is_pdb = 1; @@ -4667,7 +4656,7 @@ d_ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Enti if(!file_is_pdb) { U8 msf20_magic_maybe[sizeof(msf_msf20_magic)] = {0}; - os_file_read(file, r1u64(0, sizeof(msf20_magic_maybe)), msf20_magic_maybe); + file_read(file, r1u64(0, sizeof(msf20_magic_maybe)), msf20_magic_maybe); if(MemoryMatch(msf20_magic_maybe, msf_msf20_magic, sizeof(msf20_magic_maybe))) { file_is_pdb = 1; @@ -4678,18 +4667,18 @@ d_ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Enti // if any are found in the PDB, then this RDI is necessary. if(file_is_pdb) { - FileProperties props = os_properties_from_file(file); - OS_Handle map = os_file_map_open(OS_AccessFlag_Read, file); - void *file_base = os_file_map_view_open(map, OS_AccessFlag_Read, r1u64(0, props.size)); + FileProperties props = properties_from_file(file); + FileMap map = file_map_open(AccessFlag_Read, file); + void *file_base = file_map_view_open(map, AccessFlag_Read, r1u64(0, props.size)); String8 file_data = str8(file_base, props.size); { rdi_is_necessary = pdb_has_symbol_or_file_ref(file_data, d_ctrl_state->msg_user_bp_touched_symbols, d_ctrl_state->msg_user_bp_touched_files); } - os_file_map_view_close(map, file_base, r1u64(0, props.size)); - os_file_map_close(map); + file_map_view_close(map, file_base, r1u64(0, props.size)); + file_map_close(map); } } - os_file_close(file); + file_close(file); node = push_array(d_ctrl_state->ctrl_thread_msg_process_arena, D_ModuleReqCacheNode, 1); node->next = slot; d_ctrl_state->module_req_cache_slots[slot_idx] = node; @@ -4771,7 +4760,6 @@ d_ctrl_thread__eval_scope_begin(Arena *arena, D_BreakpointList *user_bps, D_Enti { E_IRCtx *ctx = &scope->ir_ctx; 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); @@ -4817,7 +4805,7 @@ d_ctrl_thread__end_and_flush_log(void) { Temp scratch = scratch_begin(0, 0); LogScopeResult log = log_scope_end(scratch.arena); - os_append_data_to_file_path(d_ctrl_state->ctrl_thread_log_path, log.strings[LogMsgKind_Info]); + append_data_to_file_path(d_ctrl_state->ctrl_thread_log_path, log.strings[LogMsgKind_Info]); if(log.strings[LogMsgKind_UserError].size != 0) { D_EventList evts = {0}; @@ -4842,28 +4830,28 @@ d_ctrl_thread__launch(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) String8 stderr_path = path_absolute_dst_from_relative_dst_src(scratch.arena, msg->stderr_path, msg->path); //- rjf: obtain stdout/stderr/stdin handles - OS_Handle stdout_handle = {0}; - OS_Handle stderr_handle = {0}; - OS_Handle stdin_handle = {0}; + File stdout_handle = {0}; + File stderr_handle = {0}; + File stdin_handle = {0}; if(stdout_path.size != 0) { - OS_Handle f = os_file_open(OS_AccessFlag_Write|OS_AccessFlag_Read, stdout_path); - os_file_close(f); - stdout_handle = os_file_open(OS_AccessFlag_Write|OS_AccessFlag_Append|OS_AccessFlag_ShareRead|OS_AccessFlag_ShareWrite|OS_AccessFlag_Inherited, msg->stdout_path); + File f = file_open(AccessFlag_Write|AccessFlag_Read, stdout_path); + file_close(f); + stdout_handle = file_open(AccessFlag_Write|AccessFlag_Append|AccessFlag_ShareRead|AccessFlag_ShareWrite|AccessFlag_Inherited, msg->stdout_path); } if(stderr_path.size != 0) { - OS_Handle f = os_file_open(OS_AccessFlag_Write|OS_AccessFlag_Read, stderr_path); - os_file_close(f); - stderr_handle = os_file_open(OS_AccessFlag_Write|OS_AccessFlag_Append|OS_AccessFlag_ShareRead|OS_AccessFlag_ShareWrite|OS_AccessFlag_Inherited, msg->stderr_path); + File f = file_open(AccessFlag_Write|AccessFlag_Read, stderr_path); + file_close(f); + stderr_handle = file_open(AccessFlag_Write|AccessFlag_Append|AccessFlag_ShareRead|AccessFlag_ShareWrite|AccessFlag_Inherited, msg->stderr_path); } if(stdin_path.size != 0) { - stdin_handle = os_file_open(OS_AccessFlag_Read|OS_AccessFlag_ShareRead|OS_AccessFlag_ShareWrite|OS_AccessFlag_Inherited, stdin_path); + stdin_handle = file_open(AccessFlag_Read|AccessFlag_ShareRead|AccessFlag_ShareWrite|AccessFlag_Inherited, stdin_path); } //- rjf: launch - OS_ProcessLaunchParams params = {0}; + ProcessLaunchParams params = {0}; { params.cmd_line = msg->cmd_line_string_list; params.path = msg->path; @@ -4877,9 +4865,9 @@ d_ctrl_thread__launch(DMN_CtrlCtx *ctrl_ctx, D_Msg *msg) U32 id = dmn_ctrl_launch(ctrl_ctx, ¶ms); //- rjf: close stdout/stderr/stdin files - os_file_close(stdout_handle); - os_file_close(stderr_handle); - os_file_close(stdin_handle); + file_close(stdout_handle); + file_close(stderr_handle); + file_close(stdin_handle); //- rjf: record (id -> entry points), so that we know custom entry points for this PID D_EntityCtxRWStore *entity_ctx_rw_store = d_ctrl_state->ctrl_thread_entity_store; @@ -6339,7 +6327,7 @@ d_memory_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *g if(range_size != 0) { // rjf: set up arena - U64 page_size = os_get_system_info()->page_size; // TODO(rjf): @page_size_from_process + U64 page_size = get_system_info()->page_size; // TODO(rjf): @page_size_from_process U64 arena_size = AlignPow2(range_size + ARENA_HEADER_SIZE, page_size); range_arena = arena_alloc(.reserve_size = range_size+ARENA_HEADER_SIZE, .commit_size = range_size+ARENA_HEADER_SIZE); @@ -6676,15 +6664,15 @@ d_process_write(D_Handle process, Rng1U64 range, void *src) // time. if(result) { - U64 endt_us = os_now_microseconds()+10000; - U64 page_size = os_get_system_info()->page_size; // TODO(rjf): @page_size_from_process + U64 endt_us = now_time_us()+10000; + U64 page_size = get_system_info()->page_size; // TODO(rjf): @page_size_from_process Rng1U64 page_range = r1u64(range.min/page_size, (range.max+page_size-1)/page_size); for EachInRange(page_idx, page_range) { Temp scratch = scratch_begin(0, 0); 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) + if(!slice.stale || now_time_us() >= endt_us) { break; } @@ -6826,7 +6814,7 @@ d_call_stack_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U6 { 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); + unwind = d_unwind_from_thread(arena, entity_ctx, thread_handle, now_time_us()+5000); if(!(unwind.flags & D_UnwindFlag_Stale)) { good = 1; @@ -6967,11 +6955,12 @@ d_call_stack_tree_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_ou D_Handle thread = threads[thread_idx]; D_Handle process = threads_processes[thread_idx]; Arch arch = threads_arches[thread_idx]; + ARCH_Info *arch_info = arch_info_from_arch(arch); D_CallStack call_stack = call_stacks[thread_idx]; D_CallStackTreeNode *thread_node = tree->root; for EachIndex(frame_idx, call_stack.frames_count) { - U64 vaddr = regs_rip_from_arch_block(arch, call_stack.frames[frame_idx].regs); + U64 vaddr = arch_ip_from_reg_block(arch_info, call_stack.frames[frame_idx].regs); U64 depth = call_stack.frames[frame_idx].inline_depth; 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) diff --git a/src/dbg_engine/dbg_engine_ctrl.h b/src/dbg_engine/dbg_engine_ctrl.h index 8a5cc7ea..0db01810 100644 --- a/src/dbg_engine/dbg_engine_ctrl.h +++ b/src/dbg_engine/dbg_engine_ctrl.h @@ -269,9 +269,8 @@ struct D_CtrlState Arena *arena; D_WakeupFunctionType *wakeup_hook; - // rjf: name -> register/alias hash tables for eval + // rjf: name -> register hash tables for eval E_String2NumMap arch_string2reg_tables[Arch_COUNT]; - E_String2NumMap arch_string2alias_tables[Arch_COUNT]; // rjf: caches D_ThreadRegCache thread_reg_cache; @@ -499,8 +498,8 @@ internal D_UnwindStepResult d_establish_frame_unwind_context__dwarf(Arena *arena 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 *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); +internal U64 *d_unwind_reg_from_pe_gpr_reg__pe_x64(X64_RegBlock *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, X64_RegBlock *regs, U64 endt_us); //- rjf: abstracted full unwind internal D_Unwind d_unwind_from_thread(Arena *arena, D_EntityCtx *ctx, D_Handle thread, U64 endt_us); @@ -526,7 +525,6 @@ internal U64 d_reg_gen(void); //- rjf: name -> register/alias hash tables, for eval internal E_String2NumMap *d_string2reg_from_arch(Arch arch); -internal E_String2NumMap *d_string2alias_from_arch(Arch arch); //////////////////////////////// //~ rjf: Control-Thread Functions diff --git a/src/dbg_engine/dbg_engine_user.c b/src/dbg_engine/dbg_engine_user.c index ab323399..bfaffd88 100644 --- a/src/dbg_engine/dbg_engine_user.c +++ b/src/dbg_engine/dbg_engine_user.c @@ -300,7 +300,7 @@ d_trap_net_from_thread__step_over_inst(Arena *arena, D_Entity *thread) String8 machine_code = {0}; { Rng1U64 rng = r1u64(ip_vaddr, ip_vaddr+max_instruction_size_from_arch(arch)); - D_ProcessMemorySlice machine_code_slice = d_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, now_time_us()+5000); machine_code = machine_code_slice.data; } @@ -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 = d_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, now_time_us()+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") @@ -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 = d_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, now_time_us()+5000); machine_code = machine_code_slice.data; good_machine_code = (machine_code.size >= dim_1u64(line_vaddr_rng) && !machine_code_slice.any_byte_bad); } @@ -1215,7 +1215,8 @@ d_query_cached_rip_from_thread_unwind(D_Entity *thread, U64 unwind_count) 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); + ARCH_Info *arch_info = arch_info_from_arch(thread->arch); + result = arch_ip_from_reg_block(arch_info, callstack.concrete_frames[unwind_count%callstack.concrete_frames_count]->regs); } access_close(access); } @@ -1648,7 +1649,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P String8List env = target->env; if(working_directory.size == 0) { - working_directory = os_get_current_path(scratch.arena); + working_directory = get_current_path(scratch.arena); } // rjf: build launch options @@ -1811,12 +1812,13 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P Access *access = access_open(); // rjf: thread => call stack - D_CallStack callstack = d_call_stack_from_thread(access, thread->handle, 1, os_now_microseconds()+10000); + D_CallStack callstack = d_call_stack_from_thread(access, thread->handle, 1, now_time_us()+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); + ARCH_Info *arch_info = arch_info_from_arch(thread->arch); + U64 vaddr = arch_ip_from_reg_block(arch_info, callstack.concrete_frames[1]->regs); D_Trap trap = {D_TrapFlag_EndStepping|D_TrapFlag_IgnoreStackPointerCheck, vaddr}; d_trap_list_push(scratch.arena, &trap_net.traps, &trap); trap_net.good_read = 1; @@ -1875,9 +1877,10 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P case D_CmdKind_SetThreadIP: { D_Entity *thread = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, params->thread); + ARCH_Info *arch_info = arch_info_from_arch(thread->arch); U64 vaddr = params->vaddr; 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); + arch_reg_block_write_ip(arch_info, block, vaddr); B32 result = d_thread_write_reg_block(thread->handle, block); (void)result; }break; @@ -2120,7 +2123,7 @@ d_tick(Arena *arena, D_TargetArray *targets, D_BreakpointArray *breakpoints, D_P d_user_state->ctrl_soft_halt_issued = 1; d_halt(); } - if(d_u2c_push_msgs(&d_user_state->ctrl_msgs, os_now_microseconds()+100)) + if(d_u2c_push_msgs(&d_user_state->ctrl_msgs, now_time_us()+100)) { MemoryZeroStruct(&d_user_state->ctrl_msgs); arena_clear(d_user_state->ctrl_msg_arena); diff --git a/src/dbg_info/dbg_info.c b/src/dbg_info/dbg_info.c index f215f99b..7b5a58a0 100644 --- a/src/dbg_info/dbg_info.c +++ b/src/dbg_info/dbg_info.c @@ -71,7 +71,7 @@ di_init(CmdLine *cmdline) if(!try_u64_from_str8_c_rules(signal_pid_string, &signal_pid)) { has_parent = 0; - signal_pid = os_get_process_info()->pid; + signal_pid = get_process_info()->pid; } U64 signal_code = 0; String8 signal_code_string = cmd_line_string(cmdline, str8_lit("signal_code")); @@ -84,16 +84,16 @@ di_init(CmdLine *cmdline) { di_shared->conversion_completion_lock_semaphore = semaphore_open(di_shared->conversion_completion_lock_semaphore_name); di_shared->conversion_completion_signal_semaphore = semaphore_open(di_shared->conversion_completion_signal_semaphore_name); - di_shared->conversion_completion_shared_memory = os_shared_memory_open(di_shared->conversion_completion_shared_memory_name); + di_shared->conversion_completion_shared_memory = shared_memory_open(di_shared->conversion_completion_shared_memory_name); } else { di_shared->conversion_completion_lock_semaphore = semaphore_alloc(1, 1, di_shared->conversion_completion_lock_semaphore_name); di_shared->conversion_completion_signal_semaphore = semaphore_alloc(0, 65536, di_shared->conversion_completion_signal_semaphore_name); - di_shared->conversion_completion_shared_memory = os_shared_memory_alloc(KB(4), di_shared->conversion_completion_shared_memory_name); + di_shared->conversion_completion_shared_memory = shared_memory_alloc(KB(4), di_shared->conversion_completion_shared_memory_name); di_shared->conversion_completion_signal_receiver_thread = thread_launch(di_conversion_completion_signal_receiver_thread_entry_point, 0); } - di_shared->conversion_completion_shared_memory_base = (U64 *)os_shared_memory_view_open(di_shared->conversion_completion_shared_memory, r1u64(0, KB(4))); + di_shared->conversion_completion_shared_memory_base = (U64 *)shared_memory_view_open(di_shared->conversion_completion_shared_memory, r1u64(0, KB(4))); di_shared->completion_mutex = mutex_alloc(); di_shared->completion_arena = arena_alloc(); di_shared->event_mutex = mutex_alloc(); @@ -164,8 +164,8 @@ di_key_from_path_timestamp(String8 path, U64 min_timestamp) //- rjf: try to make key from file's contents if(!made_key) { - OS_Handle file = os_file_open(OS_AccessFlag_Read|OS_AccessFlag_ShareRead, path); - FileProperties props = os_properties_from_file(file); + File file = file_open(AccessFlag_Read|AccessFlag_ShareRead, path); + FileProperties props = properties_from_file(file); if(min_timestamp <= props.modified) { //- rjf: PDB magic => use GUID for key @@ -176,7 +176,7 @@ di_key_from_path_timestamp(String8 path, U64 min_timestamp) { read_only local_persist char msf_msf20_magic[] = "Microsoft C/C++ program database 2.00\r\n\x1aJG\0\0"; U8 msf20_magic_maybe[sizeof(msf_msf20_magic)] = {0}; - os_file_read(file, r1u64(0, sizeof(msf20_magic_maybe)), msf20_magic_maybe); + file_read(file, r1u64(0, sizeof(msf20_magic_maybe)), msf20_magic_maybe); if(MemoryMatch(msf20_magic_maybe, msf_msf20_magic, sizeof(msf20_magic_maybe))) { is_pdb = 1; @@ -186,7 +186,7 @@ di_key_from_path_timestamp(String8 path, U64 min_timestamp) { read_only local_persist char msf_msf70_magic[] = "Microsoft C/C++ MSF 7.00\r\n\032DS\0\0"; U8 msf70_magic_maybe[sizeof(msf_msf70_magic)] = {0}; - os_file_read(file, r1u64(0, sizeof(msf70_magic_maybe)), msf70_magic_maybe); + file_read(file, r1u64(0, sizeof(msf70_magic_maybe)), msf70_magic_maybe); if(MemoryMatch(msf70_magic_maybe, msf_msf70_magic, sizeof(msf70_magic_maybe))) { is_pdb = 1; @@ -198,7 +198,7 @@ di_key_from_path_timestamp(String8 path, U64 min_timestamp) } } } - os_file_close(file); + file_close(file); } //- rjf: fallback: hash from path/timestamp @@ -323,8 +323,8 @@ di_close(DI_Key key, B32 force_closed) //- rjf: decrement this key's node's refcount; remove if needed B32 node_released = 0; - OS_Handle file = {0}; - OS_Handle file_map = {0}; + File file = {0}; + FileMap file_map = {0}; FileProperties file_props = {0}; void *file_base = 0; Arena *arena = 0; @@ -377,9 +377,9 @@ di_close(DI_Key key, B32 force_closed) { ins_atomic_u64_dec_eval(&di_shared->load_count); ins_atomic_u64_inc_eval(&di_shared->load_gen); - os_file_map_view_close(file_map, file_base, r1u64(0, file_props.size)); - os_file_map_close(file_map); - os_file_close(file); + file_map_view_close(file_map, file_base, r1u64(0, file_props.size)); + file_map_close(file_map); + file_close(file); if(arena != 0) { arena_release(arena); @@ -492,7 +492,7 @@ di_rdi_from_key(Access *access, DI_Key key, B32 high_priority, U64 endt_us) } // rjf: found current results, or out-of-time? abort - if(grabbed || os_now_microseconds() >= endt_us) + if(grabbed || now_time_us() >= endt_us) { break; } @@ -681,16 +681,16 @@ di_async_tick(void) if(!t->og_analyzed) { t->og_analyzed = 1; - OS_Handle file = os_file_open(OS_AccessFlag_ShareRead|OS_AccessFlag_Read, og_path); - FileProperties props = os_properties_from_file(file); + File file = file_open(AccessFlag_ShareRead|AccessFlag_Read, og_path); + FileProperties props = properties_from_file(file); t->og_size = props.size; U64 rdi_magic_maybe = 0; - if(os_file_read_struct(file, 0, &rdi_magic_maybe) == 8 && + if(file_read_struct(file, 0, &rdi_magic_maybe) == 8 && rdi_magic_maybe == RDI_MAGIC_CONSTANT) { t->og_is_rdi = 1; } - os_file_close(file); + file_close(file); } U64 og_size = t->og_size; B32 og_is_rdi = t->og_is_rdi; @@ -713,8 +713,8 @@ di_async_tick(void) if(!t->rdi_analyzed) { t->rdi_analyzed = 1; - OS_Handle file = os_file_open(OS_AccessFlag_ShareRead|OS_AccessFlag_Read, rdi_path); - FileProperties props = os_properties_from_file(file); + File file = file_open(AccessFlag_ShareRead|AccessFlag_Read, rdi_path); + FileProperties props = properties_from_file(file); if(props.modified < og_min_timestamp) { t->rdi_is_stale = 1; @@ -723,12 +723,12 @@ di_async_tick(void) { t->rdi_is_stale = 1; RDI_Header header = {0}; - if(os_file_read_struct(file, 0, &header) == sizeof(header)) + if(file_read_struct(file, 0, &header) == sizeof(header)) { t->rdi_is_stale = (header.encoding_version != RDI_ENCODING_VERSION); } } - os_file_close(file); + file_close(file); } B32 rdi_is_stale = t->rdi_is_stale; @@ -736,7 +736,7 @@ di_async_tick(void) if(!og_is_rdi && rdi_is_stale && t->thread_count == 0) { U64 thread_count = 1; - U64 max_thread_count = os_get_system_info()->logical_processor_count/2; + U64 max_thread_count = get_system_info()->logical_processor_count/2; if(priority_idx > 0) { max_thread_count = Max(1, max_thread_count/2); @@ -756,7 +756,7 @@ di_async_tick(void) //- rjf: determine if there are threads available B32 threads_available = 0; { - U64 max_threads = os_get_system_info()->logical_processor_count/2; + U64 max_threads = get_system_info()->logical_processor_count/2; U64 current_threads = di_shared->conversion_thread_count; U64 needed_threads = (current_threads + t->thread_count); threads_available = (max_threads >= needed_threads); @@ -789,8 +789,8 @@ di_async_tick(void) if(og_is_good && ready_to_launch_conversion) { B32 should_compress = 0; - OS_ProcessLaunchParams params = {0}; - params.path = os_get_process_info()->binary_path; + ProcessLaunchParams params = {0}; + params.path = get_process_info()->binary_path; params.inherit_env = 1; params.consoleless = 1; str8_list_pushf(scratch.arena, ¶ms.cmd_line, "raddbg"); @@ -804,11 +804,11 @@ di_async_tick(void) str8_list_pushf(scratch.arena, ¶ms.cmd_line, "--rdi"); str8_list_pushf(scratch.arena, ¶ms.cmd_line, "--out:%S", rdi_path); str8_list_pushf(scratch.arena, ¶ms.cmd_line, "--thread_count:%I64u", t->thread_count); - str8_list_pushf(scratch.arena, ¶ms.cmd_line, "--signal_pid:%I64u", (U64)os_get_process_info()->pid); + str8_list_pushf(scratch.arena, ¶ms.cmd_line, "--signal_pid:%I64u", (U64)get_process_info()->pid); str8_list_pushf(scratch.arena, ¶ms.cmd_line, "--signal_code:%I64u", (U64)t); str8_list_pushf(scratch.arena, ¶ms.cmd_line, "%S", og_path); ProfMsg("launch creation for %.*s", str8_varg(rdi_path)); - t->process = os_process_launch(¶ms); + t->process = process_launch(¶ms); t->status = DI_LoadTaskStatus_Active; di_shared->conversion_process_count += 1; di_shared->conversion_thread_count += t->thread_count; @@ -840,7 +840,7 @@ di_async_tick(void) } if(!task_is_done) { - task_is_done = os_process_join(t->process, 0, 0); + task_is_done = process_join(t->process, 0, 0); } if(task_is_done) { @@ -875,7 +875,7 @@ di_async_tick(void) //- rjf: if task is done, retire & recycle task; gather path to load if(t->status == DI_LoadTaskStatus_Done) { - if(!os_handle_match(t->process, os_handle_zero())) MutexScope(di_shared->event_mutex) + if(!process_match(t->process, process_zero())) MutexScope(di_shared->event_mutex) { DI_EventNode *n = push_array(di_shared->event_arena, DI_EventNode, 1); SLLQueuePush(di_shared->events.first, di_shared->events.last, n); @@ -937,15 +937,15 @@ di_async_tick(void) ProfBegin("parse %.*s", str8_varg(rdi_path)); //- rjf: open file - OS_Handle file = {0}; - OS_Handle file_map = {0}; + File file = {0}; + FileMap file_map = {0}; FileProperties file_props = {0}; void *file_base = 0; { - file = os_file_open(OS_AccessFlag_Read|OS_AccessFlag_ShareRead|OS_AccessFlag_ShareWrite, rdi_path); - file_map = os_file_map_open(OS_AccessFlag_Read, file); - file_props = os_properties_from_file(file); - file_base = os_file_map_view_open(file_map, OS_AccessFlag_Read, r1u64(0, file_props.size)); + file = file_open(AccessFlag_Read|AccessFlag_ShareRead|AccessFlag_ShareWrite, rdi_path); + file_map = file_map_open(AccessFlag_Read, file); + file_props = properties_from_file(file); + file_base = file_map_view_open(file_map, AccessFlag_Read, r1u64(0, file_props.size)); } //- rjf: do initial parse of rdi @@ -1010,9 +1010,9 @@ di_async_tick(void) { arena_release(rdi_parsed_arena); } - os_file_map_view_close(file_map, file_base, r1u64(0, file_props.size)); - os_file_map_close(file_map); - os_file_close(file); + file_map_view_close(file_map, file_base, r1u64(0, file_props.size)); + file_map_close(file_map); + file_close(file); } } cond_var_broadcast(stripe->cv); diff --git a/src/dbg_info/dbg_info.h b/src/dbg_info/dbg_info.h index 5355e6c0..654a94c9 100644 --- a/src/dbg_info/dbg_info.h +++ b/src/dbg_info/dbg_info.h @@ -69,8 +69,8 @@ struct DI_Node DI_Key key; // rjf: value - OS_Handle file; - OS_Handle file_map; + File file; + FileMap file_map; void *file_base; FileProperties file_props; Arena *arena; @@ -145,7 +145,7 @@ struct DI_LoadTask B32 rdi_is_stale; U64 thread_count; - OS_Handle process; + Process process; }; typedef struct DI_LoadCompletion DI_LoadCompletion; @@ -280,7 +280,7 @@ struct DI_Shared String8 conversion_completion_shared_memory_name; Semaphore conversion_completion_lock_semaphore; Semaphore conversion_completion_signal_semaphore; - OS_Handle conversion_completion_shared_memory; + SharedMemory conversion_completion_shared_memory; U64 *conversion_completion_shared_memory_base; Thread conversion_completion_signal_receiver_thread; diff --git a/src/demon/demon_core.c b/src/demon/demon_core.c index c4a342ae..33748624 100644 --- a/src/demon/demon_core.c +++ b/src/demon/demon_core.c @@ -132,10 +132,11 @@ dmn_rip_from_thread(DMN_Handle thread) Temp scratch = scratch_begin(0, 0); { Arch arch = dmn_arch_from_thread(thread); - U64 reg_block_size = regs_block_size_from_arch(arch); + ARCH_Info *arch_info = arch_info_from_arch(arch); + U64 reg_block_size = arch_info->reg_block_size; void *reg_block = push_array(scratch.arena, U8, reg_block_size); dmn_thread_read_reg_block(thread, reg_block); - result = regs_rip_from_arch_block(arch, reg_block); + result = arch_ip_from_reg_block(arch_info, reg_block); } scratch_end(scratch); return result; @@ -148,10 +149,11 @@ dmn_rsp_from_thread(DMN_Handle thread) Temp scratch = scratch_begin(0, 0); { Arch arch = dmn_arch_from_thread(thread); - U64 reg_block_size = regs_block_size_from_arch(arch); + ARCH_Info *arch_info = arch_info_from_arch(arch); + U64 reg_block_size = arch_info->reg_block_size; void *reg_block = push_array(scratch.arena, U8, reg_block_size); dmn_thread_read_reg_block(thread, reg_block); - result = regs_rsp_from_arch_block(arch, reg_block); + result = arch_sp_from_reg_block(arch_info, reg_block); } scratch_end(scratch); return result; @@ -165,11 +167,11 @@ dmn_process_read_cstring(Arena *arena, DMN_Handle process, U64 addr) { Temp scratch = scratch_begin(&arena, 1); String8List block_list = {0}; - for(U64 cursor = addr, stride = 256; ; cursor += stride) + for(U64 cursor = addr, stride = 256;; cursor += stride) { - U8 *raw_block = push_array_no_zero(scratch.arena, U8, stride); - U64 read_size = dmn_process_read(process, r1u64(cursor, cursor + stride), raw_block); - String8 block = str8_cstring_capped(raw_block, raw_block + read_size); + U8 *raw_block = push_array_no_zero(scratch.arena, U8, stride); + U64 read_size = dmn_process_read(process, r1u64(cursor, cursor + stride), raw_block); + String8 block = str8_cstring_capped(raw_block, raw_block + read_size); str8_list_push(scratch.arena, &block_list, block); if(read_size != stride || (block.size+1 <= read_size && block.str[block.size] == 0)) { diff --git a/src/demon/demon_core.h b/src/demon/demon_core.h index 92874f97..6878f837 100644 --- a/src/demon/demon_core.h +++ b/src/demon/demon_core.h @@ -235,7 +235,7 @@ internal DMN_CtrlCtx *dmn_ctrl_begin(void); internal void dmn_ctrl_exclusive_access_begin(void); internal void dmn_ctrl_exclusive_access_end(void); #define DMN_CtrlExclusiveAccessScope DeferLoop(dmn_ctrl_exclusive_access_begin(), dmn_ctrl_exclusive_access_end()) -internal U32 dmn_ctrl_launch(DMN_CtrlCtx *ctx, OS_ProcessLaunchParams *params); +internal U32 dmn_ctrl_launch(DMN_CtrlCtx *ctx, ProcessLaunchParams *params); internal B32 dmn_ctrl_attach(DMN_CtrlCtx *ctx, U32 pid); internal B32 dmn_ctrl_kill(DMN_CtrlCtx *ctx, DMN_Handle process, U32 exit_code); internal B32 dmn_ctrl_detach(DMN_CtrlCtx *ctx, DMN_Handle process); @@ -259,7 +259,7 @@ internal U64 dmn_process_memory_reserve(DMN_Handle process, U64 vaddr, U64 size) internal void dmn_process_memory_commit(DMN_Handle process, U64 vaddr, U64 size); internal void dmn_process_memory_decommit(DMN_Handle process, U64 vaddr, U64 size); internal void dmn_process_memory_release(DMN_Handle process, U64 vaddr, U64 size); -internal void dmn_process_memory_protect(DMN_Handle process, U64 vaddr, U64 size, OS_AccessFlags flags); +internal void dmn_process_memory_protect(DMN_Handle process, U64 vaddr, U64 size, AccessFlags flags); internal U64 dmn_process_read(DMN_Handle process, Rng1U64 range, void *dst); internal B32 dmn_process_write(DMN_Handle process, Rng1U64 range, void *src); #define dmn_process_read_struct(process, vaddr, ptr) dmn_process_read((process), r1u64((vaddr), (vaddr)+(sizeof(*ptr))), ptr) diff --git a/src/demon/linux/demon_core_linux.c b/src/demon/linux/demon_core_linux.c index 193c2554..e5619af0 100644 --- a/src/demon/linux/demon_core_linux.c +++ b/src/demon/linux/demon_core_linux.c @@ -753,7 +753,8 @@ dmn_lnx_thread_alloc(DMN_LNX_Process *process, DMN_LNX_ThreadState thread_state, } else { - U64 reg_block_size = regs_block_size_from_arch(process->ctx->arch); + ARCH_Info *arch_info = arch_info_from_arch(process->ctx->arch); + U64 reg_block_size = arch_info->reg_block_size; reg_block = push_array(process->ctx->arena, U8, reg_block_size); } @@ -1130,26 +1131,32 @@ dmn_lnx_process_untrap_probes(DMN_LNX_Process *process) internal U64 dmn_lnx_thread_read_ip(DMN_LNX_Thread *thread) { - return regs_rip_from_arch_block(thread->process->ctx->arch, thread->reg_block); + ARCH_Info *arch_info = arch_info_from_arch(thread->process->ctx->arch); + U64 result = arch_ip_from_reg_block(arch_info, thread->reg_block); + return result; } internal U64 dmn_lnx_thread_read_sp(DMN_LNX_Thread *thread) { - return regs_rsp_from_arch_block(thread->process->ctx->arch, thread->reg_block); + ARCH_Info *arch_info = arch_info_from_arch(thread->process->ctx->arch); + U64 result = arch_sp_from_reg_block(arch_info, thread->reg_block); + return result; } internal void dmn_lnx_thread_write_ip(DMN_LNX_Thread *thread, U64 ip) { - regs_arch_block_write_rip(thread->process->ctx->arch, thread->reg_block, ip); + ARCH_Info *arch_info = arch_info_from_arch(thread->process->ctx->arch); + arch_reg_block_write_ip(arch_info, thread->reg_block, ip); thread->is_reg_block_dirty = 1; } internal void dmn_lnx_thread_write_sp(DMN_LNX_Thread *thread, U64 sp) { - regs_arch_block_write_rsp(thread->process->ctx->arch, thread->reg_block, sp); + ARCH_Info *arch_info = arch_info_from_arch(thread->process->ctx->arch); + arch_reg_block_write_sp(arch_info, thread->reg_block, sp); thread->is_reg_block_dirty = 1; } @@ -1166,7 +1173,7 @@ dmn_lnx_thread_read_reg_block(DMN_LNX_Thread *thread) case Arch_x64: { DMN_LNX_ProcessCtx *process_ctx = thread->process->ctx; - REGS_RegBlockX64 *dst = thread->reg_block; + X64_RegBlock *dst = thread->reg_block; // general purpose registers { @@ -1364,7 +1371,7 @@ dmn_lnx_thread_write_reg_block(DMN_LNX_Thread *thread) case Arch_x64: { DMN_LNX_ProcessCtx *process_ctx = thread->process->ctx; - REGS_RegBlockX64 *src = thread->reg_block; + X64_RegBlock *src = thread->reg_block; // general purpose registers { @@ -1555,7 +1562,7 @@ dmn_lnx_set_single_step_flag(DMN_LNX_Thread *thread, B32 is_on) case Arch_Null: {} break; case Arch_x64: { - REGS_RegBlockX64 *reg_block = thread->reg_block; + X64_RegBlock *reg_block = thread->reg_block; if(is_on) { reg_block->rflags.u64 |= X64_RFlag_Trap; } else { reg_block->rflags.u64 &= ~X64_RFlag_Trap; } thread->is_reg_block_dirty = 1; @@ -2082,7 +2089,7 @@ dmn_lnx_event_data_breakpoint(Arena *arena, DMN_EventList *events, pid_t tid) case Arch_Null: {} break; case Arch_x64: { - REGS_RegBlockX64 *regs_x64 = thread->reg_block; + X64_RegBlock *regs_x64 = thread->reg_block; if(regs_x64->dr6.u64 & X64_DebugStatusFlag_B0) { address = regs_x64->dr0.u64; @@ -3021,7 +3028,7 @@ dmn_tls_root_vaddr_from_thread(DMN_Handle thread_handle) case Arch_Null: {} break; case Arch_x64: { - REGS_RegBlockX64 *reg_block = thread->reg_block; + X64_RegBlock *reg_block = thread->reg_block; U64 dtv_pointer = 0; if(dmn_lnx_read_struct(thread->process->fd, reg_block->fsbase.u64 + 8, &dtv_pointer)) { @@ -3050,7 +3057,8 @@ dmn_thread_read_reg_block(DMN_Handle thread_handle, void *reg_block) DMN_LNX_Thread *thread = dmn_lnx_thread_from_handle(thread_handle); if(thread) { - U64 reg_block_size = regs_block_size_from_arch(thread->process->ctx->arch); + ARCH_Info *arch_info = arch_info_from_arch(thread->process->ctx->arch); + U64 reg_block_size = arch_info->reg_block_size; MemoryCopy(reg_block, thread->reg_block, reg_block_size); } result = 1; @@ -3067,7 +3075,8 @@ dmn_thread_write_reg_block(DMN_Handle thread_handle, void *reg_block) DMN_LNX_Thread *thread = dmn_lnx_thread_from_handle(thread_handle); if(thread) { - U64 reg_block_size = regs_block_size_from_arch(thread->process->ctx->arch); + ARCH_Info *arch_info = arch_info_from_arch(thread->process->ctx->arch); + U64 reg_block_size = arch_info->reg_block_size; MemoryCopy(thread->reg_block, reg_block, reg_block_size); thread->is_reg_block_dirty = 1; result = 1; @@ -3148,4 +3157,3 @@ dmn_process_iter_end(DMN_ProcessIter *iter) } MemoryZeroStruct(iter); } - diff --git a/src/demon/win32/demon_core_win32.c b/src/demon/win32/demon_core_win32.c index cef314fb..0084818d 100644 --- a/src/demon/win32/demon_core_win32.c +++ b/src/demon/win32/demon_core_win32.c @@ -494,13 +494,13 @@ dmn_w32_image_info_from_process_base_vaddr(HANDLE process, U64 base_vaddr) if(got_coff_header) { U64 optional_off = coff_header_off + sizeof(COFF_FileHeader); - + Arch arch = arch_from_coff_machine(coff_header.machine); U64 image_size = 0; U64 data_dir_count = 0; U64 data_dir_off = max_U64; U64 tls_index = max_U64; - + // parse optional header if(pe_has_plus_header(coff_header.machine)) { @@ -524,7 +524,7 @@ dmn_w32_image_info_from_process_base_vaddr(HANDLE process, U64 base_vaddr) } else { Assert(0 && "failed to read optional header"); } } - + // extract TLS index if(PE_DataDirectoryIndex_TLS < data_dir_count) { @@ -569,7 +569,7 @@ dmn_w32_image_info_from_process_base_vaddr(HANDLE process, U64 base_vaddr) } else { Assert(0 && "failed to read TLS directory"); } } - + // fill out result result.arch = arch; result.size = image_size; @@ -606,7 +606,7 @@ dmn_w32_thread_read_reg_block(Arch arch, HANDLE thread, void *reg_block) case Arch_x64: { Temp scratch = scratch_begin(0, 0); - REGS_RegBlockX64 *dst = (REGS_RegBlockX64 *)reg_block; + X64_RegBlock *dst = (X64_RegBlock *)reg_block; //- rjf: unpack info about available features U32 feature_mask = GetEnabledXStateFeatures(); @@ -648,51 +648,51 @@ dmn_w32_thread_read_reg_block(Arch arch, HANDLE thread, void *reg_block) DWORD64 xstate_mask = 0; GetXStateFeaturesMask(ctx, &xstate_mask); - //- rjf: convert context -> REGS_RegBlockX64 + //- rjf: convert context -> X64_RegBlock XSAVE_FORMAT *xsave = &ctx->FltSave; - dst->rax.u64 = ctx->Rax; - dst->rcx.u64 = ctx->Rcx; - dst->rdx.u64 = ctx->Rdx; - dst->rbx.u64 = ctx->Rbx; - dst->rsp.u64 = ctx->Rsp; - dst->rbp.u64 = ctx->Rbp; - dst->rsi.u64 = ctx->Rsi; - dst->rdi.u64 = ctx->Rdi; - dst->r8.u64 = ctx->R8; - dst->r9.u64 = ctx->R9; - dst->r10.u64 = ctx->R10; - dst->r11.u64 = ctx->R11; - dst->r12.u64 = ctx->R12; - dst->r13.u64 = ctx->R13; - dst->r14.u64 = ctx->R14; - dst->r15.u64 = ctx->R15; - dst->rip.u64 = ctx->Rip; - dst->cs.u16 = ctx->SegCs; - dst->ds.u16 = ctx->SegDs; - dst->es.u16 = ctx->SegEs; - dst->fs.u16 = ctx->SegFs; - dst->gs.u16 = ctx->SegGs; - dst->ss.u16 = ctx->SegSs; - dst->dr0.u64 = ctx->Dr0; - dst->dr1.u64 = ctx->Dr1; - dst->dr2.u64 = ctx->Dr2; - dst->dr3.u64 = ctx->Dr3; - dst->dr6.u64 = ctx->Dr6; - dst->dr7.u64 = ctx->Dr7; + dst->rax = ctx->Rax; + dst->rcx = ctx->Rcx; + dst->rdx = ctx->Rdx; + dst->rbx = ctx->Rbx; + dst->rsp = ctx->Rsp; + dst->rbp = ctx->Rbp; + dst->rsi = ctx->Rsi; + dst->rdi = ctx->Rdi; + dst->r8 = ctx->R8; + dst->r9 = ctx->R9; + dst->r10 = ctx->R10; + dst->r11 = ctx->R11; + dst->r12 = ctx->R12; + dst->r13 = ctx->R13; + dst->r14 = ctx->R14; + dst->r15 = ctx->R15; + dst->rip = ctx->Rip; + dst->cs = ctx->SegCs; + dst->ds = ctx->SegDs; + dst->es = ctx->SegEs; + dst->fs = ctx->SegFs; + dst->gs = ctx->SegGs; + dst->ss = ctx->SegSs; + dst->dr0 = ctx->Dr0; + dst->dr1 = ctx->Dr1; + dst->dr2 = ctx->Dr2; + dst->dr3 = ctx->Dr3; + dst->dr6 = ctx->Dr6; + dst->dr7 = ctx->Dr7; // NOTE(rjf): this bit is "supposed to always be 1", according to old info. // may need to be investigated. - dst->rflags.u64 = ctx->EFlags | 0x2; - dst->fcw.u16 = xsave->ControlWord; - dst->fsw.u16 = xsave->StatusWord; + dst->rflags = ctx->EFlags | 0x2; + dst->fcw = xsave->ControlWord; + dst->fsw = xsave->StatusWord; dst->ftw = xsave->TagWord; - dst->fop.u16 = xsave->ErrorOpcode; - MemoryCopy(&dst->fip.u64, &xsave->ErrorOffset, sizeof(U64)); - MemoryCopy(&dst->fdp.u64, &xsave->DataOffset, sizeof(U64)); - dst->mxcsr.u32 = xsave->MxCsr; - dst->mxcsr_mask.u32 = xsave->MxCsr_Mask; + dst->fop = xsave->ErrorOpcode; + MemoryCopy(&dst->fip, &xsave->ErrorOffset, sizeof(U64)); + MemoryCopy(&dst->fdp, &xsave->DataOffset, sizeof(U64)); + dst->mxcsr = xsave->MxCsr; + dst->mxcsr_mask = xsave->MxCsr_Mask; { M128A *float_s = xsave->FloatRegisters; - REGS_Reg80 *float_d = &dst->st0; + U80 *float_d = &dst->st0; for(U32 n = 0; n < 8; n += 1, float_s += 1, float_d += 1) { MemoryCopy(float_d, float_s, sizeof(*float_d)); @@ -702,7 +702,7 @@ dmn_w32_thread_read_reg_block(Arch arch, HANDLE thread, void *reg_block) // SSE registers are always available in x64 { M128A *xmm_s = xsave->XmmRegisters; - REGS_Reg512 *zmm_d = &dst->zmm0; + U512 *zmm_d = &dst->zmm0; for(U32 n = 0; n < 16; n += 1, xmm_s += 1, zmm_d += 1) { MemoryCopy(zmm_d, xmm_s, sizeof(*xmm_s)); @@ -713,72 +713,77 @@ dmn_w32_thread_read_reg_block(Arch arch, HANDLE thread, void *reg_block) if(xstate_mask & XSTATE_MASK_AVX) { DWORD avx_length = 0; - U8* avx_s = (U8*)LocateXStateFeature(ctx, XSTATE_AVX, &avx_length); - Assert(avx_length == 16 * sizeof(REGS_Reg128)); - - REGS_Reg512 *zmm_d = &dst->zmm0; - for(U32 n = 0; n < 16; n += 1, avx_s += sizeof(REGS_Reg128), zmm_d += 1) + U8 *avx_s = (U8*)LocateXStateFeature(ctx, XSTATE_AVX, &avx_length); + if(avx_length == 16 * sizeof(U128)) { - MemoryCopy(&zmm_d->v[16], avx_s, sizeof(REGS_Reg128)); + U512 *zmm_d = &dst->zmm0; + for(U32 n = 0; n < 16; n += 1, avx_s += sizeof(U128), zmm_d += 1) + { + MemoryCopy(&zmm_d->u8[16], avx_s, sizeof(U128)); + } } } else { - REGS_Reg512 *zmm_d = &dst->zmm0; + U512 *zmm_d = &dst->zmm0; for(U32 n = 0; n < 16; n += 1, zmm_d += 1) { - MemoryZero(&zmm_d->v[16], sizeof(REGS_Reg128)); + MemoryZero(&zmm_d->u8[16], sizeof(U128)); } } // AVX-512 if(xstate_mask & XSTATE_MASK_AVX512) { + // rjf: kmask DWORD kmask_length = 0; - U64* kmask_s = (U64*)LocateXStateFeature(ctx, XSTATE_AVX512_KMASK, &kmask_length); - Assert(kmask_length == 8 * sizeof(U64)); - - REGS_Reg64 *kmask_d = &dst->k0; - for(U32 n = 0; n < 8; n += 1, kmask_s += 1, kmask_d += 1) + U64 *kmask_s = (U64*)LocateXStateFeature(ctx, XSTATE_AVX512_KMASK, &kmask_length); + if(kmask_length == 8 * sizeof(U64)) { - MemoryCopy(kmask_d, kmask_s, sizeof(*kmask_s)); + U64 *kmask_d = &dst->k0; + for(U32 n = 0; n < 8; n += 1, kmask_s += 1, kmask_d += 1) + { + MemoryCopy(kmask_d, kmask_s, sizeof(*kmask_s)); + } } + // rjf: zmmh DWORD avx512h_length = 0; - U8* avx512h_s = (U8*)LocateXStateFeature(ctx, XSTATE_AVX512_ZMM_H, &avx512h_length); - Assert(avx512h_length == 16 * sizeof(REGS_Reg256)); - - REGS_Reg512 *zmmh_d = &dst->zmm0; - for(U32 n = 0; n < 16; n += 1, avx512h_s += sizeof(REGS_Reg256), zmmh_d += 1) + U8 *avx512h_s = (U8*)LocateXStateFeature(ctx, XSTATE_AVX512_ZMM_H, &avx512h_length); + if(avx512h_length == 16 * sizeof(U256)) { - MemoryCopy(&zmmh_d->v[32], avx512h_s, sizeof(REGS_Reg256)); + U512 *zmmh_d = &dst->zmm0; + for(U32 n = 0; n < 16; n += 1, avx512h_s += sizeof(U256), zmmh_d += 1) + { + MemoryCopy(&zmmh_d->u8[32], avx512h_s, sizeof(U256)); + } } + // rjf: zmm DWORD avx512_length = 0; - U8* avx512_s = (U8*)LocateXStateFeature(ctx, XSTATE_AVX512_ZMM, &avx512_length); - Assert(avx512_length == 16 * sizeof(REGS_Reg512)); - - REGS_Reg512 *zmm_d = &dst->zmm16; - for(U32 n = 0; n < 16; n += 1, avx512_s += sizeof(REGS_Reg512), zmm_d += 1) + U8 *avx512_s = (U8 *)LocateXStateFeature(ctx, XSTATE_AVX512_ZMM, &avx512_length); + if(avx512_length == 16 * sizeof(U512)) { - MemoryCopy(zmm_d, avx512_s, sizeof(REGS_Reg512)); + U512 *zmm_d = &dst->zmm16; + for(U32 n = 0; n < 16; n += 1, avx512_s += sizeof(U512), zmm_d += 1) + { + MemoryCopy(zmm_d, avx512_s, sizeof(U512)); + } } } else { - REGS_Reg64 *kmask_d = &dst->k0; + U64 *kmask_d = &dst->k0; for(U32 n = 0; n < 8; n += 1, kmask_d += 1) { MemoryZero(kmask_d, sizeof(*kmask_d)); } - - REGS_Reg512 *zmmh_d = &dst->zmm0; + U512 *zmmh_d = &dst->zmm0; for(U32 n = 0; n < 16; n += 1, zmmh_d += 1) { - MemoryZero(&zmmh_d->v[32], sizeof(REGS_Reg256)); + MemoryZero(&zmmh_d->u8[32], sizeof(U256)); } - - REGS_Reg512 *zmm_d = &dst->zmm16; + U512 *zmm_d = &dst->zmm16; for(U32 n = 0; n < 16; n += 1, zmm_d += 1) { MemoryZero(zmm_d, sizeof(*zmm_d)); @@ -792,8 +797,8 @@ dmn_w32_thread_read_reg_block(Arch arch, HANDLE thread, void *reg_block) XSAVE_CET_U_FORMAT *cet = LocateXStateFeature(ctx, XSTATE_CET_U, &cet_length); if (cet_length == sizeof(*cet)) { - dst->cetmsr.u64 = cet->Ia32CetUMsr; - dst->cetssp.u64 = cet->Ia32Pl3SspMsr; + dst->cetmsr = cet->Ia32CetUMsr; + dst->cetssp = cet->Ia32Pl3SspMsr; } } @@ -828,7 +833,7 @@ dmn_w32_thread_write_reg_block(Arch arch, HANDLE thread, void *reg_block) case Arch_x64: { Temp scratch = scratch_begin(0, 0); - REGS_RegBlockX64 *src = (REGS_RegBlockX64 *)reg_block; + X64_RegBlock *src = (X64_RegBlock *)reg_block; //- rjf: unpack info about available features U32 feature_mask = GetEnabledXStateFeatures(); @@ -860,49 +865,49 @@ dmn_w32_thread_write_reg_block(Arch arch, HANDLE thread, void *reg_block) break; } - //- rjf: convert REGS_RegBlockX64 -> CONTEXT + //- rjf: convert X64_RegBlock -> CONTEXT XSAVE_FORMAT *fxsave = &ctx->FltSave; ctx->ContextFlags = ctx_flags; - ctx->MxCsr = src->mxcsr.u32 & src->mxcsr_mask.u32; - ctx->Rax = src->rax.u64; - ctx->Rcx = src->rcx.u64; - ctx->Rdx = src->rdx.u64; - ctx->Rbx = src->rbx.u64; - ctx->Rsp = src->rsp.u64; - ctx->Rbp = src->rbp.u64; - ctx->Rsi = src->rsi.u64; - ctx->Rdi = src->rdi.u64; - ctx->R8 = src->r8.u64; - ctx->R9 = src->r9.u64; - ctx->R10 = src->r10.u64; - ctx->R11 = src->r11.u64; - ctx->R12 = src->r12.u64; - ctx->R13 = src->r13.u64; - ctx->R14 = src->r14.u64; - ctx->R15 = src->r15.u64; - ctx->Rip = src->rip.u64; - ctx->SegCs = src->cs.u16; - ctx->SegDs = src->ds.u16; - ctx->SegEs = src->es.u16; - ctx->SegFs = src->fs.u16; - ctx->SegGs = src->gs.u16; - ctx->SegSs = src->ss.u16; - ctx->Dr0 = src->dr0.u64; - ctx->Dr1 = src->dr1.u64; - ctx->Dr2 = src->dr2.u64; - ctx->Dr3 = src->dr3.u64; - ctx->Dr6 = src->dr6.u64; - ctx->Dr7 = src->dr7.u64; - ctx->EFlags = src->rflags.u64; - fxsave->ControlWord = src->fcw.u16; - fxsave->StatusWord = src->fsw.u16; + ctx->MxCsr = src->mxcsr & src->mxcsr_mask; + ctx->Rax = src->rax; + ctx->Rcx = src->rcx; + ctx->Rdx = src->rdx; + ctx->Rbx = src->rbx; + ctx->Rsp = src->rsp; + ctx->Rbp = src->rbp; + ctx->Rsi = src->rsi; + ctx->Rdi = src->rdi; + ctx->R8 = src->r8; + ctx->R9 = src->r9; + ctx->R10 = src->r10; + ctx->R11 = src->r11; + ctx->R12 = src->r12; + ctx->R13 = src->r13; + ctx->R14 = src->r14; + ctx->R15 = src->r15; + ctx->Rip = src->rip; + ctx->SegCs = src->cs; + ctx->SegDs = src->ds; + ctx->SegEs = src->es; + ctx->SegFs = src->fs; + ctx->SegGs = src->gs; + ctx->SegSs = src->ss; + ctx->Dr0 = src->dr0; + ctx->Dr1 = src->dr1; + ctx->Dr2 = src->dr2; + ctx->Dr3 = src->dr3; + ctx->Dr6 = src->dr6; + ctx->Dr7 = src->dr7; + ctx->EFlags = src->rflags; + fxsave->ControlWord = src->fcw; + fxsave->StatusWord = src->fsw; fxsave->TagWord = src->ftw; - fxsave->ErrorOpcode = src->fop.u16; - MemoryCopy(&fxsave->ErrorOffset, &src->fip.u64, sizeof(U64)); - MemoryCopy(&fxsave->DataOffset, &src->fdp.u64, sizeof(U64)); + fxsave->ErrorOpcode = src->fop; + MemoryCopy(&fxsave->ErrorOffset, &src->fip, sizeof(U64)); + MemoryCopy(&fxsave->DataOffset, &src->fdp, sizeof(U64)); { M128A *float_d = fxsave->FloatRegisters; - REGS_Reg80 *float_s = &src->st0; + U80 *float_s = &src->st0; for(U32 n = 0; n < 8; n += 1, float_s += 1, float_d += 1) { MemoryCopy(float_d, float_s, 10); @@ -912,7 +917,7 @@ dmn_w32_thread_write_reg_block(Arch arch, HANDLE thread, void *reg_block) // SSE registers are always available in x64 { M128A *xmm_d = fxsave->XmmRegisters; - REGS_Reg512 *zmm_s = &src->zmm0; + U512 *zmm_s = &src->zmm0; for(U32 n = 0; n < 16; n += 1, xmm_d += 1, zmm_s += 1) { MemoryCopy(xmm_d, zmm_s, sizeof(*xmm_d)); @@ -924,12 +929,13 @@ dmn_w32_thread_write_reg_block(Arch arch, HANDLE thread, void *reg_block) { DWORD avx_length = 0; U8* avx_d = (U8*)LocateXStateFeature(ctx, XSTATE_AVX, &avx_length); - Assert(avx_length == 16 * sizeof(REGS_Reg128)); - - REGS_Reg512 *zmm_s = &src->zmm0; - for(U32 n = 0; n < 16; n += 1, avx_d += sizeof(REGS_Reg128), zmm_s += 1) + if(avx_length == 16 * sizeof(U128)) { - MemoryCopy(avx_d, &zmm_s->v[16], sizeof(REGS_Reg128)); + U512 *zmm_s = &src->zmm0; + for(U32 n = 0; n < 16; n += 1, avx_d += sizeof(U128), zmm_s += 1) + { + MemoryCopy(avx_d, &zmm_s->u8[16], sizeof(U128)); + } } } @@ -938,32 +944,35 @@ dmn_w32_thread_write_reg_block(Arch arch, HANDLE thread, void *reg_block) { DWORD kmask_length = 0; U64* kmask_d = (U64*)LocateXStateFeature(ctx, XSTATE_AVX512_KMASK, &kmask_length); - Assert(kmask_length == 8 * sizeof(*kmask_d)); - - REGS_Reg64 *kmask_s = &src->k0; - for(U32 n = 0; n < 8; n += 1, kmask_s += 1, kmask_d += 1) + if(kmask_length == 8 * sizeof(*kmask_d)) { - MemoryCopy(kmask_d, kmask_s, sizeof(*kmask_d)); + U64 *kmask_s = &src->k0; + for(U32 n = 0; n < 8; n += 1, kmask_s += 1, kmask_d += 1) + { + MemoryCopy(kmask_d, kmask_s, sizeof(*kmask_d)); + } } DWORD avx512h_length = 0; U8* avx512h_d = (U8*)LocateXStateFeature(ctx, XSTATE_AVX512_ZMM_H, &avx512h_length); - Assert(avx512h_length == 16 * sizeof(REGS_Reg256)); - - REGS_Reg512 *zmmh_s = &src->zmm0; - for(U32 n = 0; n < 16; n += 1, avx512h_d += sizeof(REGS_Reg256), zmmh_s += 1) + if(avx512h_length == 16 * sizeof(U256)) { - MemoryCopy(avx512h_d, &zmmh_s->v[32], sizeof(REGS_Reg256)); + U512 *zmmh_s = &src->zmm0; + for(U32 n = 0; n < 16; n += 1, avx512h_d += sizeof(U256), zmmh_s += 1) + { + MemoryCopy(avx512h_d, &zmmh_s->u8[32], sizeof(U256)); + } } DWORD avx512_length = 0; U8* avx512_d = (U8*)LocateXStateFeature(ctx, XSTATE_AVX512_ZMM, &avx512_length); - Assert(avx512_length == 16 * sizeof(REGS_Reg512)); - - REGS_Reg512 *zmm_s = &src->zmm16; - for(U32 n = 0; n < 16; n += 1, avx512_d += sizeof(REGS_Reg512), zmm_s += 1) + if(avx512_length == 16 * sizeof(U512)) { - MemoryCopy(avx512_d, zmm_s, sizeof(REGS_Reg512)); + U512 *zmm_s = &src->zmm16; + for(U32 n = 0; n < 16; n += 1, avx512_d += sizeof(U512), zmm_s += 1) + { + MemoryCopy(avx512_d, zmm_s, sizeof(U512)); + } } } @@ -1069,7 +1078,7 @@ dmn_ctrl_exclusive_access_end(void) } internal U32 -dmn_ctrl_launch(DMN_CtrlCtx *ctx, OS_ProcessLaunchParams *params) +dmn_ctrl_launch(DMN_CtrlCtx *ctx, ProcessLaunchParams *params) { Temp scratch = scratch_begin(0, 0); U32 result = 0; @@ -1133,21 +1142,21 @@ dmn_ctrl_launch(DMN_CtrlCtx *ctx, OS_ProcessLaunchParams *params) } BOOL inherit_handles = 0; STARTUPINFOW startup_info = {sizeof(startup_info)}; - if(!os_handle_match(params->stdout_file, os_handle_zero())) + if(!file_match(params->stdout_file, file_zero())) { HANDLE stdout_handle = (HANDLE)params->stdout_file.u64[0]; startup_info.hStdOutput = stdout_handle; startup_info.dwFlags |= STARTF_USESTDHANDLES; inherit_handles = 1; } - if(!os_handle_match(params->stderr_file, os_handle_zero())) + if(!file_match(params->stderr_file, file_zero())) { HANDLE stderr_handle = (HANDLE)params->stderr_file.u64[0]; startup_info.hStdError = stderr_handle; startup_info.dwFlags |= STARTF_USESTDHANDLES; inherit_handles = 1; } - if(!os_handle_match(params->stdin_file, os_handle_zero())) + if(!file_match(params->stdin_file, file_zero())) { HANDLE stdin_handle = (HANDLE)params->stdin_file.u64[0]; startup_info.hStdInput = stdin_handle; @@ -1502,7 +1511,7 @@ dmn_ctrl_run(Arena *arena, DMN_CtrlCtx *ctx, DMN_RunCtrls *ctrls) //- rjf: x64 case Arch_x64: { - REGS_RegBlockX64 regs = {0}; + X64_RegBlock regs = {0}; dmn_w32_thread_read_reg_block(child->arch, child->handle, ®s); { U64 trap_idx = 0; @@ -1511,7 +1520,7 @@ dmn_ctrl_run(Arena *arena, DMN_CtrlCtx *ctx, DMN_RunCtrls *ctrls) for(U64 n_idx = 0; n_idx < n->count && trap_idx < 4; n_idx += 1, trap_idx += 1) { DMN_Trap *trap = &n->v[n_idx]; - REGS_Reg64 *addr_reg = ®s.dr0; + U64 *addr_reg = ®s.dr0; switch(trap_idx) { default:{}break; @@ -1520,12 +1529,12 @@ dmn_ctrl_run(Arena *arena, DMN_CtrlCtx *ctx, DMN_RunCtrls *ctrls) case 2:{addr_reg = ®s.dr2;}break; case 3:{addr_reg = ®s.dr3;}break; } - addr_reg->u64 = trap->vaddr; - regs.dr7.u64 |= bit9|bit10|bit11; - regs.dr7.u64 |= (1ull << (trap_idx*2)); + addr_reg[0] = trap->vaddr; + regs.dr7 |= bit9|bit10|bit11; + regs.dr7 |= (1ull << (trap_idx*2)); // NOTE(rjf): global-enable regs.dr7.u64 |= (1ull << (trap_idx*2+1)); - regs.dr7.u64 &= ~((U64)(bit17|bit18|bit19|bit20) << (trap_idx*4)); - regs.dr7.u64 &= ~((U64)(bit15|bit16)); + regs.dr7 &= ~((U64)(bit17|bit18|bit19|bit20) << (trap_idx*4)); + regs.dr7 &= ~((U64)(bit15|bit16)); switch(trap->flags) { case DMN_TrapFlag_BreakOnExecute: @@ -1533,14 +1542,14 @@ dmn_ctrl_run(Arena *arena, DMN_CtrlCtx *ctx, DMN_RunCtrls *ctrls) case DMN_TrapFlag_BreakOnWrite: case DMN_TrapFlag_BreakOnWrite|DMN_TrapFlag_BreakOnExecute: { - regs.dr7.u64 |= ((U64)bit17) << (trap_idx*4); + regs.dr7 |= ((U64)bit17) << (trap_idx*4); }break; case DMN_TrapFlag_BreakOnRead|DMN_TrapFlag_BreakOnWrite|DMN_TrapFlag_BreakOnExecute: case DMN_TrapFlag_BreakOnRead|DMN_TrapFlag_BreakOnWrite: case DMN_TrapFlag_BreakOnRead: { - regs.dr7.u64 |= (((U64)bit17) << (trap_idx*4)); - regs.dr7.u64 |= (((U64)bit18) << (trap_idx*4)); + regs.dr7 |= (((U64)bit17) << (trap_idx*4)); + regs.dr7 |= (((U64)bit18) << (trap_idx*4)); }break; } switch(trap->size) @@ -1549,16 +1558,16 @@ dmn_ctrl_run(Arena *arena, DMN_CtrlCtx *ctx, DMN_RunCtrls *ctrls) default:{}break; case 2: { - regs.dr7.u64 |= (((U64)bit19) << (trap_idx*4)); + regs.dr7 |= (((U64)bit19) << (trap_idx*4)); }break; case 4: { - regs.dr7.u64 |= (((U64)bit19) << (trap_idx*4)); - regs.dr7.u64 |= (((U64)bit20) << (trap_idx*4)); + regs.dr7 |= (((U64)bit19) << (trap_idx*4)); + regs.dr7 |= (((U64)bit20) << (trap_idx*4)); }break; case 8: { - regs.dr7.u64 |= (((U64)bit20) << (trap_idx*4)); + regs.dr7 |= (((U64)bit20) << (trap_idx*4)); }break; } } @@ -1663,7 +1672,7 @@ dmn_ctrl_run(Arena *arena, DMN_CtrlCtx *ctx, DMN_RunCtrls *ctrls) B32 do_threads_resume = 1; DMN_W32_EntityNode *first_ran_thread = 0; DMN_W32_EntityNode *last_ran_thread = 0; - U64 begin_time = os_now_microseconds(); + U64 begin_time = now_time_us(); String8List debug_strings = {0}; DMN_Event *debug_strings_event = 0; for(B32 keep_going = 1; keep_going;) @@ -2178,11 +2187,12 @@ dmn_ctrl_run(Arena *arena, DMN_CtrlCtx *ctx, DMN_RunCtrls *ctrls) default: { Temp temp = temp_begin(scratch.arena); - U64 regs_block_size = regs_block_size_from_arch(thread->arch); + ARCH_Info *arch_info = arch_info_from_arch(thread->arch); + U64 regs_block_size = arch_info->reg_block_size; void *regs_block = push_array(scratch.arena, U8, regs_block_size); if(dmn_w32_thread_read_reg_block(thread->arch, thread->handle, regs_block)) { - regs_arch_block_write_rip(thread->arch, regs_block, instruction_pointer); + arch_reg_block_write_ip(arch_info, regs_block, instruction_pointer); dmn_w32_thread_write_reg_block(thread->arch, thread->handle, regs_block); } temp_end(temp); @@ -2287,16 +2297,16 @@ dmn_ctrl_run(Arena *arena, DMN_CtrlCtx *ctx, DMN_RunCtrls *ctrls) default:{NotImplemented;}break; case Arch_x64: { - REGS_RegBlockX64 regs = {0}; + X64_RegBlock regs = {0}; dmn_w32_thread_read_reg_block(thread->arch, thread->handle, ®s); - if(regs.dr6.u64 & 0xF) + if(regs.dr6 & 0xF) { e->kind = DMN_EventKind_Breakpoint; if(0){} - else if(regs.dr7.u64 & (1ull<<0) && regs.dr6.u64 & (1ull<<0)) { flagged_trap_idx = 0; e->address = regs.dr0.u64; } - else if(regs.dr7.u64 & (1ull<<2) && regs.dr6.u64 & (1ull<<1)) { flagged_trap_idx = 1; e->address = regs.dr1.u64; } - else if(regs.dr7.u64 & (1ull<<4) && regs.dr6.u64 & (1ull<<2)) { flagged_trap_idx = 2; e->address = regs.dr2.u64; } - else if(regs.dr7.u64 & (1ull<<8) && regs.dr6.u64 & (1ull<<3)) { flagged_trap_idx = 3; e->address = regs.dr3.u64; } + else if(regs.dr7 & (1ull<<0) && regs.dr6 & (1ull<<0)) { flagged_trap_idx = 0; e->address = regs.dr0; } + else if(regs.dr7 & (1ull<<2) && regs.dr6 & (1ull<<1)) { flagged_trap_idx = 1; e->address = regs.dr1; } + else if(regs.dr7 & (1ull<<4) && regs.dr6 & (1ull<<2)) { flagged_trap_idx = 2; e->address = regs.dr2; } + else if(regs.dr7 & (1ull<<8) && regs.dr6 & (1ull<<3)) { flagged_trap_idx = 3; e->address = regs.dr3; } } }break; } @@ -2540,7 +2550,7 @@ dmn_ctrl_run(Arena *arena, DMN_CtrlCtx *ctx, DMN_RunCtrls *ctrls) //////////////////////// //- rjf: exit loop after a little while, so we keep pumping e.g. debug strings // - if(os_now_microseconds() >= begin_time+100000 && debug_strings.total_size != 0) + if(now_time_us() >= begin_time+100000 && debug_strings.total_size != 0) { keep_going = 0; } @@ -2611,7 +2621,7 @@ dmn_ctrl_run(Arena *arena, DMN_CtrlCtx *ctx, DMN_RunCtrls *ctrls) { if(thread->kind != DMN_W32_EntityKind_Thread) { continue; } if(thread->thread.last_name_hash == 0 || - thread->thread.name_gather_time_us+1000000 <= os_now_microseconds()) + thread->thread.name_gather_time_us+1000000 <= now_time_us()) { String8 name = {0}; { @@ -2632,7 +2642,7 @@ dmn_ctrl_run(Arena *arena, DMN_CtrlCtx *ctx, DMN_RunCtrls *ctrls) e->thread = dmn_w32_handle_from_entity(thread); e->string = push_str8_copy(arena, name); } - thread->thread.name_gather_time_us = os_now_microseconds(); + thread->thread.name_gather_time_us = now_time_us(); thread->thread.last_name_hash = name_hash; } } @@ -2684,9 +2694,9 @@ dmn_ctrl_run(Arena *arena, DMN_CtrlCtx *ctx, DMN_RunCtrls *ctrls) //- rjf: x64 case Arch_x64: { - REGS_RegBlockX64 regs = {0}; + X64_RegBlock regs = {0}; dmn_w32_thread_read_reg_block(child->arch, child->handle, ®s); - regs.dr7.u64 = 0; + regs.dr7 = 0; dmn_w32_thread_write_reg_block(child->arch, child->handle, ®s); }break; } @@ -2897,7 +2907,7 @@ dmn_process_memory_release(DMN_Handle process, U64 vaddr, U64 size) } internal void -dmn_process_memory_protect(DMN_Handle process, U64 vaddr, U64 size, OS_AccessFlags flags) +dmn_process_memory_protect(DMN_Handle process, U64 vaddr, U64 size, AccessFlags flags) { DMN_AccessScope { @@ -2907,11 +2917,11 @@ dmn_process_memory_protect(DMN_Handle process, U64 vaddr, U64 size, OS_AccessFla switch(flags) { default:{}break; - case OS_AccessFlag_Execute:{new_flags = PAGE_EXECUTE;}break; - case OS_AccessFlag_Execute|OS_AccessFlag_Read:{new_flags = PAGE_EXECUTE_READ;}break; - case OS_AccessFlag_Execute|OS_AccessFlag_Read|OS_AccessFlag_Write:{new_flags = PAGE_EXECUTE_READWRITE;}break; - case OS_AccessFlag_Read:{new_flags = PAGE_READONLY;}break; - case OS_AccessFlag_Read|OS_AccessFlag_Write:{new_flags = PAGE_READWRITE;}break; + case AccessFlag_Execute:{new_flags = PAGE_EXECUTE;}break; + case AccessFlag_Execute|AccessFlag_Read:{new_flags = PAGE_EXECUTE_READ;}break; + case AccessFlag_Execute|AccessFlag_Read|AccessFlag_Write:{new_flags = PAGE_EXECUTE_READWRITE;}break; + case AccessFlag_Read:{new_flags = PAGE_READONLY;}break; + case AccessFlag_Read|AccessFlag_Write:{new_flags = PAGE_READWRITE;}break; } VirtualProtectEx(process_entity->handle, (void *)vaddr, size, new_flags, &old_flags); } diff --git a/src/disasm/disasm.c b/src/disasm/disasm.c index 5de6a860..7945cb0d 100644 --- a/src/disasm/disasm.c +++ b/src/disasm/disasm.c @@ -294,150 +294,142 @@ dasm_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_o //- rjf: data * arch * addr * dbg -> decode artifacts DASM_LineChunkList line_list = {0}; String8List inst_strings = {0}; - switch(params.arch) { - default:{}break; - - //- rjf: x86/x64 decoding - case Arch_x64: - case Arch_x86: + // rjf: disassemble + RDI_SourceFile *last_file = &rdi_nil_element_union.source_file; + RDI_Line *last_line = 0; + for(U64 off = 0; off < data.size;) { - // rjf: disassemble - RDI_SourceFile *last_file = &rdi_nil_element_union.source_file; - RDI_Line *last_line = 0; - for(U64 off = 0; off < data.size;) + // rjf: disassemble one instruction + DASM_Inst inst = dasm_inst_from_code(scratch.arena, params.arch, params.vaddr+off, str8_skip(data, off), params.syntax); + if(inst.size == 0) { - // rjf: disassemble one instruction - DASM_Inst inst = dasm_inst_from_code(scratch.arena, params.arch, params.vaddr+off, str8_skip(data, off), params.syntax); - if(inst.size == 0) + break; + } + + // rjf: push strings derived from voff -> line info + if(params.style_flags & (DASM_StyleFlag_SourceFilesNames|DASM_StyleFlag_SourceLines) && + rdi != &rdi_parsed_nil) + { + U64 voff = (params.vaddr+off) - params.base_vaddr; + U32 unit_idx = rdi_vmap_idx_from_section_kind_voff(rdi, RDI_SectionKind_UnitVMap, voff); + RDI_Unit *unit = rdi_element_from_name_idx(rdi, Units, unit_idx); + RDI_LineTable *line_table = rdi_element_from_name_idx(rdi, LineTables, unit->line_table_idx); + RDI_ParsedLineTable unit_line_info = {0}; + rdi_parsed_from_line_table(rdi, line_table, &unit_line_info); + U64 line_info_idx = rdi_line_info_idx_from_voff(&unit_line_info, voff); + if(line_info_idx < unit_line_info.count) { - break; - } - - // rjf: push strings derived from voff -> line info - if(params.style_flags & (DASM_StyleFlag_SourceFilesNames|DASM_StyleFlag_SourceLines) && - rdi != &rdi_parsed_nil) - { - U64 voff = (params.vaddr+off) - params.base_vaddr; - U32 unit_idx = rdi_vmap_idx_from_section_kind_voff(rdi, RDI_SectionKind_UnitVMap, voff); - RDI_Unit *unit = rdi_element_from_name_idx(rdi, Units, unit_idx); - RDI_LineTable *line_table = rdi_element_from_name_idx(rdi, LineTables, unit->line_table_idx); - RDI_ParsedLineTable unit_line_info = {0}; - rdi_parsed_from_line_table(rdi, line_table, &unit_line_info); - U64 line_info_idx = rdi_line_info_idx_from_voff(&unit_line_info, voff); - if(line_info_idx < unit_line_info.count) + RDI_Line *line = &unit_line_info.lines[line_info_idx]; + RDI_SourceFile *file = rdi_element_from_name_idx(rdi, SourceFiles, line->file_idx); + String8 file_normalized_full_path = {0}; + file_normalized_full_path.str = rdi_string_from_idx(rdi, file->normal_full_path_string_idx, &file_normalized_full_path.size); + if(file != last_file) { - RDI_Line *line = &unit_line_info.lines[line_info_idx]; - RDI_SourceFile *file = rdi_element_from_name_idx(rdi, SourceFiles, line->file_idx); - String8 file_normalized_full_path = {0}; - file_normalized_full_path.str = rdi_string_from_idx(rdi, file->normal_full_path_string_idx, &file_normalized_full_path.size); - if(file != last_file) + if(params.style_flags & DASM_StyleFlag_SourceFilesNames && + file->normal_full_path_string_idx != 0 && file_normalized_full_path.size != 0) { - if(params.style_flags & DASM_StyleFlag_SourceFilesNames && - file->normal_full_path_string_idx != 0 && file_normalized_full_path.size != 0) - { - String8 inst_string = push_str8f(scratch.arena, "> %S", file_normalized_full_path); - DASM_Line inst = {u32_from_u64_saturate(off), DASM_LineFlag_Decorative, 0, r1u64(inst_strings.total_size + inst_strings.node_count, - inst_strings.total_size + inst_strings.node_count + inst_string.size)}; - dasm_line_chunk_list_push(scratch.arena, &line_list, 1024, &inst); - str8_list_push(scratch.arena, &inst_strings, inst_string); - } - if(params.style_flags & DASM_StyleFlag_SourceFilesNames && file->normal_full_path_string_idx == 0) - { - String8 inst_string = str8_lit(">"); - DASM_Line inst = {u32_from_u64_saturate(off), DASM_LineFlag_Decorative, 0, r1u64(inst_strings.total_size + inst_strings.node_count, - inst_strings.total_size + inst_strings.node_count + inst_string.size)}; - dasm_line_chunk_list_push(scratch.arena, &line_list, 1024, &inst); - str8_list_push(scratch.arena, &inst_strings, inst_string); - } - last_file = file; + String8 inst_string = push_str8f(scratch.arena, "> %S", file_normalized_full_path); + DASM_Line inst = {u32_from_u64_saturate(off), DASM_LineFlag_Decorative, 0, r1u64(inst_strings.total_size + inst_strings.node_count, + inst_strings.total_size + inst_strings.node_count + inst_string.size)}; + dasm_line_chunk_list_push(scratch.arena, &line_list, 1024, &inst); + str8_list_push(scratch.arena, &inst_strings, inst_string); } - if(line && line != last_line && file->normal_full_path_string_idx != 0 && - params.style_flags & DASM_StyleFlag_SourceLines && - file_normalized_full_path.size != 0) + if(params.style_flags & DASM_StyleFlag_SourceFilesNames && file->normal_full_path_string_idx == 0) { - FileProperties props = os_properties_from_file_path(file_normalized_full_path); - if(props.modified != 0) + String8 inst_string = str8_lit(">"); + DASM_Line inst = {u32_from_u64_saturate(off), DASM_LineFlag_Decorative, 0, r1u64(inst_strings.total_size + inst_strings.node_count, + inst_strings.total_size + inst_strings.node_count + inst_string.size)}; + dasm_line_chunk_list_push(scratch.arena, &line_list, 1024, &inst); + str8_list_push(scratch.arena, &inst_strings, inst_string); + } + last_file = file; + } + if(line && line != last_line && file->normal_full_path_string_idx != 0 && + params.style_flags & DASM_StyleFlag_SourceLines && + file_normalized_full_path.size != 0) + { + FileProperties props = properties_from_file_path(file_normalized_full_path); + if(props.modified != 0) + { + // TODO(rjf): need redirection path - this may map to a different path on the local machine, + // need frontend to communicate path remapping info to this layer + C_Key key = fs_key_from_path_range(file_normalized_full_path, r1u64(0, max_U64), 0); + TXT_LangKind lang_kind = txt_lang_kind_from_extension(file_normalized_full_path); + U64 endt_us = max_U64; + U128 hash = {0}; + TXT_TextInfo text_info = txt_text_info_from_key_lang(access, key, lang_kind, &hash); + stale = (stale || u128_match(hash, u128_zero())); + if(0 < line->line_num && line->line_num < text_info.lines_count) { - // TODO(rjf): need redirection path - this may map to a different path on the local machine, - // need frontend to communicate path remapping info to this layer - C_Key key = fs_key_from_path_range(file_normalized_full_path, r1u64(0, max_U64), 0); - TXT_LangKind lang_kind = txt_lang_kind_from_extension(file_normalized_full_path); - U64 endt_us = max_U64; - U128 hash = {0}; - TXT_TextInfo text_info = txt_text_info_from_key_lang(access, key, lang_kind, &hash); - stale = (stale || u128_match(hash, u128_zero())); - if(0 < line->line_num && line->line_num < text_info.lines_count) + String8 data = c_data_from_hash(access, hash); + String8 line_text = str8_skip_chop_whitespace(str8_substr(data, text_info.lines_ranges[line->line_num-1])); + if(line_text.size != 0) { - String8 data = c_data_from_hash(access, hash); - String8 line_text = str8_skip_chop_whitespace(str8_substr(data, text_info.lines_ranges[line->line_num-1])); - if(line_text.size != 0) - { - String8 inst_string = push_str8f(scratch.arena, "> %S", line_text); - DASM_Line inst = {u32_from_u64_saturate(off), DASM_LineFlag_Decorative, 0, r1u64(inst_strings.total_size + inst_strings.node_count, - inst_strings.total_size + inst_strings.node_count + inst_string.size)}; - dasm_line_chunk_list_push(scratch.arena, &line_list, 1024, &inst); - str8_list_push(scratch.arena, &inst_strings, inst_string); - } + String8 inst_string = push_str8f(scratch.arena, "> %S", line_text); + DASM_Line inst = {u32_from_u64_saturate(off), DASM_LineFlag_Decorative, 0, r1u64(inst_strings.total_size + inst_strings.node_count, + inst_strings.total_size + inst_strings.node_count + inst_string.size)}; + dasm_line_chunk_list_push(scratch.arena, &line_list, 1024, &inst); + str8_list_push(scratch.arena, &inst_strings, inst_string); } } - last_line = line; } + last_line = line; } } - - // rjf: push line - String8 addr_part = {0}; - if(params.style_flags & DASM_StyleFlag_Addresses) - { - addr_part = push_str8f(scratch.arena, "%s0x%016I64x ", rdi != &rdi_parsed_nil ? " " : "", params.vaddr+off); - } - String8 code_bytes_part = {0}; - if(params.style_flags & DASM_StyleFlag_CodeBytes) - { - String8List code_bytes_strings = {0}; - str8_list_push(scratch.arena, &code_bytes_strings, str8_lit("{")); - for(U64 byte_idx = 0; byte_idx < inst.size || byte_idx < 16; byte_idx += 1) - { - if(byte_idx < inst.size) - { - str8_list_pushf(scratch.arena, &code_bytes_strings, "%02x%s ", (U32)data.str[off+byte_idx], byte_idx == inst.size-1 ? "}" : ""); - } - else if(byte_idx < 8) - { - str8_list_push(scratch.arena, &code_bytes_strings, str8_lit(" ")); - } - } - str8_list_push(scratch.arena, &code_bytes_strings, str8_lit(" ")); - code_bytes_part = str8_list_join(scratch.arena, &code_bytes_strings, 0); - } - String8 symbol_part = {0}; - if(inst.jump_dest_vaddr != 0 && rdi != &rdi_parsed_nil && params.style_flags & DASM_StyleFlag_SymbolNames) - { - RDI_U32 scope_idx = rdi_vmap_idx_from_section_kind_voff(rdi, RDI_SectionKind_ScopeVMap, inst.jump_dest_vaddr-params.base_vaddr); - if(scope_idx != 0) - { - RDI_Scope *scope = rdi_element_from_name_idx(rdi, Scopes, scope_idx); - RDI_U32 procedure_idx = scope->proc_idx; - RDI_Symbol *procedure = rdi_element_from_name_idx(rdi, Procedures, procedure_idx); - String8 procedure_name = {0}; - procedure_name.str = rdi_string_from_idx(rdi, procedure->name_string_idx, &procedure_name.size); - if(procedure_name.size != 0) - { - symbol_part = push_str8f(scratch.arena, " (%S)", procedure_name); - } - } - } - String8 inst_string = push_str8f(scratch.arena, "%S%S%S%S", addr_part, code_bytes_part, inst.string, symbol_part); - DASM_Line line = {u32_from_u64_saturate(off), 0, inst.jump_dest_vaddr, r1u64(inst_strings.total_size + inst_strings.node_count, - inst_strings.total_size + inst_strings.node_count + inst_string.size)}; - dasm_line_chunk_list_push(scratch.arena, &line_list, 1024, &line); - str8_list_push(scratch.arena, &inst_strings, inst_string); - - // rjf: increment - off += inst.size; } - }break; + + // rjf: push line + String8 addr_part = {0}; + if(params.style_flags & DASM_StyleFlag_Addresses) + { + addr_part = push_str8f(scratch.arena, "%s0x%016I64x ", rdi != &rdi_parsed_nil ? " " : "", params.vaddr+off); + } + String8 code_bytes_part = {0}; + if(params.style_flags & DASM_StyleFlag_CodeBytes) + { + String8List code_bytes_strings = {0}; + str8_list_push(scratch.arena, &code_bytes_strings, str8_lit("{")); + for(U64 byte_idx = 0; byte_idx < inst.size || byte_idx < 16; byte_idx += 1) + { + if(byte_idx < inst.size) + { + str8_list_pushf(scratch.arena, &code_bytes_strings, "%02x%s ", (U32)data.str[off+byte_idx], byte_idx == inst.size-1 ? "}" : ""); + } + else if(byte_idx < 8) + { + str8_list_push(scratch.arena, &code_bytes_strings, str8_lit(" ")); + } + } + str8_list_push(scratch.arena, &code_bytes_strings, str8_lit(" ")); + code_bytes_part = str8_list_join(scratch.arena, &code_bytes_strings, 0); + } + String8 symbol_part = {0}; + if(inst.jump_dest_vaddr != 0 && rdi != &rdi_parsed_nil && params.style_flags & DASM_StyleFlag_SymbolNames) + { + RDI_U32 scope_idx = rdi_vmap_idx_from_section_kind_voff(rdi, RDI_SectionKind_ScopeVMap, inst.jump_dest_vaddr-params.base_vaddr); + if(scope_idx != 0) + { + RDI_Scope *scope = rdi_element_from_name_idx(rdi, Scopes, scope_idx); + RDI_U32 procedure_idx = scope->proc_idx; + RDI_Symbol *procedure = rdi_element_from_name_idx(rdi, Procedures, procedure_idx); + String8 procedure_name = {0}; + procedure_name.str = rdi_string_from_idx(rdi, procedure->name_string_idx, &procedure_name.size); + if(procedure_name.size != 0) + { + symbol_part = push_str8f(scratch.arena, " (%S)", procedure_name); + } + } + } + String8 inst_string = push_str8f(scratch.arena, "%S%S%S%S", addr_part, code_bytes_part, inst.string, symbol_part); + DASM_Line line = {u32_from_u64_saturate(off), 0, inst.jump_dest_vaddr, r1u64(inst_strings.total_size + inst_strings.node_count, + inst_strings.total_size + inst_strings.node_count + inst_string.size)}; + dasm_line_chunk_list_push(scratch.arena, &line_list, 1024, &line); + str8_list_push(scratch.arena, &inst_strings, inst_string); + + // rjf: increment + off += inst.size; + } } //- rjf: artifacts -> value bundle diff --git a/src/draw/draw.c b/src/draw/draw.c index b4276f8b..7ba72da1 100644 --- a/src/draw/draw.c +++ b/src/draw/draw.c @@ -226,7 +226,7 @@ dr_begin_frame(FNT_Tag icon_font) } internal void -dr_submit_bucket(OS_Handle os_window, R_Handle r_window, DR_Bucket *bucket) +dr_submit_bucket(OS_Window os_window, R_Handle r_window, DR_Bucket *bucket) { r_window_submit(os_window, r_window, &bucket->passes); } diff --git a/src/draw/draw.h b/src/draw/draw.h index 78b4c080..c4ab7ab2 100644 --- a/src/draw/draw.h +++ b/src/draw/draw.h @@ -134,7 +134,7 @@ internal Vec2F32 dr_dim_from_fstrs(F32 tab_size_px, DR_FStrList *fstrs); // (Frame boundaries & bucket submission) internal void dr_begin_frame(FNT_Tag icon_font); -internal void dr_submit_bucket(OS_Handle os_window, R_Handle r_window, DR_Bucket *bucket); +internal void dr_submit_bucket(OS_Window os_window, R_Handle r_window, DR_Bucket *bucket); //////////////////////////////// //~ rjf: Bucket Construction & Selection API diff --git a/src/dwarf/dwarf.c b/src/dwarf/dwarf.c index 8f0763b9..3bbdc22d 100644 --- a/src/dwarf/dwarf.c +++ b/src/dwarf/dwarf.c @@ -1,6 +1,11 @@ // Copyright (c) Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) +//////////////////////////////// +//~ rjf: Generated Code + +#include "dwarf/generated/dwarf.meta.c" + internal DW_AttribClass dw_attrib_class_from_attrib_v2(DW_AttribKind k) { diff --git a/src/dwarf/dwarf.h b/src/dwarf/dwarf.h index 12a150f5..804deee1 100644 --- a/src/dwarf/dwarf.h +++ b/src/dwarf/dwarf.h @@ -1739,6 +1739,11 @@ typedef enum DW_RegX64Enum DW_RegX64_Last } DW_RegX64Enum; +//////////////////////////////// +//~ rjf: Generated Code + +#include "dwarf/generated/dwarf.meta.h" + //////////////////////////////// // Speced Encodings diff --git a/src/dwarf/dwarf.mdesk b/src/dwarf/dwarf.mdesk new file mode 100644 index 00000000..73a27850 --- /dev/null +++ b/src/dwarf/dwarf.mdesk @@ -0,0 +1,89 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +@table(name code byte_size) +DW_RegCodeTableX64: +{ + {rax 0 8} + {rdx 1 8} + {rcx 2 8} + {rbx 3 8} + {rsi 4 8} + {rdi 5 8} + {rbp 6 8} + {rsp 7 8} + {r8 8 8} + {r9 9 8} + {r10 10 8} + {r11 11 8} + {r12 12 8} + {r13 13 8} + {r14 14 8} + {r15 15 8} + {rip 16 8} + {zmm0 17 16} + {zmm1 18 16} + {zmm2 19 16} + {zmm3 20 16} + {zmm4 21 16} + {zmm5 22 16} + {zmm6 23 16} + {zmm7 24 16} + {zmm8 25 16} + {zmm9 26 16} + {zmm10 27 16} + {zmm11 28 16} + {zmm12 29 16} + {zmm13 30 16} + {zmm14 31 16} + {zmm15 32 16} + {zmm16 67 16} + {zmm17 68 16} + {zmm18 69 16} + {zmm19 70 16} + {zmm20 71 16} + {zmm21 72 16} + {zmm22 73 16} + {zmm23 74 16} + {zmm24 75 16} + {zmm25 76 16} + {zmm26 77 16} + {zmm27 78 16} + {zmm28 79 16} + {zmm29 80 16} + {zmm30 81 16} + {zmm31 82 16} + {st0 33 10} + {st1 34 10} + {st2 35 10} + {st3 36 10} + {st4 37 10} + {st5 38 10} + {st6 39 10} + {st7 40 10} + {mm0 41 8} + {mm1 42 8} + {mm2 43 8} + {mm3 44 8} + {mm4 45 8} + {mm5 46 8} + {mm6 47 8} + {mm7 48 8} + {rflags 49 4} + {es 50 2} + {cs 51 2} + {ss 52 2} + {ds 53 2} + {fs 54 2} + {gs 55 2} + {fsbase 58 8} + {gsbase 59 8} + // privileged registers: + // {Tr 62 ???} + // {Ldtr 63 ???} +} + +@enum DW_RegCodeX64: +{ + @expand(DW_RegCodeTableX64 a) `$(a.name) = $(a.code)`, +} diff --git a/src/dwarf/dwarf_expr.c b/src/dwarf/dwarf_expr.c index 5d73e1c2..4f4f0b22 100644 --- a/src/dwarf/dwarf_expr.c +++ b/src/dwarf/dwarf_expr.c @@ -15,13 +15,13 @@ internal DW_ExprValueType dw_expr_unsigned_value_type_from_bit_size(U64 bit_size) { switch (bit_size) { - case 8: return DW_ExprValueType_U8; - case 16: return DW_ExprValueType_U16; - case 32: return DW_ExprValueType_U32; - case 64: return DW_ExprValueType_U64; - case 128: return DW_ExprValueType_U128; - case 256: return DW_ExprValueType_U256; - case 512: return DW_ExprValueType_U512; + case 8: return DW_ExprValueType_U8; + case 16: return DW_ExprValueType_U16; + case 32: return DW_ExprValueType_U32; + case 64: return DW_ExprValueType_U64; + case 128: return DW_ExprValueType_U128; + case 256: return DW_ExprValueType_U256; + case 512: return DW_ExprValueType_U512; } AssertAlways(0 && "no suitable unsigned type was found for the specified size"); return DW_ExprValueType_Generic; @@ -31,13 +31,13 @@ internal DW_ExprValueType dw_expr_signed_value_type_from_bit_size(U64 bit_size) { switch (bit_size) { - case 8: return DW_ExprValueType_S8; - case 16: return DW_ExprValueType_S16; - case 32: return DW_ExprValueType_S32; - case 64: return DW_ExprValueType_S64; - case 128: return DW_ExprValueType_S128; - case 256: return DW_ExprValueType_S256; - case 512: return DW_ExprValueType_S512; + case 8: return DW_ExprValueType_S8; + case 16: return DW_ExprValueType_S16; + case 32: return DW_ExprValueType_S32; + case 64: return DW_ExprValueType_S64; + case 128: return DW_ExprValueType_S128; + case 256: return DW_ExprValueType_S256; + case 512: return DW_ExprValueType_S512; } AssertAlways(0 && "no suitable signed type was found for the specified size"); return DW_ExprValueType_Generic; @@ -47,8 +47,8 @@ internal DW_ExprValueType dw_expr_float_type_from_bit_size(U64 bit_size) { switch (bit_size) { - case 4: return DW_ExprValueType_F32; - case 8: return DW_ExprValueType_F64; + case 4: return DW_ExprValueType_F32; + case 8: return DW_ExprValueType_F64; } AssertAlways(0 && "no suitable type was found for the specified size"); return DW_ExprValueType_Generic; @@ -58,25 +58,25 @@ internal U64 dw_expr_byte_size_from_value_type(U64 addr_size, DW_ExprValueType k) { switch (k) { - default: { InvalidPath; } - case DW_ExprValueType_Generic: return 0; - case DW_ExprValueType_Addr: return addr_size; - case DW_ExprValueType_U8: return 1; - case DW_ExprValueType_U16: return 2; - case DW_ExprValueType_U32: return 4; - case DW_ExprValueType_U64: return 8; - case DW_ExprValueType_U128: return 16; - case DW_ExprValueType_U256: return 32; - case DW_ExprValueType_U512: return 64; - case DW_ExprValueType_S8: return 1; - case DW_ExprValueType_S16: return 2; - case DW_ExprValueType_S32: return 4; - case DW_ExprValueType_S64: return 8; - case DW_ExprValueType_S128: return 16; - case DW_ExprValueType_S256: return 32; - case DW_ExprValueType_S512: return 64; - case DW_ExprValueType_F32: return 4; - case DW_ExprValueType_F64: return 8; + default: { InvalidPath; } + case DW_ExprValueType_Generic: return 0; + case DW_ExprValueType_Addr: return addr_size; + case DW_ExprValueType_U8: return 1; + case DW_ExprValueType_U16: return 2; + case DW_ExprValueType_U32: return 4; + case DW_ExprValueType_U64: return 8; + case DW_ExprValueType_U128: return 16; + case DW_ExprValueType_U256: return 32; + case DW_ExprValueType_U512: return 64; + case DW_ExprValueType_S8: return 1; + case DW_ExprValueType_S16: return 2; + case DW_ExprValueType_S32: return 4; + case DW_ExprValueType_S64: return 8; + case DW_ExprValueType_S128: return 16; + case DW_ExprValueType_S256: return 32; + case DW_ExprValueType_S512: return 64; + case DW_ExprValueType_F32: return 4; + case DW_ExprValueType_F64: return 8; } } @@ -159,55 +159,55 @@ internal DW_ExprValue dw_expr_cast(DW_ExprValue value, DW_ExprValueType type) { DW_ExprValue result = { type }; - + #define CastTable(f, t) \ - switch (value.type) { \ - case DW_ExprValueType_Generic: { MemoryCopy(&result.f, value.generic.str, Min(sizeof(t), value.generic.size)); } break; \ - case DW_ExprValueType_U8: { result.f = (t)value.u8; } break; \ - case DW_ExprValueType_U16: { result.f = (t)value.u16; } break; \ - case DW_ExprValueType_U32: { result.f = (t)value.u32; } break; \ - case DW_ExprValueType_U64: { result.f = (t)value.u64; } break; \ - case DW_ExprValueType_U128: { NotImplemented; } break; \ - case DW_ExprValueType_U256: { NotImplemented; } break; \ - case DW_ExprValueType_U512: { NotImplemented; } break; \ - case DW_ExprValueType_S8: { result.f = (t)value.s8; } break; \ - case DW_ExprValueType_S16: { result.f = (t)value.s16; } break; \ - case DW_ExprValueType_S32: { result.f = (t)value.s32; } break; \ - case DW_ExprValueType_S64: { result.f = (t)value.s64; } break; \ - case DW_ExprValueType_S128: { NotImplemented; } break; \ - case DW_ExprValueType_S256: { NotImplemented; } break; \ - case DW_ExprValueType_S512: { NotImplemented; } break; \ - case DW_ExprValueType_F32: { result.f = (t)value.f32; } break; \ - case DW_ExprValueType_F64: { result.f = (t)value.f64; } break; \ - case DW_ExprValueType_Addr: { result.f = (t)value.addr; } break; \ - case DW_ExprValueType_Implicit: { InvalidPath; } break; \ - case DW_ExprValueType_Bool: { result.f = (t)value.boolean; } break; \ - default: { InvalidPath; } break; \ - } - +switch (value.type) { \ +case DW_ExprValueType_Generic: { MemoryCopy(&result.f, value.generic.str, Min(sizeof(t), value.generic.size)); } break; \ +case DW_ExprValueType_U8: { result.f = (t)value.u8; } break; \ +case DW_ExprValueType_U16: { result.f = (t)value.u16; } break; \ +case DW_ExprValueType_U32: { result.f = (t)value.u32; } break; \ +case DW_ExprValueType_U64: { result.f = (t)value.u64; } break; \ +case DW_ExprValueType_U128: { NotImplemented; } break; \ +case DW_ExprValueType_U256: { NotImplemented; } break; \ +case DW_ExprValueType_U512: { NotImplemented; } break; \ +case DW_ExprValueType_S8: { result.f = (t)value.s8; } break; \ +case DW_ExprValueType_S16: { result.f = (t)value.s16; } break; \ +case DW_ExprValueType_S32: { result.f = (t)value.s32; } break; \ +case DW_ExprValueType_S64: { result.f = (t)value.s64; } break; \ +case DW_ExprValueType_S128: { NotImplemented; } break; \ +case DW_ExprValueType_S256: { NotImplemented; } break; \ +case DW_ExprValueType_S512: { NotImplemented; } break; \ +case DW_ExprValueType_F32: { result.f = (t)value.f32; } break; \ +case DW_ExprValueType_F64: { result.f = (t)value.f64; } break; \ +case DW_ExprValueType_Addr: { result.f = (t)value.addr; } break; \ +case DW_ExprValueType_Implicit: { InvalidPath; } break; \ +case DW_ExprValueType_Bool: { result.f = (t)value.boolean; } break; \ +default: { InvalidPath; } break; \ +} + switch (type) { - case DW_ExprValueType_Generic: {} break; - case DW_ExprValueType_U8: { CastTable(u8, U8); } break; - case DW_ExprValueType_U16: { CastTable(u16, U16); } break; - case DW_ExprValueType_U32: { CastTable(u32, U32); } break; - case DW_ExprValueType_U64: { CastTable(u64, U64); } break; - case DW_ExprValueType_U128: { NotImplemented; } break; - case DW_ExprValueType_U256: { NotImplemented; } break; - case DW_ExprValueType_U512: { NotImplemented; } break; - case DW_ExprValueType_S8: { CastTable(s8, S8); } break; - case DW_ExprValueType_S16: { CastTable(s16, S16); } break; - case DW_ExprValueType_S32: { CastTable(s32, S32); } break; - case DW_ExprValueType_S64: { CastTable(s64, S64); } break; - case DW_ExprValueType_S128: { NotImplemented; } break; - case DW_ExprValueType_S256: { NotImplemented; } break; - case DW_ExprValueType_S512: { NotImplemented; } break; - case DW_ExprValueType_F32: { CastTable(f32, F32); } break; - case DW_ExprValueType_F64: { CastTable(f64, F64); } break; - case DW_ExprValueType_Addr: { CastTable(addr, U64); } break; - case DW_ExprValueType_Implicit: { NotImplemented; } break; - case DW_ExprValueType_Bool: { CastTable(boolean, DW_ExprBool); } break; + case DW_ExprValueType_Generic: {} break; + case DW_ExprValueType_U8: { CastTable(u8, U8); } break; + case DW_ExprValueType_U16: { CastTable(u16, U16); } break; + case DW_ExprValueType_U32: { CastTable(u32, U32); } break; + case DW_ExprValueType_U64: { CastTable(u64, U64); } break; + case DW_ExprValueType_U128: { NotImplemented; } break; + case DW_ExprValueType_U256: { NotImplemented; } break; + case DW_ExprValueType_U512: { NotImplemented; } break; + case DW_ExprValueType_S8: { CastTable(s8, S8); } break; + case DW_ExprValueType_S16: { CastTable(s16, S16); } break; + case DW_ExprValueType_S32: { CastTable(s32, S32); } break; + case DW_ExprValueType_S64: { CastTable(s64, S64); } break; + case DW_ExprValueType_S128: { NotImplemented; } break; + case DW_ExprValueType_S256: { NotImplemented; } break; + case DW_ExprValueType_S512: { NotImplemented; } break; + case DW_ExprValueType_F32: { CastTable(f32, F32); } break; + case DW_ExprValueType_F64: { CastTable(f64, F64); } break; + case DW_ExprValueType_Addr: { CastTable(addr, U64); } break; + case DW_ExprValueType_Implicit: { NotImplemented; } break; + case DW_ExprValueType_Bool: { CastTable(boolean, DW_ExprBool); } break; } - + #undef CastTable return result; } @@ -217,38 +217,38 @@ dw_expr_add(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 + common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 + common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 + common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 + common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 + common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 + common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 + common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 + common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 + common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 + common_rhs.f32; } break; - case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 + common_rhs.f64; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr + common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 + common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 + common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 + common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 + common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 + common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 + common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 + common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 + common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 + common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 + common_rhs.f32; } break; + case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 + common_rhs.f64; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr + common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } return result; } @@ -258,38 +258,38 @@ dw_expr_minus(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 - common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 - common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 - common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 - common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 - common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 - common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 - common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 - common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 - common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 - common_rhs.f32; } break; - case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 - common_rhs.f64; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr - common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 - common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 - common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 - common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 - common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 - common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 - common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 - common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 - common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 - common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 - common_rhs.f32; } break; + case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 - common_rhs.f64; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr - common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } return result; } @@ -299,38 +299,38 @@ dw_expr_mul(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 * common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 * common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 * common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 * common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 * common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 * common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 * common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 * common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 * common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 * common_rhs.f32; } break; - case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 * common_rhs.f64; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr * common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 * common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 * common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 * common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 * common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 * common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 * common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 * common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 * common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 * common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 * common_rhs.f32; } break; + case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 * common_rhs.f64; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr * common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } return result; } @@ -340,38 +340,38 @@ dw_expr_div(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 / common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 / common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 / common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 / common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 / common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 / common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 / common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 / common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 / common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 / common_rhs.f32; } break; - case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 / common_rhs.f64; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr / common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 / common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 / common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 / common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 / common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 / common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 / common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 / common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 / common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 / common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 / common_rhs.f32; } break; + case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 / common_rhs.f64; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr / common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } return result; } @@ -381,38 +381,38 @@ dw_expr_mod(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 % common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 % common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 % common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 % common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 % common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 % common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 % common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 % common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 % common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { InvalidPath; } break; - case DW_ExprValueType_F64: { InvalidPath; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr % common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 % common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 % common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 % common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 % common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 % common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 % common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 % common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 % common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 % common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { InvalidPath; } break; + case DW_ExprValueType_F64: { InvalidPath; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr % common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } return result; } @@ -422,40 +422,40 @@ dw_expr_eq(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_compar_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 == common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 == common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 == common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 == common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 == common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 == common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 == common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 == common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 == common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 == common_rhs.f32; } break; - case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 == common_rhs.f64; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr == common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 == common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 == common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 == common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 == common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 == common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 == common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 == common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 == common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 == common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 == common_rhs.f32; } break; + case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 == common_rhs.f64; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr == common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } - + return result; } @@ -464,40 +464,40 @@ dw_expr_ge(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_compar_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 >= common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 >= common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 >= common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 >= common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 >= common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 >= common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 >= common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 >= common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 >= common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 >= common_rhs.f32; } break; - case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 >= common_rhs.f64; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr >= common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 >= common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 >= common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 >= common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 >= common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 >= common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 >= common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 >= common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 >= common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 >= common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 >= common_rhs.f32; } break; + case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 >= common_rhs.f64; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr >= common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } - + return result; } @@ -506,40 +506,40 @@ dw_expr_gt(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_compar_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 > common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 > common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 > common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 > common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 > common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 > common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 > common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 > common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 > common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 > common_rhs.f32; } break; - case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 > common_rhs.f64; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr > common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 > common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 > common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 > common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 > common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 > common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 > common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 > common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 > common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 > common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 > common_rhs.f32; } break; + case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 > common_rhs.f64; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr > common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } - + return result; } @@ -548,40 +548,40 @@ dw_expr_le(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_compar_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 <= common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 <= common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 <= common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 <= common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 <= common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 <= common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 <= common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 <= common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 <= common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 <= common_rhs.f32; } break; - case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 <= common_rhs.f64; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr <= common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 <= common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 <= common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 <= common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 <= common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 <= common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 <= common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 <= common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 <= common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 <= common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 <= common_rhs.f32; } break; + case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 <= common_rhs.f64; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr <= common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } - + return result; } @@ -590,40 +590,40 @@ dw_expr_lt(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_compar_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 < common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 < common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 < common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 < common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 < common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 < common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 < common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 < common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 < common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 < common_rhs.f32; } break; - case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 < common_rhs.f64; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr < common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 < common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 < common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 < common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 < common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 < common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 < common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 < common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 < common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 < common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 < common_rhs.f32; } break; + case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 < common_rhs.f64; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr < common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } - + return result; } @@ -632,40 +632,40 @@ dw_expr_ne(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_compar_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 != common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 != common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 != common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 != common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 != common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 != common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 != common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 != common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 != common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 != common_rhs.f32; } break; - case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 != common_rhs.f64; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr != common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 != common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 != common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 != common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 != common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 != common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 != common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 != common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 != common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 != common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { result.f32 = common_lhs.f32 != common_rhs.f32; } break; + case DW_ExprValueType_F64: { result.f64 = common_lhs.f64 != common_rhs.f64; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr != common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } - + return result; } @@ -674,40 +674,40 @@ dw_expr_xor(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_compar_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 ^ common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 ^ common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 ^ common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 ^ common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 ^ common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 ^ common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 ^ common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 ^ common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 ^ common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { InvalidPath; } break; - case DW_ExprValueType_F64: { InvalidPath; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr ^ common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 ^ common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 ^ common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 ^ common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 ^ common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 ^ common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 ^ common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 ^ common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 ^ common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 ^ common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { InvalidPath; } break; + case DW_ExprValueType_F64: { InvalidPath; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr ^ common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } - + return result; } @@ -716,40 +716,40 @@ dw_expr_and(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_compar_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 & common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 & common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 & common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 & common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 & common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 & common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 & common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 & common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 & common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { InvalidPath; } break; - case DW_ExprValueType_F64: { InvalidPath; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr & common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 & common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 & common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 & common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 & common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 & common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 & common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 & common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 & common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 & common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { InvalidPath; } break; + case DW_ExprValueType_F64: { InvalidPath; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr & common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } - + return result; } @@ -758,40 +758,40 @@ dw_expr_or(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_compar_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 | common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 | common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 | common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 | common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 | common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 | common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 | common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 | common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 | common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { InvalidPath; } break; - case DW_ExprValueType_F64: { InvalidPath; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr | common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 | common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 | common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 | common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 | common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 | common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 | common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 | common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 | common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 | common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { InvalidPath; } break; + case DW_ExprValueType_F64: { InvalidPath; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr | common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } - + return result; } @@ -800,40 +800,40 @@ dw_expr_shl(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_compar_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 << common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 << common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 << common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 << common_rhs.u64; } break; - - case DW_ExprValueType_U128: - case DW_ExprValueType_U256: - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 << common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 << common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 << common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 << common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 << common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { InvalidPath; } break; - case DW_ExprValueType_F64: { InvalidPath; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr << common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 << common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 << common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 << common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 << common_rhs.u64; } break; + + case DW_ExprValueType_U128: + case DW_ExprValueType_U256: + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 << common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 << common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 << common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 << common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 << common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { InvalidPath; } break; + case DW_ExprValueType_F64: { InvalidPath; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr << common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } - + return result; } @@ -842,39 +842,39 @@ dw_expr_shr(DW_ExprValue lhs, DW_ExprValue rhs) { DW_ExprValue result = {0}; result.type = dw_expr_pick_common_compar_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 >> common_rhs.u8; } break; - case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 >> common_rhs.u16; } break; - case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 >> common_rhs.u32; } break; - case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 >> common_rhs.u64; } break; - - case DW_ExprValueType_U128: { NotImplemented; } break; - case DW_ExprValueType_U256: { NotImplemented; } break; - case DW_ExprValueType_U512: { NotImplemented; } break; - - case DW_ExprValueType_Bool: { InvalidPath; } break; - case DW_ExprValueType_S8: { InvalidPath; } break; - case DW_ExprValueType_S16: { InvalidPath; } break; - case DW_ExprValueType_S32: { InvalidPath; } break; - case DW_ExprValueType_S64: { InvalidPath; } break; - case DW_ExprValueType_S128: { InvalidPath; } break; - case DW_ExprValueType_S256: { InvalidPath; } break; - case DW_ExprValueType_S512: { InvalidPath; } break; - - case DW_ExprValueType_F32: { InvalidPath; } break; - case DW_ExprValueType_F64: { InvalidPath; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr >> common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = common_lhs.u8 >> common_rhs.u8; } break; + case DW_ExprValueType_U16: { result.u16 = common_lhs.u16 >> common_rhs.u16; } break; + case DW_ExprValueType_U32: { result.u32 = common_lhs.u32 >> common_rhs.u32; } break; + case DW_ExprValueType_U64: { result.u64 = common_lhs.u64 >> common_rhs.u64; } break; + + case DW_ExprValueType_U128: { NotImplemented; } break; + case DW_ExprValueType_U256: { NotImplemented; } break; + case DW_ExprValueType_U512: { NotImplemented; } break; + + case DW_ExprValueType_Bool: { InvalidPath; } break; + case DW_ExprValueType_S8: { InvalidPath; } break; + case DW_ExprValueType_S16: { InvalidPath; } break; + case DW_ExprValueType_S32: { InvalidPath; } break; + case DW_ExprValueType_S64: { InvalidPath; } break; + case DW_ExprValueType_S128: { InvalidPath; } break; + case DW_ExprValueType_S256: { InvalidPath; } break; + case DW_ExprValueType_S512: { InvalidPath; } break; + + case DW_ExprValueType_F32: { InvalidPath; } break; + case DW_ExprValueType_F64: { InvalidPath; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr >> common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } - + return result; } @@ -885,47 +885,47 @@ dw_expr_shra(DW_ExprValue lhs, DW_ExprValue rhs) DW_ExprValueType new_type = dw_expr_signed_value_type_from_bit_size(dw_expr_byte_size_from_value_type(0, lhs.type) * 8); lhs = dw_expr_cast(lhs, new_type); } - + if (DW_ExprValueType_IsUnsigned(rhs.type)) { DW_ExprValueType new_type = dw_expr_signed_value_type_from_bit_size(dw_expr_byte_size_from_value_type(0, rhs.type) * 8); rhs = dw_expr_cast(rhs, new_type); } - + DW_ExprValue result = {0}; result.type = dw_expr_pick_common_compar_value_type(lhs.type, rhs.type); - + DW_ExprValue common_lhs = dw_expr_cast(lhs, result.type); DW_ExprValue common_rhs = dw_expr_cast(rhs, result.type); - + switch (result.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { InvalidPath; } break; - case DW_ExprValueType_U16: { InvalidPath; } break; - case DW_ExprValueType_U32: { InvalidPath; } break; - case DW_ExprValueType_U64: { InvalidPath; } break; - case DW_ExprValueType_U128: { InvalidPath; } break; - case DW_ExprValueType_U256: { InvalidPath; } break; - case DW_ExprValueType_U512: { InvalidPath; } break; - - case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 >> common_rhs.s8; } break; - case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 >> common_rhs.s8; } break; - case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 >> common_rhs.s16; } break; - case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 >> common_rhs.s32; } break; - case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 >> common_rhs.s64; } break; - - case DW_ExprValueType_S128: - case DW_ExprValueType_S256: - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { InvalidPath; } break; - case DW_ExprValueType_F64: { InvalidPath; } break; - case DW_ExprValueType_Addr: { result.addr = common_lhs.addr >> common_rhs.addr; } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; - - default: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { InvalidPath; } break; + case DW_ExprValueType_U16: { InvalidPath; } break; + case DW_ExprValueType_U32: { InvalidPath; } break; + case DW_ExprValueType_U64: { InvalidPath; } break; + case DW_ExprValueType_U128: { InvalidPath; } break; + case DW_ExprValueType_U256: { InvalidPath; } break; + case DW_ExprValueType_U512: { InvalidPath; } break; + + case DW_ExprValueType_Bool: { result.s8 = common_lhs.s8 >> common_rhs.s8; } break; + case DW_ExprValueType_S8: { result.s8 = common_lhs.s8 >> common_rhs.s8; } break; + case DW_ExprValueType_S16: { result.s16 = common_lhs.s16 >> common_rhs.s16; } break; + case DW_ExprValueType_S32: { result.s32 = common_lhs.s32 >> common_rhs.s32; } break; + case DW_ExprValueType_S64: { result.s64 = common_lhs.s64 >> common_rhs.s64; } break; + + case DW_ExprValueType_S128: + case DW_ExprValueType_S256: + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { InvalidPath; } break; + case DW_ExprValueType_F64: { InvalidPath; } break; + case DW_ExprValueType_Addr: { result.addr = common_lhs.addr >> common_rhs.addr; } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; + + default: { InvalidPath; } break; } - + return result; } @@ -933,34 +933,34 @@ internal DW_ExprValue dw_expr_abs(DW_ExprValue value) { DW_ExprValue result = value; - + switch (value.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: {}; break; - case DW_ExprValueType_U16: {}; break; - case DW_ExprValueType_U32: {}; break; - case DW_ExprValueType_U64: {}; break; - case DW_ExprValueType_U128: {}; break; - case DW_ExprValueType_U256: {}; break; - case DW_ExprValueType_U512: {}; break; - - case DW_ExprValueType_S8: { result.s8 = abs_s64(result.s8); } break; - case DW_ExprValueType_S16: { result.s16 = abs_s64(result.s16); } break; - case DW_ExprValueType_S32: { result.s32 = abs_s64(result.s32); } break; - case DW_ExprValueType_S64: { result.s64 = abs_s64(result.s64); } break; - case DW_ExprValueType_S128: { NotImplemented; } break; - case DW_ExprValueType_S256: { NotImplemented; } break; - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { result.f32 = abs_f32(result.f32); } break; - case DW_ExprValueType_F64: { result.f64 = abs_f64(result.f64); } break; - - case DW_ExprValueType_Addr: {} break; - case DW_ExprValueType_Bool: { result.boolean = abs_s64(result.boolean); } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: {}; break; + case DW_ExprValueType_U16: {}; break; + case DW_ExprValueType_U32: {}; break; + case DW_ExprValueType_U64: {}; break; + case DW_ExprValueType_U128: {}; break; + case DW_ExprValueType_U256: {}; break; + case DW_ExprValueType_U512: {}; break; + + case DW_ExprValueType_S8: { result.s8 = abs_s64(result.s8); } break; + case DW_ExprValueType_S16: { result.s16 = abs_s64(result.s16); } break; + case DW_ExprValueType_S32: { result.s32 = abs_s64(result.s32); } break; + case DW_ExprValueType_S64: { result.s64 = abs_s64(result.s64); } break; + case DW_ExprValueType_S128: { NotImplemented; } break; + case DW_ExprValueType_S256: { NotImplemented; } break; + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { result.f32 = abs_f32(result.f32); } break; + case DW_ExprValueType_F64: { result.f64 = abs_f64(result.f64); } break; + + case DW_ExprValueType_Addr: {} break; + case DW_ExprValueType_Bool: { result.boolean = abs_s64(result.boolean); } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; } - + return result; } @@ -968,34 +968,34 @@ internal DW_ExprValue dw_expr_neg(DW_ExprValue value) { DW_ExprValue result = value; - + switch (value.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = -result.u8; }; break; - case DW_ExprValueType_U16: { result.u16 = -result.u16; }; break; - case DW_ExprValueType_U32: { result.u32 = -result.u32; }; break; - case DW_ExprValueType_U64: { result.u64 = -result.u64; }; break; - case DW_ExprValueType_U128: { NotImplemented; }; break; - case DW_ExprValueType_U256: { NotImplemented; }; break; - case DW_ExprValueType_U512: { NotImplemented; }; break; - - case DW_ExprValueType_S8: { result.s8 = -result.s8; } break; - case DW_ExprValueType_S16: { result.s16 = -result.s16; } break; - case DW_ExprValueType_S32: { result.s32 = -result.s32; } break; - case DW_ExprValueType_S64: { result.s64 = -result.s64; } break; - case DW_ExprValueType_S128: { NotImplemented; } break; - case DW_ExprValueType_S256: { NotImplemented; } break; - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { result.f32 = -result.f32; } break; - case DW_ExprValueType_F64: { result.f64 = -result.f64; } break; - - case DW_ExprValueType_Addr: { result.addr = -result.addr; } break; - case DW_ExprValueType_Bool: { result.boolean = abs_s64(result.boolean); } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = -result.u8; }; break; + case DW_ExprValueType_U16: { result.u16 = -result.u16; }; break; + case DW_ExprValueType_U32: { result.u32 = -result.u32; }; break; + case DW_ExprValueType_U64: { result.u64 = -result.u64; }; break; + case DW_ExprValueType_U128: { NotImplemented; }; break; + case DW_ExprValueType_U256: { NotImplemented; }; break; + case DW_ExprValueType_U512: { NotImplemented; }; break; + + case DW_ExprValueType_S8: { result.s8 = -result.s8; } break; + case DW_ExprValueType_S16: { result.s16 = -result.s16; } break; + case DW_ExprValueType_S32: { result.s32 = -result.s32; } break; + case DW_ExprValueType_S64: { result.s64 = -result.s64; } break; + case DW_ExprValueType_S128: { NotImplemented; } break; + case DW_ExprValueType_S256: { NotImplemented; } break; + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { result.f32 = -result.f32; } break; + case DW_ExprValueType_F64: { result.f64 = -result.f64; } break; + + case DW_ExprValueType_Addr: { result.addr = -result.addr; } break; + case DW_ExprValueType_Bool: { result.boolean = abs_s64(result.boolean); } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; } - + return result; } @@ -1003,34 +1003,34 @@ internal DW_ExprValue dw_expr_not(DW_ExprValue value) { DW_ExprValue result = value; - + switch (value.type) { - case DW_ExprValueType_Generic: { InvalidPath; } break; - - case DW_ExprValueType_U8: { result.u8 = !result.u8; }; break; - case DW_ExprValueType_U16: { result.u16 = !result.u16; }; break; - case DW_ExprValueType_U32: { result.u32 = !result.u32; }; break; - case DW_ExprValueType_U64: { result.u64 = !result.u64; }; break; - case DW_ExprValueType_U128: { NotImplemented; }; break; - case DW_ExprValueType_U256: { NotImplemented; }; break; - case DW_ExprValueType_U512: { NotImplemented; }; break; - - case DW_ExprValueType_S8: { result.s8 = !result.s8; } break; - case DW_ExprValueType_S16: { result.s16 = !result.s16; } break; - case DW_ExprValueType_S32: { result.s32 = !result.s32; } break; - case DW_ExprValueType_S64: { result.s64 = !result.s64; } break; - case DW_ExprValueType_S128: { NotImplemented; } break; - case DW_ExprValueType_S256: { NotImplemented; } break; - case DW_ExprValueType_S512: { NotImplemented; } break; - - case DW_ExprValueType_F32: { result.f32 = !result.f32; } break; - case DW_ExprValueType_F64: { result.f64 = !result.f64; } break; - - case DW_ExprValueType_Addr: { result.addr = !result.addr; } break; - case DW_ExprValueType_Bool: { result.boolean = abs_s64(result.boolean); } break; - case DW_ExprValueType_Implicit: { InvalidPath; } break; + case DW_ExprValueType_Generic: { InvalidPath; } break; + + case DW_ExprValueType_U8: { result.u8 = !result.u8; }; break; + case DW_ExprValueType_U16: { result.u16 = !result.u16; }; break; + case DW_ExprValueType_U32: { result.u32 = !result.u32; }; break; + case DW_ExprValueType_U64: { result.u64 = !result.u64; }; break; + case DW_ExprValueType_U128: { NotImplemented; }; break; + case DW_ExprValueType_U256: { NotImplemented; }; break; + case DW_ExprValueType_U512: { NotImplemented; }; break; + + case DW_ExprValueType_S8: { result.s8 = !result.s8; } break; + case DW_ExprValueType_S16: { result.s16 = !result.s16; } break; + case DW_ExprValueType_S32: { result.s32 = !result.s32; } break; + case DW_ExprValueType_S64: { result.s64 = !result.s64; } break; + case DW_ExprValueType_S128: { NotImplemented; } break; + case DW_ExprValueType_S256: { NotImplemented; } break; + case DW_ExprValueType_S512: { NotImplemented; } break; + + case DW_ExprValueType_F32: { result.f32 = !result.f32; } break; + case DW_ExprValueType_F64: { result.f64 = !result.f64; } break; + + case DW_ExprValueType_Addr: { result.addr = !result.addr; } break; + case DW_ExprValueType_Bool: { result.boolean = abs_s64(result.boolean); } break; + case DW_ExprValueType_Implicit: { InvalidPath; } break; } - + return result; } @@ -1039,23 +1039,23 @@ dw_string_from_expr_value(Arena *arena, U64 addr_size, DW_ExprValue v) { String8 s = {0}; switch (v.type) { - case DW_ExprValueType_Generic: { } break; - case DW_ExprValueType_U8: { s = str8_struct(&v.u8); } break; - case DW_ExprValueType_U16: { s = str8_struct(&v.u16); } break; - case DW_ExprValueType_U32: { s = str8_struct(&v.u32); } break; - case DW_ExprValueType_U64: { s = str8_struct(&v.u64); } break; - case DW_ExprValueType_U128: { s = str8_struct(&v.u128); } break; - case DW_ExprValueType_U256: { s = str8_struct(&v.u256); } break; - case DW_ExprValueType_U512: { s = str8_struct(&v.u512); } break; - case DW_ExprValueType_S8: { s = str8_struct(&v.s8); } break; - case DW_ExprValueType_S16: { s = str8_struct(&v.s16); } break; - case DW_ExprValueType_S32: { s = str8_struct(&v.s32); } break; - case DW_ExprValueType_S64: { s = str8_struct(&v.s64); } break; - case DW_ExprValueType_F32: { s = str8_struct(&v.f32); } break; - case DW_ExprValueType_F64: { s = str8_struct(&v.f64); } break; - case DW_ExprValueType_Addr: { s = str8((U8 *)&v.addr, addr_size); } break; - case DW_ExprValueType_Implicit: { s = v.implicit; } break; - default: { NotImplemented; } break; + case DW_ExprValueType_Generic: { } break; + case DW_ExprValueType_U8: { s = str8_struct(&v.u8); } break; + case DW_ExprValueType_U16: { s = str8_struct(&v.u16); } break; + case DW_ExprValueType_U32: { s = str8_struct(&v.u32); } break; + case DW_ExprValueType_U64: { s = str8_struct(&v.u64); } break; + case DW_ExprValueType_U128: { s = str8_struct(&v.u128); } break; + case DW_ExprValueType_U256: { s = str8_struct(&v.u256); } break; + case DW_ExprValueType_U512: { s = str8_struct(&v.u512); } break; + case DW_ExprValueType_S8: { s = str8_struct(&v.s8); } break; + case DW_ExprValueType_S16: { s = str8_struct(&v.s16); } break; + case DW_ExprValueType_S32: { s = str8_struct(&v.s32); } break; + case DW_ExprValueType_S64: { s = str8_struct(&v.s64); } break; + case DW_ExprValueType_F32: { s = str8_struct(&v.f32); } break; + case DW_ExprValueType_F64: { s = str8_struct(&v.f64); } break; + case DW_ExprValueType_Addr: { s = str8((U8 *)&v.addr, addr_size); } break; + case DW_ExprValueType_Implicit: { s = v.implicit; } break; + default: { NotImplemented; } break; } return str8_copy(arena, s); } @@ -1075,12 +1075,12 @@ dw_expr_stack_push_unsigned(Arena *arena, DW_ExprStack *stack, void *value, U64 { DW_ExprValueNode *n = 0; switch (value_size) { - case 0: {} break; - case 1: { n = dw_expr_stack_push(arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U8, .u8 = *(U8 *)value }); } break; - case 2: { n = dw_expr_stack_push(arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U16, .u16 = *(U16 *)value }); } break; - case 4: { n = dw_expr_stack_push(arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U32, .u32 = *(U32 *)value }); } break; - case 8: { n = dw_expr_stack_push(arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U64, .u64 = *(U64 *)value }); } break; - default: { NotImplemented; } break; + case 0: {} break; + case 1: { n = dw_expr_stack_push(arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U8, .u8 = *(U8 *)value }); } break; + case 2: { n = dw_expr_stack_push(arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U16, .u16 = *(U16 *)value }); } break; + case 4: { n = dw_expr_stack_push(arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U32, .u32 = *(U32 *)value }); } break; + case 8: { n = dw_expr_stack_push(arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U64, .u64 = *(U64 *)value }); } break; + default: { NotImplemented; } break; } return n; } @@ -1128,25 +1128,17 @@ dw_expr_inst_from_delta(DW_ExprInst *inst, S16 delta) } internal DW_ExprEvalResult -dw_eval_expr(Arena *arena, - Arch arch, - DW_Format format, - U64 frame_base, - U64 cfa, - U64 tls, - U64 exec_op_limit, - DW_Expr expr, - MachineOp_RegRead *reg_read, void *reg_read_ud, - MachineOp_MemRead *mem_read, void *mem_read_ud, - DW_ExprValue *value_out) +dw_eval_expr(Arena *arena, Arch arch, DW_Format format, U64 frame_base, U64 cfa, U64 tls, U64 exec_op_limit, DW_Expr expr, void *reg_block, MachineOp_MemRead *mem_read, void *mem_read_ud, DW_ExprValue *value_out) { Temp scratch = scratch_begin(&arena, 1); - + + ARCH_Info *arch_info = arch_info_from_arch(arch); + DW_ExprEvalResult result = DW_ExprEvalResult_Fail; DW_PieceList pieces = {0}; DW_ExprStack *stack = push_array(scratch.arena, DW_ExprStack, 1); U64 exec_op_count = 0; - + for EachNode(inst, DW_ExprInst, expr.first) { again:; @@ -1156,350 +1148,372 @@ dw_eval_expr(Arena *arena, result = DW_ExprEvalResult_ExecOpLimitReached; goto exit; } - + U64 pop_count = dw_pop_count_from_expr_op(inst->opcode); if (pop_count > stack->count) { Assert(0 && "not enough values on the stack to evaluate the instruction"); goto exit; } - + switch (inst->opcode) { - case DW_ExprOp_Nop: {} break; - - case DW_ExprOp_Lit0: case DW_ExprOp_Lit1: case DW_ExprOp_Lit2: - case DW_ExprOp_Lit3: case DW_ExprOp_Lit4: case DW_ExprOp_Lit5: - case DW_ExprOp_Lit6: case DW_ExprOp_Lit7: case DW_ExprOp_Lit8: - case DW_ExprOp_Lit9: case DW_ExprOp_Lit10: case DW_ExprOp_Lit11: - case DW_ExprOp_Lit12: case DW_ExprOp_Lit13: case DW_ExprOp_Lit14: - case DW_ExprOp_Lit15: case DW_ExprOp_Lit16: case DW_ExprOp_Lit17: - case DW_ExprOp_Lit18: case DW_ExprOp_Lit19: case DW_ExprOp_Lit20: - case DW_ExprOp_Lit21: case DW_ExprOp_Lit22: case DW_ExprOp_Lit23: - case DW_ExprOp_Lit24: case DW_ExprOp_Lit25: case DW_ExprOp_Lit26: - case DW_ExprOp_Lit27: case DW_ExprOp_Lit28: case DW_ExprOp_Lit29: - case DW_ExprOp_Lit30: case DW_ExprOp_Lit31: { - dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U8, .u8 = inst->opcode - DW_ExprOp_Lit0 }); - } break; - - case DW_ExprOp_Const1U: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U8, .u8 = inst->operands[0].u8 }); } break; - case DW_ExprOp_Const2U: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U16, .u16 = inst->operands[0].u16 }); } break; - case DW_ExprOp_Const4U: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U32, .u32 = inst->operands[0].u32 }); } break; - case DW_ExprOp_Const8U: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U64, .u64 = inst->operands[0].u64 }); } break; - case DW_ExprOp_Const1S: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_S8, .s8 = inst->operands[0].s8 }); } break; - case DW_ExprOp_Const2S: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_S16, .s16 = inst->operands[0].s16 }); } break; - case DW_ExprOp_Const4S: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_S32, .s32 = inst->operands[0].s32 }); } break; - case DW_ExprOp_Const8S: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_S64, .s64 = inst->operands[0].s64 }); } break; - case DW_ExprOp_ConstU: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U64, .u64 = inst->operands[0].u64 }); } break; - case DW_ExprOp_ConstS: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_S64, .s64 = inst->operands[0].s64 }); } break; - case DW_ExprOp_Addr: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_Addr, .addr = inst->operands[0].u64 }); } break; - - case DW_ExprOp_Reg0: case DW_ExprOp_Reg1: case DW_ExprOp_Reg2: - case DW_ExprOp_Reg3: case DW_ExprOp_Reg4: case DW_ExprOp_Reg5: - case DW_ExprOp_Reg6: case DW_ExprOp_Reg7: case DW_ExprOp_Reg8: - case DW_ExprOp_Reg9: case DW_ExprOp_Reg10: case DW_ExprOp_Reg11: - case DW_ExprOp_Reg12: case DW_ExprOp_Reg13: case DW_ExprOp_Reg14: - case DW_ExprOp_Reg15: case DW_ExprOp_Reg16: case DW_ExprOp_Reg17: - case DW_ExprOp_Reg18: case DW_ExprOp_Reg19: case DW_ExprOp_Reg20: - case DW_ExprOp_Reg21: case DW_ExprOp_Reg22: case DW_ExprOp_Reg23: - case DW_ExprOp_Reg24: case DW_ExprOp_Reg25: case DW_ExprOp_Reg26: - case DW_ExprOp_Reg27: case DW_ExprOp_Reg28: case DW_ExprOp_Reg29: - case DW_ExprOp_Reg30: case DW_ExprOp_Reg31: { - DW_Reg reg_id = inst->opcode - DW_ExprOp_Reg0; - U64 reg_size = dw_reg_size_from_code(arch, reg_id); - U8 *reg_value = push_array(scratch.arena, U8, reg_size); - MachineOpResult reg_read_result = reg_read(reg_id, reg_value, reg_size, reg_read_ud); - if (reg_read_result != MachineOpResult_Ok) { goto exit; } - dw_expr_stack_push_unsigned(scratch.arena, stack, reg_value, reg_size); - } break; - - case DW_ExprOp_BReg0: case DW_ExprOp_BReg1: case DW_ExprOp_BReg2: - case DW_ExprOp_BReg3: case DW_ExprOp_BReg4: case DW_ExprOp_BReg5: - case DW_ExprOp_BReg6: case DW_ExprOp_BReg7: case DW_ExprOp_BReg8: - case DW_ExprOp_BReg9: case DW_ExprOp_BReg10: case DW_ExprOp_BReg11: - case DW_ExprOp_BReg12: case DW_ExprOp_BReg13: case DW_ExprOp_BReg14: - case DW_ExprOp_BReg15: case DW_ExprOp_BReg16: case DW_ExprOp_BReg17: - case DW_ExprOp_BReg18: case DW_ExprOp_BReg19: case DW_ExprOp_BReg20: - case DW_ExprOp_BReg21: case DW_ExprOp_BReg22: case DW_ExprOp_BReg23: - case DW_ExprOp_BReg24: case DW_ExprOp_BReg25: case DW_ExprOp_BReg26: - case DW_ExprOp_BReg27: case DW_ExprOp_BReg28: case DW_ExprOp_BReg29: - case DW_ExprOp_BReg30: case DW_ExprOp_BReg31: { - DW_Reg reg_id = inst->opcode - DW_ExprOp_BReg0; - U64 reg_size = dw_reg_size_from_code(arch, reg_id); - AssertAlways(reg_size <= byte_size_from_arch(arch)); - - U64 reg_value; - MachineOpResult reg_read_result = reg_read(reg_id, ®_value, reg_size, reg_read_ud); - if (reg_read_result != MachineOpResult_Ok) { goto exit; } + case DW_ExprOp_Nop: {} break; - U64 addr = (U64)((S64)reg_value + inst->operands[0].s64); - dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_Addr, .addr = addr}); - } break; - - case DW_ExprOp_RegX: { - U64 reg_size = dw_reg_size_from_code(arch, inst->operands[0].u64); - U8 *reg_value = push_array(scratch.arena, U8, reg_size); - MachineOpResult reg_read_result = reg_read(inst->operands[0].u64, reg_value, reg_size, reg_read_ud); - if (reg_read_result != MachineOpResult_Ok) { goto exit; } - dw_expr_stack_push_unsigned(scratch.arena, stack, reg_value, reg_size); - } break; - - case DW_ExprOp_BRegX: { - DW_Reg reg_id = (DW_Reg)inst->operands[0].u64; - U64 reg_size = dw_reg_size_from_code(arch, reg_id); - AssertAlways(reg_size <= byte_size_from_arch(arch)); - - U64 reg_value; - MachineOpResult reg_read_result = reg_read(reg_id, ®_value, reg_size, reg_read_ud); - if (reg_read_result != MachineOpResult_Ok) { goto exit; } + case DW_ExprOp_Lit0: case DW_ExprOp_Lit1: case DW_ExprOp_Lit2: + case DW_ExprOp_Lit3: case DW_ExprOp_Lit4: case DW_ExprOp_Lit5: + case DW_ExprOp_Lit6: case DW_ExprOp_Lit7: case DW_ExprOp_Lit8: + case DW_ExprOp_Lit9: case DW_ExprOp_Lit10: case DW_ExprOp_Lit11: + case DW_ExprOp_Lit12: case DW_ExprOp_Lit13: case DW_ExprOp_Lit14: + case DW_ExprOp_Lit15: case DW_ExprOp_Lit16: case DW_ExprOp_Lit17: + case DW_ExprOp_Lit18: case DW_ExprOp_Lit19: case DW_ExprOp_Lit20: + case DW_ExprOp_Lit21: case DW_ExprOp_Lit22: case DW_ExprOp_Lit23: + case DW_ExprOp_Lit24: case DW_ExprOp_Lit25: case DW_ExprOp_Lit26: + case DW_ExprOp_Lit27: case DW_ExprOp_Lit28: case DW_ExprOp_Lit29: + case DW_ExprOp_Lit30: case DW_ExprOp_Lit31: { + dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U8, .u8 = inst->opcode - DW_ExprOp_Lit0 }); + } break; - U64 addr = (U64)((S64)reg_value + inst->operands[1].s64); - dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_Addr, .addr = addr}); - } break; - - case DW_ExprOp_FBReg: { - U64 addr = frame_base + inst->operands[0].s64; - dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_Addr, .addr = addr}); - } break; - - case DW_ExprOp_ImplicitValue: { - if (inst->operands[0].block.size <= sizeof(U512)) { - dw_expr_stack_push_unsigned(scratch.arena, stack, inst->operands[0].block.str, inst->operands[0].block.size); - } else { - NotImplemented; - } - } break; - - case DW_ExprOp_Piece: { - B32 is_undefined = stack->count == 0 || (inst->prev && inst->prev->opcode == DW_ExprOp_Piece); - if (is_undefined) { - dw_piece_list_push(arena, &pieces, (DW_Piece){ .kind = DW_PieceKind_Undefined, .bit_size = inst->operands[0].u64 * 8 }); - } else { - DW_ExprValue top = dw_expr_stack_pop(stack); - - String8 value; - - // piece is a memory reference - if (top.type == DW_ExprValueType_Addr) { - U64 value_size = inst->operands[0].u64; - U8 *value_buffer = push_array(arena, U8, value_size); - MachineOpResult read_result = mem_read(top.addr, value_buffer, value_size, mem_read_ud); - if (read_result != MachineOpResult_Ok) { Assert(0 && "failed to read piece memory referece"); goto exit; } + case DW_ExprOp_Const1U: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U8, .u8 = inst->operands[0].u8 }); } break; + case DW_ExprOp_Const2U: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U16, .u16 = inst->operands[0].u16 }); } break; + case DW_ExprOp_Const4U: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U32, .u32 = inst->operands[0].u32 }); } break; + case DW_ExprOp_Const8U: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U64, .u64 = inst->operands[0].u64 }); } break; + case DW_ExprOp_Const1S: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_S8, .s8 = inst->operands[0].s8 }); } break; + case DW_ExprOp_Const2S: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_S16, .s16 = inst->operands[0].s16 }); } break; + case DW_ExprOp_Const4S: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_S32, .s32 = inst->operands[0].s32 }); } break; + case DW_ExprOp_Const8S: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_S64, .s64 = inst->operands[0].s64 }); } break; + case DW_ExprOp_ConstU: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U64, .u64 = inst->operands[0].u64 }); } break; + case DW_ExprOp_ConstS: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_S64, .s64 = inst->operands[0].s64 }); } break; + case DW_ExprOp_Addr: { dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_Addr, .addr = inst->operands[0].u64 }); } break; + + case DW_ExprOp_Reg0: case DW_ExprOp_Reg1: case DW_ExprOp_Reg2: + case DW_ExprOp_Reg3: case DW_ExprOp_Reg4: case DW_ExprOp_Reg5: + case DW_ExprOp_Reg6: case DW_ExprOp_Reg7: case DW_ExprOp_Reg8: + case DW_ExprOp_Reg9: case DW_ExprOp_Reg10: case DW_ExprOp_Reg11: + case DW_ExprOp_Reg12: case DW_ExprOp_Reg13: case DW_ExprOp_Reg14: + case DW_ExprOp_Reg15: case DW_ExprOp_Reg16: case DW_ExprOp_Reg17: + case DW_ExprOp_Reg18: case DW_ExprOp_Reg19: case DW_ExprOp_Reg20: + case DW_ExprOp_Reg21: case DW_ExprOp_Reg22: case DW_ExprOp_Reg23: + case DW_ExprOp_Reg24: case DW_ExprOp_Reg25: case DW_ExprOp_Reg26: + case DW_ExprOp_Reg27: case DW_ExprOp_Reg28: case DW_ExprOp_Reg29: + case DW_ExprOp_Reg30: case DW_ExprOp_Reg31: + { + DW_Reg reg_dw_id = inst->opcode - DW_ExprOp_Reg0; + U64 reg_size = dw_reg_size_from_code(arch, reg_dw_id); + ARCH_RegCode reg_code = arch_reg_code_from_dw(arch, reg_dw_id); + Rng1U16 reg_rng = arch_info->reg_code_rng_table[reg_code]; + U8 *reg_value = push_array(scratch.arena, U8, reg_size); + if(!arch_reg_block_read_range(arch_info, reg_block, r1u16(reg_rng.min, reg_rng.min + reg_size), reg_value)) + { + goto exit; } - // piece is a value - else { - value = dw_string_from_expr_value(arena, arch, top); + dw_expr_stack_push_unsigned(scratch.arena, stack, reg_value, reg_size); + }break; + + case DW_ExprOp_BReg0: case DW_ExprOp_BReg1: case DW_ExprOp_BReg2: + case DW_ExprOp_BReg3: case DW_ExprOp_BReg4: case DW_ExprOp_BReg5: + case DW_ExprOp_BReg6: case DW_ExprOp_BReg7: case DW_ExprOp_BReg8: + case DW_ExprOp_BReg9: case DW_ExprOp_BReg10: case DW_ExprOp_BReg11: + case DW_ExprOp_BReg12: case DW_ExprOp_BReg13: case DW_ExprOp_BReg14: + case DW_ExprOp_BReg15: case DW_ExprOp_BReg16: case DW_ExprOp_BReg17: + case DW_ExprOp_BReg18: case DW_ExprOp_BReg19: case DW_ExprOp_BReg20: + case DW_ExprOp_BReg21: case DW_ExprOp_BReg22: case DW_ExprOp_BReg23: + case DW_ExprOp_BReg24: case DW_ExprOp_BReg25: case DW_ExprOp_BReg26: + case DW_ExprOp_BReg27: case DW_ExprOp_BReg28: case DW_ExprOp_BReg29: + case DW_ExprOp_BReg30: case DW_ExprOp_BReg31: + { + DW_Reg reg_dw_id = inst->opcode - DW_ExprOp_BReg0; + U64 reg_size = dw_reg_size_from_code(arch, reg_dw_id); + ARCH_RegCode reg_code = arch_reg_code_from_dw(arch, reg_dw_id); + Rng1U16 reg_rng = arch_info->reg_code_rng_table[reg_code]; + AssertAlways(reg_size <= byte_size_from_arch(arch)); + + U64 reg_value = 0; + if(!arch_reg_block_read_range(arch_info, reg_block, r1u16(reg_rng.min, reg_rng.min + reg_size), ®_value)) + { + goto exit; } - - if (inst->operands[0].u64 > value.size) { Assert(0 && "out of bounds size in the piece opcode"); goto exit; } - dw_piece_list_push(arena, &pieces, (DW_Piece){ .kind = DW_PieceKind_Value, .bit_size = inst->operands[0].u64 * 8, .value = value.str }); - } - } break; - - case DW_ExprOp_BitPiece: { - B32 is_undefined = stack->count == 0 || (inst->prev && inst->prev->opcode == DW_ExprOp_Piece); - if (is_undefined) { - dw_piece_list_push(arena, &pieces, (DW_Piece){ .kind = DW_PieceKind_Undefined, .bit_size = inst->operands[0].u64 }); - } else { - String8 value; - if (dw_expr_stack_peek(stack).type == DW_ExprValueType_Addr) { - NotImplemented; + + U64 addr = (U64)((S64)reg_value + inst->operands[0].s64); + dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_Addr, .addr = addr}); + }break; + + case DW_ExprOp_RegX: + { + DW_Reg reg_dw_id = inst->operands[0].u64; + U64 reg_size = dw_reg_size_from_code(arch, reg_dw_id); + U8 *reg_value = push_array(scratch.arena, U8, reg_size); + ARCH_RegCode reg_code = arch_reg_code_from_dw(arch, reg_dw_id); + Rng1U16 reg_rng = arch_info->reg_code_rng_table[reg_code]; + if(!arch_reg_block_read_range(arch_info, reg_block, r1u16(reg_rng.min, reg_rng.min + reg_size), reg_value)) + { + goto exit; + } + dw_expr_stack_push_unsigned(scratch.arena, stack, reg_value, reg_size); + }break; + + case DW_ExprOp_BRegX: + { + DW_Reg reg_dw_id = (DW_Reg)inst->operands[0].u64; + U64 reg_size = dw_reg_size_from_code(arch, reg_dw_id); + AssertAlways(reg_size <= byte_size_from_arch(arch)); + ARCH_RegCode reg_code = arch_reg_code_from_dw(arch, reg_dw_id); + Rng1U16 reg_rng = arch_info->reg_code_rng_table[reg_code]; + + U64 reg_value = 0; + if(!arch_reg_block_read_range(arch_info, reg_block, r1u16(reg_rng.min, reg_rng.min + reg_size), ®_value)) + { + goto exit; + } + + U64 addr = (U64)((S64)reg_value + inst->operands[1].s64); + dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_Addr, .addr = addr}); + }break; + + case DW_ExprOp_FBReg: { + U64 addr = frame_base + inst->operands[0].s64; + dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_Addr, .addr = addr}); + } break; + + case DW_ExprOp_ImplicitValue: { + if (inst->operands[0].block.size <= sizeof(U512)) { + dw_expr_stack_push_unsigned(scratch.arena, stack, inst->operands[0].block.str, inst->operands[0].block.size); } else { - value = dw_string_from_expr_value(arena, arch, dw_expr_stack_pop(stack)); + NotImplemented; } - if (inst->operands[0].u64 > value.size * 8) { Assert(0 && "out of bounds size in piece opcode"); goto exit; } - dw_piece_list_push(arena, &pieces, (DW_Piece){ .kind = DW_PieceKind_Value, .bit_size = inst->operands[0].u64, .value = value.str }); + } break; + + case DW_ExprOp_Piece: { + B32 is_undefined = stack->count == 0 || (inst->prev && inst->prev->opcode == DW_ExprOp_Piece); + if (is_undefined) { + dw_piece_list_push(arena, &pieces, (DW_Piece){ .kind = DW_PieceKind_Undefined, .bit_size = inst->operands[0].u64 * 8 }); + } else { + DW_ExprValue top = dw_expr_stack_pop(stack); + + String8 value; + + // piece is a memory reference + if (top.type == DW_ExprValueType_Addr) { + U64 value_size = inst->operands[0].u64; + U8 *value_buffer = push_array(arena, U8, value_size); + MachineOpResult read_result = mem_read(top.addr, value_buffer, value_size, mem_read_ud); + if (read_result != MachineOpResult_Ok) { Assert(0 && "failed to read piece memory referece"); goto exit; } + } + // piece is a value + else { + value = dw_string_from_expr_value(arena, arch, top); + } + + if (inst->operands[0].u64 > value.size) { Assert(0 && "out of bounds size in the piece opcode"); goto exit; } + dw_piece_list_push(arena, &pieces, (DW_Piece){ .kind = DW_PieceKind_Value, .bit_size = inst->operands[0].u64 * 8, .value = value.str }); + } + } break; + + case DW_ExprOp_BitPiece: { + B32 is_undefined = stack->count == 0 || (inst->prev && inst->prev->opcode == DW_ExprOp_Piece); + if (is_undefined) { + dw_piece_list_push(arena, &pieces, (DW_Piece){ .kind = DW_PieceKind_Undefined, .bit_size = inst->operands[0].u64 }); + } else { + String8 value; + if (dw_expr_stack_peek(stack).type == DW_ExprValueType_Addr) { + NotImplemented; + } else { + value = dw_string_from_expr_value(arena, arch, dw_expr_stack_pop(stack)); + } + if (inst->operands[0].u64 > value.size * 8) { Assert(0 && "out of bounds size in piece opcode"); goto exit; } + dw_piece_list_push(arena, &pieces, (DW_Piece){ .kind = DW_PieceKind_Value, .bit_size = inst->operands[0].u64, .value = value.str }); + } + } break; + + case DW_ExprOp_Pick: { + DW_ExprValueNode *src = dw_expr_stack_pick(stack, inst->operands[0].u8); + if (src) { + dw_expr_stack_push(scratch.arena, stack, src->v); + } else { + Assert(0 && "out of bounds stack index"); + goto exit; + } + } break; + + case DW_ExprOp_Over: { + DW_ExprValueNode *src = dw_expr_stack_pick(stack, 1); + if (src) { + dw_expr_stack_push(scratch.arena, stack, src->v); + } else { + Assert(0 && "out of bounds stack index"); + goto exit; + } + } break; + + case DW_ExprOp_PlusUConst: { + DW_ExprValue lhs = dw_expr_stack_pop(stack); + DW_ExprValue rhs = { .type = DW_ExprValueType_U64, .u64 = inst->operands[0].u64 }; + DW_ExprValue sum = dw_expr_add(lhs, rhs); + dw_expr_stack_push(scratch.arena, stack, sum); + } break; + + case DW_ExprOp_Skip: { + DW_ExprInst *i = dw_expr_inst_from_delta(inst, inst->operands[0].s16); + + if (i == 0) { + Assert(0 && "seeking to an invalid offset"); + goto exit; + } + + inst = i; + goto again; } - } break; - - case DW_ExprOp_Pick: { - DW_ExprValueNode *src = dw_expr_stack_pick(stack, inst->operands[0].u8); - if (src) { - dw_expr_stack_push(scratch.arena, stack, src->v); - } else { - Assert(0 && "out of bounds stack index"); - goto exit; + + case DW_ExprOp_Bra: { + DW_ExprValue cond = dw_expr_stack_pop(stack); + + if (cond.type != DW_ExprValueType_S16) { + Assert(0 && "unexpected value"); + goto exit; + } + + DW_ExprInst *i = dw_expr_inst_from_delta(inst, inst->operands[0].s16); + + if (i == 0) { + Assert(0 && "seeking to an invalid offset"); + goto exit; + } + + inst = i; + goto again; } - } break; - - case DW_ExprOp_Over: { - DW_ExprValueNode *src = dw_expr_stack_pick(stack, 1); - if (src) { - dw_expr_stack_push(scratch.arena, stack, src->v); - } else { - Assert(0 && "out of bounds stack index"); - goto exit; - } - } break; - - case DW_ExprOp_PlusUConst: { - DW_ExprValue lhs = dw_expr_stack_pop(stack); - DW_ExprValue rhs = { .type = DW_ExprValueType_U64, .u64 = inst->operands[0].u64 }; - DW_ExprValue sum = dw_expr_add(lhs, rhs); - dw_expr_stack_push(scratch.arena, stack, sum); - } break; - - case DW_ExprOp_Skip: { - DW_ExprInst *i = dw_expr_inst_from_delta(inst, inst->operands[0].s16); - - if (i == 0) { - Assert(0 && "seeking to an invalid offset"); - goto exit; - } - - inst = i; - goto again; - } - - case DW_ExprOp_Bra: { - DW_ExprValue cond = dw_expr_stack_pop(stack); - - if (cond.type != DW_ExprValueType_S16) { - Assert(0 && "unexpected value"); - goto exit; - } - - DW_ExprInst *i = dw_expr_inst_from_delta(inst, inst->operands[0].s16); - - if (i == 0) { - Assert(0 && "seeking to an invalid offset"); - goto exit; - } - - inst = i; - goto again; - } - - case DW_ExprOp_Call2: - case DW_ExprOp_Call4: - case DW_ExprOp_CallRef: { - NotImplemented; - } break; - - case DW_ExprOp_GNU_Convert: - case DW_ExprOp_Convert: { - if (inst->operands[0].u64 == 0) { - DW_ExprValue value = dw_expr_stack_pop(stack); - DW_ExprValue new_value = dw_expr_cast(value, DW_ExprValueType_Generic); - dw_expr_stack_push(scratch.arena, stack, new_value); - } else { + + case DW_ExprOp_Call2: + case DW_ExprOp_Call4: + case DW_ExprOp_CallRef: { NotImplemented; - } - } break; - - case DW_ExprOp_Reinterpret: { - if (inst->operands[0].u64 == 0) { - DW_ExprValue value = dw_expr_stack_pop(stack); - DW_ExprValue new_value = dw_expr_cast(value, DW_ExprValueType_Generic); - dw_expr_stack_push(scratch.arena, stack, new_value); - } else { - NotImplemented; - } - } break; - - case DW_ExprOp_GNU_ParameterRef: { NotImplemented; } break; - case DW_ExprOp_GNU_DerefType: { NotImplemented; } break; - case DW_ExprOp_DerefType: { NotImplemented; } break; - case DW_ExprOp_ConstType: { NotImplemented; } break; - case DW_ExprOp_GNU_ConstType: { NotImplemented; } break; - case DW_ExprOp_RegvalType: { NotImplemented; } break; - - case DW_ExprOp_EntryValue: - case DW_ExprOp_GNU_EntryValue: { - DW_Expr entry_value_expr = dw_expr_from_data(scratch.arena, format, byte_size_from_arch(arch), inst->operands[0].block); - DW_ExprValue entry_value; - result = dw_eval_expr(scratch.arena, arch, format, frame_base, cfa, tls, exec_op_limit, entry_value_expr, reg_read, reg_read_ud, mem_read, mem_read_ud, &entry_value); - if (result != DW_ExprEvalResult_Ok) { goto exit; } - dw_expr_stack_push(scratch.arena, stack, entry_value); - } break; - - case DW_ExprOp_Addrx: { NotImplemented; } break; - - case DW_ExprOp_CallFrameCfa: { - dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U64, .u64 = cfa }); - } break; - - case DW_ExprOp_PushObjectAddress: { NotImplemented; } break; - - case DW_ExprOp_Plus: { dw_expr_stack_push(scratch.arena, stack, dw_expr_add(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Minus: { dw_expr_stack_push(scratch.arena, stack, dw_expr_minus(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Div: { dw_expr_stack_push(scratch.arena, stack, dw_expr_div(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Mul: { dw_expr_stack_push(scratch.arena, stack, dw_expr_mul(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Mod: { dw_expr_stack_push(scratch.arena, stack, dw_expr_mod(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - - case DW_ExprOp_Eq: { dw_expr_stack_push(scratch.arena, stack, dw_expr_eq(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Ge: { dw_expr_stack_push(scratch.arena, stack, dw_expr_ge(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Gt: { dw_expr_stack_push(scratch.arena, stack, dw_expr_gt(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Le: { dw_expr_stack_push(scratch.arena, stack, dw_expr_le(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Lt: { dw_expr_stack_push(scratch.arena, stack, dw_expr_lt(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Ne: { dw_expr_stack_push(scratch.arena, stack, dw_expr_ne(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - - case DW_ExprOp_Xor: { dw_expr_stack_push(scratch.arena, stack, dw_expr_xor(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_And: { dw_expr_stack_push(scratch.arena, stack, dw_expr_and(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Or: { dw_expr_stack_push(scratch.arena, stack, dw_expr_or(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Shl: { dw_expr_stack_push(scratch.arena, stack, dw_expr_shl(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Shr: { dw_expr_stack_push(scratch.arena, stack, dw_expr_shr(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Shra: { dw_expr_stack_push(scratch.arena, stack, dw_expr_shra(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; - - case DW_ExprOp_Abs: { dw_expr_stack_push(scratch.arena, stack, dw_expr_abs(dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Neg: { dw_expr_stack_push(scratch.arena, stack, dw_expr_neg(dw_expr_stack_pop(stack))); } break; - case DW_ExprOp_Not: { dw_expr_stack_push(scratch.arena, stack, dw_expr_not(dw_expr_stack_pop(stack))); } break; - - case DW_ExprOp_Dup: { - dw_expr_stack_push(scratch.arena, stack, dw_expr_stack_peek(stack)); - } break; - - case DW_ExprOp_Rot: { - DW_ExprValue first = dw_expr_stack_pop(stack); - DW_ExprValue second = dw_expr_stack_pop(stack); - DW_ExprValue third = dw_expr_stack_pop(stack); - dw_expr_stack_push(scratch.arena, stack, first); // -> third - dw_expr_stack_push(scratch.arena, stack, third); // -> second - dw_expr_stack_push(scratch.arena, stack, second); // -> first - } break; - - case DW_ExprOp_Swap: { - DW_ExprValue first = dw_expr_stack_pop(stack); - DW_ExprValue second = dw_expr_stack_pop(stack); - dw_expr_stack_push(scratch.arena, stack, first); // -> second - dw_expr_stack_push(scratch.arena, stack, second); // -> first - } break; - - case DW_ExprOp_Drop: { - dw_expr_stack_pop(stack); - } break; - - case DW_ExprOp_Deref: { - DW_ExprValue value = dw_expr_stack_pop(stack); - - // expression must be of an integral type - if (!DW_ExprValueType_IsInt(value.type)) { goto exit; } - - // treat value as an address - DW_ExprValue addr = dw_expr_cast(value, DW_ExprValueType_Addr); - - // read pointer size from the address - U64 addr_size = byte_size_from_arch(arch); - U8 *generic_value = push_array(scratch.arena, U8, addr_size); - MachineOpResult read_result = mem_read(addr.addr, generic_value, addr_size, mem_read_ud); - if (read_result != MachineOpResult_Ok) { goto exit; } - - // push generic data - dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_Generic, .generic = str8(generic_value, addr_size) }); - } break; - - case DW_ExprOp_StackValue: { - stack->top->v.type = dw_expr_unsigned_value_type_from_bit_size(bit_size_from_arch(arch)); - } break; - - case DW_ExprOp_GNU_PushTlsAddress: - case DW_ExprOp_FormTlsAddress: { - DW_ExprValue tls_off = dw_expr_stack_pop(stack); - DW_ExprValue tls_base = { .type = DW_ExprValueType_Addr, .addr = tls }; - DW_ExprValue tls_addr = dw_expr_add(tls_base, tls_off); - dw_expr_stack_push(scratch.arena, stack, tls_addr); - } break; + } break; + + case DW_ExprOp_GNU_Convert: + case DW_ExprOp_Convert: { + if (inst->operands[0].u64 == 0) { + DW_ExprValue value = dw_expr_stack_pop(stack); + DW_ExprValue new_value = dw_expr_cast(value, DW_ExprValueType_Generic); + dw_expr_stack_push(scratch.arena, stack, new_value); + } else { + NotImplemented; + } + } break; + + case DW_ExprOp_Reinterpret: { + if (inst->operands[0].u64 == 0) { + DW_ExprValue value = dw_expr_stack_pop(stack); + DW_ExprValue new_value = dw_expr_cast(value, DW_ExprValueType_Generic); + dw_expr_stack_push(scratch.arena, stack, new_value); + } else { + NotImplemented; + } + } break; + + case DW_ExprOp_GNU_ParameterRef: { NotImplemented; } break; + case DW_ExprOp_GNU_DerefType: { NotImplemented; } break; + case DW_ExprOp_DerefType: { NotImplemented; } break; + case DW_ExprOp_ConstType: { NotImplemented; } break; + case DW_ExprOp_GNU_ConstType: { NotImplemented; } break; + case DW_ExprOp_RegvalType: { NotImplemented; } break; + + case DW_ExprOp_EntryValue: + case DW_ExprOp_GNU_EntryValue: + { + DW_Expr entry_value_expr = dw_expr_from_data(scratch.arena, format, byte_size_from_arch(arch), inst->operands[0].block); + DW_ExprValue entry_value; + result = dw_eval_expr(scratch.arena, arch, format, frame_base, cfa, tls, exec_op_limit, entry_value_expr, reg_block, mem_read, mem_read_ud, &entry_value); + if (result != DW_ExprEvalResult_Ok) { goto exit; } + dw_expr_stack_push(scratch.arena, stack, entry_value); + } break; + + case DW_ExprOp_Addrx: { NotImplemented; } break; + + case DW_ExprOp_CallFrameCfa: { + dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_U64, .u64 = cfa }); + } break; + + case DW_ExprOp_PushObjectAddress: { NotImplemented; } break; + + case DW_ExprOp_Plus: { dw_expr_stack_push(scratch.arena, stack, dw_expr_add(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Minus: { dw_expr_stack_push(scratch.arena, stack, dw_expr_minus(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Div: { dw_expr_stack_push(scratch.arena, stack, dw_expr_div(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Mul: { dw_expr_stack_push(scratch.arena, stack, dw_expr_mul(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Mod: { dw_expr_stack_push(scratch.arena, stack, dw_expr_mod(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + + case DW_ExprOp_Eq: { dw_expr_stack_push(scratch.arena, stack, dw_expr_eq(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Ge: { dw_expr_stack_push(scratch.arena, stack, dw_expr_ge(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Gt: { dw_expr_stack_push(scratch.arena, stack, dw_expr_gt(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Le: { dw_expr_stack_push(scratch.arena, stack, dw_expr_le(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Lt: { dw_expr_stack_push(scratch.arena, stack, dw_expr_lt(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Ne: { dw_expr_stack_push(scratch.arena, stack, dw_expr_ne(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + + case DW_ExprOp_Xor: { dw_expr_stack_push(scratch.arena, stack, dw_expr_xor(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_And: { dw_expr_stack_push(scratch.arena, stack, dw_expr_and(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Or: { dw_expr_stack_push(scratch.arena, stack, dw_expr_or(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Shl: { dw_expr_stack_push(scratch.arena, stack, dw_expr_shl(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Shr: { dw_expr_stack_push(scratch.arena, stack, dw_expr_shr(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Shra: { dw_expr_stack_push(scratch.arena, stack, dw_expr_shra(dw_expr_stack_pop(stack), dw_expr_stack_pop(stack))); } break; + + case DW_ExprOp_Abs: { dw_expr_stack_push(scratch.arena, stack, dw_expr_abs(dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Neg: { dw_expr_stack_push(scratch.arena, stack, dw_expr_neg(dw_expr_stack_pop(stack))); } break; + case DW_ExprOp_Not: { dw_expr_stack_push(scratch.arena, stack, dw_expr_not(dw_expr_stack_pop(stack))); } break; + + case DW_ExprOp_Dup: { + dw_expr_stack_push(scratch.arena, stack, dw_expr_stack_peek(stack)); + } break; + + case DW_ExprOp_Rot: { + DW_ExprValue first = dw_expr_stack_pop(stack); + DW_ExprValue second = dw_expr_stack_pop(stack); + DW_ExprValue third = dw_expr_stack_pop(stack); + dw_expr_stack_push(scratch.arena, stack, first); // -> third + dw_expr_stack_push(scratch.arena, stack, third); // -> second + dw_expr_stack_push(scratch.arena, stack, second); // -> first + } break; + + case DW_ExprOp_Swap: { + DW_ExprValue first = dw_expr_stack_pop(stack); + DW_ExprValue second = dw_expr_stack_pop(stack); + dw_expr_stack_push(scratch.arena, stack, first); // -> second + dw_expr_stack_push(scratch.arena, stack, second); // -> first + } break; + + case DW_ExprOp_Drop: { + dw_expr_stack_pop(stack); + } break; + + case DW_ExprOp_Deref: { + DW_ExprValue value = dw_expr_stack_pop(stack); + + // expression must be of an integral type + if (!DW_ExprValueType_IsInt(value.type)) { goto exit; } + + // treat value as an address + DW_ExprValue addr = dw_expr_cast(value, DW_ExprValueType_Addr); + + // read pointer size from the address + U64 addr_size = byte_size_from_arch(arch); + U8 *generic_value = push_array(scratch.arena, U8, addr_size); + MachineOpResult read_result = mem_read(addr.addr, generic_value, addr_size, mem_read_ud); + if (read_result != MachineOpResult_Ok) { goto exit; } + + // push generic data + dw_expr_stack_push(scratch.arena, stack, (DW_ExprValue){ .type = DW_ExprValueType_Generic, .generic = str8(generic_value, addr_size) }); + } break; + + case DW_ExprOp_StackValue: { + stack->top->v.type = dw_expr_unsigned_value_type_from_bit_size(bit_size_from_arch(arch)); + } break; + + case DW_ExprOp_GNU_PushTlsAddress: + case DW_ExprOp_FormTlsAddress: { + DW_ExprValue tls_off = dw_expr_stack_pop(stack); + DW_ExprValue tls_base = { .type = DW_ExprValueType_Addr, .addr = tls }; + DW_ExprValue tls_addr = dw_expr_add(tls_base, tls_off); + dw_expr_stack_push(scratch.arena, stack, tls_addr); + } break; } } - + // composite value if (pieces.count > 0) { #if 0 @@ -1507,7 +1521,7 @@ dw_eval_expr(Arena *arena, for EachNode (n, DW_PieceNode, pieces.first) { total_bit_size += n->v.bit_size; } - + U64 value_size = CeilIntegerDiv(total_bit_size, 8); U8 *value = push_array(arena, U8, value_size); Rng1U64 *ranges = push_array(arena, Rng1U64, pieces.count); @@ -1533,7 +1547,7 @@ dw_eval_expr(Arena *arena, } piece_cursor += n->v.bit_size; } - + value_out->type = DW_ExprValueType_Generic; value_out->ranges = (Rng1U64Array){ .count = pieces.count, .v = ranges }; value_out->offsets = offsets; @@ -1549,7 +1563,7 @@ dw_eval_expr(Arena *arena, if (value_out->type == DW_ExprValueType_Generic) { value_out->generic = push_str8_copy(arena, value_out->generic); } - + Rng1U64 *range = push_array(arena, Rng1U64, 1); *range = r1u64(0, max_U64); value_out->ranges = (Rng1U64Array){ .count = 1, .v = range }; @@ -1558,9 +1572,9 @@ dw_eval_expr(Arena *arena, MemoryZeroStruct(value_out); } } - + result = DW_ExprEvalResult_Ok; -exit:; + exit:; scratch_end(scratch); return result; } @@ -1569,90 +1583,90 @@ internal String8 dw_encode_expr(Arena *arena, Arch arch, DW_Format format, DW_ExprEnc *encs, U64 encs_count) { Temp scratch = scratch_begin(&arena, 1); - + String8List *srl = push_array(scratch.arena, String8List, 1); str8_serial_begin(scratch.arena, srl); - + HashTable *label_map = hash_table_init(scratch.arena, 128); - + struct Fixup { U64 offset; String8 label; struct Fixup *next; }; struct Fixup *first_fixup = 0, *last_fixup = 0; - + for EachIndex(i, encs_count) { DW_ExprEnc *e = &encs[i]; - + switch (e->type) { - case DW_ExprEncType_Null: {} break; - case DW_ExprEncType_Op: { - str8_serial_push_struct(scratch.arena, srl, &e->op); - } break; - case DW_ExprEncType_U8: { - str8_serial_push_struct(scratch.arena, srl, &e->u8); - } break; - case DW_ExprEncType_U16: { - str8_serial_push_struct(scratch.arena, srl, &e->u16); - } break; - case DW_ExprEncType_U32: { - str8_serial_push_struct(scratch.arena, srl, &e->u32); - } break; - case DW_ExprEncType_U64: { - str8_serial_push_struct(scratch.arena, srl, &e->u64); - } break; - case DW_ExprEncType_S8: { - str8_serial_push_struct(scratch.arena, srl, &e->s8); - } break; - case DW_ExprEncType_S16: { - str8_serial_push_struct(scratch.arena, srl, &e->s16); - } break; - case DW_ExprEncType_S32: { - str8_serial_push_struct(scratch.arena, srl, &e->s32); - } break; - case DW_ExprEncType_S64: { - str8_serial_push_struct(scratch.arena, srl, &e->s64); - } break; - case DW_ExprEncType_ULEB128: { - str8_serial_push_string(scratch.arena, srl, dw_write_uleb128(scratch.arena, e->u64)); - } break; - case DW_ExprEncType_SLEB128: { - str8_serial_push_string(scratch.arena, srl, dw_write_sleb128(scratch.arena, e->s64)); - } break; - case DW_ExprEncType_Addr: { - U64 addr_size = byte_size_from_arch(arch); - Assert(addr_size <= sizeof(e->addr)); - str8_serial_push_string(scratch.arena, srl, str8((U8 *)&e->addr, addr_size)); - } break; - case DW_ExprEncType_Block: { - Assert(e->block.size <= max_U8); - str8_serial_push_u8(scratch.arena, srl, (U8)e->block.size); - str8_serial_push_string(scratch.arena, srl, e->block); - } break; - case DW_ExprEncType_DwarfUInt: { - switch (format) { - case DW_Format_Null: {} break; - case DW_Format_32Bit: { str8_serial_push_u32(scratch.arena, srl, e->u32); } break; - case DW_Format_64Bit: { str8_serial_push_u64(scratch.arena, srl, e->u64); } break; + case DW_ExprEncType_Null: {} break; + case DW_ExprEncType_Op: { + str8_serial_push_struct(scratch.arena, srl, &e->op); + } break; + case DW_ExprEncType_U8: { + str8_serial_push_struct(scratch.arena, srl, &e->u8); + } break; + case DW_ExprEncType_U16: { + str8_serial_push_struct(scratch.arena, srl, &e->u16); + } break; + case DW_ExprEncType_U32: { + str8_serial_push_struct(scratch.arena, srl, &e->u32); + } break; + case DW_ExprEncType_U64: { + str8_serial_push_struct(scratch.arena, srl, &e->u64); + } break; + case DW_ExprEncType_S8: { + str8_serial_push_struct(scratch.arena, srl, &e->s8); + } break; + case DW_ExprEncType_S16: { + str8_serial_push_struct(scratch.arena, srl, &e->s16); + } break; + case DW_ExprEncType_S32: { + str8_serial_push_struct(scratch.arena, srl, &e->s32); + } break; + case DW_ExprEncType_S64: { + str8_serial_push_struct(scratch.arena, srl, &e->s64); + } break; + case DW_ExprEncType_ULEB128: { + str8_serial_push_string(scratch.arena, srl, dw_write_uleb128(scratch.arena, e->u64)); + } break; + case DW_ExprEncType_SLEB128: { + str8_serial_push_string(scratch.arena, srl, dw_write_sleb128(scratch.arena, e->s64)); + } break; + case DW_ExprEncType_Addr: { + U64 addr_size = byte_size_from_arch(arch); + Assert(addr_size <= sizeof(e->addr)); + str8_serial_push_string(scratch.arena, srl, str8((U8 *)&e->addr, addr_size)); + } break; + case DW_ExprEncType_Block: { + Assert(e->block.size <= max_U8); + str8_serial_push_u8(scratch.arena, srl, (U8)e->block.size); + str8_serial_push_string(scratch.arena, srl, e->block); + } break; + case DW_ExprEncType_DwarfUInt: { + switch (format) { + case DW_Format_Null: {} break; + case DW_Format_32Bit: { str8_serial_push_u32(scratch.arena, srl, e->u32); } break; + case DW_Format_64Bit: { str8_serial_push_u64(scratch.arena, srl, e->u64); } break; + default: { InvalidPath; } break; + } + } break; + case DW_ExprEncType_Label: { + struct Fixup *fixup = push_array(scratch.arena, struct Fixup, 1); + fixup->offset = srl->total_size; + fixup->label = e->label; + SLLQueuePush(first_fixup, last_fixup, fixup); + + S16 delta_placeholder = 0; + str8_serial_push_struct(scratch.arena, srl, &delta_placeholder); + } break; + case DW_ExprEncType_DeclLabel: { + hash_table_push_string_u64(scratch.arena, label_map, e->label, srl->total_size); + } break; default: { InvalidPath; } break; - } - } break; - case DW_ExprEncType_Label: { - struct Fixup *fixup = push_array(scratch.arena, struct Fixup, 1); - fixup->offset = srl->total_size; - fixup->label = e->label; - SLLQueuePush(first_fixup, last_fixup, fixup); - - S16 delta_placeholder = 0; - str8_serial_push_struct(scratch.arena, srl, &delta_placeholder); - } break; - case DW_ExprEncType_DeclLabel: { - hash_table_push_string_u64(scratch.arena, label_map, e->label, srl->total_size); - } break; - default: { InvalidPath; } break; } } - + // finalize expression String8 expr = str8_serial_end(arena, srl); - + // apply fixups for EachNode(fixup, struct Fixup, first_fixup) { U64 label_offset; @@ -1660,14 +1674,14 @@ dw_encode_expr(Arena *arena, Arch arch, DW_Format format, DW_ExprEnc *encs, U64 Assert(0 && "undefined label"); continue; } - + S64 delta = (S64)label_offset - (S64)fixup->offset; AssertAlways(min_S16 <= delta && delta <= max_S16); - + S16 *delta_ptr = (S16 *)(expr.str + fixup->offset); *delta_ptr = delta; } - + scratch_end(scratch); return expr; } diff --git a/src/dwarf/dwarf_expr.h b/src/dwarf/dwarf_expr.h index 4cc52f8b..7e8e74d7 100644 --- a/src/dwarf/dwarf_expr.h +++ b/src/dwarf/dwarf_expr.h @@ -227,7 +227,7 @@ internal DW_ExprValueNode * dw_expr_stack_pick(DW_ExprStack *stack, U64 idx); internal String8 dw_string_from_expr_value(Arena *arena, U64 addr_size, DW_ExprValue v); // evaluator -internal DW_ExprEvalResult dw_eval_expr(Arena *arena, Arch arch, DW_Format format, U64 frame_base, U64 cfa, U64 tls_base, U64 op_limit, DW_Expr expr, MachineOp_RegRead *reg_read, void *reg_read_ud, MachineOp_MemRead *mem_read, void *mem_read_ud, DW_ExprValue *value_out); +internal DW_ExprEvalResult dw_eval_expr(Arena *arena, Arch arch, DW_Format format, U64 frame_base, U64 cfa, U64 tls_base, U64 op_limit, DW_Expr expr, void *reg_block, MachineOp_MemRead *mem_read, void *mem_read_ud, DW_ExprValue *value_out); // encoder internal String8 dw_encode_expr(Arena *arena, Arch arch, DW_Format format, DW_ExprEnc *encs, U64 encs_count); diff --git a/src/dwarf/dwarf_inc.c b/src/dwarf/dwarf_inc.c index e090fb48..e6bfc490 100644 --- a/src/dwarf/dwarf_inc.c +++ b/src/dwarf/dwarf_inc.c @@ -13,3 +13,6 @@ #include "dwarf/dwarf_parse_2.c" #include "dwarf/eh_frame.c" #include "dwarf/eh_dump.c" +#if defined(X64_H) +# include "dwarf/x64/dwarf_x64.c" +#endif diff --git a/src/dwarf/dwarf_inc.h b/src/dwarf/dwarf_inc.h index 325c6034..fa551f62 100644 --- a/src/dwarf/dwarf_inc.h +++ b/src/dwarf/dwarf_inc.h @@ -16,5 +16,8 @@ #include "dwarf/dwarf_parse_2.h" #include "dwarf/eh_frame.h" #include "dwarf/eh_dump.h" +#if defined(X64_H) +# include "dwarf/x64/dwarf_x64.h" +#endif #endif // DWARF_INC_H diff --git a/src/dwarf/dwarf_parse_2.c b/src/dwarf/dwarf_parse_2.c index 7a45cbde..39ee4e1f 100644 --- a/src/dwarf/dwarf_parse_2.c +++ b/src/dwarf/dwarf_parse_2.c @@ -56,6 +56,43 @@ dw2_read_fmt_u64(String8 data, U64 off, DW_Format format, U64 *out) return bytes_read; } +//////////////////////////////// +//~ rjf: Unit Range Set Parsing (Top-Level .debug_info, .debug_aranges) + +internal Rng1U64Array +dw2_unit_ranges_from_data(Arena *arena, String8 data) +{ + Temp scratch = scratch_begin(&arena, 1); + Rng1U64List unit_range_list = {0}; + for(U64 off = 0; off < data.size;) + { + U64 start_off = off; + + // rjf: read next unit size + U64 unit_size = 0; + U64 unit_size_size = dw2_read_initial_length(data, off, &unit_size, 0); + + // rjf: push + if(unit_size > 0) + { + rng1u64_list_push(scratch.arena, &unit_range_list, r1u64(off, off + unit_size_size + unit_size)); + } + + // rjf: advance + off += unit_size_size; + off += unit_size; + + // rjf: break if no movement + if(off == start_off) + { + break; + } + } + Rng1U64Array result = rng1u64_array_from_list(arena, &unit_range_list); + scratch_end(scratch); + return result; +} + //////////////////////////////// //~ rjf: Unit Header Parsing diff --git a/src/dwarf/dwarf_parse_2.h b/src/dwarf/dwarf_parse_2.h index 533698cc..3687c3f4 100644 --- a/src/dwarf/dwarf_parse_2.h +++ b/src/dwarf/dwarf_parse_2.h @@ -240,6 +240,11 @@ global read_only DW2_Attrib dw2_attrib_nil = {0}; internal U64 dw2_read_initial_length(String8 data, U64 off, U64 *out, DW_Format *fmt_out); internal U64 dw2_read_fmt_u64(String8 data, U64 off, DW_Format format, U64 *out); +//////////////////////////////// +//~ rjf: Unit Range Set Parsing (Top-Level .debug_info, .debug_aranges) + +internal Rng1U64Array dw2_unit_ranges_from_data(Arena *arena, String8 data); + //////////////////////////////// //~ rjf: Unit Header Parsing diff --git a/src/dwarf/dwarf_unwind.c b/src/dwarf/dwarf_unwind.c index d0130373..9bb808bb 100644 --- a/src/dwarf/dwarf_unwind.c +++ b/src/dwarf/dwarf_unwind.c @@ -36,7 +36,7 @@ dw_cfi_unwind_init(Arena *arena, void *decode_ptr_ud) { Temp scratch = scratch_begin(&arena, 1); - + DW_CFI_Unwind *uw = push_array(arena, DW_CFI_Unwind, 1); uw->insts = dw_parse_cfa_inst_list(arena, fde->insts, cie->code_align_factor, cie->data_align_factor, decode_ptr_func, decode_ptr_ud); uw->cie = cie; @@ -44,7 +44,7 @@ dw_cfi_unwind_init(Arena *arena, uw->pc = fde->pc_range.min; uw->arch = arch; uw->reg_count = dw_reg_count_from_arch(arch); - + // setup initial register rules DW_CFA_InstList initial_insts = dw_parse_cfa_inst_list(scratch.arena, cie->insts, cie->code_align_factor, cie->data_align_factor, decode_ptr_func, decode_ptr_ud); uw->row = dw_make_cfi_row(arena, uw->reg_count); @@ -52,12 +52,12 @@ dw_cfi_unwind_init(Arena *arena, if (!dw_cfi_next_row(arena, uw)) { AssertAlways(0 && "unable to interpret initial row instructions"); } - + // make first row from initial rules uw->initial_row = uw->row; uw->row = dw_copy_cfi_row(arena, uw->initial_row, uw->reg_count); uw->curr_inst = uw->insts.first; - + scratch_end(scratch); return uw; } @@ -67,7 +67,7 @@ dw_cfi_next_row(Arena *arena, DW_CFI_Unwind *uw) { B32 is_row_valid = 0; DW_CFA_InstNode *row_inst = uw->curr_inst; - + // skip leading nops while (uw->curr_inst) { if (uw->curr_inst->v.opcode != DW_CFA_Nop) { @@ -75,10 +75,10 @@ dw_cfi_next_row(Arena *arena, DW_CFI_Unwind *uw) } uw->curr_inst = uw->curr_inst->next; } - + while (uw->curr_inst) { DW_CFA_Inst *inst = &uw->curr_inst->v; - + // validate register operands DW_CFA_OperandType *operand_types = dw_operand_types_from_cfa_op(inst->opcode); U64 operand_count = dw_operand_count_from_cfa_opcode(inst->opcode); @@ -89,113 +89,113 @@ dw_cfi_next_row(Arena *arena, DW_CFI_Unwind *uw) } } } - + switch (inst->opcode) { - // Row Creation Instructions - case DW_CFA_SetLoc: { - uw->pc = inst->operands[0].u64; - } break; - case DW_CFA_AdvanceLoc: - case DW_CFA_AdvanceLoc1: - case DW_CFA_AdvanceLoc2: - case DW_CFA_AdvanceLoc4: { - uw->pc += inst->operands[0].u64; - } break; - - // CFA Definition Instructions - case DW_CFA_DefCfa: - case DW_CFA_DefCfaSf: { - U64 reg = inst->operands[0].u64; - S64 off = inst->operands[1].s64; - uw->row->cfa.rule = DW_CFA_Rule_RegOff; - uw->row->cfa.reg = reg; - uw->row->cfa.off = off; - } break; - case DW_CFA_DefCfaRegister: { - // TODO: report error: this operation is valid only if the current CFA rule is defined to register+offset - if (uw->row->cfa.rule != DW_CFA_Rule_RegOff) { goto exit; } - U64 reg = inst->operands[0].u64; - uw->row->cfa.reg = reg; - } break; - case DW_CFA_DefCfaOffset: - case DW_CFA_DefCfaOffsetSf: { - // TODO: report error: this operation is valid only if the current CFA rule is defined to register+offset - if (uw->row->cfa.rule != DW_CFA_Rule_RegOff) { goto exit; } - uw->row->cfa.off = inst->operands[0].s64; - } break; - case DW_CFA_DefCfaExpr: { - uw->row->cfa.rule = DW_CFA_Rule_Expression; - uw->row->cfa.expr = inst->operands[0].block; - } break; - - // Register Rule Instructions - case DW_CFA_Undefined: { - U64 reg = inst->operands[0].u64; - uw->row->regs[reg].rule = DW_CFI_RegisterRule_Undefined; - } break; - case DW_CFA_SameValue: { - U64 reg = inst->operands[0].u64; - uw->row->regs[reg].rule = DW_CFI_RegisterRule_SameValue; - } break; - case DW_CFA_Offset: - case DW_CFA_OffsetExt: - case DW_CFA_OffsetExtSf: { - U64 reg = inst->operands[0].u64; - uw->row->regs[reg].rule = DW_CFI_RegisterRule_Offset; - uw->row->regs[reg].n = inst->operands[1].s64; - } break; - case DW_CFA_ValOffset: - case DW_CFA_ValOffsetSf: { - U64 reg = inst->operands[0].u64; - uw->row->regs[reg].rule = DW_CFI_RegisterRule_ValOffset; - uw->row->regs[reg].n = inst->operands[1].s64; - } break; - case DW_CFA_Register: { - U64 reg = inst->operands[0].u64; - uw->row->regs[reg].rule = DW_CFI_RegisterRule_Register; - uw->row->regs[reg].n = inst->operands[1].s64; - } break; - case DW_CFA_Expr: { - U64 reg = inst->operands[0].u64; - uw->row->regs[reg].rule = DW_CFI_RegisterRule_Expression; - uw->row->regs[reg].expr = inst->operands[1].block; - } break; - case DW_CFA_ValExpr: { - U64 reg = inst->operands[0].u64; - uw->row->regs[reg].rule = DW_CFI_RegisterRule_ValExpression; - uw->row->regs[reg].expr = inst->operands[1].block; - } break; - case DW_CFA_Restore: - case DW_CFA_RestoreExt: { - U64 reg = inst->operands[0].u64; - uw->row->regs[reg] = uw->initial_row->regs[reg]; - } break; + // Row Creation Instructions + case DW_CFA_SetLoc: { + uw->pc = inst->operands[0].u64; + } break; + case DW_CFA_AdvanceLoc: + case DW_CFA_AdvanceLoc1: + case DW_CFA_AdvanceLoc2: + case DW_CFA_AdvanceLoc4: { + uw->pc += inst->operands[0].u64; + } break; - // Row State Instructions - case DW_CFA_RememberState: { - DW_CFI_Row *new_row = dw_copy_cfi_row(arena, uw->row, uw->reg_count); - SLLStackPush(uw->row, new_row); - } break; - case DW_CFA_RestoreState: { - if (uw->row == 0) { goto exit; } // TODO: report error: unbalanced number of pushes and pops - DW_CFI_Row *free_row = uw->row; - SLLStackPop(uw->row); - SLLStackPush(uw->free_rows, free_row); - } break; - - case DW_CFA_Nop: {} break; - - default: { NotImplemented; } break; // TODO: report error: unknown CFA opcode + // CFA Definition Instructions + case DW_CFA_DefCfa: + case DW_CFA_DefCfaSf: { + U64 reg = inst->operands[0].u64; + S64 off = inst->operands[1].s64; + uw->row->cfa.rule = DW_CFA_Rule_RegOff; + uw->row->cfa.reg = reg; + uw->row->cfa.off = off; + } break; + case DW_CFA_DefCfaRegister: { + // TODO: report error: this operation is valid only if the current CFA rule is defined to register+offset + if (uw->row->cfa.rule != DW_CFA_Rule_RegOff) { goto exit; } + U64 reg = inst->operands[0].u64; + uw->row->cfa.reg = reg; + } break; + case DW_CFA_DefCfaOffset: + case DW_CFA_DefCfaOffsetSf: { + // TODO: report error: this operation is valid only if the current CFA rule is defined to register+offset + if (uw->row->cfa.rule != DW_CFA_Rule_RegOff) { goto exit; } + uw->row->cfa.off = inst->operands[0].s64; + } break; + case DW_CFA_DefCfaExpr: { + uw->row->cfa.rule = DW_CFA_Rule_Expression; + uw->row->cfa.expr = inst->operands[0].block; + } break; + + // Register Rule Instructions + case DW_CFA_Undefined: { + U64 reg = inst->operands[0].u64; + uw->row->regs[reg].rule = DW_CFI_RegisterRule_Undefined; + } break; + case DW_CFA_SameValue: { + U64 reg = inst->operands[0].u64; + uw->row->regs[reg].rule = DW_CFI_RegisterRule_SameValue; + } break; + case DW_CFA_Offset: + case DW_CFA_OffsetExt: + case DW_CFA_OffsetExtSf: { + U64 reg = inst->operands[0].u64; + uw->row->regs[reg].rule = DW_CFI_RegisterRule_Offset; + uw->row->regs[reg].n = inst->operands[1].s64; + } break; + case DW_CFA_ValOffset: + case DW_CFA_ValOffsetSf: { + U64 reg = inst->operands[0].u64; + uw->row->regs[reg].rule = DW_CFI_RegisterRule_ValOffset; + uw->row->regs[reg].n = inst->operands[1].s64; + } break; + case DW_CFA_Register: { + U64 reg = inst->operands[0].u64; + uw->row->regs[reg].rule = DW_CFI_RegisterRule_Register; + uw->row->regs[reg].n = inst->operands[1].s64; + } break; + case DW_CFA_Expr: { + U64 reg = inst->operands[0].u64; + uw->row->regs[reg].rule = DW_CFI_RegisterRule_Expression; + uw->row->regs[reg].expr = inst->operands[1].block; + } break; + case DW_CFA_ValExpr: { + U64 reg = inst->operands[0].u64; + uw->row->regs[reg].rule = DW_CFI_RegisterRule_ValExpression; + uw->row->regs[reg].expr = inst->operands[1].block; + } break; + case DW_CFA_Restore: + case DW_CFA_RestoreExt: { + U64 reg = inst->operands[0].u64; + uw->row->regs[reg] = uw->initial_row->regs[reg]; + } break; + + // Row State Instructions + case DW_CFA_RememberState: { + DW_CFI_Row *new_row = dw_copy_cfi_row(arena, uw->row, uw->reg_count); + SLLStackPush(uw->row, new_row); + } break; + case DW_CFA_RestoreState: { + if (uw->row == 0) { goto exit; } // TODO: report error: unbalanced number of pushes and pops + DW_CFI_Row *free_row = uw->row; + SLLStackPop(uw->row); + SLLStackPush(uw->free_rows, free_row); + } break; + + case DW_CFA_Nop: {} break; + + default: { NotImplemented; } break; // TODO: report error: unknown CFA opcode } - + uw->curr_inst = uw->curr_inst->next; if (uw->curr_inst) { if (dw_is_new_row_cfa_opcode(uw->curr_inst->v.opcode)) { break; } } } - + is_row_valid = row_inst != 0; -exit:; + exit:; return is_row_valid; } @@ -203,7 +203,7 @@ internal DW_CFI_Row * dw_cfi_row_from_pc(Arena *arena, Arch arch, DW_CIE *cie, DW_FDE *fde, DW_DecodePtr *decode_ptr_func, void *decode_ptr_ctx, U64 pc) { Temp scratch = scratch_begin(&arena, 1); - + B32 is_row_found = 0; U64 reg_count = dw_reg_count_from_arch(arch); DW_CFI_Unwind *uw = dw_cfi_unwind_init(scratch.arena, arch, cie, fde, decode_ptr_func, decode_ptr_ctx); @@ -217,7 +217,7 @@ dw_cfi_row_from_pc(Arena *arena, Arch arch, DW_CIE *cie, DW_FDE *fde, DW_DecodeP dw_memcpy_cfi_row(row, uw->row, uw->reg_count); prev_pc = uw->pc; } - + // handle last row if (!is_row_found) { if (contains_1u64(fde->pc_range, pc)) { @@ -225,116 +225,138 @@ dw_cfi_row_from_pc(Arena *arena, Arch arch, DW_CIE *cie, DW_FDE *fde, DW_DecodeP is_row_found = 1; } } - + // copy out final row DW_CFI_Row *result = 0; if (is_row_found) { result = dw_copy_cfi_row(arena, row, reg_count); } - + scratch_end(scratch); return result; } internal MachineOpResult -dw_compute_cfa(Arch arch, - DW_CFI_Row *row, - MachineOp_MemRead *mem_read_func, void *mem_read_ud, - MachineOp_RegRead *reg_read_func, void *reg_read_ud, - U64 *cfa_out) +dw_compute_cfa(Arch arch, DW_CFI_Row *row, void *reg_block, MachineOp_MemRead *mem_read_func, void *mem_read_ud, U64 *cfa_out) { MachineOpResult unwind_status = MachineOpResult_Fail; - - switch (row->cfa.rule) { - case DW_CFA_Rule_Null: break; - case DW_CFA_Rule_RegOff: { - // TODO: report error (invalid register read) - U64 cfa_reg_value = 0; - U64 reg_size = dw_reg_size_from_code(arch, row->cfa.reg); - AssertAlways(reg_size <= sizeof(cfa_reg_value)); - unwind_status = reg_read_func(row->cfa.reg, &cfa_reg_value, reg_size, reg_read_ud); - if (unwind_status != MachineOpResult_Ok) { break; } - *cfa_out = cfa_reg_value + row->cfa.off; - } break; - case DW_CFA_Rule_Expression: { - // TODO: evaluate expression - NotImplemented; - } break; + ARCH_Info *arch_info = arch_info_from_arch(arch); + switch(row->cfa.rule) + { + case DW_CFA_Rule_Null:{}break; + case DW_CFA_Rule_RegOff: + { + // TODO: report error (invalid register read) + U64 cfa_reg_value = 0; + U64 reg_size = dw_reg_size_from_code(arch, row->cfa.reg); + AssertAlways(reg_size <= sizeof(cfa_reg_value)); + ARCH_RegCode reg_code = arch_reg_code_from_dw(arch, row->cfa.reg); + Rng1U16 reg_rng = arch_info->reg_code_rng_table[reg_code]; + if(!arch_reg_block_read_range(arch_info, reg_block, reg_rng, &cfa_reg_value)) + { + unwind_status = MachineOpResult_Fail; + break; + } + *cfa_out = cfa_reg_value + row->cfa.off; + }break; + case DW_CFA_Rule_Expression: + { + // TODO: evaluate expression + NotImplemented; + }break; } - return unwind_status; } internal MachineOpResult -dw_cfi_apply_register_rules(Arch arch, - U64 cfa, - DW_CFI_Row *row, - MachineOp_MemRead *mem_read_func, void *mem_read_ud, - MachineOp_RegRead *reg_read_func, void *reg_read_ud, - MachineOp_RegWrite *reg_write_func, void *reg_write_ud) +dw_cfi_apply_register_rules(Arch arch, U64 cfa, DW_CFI_Row *row, void *reg_block, MachineOp_MemRead *mem_read_func, void *mem_read_ud) { Temp scratch = scratch_begin(0,0); MachineOpResult unwind_status = MachineOpResult_Ok; - + + ARCH_Info *arch_info = arch_info_from_arch(arch); + U64 max_reg_size = dw_reg_max_size_from_arch(arch); void *reg_buffer = push_array(scratch.arena, U8, max_reg_size); - + U64 reg_count = dw_reg_count_from_arch(arch); - for EachIndex(reg_idx, reg_count) { + for EachIndex(reg_idx, reg_count) + { DW_CFI_Register *reg = &row->regs[reg_idx]; - switch (reg->rule) { - case DW_CFI_RegisterRule_Undefined: {} break; - case DW_CFI_RegisterRule_SameValue: {} break; - case DW_CFI_RegisterRule_Offset: { - // read register value from memory - U64 addr = cfa + reg->n; - U64 reg_size = dw_reg_size_from_code(arch, reg_idx); - unwind_status = mem_read_func(addr, reg_buffer, reg_size, mem_read_ud); - if (unwind_status != MachineOpResult_Ok) { goto exit; } - - // write register value to the thread context - unwind_status = reg_write_func(reg_idx, reg_buffer, reg_size, reg_write_ud); - if (unwind_status != MachineOpResult_Ok) { goto exit; } - } break; - case DW_CFI_RegisterRule_ValOffset: { - // compute register value - U64 reg_value = cfa + reg->n; - - // write register value to the thread context - U64 reg_size = dw_reg_size_from_code(arch, reg_idx); - unwind_status = reg_write_func(reg_idx, ®_value, reg_size, reg_write_ud); - if (unwind_status != MachineOpResult_Ok) { goto exit; } - } break; - case DW_CFI_RegisterRule_Register: { - // read register value from another register - U64 reg_size = dw_reg_size_from_code(arch, reg_idx); - unwind_status = reg_read_func(reg->n, reg_buffer, reg_size, reg_read_ud); - if (unwind_status != MachineOpResult_Ok) { goto exit; } - - // write register value to the thread context - unwind_status = reg_write_func(reg_idx, reg_buffer, reg_size, reg_write_ud); - if (unwind_status != MachineOpResult_Ok) { goto exit; } - } break; - case DW_CFI_RegisterRule_Expression: { - // TODO: evaluate expression - NotImplemented; - } break; - case DW_CFI_RegisterRule_ValExpression: { - // TODO: evaluate expression - NotImplemented; - } break; - case DW_CFI_RegisterRule_Architectural: { - NotImplemented; - } break; - default: { InvalidPath; } break; + ARCH_RegCode reg_code = arch_reg_code_from_dw(arch, reg_idx); + Rng1U16 reg_rng = arch_info->reg_code_rng_table[reg_code]; + switch(reg->rule) + { + default:{}break; + case DW_CFI_RegisterRule_Undefined: {} break; + case DW_CFI_RegisterRule_SameValue: {} break; + case DW_CFI_RegisterRule_Offset: + { + // read register value from memory + U64 addr = cfa + reg->n; + U64 reg_size = dw_reg_size_from_code(arch, reg_idx); + unwind_status = mem_read_func(addr, reg_buffer, reg_size, mem_read_ud); + if (unwind_status != MachineOpResult_Ok) { goto exit; } + + // write register value to the thread context + if(!arch_reg_block_write_range(arch_info, reg_block, reg_rng, reg_buffer)) + { + unwind_status = MachineOpResult_Fail; + goto exit; + } + }break; + case DW_CFI_RegisterRule_ValOffset: + { + // compute register value + U64 reg_value = cfa + reg->n; + + // write register value to the thread context + U64 reg_size = dw_reg_size_from_code(arch, reg_idx); + if(!arch_reg_block_write_range(arch_info, reg_block, reg_rng, ®_value)) + { + unwind_status = MachineOpResult_Fail; + goto exit; + } + }break; + case DW_CFI_RegisterRule_Register: + { + // read register value from another register + U64 reg_size = dw_reg_size_from_code(arch, reg_idx); + if(!arch_reg_block_read_range(arch_info, reg_block, reg_rng, reg_buffer)) + { + unwind_status = MachineOpResult_Fail; + goto exit; + } + + // write register value to the thread context + if(!arch_reg_block_write_range(arch_info, reg_block, reg_rng, reg_buffer)) + { + unwind_status = MachineOpResult_Fail; + goto exit; + } + if (unwind_status != MachineOpResult_Ok) { goto exit; } + }break; + case DW_CFI_RegisterRule_Expression: + { + // TODO: evaluate expression + NotImplemented; + }break; + case DW_CFI_RegisterRule_ValExpression: + { + // TODO: evaluate expression + NotImplemented; + }break; + case DW_CFI_RegisterRule_Architectural: + { + NotImplemented; + }break; } } - + // update stack pointer - U64 sp = dw_sp_from_arch(arch); - reg_write_func(sp, &cfa, sizeof(cfa), reg_write_ud); - -exit:; + arch_reg_block_write_sp(arch_info, reg_block, cfa); + + exit:; scratch_end(scratch); return unwind_status; } diff --git a/src/dwarf/dwarf_unwind.h b/src/dwarf/dwarf_unwind.h index 510057e2..63e5ba3f 100644 --- a/src/dwarf/dwarf_unwind.h +++ b/src/dwarf/dwarf_unwind.h @@ -74,7 +74,8 @@ internal DW_CFI_Unwind * dw_cfi_unwind_init(Arena *arena, Arch arch, DW_CIE *cie internal B32 dw_cfi_next_row(Arena *arena, DW_CFI_Unwind *uw); internal DW_CFI_Row * dw_cfi_row_from_pc(Arena *arena, Arch arch, struct DW_CIE *cie, struct DW_FDE *fde, DW_DecodePtr *decode_ptr_func, void *decode_ptr_ctx, U64 pc); -internal MachineOpResult dw_cfi_apply_register_rules(Arch arch, U64 cfa, DW_CFI_Row *row, MachineOp_MemRead *mem_read_func, void *mem_read_ud, MachineOp_RegRead *reg_read_func, void *reg_read_ud, MachineOp_RegWrite *reg_write_func, void *reg_write_ud); +internal MachineOpResult dw_compute_cfa(Arch arch, DW_CFI_Row *row, void *reg_block, MachineOp_MemRead *mem_read_func, void *mem_read_ud, U64 *cfa_out); +internal MachineOpResult dw_cfi_apply_register_rules(Arch arch, U64 cfa, DW_CFI_Row *row, void *reg_block, MachineOp_MemRead *mem_read_func, void *mem_read_ud); #endif // DWARF_UNWIND_H diff --git a/src/regs/rdi/regs_rdi.c b/src/dwarf/generated/dwarf.meta.c similarity index 68% rename from src/regs/rdi/regs_rdi.c rename to src/dwarf/generated/dwarf.meta.c index 911725c1..0378fad9 100644 --- a/src/regs/rdi/regs_rdi.c +++ b/src/dwarf/generated/dwarf.meta.c @@ -1,4 +1,5 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -#include "regs/rdi/generated/regs_rdi.meta.c" +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//- GENERATED CODE + diff --git a/src/dwarf/generated/dwarf.meta.h b/src/dwarf/generated/dwarf.meta.h new file mode 100644 index 00000000..39719f80 --- /dev/null +++ b/src/dwarf/generated/dwarf.meta.h @@ -0,0 +1,87 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//- GENERATED CODE + +#ifndef DWARF_META_H +#define DWARF_META_H + +typedef enum DW_RegCodeX64 +{ +DW_RegCodeX64_rax = 0, +DW_RegCodeX64_rdx = 1, +DW_RegCodeX64_rcx = 2, +DW_RegCodeX64_rbx = 3, +DW_RegCodeX64_rsi = 4, +DW_RegCodeX64_rdi = 5, +DW_RegCodeX64_rbp = 6, +DW_RegCodeX64_rsp = 7, +DW_RegCodeX64_r8 = 8, +DW_RegCodeX64_r9 = 9, +DW_RegCodeX64_r10 = 10, +DW_RegCodeX64_r11 = 11, +DW_RegCodeX64_r12 = 12, +DW_RegCodeX64_r13 = 13, +DW_RegCodeX64_r14 = 14, +DW_RegCodeX64_r15 = 15, +DW_RegCodeX64_rip = 16, +DW_RegCodeX64_zmm0 = 17, +DW_RegCodeX64_zmm1 = 18, +DW_RegCodeX64_zmm2 = 19, +DW_RegCodeX64_zmm3 = 20, +DW_RegCodeX64_zmm4 = 21, +DW_RegCodeX64_zmm5 = 22, +DW_RegCodeX64_zmm6 = 23, +DW_RegCodeX64_zmm7 = 24, +DW_RegCodeX64_zmm8 = 25, +DW_RegCodeX64_zmm9 = 26, +DW_RegCodeX64_zmm10 = 27, +DW_RegCodeX64_zmm11 = 28, +DW_RegCodeX64_zmm12 = 29, +DW_RegCodeX64_zmm13 = 30, +DW_RegCodeX64_zmm14 = 31, +DW_RegCodeX64_zmm15 = 32, +DW_RegCodeX64_zmm16 = 67, +DW_RegCodeX64_zmm17 = 68, +DW_RegCodeX64_zmm18 = 69, +DW_RegCodeX64_zmm19 = 70, +DW_RegCodeX64_zmm20 = 71, +DW_RegCodeX64_zmm21 = 72, +DW_RegCodeX64_zmm22 = 73, +DW_RegCodeX64_zmm23 = 74, +DW_RegCodeX64_zmm24 = 75, +DW_RegCodeX64_zmm25 = 76, +DW_RegCodeX64_zmm26 = 77, +DW_RegCodeX64_zmm27 = 78, +DW_RegCodeX64_zmm28 = 79, +DW_RegCodeX64_zmm29 = 80, +DW_RegCodeX64_zmm30 = 81, +DW_RegCodeX64_zmm31 = 82, +DW_RegCodeX64_st0 = 33, +DW_RegCodeX64_st1 = 34, +DW_RegCodeX64_st2 = 35, +DW_RegCodeX64_st3 = 36, +DW_RegCodeX64_st4 = 37, +DW_RegCodeX64_st5 = 38, +DW_RegCodeX64_st6 = 39, +DW_RegCodeX64_st7 = 40, +DW_RegCodeX64_mm0 = 41, +DW_RegCodeX64_mm1 = 42, +DW_RegCodeX64_mm2 = 43, +DW_RegCodeX64_mm3 = 44, +DW_RegCodeX64_mm4 = 45, +DW_RegCodeX64_mm5 = 46, +DW_RegCodeX64_mm6 = 47, +DW_RegCodeX64_mm7 = 48, +DW_RegCodeX64_rflags = 49, +DW_RegCodeX64_es = 50, +DW_RegCodeX64_cs = 51, +DW_RegCodeX64_ss = 52, +DW_RegCodeX64_ds = 53, +DW_RegCodeX64_fs = 54, +DW_RegCodeX64_gs = 55, +DW_RegCodeX64_fsbase = 58, +DW_RegCodeX64_gsbase = 59, +} DW_RegCodeX64; + +#endif // DWARF_META_H diff --git a/src/dwarf/x64/dwarf_x64.c b/src/dwarf/x64/dwarf_x64.c new file mode 100644 index 00000000..de6cc0d3 --- /dev/null +++ b/src/dwarf/x64/dwarf_x64.c @@ -0,0 +1,4 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#include "dwarf/x64/generated/dwarf_x64.meta.c" diff --git a/src/dwarf/x64/dwarf_x64.h b/src/dwarf/x64/dwarf_x64.h new file mode 100644 index 00000000..0887fea2 --- /dev/null +++ b/src/dwarf/x64/dwarf_x64.h @@ -0,0 +1,9 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef DWARF_X64_H +#define DWARF_X64_H + +#include "dwarf/x64/generated/dwarf_x64.meta.h" + +#endif // DWARF_X64_H diff --git a/src/dwarf/x64/dwarf_x64.mdesk b/src/dwarf/x64/dwarf_x64.mdesk new file mode 100644 index 00000000..c2464c88 --- /dev/null +++ b/src/dwarf/x64/dwarf_x64.mdesk @@ -0,0 +1,7 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +@data(U8) dw_reg_code_from_x64_table: +{ + @expand(X64_RegTable a) `$(a.has_dwarf == 'x' -> "DW_RegCodeX64_" .. a.name)$(a.has_dwarf != 'x' -> 0)` +} diff --git a/src/dwarf/x64/generated/dwarf_x64.meta.c b/src/dwarf/x64/generated/dwarf_x64.meta.c new file mode 100644 index 00000000..89cec99a --- /dev/null +++ b/src/dwarf/x64/generated/dwarf_x64.meta.c @@ -0,0 +1,201 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//- GENERATED CODE + +C_LINKAGE_BEGIN +U8 dw_reg_code_from_x64_table[189] = +{ +0, +DW_RegCodeX64_rax, +DW_RegCodeX64_rcx, +DW_RegCodeX64_rdx, +DW_RegCodeX64_rbx, +DW_RegCodeX64_rsp, +DW_RegCodeX64_rbp, +DW_RegCodeX64_rsi, +DW_RegCodeX64_rdi, +DW_RegCodeX64_r8, +DW_RegCodeX64_r9, +DW_RegCodeX64_r10, +DW_RegCodeX64_r11, +DW_RegCodeX64_r12, +DW_RegCodeX64_r13, +DW_RegCodeX64_r14, +DW_RegCodeX64_r15, +DW_RegCodeX64_fsbase, +DW_RegCodeX64_gsbase, +DW_RegCodeX64_rip, +DW_RegCodeX64_rflags, +0, +0, +0, +0, +0, +0, +0, +0, +DW_RegCodeX64_st0, +DW_RegCodeX64_st1, +DW_RegCodeX64_st2, +DW_RegCodeX64_st3, +DW_RegCodeX64_st4, +DW_RegCodeX64_st5, +DW_RegCodeX64_st6, +DW_RegCodeX64_st7, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +DW_RegCodeX64_ss, +DW_RegCodeX64_cs, +DW_RegCodeX64_ds, +DW_RegCodeX64_es, +DW_RegCodeX64_fs, +DW_RegCodeX64_gs, +DW_RegCodeX64_zmm0, +DW_RegCodeX64_zmm1, +DW_RegCodeX64_zmm2, +DW_RegCodeX64_zmm3, +DW_RegCodeX64_zmm4, +DW_RegCodeX64_zmm5, +DW_RegCodeX64_zmm6, +DW_RegCodeX64_zmm7, +DW_RegCodeX64_zmm8, +DW_RegCodeX64_zmm9, +DW_RegCodeX64_zmm10, +DW_RegCodeX64_zmm11, +DW_RegCodeX64_zmm12, +DW_RegCodeX64_zmm13, +DW_RegCodeX64_zmm14, +DW_RegCodeX64_zmm15, +DW_RegCodeX64_zmm16, +DW_RegCodeX64_zmm17, +DW_RegCodeX64_zmm18, +DW_RegCodeX64_zmm19, +DW_RegCodeX64_zmm20, +DW_RegCodeX64_zmm21, +DW_RegCodeX64_zmm22, +DW_RegCodeX64_zmm23, +DW_RegCodeX64_zmm24, +DW_RegCodeX64_zmm25, +DW_RegCodeX64_zmm26, +DW_RegCodeX64_zmm27, +DW_RegCodeX64_zmm28, +DW_RegCodeX64_zmm29, +DW_RegCodeX64_zmm30, +DW_RegCodeX64_zmm31, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +DW_RegCodeX64_mm0, +DW_RegCodeX64_mm1, +DW_RegCodeX64_mm2, +DW_RegCodeX64_mm3, +DW_RegCodeX64_mm4, +DW_RegCodeX64_mm5, +DW_RegCodeX64_mm6, +DW_RegCodeX64_mm7, +}; + +C_LINKAGE_END + diff --git a/src/dwarf/x64/generated/dwarf_x64.meta.h b/src/dwarf/x64/generated/dwarf_x64.meta.h new file mode 100644 index 00000000..e9cb5806 --- /dev/null +++ b/src/dwarf/x64/generated/dwarf_x64.meta.h @@ -0,0 +1,14 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//- GENERATED CODE + +#ifndef DWARF_X64_META_H +#define DWARF_X64_META_H + +C_LINKAGE_BEGIN +extern U8 dw_reg_code_from_x64_table[189]; + +C_LINKAGE_END + +#endif // DWARF_X64_META_H diff --git a/src/eval/eval_core.c b/src/eval/eval_core.c index a7af01fc..694ddb27 100644 --- a/src/eval/eval_core.c +++ b/src/eval/eval_core.c @@ -707,11 +707,12 @@ e_oplist_from_location(Arena *arena, RDI_Parsed *rdi, RDI_Location loc) { RDI_TopLevelInfo *tli = rdi_element_from_name_idx(rdi, TopLevelInfo, 0); Arch arch = arch_from_rdi_arch(tli->arch); + ARCH_Info *arch_info = arch_info_from_arch(arch); RDI_RegCode rdi_regcode = rdi_regcode_from_location(loc); - REGS_RegCode regs_reg_code = regs_reg_code_from_arch_rdi_code(arch, rdi_regcode); - REGS_Rng reg_rng = regs_reg_code_rng_table_from_arch(arch)[regs_reg_code]; - U64 byte_size = (U64)reg_rng.byte_size; - U64 byte_pos = 0; + ARCH_RegCode reg_code = arch_reg_code_from_rdi(arch, rdi_regcode); + Rng1U16 reg_rng = arch_info->reg_code_rng_table[reg_code]; + U64 byte_size = (U64)dim_1u16(reg_rng); + U64 byte_pos = reg_rng.min; e_oplist_push_op(arena, &result, RDI_EvalOp_RegRead, e_value_u64(RDI_EncodeRegReadParam(rdi_regcode, byte_size, byte_pos))); }break; @@ -830,7 +831,6 @@ internal void e_select_ir_ctx(E_IRCtx *ctx) { if(ctx->regs_map == 0) { ctx->regs_map = &e_string2num_map_nil; } - if(ctx->reg_alias_map == 0) { ctx->reg_alias_map = &e_string2num_map_nil; } if(ctx->locals_map == 0) { ctx->locals_map = &e_string2num_map_nil; } if(ctx->member_map == 0) { ctx->member_map = &e_string2num_map_nil; } if(ctx->macro_map == 0) { ctx->macro_map = push_array(e_cache->arena, E_String2ExprMap, 1); ctx->macro_map[0] = e_string2expr_map_make(e_cache->arena, 512); } diff --git a/src/eval/eval_core.h b/src/eval/eval_core.h index 5539a60a..48eaeba0 100644 --- a/src/eval/eval_core.h +++ b/src/eval/eval_core.h @@ -165,7 +165,6 @@ typedef enum E_TypeKeyKind E_TypeKeyKind_Ext, E_TypeKeyKind_Cons, E_TypeKeyKind_Reg, - E_TypeKeyKind_RegAlias, } E_TypeKeyKind; @@ -795,7 +794,6 @@ typedef struct E_IRCtx E_IRCtx; struct E_IRCtx { E_String2NumMap *regs_map; - E_String2NumMap *reg_alias_map; E_String2NumMap *locals_map; // (within `primary_module`) E_String2NumMap *member_map; // (within `primary_module`) E_String2ExprMap *macro_map; diff --git a/src/eval/eval_interpret.c b/src/eval/eval_interpret.c index 75d75299..948c9730 100644 --- a/src/eval/eval_interpret.c +++ b/src/eval/eval_interpret.c @@ -280,13 +280,14 @@ e_interpret(String8 bytecode) U8 rdi_reg_code = (imm.u64&0x0000FF)>>0; U8 byte_size = (imm.u64&0x00FF00)>>8; U8 byte_off = (imm.u64&0xFF0000)>>16; - REGS_RegCode base_reg_code = regs_reg_code_from_arch_rdi_code(e_interpret_ctx->reg_arch, rdi_reg_code); - REGS_Rng *rng_table = regs_reg_code_rng_table_from_arch(e_interpret_ctx->reg_arch); + Arch arch = e_interpret_ctx->reg_arch; + ARCH_Info *arch_info = arch_info_from_arch(arch); + ARCH_RegCode base_reg_code = arch_reg_code_from_rdi(arch, rdi_reg_code); B32 good_read = 0; - if(0 <= rdi_reg_code && rdi_reg_code < regs_reg_code_count_from_arch(e_interpret_ctx->reg_arch)) + if(0 <= base_reg_code && base_reg_code < arch_info->reg_code_count) { - REGS_Rng rng = rng_table[base_reg_code]; - U64 off = (U64)rng.byte_off + byte_off; + Rng1U16 rng = arch_info->reg_code_rng_table[base_reg_code]; + U64 off = (U64)rng.min + byte_off; U64 size = (U64)byte_size; good_read = e_space_read(e_interpret_ctx->reg_space, &nval, r1u64(off, off+size)); } diff --git a/src/eval/eval_ir.c b/src/eval/eval_ir.c index ca17a553..00125902 100644 --- a/src/eval/eval_ir.c +++ b/src/eval/eval_ir.c @@ -2016,49 +2016,25 @@ e_push_irtree_and_type_from_expr(Arena *arena, E_IRTreeAndType *root_parent, E_I if(reg_num != 0) { string_mapped = 1; - REGS_Rng reg_rng = regs_reg_code_rng_table_from_arch(e_base_ctx->primary_module->arch)[reg_num]; + Arch arch = e_base_ctx->primary_module->arch; + ARCH_Info *arch_info = arch_info_from_arch(arch); + ARCH_RegCode reg_code = reg_num; + Rng1U16 reg_rng = arch_info->reg_code_rng_table[reg_code]; + U64 reg_size = dim_1u16(reg_rng); E_OpList oplist = {0}; - e_oplist_push_uconst(arena, &oplist, reg_rng.byte_off); + e_oplist_push_uconst(arena, &oplist, reg_rng.min); mapped_bytecode = e_bytecode_from_oplist(arena, &oplist); mapped_bytecode_mode = E_Mode_Offset; mapped_bytecode_space = e_base_ctx->thread_reg_space; - REGS_UsageKind reg_usage_kind = regs_reg_code_usage_kind_table_from_arch(e_base_ctx->primary_module->arch)[reg_num]; + B32 is_vector = arch_info->reg_code_is_vector_table[reg_code]; if(0){} - else if(reg_usage_kind == REGS_UsageKind_Normal && reg_rng.byte_size == 1) {mapped_type_key = e_type_key_basic(E_TypeKind_U8);} - else if(reg_usage_kind == REGS_UsageKind_Normal && reg_rng.byte_size == 2) {mapped_type_key = e_type_key_basic(E_TypeKind_U16);} - else if(reg_usage_kind == REGS_UsageKind_Normal && reg_rng.byte_size == 4) {mapped_type_key = e_type_key_basic(E_TypeKind_U32);} - else if(reg_usage_kind == REGS_UsageKind_Normal && reg_rng.byte_size == 8) {mapped_type_key = e_type_key_basic(E_TypeKind_U64);} + else if(!is_vector && reg_size == 1) {mapped_type_key = e_type_key_basic(E_TypeKind_U8);} + else if(!is_vector && reg_size == 2) {mapped_type_key = e_type_key_basic(E_TypeKind_U16);} + else if(!is_vector && reg_size == 4) {mapped_type_key = e_type_key_basic(E_TypeKind_U32);} + else if(!is_vector && reg_size == 8) {mapped_type_key = e_type_key_basic(E_TypeKind_U64);} else { - mapped_type_key = e_type_key_reg(e_base_ctx->primary_module->arch, reg_num); - } - } - }break; - - //- rjf: try register aliases - case E_IdentifierResolutionPath_RegisterAliases: - if(!string_mapped && (qualifier.size == 0 || str8_match(qualifier, str8_lit("reg"), 0))) - { - U64 alias_num = e_num_from_string(e_ir_ctx->reg_alias_map, string); - if(alias_num != 0) - { - string_mapped = 1; - REGS_Slice alias_slice = regs_alias_code_slice_table_from_arch(e_base_ctx->primary_module->arch)[alias_num]; - REGS_Rng alias_reg_rng = regs_reg_code_rng_table_from_arch(e_base_ctx->primary_module->arch)[alias_slice.code]; - E_OpList oplist = {0}; - e_oplist_push_uconst(arena, &oplist, alias_reg_rng.byte_off + alias_slice.byte_off); - mapped_bytecode = e_bytecode_from_oplist(arena, &oplist); - mapped_bytecode_mode = E_Mode_Offset; - mapped_bytecode_space = e_base_ctx->thread_reg_space; - REGS_UsageKind reg_usage_kind = regs_alias_code_usage_kind_table_from_arch(e_base_ctx->primary_module->arch)[alias_num]; - if(0){} - else if(reg_usage_kind == REGS_UsageKind_Normal && alias_slice.byte_size == 1) {mapped_type_key = e_type_key_basic(E_TypeKind_U8);} - else if(reg_usage_kind == REGS_UsageKind_Normal && alias_slice.byte_size == 2) {mapped_type_key = e_type_key_basic(E_TypeKind_U16);} - else if(reg_usage_kind == REGS_UsageKind_Normal && alias_slice.byte_size == 4) {mapped_type_key = e_type_key_basic(E_TypeKind_U32);} - else if(reg_usage_kind == REGS_UsageKind_Normal && alias_slice.byte_size == 8) {mapped_type_key = e_type_key_basic(E_TypeKind_U64);} - else - { - mapped_type_key = e_type_key_reg_alias(e_base_ctx->primary_module->arch, alias_num); + mapped_type_key = e_type_key_reg(arch, reg_code); } } }break; @@ -2185,7 +2161,7 @@ e_push_irtree_and_type_from_expr(Arena *arena, E_IRTreeAndType *root_parent, E_I { Temp scratch = scratch_begin(&arena, 1); String8 file_path = expr->string; - FileProperties props = os_properties_from_file_path(file_path); + FileProperties props = properties_from_file_path(file_path); if(!str8_match(expr->qualifier, str8_lit("folder"), 0) && !(props.flags & FilePropertyFlag_IsFolder) && file_path.size != 0) { E_Space space = e_space_make(E_SpaceKind_FileSystem); @@ -2196,7 +2172,7 @@ e_push_irtree_and_type_from_expr(Arena *arena, E_IRTreeAndType *root_parent, E_I else { String8 folder_path = str8_chop_last_slash(file_path); - props = os_properties_from_file_path(folder_path); + props = properties_from_file_path(folder_path); if(props.flags & FilePropertyFlag_IsFolder || folder_path.size == 0 || str8_match(folder_path, str8_lit("/"), StringMatchFlag_SlashInsensitive)) { E_Space space = e_space_make(E_SpaceKind_FileSystem); diff --git a/src/eval/eval_ir.h b/src/eval/eval_ir.h index 26a921a8..51231f44 100644 --- a/src/eval/eval_ir.h +++ b/src/eval/eval_ir.h @@ -18,7 +18,6 @@ typedef enum E_IdentifierResolutionPath E_IdentifierResolutionPath_BuiltInConstants, E_IdentifierResolutionPath_BuiltInTypes, E_IdentifierResolutionPath_Registers, - E_IdentifierResolutionPath_RegisterAliases, E_IdentifierResolutionPath_Macros, } E_IdentifierResolutionPath; @@ -89,7 +88,6 @@ E_IdentifierResolutionPath e_default_identifier_resolution_paths[] = E_IdentifierResolutionPath_BuiltInTypes, E_IdentifierResolutionPath_DebugInfoMatch, E_IdentifierResolutionPath_Registers, - E_IdentifierResolutionPath_RegisterAliases, E_IdentifierResolutionPath_Macros, }; E_IdentifierResolutionRule e_default_identifier_resolution_rule = @@ -110,7 +108,6 @@ E_IdentifierResolutionPath e_callable_identifier_resolution_paths[] = E_IdentifierResolutionPath_BuiltInTypes, E_IdentifierResolutionPath_DebugInfoMatch, E_IdentifierResolutionPath_Registers, - E_IdentifierResolutionPath_RegisterAliases, }; E_IdentifierResolutionRule e_callable_identifier_resolution_rule = { diff --git a/src/eval/eval_types.c b/src/eval/eval_types.c index cea50704..451ed179 100644 --- a/src/eval/eval_types.c +++ b/src/eval/eval_types.c @@ -288,7 +288,7 @@ e_type_key_ext(E_TypeKind kind, U32 type_idx, U32 rdi_num) } internal E_TypeKey -e_type_key_reg(Arch arch, REGS_RegCode code) +e_type_key_reg(Arch arch, ARCH_RegCode code) { E_TypeKey key = {E_TypeKeyKind_Reg}; key.u32[0] = (U32)arch; @@ -296,15 +296,6 @@ e_type_key_reg(Arch arch, REGS_RegCode code) return key; } -internal E_TypeKey -e_type_key_reg_alias(Arch arch, REGS_AliasCode code) -{ - E_TypeKey key = {E_TypeKeyKind_RegAlias}; - key.u32[0] = (U32)arch; - key.u32[1] = (U32)code; - return key; -} - //- rjf: constructed type construction internal U64 @@ -625,7 +616,6 @@ e_type_kind_from_key(E_TypeKey key) case E_TypeKeyKind_Ext: {kind = (E_TypeKind)key.u32[0];}break; case E_TypeKeyKind_Cons: {kind = (E_TypeKind)key.u32[0];}break; case E_TypeKeyKind_Reg: {kind = E_TypeKind_Union;}break; - case E_TypeKeyKind_RegAlias:{kind = E_TypeKind_Union;}break; } return kind; } @@ -1100,16 +1090,10 @@ e_push_type_from_key(Arena *arena, E_TypeKey key) case E_TypeKeyKind_Reg: { Arch arch = (Arch)key.u32[0]; - REGS_RegCode code = (REGS_RegCode)key.u32[1]; - REGS_Rng rng = regs_reg_code_rng_table_from_arch(arch)[code]; - reg_byte_count = (U64)rng.byte_size; - }goto build_reg_type; - case E_TypeKeyKind_RegAlias: - { - Arch arch = (Arch)key.u32[0]; - REGS_AliasCode code = (REGS_AliasCode)key.u32[1]; - REGS_Slice slice = regs_alias_code_slice_table_from_arch(arch)[code]; - reg_byte_count = (U64)slice.byte_size; + ARCH_Info *arch_info = arch_info_from_arch(arch); + ARCH_RegCode code = (ARCH_RegCode)key.u32[1]; + Rng1U16 rng = arch_info->reg_code_rng_table[code]; + reg_byte_count = (U64)dim_1u16(rng); }goto build_reg_type; build_reg_type: { @@ -3117,23 +3101,23 @@ E_TYPE_EXPAND_INFO_FUNCTION_DEF(folder) String8List folder_paths = {0}; String8List file_paths = {0}; { - OS_FileIter *iter = os_file_iter_begin(scratch.arena, folder_path, 0); - for(OS_FileInfo info = {0}; os_file_iter_next(scratch.arena, iter, &info);) + FileIter *iter = file_iter_begin(scratch.arena, folder_path, 0); + for(FileInfo info = {0}; file_iter_next(scratch.arena, iter, &info);) { FuzzyMatchRangeList matches = fuzzy_match_find(scratch.arena, local_filter, info.name); if(matches.count == matches.needle_part_count) { if(info.props.flags & FilePropertyFlag_IsFolder) { - str8_list_push(scratch.arena, &folder_paths, push_str8_copy(arena, info.name)); + str8_list_push(scratch.arena, &folder_paths, str8_copy(arena, info.name)); } else { - str8_list_push(scratch.arena, &file_paths, push_str8_copy(arena, info.name)); + str8_list_push(scratch.arena, &file_paths, str8_copy(arena, info.name)); } } } - os_file_iter_end(iter); + file_iter_end(iter); } //- rjf: build accelerator @@ -3252,7 +3236,7 @@ E_TYPE_IREXT_FUNCTION_DEF(file) //- rjf: fill accel accel->file_path = push_str8_copy(arena, file_path); - accel->props = os_properties_from_file_path(file_path); + accel->props = properties_from_file_path(file_path); accel->fields = str8_array_from_list(arena, &fields); scratch_end(scratch); diff --git a/src/eval/eval_types.h b/src/eval/eval_types.h index 94f6908f..216b301a 100644 --- a/src/eval/eval_types.h +++ b/src/eval/eval_types.h @@ -71,8 +71,7 @@ internal E_EnumValArray e_enum_val_array_from_list(Arena *arena, E_EnumValList * internal E_TypeKey e_type_key_zero(void); internal E_TypeKey e_type_key_basic(E_TypeKind kind); internal E_TypeKey e_type_key_ext(E_TypeKind kind, U32 type_idx, U32 rdi_num); -internal E_TypeKey e_type_key_reg(Arch arch, REGS_RegCode code); -internal E_TypeKey e_type_key_reg_alias(Arch arch, REGS_AliasCode code); +internal E_TypeKey e_type_key_reg(Arch arch, ARCH_RegCode code); //- rjf: constructed type construction internal U64 e_hash_from_cons_type_params(E_ConsTypeParams *params); diff --git a/src/file_stream/file_stream.c b/src/file_stream/file_stream.c index 88383adb..26533c17 100644 --- a/src/file_stream/file_stream.c +++ b/src/file_stream/file_stream.c @@ -53,7 +53,7 @@ fs_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out FileProperties pre_props = {0}; if(lane_idx() == 0) { - pre_props = os_properties_from_file_path(path); + pre_props = properties_from_file_path(path); file_is_good = (pre_props.modified != 0); } lane_sync_u64(&file_is_good, 0); @@ -80,16 +80,16 @@ fs_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out } //- rjf: open file - OS_Handle file = {0}; + File file = {0}; if(file_is_good) { if(lane_idx() == 0) { - file = os_file_open(OS_AccessFlag_Read|OS_AccessFlag_ShareRead|OS_AccessFlag_ShareWrite, path); + file = file_open(AccessFlag_Read|AccessFlag_ShareRead|AccessFlag_ShareWrite, path); } lane_sync_u64(&file, 0); } - B32 file_handle_is_valid = !os_handle_match(os_handle_zero(), file); + B32 file_handle_is_valid = !file_match(file_zero(), file); //- rjf: do read U64 total_bytes_read = 0; @@ -104,7 +104,7 @@ fs_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out ProfScope("read \"%.*s\" [0x%I64x, 0x%I64x)", str8_varg(path), range.min, range.max) { Rng1U64 lane_read_range = lane_range(data_buffer_size); - U64 bytes_read = os_file_read(file, shift_1u64(lane_read_range, range.min), data_buffer + lane_read_range.min); + U64 bytes_read = file_read(file, shift_1u64(lane_read_range, range.min), data_buffer + lane_read_range.min); ins_atomic_u64_add_eval(total_bytes_read_ptr, bytes_read); } lane_sync(); @@ -116,7 +116,7 @@ fs_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out { if(lane_idx() == 0) { - os_file_close(file); + file_close(file); } } @@ -124,7 +124,7 @@ fs_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U64 *gen_out FileProperties post_props = {0}; if(lane_idx() == 0) { - post_props = os_properties_from_file_path(path); + post_props = properties_from_file_path(path); } //- rjf: form content key @@ -303,7 +303,7 @@ fs_async_tick(void) { for(FS_Node *n = slot->first; n != 0; n = n->next) { - FileProperties props = os_properties_from_file_path(n->path); + FileProperties props = properties_from_file_path(n->path); if(props.modified != n->last_modified_timestamp) { found_work = 1; diff --git a/src/font_provider/dwrite/font_provider_dwrite.c b/src/font_provider/dwrite/font_provider_dwrite.c index 91dbd89e..448d8572 100644 --- a/src/font_provider/dwrite/font_provider_dwrite.c +++ b/src/font_provider/dwrite/font_provider_dwrite.c @@ -335,7 +335,7 @@ fp_font_open(String8 path) //- rjf: try to open font for(PathTask *t = first_task; t != 0 && font.file == 0; t = t->next) { - B32 file_exists = (os_properties_from_file_path(t->path).created != 0); + B32 file_exists = (properties_from_file_path(t->path).created != 0); String16 path16 = str16_from_8(scratch.arena, t->path); if(file_exists) { diff --git a/src/linker/lnk.c b/src/linker/lnk.c index c7c9f869..d0643301 100644 --- a/src/linker/lnk.c +++ b/src/linker/lnk.c @@ -136,7 +136,7 @@ lnk_make_default_cmd_line(Arena *arena, LNK_CmdLine user_cmd_line) lnk_cmd_line_push_option_if_not_presentf(arena, &cmd_line, LNK_CmdSwitch_PdbAltPath, "%%_RAD_PDB_PATH%%"); lnk_cmd_line_push_option_if_not_presentf(arena, &cmd_line, LNK_CmdSwitch_PdbPageSize, "%u", KB(4)); if (!lnk_cmd_line_has_switch(user_cmd_line, LNK_CmdSwitch_Brepro)) { - lnk_cmd_line_push_option_if_not_presentf(arena, &cmd_line, LNK_CmdSwitch_Rad_TimeStamp, "%u", os_get_process_start_time_unix()); + lnk_cmd_line_push_option_if_not_presentf(arena, &cmd_line, LNK_CmdSwitch_Rad_TimeStamp, "%u", get_process_start_time_unix()); } lnk_cmd_line_push_option_if_not_presentf(arena, &cmd_line, LNK_CmdSwitch_Rad_TypeHashAlg, "BLAKE3"); lnk_cmd_line_push_option_if_not_presentf(arena, &cmd_line, LNK_CmdSwitch_Rad_Age, "%u", 1); @@ -150,7 +150,7 @@ lnk_make_default_cmd_line(Arena *arena, LNK_CmdLine user_cmd_line) lnk_cmd_line_push_option_if_not_presentf(arena, &cmd_line, LNK_CmdSwitch_Rad_OsVer, "6.0"); lnk_cmd_line_push_option_if_not_presentf(arena, &cmd_line, LNK_CmdSwitch_Rad_PageSize, "%u", KB(4)); lnk_cmd_line_push_option_if_not_presentf(arena, &cmd_line, LNK_CmdSwitch_Rad_PathStyle, "system"); - lnk_cmd_line_push_option_if_not_presentf(arena, &cmd_line, LNK_CmdSwitch_Rad_Workers, "%u", os_get_system_info()->logical_processor_count); + lnk_cmd_line_push_option_if_not_presentf(arena, &cmd_line, LNK_CmdSwitch_Rad_Workers, "%u", get_system_info()->logical_processor_count); lnk_cmd_line_push_option_if_not_presentf(arena, &cmd_line, LNK_CmdSwitch_Rad_DebugAltPath, "%%_RAD_RDI_PATH%%"); lnk_cmd_line_push_option_if_not_presentf(arena, &cmd_line, LNK_CmdSwitch_Rad_MemoryMapFiles, ""); if (BUILD_DEBUG) { @@ -374,7 +374,7 @@ lnk_merge_manifest_files(String8 mt_path, String8 out_name, String8List manifest str8_list_pushf(scratch.arena, &cmd_line, "-nologo"); // register input manifest files on command line - String8 work_dir = os_get_current_path(scratch.arena); + String8 work_dir = get_current_path(scratch.arena); for (String8Node *man_node = manifest_path_list.first; man_node != 0; man_node = man_node->next) { @@ -390,15 +390,15 @@ lnk_merge_manifest_files(String8 mt_path, String8 out_name, String8List manifest } // launch mt.exe with our command line - OS_ProcessLaunchParams launch_opts = {0}; + ProcessLaunchParams launch_opts = {0}; launch_opts.cmd_line = cmd_line; launch_opts.inherit_env = 1; launch_opts.consoleless = 0; - OS_Handle mt_handle = os_process_launch(&launch_opts); - if (os_handle_match(mt_handle, os_handle_zero())) { + Process mt_handle = process_launch(&launch_opts); + if (process_match(mt_handle, process_zero())) { lnk_error(LNK_Error_Mt, "unable to start process: %S", mt_path); } else { - os_process_join(mt_handle, max_U64, 0); + process_join(mt_handle, max_U64, 0); } scratch_end(scratch); @@ -447,8 +447,8 @@ lnk_manifest_from_inputs(Arena *arena, } // cleanup disk - os_delete_file_at_path(linker_manifest_path); - os_delete_file_at_path(merged_manifest_path); + delete_file_at_path(linker_manifest_path); + delete_file_at_path(merged_manifest_path); ProfEnd(); } else { @@ -804,7 +804,7 @@ lnk_make_res_obj(Arena *arena, } // convert res to obj - OS_ProcessInfo *process_info = os_get_process_info(); + ProcessInfo *process_info = get_process_info(); String8List exe_path_strs = {0}; str8_list_push(scratch.arena, &exe_path_strs, process_info->binary_path); String8 exe_path = str8_list_first(&exe_path_strs); @@ -1032,7 +1032,7 @@ lnk_inputer_push_obj_thin(LNK_Inputer *inputer, LNK_LibMemberRef *link_member, S { lnk_log(LNK_Log_InputObj, "Input Obj: %S", path); Temp scratch = scratch_begin(0,0); - String8 full_path = os_full_path_from_path(scratch.arena, path); + String8 full_path = full_path_from_path(scratch.arena, path); LNK_Input *input = lnk_inputer_push_thin(inputer->arena, &inputer->new_objs, inputer->objs_ht, full_path); input->link_member = link_member; scratch_end(scratch); @@ -1059,7 +1059,7 @@ lnk_input_from_path(HashTable *load_ht, String8 path) LNK_Input *input = hash_table_search_path_raw(load_ht, path); if (input == 0) { Temp scratch = scratch_begin(0, 0); - String8 full_path = os_full_path_from_path(scratch.arena, path); + String8 full_path = full_path_from_path(scratch.arena, path); input = hash_table_search_path_raw(load_ht, full_path); scratch_end(scratch); } diff --git a/src/linker/lnk_config.c b/src/linker/lnk_config.c index 768d495e..d6e708b4 100644 --- a/src/linker/lnk_config.c +++ b/src/linker/lnk_config.c @@ -1115,7 +1115,7 @@ lnk_unwrap_rsp(Arena *arena, String8List arg_list) // remove "@" String8 name = str8_skip(curr->string, 1); - if (os_file_path_exists(name)) { + if (file_path_exists(name)) { // read rsp from disk String8 file = lnk_read_data_from_file_path(scratch.arena, 0, name); @@ -1469,8 +1469,8 @@ lnk_apply_cmd_option_to_config(LNK_Config *config, String8 cmd_name, String8List case LNK_CmdSwitch_LibPath: { String8List lib_dir_list = str8_list_copy(config->arena, &value_strings); for (String8Node *dir_n = lib_dir_list.first; dir_n != 0; dir_n = dir_n->next) { - if (!os_folder_path_exists(dir_n->string)) { - String8 full_path = os_full_path_from_path(scratch.arena, dir_n->string); + if (!folder_path_exists(dir_n->string)) { + String8 full_path = full_path_from_path(scratch.arena, dir_n->string); lnk_error_cmd_switch(LNK_Warning_Cmdl, obj, cmd_switch, "path doesn't exist %S", full_path); } } @@ -1827,7 +1827,7 @@ lnk_apply_cmd_option_to_config(LNK_Config *config, String8 cmd_name, String8List case LNK_CmdSwitch_Rad_BuildInfo: { lnk_print_build_info(); - os_abort(0); + abort_self(0); } break; case LNK_CmdSwitch_Rad_CheckUnusedDelayLoadDll: { @@ -1881,7 +1881,7 @@ lnk_apply_cmd_option_to_config(LNK_Config *config, String8 cmd_name, String8List if (str8_match_lit("imageblake3", value_strings.first->string, StringMatchFlag_CaseInsensitive)) { config->guid_type = Lnk_DebugInfoGuid_ImageBlake3; } else if (str8_match_lit("random", value_strings.first->string, StringMatchFlag_CaseInsensitive)) { - config->guid = os_make_guid(); + config->guid = make_guid(); } else { Guid guid; if (try_guid_from_string(value_strings.first->string, &guid)) { @@ -1897,7 +1897,7 @@ lnk_apply_cmd_option_to_config(LNK_Config *config, String8 cmd_name, String8List case LNK_CmdSwitch_Rad_LargePages: { if (value_strings.node_count == 0) { - OS_ProcessInfo *process_info = os_get_process_info(); + ProcessInfo *process_info = get_process_info(); if (process_info->large_pages_allowed) { arena_default_flags |= ArenaFlag_LargePages; } else { @@ -1914,7 +1914,7 @@ lnk_apply_cmd_option_to_config(LNK_Config *config, String8 cmd_name, String8List } } else if (value_strings.node_count == 1) { if (str8_match_lit("quiet", value_strings.first->string, StringMatchFlag_CaseInsensitive)) { - OS_ProcessInfo *process_info = os_get_process_info(); + ProcessInfo *process_info = get_process_info(); if (process_info->large_pages_allowed) { arena_default_flags |= ArenaFlag_LargePages; } @@ -2031,7 +2031,7 @@ lnk_apply_cmd_option_to_config(LNK_Config *config, String8 cmd_name, String8List } break; case LNK_CmdSwitch_Rad_SharedThreadPoolMaxWorkers: { - OS_SystemInfo *sysinfo = os_get_system_info(); + SystemInfo *sysinfo = get_system_info(); if (value_strings.node_count == 0) { config->max_worker_count = sysinfo->logical_processor_count; } else { @@ -2101,7 +2101,7 @@ lnk_apply_cmd_option_to_config(LNK_Config *config, String8 cmd_name, String8List case LNK_CmdSwitch_Rad_Version: { lnk_fprintf(stdout, "%s\n", BUILD_TITLE_STRING_LITERAL); - os_abort(0); + abort_self(0); } break; case LNK_CmdSwitch_Rad_Workers: { @@ -2113,7 +2113,7 @@ lnk_apply_cmd_option_to_config(LNK_Config *config, String8 cmd_name, String8List case LNK_CmdSwitch_Help: { lnk_print_help(); - os_abort(0); + abort_self(0); } break; } @@ -2130,7 +2130,7 @@ lnk_config_from_cmd_line(String8List raw_cmd_line, LNK_CmdLine cmd_line) LNK_Config *config = push_array(arena, LNK_Config, 1); config->arena = arena; config->raw_cmd_line = str8_list_copy(arena, &raw_cmd_line); - config->work_dir = os_get_current_path(arena); + config->work_dir = get_current_path(arena); config->build_imp_lib = 1; config->build_exp = 1; config->heap_reserve = MB(1); @@ -2304,17 +2304,17 @@ lnk_config_from_cmd_line(String8List raw_cmd_line, LNK_CmdLine cmd_line) } // convert to full paths - config->out_path = os_full_path_from_path(arena, config->out_path); - config->pdb_name = os_full_path_from_path(arena, config->pdb_name); - config->rad_debug_name = os_full_path_from_path(arena, config->rad_debug_name); - config->imp_lib_name = os_full_path_from_path(arena, config->imp_lib_name); - config->manifest_name = os_full_path_from_path(arena, config->manifest_name); + config->out_path = full_path_from_path(arena, config->out_path); + config->pdb_name = full_path_from_path(arena, config->pdb_name); + config->rad_debug_name = full_path_from_path(arena, config->rad_debug_name); + config->imp_lib_name = full_path_from_path(arena, config->imp_lib_name); + config->manifest_name = full_path_from_path(arena, config->manifest_name); // collect env vars HashTable *env_vars = hash_table_init(scratch.arena, 512); { #if OS_WINDOWS - OS_ProcessInfo *process_info = os_get_process_info(); + ProcessInfo *process_info = get_process_info(); for (String8Node *node = process_info->environment.first; node != 0; node = node->next) { String8List list = str8_split_by_string_chars(scratch.arena, node->string, str8_lit("="), 0); diff --git a/src/linker/lnk_debug_info.c b/src/linker/lnk_debug_info.c index db77c900..b6d998d1 100644 --- a/src/linker/lnk_debug_info.c +++ b/src/linker/lnk_debug_info.c @@ -479,7 +479,7 @@ lnk_make_code_view_input(TP_Context *tp, TP_Arena *tp_arena, LNK_Config *config, ProfBegin("Set up PCH"); { // hash_table - String8 work_dir = os_get_current_path(scratch.arena); + String8 work_dir = get_current_path(scratch.arena); HashTable *debug_p_ht = hash_table_init(scratch.arena, obj_count); for EachIndex(i, input.debug_p_indices.count) { U64 obj_idx = input.debug_p_indices.v[i]; diff --git a/src/linker/lnk_io.c b/src/linker/lnk_io.c index a7d00d9a..91371dd8 100644 --- a/src/linker/lnk_io.c +++ b/src/linker/lnk_io.c @@ -1,41 +1,41 @@ shared_function int lnk_open_file_read(char *path, uint64_t path_size, void *handle_buffer, uint64_t handle_buffer_max) { - OS_Handle handle = os_file_open(OS_AccessFlag_Read|OS_AccessFlag_ShareRead, str8((U8*)path, path_size)); + File handle = file_open(AccessFlag_Read|AccessFlag_ShareRead, str8((U8*)path, path_size)); Assert(sizeof(handle) <= handle_buffer_max); MemoryCopy(handle_buffer, &handle, sizeof(handle)); - return !os_handle_match(handle, os_handle_zero()); + return !file_match(handle, file_zero()); } shared_function int lnk_open_file_write(char *path, uint64_t path_size, void *handle_buffer, uint64_t handle_buffer_max) { - OS_Handle handle = os_file_open(OS_AccessFlag_Write, str8((U8*)path, path_size)); + File handle = file_open(AccessFlag_Write, str8((U8*)path, path_size)); Assert(sizeof(handle) <= handle_buffer_max); MemoryCopy(handle_buffer, &handle, sizeof(handle)); - return !os_handle_match(handle, os_handle_zero()); + return !file_match(handle, file_zero()); } shared_function void lnk_close_file(void *raw_handle) { - OS_Handle handle = *(OS_Handle *)raw_handle; - os_file_close(handle); + File handle = *(File *)raw_handle; + file_close(handle); } shared_function uint64_t lnk_size_from_file(void *raw_handle) { - OS_Handle handle = *(OS_Handle *)raw_handle; - FileProperties props = os_properties_from_file(handle); + File handle = *(File *)raw_handle; + FileProperties props = properties_from_file(handle); return props.size; } shared_function uint64_t lnk_read_file(void *raw_handle, void *buffer, uint64_t buffer_max) { - OS_Handle handle = *(OS_Handle *)raw_handle; - U64 read_size = os_file_read(handle, rng_1u64(0, buffer_max), buffer); + File handle = *(File *)raw_handle; + U64 read_size = file_read(handle, rng_1u64(0, buffer_max), buffer); Assert(read_size == buffer_max); return read_size; } @@ -43,8 +43,8 @@ lnk_read_file(void *raw_handle, void *buffer, uint64_t buffer_max) shared_function uint64_t lnk_write_file(void *raw_handle, uint64_t offset, void *buffer, uint64_t buffer_size) { - OS_Handle handle = *(OS_Handle*)raw_handle; - U64 write_size = os_file_write(handle, r1u64(offset, offset + buffer_size), buffer); + File handle = *(File*)raw_handle; + U64 write_size = file_write(handle, r1u64(offset, offset + buffer_size), buffer); return write_size; } @@ -54,10 +54,10 @@ lnk_find_first_file(Arena *arena, String8List dir_list, String8 path) ProfBeginFunction(); Temp scratch = scratch_begin(&arena, 1); String8 result = {0}; - if (os_file_path_exists(path)) { + if (file_path_exists(path)) { PathStyle path_style = path_style_from_str8(path); if (path_style == PathStyle_Relative) { - String8 current_path = os_get_current_path(scratch.arena); + String8 current_path = get_current_path(scratch.arena); String8List l = {0}; str8_list_push(scratch.arena, &l, current_path); str8_list_push(scratch.arena, &l, path); @@ -69,7 +69,7 @@ lnk_find_first_file(Arena *arena, String8List dir_list, String8 path) String8 file_name = str8_skip_last_slash(path); for EachNode(n, String8Node, dir_list.first) { String8 full_path = push_str8f(scratch.arena, "%S/%S", n->string, file_name); - if (os_file_path_exists(full_path)) { + if (file_path_exists(full_path)) { result = push_str8_copy(arena, full_path); break; } @@ -80,10 +80,10 @@ lnk_find_first_file(Arena *arena, String8List dir_list, String8 path) return result; } -internal OS_Handle +internal File lnk_file_open_with_rename_permissions(String8 path) { - OS_Handle file_handle = os_handle_zero(); + File file_handle = file_zero(); #if OS_WINDOWS Temp scratch = scratch_begin(0,0); @@ -109,7 +109,7 @@ lnk_file_open_with_rename_permissions(String8 path) } internal B32 -lnk_file_set_delete_on_close(OS_Handle handle, B32 delete_file) +lnk_file_set_delete_on_close(File handle, B32 delete_file) { #if OS_WINDOWS FILE_DISPOSITION_INFO file_disposition = {0}; @@ -122,7 +122,7 @@ lnk_file_set_delete_on_close(OS_Handle handle, B32 delete_file) } internal B32 -lnk_file_rename(OS_Handle handle, String8 new_name) +lnk_file_rename(File handle, String8 new_name) { Temp scratch = scratch_begin(0,0); #if OS_WINDOWS @@ -167,7 +167,7 @@ THREAD_POOL_TASK_FUNC(lnk_data_size_from_file_path_task) LNK_DiskReader *task = raw_task; String8 path = task->path_arr.v[task_id]; - OS_Handle handle = {0}; + File handle = {0}; U64 size = 0; int is_open = lnk_open_file_read((char*)path.str, path.size, &handle, sizeof(handle)); @@ -184,7 +184,7 @@ THREAD_POOL_TASK_FUNC(lnk_data_from_file_path_task) { LNK_DiskReader *task = raw_task; - OS_Handle handle = task->handle_arr[task_id]; + File handle = task->handle_arr[task_id]; U64 buffer_size = task->size_arr[task_id]; U8 *buffer = task->buffer + task->off_arr[task_id]; @@ -239,7 +239,7 @@ lnk_read_data_from_file_path_parallel(TP_Context *tp, Arena *arena, LNK_IO_Flags Temp scratch = scratch_begin(&arena,1); reader.path_arr = path_arr; - reader.handle_arr = push_array_no_zero(scratch.arena, OS_Handle, path_arr.count); + reader.handle_arr = push_array_no_zero(scratch.arena, File, path_arr.count); reader.size_arr = push_array_no_zero(scratch.arena, U64, path_arr.count); // open handles and get sizes @@ -284,7 +284,7 @@ lnk_write_data_list_to_file_path(String8 path, String8 temp_path, String8List da ProfBeginV("Write %M to %S", data.total_size, path); B32 open_with_rename = (temp_path.size > 0); - OS_Handle file_handle = {0}; + File file_handle = {0}; String8 open_file_path = {0}; if (open_with_rename) { file_handle = lnk_file_open_with_rename_permissions(temp_path); @@ -299,9 +299,9 @@ lnk_write_data_list_to_file_path(String8 path, String8 temp_path, String8List da open_file_path = path; } - if (!os_handle_match(file_handle, os_handle_zero())) { + if (!file_match(file_handle, file_zero())) { // try to reserve up front file size - if (!os_file_reserve_size(file_handle, data.total_size)) { + if (!file_reserve_size(file_handle, data.total_size)) { lnk_log(LNK_Log_IO_Write, "Failed to pre-allocate file %S with size %M", open_file_path, data.total_size); } diff --git a/src/linker/lnk_io.h b/src/linker/lnk_io.h index 76795427..3aff6fe9 100644 --- a/src/linker/lnk_io.h +++ b/src/linker/lnk_io.h @@ -11,7 +11,7 @@ typedef struct LNK_IO_Flags io_flags; String8Array path_arr; String8Array data_arr; - OS_Handle *handle_arr; + File *handle_arr; U64 *size_arr; U64 *off_arr; U8 *buffer; @@ -28,9 +28,9 @@ shared_function uint64_t lnk_write_file(void *raw_handle, uint64_t offset, void // --- IO Functions ------------------------------------------------------------ -internal OS_Handle lnk_file_open_with_rename_permissions(String8 path); -internal B32 lnk_file_set_delete_on_close(OS_Handle handle, B32 delete_file); -internal B32 lnk_file_rename(OS_Handle handle, String8 new_name); +internal File lnk_file_open_with_rename_permissions(String8 path); +internal B32 lnk_file_set_delete_on_close(File handle, B32 delete_file); +internal B32 lnk_file_rename(File handle, String8 new_name); internal String8 lnk_read_data_from_file_path(Arena *arena, LNK_IO_Flags io_flags, String8 path); internal String8Array lnk_read_data_from_file_path_parallel(TP_Context *tp, Arena *arena, LNK_IO_Flags io_flags, String8Array path_arr); diff --git a/src/linker/lnk_timer.c b/src/linker/lnk_timer.c index 4ce4522e..b94817d7 100644 --- a/src/linker/lnk_timer.c +++ b/src/linker/lnk_timer.c @@ -6,13 +6,13 @@ global LNK_Timer g_timers[LNK_Timer_Count]; internal void lnk_timer_begin(LNK_TimerType timer) { - g_timers[timer].begin = os_now_microseconds(); + g_timers[timer].begin = now_time_us(); } internal void lnk_timer_end(LNK_TimerType timer) { - g_timers[timer].end = os_now_microseconds(); + g_timers[timer].end = now_time_us(); } internal String8 diff --git a/src/linker/pdb_ext/pdb_builder.c b/src/linker/pdb_ext/pdb_builder.c index f7de6cdb..6302b52c 100644 --- a/src/linker/pdb_ext/pdb_builder.c +++ b/src/linker/pdb_ext/pdb_builder.c @@ -1613,7 +1613,7 @@ pdb_add_src(PDB_InfoContext *info, MSF_Context *msf, String8 file_path, String8 if (comp == PDB_SrcComp_NULL) { // process path so it passes VS validity checks String8 virt_path = file_path; - String8 work_dir = os_get_current_path(scratch.arena); + String8 work_dir = get_current_path(scratch.arena); virt_path = path_absolute_dst_from_relative_dst_src(scratch.arena, virt_path, work_dir); virt_path = lower_from_str8(scratch.arena, virt_path); virt_path = path_convert_slashes(scratch.arena, virt_path, PathStyle_UnixAbsolute); diff --git a/src/linker/thread_pool/thread_pool.c b/src/linker/thread_pool/thread_pool.c index 63fcd527..71003bb9 100644 --- a/src/linker/thread_pool/thread_pool.c +++ b/src/linker/thread_pool/thread_pool.c @@ -23,7 +23,7 @@ tp_run_tasks(TP_Context *pool, TP_Worker *worker) // on last task ping main thread U64 task_done = ins_atomic_u64_inc_eval(&pool->task_done); if (task_done == task_count) { - os_semaphore_drop(pool->main_semaphore); + semaphore_drop(pool->main_semaphore); } } } @@ -34,7 +34,7 @@ tp_worker_main(void *raw_worker) TP_Worker *worker = raw_worker; TP_Context *pool = worker->pool; for (; pool->is_live; ) { - if (os_semaphore_take(pool->task_semaphore, max_U64)) { + if (semaphore_take(pool->task_semaphore, max_U64)) { tp_run_tasks(pool, worker); } } @@ -46,8 +46,8 @@ tp_worker_main_shared(void *raw_worker) TP_Worker *worker = raw_worker; TP_Context *pool = worker->pool; for (; pool->is_live; ) { - if (os_semaphore_take(pool->exec_semaphore, max_U64)) { - if (os_semaphore_take(pool->task_semaphore, max_U64)) { + if (semaphore_take(pool->exec_semaphore, max_U64)) { + if (semaphore_take(pool->task_semaphore, max_U64)) { tp_run_tasks(pool, worker); } } @@ -67,13 +67,13 @@ tp_alloc(Arena *arena, U32 worker_count, U32 max_worker_count, String8 name) Semaphore task_semaphore = {0}; Semaphore exec_semaphore = {0}; if (worker_count > 1) { - main_semaphore = os_semaphore_alloc(0, 1, str8_zero()); + main_semaphore = semaphore_alloc(0, 1, str8_zero()); if (is_shared) { AssertAlways(worker_count <= max_worker_count); - task_semaphore = os_semaphore_alloc(0, max_worker_count, name); - exec_semaphore = os_semaphore_alloc(0, worker_count, str8_zero()); + task_semaphore = semaphore_alloc(0, max_worker_count, name); + exec_semaphore = semaphore_alloc(0, worker_count, str8_zero()); } else { - task_semaphore = os_semaphore_alloc(0, worker_count, str8_zero()); + task_semaphore = semaphore_alloc(0, worker_count, str8_zero()); } } @@ -213,20 +213,20 @@ tp_for_parallel(TP_Context *pool, TP_Arena *task_arena, U64 task_count, TP_TaskF // if we are in shared mode ping local semaphore if (pool->exec_semaphore.u64[0] != 0) { for (U64 worker_idx = 0; worker_idx < drop_count; worker_idx +=1) { - os_semaphore_drop(pool->exec_semaphore); + semaphore_drop(pool->exec_semaphore); } } // ping shared semaphore for (U64 worker_idx = 0; worker_idx < drop_count; worker_idx += 1) { - os_semaphore_drop(pool->task_semaphore); + semaphore_drop(pool->task_semaphore); } // run tasks on main worker tp_run_tasks(pool, &pool->worker_arr[0]); // wait for workers to finish tasks - os_semaphore_take(pool->main_semaphore, max_U64); + semaphore_take(pool->main_semaphore, max_U64); } } diff --git a/src/linux/base/linux_base.c b/src/linux/base/linux_base.c new file mode 100644 index 00000000..ae447aab --- /dev/null +++ b/src/linux/base/linux_base.c @@ -0,0 +1,2 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) diff --git a/src/linux/base/linux_base.h b/src/linux/base/linux_base.h new file mode 100644 index 00000000..2ba3a846 --- /dev/null +++ b/src/linux/base/linux_base.h @@ -0,0 +1,7 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef LINUX_BASE_H +#define LINUX_BASE_H + +#endif // LINUX_BASE_H diff --git a/src/mutable_text/mutable_text.c b/src/mutable_text/mutable_text.c index 28a735ea..420c5e94 100644 --- a/src/mutable_text/mutable_text.c +++ b/src/mutable_text/mutable_text.c @@ -14,7 +14,7 @@ mtx_init(void) mtx_shared = push_array(arena, MTX_Shared, 1); mtx_shared->arena = arena; mtx_shared->slots_count = 256; - mtx_shared->stripes_count = Min(mtx_shared->slots_count, os_get_system_info()->logical_processor_count); + mtx_shared->stripes_count = Min(mtx_shared->slots_count, get_system_info()->logical_processor_count); mtx_shared->slots = push_array(arena, MTX_Slot, mtx_shared->slots_count); mtx_shared->stripes = push_array(arena, MTX_Stripe, mtx_shared->stripes_count); for(U64 idx = 0; idx < mtx_shared->stripes_count; idx += 1) @@ -22,7 +22,7 @@ mtx_init(void) mtx_shared->stripes[idx].arena = arena_alloc(); mtx_shared->stripes[idx].rw_mutex = rw_mutex_alloc(); } - mtx_shared->mut_threads_count = Min(os_get_system_info()->logical_processor_count, 4); + mtx_shared->mut_threads_count = Min(get_system_info()->logical_processor_count, 4); mtx_shared->mut_threads = push_array(arena, MTX_MutThread, mtx_shared->mut_threads_count); for(U64 idx = 0; idx < mtx_shared->mut_threads_count; idx += 1) { diff --git a/src/os/core/linux/os_core_linux.c b/src/os/core/linux/os_core_linux.c index b1ea7097..0e95df77 100644 --- a/src/os/core/linux/os_core_linux.c +++ b/src/os/core/linux/os_core_linux.c @@ -772,23 +772,13 @@ internal OS_Handle os_process_launch(OS_ProcessLaunchParams *params) { OS_Handle handle = {0}; - posix_spawn_file_actions_t file_actions = {0}; int file_actions_init_code = posix_spawn_file_actions_init(&file_actions); if(file_actions_init_code == 0) { - // redirect STDOUT int stdout_code = posix_spawn_file_actions_adddup2(&file_actions, (int)params->stdout_file.u64[0], STDOUT_FILENO); - Assert(stdout_code == 0); - - // redirect STDERR int stderr_code = posix_spawn_file_actions_adddup2(&file_actions, (int)params->stderr_file.u64[0], STDERR_FILENO); - Assert(stderr_code == 0); - - // redirect STDIN int stdin_code = posix_spawn_file_actions_adddup2(&file_actions, (int)params->stdin_file.u64[0], STDIN_FILENO); - Assert(stdin_code == 0); - posix_spawnattr_t attr = {0}; int attr_init_code = posix_spawnattr_init(&attr); if(attr_init_code == 0) @@ -801,7 +791,6 @@ os_process_launch(OS_ProcessLaunchParams *params) String8List l = str8_split_path(scratch.arena, params->path); str8_list_push(scratch.arena, &l, params->cmd_line.first->string); String8 path_to_exe = str8_path_list_join_by_style(scratch.arena, &l, PathStyle_SystemAbsolute); - argv[0] = (char *)path_to_exe.str; U64 arg_idx = 1; for EachNode(n, String8Node, params->cmd_line.first->next) @@ -828,21 +817,9 @@ os_process_launch(OS_ProcessLaunchParams *params) } } - if(params->debug_subprocesses) - { - // not suported - InvalidPath; - } - - if(!params->consoleless) - { - NotImplemented; - } - // spawn process pid_t pid = 0; int spawn_code = posix_spawn(&pid, argv[0], &file_actions, &attr, argv, envp); - if(spawn_code == 0) { handle.u64[0] = (U64)pid; @@ -850,16 +827,12 @@ os_process_launch(OS_ProcessLaunchParams *params) // clean up attributes int attr_destroy_code = posix_spawnattr_destroy(&attr); - Assert(attr_destroy_code == 0); - scratch_end(scratch); } // clean up file actions int file_actions_destroy_code = posix_spawn_file_actions_destroy(&file_actions); - Assert(file_actions_destroy_code == 0); } - return handle; } @@ -873,14 +846,12 @@ os_process_join(OS_Handle handle, U64 endt_us, U64 *exit_code_out) if(kill(pid, 0) >= 0) { result = (errno == ENOENT); - if(result) { int status; waitpid(pid, &status, 0); } } - else { Assert(0 && "failed to get status from pid"); } } else if(endt_us == max_U64) { diff --git a/src/os/core/win32/os_core_win32.c b/src/os/core/win32/os_core_win32.c index 47761924..6b216aa1 100644 --- a/src/os/core/win32/os_core_win32.c +++ b/src/os/core/win32/os_core_win32.c @@ -1,155 +1,6 @@ // Copyright (c) Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) -//////////////////////////////// -//~ rjf: Modern Windows SDK Functions -// -// (We must dynamically link to them, since they can be missing in older SDKs) - -typedef HRESULT W32_SetThreadDescription_Type(HANDLE hThread, PCWSTR lpThreadDescription); -global W32_SetThreadDescription_Type *w32_SetThreadDescription_func = 0; -global RIO_EXTENSION_FUNCTION_TABLE w32_rio_functions = {0}; - -//////////////////////////////// -//~ rjf: File Info Conversion Helpers - -internal FilePropertyFlags -os_w32_file_property_flags_from_dwFileAttributes(DWORD dwFileAttributes) -{ - FilePropertyFlags flags = 0; - if(dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) - { - flags |= FilePropertyFlag_IsFolder; - } - return flags; -} - -internal void -os_w32_file_properties_from_attribute_data(FileProperties *properties, WIN32_FILE_ATTRIBUTE_DATA *attributes) -{ - properties->size = Compose64Bit(attributes->nFileSizeHigh, attributes->nFileSizeLow); - os_w32_dense_time_from_file_time(&properties->created, &attributes->ftCreationTime); - os_w32_dense_time_from_file_time(&properties->modified, &attributes->ftLastWriteTime); - properties->flags = os_w32_file_property_flags_from_dwFileAttributes(attributes->dwFileAttributes); -} - -//////////////////////////////// -//~ rjf: Time Conversion Helpers - -internal void -os_w32_date_time_from_system_time(DateTime *out, SYSTEMTIME *in) -{ - out->year = in->wYear; - out->mon = in->wMonth - 1; - out->wday = in->wDayOfWeek; - out->day = in->wDay; - out->hour = in->wHour; - out->min = in->wMinute; - out->sec = in->wSecond; - out->msec = in->wMilliseconds; -} - -internal void -os_w32_system_time_from_date_time(SYSTEMTIME *out, DateTime *in) -{ - out->wYear = (WORD)(in->year); - out->wMonth = in->mon + 1; - out->wDay = in->day; - out->wHour = in->hour; - out->wMinute = in->min; - out->wSecond = in->sec; - out->wMilliseconds = in->msec; -} - -internal void -os_w32_dense_time_from_file_time(DenseTime *out, FILETIME *in) -{ - SYSTEMTIME systime = {0}; - FileTimeToSystemTime(in, &systime); - DateTime date_time = {0}; - os_w32_date_time_from_system_time(&date_time, &systime); - *out = dense_time_from_date_time(date_time); -} - -internal U32 -os_w32_sleep_ms_from_endt_us(U64 endt_us) -{ - U32 sleep_ms = 0; - if(endt_us == max_U64) - { - sleep_ms = INFINITE; - } - else - { - U64 begint = os_now_microseconds(); - if(begint < endt_us) - { - U64 sleep_us = endt_us - begint; - sleep_ms = (U32)((sleep_us + 999)/1000); - } - } - return sleep_ms; -} - -internal U32 -os_w32_unix_time_from_file_time(FILETIME file_time) -{ - U64 win32_time = ((U64)file_time.dwHighDateTime << 32) | file_time.dwLowDateTime; - U64 unix_time64 = ((win32_time - 0x19DB1DED53E8000ULL) / 10000000); - - Assert(unix_time64 <= max_U32); - U32 unix_time32 = (U32)unix_time64; - - return unix_time32; -} - -//////////////////////////////// -//~ rjf: Entity Functions - -internal OS_W32_Entity * -os_w32_entity_alloc(OS_W32_EntityKind kind) -{ - OS_W32_Entity *result = 0; - EnterCriticalSection(&os_w32_state.entity_mutex); - { - result = os_w32_state.entity_free; - if(result) - { - SLLStackPop(os_w32_state.entity_free); - } - else - { - result = push_array_no_zero(os_w32_state.entity_arena, OS_W32_Entity, 1); - } - MemoryZeroStruct(result); - } - LeaveCriticalSection(&os_w32_state.entity_mutex); - result->kind = kind; - return result; -} - -internal void -os_w32_entity_release(OS_W32_Entity *entity) -{ - entity->kind = OS_W32_EntityKind_Null; - EnterCriticalSection(&os_w32_state.entity_mutex); - SLLStackPush(os_w32_state.entity_free, entity); - LeaveCriticalSection(&os_w32_state.entity_mutex); -} - -//////////////////////////////// -//~ rjf: Thread Entry Point - -internal DWORD -os_w32_thread_entry_point(void *ptr) -{ - OS_W32_Entity *entity = (OS_W32_Entity *)ptr; - ThreadEntryPointFunctionType *func = entity->thread.func; - void *thread_ptr = entity->thread.ptr; - supplement_thread_base_entry_point(func, thread_ptr); - return 0; -} - //////////////////////////////// //~ rjf: @os_hooks System/Process Info (Implemented Per-OS) diff --git a/src/os/gfx/os_gfx.c b/src/os/gfx/os_gfx.c index 3b584ec0..29f8c544 100644 --- a/src/os/gfx/os_gfx.c +++ b/src/os/gfx/os_gfx.c @@ -6,6 +6,30 @@ #include "generated/os_gfx.meta.c" +//////////////////////////////// +//~ rjf: Handle Type Helpers + +internal OS_Window +os_window_zero(void) +{ + OS_Window result = {0}; + return result; +} + +internal B32 +os_window_match(OS_Window a, OS_Window b) +{ + B32 result = MemoryMatchStruct(&a, &b); + return result; +} + +internal B32 +os_monitor_match(OS_Monitor a, OS_Monitor b) +{ + B32 result = MemoryMatchStruct(&a, &b); + return result; +} + //////////////////////////////// //~ rjf: Event Functions (Helpers, Implemented Once) @@ -182,12 +206,12 @@ os_eat_event(OS_EventList *events, OS_Event *event) } internal B32 -os_key_press(OS_EventList *events, OS_Handle window, OS_Modifiers modifiers, OS_Key key) +os_key_press(OS_EventList *events, OS_Window window, OS_Modifiers modifiers, OS_Key key) { B32 result = 0; for(OS_Event *event = events->first; event != 0; event = event->next) { - if((os_handle_match(event->window, window) || os_handle_match(window, os_handle_zero())) && + if((os_window_match(event->window, window) || os_window_match(window, os_window_zero())) && event->kind == OS_EventKind_Press && event->key == key && event->modifiers == modifiers) { result = 1; @@ -199,12 +223,12 @@ os_key_press(OS_EventList *events, OS_Handle window, OS_Modifiers modifiers, OS_ } internal B32 -os_key_release(OS_EventList *events, OS_Handle window, OS_Modifiers modifiers, OS_Key key) +os_key_release(OS_EventList *events, OS_Window window, OS_Modifiers modifiers, OS_Key key) { B32 result = 0; for(OS_Event *event = events->first; event != 0; event = event->next) { - if((os_handle_match(event->window, window) || os_handle_match(window, os_handle_zero())) && + if((os_window_match(event->window, window) || os_window_match(window, os_window_zero())) && event->kind == OS_EventKind_Release && event->key == key && event->modifiers == modifiers) { result = 1; @@ -216,12 +240,12 @@ os_key_release(OS_EventList *events, OS_Handle window, OS_Modifiers modifiers, O } internal B32 -os_text(OS_EventList *events, OS_Handle window, U32 character) +os_text(OS_EventList *events, OS_Window window, U32 character) { B32 result = 0; for(OS_Event *event = events->first; event != 0; event = event->next) { - if((os_handle_match(event->window, window) || os_handle_match(window, os_handle_zero())) && + if((os_window_match(event->window, window) || os_window_match(window, os_window_zero())) && event->kind == OS_EventKind_Text && event->character == character) { result = 1; @@ -270,7 +294,7 @@ os_event_list_push_new(Arena *arena, OS_EventList *evts, OS_EventKind kind) OS_Event *evt = push_array(arena, OS_Event, 1); DLLPushBack(evts->first, evts->last, evt); evts->count += 1; - evt->timestamp_us = os_now_microseconds(); + evt->timestamp_us = now_time_us(); evt->kind = kind; return evt; } diff --git a/src/os/gfx/os_gfx.h b/src/os/gfx/os_gfx.h index 8eabfd57..bc4a7d16 100644 --- a/src/os/gfx/os_gfx.h +++ b/src/os/gfx/os_gfx.h @@ -25,6 +25,37 @@ enum OS_WindowFlag_UseDefaultPosition = (1<<1), }; +typedef struct OS_Window OS_Window; +struct OS_Window +{ + U64 u64[1]; +}; + +//////////////////////////////// +//~ rjf: External Window Types + +typedef struct OS_ExternalWindow OS_ExternalWindow; +struct OS_ExternalWindow +{ + U64 u64[1]; +}; + +//////////////////////////////// +//~ rjf: Monitor Types + +typedef struct OS_Monitor OS_Monitor; +struct OS_Monitor +{ + U64 u64[1]; +}; + +typedef struct OS_MonitorArray OS_MonitorArray; +struct OS_MonitorArray +{ + OS_Monitor *v; + U64 count; +}; + //////////////////////////////// //~ rjf: Cursor Types @@ -81,7 +112,7 @@ struct OS_Event OS_Event *next; OS_Event *prev; U64 timestamp_us; - OS_Handle window; + OS_Window window; OS_EventKind kind; OS_Modifiers modifiers; OS_Key key; @@ -107,6 +138,13 @@ struct OS_EventList internal B32 frame(void); +//////////////////////////////// +//~ rjf: Handle Type Helpers + +internal OS_Window os_window_zero(void); +internal B32 os_window_match(OS_Window a, OS_Window b); +internal B32 os_monitor_match(OS_Monitor a, OS_Monitor b); + //////////////////////////////// //~ rjf: Event Functions (Helpers, Implemented Once) @@ -115,9 +153,9 @@ internal String8List os_string_list_from_modifiers(Arena *arena, OS_Modifiers fl internal String8 os_string_from_modifiers_key(Arena *arena, OS_Modifiers modifiers, OS_Key key); internal U32 os_codepoint_from_modifiers_and_key(OS_Modifiers flags, OS_Key key); internal void os_eat_event(OS_EventList *events, OS_Event *event); -internal B32 os_key_press(OS_EventList *events, OS_Handle window, OS_Modifiers modifiers, OS_Key key); -internal B32 os_key_release(OS_EventList *events, OS_Handle window, OS_Modifiers modifiers, OS_Key key); -internal B32 os_text(OS_EventList *events, OS_Handle window, U32 character); +internal B32 os_key_press(OS_EventList *events, OS_Window window, OS_Modifiers modifiers, OS_Key key); +internal B32 os_key_release(OS_EventList *events, OS_Window window, OS_Modifiers modifiers, OS_Key key); +internal B32 os_text(OS_EventList *events, OS_Window window, U32 character); internal OS_EventList os_event_list_copy(Arena *arena, OS_EventList *src); internal void os_event_list_concat_in_place(OS_EventList *dst, OS_EventList *to_push); internal OS_Event *os_event_list_push_new(Arena *arena, OS_EventList *evts, OS_EventKind kind); @@ -141,43 +179,43 @@ internal String8 os_get_clipboard_text(Arena *arena); //////////////////////////////// //~ rjf: @os_hooks Windows (Implemented Per-OS) -internal OS_Handle os_window_open(Rng2F32 rect, OS_WindowFlags flags, String8 title); -internal void os_window_close(OS_Handle window); -internal void os_window_set_title(OS_Handle window, String8 title); -internal void os_window_first_paint(OS_Handle window); -internal void os_window_focus(OS_Handle window); -internal B32 os_window_is_focused(OS_Handle window); -internal B32 os_window_is_fullscreen(OS_Handle window); -internal void os_window_set_fullscreen(OS_Handle window, B32 fullscreen); -internal B32 os_window_is_maximized(OS_Handle window); -internal void os_window_set_maximized(OS_Handle window, B32 maximized); -internal B32 os_window_is_minimized(OS_Handle window); -internal void os_window_set_minimized(OS_Handle window, B32 minimized); -internal void os_window_bring_to_front(OS_Handle window); -internal void os_window_set_monitor(OS_Handle window, OS_Handle monitor); -internal void os_window_clear_custom_border_data(OS_Handle handle); -internal void os_window_push_custom_title_bar(OS_Handle handle, F32 thickness); -internal void os_window_push_custom_edges(OS_Handle handle, F32 thickness); -internal void os_window_push_custom_title_bar_client_area(OS_Handle handle, Rng2F32 rect); -internal Rng2F32 os_rect_from_window(OS_Handle window); -internal Rng2F32 os_client_rect_from_window(OS_Handle window); -internal F32 os_dpi_from_window(OS_Handle window); +internal OS_Window os_window_open(Rng2F32 rect, OS_WindowFlags flags, String8 title); +internal void os_window_close(OS_Window window); +internal void os_window_set_title(OS_Window window, String8 title); +internal void os_window_first_paint(OS_Window window); +internal void os_window_focus(OS_Window window); +internal B32 os_window_is_focused(OS_Window window); +internal B32 os_window_is_fullscreen(OS_Window window); +internal void os_window_set_fullscreen(OS_Window window, B32 fullscreen); +internal B32 os_window_is_maximized(OS_Window window); +internal void os_window_set_maximized(OS_Window window, B32 maximized); +internal B32 os_window_is_minimized(OS_Window window); +internal void os_window_set_minimized(OS_Window window, B32 minimized); +internal void os_window_bring_to_front(OS_Window window); +internal void os_window_set_monitor(OS_Window window, OS_Monitor monitor); +internal void os_window_clear_custom_border_data(OS_Window handle); +internal void os_window_push_custom_title_bar(OS_Window handle, F32 thickness); +internal void os_window_push_custom_edges(OS_Window handle, F32 thickness); +internal void os_window_push_custom_title_bar_client_area(OS_Window handle, Rng2F32 rect); +internal Rng2F32 os_rect_from_window(OS_Window window); +internal Rng2F32 os_client_rect_from_window(OS_Window window); +internal F32 os_dpi_from_window(OS_Window window); //////////////////////////////// //~ rjf: @os_hooks External Windows (Implemented Per-OS) -internal OS_Handle os_focused_external_window(void); -internal void os_focus_external_window(OS_Handle handle); +internal OS_ExternalWindow os_focused_external_window(void); +internal void os_focus_external_window(OS_ExternalWindow ext_window); //////////////////////////////// //~ rjf: @os_hooks Monitors (Implemented Per-OS) -internal OS_HandleArray os_push_monitors_array(Arena *arena); -internal OS_Handle os_primary_monitor(void); -internal OS_Handle os_monitor_from_window(OS_Handle window); -internal String8 os_name_from_monitor(Arena *arena, OS_Handle monitor); -internal Vec2F32 os_dim_from_monitor(OS_Handle monitor); -internal F32 os_dpi_from_monitor(OS_Handle monitor); +internal OS_MonitorArray os_push_monitors_array(Arena *arena); +internal OS_Monitor os_primary_monitor(void); +internal OS_Monitor os_monitor_from_window(OS_Window window); +internal String8 os_name_from_monitor(Arena *arena, OS_Monitor monitor); +internal Vec2F32 os_dim_from_monitor(OS_Monitor monitor); +internal F32 os_dpi_from_monitor(OS_Monitor monitor); //////////////////////////////// //~ rjf: @os_hooks Events (Implemented Per-OS) @@ -186,7 +224,7 @@ internal void os_send_wakeup_event(void); internal OS_EventList os_get_events(Arena *arena, B32 wait); internal OS_Modifiers os_get_modifiers(void); internal B32 os_key_is_down(OS_Key key); -internal Vec2F32 os_mouse_from_window(OS_Handle window); +internal Vec2F32 os_mouse_from_window(OS_Window window); //////////////////////////////// //~ rjf: @os_hooks Cursors (Implemented Per-OS) diff --git a/src/os/gfx/win32/os_gfx_win32.c b/src/os/gfx/win32/os_gfx_win32.c index 4d7f7254..8ffa577d 100644 --- a/src/os/gfx/win32/os_gfx_win32.c +++ b/src/os/gfx/win32/os_gfx_win32.c @@ -32,15 +32,15 @@ os_w32_rng2f32_from_rect(RECT rect) //////////////////////////////// //~ rjf: Windows -internal OS_Handle +internal OS_Window os_w32_handle_from_window(OS_W32_Window *window) { - OS_Handle handle = {(U64)window}; + OS_Window handle = {(U64)window}; return handle; } internal OS_W32_Window * -os_w32_window_from_handle(OS_Handle handle) +os_w32_window_from_handle(OS_Window handle) { OS_W32_Window *window = (OS_W32_Window *)handle.u64[0]; return window; @@ -342,7 +342,7 @@ os_w32_wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) if(good) { OS_W32_Window *window = os_w32_window_from_hwnd(hwnd); - OS_Handle window_handle = os_w32_handle_from_window(window); + OS_Window window_handle = os_w32_handle_from_window(window); B32 release = 0; switch(uMsg) @@ -806,8 +806,11 @@ internal BOOL os_w32_monitor_gather_enum_proc(HMONITOR monitor, HDC hdc, LPRECT rect, LPARAM bundle_ptr) { OS_W32_MonitorGatherBundle *bundle = (OS_W32_MonitorGatherBundle *)bundle_ptr; - OS_Handle handle = {(U64)monitor}; - os_handle_list_push(bundle->arena, bundle->list, handle); + OS_Monitor m = {(U64)monitor}; + OS_W32_MonitorGatherNode *n = push_array(bundle->arena, OS_W32_MonitorGatherNode, 1); + n->v = m; + SLLQueuePush(bundle->first_monitor, bundle->last_monitor, n); + bundle->monitor_count += 1; return 1; } @@ -1052,7 +1055,7 @@ os_get_clipboard_text(Arena *arena) //////////////////////////////// //~ rjf: @os_hooks Windows (Implemented Per-OS) -internal OS_Handle +internal OS_Window os_window_open(Rng2F32 rect, OS_WindowFlags flags, String8 title) { B32 custom_border = !!(flags & OS_WindowFlag_CustomBorder); @@ -1116,19 +1119,19 @@ os_window_open(Rng2F32 rect, OS_WindowFlags flags, String8 title) } //- rjf: convert to handle + return - OS_Handle result = os_w32_handle_from_window(window); + OS_Window result = os_w32_handle_from_window(window); return result; } internal void -os_window_close(OS_Handle handle) +os_window_close(OS_Window handle) { OS_W32_Window *window = os_w32_window_from_handle(handle); os_w32_window_release(window); } internal void -os_window_set_title(OS_Handle handle, String8 title) +os_window_set_title(OS_Window handle, String8 title) { Temp scratch = scratch_begin(0, 0); OS_W32_Window *window = os_w32_window_from_handle(handle); @@ -1138,7 +1141,7 @@ os_window_set_title(OS_Handle handle, String8 title) } internal void -os_window_first_paint(OS_Handle window_handle) +os_window_first_paint(OS_Window window_handle) { OS_W32_Window *window = os_w32_window_from_handle(window_handle); window->first_paint_done = 1; @@ -1150,7 +1153,7 @@ os_window_first_paint(OS_Handle window_handle) } internal void -os_window_focus(OS_Handle handle) +os_window_focus(OS_Window handle) { OS_W32_Window *window = os_w32_window_from_handle(handle); SetForegroundWindow(window->hwnd); @@ -1158,7 +1161,7 @@ os_window_focus(OS_Handle handle) } internal B32 -os_window_is_focused(OS_Handle handle) +os_window_is_focused(OS_Window handle) { OS_W32_Window *window = os_w32_window_from_handle(handle); HWND active_hwnd = GetActiveWindow(); @@ -1166,7 +1169,7 @@ os_window_is_focused(OS_Handle handle) } internal B32 -os_window_is_fullscreen(OS_Handle handle) +os_window_is_fullscreen(OS_Window handle) { OS_W32_Window *window = os_w32_window_from_handle(handle); DWORD window_style = GetWindowLong(window->hwnd, GWL_STYLE); @@ -1174,7 +1177,7 @@ os_window_is_fullscreen(OS_Handle handle) } internal void -os_window_set_fullscreen(OS_Handle handle, B32 fullscreen) +os_window_set_fullscreen(OS_Window handle, B32 fullscreen) { OS_W32_Window *window = os_w32_window_from_handle(handle); DWORD window_style = GetWindowLong(window->hwnd, GWL_STYLE); @@ -1208,7 +1211,7 @@ os_window_set_fullscreen(OS_Handle handle, B32 fullscreen) } internal B32 -os_window_is_maximized(OS_Handle handle) +os_window_is_maximized(OS_Window handle) { B32 result = 0; OS_W32_Window *window = os_w32_window_from_handle(handle); @@ -1220,7 +1223,7 @@ os_window_is_maximized(OS_Handle handle) } internal void -os_window_set_maximized(OS_Handle handle, B32 maximized) +os_window_set_maximized(OS_Window handle, B32 maximized) { OS_W32_Window *window = os_w32_window_from_handle(handle); if(window != 0) @@ -1242,7 +1245,7 @@ os_window_set_maximized(OS_Handle handle, B32 maximized) } internal B32 -os_window_is_minimized(OS_Handle handle) +os_window_is_minimized(OS_Window handle) { B32 result = 0; OS_W32_Window *window = os_w32_window_from_handle(handle); @@ -1254,7 +1257,7 @@ os_window_is_minimized(OS_Handle handle) } internal void -os_window_set_minimized(OS_Handle handle, B32 minimized) +os_window_set_minimized(OS_Window handle, B32 minimized) { OS_W32_Window *window = os_w32_window_from_handle(handle); if(window != 0 && minimized != os_window_is_minimized(handle)) @@ -1269,7 +1272,7 @@ os_window_set_minimized(OS_Handle handle, B32 minimized) } internal void -os_window_bring_to_front(OS_Handle handle) +os_window_bring_to_front(OS_Window handle) { OS_W32_Window *window = os_w32_window_from_handle(handle); if(window != 0) @@ -1279,7 +1282,7 @@ os_window_bring_to_front(OS_Handle handle) } internal void -os_window_set_monitor(OS_Handle window_handle, OS_Handle monitor) +os_window_set_monitor(OS_Window window_handle, OS_Monitor monitor) { OS_W32_Window *window = os_w32_window_from_handle(window_handle); HMONITOR hmonitor = (HMONITOR)monitor.u64[0]; @@ -1300,7 +1303,7 @@ os_window_set_monitor(OS_Handle window_handle, OS_Handle monitor) } internal void -os_window_clear_custom_border_data(OS_Handle handle) +os_window_clear_custom_border_data(OS_Window handle) { OS_W32_Window *window = os_w32_window_from_handle(handle); if(window->custom_border) @@ -1313,21 +1316,21 @@ os_window_clear_custom_border_data(OS_Handle handle) } internal void -os_window_push_custom_title_bar(OS_Handle handle, F32 thickness) +os_window_push_custom_title_bar(OS_Window handle, F32 thickness) { OS_W32_Window *window = os_w32_window_from_handle(handle); window->custom_border_title_thickness = thickness; } internal void -os_window_push_custom_edges(OS_Handle handle, F32 thickness) +os_window_push_custom_edges(OS_Window handle, F32 thickness) { OS_W32_Window *window = os_w32_window_from_handle(handle); window->custom_border_edge_thickness = thickness; } internal void -os_window_push_custom_title_bar_client_area(OS_Handle handle, Rng2F32 rect) +os_window_push_custom_title_bar_client_area(OS_Window handle, Rng2F32 rect) { OS_W32_Window *window = os_w32_window_from_handle(handle); if(window->custom_border) @@ -1342,7 +1345,7 @@ os_window_push_custom_title_bar_client_area(OS_Handle handle, Rng2F32 rect) } internal Rng2F32 -os_rect_from_window(OS_Handle handle) +os_rect_from_window(OS_Window handle) { Rng2F32 r = {0}; OS_W32_Window *window = os_w32_window_from_handle(handle); @@ -1356,7 +1359,7 @@ os_rect_from_window(OS_Handle handle) } internal Rng2F32 -os_client_rect_from_window(OS_Handle handle) +os_client_rect_from_window(OS_Window handle) { Rng2F32 r = {0}; OS_W32_Window *window = os_w32_window_from_handle(handle); @@ -1370,7 +1373,7 @@ os_client_rect_from_window(OS_Handle handle) } internal F32 -os_dpi_from_window(OS_Handle handle) +os_dpi_from_window(OS_Window handle) { F32 result = 96.f; OS_W32_Window *window = os_w32_window_from_handle(handle); @@ -1384,16 +1387,16 @@ os_dpi_from_window(OS_Handle handle) //////////////////////////////// //~ rjf: @os_hooks External Windows (Implemented Per-OS) -internal OS_Handle +internal OS_ExternalWindow os_focused_external_window(void) { HWND hwnd = GetForegroundWindow(); - OS_Handle result = {(U64)hwnd}; + OS_ExternalWindow result = {(U64)hwnd}; return result; } internal void -os_focus_external_window(OS_Handle handle) +os_focus_external_window(OS_ExternalWindow handle) { HWND hwnd = (HWND)handle.u64[0]; if(hwnd != 0) @@ -1406,40 +1409,47 @@ os_focus_external_window(OS_Handle handle) //////////////////////////////// //~ rjf: @os_hooks Monitors (Implemented Per-OS) -internal OS_HandleArray +internal OS_MonitorArray os_push_monitors_array(Arena *arena) { Temp scratch = scratch_begin(&arena, 1); - OS_HandleList list = {0}; + OS_W32_MonitorGatherBundle bundle = {arena}; + EnumDisplayMonitors(0, 0, os_w32_monitor_gather_enum_proc, (LPARAM)&bundle); + OS_MonitorArray array = {0}; + array.count = bundle.monitor_count; + array.v = push_array(arena, OS_Monitor, array.count); { - OS_W32_MonitorGatherBundle bundle = {arena, &list}; - EnumDisplayMonitors(0, 0, os_w32_monitor_gather_enum_proc, (LPARAM)&bundle); + U64 idx = 0; + for EachNode(n, OS_W32_MonitorGatherNode, bundle.first_monitor) + { + array.v[idx] = n->v; + idx += 1; + } } - OS_HandleArray array = os_handle_array_from_list(arena, &list); scratch_end(scratch); return array; } -internal OS_Handle +internal OS_Monitor os_primary_monitor(void) { POINT zero_pt = {0, 0}; HMONITOR monitor = MonitorFromPoint(zero_pt, MONITOR_DEFAULTTOPRIMARY); - OS_Handle result = {(U64)monitor}; + OS_Monitor result = {(U64)monitor}; return result; } -internal OS_Handle -os_monitor_from_window(OS_Handle window) +internal OS_Monitor +os_monitor_from_window(OS_Window window) { OS_W32_Window *w = os_w32_window_from_handle(window); HMONITOR handle = MonitorFromWindow(w->hwnd, MONITOR_DEFAULTTOPRIMARY); - OS_Handle result = {(U64)handle}; + OS_Monitor result = {(U64)handle}; return result; } internal String8 -os_name_from_monitor(Arena *arena, OS_Handle monitor) +os_name_from_monitor(Arena *arena, OS_Monitor monitor) { String8 result = {0}; HMONITOR monitor_handle = (HMONITOR)monitor.u64[0]; @@ -1454,7 +1464,7 @@ os_name_from_monitor(Arena *arena, OS_Handle monitor) } internal Vec2F32 -os_dim_from_monitor(OS_Handle monitor) +os_dim_from_monitor(OS_Monitor monitor) { Vec2F32 result = {0}; HMONITOR monitor_handle = (HMONITOR)monitor.u64[0]; @@ -1469,7 +1479,7 @@ os_dim_from_monitor(OS_Handle monitor) } internal F32 -os_dpi_from_monitor(OS_Handle monitor) +os_dpi_from_monitor(OS_Monitor monitor) { F32 result = 96.f; HMONITOR monitor_handle = (HMONITOR)monitor.u64[0]; @@ -1546,7 +1556,7 @@ os_key_is_down(OS_Key key) } internal Vec2F32 -os_mouse_from_window(OS_Handle handle) +os_mouse_from_window(OS_Window handle) { ProfBeginFunction(); Vec2F32 v = {0}; diff --git a/src/os/gfx/win32/os_gfx_win32.h b/src/os/gfx/win32/os_gfx_win32.h index 82c03278..8dc95691 100644 --- a/src/os/gfx/win32/os_gfx_win32.h +++ b/src/os/gfx/win32/os_gfx_win32.h @@ -54,11 +54,20 @@ struct OS_W32_Window //////////////////////////////// //~ rjf: Monitor Gathering Bundle +typedef struct OS_W32_MonitorGatherNode OS_W32_MonitorGatherNode; +struct OS_W32_MonitorGatherNode +{ + OS_W32_MonitorGatherNode *next; + OS_Monitor v; +}; + typedef struct OS_W32_MonitorGatherBundle OS_W32_MonitorGatherBundle; struct OS_W32_MonitorGatherBundle { Arena *arena; - OS_HandleList *list; + OS_W32_MonitorGatherNode *first_monitor; + OS_W32_MonitorGatherNode *last_monitor; + U64 monitor_count; }; //////////////////////////////// @@ -95,8 +104,8 @@ internal Rng2F32 os_w32_rng2f32_from_rect(RECT rect); //////////////////////////////// //~ rjf: Windows -internal OS_Handle os_w32_handle_from_window(OS_W32_Window *window); -internal OS_W32_Window * os_w32_window_from_handle(OS_Handle window); +internal OS_Window os_w32_handle_from_window(OS_W32_Window *window); +internal OS_W32_Window * os_w32_window_from_handle(OS_Window window); internal OS_W32_Window * os_w32_window_from_hwnd(HWND hwnd); internal HWND os_w32_hwnd_from_window(OS_W32_Window *window); internal OS_W32_Window * os_w32_window_alloc(void); diff --git a/src/os/os_inc.c b/src/os/os_inc.c index 37c3e2aa..555089ca 100644 --- a/src/os/os_inc.c +++ b/src/os/os_inc.c @@ -1,13 +1,13 @@ // Copyright (c) Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) -#include "os/core/os_core.c" +// #include "os/core/os_core.c" #if OS_FEATURE_GRAPHICAL # include "os/gfx/os_gfx.c" #endif #if OS_WINDOWS -# include "os/core/win32/os_core_win32.c" +// # include "os/core/win32/os_core_win32.c" #elif OS_LINUX # include "os/core/linux/os_core_linux.c" #else diff --git a/src/os/os_inc.h b/src/os/os_inc.h index d581fe6a..233b55d3 100644 --- a/src/os/os_inc.h +++ b/src/os/os_inc.h @@ -12,13 +12,13 @@ # define OS_GFX_STUB 0 #endif -#include "os/core/os_core.h" +// #include "os/core/os_core.h" #if OS_FEATURE_GRAPHICAL # include "os/gfx/os_gfx.h" #endif #if OS_WINDOWS -# include "os/core/win32/os_core_win32.h" +// # include "os/core/win32/os_core_win32.h" #elif OS_LINUX # include "os/core/linux/os_core_linux.h" #else diff --git a/src/pe/pe.c b/src/pe/pe.c index 2a967c2c..85d9ed17 100644 --- a/src/pe/pe.c +++ b/src/pe/pe.c @@ -520,10 +520,6 @@ pe_bin_info_from_data(Arena *arena, String8 data) reported_data_dir_offset = sizeof(*pe_optional); reported_data_dir_count = pe_optional->data_dir_count; } - else - { - Assert(!"unable to read PE Optional Header"); - } }break; case PE_PE32PLUS_MAGIC: { @@ -539,10 +535,6 @@ pe_bin_info_from_data(Arena *arena, String8 data) reported_data_dir_offset = sizeof(*pe_optional); reported_data_dir_count = pe_optional->data_dir_count; } - else - { - Assert(!"unable to read PE Optional Plus Header"); - } }break; } @@ -561,10 +553,6 @@ pe_bin_info_from_data(Arena *arena, String8 data) U64 file_off = coff_foff_from_voff(sections, clamped_sec_count, dir.virt_off); data_dir_franges[dir_idx] = r1u64(file_off, file_off+dir.virt_size); } - else - { - Assert(!"unable to read data directory"); - } } // export virtual directory ranges @@ -577,10 +565,6 @@ pe_bin_info_from_data(Arena *arena, String8 data) { data_dir_vranges[dir_idx] = r1u64(dir.virt_off, dir.virt_off+dir.virt_size); } - else - { - Assert(!"unable to read data directory"); - } } // export directory range @@ -608,17 +592,12 @@ pe_bin_info_from_data(Arena *arena, String8 data) tls_header.zero_fill_size = (U64)tls_header32.zero_fill_size; tls_header.characteristics = (U64)tls_header32.characteristics; } - else - { - Assert(!"unable to read TLS Header 32"); - } }break; case COFF_MachineType_X64: { if(str8_deserial_read_struct(data, tls_header_frng.min, &tls_header) != sizeof(tls_header)) { MemoryZeroStruct(&tls_header); - Assert(!"unable to read TLS Header 64"); } }break; } diff --git a/src/radbin/radbin.c b/src/radbin/radbin.c index 92d142f2..734a6d85 100644 --- a/src/radbin/radbin.c +++ b/src/radbin/radbin.c @@ -13,7 +13,7 @@ internal void rb_entry_point(CmdLine *cmdline) { Temp scratch = scratch_begin(0, 0); - U64 threads_count = os_get_system_info()->logical_processor_count; + U64 threads_count = get_system_info()->logical_processor_count; String8 threads_count_from_cmdline_string = cmd_line_string(cmdline, str8_lit("thread_count")); if(threads_count_from_cmdline_string.size != 0) { @@ -70,7 +70,7 @@ rb_thread_entry_point(void *p) // ProfScope("analyze & load command line input files") if(lane_idx() == 0) { - String8 working_directory = os_get_current_path(arena); + String8 working_directory = get_current_path(arena); String8List input_file_path_tasks = str8_list_copy(arena, &cmdline->inputs); for(String8Node *n = input_file_path_tasks.first; n != 0; n = n->next) { @@ -93,14 +93,14 @@ rb_thread_entry_point(void *p) RB_FileFormatFlags file_format_flags = 0; ProfScope("do thin analysis of file") { - OS_Handle file = os_file_open(OS_AccessFlag_Read|OS_AccessFlag_ShareRead, input_file_path); - FileProperties props = os_properties_from_file(file); + File file = file_open(AccessFlag_Read|AccessFlag_ShareRead, input_file_path); + FileProperties props = properties_from_file(file); //- rjf: PDB magic -> PDB input if(file_format == RB_FileFormat_Null) { U8 msf20_magic_maybe[sizeof(msf_msf20_magic)] = {0}; - os_file_read(file, r1u64(0, sizeof(msf20_magic_maybe)), msf20_magic_maybe); + file_read(file, r1u64(0, sizeof(msf20_magic_maybe)), msf20_magic_maybe); if(MemoryMatch(msf20_magic_maybe, msf_msf20_magic, sizeof(msf20_magic_maybe))) { file_format = RB_FileFormat_PDB; @@ -109,7 +109,7 @@ rb_thread_entry_point(void *p) if(file_format == RB_FileFormat_Null) { U8 msf70_magic_maybe[sizeof(msf_msf70_magic)] = {0}; - os_file_read(file, r1u64(0, sizeof(msf70_magic_maybe)), msf70_magic_maybe); + file_read(file, r1u64(0, sizeof(msf70_magic_maybe)), msf70_magic_maybe); if(MemoryMatch(msf70_magic_maybe, msf_msf70_magic, sizeof(msf70_magic_maybe))) { file_format = RB_FileFormat_PDB; @@ -120,11 +120,11 @@ rb_thread_entry_point(void *p) if(file_format == RB_FileFormat_Null) { PE_DosHeader dos_header_maybe = {0}; - os_file_read_struct(file, 0, &dos_header_maybe); + file_read_struct(file, 0, &dos_header_maybe); if(dos_header_maybe.magic == PE_DOS_MAGIC) { U32 pe_magic_maybe = 0; - os_file_read_struct(file, dos_header_maybe.coff_file_offset, &pe_magic_maybe); + file_read_struct(file, dos_header_maybe.coff_file_offset, &pe_magic_maybe); if(pe_magic_maybe == PE_MAGIC) { file_format = RB_FileFormat_PE; @@ -136,7 +136,7 @@ rb_thread_entry_point(void *p) if(file_format == RB_FileFormat_Null) { U8 coff_archive_sig_maybe[sizeof(g_coff_archive_sig)] = {0}; - os_file_read(file, r1u64(0, sizeof(coff_archive_sig_maybe)), coff_archive_sig_maybe); + file_read(file, r1u64(0, sizeof(coff_archive_sig_maybe)), coff_archive_sig_maybe); if(MemoryMatch(coff_archive_sig_maybe, g_coff_archive_sig, sizeof(g_coff_archive_sig))) { file_format = RB_FileFormat_COFF_Archive; @@ -145,7 +145,7 @@ rb_thread_entry_point(void *p) if(file_format == RB_FileFormat_Null) { U8 coff_thin_archive_sig_maybe[sizeof(g_coff_thin_archive_sig)] = {0}; - os_file_read(file, r1u64(0, sizeof(coff_thin_archive_sig_maybe)), coff_thin_archive_sig_maybe); + file_read(file, r1u64(0, sizeof(coff_thin_archive_sig_maybe)), coff_thin_archive_sig_maybe); if(MemoryMatch(coff_thin_archive_sig_maybe, g_coff_thin_archive_sig, sizeof(g_coff_thin_archive_sig))) { file_format = RB_FileFormat_COFF_ThinArchive; @@ -156,7 +156,7 @@ rb_thread_entry_point(void *p) if(file_format == RB_FileFormat_Null) { COFF_BigObjHeader header_maybe = {0}; - os_file_read_struct(file, 0, &header_maybe); + file_read_struct(file, 0, &header_maybe); if(header_maybe.sig1 == COFF_MachineType_Unknown && header_maybe.sig2 == max_U16 && header_maybe.version >= 2 && @@ -169,7 +169,7 @@ rb_thread_entry_point(void *p) { Temp scratch = scratch_begin(&arena, 1); COFF_FileHeader header_maybe = {0}; - os_file_read_struct(file, 0, &header_maybe); + file_read_struct(file, 0, &header_maybe); U64 section_count = header_maybe.section_count; U64 section_hdr_opl_off = sizeof(header_maybe) + section_count*sizeof(COFF_SectionHeader); @@ -202,7 +202,7 @@ rb_thread_entry_point(void *p) if(props.size >= section_hdr_opl_off) { COFF_SectionHeader *section_hdrs = push_array(scratch.arena, COFF_SectionHeader, section_count); - os_file_read(file, r1u64(sizeof(header_maybe), sizeof(header_maybe) + section_count*sizeof(COFF_SectionHeader)), section_hdrs); + file_read(file, r1u64(sizeof(header_maybe), sizeof(header_maybe) + section_count*sizeof(COFF_SectionHeader)), section_hdrs); B32 section_ranges_valid = 1; for EachIndex(section_hdr_idx, section_count) { @@ -252,7 +252,7 @@ rb_thread_entry_point(void *p) if(file_format == RB_FileFormat_Null) { U8 identifier_maybe[ELF_Identifier_Max] = {0}; - os_file_read(file, r1u64(0, sizeof(identifier_maybe)), identifier_maybe); + file_read(file, r1u64(0, sizeof(identifier_maybe)), identifier_maybe); B32 is_elf_magic = (identifier_maybe[ELF_Identifier_Mag0] == 0x7f && identifier_maybe[ELF_Identifier_Mag1] == 'E' && identifier_maybe[ELF_Identifier_Mag2] == 'L' && @@ -267,14 +267,14 @@ rb_thread_entry_point(void *p) if(file_format == RB_FileFormat_Null) { RDI_Header rdi_header_maybe = {0}; - os_file_read_struct(file, 0, &rdi_header_maybe); + file_read_struct(file, 0, &rdi_header_maybe); if(rdi_header_maybe.magic == RDI_MAGIC_CONSTANT) { file_format = RB_FileFormat_RDI; } } - os_file_close(file); + file_close(file); } ////////////////////////// @@ -295,7 +295,7 @@ rb_thread_entry_point(void *p) String8 file_data = {0}; if(file_format != RB_FileFormat_Null) ProfScope("load recognized file") { - file_data = os_data_from_file_path(arena, input_file_path); + file_data = data_from_file_path(arena, input_file_path); } ////////////////////////// @@ -1593,7 +1593,7 @@ rb_thread_entry_point(void *p) { if(output_path.size != 0) ProfScope("write outputs [file]") { - B32 is_written = os_write_data_list_to_file_path(output_path, output_blobs); + B32 is_written = write_data_list_to_file_path(output_path, output_blobs); if(is_written) { log_infof("Results written to %S", output_path); diff --git a/src/radbin/radbin_main.c b/src/radbin/radbin_main.c index 7d6db3f5..ee14fe07 100644 --- a/src/radbin/radbin_main.c +++ b/src/radbin/radbin_main.c @@ -33,6 +33,7 @@ #include "pdb/pdb.h" #include "pdb/pdb_parse.h" #include "pdb/pdb_stringize.h" +#include "arch/arch_inc.h" #include "rdi_from_coff/rdi_from_coff.h" #include "rdi_from_elf/rdi_from_elf.h" #include "rdi_from_pdb/rdi_from_pdb.h" @@ -63,6 +64,7 @@ #include "pdb/pdb.c" #include "pdb/pdb_parse.c" #include "pdb/pdb_stringize.c" +#include "arch/arch_inc.c" #include "rdi_from_coff/rdi_from_coff.c" #include "rdi_from_elf/rdi_from_elf.c" #include "rdi_from_pdb/rdi_from_pdb.c" diff --git a/src/raddbg/raddbg_core.c b/src/raddbg/raddbg_core.c index 966d78ad..334826b6 100644 --- a/src/raddbg/raddbg_core.c +++ b/src/raddbg/raddbg_core.c @@ -784,7 +784,8 @@ rd_eval_space_read(E_Space space, void *out, Rng1U64 range) } if(regs_block != 0) { - U64 regs_size = regs_block_size_from_arch(e_interpret_ctx->reg_arch); + ARCH_Info *arch_info = arch_info_from_arch(entity->arch); + U64 regs_size = arch_info->reg_block_size; Rng1U64 legal_range = r1u64(0, regs_size); Rng1U64 read_range = intersect_1u64(legal_range, range); U64 read_size = dim_1u64(read_range); @@ -1013,7 +1014,8 @@ rd_eval_space_write(E_Space space, void *in, Rng1U64 range) case D_EntityKind_Thread: { Temp scratch = scratch_begin(0, 0); - U64 regs_size = regs_block_size_from_arch(entity->arch); + ARCH_Info *arch_info = arch_info_from_arch(entity->arch); + U64 regs_size = arch_info->reg_block_size; Rng1U64 legal_range = r1u64(0, regs_size); Rng1U64 write_range = intersect_1u64(legal_range, range); U64 write_size = dim_1u64(write_range); @@ -1186,7 +1188,7 @@ rd_whole_range_from_eval_space(E_Space space) { U64 file_path_string_id = space.u64_0; String8 file_path = e_string_from_id(file_path_string_id); - FileProperties props = os_properties_from_file_path(file_path); + FileProperties props = properties_from_file_path(file_path); result = r1u64(0, props.size); }break; case D_EvalSpaceKind_Entity: @@ -4935,7 +4937,7 @@ rd_window_state_from_cfg(CFG_Node *cfg) B32 has_pos = 0; Vec2F32 pos = {0}; Vec2F32 size = {0}; - OS_Handle preferred_monitor = {0}; + OS_Monitor preferred_monitor = {0}; { CFG_Node *pos_cfg = cfg_node_child_from_string(window_cfg, str8_lit("pos")); has_pos = (pos_cfg != &cfg_nil_node); @@ -4945,7 +4947,7 @@ rd_window_state_from_cfg(CFG_Node *cfg) pos.y = (F32)f64_from_str8(pos_cfg->first->next->string); size.x = (F32)f64_from_str8(size_cfg->first->string); size.y = (F32)f64_from_str8(size_cfg->first->next->string); - OS_HandleArray monitors = os_push_monitors_array(scratch.arena); + OS_MonitorArray monitors = os_push_monitors_array(scratch.arena); for EachIndex(idx, monitors.count) { String8 monitor_name = os_name_from_monitor(scratch.arena, monitors.v[idx]); @@ -4983,8 +4985,8 @@ rd_window_state_from_cfg(CFG_Node *cfg) ws->hover_eval_arena = arena_alloc(); ws->autocomp_arena = arena_alloc(); ws->last_dpi = os_dpi_from_window(ws->os); - OS_Handle zero_monitor = {0}; - if(!os_handle_match(zero_monitor, preferred_monitor)) + OS_Monitor zero_monitor = {0}; + if(!os_monitor_match(zero_monitor, preferred_monitor)) { os_window_set_monitor(ws->os, preferred_monitor); } @@ -5019,7 +5021,7 @@ rd_window_state_from_cfg(CFG_Node *cfg) } internal RD_WindowState * -rd_window_state_from_os_handle(OS_Handle os) +rd_window_state_from_os_handle(OS_Window os) { RD_WindowState *ws = &rd_nil_window_state; { @@ -5027,7 +5029,7 @@ rd_window_state_from_os_handle(OS_Handle os) w != &rd_nil_window_state; w = w->order_next) { - if(os_handle_match(w->os, os)) + if(os_window_match(w->os, os)) { ws = w; break; @@ -5343,7 +5345,7 @@ rd_window_frame(void) //- rjf: commit monitor if(!is_minimized) { - OS_Handle monitor = os_monitor_from_window(ws->os); + OS_Monitor monitor = os_monitor_from_window(ws->os); String8 monitor_name = os_name_from_monitor(scratch.arena, monitor); CFG_Node *monitor_root = cfg_node_child_from_string_or_alloc(rd_state->cfg, window, str8_lit("monitor")); if(!str8_match(monitor_root->first->string, monitor_name, 0)) @@ -5478,7 +5480,7 @@ rd_window_frame(void) case RD_RegSlot_FilePath: UI_Tooltip { - FileProperties props = os_properties_from_file_path(regs->file_path); + FileProperties props = properties_from_file_path(regs->file_path); ui_set_next_pref_width(ui_children_sum(1)); UI_Row { @@ -9434,11 +9436,11 @@ rd_theme_tree_from_name(Arena *arena, Access *access, String8 theme_name) } if(theme_tree == &md_nil_node) { - String8 path = push_str8f(scratch.arena, "%S/raddbg/themes/%S", os_get_process_info()->user_program_data_path, theme_name); - U64 endt_us = os_now_microseconds()+100; + String8 path = str8f(scratch.arena, "%S/raddbg/themes/%S", get_process_info()->user_program_data_path, theme_name); + U64 endt_us = now_time_us()+100; if(rd_state->frame_index <= 5) { - endt_us = os_now_microseconds()+50000; + endt_us = now_time_us()+50000; } U128 hash = fs_hash_from_path_range(path, r1u64(0, max_U64), endt_us); String8 data = c_data_from_hash(access, hash); @@ -9515,17 +9517,6 @@ rd_code_color_slot_from_txt_token_kind_lookup_string(TXT_TokenKind kind, String8 } } - // rjf: try to map as register alias - if(!mapped) - { - U64 alias_num = e_num_from_string(e_ir_ctx->reg_alias_map, string); - if(alias_num != 0) - { - mapped = 1; - color = RD_CodeColorSlot_CodeRegister; - } - } - // rjf: try to map as macro if((!mapped || is_called) && allow_macros) { @@ -10100,11 +10091,11 @@ rd_init(CmdLine *cmdln) log_select(rd_state->log); { Temp scratch = scratch_begin(0, 0); - String8 user_program_data_path = os_get_process_info()->user_program_data_path; + String8 user_program_data_path = get_process_info()->user_program_data_path; String8 user_data_folder = push_str8f(scratch.arena, "%S/raddbg/logs", user_program_data_path); rd_state->log_path = push_str8f(rd_state->arena, "%S/ui_thread.raddbg_log", user_data_folder); - os_make_directory(user_data_folder); - os_write_data_to_file_path(rd_state->log_path, str8_zero()); + make_directory(user_data_folder); + write_data_to_file_path(rd_state->log_path, str8_zero()); scratch_end(scratch); } rd_state->num_frames_requested = 2; @@ -10214,17 +10205,17 @@ rd_init(CmdLine *cmdln) B32 is_cfg = 0; if(!is_flag && !after_first_non_flag) { - OS_Handle file = os_file_open(OS_AccessFlag_Read|OS_AccessFlag_ShareRead, arg); + File file = file_open(AccessFlag_Read|AccessFlag_ShareRead, arg); U8 raddbg_cfg_magic[] = "// raddbg "; U8 file_magic_maybe[ArrayCount(raddbg_cfg_magic)] = {0}; - os_file_read(file, r1u64(0, 10), file_magic_maybe); + file_read(file, r1u64(0, 10), file_magic_maybe); if(MemoryMatchArray(raddbg_cfg_magic, file_magic_maybe)) { is_cfg = 1; U8 header_suffix_buffer[256] = {0}; String8 header_suffix = {0}; header_suffix.str = header_suffix_buffer; - header_suffix.size = os_file_read(file, r1u64(10, 10+256), header_suffix_buffer); + header_suffix.size = file_read(file, r1u64(10, 10+256), header_suffix_buffer); String8 header_type_suffix = str8_skip(header_suffix, str8_find_needle(header_suffix, 0, str8_lit(" "), 0)+1); if(str8_match(header_type_suffix, str8_lit("user"), StringMatchFlag_RightSideSloppy)) { @@ -10235,7 +10226,7 @@ rd_init(CmdLine *cmdln) implicit_project_arg = arg; } } - os_file_close(file); + file_close(file); } if(!is_flag) { @@ -10261,7 +10252,7 @@ rd_init(CmdLine *cmdln) PathStyle style = path_style_from_str8(exe_name); if(style == PathStyle_Relative) { - String8 current_path = os_get_current_path(scratch.arena); + String8 current_path = get_current_path(scratch.arena); exe_name = push_str8f(scratch.arena, "%S/%S", current_path, exe_name); exe_name = path_normalized_from_string(scratch.arena, exe_name); } @@ -10270,7 +10261,7 @@ rd_init(CmdLine *cmdln) // rjf: get current directory, use as working directory { - working_directory_string = path_normalized_from_string(scratch.arena, os_get_current_path(scratch.arena)); + working_directory_string = path_normalized_from_string(scratch.arena, get_current_path(scratch.arena)); } // rjf: unpack arguments @@ -10314,17 +10305,17 @@ rd_init(CmdLine *cmdln) { if(user_path.size != 0) { - user_path = path_absolute_dst_from_relative_dst_src(scratch.arena, user_path, os_get_process_info()->initial_path); + user_path = path_absolute_dst_from_relative_dst_src(scratch.arena, user_path, get_process_info()->initial_path); } if(project_path.size != 0) { - project_path = path_absolute_dst_from_relative_dst_src(scratch.arena, project_path, os_get_process_info()->initial_path); + project_path = path_absolute_dst_from_relative_dst_src(scratch.arena, project_path, get_process_info()->initial_path); } } { - String8 user_program_data_path = os_get_process_info()->user_program_data_path; + String8 user_program_data_path = get_process_info()->user_program_data_path; String8 user_data_folder = push_str8f(scratch.arena, "%S/raddbg", user_program_data_path); - os_make_directory(user_data_folder); + make_directory(user_data_folder); if(user_path.size == 0) { user_path = implicit_user_arg; @@ -10332,7 +10323,7 @@ rd_init(CmdLine *cmdln) if(user_path.size == 0) { String8 last_user_path = push_str8f(scratch.arena, "%S/last_user", user_data_folder); - user_path = os_data_from_file_path(scratch.arena, last_user_path); + user_path = data_from_file_path(scratch.arena, last_user_path); } if(user_path.size == 0) { @@ -10837,7 +10828,7 @@ rd_frame(void) if(frame_time_history_avg_us < frame_time_target_cap_us) { U64 spare_time = (frame_time_target_cap_us - frame_time_history_avg_us) + 4000; - rd_state->frame_eval_memread_endt_us = os_now_microseconds() + spare_time; + rd_state->frame_eval_memread_endt_us = now_time_us() + spare_time; } } @@ -10849,19 +10840,19 @@ rd_frame(void) ////////////////////////////// //- rjf: begin measuring actual per-frame work // - U64 begin_time_us = os_now_microseconds(); + U64 begin_time_us = now_time_us(); ////////////////////////////// //- rjf: bind change // if(!rd_state->popup_active && rd_state->bind_change_active) { - if(os_key_press(&events, os_handle_zero(), 0, OS_Key_Esc)) + if(os_key_press(&events, os_window_zero(), 0, OS_Key_Esc)) { rd_request_frame(); rd_state->bind_change_active = 0; } - if(os_key_press(&events, os_handle_zero(), 0, OS_Key_Delete)) + if(os_key_press(&events, os_window_zero(), 0, OS_Key_Delete)) { rd_request_frame(); cfg_node_release(rd_state->cfg, cfg_node_from_id(rd_state->bind_change_binding_id)); @@ -12042,7 +12033,6 @@ rd_frame(void) { E_IRCtx *ctx = ir_ctx; 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; @@ -12286,7 +12276,7 @@ rd_frame(void) String8 current_path_string = current_path->first->string; if(current_path_string.size == 0) { - current_path_string = path_normalized_from_string(scratch.arena, os_get_current_path(scratch.arena)); + current_path_string = path_normalized_from_string(scratch.arena, get_current_path(scratch.arena)); } String8 file_path = os_graphical_pick_file(scratch.arena, current_path_string); file_path = path_normalized_from_string(scratch.arena, file_path); @@ -12506,8 +12496,8 @@ rd_frame(void) //- rjf: load the new file's data String8 file_path = rd_regs()->file_path; - String8 file_data = os_data_from_file_path(scratch.arena, file_path); - FileProperties file_props = os_properties_from_file_path(file_path); + String8 file_data = data_from_file_path(scratch.arena, file_path); + FileProperties file_props = properties_from_file_path(file_path); //- rjf: determine if the file is good B32 file_is_okay = 0; @@ -12593,7 +12583,7 @@ rd_frame(void) CFG_NodePtrList all_user_windows = cfg_node_child_list_from_string(scratch.arena, file_root, str8_lit("window")); if(all_user_windows.count == 0) { - OS_Handle monitor = os_primary_monitor(); + OS_Monitor monitor = os_primary_monitor(); String8 monitor_name = os_name_from_monitor(scratch.arena, monitor); Vec2F32 monitor_dim = os_dim_from_monitor(monitor); F32 monitor_dpi = os_dpi_from_monitor(monitor); @@ -12676,9 +12666,9 @@ rd_frame(void) String8 project_path = rd_path_from_cfg(recent_project); if(project_path.size == 0) { - String8 user_program_data_path = os_get_process_info()->user_program_data_path; + String8 user_program_data_path = get_process_info()->user_program_data_path; String8 user_data_folder = push_str8f(scratch.arena, "%S/%S", user_program_data_path, str8_lit("raddbg")); - os_make_directory(user_data_folder); + make_directory(user_data_folder); project_path = push_str8f(scratch.arena, "%S/default.raddbg_project", user_data_folder); } rd_cmd(RD_CmdKind_OpenProject, .file_path = project_path); @@ -12688,7 +12678,7 @@ rd_frame(void) case RD_CmdKind_NewProject: { String8 new_path = rd_regs()->file_path; - B32 file_will_be_overwritten = (os_properties_from_file_path(new_path).created != 0); + B32 file_will_be_overwritten = (properties_from_file_path(new_path).created != 0); UI_Key key = ui_key_from_string(ui_key_zero(), str8_lit("new_config_overwrite_confirm")); if(file_will_be_overwritten && !rd_regs()->force_confirm && !ui_key_match(rd_state->popup_key, key)) { @@ -12707,12 +12697,12 @@ rd_frame(void) default:{}break; case RD_CmdKind_NewUser: { - os_delete_file_at_path(new_path); + delete_file_at_path(new_path); rd_cmd(RD_CmdKind_OpenUser, .file_path = new_path); }break; case RD_CmdKind_NewProject: { - os_delete_file_at_path(new_path); + delete_file_at_path(new_path); rd_cmd(RD_CmdKind_OpenProject, .file_path = new_path); }break; } @@ -12721,7 +12711,7 @@ rd_frame(void) case RD_CmdKind_SaveProject: { String8 new_path = rd_regs()->file_path; - B32 file_will_be_overwritten = (os_properties_from_file_path(new_path).created != 0); + B32 file_will_be_overwritten = (properties_from_file_path(new_path).created != 0); UI_Key key = ui_key_from_string(ui_key_zero(), str8_lit("save_config_overwrite_confirm")); if(file_will_be_overwritten && !rd_regs()->force_confirm && !ui_key_match(rd_state->popup_key, key)) { @@ -12785,8 +12775,8 @@ rd_frame(void) case RD_CmdKind_RecordUserAsLastOpened: { String8 file_path = rd_regs()->file_path; - String8 last_user_path = push_str8f(scratch.arena, "%S/raddbg/last_user", os_get_process_info()->user_program_data_path); - os_write_data_to_file_path(last_user_path, file_path); + String8 last_user_path = str8f(scratch.arena, "%S/raddbg/last_user", get_process_info()->user_program_data_path); + write_data_to_file_path(last_user_path, file_path); }break; //- rjf: writing config changes @@ -12794,7 +12784,7 @@ rd_frame(void) case RD_CmdKind_WriteProjectData: dst_path = rd_state->project_path; bucket_name = str8_lit("project"); goto write; write:; { - B32 dst_exists = (os_properties_from_file_path(dst_path).created != 0); + B32 dst_exists = (properties_from_file_path(dst_path).created != 0); String8 temp_path = push_str8f(scratch.arena, "%S.temp", dst_path); String8 overwritten_path = push_str8f(scratch.arena, "%S.old", dst_path); CFG_Node *tree_root = cfg_node_child_from_string(cfg_node_root(), bucket_name); @@ -12805,17 +12795,17 @@ rd_frame(void) str8_list_push(scratch.arena, &strings, cfg_string_from_tree(scratch.arena, rd_state->cfg_schema_table, str8_chop_last_slash(dst_path), child)); } String8 data = str8_list_join(scratch.arena, &strings, 0); - B32 temp_write_good = os_write_data_to_file_path(temp_path, data); - B32 old_del_good = (temp_write_good && os_delete_file_at_path(overwritten_path)); - B32 old_move_good = (temp_write_good && (!dst_exists || os_move_file_path(overwritten_path, dst_path))); - B32 new_move_good = (old_move_good && os_move_file_path(dst_path, temp_path)); + B32 temp_write_good = write_data_to_file_path(temp_path, data); + B32 old_del_good = (temp_write_good && delete_file_at_path(overwritten_path)); + B32 old_move_good = (temp_write_good && (!dst_exists || move_file_path(overwritten_path, dst_path))); + B32 new_move_good = (old_move_good && move_file_path(dst_path, temp_path)); if(new_move_good && dst_exists) { - os_delete_file_at_path(overwritten_path); + delete_file_at_path(overwritten_path); } else if(!new_move_good && old_move_good && dst_exists) { - os_move_file_path(dst_path, overwritten_path); + move_file_path(dst_path, overwritten_path); } }break; @@ -13639,8 +13629,8 @@ rd_frame(void) //- rjf: files case RD_CmdKind_Open: { - String8 path = path_absolute_dst_from_relative_dst_src(scratch.arena, rd_regs()->file_path, os_get_current_path(scratch.arena)); - FileProperties props = os_properties_from_file_path(path); + String8 path = path_absolute_dst_from_relative_dst_src(scratch.arena, rd_regs()->file_path, get_current_path(scratch.arena)); + FileProperties props = properties_from_file_path(path); if(props.created != 0) { rd_cmd(RD_CmdKind_RecordFileInProject); @@ -13686,9 +13676,9 @@ rd_frame(void) { if(!str8_match(partner_ext_candidates[idx], file_ext, StringMatchFlag_CaseInsensitive)) { - String8 candidate = push_str8f(scratch.arena, "%S.%S", file_name, partner_ext_candidates[idx]); - String8 candidate_path = push_str8f(scratch.arena, "%S/%S", file_folder, candidate); - FileProperties candidate_props = os_properties_from_file_path(candidate_path); + String8 candidate = str8f(scratch.arena, "%S.%S", file_name, partner_ext_candidates[idx]); + String8 candidate_path = str8f(scratch.arena, "%S/%S", file_folder, candidate); + FileProperties candidate_props = properties_from_file_path(candidate_path); if(candidate_props.modified != 0) { rd_cmd(RD_CmdKind_FindCodeLocation, .file_path = candidate_path, .cursor = txt_pt(0, 0), .vaddr = 0, .prefer_new_tab = 1); @@ -14173,7 +14163,7 @@ rd_frame(void) str8_list_push(temp.arena, &try_path_parts, try_n->string); } String8 try_path = str8_list_join(temp.arena, &try_path_parts, &(StringJoin){.sep = str8_lit("/")}); - FileProperties try_props = os_properties_from_file_path(try_path); + FileProperties try_props = properties_from_file_path(try_path); if(try_props.modified != 0) { name_resolved = 1; @@ -14934,7 +14924,7 @@ rd_frame(void) String8 current_path_string = current_path->first->string; if(current_path_string.size == 0) { - current_path_string = path_normalized_from_string(scratch.arena, os_get_current_path(scratch.arena)); + current_path_string = path_normalized_from_string(scratch.arena, get_current_path(scratch.arena)); } initial_input = current_path_string; initial_input = push_str8f(scratch.arena, "%S/", initial_input); @@ -15373,8 +15363,8 @@ rd_frame(void) String8 name = rd_regs()->string; if(name.size != 0) { - String8 themes_folder = push_str8f(scratch.arena, "%S/raddbg/themes", os_get_process_info()->user_program_data_path); - if(os_make_directory(themes_folder)) + String8 themes_folder = str8f(scratch.arena, "%S/raddbg/themes", get_process_info()->user_program_data_path); + if(make_directory(themes_folder)) { String8 dst_path = push_str8f(scratch.arena, "%S/%S", themes_folder, name); CFG_Node *parent = cfg_node_from_id(rd_regs()->cfg); @@ -15385,7 +15375,7 @@ rd_frame(void) str8_list_push(scratch.arena, &strings, cfg_string_from_tree(scratch.arena, rd_state->cfg_schema_table, str8_chop_last_slash(dst_path), n->v)); } String8 data = str8_list_join(scratch.arena, &strings, 0); - if(os_write_data_to_file_path(dst_path, data)) + if(write_data_to_file_path(dst_path, data)) { if(kind == RD_CmdKind_SaveAndSetTheme) { @@ -15645,7 +15635,7 @@ rd_frame(void) { Access *access = access_open(); 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_CallStack call_stack = d_call_stack_from_thread(access, thread->handle, 1, now_time_us()+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) { @@ -15664,7 +15654,7 @@ rd_frame(void) { Access *access = access_open(); 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_CallStack call_stack = d_call_stack_from_thread(access, thread->handle, 1, now_time_us()+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) @@ -16397,7 +16387,7 @@ rd_frame(void) 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)) + if(new_path.size != 0 && file_path_exists(new_path)) { CFG_NodePtrList dbg_infos = cfg_node_top_level_list_from_string(scratch.arena, str8_lit("debug_info")); B32 path_found = 0; @@ -16749,7 +16739,7 @@ rd_frame(void) // if(DEV_simulate_lag) { - os_sleep_milliseconds(300); + sleep_ms(300); } ////////////////////////////// @@ -16817,7 +16807,7 @@ rd_frame(void) ////////////////////////////// //- rjf: determine frame time, record into history // - U64 end_time_us = os_now_microseconds(); + U64 end_time_us = now_time_us(); U64 frame_time_us = end_time_us-begin_time_us; rd_state->frame_time_us_history[rd_state->frame_index%ArrayCount(rd_state->frame_time_us_history)] = frame_time_us; @@ -16855,7 +16845,7 @@ rd_frame(void) ProfScope("collect logs") { LogScopeResult log = log_scope_end(scratch.arena); - os_append_data_to_file_path(rd_state->log_path, log.strings[LogMsgKind_Info]); + append_data_to_file_path(rd_state->log_path, log.strings[LogMsgKind_Info]); if(log.strings[LogMsgKind_UserError].size != 0) { String8 error_log = log.strings[LogMsgKind_UserError]; diff --git a/src/raddbg/raddbg_core.h b/src/raddbg/raddbg_core.h index 5f5d119d..417ccd7a 100644 --- a/src/raddbg/raddbg_core.h +++ b/src/raddbg/raddbg_core.h @@ -283,7 +283,7 @@ struct RD_WindowState // rjf: top-level info & handles Arena *arena; - OS_Handle os; + OS_Window os; R_Handle r; UI_State *ui; F32 last_dpi; @@ -543,7 +543,7 @@ struct RD_State String8 bind_change_cmd_name; // rjf: pre-stop focused window - OS_Handle prestop_focused_window; + OS_ExternalWindow prestop_focused_window; }; //////////////////////////////// @@ -730,7 +730,7 @@ internal void rd_store_view_paramf(String8 key, char *fmt, ...); internal String8 rd_push_window_title(Arena *arena); internal CFG_Node *rd_window_from_cfg(CFG_Node *cfg); internal RD_WindowState *rd_window_state_from_cfg(CFG_Node *cfg); -internal RD_WindowState *rd_window_state_from_os_handle(OS_Handle os); +internal RD_WindowState *rd_window_state_from_os_handle(OS_Window os); internal void rd_window_frame(void); //////////////////////////////// diff --git a/src/raddbg/raddbg_eval.c b/src/raddbg/raddbg_eval.c index 5b7adf0c..0bed5d80 100644 --- a/src/raddbg/raddbg_eval.c +++ b/src/raddbg/raddbg_eval.c @@ -122,18 +122,18 @@ E_TYPE_EXPAND_INFO_FUNCTION_DEF(themes) //- rjf: gather theme files { - String8 theme_folder = push_str8f(scratch.arena, "%S/raddbg/themes", os_get_process_info()->user_program_data_path); - OS_FileIter *it = os_file_iter_begin(scratch.arena, theme_folder, OS_FileIterFlag_SkipFolders); - for(OS_FileInfo info = {0}; os_file_iter_next(scratch.arena, it, &info);) + String8 theme_folder = push_str8f(scratch.arena, "%S/raddbg/themes", get_process_info()->user_program_data_path); + FileIter *it = file_iter_begin(scratch.arena, theme_folder, FileIterFlag_SkipFolders); + for(FileInfo info = {0}; file_iter_next(scratch.arena, it, &info);) { String8 name = info.name; FuzzyMatchRangeList name_matches = fuzzy_match_find(scratch.arena, filter, name); if(name_matches.count == name_matches.needle_part_count) { - str8_list_push(scratch.arena, &names, push_str8_copy(arena, name)); + str8_list_push(scratch.arena, &names, str8_copy(arena, name)); } } - os_file_iter_end(it); + file_iter_end(it); } //- rjf: flatten & build accelerator @@ -269,11 +269,16 @@ E_TYPE_EXPAND_INFO_FUNCTION_DEF(registers) Temp scratch = scratch_begin(&arena, 1); 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); + ARCH_Info *arch_info = arch_info_from_arch(arch); + U64 reg_count = arch_info->reg_code_count; + String8 *reg_strings = arch_info->reg_code_name_table; String8List exprs_list = {0}; for(U64 idx = 1; idx < reg_count; idx += 1) { + if(arch_info->reg_code_base_table[idx] != 0) + { + continue; + } FuzzyMatchRangeList matches = fuzzy_match_find(scratch.arena, filter, reg_strings[idx]); if(matches.count == matches.needle_part_count) { @@ -1041,8 +1046,9 @@ E_TYPE_ACCESS_FUNCTION_DEF(call_stack) if(0 <= rhs_value.u64 && rhs_value.u64 < call_stack->frames_count) { D_Entity *process = d_entity_from_handle(&d_user_state->ctrl_entity_store->ctx, accel->process); + ARCH_Info *arch_info = arch_info_from_arch(accel->arch); 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.root = e_irtree_set_space(arena, rd_eval_space_from_ctrl_entity(process, D_EvalSpaceKind_Entity), e_irtree_const_u(arena, arch_ip_from_reg_block(arch_info, 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); result.mode = E_Mode_Value; } diff --git a/src/raddbg/raddbg_main.c b/src/raddbg/raddbg_main.c index ccf5f745..7db1c57c 100644 --- a/src/raddbg/raddbg_main.c +++ b/src/raddbg/raddbg_main.c @@ -297,9 +297,7 @@ #include "rdi_from_dwarf/rdi_from_dwarf.h" #include "rdi_from_dwarf/rdi_from_dwarf_2.h" #include "radbin/radbin.h" -#include "regs/regs.h" -#include "regs/rdi/regs_rdi.h" -#include "regs/dwarf/regs_dwarf.h" +#include "arch/arch_inc.h" #include "dbg_info/dbg_info.h" #include "disasm/disasm.h" #include "stap/stap_parse.h" @@ -352,9 +350,7 @@ #include "rdi_from_dwarf/rdi_from_dwarf.c" #include "rdi_from_dwarf/rdi_from_dwarf_2.c" #include "radbin/radbin.c" -#include "regs/regs.c" -#include "regs/rdi/regs_rdi.c" -#include "regs/dwarf/regs_dwarf.c" +#include "arch/arch_inc.c" #include "dbg_info/dbg_info.c" #include "disasm/disasm.c" #include "stap/stap_parse.c" @@ -414,9 +410,9 @@ ipc_signaler_thread__entry_point(void *p) ThreadNameF("rd_ipc_signaler_thread"); for(;;) { - if(os_semaphore_take(ipc_sender2main_signal_semaphore, max_U64)) + if(semaphore_take(ipc_sender2main_signal_semaphore, max_U64)) { - if(os_semaphore_take(ipc_sender2main_lock_semaphore, max_U64)) + if(semaphore_take(ipc_sender2main_lock_semaphore, max_U64)) { IPCInfo *ipc_info = (IPCInfo *)ipc_sender2main_shared_memory_base; String8 msg = str8((U8 *)(ipc_info+1), ipc_info->msg_size); @@ -436,7 +432,7 @@ ipc_signaler_thread__entry_point(void *p) cond_var_broadcast(ipc_s2m_ring_cv); os_send_wakeup_event(); ipc_info->msg_size = 0; - os_semaphore_drop(ipc_sender2main_lock_semaphore); + semaphore_drop(ipc_sender2main_lock_semaphore); } } } @@ -559,23 +555,23 @@ entry_point(CmdLine *cmd_line) //- rjf: set up shared resources for ipc to this instance; launch IPC signaler thread { Temp scratch = scratch_begin(0, 0); - U32 instance_pid = os_get_process_info()->pid; + U32 instance_pid = get_process_info()->pid; // rjf: set up cross-process sender -> main ring buffer - String8 ipc_sender2main_shared_memory_name = push_str8f(scratch.arena, "_raddbg_ipc_sender2main_shared_memory_%i_", instance_pid); - String8 ipc_sender2main_signal_semaphore_name = push_str8f(scratch.arena, "_raddbg_ipc_sender2main_signal_semaphore_%i_", instance_pid); - String8 ipc_sender2main_lock_semaphore_name = push_str8f(scratch.arena, "_raddbg_ipc_sender2main_lock_semaphore_%i_", instance_pid); - OS_Handle ipc_sender2main_shared_memory = os_shared_memory_alloc(IPC_SHARED_MEMORY_BUFFER_SIZE, ipc_sender2main_shared_memory_name); - ipc_sender2main_shared_memory_base = (U8 *)os_shared_memory_view_open(ipc_sender2main_shared_memory, r1u64(0, IPC_SHARED_MEMORY_BUFFER_SIZE)); + String8 ipc_sender2main_shared_memory_name = str8f(scratch.arena, "_raddbg_ipc_sender2main_shared_memory_%i_", instance_pid); + String8 ipc_sender2main_signal_semaphore_name = str8f(scratch.arena, "_raddbg_ipc_sender2main_signal_semaphore_%i_", instance_pid); + String8 ipc_sender2main_lock_semaphore_name = str8f(scratch.arena, "_raddbg_ipc_sender2main_lock_semaphore_%i_", instance_pid); + SharedMemory ipc_sender2main_shared_memory = shared_memory_alloc(IPC_SHARED_MEMORY_BUFFER_SIZE, ipc_sender2main_shared_memory_name); + ipc_sender2main_shared_memory_base = (U8 *)shared_memory_view_open(ipc_sender2main_shared_memory, r1u64(0, IPC_SHARED_MEMORY_BUFFER_SIZE)); ipc_sender2main_signal_semaphore = semaphore_alloc(0, 1, ipc_sender2main_signal_semaphore_name); ipc_sender2main_lock_semaphore = semaphore_alloc(1, 1, ipc_sender2main_lock_semaphore_name); // rjf: set up cross-process main -> sender ring buffer - String8 ipc_main2sender_shared_memory_name = push_str8f(scratch.arena, "_raddbg_ipc_main2sender_shared_memory_%i_", instance_pid); - String8 ipc_main2sender_signal_semaphore_name = push_str8f(scratch.arena, "_raddbg_ipc_main2sender_signal_semaphore_%i_", instance_pid); - String8 ipc_main2sender_lock_semaphore_name = push_str8f(scratch.arena, "_raddbg_ipc_main2sender_lock_semaphore_%i_", instance_pid); - OS_Handle ipc_main2sender_shared_memory = os_shared_memory_alloc(IPC_SHARED_MEMORY_BUFFER_SIZE, ipc_main2sender_shared_memory_name); - ipc_main2sender_shared_memory_base = (U8 *)os_shared_memory_view_open(ipc_main2sender_shared_memory, r1u64(0, IPC_SHARED_MEMORY_BUFFER_SIZE)); + String8 ipc_main2sender_shared_memory_name = str8f(scratch.arena, "_raddbg_ipc_main2sender_shared_memory_%i_", instance_pid); + String8 ipc_main2sender_signal_semaphore_name = str8f(scratch.arena, "_raddbg_ipc_main2sender_signal_semaphore_%i_", instance_pid); + String8 ipc_main2sender_lock_semaphore_name = str8f(scratch.arena, "_raddbg_ipc_main2sender_lock_semaphore_%i_", instance_pid); + SharedMemory ipc_main2sender_shared_memory = shared_memory_alloc(IPC_SHARED_MEMORY_BUFFER_SIZE, ipc_main2sender_shared_memory_name); + ipc_main2sender_shared_memory_base = (U8 *)shared_memory_view_open(ipc_main2sender_shared_memory, r1u64(0, IPC_SHARED_MEMORY_BUFFER_SIZE)); ipc_main2sender_signal_semaphore = semaphore_alloc(0, 1, ipc_main2sender_signal_semaphore_name); ipc_main2sender_lock_semaphore = semaphore_alloc(1, 1, ipc_main2sender_lock_semaphore_name); @@ -682,7 +678,7 @@ entry_point(CmdLine *cmd_line) if(ipc_command_frame) { if(ipc_main2sender_shared_memory_base != 0 && - os_semaphore_take(ipc_main2sender_lock_semaphore, os_now_microseconds()+5000000)) + semaphore_take(ipc_main2sender_lock_semaphore, now_time_us()+5000000)) { IPCInfo *ipc_info = (IPCInfo *)ipc_main2sender_shared_memory_base; U8 *buffer = (U8 *)(ipc_info+1); @@ -691,8 +687,8 @@ entry_point(CmdLine *cmd_line) String8 msg = str8_list_join(scratch.arena, &rd_state->cmd_outputs, &join); ipc_info->msg_size = Min(buffer_max, msg.size); MemoryCopy(buffer, msg.str, ipc_info->msg_size); - os_semaphore_drop(ipc_main2sender_signal_semaphore); - os_semaphore_drop(ipc_main2sender_lock_semaphore); + semaphore_drop(ipc_main2sender_signal_semaphore); + semaphore_drop(ipc_main2sender_lock_semaphore); } } } @@ -721,7 +717,7 @@ entry_point(CmdLine *cmd_line) //- rjf: no explicit PID? -> find PID to send message to, by looking for other raddbg instances if(dst_pid == 0) { - U32 this_pid = os_get_process_info()->pid; + U32 this_pid = get_process_info()->pid; DMN_ProcessIter it = {0}; dmn_process_iter_begin(&it); for(DMN_ProcessInfo info = {0}; dmn_process_iter_next(scratch.arena, &it, &info);) @@ -740,23 +736,23 @@ entry_point(CmdLine *cmd_line) String8 ipc_sender2main_shared_memory_name = push_str8f(scratch.arena, "_raddbg_ipc_sender2main_shared_memory_%i_", dst_pid); String8 ipc_sender2main_signal_semaphore_name = push_str8f(scratch.arena, "_raddbg_ipc_sender2main_signal_semaphore_%i_", dst_pid); String8 ipc_sender2main_lock_semaphore_name = push_str8f(scratch.arena, "_raddbg_ipc_sender2main_lock_semaphore_%i_", dst_pid); - OS_Handle ipc_sender2main_shared_memory = os_shared_memory_alloc(IPC_SHARED_MEMORY_BUFFER_SIZE, ipc_sender2main_shared_memory_name); - ipc_sender2main_shared_memory_base = (U8 *)os_shared_memory_view_open(ipc_sender2main_shared_memory, r1u64(0, IPC_SHARED_MEMORY_BUFFER_SIZE)); - ipc_sender2main_signal_semaphore = os_semaphore_alloc(0, 1, ipc_sender2main_signal_semaphore_name); - ipc_sender2main_lock_semaphore = os_semaphore_alloc(1, 1, ipc_sender2main_lock_semaphore_name); + SharedMemory ipc_sender2main_shared_memory = shared_memory_alloc(IPC_SHARED_MEMORY_BUFFER_SIZE, ipc_sender2main_shared_memory_name); + ipc_sender2main_shared_memory_base = (U8 *)shared_memory_view_open(ipc_sender2main_shared_memory, r1u64(0, IPC_SHARED_MEMORY_BUFFER_SIZE)); + ipc_sender2main_signal_semaphore = semaphore_alloc(0, 1, ipc_sender2main_signal_semaphore_name); + ipc_sender2main_lock_semaphore = semaphore_alloc(1, 1, ipc_sender2main_lock_semaphore_name); String8 ipc_main2sender_shared_memory_name = push_str8f(scratch.arena, "_raddbg_ipc_main2sender_shared_memory_%i_", dst_pid); String8 ipc_main2sender_signal_semaphore_name = push_str8f(scratch.arena, "_raddbg_ipc_main2sender_signal_semaphore_%i_", dst_pid); String8 ipc_main2sender_lock_semaphore_name = push_str8f(scratch.arena, "_raddbg_ipc_main2sender_lock_semaphore_%i_", dst_pid); - OS_Handle ipc_main2sender_shared_memory = os_shared_memory_alloc(IPC_SHARED_MEMORY_BUFFER_SIZE, ipc_main2sender_shared_memory_name); - ipc_main2sender_shared_memory_base = (U8 *)os_shared_memory_view_open(ipc_main2sender_shared_memory, r1u64(0, IPC_SHARED_MEMORY_BUFFER_SIZE)); - ipc_main2sender_signal_semaphore = os_semaphore_alloc(0, 1, ipc_main2sender_signal_semaphore_name); - ipc_main2sender_lock_semaphore = os_semaphore_alloc(1, 1, ipc_main2sender_lock_semaphore_name); + SharedMemory ipc_main2sender_shared_memory = shared_memory_alloc(IPC_SHARED_MEMORY_BUFFER_SIZE, ipc_main2sender_shared_memory_name); + ipc_main2sender_shared_memory_base = (U8 *)shared_memory_view_open(ipc_main2sender_shared_memory, r1u64(0, IPC_SHARED_MEMORY_BUFFER_SIZE)); + ipc_main2sender_signal_semaphore = semaphore_alloc(0, 1, ipc_main2sender_signal_semaphore_name); + ipc_main2sender_lock_semaphore = semaphore_alloc(1, 1, ipc_main2sender_lock_semaphore_name); //- rjf: got resources -> write message B32 wrote_message = 0; if(dst_pid != 0 && ipc_sender2main_shared_memory_base != 0 && - os_semaphore_take(ipc_sender2main_lock_semaphore, max_U64)) + semaphore_take(ipc_sender2main_lock_semaphore, max_U64)) { wrote_message = 1; IPCInfo *ipc_info = (IPCInfo *)ipc_sender2main_shared_memory_base; @@ -773,24 +769,24 @@ entry_point(CmdLine *cmd_line) String8 msg = str8_list_join(scratch.arena, &parts, &join); ipc_info->msg_size = Min(buffer_max, msg.size); MemoryCopy(buffer, msg.str, ipc_info->msg_size); - os_semaphore_drop(ipc_sender2main_signal_semaphore); - os_semaphore_drop(ipc_sender2main_lock_semaphore); + semaphore_drop(ipc_sender2main_signal_semaphore); + semaphore_drop(ipc_sender2main_lock_semaphore); } //- rjf: wrote message -> wait for outputs, read outputs String8List outputs = {0}; if(wrote_message && ipc_main2sender_shared_memory_base != 0 && - os_semaphore_take(ipc_main2sender_signal_semaphore, os_now_microseconds()+10000000)) + semaphore_take(ipc_main2sender_signal_semaphore, now_time_us()+10000000)) { - if(os_semaphore_take(ipc_main2sender_lock_semaphore, max_U64)) + if(semaphore_take(ipc_main2sender_lock_semaphore, max_U64)) { IPCInfo *ipc_info = (IPCInfo *)ipc_main2sender_shared_memory_base; String8 msg = str8((U8 *)(ipc_info+1), ipc_info->msg_size); msg.size = Min(msg.size, IPC_SHARED_MEMORY_BUFFER_SIZE - sizeof(IPCInfo)); U8 split_char = 0; outputs = str8_split(scratch.arena, msg, &split_char, 1, 0); - os_semaphore_drop(ipc_main2sender_lock_semaphore); + semaphore_drop(ipc_main2sender_lock_semaphore); } } diff --git a/src/raddbg/raddbg_views.c b/src/raddbg/raddbg_views.c index fb3fe45e..05f96794 100644 --- a/src/raddbg/raddbg_views.c +++ b/src/raddbg/raddbg_views.c @@ -1028,10 +1028,11 @@ rd_watch_row_info_from_row(Arena *arena, EV_Row *row) 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) { + ARCH_Info *arch_info = arch_info_from_arch(entity->arch); D_CallStackFrame *f = &call_stack.frames[frame_num-1]; info.callstack_unwind_index = f->unwind_count; info.callstack_inline_depth = f->inline_depth; - info.callstack_vaddr = regs_rip_from_arch_block(entity->arch, f->regs); + info.callstack_vaddr = arch_ip_from_reg_block(arch_info, f->regs); } access_close(access); } @@ -2148,7 +2149,7 @@ RD_VIEW_UI_FUNCTION_DEF(text) U128 hash = {0}; TXT_TextInfo info = txt_text_info_from_key_lang(access, rd_regs()->text_key, rd_regs()->lang_kind, &hash); String8 data = c_data_from_hash(access, hash); - B32 file_is_missing = (rd_regs()->file_path.size != 0 && os_properties_from_file_path(rd_regs()->file_path).modified == 0); + B32 file_is_missing = (rd_regs()->file_path.size != 0 && properties_from_file_path(rd_regs()->file_path).modified == 0); B32 key_has_data = !u128_match(hash, u128_zero()) && info.lines_count; ProfEnd(); @@ -2305,7 +2306,7 @@ RD_VIEW_UI_FUNCTION_DEF(text) }break; case RDI_ChecksumKind_Timestamp: { - FileProperties props = os_properties_from_file_path(rd_regs()->file_path); + FileProperties props = properties_from_file_path(rd_regs()->file_path); String8 timestamp_string = str8_struct(&props.modified); file_is_out_of_date = !MemoryIsZeroStruct(&props.modified) && !str8_match(timestamp_string, checksum_expected, 0); }break; @@ -3271,8 +3272,9 @@ RD_VIEW_UI_FUNCTION_DEF(memory) //- rjf: fill selected thread stack range annotation if(selected_call_stack.concrete_frames_count > 0) { + ARCH_Info *arch_info = arch_info_from_arch(selected_thread->arch); U64 stack_base_vaddr = selected_thread->stack_base; - U64 stack_top_vaddr = regs_rsp_from_arch_block(selected_thread->arch, selected_call_stack.concrete_frames[0]->regs); + U64 stack_top_vaddr = arch_sp_from_reg_block(arch_info, selected_call_stack.concrete_frames[0]->regs); Rng1U64 stack_vaddr_range = r1u64(stack_base_vaddr, stack_top_vaddr); Rng1U64 stack_vaddr_range_in_viz = intersect_1u64(stack_vaddr_range, viz_range_bytes); if(dim_1u64(stack_vaddr_range_in_viz) != 0) @@ -3294,13 +3296,14 @@ RD_VIEW_UI_FUNCTION_DEF(memory) //- rjf: fill unwind frame annotations if(selected_call_stack.concrete_frames_count != 0) UI_Tag(str8_lit("weak")) { + ARCH_Info *arch_info = arch_info_from_arch(selected_thread->arch); Vec4F32 symbol_color = ui_color_from_name(str8_lit("code_symbol")); - U64 last_rip = regs_rip_from_arch_block(selected_thread->arch, selected_call_stack.concrete_frames[0]->regs); - U64 last_stack_top = regs_rsp_from_arch_block(selected_thread->arch, selected_call_stack.concrete_frames[0]->regs); + U64 last_rip = arch_ip_from_reg_block(arch_info, selected_call_stack.concrete_frames[0]->regs); + U64 last_stack_top = arch_sp_from_reg_block(arch_info, selected_call_stack.concrete_frames[0]->regs); for(U64 idx = 1; idx < selected_call_stack.concrete_frames_count; idx += 1) { D_CallStackFrame *f = selected_call_stack.concrete_frames[idx]; - U64 f_stack_top = regs_rsp_from_arch_block(selected_thread->arch, f->regs); + U64 f_stack_top = arch_sp_from_reg_block(arch_info, f->regs); Rng1U64 frame_vaddr_range = r1u64(last_stack_top, f_stack_top); Rng1U64 frame_vaddr_range_in_viz = intersect_1u64(frame_vaddr_range, viz_range_bytes); last_stack_top = f_stack_top; @@ -3308,7 +3311,7 @@ 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); + last_rip = arch_ip_from_reg_block(arch_info, f->regs); 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); diff --git a/src/raddbg/raddbg_widgets.c b/src/raddbg/raddbg_widgets.c index 32392c38..a1db6221 100644 --- a/src/raddbg/raddbg_widgets.c +++ b/src/raddbg/raddbg_widgets.c @@ -550,6 +550,7 @@ rd_title_fstrs_from_ctrl_entity(Arena *arena, D_Entity *entity, B32 include_extr Access *access = access_open(); D_Entity *process = d_entity_ancestor_from_kind(entity, D_EntityKind_Process); Arch arch = entity->arch; + ARCH_Info *arch_info = arch_info_from_arch(entity->arch); 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; @@ -558,7 +559,7 @@ rd_title_fstrs_from_ctrl_entity(Arena *arena, D_Entity *entity, B32 include_extr idx += 1) { D_CallStackFrame *f = &call_stack.frames[call_stack.frames_count - 1 - idx]; - U64 rip_vaddr = regs_rip_from_arch_block(arch, f->regs); + U64 rip_vaddr = arch_ip_from_reg_block(arch_info, f->regs); D_Entity *module = d_module_from_process_vaddr(process, rip_vaddr); U64 rip_voff = d_voff_from_vaddr(module, rip_vaddr); String8 name = {0}; @@ -653,7 +654,7 @@ rd_title_fstrs_from_file_path(Arena *arena, String8 file_path) { DR_FStrList fstrs = {0}; String8 file_name = str8_skip_last_slash(file_path); - FileProperties props = os_properties_from_file_path(file_path); + FileProperties props = properties_from_file_path(file_path); RD_IconKind icon_kind = RD_IconKind_FileOutline; if(props.flags & FilePropertyFlag_IsFolder) { diff --git a/src/rdi/rdi_local.c b/src/rdi/rdi_local.c index 19a39d58..b575ea3e 100644 --- a/src/rdi/rdi_local.c +++ b/src/rdi/rdi_local.c @@ -3,6 +3,9 @@ #include "lib_rdi/rdi.c" #include "lib_rdi/rdi_parse.c" +#if defined(X64_H) +# include "rdi/x64/rdi_x64.c" +#endif //////////////////////////////// //~ rjf: RDI Enum <=> Base Enum @@ -20,6 +23,22 @@ arch_from_rdi_arch(RDI_Arch arch) return result; } +internal RDI_Arch +rdi_arch_from_arch(Arch arch) +{ + RDI_Arch result = RDI_Arch_NULL; + switch(arch) + { + case Arch_COUNT: + case Arch_Null:{}break; + case Arch_x86:{result = RDI_Arch_X86;}break; + case Arch_x64:{result = RDI_Arch_X64;}break; + case Arch_arm64:{}break; + case Arch_arm32:{}break; + } + return result; +} + //////////////////////////////// //~ rjf: Lookup Helpers diff --git a/src/rdi/rdi_local.h b/src/rdi/rdi_local.h index adc5f180..c7ef8f78 100644 --- a/src/rdi/rdi_local.h +++ b/src/rdi/rdi_local.h @@ -6,6 +6,9 @@ #include "lib_rdi/rdi.h" #include "lib_rdi/rdi_parse.h" +#if defined(X64_H) +# include "rdi/x64/rdi_x64.h" +#endif //////////////////////////////// //~ rjf: RDI Dumping Flags @@ -70,6 +73,7 @@ read_only global String8 rdi_name_title_from_dump_subset_table[] = //~ rjf: RDI Enum <=> Base Enum internal Arch arch_from_rdi_arch(RDI_Arch arch); +internal RDI_Arch rdi_arch_from_arch(Arch arch); //////////////////////////////// //~ rjf: Lookup Helpers diff --git a/src/rdi/x64/generated/rdi_x64.meta.c b/src/rdi/x64/generated/rdi_x64.meta.c new file mode 100644 index 00000000..68f9269f --- /dev/null +++ b/src/rdi/x64/generated/rdi_x64.meta.c @@ -0,0 +1,201 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//- GENERATED CODE + +C_LINKAGE_BEGIN +U8 rdi_reg_code_from_x64_table[189] = +{ +RDI_RegCodeX64_nil, +RDI_RegCodeX64_rax, +RDI_RegCodeX64_rcx, +RDI_RegCodeX64_rdx, +RDI_RegCodeX64_rbx, +RDI_RegCodeX64_rsp, +RDI_RegCodeX64_rbp, +RDI_RegCodeX64_rsi, +RDI_RegCodeX64_rdi, +RDI_RegCodeX64_r8, +RDI_RegCodeX64_r9, +RDI_RegCodeX64_r10, +RDI_RegCodeX64_r11, +RDI_RegCodeX64_r12, +RDI_RegCodeX64_r13, +RDI_RegCodeX64_r14, +RDI_RegCodeX64_r15, +RDI_RegCodeX64_fsbase, +RDI_RegCodeX64_gsbase, +RDI_RegCodeX64_rip, +RDI_RegCodeX64_rflags, +RDI_RegCodeX64_dr0, +RDI_RegCodeX64_dr1, +RDI_RegCodeX64_dr2, +RDI_RegCodeX64_dr3, +RDI_RegCodeX64_dr4, +RDI_RegCodeX64_dr5, +RDI_RegCodeX64_dr6, +RDI_RegCodeX64_dr7, +RDI_RegCodeX64_st0, +RDI_RegCodeX64_st1, +RDI_RegCodeX64_st2, +RDI_RegCodeX64_st3, +RDI_RegCodeX64_st4, +RDI_RegCodeX64_st5, +RDI_RegCodeX64_st6, +RDI_RegCodeX64_st7, +RDI_RegCodeX64_fcw, +RDI_RegCodeX64_fsw, +RDI_RegCodeX64_ftw, +RDI_RegCodeX64_fop, +RDI_RegCodeX64_fcs, +RDI_RegCodeX64_fds, +RDI_RegCodeX64_fip, +RDI_RegCodeX64_fdp, +RDI_RegCodeX64_mxcsr, +RDI_RegCodeX64_mxcsr_mask, +RDI_RegCodeX64_ss, +RDI_RegCodeX64_cs, +RDI_RegCodeX64_ds, +RDI_RegCodeX64_es, +RDI_RegCodeX64_fs, +RDI_RegCodeX64_gs, +RDI_RegCodeX64_zmm0, +RDI_RegCodeX64_zmm1, +RDI_RegCodeX64_zmm2, +RDI_RegCodeX64_zmm3, +RDI_RegCodeX64_zmm4, +RDI_RegCodeX64_zmm5, +RDI_RegCodeX64_zmm6, +RDI_RegCodeX64_zmm7, +RDI_RegCodeX64_zmm8, +RDI_RegCodeX64_zmm9, +RDI_RegCodeX64_zmm10, +RDI_RegCodeX64_zmm11, +RDI_RegCodeX64_zmm12, +RDI_RegCodeX64_zmm13, +RDI_RegCodeX64_zmm14, +RDI_RegCodeX64_zmm15, +RDI_RegCodeX64_zmm16, +RDI_RegCodeX64_zmm17, +RDI_RegCodeX64_zmm18, +RDI_RegCodeX64_zmm19, +RDI_RegCodeX64_zmm20, +RDI_RegCodeX64_zmm21, +RDI_RegCodeX64_zmm22, +RDI_RegCodeX64_zmm23, +RDI_RegCodeX64_zmm24, +RDI_RegCodeX64_zmm25, +RDI_RegCodeX64_zmm26, +RDI_RegCodeX64_zmm27, +RDI_RegCodeX64_zmm28, +RDI_RegCodeX64_zmm29, +RDI_RegCodeX64_zmm30, +RDI_RegCodeX64_zmm31, +RDI_RegCodeX64_k0, +RDI_RegCodeX64_k1, +RDI_RegCodeX64_k2, +RDI_RegCodeX64_k3, +RDI_RegCodeX64_k4, +RDI_RegCodeX64_k5, +RDI_RegCodeX64_k6, +RDI_RegCodeX64_k7, +RDI_RegCodeX64_cetmsr, +RDI_RegCodeX64_cetssp, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +}; + +C_LINKAGE_END + diff --git a/src/rdi/x64/generated/rdi_x64.meta.h b/src/rdi/x64/generated/rdi_x64.meta.h new file mode 100644 index 00000000..82c9e28f --- /dev/null +++ b/src/rdi/x64/generated/rdi_x64.meta.h @@ -0,0 +1,14 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//- GENERATED CODE + +#ifndef RDI_X64_META_H +#define RDI_X64_META_H + +C_LINKAGE_BEGIN +extern U8 rdi_reg_code_from_x64_table[189]; + +C_LINKAGE_END + +#endif // RDI_X64_META_H diff --git a/src/rdi/x64/rdi_x64.c b/src/rdi/x64/rdi_x64.c new file mode 100644 index 00000000..1a7ce768 --- /dev/null +++ b/src/rdi/x64/rdi_x64.c @@ -0,0 +1,4 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#include "rdi/x64/generated/rdi_x64.meta.c" diff --git a/src/regs/rdi/generated/regs_rdi.meta.h b/src/rdi/x64/rdi_x64.h similarity index 51% rename from src/regs/rdi/generated/regs_rdi.meta.h rename to src/rdi/x64/rdi_x64.h index b5d77852..46cb0858 100644 --- a/src/regs/rdi/generated/regs_rdi.meta.h +++ b/src/rdi/x64/rdi_x64.h @@ -1,9 +1,9 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//- GENERATED CODE - -#ifndef REGS_RDI_META_H -#define REGS_RDI_META_H - -#endif // REGS_RDI_META_H +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef RDI_X64_H +#define RDI_X64_H + +#include "rdi/x64/generated/rdi_x64.meta.h" + +#endif // RDI_X64_H diff --git a/src/rdi/x64/rdi_x64.mdesk b/src/rdi/x64/rdi_x64.mdesk new file mode 100644 index 00000000..e244f037 --- /dev/null +++ b/src/rdi/x64/rdi_x64.mdesk @@ -0,0 +1,7 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +@data(U8) rdi_reg_code_from_x64_table: +{ + @expand(X64_RegTable a) `$(a.has_rdi == 'x' -> "RDI_RegCodeX64_" .. a.name)$(a.has_rdi != 'x' -> 0)` +} diff --git a/src/rdi_from_dwarf/rdi_from_dwarf_2.c b/src/rdi_from_dwarf/rdi_from_dwarf_2.c index e67a0009..ce5d56f4 100644 --- a/src/rdi_from_dwarf/rdi_from_dwarf_2.c +++ b/src/rdi_from_dwarf/rdi_from_dwarf_2.c @@ -21,6 +21,7 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) DW_Raw *raw = ¶ms->raw; RDIM_BinarySectionList binary_sections = params->binary_sections; Arch arch = params->arch; + ARCH_Info *arch_info = arch_info_from_arch(arch); U64 base_vaddr = params->base_vaddr; U64 arch_addr_size = byte_size_from_arch(arch); @@ -62,21 +63,7 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) RDIM_TopLevelInfo top_level_info = {0}; ProfScope("produce top-level-info") { - // rjf: base arch -> rdi - RDI_Arch arch_rdi = RDI_Arch_NULL; - switch(arch) - { - case Arch_Null: - case Arch_arm64: - case Arch_arm32: - case Arch_COUNT: - {}break; - case Arch_x64:{arch_rdi = RDI_Arch_X64;}break; - case Arch_x86:{arch_rdi = RDI_Arch_X86;}break; - } - - // rjf: fill - top_level_info.arch = arch_rdi; + top_level_info.arch = rdi_arch_from_arch(arch); top_level_info.exe_name = params->exe_name; top_level_info.exe_hash = exe_hash; top_level_info.voff_max = acceptable_vaddr_range.max - base_vaddr; @@ -94,49 +81,10 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) Rng1U64Array *unit_arange_ranges = 0; ProfScope("gather unit ranges from .debug_info, .debug_aranges") if(lane_idx() == 0) { - struct - { - String8 data; - Rng1U64Array **dst_array; - } - tasks[] = - { - {raw->sec[DW_Section_Info].data, &unit_info_ranges}, - {raw->sec[DW_Section_ARanges].data, &unit_arange_ranges}, - }; - for EachElement(task_idx, tasks) - { - Temp scratch2 = scratch_begin(&scratch.arena, 1); - String8 data = tasks[task_idx].data; - Rng1U64List unit_range_list = {0}; - for(U64 off = 0; off < data.size;) - { - U64 start_off = off; - - // rjf: read next unit size - U64 unit_size = 0; - U64 unit_size_size = dw2_read_initial_length(data, off, &unit_size, 0); - - // rjf: push - if(unit_size > 0) - { - rng1u64_list_push(scratch2.arena, &unit_range_list, r1u64(off, off + unit_size_size + unit_size)); - } - - // rjf: advance - off += unit_size_size; - off += unit_size; - - // rjf: break if no movement - if(off == start_off) - { - break; - } - } - tasks[task_idx].dst_array[0] = push_array(scratch.arena, Rng1U64Array, 1); - tasks[task_idx].dst_array[0][0] = rng1u64_array_from_list(scratch.arena, &unit_range_list); - scratch_end(scratch2); - } + unit_info_ranges = push_array(scratch.arena, Rng1U64Array, 1); + *unit_info_ranges = dw2_unit_ranges_from_data(scratch.arena, raw->sec[DW_Section_Info].data); + unit_arange_ranges = push_array(scratch.arena, Rng1U64Array, 1); + *unit_arange_ranges = dw2_unit_ranges_from_data(scratch.arena, raw->sec[DW_Section_ARanges].data); } lane_sync_u64(&unit_info_ranges, 0); lane_sync_u64(&unit_arange_ranges, 0); @@ -1452,29 +1400,16 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) //////////////////////////// //- rjf: gather all unique, to-be-deduplicated tags across all units (types, namespaces) // - typedef struct UnitDedupedTagNode UnitDedupedTagNode; - struct UnitDedupedTagNode - { - UnitDedupedTagNode *next; - U64 src_info_off; - U64 dst_hash; - }; - typedef struct UnitDedupedTagMap UnitDedupedTagMap; - struct UnitDedupedTagMap - { - UnitDedupedTagNode **slots; - U64 slots_count; - }; D2R2_UniqueTagNode **unique_tag_slots = 0; U64 unique_tag_slots_count = total_tag_count_estimate/8 + 1; - UnitDedupedTagMap *unit_deduped_tag_maps = 0; + D2R2_UnitDedupedTagMap *unit_deduped_tag_maps = 0; ProfScope("gather all unique, to-be-deduplicated tags across all units (types, namespaces)") { //- rjf: set up tables if(lane_idx() == 0) { unique_tag_slots = push_array(scratch.arena, D2R2_UniqueTagNode *, unique_tag_slots_count); - unit_deduped_tag_maps = push_array(scratch.arena, UnitDedupedTagMap, unit_count); + unit_deduped_tag_maps = push_array(scratch.arena, D2R2_UnitDedupedTagMap, unit_count); } lane_sync_u64(&unique_tag_slots, 0); lane_sync_u64(&unit_deduped_tag_maps, 0); @@ -1486,7 +1421,7 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) { Rng1U64 unit_info_tag_range = unit_info_tag_ranges[unit_idx]; unit_deduped_tag_maps[unit_idx].slots_count = dim_1u64(unit_info_tag_range) / 256 + 1; - unit_deduped_tag_maps[unit_idx].slots = push_array(scratch.arena, UnitDedupedTagNode *, unit_deduped_tag_maps[unit_idx].slots_count); + unit_deduped_tag_maps[unit_idx].slots = push_array(scratch.arena, D2R2_UnitDedupedTagNode *, unit_deduped_tag_maps[unit_idx].slots_count); } lane_sync(); } @@ -1945,13 +1880,13 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) { U64 info_off_hash = u64_hash_from_str8(str8_struct(&start_off)); U64 info_off_slot_idx = info_off_hash%unit_deduped_tag_maps[origin_unit_idx].slots_count; - UnitDedupedTagNode *n = push_array(scratch.arena, UnitDedupedTagNode, 1); + D2R2_UnitDedupedTagNode *n = push_array(scratch.arena, D2R2_UnitDedupedTagNode, 1); n->src_info_off = start_off; n->dst_hash = hash; for(B32 inserted = 0; !inserted;) { U64 slot_head_val = ins_atomic_u64_eval(&unit_deduped_tag_maps[origin_unit_idx].slots[info_off_slot_idx]); - n->next = (UnitDedupedTagNode *)slot_head_val; + n->next = (D2R2_UnitDedupedTagNode *)slot_head_val; if(slot_head_val == ins_atomic_u64_eval_cond_assign(&unit_deduped_tag_maps[origin_unit_idx].slots[info_off_slot_idx], (U64)n, slot_head_val)) { inserted = 1; @@ -2239,7 +2174,7 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) { U64 off_hash = u64_hash_from_str8(str8_struct(&direct_type_info_off)); U64 off_slot_idx = off_hash%unit_deduped_tag_maps[direct_type_unit_idx].slots_count; - for(UnitDedupedTagNode *n = unit_deduped_tag_maps[direct_type_unit_idx].slots[off_slot_idx]; n != 0; n = n->next) + for(D2R2_UnitDedupedTagNode *n = unit_deduped_tag_maps[direct_type_unit_idx].slots[off_slot_idx]; n != 0; n = n->next) { if(n->src_info_off == direct_type_info_off) { @@ -2404,11 +2339,11 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) U64 new_unit_num = rng1u64_array_num_from_value__binary_search(&unit_info_tag_ranges_array, direct_type_info_off); direct_type_unit_idx = (new_unit_num > 0 ? new_unit_num-1 : unit_idx); } - UnitDedupedTagMap *direct_type_unit_type_map = &unit_deduped_tag_maps[direct_type_unit_idx]; + D2R2_UnitDedupedTagMap *direct_type_unit_type_map = &unit_deduped_tag_maps[direct_type_unit_idx]; U64 info_off_hash = u64_hash_from_str8(str8_struct(&direct_type_info_off)); U64 info_off_slot_idx = info_off_hash%direct_type_unit_type_map->slots_count; U64 direct_type_hash = 0; - for(UnitDedupedTagNode *n = direct_type_unit_type_map->slots[info_off_slot_idx]; n != 0; n = n->next) + for(D2R2_UnitDedupedTagNode *n = direct_type_unit_type_map->slots[info_off_slot_idx]; n != 0; n = n->next) { if(n->src_info_off == direct_type_info_off) { @@ -2543,10 +2478,10 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) // rjf: map info_off/unit_idx -> hash U64 param_type_hash = 0; { - UnitDedupedTagMap *direct_type_unit_type_map = &unit_deduped_tag_maps[param_type_unit_idx]; + D2R2_UnitDedupedTagMap *direct_type_unit_type_map = &unit_deduped_tag_maps[param_type_unit_idx]; U64 info_off_hash = u64_hash_from_str8(str8_struct(¶m_type_info_off)); U64 info_off_slot_idx = info_off_hash%direct_type_unit_type_map->slots_count; - for(UnitDedupedTagNode *n = direct_type_unit_type_map->slots[info_off_slot_idx]; n != 0; n = n->next) + for(D2R2_UnitDedupedTagNode *n = direct_type_unit_type_map->slots[info_off_slot_idx]; n != 0; n = n->next) { if(n->src_info_off == param_type_info_off) { @@ -3006,10 +2941,10 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) // rjf: (info_off, unit_idx) -> hash U64 type_hash = 0; { - UnitDedupedTagMap *unit_deduped_tag_map = &unit_deduped_tag_maps[type_unit_idx]; + D2R2_UnitDedupedTagMap *unit_deduped_tag_map = &unit_deduped_tag_maps[type_unit_idx]; U64 info_off_hash = u64_hash_from_str8(str8_struct(&type_info_off)); U64 info_off_slot_idx = info_off_hash%unit_deduped_tag_map->slots_count; - for(UnitDedupedTagNode *n = unit_deduped_tag_map->slots[info_off_slot_idx]; n != 0; n = n->next) + for(D2R2_UnitDedupedTagNode *n = unit_deduped_tag_map->slots[info_off_slot_idx]; n != 0; n = n->next) { if(n->src_info_off == type_info_off) { @@ -3445,10 +3380,10 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) // rjf: (info_off, unit_idx) -> hash U64 type_hash = 0; { - UnitDedupedTagMap *unit_deduped_tag_map = &unit_deduped_tag_maps[type_unit_idx]; + D2R2_UnitDedupedTagMap *unit_deduped_tag_map = &unit_deduped_tag_maps[type_unit_idx]; U64 info_off_hash = u64_hash_from_str8(str8_struct(&type_info_off)); U64 info_off_slot_idx = info_off_hash%unit_deduped_tag_map->slots_count; - for(UnitDedupedTagNode *n = unit_deduped_tag_map->slots[info_off_slot_idx]; n != 0; n = n->next) + for(D2R2_UnitDedupedTagNode *n = unit_deduped_tag_map->slots[info_off_slot_idx]; n != 0; n = n->next) { if(n->src_info_off == type_info_off) { @@ -3758,31 +3693,17 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) }goto reg_read; reg_read:; { - // rjf: DWARF regcode -> RDI, off, size + // rjf: DWARF regcode -> internal regcode + ARCH_RegCode regcode = arch_reg_code_from_dw(arch, regcode_dw); + + // rjf: internal regcode -> RDI, offset, size RDI_RegCode regcode_rdi = 0; U64 reg_off = 0; U64 reg_size = 0; - switch((Arch)arch) { - case Arch_Null: - case Arch_COUNT: - {}break; - case Arch_arm32: - case Arch_arm64: - case Arch_x86: - { - // TODO(rjf): unsupported architectures - }break; - case Arch_x64: - { - switch(regcode_dw) - { - default:{}break; -#define X(reg_dw, val_dw, reg_rdi, off, size) case DW_RegX64_##reg_dw:{regcode_rdi = RDI_RegCodeX64_##reg_rdi; reg_off = (off); reg_size = (size);}break; - DW_Regs_X64_XList -#undef X - } - }break; + Rng1U16 reg_rng = arch_info->reg_code_rng_table[regcode]; + reg_size = dim_1u16(reg_rng); + regcode_rdi = arch_rdi_from_reg_code_table_from_arch(arch)[regcode]; } // rjf: push op @@ -4400,10 +4321,10 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) // rjf: info offset -> hash U64 hash = 0; { - UnitDedupedTagMap *unit_deduped_tag_map = &unit_deduped_tag_maps[unit_idx]; + D2R2_UnitDedupedTagMap *unit_deduped_tag_map = &unit_deduped_tag_maps[unit_idx]; U64 info_off_hash = u64_hash_from_str8(str8_struct(&start_off)); U64 info_off_slot_idx = info_off_hash%unit_deduped_tag_map->slots_count; - for EachNode(n, UnitDedupedTagNode, unit_deduped_tag_map->slots[info_off_slot_idx]) + for EachNode(n, D2R2_UnitDedupedTagNode, unit_deduped_tag_map->slots[info_off_slot_idx]) { if(n->src_info_off == start_off) { @@ -4581,10 +4502,10 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) // rjf: info off -> hash U64 hash = 0; { - UnitDedupedTagMap *unit_deduped_tag_map = &unit_deduped_tag_maps[unit_idx]; + D2R2_UnitDedupedTagMap *unit_deduped_tag_map = &unit_deduped_tag_maps[unit_idx]; U64 info_off_hash = u64_hash_from_str8(str8_struct(&info_off)); U64 info_off_slot_idx = info_off_hash%unit_deduped_tag_map->slots_count; - for(UnitDedupedTagNode *n = unit_deduped_tag_map->slots[info_off_slot_idx]; n != 0; n = n->next) + for(D2R2_UnitDedupedTagNode *n = unit_deduped_tag_map->slots[info_off_slot_idx]; n != 0; n = n->next) { if(n->src_info_off == info_off) { @@ -4666,10 +4587,10 @@ d2r2_convert(Arena *arena, D2R2_ConvertParams *params) // rjf: info off -> hash U64 hash = 0; { - UnitDedupedTagMap *unit_deduped_tag_map = &unit_deduped_tag_maps[unit_idx]; + D2R2_UnitDedupedTagMap *unit_deduped_tag_map = &unit_deduped_tag_maps[unit_idx]; U64 info_off_hash = u64_hash_from_str8(str8_struct(&info_off)); U64 info_off_slot_idx = info_off_hash%unit_deduped_tag_map->slots_count; - for(UnitDedupedTagNode *n = unit_deduped_tag_map->slots[info_off_slot_idx]; n != 0; n = n->next) + for(D2R2_UnitDedupedTagNode *n = unit_deduped_tag_map->slots[info_off_slot_idx]; n != 0; n = n->next) { if(n->src_info_off == info_off) { diff --git a/src/rdi_from_dwarf/rdi_from_dwarf_2.h b/src/rdi_from_dwarf/rdi_from_dwarf_2.h index ff09ee2d..a0b63230 100644 --- a/src/rdi_from_dwarf/rdi_from_dwarf_2.h +++ b/src/rdi_from_dwarf/rdi_from_dwarf_2.h @@ -5,7 +5,7 @@ #define RDI_FROM_DWARF_2_H //////////////////////////////// -//~ rjf: Helper Types +//~ rjf: Unique Tag Tree Deduplication Types typedef enum D2R2_UniqueTagKind { @@ -26,6 +26,21 @@ struct D2R2_UniqueTagNode U64 order_idx; }; +typedef struct D2R2_UnitDedupedTagNode D2R2_UnitDedupedTagNode; +struct D2R2_UnitDedupedTagNode +{ + D2R2_UnitDedupedTagNode *next; + U64 src_info_off; + U64 dst_hash; +}; + +typedef struct D2R2_UnitDedupedTagMap D2R2_UnitDedupedTagMap; +struct D2R2_UnitDedupedTagMap +{ + D2R2_UnitDedupedTagNode **slots; + U64 slots_count; +}; + //////////////////////////////// //~ rjf: Conversion Stage Inputs (New) diff --git a/src/regs/dwarf/regs_dwarf.c b/src/regs/dwarf/regs_dwarf.c deleted file mode 100644 index d7fcc715..00000000 --- a/src/regs/dwarf/regs_dwarf.c +++ /dev/null @@ -1,77 +0,0 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -internal REGS_RegCode -reg_code_from_dw_reg_x64(DW_Reg reg) -{ - switch (reg) { -#define X(_SRC, _SRC_ID, _DST_ID, ...) case _SRC_ID: return REGS_RegCodeX64_##_DST_ID; - DW_Regs_X64_XList -#undef X - } - return REGS_RegCodeX64_NULL; -} - -internal REGS_RegCode -reg_code_from_dw_reg(Arch arch, DW_Reg reg) -{ - REGS_RegCode result = 0; - switch (arch) { - case Arch_Null: {} break; - case Arch_x64: { result = reg_code_from_dw_reg_x64(reg); } break; - case Arch_x86: - case Arch_arm32: - case Arch_arm64: { NotImplemented; } break; - default: { InvalidPath; } break; - } - return result; -} - -internal -MACHINE_OP_REG_READ(regs_read_dwarf_x64) -{ - // map DWARF register to -> the internal register - REGS_RegBlockX64 *regs = ud; - U64 reg_size = 0; void *reg_bytes = 0; - switch (reg_id) { -#define X(_N, _ID, _MAP_N, ...) case _ID: { reg_size = sizeof(regs->_MAP_N); reg_bytes = ®s->_MAP_N; } break; - DW_Regs_X64_XList -#undef X - default: { InvalidPath; } break; - } - - // copy out register value - MachineOpResult status = MachineOpResult_Fail; - if (reg_size > 0) { - AssertAlways(reg_size == buffer_max); - MemoryCopy(buffer, reg_bytes, reg_size); - status = MachineOpResult_Ok; - } - - return status; -} - -internal -MACHINE_OP_REG_WRITE(regs_write_dwarf_x64) -{ - // map DWARF register to -> the internal register - REGS_RegBlockX64 *regs = ud; - U64 reg_size = 0; void *reg_bytes = 0; - switch (reg_id) { -#define X(_N, _ID, _MAP_N, ...) case _ID: { reg_size = sizeof(regs->_MAP_N); reg_bytes = ®s->_MAP_N; } break; - DW_Regs_X64_XList -#undef X - default: { InvalidPath; } break; - } - - // write value to the register - MachineOpResult status = MachineOpResult_Fail; - if (reg_size > 0) { - AssertAlways(value_size <= reg_size); - MemoryCopy(reg_bytes, value, value_size); - status = MachineOpResult_Ok; - } - - return status; -} - diff --git a/src/regs/dwarf/regs_dwarf.h b/src/regs/dwarf/regs_dwarf.h deleted file mode 100644 index 37faf65a..00000000 --- a/src/regs/dwarf/regs_dwarf.h +++ /dev/null @@ -1,14 +0,0 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -#ifndef REGS_DWARF_H -#define REGS_DWARF_H - -internal REGS_RegCode reg_code_from_dw_reg_x64(DW_Reg reg); -internal REGS_RegCode reg_code_from_dw_reg(Arch arch, DW_Reg reg); - -internal MACHINE_OP_REG_READ(regs_read_dwarf_x64); -internal MACHINE_OP_REG_WRITE(regs_write_dwarf_x64); - -#endif // REGS_DWARF_H - diff --git a/src/regs/generated/regs.meta.c b/src/regs/generated/regs.meta.c deleted file mode 100644 index e93d742e..00000000 --- a/src/regs/generated/regs.meta.c +++ /dev/null @@ -1,686 +0,0 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//- GENERATED CODE - -internal U64 regs_block_size_from_arch(Arch arch) -{ -U64 result = 8; -switch(arch) -{ -default:{}break; -case Arch_x64:{result = sizeof(REGS_RegBlockX64);}break; -} -return result; -} -internal U64 regs_reg_code_count_from_arch(Arch arch) -{ -U64 result = 0; -switch(arch) -{ -default:{}break; -case Arch_x64:{result = REGS_RegCodeX64_COUNT;}break; -} -return result; -} -internal U64 regs_alias_code_count_from_arch(Arch arch) -{ -U64 result = 0; -switch(arch) -{ -default:{}break; -case Arch_x64:{result = REGS_AliasCodeX64_COUNT;}break; -} -return result; -} -internal String8 *regs_reg_code_string_table_from_arch(Arch arch) -{ -String8 *result = 0; -switch(arch) -{ -default:{}break; -case Arch_x64:{result = regs_g_reg_code_x64_string_table;}break; -} -return result; -} -internal String8 *regs_alias_code_string_table_from_arch(Arch arch) -{ -String8 *result = 0; -switch(arch) -{ -default:{}break; -case Arch_x64:{result = regs_g_alias_code_x64_string_table;}break; -} -return result; -} -internal REGS_Rng *regs_reg_code_rng_table_from_arch(Arch arch) -{ -REGS_Rng *result = 0; -switch(arch) -{ -default:{}break; -case Arch_x64:{result = regs_g_reg_code_x64_rng_table;}break; -} -return result; -} -internal REGS_Slice *regs_alias_code_slice_table_from_arch(Arch arch) -{ -REGS_Slice *result = 0; -switch(arch) -{ -default:{}break; -case Arch_x64:{result = regs_g_alias_code_x64_slice_table;}break; -} -return result; -} -internal REGS_UsageKind *regs_reg_code_usage_kind_table_from_arch(Arch arch) -{ -REGS_UsageKind *result = 0; -switch(arch) -{ -default:{}break; -case Arch_x64:{result = regs_g_reg_code_x64_usage_kind_table;}break; -} -return result; -} -internal REGS_UsageKind *regs_alias_code_usage_kind_table_from_arch(Arch arch) -{ -REGS_UsageKind *result = 0; -switch(arch) -{ -default:{}break; -case Arch_x64:{result = regs_g_alias_code_x64_usage_kind_table;}break; -} -return result; -} -C_LINKAGE_BEGIN -REGS_UsageKind regs_g_reg_code_x64_usage_kind_table[93] = -{ -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -}; - -REGS_UsageKind regs_g_alias_code_x64_usage_kind_table[95] = -{ -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Normal, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -REGS_UsageKind_Vector, -}; - -String8 regs_g_reg_code_x64_string_table[93] = -{ -str8_lit_comp(""), -str8_lit_comp("rax"), -str8_lit_comp("rcx"), -str8_lit_comp("rdx"), -str8_lit_comp("rbx"), -str8_lit_comp("rsp"), -str8_lit_comp("rbp"), -str8_lit_comp("rsi"), -str8_lit_comp("rdi"), -str8_lit_comp("r8"), -str8_lit_comp("r9"), -str8_lit_comp("r10"), -str8_lit_comp("r11"), -str8_lit_comp("r12"), -str8_lit_comp("r13"), -str8_lit_comp("r14"), -str8_lit_comp("r15"), -str8_lit_comp("fsbase"), -str8_lit_comp("gsbase"), -str8_lit_comp("rip"), -str8_lit_comp("rflags"), -str8_lit_comp("dr0"), -str8_lit_comp("dr1"), -str8_lit_comp("dr2"), -str8_lit_comp("dr3"), -str8_lit_comp("dr4"), -str8_lit_comp("dr5"), -str8_lit_comp("dr6"), -str8_lit_comp("dr7"), -str8_lit_comp("st0"), -str8_lit_comp("st1"), -str8_lit_comp("st2"), -str8_lit_comp("st3"), -str8_lit_comp("st4"), -str8_lit_comp("st5"), -str8_lit_comp("st6"), -str8_lit_comp("st7"), -str8_lit_comp("fcw"), -str8_lit_comp("fsw"), -str8_lit_comp("ftw"), -str8_lit_comp("fop"), -str8_lit_comp("fip"), -str8_lit_comp("fdp"), -str8_lit_comp("mxcsr"), -str8_lit_comp("mxcsr_mask"), -str8_lit_comp("ss"), -str8_lit_comp("cs"), -str8_lit_comp("ds"), -str8_lit_comp("es"), -str8_lit_comp("fs"), -str8_lit_comp("gs"), -str8_lit_comp("zmm0"), -str8_lit_comp("zmm1"), -str8_lit_comp("zmm2"), -str8_lit_comp("zmm3"), -str8_lit_comp("zmm4"), -str8_lit_comp("zmm5"), -str8_lit_comp("zmm6"), -str8_lit_comp("zmm7"), -str8_lit_comp("zmm8"), -str8_lit_comp("zmm9"), -str8_lit_comp("zmm10"), -str8_lit_comp("zmm11"), -str8_lit_comp("zmm12"), -str8_lit_comp("zmm13"), -str8_lit_comp("zmm14"), -str8_lit_comp("zmm15"), -str8_lit_comp("zmm16"), -str8_lit_comp("zmm17"), -str8_lit_comp("zmm18"), -str8_lit_comp("zmm19"), -str8_lit_comp("zmm20"), -str8_lit_comp("zmm21"), -str8_lit_comp("zmm22"), -str8_lit_comp("zmm23"), -str8_lit_comp("zmm24"), -str8_lit_comp("zmm25"), -str8_lit_comp("zmm26"), -str8_lit_comp("zmm27"), -str8_lit_comp("zmm28"), -str8_lit_comp("zmm29"), -str8_lit_comp("zmm30"), -str8_lit_comp("zmm31"), -str8_lit_comp("k0"), -str8_lit_comp("k1"), -str8_lit_comp("k2"), -str8_lit_comp("k3"), -str8_lit_comp("k4"), -str8_lit_comp("k5"), -str8_lit_comp("k6"), -str8_lit_comp("k7"), -str8_lit_comp("cetmsr"), -str8_lit_comp("cetssp"), -}; - -String8 regs_g_alias_code_x64_string_table[95] = -{ -str8_lit_comp(""), -str8_lit_comp("eax"), -str8_lit_comp("ecx"), -str8_lit_comp("edx"), -str8_lit_comp("ebx"), -str8_lit_comp("esp"), -str8_lit_comp("ebp"), -str8_lit_comp("esi"), -str8_lit_comp("edi"), -str8_lit_comp("r8d"), -str8_lit_comp("r9d"), -str8_lit_comp("r10d"), -str8_lit_comp("r11d"), -str8_lit_comp("r12d"), -str8_lit_comp("r13d"), -str8_lit_comp("r14d"), -str8_lit_comp("r15d"), -str8_lit_comp("eflags"), -str8_lit_comp("ax"), -str8_lit_comp("cx"), -str8_lit_comp("dx"), -str8_lit_comp("bx"), -str8_lit_comp("si"), -str8_lit_comp("di"), -str8_lit_comp("sp"), -str8_lit_comp("bp"), -str8_lit_comp("ip"), -str8_lit_comp("r8w"), -str8_lit_comp("r9w"), -str8_lit_comp("r10w"), -str8_lit_comp("r11w"), -str8_lit_comp("r12w"), -str8_lit_comp("r13w"), -str8_lit_comp("r14w"), -str8_lit_comp("r15w"), -str8_lit_comp("al"), -str8_lit_comp("cl"), -str8_lit_comp("dl"), -str8_lit_comp("bl"), -str8_lit_comp("sil"), -str8_lit_comp("dil"), -str8_lit_comp("bpl"), -str8_lit_comp("spl"), -str8_lit_comp("r8b"), -str8_lit_comp("r9b"), -str8_lit_comp("r10b"), -str8_lit_comp("r11b"), -str8_lit_comp("r12b"), -str8_lit_comp("r13b"), -str8_lit_comp("r14b"), -str8_lit_comp("r15b"), -str8_lit_comp("ah"), -str8_lit_comp("ch"), -str8_lit_comp("dh"), -str8_lit_comp("bh"), -str8_lit_comp("xmm0"), -str8_lit_comp("xmm1"), -str8_lit_comp("xmm2"), -str8_lit_comp("xmm3"), -str8_lit_comp("xmm4"), -str8_lit_comp("xmm5"), -str8_lit_comp("xmm6"), -str8_lit_comp("xmm7"), -str8_lit_comp("xmm8"), -str8_lit_comp("xmm9"), -str8_lit_comp("xmm10"), -str8_lit_comp("xmm11"), -str8_lit_comp("xmm12"), -str8_lit_comp("xmm13"), -str8_lit_comp("xmm14"), -str8_lit_comp("xmm15"), -str8_lit_comp("ymm0"), -str8_lit_comp("ymm1"), -str8_lit_comp("ymm2"), -str8_lit_comp("ymm3"), -str8_lit_comp("ymm4"), -str8_lit_comp("ymm5"), -str8_lit_comp("ymm6"), -str8_lit_comp("ymm7"), -str8_lit_comp("ymm8"), -str8_lit_comp("ymm9"), -str8_lit_comp("ymm10"), -str8_lit_comp("ymm11"), -str8_lit_comp("ymm12"), -str8_lit_comp("ymm13"), -str8_lit_comp("ymm14"), -str8_lit_comp("ymm15"), -str8_lit_comp("mm0"), -str8_lit_comp("mm1"), -str8_lit_comp("mm2"), -str8_lit_comp("mm3"), -str8_lit_comp("mm4"), -str8_lit_comp("mm5"), -str8_lit_comp("mm6"), -str8_lit_comp("mm7"), -}; - -REGS_Rng regs_g_reg_code_x64_rng_table[93] = -{ -{0}, -{(U16)OffsetOf(REGS_RegBlockX64, rax), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, rcx), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, rdx), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, rbx), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, rsp), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, rbp), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, rsi), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, rdi), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, r8), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, r9), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, r10), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, r11), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, r12), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, r13), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, r14), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, r15), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, fsbase), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, gsbase), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, rip), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, rflags), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, dr0), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, dr1), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, dr2), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, dr3), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, dr4), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, dr5), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, dr6), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, dr7), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, st0), 10}, -{(U16)OffsetOf(REGS_RegBlockX64, st1), 10}, -{(U16)OffsetOf(REGS_RegBlockX64, st2), 10}, -{(U16)OffsetOf(REGS_RegBlockX64, st3), 10}, -{(U16)OffsetOf(REGS_RegBlockX64, st4), 10}, -{(U16)OffsetOf(REGS_RegBlockX64, st5), 10}, -{(U16)OffsetOf(REGS_RegBlockX64, st6), 10}, -{(U16)OffsetOf(REGS_RegBlockX64, st7), 10}, -{(U16)OffsetOf(REGS_RegBlockX64, fcw), 2}, -{(U16)OffsetOf(REGS_RegBlockX64, fsw), 2}, -{(U16)OffsetOf(REGS_RegBlockX64, ftw), 1}, -{(U16)OffsetOf(REGS_RegBlockX64, fop), 2}, -{(U16)OffsetOf(REGS_RegBlockX64, fip), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, fdp), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, mxcsr), 4}, -{(U16)OffsetOf(REGS_RegBlockX64, mxcsr_mask), 4}, -{(U16)OffsetOf(REGS_RegBlockX64, ss), 2}, -{(U16)OffsetOf(REGS_RegBlockX64, cs), 2}, -{(U16)OffsetOf(REGS_RegBlockX64, ds), 2}, -{(U16)OffsetOf(REGS_RegBlockX64, es), 2}, -{(U16)OffsetOf(REGS_RegBlockX64, fs), 2}, -{(U16)OffsetOf(REGS_RegBlockX64, gs), 2}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm0), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm1), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm2), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm3), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm4), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm5), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm6), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm7), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm8), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm9), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm10), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm11), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm12), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm13), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm14), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm15), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm16), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm17), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm18), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm19), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm20), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm21), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm22), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm23), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm24), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm25), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm26), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm27), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm28), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm29), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm30), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, zmm31), 64}, -{(U16)OffsetOf(REGS_RegBlockX64, k0), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, k1), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, k2), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, k3), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, k4), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, k5), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, k6), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, k7), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, cetmsr), 8}, -{(U16)OffsetOf(REGS_RegBlockX64, cetssp), 8}, -}; - -REGS_Slice regs_g_alias_code_x64_slice_table[95] = -{ -{0}, -{REGS_RegCodeX64_rax, 0, 4}, -{REGS_RegCodeX64_rcx, 0, 4}, -{REGS_RegCodeX64_rdx, 0, 4}, -{REGS_RegCodeX64_rbx, 0, 4}, -{REGS_RegCodeX64_rsp, 0, 4}, -{REGS_RegCodeX64_rbp, 0, 4}, -{REGS_RegCodeX64_rsi, 0, 4}, -{REGS_RegCodeX64_rdi, 0, 4}, -{REGS_RegCodeX64_r8, 0, 4}, -{REGS_RegCodeX64_r9, 0, 4}, -{REGS_RegCodeX64_r10, 0, 4}, -{REGS_RegCodeX64_r11, 0, 4}, -{REGS_RegCodeX64_r12, 0, 4}, -{REGS_RegCodeX64_r13, 0, 4}, -{REGS_RegCodeX64_r14, 0, 4}, -{REGS_RegCodeX64_r15, 0, 4}, -{REGS_RegCodeX64_rflags, 0, 4}, -{REGS_RegCodeX64_rax, 0, 2}, -{REGS_RegCodeX64_rcx, 0, 2}, -{REGS_RegCodeX64_rdx, 0, 2}, -{REGS_RegCodeX64_rbx, 0, 2}, -{REGS_RegCodeX64_rsi, 0, 2}, -{REGS_RegCodeX64_rdi, 0, 2}, -{REGS_RegCodeX64_rsp, 0, 2}, -{REGS_RegCodeX64_rbp, 0, 2}, -{REGS_RegCodeX64_rip, 0, 2}, -{REGS_RegCodeX64_r8, 0, 2}, -{REGS_RegCodeX64_r9, 0, 2}, -{REGS_RegCodeX64_r10, 0, 2}, -{REGS_RegCodeX64_r11, 0, 2}, -{REGS_RegCodeX64_r12, 0, 2}, -{REGS_RegCodeX64_r13, 0, 2}, -{REGS_RegCodeX64_r14, 0, 2}, -{REGS_RegCodeX64_r15, 0, 2}, -{REGS_RegCodeX64_rax, 0, 1}, -{REGS_RegCodeX64_rcx, 0, 1}, -{REGS_RegCodeX64_rdx, 0, 1}, -{REGS_RegCodeX64_rbx, 0, 1}, -{REGS_RegCodeX64_rsi, 0, 1}, -{REGS_RegCodeX64_rdi, 0, 1}, -{REGS_RegCodeX64_rbp, 0, 1}, -{REGS_RegCodeX64_rsp, 0, 1}, -{REGS_RegCodeX64_r8, 0, 1}, -{REGS_RegCodeX64_r9, 0, 1}, -{REGS_RegCodeX64_r10, 0, 1}, -{REGS_RegCodeX64_r11, 0, 1}, -{REGS_RegCodeX64_r12, 0, 1}, -{REGS_RegCodeX64_r13, 0, 1}, -{REGS_RegCodeX64_r14, 0, 1}, -{REGS_RegCodeX64_r15, 0, 1}, -{REGS_RegCodeX64_rax, 1, 1}, -{REGS_RegCodeX64_rcx, 1, 1}, -{REGS_RegCodeX64_rdx, 1, 1}, -{REGS_RegCodeX64_rbx, 1, 1}, -{REGS_RegCodeX64_zmm0, 0, 16}, -{REGS_RegCodeX64_zmm1, 0, 16}, -{REGS_RegCodeX64_zmm2, 0, 16}, -{REGS_RegCodeX64_zmm3, 0, 16}, -{REGS_RegCodeX64_zmm4, 0, 16}, -{REGS_RegCodeX64_zmm5, 0, 16}, -{REGS_RegCodeX64_zmm6, 0, 16}, -{REGS_RegCodeX64_zmm7, 0, 16}, -{REGS_RegCodeX64_zmm8, 0, 16}, -{REGS_RegCodeX64_zmm9, 0, 16}, -{REGS_RegCodeX64_zmm10, 0, 16}, -{REGS_RegCodeX64_zmm11, 0, 16}, -{REGS_RegCodeX64_zmm12, 0, 16}, -{REGS_RegCodeX64_zmm13, 0, 16}, -{REGS_RegCodeX64_zmm14, 0, 16}, -{REGS_RegCodeX64_zmm15, 0, 16}, -{REGS_RegCodeX64_zmm0, 0, 32}, -{REGS_RegCodeX64_zmm1, 0, 32}, -{REGS_RegCodeX64_zmm2, 0, 32}, -{REGS_RegCodeX64_zmm3, 0, 32}, -{REGS_RegCodeX64_zmm4, 0, 32}, -{REGS_RegCodeX64_zmm5, 0, 32}, -{REGS_RegCodeX64_zmm6, 0, 32}, -{REGS_RegCodeX64_zmm7, 0, 32}, -{REGS_RegCodeX64_zmm8, 0, 32}, -{REGS_RegCodeX64_zmm9, 0, 32}, -{REGS_RegCodeX64_zmm10, 0, 32}, -{REGS_RegCodeX64_zmm11, 0, 32}, -{REGS_RegCodeX64_zmm12, 0, 32}, -{REGS_RegCodeX64_zmm13, 0, 32}, -{REGS_RegCodeX64_zmm14, 0, 32}, -{REGS_RegCodeX64_zmm15, 0, 32}, -{REGS_RegCodeX64_st0, 0, 8}, -{REGS_RegCodeX64_st1, 0, 8}, -{REGS_RegCodeX64_st2, 0, 8}, -{REGS_RegCodeX64_st3, 0, 8}, -{REGS_RegCodeX64_st4, 0, 8}, -{REGS_RegCodeX64_st5, 0, 8}, -{REGS_RegCodeX64_st6, 0, 8}, -{REGS_RegCodeX64_st7, 0, 8}, -}; - -C_LINKAGE_END - diff --git a/src/regs/generated/regs.meta.h b/src/regs/generated/regs.meta.h deleted file mode 100644 index 5bf2dfdb..00000000 --- a/src/regs/generated/regs.meta.h +++ /dev/null @@ -1,314 +0,0 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//- GENERATED CODE - -#ifndef REGS_META_H -#define REGS_META_H - -typedef enum REGS_RegCodeX64 -{ -REGS_RegCodeX64_NULL, -REGS_RegCodeX64_rax, -REGS_RegCodeX64_rcx, -REGS_RegCodeX64_rdx, -REGS_RegCodeX64_rbx, -REGS_RegCodeX64_rsp, -REGS_RegCodeX64_rbp, -REGS_RegCodeX64_rsi, -REGS_RegCodeX64_rdi, -REGS_RegCodeX64_r8, -REGS_RegCodeX64_r9, -REGS_RegCodeX64_r10, -REGS_RegCodeX64_r11, -REGS_RegCodeX64_r12, -REGS_RegCodeX64_r13, -REGS_RegCodeX64_r14, -REGS_RegCodeX64_r15, -REGS_RegCodeX64_fsbase, -REGS_RegCodeX64_gsbase, -REGS_RegCodeX64_rip, -REGS_RegCodeX64_rflags, -REGS_RegCodeX64_dr0, -REGS_RegCodeX64_dr1, -REGS_RegCodeX64_dr2, -REGS_RegCodeX64_dr3, -REGS_RegCodeX64_dr4, -REGS_RegCodeX64_dr5, -REGS_RegCodeX64_dr6, -REGS_RegCodeX64_dr7, -REGS_RegCodeX64_st0, -REGS_RegCodeX64_st1, -REGS_RegCodeX64_st2, -REGS_RegCodeX64_st3, -REGS_RegCodeX64_st4, -REGS_RegCodeX64_st5, -REGS_RegCodeX64_st6, -REGS_RegCodeX64_st7, -REGS_RegCodeX64_fcw, -REGS_RegCodeX64_fsw, -REGS_RegCodeX64_ftw, -REGS_RegCodeX64_fop, -REGS_RegCodeX64_fip, -REGS_RegCodeX64_fdp, -REGS_RegCodeX64_mxcsr, -REGS_RegCodeX64_mxcsr_mask, -REGS_RegCodeX64_ss, -REGS_RegCodeX64_cs, -REGS_RegCodeX64_ds, -REGS_RegCodeX64_es, -REGS_RegCodeX64_fs, -REGS_RegCodeX64_gs, -REGS_RegCodeX64_zmm0, -REGS_RegCodeX64_zmm1, -REGS_RegCodeX64_zmm2, -REGS_RegCodeX64_zmm3, -REGS_RegCodeX64_zmm4, -REGS_RegCodeX64_zmm5, -REGS_RegCodeX64_zmm6, -REGS_RegCodeX64_zmm7, -REGS_RegCodeX64_zmm8, -REGS_RegCodeX64_zmm9, -REGS_RegCodeX64_zmm10, -REGS_RegCodeX64_zmm11, -REGS_RegCodeX64_zmm12, -REGS_RegCodeX64_zmm13, -REGS_RegCodeX64_zmm14, -REGS_RegCodeX64_zmm15, -REGS_RegCodeX64_zmm16, -REGS_RegCodeX64_zmm17, -REGS_RegCodeX64_zmm18, -REGS_RegCodeX64_zmm19, -REGS_RegCodeX64_zmm20, -REGS_RegCodeX64_zmm21, -REGS_RegCodeX64_zmm22, -REGS_RegCodeX64_zmm23, -REGS_RegCodeX64_zmm24, -REGS_RegCodeX64_zmm25, -REGS_RegCodeX64_zmm26, -REGS_RegCodeX64_zmm27, -REGS_RegCodeX64_zmm28, -REGS_RegCodeX64_zmm29, -REGS_RegCodeX64_zmm30, -REGS_RegCodeX64_zmm31, -REGS_RegCodeX64_k0, -REGS_RegCodeX64_k1, -REGS_RegCodeX64_k2, -REGS_RegCodeX64_k3, -REGS_RegCodeX64_k4, -REGS_RegCodeX64_k5, -REGS_RegCodeX64_k6, -REGS_RegCodeX64_k7, -REGS_RegCodeX64_cetmsr, -REGS_RegCodeX64_cetssp, -REGS_RegCodeX64_COUNT, -} REGS_RegCodeX64; - -typedef enum REGS_AliasCodeX64 -{ -REGS_AliasCodeX64_NULL, -REGS_AliasCodeX64_eax, -REGS_AliasCodeX64_ecx, -REGS_AliasCodeX64_edx, -REGS_AliasCodeX64_ebx, -REGS_AliasCodeX64_esp, -REGS_AliasCodeX64_ebp, -REGS_AliasCodeX64_esi, -REGS_AliasCodeX64_edi, -REGS_AliasCodeX64_r8d, -REGS_AliasCodeX64_r9d, -REGS_AliasCodeX64_r10d, -REGS_AliasCodeX64_r11d, -REGS_AliasCodeX64_r12d, -REGS_AliasCodeX64_r13d, -REGS_AliasCodeX64_r14d, -REGS_AliasCodeX64_r15d, -REGS_AliasCodeX64_eflags, -REGS_AliasCodeX64_ax, -REGS_AliasCodeX64_cx, -REGS_AliasCodeX64_dx, -REGS_AliasCodeX64_bx, -REGS_AliasCodeX64_si, -REGS_AliasCodeX64_di, -REGS_AliasCodeX64_sp, -REGS_AliasCodeX64_bp, -REGS_AliasCodeX64_ip, -REGS_AliasCodeX64_r8w, -REGS_AliasCodeX64_r9w, -REGS_AliasCodeX64_r10w, -REGS_AliasCodeX64_r11w, -REGS_AliasCodeX64_r12w, -REGS_AliasCodeX64_r13w, -REGS_AliasCodeX64_r14w, -REGS_AliasCodeX64_r15w, -REGS_AliasCodeX64_al, -REGS_AliasCodeX64_cl, -REGS_AliasCodeX64_dl, -REGS_AliasCodeX64_bl, -REGS_AliasCodeX64_sil, -REGS_AliasCodeX64_dil, -REGS_AliasCodeX64_bpl, -REGS_AliasCodeX64_spl, -REGS_AliasCodeX64_r8b, -REGS_AliasCodeX64_r9b, -REGS_AliasCodeX64_r10b, -REGS_AliasCodeX64_r11b, -REGS_AliasCodeX64_r12b, -REGS_AliasCodeX64_r13b, -REGS_AliasCodeX64_r14b, -REGS_AliasCodeX64_r15b, -REGS_AliasCodeX64_ah, -REGS_AliasCodeX64_ch, -REGS_AliasCodeX64_dh, -REGS_AliasCodeX64_bh, -REGS_AliasCodeX64_xmm0, -REGS_AliasCodeX64_xmm1, -REGS_AliasCodeX64_xmm2, -REGS_AliasCodeX64_xmm3, -REGS_AliasCodeX64_xmm4, -REGS_AliasCodeX64_xmm5, -REGS_AliasCodeX64_xmm6, -REGS_AliasCodeX64_xmm7, -REGS_AliasCodeX64_xmm8, -REGS_AliasCodeX64_xmm9, -REGS_AliasCodeX64_xmm10, -REGS_AliasCodeX64_xmm11, -REGS_AliasCodeX64_xmm12, -REGS_AliasCodeX64_xmm13, -REGS_AliasCodeX64_xmm14, -REGS_AliasCodeX64_xmm15, -REGS_AliasCodeX64_ymm0, -REGS_AliasCodeX64_ymm1, -REGS_AliasCodeX64_ymm2, -REGS_AliasCodeX64_ymm3, -REGS_AliasCodeX64_ymm4, -REGS_AliasCodeX64_ymm5, -REGS_AliasCodeX64_ymm6, -REGS_AliasCodeX64_ymm7, -REGS_AliasCodeX64_ymm8, -REGS_AliasCodeX64_ymm9, -REGS_AliasCodeX64_ymm10, -REGS_AliasCodeX64_ymm11, -REGS_AliasCodeX64_ymm12, -REGS_AliasCodeX64_ymm13, -REGS_AliasCodeX64_ymm14, -REGS_AliasCodeX64_ymm15, -REGS_AliasCodeX64_mm0, -REGS_AliasCodeX64_mm1, -REGS_AliasCodeX64_mm2, -REGS_AliasCodeX64_mm3, -REGS_AliasCodeX64_mm4, -REGS_AliasCodeX64_mm5, -REGS_AliasCodeX64_mm6, -REGS_AliasCodeX64_mm7, -REGS_AliasCodeX64_COUNT, -} REGS_AliasCodeX64; - -typedef struct REGS_RegBlockX64 REGS_RegBlockX64; -struct REGS_RegBlockX64 -{ -REGS_Reg64 rax; -REGS_Reg64 rcx; -REGS_Reg64 rdx; -REGS_Reg64 rbx; -REGS_Reg64 rsp; -REGS_Reg64 rbp; -REGS_Reg64 rsi; -REGS_Reg64 rdi; -REGS_Reg64 r8; -REGS_Reg64 r9; -REGS_Reg64 r10; -REGS_Reg64 r11; -REGS_Reg64 r12; -REGS_Reg64 r13; -REGS_Reg64 r14; -REGS_Reg64 r15; -REGS_Reg64 fsbase; -REGS_Reg64 gsbase; -REGS_Reg64 rip; -REGS_Reg64 rflags; -REGS_Reg64 dr0; -REGS_Reg64 dr1; -REGS_Reg64 dr2; -REGS_Reg64 dr3; -REGS_Reg64 dr4; -REGS_Reg64 dr5; -REGS_Reg64 dr6; -REGS_Reg64 dr7; -REGS_Reg80 st0; -REGS_Reg80 st1; -REGS_Reg80 st2; -REGS_Reg80 st3; -REGS_Reg80 st4; -REGS_Reg80 st5; -REGS_Reg80 st6; -REGS_Reg80 st7; -REGS_Reg16 fcw; -REGS_Reg16 fsw; -REGS_Reg8 ftw; -REGS_Reg16 fop; -REGS_Reg64 fip; -REGS_Reg64 fdp; -REGS_Reg32 mxcsr; -REGS_Reg32 mxcsr_mask; -REGS_Reg16 ss; -REGS_Reg16 cs; -REGS_Reg16 ds; -REGS_Reg16 es; -REGS_Reg16 fs; -REGS_Reg16 gs; -REGS_Reg512 zmm0; -REGS_Reg512 zmm1; -REGS_Reg512 zmm2; -REGS_Reg512 zmm3; -REGS_Reg512 zmm4; -REGS_Reg512 zmm5; -REGS_Reg512 zmm6; -REGS_Reg512 zmm7; -REGS_Reg512 zmm8; -REGS_Reg512 zmm9; -REGS_Reg512 zmm10; -REGS_Reg512 zmm11; -REGS_Reg512 zmm12; -REGS_Reg512 zmm13; -REGS_Reg512 zmm14; -REGS_Reg512 zmm15; -REGS_Reg512 zmm16; -REGS_Reg512 zmm17; -REGS_Reg512 zmm18; -REGS_Reg512 zmm19; -REGS_Reg512 zmm20; -REGS_Reg512 zmm21; -REGS_Reg512 zmm22; -REGS_Reg512 zmm23; -REGS_Reg512 zmm24; -REGS_Reg512 zmm25; -REGS_Reg512 zmm26; -REGS_Reg512 zmm27; -REGS_Reg512 zmm28; -REGS_Reg512 zmm29; -REGS_Reg512 zmm30; -REGS_Reg512 zmm31; -REGS_Reg64 k0; -REGS_Reg64 k1; -REGS_Reg64 k2; -REGS_Reg64 k3; -REGS_Reg64 k4; -REGS_Reg64 k5; -REGS_Reg64 k6; -REGS_Reg64 k7; -REGS_Reg64 cetmsr; -REGS_Reg64 cetssp; -}; - -C_LINKAGE_BEGIN -extern REGS_UsageKind regs_g_reg_code_x64_usage_kind_table[93]; -extern REGS_UsageKind regs_g_alias_code_x64_usage_kind_table[95]; -extern String8 regs_g_reg_code_x64_string_table[93]; -extern String8 regs_g_alias_code_x64_string_table[95]; -extern REGS_Rng regs_g_reg_code_x64_rng_table[93]; -extern REGS_Slice regs_g_alias_code_x64_slice_table[95]; - -C_LINKAGE_END - -#endif // REGS_META_H diff --git a/src/regs/rdi/generated/regs_rdi.meta.c b/src/regs/rdi/generated/regs_rdi.meta.c deleted file mode 100644 index 49a4c827..00000000 --- a/src/regs/rdi/generated/regs_rdi.meta.c +++ /dev/null @@ -1,229 +0,0 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//- GENERATED CODE - -internal RDI_RegCode regs_rdi_code_from_arch_reg_code(Arch arch, REGS_RegCode code) -{ -RDI_RegCode result = 0; -switch(arch) -{ -default:{}break; -case Arch_x64: -{ -switch(code) -{ -default:{}break; -case REGS_RegCodeX64_rax:{result = RDI_RegCodeX64_rax;}break; -case REGS_RegCodeX64_rcx:{result = RDI_RegCodeX64_rcx;}break; -case REGS_RegCodeX64_rdx:{result = RDI_RegCodeX64_rdx;}break; -case REGS_RegCodeX64_rbx:{result = RDI_RegCodeX64_rbx;}break; -case REGS_RegCodeX64_rsp:{result = RDI_RegCodeX64_rsp;}break; -case REGS_RegCodeX64_rbp:{result = RDI_RegCodeX64_rbp;}break; -case REGS_RegCodeX64_rsi:{result = RDI_RegCodeX64_rsi;}break; -case REGS_RegCodeX64_rdi:{result = RDI_RegCodeX64_rdi;}break; -case REGS_RegCodeX64_r8:{result = RDI_RegCodeX64_r8;}break; -case REGS_RegCodeX64_r9:{result = RDI_RegCodeX64_r9;}break; -case REGS_RegCodeX64_r10:{result = RDI_RegCodeX64_r10;}break; -case REGS_RegCodeX64_r11:{result = RDI_RegCodeX64_r11;}break; -case REGS_RegCodeX64_r12:{result = RDI_RegCodeX64_r12;}break; -case REGS_RegCodeX64_r13:{result = RDI_RegCodeX64_r13;}break; -case REGS_RegCodeX64_r14:{result = RDI_RegCodeX64_r14;}break; -case REGS_RegCodeX64_r15:{result = RDI_RegCodeX64_r15;}break; -case REGS_RegCodeX64_fsbase:{result = RDI_RegCodeX64_fsbase;}break; -case REGS_RegCodeX64_gsbase:{result = RDI_RegCodeX64_gsbase;}break; -case REGS_RegCodeX64_rip:{result = RDI_RegCodeX64_rip;}break; -case REGS_RegCodeX64_rflags:{result = RDI_RegCodeX64_rflags;}break; -case REGS_RegCodeX64_dr0:{result = RDI_RegCodeX64_dr0;}break; -case REGS_RegCodeX64_dr1:{result = RDI_RegCodeX64_dr1;}break; -case REGS_RegCodeX64_dr2:{result = RDI_RegCodeX64_dr2;}break; -case REGS_RegCodeX64_dr3:{result = RDI_RegCodeX64_dr3;}break; -case REGS_RegCodeX64_dr4:{result = RDI_RegCodeX64_dr4;}break; -case REGS_RegCodeX64_dr5:{result = RDI_RegCodeX64_dr5;}break; -case REGS_RegCodeX64_dr6:{result = RDI_RegCodeX64_dr6;}break; -case REGS_RegCodeX64_dr7:{result = RDI_RegCodeX64_dr7;}break; -case REGS_RegCodeX64_st0:{result = RDI_RegCodeX64_st0;}break; -case REGS_RegCodeX64_st1:{result = RDI_RegCodeX64_st1;}break; -case REGS_RegCodeX64_st2:{result = RDI_RegCodeX64_st2;}break; -case REGS_RegCodeX64_st3:{result = RDI_RegCodeX64_st3;}break; -case REGS_RegCodeX64_st4:{result = RDI_RegCodeX64_st4;}break; -case REGS_RegCodeX64_st5:{result = RDI_RegCodeX64_st5;}break; -case REGS_RegCodeX64_st6:{result = RDI_RegCodeX64_st6;}break; -case REGS_RegCodeX64_st7:{result = RDI_RegCodeX64_st7;}break; -case REGS_RegCodeX64_fcw:{result = RDI_RegCodeX64_fcw;}break; -case REGS_RegCodeX64_fsw:{result = RDI_RegCodeX64_fsw;}break; -case REGS_RegCodeX64_ftw:{result = RDI_RegCodeX64_ftw;}break; -case REGS_RegCodeX64_fop:{result = RDI_RegCodeX64_fop;}break; -case REGS_RegCodeX64_fip:{result = RDI_RegCodeX64_fip;}break; -case REGS_RegCodeX64_fdp:{result = RDI_RegCodeX64_fdp;}break; -case REGS_RegCodeX64_mxcsr:{result = RDI_RegCodeX64_mxcsr;}break; -case REGS_RegCodeX64_mxcsr_mask:{result = RDI_RegCodeX64_mxcsr_mask;}break; -case REGS_RegCodeX64_ss:{result = RDI_RegCodeX64_ss;}break; -case REGS_RegCodeX64_cs:{result = RDI_RegCodeX64_cs;}break; -case REGS_RegCodeX64_ds:{result = RDI_RegCodeX64_ds;}break; -case REGS_RegCodeX64_es:{result = RDI_RegCodeX64_es;}break; -case REGS_RegCodeX64_fs:{result = RDI_RegCodeX64_fs;}break; -case REGS_RegCodeX64_gs:{result = RDI_RegCodeX64_gs;}break; -case REGS_RegCodeX64_zmm0:{result = RDI_RegCodeX64_zmm0;}break; -case REGS_RegCodeX64_zmm1:{result = RDI_RegCodeX64_zmm1;}break; -case REGS_RegCodeX64_zmm2:{result = RDI_RegCodeX64_zmm2;}break; -case REGS_RegCodeX64_zmm3:{result = RDI_RegCodeX64_zmm3;}break; -case REGS_RegCodeX64_zmm4:{result = RDI_RegCodeX64_zmm4;}break; -case REGS_RegCodeX64_zmm5:{result = RDI_RegCodeX64_zmm5;}break; -case REGS_RegCodeX64_zmm6:{result = RDI_RegCodeX64_zmm6;}break; -case REGS_RegCodeX64_zmm7:{result = RDI_RegCodeX64_zmm7;}break; -case REGS_RegCodeX64_zmm8:{result = RDI_RegCodeX64_zmm8;}break; -case REGS_RegCodeX64_zmm9:{result = RDI_RegCodeX64_zmm9;}break; -case REGS_RegCodeX64_zmm10:{result = RDI_RegCodeX64_zmm10;}break; -case REGS_RegCodeX64_zmm11:{result = RDI_RegCodeX64_zmm11;}break; -case REGS_RegCodeX64_zmm12:{result = RDI_RegCodeX64_zmm12;}break; -case REGS_RegCodeX64_zmm13:{result = RDI_RegCodeX64_zmm13;}break; -case REGS_RegCodeX64_zmm14:{result = RDI_RegCodeX64_zmm14;}break; -case REGS_RegCodeX64_zmm15:{result = RDI_RegCodeX64_zmm15;}break; -case REGS_RegCodeX64_zmm16:{result = RDI_RegCodeX64_zmm16;}break; -case REGS_RegCodeX64_zmm17:{result = RDI_RegCodeX64_zmm17;}break; -case REGS_RegCodeX64_zmm18:{result = RDI_RegCodeX64_zmm18;}break; -case REGS_RegCodeX64_zmm19:{result = RDI_RegCodeX64_zmm19;}break; -case REGS_RegCodeX64_zmm20:{result = RDI_RegCodeX64_zmm20;}break; -case REGS_RegCodeX64_zmm21:{result = RDI_RegCodeX64_zmm21;}break; -case REGS_RegCodeX64_zmm22:{result = RDI_RegCodeX64_zmm22;}break; -case REGS_RegCodeX64_zmm23:{result = RDI_RegCodeX64_zmm23;}break; -case REGS_RegCodeX64_zmm24:{result = RDI_RegCodeX64_zmm24;}break; -case REGS_RegCodeX64_zmm25:{result = RDI_RegCodeX64_zmm25;}break; -case REGS_RegCodeX64_zmm26:{result = RDI_RegCodeX64_zmm26;}break; -case REGS_RegCodeX64_zmm27:{result = RDI_RegCodeX64_zmm27;}break; -case REGS_RegCodeX64_zmm28:{result = RDI_RegCodeX64_zmm28;}break; -case REGS_RegCodeX64_zmm29:{result = RDI_RegCodeX64_zmm29;}break; -case REGS_RegCodeX64_zmm30:{result = RDI_RegCodeX64_zmm30;}break; -case REGS_RegCodeX64_zmm31:{result = RDI_RegCodeX64_zmm31;}break; -case REGS_RegCodeX64_k0:{result = RDI_RegCodeX64_k0;}break; -case REGS_RegCodeX64_k1:{result = RDI_RegCodeX64_k1;}break; -case REGS_RegCodeX64_k2:{result = RDI_RegCodeX64_k2;}break; -case REGS_RegCodeX64_k3:{result = RDI_RegCodeX64_k3;}break; -case REGS_RegCodeX64_k4:{result = RDI_RegCodeX64_k4;}break; -case REGS_RegCodeX64_k5:{result = RDI_RegCodeX64_k5;}break; -case REGS_RegCodeX64_k6:{result = RDI_RegCodeX64_k6;}break; -case REGS_RegCodeX64_k7:{result = RDI_RegCodeX64_k7;}break; -case REGS_RegCodeX64_cetmsr:{result = RDI_RegCodeX64_cetmsr;}break; -case REGS_RegCodeX64_cetssp:{result = RDI_RegCodeX64_cetssp;}break; -} -}break; -case Arch_x86: -{ -NotImplemented; -}break; -} -return result; -} -internal REGS_RegCode regs_reg_code_from_arch_rdi_code(Arch arch, RDI_RegCode code) -{ -REGS_RegCode result = 0; -switch(arch) -{ -default:{}break; -case Arch_x64: -{ -switch(code) -{ -default:{}break; -case RDI_RegCodeX64_rax:{result = REGS_RegCodeX64_rax;}break; -case RDI_RegCodeX64_rcx:{result = REGS_RegCodeX64_rcx;}break; -case RDI_RegCodeX64_rdx:{result = REGS_RegCodeX64_rdx;}break; -case RDI_RegCodeX64_rbx:{result = REGS_RegCodeX64_rbx;}break; -case RDI_RegCodeX64_rsp:{result = REGS_RegCodeX64_rsp;}break; -case RDI_RegCodeX64_rbp:{result = REGS_RegCodeX64_rbp;}break; -case RDI_RegCodeX64_rsi:{result = REGS_RegCodeX64_rsi;}break; -case RDI_RegCodeX64_rdi:{result = REGS_RegCodeX64_rdi;}break; -case RDI_RegCodeX64_r8:{result = REGS_RegCodeX64_r8;}break; -case RDI_RegCodeX64_r9:{result = REGS_RegCodeX64_r9;}break; -case RDI_RegCodeX64_r10:{result = REGS_RegCodeX64_r10;}break; -case RDI_RegCodeX64_r11:{result = REGS_RegCodeX64_r11;}break; -case RDI_RegCodeX64_r12:{result = REGS_RegCodeX64_r12;}break; -case RDI_RegCodeX64_r13:{result = REGS_RegCodeX64_r13;}break; -case RDI_RegCodeX64_r14:{result = REGS_RegCodeX64_r14;}break; -case RDI_RegCodeX64_r15:{result = REGS_RegCodeX64_r15;}break; -case RDI_RegCodeX64_fsbase:{result = REGS_RegCodeX64_fsbase;}break; -case RDI_RegCodeX64_gsbase:{result = REGS_RegCodeX64_gsbase;}break; -case RDI_RegCodeX64_rip:{result = REGS_RegCodeX64_rip;}break; -case RDI_RegCodeX64_rflags:{result = REGS_RegCodeX64_rflags;}break; -case RDI_RegCodeX64_dr0:{result = REGS_RegCodeX64_dr0;}break; -case RDI_RegCodeX64_dr1:{result = REGS_RegCodeX64_dr1;}break; -case RDI_RegCodeX64_dr2:{result = REGS_RegCodeX64_dr2;}break; -case RDI_RegCodeX64_dr3:{result = REGS_RegCodeX64_dr3;}break; -case RDI_RegCodeX64_dr4:{result = REGS_RegCodeX64_dr4;}break; -case RDI_RegCodeX64_dr5:{result = REGS_RegCodeX64_dr5;}break; -case RDI_RegCodeX64_dr6:{result = REGS_RegCodeX64_dr6;}break; -case RDI_RegCodeX64_dr7:{result = REGS_RegCodeX64_dr7;}break; -case RDI_RegCodeX64_st0:{result = REGS_RegCodeX64_st0;}break; -case RDI_RegCodeX64_st1:{result = REGS_RegCodeX64_st1;}break; -case RDI_RegCodeX64_st2:{result = REGS_RegCodeX64_st2;}break; -case RDI_RegCodeX64_st3:{result = REGS_RegCodeX64_st3;}break; -case RDI_RegCodeX64_st4:{result = REGS_RegCodeX64_st4;}break; -case RDI_RegCodeX64_st5:{result = REGS_RegCodeX64_st5;}break; -case RDI_RegCodeX64_st6:{result = REGS_RegCodeX64_st6;}break; -case RDI_RegCodeX64_st7:{result = REGS_RegCodeX64_st7;}break; -case RDI_RegCodeX64_fcw:{result = REGS_RegCodeX64_fcw;}break; -case RDI_RegCodeX64_fsw:{result = REGS_RegCodeX64_fsw;}break; -case RDI_RegCodeX64_ftw:{result = REGS_RegCodeX64_ftw;}break; -case RDI_RegCodeX64_fop:{result = REGS_RegCodeX64_fop;}break; -case RDI_RegCodeX64_fip:{result = REGS_RegCodeX64_fip;}break; -case RDI_RegCodeX64_fdp:{result = REGS_RegCodeX64_fdp;}break; -case RDI_RegCodeX64_mxcsr:{result = REGS_RegCodeX64_mxcsr;}break; -case RDI_RegCodeX64_mxcsr_mask:{result = REGS_RegCodeX64_mxcsr_mask;}break; -case RDI_RegCodeX64_ss:{result = REGS_RegCodeX64_ss;}break; -case RDI_RegCodeX64_cs:{result = REGS_RegCodeX64_cs;}break; -case RDI_RegCodeX64_ds:{result = REGS_RegCodeX64_ds;}break; -case RDI_RegCodeX64_es:{result = REGS_RegCodeX64_es;}break; -case RDI_RegCodeX64_fs:{result = REGS_RegCodeX64_fs;}break; -case RDI_RegCodeX64_gs:{result = REGS_RegCodeX64_gs;}break; -case RDI_RegCodeX64_zmm0:{result = REGS_RegCodeX64_zmm0;}break; -case RDI_RegCodeX64_zmm1:{result = REGS_RegCodeX64_zmm1;}break; -case RDI_RegCodeX64_zmm2:{result = REGS_RegCodeX64_zmm2;}break; -case RDI_RegCodeX64_zmm3:{result = REGS_RegCodeX64_zmm3;}break; -case RDI_RegCodeX64_zmm4:{result = REGS_RegCodeX64_zmm4;}break; -case RDI_RegCodeX64_zmm5:{result = REGS_RegCodeX64_zmm5;}break; -case RDI_RegCodeX64_zmm6:{result = REGS_RegCodeX64_zmm6;}break; -case RDI_RegCodeX64_zmm7:{result = REGS_RegCodeX64_zmm7;}break; -case RDI_RegCodeX64_zmm8:{result = REGS_RegCodeX64_zmm8;}break; -case RDI_RegCodeX64_zmm9:{result = REGS_RegCodeX64_zmm9;}break; -case RDI_RegCodeX64_zmm10:{result = REGS_RegCodeX64_zmm10;}break; -case RDI_RegCodeX64_zmm11:{result = REGS_RegCodeX64_zmm11;}break; -case RDI_RegCodeX64_zmm12:{result = REGS_RegCodeX64_zmm12;}break; -case RDI_RegCodeX64_zmm13:{result = REGS_RegCodeX64_zmm13;}break; -case RDI_RegCodeX64_zmm14:{result = REGS_RegCodeX64_zmm14;}break; -case RDI_RegCodeX64_zmm15:{result = REGS_RegCodeX64_zmm15;}break; -case RDI_RegCodeX64_zmm16:{result = REGS_RegCodeX64_zmm16;}break; -case RDI_RegCodeX64_zmm17:{result = REGS_RegCodeX64_zmm17;}break; -case RDI_RegCodeX64_zmm18:{result = REGS_RegCodeX64_zmm18;}break; -case RDI_RegCodeX64_zmm19:{result = REGS_RegCodeX64_zmm19;}break; -case RDI_RegCodeX64_zmm20:{result = REGS_RegCodeX64_zmm20;}break; -case RDI_RegCodeX64_zmm21:{result = REGS_RegCodeX64_zmm21;}break; -case RDI_RegCodeX64_zmm22:{result = REGS_RegCodeX64_zmm22;}break; -case RDI_RegCodeX64_zmm23:{result = REGS_RegCodeX64_zmm23;}break; -case RDI_RegCodeX64_zmm24:{result = REGS_RegCodeX64_zmm24;}break; -case RDI_RegCodeX64_zmm25:{result = REGS_RegCodeX64_zmm25;}break; -case RDI_RegCodeX64_zmm26:{result = REGS_RegCodeX64_zmm26;}break; -case RDI_RegCodeX64_zmm27:{result = REGS_RegCodeX64_zmm27;}break; -case RDI_RegCodeX64_zmm28:{result = REGS_RegCodeX64_zmm28;}break; -case RDI_RegCodeX64_zmm29:{result = REGS_RegCodeX64_zmm29;}break; -case RDI_RegCodeX64_zmm30:{result = REGS_RegCodeX64_zmm30;}break; -case RDI_RegCodeX64_zmm31:{result = REGS_RegCodeX64_zmm31;}break; -case RDI_RegCodeX64_k0:{result = REGS_RegCodeX64_k0;}break; -case RDI_RegCodeX64_k1:{result = REGS_RegCodeX64_k1;}break; -case RDI_RegCodeX64_k2:{result = REGS_RegCodeX64_k2;}break; -case RDI_RegCodeX64_k3:{result = REGS_RegCodeX64_k3;}break; -case RDI_RegCodeX64_k4:{result = REGS_RegCodeX64_k4;}break; -case RDI_RegCodeX64_k5:{result = REGS_RegCodeX64_k5;}break; -case RDI_RegCodeX64_k6:{result = REGS_RegCodeX64_k6;}break; -case RDI_RegCodeX64_k7:{result = REGS_RegCodeX64_k7;}break; -case RDI_RegCodeX64_cetmsr:{result = REGS_RegCodeX64_cetmsr;}break; -case RDI_RegCodeX64_cetssp:{result = REGS_RegCodeX64_cetssp;}break; -} -}break; -case Arch_x86: -{ -NotImplemented; -}break; -} -return result; -} diff --git a/src/regs/rdi/regs_rdi.h b/src/regs/rdi/regs_rdi.h deleted file mode 100644 index a7fadd80..00000000 --- a/src/regs/rdi/regs_rdi.h +++ /dev/null @@ -1,10 +0,0 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -#ifndef REGS_RDI_H -#define REGS_RDI_H - -internal RDI_RegCode regs_rdi_code_from_arch_reg_code(Arch arch, REGS_RegCode code); -internal REGS_RegCode regs_reg_code_from_arch_rdi_code(Arch arch, RDI_RegCode reg); - -#endif //REGS_RDI_H diff --git a/src/regs/rdi/regs_rdi.mdesk b/src/regs/rdi/regs_rdi.mdesk deleted file mode 100644 index a03b73ea..00000000 --- a/src/regs/rdi/regs_rdi.mdesk +++ /dev/null @@ -1,55 +0,0 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//////////////////////////////// -//~ rjf: RADDBG Converter Helper Implementation Generators - -@gen @c_file -{ - `internal RDI_RegCode regs_rdi_code_from_arch_reg_code(Arch arch, REGS_RegCode code)`; - `{`; - `RDI_RegCode result = 0;`; - `switch(arch)`; - `{`; - `default:{}break;`; - `case Arch_x64:`; - `{`; - `switch(code)` - `{`; - `default:{}break;`; - @expand(REGS_RegTableX64 a) `case REGS_RegCodeX64_$(a.name):{result = RDI_RegCodeX64_$(a.name);}break;`; - `}`; - `}break;`; - `case Arch_x86:`; - `{`; - `NotImplemented;` - `}break;`; - `}`; - `return result;`; - `}`; -} - -@gen @c_file -{ - `internal REGS_RegCode regs_reg_code_from_arch_rdi_code(Arch arch, RDI_RegCode code)`; - `{`; - `REGS_RegCode result = 0;`; - `switch(arch)`; - `{`; - `default:{}break;`; - `case Arch_x64:`; - `{`; - `switch(code)` - `{`; - `default:{}break;`; - @expand(REGS_RegTableX64 a) `case RDI_RegCodeX64_$(a.name):{result = REGS_RegCodeX64_$(a.name);}break;`; - `}`; - `}break;`; - `case Arch_x86:`; - `{`; - `NotImplemented;` - `}break;`; - `}`; - `return result;`; - `}`; -} diff --git a/src/regs/regs.c b/src/regs/regs.c deleted file mode 100644 index 83b171d7..00000000 --- a/src/regs/regs.c +++ /dev/null @@ -1,106 +0,0 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//////////////////////////////// -//~ rjf: Generated Code - -#include "regs/generated/regs.meta.c" - -//////////////////////////////// -//~ rjf: Helpers - -internal REGS_RegCode -regs_reg_code_from_name(Arch arch, String8 name) -{ - String8 *name_table = regs_reg_code_string_table_from_arch(arch); - U64 name_count = regs_reg_code_count_from_arch(arch); - for EachIndex(i, name_count) - { - if(str8_match(name_table[i], name, StringMatchFlag_CaseInsensitive)) - { - return (REGS_RegCode)i; - } - } - return 0; -} - -internal REGS_AliasCode -regs_alias_code_from_name(Arch arch, String8 name) -{ - String8 *alias_table = regs_alias_code_string_table_from_arch(arch); - U64 alias_count = regs_alias_code_count_from_arch(arch); - for EachIndex(i, alias_count) - { - if(str8_match(alias_table[i], name, StringMatchFlag_CaseInsensitive)) - { - return (REGS_RegCode)i; - } - } - return 0; -} - -internal Rng1U64 -regs_range_from_code(Arch arch, B32 is_alias, U64 reg_code) -{ - Rng1U64 range = {0}; - if(is_alias) - { - REGS_Slice slice = regs_alias_code_slice_table_from_arch(arch)[reg_code]; - REGS_Rng rng = regs_reg_code_rng_table_from_arch(arch)[reg_code]; - range = r1u64(rng.byte_off + slice.byte_off, rng.byte_off + slice.byte_off + slice.byte_size); - } - else - { - REGS_Rng rng = regs_reg_code_rng_table_from_arch(arch)[reg_code]; - range = r1u64(rng.byte_off, rng.byte_off + rng.byte_size); - } - return range; -} - -internal U64 -regs_rip_from_arch_block(Arch arch, void *block) -{ - U64 result = 0; - if(block != 0) switch(arch) - { - default:{}break; - case Arch_x64:{result = ((REGS_RegBlockX64 *)block)->rip.u64;}break; - case Arch_x86:{NotImplemented;}break; - } - return result; -} - -internal U64 -regs_rsp_from_arch_block(Arch arch, void *block) -{ - U64 result = 0; - if(block != 0) switch(arch) - { - default:{}break; - case Arch_x64:{result = ((REGS_RegBlockX64 *)block)->rsp.u64;}break; - case Arch_x86:{NotImplemented;}break; - } - return result; -} - -internal void -regs_arch_block_write_rip(Arch arch, void *block, U64 rip) -{ - if(block != 0) switch(arch) - { - default:{}break; - case Arch_x64:{((REGS_RegBlockX64 *)block)->rip.u64 = rip;}break; - case Arch_x86:{NotImplemented;}break; - } -} - -internal void -regs_arch_block_write_rsp(Arch arch, void *block, U64 rsp) -{ - if(block != 0) switch(arch) - { - default:{}break; - case Arch_x64:{((REGS_RegBlockX64 *)block)->rsp.u64 = rsp;}break; - case Arch_x86:{NotImplemented;}break; - } -} diff --git a/src/regs/regs.h b/src/regs/regs.h deleted file mode 100644 index 76214f41..00000000 --- a/src/regs/regs.h +++ /dev/null @@ -1,131 +0,0 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -#ifndef REGS_H -#define REGS_H - -//////////////////////////////// -//~ rjf: Register Usage Kinds - -typedef enum REGS_UsageKind -{ - REGS_UsageKind_Normal, - REGS_UsageKind_Vector, -} -REGS_UsageKind; - -//////////////////////////////// -//~ rjf: Register Types - -typedef U8 REGS_RegCode; -typedef U8 REGS_AliasCode; - -typedef U8 REGS_Reg8; - -typedef union REGS_Reg16 REGS_Reg16; -union REGS_Reg16 -{ - U8 v[2]; - U16 u16; -}; - -typedef union REGS_Reg32 REGS_Reg32; -union REGS_Reg32 -{ - U8 v[4]; - U32 u32; - F32 f32; -}; - -typedef union REGS_Reg64 REGS_Reg64; -union REGS_Reg64 -{ - U8 v[8]; - U32 u32[2]; - U64 u64; - F64 f64; -}; - -#pragma pack(push, 1) -typedef struct REGS_Reg80 REGS_Reg80; -struct REGS_Reg80 -{ - U64 int1_frac63; - U16 sign1_exp15; -}; -#pragma pack(pop) - -typedef union REGS_Reg128 REGS_Reg128; -union REGS_Reg128 -{ - U8 v[16]; - U32 u32[4]; - F32 f32[4]; - U64 u64[2]; - F64 f64[2]; -}; - -typedef union REGS_Reg256 REGS_Reg256; -union REGS_Reg256 -{ - U8 v[32]; - U32 u32[8]; - F32 f32[8]; - U64 u64[4]; - F64 f64[4]; -}; - -typedef union REGS_Reg512 REGS_Reg512; -union REGS_Reg512 -{ - U8 v[64]; - U32 u32[16]; - F32 f32[16]; - U64 u64[8]; - F64 f64[8]; -}; - -//////////////////////////////// -//~ rjf: Register Slicing Types - -typedef struct REGS_Rng REGS_Rng; -struct REGS_Rng -{ - U16 byte_off; - U16 byte_size; -}; - -typedef struct REGS_Slice REGS_Slice; -struct REGS_Slice -{ - U16 code; - U8 byte_off; - U8 byte_size; -}; - -//////////////////////////////// -//~ rjf: Generated Code - -#include "regs/generated/regs.meta.h" - -//////////////////////////////// -//~ rjf: Helpers - -internal REGS_RegCode regs_reg_code_from_name(Arch arch, String8 name); -internal REGS_AliasCode regs_alias_code_from_name(Arch arch, String8 name); -internal Rng1U64 regs_range_from_code(Arch arch, B32 is_alias, U64 reg_code); -internal U64 regs_block_size_from_arch(Arch arch); -internal U64 regs_reg_code_count_from_arch(Arch arch); -internal U64 regs_alias_code_count_from_arch(Arch arch); -internal String8 *regs_reg_code_string_table_from_arch(Arch arch); -internal String8 *regs_alias_code_string_table_from_arch(Arch arch); -internal REGS_Rng *regs_reg_code_rng_table_from_arch(Arch arch); -internal REGS_Slice *regs_alias_code_slice_table_from_arch(Arch arch); -internal REGS_UsageKind *regs_reg_code_usage_kind_table_from_arch(Arch arch); -internal REGS_UsageKind *regs_alias_code_usage_kind_table_from_arch(Arch arch); -internal U64 regs_rip_from_arch_block(Arch arch, void *block); -internal U64 regs_rsp_from_arch_block(Arch arch, void *block); -internal void regs_arch_block_write_rip(Arch arch, void *block, U64 rip); -internal void regs_arch_block_write_rsp(Arch arch, void *block, U64 rsp); - -#endif // REGS_H diff --git a/src/regs/regs.mdesk b/src/regs/regs.mdesk deleted file mode 100644 index 765781f7..00000000 --- a/src/regs/regs.mdesk +++ /dev/null @@ -1,395 +0,0 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//////////////////////////////// -//~ rjf: Architecture Tables - -@table(name, name_lower) -REGS_ArchTable: -{ - {X64 x64} -} - -//////////////////////////////// -//~ rjf: X64 Tables - -@table(name size usage) -REGS_RegTableX64: -{ - {rax 64 Normal} - {rcx 64 Normal} - {rdx 64 Normal} - {rbx 64 Normal} - {rsp 64 Normal} - {rbp 64 Normal} - {rsi 64 Normal} - {rdi 64 Normal} - {r8 64 Normal} - {r9 64 Normal} - {r10 64 Normal} - {r11 64 Normal} - {r12 64 Normal} - {r13 64 Normal} - {r14 64 Normal} - {r15 64 Normal} - {fsbase 64 Normal} - {gsbase 64 Normal} - {rip 64 Normal} - {rflags 64 Normal} - {dr0 64 Normal} - {dr1 64 Normal} - {dr2 64 Normal} - {dr3 64 Normal} - {dr4 64 Normal} - {dr5 64 Normal} - {dr6 64 Normal} - {dr7 64 Normal} - {st0 80 Normal} - {st1 80 Normal} - {st2 80 Normal} - {st3 80 Normal} - {st4 80 Normal} - {st5 80 Normal} - {st6 80 Normal} - {st7 80 Normal} - {fcw 16 Normal} - {fsw 16 Normal} - {ftw 8 Normal} - {fop 16 Normal} - {fip 64 Normal} - {fdp 64 Normal} - {mxcsr 32 Normal} - {mxcsr_mask 32 Normal} - {ss 16 Normal} - {cs 16 Normal} - {ds 16 Normal} - {es 16 Normal} - {fs 16 Normal} - {gs 16 Normal} - {zmm0 512 Vector} - {zmm1 512 Vector} - {zmm2 512 Vector} - {zmm3 512 Vector} - {zmm4 512 Vector} - {zmm5 512 Vector} - {zmm6 512 Vector} - {zmm7 512 Vector} - {zmm8 512 Vector} - {zmm9 512 Vector} - {zmm10 512 Vector} - {zmm11 512 Vector} - {zmm12 512 Vector} - {zmm13 512 Vector} - {zmm14 512 Vector} - {zmm15 512 Vector} - {zmm16 512 Vector} - {zmm17 512 Vector} - {zmm18 512 Vector} - {zmm19 512 Vector} - {zmm20 512 Vector} - {zmm21 512 Vector} - {zmm22 512 Vector} - {zmm23 512 Vector} - {zmm24 512 Vector} - {zmm25 512 Vector} - {zmm26 512 Vector} - {zmm27 512 Vector} - {zmm28 512 Vector} - {zmm29 512 Vector} - {zmm30 512 Vector} - {zmm31 512 Vector} - {k0 64 Normal} - {k1 64 Normal} - {k2 64 Normal} - {k3 64 Normal} - {k4 64 Normal} - {k5 64 Normal} - {k6 64 Normal} - {k7 64 Normal} - {cetmsr 64 Normal} - {cetssp 64 Normal} -} - -@table(name base off size usage) -REGS_AliasTableX64: -{ - {eax rax 0 32 Normal} - {ecx rcx 0 32 Normal} - {edx rdx 0 32 Normal} - {ebx rbx 0 32 Normal} - {esp rsp 0 32 Normal} - {ebp rbp 0 32 Normal} - {esi rsi 0 32 Normal} - {edi rdi 0 32 Normal} - {r8d r8 0 32 Normal} - {r9d r9 0 32 Normal} - {r10d r10 0 32 Normal} - {r11d r11 0 32 Normal} - {r12d r12 0 32 Normal} - {r13d r13 0 32 Normal} - {r14d r14 0 32 Normal} - {r15d r15 0 32 Normal} - {eflags rflags 0 32 Normal} - {ax rax 0 16 Normal} - {cx rcx 0 16 Normal} - {dx rdx 0 16 Normal} - {bx rbx 0 16 Normal} - {si rsi 0 16 Normal} - {di rdi 0 16 Normal} - {sp rsp 0 16 Normal} - {bp rbp 0 16 Normal} - {ip rip 0 16 Normal} - {r8w r8 0 16 Normal} - {r9w r9 0 16 Normal} - {r10w r10 0 16 Normal} - {r11w r11 0 16 Normal} - {r12w r12 0 16 Normal} - {r13w r13 0 16 Normal} - {r14w r14 0 16 Normal} - {r15w r15 0 16 Normal} - {al rax 0 8 Normal} - {cl rcx 0 8 Normal} - {dl rdx 0 8 Normal} - {bl rbx 0 8 Normal} - {sil rsi 0 8 Normal} - {dil rdi 0 8 Normal} - {bpl rbp 0 8 Normal} - {spl rsp 0 8 Normal} - {r8b r8 0 8 Normal} - {r9b r9 0 8 Normal} - {r10b r10 0 8 Normal} - {r11b r11 0 8 Normal} - {r12b r12 0 8 Normal} - {r13b r13 0 8 Normal} - {r14b r14 0 8 Normal} - {r15b r15 0 8 Normal} - {ah rax 8 8 Normal} - {ch rcx 8 8 Normal} - {dh rdx 8 8 Normal} - {bh rbx 8 8 Normal} - {xmm0 zmm0 0 128 Vector} - {xmm1 zmm1 0 128 Vector} - {xmm2 zmm2 0 128 Vector} - {xmm3 zmm3 0 128 Vector} - {xmm4 zmm4 0 128 Vector} - {xmm5 zmm5 0 128 Vector} - {xmm6 zmm6 0 128 Vector} - {xmm7 zmm7 0 128 Vector} - {xmm8 zmm8 0 128 Vector} - {xmm9 zmm9 0 128 Vector} - {xmm10 zmm10 0 128 Vector} - {xmm11 zmm11 0 128 Vector} - {xmm12 zmm12 0 128 Vector} - {xmm13 zmm13 0 128 Vector} - {xmm14 zmm14 0 128 Vector} - {xmm15 zmm15 0 128 Vector} - {ymm0 zmm0 0 256 Vector} - {ymm1 zmm1 0 256 Vector} - {ymm2 zmm2 0 256 Vector} - {ymm3 zmm3 0 256 Vector} - {ymm4 zmm4 0 256 Vector} - {ymm5 zmm5 0 256 Vector} - {ymm6 zmm6 0 256 Vector} - {ymm7 zmm7 0 256 Vector} - {ymm8 zmm8 0 256 Vector} - {ymm9 zmm9 0 256 Vector} - {ymm10 zmm10 0 256 Vector} - {ymm11 zmm11 0 256 Vector} - {ymm12 zmm12 0 256 Vector} - {ymm13 zmm13 0 256 Vector} - {ymm14 zmm14 0 256 Vector} - {ymm15 zmm15 0 256 Vector} - {mm0 st0 0 64 Vector} - {mm1 st1 0 64 Vector} - {mm2 st2 0 64 Vector} - {mm3 st3 0 64 Vector} - {mm4 st4 0 64 Vector} - {mm5 st5 0 64 Vector} - {mm6 st6 0 64 Vector} - {mm7 st7 0 64 Vector} -} - -@enum REGS_RegCodeX64: -{ - NULL, - @expand(REGS_RegTableX64 a) `$(a.name)`, - COUNT, -} - -@enum REGS_AliasCodeX64: -{ - NULL, - @expand(REGS_AliasTableX64 a) `$(a.name)`, - COUNT, -} - -@struct REGS_RegBlockX64: -{ - @expand(REGS_RegTableX64 a) `REGS_Reg$(a.size) $(a.name)`, -} - -@data(REGS_UsageKind) regs_g_reg_code_x64_usage_kind_table: -{ - `REGS_UsageKind_Normal`; - @expand(REGS_RegTableX64 a) `REGS_UsageKind_$(a.usage)`; -} - -@data(REGS_UsageKind) -regs_g_alias_code_x64_usage_kind_table: -{ - `REGS_UsageKind_Normal`; - @expand(REGS_AliasTableX64 a) `REGS_UsageKind_$(a.usage)`; -} - -@data(String8) regs_g_reg_code_x64_string_table: -{ - `str8_lit_comp("")`; - @expand(REGS_RegTableX64 a) `str8_lit_comp("$(a.name)")`; -} - -@data(String8) regs_g_alias_code_x64_string_table: -{ - `str8_lit_comp("")`; - @expand(REGS_AliasTableX64 a) `str8_lit_comp("$(a.name)")`; -} - -@data(REGS_Rng) regs_g_reg_code_x64_rng_table: -{ - `{0}`; - @expand(REGS_RegTableX64 a) `{(U16)OffsetOf(REGS_RegBlockX64, $(a.name)), $(a.size/8)}`, -} - -@data(REGS_Slice) regs_g_alias_code_x64_slice_table: -{ - `{0}`; - @expand(REGS_AliasTableX64 a) `{REGS_RegCodeX64_$(a.base), $(a.off/8), $(a.size/8)}`, -} - -//////////////////////////////// -//~ rjf: Architecture-Dynamic Helper Implementation Generators - -@c_file @gen -{ - `internal U64 regs_block_size_from_arch(Arch arch)`; - `{`; - `U64 result = 8;`; - `switch(arch)`; - `{`; - `default:{}break;`; - @expand(REGS_ArchTable a) `case Arch_$(a.name_lower):{result = sizeof(REGS_RegBlock$(a.name));}break;`; - `}`; - `return result;`; - `}`; -} - -@c_file @gen -{ - `internal U64 regs_reg_code_count_from_arch(Arch arch)`; - `{`; - `U64 result = 0;`; - `switch(arch)`; - `{`; - `default:{}break;`; - @expand(REGS_ArchTable a) `case Arch_$(a.name_lower):{result = REGS_RegCode$(a.name)_COUNT;}break;`; - `}`; - `return result;`; - `}`; -} - -@c_file @gen -{ - `internal U64 regs_alias_code_count_from_arch(Arch arch)`; - `{`; - `U64 result = 0;`; - `switch(arch)`; - `{`; - `default:{}break;`; - @expand(REGS_ArchTable a) `case Arch_$(a.name_lower):{result = REGS_AliasCode$(a.name)_COUNT;}break;`; - `}`; - `return result;`; - `}`; -} - -@c_file @gen -{ - `internal String8 *regs_reg_code_string_table_from_arch(Arch arch)`; - `{`; - `String8 *result = 0;`; - `switch(arch)`; - `{`; - `default:{}break;`; - @expand(REGS_ArchTable a) `case Arch_$(a.name_lower):{result = regs_g_reg_code_$(a.name_lower)_string_table;}break;`; - `}`; - `return result;`; - `}`; -} - -@c_file @gen -{ - `internal String8 *regs_alias_code_string_table_from_arch(Arch arch)`; - `{`; - `String8 *result = 0;`; - `switch(arch)`; - `{`; - `default:{}break;`; - @expand(REGS_ArchTable a) `case Arch_$(a.name_lower):{result = regs_g_alias_code_$(a.name_lower)_string_table;}break;`; - `}`; - `return result;`; - `}`; -} - -@c_file @gen -{ - `internal REGS_Rng *regs_reg_code_rng_table_from_arch(Arch arch)`; - `{`; - `REGS_Rng *result = 0;`; - `switch(arch)`; - `{`; - `default:{}break;`; - @expand(REGS_ArchTable a) `case Arch_$(a.name_lower):{result = regs_g_reg_code_$(a.name_lower)_rng_table;}break;`; - `}`; - `return result;`; - `}`; -} - -@c_file @gen -{ - `internal REGS_Slice *regs_alias_code_slice_table_from_arch(Arch arch)`; - `{`; - `REGS_Slice *result = 0;`; - `switch(arch)`; - `{`; - `default:{}break;`; - @expand(REGS_ArchTable a) `case Arch_$(a.name_lower):{result = regs_g_alias_code_$(a.name_lower)_slice_table;}break;`; - `}`; - `return result;`; - `}`; -} - -@c_file @gen -{ - `internal REGS_UsageKind *regs_reg_code_usage_kind_table_from_arch(Arch arch)`; - `{`; - `REGS_UsageKind *result = 0;`; - `switch(arch)`; - `{`; - `default:{}break;`; - @expand(REGS_ArchTable a) `case Arch_$(a.name_lower):{result = regs_g_reg_code_$(a.name_lower)_usage_kind_table;}break;`; - `}`; - `return result;`; - `}`; -} - -@c_file @gen -{ - `internal REGS_UsageKind *regs_alias_code_usage_kind_table_from_arch(Arch arch)`; - `{`; - `REGS_UsageKind *result = 0;`; - `switch(arch)`; - `{`; - `default:{}break;`; - @expand(REGS_ArchTable a) `case Arch_$(a.name_lower):{result = regs_g_alias_code_$(a.name_lower)_usage_kind_table;}break;`; - `}`; - `return result;`; - `}`; -} diff --git a/src/render/d3d11/render_d3d11.c b/src/render/d3d11/render_d3d11.c index 6cf22683..9d80584e 100644 --- a/src/render/d3d11/render_d3d11.c +++ b/src/render/d3d11/render_d3d11.c @@ -199,7 +199,7 @@ r_init(CmdLine *cmdln) char buffer[256] = {0}; raddbg_snprintf(buffer, sizeof(buffer), "D3D11 device creation failure (%lx). The process is terminating.", error); os_graphical_message(1, str8_lit("Fatal Error"), str8_cstring(buffer)); - os_abort(1); + abort_self(1); } ProfEnd(); @@ -483,7 +483,7 @@ r_init(CmdLine *cmdln) //- rjf: window setup/teardown r_hook R_Handle -r_window_equip(OS_Handle handle) +r_window_equip(OS_Window handle) { ProfBeginFunction(); R_Handle result = {0}; @@ -535,7 +535,7 @@ r_window_equip(OS_Handle handle) char buffer[256] = {0}; raddbg_snprintf(buffer, sizeof(buffer), "DXGI swap chain creation failure (%lx). The process is terminating.", error); os_graphical_message(1, str8_lit("Fatal Error"), str8_cstring(buffer)); - os_abort(1); + abort_self(1); } r_d3d11_state->dxgi_factory->lpVtbl->MakeWindowAssociation(r_d3d11_state->dxgi_factory, hwnd, DXGI_MWA_NO_ALT_ENTER); @@ -556,7 +556,7 @@ r_window_equip(OS_Handle handle) } r_hook void -r_window_unequip(OS_Handle handle, R_Handle equip_handle) +r_window_unequip(OS_Window handle, R_Handle equip_handle) { ProfBeginFunction(); MutexScopeW(r_d3d11_state->device_rw_mutex) @@ -605,13 +605,10 @@ r_tex2d_alloc(R_ResourceKind kind, Vec2S32 size, R_Tex2DFormat format, void *dat texture->generation += 1; } + //- rjf: resource kind -> d3d11 usage / cpu access flags D3D11_USAGE d3d11_usage = D3D11_USAGE_DEFAULT; UINT cpu_access_flags = 0; r_usage_access_flags_from_resource_kind(kind, &d3d11_usage, &cpu_access_flags); - if (kind == R_ResourceKind_Static) - { - Assert(data != 0 && "static texture must have initial data provided"); - } //- rjf: format -> dxgi format DXGI_FORMAT dxgi_format = DXGI_FORMAT_R8G8B8A8_UNORM; @@ -714,9 +711,8 @@ r_fill_tex2d_region(R_Handle handle, Rng2S32 subrect, void *data) MutexScopeW(r_d3d11_state->device_rw_mutex) { R_D3D11_Tex2D *texture = r_d3d11_tex2d_from_handle(handle); - if(texture != &r_d3d11_tex2d_nil) + if(texture != &r_d3d11_tex2d_nil && texture->kind == R_ResourceKind_Dynamic) { - Assert(texture->kind == R_ResourceKind_Dynamic && "only dynamic texture can update region"); U64 bytes_per_pixel = r_tex2d_format_bytes_per_pixel_table[texture->format]; Vec2S32 dim = v2s32(subrect.x1 - subrect.x0, subrect.y1 - subrect.y0); D3D11_BOX dst_box = @@ -756,13 +752,10 @@ r_buffer_alloc(R_ResourceKind kind, U64 size, void *data) buffer->generation += 1; } + //- rjf: resource kind -> d3d11 usage / cpu access flags D3D11_USAGE d3d11_usage = D3D11_USAGE_DEFAULT; UINT cpu_access_flags = 0; r_usage_access_flags_from_resource_kind(kind, &d3d11_usage, &cpu_access_flags); - if (kind == R_ResourceKind_Static) - { - Assert(data != 0 && "static buffer must have initial data provided"); - } //- rjf: prep initial data, if passed D3D11_SUBRESOURCE_DATA initial_data_ = {0}; @@ -868,7 +861,7 @@ r_end_frame(void) } r_hook void -r_window_begin_frame(OS_Handle window, R_Handle window_equip) +r_window_begin_frame(OS_Window window, R_Handle window_equip) { ProfBeginFunction(); MutexScopeW(r_d3d11_state->device_rw_mutex) @@ -1000,7 +993,7 @@ r_window_begin_frame(OS_Handle window, R_Handle window_equip) } r_hook void -r_window_end_frame(OS_Handle window, R_Handle window_equip) +r_window_end_frame(OS_Window window, R_Handle window_equip) { ProfBeginFunction(); MutexScopeW(r_d3d11_state->device_rw_mutex) @@ -1060,7 +1053,7 @@ r_window_end_frame(OS_Handle window, R_Handle window_equip) char buffer[256] = {0}; raddbg_snprintf(buffer, sizeof(buffer), "D3D11 present failure (%lx). The process is terminating.", error); os_graphical_message(1, str8_lit("Fatal Error"), str8_cstring(buffer)); - os_abort(1); + abort_self(1); } d_ctx->lpVtbl->ClearState(d_ctx); } @@ -1070,7 +1063,7 @@ r_window_end_frame(OS_Handle window, R_Handle window_equip) //- rjf: render pass submission r_hook void -r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes) +r_window_submit(OS_Window window, R_Handle window_equip, R_PassList *passes) { ProfBeginFunction(); MutexScopeW(r_d3d11_state->device_rw_mutex) diff --git a/src/render/opengl/linux/egl/render_opengl_linux_egl.c b/src/render/opengl/linux/egl/render_opengl_linux_egl.c index 28505f19..0e8a6f1d 100644 --- a/src/render/opengl/linux/egl/render_opengl_linux_egl.c +++ b/src/render/opengl/linux/egl/render_opengl_linux_egl.c @@ -24,7 +24,7 @@ r_ogl_os_init(CmdLine *cmdln) if(r_ogl_lnx_state->display == EGL_NO_DISPLAY) { os_graphical_message(1, str8_lit("Fatal Error"), str8_lit("Failed to get EGL display.")); - os_abort(1); + abort_self(1); } } @@ -34,14 +34,14 @@ r_ogl_os_init(CmdLine *cmdln) if(!eglInitialize(r_ogl_lnx_state->display, &egl_version_major, &egl_version_minor)) { os_graphical_message(1, str8_lit("Fatal Error"), str8_lit("Couldn't initialize EGL display.")); - os_abort(1); + abort_self(1); } if(egl_version_major < 1 || (egl_version_major == 1 && egl_version_minor < 5)) { Temp scratch = scratch_begin(0, 0); String8 message = push_str8f(scratch.arena, "Unsupported EGL version (%i.%i, need at least 1.5)", egl_version_major, egl_version_minor); os_graphical_message(1, str8_lit("Fatal Error"), message); - os_abort(1); + abort_self(1); scratch_end(scratch); } @@ -49,7 +49,7 @@ r_ogl_os_init(CmdLine *cmdln) if(!eglBindAPI(EGL_OPENGL_API)) { os_graphical_message(1, str8_lit("Fatal Error"), str8_lit("Couldn't initialize EGL API to OpenGL.")); - os_abort(1); + abort_self(1); } //- rjf: construct context @@ -70,7 +70,7 @@ r_ogl_os_init(CmdLine *cmdln) if(r_ogl_lnx_state->context == EGL_NO_CONTEXT) { os_graphical_message(1, str8_lit("Fatal Error"), str8_lit("Couldn't create OpenGL context with EGL.")); - os_abort(1); + abort_self(1); } } @@ -121,7 +121,7 @@ r_ogl_os_window_equip(OS_Handle window) if(!eglChooseConfig(r_ogl_lnx_state->display, options, configs, ArrayCount(configs), &configs_count) || configs_count == 0) { os_graphical_message(1, str8_lit("Fatal Error"), str8_lit("Couldn't choose EGL configuration.")); - os_abort(1); + abort_self(1); } } @@ -144,7 +144,7 @@ r_ogl_os_window_equip(OS_Handle window) if(r_ogl_lnx_state->config == 0) { os_graphical_message(1, str8_lit("Fatal Error"), str8_lit("Couldn't find a suitable EGL configuration.")); - os_abort(1); + abort_self(1); } } } @@ -155,7 +155,7 @@ r_ogl_os_window_equip(OS_Handle window) if(w->surface == EGL_NO_SURFACE) { os_graphical_message(1, str8_lit("Fatal Error"), str8_lit("Couldn't create EGL surface.")); - os_abort(1); + abort_self(1); } } R_Handle result = {(U64)w}; diff --git a/src/render/opengl/linux/glx/render_opengl_linux_glx.c b/src/render/opengl/linux/glx/render_opengl_linux_glx.c index fa7217da..6f835515 100644 --- a/src/render/opengl/linux/glx/render_opengl_linux_glx.c +++ b/src/render/opengl/linux/glx/render_opengl_linux_glx.c @@ -21,7 +21,7 @@ r_ogl_os_init(CmdLine *cmdln) Temp scratch = scratch_begin(0, 0); String8 message = push_str8f(scratch.arena, "Unsupported GLX version (%i.%i, need at least 1.3)", glx_version_major, glx_version_minor); os_graphical_message(1, str8_lit("Fatal Error"), message); - os_abort(1); + abort_self(1); scratch_end(scratch); } @@ -46,7 +46,7 @@ r_ogl_os_init(CmdLine *cmdln) if(framebuffer_configs == 0) { os_graphical_message(1, str8_lit("Fatal Error"), str8_lit("Could not find a suitable framebuffer configuration.")); - os_abort(1); + abort_self(1); } GLXFBConfig framebuffer_config = framebuffer_configs[0]; XFree(framebuffer_configs); diff --git a/src/render/render_core.h b/src/render/render_core.h index 039cfa99..6aa8decb 100644 --- a/src/render/render_core.h +++ b/src/render/render_core.h @@ -281,8 +281,8 @@ internal R_Pass *r_pass_from_kind(Arena *arena, R_PassList *list, R_PassKind kin r_hook void r_init(CmdLine *cmdln); //- rjf: window setup/teardown -r_hook R_Handle r_window_equip(OS_Handle window); -r_hook void r_window_unequip(OS_Handle window, R_Handle window_equip); +r_hook R_Handle r_window_equip(OS_Window window); +r_hook void r_window_unequip(OS_Window window, R_Handle window_equip); //- rjf: textures r_hook R_Handle r_tex2d_alloc(R_ResourceKind kind, Vec2S32 size, R_Tex2DFormat format, void *data); @@ -299,10 +299,10 @@ r_hook void r_buffer_release(R_Handle buffer); //- rjf: frame markers r_hook void r_begin_frame(void); r_hook void r_end_frame(void); -r_hook void r_window_begin_frame(OS_Handle window, R_Handle window_equip); -r_hook void r_window_end_frame(OS_Handle window, R_Handle window_equip); +r_hook void r_window_begin_frame(OS_Window window, R_Handle window_equip); +r_hook void r_window_end_frame(OS_Window window, R_Handle window_equip); //- rjf: render pass submission -r_hook void r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes); +r_hook void r_window_submit(OS_Window window, R_Handle window_equip, R_PassList *passes); #endif // RENDER_CORE_H diff --git a/src/scratch/eval_scratch.c b/src/scratch/eval_scratch.c deleted file mode 100644 index a9cb9a32..00000000 --- a/src/scratch/eval_scratch.c +++ /dev/null @@ -1,51 +0,0 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -//////////////////////////////// -//~ rjf: Includes - -//- rjf: [h] -#include "base/base_inc.h" -#include "os/os_inc.h" -#include "rdi_format/rdi_format_local.h" -#include "regs/regs.h" -#include "regs/rdi/regs_rdi.h" -#include "eval/eval_inc.h" - -//- rjf: [c] -#include "base/base_inc.c" -#include "os/os_inc.c" -#include "rdi_format/rdi_format_local.c" -#include "regs/regs.c" -#include "regs/rdi/regs_rdi.c" -#include "eval/eval_inc.c" - -//////////////////////////////// -//~ rjf: Entry Point - -internal void -entry_point(CmdLine *cmdline) -{ - Arena *arena = arena_alloc(); - E_TypeCtx *type_ctx = push_array(arena, E_TypeCtx, 1); - e_select_type_ctx(type_ctx); - E_ParseCtx *parse_ctx = push_array(arena, E_ParseCtx, 1); - e_select_parse_ctx(parse_ctx); - E_IRCtx *ir_ctx = push_array(arena, E_IRCtx, 1); - e_select_ir_ctx(ir_ctx); - E_InterpretCtx *interpret_ctx = push_array(arena, E_InterpretCtx, 1); - e_select_interpret_ctx(interpret_ctx, 0, 0); - String8 exprs[] = - { - str8_lit("123"), - str8_lit("1 + 2"), - str8_lit("foo"), - str8_lit("foo(bar)"), - str8_lit("foo(bar(baz))"), - }; - for EachElement(idx, exprs) - { - String8 debug_string = e_debug_log_from_expr_string(arena, exprs[idx]); - raddbg_log("%S", debug_string); - } -} diff --git a/src/stap/stap_parse.c b/src/stap/stap_parse.c index 8bb048de..25e696af 100644 --- a/src/stap/stap_parse.c +++ b/src/stap/stap_parse.c @@ -73,24 +73,24 @@ stap_parse_args_x64(String8 string, STAP_Arg *arg_out) U64 sep_pos = str8_find_needle(string, 0, str8_lit("@"), 0); if (sep_pos < string.size) { STAP_Arg arg = {0}; - + String8 tag = str8_prefix(string, sep_pos + 1); String8 oper = str8_skip(string, tag.size); - + STAP_ArgValueType arg_value_type = STAP_ArgValueType_Null; U64 arg_value_size = 0; B32 infer_arg_value_size = 1; U64 tag_size = 0; { U8 *ptr = tag.str, *end = tag.str + tag.size; - + // is signed? if (ptr >= end) { goto operand_parse_exit; } if (*ptr == '-') { arg_value_type = STAP_ArgValueType_S; ptr += 1; } - + // parse optional size if (ptr >= end) { goto operand_parse_exit; } if (char_is_digit(*ptr, 10)) { @@ -102,7 +102,7 @@ stap_parse_args_x64(String8 string, STAP_Arg *arg_out) ptr += 1; infer_arg_value_size = 0; } - + // is this float? if (ptr >= end) { goto operand_parse_exit; } if (*ptr == 'f') { @@ -113,22 +113,22 @@ stap_parse_args_x64(String8 string, STAP_Arg *arg_out) ptr += 1; arg_value_type = STAP_ArgValueType_F; } - + // assume default value type to be unsigned if (arg_value_type == STAP_ArgValueType_Null) { arg_value_type = STAP_ArgValueType_U; } - + if (ptr >= end) { goto operand_parse_exit; } if (*ptr != '@') { error = str8_lit("failed to find @"); goto operand_parse_exit; } ptr += 1; - + tag_size = (U64)(ptr - tag.str); } - + U64 memory_ref_start = str8_find_needle_reverse(oper, 0, str8_lit("("), 0); // memory operand if (memory_ref_start > 0 && memory_ref_start < oper.size) { @@ -141,7 +141,7 @@ stap_parse_args_x64(String8 string, STAP_Arg *arg_out) // Scale: 1|2|4|8 // Expr: A small C-like infix expression // - + // find closing ')' U64 memory_ref_end = str8_find_needle(oper, memory_ref_start+1, str8_lit(")"), 0); if (memory_ref_end > oper.size) { @@ -152,7 +152,7 @@ stap_parse_args_x64(String8 string, STAP_Arg *arg_out) error = str8_lit("expression does not terminate after ')'"); goto operand_parse_exit; } - + // parse displacement String8 disp_str = str8_skip_chop_whitespace(str8_prefix(oper, memory_ref_start-1)); if (disp_str.size > 0 && !str8_is_integer_signed(disp_str, 10)) { @@ -160,7 +160,7 @@ stap_parse_args_x64(String8 string, STAP_Arg *arg_out) goto operand_parse_exit; } S64 disp = s64_from_str8(disp_str, 10); - + // parse base, index, scale String8 base_index_scale = str8_skip_chop_whitespace(str8_substr(oper, r1u64(memory_ref_start, memory_ref_end))); U64 first_comma = str8_find_needle(base_index_scale, 0, str8_lit(","), 0); @@ -168,7 +168,7 @@ stap_parse_args_x64(String8 string, STAP_Arg *arg_out) String8 base_str = str8_skip_chop_whitespace(str8_substr(base_index_scale, r1u64(0, first_comma))); String8 index_str = str8_skip_chop_whitespace(str8_substr(base_index_scale, r1u64(first_comma + 1, second_comma))); String8 scale_str = str8_skip_chop_whitespace(str8_substr(base_index_scale, r1u64(second_comma + 1, memory_ref_end))); - + // syntax check if(first_comma >= base_index_scale.size && base_str.size == 0) { error = str8_lit("missing base register"); @@ -194,11 +194,11 @@ stap_parse_args_x64(String8 string, STAP_Arg *arg_out) error = str8_lit("invalid of scale (expected unsigned integral type)"); goto operand_parse_exit; } - + // stip '%' prefix base_str = str8_skip(base_str, 1); index_str = str8_skip(index_str, 1); - + // parse base B8 base_is_alias = 0; U32 base_reg_code = 0; @@ -213,7 +213,7 @@ stap_parse_args_x64(String8 string, STAP_Arg *arg_out) goto operand_parse_exit; } } - + // parse index B8 index_is_alias = 0; U32 index_reg_code = 0; @@ -237,12 +237,12 @@ stap_parse_args_x64(String8 string, STAP_Arg *arg_out) goto operand_parse_exit; } } - + if (infer_arg_value_size) { error = str8_lit("memory operands must have a sice"); goto operand_parse_exit; } - + // fill out memory ref portion arg.type = STAP_ArgType_MemoryRef; arg.memory_ref.disp = disp; @@ -255,36 +255,36 @@ stap_parse_args_x64(String8 string, STAP_Arg *arg_out) // $imm else if (str8_match(str8_lit("$"), oper, StringMatchFlag_RightSideSloppy)) { String8 imm_str = str8_skip(oper, 1); - + U64 imm_size = str8_find_needle(imm_str, 0, str8_lit(" "), 0); if (imm_size > imm_str.size ) { imm_size = imm_str.size; } imm_str = str8_prefix(imm_str, imm_size); - + if (imm_str.size == 0) { goto operand_parse_exit; } - + U64 imm = 0; B32 is_parsed = 0; switch (arg_value_type) { - case STAP_ArgValueType_Null: - case STAP_ArgValueType_U: - case STAP_ArgValueType_F: { - is_parsed = try_u64_from_str8_c_rules(imm_str, &imm); - } break; - case STAP_ArgValueType_S: { - is_parsed = try_s64_from_str8_c_rules(imm_str, (S64 *)&imm); - } break; - default: { InvalidPath; } break; + case STAP_ArgValueType_Null: + case STAP_ArgValueType_U: + case STAP_ArgValueType_F: { + is_parsed = try_u64_from_str8_c_rules(imm_str, &imm); + } break; + case STAP_ArgValueType_S: { + is_parsed = try_s64_from_str8_c_rules(imm_str, (S64 *)&imm); + } break; + default: { InvalidPath; } break; } - + if (!is_parsed) { error = str8_lit("failed to parse immediate"); goto operand_parse_exit; } - + arg.type = STAP_ArgType_Imm; arg.imm = imm; } @@ -295,7 +295,7 @@ stap_parse_args_x64(String8 string, STAP_Arg *arg_out) if (reg_str.size == 0) { goto operand_parse_exit; } - + B8 is_reg_alias = 0; U32 reg_code = regs_reg_code_from_name(Arch_x64, reg_str); if (reg_code == 0) { @@ -306,31 +306,31 @@ stap_parse_args_x64(String8 string, STAP_Arg *arg_out) error = str8_lit("invalid register name"); goto operand_parse_exit; } - + arg.type = STAP_ArgType_Reg; arg.reg.is_alias = is_reg_alias; arg.reg.reg_code = reg_code; } else { goto operand_parse_exit; } - + // fill out value portion arg.value_type = arg_value_type == STAP_ArgValueType_Null ? STAP_ArgValueType_U : arg_value_type; arg.value_size = arg_value_size; - + // write output if (arg_out) { *arg_out = arg; } - + // clear error tracker error = str8_zero(); - -operand_parse_exit:; + + operand_parse_exit:; } else { error = str8_lit("invalid argument string"); } - + return error; } @@ -343,16 +343,16 @@ stap_arg_array_from_string(Arena *arena, Arch arch, String8 string) result.v = push_array(arena, STAP_Arg, arg_strings.node_count); for EachNode(n, String8Node, arg_strings.first) { STAP_Arg *arg = &result.v[result.count++]; - + switch (arch) { - case Arch_Null: {} break; - case Arch_x64: { - stap_parse_args_x64(n->string, arg); - } break; - case Arch_x86: - case Arch_arm32: - case Arch_arm64: { NotImplemented; } break; - default: { InvalidPath; } break; + case Arch_Null: {} break; + case Arch_x64: { + stap_parse_args_x64(n->string, arg); + } break; + case Arch_x86: + case Arch_arm32: + case Arch_arm64: { NotImplemented; } break; + default: { InvalidPath; } break; } } scratch_end(scratch); @@ -368,53 +368,52 @@ stap_read_arg(STAP_Arg arg, void *raw_value) { AssertAlways(arg.value_size <= 8); - + ARCH_Info *arch_info = arch_info_from_arch(arch); B32 is_value_read = 0; - - switch (arg.type) { - case STAP_ArgType_Null: break; - case STAP_ArgType_Imm: { - MemoryCopy(raw_value, &arg.imm, arg.value_size); - is_value_read = 1; - } break; - case STAP_ArgType_Reg: { - Rng1U64 range = regs_range_from_code(arch, arg.reg.is_alias, arg.reg.reg_code); - U64 copy_size = Min(arg.value_size, dim_1u64(range)); - MemoryCopy(raw_value, (U8 *)reg_block + range.min, copy_size); - is_value_read = 1; - } break; - case STAP_ArgType_MemoryRef: { - U64 base = 0; - if(arg.memory_ref.base.reg_code) { - Rng1U64 range = regs_range_from_code(arch, arg.memory_ref.base.is_alias, arg.memory_ref.base.reg_code); - U64 copy_size = Min(sizeof(base), dim_1u64(range)); - MemoryCopy(&base, (U8 *)reg_block + range.min, copy_size); - } - - U64 index = 0; - if(arg.memory_ref.index.reg_code) { - Rng1U64 range = regs_range_from_code(arch, arg.memory_ref.index.is_alias, arg.memory_ref.index.reg_code); - U64 copy_size = Min(sizeof(base), dim_1u64(range)); - MemoryCopy(&index, (U8 *)reg_block + range.min, copy_size); - } - - U64 addr = arg.memory_ref.disp + (base + index * arg.memory_ref.scale); - if (memory_read(addr, raw_value, arg.value_size, memory_read_ctx)) { + switch(arg.type) + { + default:{}break; + case STAP_ArgType_Null:{}break; + case STAP_ArgType_Imm: + { + MemoryCopy(raw_value, &arg.imm, arg.value_size); is_value_read = 1; - } - } break; - default: { InvalidPath; } break; + }break; + case STAP_ArgType_Reg: + if(0 < arg.reg.reg_code && arg.reg.reg_code < arch_info->reg_code_count) + { + is_value_read = arch_reg_block_read_range(arch_info, reg_block, arch_info->reg_code_rng_table[arg.reg.reg_code], raw_value); + }break; + case STAP_ArgType_MemoryRef: + { + U64 base = 0; + if(0 < arg.memory_ref.base.reg_code && arg.memory_ref.base.reg_code < arch_info->reg_code_count) + { + arch_reg_block_read_range(arch_info, reg_block, arch_info->reg_code_rng_table[arg.memory_ref.base.reg_code], &base); + } + U64 index = 0; + if(0 < arg.memory_ref.index.reg_code && arg.memory_ref.index.reg_code < arch_info->reg_code_count) + { + arch_reg_block_read_range(arch_info, reg_block, arch_info->reg_code_rng_table[arg.memory_ref.index.reg_code], &index); + } + U64 addr = arg.memory_ref.disp + (base + index * arg.memory_ref.scale); + if(memory_read(addr, raw_value, arg.value_size, memory_read_ctx)) + { + is_value_read = 1; + } + }break; } - - if (arg.value_size < 8) { - if (arg.value_type == STAP_ArgValueType_S) { + if(arg.value_size < 8) + { + if(arg.value_type == STAP_ArgValueType_S) + { *(U64 *)raw_value = extend_sign64(*(U64 *)raw_value, arg.value_size); - } else if (arg.value_type == STAP_ArgValueType_F) { - Assert(arg.value_size == 4); + } + else if(arg.value_type == STAP_ArgValueType_F && arg.value_size == 4) + { *(F64 *)raw_value = *(F32 *)raw_value; } } - return is_value_read; } diff --git a/src/stap/stap_test.c b/src/stap/stap_test.c index 70c31539..7996ae44 100644 --- a/src/stap/stap_test.c +++ b/src/stap/stap_test.c @@ -6,12 +6,12 @@ #include "base/base_inc.h" #include "os/os_inc.h" -#include "regs/regs.h" +#include "arch/arch_inc.h" #include "stap/stap_parse.h" #include "base/base_inc.c" #include "os/os_inc.c" -#include "regs/regs.c" +#include "arch/arch_inc.c" #include "stap/stap_parse.c" internal void @@ -21,7 +21,7 @@ entry_point(CmdLine *cmd_line) STAP_Arg arg = {0}; String8 error = {0}; String8 string = {0}; - + string = str8_lit("-2@$-123"); error = stap_parse_args_x64(string, &arg); if (error.size != 0) { goto exit; } @@ -29,7 +29,7 @@ entry_point(CmdLine *cmd_line) AssertAlways(arg.value_size == 2); AssertAlways(arg.type == STAP_ArgType_Imm); AssertAlways((S64)arg.imm == -123); - + string = str8_lit("1@$43"); error = stap_parse_args_x64(string, &arg); if (error.size != 0) { goto exit; } @@ -37,7 +37,7 @@ entry_point(CmdLine *cmd_line) AssertAlways(arg.value_size == 1); AssertAlways(arg.type == STAP_ArgType_Imm); AssertAlways((S64)arg.imm == 43); - + string = str8_lit("4f@%eax"); error = stap_parse_args_x64(string, &arg); if (error.size != 0) { goto exit; } @@ -46,7 +46,7 @@ entry_point(CmdLine *cmd_line) AssertAlways(arg.type == STAP_ArgType_Reg); AssertAlways(arg.reg.is_alias == 1); AssertAlways(arg.reg.reg_code == REGS_AliasCodeX64_eax); - + string = str8_lit("4@(%rdi)"); error = stap_parse_args_x64(string, &arg); if (error.size != 0) { goto exit; } @@ -59,7 +59,7 @@ entry_point(CmdLine *cmd_line) AssertAlways(arg.memory_ref.index.reg_code == 0); AssertAlways(arg.memory_ref.index.is_alias == 0); AssertAlways(arg.memory_ref.scale == 1); - + string = str8_lit("4@-22(%rdi)"); error = stap_parse_args_x64(string, &arg); if (error.size != 0) { goto exit; } @@ -72,7 +72,7 @@ entry_point(CmdLine *cmd_line) AssertAlways(arg.memory_ref.index.reg_code == 0); AssertAlways(arg.memory_ref.index.is_alias == 0); AssertAlways(arg.memory_ref.scale == 1); - + string = str8_lit("4@32(%rax,%rsi,8)"); error = stap_parse_args_x64(string, &arg); if (error.size != 0) { goto exit; } @@ -84,7 +84,7 @@ entry_point(CmdLine *cmd_line) AssertAlways(arg.memory_ref.index.reg_code == REGS_RegCodeX64_rsi); AssertAlways(arg.memory_ref.index.is_alias == 0); AssertAlways(arg.memory_ref.scale == 8); - + string = str8_lit("4@32(,%rsi,8)"); error = stap_parse_args_x64(string, &arg); if (error.size != 0) { goto exit; } @@ -94,21 +94,21 @@ entry_point(CmdLine *cmd_line) AssertAlways(arg.memory_ref.base.reg_code == 0); AssertAlways(arg.memory_ref.index.reg_code == REGS_RegCodeX64_rsi); AssertAlways(arg.memory_ref.scale == 8); - + error = stap_parse_args_x64(str8_lit("4@(,,)"), &arg); if (error.size == 0) { goto exit; } - + error = stap_parse_args_x64(str8_lit("4@()"), &arg); if (error.size == 0) { goto exit; } - + error = stap_parse_args_x64(str8_lit("4@(%rdi, %rsi, 8"), &arg); if (error.size == 0) { goto exit; } - + error = stap_parse_args_x64(str8_lit("4@( ,, 8"), &arg); if (error.size == 0) { goto exit; } - + passed = 1; -exit:; + exit:; AssertAlways(passed); } diff --git a/src/strip_lib_debug/strip_lib_debug.c b/src/strip_lib_debug/strip_lib_debug.c index 23c15b1c..6bb5f1e5 100644 --- a/src/strip_lib_debug/strip_lib_debug.c +++ b/src/strip_lib_debug/strip_lib_debug.c @@ -24,60 +24,60 @@ internal void sld_main(CmdLine *cmdl) { B32 do_help = cmd_line_has_flag(cmdl, str8_lit("help")) || - cmd_line_has_flag(cmdl, str8_lit("h")) || - cmd_line_has_flag(cmdl, str8_lit("?")) || - cmdl->argc == 1; + cmd_line_has_flag(cmdl, str8_lit("h")) || + cmd_line_has_flag(cmdl, str8_lit("?")) || + cmdl->argc == 1; if (do_help) { fprintf(stderr, "--- Help ---------------------------------------------------------------------\n"); fprintf(stderr, " %s\n\n", BUILD_TITLE_STRING_LITERAL); fprintf(stderr, " Usage: strip_lib_debug [Options]\n\n"); fprintf(stderr, " Options:\n"); fprintf(stderr, " -in: Path to input lib file\n"); fprintf(stderr, " -out: Path to output lib file\n"); - os_abort(0); + abort_self(0); } - + Temp scratch = scratch_begin(0,0); - + String8 in_lib_path = cmd_line_string(cmdl, str8_lit("in")); String8 out_lib_path = cmd_line_string(cmdl, str8_lit("out")); - + if (in_lib_path.size == 0) { fprintf(stderr, "ERROR: please provide an input path via -in:\n"); - os_abort(1); + abort_self(1); } if (out_lib_path.size == 0) { fprintf(stderr, "ERROR: please provide an output path via -out:\n"); - os_abort(1); + abort_self(1); } - + String8 in_lib = os_data_from_file_path(scratch.arena, in_lib_path); if (in_lib.size == 0) { fprintf(stderr, "ERROR: unable to read file %.*s\n", str8_varg(in_lib_path)); - os_abort(1); + abort_self(1); } - + if (!coff_is_regular_archive(in_lib)) { fprintf(stderr, "ERROR: input lib is not COFF archive\n"); - os_abort(1); + abort_self(1); } - + // read & parse lib String8 out_lib = push_str8_copy(scratch.arena, in_lib); COFF_ArchiveParse parse = coff_archive_parse_from_data(out_lib); - + // was parse successful? if (parse.error.size) { fprintf(stderr, "ERROR: %.*s: %.*s\n", str8_varg(in_lib_path), str8_varg(parse.error)); - os_abort(1); + abort_self(1); } - + // convert big endian offsets U32 member_offsets_count = parse.first_member.symbol_count; U32 *member_offsets = push_array(scratch.arena, U32, parse.first_member.member_offset_count); for (U32 offset_idx = 0; offset_idx < member_offsets_count; offset_idx += 1) { member_offsets[offset_idx] = from_be_u32(parse.first_member.member_offsets[offset_idx]); } - + // fixup sections for (U64 member_idx = 0; member_idx < member_offsets_count; member_idx += 1) { COFF_ParsedArchiveMemberHeader member_header = {0}; @@ -98,13 +98,13 @@ sld_main(CmdLine *cmdl) } } } - + // wirte modified library - if (!os_write_data_to_file_path(out_lib_path, out_lib)) { + if (!write_data_to_file_path(out_lib_path, out_lib)) { fprintf(stderr, "ERROR: unable to write output file to %.*s\n", str8_varg(out_lib_path)); - os_abort(1); + abort_self(1); } - + scratch_end(scratch); } diff --git a/src/torture/torture.c b/src/torture/torture.c index 572de849..f2c285e1 100644 --- a/src/torture/torture.c +++ b/src/torture/torture.c @@ -28,9 +28,9 @@ internal char * t_string_from_result(T_RunStatus v) { switch (v) { - case T_RunStatus_Fail: return "FAIL"; - case T_RunStatus_Crash: return "CRASH"; - case T_RunStatus_Pass: return "PASS"; + case T_RunStatus_Fail: return "FAIL"; + case T_RunStatus_Crash: return "CRASH"; + case T_RunStatus_Pass: return "PASS"; } return 0; } @@ -40,7 +40,7 @@ t_write_file_list(String8 name, String8List data) { Temp scratch = scratch_begin(0,0); String8 path = t_make_file_path(scratch.arena, name); - B32 is_written = os_write_data_list_to_file_path(path, data); + B32 is_written = write_data_list_to_file_path(path, data); scratch_end(scratch); return is_written; } @@ -50,10 +50,10 @@ t_write_file(String8 name, String8 data) { String8Node temp_node = {0}; temp_node.string = data; - + String8List temp_list = {0}; str8_list_push_node(&temp_list, &temp_node); - + return t_write_file_list(name, temp_list); } @@ -62,7 +62,7 @@ t_read_file(Arena *arena, String8 name) { Temp scratch = scratch_begin(&arena,1); String8 path = t_make_file_path(scratch.arena, name); - String8 data = os_data_from_file_path(arena, path); + String8 data = data_from_file_path(arena, path); scratch_end(scratch); return data; } @@ -72,7 +72,7 @@ t_delete_file(String8 name) { Temp scratch = scratch_begin(0,0); String8 path = t_make_file_path(scratch.arena, name); - B32 is_deleted = os_delete_file_at_path(path); + B32 is_deleted = delete_file_at_path(path); scratch_end(scratch); return is_deleted; } @@ -81,26 +81,26 @@ internal void t_delete_dir(String8 path) { Temp scratch = scratch_begin(0,0); - - OS_FileIter *file_iter = os_file_iter_begin(scratch.arena, path, 0); + + FileIter *file_iter = file_iter_begin(scratch.arena, path, 0); for (;;) { - OS_FileInfo info = {0}; - if ( ! os_file_iter_next(scratch.arena, file_iter, &info)) { break; } - + FileInfo info = {0}; + if ( ! file_iter_next(scratch.arena, file_iter, &info)) { break; } + if (info.props.flags & FilePropertyFlag_IsFolder) { t_delete_dir(str8f(scratch.arena, "%S/%S", path, info.name)); continue; } - + String8 file_path = str8f(scratch.arena, "%S/%S", path, info.name); - if ( ! os_delete_file_at_path(file_path)) { + if ( ! delete_file_at_path(file_path)) { fprintf(stderr, "ERROR: unable to delete file %.*s\n", str8_varg(file_path)); } } - os_file_iter_end(file_iter); - + file_iter_end(file_iter); + // TODO: delete directories - + scratch_end(scratch); } @@ -114,7 +114,7 @@ internal B32 t_make_dir(String8 name) { Temp scratch = scratch_begin(0,0); - B32 is_ok = os_make_directory(t_make_file_path(scratch.arena, name)); + B32 is_ok = make_directory(t_make_file_path(scratch.arena, name)); scratch_end(scratch); return is_ok; } @@ -148,7 +148,7 @@ internal T_RunResult t_run(T_Run run) { T_RunCtx ctx = { .run = run }; - + B32 do_safe_call = 1; #if OS_WINDOWS if (IsDebuggerPresent()) { @@ -156,7 +156,7 @@ t_run(T_Run run) } #endif if (do_safe_call) { - os_safe_call(t_run_caller, t_run_fail_handler, &ctx); + safe_call(t_run_caller, t_run_fail_handler, &ctx); } else { t_run_caller(&ctx); } @@ -172,9 +172,9 @@ t_radbin_path(void) ArenaParams params = { .reserve_size = sizeof(buffer), .commit_size = sizeof(buffer), .optional_backing_buffer = buffer }; Arena *arena = arena_alloc_(¶ms); #if OS_WINDOWS - path = os_full_path_from_path(arena, str8_lit("radbin.exe")); + path = full_path_from_path(arena, str8_lit("radbin.exe")); #else - path = os_full_path_from_path(arena, str8_lit("radbin")); + path = full_path_from_path(arena, str8_lit("radbin")); #endif AssertAlways(path.size); } @@ -205,33 +205,33 @@ internal String8 t_cl_version(void) { local_persist String8 version; - + if ( ! version.size) { Temp scratch = scratch_begin(0, 0); - + String8 output = {0}; t_invoke_(t_cl_path(), str8_zero(), max_U64, scratch.arena, &output); AssertAlways(g_last_exit_code == 0); - + String8 needle = str8_lit("Version"); U64 version_lo = str8_find_needle(output, 0, needle, 0); version_lo += needle.size + 1; AssertAlways(version_lo < output.size); - + U64 version_hi = str8_find_needle(output, version_lo, str8_lit(" "), 0); AssertAlways(version_hi < output.size); - + version = str8_substr(output, r1u64(version_lo, version_hi)); AssertAlways(version.size > 0); - + local_persist U8 buffer[4096]; ArenaParams params = { .reserve_size = sizeof(buffer), .commit_size = sizeof(buffer), .optional_backing_buffer = buffer }; Arena *arena = arena_alloc_(¶ms); version = str8_copy(arena, version); - + scratch_end(scratch); } - + return version; } @@ -244,9 +244,9 @@ t_radlink_path(void) ArenaParams params = { .reserve_size = sizeof(buffer), .commit_size = sizeof(buffer), .optional_backing_buffer = buffer }; Arena *arena = arena_alloc_(¶ms); #if OS_WINDOWS - path = os_full_path_from_path(arena, str8_lit("radlink.exe")); + path = full_path_from_path(arena, str8_lit("radlink.exe")); #else - path = os_full_path_from_path(arena, str8_lit("radlink")); + path = full_path_from_path(arena, str8_lit("radlink")); #endif AssertAlways(path.size); } @@ -259,7 +259,7 @@ t_cwd_path(void) local_persist U8 path[4096] = {0}; if (path[0] == 0) { Temp scratch = scratch_begin(0, 0); - String8 cwd = os_get_current_path(scratch.arena); + String8 cwd = get_current_path(scratch.arena); cwd = str8_chop_last_slash(cwd); cwd = str8f(scratch.arena, "%S", cwd); MemoryCopyStr8(path, cwd); @@ -287,26 +287,26 @@ internal B32 t_invoke_env(String8 exe_path, String8 cmdline, String8List env, U64 timeout, Arena *output_arena, String8 *output_out) { Temp scratch = scratch_begin(&output_arena,1); - + B32 is_ok = 0; - + B32 capture_output = output_out || g_redirect_stdout; - + g_last_exit_code = -1; - - OS_Handle read_pipe_handle = {0}, write_pipe_handle = {0}; + + File read_pipe_handle = {0}, write_pipe_handle = {0}; if (capture_output) { HANDLE read_pipe, write_pipe; SECURITY_ATTRIBUTES at = { .nLength = sizeof(at), .bInheritHandle = 1 }; if (!CreatePipe(&read_pipe, &write_pipe, &at, 0)) { AssertAlways(0 && "failed to create a pipe"); } - read_pipe_handle = (OS_Handle){ .u64[0] = (U64)read_pipe }; - write_pipe_handle = (OS_Handle){ .u64[0] = (U64)write_pipe }; + read_pipe_handle = (File){ .u64[0] = (U64)read_pipe }; + write_pipe_handle = (File){ .u64[0] = (U64)write_pipe }; } - + // Build Launch Options - OS_ProcessLaunchParams launch_opts = { + ProcessLaunchParams launch_opts = { .path = g_wdir, .inherit_env = 1, .env = env, @@ -315,49 +315,49 @@ t_invoke_env(String8 exe_path, String8 cmdline, String8List env, U64 timeout, Ar .cmd_line = lnk_arg_list_parse_windows_rules(scratch.arena, cmdline), }; str8_list_push_front(scratch.arena, &launch_opts.cmd_line, exe_path); - + if (g_verbose) { String8 full_cmd_line = str8_list_join(scratch.arena, &launch_opts.cmd_line, &(StringJoin){ .sep = str8_lit(" ") }); fprintf(stdout, "Command Line: %.*s\n", str8_varg(full_cmd_line)); fprintf(stdout, "Working Dir: %.*s\n", str8_varg(g_wdir)); } - + // invoke exe - OS_Handle process_handle = os_process_launch(&launch_opts); - + Process process_handle = process_launch(&launch_opts); + // close handle so last to ReadFile does not block - os_file_close(write_pipe_handle); - - if ( ! os_handle_match(process_handle, os_handle_zero())) { + file_close(write_pipe_handle); + + if ( ! process_match(process_handle, process_zero())) { if (capture_output) { // capture process output String8List output = {0}; for (;;) { - String8 string = os_file_read_cstring(scratch.arena, read_pipe_handle, 0); + String8 string = file_read_cstring(scratch.arena, read_pipe_handle, 0); if (string.size == 0) { break; } str8_list_push(scratch.arena, &output, string); } - os_file_close(read_pipe_handle); - + file_close(read_pipe_handle); + if (output_out) { *output_out = str8_list_join(output_arena, &output, 0); } - + // write to the output file if (g_redirect_stdout) { - os_write_data_list_to_file_path(g_stdout_file_name, output); + write_data_list_to_file_path(g_stdout_file_name, output); } } - + U64 exit_code_u64 = 0; - if (os_process_join(process_handle, timeout, &exit_code_u64)) { + if (process_join(process_handle, timeout, &exit_code_u64)) { g_last_exit_code = (int)exit_code_u64; is_ok = 1; } else { - os_process_kill(process_handle); + process_kill(process_handle); } } - + scratch_end(scratch); return is_ok; } @@ -428,24 +428,24 @@ t_file_paths_from_dir(Arena *arena, String8 dir) Temp scratch = scratch_begin(&arena, 1); String8List dirs = {0}; String8List files = {0}; - - OS_FileIter *iter = os_file_iter_begin(scratch.arena, dir, 0); - OS_FileInfo file; - while (os_file_iter_next(scratch.arena, iter, &file)) { + + FileIter *iter = file_iter_begin(scratch.arena, dir, 0); + FileInfo file; + while (file_iter_next(scratch.arena, iter, &file)) { if (file.props.flags & FilePropertyFlag_IsFolder) { str8_list_pushf(scratch.arena, &dirs, "%S/%S", dir, file.name); } else { str8_list_pushf(arena, &files, "%S/%S", dir, file.name); } } - os_file_iter_end(iter); - + file_iter_end(iter); + String8List result = {0}; for EachNode(n, String8Node, dirs.first) { String8List sub_result = t_file_paths_from_dir(arena, n->string); str8_list_concat_in_place(&result, &sub_result); } - + scratch_end(scratch); //str8_list_concat_in_place(&result, &dirs); str8_list_concat_in_place(&result, &files); @@ -463,12 +463,12 @@ t_match_folders(String8 a, String8 b) //for EachNode(n, String8Node, files_a.first) printf("%.*s\n", str8_varg(n->string)); String8List files_b = t_file_paths_from_dir(scratch.arena, b); B32 is_match = 0; - + String8Array sorted_a = str8_array_from_list(scratch.arena, &files_a); String8Array sorted_b = str8_array_from_list(scratch.arena, &files_b); t_sort_str8_array(sorted_a); t_sort_str8_array(sorted_b); - + if (sorted_a.count == sorted_b.count) { for EachIndex(i, sorted_a.count) { Temp temp = temp_begin(scratch.arena); @@ -477,15 +477,15 @@ t_match_folders(String8 a, String8 b) if (str8_match(ext_a, ext_b, 0)) { if (str8_match(ext_a, str8_lit("obj"), StringMatchFlag_CaseInsensitive) || str8_match(ext_a, str8_lit("lib"), StringMatchFlag_CaseInsensitive)) { - String8 data_a = os_data_from_file_path(temp.arena, sorted_a.v[i]); - String8 data_b = os_data_from_file_path(temp.arena, sorted_b.v[i]); + String8 data_a = data_from_file_path(temp.arena, sorted_a.v[i]); + String8 data_b = data_from_file_path(temp.arena, sorted_b.v[i]); is_match = str8_match(data_a, data_b, 0); if ( ! is_match) { - OS_Handle h; - h = os_cmd_line_launchf("dumpbin /all %S /out:a.txt", sorted_a.v[i]); - os_process_join(h, max_U64, 0); - h = os_cmd_line_launchf("dumpbin /all %S /out:b.txt", sorted_b.v[i]); - os_process_join(h, max_U64, 0); + Process h; + h = launch_cmd_linef("dumpbin /all %S /out:a.txt", sorted_a.v[i]); + process_join(h, max_U64, 0); + h = launch_cmd_linef("dumpbin /all %S /out:b.txt", sorted_b.v[i]); + process_join(h, max_U64, 0); } Assert(is_match); if (!is_match) { break; } @@ -495,7 +495,7 @@ t_match_folders(String8 a, String8 b) temp_end(temp); } } - + scratch_end(scratch); return is_match; } @@ -504,25 +504,25 @@ internal void t_entry_point(CmdLine *cmdline) { Temp scratch = scratch_begin(0,0); - + U64 dashes_size = 9999; U8 *dashes = push_array(scratch.arena, U8, dashes_size); MemorySet(dashes, '-', dashes_size); - + U64 dots_size = 9999; U8 *dots = push_array(scratch.arena, U8, dots_size); MemorySet(dots, '.', dots_size); - + char *spaces = " "; - + #define PrintHeader(p) fprintf(stderr, "--- %s %.*s\n", p, Max((80-4) - (int)strlen(p), 3), dashes) - + // // Handle -help // { B32 print_help = cmd_line_has_flag(cmdline, str8_lit("help")) || - cmd_line_has_flag(cmdline, str8_lit("h")); + cmd_line_has_flag(cmdline, str8_lit("h")); if (print_help) { PrintHeader("Help"); fprintf(stderr, " %s\n\n", BUILD_TITLE_STRING_LITERAL); @@ -536,10 +536,10 @@ t_entry_point(CmdLine *cmdline) fprintf(stderr, " -verbose Enable verbose mode\n"); fprintf(stderr, " -print_stdout Print to console stdout and stderr of a run\n"); fprintf(stderr, " -help Print help menu and exit\n"); - os_abort(0); + abort_self(0); } } - + #if 0 // // config @@ -564,7 +564,7 @@ t_entry_point(CmdLine *cmdline) fprintf(stderr, "\n"); } #endif - + // // Handle -list // @@ -574,10 +574,10 @@ t_entry_point(CmdLine *cmdline) for EachIndex(i, g_torture_test_count) { fprintf(stdout, " %s\n", g_torture_tests[i].label); } - os_abort(0); + abort_self(0); } } - + // // Handle -linker // @@ -591,14 +591,14 @@ t_entry_point(CmdLine *cmdline) g_linker = linker_opt->value_string; } else { fprintf(stderr, "ERROR: -linker has invalid number of arguments\n"); - os_abort(1); + abort_self(1); } } else { // assume default linker g_linker = str8_lit("radlink"); } } - + // // Handle -test_data // @@ -609,7 +609,7 @@ t_entry_point(CmdLine *cmdline) //fprintf(stderr, "WARNING: The test data folder path was not specified. Specify the path when running the program, assuming: %.*s --test_data:%.*s\n", str8_varg(cmdline->exe_name), str8_varg(g_test_data)); } } - + // // Handle optional -target // @@ -637,31 +637,31 @@ t_entry_point(CmdLine *cmdline) } } } - + if (ht->count == 0) { fprintf(stderr, "ERROR: -target matches not found for the following patterns: "); for EachNode(n, String8Node, target_opt->value_strings.first) { fprintf(stderr, "\"%.*s\"\n", str8_varg(n->string)); } - os_abort(1); + abort_self(1); } } else { fprintf(stderr, "ERROR: -target has invalid number of arguments\n"); } } } - + g_verbose = cmd_line_has_flag(cmdline, str8_lit("verbose")); g_redirect_stdout = !cmd_line_has_flag(cmdline, str8_lit("print_stdout")); g_stop_on_first_fail_or_crash = !cmd_line_has_flag(cmdline, str8_lit("keep_going")); - + // default options when running under debugger #if OS_WINDOWS if (!cmd_line_has_flag(cmdline, str8_lit("print_stdout")) && IsDebuggerPresent()) { g_redirect_stdout = 0; } #endif - + // Handle -out { CmdLineOpt *out_opt = cmd_line_opt_from_string(cmdline, str8_lit("out")); @@ -673,27 +673,27 @@ t_entry_point(CmdLine *cmdline) } } } - + // // Make Output Directory // - os_make_directory(g_out); - if (!os_folder_path_exists(g_out)) { + make_directory(g_out); + if (!folder_path_exists(g_out)) { fprintf(stderr, "ERROR: unable to create output directory \"%.*s\"\n", str8_varg(g_out)); - os_abort(1); + abort_self(1); } - + // // Clean up output from previous run // - os_delete_file_at_path(g_stdout_file_name); - + delete_file_at_path(g_stdout_file_name); + // // Run tests // { radsort(g_torture_tests, g_torture_test_count, t_test_is_before); - + U64List target_indices_list = {0}; if (target.node_count == 0) { for EachIndex(i, g_torture_test_count) { u64_list_push(scratch.arena, &target_indices_list, i); } @@ -712,7 +712,7 @@ t_entry_point(CmdLine *cmdline) } } } - + // // -skip // @@ -730,15 +730,15 @@ t_entry_point(CmdLine *cmdline) break; } } - + if (include_test) { u64_list_push(scratch.arena, &final_target_list, n->data); } } - + U64 skip_count = target_indices_list.count - final_target_list.count; U64Array target_indices = u64_array_from_list(scratch.arena, &final_target_list); - + U64 max_label_size = 0; U64 max_group_size = 0; for EachIndex(i, target_indices.count) { @@ -746,19 +746,19 @@ t_entry_point(CmdLine *cmdline) max_label_size = Max(max_label_size, cstring8_length((U8*)g_torture_tests[test_idx].label)); max_group_size = Max(max_group_size, cstring8_length((U8*)g_torture_tests[test_idx].group)); } - + PrintHeader("Tests"); U64 pass_count = 0; U64 fail_count = 0; U64 crash_count = 0; U64 max_digit_count = count_digits_u64(target_indices.count, 10); - U64 total_time_start = os_now_microseconds(); + U64 total_time_start = now_time_us(); typedef struct { U64 target_idx, d; } Slowest; Slowest slowest[5] = {0}; for EachElement(i, slowest) { slowest[i].target_idx = max_U64; } for EachIndex(i, target_indices.count) { U64 target_idx = target_indices.v[i]; - + // print run progress U64 dots_min = 10; U64 dots_count = (max_label_size - cstring8_length((U8*)g_torture_tests[target_idx].label)) + dots_min; @@ -767,27 +767,27 @@ t_entry_point(CmdLine *cmdline) fprintf(stdout, "[%.*s%I64u/%I64u] ", idx_align_space_count, spaces, i+1, target_indices.count); fprintf(stdout, "%s %.*s:: %s", g_torture_tests[target_idx].group, (int)(max_group_size - cstring8_length((U8*)g_torture_tests[target_idx].group)), spaces, g_torture_tests[target_idx].label); fprintf(stdout, " %.*s ", (int)dots_count, dots); - + // setup output directory g_wdir = push_str8f(scratch.arena, "%S\\%s", g_out, g_torture_tests[target_idx].label); - g_wdir = os_full_path_from_path(scratch.arena, g_wdir); - + g_wdir = full_path_from_path(scratch.arena, g_wdir); + // delete files from last run in the work directory - if (os_folder_path_exists(g_wdir)) { + if (folder_path_exists(g_wdir)) { t_delete_dir(g_wdir); } - os_make_directory(g_wdir); - - if (!os_folder_path_exists(g_out)) { + make_directory(g_wdir); + + if (!folder_path_exists(g_out)) { fprintf(stderr, "ERROR: unable to create output directory for test run %.*s\n", str8_varg(g_wdir)); continue; } - + // run test - U64 run_start_time = os_now_microseconds(); + U64 run_start_time = now_time_us(); T_RunResult result = t_run(g_torture_tests[target_idx].r); - U64 run_end_time = os_now_microseconds(); - + U64 run_end_time = now_time_us(); + // print result if (result.status == T_RunStatus_Pass) { fprintf(stdout, "\x1b[32m" "%s" "\x1b[0m", t_string_from_result(result.status)); @@ -799,13 +799,13 @@ t_entry_point(CmdLine *cmdline) fprintf(stdout, "\x1b[33m" "%s" "\x1b[0m", t_string_from_result(result.status)); crash_count += 1; } - + if (result.status == T_RunStatus_Pass) { U64 d = run_end_time - run_start_time; DateTime t = date_time_from_micro_seconds(d); String8 s = string_from_elapsed_time(scratch.arena, t); fprintf(stdout, " %.*s", str8_varg(s)); - + U64 insert_idx = max_U64; for EachElement(i, slowest) { if (d > slowest[i].d) { @@ -822,18 +822,18 @@ t_entry_point(CmdLine *cmdline) } } fprintf(stdout, "\n"); - + if (result.status == T_RunStatus_Fail) { fprintf(stdout, " ERROR: %s:%d: condition: \"%s\"\n", result.fail_file, result.fail_line, result.fail_cond); } - + if (result.status == T_RunStatus_Fail || result.status == T_RunStatus_Crash) { if (g_stop_on_first_fail_or_crash) { goto exit; } } } fprintf(stderr, "\n"); - U64 total_time_end = os_now_microseconds(); - + U64 total_time_end = now_time_us(); + PrintHeader("Summary"); U64 total_time_dt = total_time_end - total_time_start; String8 total_time_str = string_from_elapsed_time(scratch.arena, date_time_from_micro_seconds(total_time_dt)); @@ -843,7 +843,7 @@ t_entry_point(CmdLine *cmdline) fprintf(stderr, " Skipped %llu\n", skip_count); fprintf(stderr, " Time %.*s\n", str8_varg(total_time_str)); fprintf(stderr, "\n"); - + { fprintf(stderr, " Slow Tests\n"); U64 label_max = 0; @@ -854,7 +854,7 @@ t_entry_point(CmdLine *cmdline) label_max = Max(strlen(g_torture_tests[s.target_idx].label), label_max); group_max = Max(strlen(g_torture_tests[s.target_idx].group), group_max); } - + for EachElement(i, slowest) { Slowest s = slowest[i]; if (s.target_idx >= g_torture_test_count) { break; } @@ -866,17 +866,17 @@ t_entry_point(CmdLine *cmdline) (int)(label_max - strlen(g_torture_tests[s.target_idx].label)) + 4, dots, str8_varg(elapsed_time)); } - + fprintf(stderr, "\n"); } - + exit:; if (fail_count + crash_count != 0) { fflush(stdout); - os_abort(fail_count + crash_count); + abort_self(fail_count + crash_count); } } - + scratch_end(scratch); } diff --git a/src/torture/torture_d2r.c b/src/torture/torture_d2r.c index cf667d49..c4f5ace2 100644 --- a/src/torture/torture_d2r.c +++ b/src/torture/torture_d2r.c @@ -25,7 +25,7 @@ d2r_rdi_from_dwarf_writer(Arena *arena, DW_Writer *writer) String8 exe = t_read_file(scratch.arena, str8_lit("a.exe")); Assert(exe.size > 0); - B32 was_pdb_deleted = os_delete_file_at_path(t_make_file_path(scratch.arena, str8_lit("a.pdb"))); + B32 was_pdb_deleted = delete_file_at_path(t_make_file_path(scratch.arena, str8_lit("a.pdb"))); Assert(was_pdb_deleted); t_invoke_(t_radbin_path(), str8_lit("-rdi a.exe -out:a.rdi"), max_U64, 0, 0); @@ -489,14 +489,14 @@ TEST(d2r_general) T_Ok((test_local->symbol_flags & RDI_SymbolFlag_IsParam) == 0); String8 test_local_name = str8_from_rdi_string_idx(rdi, test_local->name_string_idx); T_Ok(str8_match(test_local_name, str8_lit("TestLocal"), 0)); - + RDI_TypeNode *test_local_type = rdi_element_from_name_idx(rdi, TypeNodes, test_local->type_idx); T_Ok(test_local_type); T_Ok(test_local_type->kind == RDI_TypeKind_Alias); T_Ok(test_local_type->flags == 0); String8 alias_name = str8_from_rdi_string_idx(rdi, test_local_type->user_defined.name_string_idx); T_Ok(str8_match(alias_name, str8_lit("char"), 0)); - + RDI_TypeNode *char_type = rdi_element_from_name_idx(rdi, TypeNodes, test_local_type->user_defined.direct_type_idx); T_Ok(char_type); T_Ok(char_type->kind == RDI_TypeKind_Char8); @@ -505,21 +505,21 @@ TEST(d2r_general) String8 char_type_name = str8_from_rdi_string_idx(rdi, char_type->built_in.name_string_idx); T_Ok(str8_match(char_type_name, str8_lit("Char8"), 0)); } - + { RDI_Symbol *test_local = rdi_element_from_name_idx(rdi, LocalVariables, root_scope->local_first + 1); T_Ok(test_local); T_Ok((test_local->symbol_flags & RDI_SymbolFlag_IsParam) != 0); String8 test_local_name = str8_from_rdi_string_idx(rdi, test_local->name_string_idx); T_Ok(str8_match(test_local_name, str8_lit("TestParam"), 0)); - + RDI_TypeNode *test_local_type = rdi_element_from_name_idx(rdi, TypeNodes, test_local->type_idx); T_Ok(test_local_type); T_Ok(test_local_type->kind == RDI_TypeKind_Alias); T_Ok(test_local_type->flags == 0); String8 alias_name = str8_from_rdi_string_idx(rdi, test_local_type->user_defined.name_string_idx); T_Ok(str8_match(alias_name, str8_lit("char"), 0)); - + RDI_TypeNode *char_type = rdi_element_from_name_idx(rdi, TypeNodes, test_local_type->user_defined.direct_type_idx); T_Ok(char_type); T_Ok(char_type->kind == RDI_TypeKind_Char8); diff --git a/src/torture/torture_dwarf.c b/src/torture/torture_dwarf.c index e9eebf2d..5d346368 100644 --- a/src/torture/torture_dwarf.c +++ b/src/torture/torture_dwarf.c @@ -121,7 +121,7 @@ dw_input_from_writer(Arena *arena, DW_Writer *writer) t_write_file(str8_lit("dwarf.obj"), raw_coff); t_invoke(str8_lit("radlink"), str8_lit("/subsystem:console /entry:entry /out:a.exe /debug:full dwarf.obj"), max_U64); - os_delete_file_at_path(t_make_file_path(scratch.arena, str8_lit("a.pdb"))); + delete_file_at_path(t_make_file_path(scratch.arena, str8_lit("a.pdb"))); String8 exe = t_read_file(arena, str8_lit("a.exe")); PE_BinInfo pe = pe_bin_info_from_data(scratch.arena, exe); @@ -862,9 +862,10 @@ TEST(dwarf_writer) TEST(value_in_register) { // setup register context - REGS_RegBlockX64 regs = {0}; - REGS_RegCode reg_code = reg_code_from_dw_reg(Arch_x64, DW_ExprOp_Reg3 - DW_ExprOp_Reg0); - Rng1U64 reg_range = regs_range_from_code(Arch_x64, 0, reg_code); + X64_RegBlock regs = {0}; + ARCH_Info *arch_info = arch_info_from_arch(Arch_x64); + ARCH_RegCode reg_code = arch_reg_code_from_dw(Arch_x64, DW_ExprOp_Reg3 - DW_ExprOp_Reg0); + Rng1U16 reg_range = arch_info->reg_code_rng_table[reg_code]; U64 value = 0xc0ffee; MemoryCopy((U8 *)®s + reg_range.min, &value, sizeof(value)); @@ -875,7 +876,7 @@ TEST(value_in_register) // evaluate the program DW_ExprValue expr_value; - DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, 0, 0, 0, max_U64, expr, regs_read_dwarf_x64, ®s, 0, 0, &expr_value); + DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, 0, 0, 0, max_U64, expr, ®s, 0, 0, &expr_value); // validate eval result T_Ok(expr_eval == DW_ExprEvalResult_Ok); @@ -886,9 +887,10 @@ TEST(value_in_register) TEST(value_in_x_register) { // setup register context - REGS_RegBlockX64 regs = {0}; - REGS_RegCode reg_code = reg_code_from_dw_reg(Arch_x64, DW_RegX64_FsBase); - Rng1U64 reg_range = regs_range_from_code(Arch_x64, 0, reg_code); + X64_RegBlock regs = {0}; + ARCH_Info *arch_info = arch_info_from_arch(Arch_x64); + ARCH_RegCode reg_code = arch_reg_code_from_dw(Arch_x64, DW_RegX64_FsBase); + Rng1U16 reg_range = arch_info->reg_code_rng_table[reg_code]; U64 value = 0xc0ffee; MemoryCopy((U8 *)®s + reg_range.min, &value, sizeof(value)); @@ -899,7 +901,7 @@ TEST(value_in_x_register) // evaluate the program DW_ExprValue expr_value; - DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, 0, 0, 0, max_U64, expr, regs_read_dwarf_x64, ®s, 0, 0, &expr_value); + DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, 0, 0, 0, max_U64, expr, ®s, 0, 0, &expr_value); // validate eval result T_Ok(expr_eval == DW_ExprEvalResult_Ok); @@ -917,7 +919,7 @@ TEST(address_of_value) // evaluate the program DW_ExprValue expr_value; - DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, 0, 0, 0, max_U64, expr, 0, 0, 0, 0, &expr_value); + DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, 0, 0, 0, max_U64, expr, 0, 0, 0, &expr_value); // validate eval result T_Ok(expr_eval == DW_ExprEvalResult_Ok); @@ -927,19 +929,22 @@ TEST(address_of_value) TEST(register_relative_variable) { + ARCH_Info *arch_info = arch_info_from_arch(Arch_x64); + // setup register context - REGS_RegBlockX64 regs = {0}; - REGS_RegCode reg_code = reg_code_from_dw_reg(Arch_x64, DW_ExprOp_BReg11 - DW_ExprOp_BReg0); - Rng1U64 reg_range = regs_range_from_code(Arch_x64, 0, reg_code); + X64_RegBlock regs = {0}; + DW_Reg reg_dw_id = (DW_ExprOp_BReg11 - DW_ExprOp_BReg0); + ARCH_RegCode reg_code = arch_reg_code_from_dw(Arch_x64, reg_dw_id); + Rng1U16 reg_rng = arch_info->reg_code_rng_table[reg_code]; U64 value = 1; - MemoryCopy((U8 *)®s + reg_range.min, &value, sizeof(value)); + MemoryCopy((U8 *)®s + reg_rng.min, &value, sizeof(value)); DW_ExprEnc expr_encs[] = { DW_ExprEnc_Op(BReg11), DW_ExprEnc_SLEB128(44) }; String8 expr_data = dw_encode_expr(arena, Arch_x64, DW_Format_64Bit, expr_encs, ArrayCount(expr_encs)); DW_Expr expr = dw_expr_from_data(arena, DW_Format_64Bit, byte_size_from_arch(Arch_x64), expr_data); DW_ExprValue expr_value; - DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, 0, 0, 0, max_U64, expr, regs_read_dwarf_x64, ®s, 0, 0, &expr_value); + DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, 0, 0, 0, max_U64, expr, ®s, 0, 0, &expr_value); // validate eval result T_Ok(expr_eval == DW_ExprEvalResult_Ok); @@ -955,7 +960,7 @@ TEST(frame_relative_variable) U64 frame_base = 123; DW_ExprValue expr_value; - DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, frame_base, 0, 0, max_U64, expr, 0, 0, 0, 0, &expr_value); + DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, frame_base, 0, 0, max_U64, expr, 0, 0, 0, &expr_value); T_Ok(expr_eval == DW_ExprEvalResult_Ok); T_Ok(expr_value.type == DW_ExprValueType_Addr); @@ -975,18 +980,19 @@ TEST(call_by_reference) U64 value = 0xc0ffee; MemoryCopy(memory + 32, &value, sizeof(value)); - REGS_RegBlockX64 regs = {0}; - REGS_RegCode reg_code = reg_code_from_dw_reg(Arch_x64, 58); // fsbase - Rng1U64 reg_range = regs_range_from_code(Arch_x64, 0, reg_code); + ARCH_Info *arch_info = arch_info_from_arch(Arch_x64); + X64_RegBlock regs = {0}; + ARCH_RegCode reg_code = arch_reg_code_from_dw(Arch_x64, 58); // fsbase + Rng1U16 reg_rng = arch_info->reg_code_rng_table[reg_code]; U64 memory_ptr = IntFromPtr(memory); - MemoryCopy((U8 *)®s + reg_range.min, &memory_ptr, sizeof(memory_ptr)); + MemoryCopy((U8 *)®s + reg_rng.min, &memory_ptr, sizeof(memory_ptr)); DW_ExprEnc expr_encs[] = { DW_ExprEnc_Op(BRegX), DW_ExprEnc_ULEB128(58), DW_ExprEnc_SLEB128(32), DW_ExprEnc_Op(Deref) }; String8 expr_data = dw_encode_expr(arena, Arch_x64, DW_Format_64Bit, expr_encs, ArrayCount(expr_encs)); DW_Expr expr = dw_expr_from_data(arena, DW_Format_64Bit, byte_size_from_arch(Arch_x64), expr_data); DW_ExprValue expr_value = { 0 }; - DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, 0, 0, 0, max_U64, expr, regs_read_dwarf_x64, ®s, t_machine_op_mem_read, 0, &expr_value); + DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, 0, 0, 0, max_U64, expr, ®s, t_machine_op_mem_read, 0, &expr_value); T_Ok(expr_value.type == DW_ExprValueType_Generic); T_Ok(expr_value.generic.size == sizeof(U64)); @@ -1001,7 +1007,7 @@ TEST(plus_uconst) DW_Expr expr = dw_expr_from_data(arena, DW_Format_64Bit, byte_size_from_arch(Arch_x64), expr_data); DW_ExprValue expr_value; - DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, 0, 0, 0, max_U64, expr, 0, 0, t_machine_op_mem_read, 0, &expr_value); + DW_ExprEvalResult expr_eval = dw_eval_expr(arena, Arch_x64, DW_Format_64Bit, 0, 0, 0, max_U64, expr, 0, t_machine_op_mem_read, 0, &expr_value); T_Ok(expr_value.type == DW_ExprValueType_Addr); T_Ok(expr_value.addr == 0x123 + 4); @@ -1011,7 +1017,7 @@ TEST(plus_uconst) TEST(reg_split_spill) { // setup register context - REGS_RegBlockX64 regs = {0}; + X64_RegBlock regs = {0}; { REGS_RegCode reg_code = reg_code_from_dw_reg(Arch_x64, DW_ExprOp_BReg3 - DW_ExprOp_BReg0); Rng1U64 reg_range = regs_range_from_code(Arch_x64, 0, reg_code); diff --git a/src/torture/torture_main.c b/src/torture/torture_main.c index bdc588c5..fe3e0819 100644 --- a/src/torture/torture_main.c +++ b/src/torture/torture_main.c @@ -62,9 +62,7 @@ #include "rdi_from_dwarf/rdi_from_dwarf_2.h" #include "obj/obj.h" #include "radbin/radbin.h" -#include "regs/regs.h" -#include "regs/rdi/regs_rdi.h" -#include "regs/dwarf/regs_dwarf.h" +#include "arch/arch_inc.h" #include "dbg_info/dbg_info.h" #include "disasm/disasm.h" #include "stap/stap_parse.h" @@ -137,9 +135,7 @@ #include "rdi_from_dwarf/rdi_from_dwarf_2.c" #include "obj/obj.c" #include "radbin/radbin.c" -#include "regs/regs.c" -#include "regs/rdi/regs_rdi.c" -#include "regs/dwarf/regs_dwarf.c" +#include "arch/arch_inc.c" #include "dbg_info/dbg_info.c" #include "disasm/disasm.c" #include "stap/stap_parse.c" diff --git a/src/torture/torture_p2r.c b/src/torture/torture_p2r.c index 17f76c5e..a7804059 100644 --- a/src/torture/torture_p2r.c +++ b/src/torture/torture_p2r.c @@ -16,42 +16,46 @@ TEST(p2r_determ) { // rjf: unpack paths, make output directory String8 pdb_path = path_normalized_from_string(arena, pdb_paths[pdb_idx]); - + // rjf: generate all RDIs String8List rdi_paths = {0}; String8List dump_paths = {0}; { - OS_HandleList processes = {0}; + ProcessList processes = {0}; for EachIndex(repeat_idx, num_repeats_per_pdb) { String8 rdi_name = push_str8f(arena, "repeat_%I64u.rdi", repeat_idx); String8 rdi_path = t_make_file_path(arena, rdi_name); str8_list_push(arena, &rdi_paths, rdi_path); String8 cmdl = str8f(arena, "radbin -rdi -deterministic %S -out:%S", pdb_path, rdi_path); - OS_Handle process_handle = os_cmd_line_launch(cmdl); - T_Ok(!os_handle_match(os_handle_zero(), process_handle)); - os_handle_list_push(arena, &processes, process_handle); + Process process = launch_cmd_line(cmdl); + T_Ok(!process_match(process_zero(), process)); + process_list_push(arena, &processes, process); + } + for EachNode(n, ProcessNode, processes.first) + { + process_join(n->v, max_U64, 0); } - - // wait on the converters - for EachNode(n, OS_HandleNode, processes.first) { os_process_join(n->v, max_U64, 0); } } - + // rjf: generate all dumps { - OS_HandleList processes = {0}; + ProcessList processes = {0}; for EachNode(n, String8Node, rdi_paths.first) { String8 rdi_path = n->string; - String8 dump_path = push_str8f(arena, "%S.dump", rdi_path); + String8 dump_path = str8f(arena, "%S.dump", rdi_path); str8_list_push(arena, &dump_paths, dump_path); - OS_Handle process_handle = os_cmd_line_launchf("radbin -dump -deterministic %S -out:%S", rdi_path, dump_path); - T_Ok(!os_handle_match(os_handle_zero(), process_handle)); - os_handle_list_push(arena, &processes, process_handle); + Process process_handle = launch_cmd_linef("radbin -dump -deterministic %S -out:%S", rdi_path, dump_path); + T_Ok(!process_match(process_zero(), process_handle)); + process_list_push(arena, &processes, process_handle); + } + for EachNode(n, ProcessNode, processes.first) + { + process_join(n->v, max_U64, 0); } - for EachNode(n, OS_HandleNode, processes.first) { os_process_join(n->v, max_U64, 0); } } - + // rjf: gather all hashes/paths U64 rdi_hashes_count = rdi_paths.node_count; U128 *rdi_hashes = push_array(arena, U128, rdi_hashes_count); @@ -65,11 +69,11 @@ TEST(p2r_determ) { Temp scratch = scratch_begin(0, 0); String8 rdi_path = n->string; - String8 path = rdi_path; + String8 path = rdi_path; T_Ok(path.size); - String8 data = os_data_from_file_path(scratch.arena, path); + String8 data = data_from_file_path(scratch.arena, path); T_Ok(data.size); - rdi_hashes [idx] = u128_hash_from_str8(data); + rdi_hashes[idx] = u128_hash_from_str8(data); rdi_paths_array[idx] = path; scratch_end(scratch); idx += 1; @@ -82,15 +86,15 @@ TEST(p2r_determ) Temp scratch = scratch_begin(0, 0); String8 path = n->string; T_Ok(path.size); - String8 data = os_data_from_file_path(scratch.arena, path); + String8 data = data_from_file_path(scratch.arena, path); T_Ok(data.size); - dump_hashes [idx] = u128_hash_from_str8(data); + dump_hashes[idx] = u128_hash_from_str8(data); dump_paths_array[idx] = path; scratch_end(scratch); idx += 1; } } - + // rjf: determine if all hashes match U64 mismatch_idx = max_U64; for EachIndex(idx, rdi_hashes_count) @@ -109,7 +113,7 @@ TEST(p2r_determ) break; } } - + // rjf: output bad case info if (mismatch_idx != max_U64) { U64 idx = mismatch_idx; diff --git a/src/torture/torture_radlink.c b/src/torture/torture_radlink.c index 9c3e38ec..b937fac5 100644 --- a/src/torture/torture_radlink.c +++ b/src/torture/torture_radlink.c @@ -1915,7 +1915,7 @@ TEST(weak_cycle) .symbols = (T_COFF_DefSymbol[]){ T_COFF_DefSymbol_Extern("my_entry", "text", 0), {0} } })); - U64 timeout = os_now_microseconds() + 3 * 1000 * 1000; // give a generous 3 seconds + U64 timeout = now_time_us() + 3 * 1000 * 1000; // give a generous 3 seconds t_invoke_linker_timeoutf(timeout, "/subsystem:console /entry:my_entry %S %S %S", entry_obj_name, ab_obj_name, ba_obj_name); } @@ -3979,18 +3979,18 @@ TEST(import_kernel32) #if OS_WINDOWS { String8 test_file_path = push_str8f(arena, "%S/test", g_wdir); - os_delete_file_at_path(test_file_path); + delete_file_at_path(test_file_path); - OS_ProcessLaunchParams launch_opts = {0}; + ProcessLaunchParams launch_opts = {0}; launch_opts.inherit_env = 0; launch_opts.path = g_wdir; str8_list_pushf(arena, &launch_opts.cmd_line, "%S/a.exe", g_wdir); - OS_Handle handle = os_process_launch(&launch_opts); - AssertAlways(!os_handle_match(handle, os_handle_zero())); + Process handle = process_launch(&launch_opts); + AssertAlways(!process_match(handle, process_zero())); U64 exit_code = max_U64; - os_process_join(handle, max_U64, &exit_code); + process_join(handle, max_U64, &exit_code); T_Ok(exit_code == 0); - T_Ok(os_file_path_exists(test_file_path)); + T_Ok(file_path_exists(test_file_path)); } #endif } @@ -6413,17 +6413,17 @@ TEST(determ_test) String8 main_pdb = t_read_file(arena, str8_lit("main.pdb")); // multi-threaded links - OS_HandleList linkers = {0}; + ProcessList linkers = {0}; for EachIndex(i, run_count) { String8 out_path = t_make_file_path(arena, str8f(arena, "%llu.exe", i)); String8 cmdl = str8f(arena, "%S %S /debug:full /rad_time_stamp:0 /rad_imagealtpath:main.exe /pdbaltpath:main.pdb /rad_log:-all /rad_ignore:74 /out:%S", t_radlink_path(), test_path, out_path); - OS_Handle process_handle = os_cmd_line_launch(cmdl); - T_Ok(!os_handle_match(os_handle_zero(), process_handle)); - os_handle_list_push(arena, &linkers, process_handle); + Process process_handle = launch_cmd_line(cmdl); + T_Ok(!process_match(process_zero(), process_handle)); + process_list_push(arena, &linkers, process_handle); } // wait for linkers - for EachNode(n, OS_HandleNode, linkers.first) { os_process_join(n->v, max_U64, 0); } + for EachNode(n, ProcessNode, linkers.first) { process_join(n->v, max_U64, 0); } for EachIndex(i, run_count) { Temp temp = temp_begin(arena); diff --git a/src/ui/ui_core.c b/src/ui/ui_core.c index 333d1b47..b181f976 100644 --- a/src/ui/ui_core.c +++ b/src/ui/ui_core.c @@ -471,7 +471,7 @@ ui_build_arena(void) return result; } -internal OS_Handle +internal OS_Window ui_window(void) { return ui_state->window; @@ -722,7 +722,7 @@ internal B32 ui_string_hover_active(void) { return (ui_state->build_index > 0 && ui_state->string_hover_build_index >= ui_state->build_index-1 && - os_now_microseconds() >= ui_state->string_hover_begin_us + 500000); + now_time_us() >= ui_state->string_hover_begin_us + 500000); } internal U64 @@ -796,7 +796,7 @@ ui_box_from_key(UI_Key key) //~ rjf: Top-Level Building API internal void -ui_begin_build(OS_Handle window, UI_EventList *events, UI_IconInfo *icon_info, UI_Theme *theme, UI_AnimationInfo *animation_info, F32 real_dt, F32 animation_dt) +ui_begin_build(OS_Window window, UI_EventList *events, UI_IconInfo *icon_info, UI_Theme *theme, UI_AnimationInfo *animation_info, F32 real_dt, F32 animation_dt) { //- rjf: reset per-build ui state { @@ -865,7 +865,7 @@ ui_begin_build(OS_Handle window, UI_EventList *events, UI_IconInfo *icon_info, U { if(n->v.kind == UI_EventKind_MouseMove) { - ui_state->last_time_mousemoved_us = os_now_microseconds(); + ui_state->last_time_mousemoved_us = now_time_us(); } } @@ -887,7 +887,7 @@ ui_begin_build(OS_Handle window, UI_EventList *events, UI_IconInfo *icon_info, U ui_state->theme = theme; ui_state->events = events; ui_state->window = window; - ui_state->mouse = (os_window_is_focused(window) || ui_state->last_time_mousemoved_us+500000 >= os_now_microseconds()) ? os_mouse_from_window(window) : v2f32(-100, -100); + ui_state->mouse = (os_window_is_focused(window) || ui_state->last_time_mousemoved_us+500000 >= now_time_us()) ? os_mouse_from_window(window) : v2f32(-100, -100); ui_state->animation_dt = animation_dt; MemoryZeroStruct(&ui_state->icon_info); ui_state->icon_info.icon_font = icon_info->icon_font; @@ -1643,7 +1643,7 @@ ui_end_build(void) ui_state->string_hover_string = push_str8_copy(ui_state->string_hover_arena, box_display_string); ui_state->string_hover_size = box->font_size; ui_state->string_hover_fstrs = dr_fstrs_copy(ui_state->string_hover_arena, &b->display_fstrs); - ui_state->string_hover_begin_us = os_now_microseconds(); + ui_state->string_hover_begin_us = now_time_us(); } ui_state->string_hover_build_index = ui_state->build_index; found = 1; diff --git a/src/ui/ui_core.h b/src/ui/ui_core.h index f5acb805..85fdbe53 100644 --- a/src/ui/ui_core.h +++ b/src/ui/ui_core.h @@ -705,7 +705,7 @@ struct UI_State UI_IconInfo icon_info; UI_Theme *theme; UI_AnimationInfo animation_info; - OS_Handle window; + OS_Window window; UI_EventList *events; Vec2F32 mouse; F32 animation_dt; @@ -826,7 +826,7 @@ internal UI_State *ui_get_selected_state(void); //- rjf: per-frame info internal Arena * ui_build_arena(void); -internal OS_Handle ui_window(void); +internal OS_Window ui_window(void); internal Vec2F32 ui_mouse(void); internal FNT_Tag ui_icon_font(void); internal String8 ui_icon_string_from_kind(UI_IconKind icon_kind); @@ -873,7 +873,7 @@ internal UI_Box * ui_box_from_key(UI_Key key); //////////////////////////////// //~ rjf: Top-Level Building API -internal void ui_begin_build(OS_Handle window, UI_EventList *events, UI_IconInfo *icon_info, UI_Theme *theme, UI_AnimationInfo *animation_info, F32 real_dt, F32 animation_dt); +internal void ui_begin_build(OS_Window window, UI_EventList *events, UI_IconInfo *icon_info, UI_Theme *theme, UI_AnimationInfo *animation_info, F32 real_dt, F32 animation_dt); internal void ui_end_build(void); internal void ui_calc_sizes_standalone__in_place(UI_Box *root, Axis2 axis); internal void ui_calc_sizes_upwards_dependent__in_place(UI_Box *root, Axis2 axis); diff --git a/src/win32/base/win32_base.c b/src/win32/base/win32_base.c new file mode 100644 index 00000000..9e98025f --- /dev/null +++ b/src/win32/base/win32_base.c @@ -0,0 +1,1919 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//////////////////////////////// +//~ rjf: Modern Windows SDK Functions +// +// (We must dynamically link to them, since they can be missing in older SDKs) + +typedef HRESULT W32_SetThreadDescription_Type(HANDLE hThread, PCWSTR lpThreadDescription); +global W32_SetThreadDescription_Type *w32_SetThreadDescription_func = 0; +global RIO_EXTENSION_FUNCTION_TABLE w32_rio_functions = {0}; + +//////////////////////////////// +//~ rjf: File Info Conversion Helpers + +internal FilePropertyFlags +os_w32_file_property_flags_from_dwFileAttributes(DWORD dwFileAttributes) +{ + FilePropertyFlags flags = 0; + if(dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + { + flags |= FilePropertyFlag_IsFolder; + } + return flags; +} + +internal void +os_w32_file_properties_from_attribute_data(FileProperties *properties, WIN32_FILE_ATTRIBUTE_DATA *attributes) +{ + properties->size = Compose64Bit(attributes->nFileSizeHigh, attributes->nFileSizeLow); + os_w32_dense_time_from_file_time(&properties->created, &attributes->ftCreationTime); + os_w32_dense_time_from_file_time(&properties->modified, &attributes->ftLastWriteTime); + properties->flags = os_w32_file_property_flags_from_dwFileAttributes(attributes->dwFileAttributes); +} + +//////////////////////////////// +//~ rjf: Time Conversion Helpers + +internal void +os_w32_date_time_from_system_time(DateTime *out, SYSTEMTIME *in) +{ + out->year = in->wYear; + out->mon = in->wMonth - 1; + out->wday = in->wDayOfWeek; + out->day = in->wDay; + out->hour = in->wHour; + out->min = in->wMinute; + out->sec = in->wSecond; + out->msec = in->wMilliseconds; +} + +internal void +os_w32_system_time_from_date_time(SYSTEMTIME *out, DateTime *in) +{ + out->wYear = (WORD)(in->year); + out->wMonth = in->mon + 1; + out->wDay = in->day; + out->wHour = in->hour; + out->wMinute = in->min; + out->wSecond = in->sec; + out->wMilliseconds = in->msec; +} + +internal void +os_w32_dense_time_from_file_time(DenseTime *out, FILETIME *in) +{ + SYSTEMTIME systime = {0}; + FileTimeToSystemTime(in, &systime); + DateTime date_time = {0}; + os_w32_date_time_from_system_time(&date_time, &systime); + *out = dense_time_from_date_time(date_time); +} + +internal U32 +os_w32_sleep_ms_from_endt_us(U64 endt_us) +{ + U32 sleep_ms = 0; + if(endt_us == max_U64) + { + sleep_ms = INFINITE; + } + else + { + U64 begint = now_time_us(); + if(begint < endt_us) + { + U64 sleep_us = endt_us - begint; + sleep_ms = (U32)((sleep_us + 999)/1000); + } + } + return sleep_ms; +} + +internal U32 +os_w32_unix_time_from_file_time(FILETIME file_time) +{ + U64 win32_time = ((U64)file_time.dwHighDateTime << 32) | file_time.dwLowDateTime; + U64 unix_time64 = ((win32_time - 0x19DB1DED53E8000ULL) / 10000000); + + Assert(unix_time64 <= max_U32); + U32 unix_time32 = (U32)unix_time64; + + return unix_time32; +} + +//////////////////////////////// +//~ rjf: Entity Functions + +internal OS_W32_Entity * +os_w32_entity_alloc(OS_W32_EntityKind kind) +{ + OS_W32_Entity *result = 0; + EnterCriticalSection(&os_w32_state.entity_mutex); + { + result = os_w32_state.entity_free; + if(result) + { + SLLStackPop(os_w32_state.entity_free); + } + else + { + result = push_array_no_zero(os_w32_state.entity_arena, OS_W32_Entity, 1); + } + MemoryZeroStruct(result); + } + LeaveCriticalSection(&os_w32_state.entity_mutex); + result->kind = kind; + return result; +} + +internal void +os_w32_entity_release(OS_W32_Entity *entity) +{ + entity->kind = OS_W32_EntityKind_Null; + EnterCriticalSection(&os_w32_state.entity_mutex); + SLLStackPush(os_w32_state.entity_free, entity); + LeaveCriticalSection(&os_w32_state.entity_mutex); +} + +//////////////////////////////// +//~ rjf: Thread Entry Point + +internal DWORD +os_w32_thread_entry_point(void *ptr) +{ + OS_W32_Entity *entity = (OS_W32_Entity *)ptr; + ThreadEntryPointFunctionType *func = entity->thread.func; + void *thread_ptr = entity->thread.ptr; + supplement_thread_base_entry_point(func, thread_ptr); + return 0; +} + +//////////////////////////////// +//~ rjf: @per_os_impl Platform Time Functions + +internal U64 +now_time_us(void) +{ + U64 result = 0; + LARGE_INTEGER large_int_counter; + if(QueryPerformanceCounter(&large_int_counter)) + { + result = (large_int_counter.QuadPart*Million(1))/os_w32_state.microsecond_resolution; + } + return result; +} + +internal U32 +now_time_unix(void) +{ + FILETIME file_time; + GetSystemTimeAsFileTime(&file_time); + U32 unix_time = os_w32_unix_time_from_file_time(file_time); + return unix_time; +} + +internal DateTime +now_time_universal(void) +{ + SYSTEMTIME systime = {0}; + GetSystemTime(&systime); + DateTime result = {0}; + os_w32_date_time_from_system_time(&result, &systime); + return result; +} + +internal DateTime +universal_from_local_time(DateTime *date_time) +{ + SYSTEMTIME systime = {0}; + os_w32_system_time_from_date_time(&systime, date_time); + FILETIME ftime = {0}; + SystemTimeToFileTime(&systime, &ftime); + FILETIME ftime_local = {0}; + LocalFileTimeToFileTime(&ftime, &ftime_local); + FileTimeToSystemTime(&ftime_local, &systime); + DateTime result = {0}; + os_w32_date_time_from_system_time(&result, &systime); + return result; +} + +internal DateTime +local_from_universal_time(DateTime *date_time) +{ + SYSTEMTIME systime = {0}; + os_w32_system_time_from_date_time(&systime, date_time); + FILETIME ftime = {0}; + SystemTimeToFileTime(&systime, &ftime); + FILETIME ftime_local = {0}; + FileTimeToLocalFileTime(&ftime, &ftime_local); + FileTimeToSystemTime(&ftime_local, &systime); + DateTime result = {0}; + os_w32_date_time_from_system_time(&result, &systime); + return result; +} + +internal void +sleep_ms(U32 msec) +{ + Sleep(msec); +} + +//////////////////////////////// +//~ rjf: @per_os_impl Platform GUID Functions + +internal Guid +make_guid(void) +{ + Guid result; + MemoryZeroStruct(&result); + UUID uuid; + RPC_STATUS rpc_status = UuidCreate(&uuid); + if(rpc_status == RPC_S_OK) + { + result.data1 = uuid.Data1; + result.data2 = uuid.Data2; + result.data3 = uuid.Data3; + MemoryCopyArray(result.data4, uuid.Data4); + } + return result; +} + +//////////////////////////////// +//~ rjf: @per_os_impl Platform Memory Allocation + +//- rjf: basic + +internal void * +reserve_memory(U64 size) +{ + void *result = VirtualAlloc(0, size, MEM_RESERVE, PAGE_READWRITE); + return result; +} + +internal B32 +commit_memory(void *ptr, U64 size) +{ + B32 result = (VirtualAlloc(ptr, size, MEM_COMMIT, PAGE_READWRITE) != 0); + if(w32_rio_functions.RIORegisterBuffer) + { + // wine does not implement these functions + w32_rio_functions.RIODeregisterBuffer(w32_rio_functions.RIORegisterBuffer(ptr, size)); + } +#if PROFILE_TELEMETRY + tmAlloc(0, ptr, size / 1024, "Win32 Commit"); +#endif + return result; +} + +internal void +decommit_memory(void *ptr, U64 size) +{ + VirtualFree(ptr, size, MEM_DECOMMIT); +#if PROFILE_TELEMETRY + tmFree(0, ptr); +#endif +} + +internal void +release_memory(void *ptr, U64 size) +{ + // NOTE(rjf): size not used - not necessary on Windows, but necessary for other OSes. + VirtualFree(ptr, 0, MEM_RELEASE); +} + +//- rjf: large pages + +internal void * +reserve_memory_large(U64 size) +{ + // we commit on reserve because windows + void *result = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT|MEM_LARGE_PAGES, PAGE_READWRITE); + return result; +} + +internal B32 +commit_memory_large(void *ptr, U64 size) +{ + return 1; +} + +//////////////////////////////// +//~ rjf: @os_hooks Shared Memory + +internal SharedMemory +shared_memory_alloc(U64 size, String8 name) +{ + Temp scratch = scratch_begin(0, 0); + String16 name16 = str16_from_8(scratch.arena, name); + HANDLE file = CreateFileMappingW(INVALID_HANDLE_VALUE, + 0, + PAGE_READWRITE, + (U32)((size & 0xffffffff00000000) >> 32), + (U32)((size & 0x00000000ffffffff)), + (WCHAR *)name16.str); + SharedMemory result = {(U64)file}; + scratch_end(scratch); + return result; +} + +internal SharedMemory +shared_memory_open(String8 name) +{ + Temp scratch = scratch_begin(0, 0); + String16 name16 = str16_from_8(scratch.arena, name); + HANDLE file = OpenFileMappingW(FILE_MAP_ALL_ACCESS, 0, (WCHAR *)name16.str); + SharedMemory result = {(U64)file}; + scratch_end(scratch); + return result; +} + +internal void +shared_memory_close(SharedMemory handle) +{ + HANDLE file = (HANDLE)(handle.u64[0]); + CloseHandle(file); +} + +internal void * +shared_memory_view_open(SharedMemory handle, Rng1U64 range) +{ + HANDLE file = (HANDLE)(handle.u64[0]); + U64 offset = range.min; + U64 size = range.max-range.min; + void *ptr = MapViewOfFile(file, FILE_MAP_ALL_ACCESS, + (U32)((offset & 0xffffffff00000000) >> 32), + (U32)((offset & 0x00000000ffffffff)), + size); + return ptr; +} + +internal void +shared_memory_view_close(SharedMemory handle, void *ptr, Rng1U64 range) +{ + UnmapViewOfFile(ptr); +} + +//////////////////////////////// +//~ rjf: @per_os_impl System Info + +internal SystemInfo * +get_system_info(void) +{ + return &os_w32_state.system_info; +} + +//////////////////////////////// +//~ rjf: @per_os_impl Current Thread Info + +internal U32 +tid(void) +{ + DWORD id = GetCurrentThreadId(); + return (U32)id; +} + +internal void +set_platform_thread_name(String8 name) +{ + Temp scratch = scratch_begin(0, 0); + + // rjf: windows 10 style + if(w32_SetThreadDescription_func) + { + String16 name16 = str16_from_8(scratch.arena, name); + HRESULT hr = w32_SetThreadDescription_func(GetCurrentThread(), (WCHAR*)name16.str); + } + + // rjf: raise-exception style + { + String8 name_copy = push_str8_copy(scratch.arena, name); +#pragma pack(push,8) + typedef struct THREADNAME_INFO THREADNAME_INFO; + struct THREADNAME_INFO + { + U32 dwType; // Must be 0x1000. + char *szName; // Pointer to name (in user addr space). + U32 dwThreadID; // Thread ID (-1=caller thread). + U32 dwFlags; // Reserved for future use, must be zero. + }; +#pragma pack(pop) + THREADNAME_INFO info; + info.dwType = 0x1000; + info.szName = (char *)name_copy.str; + info.dwThreadID = tid(); + info.dwFlags = 0; +#pragma warning(push) +#pragma warning(disable: 6320 6322) + __try + { + RaiseException(0x406D1388, 0, sizeof(info) / sizeof(void *), (const ULONG_PTR *)&info); + } + __except (EXCEPTION_EXECUTE_HANDLER) + { + } +#pragma warning(pop) + } + + scratch_end(scratch); +} + +//////////////////////////////// +//~ rjf: @per_os_impl Thread Functions + +internal Thread +thread_launch(ThreadEntryPointFunctionType *f, void *p) +{ + OS_W32_Entity *entity = os_w32_entity_alloc(OS_W32_EntityKind_Thread); + entity->thread.func = f; + entity->thread.ptr = p; + entity->thread.handle = CreateThread(0, 0, os_w32_thread_entry_point, entity, 0, &entity->thread.tid); + Thread result = {IntFromPtr(entity)}; + return result; +} + +internal B32 +thread_join(Thread thread, U64 endt_us) +{ + DWORD sleep_ms = os_w32_sleep_ms_from_endt_us(endt_us); + OS_W32_Entity *entity = (OS_W32_Entity *)PtrFromInt(thread.u64[0]); + DWORD wait_result = WAIT_OBJECT_0; + if(entity != 0) + { + wait_result = WaitForSingleObject(entity->thread.handle, sleep_ms); + CloseHandle(entity->thread.handle); + os_w32_entity_release(entity); + } + return (wait_result == WAIT_OBJECT_0); +} + +internal void +thread_detach(Thread thread) +{ + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(thread.u64[0]); + if(entity != 0) + { + CloseHandle(entity->thread.handle); + os_w32_entity_release(entity); + } +} + +//////////////////////////////// +//~ rjf: @os_hooks Safe Calls + +internal void +safe_call(ThreadEntryPointFunctionType *func, ThreadEntryPointFunctionType *fail_handler, void *ptr) +{ + __try + { + func(ptr); + } + __except (EXCEPTION_EXECUTE_HANDLER) + { + if(fail_handler != 0) + { + fail_handler(ptr); + } + } +} + +//////////////////////////////// +//~ rjf: @per_os_impl Synchronization Primitive Functions + +//- rjf: recursive mutexes + +internal Mutex +mutex_alloc(void) +{ + OS_W32_Entity *entity = os_w32_entity_alloc(OS_W32_EntityKind_Mutex); + InitializeCriticalSection(&entity->mutex); + Mutex result = {IntFromPtr(entity)}; + return result; +} + +internal void +mutex_release(Mutex mutex) +{ + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(mutex.u64[0]); + DeleteCriticalSection(&entity->mutex); + os_w32_entity_release(entity); +} + +internal void +mutex_take(Mutex mutex) +{ + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(mutex.u64[0]); + EnterCriticalSection(&entity->mutex); +} + +internal void +mutex_drop(Mutex mutex) +{ + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(mutex.u64[0]); + LeaveCriticalSection(&entity->mutex); +} + +//- rjf: reader/writer mutexes + +internal RWMutex +rw_mutex_alloc(void) +{ + OS_W32_Entity *entity = os_w32_entity_alloc(OS_W32_EntityKind_RWMutex); + InitializeSRWLock(&entity->rw_mutex); + RWMutex result = {IntFromPtr(entity)}; + return result; +} + +internal void +rw_mutex_release(RWMutex rw_mutex) +{ + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(rw_mutex.u64[0]); + os_w32_entity_release(entity); +} + +internal void +rw_mutex_take(RWMutex rw_mutex, B32 write_mode) +{ + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(rw_mutex.u64[0]); + if(write_mode) + { + AcquireSRWLockExclusive(&entity->rw_mutex); + } + else + { + AcquireSRWLockShared(&entity->rw_mutex); + } +} + +internal void +rw_mutex_drop(RWMutex rw_mutex, B32 write_mode) +{ + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(rw_mutex.u64[0]); + if(write_mode) + { + ReleaseSRWLockExclusive(&entity->rw_mutex); + } + else + { + ReleaseSRWLockShared(&entity->rw_mutex); + } +} + +//- rjf: condition variables + +internal CondVar +cond_var_alloc(void) +{ + OS_W32_Entity *entity = os_w32_entity_alloc(OS_W32_EntityKind_ConditionVariable); + InitializeConditionVariable(&entity->cv); + CondVar result = {IntFromPtr(entity)}; + return result; +} + +internal void +cond_var_release(CondVar cv) +{ + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(cv.u64[0]); + os_w32_entity_release(entity); +} + +internal B32 +cond_var_wait(CondVar cv, Mutex mutex, U64 endt_us) +{ + U32 sleep_ms = os_w32_sleep_ms_from_endt_us(endt_us); + BOOL result = 0; + if(sleep_ms > 0) + { + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(cv.u64[0]); + OS_W32_Entity *mutex_entity = (OS_W32_Entity*)PtrFromInt(mutex.u64[0]); + result = SleepConditionVariableCS(&entity->cv, &mutex_entity->mutex, sleep_ms); + } + return result; +} + +internal B32 +cond_var_wait_rw(CondVar cv, RWMutex mutex_rw, B32 write_mode, U64 endt_us) +{ + U32 sleep_ms = os_w32_sleep_ms_from_endt_us(endt_us); + BOOL result = 0; + if(sleep_ms > 0) + { + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(cv.u64[0]); + OS_W32_Entity *mutex_entity = (OS_W32_Entity*)PtrFromInt(mutex_rw.u64[0]); + result = SleepConditionVariableSRW(&entity->cv, &mutex_entity->rw_mutex, sleep_ms, + write_mode ? 0 : CONDITION_VARIABLE_LOCKMODE_SHARED); + } + return result; +} + +internal void +cond_var_signal(CondVar cv) +{ + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(cv.u64[0]); + WakeConditionVariable(&entity->cv); +} + +internal void +cond_var_broadcast(CondVar cv) +{ + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(cv.u64[0]); + WakeAllConditionVariable(&entity->cv); +} + +//- rjf: cross-process semaphores + +internal Semaphore +semaphore_alloc(U32 initial_count, U32 max_count, String8 name) +{ + Temp scratch = scratch_begin(0, 0); + String16 name16 = str16_from_8(scratch.arena, name); + HANDLE handle = CreateSemaphoreW(0, initial_count, max_count, (WCHAR *)name16.str); + Semaphore result = {(U64)handle}; + scratch_end(scratch); + return result; +} + +internal void +semaphore_release(Semaphore semaphore) +{ + HANDLE handle = (HANDLE)semaphore.u64[0]; + CloseHandle(handle); +} + +internal Semaphore +semaphore_open(String8 name) +{ + Temp scratch = scratch_begin(0, 0); + String16 name16 = str16_from_8(scratch.arena, name); + HANDLE handle = OpenSemaphoreW(SEMAPHORE_ALL_ACCESS, 0, (WCHAR *)name16.str); + Semaphore result = {(U64)handle}; + scratch_end(scratch); + return result; +} + +internal void +semaphore_close(Semaphore semaphore) +{ + HANDLE handle = (HANDLE)semaphore.u64[0]; + CloseHandle(handle); +} + +internal B32 +semaphore_take(Semaphore semaphore, U64 endt_us) +{ + U32 sleep_ms = os_w32_sleep_ms_from_endt_us(endt_us); + HANDLE handle = (HANDLE)semaphore.u64[0]; + DWORD wait_result = WaitForSingleObject(handle, sleep_ms); + B32 result = (wait_result == WAIT_OBJECT_0); + return result; +} + +internal void +semaphore_drop(Semaphore semaphore) +{ + HANDLE handle = (HANDLE)semaphore.u64[0]; + ReleaseSemaphore(handle, 1, 0); +} + +//- rjf: barriers + +internal Barrier +barrier_alloc(U64 count) +{ + OS_W32_Entity *entity = os_w32_entity_alloc(OS_W32_EntityKind_Barrier); + if(entity != 0) + { + BOOL init_good = InitializeSynchronizationBarrier(&entity->sb, count, -1); + (void)init_good; + } + Barrier result = {IntFromPtr(entity)}; + return result; +} + +internal void +barrier_release(Barrier barrier) +{ + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(barrier.u64[0]); + if(entity != 0) + { + DeleteSynchronizationBarrier(&entity->sb); + os_w32_entity_release(entity); + } +} + +internal void +barrier_wait(Barrier barrier) +{ + OS_W32_Entity *entity = (OS_W32_Entity*)PtrFromInt(barrier.u64[0]); + if(entity != 0) + { + EnterSynchronizationBarrier(&entity->sb, 0); + } +} + +//////////////////////////////// +//~ rjf: @per_os_impl File System (Implemented Per-OS) + +//- rjf: files + +internal File +file_open(AccessFlags flags, String8 path) +{ + File result = {0}; + Temp scratch = scratch_begin(0, 0); + String16 path16 = str16_from_8(scratch.arena, path); + DWORD access_flags = 0; + DWORD share_mode = 0; + DWORD creation_disposition = OPEN_EXISTING; + SECURITY_ATTRIBUTES security_attributes = {sizeof(security_attributes), 0, 0}; + if(flags & AccessFlag_Read) {access_flags |= GENERIC_READ;} + if(flags & AccessFlag_Write) {access_flags |= GENERIC_WRITE;} + if(flags & AccessFlag_Execute) {access_flags |= GENERIC_EXECUTE;} + if(flags & AccessFlag_ShareRead) {share_mode |= FILE_SHARE_READ;} + if(flags & AccessFlag_ShareWrite) {share_mode |= FILE_SHARE_WRITE|FILE_SHARE_DELETE;} + if(flags & AccessFlag_Write) {creation_disposition = CREATE_ALWAYS;} + if(flags & AccessFlag_Append) {creation_disposition = OPEN_ALWAYS; access_flags |= FILE_APPEND_DATA; } + if(flags & AccessFlag_Inherited) + { + security_attributes.bInheritHandle = 1; + } + HANDLE file = CreateFileW((WCHAR *)path16.str, access_flags, share_mode, &security_attributes, creation_disposition, FILE_ATTRIBUTE_NORMAL, 0); + if(file != INVALID_HANDLE_VALUE) + { + result.u64[0] = (U64)file; + } + else + { + DWORD err = GetLastError(); + (void)err; + } + scratch_end(scratch); + return result; +} + +internal void +file_close(File file) +{ + if(file_match(file, file_zero())) { return; } + HANDLE handle = (HANDLE)file.u64[0]; + BOOL result = CloseHandle(handle); + (void)result; +} + +internal U64 +file_read(File file, Rng1U64 rng, void *out_data) +{ + if(file_match(file, file_zero())) { return 0; } + + HANDLE handle = (HANDLE)file.u64[0]; + U8 *ptr = out_data; + U64 off = rng.min; + while(off != rng.max) + { + U64 amt64 = rng.max - off; + U32 amt32 = (U32)Min(MB(32), amt64); + DWORD read_size = 0; + OVERLAPPED overlapped = { .Offset = (U32)off, .OffsetHigh = (U32)(off >> 32) }; + if( ! ReadFile(handle, ptr, amt32, &read_size, &overlapped)) + { + break; + } + ptr += read_size; + off += read_size; + } + + U64 total_read_size = off - rng.min; + return total_read_size; +} + +internal U64 +file_write(File file, Rng1U64 rng, void *data) +{ + if(file_match(file, file_zero())) { return 0; } + HANDLE win_handle = (HANDLE)file.u64[0]; + U64 src_off = 0; + U64 dst_off = rng.min; + U64 total_write_size = dim_1u64(rng); + for(;;) + { + void *bytes_src = (U8 *)data + src_off; + U64 bytes_left = total_write_size - src_off; + DWORD write_size = Min(MB(1), bytes_left); + DWORD bytes_written = 0; + OVERLAPPED overlapped = {0}; + overlapped.Offset = (dst_off&0x00000000ffffffffull); + overlapped.OffsetHigh = (dst_off&0xffffffff00000000ull) >> 32; + BOOL success = WriteFile(win_handle, bytes_src, write_size, &bytes_written, &overlapped); + if(success == 0) + { + break; + } + src_off += bytes_written; + dst_off += bytes_written; + if(bytes_left == 0) + { + break; + } + } + return src_off; +} + +internal B32 +file_set_time(File file, DateTime time) +{ + if(file_match(file, file_zero())) { return 0; } + B32 result = 0; + HANDLE handle = (HANDLE)file.u64[0]; + SYSTEMTIME system_time = {0}; + os_w32_system_time_from_date_time(&system_time, &time); + FILETIME file_time = {0}; + result = (SystemTimeToFileTime(&system_time, &file_time) && + SetFileTime(handle, &file_time, &file_time, &file_time)); + return result; +} + +internal FileProperties +properties_from_file(File file) +{ + if(file_match(file, file_zero())) { FileProperties r = {0}; return r; } + FileProperties props = {0}; + HANDLE handle = (HANDLE)file.u64[0]; + BY_HANDLE_FILE_INFORMATION info; + BOOL info_good = GetFileInformationByHandle(handle, &info); + if(info_good) + { + U32 size_lo = info.nFileSizeLow; + U32 size_hi = info.nFileSizeHigh; + props.size = (U64)size_lo | (((U64)size_hi)<<32); + os_w32_dense_time_from_file_time(&props.modified, &info.ftLastWriteTime); + os_w32_dense_time_from_file_time(&props.created, &info.ftCreationTime); + props.flags = os_w32_file_property_flags_from_dwFileAttributes(info.dwFileAttributes); + } + return props; +} + +internal FileID +id_from_file(File file) +{ + if(file_match(file, file_zero())) { FileID r = {0}; return r; } + FileID result = {0}; + HANDLE handle = (HANDLE)file.u64[0]; + BY_HANDLE_FILE_INFORMATION info; + BOOL is_ok = GetFileInformationByHandle(handle, &info); + if(is_ok) + { + result.v[0] = info.dwVolumeSerialNumber; + result.v[1] = info.nFileIndexLow; + result.v[2] = info.nFileIndexHigh; + } + return result; +} + +internal B32 +file_reserve_size(File file, U64 size) +{ + HANDLE handle = (HANDLE)file.u64[0]; + + FILE_ALLOCATION_INFO alloc_info = {0}; + alloc_info.AllocationSize.LowPart = size & max_U32; + alloc_info.AllocationSize.HighPart = (size >> 32) & max_U32; + + BOOL is_reserved = SetFileInformationByHandle(handle, FileAllocationInfo, &alloc_info, sizeof(alloc_info)); + return is_reserved; +} + +internal B32 +delete_file_at_path(String8 path) +{ + Temp scratch = scratch_begin(0, 0); + String16 path16 = str16_from_8(scratch.arena, path); + B32 result = DeleteFileW((WCHAR*)path16.str); + scratch_end(scratch); + return result; +} + +internal B32 +copy_file_path(String8 dst, String8 src) +{ + Temp scratch = scratch_begin(0, 0); + String16 dst16 = str16_from_8(scratch.arena, dst); + String16 src16 = str16_from_8(scratch.arena, src); + B32 result = CopyFileW((WCHAR*)src16.str, (WCHAR*)dst16.str, 0); + scratch_end(scratch); + return result; +} + +internal B32 +move_file_path(String8 dst, String8 src) +{ + Temp scratch = scratch_begin(0, 0); + String16 dst16 = str16_from_8(scratch.arena, dst); + String16 src16 = str16_from_8(scratch.arena, src); + B32 result = MoveFileW((WCHAR*)src16.str, (WCHAR*)dst16.str); + scratch_end(scratch); + return result; +} + +internal String8 +full_path_from_path(Arena *arena, String8 path) +{ + Temp scratch = scratch_begin(&arena, 1); + DWORD buffer_size = Max(MAX_PATH, path.size * 2) + 1; + String16 path16 = str16_from_8(scratch.arena, path); + WCHAR *buffer = push_array_no_zero(scratch.arena, WCHAR, buffer_size); + DWORD path16_size = GetFullPathNameW((WCHAR*)path16.str, buffer_size, buffer, NULL); + if(path16_size > buffer_size) + { + arena_pop(scratch.arena, buffer_size); + buffer_size = path16_size + 1; + buffer = push_array_no_zero(scratch.arena, WCHAR, buffer_size); + path16_size = GetFullPathNameW((WCHAR*)path16.str, buffer_size, buffer, NULL); + } + String8 full_path = str8_from_16(arena, str16((U16*)buffer, path16_size)); + scratch_end(scratch); + return full_path; +} + +internal B32 +file_path_exists(String8 path) +{ + Temp scratch = scratch_begin(0,0); + String16 path16 = str16_from_8(scratch.arena, path); + DWORD attributes = GetFileAttributesW((WCHAR *)path16.str); + B32 exists = (attributes != INVALID_FILE_ATTRIBUTES) && !!(~attributes & FILE_ATTRIBUTE_DIRECTORY); + scratch_end(scratch); + return exists; +} + +internal B32 +folder_path_exists(String8 path) +{ + Temp scratch = scratch_begin(0,0); + String16 path16 = str16_from_8(scratch.arena, path); + DWORD attributes = GetFileAttributesW((WCHAR *)path16.str); + B32 exists = (attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY); + scratch_end(scratch); + return exists; +} + +internal FileProperties +properties_from_file_path(String8 path) +{ + WIN32_FIND_DATAW find_data = {0}; + Temp scratch = scratch_begin(0, 0); + String16 path16 = str16_from_8(scratch.arena, path); + HANDLE handle = FindFirstFileW((WCHAR *)path16.str, &find_data); + FileProperties props = {0}; + if(handle != INVALID_HANDLE_VALUE) + { + props.size = Compose64Bit(find_data.nFileSizeHigh, find_data.nFileSizeLow); + os_w32_dense_time_from_file_time(&props.created, &find_data.ftCreationTime); + os_w32_dense_time_from_file_time(&props.modified, &find_data.ftLastWriteTime); + props.flags = os_w32_file_property_flags_from_dwFileAttributes(find_data.dwFileAttributes); + } + else + { + Temp scratch = scratch_begin(0, 0); + WCHAR buffer[512] = {0}; + DWORD length = GetLogicalDriveStringsW(sizeof(buffer), buffer); + U64 last_slash_pos = 0; + for(;last_slash_pos < path.size; last_slash_pos = str8_find_needle(path, last_slash_pos+1, str8_lit("/"), StringMatchFlag_SlashInsensitive)); + String8 path_trimmed = str8_prefix(path, last_slash_pos); + for(U64 off = 0; off < (U64)length;) + { + String16 next_drive_string_16 = str16_cstring((U16 *)buffer+off); + off += next_drive_string_16.size+1; + String8 next_drive_string = str8_from_16(scratch.arena, next_drive_string_16); + next_drive_string = str8_chop_last_slash(next_drive_string); + if(str8_match(path_trimmed, next_drive_string, StringMatchFlag_CaseInsensitive)) + { + props.flags |= FilePropertyFlag_IsFolder; + break; + } + } + scratch_end(scratch); + } + FindClose(handle); + scratch_end(scratch); + return props; +} + +//- rjf: file maps + +internal FileMap +file_map_open(AccessFlags flags, File file) +{ + FileMap map = {0}; + { + HANDLE file_handle = (HANDLE)file.u64[0]; + DWORD protect_flags = 0; + { + switch(flags) + { + default:{}break; + case AccessFlag_Read: + {protect_flags = PAGE_READONLY;}break; + case AccessFlag_Write: + case AccessFlag_Read|AccessFlag_Write: + {protect_flags = PAGE_READWRITE;}break; + case AccessFlag_Execute: + case AccessFlag_Read|AccessFlag_Execute: + {protect_flags = PAGE_EXECUTE_READ;}break; + case AccessFlag_Execute|AccessFlag_Write|AccessFlag_Read: + case AccessFlag_Execute|AccessFlag_Write: + {protect_flags = PAGE_EXECUTE_READWRITE;}break; + } + } + HANDLE map_handle = CreateFileMappingA(file_handle, 0, protect_flags, 0, 0, 0); + map.u64[0] = (U64)map_handle; + } + return map; +} + +internal void +file_map_close(FileMap map) +{ + HANDLE handle = (HANDLE)map.u64[0]; + BOOL result = CloseHandle(handle); + (void)result; +} + +internal void * +file_map_view_open(FileMap map, AccessFlags flags, Rng1U64 range) +{ + HANDLE handle = (HANDLE)map.u64[0]; + U32 off_lo = (U32)((range.min&0x00000000ffffffffull)>>0); + U32 off_hi = (U32)((range.min&0xffffffff00000000ull)>>32); + U64 size = dim_1u64(range); + DWORD access_flags = 0; + { + switch(flags) + { + default:{}break; + case AccessFlag_Read: + { + access_flags = FILE_MAP_READ; + }break; + case AccessFlag_Write: + { + access_flags = FILE_MAP_WRITE; + }break; + case AccessFlag_Read|AccessFlag_Write: + { + access_flags = FILE_MAP_ALL_ACCESS; + }break; + case AccessFlag_Execute: + case AccessFlag_Read|AccessFlag_Execute: + case AccessFlag_Write|AccessFlag_Execute: + case AccessFlag_Read|AccessFlag_Write|AccessFlag_Execute: + { + access_flags = FILE_MAP_ALL_ACCESS|FILE_MAP_EXECUTE; + }break; + } + } + void *result = MapViewOfFile(handle, access_flags, off_hi, off_lo, size); + return result; +} + +internal void +file_map_view_close(FileMap map, void *ptr, Rng1U64 range) +{ + BOOL result = UnmapViewOfFile(ptr); + (void)result; +} + +//- rjf: directory iteration + +internal FileIter * +file_iter_begin(Arena *arena, String8 path, FileIterFlags flags) +{ + Temp scratch = scratch_begin(&arena, 1); + String8 path_with_wildcard = push_str8_cat(scratch.arena, path, str8_lit("\\*")); + String16 path16 = str16_from_8(scratch.arena, path_with_wildcard); + FileIter *iter = push_array(arena, FileIter, 1); + iter->flags = flags; + OS_W32_FileIter *w32_iter = (OS_W32_FileIter*)iter->memory; + if(path.size == 0) + { + w32_iter->is_volume_iter = 1; + WCHAR buffer[512] = {0}; + DWORD length = GetLogicalDriveStringsW(sizeof(buffer), buffer); + String8List drive_strings = {0}; + for(U64 off = 0; off < (U64)length;) + { + String16 next_drive_string_16 = str16_cstring((U16 *)buffer+off); + off += next_drive_string_16.size+1; + String8 next_drive_string = str8_from_16(arena, next_drive_string_16); + next_drive_string = str8_chop_last_slash(next_drive_string); + str8_list_push(scratch.arena, &drive_strings, next_drive_string); + } + w32_iter->drive_strings = str8_array_from_list(arena, &drive_strings); + w32_iter->drive_strings_iter_idx = 0; + } + else + { + w32_iter->handle = FindFirstFileExW((WCHAR*)path16.str, FindExInfoBasic, &w32_iter->find_data, FindExSearchNameMatch, 0, FIND_FIRST_EX_LARGE_FETCH); + } + scratch_end(scratch); + return iter; +} + +internal B32 +file_iter_next(Arena *arena, FileIter *iter, FileInfo *info_out) +{ + B32 result = 0; + FileIterFlags flags = iter->flags; + OS_W32_FileIter *w32_iter = (OS_W32_FileIter*)iter->memory; + switch(w32_iter->is_volume_iter) + { + //- rjf: file iteration + default: + case 0: + { + if (!(flags & FileIterFlag_Done) && w32_iter->handle != INVALID_HANDLE_VALUE) + { + do + { + // check is usable + B32 usable_file = 1; + + WCHAR *file_name = w32_iter->find_data.cFileName; + DWORD attributes = w32_iter->find_data.dwFileAttributes; + if (file_name[0] == '.'){ + if (flags & FileIterFlag_SkipHiddenFiles){ + usable_file = 0; + } + else if (file_name[1] == 0){ + usable_file = 0; + } + else if (file_name[1] == '.' && file_name[2] == 0){ + usable_file = 0; + } + } + if (attributes & FILE_ATTRIBUTE_DIRECTORY){ + if (flags & FileIterFlag_SkipFolders){ + usable_file = 0; + } + } + else{ + if (flags & FileIterFlag_SkipFiles){ + usable_file = 0; + } + } + + // emit if usable + if (usable_file){ + info_out->name = str8_from_16(arena, str16_cstring((U16*)file_name)); + info_out->props.size = (U64)w32_iter->find_data.nFileSizeLow | (((U64)w32_iter->find_data.nFileSizeHigh)<<32); + os_w32_dense_time_from_file_time(&info_out->props.created, &w32_iter->find_data.ftCreationTime); + os_w32_dense_time_from_file_time(&info_out->props.modified, &w32_iter->find_data.ftLastWriteTime); + info_out->props.flags = os_w32_file_property_flags_from_dwFileAttributes(attributes); + result = 1; + if (!FindNextFileW(w32_iter->handle, &w32_iter->find_data)){ + iter->flags |= FileIterFlag_Done; + } + break; + } + }while(FindNextFileW(w32_iter->handle, &w32_iter->find_data)); + } + }break; + + //- rjf: volume iteration + case 1: + { + result = w32_iter->drive_strings_iter_idx < w32_iter->drive_strings.count; + if(result != 0) + { + MemoryZeroStruct(info_out); + info_out->name = w32_iter->drive_strings.v[w32_iter->drive_strings_iter_idx]; + info_out->props.flags |= FilePropertyFlag_IsFolder; + w32_iter->drive_strings_iter_idx += 1; + } + }break; + } + if(!result) + { + iter->flags |= FileIterFlag_Done; + } + return result; +} + +internal void +file_iter_end(FileIter *iter) +{ + OS_W32_FileIter *w32_iter = (OS_W32_FileIter*)iter->memory; + HANDLE zero_handle; + MemoryZeroStruct(&zero_handle); + if(!MemoryMatchStruct(&zero_handle, &w32_iter->handle)) + { + FindClose(w32_iter->handle); + } +} + +//- rjf: directory creation + +internal B32 +make_directory(String8 path) +{ + B32 result = 0; + Temp scratch = scratch_begin(0, 0); + String16 name16 = str16_from_8(scratch.arena, path); + WIN32_FILE_ATTRIBUTE_DATA attributes = {0}; + GetFileAttributesExW((WCHAR*)name16.str, GetFileExInfoStandard, &attributes); + if(attributes.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + { + result = 1; + } + else if(CreateDirectoryW((WCHAR*)name16.str, 0)) + { + result = 1; + } + scratch_end(scratch); + return(result); +} + +//////////////////////////////// +//~ rjf: @per_os_impl Aborting + +internal void +abort_self(S32 exit_code) +{ + ExitProcess(exit_code); +} + +//////////////////////////////// +//~ rjf: @per_os_impl Process Info + +internal ProcessInfo * +get_process_info(void) +{ + return &os_w32_state.process_info; +} + +internal String8 +get_current_path(Arena *arena) +{ + Temp scratch = scratch_begin(&arena, 1); + DWORD length = GetCurrentDirectoryW(0, 0); + U16 *memory = push_array_no_zero(scratch.arena, U16, length + 1); + length = GetCurrentDirectoryW(length + 1, (WCHAR*)memory); + String8 name = str8_from_16(arena, str16(memory, length)); + scratch_end(scratch); + return name; +} + +internal U32 +get_process_start_time_unix(void) +{ + U32 result = 0; + HANDLE handle = GetCurrentProcess(); + FILETIME start_time = {0}; + FILETIME exit_time; + FILETIME kernel_time; + FILETIME user_time; + if(GetProcessTimes(handle, &start_time, &exit_time, &kernel_time, &user_time)) + { + result = os_w32_unix_time_from_file_time(start_time); + } + return result; +} + +//////////////////////////////// +//~ rjf: @per_os_impl Child Processes + +internal Process +process_launch(ProcessLaunchParams *params) +{ + Process result = {0}; + Temp scratch = scratch_begin(0, 0); + + //- rjf: form full command string + String8 cmd = {0}; + { + StringJoin join_params = {0}; + join_params.pre = str8_lit("\""); + join_params.sep = str8_lit("\" \""); + join_params.post = str8_lit("\""); + cmd = str8_list_join(scratch.arena, ¶ms->cmd_line, &join_params); + } + + //- rjf: form environment + B32 use_null_env_arg = 0; + String8 env = {0}; + { + StringJoin join_params2 = {0}; + join_params2.sep = str8_lit("\0"); + join_params2.post = str8_lit("\0"); + String8List all_opts = params->env; + if(params->inherit_env != 0) + { + if(all_opts.node_count != 0) + { + MemoryZeroStruct(&all_opts); + for(String8Node *n = params->env.first; n != 0; n = n->next) + { + str8_list_push(scratch.arena, &all_opts, n->string); + } + for(String8Node *n = os_w32_state.process_info.environment.first; n != 0; n = n->next) + { + str8_list_push(scratch.arena, &all_opts, n->string); + } + } + else + { + use_null_env_arg = 1; + } + } + if(use_null_env_arg == 0) + { + env = str8_list_join(scratch.arena, &all_opts, &join_params2); + } + } + + //- rjf: utf-8 -> utf-16 + String16 cmd16 = str16_from_8(scratch.arena, cmd); + String16 dir16 = str16_from_8(scratch.arena, params->path); + String16 env16 = {0}; + if(use_null_env_arg == 0) + { + env16 = str16_from_8(scratch.arena, env); + } + + //- rjf: determine creation flags + DWORD creation_flags = CREATE_UNICODE_ENVIRONMENT; + if(params->consoleless) + { + creation_flags |= CREATE_NO_WINDOW; + } + + //- rjf: launch + BOOL inherit_handles = 0; + STARTUPINFOW startup_info = {sizeof(startup_info)}; + if(!file_match(params->stdout_file, file_zero())) + { + HANDLE stdout_handle = (HANDLE)params->stdout_file.u64[0]; + startup_info.hStdOutput = stdout_handle; + startup_info.dwFlags |= STARTF_USESTDHANDLES; + inherit_handles = 1; + } + if(!file_match(params->stderr_file, file_zero())) + { + HANDLE stderr_handle = (HANDLE)params->stderr_file.u64[0]; + startup_info.hStdError = stderr_handle; + startup_info.dwFlags |= STARTF_USESTDHANDLES; + inherit_handles = 1; + } + if(!file_match(params->stdin_file, file_zero())) + { + HANDLE stdin_handle = (HANDLE)params->stdin_file.u64[0]; + startup_info.hStdInput = stdin_handle; + startup_info.dwFlags |= STARTF_USESTDHANDLES; + inherit_handles = 1; + } + PROCESS_INFORMATION process_info = {0}; + if(CreateProcessW(0, (WCHAR*)cmd16.str, 0, 0, inherit_handles, creation_flags, use_null_env_arg ? 0 : (WCHAR*)env16.str, (WCHAR*)dir16.str, &startup_info, &process_info)) + { + result.u64[0] = (U64)process_info.hProcess; + CloseHandle(process_info.hThread); + } + + scratch_end(scratch); + return result; +} + +internal B32 +process_join(Process process, U64 endt_us, U64 *exit_code_out) +{ + HANDLE process_handle = (HANDLE)(process.u64[0]); + DWORD sleep_ms = os_w32_sleep_ms_from_endt_us(endt_us); + DWORD result = WaitForSingleObject(process_handle, sleep_ms); + B32 process_joined = (result == WAIT_OBJECT_0); + if(process_joined && exit_code_out) + { + DWORD exit_code = 0; + if(GetExitCodeProcess(process_handle, &exit_code)) + { + *exit_code_out = exit_code; + } + } + if(process_joined) + { + CloseHandle(process_handle); + } + return process_joined; +} + +internal void +process_detach(Process process) +{ + HANDLE process_handle = (HANDLE)(process.u64[0]); + CloseHandle(process_handle); +} + +internal B32 +process_kill(Process process) +{ + HANDLE process_handle = (HANDLE)process.u64[0]; + BOOL was_terminated = TerminateProcess(process_handle, 999); + return was_terminated; +} + +//////////////////////////////// +//~ rjf: @per_os_impl Dynamically-Loaded Libraries + +internal Library +library_open(String8 path) +{ + Temp scratch = scratch_begin(0, 0); + String16 path16 = str16_from_8(scratch.arena, path); + HMODULE mod = LoadLibraryW((LPCWSTR)path16.str); + Library result = { (U64)mod }; + scratch_end(scratch); + return result; +} + +internal void +library_close(Library lib) +{ + HMODULE mod = (HMODULE)lib.u64[0]; + FreeLibrary(mod); +} + +internal VoidProc * +library_load_proc(Library lib, String8 name) +{ + Temp scratch = scratch_begin(0, 0); + HMODULE mod = (HMODULE)lib.u64[0]; + name = push_str8_copy(scratch.arena, name); + VoidProc *result = (VoidProc*)GetProcAddress(mod, (LPCSTR)name.str); + scratch_end(scratch); + return result; +} + +//////////////////////////////// +//~ rjf: Entry Point + +#include +#undef OS_WINDOWS // shlwapi uses its own OS_WINDOWS include inside +#include + +internal B32 win32_g_is_quiet = 0; +internal B32 win32_g_gen_dump = 0; + +internal HRESULT WINAPI +win32_dialog_callback(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam, LONG_PTR data) +{ + if(msg == TDN_HYPERLINK_CLICKED) + { + ShellExecuteW(NULL, L"open", (LPWSTR)lparam, NULL, NULL, SW_SHOWNORMAL); + } + return S_OK; +} + +internal LONG WINAPI +win32_exception_filter(EXCEPTION_POINTERS* exception_ptrs) +{ + if(win32_g_is_quiet) + { + ExitProcess(1); + } + + static volatile LONG first = 0; + if(InterlockedCompareExchange(&first, 1, 0) != 0) + { + // prevent failures in other threads to popup same message box + // this handler just shows first thread that crashes + // we are terminating afterwards anyway + for (;;) Sleep(1000); + } + + WCHAR buffer[4096] = {0}; + int buflen = 0; + + DWORD exception_code = exception_ptrs->ExceptionRecord->ExceptionCode; + buflen += wnsprintfW(buffer + buflen, ArrayCount(buffer) - buflen, L"A fatal exception (code 0x%x) occurred. The process is terminating.\n", exception_code); + + // load dbghelp dynamically just in case if it is missing + BOOL (WINAPI *dbg_MiniDumpWriteDump)(HANDLE hProcess, DWORD ProcessId, HANDLE hFile, MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam, PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, PMINIDUMP_CALLBACK_INFORMATION CallbackParam) = 0; + HMODULE dbghelp = LoadLibraryA("dbghelp.dll"); + if(dbghelp) + { + DWORD (WINAPI *dbg_SymSetOptions)(DWORD SymOptions); + BOOL (WINAPI *dbg_SymInitializeW)(HANDLE hProcess, PCWSTR UserSearchPath, BOOL fInvadeProcess); + BOOL (WINAPI *dbg_StackWalk64)(DWORD MachineType, HANDLE hProcess, HANDLE hThread, + LPSTACKFRAME64 StackFrame, PVOID ContextRecord, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, + PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, + PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress); + PVOID (WINAPI *dbg_SymFunctionTableAccess64)(HANDLE hProcess, DWORD64 AddrBase); + DWORD64 (WINAPI *dbg_SymGetModuleBase64)(HANDLE hProcess, DWORD64 qwAddr); + BOOL (WINAPI *dbg_SymFromAddrW)(HANDLE hProcess, DWORD64 Address, PDWORD64 Displacement, PSYMBOL_INFOW Symbol); + BOOL (WINAPI *dbg_SymGetLineFromAddrW64)(HANDLE hProcess, DWORD64 dwAddr, PDWORD pdwDisplacement, PIMAGEHLP_LINEW64 Line); + BOOL (WINAPI *dbg_SymGetModuleInfoW64)(HANDLE hProcess, DWORD64 qwAddr, PIMAGEHLP_MODULEW64 ModuleInfo); + + *(FARPROC*)&dbg_SymSetOptions = GetProcAddress(dbghelp, "SymSetOptions"); + *(FARPROC*)&dbg_SymInitializeW = GetProcAddress(dbghelp, "SymInitializeW"); + *(FARPROC*)&dbg_StackWalk64 = GetProcAddress(dbghelp, "StackWalk64"); + *(FARPROC*)&dbg_SymFunctionTableAccess64 = GetProcAddress(dbghelp, "SymFunctionTableAccess64"); + *(FARPROC*)&dbg_SymGetModuleBase64 = GetProcAddress(dbghelp, "SymGetModuleBase64"); + *(FARPROC*)&dbg_SymFromAddrW = GetProcAddress(dbghelp, "SymFromAddrW"); + *(FARPROC*)&dbg_SymGetLineFromAddrW64 = GetProcAddress(dbghelp, "SymGetLineFromAddrW64"); + *(FARPROC*)&dbg_SymGetModuleInfoW64 = GetProcAddress(dbghelp, "SymGetModuleInfoW64"); + *(FARPROC*)&dbg_MiniDumpWriteDump = GetProcAddress(dbghelp, "MiniDumpWriteDump"); + + if(dbg_SymSetOptions && dbg_SymInitializeW && dbg_StackWalk64 && dbg_SymFunctionTableAccess64 && dbg_SymGetModuleBase64 && dbg_SymFromAddrW && dbg_SymGetLineFromAddrW64 && dbg_SymGetModuleInfoW64) + { + HANDLE process = GetCurrentProcess(); + HANDLE thread = GetCurrentThread(); + CONTEXT context = *exception_ptrs->ContextRecord; + + WCHAR module_path[MAX_PATH]; + GetModuleFileNameW(NULL, module_path, ArrayCount(module_path)); + PathRemoveFileSpecW(module_path); + + dbg_SymSetOptions(SYMOPT_EXACT_SYMBOLS | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_LOAD_LINES | SYMOPT_UNDNAME); + if(dbg_SymInitializeW(process, module_path, TRUE)) + { + // check that raddbg.pdb file is good + B32 raddbg_pdb_valid = 0; + { + IMAGEHLP_MODULEW64 module = {0}; + module.SizeOfStruct = sizeof(module); + if(dbg_SymGetModuleInfoW64(process, (DWORD64)&win32_exception_filter, &module)) + { + raddbg_pdb_valid = (module.SymType == SymPdb); + } + } + + if(!raddbg_pdb_valid) + { + buflen += wnsprintfW(buffer + buflen, sizeof(buffer) - buflen, + L"\nThe PDB debug information file for this executable is not valid or was not found. Please rebuild binary to get the call stack.\n"); + } + else + { + STACKFRAME64 frame = {0}; + DWORD image_type; +#if defined(_M_AMD64) + image_type = IMAGE_FILE_MACHINE_AMD64; + frame.AddrPC.Offset = context.Rip; + frame.AddrPC.Mode = AddrModeFlat; + frame.AddrFrame.Offset = context.Rbp; + frame.AddrFrame.Mode = AddrModeFlat; + frame.AddrStack.Offset = context.Rsp; + frame.AddrStack.Mode = AddrModeFlat; +#elif defined(_M_ARM64) + image_type = IMAGE_FILE_MACHINE_ARM64; + frame.AddrPC.Offset = context.Pc; + frame.AddrPC.Mode = AddrModeFlat; + frame.AddrFrame.Offset = context.Fp; + frame.AddrFrame.Mode = AddrModeFlat; + frame.AddrStack.Offset = context.Sp; + frame.AddrStack.Mode = AddrModeFlat; +#else +# error Arch not supported! +#endif + +#if BUILD_CONSOLE_INTERFACE + buflen += wnsprintfW(buffer + buflen, ArrayCount(buffer) - buflen, L"\nCreate a new issue with this report at %S.\n\n", BUILD_ISSUES_LINK_STRING_LITERAL); +#else + buflen += wnsprintfW(buffer + buflen, ArrayCount(buffer) - buflen, + L"\nPress Ctrl+C to copy this text to clipboard, then create a new issue at\n" + L"%S\n\n", BUILD_ISSUES_LINK_STRING_LITERAL, BUILD_ISSUES_LINK_STRING_LITERAL); +#endif + buflen += wnsprintfW(buffer + buflen, ArrayCount(buffer) - buflen, L"Call stack:\n"); + + U64 frame_offset = 0; + + if (frame.AddrPC.Offset == 0) + { + // if IP address is 0 then most likely we have called indirectly on NULL function pointer + // which means no useful stack unwinding will happen, because there's no unwind info for address 0 + // but we can try reading 8 bytes of return address from stack, and start unwinding there + + ULONG_PTR hi, lo; + GetCurrentThreadStackLimits(&lo, &hi); + if (frame.AddrStack.Offset >= lo && frame.AddrStack.Offset <= hi - sizeof(void*)) + { + frame.AddrPC.Offset = *(DWORD64*)frame.AddrStack.Offset - 1; + frame.AddrStack.Offset += sizeof(void*); +#if defined(_M_AMD64) + context.Rip = frame.AddrPC.Offset; + context.Rsp = frame.AddrStack.Offset; +#elif defined(_M_ARM64) + context.Pc = frame.AddrPC.Offset; + context.Sp = frame.AddrStack.Offset; +#endif + } + + buflen += wnsprintfW(buffer + buflen, ArrayCount(buffer) - buflen, L"1. [NULL]\n"); + frame_offset = 1; + } + + for(U32 idx=0; ;idx++) + { + const U32 max_frames = 32; + if(idx == max_frames) + { + buflen += wnsprintfW(buffer + buflen, ArrayCount(buffer) - buflen, L"..."); + break; + } + + if(!dbg_StackWalk64(image_type, process, thread, &frame, &context, 0, dbg_SymFunctionTableAccess64, dbg_SymGetModuleBase64, 0)) + { + break; + } + + U64 address = frame.AddrPC.Offset; + if(address == 0) + { + break; + } + + buflen += wnsprintfW(buffer + buflen, ArrayCount(buffer) - buflen, L"%u. [0x%I64x]", frame_offset + idx + 1, address); + + struct { + SYMBOL_INFOW info; + WCHAR name[MAX_SYM_NAME]; + } symbol = {0}; + + symbol.info.SizeOfStruct = sizeof(symbol.info); + symbol.info.MaxNameLen = MAX_SYM_NAME; + + DWORD64 displacement = 0; + if(dbg_SymFromAddrW(process, address, &displacement, &symbol.info)) + { + buflen += wnsprintfW(buffer + buflen, ArrayCount(buffer) - buflen, L" %s +%u", symbol.info.Name, (DWORD)displacement); + + IMAGEHLP_LINEW64 line = {0}; + line.SizeOfStruct = sizeof(line); + + DWORD line_displacement = 0; + if(dbg_SymGetLineFromAddrW64(process, address, &line_displacement, &line)) + { + buflen += wnsprintfW(buffer + buflen, ArrayCount(buffer) - buflen, L", %s line %u", PathFindFileNameW(line.FileName), line.LineNumber); + } + } + else + { + IMAGEHLP_MODULEW64 module = {0}; + module.SizeOfStruct = sizeof(module); + if(dbg_SymGetModuleInfoW64(process, address, &module)) + { + buflen += wnsprintfW(buffer + buflen, ArrayCount(buffer) - buflen, L" %s", module.ModuleName); + } + } + + buflen += wnsprintfW(buffer + buflen, ArrayCount(buffer) - buflen, L"\n"); + } + } + } + } + } + + buflen += wnsprintfW(buffer + buflen, ArrayCount(buffer) - buflen, L"\nVersion: %S%S", BUILD_VERSION_STRING_LITERAL, BUILD_GIT_HASH_STRING_LITERAL_APPEND); + + B32 generate_crash_dump = win32_g_gen_dump; +#if BUILD_CONSOLE_INTERFACE + fwprintf(stderr, L"\n--- Fatal Exception ---\n"); + fwprintf(stderr, L"%s\n\n", buffer); +#else + int selected_button = 0; + TASKDIALOG_BUTTON generate_dump = {1, L"Generate Crash Dump File"}; + TASKDIALOGCONFIG dialog = {0}; + dialog.cbSize = sizeof(dialog); + dialog.dwFlags = TDF_SIZE_TO_CONTENT | TDF_ENABLE_HYPERLINKS | TDF_ALLOW_DIALOG_CANCELLATION; + dialog.pszMainIcon = TD_ERROR_ICON; + dialog.dwCommonButtons = TDCBF_CLOSE_BUTTON; + dialog.pszWindowTitle = L"Fatal Exception"; + dialog.pszContent = buffer; + dialog.pfCallback = &win32_dialog_callback; + dialog.cButtons = 1; + dialog.pButtons = &generate_dump; + TaskDialogIndirect(&dialog, &selected_button, 0, 0); + generate_crash_dump = (selected_button == generate_dump.nButtonID); +#endif + + if(dbg_MiniDumpWriteDump && generate_crash_dump) + { + WCHAR dump_file_path[MAX_PATH] = {0}; + SHGetFolderPathW(0, CSIDL_DESKTOP, 0, 0, dump_file_path); + PathAppendW(dump_file_path, L"raddbg_crash_dump.dmp"); + HANDLE file = CreateFileW(dump_file_path, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0); + if (file != INVALID_HANDLE_VALUE) + { + MINIDUMP_EXCEPTION_INFORMATION info = {0}; + info.ThreadId = GetCurrentThreadId(); + info.ExceptionPointers = exception_ptrs; + info.ClientPointers = FALSE; + BOOL dump_successful = dbg_MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), file, MiniDumpNormal, &info, 0, 0); + CloseHandle(file); + + if (dump_successful) + { +#if !BUILD_CONSOLE_INTERFACE + // opens explorer and selects file + SFGAOF flags = 0; + PIDLIST_ABSOLUTE list = 0; + if (SUCCEEDED(SHParseDisplayName(dump_file_path, NULL, &list, 0, &flags))) + { + SHOpenFolderAndSelectItems(list, 0, NULL, 0); + CoTaskMemFree(list); + } +#endif + } + } + } + + ExitProcess(1); +} + +#undef OS_WINDOWS // shlwapi uses its own OS_WINDOWS include inside +#define OS_WINDOWS 1 + +internal void +w32_entry_point_caller(int argc, WCHAR **wargv) +{ + SetUnhandledExceptionFilter(&win32_exception_filter); + + //- rjf: dynamically load windows functions which are not guaranteed + // in all SDKs + { + HMODULE module = LoadLibraryA("kernel32.dll"); + w32_SetThreadDescription_func = (W32_SetThreadDescription_Type *)GetProcAddress(module, "SetThreadDescription"); + FreeLibrary(module); + } + + //- rjf: try to allow large pages if we can + B32 large_pages_allowed = 0; + { + HANDLE token; + if(OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token)) + { + LUID luid; + if(LookupPrivilegeValue(0, SE_LOCK_MEMORY_NAME, &luid)) + { + TOKEN_PRIVILEGES priv; + priv.PrivilegeCount = 1; + priv.Privileges[0].Luid = luid; + priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; + large_pages_allowed = !!AdjustTokenPrivileges(token, 0, &priv, sizeof(priv), 0, 0); + } + CloseHandle(token); + } + } + + //- rjf: get RIO extension function table + { + // NOTE(mmozeiko): need to get function pointers to RIO functions, and that requires dummy socket + WSADATA WinSockData; + WSAStartup(MAKEWORD(2, 2), &WinSockData); + GUID guid = WSAID_MULTIPLE_RIO; + DWORD rio_byte = 0; + SOCKET Sock = socket(AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP); + WSAIoctl(Sock, SIO_GET_MULTIPLE_EXTENSION_FUNCTION_POINTER, &guid, sizeof(guid), (void**)&w32_rio_functions, sizeof(w32_rio_functions), &rio_byte, 0, 0); + closesocket(Sock); + } + + //- rjf: get system info + SYSTEM_INFO sysinfo = {0}; + GetSystemInfo(&sysinfo); + + //- rjf: set up non-dynamically-alloc'd state + // + // (we need to set up some basics before this layer can supply + // memory allocation primitives) + { + os_w32_state.microsecond_resolution = 1; + LARGE_INTEGER large_int_resolution; + if(QueryPerformanceFrequency(&large_int_resolution)) + { + os_w32_state.microsecond_resolution = large_int_resolution.QuadPart; + } + } + { + SystemInfo *info = &os_w32_state.system_info; + info->logical_processor_count = (U64)sysinfo.dwNumberOfProcessors; + info->page_size = sysinfo.dwPageSize; + info->large_page_size = GetLargePageMinimum(); + info->allocation_granularity = sysinfo.dwAllocationGranularity; + } + { + ProcessInfo *info = &os_w32_state.process_info; + info->large_pages_allowed = large_pages_allowed; + info->pid = GetCurrentProcessId(); + } + + //- rjf: extract arguments + Arena *args_arena = arena_alloc(.reserve_size = MB(1), .commit_size = KB(32)); + char **argv = push_array(args_arena, char *, argc); + for(int i = 0; i < argc; i += 1) + { + String16 arg16 = str16_cstring((U16 *)wargv[i]); + String8 arg8 = str8_from_16(args_arena, arg16); + if(str8_match(arg8, str8_lit("--quiet"), StringMatchFlag_CaseInsensitive) || + str8_match(arg8, str8_lit("-quiet"), StringMatchFlag_CaseInsensitive)) + { + win32_g_is_quiet = 1; + } + if(str8_match(arg8, str8_lit("--large_pages"), StringMatchFlag_CaseInsensitive) || + str8_match(arg8, str8_lit("-large_pages"), StringMatchFlag_CaseInsensitive)) + { + arena_default_flags = ArenaFlag_LargePages; + arena_default_reserve_size = Max(MB(64), os_w32_state.system_info.large_page_size); + arena_default_commit_size = arena_default_reserve_size; + } + if(str8_match(arg8, str8_lit("--gen_crash_dump"), StringMatchFlag_CaseInsensitive) || + str8_match(arg8, str8_lit("-gen_crash_dump"), StringMatchFlag_CaseInsensitive)) + { + win32_g_gen_dump = 1; + } + argv[i] = (char *)arg8.str; + } + + //- rjf: set up thread context + TCTX *tctx = tctx_alloc(); + tctx_select(tctx); + + //- rjf: set up dynamically-alloc'd state + Arena *arena = arena_alloc(); + { + os_w32_state.arena = arena; + { + SystemInfo *info = &os_w32_state.system_info; + U8 buffer[MAX_COMPUTERNAME_LENGTH + 1] = {0}; + DWORD size = MAX_COMPUTERNAME_LENGTH + 1; + if(GetComputerNameA((char*)buffer, &size)) + { + info->machine_name = push_str8_copy(arena, str8(buffer, size)); + } + } + } + { + ProcessInfo *info = &os_w32_state.process_info; + { + Temp scratch = scratch_begin(0, 0); + DWORD size = KB(32); + U16 *buffer = push_array_no_zero(scratch.arena, U16, size); + DWORD length = GetModuleFileNameW(0, (WCHAR*)buffer, size); + String8 name8 = str8_from_16(scratch.arena, str16(buffer, length)); + String8 name_chopped = str8_chop_last_slash(name8); + info->binary_path = push_str8_copy(arena, name_chopped); + scratch_end(scratch); + } + info->initial_path = get_current_path(arena); + { + Temp scratch = scratch_begin(0, 0); + U64 size = KB(32); + U16 *buffer = push_array_no_zero(scratch.arena, U16, size); + if(SUCCEEDED(SHGetFolderPathW(0, CSIDL_APPDATA, 0, 0, (WCHAR*)buffer))) + { + info->user_program_data_path = str8_from_16(arena, str16_cstring(buffer)); + } + scratch_end(scratch); + } + { + WCHAR *this_proc_env = GetEnvironmentStringsW(); + U64 start_idx = 0; + for(U64 idx = 0;; idx += 1) + { + if(this_proc_env[idx] == 0) + { + if(start_idx == idx) + { + break; + } + else + { + String16 string16 = str16((U16 *)this_proc_env + start_idx, idx - start_idx); + String8 string = str8_from_16(arena, string16); + str8_list_push(arena, &info->environment, string); + start_idx = idx+1; + } + } + } + } + } + + //- rjf: set up entity storage + InitializeCriticalSection(&os_w32_state.entity_mutex); + os_w32_state.entity_arena = arena_alloc(); + + //- rjf: call into "real" entry point + main_thread_base_entry_point(argc, argv); +} + +#if BUILD_CONSOLE_INTERFACE +int wmain(int argc, WCHAR **argv) +{ + w32_entry_point_caller(argc, argv); + return 0; +} +#else +int wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nShowCmd) +{ + CoInitializeEx(0, COINIT_APARTMENTTHREADED); + w32_entry_point_caller(__argc, __wargv); + return 0; +} +#endif diff --git a/src/os/core/win32/os_core_win32.h b/src/win32/base/win32_base.h similarity index 89% rename from src/os/core/win32/os_core_win32.h rename to src/win32/base/win32_base.h index a15a223c..f03113ee 100644 --- a/src/os/core/win32/os_core_win32.h +++ b/src/win32/base/win32_base.h @@ -1,126 +1,126 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -#ifndef OS_CORE_WIN32_H -#define OS_CORE_WIN32_H - -//////////////////////////////// -//~ rjf: Includes / Libraries - -#include -#include -#include -#include -#include -#include -#include -#include -#pragma comment(lib, "user32") -#pragma comment(lib, "ole32") -#pragma comment(lib, "shell32") -#pragma comment(lib, "advapi32") -#pragma comment(lib, "rpcrt4") -#pragma comment(lib, "shlwapi") -#pragma comment(lib, "comctl32") -#pragma comment(lib, "ws2_32") -#pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") // this is required for loading correct comctl32 dll file - -//////////////////////////////// -//~ rjf: File Iterator Types - -typedef struct OS_W32_FileIter OS_W32_FileIter; -struct OS_W32_FileIter -{ - HANDLE handle; - WIN32_FIND_DATAW find_data; - B32 is_volume_iter; - String8Array drive_strings; - U64 drive_strings_iter_idx; -}; -StaticAssert(sizeof(Member(OS_FileIter, memory)) >= sizeof(OS_W32_FileIter), file_iter_memory_size); - -//////////////////////////////// -//~ rjf: Entity Types - -typedef enum OS_W32_EntityKind -{ - OS_W32_EntityKind_Null, - OS_W32_EntityKind_Thread, - OS_W32_EntityKind_Mutex, - OS_W32_EntityKind_RWMutex, - OS_W32_EntityKind_ConditionVariable, - OS_W32_EntityKind_Barrier, -} -OS_W32_EntityKind; - -typedef struct OS_W32_Entity OS_W32_Entity; -struct OS_W32_Entity -{ - OS_W32_Entity *next; - OS_W32_EntityKind kind; - union - { - struct - { - ThreadEntryPointFunctionType *func; - void *ptr; - HANDLE handle; - DWORD tid; - } thread; - CRITICAL_SECTION mutex; - SRWLOCK rw_mutex; - CONDITION_VARIABLE cv; - SYNCHRONIZATION_BARRIER sb; - }; -}; - -//////////////////////////////// -//~ rjf: State - -typedef struct OS_W32_State OS_W32_State; -struct OS_W32_State -{ - Arena *arena; - - // rjf: info - OS_SystemInfo system_info; - OS_ProcessInfo process_info; - U64 microsecond_resolution; - - // rjf: entity storage - CRITICAL_SECTION entity_mutex; - Arena *entity_arena; - OS_W32_Entity *entity_free; -}; - -//////////////////////////////// -//~ rjf: Globals - -global OS_W32_State os_w32_state = {0}; - -//////////////////////////////// -//~ rjf: File Info Conversion Helpers - -internal FilePropertyFlags os_w32_file_property_flags_from_dwFileAttributes(DWORD dwFileAttributes); -internal void os_w32_file_properties_from_attribute_data(FileProperties *properties, WIN32_FILE_ATTRIBUTE_DATA *attributes); - -//////////////////////////////// -//~ rjf: Time Conversion Helpers - -internal void os_w32_date_time_from_system_time(DateTime *out, SYSTEMTIME *in); -internal void os_w32_system_time_from_date_time(SYSTEMTIME *out, DateTime *in); -internal void os_w32_dense_time_from_file_time(DenseTime *out, FILETIME *in); -internal U32 os_w32_sleep_ms_from_endt_us(U64 endt_us); - -//////////////////////////////// -//~ rjf: Entity Functions - -internal OS_W32_Entity *os_w32_entity_alloc(OS_W32_EntityKind kind); -internal void os_w32_entity_release(OS_W32_Entity *entity); - -//////////////////////////////// -//~ rjf: Thread Entry Point - -internal DWORD os_w32_thread_entry_point(void *ptr); - -#endif // OS_CORE_WIN32_H +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef WIN32_BASE_H +#define WIN32_BASE_H + +//////////////////////////////// +//~ rjf: Includes / Libraries + +#include +#include +#include +#include +#include +#include +#include +#include +#pragma comment(lib, "user32") +#pragma comment(lib, "ole32") +#pragma comment(lib, "shell32") +#pragma comment(lib, "advapi32") +#pragma comment(lib, "rpcrt4") +#pragma comment(lib, "shlwapi") +#pragma comment(lib, "comctl32") +#pragma comment(lib, "ws2_32") +#pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") // this is required for loading correct comctl32 dll file + +//////////////////////////////// +//~ rjf: File Iterator Types + +typedef struct OS_W32_FileIter OS_W32_FileIter; +struct OS_W32_FileIter +{ + HANDLE handle; + WIN32_FIND_DATAW find_data; + B32 is_volume_iter; + String8Array drive_strings; + U64 drive_strings_iter_idx; +}; +StaticAssert(sizeof(Member(FileIter, memory)) >= sizeof(OS_W32_FileIter), file_iter_memory_size); + +//////////////////////////////// +//~ rjf: Entity Types + +typedef enum OS_W32_EntityKind +{ + OS_W32_EntityKind_Null, + OS_W32_EntityKind_Thread, + OS_W32_EntityKind_Mutex, + OS_W32_EntityKind_RWMutex, + OS_W32_EntityKind_ConditionVariable, + OS_W32_EntityKind_Barrier, +} +OS_W32_EntityKind; + +typedef struct OS_W32_Entity OS_W32_Entity; +struct OS_W32_Entity +{ + OS_W32_Entity *next; + OS_W32_EntityKind kind; + union + { + struct + { + ThreadEntryPointFunctionType *func; + void *ptr; + HANDLE handle; + DWORD tid; + } thread; + CRITICAL_SECTION mutex; + SRWLOCK rw_mutex; + CONDITION_VARIABLE cv; + SYNCHRONIZATION_BARRIER sb; + }; +}; + +//////////////////////////////// +//~ rjf: State + +typedef struct OS_W32_State OS_W32_State; +struct OS_W32_State +{ + Arena *arena; + + // rjf: info + SystemInfo system_info; + ProcessInfo process_info; + U64 microsecond_resolution; + + // rjf: entity storage + CRITICAL_SECTION entity_mutex; + Arena *entity_arena; + OS_W32_Entity *entity_free; +}; + +//////////////////////////////// +//~ rjf: Globals + +global OS_W32_State os_w32_state = {0}; + +//////////////////////////////// +//~ rjf: File Info Conversion Helpers + +internal FilePropertyFlags os_w32_file_property_flags_from_dwFileAttributes(DWORD dwFileAttributes); +internal void os_w32_file_properties_from_attribute_data(FileProperties *properties, WIN32_FILE_ATTRIBUTE_DATA *attributes); + +//////////////////////////////// +//~ rjf: Time Conversion Helpers + +internal void os_w32_date_time_from_system_time(DateTime *out, SYSTEMTIME *in); +internal void os_w32_system_time_from_date_time(SYSTEMTIME *out, DateTime *in); +internal void os_w32_dense_time_from_file_time(DenseTime *out, FILETIME *in); +internal U32 os_w32_sleep_ms_from_endt_us(U64 endt_us); + +//////////////////////////////// +//~ rjf: Entity Functions + +internal OS_W32_Entity *os_w32_entity_alloc(OS_W32_EntityKind kind); +internal void os_w32_entity_release(OS_W32_Entity *entity); + +//////////////////////////////// +//~ rjf: Thread Entry Point + +internal DWORD os_w32_thread_entry_point(void *ptr); + +#endif // WIN32_BASE_H diff --git a/src/x64/generated/x64.meta.c b/src/x64/generated/x64.meta.c new file mode 100644 index 00000000..bcfabd59 --- /dev/null +++ b/src/x64/generated/x64.meta.c @@ -0,0 +1,780 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//- GENERATED CODE + +C_LINKAGE_BEGIN +B8 x64_reg_code_is_vector_table[189] = +{ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +1, +}; + +String8 x64_reg_code_name_table[189] = +{ +str8_lit_comp("nil"), +str8_lit_comp("rax"), +str8_lit_comp("rcx"), +str8_lit_comp("rdx"), +str8_lit_comp("rbx"), +str8_lit_comp("rsp"), +str8_lit_comp("rbp"), +str8_lit_comp("rsi"), +str8_lit_comp("rdi"), +str8_lit_comp("r8"), +str8_lit_comp("r9"), +str8_lit_comp("r10"), +str8_lit_comp("r11"), +str8_lit_comp("r12"), +str8_lit_comp("r13"), +str8_lit_comp("r14"), +str8_lit_comp("r15"), +str8_lit_comp("fsbase"), +str8_lit_comp("gsbase"), +str8_lit_comp("rip"), +str8_lit_comp("rflags"), +str8_lit_comp("dr0"), +str8_lit_comp("dr1"), +str8_lit_comp("dr2"), +str8_lit_comp("dr3"), +str8_lit_comp("dr4"), +str8_lit_comp("dr5"), +str8_lit_comp("dr6"), +str8_lit_comp("dr7"), +str8_lit_comp("st0"), +str8_lit_comp("st1"), +str8_lit_comp("st2"), +str8_lit_comp("st3"), +str8_lit_comp("st4"), +str8_lit_comp("st5"), +str8_lit_comp("st6"), +str8_lit_comp("st7"), +str8_lit_comp("fcw"), +str8_lit_comp("fsw"), +str8_lit_comp("ftw"), +str8_lit_comp("fop"), +str8_lit_comp("fcs"), +str8_lit_comp("fds"), +str8_lit_comp("fip"), +str8_lit_comp("fdp"), +str8_lit_comp("mxcsr"), +str8_lit_comp("mxcsr_mask"), +str8_lit_comp("ss"), +str8_lit_comp("cs"), +str8_lit_comp("ds"), +str8_lit_comp("es"), +str8_lit_comp("fs"), +str8_lit_comp("gs"), +str8_lit_comp("zmm0"), +str8_lit_comp("zmm1"), +str8_lit_comp("zmm2"), +str8_lit_comp("zmm3"), +str8_lit_comp("zmm4"), +str8_lit_comp("zmm5"), +str8_lit_comp("zmm6"), +str8_lit_comp("zmm7"), +str8_lit_comp("zmm8"), +str8_lit_comp("zmm9"), +str8_lit_comp("zmm10"), +str8_lit_comp("zmm11"), +str8_lit_comp("zmm12"), +str8_lit_comp("zmm13"), +str8_lit_comp("zmm14"), +str8_lit_comp("zmm15"), +str8_lit_comp("zmm16"), +str8_lit_comp("zmm17"), +str8_lit_comp("zmm18"), +str8_lit_comp("zmm19"), +str8_lit_comp("zmm20"), +str8_lit_comp("zmm21"), +str8_lit_comp("zmm22"), +str8_lit_comp("zmm23"), +str8_lit_comp("zmm24"), +str8_lit_comp("zmm25"), +str8_lit_comp("zmm26"), +str8_lit_comp("zmm27"), +str8_lit_comp("zmm28"), +str8_lit_comp("zmm29"), +str8_lit_comp("zmm30"), +str8_lit_comp("zmm31"), +str8_lit_comp("k0"), +str8_lit_comp("k1"), +str8_lit_comp("k2"), +str8_lit_comp("k3"), +str8_lit_comp("k4"), +str8_lit_comp("k5"), +str8_lit_comp("k6"), +str8_lit_comp("k7"), +str8_lit_comp("cetmsr"), +str8_lit_comp("cetssp"), +str8_lit_comp("eax"), +str8_lit_comp("ecx"), +str8_lit_comp("edx"), +str8_lit_comp("ebx"), +str8_lit_comp("esp"), +str8_lit_comp("ebp"), +str8_lit_comp("esi"), +str8_lit_comp("edi"), +str8_lit_comp("r8d"), +str8_lit_comp("r9d"), +str8_lit_comp("r10d"), +str8_lit_comp("r11d"), +str8_lit_comp("r12d"), +str8_lit_comp("r13d"), +str8_lit_comp("r14d"), +str8_lit_comp("r15d"), +str8_lit_comp("eflags"), +str8_lit_comp("ax"), +str8_lit_comp("cx"), +str8_lit_comp("dx"), +str8_lit_comp("bx"), +str8_lit_comp("si"), +str8_lit_comp("di"), +str8_lit_comp("sp"), +str8_lit_comp("bp"), +str8_lit_comp("ip"), +str8_lit_comp("r8w"), +str8_lit_comp("r9w"), +str8_lit_comp("r10w"), +str8_lit_comp("r11w"), +str8_lit_comp("r12w"), +str8_lit_comp("r13w"), +str8_lit_comp("r14w"), +str8_lit_comp("r15w"), +str8_lit_comp("al"), +str8_lit_comp("cl"), +str8_lit_comp("dl"), +str8_lit_comp("bl"), +str8_lit_comp("sil"), +str8_lit_comp("dil"), +str8_lit_comp("bpl"), +str8_lit_comp("spl"), +str8_lit_comp("r8b"), +str8_lit_comp("r9b"), +str8_lit_comp("r10b"), +str8_lit_comp("r11b"), +str8_lit_comp("r12b"), +str8_lit_comp("r13b"), +str8_lit_comp("r14b"), +str8_lit_comp("r15b"), +str8_lit_comp("ah"), +str8_lit_comp("ch"), +str8_lit_comp("dh"), +str8_lit_comp("bh"), +str8_lit_comp("xmm0"), +str8_lit_comp("xmm1"), +str8_lit_comp("xmm2"), +str8_lit_comp("xmm3"), +str8_lit_comp("xmm4"), +str8_lit_comp("xmm5"), +str8_lit_comp("xmm6"), +str8_lit_comp("xmm7"), +str8_lit_comp("xmm8"), +str8_lit_comp("xmm9"), +str8_lit_comp("xmm10"), +str8_lit_comp("xmm11"), +str8_lit_comp("xmm12"), +str8_lit_comp("xmm13"), +str8_lit_comp("xmm14"), +str8_lit_comp("xmm15"), +str8_lit_comp("ymm0"), +str8_lit_comp("ymm1"), +str8_lit_comp("ymm2"), +str8_lit_comp("ymm3"), +str8_lit_comp("ymm4"), +str8_lit_comp("ymm5"), +str8_lit_comp("ymm6"), +str8_lit_comp("ymm7"), +str8_lit_comp("ymm8"), +str8_lit_comp("ymm9"), +str8_lit_comp("ymm10"), +str8_lit_comp("ymm11"), +str8_lit_comp("ymm12"), +str8_lit_comp("ymm13"), +str8_lit_comp("ymm14"), +str8_lit_comp("ymm15"), +str8_lit_comp("mm0"), +str8_lit_comp("mm1"), +str8_lit_comp("mm2"), +str8_lit_comp("mm3"), +str8_lit_comp("mm4"), +str8_lit_comp("mm5"), +str8_lit_comp("mm6"), +str8_lit_comp("mm7"), +}; + +U8 x64_reg_code_base_table[189] = +{ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +X64_RegCode_rax, +X64_RegCode_rcx, +X64_RegCode_rdx, +X64_RegCode_rbx, +X64_RegCode_rsp, +X64_RegCode_rbp, +X64_RegCode_rsi, +X64_RegCode_rdi, +X64_RegCode_r8, +X64_RegCode_r9, +X64_RegCode_r10, +X64_RegCode_r11, +X64_RegCode_r12, +X64_RegCode_r13, +X64_RegCode_r14, +X64_RegCode_r15, +X64_RegCode_rflags, +X64_RegCode_rax, +X64_RegCode_rcx, +X64_RegCode_rdx, +X64_RegCode_rbx, +X64_RegCode_rsi, +X64_RegCode_rdi, +X64_RegCode_rsp, +X64_RegCode_rbp, +X64_RegCode_rip, +X64_RegCode_r8, +X64_RegCode_r9, +X64_RegCode_r10, +X64_RegCode_r11, +X64_RegCode_r12, +X64_RegCode_r13, +X64_RegCode_r14, +X64_RegCode_r15, +X64_RegCode_rax, +X64_RegCode_rcx, +X64_RegCode_rdx, +X64_RegCode_rbx, +X64_RegCode_rsi, +X64_RegCode_rdi, +X64_RegCode_rbp, +X64_RegCode_rsp, +X64_RegCode_r8, +X64_RegCode_r9, +X64_RegCode_r10, +X64_RegCode_r11, +X64_RegCode_r12, +X64_RegCode_r13, +X64_RegCode_r14, +X64_RegCode_r15, +X64_RegCode_rax, +X64_RegCode_rcx, +X64_RegCode_rdx, +X64_RegCode_rbx, +X64_RegCode_zmm0, +X64_RegCode_zmm1, +X64_RegCode_zmm2, +X64_RegCode_zmm3, +X64_RegCode_zmm4, +X64_RegCode_zmm5, +X64_RegCode_zmm6, +X64_RegCode_zmm7, +X64_RegCode_zmm8, +X64_RegCode_zmm9, +X64_RegCode_zmm10, +X64_RegCode_zmm11, +X64_RegCode_zmm12, +X64_RegCode_zmm13, +X64_RegCode_zmm14, +X64_RegCode_zmm15, +X64_RegCode_zmm0, +X64_RegCode_zmm1, +X64_RegCode_zmm2, +X64_RegCode_zmm3, +X64_RegCode_zmm4, +X64_RegCode_zmm5, +X64_RegCode_zmm6, +X64_RegCode_zmm7, +X64_RegCode_zmm8, +X64_RegCode_zmm9, +X64_RegCode_zmm10, +X64_RegCode_zmm11, +X64_RegCode_zmm12, +X64_RegCode_zmm13, +X64_RegCode_zmm14, +X64_RegCode_zmm15, +X64_RegCode_st0, +X64_RegCode_st1, +X64_RegCode_st2, +X64_RegCode_st3, +X64_RegCode_st4, +X64_RegCode_st5, +X64_RegCode_st6, +X64_RegCode_st7, +}; + +Rng1U16 x64_reg_code_rng_table[189] = +{ +{0}, +{(U16)OffsetOf(X64_RegBlock, rax), (U16)OffsetOf(X64_RegBlock, rax) + 8}, +{(U16)OffsetOf(X64_RegBlock, rcx), (U16)OffsetOf(X64_RegBlock, rcx) + 8}, +{(U16)OffsetOf(X64_RegBlock, rdx), (U16)OffsetOf(X64_RegBlock, rdx) + 8}, +{(U16)OffsetOf(X64_RegBlock, rbx), (U16)OffsetOf(X64_RegBlock, rbx) + 8}, +{(U16)OffsetOf(X64_RegBlock, rsp), (U16)OffsetOf(X64_RegBlock, rsp) + 8}, +{(U16)OffsetOf(X64_RegBlock, rbp), (U16)OffsetOf(X64_RegBlock, rbp) + 8}, +{(U16)OffsetOf(X64_RegBlock, rsi), (U16)OffsetOf(X64_RegBlock, rsi) + 8}, +{(U16)OffsetOf(X64_RegBlock, rdi), (U16)OffsetOf(X64_RegBlock, rdi) + 8}, +{(U16)OffsetOf(X64_RegBlock, r8), (U16)OffsetOf(X64_RegBlock, r8) + 8}, +{(U16)OffsetOf(X64_RegBlock, r9), (U16)OffsetOf(X64_RegBlock, r9) + 8}, +{(U16)OffsetOf(X64_RegBlock, r10), (U16)OffsetOf(X64_RegBlock, r10) + 8}, +{(U16)OffsetOf(X64_RegBlock, r11), (U16)OffsetOf(X64_RegBlock, r11) + 8}, +{(U16)OffsetOf(X64_RegBlock, r12), (U16)OffsetOf(X64_RegBlock, r12) + 8}, +{(U16)OffsetOf(X64_RegBlock, r13), (U16)OffsetOf(X64_RegBlock, r13) + 8}, +{(U16)OffsetOf(X64_RegBlock, r14), (U16)OffsetOf(X64_RegBlock, r14) + 8}, +{(U16)OffsetOf(X64_RegBlock, r15), (U16)OffsetOf(X64_RegBlock, r15) + 8}, +{(U16)OffsetOf(X64_RegBlock, fsbase), (U16)OffsetOf(X64_RegBlock, fsbase) + 8}, +{(U16)OffsetOf(X64_RegBlock, gsbase), (U16)OffsetOf(X64_RegBlock, gsbase) + 8}, +{(U16)OffsetOf(X64_RegBlock, rip), (U16)OffsetOf(X64_RegBlock, rip) + 8}, +{(U16)OffsetOf(X64_RegBlock, rflags), (U16)OffsetOf(X64_RegBlock, rflags) + 8}, +{(U16)OffsetOf(X64_RegBlock, dr0), (U16)OffsetOf(X64_RegBlock, dr0) + 8}, +{(U16)OffsetOf(X64_RegBlock, dr1), (U16)OffsetOf(X64_RegBlock, dr1) + 8}, +{(U16)OffsetOf(X64_RegBlock, dr2), (U16)OffsetOf(X64_RegBlock, dr2) + 8}, +{(U16)OffsetOf(X64_RegBlock, dr3), (U16)OffsetOf(X64_RegBlock, dr3) + 8}, +{(U16)OffsetOf(X64_RegBlock, dr4), (U16)OffsetOf(X64_RegBlock, dr4) + 8}, +{(U16)OffsetOf(X64_RegBlock, dr5), (U16)OffsetOf(X64_RegBlock, dr5) + 8}, +{(U16)OffsetOf(X64_RegBlock, dr6), (U16)OffsetOf(X64_RegBlock, dr6) + 8}, +{(U16)OffsetOf(X64_RegBlock, dr7), (U16)OffsetOf(X64_RegBlock, dr7) + 8}, +{(U16)OffsetOf(X64_RegBlock, st0), (U16)OffsetOf(X64_RegBlock, st0) + 10}, +{(U16)OffsetOf(X64_RegBlock, st1), (U16)OffsetOf(X64_RegBlock, st1) + 10}, +{(U16)OffsetOf(X64_RegBlock, st2), (U16)OffsetOf(X64_RegBlock, st2) + 10}, +{(U16)OffsetOf(X64_RegBlock, st3), (U16)OffsetOf(X64_RegBlock, st3) + 10}, +{(U16)OffsetOf(X64_RegBlock, st4), (U16)OffsetOf(X64_RegBlock, st4) + 10}, +{(U16)OffsetOf(X64_RegBlock, st5), (U16)OffsetOf(X64_RegBlock, st5) + 10}, +{(U16)OffsetOf(X64_RegBlock, st6), (U16)OffsetOf(X64_RegBlock, st6) + 10}, +{(U16)OffsetOf(X64_RegBlock, st7), (U16)OffsetOf(X64_RegBlock, st7) + 10}, +{(U16)OffsetOf(X64_RegBlock, fcw), (U16)OffsetOf(X64_RegBlock, fcw) + 2}, +{(U16)OffsetOf(X64_RegBlock, fsw), (U16)OffsetOf(X64_RegBlock, fsw) + 2}, +{(U16)OffsetOf(X64_RegBlock, ftw), (U16)OffsetOf(X64_RegBlock, ftw) + 1}, +{(U16)OffsetOf(X64_RegBlock, fop), (U16)OffsetOf(X64_RegBlock, fop) + 2}, +{(U16)OffsetOf(X64_RegBlock, fcs), (U16)OffsetOf(X64_RegBlock, fcs) + 2}, +{(U16)OffsetOf(X64_RegBlock, fds), (U16)OffsetOf(X64_RegBlock, fds) + 2}, +{(U16)OffsetOf(X64_RegBlock, fip), (U16)OffsetOf(X64_RegBlock, fip) + 8}, +{(U16)OffsetOf(X64_RegBlock, fdp), (U16)OffsetOf(X64_RegBlock, fdp) + 8}, +{(U16)OffsetOf(X64_RegBlock, mxcsr), (U16)OffsetOf(X64_RegBlock, mxcsr) + 4}, +{(U16)OffsetOf(X64_RegBlock, mxcsr_mask), (U16)OffsetOf(X64_RegBlock, mxcsr_mask) + 4}, +{(U16)OffsetOf(X64_RegBlock, ss), (U16)OffsetOf(X64_RegBlock, ss) + 2}, +{(U16)OffsetOf(X64_RegBlock, cs), (U16)OffsetOf(X64_RegBlock, cs) + 2}, +{(U16)OffsetOf(X64_RegBlock, ds), (U16)OffsetOf(X64_RegBlock, ds) + 2}, +{(U16)OffsetOf(X64_RegBlock, es), (U16)OffsetOf(X64_RegBlock, es) + 2}, +{(U16)OffsetOf(X64_RegBlock, fs), (U16)OffsetOf(X64_RegBlock, fs) + 2}, +{(U16)OffsetOf(X64_RegBlock, gs), (U16)OffsetOf(X64_RegBlock, gs) + 2}, +{(U16)OffsetOf(X64_RegBlock, zmm0), (U16)OffsetOf(X64_RegBlock, zmm0) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm1), (U16)OffsetOf(X64_RegBlock, zmm1) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm2), (U16)OffsetOf(X64_RegBlock, zmm2) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm3), (U16)OffsetOf(X64_RegBlock, zmm3) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm4), (U16)OffsetOf(X64_RegBlock, zmm4) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm5), (U16)OffsetOf(X64_RegBlock, zmm5) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm6), (U16)OffsetOf(X64_RegBlock, zmm6) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm7), (U16)OffsetOf(X64_RegBlock, zmm7) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm8), (U16)OffsetOf(X64_RegBlock, zmm8) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm9), (U16)OffsetOf(X64_RegBlock, zmm9) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm10), (U16)OffsetOf(X64_RegBlock, zmm10) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm11), (U16)OffsetOf(X64_RegBlock, zmm11) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm12), (U16)OffsetOf(X64_RegBlock, zmm12) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm13), (U16)OffsetOf(X64_RegBlock, zmm13) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm14), (U16)OffsetOf(X64_RegBlock, zmm14) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm15), (U16)OffsetOf(X64_RegBlock, zmm15) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm16), (U16)OffsetOf(X64_RegBlock, zmm16) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm17), (U16)OffsetOf(X64_RegBlock, zmm17) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm18), (U16)OffsetOf(X64_RegBlock, zmm18) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm19), (U16)OffsetOf(X64_RegBlock, zmm19) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm20), (U16)OffsetOf(X64_RegBlock, zmm20) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm21), (U16)OffsetOf(X64_RegBlock, zmm21) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm22), (U16)OffsetOf(X64_RegBlock, zmm22) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm23), (U16)OffsetOf(X64_RegBlock, zmm23) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm24), (U16)OffsetOf(X64_RegBlock, zmm24) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm25), (U16)OffsetOf(X64_RegBlock, zmm25) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm26), (U16)OffsetOf(X64_RegBlock, zmm26) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm27), (U16)OffsetOf(X64_RegBlock, zmm27) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm28), (U16)OffsetOf(X64_RegBlock, zmm28) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm29), (U16)OffsetOf(X64_RegBlock, zmm29) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm30), (U16)OffsetOf(X64_RegBlock, zmm30) + 64}, +{(U16)OffsetOf(X64_RegBlock, zmm31), (U16)OffsetOf(X64_RegBlock, zmm31) + 64}, +{(U16)OffsetOf(X64_RegBlock, k0), (U16)OffsetOf(X64_RegBlock, k0) + 8}, +{(U16)OffsetOf(X64_RegBlock, k1), (U16)OffsetOf(X64_RegBlock, k1) + 8}, +{(U16)OffsetOf(X64_RegBlock, k2), (U16)OffsetOf(X64_RegBlock, k2) + 8}, +{(U16)OffsetOf(X64_RegBlock, k3), (U16)OffsetOf(X64_RegBlock, k3) + 8}, +{(U16)OffsetOf(X64_RegBlock, k4), (U16)OffsetOf(X64_RegBlock, k4) + 8}, +{(U16)OffsetOf(X64_RegBlock, k5), (U16)OffsetOf(X64_RegBlock, k5) + 8}, +{(U16)OffsetOf(X64_RegBlock, k6), (U16)OffsetOf(X64_RegBlock, k6) + 8}, +{(U16)OffsetOf(X64_RegBlock, k7), (U16)OffsetOf(X64_RegBlock, k7) + 8}, +{(U16)OffsetOf(X64_RegBlock, cetmsr), (U16)OffsetOf(X64_RegBlock, cetmsr) + 8}, +{(U16)OffsetOf(X64_RegBlock, cetssp), (U16)OffsetOf(X64_RegBlock, cetssp) + 8}, +{(U16)OffsetOf(X64_RegBlock, rax) + 0, (U16)OffsetOf(X64_RegBlock, rax) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, rcx) + 0, (U16)OffsetOf(X64_RegBlock, rcx) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, rdx) + 0, (U16)OffsetOf(X64_RegBlock, rdx) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, rbx) + 0, (U16)OffsetOf(X64_RegBlock, rbx) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, rsp) + 0, (U16)OffsetOf(X64_RegBlock, rsp) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, rbp) + 0, (U16)OffsetOf(X64_RegBlock, rbp) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, rsi) + 0, (U16)OffsetOf(X64_RegBlock, rsi) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, rdi) + 0, (U16)OffsetOf(X64_RegBlock, rdi) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, r8) + 0, (U16)OffsetOf(X64_RegBlock, r8) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, r9) + 0, (U16)OffsetOf(X64_RegBlock, r9) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, r10) + 0, (U16)OffsetOf(X64_RegBlock, r10) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, r11) + 0, (U16)OffsetOf(X64_RegBlock, r11) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, r12) + 0, (U16)OffsetOf(X64_RegBlock, r12) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, r13) + 0, (U16)OffsetOf(X64_RegBlock, r13) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, r14) + 0, (U16)OffsetOf(X64_RegBlock, r14) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, r15) + 0, (U16)OffsetOf(X64_RegBlock, r15) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, rflags) + 0, (U16)OffsetOf(X64_RegBlock, rflags) + 0 + 4}, +{(U16)OffsetOf(X64_RegBlock, rax) + 0, (U16)OffsetOf(X64_RegBlock, rax) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, rcx) + 0, (U16)OffsetOf(X64_RegBlock, rcx) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, rdx) + 0, (U16)OffsetOf(X64_RegBlock, rdx) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, rbx) + 0, (U16)OffsetOf(X64_RegBlock, rbx) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, rsi) + 0, (U16)OffsetOf(X64_RegBlock, rsi) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, rdi) + 0, (U16)OffsetOf(X64_RegBlock, rdi) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, rsp) + 0, (U16)OffsetOf(X64_RegBlock, rsp) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, rbp) + 0, (U16)OffsetOf(X64_RegBlock, rbp) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, rip) + 0, (U16)OffsetOf(X64_RegBlock, rip) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, r8) + 0, (U16)OffsetOf(X64_RegBlock, r8) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, r9) + 0, (U16)OffsetOf(X64_RegBlock, r9) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, r10) + 0, (U16)OffsetOf(X64_RegBlock, r10) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, r11) + 0, (U16)OffsetOf(X64_RegBlock, r11) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, r12) + 0, (U16)OffsetOf(X64_RegBlock, r12) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, r13) + 0, (U16)OffsetOf(X64_RegBlock, r13) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, r14) + 0, (U16)OffsetOf(X64_RegBlock, r14) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, r15) + 0, (U16)OffsetOf(X64_RegBlock, r15) + 0 + 2}, +{(U16)OffsetOf(X64_RegBlock, rax) + 0, (U16)OffsetOf(X64_RegBlock, rax) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, rcx) + 0, (U16)OffsetOf(X64_RegBlock, rcx) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, rdx) + 0, (U16)OffsetOf(X64_RegBlock, rdx) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, rbx) + 0, (U16)OffsetOf(X64_RegBlock, rbx) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, rsi) + 0, (U16)OffsetOf(X64_RegBlock, rsi) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, rdi) + 0, (U16)OffsetOf(X64_RegBlock, rdi) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, rbp) + 0, (U16)OffsetOf(X64_RegBlock, rbp) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, rsp) + 0, (U16)OffsetOf(X64_RegBlock, rsp) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, r8) + 0, (U16)OffsetOf(X64_RegBlock, r8) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, r9) + 0, (U16)OffsetOf(X64_RegBlock, r9) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, r10) + 0, (U16)OffsetOf(X64_RegBlock, r10) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, r11) + 0, (U16)OffsetOf(X64_RegBlock, r11) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, r12) + 0, (U16)OffsetOf(X64_RegBlock, r12) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, r13) + 0, (U16)OffsetOf(X64_RegBlock, r13) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, r14) + 0, (U16)OffsetOf(X64_RegBlock, r14) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, r15) + 0, (U16)OffsetOf(X64_RegBlock, r15) + 0 + 1}, +{(U16)OffsetOf(X64_RegBlock, rax) + 1, (U16)OffsetOf(X64_RegBlock, rax) + 1 + 1}, +{(U16)OffsetOf(X64_RegBlock, rcx) + 1, (U16)OffsetOf(X64_RegBlock, rcx) + 1 + 1}, +{(U16)OffsetOf(X64_RegBlock, rdx) + 1, (U16)OffsetOf(X64_RegBlock, rdx) + 1 + 1}, +{(U16)OffsetOf(X64_RegBlock, rbx) + 1, (U16)OffsetOf(X64_RegBlock, rbx) + 1 + 1}, +{(U16)OffsetOf(X64_RegBlock, zmm0) + 0, (U16)OffsetOf(X64_RegBlock, zmm0) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm1) + 0, (U16)OffsetOf(X64_RegBlock, zmm1) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm2) + 0, (U16)OffsetOf(X64_RegBlock, zmm2) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm3) + 0, (U16)OffsetOf(X64_RegBlock, zmm3) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm4) + 0, (U16)OffsetOf(X64_RegBlock, zmm4) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm5) + 0, (U16)OffsetOf(X64_RegBlock, zmm5) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm6) + 0, (U16)OffsetOf(X64_RegBlock, zmm6) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm7) + 0, (U16)OffsetOf(X64_RegBlock, zmm7) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm8) + 0, (U16)OffsetOf(X64_RegBlock, zmm8) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm9) + 0, (U16)OffsetOf(X64_RegBlock, zmm9) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm10) + 0, (U16)OffsetOf(X64_RegBlock, zmm10) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm11) + 0, (U16)OffsetOf(X64_RegBlock, zmm11) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm12) + 0, (U16)OffsetOf(X64_RegBlock, zmm12) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm13) + 0, (U16)OffsetOf(X64_RegBlock, zmm13) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm14) + 0, (U16)OffsetOf(X64_RegBlock, zmm14) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm15) + 0, (U16)OffsetOf(X64_RegBlock, zmm15) + 0 + 16}, +{(U16)OffsetOf(X64_RegBlock, zmm0) + 0, (U16)OffsetOf(X64_RegBlock, zmm0) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm1) + 0, (U16)OffsetOf(X64_RegBlock, zmm1) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm2) + 0, (U16)OffsetOf(X64_RegBlock, zmm2) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm3) + 0, (U16)OffsetOf(X64_RegBlock, zmm3) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm4) + 0, (U16)OffsetOf(X64_RegBlock, zmm4) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm5) + 0, (U16)OffsetOf(X64_RegBlock, zmm5) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm6) + 0, (U16)OffsetOf(X64_RegBlock, zmm6) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm7) + 0, (U16)OffsetOf(X64_RegBlock, zmm7) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm8) + 0, (U16)OffsetOf(X64_RegBlock, zmm8) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm9) + 0, (U16)OffsetOf(X64_RegBlock, zmm9) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm10) + 0, (U16)OffsetOf(X64_RegBlock, zmm10) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm11) + 0, (U16)OffsetOf(X64_RegBlock, zmm11) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm12) + 0, (U16)OffsetOf(X64_RegBlock, zmm12) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm13) + 0, (U16)OffsetOf(X64_RegBlock, zmm13) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm14) + 0, (U16)OffsetOf(X64_RegBlock, zmm14) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, zmm15) + 0, (U16)OffsetOf(X64_RegBlock, zmm15) + 0 + 32}, +{(U16)OffsetOf(X64_RegBlock, st0) + 0, (U16)OffsetOf(X64_RegBlock, st0) + 0 + 8}, +{(U16)OffsetOf(X64_RegBlock, st1) + 0, (U16)OffsetOf(X64_RegBlock, st1) + 0 + 8}, +{(U16)OffsetOf(X64_RegBlock, st2) + 0, (U16)OffsetOf(X64_RegBlock, st2) + 0 + 8}, +{(U16)OffsetOf(X64_RegBlock, st3) + 0, (U16)OffsetOf(X64_RegBlock, st3) + 0 + 8}, +{(U16)OffsetOf(X64_RegBlock, st4) + 0, (U16)OffsetOf(X64_RegBlock, st4) + 0 + 8}, +{(U16)OffsetOf(X64_RegBlock, st5) + 0, (U16)OffsetOf(X64_RegBlock, st5) + 0 + 8}, +{(U16)OffsetOf(X64_RegBlock, st6) + 0, (U16)OffsetOf(X64_RegBlock, st6) + 0 + 8}, +{(U16)OffsetOf(X64_RegBlock, st7) + 0, (U16)OffsetOf(X64_RegBlock, st7) + 0 + 8}, +}; + +C_LINKAGE_END + diff --git a/src/x64/generated/x64.meta.h b/src/x64/generated/x64.meta.h new file mode 100644 index 00000000..f47e083c --- /dev/null +++ b/src/x64/generated/x64.meta.h @@ -0,0 +1,310 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//- GENERATED CODE + +#ifndef X64_META_H +#define X64_META_H + +typedef enum X64_RegCode +{ +X64_RegCode_nil, +X64_RegCode_rax, +X64_RegCode_rcx, +X64_RegCode_rdx, +X64_RegCode_rbx, +X64_RegCode_rsp, +X64_RegCode_rbp, +X64_RegCode_rsi, +X64_RegCode_rdi, +X64_RegCode_r8, +X64_RegCode_r9, +X64_RegCode_r10, +X64_RegCode_r11, +X64_RegCode_r12, +X64_RegCode_r13, +X64_RegCode_r14, +X64_RegCode_r15, +X64_RegCode_fsbase, +X64_RegCode_gsbase, +X64_RegCode_rip, +X64_RegCode_rflags, +X64_RegCode_dr0, +X64_RegCode_dr1, +X64_RegCode_dr2, +X64_RegCode_dr3, +X64_RegCode_dr4, +X64_RegCode_dr5, +X64_RegCode_dr6, +X64_RegCode_dr7, +X64_RegCode_st0, +X64_RegCode_st1, +X64_RegCode_st2, +X64_RegCode_st3, +X64_RegCode_st4, +X64_RegCode_st5, +X64_RegCode_st6, +X64_RegCode_st7, +X64_RegCode_fcw, +X64_RegCode_fsw, +X64_RegCode_ftw, +X64_RegCode_fop, +X64_RegCode_fcs, +X64_RegCode_fds, +X64_RegCode_fip, +X64_RegCode_fdp, +X64_RegCode_mxcsr, +X64_RegCode_mxcsr_mask, +X64_RegCode_ss, +X64_RegCode_cs, +X64_RegCode_ds, +X64_RegCode_es, +X64_RegCode_fs, +X64_RegCode_gs, +X64_RegCode_zmm0, +X64_RegCode_zmm1, +X64_RegCode_zmm2, +X64_RegCode_zmm3, +X64_RegCode_zmm4, +X64_RegCode_zmm5, +X64_RegCode_zmm6, +X64_RegCode_zmm7, +X64_RegCode_zmm8, +X64_RegCode_zmm9, +X64_RegCode_zmm10, +X64_RegCode_zmm11, +X64_RegCode_zmm12, +X64_RegCode_zmm13, +X64_RegCode_zmm14, +X64_RegCode_zmm15, +X64_RegCode_zmm16, +X64_RegCode_zmm17, +X64_RegCode_zmm18, +X64_RegCode_zmm19, +X64_RegCode_zmm20, +X64_RegCode_zmm21, +X64_RegCode_zmm22, +X64_RegCode_zmm23, +X64_RegCode_zmm24, +X64_RegCode_zmm25, +X64_RegCode_zmm26, +X64_RegCode_zmm27, +X64_RegCode_zmm28, +X64_RegCode_zmm29, +X64_RegCode_zmm30, +X64_RegCode_zmm31, +X64_RegCode_k0, +X64_RegCode_k1, +X64_RegCode_k2, +X64_RegCode_k3, +X64_RegCode_k4, +X64_RegCode_k5, +X64_RegCode_k6, +X64_RegCode_k7, +X64_RegCode_cetmsr, +X64_RegCode_cetssp, +X64_RegCode_eax, +X64_RegCode_ecx, +X64_RegCode_edx, +X64_RegCode_ebx, +X64_RegCode_esp, +X64_RegCode_ebp, +X64_RegCode_esi, +X64_RegCode_edi, +X64_RegCode_r8d, +X64_RegCode_r9d, +X64_RegCode_r10d, +X64_RegCode_r11d, +X64_RegCode_r12d, +X64_RegCode_r13d, +X64_RegCode_r14d, +X64_RegCode_r15d, +X64_RegCode_eflags, +X64_RegCode_ax, +X64_RegCode_cx, +X64_RegCode_dx, +X64_RegCode_bx, +X64_RegCode_si, +X64_RegCode_di, +X64_RegCode_sp, +X64_RegCode_bp, +X64_RegCode_ip, +X64_RegCode_r8w, +X64_RegCode_r9w, +X64_RegCode_r10w, +X64_RegCode_r11w, +X64_RegCode_r12w, +X64_RegCode_r13w, +X64_RegCode_r14w, +X64_RegCode_r15w, +X64_RegCode_al, +X64_RegCode_cl, +X64_RegCode_dl, +X64_RegCode_bl, +X64_RegCode_sil, +X64_RegCode_dil, +X64_RegCode_bpl, +X64_RegCode_spl, +X64_RegCode_r8b, +X64_RegCode_r9b, +X64_RegCode_r10b, +X64_RegCode_r11b, +X64_RegCode_r12b, +X64_RegCode_r13b, +X64_RegCode_r14b, +X64_RegCode_r15b, +X64_RegCode_ah, +X64_RegCode_ch, +X64_RegCode_dh, +X64_RegCode_bh, +X64_RegCode_xmm0, +X64_RegCode_xmm1, +X64_RegCode_xmm2, +X64_RegCode_xmm3, +X64_RegCode_xmm4, +X64_RegCode_xmm5, +X64_RegCode_xmm6, +X64_RegCode_xmm7, +X64_RegCode_xmm8, +X64_RegCode_xmm9, +X64_RegCode_xmm10, +X64_RegCode_xmm11, +X64_RegCode_xmm12, +X64_RegCode_xmm13, +X64_RegCode_xmm14, +X64_RegCode_xmm15, +X64_RegCode_ymm0, +X64_RegCode_ymm1, +X64_RegCode_ymm2, +X64_RegCode_ymm3, +X64_RegCode_ymm4, +X64_RegCode_ymm5, +X64_RegCode_ymm6, +X64_RegCode_ymm7, +X64_RegCode_ymm8, +X64_RegCode_ymm9, +X64_RegCode_ymm10, +X64_RegCode_ymm11, +X64_RegCode_ymm12, +X64_RegCode_ymm13, +X64_RegCode_ymm14, +X64_RegCode_ymm15, +X64_RegCode_mm0, +X64_RegCode_mm1, +X64_RegCode_mm2, +X64_RegCode_mm3, +X64_RegCode_mm4, +X64_RegCode_mm5, +X64_RegCode_mm6, +X64_RegCode_mm7, +X64_RegCode_COUNT, +} X64_RegCode; + +typedef struct X64_RegBlock X64_RegBlock; +struct X64_RegBlock +{ +U64 rax; +U64 rcx; +U64 rdx; +U64 rbx; +U64 rsp; +U64 rbp; +U64 rsi; +U64 rdi; +U64 r8; +U64 r9; +U64 r10; +U64 r11; +U64 r12; +U64 r13; +U64 r14; +U64 r15; +U64 fsbase; +U64 gsbase; +U64 rip; +U64 rflags; +U64 dr0; +U64 dr1; +U64 dr2; +U64 dr3; +U64 dr4; +U64 dr5; +U64 dr6; +U64 dr7; +U80 st0; +U80 st1; +U80 st2; +U80 st3; +U80 st4; +U80 st5; +U80 st6; +U80 st7; +U16 fcw; +U16 fsw; +U8 ftw; +U16 fop; +U16 fcs; +U16 fds; +U64 fip; +U64 fdp; +U32 mxcsr; +U32 mxcsr_mask; +U16 ss; +U16 cs; +U16 ds; +U16 es; +U16 fs; +U16 gs; +U512 zmm0; +U512 zmm1; +U512 zmm2; +U512 zmm3; +U512 zmm4; +U512 zmm5; +U512 zmm6; +U512 zmm7; +U512 zmm8; +U512 zmm9; +U512 zmm10; +U512 zmm11; +U512 zmm12; +U512 zmm13; +U512 zmm14; +U512 zmm15; +U512 zmm16; +U512 zmm17; +U512 zmm18; +U512 zmm19; +U512 zmm20; +U512 zmm21; +U512 zmm22; +U512 zmm23; +U512 zmm24; +U512 zmm25; +U512 zmm26; +U512 zmm27; +U512 zmm28; +U512 zmm29; +U512 zmm30; +U512 zmm31; +U64 k0; +U64 k1; +U64 k2; +U64 k3; +U64 k4; +U64 k5; +U64 k6; +U64 k7; +U64 cetmsr; +U64 cetssp; +}; + +C_LINKAGE_BEGIN +extern B8 x64_reg_code_is_vector_table[189]; +extern String8 x64_reg_code_name_table[189]; +extern U8 x64_reg_code_base_table[189]; +extern Rng1U16 x64_reg_code_rng_table[189]; + +C_LINKAGE_END + +#endif // X64_META_H diff --git a/src/x64/x64.c b/src/x64/x64.c index e099d9de..e1ee9e02 100644 --- a/src/x64/x64.c +++ b/src/x64/x64.c @@ -1,6 +1,14 @@ // Copyright (c) Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) +//////////////////////////////// +//~ rjf: Generated + +#include "x64/generated/x64.meta.c" + +//////////////////////////////// +//~ cpuid + internal void x64_cpuid(U32 leaf, U32 *eax, U32 *ebx, U32 *ecx, U32 *edx) { @@ -43,6 +51,9 @@ x64_cpuid_ex(U32 leaf, U32 sub_leaf, U32 *eax, U32 *ebx, U32 *ecx, U32 *edx) #endif } +//////////////////////////////// +//~ fxsave/xsave + internal B32 x64_is_xsave_supported(void) { @@ -114,6 +125,9 @@ x64_get_xsave_layout(U64 xcr0) return xsave_layout; } +//////////////////////////////// +//~ Debug Control Register + internal void x64_set_debug_break(U64 *drs, U64 trap_idx, U64 addr, U64 size, X64_BreakpointType bp_type, X64_DebugBreakType break_type) { @@ -181,4 +195,3 @@ x64_set_debug_break(U64 *drs, U64 trap_idx, U64 addr, U64 size, X64_BreakpointTy default: { InvalidPath; } } } - diff --git a/src/x64/x64.h b/src/x64/x64.h index 8a41a154..db5edf11 100644 --- a/src/x64/x64.h +++ b/src/x64/x64.h @@ -177,30 +177,35 @@ typedef enum X64_DebugControlFlags X64_DebugControlFlag_L1 = (1 << 2), X64_DebugControlFlag_L2 = (1 << 4), X64_DebugControlFlag_L3 = (1 << 6), - + X64_DebugControlFlag_G0 = (1 << 1), X64_DebugControlFlag_G1 = (1 << 3), X64_DebugControlFlag_G3 = (1 << 5), X64_DebugControlFlag_G4 = (1 << 7), - + X64_DebugControlFlag_LE = (1 << 8), X64_DebugControlFlag_GE = (1 << 9), - + X64_DebugControlFlag_RTM = (1 << 11), - + X64_DebugControlFlag_GD = (1 << 13), - + X64_DebugControlFlag_RW0 = (3 << 16), X64_DebugControlFlag_RW1 = (3 << 20), X64_DebugControlFlag_RW2 = (3 << 24), X64_DebugControlFlag_FW3 = (3 << 26), - + X64_DebugControlFlag_LEN0 = (3 << 18), X64_DebugControlFlag_LEN1 = (3 << 22), X64_DebugControlFlag_LEN2 = (3 << 26), X64_DebugControlFlag_LEN3 = (3 << 30), } X64_DebugControlFlags; +//////////////////////////////// +//~ rjf: Generated + +#include "x64/generated/x64.meta.h" + //////////////////////////////// //~ cpuid @@ -222,4 +227,3 @@ internal X64_XSaveLayout x64_get_xsave_layout(U64 xcr0); internal void x64_set_debug_break(U64 *drs, U64 trap_idx, U64 addr, U64 size, X64_BreakpointType bp_type, X64_DebugBreakType break_type); #endif // BASE_X64_H - diff --git a/src/x64/x64.mdesk b/src/x64/x64.mdesk new file mode 100644 index 00000000..9bae9a8d --- /dev/null +++ b/src/x64/x64.mdesk @@ -0,0 +1,231 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +@table(name base off size is_vector has_rdi has_dwarf) +X64_RegTable: +{ + {nil - 0 0 - x - } + {rax - 0 8 - x x } + {rcx - 0 8 - x x } + {rdx - 0 8 - x x } + {rbx - 0 8 - x x } + {rsp - 0 8 - x x } + {rbp - 0 8 - x x } + {rsi - 0 8 - x x } + {rdi - 0 8 - x x } + {r8 - 0 8 - x x } + {r9 - 0 8 - x x } + {r10 - 0 8 - x x } + {r11 - 0 8 - x x } + {r12 - 0 8 - x x } + {r13 - 0 8 - x x } + {r14 - 0 8 - x x } + {r15 - 0 8 - x x } + {fsbase - 0 8 - x x } + {gsbase - 0 8 - x x } + {rip - 0 8 - x x } + {rflags - 0 8 - x x } + {dr0 - 0 8 - x - } + {dr1 - 0 8 - x - } + {dr2 - 0 8 - x - } + {dr3 - 0 8 - x - } + {dr4 - 0 8 - x - } + {dr5 - 0 8 - x - } + {dr6 - 0 8 - x - } + {dr7 - 0 8 - x - } + {st0 - 0 10 - x x } + {st1 - 0 10 - x x } + {st2 - 0 10 - x x } + {st3 - 0 10 - x x } + {st4 - 0 10 - x x } + {st5 - 0 10 - x x } + {st6 - 0 10 - x x } + {st7 - 0 10 - x x } + {fcw - 0 2 - x - } + {fsw - 0 2 - x - } + {ftw - 0 1 - x - } + {fop - 0 2 - x - } + {fcs - 0 2 - x - } + {fds - 0 2 - x - } + {fip - 0 8 - x - } + {fdp - 0 8 - x - } + {mxcsr - 0 4 - x - } + {mxcsr_mask - 0 4 - x - } + {ss - 0 2 - x x } + {cs - 0 2 - x x } + {ds - 0 2 - x x } + {es - 0 2 - x x } + {fs - 0 2 - x x } + {gs - 0 2 - x x } + {zmm0 - 0 64 x x x } + {zmm1 - 0 64 x x x } + {zmm2 - 0 64 x x x } + {zmm3 - 0 64 x x x } + {zmm4 - 0 64 x x x } + {zmm5 - 0 64 x x x } + {zmm6 - 0 64 x x x } + {zmm7 - 0 64 x x x } + {zmm8 - 0 64 x x x } + {zmm9 - 0 64 x x x } + {zmm10 - 0 64 x x x } + {zmm11 - 0 64 x x x } + {zmm12 - 0 64 x x x } + {zmm13 - 0 64 x x x } + {zmm14 - 0 64 x x x } + {zmm15 - 0 64 x x x } + {zmm16 - 0 64 x x x } + {zmm17 - 0 64 x x x } + {zmm18 - 0 64 x x x } + {zmm19 - 0 64 x x x } + {zmm20 - 0 64 x x x } + {zmm21 - 0 64 x x x } + {zmm22 - 0 64 x x x } + {zmm23 - 0 64 x x x } + {zmm24 - 0 64 x x x } + {zmm25 - 0 64 x x x } + {zmm26 - 0 64 x x x } + {zmm27 - 0 64 x x x } + {zmm28 - 0 64 x x x } + {zmm29 - 0 64 x x x } + {zmm30 - 0 64 x x x } + {zmm31 - 0 64 x x x } + {k0 - 0 8 - x - } + {k1 - 0 8 - x - } + {k2 - 0 8 - x - } + {k3 - 0 8 - x - } + {k4 - 0 8 - x - } + {k5 - 0 8 - x - } + {k6 - 0 8 - x - } + {k7 - 0 8 - x - } + {cetmsr - 0 8 - x - } + {cetssp - 0 8 - x - } + //- + //- aliases + //- + {eax rax 0 4 - - - } + {ecx rcx 0 4 - - - } + {edx rdx 0 4 - - - } + {ebx rbx 0 4 - - - } + {esp rsp 0 4 - - - } + {ebp rbp 0 4 - - - } + {esi rsi 0 4 - - - } + {edi rdi 0 4 - - - } + {r8d r8 0 4 - - - } + {r9d r9 0 4 - - - } + {r10d r10 0 4 - - - } + {r11d r11 0 4 - - - } + {r12d r12 0 4 - - - } + {r13d r13 0 4 - - - } + {r14d r14 0 4 - - - } + {r15d r15 0 4 - - - } + {eflags rflags 0 4 - - - } + {ax rax 0 2 - - - } + {cx rcx 0 2 - - - } + {dx rdx 0 2 - - - } + {bx rbx 0 2 - - - } + {si rsi 0 2 - - - } + {di rdi 0 2 - - - } + {sp rsp 0 2 - - - } + {bp rbp 0 2 - - - } + {ip rip 0 2 - - - } + {r8w r8 0 2 - - - } + {r9w r9 0 2 - - - } + {r10w r10 0 2 - - - } + {r11w r11 0 2 - - - } + {r12w r12 0 2 - - - } + {r13w r13 0 2 - - - } + {r14w r14 0 2 - - - } + {r15w r15 0 2 - - - } + {al rax 0 1 - - - } + {cl rcx 0 1 - - - } + {dl rdx 0 1 - - - } + {bl rbx 0 1 - - - } + {sil rsi 0 1 - - - } + {dil rdi 0 1 - - - } + {bpl rbp 0 1 - - - } + {spl rsp 0 1 - - - } + {r8b r8 0 1 - - - } + {r9b r9 0 1 - - - } + {r10b r10 0 1 - - - } + {r11b r11 0 1 - - - } + {r12b r12 0 1 - - - } + {r13b r13 0 1 - - - } + {r14b r14 0 1 - - - } + {r15b r15 0 1 - - - } + {ah rax 1 1 - - - } + {ch rcx 1 1 - - - } + {dh rdx 1 1 - - - } + {bh rbx 1 1 - - - } + {xmm0 zmm0 0 16 x - - } + {xmm1 zmm1 0 16 x - - } + {xmm2 zmm2 0 16 x - - } + {xmm3 zmm3 0 16 x - - } + {xmm4 zmm4 0 16 x - - } + {xmm5 zmm5 0 16 x - - } + {xmm6 zmm6 0 16 x - - } + {xmm7 zmm7 0 16 x - - } + {xmm8 zmm8 0 16 x - - } + {xmm9 zmm9 0 16 x - - } + {xmm10 zmm10 0 16 x - - } + {xmm11 zmm11 0 16 x - - } + {xmm12 zmm12 0 16 x - - } + {xmm13 zmm13 0 16 x - - } + {xmm14 zmm14 0 16 x - - } + {xmm15 zmm15 0 16 x - - } + {ymm0 zmm0 0 32 x - - } + {ymm1 zmm1 0 32 x - - } + {ymm2 zmm2 0 32 x - - } + {ymm3 zmm3 0 32 x - - } + {ymm4 zmm4 0 32 x - - } + {ymm5 zmm5 0 32 x - - } + {ymm6 zmm6 0 32 x - - } + {ymm7 zmm7 0 32 x - - } + {ymm8 zmm8 0 32 x - - } + {ymm9 zmm9 0 32 x - - } + {ymm10 zmm10 0 32 x - - } + {ymm11 zmm11 0 32 x - - } + {ymm12 zmm12 0 32 x - - } + {ymm13 zmm13 0 32 x - - } + {ymm14 zmm14 0 32 x - - } + {ymm15 zmm15 0 32 x - - } + {mm0 st0 0 8 x - x } + {mm1 st1 0 8 x - x } + {mm2 st2 0 8 x - x } + {mm3 st3 0 8 x - x } + {mm4 st4 0 8 x - x } + {mm5 st5 0 8 x - x } + {mm6 st6 0 8 x - x } + {mm7 st7 0 8 x - x } +} + +@enum X64_RegCode: +{ + @expand(X64_RegTable a) `$(a.name)`, + COUNT, +} + +@struct X64_RegBlock: +{ + @expand(X64_RegTable a) `$(a.name != 'nil' && a.base == '-' -> 'U' .. a.size*8 .. ' ' .. a.name)`, +} + +@data(B8) x64_reg_code_is_vector_table: +{ + @expand(X64_RegTable a) `$(a.is_vector == 'x' -> '1')$(a.is_vector != 'x' -> '0')`; +} + +@data(String8) x64_reg_code_name_table: +{ + @expand(X64_RegTable a) `str8_lit_comp("$(a.name)")`; +} + +@data(U8) x64_reg_code_base_table: +{ + @expand(X64_RegTable a) `$(a.base != '-' -> "X64_RegCode_" .. a.base)$(a.base == '-' -> 0)`; +} + +@data(Rng1U16) x64_reg_code_rng_table: +{ + `{0}`, + @expand(X64_RegTable a) `$(a.name != 'nil' && a.base == '-'-> ("{(U16)OffsetOf(X64_RegBlock, " .. a.name .. "), (U16)OffsetOf(X64_RegBlock, " .. a.name .. ") + " .. a.size .. "}"))$(a.name != 'nil' && a.base != '-' -> ("{(U16)OffsetOf(X64_RegBlock, " .. a.base .. ") + " .. a.off .. ", (U16)OffsetOf(X64_RegBlock, " .. a.base .. ") + " .. a.off .. " + " .. a.size .. "}"))`, +}