ShuriZma
/
xenia
mirror of https://github.com/xenia-project/xenia.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[Kernel] Use tables for export groups.

This commit is contained in:
gibbed 2022-01-09 13:29:47 -06:00 committed by Rick Gibbed
parent 3ad0a7dab2
commit 12ec728989
44 changed files with 151 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -564,6 +564,11 @@ using xe::cpu::ExportTag;
xe::cpu::ExportCategory::category) \
<< xe::cpu::ExportTag::CategoryShift)));
#define DECLARE_EMPTY_REGISTER_EXPORTS(module_name, group_name) \
void xe::kernel::module_name::Register##group_name##Exports( \
xe::cpu::ExportResolver* export_resolver, \
xe::kernel::KernelState* kernel_state) {}
#define DECLARE_XAM_EXPORT_(name, category, tags) \
DECLARE_EXPORT(xam, name, category, tags)
#define DECLARE_XAM_EXPORT1(name, category, tag) \
@ -572,11 +577,17 @@ using xe::cpu::ExportTag;
DECLARE_EXPORT(xam, name, category, \
xe::cpu::ExportTag::tag1 | xe::cpu::ExportTag::tag2)
#define DECLARE_XAM_EMPTY_REGISTER_EXPORTS(group_name) \
DECLARE_EMPTY_REGISTER_EXPORTS(xam, group_name)
#define DECLARE_XBDM_EXPORT_(name, category, tags) \
DECLARE_EXPORT(xbdm, name, category, tags)
#define DECLARE_XBDM_EXPORT1(name, category, tag) \
DECLARE_EXPORT(xbdm, name, category, xe::cpu::ExportTag::tag)
#define DECLARE_XBDM_EMPTY_REGISTER_EXPORTS(group_name) \
DECLARE_EMPTY_REGISTER_EXPORTS(xbdm, group_name)
#define DECLARE_XBOXKRNL_EXPORT_(name, category, tags) \
DECLARE_EXPORT(xboxkrnl, name, category, tags)
#define DECLARE_XBOXKRNL_EXPORT1(name, category, tag) \
@ -593,6 +604,9 @@ using xe::cpu::ExportTag;
xe::cpu::ExportTag::tag1 | xe::cpu::ExportTag::tag2 | \
xe::cpu::ExportTag::tag3 | xe::cpu::ExportTag::tag4)
#define DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(group_name) \
DECLARE_EMPTY_REGISTER_EXPORTS(xboxkrnl, group_name)
} // namespace kernel
} // namespace xe

2
src/xenia/kernel/xam/xam_avatar.cc
View File

@ -41,3 +41,5 @@ void RegisterAvatarExports(xe::cpu::ExportResolver* export_resolver,
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(Avatar);

5
src/xenia/kernel/xam/xam_content.cc
View File

@ -420,9 +420,8 @@ dword_result_t XamContentDeleteInternal_entry(lpvoid_t content_data_ptr,
}
DECLARE_XAM_EXPORT1(XamContentDeleteInternal, kContent, kImplemented);
void RegisterContentExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(Content);

5
src/xenia/kernel/xam/xam_content_aggregate.cc
View File

@ -139,9 +139,8 @@ dword_result_t XamContentAggregateCreateEnumerator_entry(qword_t xuid,
}
DECLARE_XAM_EXPORT1(XamContentAggregateCreateEnumerator, kContent, kStub);
void RegisterContentAggregateExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(ContentAggregate);

5
src/xenia/kernel/xam/xam_content_device.cc
View File

@ -167,9 +167,8 @@ dword_result_t XamContentCreateDeviceEnumerator_entry(dword_t content_type,
}
DECLARE_XAM_EXPORT1(XamContentCreateDeviceEnumerator, kNone, kImplemented);
void RegisterContentDeviceExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(ContentDevice);

5
src/xenia/kernel/xam/xam_enum.cc
View File

@ -110,9 +110,8 @@ dword_result_t XamGetPrivateEnumStructureFromHandle_entry(
}
DECLARE_XAM_EXPORT1(XamGetPrivateEnumStructureFromHandle, kNone, kStub);
void RegisterEnumExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(Enum);

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

@ -342,9 +342,8 @@ dword_result_t XamQueryLiveHiveW_entry(lpu16string_t name, lpvoid_t out_buf,
}
DECLARE_XAM_EXPORT1(XamQueryLiveHiveW, kNone, kStub);
void RegisterInfoExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(Info);

5
src/xenia/kernel/xam/xam_input.cc
View File

@ -194,9 +194,8 @@ X_HRESULT_result_t XamUserGetDeviceContext_entry(dword_t user_index,
}
DECLARE_XAM_EXPORT1(XamUserGetDeviceContext, kInput, kStub);
void RegisterInputExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(Input);

3
src/xenia/kernel/xam/xam_locale.cc
View File

@ -436,5 +436,4 @@ DECLARE_XAM_EXPORT1(XamGetLocaleEx, kLocale, kImplemented);
} // namespace kernel
} // namespace xe
void xe::kernel::xam::RegisterLocaleExports(
xe::cpu::ExportResolver* export_resolver, KernelState* kernel_state) {}
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(Locale);

