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

Code cleanup: moving ExportResolver to xe::cpu

Browse Source
This commit is contained in:
Ben Vanik
2015-05-02 02:11:11 -07:00
parent d76998915a
commit 642259e16f
50 changed files with 148 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/xenia/kernel/kernel_state.h
View File

@@ -13,7 +13,7 @@
#include <memory>
#include <mutex>
#include "xenia/export_resolver.h"
#include "xenia/cpu/export_resolver.h"
#include "xenia/kernel/app.h"
#include "xenia/kernel/content_manager.h"
#include "xenia/kernel/fs/filesystem.h"
@@ -49,7 +49,7 @@ class KernelState {
Memory* memory() const { return memory_; }
cpu::Processor* processor() const { return processor_; }
fs::FileSystem* file_system() const { return file_system_; }
uint32_t title_id() const;
Dispatcher* dispatcher() const { return dispatcher_; }

2
src/xenia/kernel/objects/xkernel_module.h
View File

@@ -28,7 +28,7 @@ class XKernelModule : public XModule {
protected:
Emulator* emulator_;
Memory* memory_;
ExportResolver* export_resolver_;
xe::cpu::ExportResolver* export_resolver_;
};
} // namespace kernel

2
src/xenia/kernel/objects/xuser_module.cc
View File

