From 640cf0d40113224af73e667bfb485d830054a877 Mon Sep 17 00:00:00 2001 From: York Jasper Niebuhr Date: Tue, 7 Apr 2026 23:31:14 +0200 Subject: [PATCH] Selfpatch typedefs --- selfpatch/src/env.c | 34 ++++----- selfpatch/src/env.h | 20 +++--- selfpatch/src/randomizer.c | 122 ++++++++++++++++---------------- selfpatch/src/randomizer.h | 16 ++--- selfpatch/src/selfpatch.c | 50 +++++++------ selfpatch/src/spslr_list.h | 52 +++++++------- selfpatch/src/spslr_list_link.h | 10 +-- selfpatch/src/spslr_types.h | 17 +++++ 8 files changed, 167 insertions(+), 154 deletions(-) create mode 100644 selfpatch/src/spslr_types.h diff --git a/selfpatch/src/env.c b/selfpatch/src/env.c index c2afed4..591366d 100644 --- a/selfpatch/src/env.c +++ b/selfpatch/src/env.c @@ -13,11 +13,11 @@ static int spslr_env_get_prot(void* addr, int* prot) { if (!f) return -1; - uintptr_t query = (uintptr_t)addr; + spslr_uintptr query = (spslr_uintptr)addr; char line[512]; while (fgets(line, sizeof(line), f)) { - uintptr_t start, end; + spslr_uintptr start, end; char perms[5]; if (sscanf(line, "%lx-%lx %4s", &start, &end, perms) != 3) @@ -43,14 +43,14 @@ static int spslr_env_get_prot(void* addr, int* prot) { return -1; } -static void spslr_env_poke_safe(void* dst, const void* src, uint32_t n) { +static void spslr_env_poke_safe(void* dst, const void* src, spslr_u32 n) { int original_prot; if (spslr_env_get_prot(dst, &original_prot)) spslr_env_panic("failed to get prot of text poke destination"); - uint64_t ptr_uint = (uint64_t)dst; - uint64_t ptr_page = ptr_uint & PAGE_MASK; - uint64_t prot_size = n + (ptr_uint - ptr_page); + spslr_u64 ptr_uint = (spslr_u64)dst; + spslr_u64 ptr_page = ptr_uint & PAGE_MASK; + spslr_u64 prot_size = n + (ptr_uint - ptr_page); int tmp_prot = original_prot | PROT_WRITE; @@ -68,23 +68,23 @@ void spslr_env_panic(const char* reason) { exit(1); } -void spslr_env_poke_text_8(void* dst, uint8_t value) { +void spslr_env_poke_text_8(void* dst, spslr_u8 value) { spslr_env_poke_safe(dst, &value, sizeof(value)); } -void spslr_env_poke_text_16(void* dst, uint16_t value) { +void spslr_env_poke_text_16(void* dst, spslr_u16 value) { spslr_env_poke_safe(dst, &value, sizeof(value)); } -void spslr_env_poke_text_32(void* dst, uint32_t value) { +void spslr_env_poke_text_32(void* dst, spslr_u32 value) { spslr_env_poke_safe(dst, &value, sizeof(value)); } -void spslr_env_poke_text_64(void* dst, uint64_t value) { +void spslr_env_poke_text_64(void* dst, spslr_u64 value) { spslr_env_poke_safe(dst, &value, sizeof(value)); } -void* spslr_env_malloc(uint32_t n) { +void* spslr_env_malloc(spslr_u32 n) { void* res = malloc(n); if (!res) spslr_env_panic("malloc failed"); @@ -96,26 +96,26 @@ void spslr_env_free(void* ptr) { free(ptr); } -void spslr_env_poke_data(void* dst, const void* src, uint32_t n) { +void spslr_env_poke_data(void* dst, const void* src, spslr_u32 n) { spslr_env_poke_safe(dst, src, n); } -void spslr_env_memset(void* dst, int v, uint32_t n) { +void spslr_env_memset(void* dst, int v, spslr_u32 n) { memset(dst, v, n); } -void spslr_env_memcpy(void* dst, const void* src, uint32_t n) { +void spslr_env_memcpy(void* dst, const void* src, spslr_u32 n) { memcpy(dst, src, n); } static int rand_initialized = 0; -uint32_t spslr_env_random_u32() { +spslr_u32 spslr_env_random_u32() { if (!rand_initialized) { - srand(time(NULL)); + srand(time(SPSLR_NULL)); rand_initialized = 1; } - return (uint32_t)rand(); + return (spslr_u32)rand(); } diff --git a/selfpatch/src/env.h b/selfpatch/src/env.h index b2916bd..00c1007 100644 --- a/selfpatch/src/env.h +++ b/selfpatch/src/env.h @@ -1,18 +1,18 @@ #ifndef SPSLR_ENV_H #define SPSLR_ENV_H -#include +#include "spslr_types.h" void spslr_env_panic(const char* reason); -void spslr_env_poke_text_8(void* dst, uint8_t value); -void spslr_env_poke_text_16(void* dst, uint16_t value); -void spslr_env_poke_text_32(void* dst, uint32_t value); -void spslr_env_poke_text_64(void* dst, uint64_t value); -void* spslr_env_malloc(uint32_t n); // Either return valid buffer or panic internally +void spslr_env_poke_text_8(void* dst, spslr_u8 value); +void spslr_env_poke_text_16(void* dst, spslr_u16 value); +void spslr_env_poke_text_32(void* dst, spslr_u32 value); +void spslr_env_poke_text_64(void* dst, spslr_u64 value); +void* spslr_env_malloc(spslr_u32 n); // Either return valid buffer or panic internally void spslr_env_free(void* ptr); -void spslr_env_poke_data(void* dst, const void* src, uint32_t n); -void spslr_env_memset(void* dst, int v, uint32_t n); -void spslr_env_memcpy(void* dst, const void* src, uint32_t n); -uint32_t spslr_env_random_u32(); +void spslr_env_poke_data(void* dst, const void* src, spslr_u32 n); +void spslr_env_memset(void* dst, int v, spslr_u32 n); +void spslr_env_memcpy(void* dst, const void* src, spslr_u32 n); +spslr_u32 spslr_env_random_u32(); #endif diff --git a/selfpatch/src/randomizer.c b/selfpatch/src/randomizer.c index d51a01c..e8d52bf 100644 --- a/selfpatch/src/randomizer.c +++ b/selfpatch/src/randomizer.c @@ -3,12 +3,10 @@ #include "spslr_list_link.h" #include "env.h" -#include - struct Field { - uint32_t offset; /* Final field offset -> fields[i].offset = offset of field i in final layout */ - uint32_t oidx; /* Original field idx -> fields[i].oidx = original position of field i in final layout */ - uint32_t fidx; /* Final field idx -> fields[i].fidx = randomized/final position of original field i */ + spslr_u32 offset; /* Final field offset -> fields[i].offset = offset of field i in final layout */ + spslr_u32 oidx; /* Original field idx -> fields[i].oidx = original position of field i in final layout */ + spslr_u32 fidx; /* Final field idx -> fields[i].fidx = randomized/final position of original field i */ }; static struct Field* fields; @@ -18,11 +16,11 @@ int spslr_randomizer_init() { if (!fields) return -1; - for (uint32_t tidx = 0; tidx < spslr_target_cnt; tidx++) { + for (spslr_u32 tidx = 0; tidx < spslr_target_cnt; tidx++) { const struct spslr_target* t = &spslr_targets[tidx]; - for (uint32_t fidx = 0; fidx < t->fieldcnt; fidx++) { - uint32_t gfidx = t->fieldoff + fidx; + for (spslr_u32 fidx = 0; fidx < t->fieldcnt; fidx++) { + spslr_u32 gfidx = t->fieldoff + fidx; const struct spslr_target_field* srcf = &spslr_target_fields[gfidx]; struct Field* dstf = &fields[gfidx]; @@ -41,10 +39,10 @@ void spslr_randomizer_clear() { return; spslr_env_free(fields); - fields = NULL; + fields = SPSLR_NULL; } -int spslr_randomizer_get_target(uint32_t target, uint32_t* size, uint32_t* fieldcnt) { +int spslr_randomizer_get_target(spslr_u32 target, spslr_u32* size, spslr_u32* fieldcnt) { if (target >= spslr_target_cnt) return -1; @@ -59,7 +57,7 @@ int spslr_randomizer_get_target(uint32_t target, uint32_t* size, uint32_t* field return 0; } -int spslr_randomizer_get_field(uint32_t target, uint32_t field, int field_idx_mode, +int spslr_randomizer_get_field(spslr_u32 target, spslr_u32 field, int field_idx_mode, struct spslr_randomizer_field_info* info) { if (target >= spslr_target_cnt) return -1; @@ -72,8 +70,8 @@ int spslr_randomizer_get_field(uint32_t target, uint32_t field, int field_idx_mo if (field >= t->fieldcnt) return -1; - const struct spslr_target_field* of = NULL; - const struct Field* rf = NULL; + const struct spslr_target_field* of = SPSLR_NULL; + const struct Field* rf = SPSLR_NULL; switch (field_idx_mode) { case SPSLR_RANDOMIZER_FIELD_IDX_MODE_ORIGINAL: @@ -100,38 +98,38 @@ int spslr_randomizer_get_field(uint32_t target, uint32_t field, int field_idx_mo // RANDOMIZATION CODE struct ShuffleRegion { - uint32_t begin; - uint32_t end; - uint32_t fill_begin; - uint32_t fill_end; + spslr_u32 begin; + spslr_u32 end; + spslr_u32 fill_begin; + spslr_u32 fill_end; }; -static uint32_t rand_u32(void); -static struct Field* get_rfield(uint32_t target, uint32_t final_idx); -static const struct spslr_target_field* get_ofield(uint32_t target, uint32_t orig_idx); -static void get_origin_region(uint32_t target, uint32_t final_idx, struct ShuffleRegion* region); -static int pick_shuffle_option(uint32_t target, uint32_t origin_final_idx, - const struct ShuffleRegion* origin, uint32_t alignment, uint32_t* selected); -static void do_swap(uint32_t target, uint32_t origin_final_idx, - const struct ShuffleRegion* origin_region, uint32_t new_offset); -static void shuffle_one_target(uint32_t target); -static void shuffle_target(uint32_t target); +static spslr_u32 rand_u32(void); +static struct Field* get_rfield(spslr_u32 target, spslr_u32 final_idx); +static const struct spslr_target_field* get_ofield(spslr_u32 target, spslr_u32 orig_idx); +static void get_origin_region(spslr_u32 target, spslr_u32 final_idx, struct ShuffleRegion* region); +static int pick_shuffle_option(spslr_u32 target, spslr_u32 origin_final_idx, + const struct ShuffleRegion* origin, spslr_u32 alignment, spslr_u32* selected); +static void do_swap(spslr_u32 target, spslr_u32 origin_final_idx, + const struct ShuffleRegion* origin_region, spslr_u32 new_offset); +static void shuffle_one_target(spslr_u32 target); +static void shuffle_target(spslr_u32 target); -static uint32_t rand_u32(void) { +static spslr_u32 rand_u32(void) { return spslr_env_random_u32(); } -static struct Field* get_rfield(uint32_t target, uint32_t final_idx) { +static struct Field* get_rfield(spslr_u32 target, spslr_u32 final_idx) { const struct spslr_target* t = &spslr_targets[target]; return &fields[t->fieldoff + final_idx]; } -static const struct spslr_target_field* get_ofield(uint32_t target, uint32_t orig_idx) { +static const struct spslr_target_field* get_ofield(spslr_u32 target, spslr_u32 orig_idx) { const struct spslr_target* t = &spslr_targets[target]; return &spslr_target_fields[t->fieldoff + orig_idx]; } -static void get_origin_region(uint32_t target, uint32_t final_idx, struct ShuffleRegion* region) { +static void get_origin_region(spslr_u32 target, spslr_u32 final_idx, struct ShuffleRegion* region) { const struct spslr_target* t = &spslr_targets[target]; const struct Field* rf = get_rfield(target, final_idx); const struct spslr_target_field* of = get_ofield(target, rf->oidx); @@ -155,20 +153,20 @@ static void get_origin_region(uint32_t target, uint32_t final_idx, struct Shuffl } } -static int option_is_valid(uint32_t target, uint32_t origin_final_idx, const struct ShuffleRegion* origin, uint32_t offset) { +static int option_is_valid(spslr_u32 target, spslr_u32 origin_final_idx, const struct ShuffleRegion* origin, spslr_u32 offset) { const struct spslr_target* t = &spslr_targets[target]; const struct spslr_target_field* origin_of = get_ofield(target, get_rfield(target, origin_final_idx)->oidx); // When placed at offset, field will occupy [offset, option_would_end) - uint32_t option_would_end = offset + origin_of->size; + spslr_u32 option_would_end = offset + origin_of->size; if (option_would_end > t->size) return 0; // Field may overlap with origin region. Moving field to offset truly frees: // [true_origin_region_begin, true_origin_region_end) - uint32_t true_origin_region_begin = origin->begin; - uint32_t true_origin_region_end = origin->end; + spslr_u32 true_origin_region_begin = origin->begin; + spslr_u32 true_origin_region_end = origin->end; if (offset <= origin->fill_begin && option_would_end > true_origin_region_begin) true_origin_region_begin = option_would_end; @@ -177,8 +175,8 @@ static int option_is_valid(uint32_t target, uint32_t origin_final_idx, const str true_origin_region_end = offset; // Iterate over fields in target region [offset, option_would_end] and see if they fit into true origin region - uint32_t origin_region_ptr = true_origin_region_begin; - for (uint32_t it = 0; it < t->fieldcnt; it++) { + spslr_u32 origin_region_ptr = true_origin_region_begin; + for (spslr_u32 it = 0; it < t->fieldcnt; it++) { const struct Field* rf = get_rfield(target, it); const struct spslr_target_field* of = get_ofield(target, rf->oidx); @@ -212,12 +210,12 @@ static int option_is_valid(uint32_t target, uint32_t origin_final_idx, const str return 1; } -static int pick_shuffle_option(uint32_t target, uint32_t origin_final_idx, const struct ShuffleRegion* origin, - uint32_t alignment, uint32_t* selected) { +static int pick_shuffle_option(spslr_u32 target, spslr_u32 origin_final_idx, const struct ShuffleRegion* origin, + spslr_u32 alignment, spslr_u32* selected) { const struct spslr_target* t = &spslr_targets[target]; - uint32_t seen = 0; + spslr_u32 seen = 0; - for (uint32_t offset = 0; offset < t->size; offset += alignment) { + for (spslr_u32 offset = 0; offset < t->size; offset += alignment) { if (!option_is_valid(target, origin_final_idx, origin, offset)) continue; @@ -230,21 +228,21 @@ static int pick_shuffle_option(uint32_t target, uint32_t origin_final_idx, const return seen ? 0 : -1; } -static void do_swap(uint32_t target, uint32_t origin_idx, - const struct ShuffleRegion* origin_region, uint32_t new_offset) { +static void do_swap(spslr_u32 target, spslr_u32 origin_idx, + const struct ShuffleRegion* origin_region, spslr_u32 new_offset) { const struct spslr_target* t = &spslr_targets[target]; int pulled = 0; - uint32_t option_fill_end = new_offset + (origin_region->fill_end - origin_region->fill_begin); + spslr_u32 option_fill_end = new_offset + (origin_region->fill_end - origin_region->fill_begin); - uint32_t true_origin_region_begin = origin_region->begin; + spslr_u32 true_origin_region_begin = origin_region->begin; if (new_offset <= origin_region->fill_begin && option_fill_end > true_origin_region_begin) true_origin_region_begin = option_fill_end; - uint32_t origin_oidx = get_rfield(target, origin_idx)->oidx; + spslr_u32 origin_oidx = get_rfield(target, origin_idx)->oidx; - uint32_t origin_region_ptr = true_origin_region_begin; - for (uint32_t it = 0; it < t->fieldcnt; it++) { + spslr_u32 origin_region_ptr = true_origin_region_begin; + for (spslr_u32 it = 0; it < t->fieldcnt; it++) { struct Field* itf = get_rfield(target, it); if (itf->oidx == origin_oidx) @@ -258,7 +256,7 @@ static void do_swap(uint32_t target, uint32_t origin_idx, if (itf->offset >= option_fill_end) break; - uint32_t falign = itof->alignment; + spslr_u32 falign = itof->alignment; if (origin_region_ptr % falign != 0) origin_region_ptr += falign - (origin_region_ptr % falign); @@ -280,19 +278,19 @@ static void do_swap(uint32_t target, uint32_t origin_idx, struct Field tmp = *get_rfield(target, it); if (origin_idx >= it) { - for (uint32_t pull_it = it + 1; pull_it <= origin_idx; pull_it++) + for (spslr_u32 pull_it = it + 1; pull_it <= origin_idx; pull_it++) *get_rfield(target, pull_it - 1) = *get_rfield(target, pull_it); *get_rfield(target, origin_idx) = tmp; get_rfield(target, origin_idx)->offset = origin_region_ptr; origin_region_ptr += get_ofield(target, get_rfield(target, origin_idx)->oidx)->size; } else { - for (uint32_t pull_it = it; pull_it > origin_idx + (uint32_t)pulled; pull_it--) + for (spslr_u32 pull_it = it; pull_it > origin_idx + (spslr_u32)pulled; pull_it--) *get_rfield(target, pull_it) = *get_rfield(target, pull_it - 1); - *get_rfield(target, origin_idx + (uint32_t)pulled) = tmp; - get_rfield(target, origin_idx + (uint32_t)pulled)->offset = origin_region_ptr; - origin_region_ptr += get_ofield(target, get_rfield(target, origin_idx + (uint32_t)pulled)->oidx)->size; + *get_rfield(target, origin_idx + (spslr_u32)pulled) = tmp; + get_rfield(target, origin_idx + (spslr_u32)pulled)->offset = origin_region_ptr; + origin_region_ptr += get_ofield(target, get_rfield(target, origin_idx + (spslr_u32)pulled)->oidx)->size; } } @@ -302,18 +300,18 @@ static void do_swap(uint32_t target, uint32_t origin_idx, /* * Rebuild original->final mapping for this target. */ - for (uint32_t final_idx = 0; final_idx < t->fieldcnt; final_idx++) { + for (spslr_u32 final_idx = 0; final_idx < t->fieldcnt; final_idx++) { struct Field* rf = get_rfield(target, final_idx); fields[t->fieldoff + rf->oidx].fidx = final_idx; } } -static void shuffle_one_target(uint32_t target) { +static void shuffle_one_target(spslr_u32 target) { const struct spslr_target* t = &spslr_targets[target]; if (t->fieldcnt == 0) return; - uint32_t origin_final_idx = rand_u32() % t->fieldcnt; + spslr_u32 origin_final_idx = rand_u32() % t->fieldcnt; struct Field* origin_rf = get_rfield(target, origin_final_idx); const struct spslr_target_field* origin_of = get_ofield(target, origin_rf->oidx); @@ -321,7 +319,7 @@ static void shuffle_one_target(uint32_t target) { return; struct ShuffleRegion origin_region; - uint32_t selected_option; + spslr_u32 selected_option; get_origin_region(target, origin_final_idx, &origin_region); @@ -332,11 +330,11 @@ static void shuffle_one_target(uint32_t target) { do_swap(target, origin_final_idx, &origin_region, selected_option); } -static void shuffle_target(uint32_t target) { +static void shuffle_target(spslr_u32 target) { const struct spslr_target* t = &spslr_targets[target]; - uint32_t shuffle_count = t->fieldcnt * 2; + spslr_u32 shuffle_count = t->fieldcnt * 2; - for (uint32_t i = 0; i < shuffle_count; i++) + for (spslr_u32 i = 0; i < shuffle_count; i++) shuffle_one_target(target); } @@ -344,7 +342,7 @@ int spslr_randomize() { if (!fields) return -1; - for (uint32_t tidx = 0; tidx < spslr_target_cnt; tidx++) + for (spslr_u32 tidx = 0; tidx < spslr_target_cnt; tidx++) shuffle_target(tidx); return 0; diff --git a/selfpatch/src/randomizer.h b/selfpatch/src/randomizer.h index d2bafaf..444c83d 100644 --- a/selfpatch/src/randomizer.h +++ b/selfpatch/src/randomizer.h @@ -1,25 +1,25 @@ #ifndef SPSLR_RANDOMIZER_H #define SPSLR_RANDOMIZER_H -#include +#include "spslr_types.h" #define SPSLR_RANDOMIZER_FIELD_IDX_MODE_ORIGINAL 1 #define SPSLR_RANDOMIZER_FIELD_IDX_MODE_FINAL 2 struct spslr_randomizer_field_info { - uint32_t size; - uint32_t offset; - uint32_t initial_offset; - uint32_t alignment; - uint32_t flags; + spslr_u32 size; + spslr_u32 offset; + spslr_u32 initial_offset; + spslr_u32 alignment; + spslr_u32 flags; }; int spslr_randomizer_init(); int spslr_randomize(); void spslr_randomizer_clear(); -int spslr_randomizer_get_target(uint32_t target, uint32_t* size, uint32_t* fieldcnt); -int spslr_randomizer_get_field(uint32_t target, uint32_t field, int field_idx_mode, +int spslr_randomizer_get_target(spslr_u32 target, spslr_u32* size, spslr_u32* fieldcnt); +int spslr_randomizer_get_field(spslr_u32 target, spslr_u32 field, int field_idx_mode, struct spslr_randomizer_field_info* info); #endif diff --git a/selfpatch/src/selfpatch.c b/selfpatch/src/selfpatch.c index 7229f7e..40494c0 100644 --- a/selfpatch/src/selfpatch.c +++ b/selfpatch/src/selfpatch.c @@ -1,9 +1,7 @@ #include -#include #include "randomizer.h" #include "env.h" - #include "spslr_list_link.h" #define SPSLR_SANITY_CHECK @@ -11,13 +9,13 @@ static void spslr_selfpatch_load_targets(void); static void spslr_selfpatch_randomize_targets(void); static void spslr_selfpatch_patch_dpins(void); -static void spslr_selfpatch_patch_dpin(void* addr, uint32_t target); +static void spslr_selfpatch_patch_dpin(void* addr, spslr_u32 target); static void spslr_selfpatch_patch_ipins(void); -static void reorder_object(void* dst, const void* src, uint32_t target); -static int64_t spslr_calculate_ipin_value(uint32_t start); +static void reorder_object(void* dst, const void* src, spslr_u32 target); +static spslr_s64 spslr_calculate_ipin_value(spslr_u32 start); -static void* reorder_buffer = NULL; +static void* reorder_buffer = SPSLR_NULL; static void allocate_reorder_buffer(); static void release_reorder_buffer(); @@ -42,8 +40,8 @@ static void allocate_reorder_buffer() { if (reorder_buffer) return; - uint32_t max_target_size = 0; - for (uint32_t i = 0; i < spslr_target_cnt; i++) { + spslr_u32 max_target_size = 0; + for (spslr_u32 i = 0; i < spslr_target_cnt; i++) { if (spslr_targets[i].size > max_target_size) max_target_size = spslr_targets[i].size; } @@ -58,25 +56,25 @@ static void release_reorder_buffer() { return; spslr_env_free(reorder_buffer); - reorder_buffer = NULL; + reorder_buffer = SPSLR_NULL; } static void spslr_selfpatch_patch_dpins(void) { - for (uint32_t dpidx = 0; dpidx < spslr_dpin_cnt; dpidx++) { + for (spslr_u32 dpidx = 0; dpidx < spslr_dpin_cnt; dpidx++) { const struct spslr_dpin* dp = &spslr_dpins[dpidx]; spslr_selfpatch_patch_dpin((void*)dp->addr, dp->target); } } -static void reorder_object(void* dst, const void* src, uint32_t target) { - uint32_t field_count; - if (spslr_randomizer_get_target(target, NULL, &field_count)) +static void reorder_object(void* dst, const void* src, spslr_u32 target) { + spslr_u32 field_count; + if (spslr_randomizer_get_target(target, SPSLR_NULL, &field_count)) spslr_env_panic("failed to get target field count"); - const uint8_t* src_countable = (const uint8_t*)src; - uint8_t* dst_countable = (uint8_t*)dst; + const spslr_u8* src_countable = (const spslr_u8*)src; + spslr_u8* dst_countable = (spslr_u8*)dst; - for (uint32_t i = 0; i < field_count; i++) { + for (spslr_u32 i = 0; i < field_count; i++) { struct spslr_randomizer_field_info finfo; if (spslr_randomizer_get_field(target, i, SPSLR_RANDOMIZER_FIELD_IDX_MODE_FINAL, &finfo)) spslr_env_panic("failed to get ordered field descriptor"); @@ -85,7 +83,7 @@ static void reorder_object(void* dst, const void* src, uint32_t target) { } } -static void spslr_selfpatch_patch_dpin(void* addr, uint32_t target) { +static void spslr_selfpatch_patch_dpin(void* addr, spslr_u32 target) { #ifdef SPSLR_SANITY_CHECK if (target >= spslr_target_cnt) spslr_env_panic("dpin refers to invalid target"); @@ -99,23 +97,23 @@ static void spslr_selfpatch_patch_dpin(void* addr, uint32_t target) { } static void spslr_selfpatch_patch_ipins(void) { - for (uint32_t ipidx = 0; ipidx < spslr_ipin_cnt; ipidx++) { + for (spslr_u32 ipidx = 0; ipidx < spslr_ipin_cnt; ipidx++) { const struct spslr_ipin* ip = &spslr_ipins[ipidx]; - int64_t value = spslr_calculate_ipin_value(ip->program); + spslr_s64 value = spslr_calculate_ipin_value(ip->program); switch (ip->size) { case 1: - spslr_env_poke_text_8((void*)ip->addr, (uint8_t)value); + spslr_env_poke_text_8((void*)ip->addr, (spslr_u8)value); break; case 2: - spslr_env_poke_text_16((void*)ip->addr, (uint16_t)value); + spslr_env_poke_text_16((void*)ip->addr, (spslr_u16)value); break; case 4: - spslr_env_poke_text_32((void*)ip->addr, (uint32_t)value); + spslr_env_poke_text_32((void*)ip->addr, (spslr_u32)value); break; case 8: - spslr_env_poke_text_64((void*)ip->addr, (uint64_t)value); + spslr_env_poke_text_64((void*)ip->addr, (spslr_u64)value); break; #ifdef SPSLR_SANITY_CHECK default: @@ -125,10 +123,10 @@ static void spslr_selfpatch_patch_ipins(void) { } } -static int64_t spslr_calculate_ipin_value(uint32_t start) { - int64_t res = 0; +static spslr_s64 spslr_calculate_ipin_value(spslr_u32 start) { + spslr_s64 res = 0; - uint32_t pc = start; + spslr_u32 pc = start; while (true) { #ifdef SPSLR_SANITY_CHECK if (pc >= spslr_ipin_op_cnt) diff --git a/selfpatch/src/spslr_list.h b/selfpatch/src/spslr_list.h index 2ec4519..0d68826 100644 --- a/selfpatch/src/spslr_list.h +++ b/selfpatch/src/spslr_list.h @@ -1,7 +1,7 @@ #ifndef SPSLR_LIST_H #define SPSLR_LIST_H -#include +#include "spslr_types.h" #define __packed __attribute__((packed)) @@ -15,49 +15,49 @@ #define SPSLR_FLAG_FIELD_FIXED 1 struct spslr_target { - uint32_t size; - uint32_t fieldcnt; - uint32_t fieldoff; // Offset into spslr_target_field array + spslr_u32 size; + spslr_u32 fieldcnt; + spslr_u32 fieldoff; // Offset into spslr_target_field array } __packed; struct spslr_target_field { - uint32_t offset; - uint32_t size; - uint32_t alignment; - uint32_t flags; + spslr_u32 offset; + spslr_u32 size; + spslr_u32 alignment; + spslr_u32 flags; } __packed; struct spslr_ipin { - uint64_t addr; - uint32_t size; - uint32_t program; // Index in spslr_ipin_op array + spslr_u64 addr; + spslr_u32 size; + spslr_u32 program; // Index in spslr_ipin_op array } __packed; struct spslr_ipin_op { - uint32_t code; + spslr_u32 code; union { - uint32_t patch_unused; - uint32_t add_initial_offset_target; - uint32_t sub_initial_offset_target; - uint32_t add_offset_target; - uint32_t sub_offset_target; - int32_t add_const_value; + spslr_u32 patch_unused; + spslr_u32 add_initial_offset_target; + spslr_u32 sub_initial_offset_target; + spslr_u32 add_offset_target; + spslr_u32 sub_offset_target; + spslr_s32 add_const_value; } op0; union { - uint32_t patch_unused; - uint32_t add_initial_offset_field; - uint32_t sub_initial_offset_field; - uint32_t add_offset_field; - uint32_t sub_offset_field; - uint32_t add_const_unused; + spslr_u32 patch_unused; + spslr_u32 add_initial_offset_field; + spslr_u32 sub_initial_offset_field; + spslr_u32 add_offset_field; + spslr_u32 sub_offset_field; + spslr_u32 add_const_unused; } op1; } __packed; struct spslr_dpin { - uint64_t addr; - uint32_t target; // Index in spslr_target array + spslr_u64 addr; + spslr_u32 target; // Index in spslr_target array } __packed; #undef __packed diff --git a/selfpatch/src/spslr_list_link.h b/selfpatch/src/spslr_list_link.h index 0418a3f..91a4e12 100644 --- a/selfpatch/src/spslr_list_link.h +++ b/selfpatch/src/spslr_list_link.h @@ -3,19 +3,19 @@ #include "spslr_list.h" -extern const uint32_t spslr_target_cnt; +extern const spslr_u32 spslr_target_cnt; extern const struct spslr_target spslr_targets[]; -extern const uint32_t spslr_target_field_cnt; +extern const spslr_u32 spslr_target_field_cnt; extern const struct spslr_target_field spslr_target_fields[]; -extern const uint32_t spslr_ipin_cnt; +extern const spslr_u32 spslr_ipin_cnt; extern const struct spslr_ipin spslr_ipins[]; -extern const uint32_t spslr_ipin_op_cnt; +extern const spslr_u32 spslr_ipin_op_cnt; extern const struct spslr_ipin_op spslr_ipin_ops[]; -extern const uint32_t spslr_dpin_cnt; +extern const spslr_u32 spslr_dpin_cnt; extern const struct spslr_dpin spslr_dpins[]; #endif diff --git a/selfpatch/src/spslr_types.h b/selfpatch/src/spslr_types.h new file mode 100644 index 0000000..4597aad --- /dev/null +++ b/selfpatch/src/spslr_types.h @@ -0,0 +1,17 @@ +#ifndef SPSLR_TYPES_H +#define SPSLR_TYPES_H + +#include +#include + +typedef uint8_t spslr_u8; +typedef uint16_t spslr_u16; +typedef uint32_t spslr_u32; +typedef uint64_t spslr_u64; +typedef int32_t spslr_s32; +typedef int64_t spslr_s64; +typedef uintptr_t spslr_uintptr; + +#define SPSLR_NULL NULL + +#endif