1
src/xenia/kernel/xam/xam_module.cc
View File

@ -27,6 +27,7 @@ XamModule::XamModule(Emulator* emulator, KernelState* kernel_state)
: KernelModule(kernel_state, "xe:\\xam.xex"), loader_data_() {
RegisterExportTable(export_resolver_);
// Register all exported functions.
#define XE_MODULE_EXPORT_GROUP(m, n) \
Register##n##Exports(export_resolver_, kernel_state_);
#include "xam_module_export_groups.inc"

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

@ -135,9 +135,8 @@ dword_result_t XamGetOverlappedResult_entry(
}
DECLARE_XAM_EXPORT2(XamGetOverlappedResult, kNone, kImplemented, kSketchy);
void RegisterMsgExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(Msg);

5
src/xenia/kernel/xam/xam_net.cc
View File

@ -1031,9 +1031,8 @@ void NetDll_WSASetLastError_entry(dword_t error_code) {
}
DECLARE_XAM_EXPORT1(NetDll_WSASetLastError, kNetworking, kImplemented);
void RegisterNetExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(Net);

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

@ -102,9 +102,8 @@ void XNotifyPositionUI_entry(dword_t position) {
}
DECLARE_XAM_EXPORT1(XNotifyPositionUI, kNone, kStub);
void RegisterNotifyExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(Notify);

5
src/xenia/kernel/xam/xam_nui.cc
View File

@ -66,9 +66,8 @@ dword_result_t XamShowNuiTroubleshooterUI_entry(unknown_t unk1, unknown_t unk2,
}
DECLARE_XAM_EXPORT1(XamShowNuiTroubleshooterUI, kNone, kStub);
void RegisterNUIExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(NUI);

4
src/xenia/kernel/xam/xam_party.cc
View File

@ -40,8 +40,8 @@ dword_result_t XamPartyGetBandwidth_entry(dword_t r3, dword_t r4) {
}
DECLARE_XAM_EXPORT1(XamPartyGetBandwidth, kNone, kStub);
void RegisterPartyExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(Party);

5
src/xenia/kernel/xam/xam_task.cc
View File

@ -72,9 +72,8 @@ DECLARE_XAM_EXPORT2(XamTaskSchedule, kNone, kImplemented, kSketchy);
dword_result_t XamTaskShouldExit_entry(dword_t r3) { return 0; }
DECLARE_XAM_EXPORT2(XamTaskShouldExit, kNone, kStub, kSketchy);
void RegisterTaskExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(Task);

5
src/xenia/kernel/xam/xam_ui.cc
View File

@ -503,9 +503,8 @@ dword_result_t XamShowCommunitySessionsUI_entry(unknown_t r3, unknown_t r4) {
}
DECLARE_XAM_EXPORT1(XamShowCommunitySessionsUI, kNone, kStub);
void RegisterUIExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(UI);

3
src/xenia/kernel/xam/xam_user.cc
View File

@ -788,5 +788,4 @@ DECLARE_XAM_EXPORT1(XamSessionRefObjByHandle, kUserProfiles, kStub);
} // namespace kernel
} // namespace xe
void xe::kernel::xam::RegisterUserExports(
xe::cpu::ExportResolver* export_resolver, KernelState* kernel_state) {}
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(User);

5
src/xenia/kernel/xam/xam_video.cc
View File

@ -27,9 +27,8 @@ DECLARE_XAM_EXPORT1(XGetVideoMode, kVideo, ExportTag::kSketchy);
dword_result_t XGetVideoCapabilities_entry() { return 0; }
DECLARE_XAM_EXPORT1(XGetVideoCapabilities, kVideo, kStub);
void RegisterVideoExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(Video);

5
src/xenia/kernel/xam/xam_voice.cc
View File