@@ -190,7 +190,7 @@ X_STATUS XUserModule::Launch(uint32_t flags) {
}
void XUserModule::Dump() {
ExportResolver* export_resolver =
xe::cpu::ExportResolver* export_resolver =
kernel_state_->emulator()->export_resolver();
const xe_xex2_header_t* header = xe_xex2_get_header(xex_);

2
src/xenia/kernel/objects/xuser_module.h
View File

@@ -12,7 +12,7 @@
#include "xenia/kernel/objects/xmodule.h"
#include "xenia/export_resolver.h"
#include "xenia/cpu/export_resolver.h"
#include "xenia/kernel/util/xex2.h"
#include "xenia/xbox.h"

2
src/xenia/kernel/util/export_table_pre.inc
View File

@@ -26,7 +26,7 @@
#define XE_EXPORT(module, ordinal, name, type, flags) \
{ \
ordinal, \
KernelExport::type, \
xe::cpu::KernelExport::type, \
flags, \
#name, \
}

9
src/xenia/kernel/util/shim_utils.h
View File

@@ -10,8 +10,8 @@
#ifndef XENIA_KERNEL_UTIL_SHIM_UTILS_H_
#define XENIA_KERNEL_UTIL_SHIM_UTILS_H_
#include "xenia/cpu/export_resolver.h"
#include "xenia/cpu/frontend/ppc_context.h"
#include "xenia/export_resolver.h"
namespace xe {
namespace kernel {
@@ -20,10 +20,9 @@ using PPCContext = xe::cpu::frontend::PPCContext;
#define SHIM_CALL void _cdecl
#define SHIM_SET_MAPPING(library_name, export_name, shim_data) \
export_resolver->SetFunctionMapping( \
library_name, ordinals::##export_name, \
shim_data, \
(xe_kernel_export_shim_fn)export_name##_shim);
export_resolver->SetFunctionMapping( \
library_name, ordinals::##export_name, shim_data, \
(xe::cpu::xe_kernel_export_shim_fn)export_name##_shim);
#define SHIM_MEM_BASE ppc_state->virtual_membase
#define SHIM_MEM_ADDR(a) (a ? (ppc_state->virtual_membase + a) : nullptr)

4
src/xenia/kernel/xam_content.cc
View File

@@ -535,8 +535,8 @@ SHIM_CALL XamContentDelete_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace kernel
} // namespace xe
void xe::kernel::xam::RegisterContentExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xam::RegisterContentExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xam.xex", XamContentGetLicenseMask, state);
SHIM_SET_MAPPING("xam.xex", XamShowDeviceSelectorUI, state);
SHIM_SET_MAPPING("xam.xex", XamContentGetDeviceName, state);

4
src/xenia/kernel/xam_info.cc
View File

@@ -186,8 +186,8 @@ SHIM_CALL XamEnumerate_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace kernel
} // namespace xe
void xe::kernel::xam::RegisterInfoExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xam::RegisterInfoExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xam.xex", XamGetSystemVersion, state);
SHIM_SET_MAPPING("xam.xex", XGetAVPack, state);
SHIM_SET_MAPPING("xam.xex", XGetGameRegion, state);

4
src/xenia/kernel/xam_input.cc
View File

@@ -195,8 +195,8 @@ SHIM_CALL XamUserGetDeviceContext_shim(PPCContext* ppc_state,
} // namespace kernel
} // namespace xe
void xe::kernel::xam::RegisterInputExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xam::RegisterInputExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xam.xex", XamResetInactivity, state);
SHIM_SET_MAPPING("xam.xex", XamEnableInactivityProcessing, state);
SHIM_SET_MAPPING("xam.xex", XamInputGetCapabilities, state);

5
src/xenia/kernel/xam_module.cc
View File

@@ -10,7 +10,6 @@
#include "xenia/kernel/xam_module.h"
#include "poly/math.h"
#include "xenia/export_resolver.h"
#include "xenia/kernel/kernel_state.h"
#include "xenia/kernel/xam_private.h"
@@ -34,7 +33,7 @@ XamModule::XamModule(Emulator* emulator, KernelState* kernel_state)
xam::RegisterVoiceExports(export_resolver_, kernel_state_);
}
void XamModule::RegisterExportTable(ExportResolver* export_resolver) {
void XamModule::RegisterExportTable(xe::cpu::ExportResolver* export_resolver) {
assert_not_null(export_resolver);
if (!export_resolver) {
@@ -43,7 +42,7 @@ void XamModule::RegisterExportTable(ExportResolver* export_resolver) {
// Build the export table used for resolution.
#include "xenia/kernel/util/export_table_pre.inc"
static KernelExport xam_export_table[] = {
static xe::cpu::KernelExport xam_export_table[] = {
#include "xenia/kernel/xam_table.inc"
};
#include "xenia/kernel/util/export_table_post.inc"

5
src/xenia/kernel/xam_module.h
View File

@@ -10,7 +10,7 @@
#ifndef XENIA_KERNEL_XAM_H_
#define XENIA_KERNEL_XAM_H_
#include "xenia/export_resolver.h"
#include "xenia/cpu/export_resolver.h"
#include "xenia/kernel/objects/xkernel_module.h"
#include "xenia/kernel/xam_ordinals.h"
@@ -22,7 +22,8 @@ class XamModule : public XKernelModule {
XamModule(Emulator* emulator, KernelState* kernel_state);
virtual ~XamModule();
static void RegisterExportTable(ExportResolver* export_resolver);
static void RegisterExportTable(xe::cpu::ExportResolver* export_resolver);
private:
};

4
src/xenia/kernel/xam_msg.cc
View File

@@ -117,8 +117,8 @@ SHIM_CALL XMsgCancelIORequest_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace kernel
} // namespace xe
void xe::kernel::xam::RegisterMsgExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xam::RegisterMsgExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xam.xex", XMsgInProcessCall, state);
SHIM_SET_MAPPING("xam.xex", XMsgSystemProcessCall, state);
SHIM_SET_MAPPING("xam.xex", XMsgStartIORequest, state);

4
src/xenia/kernel/xam_net.cc
View File

@@ -389,8 +389,8 @@ SHIM_CALL NetDll_sendto_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace kernel
} // namespace xe
void xe::kernel::xam::RegisterNetExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xam::RegisterNetExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xam.xex", NetDll_XNetStartup, state);
SHIM_SET_MAPPING("xam.xex", NetDll_XNetCleanup, state);
SHIM_SET_MAPPING("xam.xex", NetDll_XNetRandom, state);

4
src/xenia/kernel/xam_notify.cc
View File

@@ -102,8 +102,8 @@ SHIM_CALL XNotifyPositionUI_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace kernel
} // namespace xe
void xe::kernel::xam::RegisterNotifyExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xam::RegisterNotifyExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xam.xex", XamNotifyCreateListener, state);
SHIM_SET_MAPPING("xam.xex", XNotifyGetNext, state);
SHIM_SET_MAPPING("xam.xex", XNotifyDelayUI, state);

2
src/xenia/kernel/xam_ordinals.h
View File

@@ -10,7 +10,7 @@
#ifndef XENIA_KERNEL_XAM_ORDINALS_H_
#define XENIA_KERNEL_XAM_ORDINALS_H_
#include "xenia/export_resolver.h"
#include "xenia/cpu/export_resolver.h"
// Build an ordinal enum to make it easy to lookup ordinals.
#include "xenia/kernel/util/ordinal_table_pre.inc"

30
src/xenia/kernel/xam_private.h
View File

@@ -10,6 +10,7 @@
#ifndef XENIA_KERNEL_XAM_PRIVATE_H_
#define XENIA_KERNEL_XAM_PRIVATE_H_
#include "xenia/cpu/export_resolver.h"
#include "xenia/kernel/xam_ordinals.h"
namespace xe {
@@ -19,17 +20,26 @@ class KernelState;
namespace xam {
// Registration functions, one per file.
void RegisterContentExports(ExportResolver* export_resolver,
void RegisterContentExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterInfoExports(ExportResolver* export_resolver, KernelState* state);
void RegisterInputExports(ExportResolver* export_resolver, KernelState* state);
void RegisterMsgExports(ExportResolver* export_resolver, KernelState* state);
void RegisterNetExports(ExportResolver* export_resolver, KernelState* state);
void RegisterNotifyExports(ExportResolver* export_resolver, KernelState* state);
void RegisterUIExports(ExportResolver* export_resolver, KernelState* state);
void RegisterUserExports(ExportResolver* export_resolver, KernelState* state);
void RegisterVideoExports(ExportResolver* export_resolver, KernelState* state);
void RegisterVoiceExports(ExportResolver* export_resolver, KernelState* state);
void RegisterInfoExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterInputExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterMsgExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterNetExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterNotifyExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterUIExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterUserExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterVideoExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterVoiceExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
} // namespace xam
} // namespace kernel

4
src/xenia/kernel/xam_ui.cc
View File

@@ -61,7 +61,7 @@ SHIM_CALL XamShowMessageBoxUI_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace kernel
} // namespace xe
void xe::kernel::xam::RegisterUIExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xam::RegisterUIExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xam.xex", XamShowMessageBoxUI, state);
}

4
src/xenia/kernel/xam_user.cc
View File

@@ -442,8 +442,8 @@ SHIM_CALL XamSessionRefObjByHandle_shim(PPCContext* ppc_state, KernelState* stat
} // namespace kernel
} // namespace xe
void xe::kernel::xam::RegisterUserExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xam::RegisterUserExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xam.xex", XamUserGetXUID, state);
SHIM_SET_MAPPING("xam.xex", XamUserGetSigninState, state);
SHIM_SET_MAPPING("xam.xex", XamUserGetSigninInfo, state);

4
src/xenia/kernel/xam_video.cc
View File

@@ -26,7 +26,7 @@ SHIM_CALL XGetVideoMode_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace kernel
} // namespace xe
void xe::kernel::xam::RegisterVideoExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xam::RegisterVideoExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xam.xex", XGetVideoMode, state);
}

