mirror of
https://git.triforceproject.com/triforce/source
synced 2026-11-19 16:20:01 -04:00
In-game mods (GameBanana browser, search and installs, with the Mask Salesman), code-patch and cheat mods, the devs' test18 to test45 work (full performance overlay, frame pacing on, steady frame rate, save export and import, bug capture, new options rows, Setup's Mods page and Add to Steam), occlusion queries and new defaults, Auto resolution that scales, replay helper threads and robust buffers off by default, the options in sections.
172 lines
10 KiB
C
172 lines
10 KiB
C
/* Horizon OS layer (HLE of the Nintendo SDK at the nn:: boundary) for a64-kit games.
|
|
|
|
An import or SDK function the game calls is a C function `void imp_<mangled name>(Ctx *c)` (HLE(...) below):
|
|
arguments in c->x[0..7], the result in c->x[0]. A symbol with such a definition is hooked both where the game
|
|
imports it and at the sdk's own definition, so lifted SDK code reaching it lands here too (nx_image.py).
|
|
Everything without a definition gets a generated stub that logs its first call and returns 0.
|
|
|
|
Guest address map (mkw-recomp: the 64-bit window of a 39-bit process, reserved whole and committed as used):
|
|
0x01000000 - 0x07000000 system region: our own guest objects (main stack, TLS blocks, thread regions)
|
|
0x80000000 - image end rtld, main, subsdk0, subsdk1, sdk in Eden's layout (hos_image_base, the lift's)
|
|
0x1000000000 - ... heap (SetMemoryHeapSize), up from 64 GB
|
|
... - 0x8000000000 address regions (AllocateAddressRegion), down from 512 GB */
|
|
#ifndef HOS_H
|
|
#define HOS_H
|
|
#include "a64.h"
|
|
#include <stdarg.h>
|
|
|
|
#define HLE(sym) void imp_##sym(Ctx *c)
|
|
/* HOS_GAME_VERSION: the game update the address hooks below are for, from the build (build.py reads the main
|
|
module's build id). An update moves the game's functions, so a hook compiles the address of the version it is
|
|
for and the other version's hooks are left out (ENTRY_HOOKs: the address is not in the lift; SPLICE_AFTERs:
|
|
skipped with a note). */
|
|
#ifndef HOS_GAME_VERSION
|
|
#define HOS_GAME_VERSION 100
|
|
#endif
|
|
/* ENTRY_HOOK(0x0xxxxxxx) { ... }: runs at the entry of the lifted guest function at that address (8 hex digits),
|
|
with its arguments in c; return 1 when it handled the call (the function then returns at once, x0 is the result),
|
|
0 to run the function as usual. build.py splices the call into the lifted code (only that file recompiles). */
|
|
#define ENTRY_HOOK(addr) int entry_##addr(Ctx *c)
|
|
#define ENTRY_HOOK_SYM(sym) int entry_sym_##sym(Ctx *c)
|
|
/* SPLICE_AFTER(0x0xxxxxxx, "text") { ... }: runs inside the lifted guest function at that address, right after the
|
|
first line of its lifted C that contains the text (a game patch in the middle of a function: c holds the guest
|
|
registers there). build.py splices the call in and stops the build if the text is not found. One per function. */
|
|
#define SPLICE_AFTER(addr, anchor) void splice_##addr(Ctx *c)
|
|
/* SPLICE_AFTER_EACH(0x0xxxxxxx, "text") { ... }: the same after every line of that function with the text */
|
|
#define SPLICE_AFTER_EACH(addr, anchor) void splice_##addr(Ctx *c)
|
|
#define ARG(n) (c->x[n])
|
|
#define RET(v) (c->x[0] = (uint64_t)(v))
|
|
#define GP(a) ((void *)A64_PTR(a)) /* host pointer of a guest address */
|
|
#define G64(a) (*(uint64_t *)GP(a))
|
|
#define G32(a) (*(uint32_t *)GP(a))
|
|
|
|
#define HOS_SYSTEM_BASE 0x01000000ULL
|
|
#define HOS_SYSTEM_END 0x07000000ULL
|
|
#define HOS_HEAP_BASE 0x1000000000ULL
|
|
#define HOS_GUEST_SPACE (1ULL << 39)
|
|
extern const uint64_t hos_image_base, hos_image_end; /* (gen/hos_image.c) */
|
|
extern const uint64_t hos_program_id; /* (gen/hos_image.c: main.npdm's) */
|
|
extern const char hos_main_build_id[]; /* (gen/hos_image.c: main's NSO build id, hex) */
|
|
/* (oot-recomp) MKW's own hooks at fixed guest addresses (its frame pacer in nvn_native.c / nn_vi.c, its idle loop in
|
|
hos_thread.c) run only when the lifted main is Mario Kart World's: any other game has other code there */
|
|
int hos_game_is_mkw(void);
|
|
#define HOS_GAME_TITLE "Triforce"
|
|
/* (mkw_glue.c) guest pages made usable by host APIs. (Triforce) 1: committed, 0: the commit failed (logged), -1: not in
|
|
the guest window (logged) */
|
|
int hos_commit(uint64_t addr, uint64_t size);
|
|
/* (Triforce) the guest memory census (hos_mem.c, host/guest_census.h): each place that commits, maps or lets go of guest
|
|
pages says what it did. COMMITTED: handed out and committed (before the commit itself); TOUCHED: committed on a first
|
|
touch; PAGES, MAPPED: the game's own pages and physical maps; DECOMMITTED: let go and decommitted; ZEROED: let go and
|
|
zeroed in place (an import holds them); DISCARDED: let go, out of RAM but still committed */
|
|
enum { HOS_MEM_COMMITTED, HOS_MEM_TOUCHED, HOS_MEM_PAGES, HOS_MEM_MAPPED, HOS_MEM_DECOMMITTED, HOS_MEM_ZEROED, HOS_MEM_DISCARDED };
|
|
void hos_mem_note(int what, uint64_t addr, uint64_t size);
|
|
int hos_mem_census_on(void); /* (the notes are kept: HOS_MEM_CENSUS or HOS_MEM_GIVE_BACK) */
|
|
int64_t hos_mem_give_back(uint64_t max_bytes);
|
|
void hos_mem_census_start(void); /* (mkw_glue.c: the census's thread) */
|
|
/* (Triforce, rx_backend.c) before a call that hands the guest memory [p, p + n) to the kernel or changes its pages' state,
|
|
and after it with what the first returned: the lazy write-back's pages there are paid and left alone meanwhile */
|
|
int hos_guest_io_begin(const void *p, uint64_t n);
|
|
void hos_guest_io_end(int held);
|
|
#if defined(A64_WRITE_TRACK) && !defined(__EMSCRIPTEN__)
|
|
void hos_mark_written(const void *p, size_t n); /* (hos_mem.c: guest memory written by host code, native soft watch) */
|
|
#define HOS_WRITTEN(p, n) hos_mark_written((p), (n))
|
|
#elif defined(A64_WRITE_TRACK)
|
|
void web_mark_written(const void *p, size_t n); /* (hos/web/win32.c: guest memory written by host code) */
|
|
#define HOS_WRITTEN(p, n) web_mark_written((p), (n))
|
|
#else
|
|
#define HOS_WRITTEN(p, n) ((void)0)
|
|
#endif
|
|
#ifdef A64_MEM_ZERO
|
|
extern uint64_t hos_space_end; /* web: the guest window ends where the host's own data starts (hos_main.c) */
|
|
#define HOS_SPACE_END hos_space_end
|
|
#else
|
|
#define HOS_SPACE_END 0x8000000000ULL
|
|
#endif
|
|
/* (hookshot) host pointer of the n guest bytes at a, NULL unless all of them lie in the guest window. For addresses
|
|
and sizes host code takes from guest memory or arguments before it reads or writes there: GP alone wraps around
|
|
to any host address. */
|
|
static inline void *hos_guest_range(uint64_t a, uint64_t n) {
|
|
return a < (uint64_t)HOS_SPACE_END && n <= (uint64_t)HOS_SPACE_END - a ? GP(a) : (void *)0;
|
|
}
|
|
#define HOS_TICK_HZ 31250000ULL /* (mkw-recomp: the Switch 2 counter; the SDK checks it at init) */
|
|
|
|
/* ---- logging: HOS_TRACE=1 logs every HLE call that uses HOS_TRACE_CALL */
|
|
extern int hos_trace;
|
|
void hos_log(const char *fmt, ...);
|
|
void hos_log_flush(void);
|
|
#define HOS_TRACE_CALL(name) do { if (hos_trace) hos_log("%s(%#llx, %#llx, %#llx, %#llx) lr %#llx", name, \
|
|
(unsigned long long)c->x[0], (unsigned long long)c->x[1], (unsigned long long)c->x[2], \
|
|
(unsigned long long)c->x[3], (unsigned long long)c->x[30]); } while (0)
|
|
void hos_fatal(Ctx *c, const char *fmt, ...);
|
|
|
|
/* ---- guest memory (hos_mem.c) */
|
|
uint64_t hos_sys_alloc(uint64_t size, uint64_t align); /* zeroed, from the system region, never freed */
|
|
uint64_t hos_region_alloc(uint64_t size, uint64_t align); /* address space above the heap */
|
|
void hos_region_free(uint64_t addr);
|
|
void hos_mem_init(uint64_t image_end);
|
|
extern uint64_t hos_heap_size, hos_heap_used, hos_total_memory, hos_program_size;
|
|
|
|
/* ---- threads (hos_thread.c) */
|
|
typedef struct HosThread HosThread;
|
|
HosThread *hos_self(void);
|
|
Ctx *hos_ctx(void);
|
|
uint64_t hos_thread_guest(HosThread *t); /* its nn::os::ThreadType in guest memory */
|
|
uint64_t hos_thread_id(HosThread *t);
|
|
HosThread *hos_thread_of(uint64_t guest_thread_type); /* NULL if unknown */
|
|
HosThread *hos_thread_create(uint64_t guest_tt, uint64_t entry, uint64_t arg, uint64_t stack, uint64_t stack_size,
|
|
int priority, int core);
|
|
void hos_thread_start(HosThread *t);
|
|
void hos_thread_join(HosThread *t);
|
|
void hos_thread_destroy(HosThread *t);
|
|
void hos_thread_set_name(HosThread *t, const char *name);
|
|
void hos_thread_pin(void *h, const char *name); /* HOS_PIN: host CPU affinity by thread name */
|
|
int hos_game_cores(void); /* totk_cores.c: HOS_GAME_CORES, or 0 */
|
|
const char *hos_thread_name(HosThread *t);
|
|
void hos_thread_affinity(HosThread *t, int ideal, uint64_t mask);
|
|
uint64_t hos_thread_mask(HosThread *t);
|
|
int hos_thread_priority(HosThread *t, int set, int value);
|
|
int hos_thread_core(HosThread *t);
|
|
int hos_cores(void);
|
|
/* virtual cores (hos_thread.c, HOS_VCORES=1): a guest thread gives its core up for a block (hos_vcore_away: 1 if it
|
|
held one) and takes one again after it (hos_vcore_back); checkpoints hand it to a better waiter that asked */
|
|
int hos_vcores_on(void);
|
|
int hos_vcore_away(void);
|
|
void hos_vcore_back(void);
|
|
void hos_vcore_checkpoint(void);
|
|
void hos_vcore_yield(void);
|
|
int hos_cv_sleep(void *cv, void *srw_lock, unsigned ms); /* SleepConditionVariableSRW (exclusive) for guest threads */
|
|
void hos_thread_boost(int level);
|
|
void hos_thread_stack(HosThread *t, uint64_t *addr, uint64_t *size);
|
|
uint64_t *hos_tls_slots(HosThread *t); /* nn::os TLS slot values */
|
|
#define HOS_TLS_SLOTS 32
|
|
Ctx *hos_boot_main_thread(uint64_t stack_size); /* the calling host thread becomes the guest main thread */
|
|
/* the kernel side: Horizon handles and blocking for hos_svc.c's arbitration */
|
|
uint32_t hos_thread_handle(HosThread *t);
|
|
HosThread *hos_thread_by_handle(uint32_t h);
|
|
int hos_thread_prio(HosThread *t);
|
|
void hos_thread_wait(HosThread *t, int64_t timeout_ns, int *timed_out); /* < 0: forever */
|
|
void hos_thread_wake(HosThread *t);
|
|
|
|
/* ---- for host-side devices: game files by guest path (nn_fs.c), guest events (nn_os_sync.c) */
|
|
int hos_fs_host_path(const char *guest, char *out, size_t cap);
|
|
void hos_event_signal(uint64_t guest_event);
|
|
|
|
/* ---- videos (movie_mf.c): a video file read as compressed samples or as decoded NV12 frames */
|
|
typedef struct MovieReader MovieReader;
|
|
MovieReader *movie_reader_open(const char *host_path, int decoded, int *width, int *height, int64_t *duration_us);
|
|
/* compressed: the next sample into dst; its size, 0 at the end, -1 on an error or if it does not fit */
|
|
int movie_reader_sample(MovieReader *r, void *dst, int cap, int64_t *time_us);
|
|
/* decoded: the next frame as NV12 (width x height luma rows of `width` bytes, then the interleaved chroma rows);
|
|
1, or 0 at the end */
|
|
int movie_reader_frame(MovieReader *r, uint8_t *dst, int64_t *time_us);
|
|
void movie_reader_close(MovieReader *r);
|
|
uint32_t movie_reader_codec(MovieReader *r); /* the stream's FourCC: 'VP90', 'VP80', 'H264', ... */
|
|
|
|
/* ---- time */
|
|
uint64_t hos_ticks(void);
|
|
void hos_sleep_ns(int64_t ns);
|
|
/* (Triforce) until hos_now_ns reads `until`: the timer to margin_ns before it, the rest yielded (pace_wait.h) */
|
|
void hos_sleep_until_ns(int64_t until, int64_t margin_ns);
|
|
int64_t hos_now_ns(void);
|
|
#endif
|