format shim conversion on some files
xam_info.cc, xam_msg.cc, xam_notify.cc, xboxkrnl_memory.cc, xboxkrnl_misc.cc
This commit is contained in:
Megamouse
parent
46504adcc0
commit
c38accbb76
|
|
@ -25,42 +25,35 @@ namespace xam {
|
|||
constexpr uint32_t X_LANGUAGE_ENGLISH = 1;
|
||||
constexpr uint32_t X_LANGUAGE_JAPANESE = 2;
|
||||
|
||||
SHIM_CALL XamGetSystemVersion_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
XELOGD("XamGetSystemVersion()");
|
||||
dword_result_t XamGetSystemVersion() {
|
||||
// eh, just picking one. If we go too low we may break new games, but
|
||||
// this value seems to be used for conditionally loading symbols and if
|
||||
// we pretend to be old we have less to worry with implementing.
|
||||
// 0x200A3200
|
||||
// 0x20096B00
|
||||
SHIM_SET_RETURN_32(0);
|
||||
return 0;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XamGetSystemVersion, ExportTag::kStub);
|
||||
|
||||
void XCustomRegisterDynamicActions() {
|
||||
// ???
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XCustomRegisterDynamicActions, ExportTag::kStub);
|
||||
|
||||
SHIM_CALL XGetAVPack_shim(PPCContext* ppc_context, KernelState* kernel_state) {
|
||||
dword_result_t XGetAVPack() {
|
||||
// DWORD
|
||||
// Not sure what the values are for this, but 6 is VGA.
|
||||
// Other likely values are 3/4/8 for HDMI or something.
|
||||
// Games seem to use this as a PAL check - if the result is not 3/4/6/8
|
||||
// they explode with errors if not in PAL mode.
|
||||
SHIM_SET_RETURN_32(6);
|
||||
return 6;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XGetAVPack, ExportTag::kStub);
|
||||
|
||||
SHIM_CALL XGetGameRegion_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
XELOGD("XGetGameRegion()");
|
||||
|
||||
SHIM_SET_RETURN_32(0xFFFF);
|
||||
}
|
||||
|
||||
SHIM_CALL XGetLanguage_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
XELOGD("XGetLanguage()");
|
||||
dword_result_t XGetGameRegion() { return 0xFFFF; }
|
||||
DECLARE_XAM_EXPORT(XGetGameRegion, ExportTag::kStub);
|
||||
|
||||
dword_result_t XGetLanguage() {
|
||||
uint32_t desired_language = X_LANGUAGE_ENGLISH;
|
||||
|
||||
// Switch the language based on game region.
|
||||
|
|
@ -73,16 +66,12 @@ SHIM_CALL XGetLanguage_shim(PPCContext* ppc_context,
|
|||
}
|
||||
// Add more overrides?
|
||||
|
||||
SHIM_SET_RETURN_32(desired_language);
|
||||
return desired_language;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XGetLanguage, ExportTag::kImplemented);
|
||||
|
||||
SHIM_CALL XamGetExecutionId_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t info_ptr = SHIM_GET_ARG_32(0);
|
||||
|
||||
XELOGD("XamGetExecutionId(%.8X)", info_ptr);
|
||||
|
||||
auto module = kernel_state->GetExecutableModule();
|
||||
dword_result_t XamGetExecutionId(lpdword_t info_ptr) {
|
||||
auto module = kernel_state()->GetExecutableModule();
|
||||
assert_not_null(module);
|
||||
|
||||
uint32_t guest_hdr_ptr;
|
||||
|
|
@ -90,13 +79,13 @@ SHIM_CALL XamGetExecutionId_shim(PPCContext* ppc_context,
|
|||
module->GetOptHeader(XEX_HEADER_EXECUTION_INFO, &guest_hdr_ptr);
|
||||
|
||||
if (XFAILED(result)) {
|
||||
SHIM_SET_RETURN_32(result);
|
||||
return;
|
||||
return result;
|
||||
}
|
||||
|
||||
SHIM_SET_MEM_32(info_ptr, guest_hdr_ptr);
|
||||
SHIM_SET_RETURN_32(X_STATUS_SUCCESS);
|
||||
*info_ptr = guest_hdr_ptr;
|
||||
return X_STATUS_SUCCESS;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XamGetExecutionId, ExportTag::kImplemented);
|
||||
|
||||
dword_result_t XamLoaderSetLaunchData(lpvoid_t data, dword_t size) {
|
||||
auto xam = kernel_state()->GetKernelModule<XamModule>("xam.xex");
|
||||
|
|
@ -173,32 +162,24 @@ void XamLoaderTerminateTitle() {
|
|||
}
|
||||
DECLARE_XAM_EXPORT(XamLoaderTerminateTitle, ExportTag::kSketchy);
|
||||
|
||||
SHIM_CALL XamAlloc_shim(PPCContext* ppc_context, KernelState* kernel_state) {
|
||||
uint32_t unk = SHIM_GET_ARG_32(0);
|
||||
uint32_t size = SHIM_GET_ARG_32(1);
|
||||
uint32_t out_ptr = SHIM_GET_ARG_32(2);
|
||||
|
||||
XELOGD("XamAlloc(%d, %d, %.8X)", unk, size, out_ptr);
|
||||
|
||||
dword_result_t XamAlloc(dword_t unk, dword_t size, lpword_t out_ptr) {
|
||||
assert_true(unk == 0);
|
||||
|
||||
// Allocate from the heap. Not sure why XAM does this specially, perhaps
|
||||
// it keeps stuff in a separate heap?
|
||||
uint32_t ptr = kernel_state->memory()->SystemHeapAlloc(size);
|
||||
SHIM_SET_MEM_32(out_ptr, ptr);
|
||||
uint32_t ptr = kernel_state()->memory()->SystemHeapAlloc(size);
|
||||
*out_ptr = ptr;
|
||||
|
||||
SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
|
||||
return X_ERROR_SUCCESS;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XamAlloc, ExportTag::kImplemented);
|
||||
|
||||
SHIM_CALL XamFree_shim(PPCContext* ppc_context, KernelState* kernel_state) {
|
||||
uint32_t ptr = SHIM_GET_ARG_32(0);
|
||||
dword_result_t XamFree(lpdword_t ptr) {
|
||||
kernel_state()->memory()->SystemHeapFree(ptr);
|
||||
|
||||
XELOGD("XamFree(%.8X)", ptr);
|
||||
|
||||
kernel_state->memory()->SystemHeapFree(ptr);
|
||||
|
||||
SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
|
||||
return X_ERROR_SUCCESS;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XamFree, ExportTag::kImplemented);
|
||||
|
||||
// https://github.com/LestaD/SourceEngine2007/blob/master/se2007/engine/xboxsystem.cpp#L518
|
||||
dword_result_t XamEnumerate(dword_t handle, dword_t flags, lpvoid_t buffer,
|
||||
|
|
@ -244,18 +225,8 @@ dword_result_t XamEnumerate(dword_t handle, dword_t flags, lpvoid_t buffer,
|
|||
DECLARE_XAM_EXPORT(XamEnumerate, ExportTag::kImplemented);
|
||||
|
||||
void RegisterInfoExports(xe::cpu::ExportResolver* export_resolver,
|
||||
KernelState* kernel_state) {
|
||||
SHIM_SET_MAPPING("xam.xex", XamGetSystemVersion, state);
|
||||
SHIM_SET_MAPPING("xam.xex", XGetAVPack, state);
|
||||
SHIM_SET_MAPPING("xam.xex", XGetGameRegion, state);
|
||||
SHIM_SET_MAPPING("xam.xex", XGetLanguage, state);
|
||||
|
||||
SHIM_SET_MAPPING("xam.xex", XamGetExecutionId, state);
|
||||
|
||||
SHIM_SET_MAPPING("xam.xex", XamAlloc, state);
|
||||
SHIM_SET_MAPPING("xam.xex", XamFree, state);
|
||||
}
|
||||
KernelState* kernel_state) {}
|
||||
|
||||
} // namespace xam
|
||||
} // namespace kernel
|
||||
} // namespace xe
|
||||
} // namespace xe
|
||||
|
|
@ -18,115 +18,79 @@ namespace xe {
|
|||
namespace kernel {
|
||||
namespace xam {
|
||||
|
||||
SHIM_CALL XMsgInProcessCall_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t app = SHIM_GET_ARG_32(0);
|
||||
uint32_t message = SHIM_GET_ARG_32(1);
|
||||
uint32_t arg1 = SHIM_GET_ARG_32(2);
|
||||
uint32_t arg2 = SHIM_GET_ARG_32(3);
|
||||
|
||||
XELOGD("XMsgInProcessCall(%.8X, %.8X, %.8X, %.8X)", app, message, arg1, arg2);
|
||||
|
||||
auto result = kernel_state->app_manager()->DispatchMessageSync(app, message,
|
||||
arg1, arg2);
|
||||
dword_result_t XMsgInProcessCall(dword_t app, dword_t message, dword_t arg1,
|
||||
dword_t arg2) {
|
||||
auto result = kernel_state()->app_manager()->DispatchMessageSync(app, message,
|
||||
arg1, arg2);
|
||||
if (result == X_ERROR_NOT_FOUND) {
|
||||
XELOGE("XMsgInProcessCall: app %.8X undefined", app);
|
||||
}
|
||||
SHIM_SET_RETURN_32(result);
|
||||
return result;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XMsgInProcessCall, ExportTag::kImplemented);
|
||||
|
||||
SHIM_CALL XMsgSystemProcessCall_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t app = SHIM_GET_ARG_32(0);
|
||||
uint32_t message = SHIM_GET_ARG_32(1);
|
||||
uint32_t buffer = SHIM_GET_ARG_32(2);
|
||||
uint32_t buffer_length = SHIM_GET_ARG_32(3);
|
||||
|
||||
XELOGD("XMsgSystemProcessCall(%.8X, %.8X, %.8X, %.8X)", app, message, buffer,
|
||||
buffer_length);
|
||||
|
||||
auto result = kernel_state->app_manager()->DispatchMessageAsync(
|
||||
dword_result_t XMsgSystemProcessCall(dword_t app, dword_t message,
|
||||
dword_t buffer, dword_t buffer_length) {
|
||||
auto result = kernel_state()->app_manager()->DispatchMessageAsync(
|
||||
app, message, buffer, buffer_length);
|
||||
if (result == X_ERROR_NOT_FOUND) {
|
||||
XELOGE("XMsgSystemProcessCall: app %.8X undefined", app);
|
||||
}
|
||||
SHIM_SET_RETURN_32(result);
|
||||
return result;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XMsgSystemProcessCall, ExportTag::kImplemented);
|
||||
|
||||
SHIM_CALL XMsgStartIORequest_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t app = SHIM_GET_ARG_32(0);
|
||||
uint32_t message = SHIM_GET_ARG_32(1);
|
||||
uint32_t overlapped_ptr = SHIM_GET_ARG_32(2);
|
||||
uint32_t buffer = SHIM_GET_ARG_32(3);
|
||||
uint32_t buffer_length = SHIM_GET_ARG_32(4);
|
||||
|
||||
XELOGD("XMsgStartIORequest(%.8X, %.8X, %.8X, %.8X, %d)", app, message,
|
||||
overlapped_ptr, buffer, buffer_length);
|
||||
|
||||
auto result = kernel_state->app_manager()->DispatchMessageAsync(
|
||||
dword_result_t XMsgStartIORequest(dword_t app, dword_t message,
|
||||
pointer_t<XAM_OVERLAPPED> overlapped_ptr,
|
||||
dword_t buffer, dword_t buffer_length) {
|
||||
auto result = kernel_state()->app_manager()->DispatchMessageAsync(
|
||||
app, message, buffer, buffer_length);
|
||||
if (result == X_ERROR_NOT_FOUND) {
|
||||
XELOGE("XMsgStartIORequest: app %.8X undefined", app);
|
||||
}
|
||||
if (overlapped_ptr) {
|
||||
kernel_state->CompleteOverlappedImmediate(overlapped_ptr, result);
|
||||
kernel_state()->CompleteOverlappedImmediate(overlapped_ptr, result);
|
||||
result = X_ERROR_IO_PENDING;
|
||||
}
|
||||
SHIM_SET_RETURN_32(result);
|
||||
return result;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XMsgStartIORequest, ExportTag::kImplemented);
|
||||
|
||||
SHIM_CALL XMsgStartIORequestEx_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t app = SHIM_GET_ARG_32(0);
|
||||
uint32_t message = SHIM_GET_ARG_32(1);
|
||||
uint32_t overlapped_ptr = SHIM_GET_ARG_32(2);
|
||||
uint32_t buffer = SHIM_GET_ARG_32(3);
|
||||
uint32_t buffer_length = SHIM_GET_ARG_32(4);
|
||||
uint32_t unknown_ptr = SHIM_GET_ARG_32(5);
|
||||
|
||||
XELOGD("XMsgStartIORequestEx(%.8X, %.8X, %.8X, %.8X, %d, %.8X)", app, message,
|
||||
overlapped_ptr, buffer, buffer_length, unknown_ptr);
|
||||
|
||||
auto result = kernel_state->app_manager()->DispatchMessageAsync(
|
||||
dword_result_t XMsgStartIORequestEx(dword_t app, dword_t message,
|
||||
pointer_t<XAM_OVERLAPPED> overlapped_ptr,
|
||||
dword_t buffer, dword_t buffer_length,
|
||||
lpdword_t unknown_ptr) {
|
||||
auto result = kernel_state()->app_manager()->DispatchMessageAsync(
|
||||
app, message, buffer, buffer_length);
|
||||
if (result == X_ERROR_NOT_FOUND) {
|
||||
XELOGE("XMsgStartIORequestEx: app %.8X undefined", app);
|
||||
}
|
||||
if (overlapped_ptr) {
|
||||
kernel_state->CompleteOverlappedImmediate(overlapped_ptr, result);
|
||||
kernel_state()->CompleteOverlappedImmediate(overlapped_ptr, result);
|
||||
result = X_ERROR_IO_PENDING;
|
||||
}
|
||||
SHIM_SET_RETURN_32(result);
|
||||
return result;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XMsgStartIORequestEx, ExportTag::kImplemented);
|
||||
|
||||
SHIM_CALL XMsgCancelIORequest_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t overlapped_ptr = SHIM_GET_ARG_32(0);
|
||||
uint32_t wait = SHIM_GET_ARG_32(1);
|
||||
|
||||
XELOGD("XMsgCancelIORequest(%.8X, %d)", overlapped_ptr, wait);
|
||||
|
||||
X_HANDLE event_handle = XOverlappedGetEvent(SHIM_MEM_ADDR(overlapped_ptr));
|
||||
dword_result_t XMsgCancelIORequest(pointer_t<XAM_OVERLAPPED> overlapped_ptr,
|
||||
dword_t wait) {
|
||||
X_HANDLE event_handle = XOverlappedGetEvent(overlapped_ptr);
|
||||
if (event_handle && wait) {
|
||||
auto ev = kernel_state->object_table()->LookupObject<XEvent>(event_handle);
|
||||
auto ev =
|
||||
kernel_state()->object_table()->LookupObject<XEvent>(event_handle);
|
||||
if (ev) {
|
||||
ev->Wait(0, 0, true, nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
SHIM_SET_RETURN_32(0);
|
||||
return 0;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XMsgCancelIORequest, ExportTag::kImplemented);
|
||||
|
||||
void RegisterMsgExports(xe::cpu::ExportResolver* export_resolver,
|
||||
KernelState* kernel_state) {
|
||||
SHIM_SET_MAPPING("xam.xex", XMsgInProcessCall, state);
|
||||
SHIM_SET_MAPPING("xam.xex", XMsgSystemProcessCall, state);
|
||||
SHIM_SET_MAPPING("xam.xex", XMsgStartIORequest, state);
|
||||
SHIM_SET_MAPPING("xam.xex", XMsgStartIORequestEx, state);
|
||||
SHIM_SET_MAPPING("xam.xex", XMsgCancelIORequest, state);
|
||||
}
|
||||
KernelState* kernel_state) {}
|
||||
|
||||
} // namespace xam
|
||||
} // namespace kernel
|
||||
} // namespace xe
|
||||
} // namespace xe
|
||||
|
|
@ -18,46 +18,32 @@ namespace xe {
|
|||
namespace kernel {
|
||||
namespace xam {
|
||||
|
||||
SHIM_CALL XamNotifyCreateListener_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint64_t mask = SHIM_GET_ARG_64(0);
|
||||
uint32_t one = SHIM_GET_ARG_32(1);
|
||||
|
||||
XELOGD("XamNotifyCreateListener(%.8llX, %d)", mask, one);
|
||||
|
||||
dword_result_t XamNotifyCreateListener(qword_t mask, dword_t one) {
|
||||
// r4=1 may indicate user process?
|
||||
|
||||
auto listener = object_ref<NotifyListener>(new NotifyListener(kernel_state));
|
||||
auto listener =
|
||||
object_ref<NotifyListener>(new NotifyListener(kernel_state()));
|
||||
listener->Initialize(mask);
|
||||
|
||||
// Handle ref is incremented, so return that.
|
||||
uint32_t handle = listener->handle();
|
||||
|
||||
SHIM_SET_RETURN_32(handle);
|
||||
return handle;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XamNotifyCreateListener, ExportTag::kImplemented);
|
||||
|
||||
// http://ffplay360.googlecode.com/svn/Test/Common/AtgSignIn.cpp
|
||||
SHIM_CALL XNotifyGetNext_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t handle = SHIM_GET_ARG_32(0);
|
||||
uint32_t match_id = SHIM_GET_ARG_32(1);
|
||||
uint32_t id_ptr = SHIM_GET_ARG_32(2);
|
||||
uint32_t param_ptr = SHIM_GET_ARG_32(3);
|
||||
|
||||
XELOGD("XNotifyGetNext(%.8X, %.8X, %.8X, %.8X)", handle, match_id, id_ptr,
|
||||
param_ptr);
|
||||
|
||||
dword_result_t XNotifyGetNext(dword_t handle, dword_t match_id,
|
||||
lpdword_t id_ptr, lpdword_t param_ptr) {
|
||||
if (!handle) {
|
||||
SHIM_SET_RETURN_32(0);
|
||||
return;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Grab listener.
|
||||
auto listener =
|
||||
kernel_state->object_table()->LookupObject<NotifyListener>(handle);
|
||||
kernel_state()->object_table()->LookupObject<NotifyListener>(handle);
|
||||
if (!listener) {
|
||||
SHIM_SET_RETURN_32(0);
|
||||
return;
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool dequeued = false;
|
||||
|
|
@ -73,43 +59,31 @@ SHIM_CALL XNotifyGetNext_shim(PPCContext* ppc_context,
|
|||
}
|
||||
|
||||
if (dequeued) {
|
||||
SHIM_SET_MEM_32(id_ptr, id);
|
||||
SHIM_SET_MEM_32(param_ptr, param);
|
||||
*id_ptr = id;
|
||||
*param_ptr = param;
|
||||
} else {
|
||||
SHIM_SET_MEM_32(id_ptr, 0);
|
||||
SHIM_SET_MEM_32(param_ptr, 0);
|
||||
*id_ptr = 0;
|
||||
*param_ptr = 0;
|
||||
}
|
||||
|
||||
SHIM_SET_RETURN_32(dequeued ? 1 : 0);
|
||||
return dequeued ? 1 : 0;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XNotifyGetNext, ExportTag::kImplemented);
|
||||
|
||||
SHIM_CALL XNotifyDelayUI_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t delay_ms = SHIM_GET_ARG_32(0);
|
||||
|
||||
XELOGD("XNotifyDelayUI(%d)", delay_ms);
|
||||
|
||||
dword_result_t XNotifyDelayUI(dword_t delay_ms) {
|
||||
// Ignored.
|
||||
SHIM_SET_RETURN_32(0);
|
||||
return 0;
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XNotifyDelayUI, ExportTag::kStub);
|
||||
|
||||
SHIM_CALL XNotifyPositionUI_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t position = SHIM_GET_ARG_32(0);
|
||||
|
||||
XELOGD("XNotifyPositionUI(%.8X)", position);
|
||||
|
||||
void XNotifyPositionUI(dword_t position) {
|
||||
// Ignored.
|
||||
}
|
||||
DECLARE_XAM_EXPORT(XNotifyPositionUI, ExportTag::kStub);
|
||||
|
||||
void RegisterNotifyExports(xe::cpu::ExportResolver* export_resolver,
|
||||
KernelState* kernel_state) {
|
||||
SHIM_SET_MAPPING("xam.xex", XamNotifyCreateListener, state);
|
||||
SHIM_SET_MAPPING("xam.xex", XNotifyGetNext, state);
|
||||
SHIM_SET_MAPPING("xam.xex", XNotifyDelayUI, state);
|
||||
SHIM_SET_MAPPING("xam.xex", XNotifyPositionUI, state);
|
||||
}
|
||||
KernelState* kernel_state) {}
|
||||
|
||||
} // namespace xam
|
||||
} // namespace kernel
|
||||
} // namespace xe
|
||||
} // namespace xe
|
||||
|
|
@ -164,19 +164,12 @@ dword_result_t NtAllocateVirtualMemory(lpdword_t base_addr_ptr,
|
|||
DECLARE_XBOXKRNL_EXPORT(NtAllocateVirtualMemory,
|
||||
ExportTag::kImplemented | ExportTag::kMemory);
|
||||
|
||||
SHIM_CALL NtFreeVirtualMemory_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t base_addr_ptr = SHIM_GET_ARG_32(0);
|
||||
uint32_t base_addr_value = SHIM_MEM_32(base_addr_ptr);
|
||||
uint32_t region_size_ptr = SHIM_GET_ARG_32(1);
|
||||
uint32_t region_size_value = SHIM_MEM_32(region_size_ptr);
|
||||
dword_result_t NtFreeVirtualMemory(lpdword_t base_addr_ptr,
|
||||
lpdword_t region_size_ptr, dword_t free_type,
|
||||
dword_t debug_memory) {
|
||||
uint32_t base_addr_value = *base_addr_ptr;
|
||||
uint32_t region_size_value = *region_size_ptr;
|
||||
// X_MEM_DECOMMIT | X_MEM_RELEASE
|
||||
uint32_t free_type = SHIM_GET_ARG_32(2);
|
||||
uint32_t debug_memory = SHIM_GET_ARG_32(3);
|
||||
|
||||
XELOGD("NtFreeVirtualMemory(%.8X(%.8X), %.8X(%.8X), %.8X, %.8X)",
|
||||
base_addr_ptr, base_addr_value, region_size_ptr, region_size_value,
|
||||
free_type, debug_memory);
|
||||
|
||||
// NTSTATUS
|
||||
// _Inout_ PVOID *BaseAddress,
|
||||
|
|
@ -188,11 +181,10 @@ SHIM_CALL NtFreeVirtualMemory_shim(PPCContext* ppc_context,
|
|||
assert_true(debug_memory == 0);
|
||||
|
||||
if (!base_addr_value) {
|
||||
SHIM_SET_RETURN_32(X_STATUS_MEMORY_NOT_ALLOCATED);
|
||||
return;
|
||||
return X_STATUS_MEMORY_NOT_ALLOCATED;
|
||||
}
|
||||
|
||||
auto heap = kernel_state->memory()->LookupHeap(base_addr_value);
|
||||
auto heap = kernel_state()->memory()->LookupHeap(base_addr_value);
|
||||
bool result = false;
|
||||
if (free_type == X_MEM_DECOMMIT) {
|
||||
// If zero, we may need to query size (free whole region).
|
||||
|
|
@ -204,14 +196,14 @@ SHIM_CALL NtFreeVirtualMemory_shim(PPCContext* ppc_context,
|
|||
result = heap->Release(base_addr_value, ®ion_size_value);
|
||||
}
|
||||
if (!result) {
|
||||
SHIM_SET_RETURN_32(X_STATUS_UNSUCCESSFUL);
|
||||
return;
|
||||
return X_STATUS_UNSUCCESSFUL;
|
||||
}
|
||||
|
||||
SHIM_SET_MEM_32(base_addr_ptr, base_addr_value);
|
||||
SHIM_SET_MEM_32(region_size_ptr, region_size_value);
|
||||
SHIM_SET_RETURN_32(X_STATUS_SUCCESS);
|
||||
*base_addr_ptr = base_addr_value;
|
||||
*region_size_ptr = region_size_value;
|
||||
return X_STATUS_SUCCESS;
|
||||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(NtFreeVirtualMemory, ExportTag::kImplemented);
|
||||
|
||||
struct X_MEMORY_BASIC_INFORMATION {
|
||||
be<uint32_t> base_address;
|
||||
|
|
@ -223,30 +215,22 @@ struct X_MEMORY_BASIC_INFORMATION {
|
|||
be<uint32_t> type;
|
||||
};
|
||||
|
||||
SHIM_CALL NtQueryVirtualMemory_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t base_address = SHIM_GET_ARG_32(0);
|
||||
uint32_t memory_basic_information_ptr = SHIM_GET_ARG_32(1);
|
||||
auto memory_basic_information =
|
||||
SHIM_STRUCT(X_MEMORY_BASIC_INFORMATION, memory_basic_information_ptr);
|
||||
|
||||
XELOGD("NtQueryVirtualMemory(%.8X, %.8X)", base_address,
|
||||
memory_basic_information_ptr);
|
||||
|
||||
auto heap = kernel_state->memory()->LookupHeap(base_address);
|
||||
dword_result_t NtQueryVirtualMemory(
|
||||
dword_t base_address,
|
||||
pointer_t<X_MEMORY_BASIC_INFORMATION> memory_basic_information_ptr) {
|
||||
auto heap = kernel_state()->memory()->LookupHeap(base_address);
|
||||
HeapAllocationInfo alloc_info;
|
||||
if (heap == nullptr || !heap->QueryRegionInfo(base_address, &alloc_info)) {
|
||||
SHIM_SET_RETURN_32(X_STATUS_INVALID_PARAMETER);
|
||||
return;
|
||||
return X_STATUS_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
memory_basic_information->base_address =
|
||||
memory_basic_information_ptr->base_address =
|
||||
static_cast<uint32_t>(alloc_info.base_address);
|
||||
memory_basic_information->allocation_base =
|
||||
memory_basic_information_ptr->allocation_base =
|
||||
static_cast<uint32_t>(alloc_info.allocation_base);
|
||||
memory_basic_information->allocation_protect =
|
||||
memory_basic_information_ptr->allocation_protect =
|
||||
ToXdkProtectFlags(alloc_info.allocation_protect);
|
||||
memory_basic_information->region_size =
|
||||
memory_basic_information_ptr->region_size =
|
||||
static_cast<uint32_t>(alloc_info.region_size);
|
||||
uint32_t x_state = 0;
|
||||
if (alloc_info.state & kMemoryAllocationReserve) {
|
||||
|
|
@ -255,12 +239,13 @@ SHIM_CALL NtQueryVirtualMemory_shim(PPCContext* ppc_context,
|
|||
if (alloc_info.state & kMemoryAllocationCommit) {
|
||||
x_state |= X_MEM_COMMIT;
|
||||
}
|
||||
memory_basic_information->state = x_state;
|
||||
memory_basic_information->protect = ToXdkProtectFlags(alloc_info.protect);
|
||||
memory_basic_information->type = alloc_info.type;
|
||||
memory_basic_information_ptr->state = x_state;
|
||||
memory_basic_information_ptr->protect = ToXdkProtectFlags(alloc_info.protect);
|
||||
memory_basic_information_ptr->type = alloc_info.type;
|
||||
|
||||
SHIM_SET_RETURN_32(X_STATUS_SUCCESS);
|
||||
return X_STATUS_SUCCESS;
|
||||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(NtQueryVirtualMemory, ExportTag::kImplemented);
|
||||
|
||||
dword_result_t MmAllocatePhysicalMemoryEx(dword_t flags, dword_t region_size,
|
||||
dword_t protect_bits,
|
||||
|
|
@ -316,60 +301,53 @@ dword_result_t MmAllocatePhysicalMemoryEx(dword_t flags, dword_t region_size,
|
|||
DECLARE_XBOXKRNL_EXPORT(MmAllocatePhysicalMemoryEx,
|
||||
ExportTag::kImplemented | ExportTag::kMemory);
|
||||
|
||||
SHIM_CALL MmFreePhysicalMemory_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t type = SHIM_GET_ARG_32(0);
|
||||
uint32_t base_address = SHIM_GET_ARG_32(1);
|
||||
|
||||
XELOGD("MmFreePhysicalAddress(%d, %.8X)", type, base_address);
|
||||
|
||||
dword_result_t MmFreePhysicalMemory(dword_t type, dword_t base_address) {
|
||||
// base_address = result of MmAllocatePhysicalMemory.
|
||||
|
||||
assert_true((base_address & 0x1F) == 0);
|
||||
|
||||
auto heap = kernel_state->memory()->LookupHeap(base_address);
|
||||
heap->Release(base_address);
|
||||
auto heap = kernel_state()->memory()->LookupHeap(base_address);
|
||||
if (heap->Release(base_address)) {
|
||||
return X_STATUS_SUCCESS;
|
||||
}
|
||||
return X_STATUS_UNSUCCESSFUL;
|
||||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(MmFreePhysicalMemory, ExportTag::kImplemented);
|
||||
|
||||
SHIM_CALL MmQueryAddressProtect_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t base_address = SHIM_GET_ARG_32(0);
|
||||
|
||||
XELOGD("MmQueryAddressProtect(%.8X)", base_address);
|
||||
|
||||
auto heap = kernel_state->memory()->LookupHeap(base_address);
|
||||
dword_result_t MmQueryAddressProtect(dword_t base_address) {
|
||||
auto heap = kernel_state()->memory()->LookupHeap(base_address);
|
||||
uint32_t access;
|
||||
if (!heap->QueryProtect(base_address, &access)) {
|
||||
access = 0;
|
||||
}
|
||||
access = ToXdkProtectFlags(access);
|
||||
|
||||
SHIM_SET_RETURN_32(access);
|
||||
return access;
|
||||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(MmQueryAddressProtect, ExportTag::kImplemented);
|
||||
|
||||
void MmSetAddressProtect(lpvoid_t base_address, dword_t region_size,
|
||||
dword_t protect_bits) {
|
||||
dword_result_t MmSetAddressProtect(lpvoid_t base_address, dword_t region_size,
|
||||
dword_t protect_bits) {
|
||||
uint32_t protect = FromXdkProtectFlags(protect_bits);
|
||||
auto heap = kernel_memory()->LookupHeap(base_address);
|
||||
heap->Protect(base_address.guest_address(), region_size, protect);
|
||||
if (heap->Protect(base_address.guest_address(), region_size, protect)) {
|
||||
return X_STATUS_SUCCESS;
|
||||
}
|
||||
return X_STATUS_UNSUCCESSFUL;
|
||||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(MmSetAddressProtect,
|
||||
ExportTag::kImplemented | ExportTag::kMemory);
|
||||
|
||||
SHIM_CALL MmQueryAllocationSize_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t base_address = SHIM_GET_ARG_32(0);
|
||||
|
||||
XELOGD("MmQueryAllocationSize(%.8X)", base_address);
|
||||
|
||||
auto heap = kernel_state->memory()->LookupHeap(base_address);
|
||||
dword_result_t MmQueryAllocationSize(lpvoid_t base_address) {
|
||||
auto heap = kernel_state()->memory()->LookupHeap(base_address);
|
||||
uint32_t size;
|
||||
if (!heap->QuerySize(base_address, &size)) {
|
||||
size = 0;
|
||||
}
|
||||
|
||||
SHIM_SET_RETURN_32(size);
|
||||
return size;
|
||||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(MmQueryAllocationSize, ExportTag::kImplemented);
|
||||
|
||||
// https://code.google.com/p/vdash/source/browse/trunk/vdash/include/kernel.h
|
||||
struct X_MM_QUERY_STATISTICS_SECTION {
|
||||
|
|
@ -396,37 +374,29 @@ struct X_MM_QUERY_STATISTICS_RESULT {
|
|||
};
|
||||
static_assert_size(X_MM_QUERY_STATISTICS_RESULT, 104);
|
||||
|
||||
SHIM_CALL MmQueryStatistics_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t stats_ptr = SHIM_GET_ARG_32(0);
|
||||
|
||||
XELOGD("MmQueryStatistics(%.8X)", stats_ptr);
|
||||
|
||||
if (stats_ptr == 0) {
|
||||
SHIM_SET_RETURN_32(X_STATUS_INVALID_PARAMETER);
|
||||
return;
|
||||
dword_result_t MmQueryStatistics(
|
||||
pointer_t<X_MM_QUERY_STATISTICS_RESULT> stats_ptr) {
|
||||
if (!stats_ptr) {
|
||||
return X_STATUS_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
const uint32_t size = sizeof(X_MM_QUERY_STATISTICS_RESULT);
|
||||
|
||||
auto stats =
|
||||
reinterpret_cast<X_MM_QUERY_STATISTICS_RESULT*>(SHIM_MEM_ADDR(stats_ptr));
|
||||
if (stats->size != size) {
|
||||
SHIM_SET_RETURN_32(X_STATUS_BUFFER_TOO_SMALL);
|
||||
return;
|
||||
if (stats_ptr->size != size) {
|
||||
return X_STATUS_BUFFER_TOO_SMALL;
|
||||
}
|
||||
|
||||
// Zero out the struct.
|
||||
std::memset(stats, 0, size);
|
||||
std::memset(stats_ptr, 0, size);
|
||||
|
||||
// Set the constants the game is likely asking for.
|
||||
// These numbers are mostly guessed. If the game is just checking for
|
||||
// memory, this should satisfy it. If it's actually verifying things
|
||||
// this won't work :/
|
||||
stats->size = size;
|
||||
stats_ptr->size = size;
|
||||
|
||||
stats->total_physical_pages = 0x00020000; // 512mb / 4kb pages
|
||||
stats->kernel_pages = 0x00000300;
|
||||
stats_ptr->total_physical_pages = 0x00020000; // 512mb / 4kb pages
|
||||
stats_ptr->kernel_pages = 0x00000300;
|
||||
|
||||
// TODO(gibbed): maybe use LookupHeapByType instead?
|
||||
auto heap_a = kernel_memory()->LookupHeap(0xA0000000);
|
||||
|
|
@ -447,45 +417,43 @@ SHIM_CALL MmQueryStatistics_shim(PPCContext* ppc_context,
|
|||
#undef GET_USED_PAGE_SIZE
|
||||
#undef GET_USED_PAGE_COUNT
|
||||
|
||||
assert_true(used_pages < stats->total_physical_pages);
|
||||
assert_true(used_pages < stats_ptr->total_physical_pages);
|
||||
|
||||
stats->title.available_pages = stats->total_physical_pages - used_pages;
|
||||
stats->title.total_virtual_memory_bytes = 0x2FFF0000; // TODO(gibbed): FIXME
|
||||
stats->title.reserved_virtual_memory_bytes =
|
||||
0x00160000; // TODO(gibbed): FIXME
|
||||
stats->title.physical_pages = 0x00001000; // TODO(gibbed): FIXME
|
||||
stats->title.pool_pages = 0x00000010;
|
||||
stats->title.stack_pages = 0x00000100;
|
||||
stats->title.image_pages = 0x00000100;
|
||||
stats->title.heap_pages = 0x00000100;
|
||||
stats->title.virtual_pages = 0x00000100;
|
||||
stats->title.page_table_pages = 0x00000100;
|
||||
stats->title.cache_pages = 0x00000100;
|
||||
stats_ptr->title.available_pages =
|
||||
stats_ptr->total_physical_pages - used_pages;
|
||||
stats_ptr->title.total_virtual_memory_bytes =
|
||||
0x2FFF0000; // TODO(gibbed): FIXME
|
||||
stats_ptr->title.reserved_virtual_memory_bytes =
|
||||
0x00160000; // TODO(gibbed): FIXME
|
||||
stats_ptr->title.physical_pages = 0x00001000; // TODO(gibbed): FIXME
|
||||
stats_ptr->title.pool_pages = 0x00000010;
|
||||
stats_ptr->title.stack_pages = 0x00000100;
|
||||
stats_ptr->title.image_pages = 0x00000100;
|
||||
stats_ptr->title.heap_pages = 0x00000100;
|
||||
stats_ptr->title.virtual_pages = 0x00000100;
|
||||
stats_ptr->title.page_table_pages = 0x00000100;
|
||||
stats_ptr->title.cache_pages = 0x00000100;
|
||||
|
||||
stats->system.available_pages = 0x00000000;
|
||||
stats->system.total_virtual_memory_bytes = 0x00000000;
|
||||
stats->system.reserved_virtual_memory_bytes = 0x00000000;
|
||||
stats->system.physical_pages = 0x00000000;
|
||||
stats->system.pool_pages = 0x00000000;
|
||||
stats->system.stack_pages = 0x00000000;
|
||||
stats->system.image_pages = 0x00000000;
|
||||
stats->system.heap_pages = 0x00000000;
|
||||
stats->system.virtual_pages = 0x00000000;
|
||||
stats->system.page_table_pages = 0x00000000;
|
||||
stats->system.cache_pages = 0x00000000;
|
||||
stats_ptr->system.available_pages = 0x00000000;
|
||||
stats_ptr->system.total_virtual_memory_bytes = 0x00000000;
|
||||
stats_ptr->system.reserved_virtual_memory_bytes = 0x00000000;
|
||||
stats_ptr->system.physical_pages = 0x00000000;
|
||||
stats_ptr->system.pool_pages = 0x00000000;
|
||||
stats_ptr->system.stack_pages = 0x00000000;
|
||||
stats_ptr->system.image_pages = 0x00000000;
|
||||
stats_ptr->system.heap_pages = 0x00000000;
|
||||
stats_ptr->system.virtual_pages = 0x00000000;
|
||||
stats_ptr->system.page_table_pages = 0x00000000;
|
||||
stats_ptr->system.cache_pages = 0x00000000;
|
||||
|
||||
stats->highest_physical_page = 0x0001FFFF;
|
||||
stats_ptr->highest_physical_page = 0x0001FFFF;
|
||||
|
||||
SHIM_SET_RETURN_32(X_STATUS_SUCCESS);
|
||||
return X_STATUS_SUCCESS;
|
||||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(MmQueryStatistics, ExportTag::kImplemented);
|
||||
|
||||
// http://msdn.microsoft.com/en-us/library/windows/hardware/ff554547(v=vs.85).aspx
|
||||
SHIM_CALL MmGetPhysicalAddress_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t base_address = SHIM_GET_ARG_32(0);
|
||||
|
||||
XELOGD("MmGetPhysicalAddress(%.8X)", base_address);
|
||||
|
||||
dword_result_t MmGetPhysicalAddress(dword_t base_address) {
|
||||
// PHYSICAL_ADDRESS MmGetPhysicalAddress(
|
||||
// _In_ PVOID BaseAddress
|
||||
// );
|
||||
|
|
@ -497,18 +465,12 @@ SHIM_CALL MmGetPhysicalAddress_shim(PPCContext* ppc_context,
|
|||
physical_address += 0x1000;
|
||||
}
|
||||
|
||||
SHIM_SET_RETURN_32(physical_address);
|
||||
return physical_address;
|
||||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(MmGetPhysicalAddress, ExportTag::kImplemented);
|
||||
|
||||
SHIM_CALL MmMapIoSpace_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t unk0 = SHIM_GET_ARG_32(0);
|
||||
uint32_t src_address = SHIM_GET_ARG_32(1); // from MmGetPhysicalAddress
|
||||
uint32_t size = SHIM_GET_ARG_32(2);
|
||||
uint32_t flags = SHIM_GET_ARG_32(3);
|
||||
|
||||
XELOGD("MmMapIoSpace(%.8X, %.8X, %d, %.8X)", unk0, src_address, size, flags);
|
||||
|
||||
dword_result_t MmMapIoSpace(dword_t unk0, lpvoid_t src_address, dword_t size,
|
||||
dword_t flags) {
|
||||
// I've only seen this used to map XMA audio contexts.
|
||||
// The code seems fine with taking the src address, so this just returns that.
|
||||
// If others start using it there could be problems.
|
||||
|
|
@ -516,17 +478,12 @@ SHIM_CALL MmMapIoSpace_shim(PPCContext* ppc_context,
|
|||
assert_true(size == 0x40);
|
||||
assert_true(flags == 0x404);
|
||||
|
||||
SHIM_SET_RETURN_32(src_address);
|
||||
return 0;
|
||||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(MmMapIoSpace, ExportTag::kImplemented);
|
||||
|
||||
SHIM_CALL ExAllocatePoolTypeWithTag_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t size = SHIM_GET_ARG_32(0);
|
||||
uint32_t tag = SHIM_GET_ARG_32(1);
|
||||
uint32_t zero = SHIM_GET_ARG_32(2);
|
||||
|
||||
XELOGD("ExAllocatePoolTypeWithTag(%d, %.4s, %d)", size, &tag, zero);
|
||||
|
||||
dword_result_t ExAllocatePoolTypeWithTag(dword_t size, dword_t tag,
|
||||
dword_t zero) {
|
||||
uint32_t alignment = 8;
|
||||
uint32_t adjusted_size = size;
|
||||
if (adjusted_size < 4 * 1024) {
|
||||
|
|
@ -536,18 +493,16 @@ SHIM_CALL ExAllocatePoolTypeWithTag_shim(PPCContext* ppc_context,
|
|||
}
|
||||
|
||||
uint32_t addr =
|
||||
kernel_state->memory()->SystemHeapAlloc(adjusted_size, alignment);
|
||||
kernel_state()->memory()->SystemHeapAlloc(adjusted_size, alignment);
|
||||
|
||||
SHIM_SET_RETURN_32(addr);
|
||||
return addr;
|
||||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(ExAllocatePoolTypeWithTag, ExportTag::kImplemented);
|
||||
|
||||
SHIM_CALL ExFreePool_shim(PPCContext* ppc_context, KernelState* kernel_state) {
|
||||
uint32_t base_address = SHIM_GET_ARG_32(0);
|
||||
|
||||
XELOGD("ExFreePool(%.8X)", base_address);
|
||||
|
||||
kernel_state->memory()->SystemHeapFree(base_address);
|
||||
void ExFreePool(lpvoid_t base_address) {
|
||||
kernel_state()->memory()->SystemHeapFree(base_address);
|
||||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(ExFreePool, ExportTag::kImplemented);
|
||||
|
||||
dword_result_t KeGetImagePageTableEntry(lpvoid_t address) {
|
||||
// Unknown
|
||||
|
|
@ -555,18 +510,14 @@ dword_result_t KeGetImagePageTableEntry(lpvoid_t address) {
|
|||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(KeGetImagePageTableEntry, ExportTag::kStub);
|
||||
|
||||
SHIM_CALL KeLockL2_shim(PPCContext* ppc_context, KernelState* kernel_state) {
|
||||
// Ignored for now. This is just a perf optimization, I think.
|
||||
// It may be useful as a hint for CPU-GPU transfer.
|
||||
|
||||
XELOGD("KeLockL2(?)");
|
||||
|
||||
SHIM_SET_RETURN_32(0);
|
||||
dword_result_t KeLockL2() {
|
||||
// TODO
|
||||
return 0;
|
||||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(KeLockL2, ExportTag::kStub);
|
||||
|
||||
SHIM_CALL KeUnlockL2_shim(PPCContext* ppc_context, KernelState* kernel_state) {
|
||||
XELOGD("KeUnlockL2(?)");
|
||||
}
|
||||
void KeUnlockL2() {}
|
||||
DECLARE_XBOXKRNL_EXPORT(KeUnlockL2, ExportTag::kStub);
|
||||
|
||||
dword_result_t MmCreateKernelStack(dword_t stack_size, dword_t r4) {
|
||||
assert_zero(r4); // Unknown argument.
|
||||
|
|
@ -596,23 +547,8 @@ dword_result_t MmDeleteKernelStack(lpvoid_t stack_base, lpvoid_t stack_end) {
|
|||
DECLARE_XBOXKRNL_EXPORT(MmDeleteKernelStack, ExportTag::kImplemented);
|
||||
|
||||
void RegisterMemoryExports(xe::cpu::ExportResolver* export_resolver,
|
||||
KernelState* kernel_state) {
|
||||
SHIM_SET_MAPPING("xboxkrnl.exe", NtFreeVirtualMemory, state);
|
||||
SHIM_SET_MAPPING("xboxkrnl.exe", NtQueryVirtualMemory, state);
|
||||
SHIM_SET_MAPPING("xboxkrnl.exe", MmFreePhysicalMemory, state);
|
||||
SHIM_SET_MAPPING("xboxkrnl.exe", MmQueryAddressProtect, state);
|
||||
SHIM_SET_MAPPING("xboxkrnl.exe", MmQueryAllocationSize, state);
|
||||
SHIM_SET_MAPPING("xboxkrnl.exe", MmQueryStatistics, state);
|
||||
SHIM_SET_MAPPING("xboxkrnl.exe", MmGetPhysicalAddress, state);
|
||||
SHIM_SET_MAPPING("xboxkrnl.exe", MmMapIoSpace, state);
|
||||
|
||||
SHIM_SET_MAPPING("xboxkrnl.exe", ExAllocatePoolTypeWithTag, state);
|
||||
SHIM_SET_MAPPING("xboxkrnl.exe", ExFreePool, state);
|
||||
|
||||
SHIM_SET_MAPPING("xboxkrnl.exe", KeLockL2, state);
|
||||
SHIM_SET_MAPPING("xboxkrnl.exe", KeUnlockL2, state);
|
||||
}
|
||||
KernelState* kernel_state) {}
|
||||
|
||||
} // namespace xboxkrnl
|
||||
} // namespace kernel
|
||||
} // namespace xe
|
||||
} // namespace xe
|
||||
|
|
@ -18,17 +18,13 @@ namespace xe {
|
|||
namespace kernel {
|
||||
namespace xboxkrnl {
|
||||
|
||||
SHIM_CALL KeEnableFpuExceptions_shim(PPCContext* ppc_context,
|
||||
KernelState* kernel_state) {
|
||||
uint32_t enabled = SHIM_GET_ARG_32(0);
|
||||
XELOGD("KeEnableFpuExceptions(%d)", enabled);
|
||||
void KeEnableFpuExceptions(dword_t enabled) {
|
||||
// TODO(benvanik): can we do anything about exceptions?
|
||||
}
|
||||
DECLARE_XBOXKRNL_EXPORT(KeEnableFpuExceptions, ExportTag::kStub);
|
||||
|
||||
void RegisterMiscExports(xe::cpu::ExportResolver* export_resolver,
|
||||
KernelState* kernel_state) {
|
||||
SHIM_SET_MAPPING("xboxkrnl.exe", KeEnableFpuExceptions, state);
|
||||
}
|
||||
KernelState* kernel_state) {}
|
||||
|
||||
} // namespace xboxkrnl
|
||||
} // namespace kernel
|
||||
|
|
|
|||
Loading…
Reference in New Issue