4
src/xenia/kernel/xam_voice.cc
View File

@@ -50,8 +50,8 @@ SHIM_CALL XamVoiceHeadsetPresent_shim(PPCContext* ppc_state,
} // namespace kernel
} // namespace xe
void xe::kernel::xam::RegisterVoiceExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xam::RegisterVoiceExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xam.xex", XamVoiceCreate, state);
SHIM_SET_MAPPING("xam.xex", XamVoiceClose, state);
SHIM_SET_MAPPING("xam.xex", XamVoiceHeadsetPresent, state);

4
src/xenia/kernel/xboxkrnl_audio.cc
View File

@@ -126,8 +126,8 @@ SHIM_CALL XAudioSubmitRenderDriverFrame_shim(PPCContext* ppc_state,
} // namespace kernel
} // namespace xe
void xe::kernel::xboxkrnl::RegisterAudioExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xboxkrnl::RegisterAudioExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
// Additional XMA* methods are in xboxkrnl_audio_xma.cc.
SHIM_SET_MAPPING("xboxkrnl.exe", XAudioGetSpeakerConfig, state);

2
src/xenia/kernel/xboxkrnl_audio_xma.cc
View File

@@ -468,7 +468,7 @@ SHIM_CALL XMABlockWhileInUse_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace xe
void xe::kernel::xboxkrnl::RegisterAudioXmaExports(
ExportResolver* export_resolver, KernelState* state) {
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
// Used for both XMA* methods and direct register access.
SHIM_SET_MAPPING("xboxkrnl.exe", XMACreateContext, state);
SHIM_SET_MAPPING("xboxkrnl.exe", XMAReleaseContext, state);

4
src/xenia/kernel/xboxkrnl_debug.cc
View File

@@ -283,8 +283,8 @@ SHIM_CALL KeBugCheckEx_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace kernel
} // namespace xe
void xe::kernel::xboxkrnl::RegisterDebugExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xboxkrnl::RegisterDebugExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xboxkrnl.exe", DbgPrint, state);
SHIM_SET_MAPPING("xboxkrnl.exe", DbgBreakPoint, state);
SHIM_SET_MAPPING("xboxkrnl.exe", RtlRaiseException, state);