@ -38,9 +38,8 @@ DECLARE_XAM_EXPORT1(XamVoiceClose, kNone, kStub);
dword_result_t XamVoiceHeadsetPresent_entry(lpunknown_t voice_ptr) { return 0; }
DECLARE_XAM_EXPORT1(XamVoiceHeadsetPresent, kNone, kStub);
void RegisterVoiceExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xam
} // namespace kernel
} // namespace xe
DECLARE_XAM_EMPTY_REGISTER_EXPORTS(Voice);

5
src/xenia/kernel/xbdm/xbdm_misc.cc
View File

@ -86,9 +86,8 @@ dword_result_t DmFindPdbSignature_entry(lpdword_t unk0_ptr,
}
DECLARE_XBDM_EXPORT1(DmFindPdbSignature, kDebug, kStub);
void RegisterMiscExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xbdm
} // namespace kernel
} // namespace xe
DECLARE_XBDM_EMPTY_REGISTER_EXPORTS(Misc);

7
src/xenia/kernel/xbdm/xbdm_module.cc
View File

@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Copyright 2022 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@ -24,7 +24,10 @@ XbdmModule::XbdmModule(Emulator* emulator, KernelState* kernel_state)
RegisterExportTable(export_resolver_);
// Register all exported functions.
RegisterMiscExports(export_resolver_, kernel_state_);
#define XE_MODULE_EXPORT_GROUP(m, n) \
Register##n##Exports(export_resolver_, kernel_state_);
#include "xbdm_module_export_groups.inc"
#undef XE_MODULE_EXPORT_GROUP
}
std::vector<xe::cpu::Export*> xbdm_exports(4096);

13
src/xenia/kernel/xbdm/xbdm_module_export_groups.inc Normal file
View File

@ -0,0 +1,13 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2022 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
// This is a partial file designed to be included by other files when
// constructing various tables.
XE_MODULE_EXPORT_GROUP(xbdm, Misc)

9
src/xenia/kernel/xbdm/xbdm_private.h
View File

@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Copyright 2022 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@ -21,8 +21,11 @@ namespace xbdm {
xe::cpu::Export* RegisterExport_xbdm(xe::cpu::Export* export_entry);
// Registration functions, one per file.
void RegisterMiscExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state);
#define XE_MODULE_EXPORT_GROUP(m, n) \
void Register##n##Exports(xe::cpu::ExportResolver* export_resolver, \
KernelState* kernel_state);
#include "xbdm_module_export_groups.inc"
#undef XE_MODULE_EXPORT_GROUP
} // namespace xbdm
} // namespace kernel

7
src/xenia/kernel/xboxkrnl/xboxkrnl_audio.cc
View File

@ -96,11 +96,8 @@ dword_result_t XAudioSubmitRenderDriverFrame_entry(lpunknown_t driver_ptr,
DECLARE_XBOXKRNL_EXPORT2(XAudioSubmitRenderDriverFrame, kAudio, kImplemented,
kHighFrequency);
void RegisterAudioExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {
// Additional XMA* methods are in xboxkrnl_audio_xma.cc.
}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Audio);

5
src/xenia/kernel/xboxkrnl/xboxkrnl_audio_xma.cc
View File

@ -392,9 +392,8 @@ dword_result_t XMABlockWhileInUse_entry(lpvoid_t context_ptr) {
DECLARE_XBOXKRNL_EXPORT2(XMABlockWhileInUse, kAudio, kImplemented,
kHighFrequency);
void RegisterAudioXmaExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(AudioXma);

5
src/xenia/kernel/xboxkrnl/xboxkrnl_crypt.cc
View File

@ -686,9 +686,8 @@ dword_result_t XeKeysHmacShaUsingKey_entry(lpvoid_t obscured_key,
}
DECLARE_XBOXKRNL_EXPORT1(XeKeysHmacShaUsingKey, kNone, kImplemented);
void RegisterCryptExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Crypt);

5
src/xenia/kernel/xboxkrnl/xboxkrnl_debug.cc
View File

@ -154,9 +154,8 @@ DECLARE_XBOXKRNL_EXPORT2(KeBugCheckEx, kDebug, kStub, kImportant);
void KeBugCheck_entry(dword_t code) { KeBugCheckEx_entry(code, 0, 0, 0, 0); }
DECLARE_XBOXKRNL_EXPORT2(KeBugCheck, kDebug, kImplemented, kImportant);
void RegisterDebugExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Debug);

5
src/xenia/kernel/xboxkrnl/xboxkrnl_error.cc
View File

@ -1017,9 +1017,8 @@ dword_result_t RtlNtStatusToDosError_entry(dword_t source_status) {
DECLARE_XBOXKRNL_EXPORT3(RtlNtStatusToDosError, kNone, kImportant,
kHighFrequency, kLogResult);
void RegisterErrorExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Error);

