fabi/Xenia-Canary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

format shim conversion on some files

Browse Source 
xam_info.cc, xam_msg.cc, xam_notify.cc, xboxkrnl_memory.cc,
xboxkrnl_misc.cc
This commit is contained in:
Megamouse
2017-03-27 22:43:03 +02:00
parent 46504adcc0
commit c38accbb76
5 changed files with 198 additions and 357 deletions
Download Patch File Download Diff File Expand all files Collapse all files

85
src/xenia/kernel/xam/xam_info.cc
View File

@@ -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

106
src/xenia/kernel/xam/xam_msg.cc
View File

@@ -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

72
src/xenia/kernel/xam/xam_notify.cc
View File

@@ -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