4
src/xenia/kernel/xboxkrnl_hal.cc
View File

@@ -36,7 +36,7 @@ SHIM_CALL HalReturnToFirmware_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace kernel
} // namespace xe
void xe::kernel::xboxkrnl::RegisterHalExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xboxkrnl::RegisterHalExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xboxkrnl.exe", HalReturnToFirmware, state);
}

4
src/xenia/kernel/xboxkrnl_io.cc
View File

@@ -740,8 +740,8 @@ SHIM_CALL FscSetCacheElementCount_shim(PPCContext* ppc_state,
} // namespace kernel
} // namespace xe
void xe::kernel::xboxkrnl::RegisterIoExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xboxkrnl::RegisterIoExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xboxkrnl.exe", NtCreateFile, state);
SHIM_SET_MAPPING("xboxkrnl.exe", NtOpenFile, state);
SHIM_SET_MAPPING("xboxkrnl.exe", NtReadFile, state);

2
src/xenia/kernel/xboxkrnl_memory.cc
View File

@@ -451,7 +451,7 @@ SHIM_CALL KeUnlockL2_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace xe
void xe::kernel::xboxkrnl::RegisterMemoryExports(
ExportResolver* export_resolver, KernelState* state) {
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xboxkrnl.exe", NtAllocateVirtualMemory, state);
SHIM_SET_MAPPING("xboxkrnl.exe", NtFreeVirtualMemory, state);
SHIM_SET_MAPPING("xboxkrnl.exe", NtQueryVirtualMemory, state);

4
src/xenia/kernel/xboxkrnl_misc.cc
View File

@@ -27,7 +27,7 @@ SHIM_CALL KeEnableFpuExceptions_shim(PPCContext* ppc_state,
} // namespace kernel
} // namespace xe
void xe::kernel::xboxkrnl::RegisterMiscExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xboxkrnl::RegisterMiscExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xboxkrnl.exe", KeEnableFpuExceptions, state);
}

6
src/xenia/kernel/xboxkrnl_module.cc
View File