5
src/xenia/kernel/xboxkrnl/xboxkrnl_hal.cc
View File

@ -31,9 +31,8 @@ void HalReturnToFirmware_entry(dword_t routine) {
}
DECLARE_XBOXKRNL_EXPORT2(HalReturnToFirmware, kNone, kStub, kImportant);
void RegisterHalExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Hal);

5
src/xenia/kernel/xboxkrnl/xboxkrnl_hid.cc
View File

@ -32,9 +32,8 @@ dword_result_t HidReadKeys_entry(dword_t unk1, unknown_t unk2, unknown_t unk3) {
}
DECLARE_XBOXKRNL_EXPORT1(HidReadKeys, kInput, kStub);
void RegisterHidExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Hid);

5
src/xenia/kernel/xboxkrnl/xboxkrnl_io.cc
View File

@ -735,9 +735,8 @@ dword_result_t IoCreateDevice_entry(dword_t device_struct, dword_t r4,
}
DECLARE_XBOXKRNL_EXPORT1(IoCreateDevice, kFileSystem, kStub);
void RegisterIoExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Io);

5
src/xenia/kernel/xboxkrnl/xboxkrnl_io_info.cc
View File

@ -357,9 +357,8 @@ dword_result_t NtQueryVolumeInformationFile_entry(
DECLARE_XBOXKRNL_EXPORT1(NtQueryVolumeInformationFile, kFileSystem,
kImplemented);
void RegisterIoInfoExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(IoInfo);

7
src/xenia/kernel/xboxkrnl/xboxkrnl_memory.cc
View File

@ -649,9 +649,8 @@ dword_result_t MmDeleteKernelStack_entry(lpvoid_t stack_base,
}
DECLARE_XBOXKRNL_EXPORT1(MmDeleteKernelStack, kMemory, kImplemented);
void RegisterMemoryExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Memory);

5
src/xenia/kernel/xboxkrnl/xboxkrnl_misc.cc
View File

@ -23,9 +23,8 @@ void KeEnableFpuExceptions_entry(dword_t enabled) {
}
DECLARE_XBOXKRNL_EXPORT1(KeEnableFpuExceptions, kNone, kStub);
void RegisterMiscExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Misc);

23
src/xenia/kernel/xboxkrnl/xboxkrnl_module.cc
View File

@ -83,25 +83,10 @@ XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state)
RegisterExportTable(export_resolver_);
// Register all exported functions.
RegisterAudioExports(export_resolver_, kernel_state_);
RegisterAudioXmaExports(export_resolver_, kernel_state_);
RegisterCryptExports(export_resolver_, kernel_state_);
RegisterDebugExports(export_resolver_, kernel_state_);
RegisterErrorExports(export_resolver_, kernel_state_);
RegisterHalExports(export_resolver_, kernel_state_);
RegisterHidExports(export_resolver_, kernel_state_);
RegisterIoExports(export_resolver_, kernel_state_);
RegisterIoInfoExports(export_resolver_, kernel_state_);
RegisterMemoryExports(export_resolver_, kernel_state_);
RegisterMiscExports(export_resolver_, kernel_state_);
RegisterModuleExports(export_resolver_, kernel_state_);
RegisterObExports(export_resolver_, kernel_state_);
RegisterRtlExports(export_resolver_, kernel_state_);
RegisterStringExports(export_resolver_, kernel_state_);
RegisterThreadingExports(export_resolver_, kernel_state_);
RegisterUsbcamExports(export_resolver_, kernel_state_);
RegisterVideoExports(export_resolver_, kernel_state_);
RegisterXConfigExports(export_resolver_, kernel_state_);
#define XE_MODULE_EXPORT_GROUP(m, n) \
Register##n##Exports(export_resolver_, kernel_state_);
#include "xboxkrnl_module_export_groups.inc"
#undef XE_MODULE_EXPORT_GROUP
// KeDebugMonitorData (?*)
// Set to a valid value when a remote debugger is attached.

31
src/xenia/kernel/xboxkrnl/xboxkrnl_module_export_groups.inc Normal file
View File

@ -0,0 +1,31 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2022 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
// This is a partial file designed to be included by other files when
// constructing various tables.
XE_MODULE_EXPORT_GROUP(xboxkrnl, Audio)
XE_MODULE_EXPORT_GROUP(xboxkrnl, AudioXma)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Crypt)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Debug)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Error)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Hal)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Hid)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Io)
XE_MODULE_EXPORT_GROUP(xboxkrnl, IoInfo)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Memory)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Misc)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Module)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Ob)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Rtl)
XE_MODULE_EXPORT_GROUP(xboxkrnl, String)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Threading)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Usbcam)
XE_MODULE_EXPORT_GROUP(xboxkrnl, Video)
XE_MODULE_EXPORT_GROUP(xboxkrnl, XConfig)