@@ -12,7 +12,6 @@
#include <gflags/gflags.h>
#include "poly/math.h"
#include "xenia/emulator.h"
#include "xenia/export_resolver.h"
#include "xenia/kernel/kernel_state.h"
#include "xenia/kernel/xboxkrnl_private.h"
#include "xenia/kernel/objects/xuser_module.h"
@@ -149,7 +148,8 @@ XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state)
WT_EXECUTEINTIMERTHREAD);
}
void XboxkrnlModule::RegisterExportTable(ExportResolver* export_resolver) {
void XboxkrnlModule::RegisterExportTable(
xe::cpu::ExportResolver* export_resolver) {
assert_not_null(export_resolver);
if (!export_resolver) {
@@ -158,7 +158,7 @@ void XboxkrnlModule::RegisterExportTable(ExportResolver* export_resolver) {
// Build the export table used for resolution.
#include "xenia/kernel/util/export_table_pre.inc"
static KernelExport xboxkrnl_export_table[] = {
static xe::cpu::KernelExport xboxkrnl_export_table[] = {
#include "xenia/kernel/xboxkrnl_table.inc"
};
#include "xenia/kernel/util/export_table_post.inc"

4
src/xenia/kernel/xboxkrnl_module.h
View File

@@ -10,7 +10,7 @@
#ifndef XENIA_KERNEL_XBOXKRNL_MODULE_H_
#define XENIA_KERNEL_XBOXKRNL_MODULE_H_
#include "xenia/export_resolver.h"
#include "xenia/cpu/export_resolver.h"
#include "xenia/kernel/objects/xkernel_module.h"
#include "xenia/kernel/xboxkrnl_ordinals.h"
@@ -27,7 +27,7 @@ class XboxkrnlModule : public XKernelModule {
XboxkrnlModule(Emulator* emulator, KernelState* kernel_state);
virtual ~XboxkrnlModule();
static void RegisterExportTable(ExportResolver* export_resolver);
static void RegisterExportTable(xe::cpu::ExportResolver* export_resolver);
int LaunchModule(const char* path);

2
src/xenia/kernel/xboxkrnl_modules.cc
View File

@@ -301,7 +301,7 @@ SHIM_CALL ExRegisterTitleTerminateNotification_shim(PPCContext* ppc_state,
} // namespace xe
void xe::kernel::xboxkrnl::RegisterModuleExports(
ExportResolver* export_resolver, KernelState* state) {
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xboxkrnl.exe", ExGetXConfigSetting, state);
SHIM_SET_MAPPING("xboxkrnl.exe", XexCheckExecutablePrivilege, state);

4
src/xenia/kernel/xboxkrnl_ob.cc
View File

@@ -157,8 +157,8 @@ SHIM_CALL NtClose_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace kernel
} // namespace xe
void xe::kernel::xboxkrnl::RegisterObExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xboxkrnl::RegisterObExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xboxkrnl.exe", ObOpenObjectByName, state);
SHIM_SET_MAPPING("xboxkrnl.exe", ObReferenceObjectByHandle, state);
SHIM_SET_MAPPING("xboxkrnl.exe", ObDereferenceObject, state);

2
src/xenia/kernel/xboxkrnl_ordinals.h
View File

@@ -10,7 +10,7 @@
#ifndef XENIA_KERNEL_XBOXKRNL_ORDINALS_H_
#define XENIA_KERNEL_XBOXKRNL_ORDINALS_H_
#include "xenia/export_resolver.h"
#include "xenia/cpu/export_resolver.h"
// Build an ordinal enum to make it easy to lookup ordinals.
#include "xenia/kernel/util/ordinal_table_pre.inc"

40
src/xenia/kernel/xboxkrnl_private.h
View File

@@ -19,22 +19,34 @@ class KernelState;
namespace xboxkrnl {
// Registration functions, one per file.
void RegisterAudioExports(ExportResolver* export_resolver, KernelState* state);
void RegisterAudioXmaExports(ExportResolver* export_resolver,
void RegisterAudioExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterAudioXmaExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterDebugExports(ExportResolver* export_resolver, KernelState* state);
void RegisterHalExports(ExportResolver* export_resolver, KernelState* state);
void RegisterIoExports(ExportResolver* export_resolver, KernelState* state);
void RegisterMemoryExports(ExportResolver* export_resolver, KernelState* state);
void RegisterMiscExports(ExportResolver* export_resolver, KernelState* state);
void RegisterModuleExports(ExportResolver* export_resolver, KernelState* state);
void RegisterObExports(ExportResolver* export_resolver, KernelState* state);
void RegisterRtlExports(ExportResolver* export_resolver, KernelState* state);
void RegisterStringExports(ExportResolver* export_resolver, KernelState* state);
void RegisterThreadingExports(ExportResolver* export_resolver,
void RegisterDebugExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterHalExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterIoExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterMemoryExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterMiscExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterModuleExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterObExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterRtlExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterStringExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterThreadingExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterUsbcamExports(ExportResolver* export_resolver, KernelState* state);
void RegisterVideoExports(ExportResolver* export_resolver, KernelState* state);
void RegisterUsbcamExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
void RegisterVideoExports(xe::cpu::ExportResolver* export_resolver,
KernelState* state);
} // namespace xboxkrnl
} // namespace kernel

4
src/xenia/kernel/xboxkrnl_rtl.cc
View File

@@ -682,8 +682,8 @@ SHIM_CALL RtlTimeFieldsToTime_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace kernel
} // namespace xe
void xe::kernel::xboxkrnl::RegisterRtlExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xboxkrnl::RegisterRtlExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xboxkrnl.exe", RtlCompareMemory, state);
SHIM_SET_MAPPING("xboxkrnl.exe", RtlCompareMemoryUlong, state);
SHIM_SET_MAPPING("xboxkrnl.exe", RtlFillMemoryUlong, state);

2
src/xenia/kernel/xboxkrnl_strings.cc
View File

@@ -834,7 +834,7 @@ SHIM_CALL _vscwprintf_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace xe
void xe::kernel::xboxkrnl::RegisterStringExports(
ExportResolver* export_resolver, KernelState* state) {
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xboxkrnl.exe", sprintf, state);
SHIM_SET_MAPPING("xboxkrnl.exe", vsprintf, state);
SHIM_SET_MAPPING("xboxkrnl.exe", _vsnprintf, state);

2
src/xenia/kernel/xboxkrnl_threading.cc
View File

@@ -1282,7 +1282,7 @@ SHIM_CALL KeRemoveQueueDpc_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace xe
void xe::kernel::xboxkrnl::RegisterThreadingExports(
ExportResolver* export_resolver, KernelState* state) {
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xboxkrnl.exe", ExCreateThread, state);
SHIM_SET_MAPPING("xboxkrnl.exe", ExTerminateThread, state);
SHIM_SET_MAPPING("xboxkrnl.exe", NtResumeThread, state);

2
src/xenia/kernel/xboxkrnl_usbcam.cc
View File

@@ -37,7 +37,7 @@ SHIM_CALL XUsbcamGetState_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace xe
void xe::kernel::xboxkrnl::RegisterUsbcamExports(
ExportResolver* export_resolver, KernelState* state) {
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xboxkrnl.exe", XUsbcamCreate, state);
SHIM_SET_MAPPING("xboxkrnl.exe", XUsbcamGetState, state);
}

4
src/xenia/kernel/xboxkrnl_video.cc
View File

@@ -433,8 +433,8 @@ SHIM_CALL VdSwap_shim(PPCContext* ppc_state, KernelState* state) {
} // namespace kernel
} // namespace xe
void xe::kernel::xboxkrnl::RegisterVideoExports(ExportResolver* export_resolver,
KernelState* state) {
void xe::kernel::xboxkrnl::RegisterVideoExports(
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
SHIM_SET_MAPPING("xboxkrnl.exe", VdGetCurrentDisplayGamma, state);
SHIM_SET_MAPPING("xboxkrnl.exe", VdGetCurrentDisplayInformation, state);
SHIM_SET_MAPPING("xboxkrnl.exe", VdQueryVideoFlags, state);