5
src/xenia/kernel/xboxkrnl/xboxkrnl_modules.cc
View File

@ -199,9 +199,8 @@ void ExRegisterTitleTerminateNotification_entry(
DECLARE_XBOXKRNL_EXPORT1(ExRegisterTitleTerminateNotification, kModules,
kImplemented);
void RegisterModuleExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Module);

5
src/xenia/kernel/xboxkrnl/xboxkrnl_ob.cc
View File

@ -201,9 +201,8 @@ dword_result_t NtClose_entry(dword_t handle) {
}
DECLARE_XBOXKRNL_EXPORT1(NtClose, kNone, kImplemented);
void RegisterObExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Ob);

28
src/xenia/kernel/xboxkrnl/xboxkrnl_private.h
View File

@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2020 Ben Vanik. All rights reserved. *
* Copyright 2022 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@ -21,29 +21,11 @@ namespace xboxkrnl {
xe::cpu::Export* RegisterExport_xboxkrnl(xe::cpu::Export* export_entry);
// Registration functions, one per file.
#define DECLARE_REGISTER_EXPORTS(n) \
#define XE_MODULE_EXPORT_GROUP(m, n) \
void Register##n##Exports(xe::cpu::ExportResolver* export_resolver, \
KernelState* kernel_state)
DECLARE_REGISTER_EXPORTS(Audio);
DECLARE_REGISTER_EXPORTS(AudioXma);
DECLARE_REGISTER_EXPORTS(Crypt);
DECLARE_REGISTER_EXPORTS(Debug);
DECLARE_REGISTER_EXPORTS(Error);
DECLARE_REGISTER_EXPORTS(Hal);
DECLARE_REGISTER_EXPORTS(Hid);
DECLARE_REGISTER_EXPORTS(Io);
DECLARE_REGISTER_EXPORTS(IoInfo);
DECLARE_REGISTER_EXPORTS(Memory);
DECLARE_REGISTER_EXPORTS(Misc);
DECLARE_REGISTER_EXPORTS(Module);
DECLARE_REGISTER_EXPORTS(Ob);
DECLARE_REGISTER_EXPORTS(Rtl);
DECLARE_REGISTER_EXPORTS(String);
DECLARE_REGISTER_EXPORTS(Threading);
DECLARE_REGISTER_EXPORTS(Usbcam);
DECLARE_REGISTER_EXPORTS(Video);
DECLARE_REGISTER_EXPORTS(XConfig);
#undef DECLARE_REGISTER_EXPORTS
KernelState* kernel_state);
#include "xboxkrnl_module_export_groups.inc"
#undef XE_MODULE_EXPORT_GROUP
} // namespace xboxkrnl
} // namespace kernel

5
src/xenia/kernel/xboxkrnl/xboxkrnl_rtl.cc
View File

@ -624,9 +624,8 @@ dword_result_t RtlComputeCrc32_entry(dword_t seed, lpvoid_t buffer,
}
DECLARE_XBOXKRNL_EXPORT1(RtlComputeCrc32, kNone, kImplemented);
void RegisterRtlExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Rtl);

5
src/xenia/kernel/xboxkrnl/xboxkrnl_threading.cc
View File

@ -1383,9 +1383,8 @@ pointer_result_t InterlockedFlushSList_entry(
}
DECLARE_XBOXKRNL_EXPORT1(InterlockedFlushSList, kThreading, kImplemented);
void RegisterThreadingExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Threading);

5
src/xenia/kernel/xboxkrnl/xboxkrnl_usbcam.cc
View File

@ -37,9 +37,8 @@ dword_result_t XUsbcamGetState_entry() {
}
DECLARE_XBOXKRNL_EXPORT1(XUsbcamGetState, kNone, kStub);
void RegisterUsbcamExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(Usbcam);

5
src/xenia/kernel/xboxkrnl/xboxkrnl_xconfig.cc
View File

@ -138,9 +138,8 @@ dword_result_t ExGetXConfigSetting_entry(word_t category, word_t setting,
}
DECLARE_XBOXKRNL_EXPORT1(ExGetXConfigSetting, kModules, kImplemented);
void RegisterXConfigExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state) {}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
DECLARE_XBOXKRNL_EMPTY_REGISTER_EXPORTS(XConfig);