[Kernel] Suffix export functions with _entry.

src/xenia/kernel/xam/xam_avatar.cc

@@ -2,7 +2,7 @@
  ******************************************************************************
  * Xenia : Xbox 360 Emulator Research Project                                 *
  ******************************************************************************
- * Copyright 2015 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. *
  ******************************************************************************
  */
@@ -17,7 +17,7 @@ namespace xe {
 namespace kernel {
 namespace xam {
 
-dword_result_t XamAvatarInitialize(
+dword_result_t XamAvatarInitialize_entry(
     dword_t unk1,              // 1, 4, etc
     dword_t unk2,              // 0 or 1
     dword_t processor_number,  // for thread creation?
@@ -30,7 +30,7 @@ dword_result_t XamAvatarInitialize(
 }
 DECLARE_XAM_EXPORT1(XamAvatarInitialize, kAvatars, kStub);
 
-void XamAvatarShutdown() {
+void XamAvatarShutdown_entry() {
   // No-op.
 }
 DECLARE_XAM_EXPORT1(XamAvatarShutdown, kAvatars, kStub);

src/xenia/kernel/xam/xam_content.cc

@@ -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. *
  ******************************************************************************
  */
@@ -31,8 +31,8 @@ namespace xe {
 namespace kernel {
 namespace xam {
 
-dword_result_t XamContentGetLicenseMask(lpdword_t mask_ptr,
-                                        lpunknown_t overlapped_ptr) {
+dword_result_t XamContentGetLicenseMask_entry(lpdword_t mask_ptr,
+                                              lpunknown_t overlapped_ptr) {
   // Each bit in the mask represents a granted license. Available licenses
   // seems to vary from game to game, but most appear to use bit 0 to indicate
   // if the game is purchased or not.
@@ -48,9 +48,11 @@ dword_result_t XamContentGetLicenseMask(lpdword_t mask_ptr,
 }
 DECLARE_XAM_EXPORT2(XamContentGetLicenseMask, kContent, kStub, kHighFrequency);
 
-dword_result_t XamContentResolve(dword_t user_index, lpvoid_t content_data_ptr,
-                                 lpunknown_t buffer_ptr, dword_t buffer_size,
-                                 dword_t unk1, dword_t unk2, dword_t unk3) {
+dword_result_t XamContentResolve_entry(dword_t user_index,
+                                       lpvoid_t content_data_ptr,
+                                       lpunknown_t buffer_ptr,
+                                       dword_t buffer_size, dword_t unk1,
+                                       dword_t unk2, dword_t unk3) {
   auto content_data = content_data_ptr.as<XCONTENT_DATA*>();
 
   // Result of buffer_ptr is sent to RtlInitAnsiString.
@@ -64,12 +66,10 @@ DECLARE_XAM_EXPORT1(XamContentResolve, kContent, kStub);
 
 // https://github.com/MrColdbird/gameservice/blob/master/ContentManager.cpp
 // https://github.com/LestaD/SourceEngine2007/blob/master/se2007/engine/xboxsystem.cpp#L499
-dword_result_t XamContentCreateEnumerator(dword_t user_index, dword_t device_id,
-                                          dword_t content_type,
-                                          dword_t content_flags,
-                                          dword_t items_per_enumerate,
-                                          lpdword_t buffer_size_ptr,
-                                          lpdword_t handle_out) {
+dword_result_t XamContentCreateEnumerator_entry(
+    dword_t user_index, dword_t device_id, dword_t content_type,
+    dword_t content_flags, dword_t items_per_enumerate,
+    lpdword_t buffer_size_ptr, lpdword_t handle_out) {
   assert_not_null(handle_out);
 
   auto device_info = device_id == 0 ? nullptr : GetDummyDeviceInfo(device_id);
@@ -226,12 +226,10 @@ dword_result_t xeXamContentCreate(dword_t user_index, lpstring_t root_name,
   }
 }
 
-dword_result_t XamContentCreateEx(dword_t user_index, lpstring_t root_name,
-                                  lpvoid_t content_data_ptr, dword_t flags,
-                                  lpdword_t disposition_ptr,
-                                  lpdword_t license_mask_ptr,
-                                  dword_t cache_size, qword_t content_size,
-                                  lpvoid_t overlapped_ptr) {
+dword_result_t XamContentCreateEx_entry(
+    dword_t user_index, lpstring_t root_name, lpvoid_t content_data_ptr,
+    dword_t flags, lpdword_t disposition_ptr, lpdword_t license_mask_ptr,
+    dword_t cache_size, qword_t content_size, lpvoid_t overlapped_ptr) {
   return xeXamContentCreate(user_index, root_name, content_data_ptr,
                             sizeof(XCONTENT_DATA), flags, disposition_ptr,
                             license_mask_ptr, cache_size, content_size,
@@ -239,18 +237,18 @@ dword_result_t XamContentCreateEx(dword_t user_index, lpstring_t root_name,
 }
 DECLARE_XAM_EXPORT1(XamContentCreateEx, kContent, kImplemented);
 
-dword_result_t XamContentCreate(dword_t user_index, lpstring_t root_name,
-                                lpvoid_t content_data_ptr, dword_t flags,
-                                lpdword_t disposition_ptr,
-                                lpdword_t license_mask_ptr,
-                                lpvoid_t overlapped_ptr) {
+dword_result_t XamContentCreate_entry(dword_t user_index, lpstring_t root_name,
+                                      lpvoid_t content_data_ptr, dword_t flags,
+                                      lpdword_t disposition_ptr,
+                                      lpdword_t license_mask_ptr,
+                                      lpvoid_t overlapped_ptr) {
   return xeXamContentCreate(user_index, root_name, content_data_ptr,
                             sizeof(XCONTENT_DATA), flags, disposition_ptr,
                             license_mask_ptr, 0, 0, overlapped_ptr);
 }
 DECLARE_XAM_EXPORT1(XamContentCreate, kContent, kImplemented);
 
-dword_result_t XamContentCreateInternal(
+dword_result_t XamContentCreateInternal_entry(
     lpstring_t root_name, lpvoid_t content_data_ptr, dword_t flags,
     lpdword_t disposition_ptr, lpdword_t license_mask_ptr, dword_t cache_size,
     qword_t content_size, lpvoid_t overlapped_ptr) {
@@ -261,18 +259,19 @@ dword_result_t XamContentCreateInternal(
 }
 DECLARE_XAM_EXPORT1(XamContentCreateInternal, kContent, kImplemented);
 
-dword_result_t XamContentOpenFile(dword_t user_index, lpstring_t root_name,
-                                  lpstring_t path, dword_t flags,
-                                  lpdword_t disposition_ptr,
-                                  lpdword_t license_mask_ptr,
-                                  lpvoid_t overlapped_ptr) {
+dword_result_t XamContentOpenFile_entry(dword_t user_index,
+                                        lpstring_t root_name, lpstring_t path,
+                                        dword_t flags,
+                                        lpdword_t disposition_ptr,
+                                        lpdword_t license_mask_ptr,
+                                        lpvoid_t overlapped_ptr) {
   // TODO(gibbed): arguments assumed based on XamContentCreate.
   return X_ERROR_FILE_NOT_FOUND;
 }
 DECLARE_XAM_EXPORT1(XamContentOpenFile, kContent, kStub);
 
-dword_result_t XamContentFlush(lpstring_t root_name,
-                               lpunknown_t overlapped_ptr) {
+dword_result_t XamContentFlush_entry(lpstring_t root_name,
+                                     lpunknown_t overlapped_ptr) {
   X_RESULT result = X_ERROR_SUCCESS;
   if (overlapped_ptr) {
     kernel_state()->CompleteOverlappedImmediate(overlapped_ptr, result);
@@ -283,8 +282,8 @@ dword_result_t XamContentFlush(lpstring_t root_name,
 }
 DECLARE_XAM_EXPORT1(XamContentFlush, kContent, kStub);
 
-dword_result_t XamContentClose(lpstring_t root_name,
-                               lpunknown_t overlapped_ptr) {
+dword_result_t XamContentClose_entry(lpstring_t root_name,
+                                     lpunknown_t overlapped_ptr) {
   // Closes a previously opened root from XamContentCreate*.
   auto result =
       kernel_state()->content_manager()->CloseContent(root_name.value());
@@ -298,11 +297,11 @@ dword_result_t XamContentClose(lpstring_t root_name,
 }
 DECLARE_XAM_EXPORT1(XamContentClose, kContent, kImplemented);
 
-dword_result_t XamContentGetCreator(dword_t user_index,
-                                    lpvoid_t content_data_ptr,
-                                    lpdword_t is_creator_ptr,
-                                    lpqword_t creator_xuid_ptr,
-                                    lpunknown_t overlapped_ptr) {
+dword_result_t XamContentGetCreator_entry(dword_t user_index,
+                                          lpvoid_t content_data_ptr,
+                                          lpdword_t is_creator_ptr,
+                                          lpqword_t creator_xuid_ptr,
+                                          lpunknown_t overlapped_ptr) {
   auto result = X_ERROR_SUCCESS;
 
   XCONTENT_AGGREGATE_DATA content_data = *content_data_ptr.as<XCONTENT_DATA*>();
@@ -336,11 +335,11 @@ dword_result_t XamContentGetCreator(dword_t user_index,
 }
 DECLARE_XAM_EXPORT1(XamContentGetCreator, kContent, kImplemented);
 
-dword_result_t XamContentGetThumbnail(dword_t user_index,
-                                      lpvoid_t content_data_ptr,
-                                      lpvoid_t buffer_ptr,
-                                      lpdword_t buffer_size_ptr,
-                                      lpunknown_t overlapped_ptr) {
+dword_result_t XamContentGetThumbnail_entry(dword_t user_index,
+                                            lpvoid_t content_data_ptr,
+                                            lpvoid_t buffer_ptr,
+                                            lpdword_t buffer_size_ptr,
+                                            lpunknown_t overlapped_ptr) {
   assert_not_null(buffer_size_ptr);
   uint32_t buffer_size = *buffer_size_ptr;
   XCONTENT_AGGREGATE_DATA content_data = *content_data_ptr.as<XCONTENT_DATA*>();
@@ -375,10 +374,11 @@ dword_result_t XamContentGetThumbnail(dword_t user_index,
 }
 DECLARE_XAM_EXPORT1(XamContentGetThumbnail, kContent, kImplemented);
 
-dword_result_t XamContentSetThumbnail(dword_t user_index,
-                                      lpvoid_t content_data_ptr,
-                                      lpvoid_t buffer_ptr, dword_t buffer_size,
-                                      lpunknown_t overlapped_ptr) {
+dword_result_t XamContentSetThumbnail_entry(dword_t user_index,
+                                            lpvoid_t content_data_ptr,
+                                            lpvoid_t buffer_ptr,
+                                            dword_t buffer_size,
+                                            lpunknown_t overlapped_ptr) {
   XCONTENT_AGGREGATE_DATA content_data = *content_data_ptr.as<XCONTENT_DATA*>();
 
   // Buffer is PNG data.
@@ -396,8 +396,9 @@ dword_result_t XamContentSetThumbnail(dword_t user_index,
 }
 DECLARE_XAM_EXPORT1(XamContentSetThumbnail, kContent, kImplemented);
 
-dword_result_t XamContentDelete(dword_t user_index, lpvoid_t content_data_ptr,
-                                lpunknown_t overlapped_ptr) {
+dword_result_t XamContentDelete_entry(dword_t user_index,
+                                      lpvoid_t content_data_ptr,
+                                      lpunknown_t overlapped_ptr) {
   XCONTENT_AGGREGATE_DATA content_data = *content_data_ptr.as<XCONTENT_DATA*>();
 
   auto result = kernel_state()->content_manager()->DeleteContent(content_data);
@@ -411,11 +412,11 @@ dword_result_t XamContentDelete(dword_t user_index, lpvoid_t content_data_ptr,
 }
 DECLARE_XAM_EXPORT1(XamContentDelete, kContent, kImplemented);
 
-dword_result_t XamContentDeleteInternal(lpvoid_t content_data_ptr,
-                                        lpunknown_t overlapped_ptr) {
+dword_result_t XamContentDeleteInternal_entry(lpvoid_t content_data_ptr,
+                                              lpunknown_t overlapped_ptr) {
   // INFO: Analysis of xam.xex shows that "internal" functions are wrappers with
   // 0xFE as user_index
-  return XamContentDelete(0xFE, content_data_ptr, overlapped_ptr);
+  return XamContentDelete_entry(0xFE, content_data_ptr, overlapped_ptr);
 }
 DECLARE_XAM_EXPORT1(XamContentDeleteInternal, kContent, kImplemented);
 

src/xenia/kernel/xam/xam_content_aggregate.cc

@@ -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. *
  ******************************************************************************
  */
@@ -76,11 +76,11 @@ void AddODDContentTest(object_ref<XStaticEnumerator<XCONTENT_AGGREGATE_DATA>> e,
   }
 }
 
-dword_result_t XamContentAggregateCreateEnumerator(qword_t xuid,
-                                                   dword_t device_id,
-                                                   dword_t content_type,
-                                                   unknown_t unk3,
-                                                   lpdword_t handle_out) {
+dword_result_t XamContentAggregateCreateEnumerator_entry(qword_t xuid,
+                                                         dword_t device_id,
+                                                         dword_t content_type,
+                                                         unknown_t unk3,
+                                                         lpdword_t handle_out) {
   assert_not_null(handle_out);
 
   auto device_info = device_id == 0 ? nullptr : GetDummyDeviceInfo(device_id);

src/xenia/kernel/xam/xam_content_device.cc

@@ -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. *
  ******************************************************************************
  */
@@ -59,9 +59,9 @@ const DummyDeviceInfo* GetDummyDeviceInfo(uint32_t device_id) {
   return it == end ? nullptr : *it;
 }
 
-dword_result_t XamContentGetDeviceName(dword_t device_id,
-                                       lpu16string_t name_buffer,
-                                       dword_t name_capacity) {
+dword_result_t XamContentGetDeviceName_entry(dword_t device_id,
+                                             lpu16string_t name_buffer,
+                                             dword_t name_capacity) {
   auto device_info = GetDummyDeviceInfo(device_id);
   if (device_info == nullptr) {
     return X_ERROR_DEVICE_NOT_CONNECTED;
@@ -75,8 +75,8 @@ dword_result_t XamContentGetDeviceName(dword_t device_id,
 }
 DECLARE_XAM_EXPORT1(XamContentGetDeviceName, kContent, kImplemented);
 
-dword_result_t XamContentGetDeviceState(dword_t device_id,
-                                        lpunknown_t overlapped_ptr) {
+dword_result_t XamContentGetDeviceState_entry(dword_t device_id,
+                                              lpunknown_t overlapped_ptr) {
   auto device_info = GetDummyDeviceInfo(device_id);
   if (device_info == nullptr) {
     if (overlapped_ptr) {
@@ -110,7 +110,7 @@ typedef struct {
 } X_CONTENT_DEVICE_DATA;
 static_assert_size(X_CONTENT_DEVICE_DATA, 0x50);
 
-dword_result_t XamContentGetDeviceData(
+dword_result_t XamContentGetDeviceData_entry(
     dword_t device_id, pointer_t<X_CONTENT_DEVICE_DATA> device_data) {
   auto device_info = GetDummyDeviceInfo(device_id);
   if (device_info == nullptr) {
@@ -128,11 +128,11 @@ dword_result_t XamContentGetDeviceData(
 }
 DECLARE_XAM_EXPORT1(XamContentGetDeviceData, kContent, kImplemented);
 
-dword_result_t XamContentCreateDeviceEnumerator(dword_t content_type,
-                                                dword_t content_flags,
-                                                dword_t max_count,
-                                                lpdword_t buffer_size_ptr,
-                                                lpdword_t handle_out) {
+dword_result_t XamContentCreateDeviceEnumerator_entry(dword_t content_type,
+                                                      dword_t content_flags,
+                                                      dword_t max_count,
+                                                      lpdword_t buffer_size_ptr,
+                                                      lpdword_t handle_out) {
   assert_not_null(handle_out);
 
   if (buffer_size_ptr) {

src/xenia/kernel/xam/xam_enum.cc

@@ -2,7 +2,7 @@
  ******************************************************************************
  * Xenia : Xbox 360 Emulator Research Project                                 *
  ******************************************************************************
- * Copyright 2021 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. *
  ******************************************************************************
  */
@@ -69,9 +69,10 @@ uint32_t xeXamEnumerate(uint32_t handle, uint32_t flags, lpvoid_t buffer_ptr,
   }
 }
 
-dword_result_t XamEnumerate(dword_t handle, dword_t flags, lpvoid_t buffer,
-                            dword_t buffer_length, lpdword_t items_returned,
-                            pointer_t<XAM_OVERLAPPED> overlapped) {
+dword_result_t XamEnumerate_entry(dword_t handle, dword_t flags,
+                                  lpvoid_t buffer, dword_t buffer_length,
+                                  lpdword_t items_returned,
+                                  pointer_t<XAM_OVERLAPPED> overlapped) {
   uint32_t dummy;
   auto result = xeXamEnumerate(handle, flags, buffer, buffer_length,
                                !overlapped ? &dummy : nullptr, overlapped);
@@ -82,16 +83,16 @@ dword_result_t XamEnumerate(dword_t handle, dword_t flags, lpvoid_t buffer,
 }
 DECLARE_XAM_EXPORT1(XamEnumerate, kNone, kImplemented);
 
-dword_result_t XamCreateEnumeratorHandle(unknown_t unk1, unknown_t unk2,
-                                         unknown_t unk3, unknown_t unk4,
-                                         unknown_t unk5, unknown_t unk6,
-                                         unknown_t unk7, unknown_t unk8) {
+dword_result_t XamCreateEnumeratorHandle_entry(unknown_t unk1, unknown_t unk2,
+                                               unknown_t unk3, unknown_t unk4,
+                                               unknown_t unk5, unknown_t unk6,
+                                               unknown_t unk7, unknown_t unk8) {
   return X_ERROR_INVALID_PARAMETER;
 }
 DECLARE_XAM_EXPORT1(XamCreateEnumeratorHandle, kNone, kStub);
 
-dword_result_t XamGetPrivateEnumStructureFromHandle(dword_t handle,
-                                                    lpdword_t out_object_ptr) {
+dword_result_t XamGetPrivateEnumStructureFromHandle_entry(
+    dword_t handle, lpdword_t out_object_ptr) {
   auto e = kernel_state()->object_table()->LookupObject<XEnumerator>(handle);
   if (!e) {
     return X_STATUS_INVALID_HANDLE;

src/xenia/kernel/xam/xam_info.cc

@@ -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. *
  ******************************************************************************
  */
@@ -28,7 +28,7 @@ namespace xe {
 namespace kernel {
 namespace xam {
 
-dword_result_t XamFeatureEnabled(dword_t unk) { return 0; }
+dword_result_t XamFeatureEnabled_entry(dword_t unk) { return 0; }
 DECLARE_XAM_EXPORT1(XamFeatureEnabled, kNone, kStub);
 
 // Empty stub schema binary.
@@ -39,7 +39,7 @@ uint8_t schema_bin[] = {
     0x00, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
 };
 
-dword_result_t XamGetOnlineSchema() {
+dword_result_t XamGetOnlineSchema_entry() {
   static uint32_t schema_guest = 0;
 
   if (!schema_guest) {
@@ -70,8 +70,8 @@ static SYSTEMTIME xeGetLocalSystemTime(uint64_t filetime) {
 }
 #endif
 
-void XamFormatDateString(dword_t unk, qword_t filetime, lpvoid_t output_buffer,
-                         dword_t output_count) {
+void XamFormatDateString_entry(dword_t unk, qword_t filetime,
+                               lpvoid_t output_buffer, dword_t output_count) {
   std::memset(output_buffer, 0, output_count * sizeof(char16_t));
 
 // TODO: implement this for other platforms
@@ -87,8 +87,8 @@ void XamFormatDateString(dword_t unk, qword_t filetime, lpvoid_t output_buffer,
 }
 DECLARE_XAM_EXPORT1(XamFormatDateString, kNone, kImplemented);
 
-void XamFormatTimeString(dword_t unk, qword_t filetime, lpvoid_t output_buffer,
-                         dword_t output_count) {
+void XamFormatTimeString_entry(dword_t unk, qword_t filetime,
+                               lpvoid_t output_buffer, dword_t output_count) {
   std::memset(output_buffer, 0, output_count * sizeof(char16_t));
 
 // TODO: implement this for other platforms
@@ -124,18 +124,19 @@ dword_result_t keXamBuildResourceLocator(uint64_t module,
   return 0;
 }
 
-dword_result_t XamBuildResourceLocator(qword_t module, lpu16string_t container,
-                                       lpu16string_t resource,
-                                       lpvoid_t buffer_ptr,
-                                       dword_t buffer_count) {
+dword_result_t XamBuildResourceLocator_entry(qword_t module,
+                                             lpu16string_t container,
+                                             lpu16string_t resource,
+                                             lpvoid_t buffer_ptr,
+                                             dword_t buffer_count) {
   return keXamBuildResourceLocator(module, container.value(), resource.value(),
                                    buffer_ptr, buffer_count);
 }
 DECLARE_XAM_EXPORT1(XamBuildResourceLocator, kNone, kImplemented);
 
-dword_result_t XamBuildGamercardResourceLocator(lpu16string_t filename,
-                                                lpvoid_t buffer_ptr,
-                                                dword_t buffer_count) {
+dword_result_t XamBuildGamercardResourceLocator_entry(lpu16string_t filename,
+                                                      lpvoid_t buffer_ptr,
+                                                      dword_t buffer_count) {
   // On an actual xbox these funcs would return a locator to xam.xex resources,
   // but for Xenia we can return a locator to the resources as local files. (big
   // thanks to MS for letting XamBuildResourceLocator return local file
@@ -149,32 +150,32 @@ dword_result_t XamBuildGamercardResourceLocator(lpu16string_t filename,
 }
 DECLARE_XAM_EXPORT1(XamBuildGamercardResourceLocator, kNone, kImplemented);
 
-dword_result_t XamBuildSharedSystemResourceLocator(lpu16string_t filename,
-                                                   lpvoid_t buffer_ptr,
-                                                   dword_t buffer_count) {
+dword_result_t XamBuildSharedSystemResourceLocator_entry(lpu16string_t filename,
+                                                         lpvoid_t buffer_ptr,
+                                                         dword_t buffer_count) {
   // see notes inside XamBuildGamercardResourceLocator above
   return keXamBuildResourceLocator(0, u"shrdres", filename.value(), buffer_ptr,
                                    buffer_count);
 }
 DECLARE_XAM_EXPORT1(XamBuildSharedSystemResourceLocator, kNone, kImplemented);
 
-dword_result_t XamBuildLegacySystemResourceLocator(lpu16string_t filename,
-                                                   lpvoid_t buffer_ptr,
-                                                   dword_t buffer_count) {
-  return XamBuildSharedSystemResourceLocator(filename, buffer_ptr,
-                                             buffer_count);
+dword_result_t XamBuildLegacySystemResourceLocator_entry(lpu16string_t filename,
+                                                         lpvoid_t buffer_ptr,
+                                                         dword_t buffer_count) {
+  return XamBuildSharedSystemResourceLocator_entry(filename, buffer_ptr,
+                                                   buffer_count);
 }
 DECLARE_XAM_EXPORT1(XamBuildLegacySystemResourceLocator, kNone, kImplemented);
 
-dword_result_t XamBuildXamResourceLocator(lpu16string_t filename,
-                                          lpvoid_t buffer_ptr,
-                                          dword_t buffer_count) {
+dword_result_t XamBuildXamResourceLocator_entry(lpu16string_t filename,
+                                                lpvoid_t buffer_ptr,
+                                                dword_t buffer_count) {
   return keXamBuildResourceLocator(0, u"xam", filename.value(), buffer_ptr,
                                    buffer_count);
 }
 DECLARE_XAM_EXPORT1(XamBuildXamResourceLocator, kNone, kImplemented);
 
-dword_result_t XamGetSystemVersion() {
+dword_result_t XamGetSystemVersion_entry() {
   // 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.
@@ -184,12 +185,12 @@ dword_result_t XamGetSystemVersion() {
 }
 DECLARE_XAM_EXPORT1(XamGetSystemVersion, kNone, kStub);
 
-void XCustomRegisterDynamicActions() {
+void XCustomRegisterDynamicActions_entry() {
   // ???
 }
 DECLARE_XAM_EXPORT1(XCustomRegisterDynamicActions, kNone, kStub);
 
-dword_result_t XGetAVPack() {
+dword_result_t XGetAVPack_entry() {
   // DWORD
   // Not sure what the values are for this, but 6 is VGA.
   // Other likely values are 3/4/8 for HDMI or something.
@@ -201,10 +202,10 @@ DECLARE_XAM_EXPORT1(XGetAVPack, kNone, kStub);
 
 uint32_t xeXGetGameRegion() { return 0xFFFFu; }
 
-dword_result_t XGetGameRegion() { return xeXGetGameRegion(); }
+dword_result_t XGetGameRegion_entry() { return xeXGetGameRegion(); }
 DECLARE_XAM_EXPORT1(XGetGameRegion, kNone, kStub);
 
-dword_result_t XGetLanguage() {
+dword_result_t XGetLanguage_entry() {
   auto desired_language = XLanguage::kEnglish;
 
   // Switch the language based on game region.
@@ -221,7 +222,7 @@ dword_result_t XGetLanguage() {
 }
 DECLARE_XAM_EXPORT1(XGetLanguage, kNone, kImplemented);
 
-dword_result_t XamGetExecutionId(lpdword_t info_ptr) {
+dword_result_t XamGetExecutionId_entry(lpdword_t info_ptr) {
   auto module = kernel_state()->GetExecutableModule();
   assert_not_null(module);
 
@@ -238,7 +239,7 @@ dword_result_t XamGetExecutionId(lpdword_t info_ptr) {
 }
 DECLARE_XAM_EXPORT1(XamGetExecutionId, kNone, kImplemented);
 
-dword_result_t XamLoaderSetLaunchData(lpvoid_t data, dword_t size) {
+dword_result_t XamLoaderSetLaunchData_entry(lpvoid_t data, dword_t size) {
   auto xam = kernel_state()->GetKernelModule<XamModule>("xam.xex");
   auto& loader_data = xam->loader_data();
   loader_data.launch_data_present = size ? true : false;
@@ -248,7 +249,7 @@ dword_result_t XamLoaderSetLaunchData(lpvoid_t data, dword_t size) {
 }
 DECLARE_XAM_EXPORT1(XamLoaderSetLaunchData, kNone, kSketchy);
 
-dword_result_t XamLoaderGetLaunchDataSize(lpdword_t size_ptr) {
+dword_result_t XamLoaderGetLaunchDataSize_entry(lpdword_t size_ptr) {
   if (!size_ptr) {
     return X_ERROR_INVALID_PARAMETER;
   }
@@ -265,8 +266,8 @@ dword_result_t XamLoaderGetLaunchDataSize(lpdword_t size_ptr) {
 }
 DECLARE_XAM_EXPORT1(XamLoaderGetLaunchDataSize, kNone, kSketchy);
 
-dword_result_t XamLoaderGetLaunchData(lpvoid_t buffer_ptr,
-                                      dword_t buffer_size) {
+dword_result_t XamLoaderGetLaunchData_entry(lpvoid_t buffer_ptr,
+                                            dword_t buffer_size) {
   auto xam = kernel_state()->GetKernelModule<XamModule>("xam.xex");
   auto& loader_data = xam->loader_data();
   if (!loader_data.launch_data_present) {
@@ -280,7 +281,7 @@ dword_result_t XamLoaderGetLaunchData(lpvoid_t buffer_ptr,
 }
 DECLARE_XAM_EXPORT1(XamLoaderGetLaunchData, kNone, kSketchy);
 
-void XamLoaderLaunchTitle(lpstring_t raw_name_ptr, dword_t flags) {
+void XamLoaderLaunchTitle_entry(lpstring_t raw_name_ptr, dword_t flags) {
   auto xam = kernel_state()->GetKernelModule<XamModule>("xam.xex");
 
   auto& loader_data = xam->loader_data();
@@ -309,13 +310,13 @@ void XamLoaderLaunchTitle(lpstring_t raw_name_ptr, dword_t flags) {
 }
 DECLARE_XAM_EXPORT1(XamLoaderLaunchTitle, kNone, kSketchy);
 
-void XamLoaderTerminateTitle() {
+void XamLoaderTerminateTitle_entry() {
   // This function does not return.
   kernel_state()->TerminateTitle();
 }
 DECLARE_XAM_EXPORT1(XamLoaderTerminateTitle, kNone, kSketchy);
 
-dword_result_t XamAlloc(dword_t unk, dword_t size, lpdword_t out_ptr) {
+dword_result_t XamAlloc_entry(dword_t unk, dword_t size, lpdword_t out_ptr) {
   assert_true(unk == 0);
 
   // Allocate from the heap. Not sure why XAM does this specially, perhaps
@@ -327,15 +328,16 @@ dword_result_t XamAlloc(dword_t unk, dword_t size, lpdword_t out_ptr) {
 }
 DECLARE_XAM_EXPORT1(XamAlloc, kMemory, kImplemented);
 
-dword_result_t XamFree(lpdword_t ptr) {
+dword_result_t XamFree_entry(lpdword_t ptr) {
   kernel_state()->memory()->SystemHeapFree(ptr.guest_address());
 
   return X_ERROR_SUCCESS;
 }
 DECLARE_XAM_EXPORT1(XamFree, kMemory, kImplemented);
 
-dword_result_t XamQueryLiveHiveW(lpu16string_t name, lpvoid_t out_buf,
-                                 dword_t out_size, dword_t type /* guess */) {
+dword_result_t XamQueryLiveHiveW_entry(lpu16string_t name, lpvoid_t out_buf,
+                                       dword_t out_size,
+                                       dword_t type /* guess */) {
   return X_STATUS_INVALID_PARAMETER_1;
 }
 DECLARE_XAM_EXPORT1(XamQueryLiveHiveW, kNone, kStub);

src/xenia/kernel/xam/xam_input.cc

@@ -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. *
  ******************************************************************************
  */
@@ -28,19 +28,20 @@ using xe::hid::X_INPUT_VIBRATION;
 constexpr uint32_t XINPUT_FLAG_GAMEPAD = 0x01;
 constexpr uint32_t XINPUT_FLAG_ANY_USER = 1 << 30;
 
-void XamResetInactivity() {
+void XamResetInactivity_entry() {
   // Do we need to do anything?
 }
 DECLARE_XAM_EXPORT1(XamResetInactivity, kInput, kStub);
 
-dword_result_t XamEnableInactivityProcessing(dword_t unk, dword_t enable) {
+dword_result_t XamEnableInactivityProcessing_entry(dword_t unk,
+                                                   dword_t enable) {
   return X_ERROR_SUCCESS;
 }
 DECLARE_XAM_EXPORT1(XamEnableInactivityProcessing, kInput, kStub);
 
 // https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputgetcapabilities(v=vs.85).aspx
-dword_result_t XamInputGetCapabilities(dword_t user_index, dword_t flags,
-                                       pointer_t<X_INPUT_CAPABILITIES> caps) {
+dword_result_t XamInputGetCapabilities_entry(
+    dword_t user_index, dword_t flags, pointer_t<X_INPUT_CAPABILITIES> caps) {
   if (!caps) {
     return X_ERROR_BAD_ARGUMENTS;
   }
@@ -61,9 +62,9 @@ dword_result_t XamInputGetCapabilities(dword_t user_index, dword_t flags,
 }
 DECLARE_XAM_EXPORT1(XamInputGetCapabilities, kInput, kSketchy);
 
-dword_result_t XamInputGetCapabilitiesEx(dword_t unk, dword_t user_index,
-                                         dword_t flags,
-                                         pointer_t<X_INPUT_CAPABILITIES> caps) {
+dword_result_t XamInputGetCapabilitiesEx_entry(
+    dword_t unk, dword_t user_index, dword_t flags,
+    pointer_t<X_INPUT_CAPABILITIES> caps) {
   if (!caps) {
     return X_ERROR_BAD_ARGUMENTS;
   }
@@ -85,8 +86,8 @@ dword_result_t XamInputGetCapabilitiesEx(dword_t unk, dword_t user_index,
 DECLARE_XAM_EXPORT1(XamInputGetCapabilitiesEx, kInput, kSketchy);
 
 // https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputgetstate(v=vs.85).aspx
-dword_result_t XamInputGetState(dword_t user_index, dword_t flags,
-                                pointer_t<X_INPUT_STATE> input_state) {
+dword_result_t XamInputGetState_entry(dword_t user_index, dword_t flags,
+                                      pointer_t<X_INPUT_STATE> input_state) {
   // Games call this with a NULL state ptr, probably as a query.
 
   if ((flags & 0xFF) && (flags & XINPUT_FLAG_GAMEPAD) == 0) {
@@ -103,11 +104,11 @@ dword_result_t XamInputGetState(dword_t user_index, dword_t flags,
   auto input_system = kernel_state()->emulator()->input_system();
   return input_system->GetState(user_index, input_state);
 }
-DECLARE_XAM_EXPORT1(XamInputGetState, kInput, kImplemented);
+DECLARE_XAM_EXPORT2(XamInputGetState, kInput, kImplemented, kHighFrequency);
 
 // https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputsetstate(v=vs.85).aspx
-dword_result_t XamInputSetState(dword_t user_index, dword_t unk,
-                                pointer_t<X_INPUT_VIBRATION> vibration) {
+dword_result_t XamInputSetState_entry(dword_t user_index, dword_t unk,
+                                      pointer_t<X_INPUT_VIBRATION> vibration) {
   if (!vibration) {
     return X_ERROR_BAD_ARGUMENTS;
   }
@@ -124,8 +125,8 @@ dword_result_t XamInputSetState(dword_t user_index, dword_t unk,
 DECLARE_XAM_EXPORT1(XamInputSetState, kInput, kImplemented);
 
 // https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputgetkeystroke(v=vs.85).aspx
-dword_result_t XamInputGetKeystroke(dword_t user_index, dword_t flags,
-                                    pointer_t<X_INPUT_KEYSTROKE> keystroke) {
+dword_result_t XamInputGetKeystroke_entry(
+    dword_t user_index, dword_t flags, pointer_t<X_INPUT_KEYSTROKE> keystroke) {
   // https://github.com/CodeAsm/ffplay360/blob/master/Common/AtgXime.cpp
   // user index = index or XUSER_INDEX_ANY
   // flags = XINPUT_FLAG_GAMEPAD (| _ANYUSER | _ANYDEVICE)
@@ -151,8 +152,9 @@ dword_result_t XamInputGetKeystroke(dword_t user_index, dword_t flags,
 DECLARE_XAM_EXPORT1(XamInputGetKeystroke, kInput, kImplemented);
 
 // Same as non-ex, just takes a pointer to user index.
-dword_result_t XamInputGetKeystrokeEx(lpdword_t user_index_ptr, dword_t flags,
-                                      pointer_t<X_INPUT_KEYSTROKE> keystroke) {
+dword_result_t XamInputGetKeystrokeEx_entry(
+    lpdword_t user_index_ptr, dword_t flags,
+    pointer_t<X_INPUT_KEYSTROKE> keystroke) {
   if (!keystroke) {
     return X_ERROR_BAD_ARGUMENTS;
   }
@@ -177,8 +179,9 @@ dword_result_t XamInputGetKeystrokeEx(lpdword_t user_index_ptr, dword_t flags,
 }
 DECLARE_XAM_EXPORT1(XamInputGetKeystrokeEx, kInput, kImplemented);
 
-X_HRESULT_result_t XamUserGetDeviceContext(dword_t user_index, dword_t unk,
-                                           lpdword_t out_ptr) {
+X_HRESULT_result_t XamUserGetDeviceContext_entry(dword_t user_index,
+                                                 dword_t unk,
+                                                 lpdword_t out_ptr) {
   // Games check the result - usually with some masking.
   // If this function fails they assume zero, so let's fail AND
   // set zero just to be safe.

src/xenia/kernel/xam/xam_locale.cc

@@ -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. *
  ******************************************************************************
  */
@@ -226,16 +226,19 @@ uint8_t xeXamGetLocale() { return xeXamGetLocaleEx(111, 43); }
 
 // Exports.
 
-dword_result_t XamGetLocale() { return xeXamGetLocale(); }
+dword_result_t XamGetLocale_entry() {
+  return static_cast<uint8_t>(xeXamGetLocale());
+}
 DECLARE_XAM_EXPORT1(XamGetLocale, kLocale, kImplemented);
 
-dword_result_t XamGetOnlineCountryFromLocale(dword_t id) {
+dword_result_t XamGetOnlineCountryFromLocale_entry(dword_t id) {
   return xeXamGetOnlineCountryFromLocale(id);
 }
 DECLARE_XAM_EXPORT1(XamGetOnlineCountryFromLocale, kLocale, kImplemented);
 
-dword_result_t XamGetOnlineCountryString(dword_t id, dword_t buffer_length,
-                                         lpu16string_t buffer) {
+dword_result_t XamGetOnlineCountryString_entry(dword_t id,
+                                               dword_t buffer_length,
+                                               lpu16string_t buffer) {
   if (buffer_length >= 0x80000000u) {
     return X_E_INVALIDARG;
   }
@@ -256,8 +259,8 @@ dword_result_t XamGetOnlineCountryString(dword_t id, dword_t buffer_length,
 }
 DECLARE_XAM_EXPORT1(XamGetOnlineCountryString, kLocale, kImplemented);
 
-dword_result_t XamGetCountryString(dword_t id, dword_t buffer_length,
-                                   lpu16string_t buffer) {
+dword_result_t XamGetCountryString_entry(dword_t id, dword_t buffer_length,
+                                         lpu16string_t buffer) {
   if (buffer_length >= 0x80000000u) {
     return X_E_INVALIDARG;
   }
@@ -278,8 +281,8 @@ dword_result_t XamGetCountryString(dword_t id, dword_t buffer_length,
 }
 DECLARE_XAM_EXPORT1(XamGetCountryString, kLocale, kImplemented);
 
-dword_result_t XamGetLanguageString(dword_t id, dword_t buffer_length,
-                                    lpu16string_t buffer) {
+dword_result_t XamGetLanguageString_entry(dword_t id, dword_t buffer_length,
+                                          lpu16string_t buffer) {
   if (buffer_length >= 0x80000000u) {
     return X_E_INVALIDARG;
   }
@@ -300,10 +303,10 @@ dword_result_t XamGetLanguageString(dword_t id, dword_t buffer_length,
 }
 DECLARE_XAM_EXPORT1(XamGetLanguageString, kLocale, kImplemented);
 
-dword_result_t XamGetLanguageLocaleString(dword_t language_id,
-                                          dword_t locale_id,
-                                          dword_t buffer_length,
-                                          lpu16string_t buffer) {
+dword_result_t XamGetLanguageLocaleString_entry(dword_t language_id,
+                                                dword_t locale_id,
+                                                dword_t buffer_length,
+                                                lpu16string_t buffer) {
   if (buffer_length >= 0x80000000u) {
     return X_E_INVALIDARG;
   }
@@ -330,10 +333,9 @@ dword_result_t XamGetLanguageLocaleString(dword_t language_id,
 }
 DECLARE_XAM_EXPORT1(XamGetLanguageLocaleString, kLocale, kImplemented);
 
-dword_result_t XamGetOnlineLanguageAndCountryString(dword_t language_id,
-                                                    dword_t country_id,
-                                                    dword_t buffer_length,
-                                                    lpu16string_t buffer) {
+dword_result_t XamGetOnlineLanguageAndCountryString_entry(
+    dword_t language_id, dword_t country_id, dword_t buffer_length,
+    lpu16string_t buffer) {
   if (buffer_length >= 0x80000000u) {
     return X_E_INVALIDARG;
   }
@@ -363,8 +365,8 @@ dword_result_t XamGetOnlineLanguageAndCountryString(dword_t language_id,
 DECLARE_XAM_EXPORT1(XamGetOnlineLanguageAndCountryString, kLocale,
                     kImplemented);
 
-dword_result_t XamGetLocaleString(dword_t id, dword_t buffer_length,
-                                  lpu16string_t buffer) {
+dword_result_t XamGetLocaleString_entry(dword_t id, dword_t buffer_length,
+                                        lpu16string_t buffer) {
   if (buffer_length >= 0x80000000u) {
     return X_E_INVALIDARG;
   }
@@ -385,18 +387,19 @@ dword_result_t XamGetLocaleString(dword_t id, dword_t buffer_length,
 }
 DECLARE_XAM_EXPORT1(XamGetLocaleString, kLocale, kImplemented);
 
-dword_result_t XamGetLocaleFromOnlineCountry(dword_t id) {
+dword_result_t XamGetLocaleFromOnlineCountry_entry(dword_t id) {
   return xeXamGetLocaleFromOnlineCountry(static_cast<uint8_t>(id));
 }
 DECLARE_XAM_EXPORT1(XamGetLocaleFromOnlineCountry, kLocale, kImplemented);
 
-dword_result_t XamGetLanguageFromOnlineLanguage(dword_t id) {
+dword_result_t XamGetLanguageFromOnlineLanguage_entry(dword_t id) {
   return xeXamGetLanguageFromOnlineLanguage(static_cast<uint8_t>(id));
 }
 DECLARE_XAM_EXPORT1(XamGetLanguageFromOnlineLanguage, kLocale, kImplemented);
 
-dword_result_t XamGetOnlineLanguageString(dword_t id, dword_t buffer_length,
-                                          lpu16string_t buffer) {
+dword_result_t XamGetOnlineLanguageString_entry(dword_t id,
+                                                dword_t buffer_length,
+                                                lpu16string_t buffer) {
   if (buffer_length >= 0x80000000u) {
     return X_E_INVALIDARG;
   }
@@ -417,12 +420,13 @@ dword_result_t XamGetOnlineLanguageString(dword_t id, dword_t buffer_length,
 }
 DECLARE_XAM_EXPORT1(XamGetOnlineLanguageString, kLocale, kImplemented);
 
-dword_result_t XamGetCountryFromOnlineCountry(dword_t id) {
+dword_result_t XamGetCountryFromOnlineCountry_entry(dword_t id) {
   return xeXamGetCountryFromOnlineCountry(static_cast<uint8_t>(id));
 }
 DECLARE_XAM_EXPORT1(XamGetCountryFromOnlineCountry, kLocale, kImplemented);
 
-dword_result_t XamGetLocaleEx(dword_t max_country_id, dword_t max_locale_id) {
+dword_result_t XamGetLocaleEx_entry(dword_t max_country_id,
+                                    dword_t max_locale_id) {
   return xeXamGetLocaleEx(static_cast<uint8_t>(max_country_id),
                           static_cast<uint8_t>(max_locale_id));
 }

src/xenia/kernel/xam/xam_msg.cc

@@ -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. *
  ******************************************************************************
  */
@@ -20,8 +20,8 @@ namespace xe {
 namespace kernel {
 namespace xam {
 
-dword_result_t XMsgInProcessCall(dword_t app, dword_t message, dword_t arg1,
-                                 dword_t arg2) {
+dword_result_t XMsgInProcessCall_entry(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) {
@@ -31,8 +31,9 @@ dword_result_t XMsgInProcessCall(dword_t app, dword_t message, dword_t arg1,
 }
 DECLARE_XAM_EXPORT1(XMsgInProcessCall, kNone, kImplemented);
 
-dword_result_t XMsgSystemProcessCall(dword_t app, dword_t message,
-                                     dword_t buffer, dword_t buffer_length) {
+dword_result_t XMsgSystemProcessCall_entry(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) {
@@ -68,7 +69,7 @@ X_HRESULT xeXMsgStartIORequestEx(uint32_t app, uint32_t message,
   return result;
 }
 
-dword_result_t XMsgStartIORequestEx(
+dword_result_t XMsgStartIORequestEx_entry(
     dword_t app, dword_t message, pointer_t<XAM_OVERLAPPED> overlapped_ptr,
     dword_t buffer_ptr, dword_t buffer_length,
     pointer_t<XMSGSTARTIOREQUEST_UNKNOWNARG> unknown_ptr) {
@@ -77,16 +78,16 @@ dword_result_t XMsgStartIORequestEx(
 }
 DECLARE_XAM_EXPORT1(XMsgStartIORequestEx, kNone, kImplemented);
 
-dword_result_t XMsgStartIORequest(dword_t app, dword_t message,
-                                  pointer_t<XAM_OVERLAPPED> overlapped_ptr,
-                                  dword_t buffer_ptr, dword_t buffer_length) {
+dword_result_t XMsgStartIORequest_entry(
+    dword_t app, dword_t message, pointer_t<XAM_OVERLAPPED> overlapped_ptr,
+    dword_t buffer_ptr, dword_t buffer_length) {
   return xeXMsgStartIORequestEx(app, message, overlapped_ptr, buffer_ptr,
                                 buffer_length, nullptr);
 }
 DECLARE_XAM_EXPORT1(XMsgStartIORequest, kNone, kImplemented);
 
-dword_result_t XMsgCancelIORequest(pointer_t<XAM_OVERLAPPED> overlapped_ptr,
-                                   dword_t wait) {
+dword_result_t XMsgCancelIORequest_entry(
+    pointer_t<XAM_OVERLAPPED> overlapped_ptr, dword_t wait) {
   X_HANDLE event_handle = XOverlappedGetEvent(overlapped_ptr);
   if (event_handle && wait) {
     auto ev =
@@ -100,17 +101,18 @@ dword_result_t XMsgCancelIORequest(pointer_t<XAM_OVERLAPPED> overlapped_ptr,
 }
 DECLARE_XAM_EXPORT1(XMsgCancelIORequest, kNone, kImplemented);
 
-dword_result_t XMsgCompleteIORequest(pointer_t<XAM_OVERLAPPED> overlapped_ptr,
-                                     dword_t result, dword_t extended_error,
-                                     dword_t length) {
+dword_result_t XMsgCompleteIORequest_entry(
+    pointer_t<XAM_OVERLAPPED> overlapped_ptr, dword_t result,
+    dword_t extended_error, dword_t length) {
   kernel_state()->CompleteOverlappedImmediateEx(overlapped_ptr, result,
                                                 extended_error, length);
   return X_ERROR_SUCCESS;
 }
 DECLARE_XAM_EXPORT2(XMsgCompleteIORequest, kNone, kImplemented, kSketchy);
 
-dword_result_t XamGetOverlappedResult(pointer_t<XAM_OVERLAPPED> overlapped_ptr,
-                                      lpdword_t length_ptr, dword_t unknown) {
+dword_result_t XamGetOverlappedResult_entry(
+    pointer_t<XAM_OVERLAPPED> overlapped_ptr, lpdword_t length_ptr,
+    dword_t unknown) {
   uint32_t result;
   if (overlapped_ptr->result != X_ERROR_IO_PENDING) {
     result = overlapped_ptr->result;

src/xenia/kernel/xam/xam_net.cc

@@ -2,7 +2,7 @@
  ******************************************************************************
  * Xenia : Xbox 360 Emulator Research Project                                 *
  ******************************************************************************
- * Copyright 2021 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. *
  ******************************************************************************
  */
@@ -169,8 +169,8 @@ struct XNetStartupParams {
 
 XNetStartupParams xnet_startup_params = {0};
 
-dword_result_t NetDll_XNetStartup(dword_t caller,
-                                  pointer_t<XNetStartupParams> params) {
+dword_result_t NetDll_XNetStartup_entry(dword_t caller,
+                                        pointer_t<XNetStartupParams> params) {
   if (params) {
     assert_true(params->cfgSizeOfStruct == sizeof(XNetStartupParams));
     std::memcpy(&xnet_startup_params, params, sizeof(XNetStartupParams));
@@ -191,7 +191,7 @@ dword_result_t NetDll_XNetStartup(dword_t caller,
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetStartup, kNetworking, kImplemented);
 
-dword_result_t NetDll_XNetCleanup(dword_t caller, lpvoid_t params) {
+dword_result_t NetDll_XNetCleanup_entry(dword_t caller, lpvoid_t params) {
   auto xam = kernel_state()->GetKernelModule<XamModule>("xam.xex");
   // auto xnet = xam->xnet();
   // xam->set_xnet(nullptr);
@@ -203,8 +203,9 @@ dword_result_t NetDll_XNetCleanup(dword_t caller, lpvoid_t params) {
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetCleanup, kNetworking, kImplemented);
 
-dword_result_t NetDll_XNetGetOpt(dword_t one, dword_t option_id,
-                                 lpvoid_t buffer_ptr, lpdword_t buffer_size) {
+dword_result_t NetDll_XNetGetOpt_entry(dword_t one, dword_t option_id,
+                                       lpvoid_t buffer_ptr,
+                                       lpdword_t buffer_size) {
   assert_true(one == 1);
   switch (option_id) {
     case 1:
@@ -221,8 +222,8 @@ dword_result_t NetDll_XNetGetOpt(dword_t one, dword_t option_id,
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetGetOpt, kNetworking, kSketchy);
 
-dword_result_t NetDll_XNetRandom(dword_t caller, lpvoid_t buffer_ptr,
-                                 dword_t length) {
+dword_result_t NetDll_XNetRandom_entry(dword_t caller, lpvoid_t buffer_ptr,
+                                       dword_t length) {
   // For now, constant values.
   // This makes replicating things easier.
   std::memset(buffer_ptr, 0xBB, length);
@@ -231,8 +232,8 @@ dword_result_t NetDll_XNetRandom(dword_t caller, lpvoid_t buffer_ptr,
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetRandom, kNetworking, kStub);
 
-dword_result_t NetDll_WSAStartup(dword_t caller, word_t version,
-                                 pointer_t<X_WSADATA> data_ptr) {
+dword_result_t NetDll_WSAStartup_entry(dword_t caller, word_t version,
+                                       pointer_t<X_WSADATA> data_ptr) {
 // TODO(benvanik): abstraction layer needed.
 #ifdef XE_PLATFORM_WIN32
   WSADATA wsaData;
@@ -281,22 +282,22 @@ dword_result_t NetDll_WSAStartup(dword_t caller, word_t version,
 }
 DECLARE_XAM_EXPORT1(NetDll_WSAStartup, kNetworking, kImplemented);
 
-dword_result_t NetDll_WSACleanup(dword_t caller) {
+dword_result_t NetDll_WSACleanup_entry(dword_t caller) {
   // This does nothing. Xenia needs WSA running.
   return 0;
 }
 DECLARE_XAM_EXPORT1(NetDll_WSACleanup, kNetworking, kImplemented);
 
-dword_result_t NetDll_WSAGetLastError() { return XThread::GetLastError(); }
+dword_result_t NetDll_WSAGetLastError_entry() {
+  return XThread::GetLastError();
+}
 DECLARE_XAM_EXPORT1(NetDll_WSAGetLastError, kNetworking, kImplemented);
 
-dword_result_t NetDll_WSARecvFrom(dword_t caller, dword_t socket,
-                                  pointer_t<XWSABUF> buffers_ptr,
-                                  dword_t buffer_count,
-                                  lpdword_t num_bytes_recv, lpdword_t flags_ptr,
-                                  pointer_t<XSOCKADDR_IN> from_addr,
-                                  pointer_t<XWSAOVERLAPPED> overlapped_ptr,
-                                  lpvoid_t completion_routine_ptr) {
+dword_result_t NetDll_WSARecvFrom_entry(
+    dword_t caller, dword_t socket, pointer_t<XWSABUF> buffers_ptr,
+    dword_t buffer_count, lpdword_t num_bytes_recv, lpdword_t flags_ptr,
+    pointer_t<XSOCKADDR_IN> from_addr, pointer_t<XWSAOVERLAPPED> overlapped_ptr,
+    lpvoid_t completion_routine_ptr) {
   if (overlapped_ptr) {
     // auto evt = kernel_state()->object_table()->LookupObject<XEvent>(
     //    overlapped_ptr->event_handle);
@@ -314,12 +315,11 @@ DECLARE_XAM_EXPORT2(NetDll_WSARecvFrom, kNetworking, kStub, kHighFrequency);
 
 // If the socket is a VDP socket, buffer 0 is the game data length, and buffer 1
 // is the unencrypted game data.
-dword_result_t NetDll_WSASendTo(dword_t caller, dword_t socket_handle,
-                                pointer_t<XWSABUF> buffers, dword_t num_buffers,
-                                lpdword_t num_bytes_sent, dword_t flags,
-                                pointer_t<XSOCKADDR_IN> to_ptr, dword_t to_len,
-                                pointer_t<XWSAOVERLAPPED> overlapped,
-                                lpvoid_t completion_routine) {
+dword_result_t NetDll_WSASendTo_entry(
+    dword_t caller, dword_t socket_handle, pointer_t<XWSABUF> buffers,
+    dword_t num_buffers, lpdword_t num_bytes_sent, dword_t flags,
+    pointer_t<XSOCKADDR_IN> to_ptr, dword_t to_len,
+    pointer_t<XWSAOVERLAPPED> overlapped, lpvoid_t completion_routine) {
   assert(!overlapped);
   assert(!completion_routine);
 
@@ -357,11 +357,11 @@ dword_result_t NetDll_WSASendTo(dword_t caller, dword_t socket_handle,
 }
 DECLARE_XAM_EXPORT1(NetDll_WSASendTo, kNetworking, kImplemented);
 
-dword_result_t NetDll_WSAWaitForMultipleEvents(dword_t num_events,
-                                               lpdword_t events,
-                                               dword_t wait_all,
-                                               dword_t timeout,
-                                               dword_t alertable) {
+dword_result_t NetDll_WSAWaitForMultipleEvents_entry(dword_t num_events,
+                                                     lpdword_t events,
+                                                     dword_t wait_all,
+                                                     dword_t timeout,
+                                                     dword_t alertable) {
   if (num_events > 64) {
     XThread::SetLastError(87);  // ERROR_INVALID_PARAMETER
     return ~0u;
@@ -386,14 +386,14 @@ dword_result_t NetDll_WSAWaitForMultipleEvents(dword_t num_events,
 DECLARE_XAM_EXPORT2(NetDll_WSAWaitForMultipleEvents, kNetworking, kImplemented,
                     kBlocking);
 
-dword_result_t NetDll_WSACreateEvent() {
+dword_result_t NetDll_WSACreateEvent_entry() {
   XEvent* ev = new XEvent(kernel_state());
   ev->Initialize(true, false);
   return ev->handle();
 }
 DECLARE_XAM_EXPORT1(NetDll_WSACreateEvent, kNetworking, kImplemented);
 
-dword_result_t NetDll_WSACloseEvent(dword_t event_handle) {
+dword_result_t NetDll_WSACloseEvent_entry(dword_t event_handle) {
   X_STATUS result = kernel_state()->object_table()->ReleaseHandle(event_handle);
   if (XFAILED(result)) {
     uint32_t error = xboxkrnl::xeRtlNtStatusToDosError(result);
@@ -404,7 +404,7 @@ dword_result_t NetDll_WSACloseEvent(dword_t event_handle) {
 }
 DECLARE_XAM_EXPORT1(NetDll_WSACloseEvent, kNetworking, kImplemented);
 
-dword_result_t NetDll_WSAResetEvent(dword_t event_handle) {
+dword_result_t NetDll_WSAResetEvent_entry(dword_t event_handle) {
   X_STATUS result = xboxkrnl::xeNtClearEvent(event_handle);
   if (XFAILED(result)) {
     uint32_t error = xboxkrnl::xeRtlNtStatusToDosError(result);
@@ -415,7 +415,7 @@ dword_result_t NetDll_WSAResetEvent(dword_t event_handle) {
 }
 DECLARE_XAM_EXPORT1(NetDll_WSAResetEvent, kNetworking, kImplemented);
 
-dword_result_t NetDll_WSASetEvent(dword_t event_handle) {
+dword_result_t NetDll_WSASetEvent_entry(dword_t event_handle) {
   X_STATUS result = xboxkrnl::xeNtSetEvent(event_handle, nullptr);
   if (XFAILED(result)) {
     uint32_t error = xboxkrnl::xeRtlNtStatusToDosError(result);
@@ -449,8 +449,8 @@ struct XnAddrStatus {
   static const uint32_t XNET_GET_XNADDR_TROUBLESHOOT = 0x00008000;
 };
 
-dword_result_t NetDll_XNetGetTitleXnAddr(dword_t caller,
-                                         pointer_t<XNADDR> addr_ptr) {
+dword_result_t NetDll_XNetGetTitleXnAddr_entry(dword_t caller,
+                                               pointer_t<XNADDR> addr_ptr) {
   // Just return a loopback address atm.
   addr_ptr->ina.s_addr = htonl(INADDR_LOOPBACK);
   addr_ptr->inaOnline.s_addr = 0;
@@ -475,8 +475,8 @@ dword_result_t NetDll_XNetGetTitleXnAddr(dword_t caller,
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetGetTitleXnAddr, kNetworking, kStub);
 
-dword_result_t NetDll_XNetGetDebugXnAddr(dword_t caller,
-                                         pointer_t<XNADDR> addr_ptr) {
+dword_result_t NetDll_XNetGetDebugXnAddr_entry(dword_t caller,
+                                               pointer_t<XNADDR> addr_ptr) {
   addr_ptr.Zero();
 
   // XNET_GET_XNADDR_NONE causes caller to gracefully return.
@@ -484,41 +484,43 @@ dword_result_t NetDll_XNetGetDebugXnAddr(dword_t caller,
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetGetDebugXnAddr, kNetworking, kStub);
 
-dword_result_t NetDll_XNetXnAddrToMachineId(dword_t caller,
-                                            pointer_t<XNADDR> addr_ptr,
-                                            lpdword_t id_ptr) {
+dword_result_t NetDll_XNetXnAddrToMachineId_entry(dword_t caller,
+                                                  pointer_t<XNADDR> addr_ptr,
+                                                  lpdword_t id_ptr) {
   // Tell the caller we're not signed in to live (non-zero ret)
   return 1;
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetXnAddrToMachineId, kNetworking, kStub);
 
-void NetDll_XNetInAddrToString(dword_t caller, dword_t in_addr,
-                               lpstring_t string_out, dword_t string_size) {
+void NetDll_XNetInAddrToString_entry(dword_t caller, dword_t in_addr,
+                                     lpstring_t string_out,
+                                     dword_t string_size) {
   strncpy(string_out, "666.666.666.666", string_size);
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetInAddrToString, kNetworking, kStub);
 
 // This converts a XNet address to an IN_ADDR. The IN_ADDR is used for
 // subsequent socket calls (like a handle to a XNet address)
-dword_result_t NetDll_XNetXnAddrToInAddr(dword_t caller,
-                                         pointer_t<XNADDR> xn_addr,
-                                         lpvoid_t xid, lpvoid_t in_addr) {
+dword_result_t NetDll_XNetXnAddrToInAddr_entry(dword_t caller,
+                                               pointer_t<XNADDR> xn_addr,
+                                               lpvoid_t xid, lpvoid_t in_addr) {
   return 1;
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetXnAddrToInAddr, kNetworking, kStub);
 
 // Does the reverse of the above.
 // FIXME: Arguments may not be correct.
-dword_result_t NetDll_XNetInAddrToXnAddr(dword_t caller, lpvoid_t in_addr,
-                                         pointer_t<XNADDR> xn_addr,
-                                         lpvoid_t xid) {
+dword_result_t NetDll_XNetInAddrToXnAddr_entry(dword_t caller, lpvoid_t in_addr,
+                                               pointer_t<XNADDR> xn_addr,
+                                               lpvoid_t xid) {
   return 1;
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetInAddrToXnAddr, kNetworking, kStub);
 
 // https://www.google.com/patents/WO2008112448A1?cl=en
 // Reserves a port for use by system link
-dword_result_t NetDll_XNetSetSystemLinkPort(dword_t caller, dword_t port) {
+dword_result_t NetDll_XNetSetSystemLinkPort_entry(dword_t caller,
+                                                  dword_t port) {
   return 1;
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetSetSystemLinkPort, kNetworking, kStub);
@@ -532,11 +534,14 @@ struct XEthernetStatus {
   static const uint32_t XNET_ETHERNET_LINK_HALF_DUPLEX = 0x10;
 };
 
-dword_result_t NetDll_XNetGetEthernetLinkStatus(dword_t caller) { return 0; }
+dword_result_t NetDll_XNetGetEthernetLinkStatus_entry(dword_t caller) {
+  return 0;
+}
 DECLARE_XAM_EXPORT1(NetDll_XNetGetEthernetLinkStatus, kNetworking, kStub);
 
-dword_result_t NetDll_XNetDnsLookup(dword_t caller, lpstring_t host,
-                                    dword_t event_handle, lpdword_t pdns) {
+dword_result_t NetDll_XNetDnsLookup_entry(dword_t caller, lpstring_t host,
+                                          dword_t event_handle,
+                                          lpdword_t pdns) {
   // TODO(gibbed): actually implement this
   if (pdns) {
     auto dns_guest = kernel_memory()->SystemHeapAlloc(sizeof(XNDNS));
@@ -554,7 +559,8 @@ dword_result_t NetDll_XNetDnsLookup(dword_t caller, lpstring_t host,
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetDnsLookup, kNetworking, kStub);
 
-dword_result_t NetDll_XNetDnsRelease(dword_t caller, pointer_t<XNDNS> dns) {
+dword_result_t NetDll_XNetDnsRelease_entry(dword_t caller,
+                                           pointer_t<XNDNS> dns) {
   if (!dns) {
     return X_STATUS_INVALID_PARAMETER;
   }
@@ -563,9 +569,9 @@ dword_result_t NetDll_XNetDnsRelease(dword_t caller, pointer_t<XNDNS> dns) {
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetDnsRelease, kNetworking, kStub);
 
-dword_result_t NetDll_XNetQosServiceLookup(dword_t caller, dword_t flags,
-                                           dword_t event_handle,
-                                           lpdword_t pqos) {
+dword_result_t NetDll_XNetQosServiceLookup_entry(dword_t caller, dword_t flags,
+                                                 dword_t event_handle,
+                                                 lpdword_t pqos) {
   // Set pqos as some games will try accessing it despite non-successful result
   if (pqos) {
     auto qos_guest = kernel_memory()->SystemHeapAlloc(sizeof(XNQOS));
@@ -583,7 +589,8 @@ dword_result_t NetDll_XNetQosServiceLookup(dword_t caller, dword_t flags,
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetQosServiceLookup, kNetworking, kStub);
 
-dword_result_t NetDll_XNetQosRelease(dword_t caller, pointer_t<XNQOS> qos) {
+dword_result_t NetDll_XNetQosRelease_entry(dword_t caller,
+                                           pointer_t<XNQOS> qos) {
   if (!qos) {
     return X_STATUS_INVALID_PARAMETER;
   }
@@ -592,14 +599,14 @@ dword_result_t NetDll_XNetQosRelease(dword_t caller, pointer_t<XNQOS> qos) {
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetQosRelease, kNetworking, kStub);
 
-dword_result_t NetDll_XNetQosListen(dword_t caller, lpvoid_t id, lpvoid_t data,
-                                    dword_t data_size, dword_t r7,
-                                    dword_t flags) {
+dword_result_t NetDll_XNetQosListen_entry(dword_t caller, lpvoid_t id,
+                                          lpvoid_t data, dword_t data_size,
+                                          dword_t r7, dword_t flags) {
   return X_ERROR_FUNCTION_FAILED;
 }
 DECLARE_XAM_EXPORT1(NetDll_XNetQosListen, kNetworking, kStub);
 
-dword_result_t NetDll_inet_addr(lpstring_t addr_ptr) {
+dword_result_t NetDll_inet_addr_entry(lpstring_t addr_ptr) {
   if (!addr_ptr) {
     return -1;
   }
@@ -616,8 +623,8 @@ dword_result_t NetDll_inet_addr(lpstring_t addr_ptr) {
 }
 DECLARE_XAM_EXPORT1(NetDll_inet_addr, kNetworking, kImplemented);
 
-dword_result_t NetDll_socket(dword_t caller, dword_t af, dword_t type,
-                             dword_t protocol) {
+dword_result_t NetDll_socket_entry(dword_t caller, dword_t af, dword_t type,
+                                   dword_t protocol) {
   XSocket* socket = new XSocket(kernel_state());
   X_STATUS result = socket->Initialize(XSocket::AddressFamily((uint32_t)af),
                                        XSocket::Type((uint32_t)type),
@@ -635,7 +642,7 @@ dword_result_t NetDll_socket(dword_t caller, dword_t af, dword_t type,
 }
 DECLARE_XAM_EXPORT1(NetDll_socket, kNetworking, kImplemented);
 
-dword_result_t NetDll_closesocket(dword_t caller, dword_t socket_handle) {
+dword_result_t NetDll_closesocket_entry(dword_t caller, dword_t socket_handle) {
   auto socket =
       kernel_state()->object_table()->LookupObject<XSocket>(socket_handle);
   if (!socket) {
@@ -652,7 +659,8 @@ dword_result_t NetDll_closesocket(dword_t caller, dword_t socket_handle) {
 }
 DECLARE_XAM_EXPORT1(NetDll_closesocket, kNetworking, kImplemented);
 
-int_result_t NetDll_shutdown(dword_t caller, dword_t socket_handle, int_t how) {
+int_result_t NetDll_shutdown_entry(dword_t caller, dword_t socket_handle,
+                                   int_t how) {
   auto socket =
       kernel_state()->object_table()->LookupObject<XSocket>(socket_handle);
   if (!socket) {
@@ -674,9 +682,9 @@ int_result_t NetDll_shutdown(dword_t caller, dword_t socket_handle, int_t how) {
 }
 DECLARE_XAM_EXPORT1(NetDll_shutdown, kNetworking, kImplemented);
 
-dword_result_t NetDll_setsockopt(dword_t caller, dword_t socket_handle,
-                                 dword_t level, dword_t optname,
-                                 lpvoid_t optval_ptr, dword_t optlen) {
+dword_result_t NetDll_setsockopt_entry(dword_t caller, dword_t socket_handle,
+                                       dword_t level, dword_t optname,
+                                       lpvoid_t optval_ptr, dword_t optlen) {
   auto socket =
       kernel_state()->object_table()->LookupObject<XSocket>(socket_handle);
   if (!socket) {
@@ -690,8 +698,8 @@ dword_result_t NetDll_setsockopt(dword_t caller, dword_t socket_handle,
 }
 DECLARE_XAM_EXPORT1(NetDll_setsockopt, kNetworking, kImplemented);
 
-dword_result_t NetDll_ioctlsocket(dword_t caller, dword_t socket_handle,
-                                  dword_t cmd, lpvoid_t arg_ptr) {
+dword_result_t NetDll_ioctlsocket_entry(dword_t caller, dword_t socket_handle,
+                                        dword_t cmd, lpvoid_t arg_ptr) {
   auto socket =
       kernel_state()->object_table()->LookupObject<XSocket>(socket_handle);
   if (!socket) {
@@ -711,8 +719,9 @@ dword_result_t NetDll_ioctlsocket(dword_t caller, dword_t socket_handle,
 }
 DECLARE_XAM_EXPORT1(NetDll_ioctlsocket, kNetworking, kImplemented);
 
-dword_result_t NetDll_bind(dword_t caller, dword_t socket_handle,
-                           pointer_t<XSOCKADDR_IN> name, dword_t namelen) {
+dword_result_t NetDll_bind_entry(dword_t caller, dword_t socket_handle,
+                                 pointer_t<XSOCKADDR_IN> name,
+                                 dword_t namelen) {
   auto socket =
       kernel_state()->object_table()->LookupObject<XSocket>(socket_handle);
   if (!socket) {
@@ -732,8 +741,9 @@ dword_result_t NetDll_bind(dword_t caller, dword_t socket_handle,
 }
 DECLARE_XAM_EXPORT1(NetDll_bind, kNetworking, kImplemented);
 
-dword_result_t NetDll_connect(dword_t caller, dword_t socket_handle,
-                              pointer_t<XSOCKADDR> name, dword_t namelen) {
+dword_result_t NetDll_connect_entry(dword_t caller, dword_t socket_handle,
+                                    pointer_t<XSOCKADDR> name,
+                                    dword_t namelen) {
   auto socket =
       kernel_state()->object_table()->LookupObject<XSocket>(socket_handle);
   if (!socket) {
@@ -753,8 +763,8 @@ dword_result_t NetDll_connect(dword_t caller, dword_t socket_handle,
 }
 DECLARE_XAM_EXPORT1(NetDll_connect, kNetworking, kImplemented);
 
-dword_result_t NetDll_listen(dword_t caller, dword_t socket_handle,
-                             int_t backlog) {
+dword_result_t NetDll_listen_entry(dword_t caller, dword_t socket_handle,
+                                   int_t backlog) {
   auto socket =
       kernel_state()->object_table()->LookupObject<XSocket>(socket_handle);
   if (!socket) {
@@ -773,9 +783,9 @@ dword_result_t NetDll_listen(dword_t caller, dword_t socket_handle,
 }
 DECLARE_XAM_EXPORT1(NetDll_listen, kNetworking, kImplemented);
 
-dword_result_t NetDll_accept(dword_t caller, dword_t socket_handle,
-                             pointer_t<XSOCKADDR> addr_ptr,
-                             lpdword_t addrlen_ptr) {
+dword_result_t NetDll_accept_entry(dword_t caller, dword_t socket_handle,
+                                   pointer_t<XSOCKADDR> addr_ptr,
+                                   lpdword_t addrlen_ptr) {
   if (!addr_ptr) {
     // WSAEFAULT
     XThread::SetLastError(0x271E);
@@ -858,11 +868,11 @@ struct host_set {
   }
 };
 
-int_result_t NetDll_select(int_t caller, int_t nfds,
-                           pointer_t<x_fd_set> readfds,
-                           pointer_t<x_fd_set> writefds,
-                           pointer_t<x_fd_set> exceptfds,
-                           lpvoid_t timeout_ptr) {
+int_result_t NetDll_select_entry(int_t caller, int_t nfds,
+                                 pointer_t<x_fd_set> readfds,
+                                 pointer_t<x_fd_set> writefds,
+                                 pointer_t<x_fd_set> exceptfds,
+                                 lpvoid_t timeout_ptr) {
   host_set host_readfds = {0};
   fd_set native_readfds = {0};
   if (readfds) {
@@ -912,8 +922,9 @@ int_result_t NetDll_select(int_t caller, int_t nfds,
 }
 DECLARE_XAM_EXPORT1(NetDll_select, kNetworking, kImplemented);
 
-dword_result_t NetDll_recv(dword_t caller, dword_t socket_handle,
-                           lpvoid_t buf_ptr, dword_t buf_len, dword_t flags) {
+dword_result_t NetDll_recv_entry(dword_t caller, dword_t socket_handle,
+                                 lpvoid_t buf_ptr, dword_t buf_len,
+                                 dword_t flags) {
   auto socket =
       kernel_state()->object_table()->LookupObject<XSocket>(socket_handle);
   if (!socket) {
@@ -926,10 +937,11 @@ dword_result_t NetDll_recv(dword_t caller, dword_t socket_handle,
 }
 DECLARE_XAM_EXPORT1(NetDll_recv, kNetworking, kImplemented);
 
-dword_result_t NetDll_recvfrom(dword_t caller, dword_t socket_handle,
-                               lpvoid_t buf_ptr, dword_t buf_len, dword_t flags,
-                               pointer_t<XSOCKADDR_IN> from_ptr,
-                               lpdword_t fromlen_ptr) {
+dword_result_t NetDll_recvfrom_entry(dword_t caller, dword_t socket_handle,
+                                     lpvoid_t buf_ptr, dword_t buf_len,
+                                     dword_t flags,
+                                     pointer_t<XSOCKADDR_IN> from_ptr,
+                                     lpdword_t fromlen_ptr) {
   auto socket =
       kernel_state()->object_table()->LookupObject<XSocket>(socket_handle);
   if (!socket) {
@@ -970,8 +982,9 @@ dword_result_t NetDll_recvfrom(dword_t caller, dword_t socket_handle,
 }
 DECLARE_XAM_EXPORT1(NetDll_recvfrom, kNetworking, kImplemented);
 
-dword_result_t NetDll_send(dword_t caller, dword_t socket_handle,
-                           lpvoid_t buf_ptr, dword_t buf_len, dword_t flags) {
+dword_result_t NetDll_send_entry(dword_t caller, dword_t socket_handle,
+                                 lpvoid_t buf_ptr, dword_t buf_len,
+                                 dword_t flags) {
   auto socket =
       kernel_state()->object_table()->LookupObject<XSocket>(socket_handle);
   if (!socket) {
@@ -984,9 +997,11 @@ dword_result_t NetDll_send(dword_t caller, dword_t socket_handle,
 }
 DECLARE_XAM_EXPORT1(NetDll_send, kNetworking, kImplemented);
 
-dword_result_t NetDll_sendto(dword_t caller, dword_t socket_handle,
-                             lpvoid_t buf_ptr, dword_t buf_len, dword_t flags,
-                             pointer_t<XSOCKADDR_IN> to_ptr, dword_t to_len) {
+dword_result_t NetDll_sendto_entry(dword_t caller, dword_t socket_handle,
+                                   lpvoid_t buf_ptr, dword_t buf_len,
+                                   dword_t flags,
+                                   pointer_t<XSOCKADDR_IN> to_ptr,
+                                   dword_t to_len) {
   auto socket =
       kernel_state()->object_table()->LookupObject<XSocket>(socket_handle);
   if (!socket) {
@@ -1000,8 +1015,8 @@ dword_result_t NetDll_sendto(dword_t caller, dword_t socket_handle,
 }
 DECLARE_XAM_EXPORT1(NetDll_sendto, kNetworking, kImplemented);
 
-dword_result_t NetDll___WSAFDIsSet(dword_t socket_handle,
-                                   pointer_t<x_fd_set> fd_set) {
+dword_result_t NetDll___WSAFDIsSet_entry(dword_t socket_handle,
+                                         pointer_t<x_fd_set> fd_set) {
   for (uint32_t i = 0; i < fd_set->fd_count.value; i++) {
     if (fd_set->fd_array[i] == socket_handle) {
       return 1;
@@ -1011,7 +1026,7 @@ dword_result_t NetDll___WSAFDIsSet(dword_t socket_handle,
 }
 DECLARE_XAM_EXPORT1(NetDll___WSAFDIsSet, kNetworking, kImplemented);
 
-void NetDll_WSASetLastError(dword_t error_code) {
+void NetDll_WSASetLastError_entry(dword_t error_code) {
   XThread::SetLastError(error_code);
 }
 DECLARE_XAM_EXPORT1(NetDll_WSASetLastError, kNetworking, kImplemented);

src/xenia/kernel/xam/xam_notify.cc

@@ -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. *
  ******************************************************************************
  */
@@ -36,20 +36,22 @@ uint32_t xeXamNotifyCreateListener(uint64_t mask, uint32_t is_system,
   return handle;
 }
 
-dword_result_t XamNotifyCreateListener(qword_t mask, dword_t max_version) {
+dword_result_t XamNotifyCreateListener_entry(qword_t mask,
+                                             dword_t max_version) {
   return xeXamNotifyCreateListener(mask, 0, max_version);
 }
 DECLARE_XAM_EXPORT1(XamNotifyCreateListener, kNone, kImplemented);
 
-dword_result_t XamNotifyCreateListenerInternal(qword_t mask, dword_t is_system,
-                                               dword_t max_version) {
+dword_result_t XamNotifyCreateListenerInternal_entry(qword_t mask,
+                                                     dword_t is_system,
+                                                     dword_t max_version) {
   return xeXamNotifyCreateListener(mask, is_system, max_version);
 }
 DECLARE_XAM_EXPORT1(XamNotifyCreateListenerInternal, kNone, kImplemented);
 
 // https://github.com/CodeAsm/ffplay360/blob/master/Common/AtgSignIn.cpp
-dword_result_t XNotifyGetNext(dword_t handle, dword_t match_id,
-                              lpdword_t id_ptr, lpdword_t param_ptr) {
+dword_result_t XNotifyGetNext_entry(dword_t handle, dword_t match_id,
+                                    lpdword_t id_ptr, lpdword_t param_ptr) {
   if (param_ptr) {
     *param_ptr = 0;
   }
@@ -89,13 +91,13 @@ dword_result_t XNotifyGetNext(dword_t handle, dword_t match_id,
 }
 DECLARE_XAM_EXPORT2(XNotifyGetNext, kNone, kImplemented, kHighFrequency);
 
-dword_result_t XNotifyDelayUI(dword_t delay_ms) {
+dword_result_t XNotifyDelayUI_entry(dword_t delay_ms) {
   // Ignored.
   return 0;
 }
 DECLARE_XAM_EXPORT1(XNotifyDelayUI, kNone, kStub);
 
-void XNotifyPositionUI(dword_t position) {
+void XNotifyPositionUI_entry(dword_t position) {
   // Ignored.
 }
 DECLARE_XAM_EXPORT1(XNotifyPositionUI, kNone, kStub);

src/xenia/kernel/xam/xam_nui.cc

@@ -2,7 +2,7 @@
  ******************************************************************************
  * Xenia : Xbox 360 Emulator Research Project                                 *
  ******************************************************************************
- * Copyright 2015 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. *
  ******************************************************************************
  */
@@ -34,14 +34,14 @@ struct X_NUI_DEVICE_STATUS {
 };
 static_assert(sizeof(X_NUI_DEVICE_STATUS) == 24, "Size matters");
 
-void XamNuiGetDeviceStatus(pointer_t<X_NUI_DEVICE_STATUS> status_ptr) {
+void XamNuiGetDeviceStatus_entry(pointer_t<X_NUI_DEVICE_STATUS> status_ptr) {
   status_ptr.Zero();
   status_ptr->status = 0;  // Not connected.
 }
 DECLARE_XAM_EXPORT1(XamNuiGetDeviceStatus, kNone, kStub);
 
-dword_result_t XamShowNuiTroubleshooterUI(unknown_t unk1, unknown_t unk2,
-                                          unknown_t unk3) {
+dword_result_t XamShowNuiTroubleshooterUI_entry(unknown_t unk1, unknown_t unk2,
+                                                unknown_t unk3) {
   // unk1 is 0xFF - possibly user index?
   // unk2, unk3 appear to always be zero.
 

src/xenia/kernel/xam/xam_party.cc

@@ -2,7 +2,7 @@
  ******************************************************************************
  * Xenia : Xbox 360 Emulator Research Project                                 *
  ******************************************************************************
- * Copyright 2021 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. *
  ******************************************************************************
  */
@@ -16,24 +16,26 @@ namespace xe {
 namespace kernel {
 namespace xam {
 
-dword_result_t XamPartyGetUserList(dword_t player_count, lpdword_t party_list) {
+dword_result_t XamPartyGetUserList_entry(dword_t player_count,
+                                         lpdword_t party_list) {
   // 5345085D wants specifically this code to skip loading party data.
   // This code is not documented in NT_STATUS code list
   return 0x807D0003;
 }
 DECLARE_XAM_EXPORT1(XamPartyGetUserList, kNone, kStub);
 
-dword_result_t XamPartySendGameInvites(dword_t r3, dword_t r4, dword_t r5) {
+dword_result_t XamPartySendGameInvites_entry(dword_t r3, dword_t r4,
+                                             dword_t r5) {
   return X_ERROR_FUNCTION_FAILED;
 }
 DECLARE_XAM_EXPORT1(XamPartySendGameInvites, kNone, kStub);
 
-dword_result_t XamPartySetCustomData(dword_t r3, dword_t r4, dword_t r5) {
+dword_result_t XamPartySetCustomData_entry(dword_t r3, dword_t r4, dword_t r5) {
   return X_ERROR_FUNCTION_FAILED;
 }
 DECLARE_XAM_EXPORT1(XamPartySetCustomData, kNone, kStub);
 
-dword_result_t XamPartyGetBandwidth(dword_t r3, dword_t r4) {
+dword_result_t XamPartyGetBandwidth_entry(dword_t r3, dword_t r4) {
   return X_ERROR_FUNCTION_FAILED;
 }
 DECLARE_XAM_EXPORT1(XamPartyGetBandwidth, kNone, kStub);

src/xenia/kernel/xam/xam_task.cc

@@ -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. *
  ******************************************************************************
  */
@@ -39,9 +39,9 @@ struct XTASK_MESSAGE {
 };
 static_assert_size(XTASK_MESSAGE, 0x1C);
 
-dword_result_t XamTaskSchedule(lpvoid_t callback,
-                               pointer_t<XTASK_MESSAGE> message,
-                               lpdword_t unknown, lpdword_t handle_ptr) {
+dword_result_t XamTaskSchedule_entry(lpvoid_t callback,
+                                     pointer_t<XTASK_MESSAGE> message,
+                                     lpdword_t unknown, lpdword_t handle_ptr) {
   // TODO(gibbed): figure out what this is for
   *handle_ptr = 12345;
 
@@ -69,7 +69,7 @@ dword_result_t XamTaskSchedule(lpvoid_t callback,
 }
 DECLARE_XAM_EXPORT2(XamTaskSchedule, kNone, kImplemented, kSketchy);
 
-dword_result_t XamTaskShouldExit(dword_t r3) { return 0; }
+dword_result_t XamTaskShouldExit_entry(dword_t r3) { return 0; }
 DECLARE_XAM_EXPORT2(XamTaskShouldExit, kNone, kStub, kSketchy);
 
 void RegisterTaskExports(xe::cpu::ExportResolver* export_resolver,

src/xenia/kernel/xam/xam_ui.cc

@@ -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. *
  ******************************************************************************
  */
@@ -201,7 +201,7 @@ X_RESULT xeXamDispatchHeadlessEx(
   }
 }
 
-dword_result_t XamIsUIActive() { return xeXamIsUIActive(); }
+dword_result_t XamIsUIActive_entry() { return xeXamIsUIActive(); }
 DECLARE_XAM_EXPORT2(XamIsUIActive, kUI, kImplemented, kHighFrequency);
 
 class MessageBoxDialog : public XamDialog {
@@ -263,11 +263,10 @@ class MessageBoxDialog : public XamDialog {
 };
 
 // https://www.se7ensins.com/forums/threads/working-xshowmessageboxui.844116/
-dword_result_t XamShowMessageBoxUI(dword_t user_index, lpu16string_t title_ptr,
-                                   lpu16string_t text_ptr, dword_t button_count,
-                                   lpdword_t button_ptrs, dword_t active_button,
-                                   dword_t flags, lpdword_t result_ptr,
-                                   pointer_t<XAM_OVERLAPPED> overlapped) {
+dword_result_t XamShowMessageBoxUI_entry(
+    dword_t user_index, lpu16string_t title_ptr, lpu16string_t text_ptr,
+    dword_t button_count, lpdword_t button_ptrs, dword_t active_button,
+    dword_t flags, lpdword_t result_ptr, pointer_t<XAM_OVERLAPPED> overlapped) {
   std::string title;
   if (title_ptr) {
     title = xe::to_utf8(title_ptr.value());
@@ -404,11 +403,10 @@ class KeyboardInputDialog : public XamDialog {
 };
 
 // https://www.se7ensins.com/forums/threads/release-how-to-use-xshowkeyboardui-release.906568/
-dword_result_t XamShowKeyboardUI(dword_t user_index, dword_t flags,
-                                 lpu16string_t default_text,
-                                 lpu16string_t title, lpu16string_t description,
-                                 lpu16string_t buffer, dword_t buffer_length,
-                                 pointer_t<XAM_OVERLAPPED> overlapped) {
+dword_result_t XamShowKeyboardUI_entry(
+    dword_t user_index, dword_t flags, lpu16string_t default_text,
+    lpu16string_t title, lpu16string_t description, lpu16string_t buffer,
+    dword_t buffer_length, pointer_t<XAM_OVERLAPPED> overlapped) {
   if (!buffer) {
     return X_ERROR_INVALID_PARAMETER;
   }
@@ -461,11 +459,10 @@ dword_result_t XamShowKeyboardUI(dword_t user_index, dword_t flags,
 }
 DECLARE_XAM_EXPORT1(XamShowKeyboardUI, kUI, kImplemented);
 
-dword_result_t XamShowDeviceSelectorUI(dword_t user_index, dword_t content_type,
-                                       dword_t content_flags,
-                                       qword_t total_requested,
-                                       lpdword_t device_id_ptr,
-                                       pointer_t<XAM_OVERLAPPED> overlapped) {
+dword_result_t XamShowDeviceSelectorUI_entry(
+    dword_t user_index, dword_t content_type, dword_t content_flags,
+    qword_t total_requested, lpdword_t device_id_ptr,
+    pointer_t<XAM_OVERLAPPED> overlapped) {
   return xeXamDispatchHeadless(
       [device_id_ptr]() -> X_RESULT {
         // NOTE: 0x00000001 is our dummy device ID from xam_content.cc
@@ -476,7 +473,7 @@ dword_result_t XamShowDeviceSelectorUI(dword_t user_index, dword_t content_type,
 }
 DECLARE_XAM_EXPORT1(XamShowDeviceSelectorUI, kUI, kImplemented);
 
-void XamShowDirtyDiscErrorUI(dword_t user_index) {
+void XamShowDirtyDiscErrorUI_entry(dword_t user_index) {
   if (cvars::headless) {
     assert_always();
     exit(1);
@@ -496,12 +493,12 @@ void XamShowDirtyDiscErrorUI(dword_t user_index) {
 }
 DECLARE_XAM_EXPORT1(XamShowDirtyDiscErrorUI, kUI, kImplemented);
 
-dword_result_t XamShowPartyUI(unknown_t r3, unknown_t r4) {
+dword_result_t XamShowPartyUI_entry(unknown_t r3, unknown_t r4) {
   return X_ERROR_FUNCTION_FAILED;
 }
 DECLARE_XAM_EXPORT1(XamShowPartyUI, kNone, kStub);
 
-dword_result_t XamShowCommunitySessionsUI(unknown_t r3, unknown_t r4) {
+dword_result_t XamShowCommunitySessionsUI_entry(unknown_t r3, unknown_t r4) {
   return X_ERROR_FUNCTION_FAILED;
 }
 DECLARE_XAM_EXPORT1(XamShowCommunitySessionsUI, kNone, kStub);

src/xenia/kernel/xam/xam_user.cc

@@ -2,7 +2,7 @@
  ******************************************************************************
  * Xenia : Xbox 360 Emulator Research Project                                 *
  ******************************************************************************
- * Copyright 2021 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. *
  ******************************************************************************
  */
@@ -23,8 +23,8 @@ namespace xe {
 namespace kernel {
 namespace xam {
 
-X_HRESULT_result_t XamUserGetXUID(dword_t user_index, dword_t type_mask,
-                                  lpqword_t xuid_ptr) {
+X_HRESULT_result_t XamUserGetXUID_entry(dword_t user_index, dword_t type_mask,
+                                        lpqword_t xuid_ptr) {
   assert_true(type_mask == 1 || type_mask == 2 || type_mask == 3 ||
               type_mask == 4 || type_mask == 7);
   if (!xuid_ptr) {
@@ -54,7 +54,7 @@ X_HRESULT_result_t XamUserGetXUID(dword_t user_index, dword_t type_mask,
 }
 DECLARE_XAM_EXPORT1(XamUserGetXUID, kUserProfiles, kImplemented);
 
-dword_result_t XamUserGetSigninState(dword_t user_index) {
+dword_result_t XamUserGetSigninState_entry(dword_t user_index) {
   // Yield, as some games spam this.
   xe::threading::MaybeYield();
   uint32_t signin_state = 0;
@@ -79,8 +79,8 @@ typedef struct {
 } X_USER_SIGNIN_INFO;
 static_assert_size(X_USER_SIGNIN_INFO, 40);
 
-X_HRESULT_result_t XamUserGetSigninInfo(dword_t user_index, dword_t flags,
-                                        pointer_t<X_USER_SIGNIN_INFO> info) {
+X_HRESULT_result_t XamUserGetSigninInfo_entry(
+    dword_t user_index, dword_t flags, pointer_t<X_USER_SIGNIN_INFO> info) {
   if (!info) {
     return X_E_INVALIDARG;
   }
@@ -99,8 +99,8 @@ X_HRESULT_result_t XamUserGetSigninInfo(dword_t user_index, dword_t flags,
 }
 DECLARE_XAM_EXPORT1(XamUserGetSigninInfo, kUserProfiles, kImplemented);
 
-dword_result_t XamUserGetName(dword_t user_index, lpstring_t buffer,
-                              dword_t buffer_len) {
+dword_result_t XamUserGetName_entry(dword_t user_index, lpstring_t buffer,
+                                    dword_t buffer_len) {
   if (user_index >= 4) {
     return X_E_INVALIDARG;
   }
@@ -117,8 +117,9 @@ dword_result_t XamUserGetName(dword_t user_index, lpstring_t buffer,
 }
 DECLARE_XAM_EXPORT1(XamUserGetName, kUserProfiles, kImplemented);
 
-dword_result_t XamUserGetGamerTag(dword_t user_index, lpu16string_t buffer,
-                                  dword_t buffer_len) {
+dword_result_t XamUserGetGamerTag_entry(dword_t user_index,
+                                        lpu16string_t buffer,
+                                        dword_t buffer_len) {
   if (user_index >= 4) {
     return X_E_INVALIDARG;
   }
@@ -304,7 +305,7 @@ uint32_t xeXamUserReadProfileSettingsEx(uint32_t title_id, uint32_t user_index,
   return X_ERROR_SUCCESS;
 }
 
-dword_result_t XamUserReadProfileSettings(
+dword_result_t XamUserReadProfileSettings_entry(
     dword_t title_id, dword_t user_index, dword_t xuid_count, lpqword_t xuids,
     dword_t setting_count, lpdword_t setting_ids, lpdword_t buffer_size_ptr,
     lpvoid_t buffer_ptr, dword_t overlapped_ptr) {
@@ -314,7 +315,7 @@ dword_result_t XamUserReadProfileSettings(
 }
 DECLARE_XAM_EXPORT1(XamUserReadProfileSettings, kUserProfiles, kImplemented);
 
-dword_result_t XamUserReadProfileSettingsEx(
+dword_result_t XamUserReadProfileSettingsEx_entry(
     dword_t title_id, dword_t user_index, dword_t xuid_count, lpqword_t xuids,
     dword_t setting_count, lpdword_t setting_ids, lpdword_t buffer_size_ptr,
     dword_t unk_2, lpvoid_t buffer_ptr, dword_t overlapped_ptr) {
@@ -347,7 +348,7 @@ typedef struct {
   };
 } X_USER_WRITE_PROFILE_SETTING;
 
-dword_result_t XamUserWriteProfileSettings(
+dword_result_t XamUserWriteProfileSettings_entry(
     dword_t title_id, dword_t user_index, dword_t setting_count,
     pointer_t<X_USER_WRITE_PROFILE_SETTING> settings, dword_t overlapped_ptr) {
   if (!setting_count || !settings) {
@@ -423,8 +424,8 @@ dword_result_t XamUserWriteProfileSettings(
 }
 DECLARE_XAM_EXPORT1(XamUserWriteProfileSettings, kUserProfiles, kImplemented);
 
-dword_result_t XamUserCheckPrivilege(dword_t user_index, dword_t mask,
-                                     lpdword_t out_value) {
+dword_result_t XamUserCheckPrivilege_entry(dword_t user_index, dword_t mask,
+                                           lpdword_t out_value) {
   // checking all users?
   if (user_index != 0xFF) {
     if (user_index >= 4) {
@@ -442,8 +443,8 @@ dword_result_t XamUserCheckPrivilege(dword_t user_index, dword_t mask,
 }
 DECLARE_XAM_EXPORT1(XamUserCheckPrivilege, kUserProfiles, kStub);
 
-dword_result_t XamUserContentRestrictionGetFlags(dword_t user_index,
-                                                 lpdword_t out_flags) {
+dword_result_t XamUserContentRestrictionGetFlags_entry(dword_t user_index,
+                                                       lpdword_t out_flags) {
   if (user_index) {
     return X_ERROR_NO_SUCH_USER;
   }
@@ -454,10 +455,10 @@ dword_result_t XamUserContentRestrictionGetFlags(dword_t user_index,
 }
 DECLARE_XAM_EXPORT1(XamUserContentRestrictionGetFlags, kUserProfiles, kStub);
 
-dword_result_t XamUserContentRestrictionGetRating(dword_t user_index,
-                                                  dword_t unk1,
-                                                  lpdword_t out_unk2,
-                                                  lpdword_t out_unk3) {
+dword_result_t XamUserContentRestrictionGetRating_entry(dword_t user_index,
+                                                        dword_t unk1,
+                                                        lpdword_t out_unk2,
+                                                        lpdword_t out_unk3) {
   if (user_index) {
     return X_ERROR_NO_SUCH_USER;
   }
@@ -470,11 +471,9 @@ dword_result_t XamUserContentRestrictionGetRating(dword_t user_index,
 }
 DECLARE_XAM_EXPORT1(XamUserContentRestrictionGetRating, kUserProfiles, kStub);
 
-dword_result_t XamUserContentRestrictionCheckAccess(dword_t user_index,
-                                                    dword_t unk1, dword_t unk2,
-                                                    dword_t unk3, dword_t unk4,
-                                                    lpdword_t out_unk5,
-                                                    dword_t overlapped_ptr) {
+dword_result_t XamUserContentRestrictionCheckAccess_entry(
+    dword_t user_index, dword_t unk1, dword_t unk2, dword_t unk3, dword_t unk4,
+    lpdword_t out_unk5, dword_t overlapped_ptr) {
   *out_unk5 = 1;
 
   if (overlapped_ptr) {
@@ -487,10 +486,10 @@ dword_result_t XamUserContentRestrictionCheckAccess(dword_t user_index,
 }
 DECLARE_XAM_EXPORT1(XamUserContentRestrictionCheckAccess, kUserProfiles, kStub);
 
-dword_result_t XamUserIsOnlineEnabled(dword_t user_index) { return 1; }
+dword_result_t XamUserIsOnlineEnabled_entry(dword_t user_index) { return 1; }
 DECLARE_XAM_EXPORT1(XamUserIsOnlineEnabled, kUserProfiles, kStub);
 
-dword_result_t XamUserGetMembershipTier(dword_t user_index) {
+dword_result_t XamUserGetMembershipTier_entry(dword_t user_index) {
   if (user_index >= 4) {
     return X_ERROR_INVALID_PARAMETER;
   }
@@ -501,9 +500,9 @@ dword_result_t XamUserGetMembershipTier(dword_t user_index) {
 }
 DECLARE_XAM_EXPORT1(XamUserGetMembershipTier, kUserProfiles, kStub);
 
-dword_result_t XamUserAreUsersFriends(dword_t user_index, dword_t unk1,
-                                      dword_t unk2, lpdword_t out_value,
-                                      dword_t overlapped_ptr) {
+dword_result_t XamUserAreUsersFriends_entry(dword_t user_index, dword_t unk1,
+                                            dword_t unk2, lpdword_t out_value,
+                                            dword_t overlapped_ptr) {
   uint32_t are_friends = 0;
   X_RESULT result;
 
@@ -545,7 +544,7 @@ dword_result_t XamUserAreUsersFriends(dword_t user_index, dword_t unk1,
 }
 DECLARE_XAM_EXPORT1(XamUserAreUsersFriends, kUserProfiles, kStub);
 
-dword_result_t XamShowSigninUI(dword_t unk, dword_t unk_mask) {
+dword_result_t XamShowSigninUI_entry(dword_t unk, dword_t unk_mask) {
   // Mask values vary. Probably matching user types? Local/remote?
 
   // To fix game modes that display a 4 profile signin UI (even if playing
@@ -676,12 +675,10 @@ class XStaticAchievementEnumerator : public XEnumerator {
   size_t current_item_ = 0;
 };
 
-dword_result_t XamUserCreateAchievementEnumerator(dword_t title_id,
-                                                  dword_t user_index,
-                                                  dword_t xuid, dword_t flags,
-                                                  dword_t offset, dword_t count,
-                                                  lpdword_t buffer_size_ptr,
-                                                  lpdword_t handle_ptr) {
+dword_result_t XamUserCreateAchievementEnumerator_entry(
+    dword_t title_id, dword_t user_index, dword_t xuid, dword_t flags,
+    dword_t offset, dword_t count, lpdword_t buffer_size_ptr,
+    lpdword_t handle_ptr) {
   if (!count || !buffer_size_ptr || !handle_ptr) {
     return X_ERROR_INVALID_PARAMETER;
   }
@@ -727,8 +724,9 @@ dword_result_t XamUserCreateAchievementEnumerator(dword_t title_id,
 DECLARE_XAM_EXPORT1(XamUserCreateAchievementEnumerator, kUserProfiles,
                     kSketchy);
 
-dword_result_t XamParseGamerTileKey(lpdword_t key_ptr, lpdword_t out1_ptr,
-                                    lpdword_t out2_ptr, lpdword_t out3_ptr) {
+dword_result_t XamParseGamerTileKey_entry(lpdword_t key_ptr, lpdword_t out1_ptr,
+                                          lpdword_t out2_ptr,
+                                          lpdword_t out3_ptr) {
   *out1_ptr = 0xC0DE0001;
   *out2_ptr = 0xC0DE0002;
   *out3_ptr = 0xC0DE0003;
@@ -736,10 +734,11 @@ dword_result_t XamParseGamerTileKey(lpdword_t key_ptr, lpdword_t out1_ptr,
 }
 DECLARE_XAM_EXPORT1(XamParseGamerTileKey, kUserProfiles, kStub);
 
-dword_result_t XamReadTileToTexture(dword_t unknown, dword_t title_id,
-                                    qword_t tile_id, dword_t user_index,
-                                    lpvoid_t buffer_ptr, dword_t stride,
-                                    dword_t height, dword_t overlapped_ptr) {
+dword_result_t XamReadTileToTexture_entry(dword_t unknown, dword_t title_id,
+                                          qword_t tile_id, dword_t user_index,
+                                          lpvoid_t buffer_ptr, dword_t stride,
+                                          dword_t height,
+                                          dword_t overlapped_ptr) {
   // TODO(gibbed): unknown=0,2,3,9
   if (!tile_id) {
     return X_ERROR_INVALID_PARAMETER;
@@ -757,9 +756,9 @@ dword_result_t XamReadTileToTexture(dword_t unknown, dword_t title_id,
 }
 DECLARE_XAM_EXPORT1(XamReadTileToTexture, kUserProfiles, kStub);
 
-dword_result_t XamWriteGamerTile(dword_t arg1, dword_t arg2, dword_t arg3,
-                                 dword_t arg4, dword_t arg5,
-                                 dword_t overlapped_ptr) {
+dword_result_t XamWriteGamerTile_entry(dword_t arg1, dword_t arg2, dword_t arg3,
+                                       dword_t arg4, dword_t arg5,
+                                       dword_t overlapped_ptr) {
   if (overlapped_ptr) {
     kernel_state()->CompleteOverlappedImmediate(overlapped_ptr,
                                                 X_ERROR_SUCCESS);
@@ -769,13 +768,14 @@ dword_result_t XamWriteGamerTile(dword_t arg1, dword_t arg2, dword_t arg3,
 }
 DECLARE_XAM_EXPORT1(XamWriteGamerTile, kUserProfiles, kStub);
 
-dword_result_t XamSessionCreateHandle(lpdword_t handle_ptr) {
+dword_result_t XamSessionCreateHandle_entry(lpdword_t handle_ptr) {
   *handle_ptr = 0xCAFEDEAD;
   return X_ERROR_SUCCESS;
 }
 DECLARE_XAM_EXPORT1(XamSessionCreateHandle, kUserProfiles, kStub);
 
-dword_result_t XamSessionRefObjByHandle(dword_t handle, lpdword_t obj_ptr) {
+dword_result_t XamSessionRefObjByHandle_entry(dword_t handle,
+                                              lpdword_t obj_ptr) {
   assert_true(handle == 0xCAFEDEAD);
   // TODO(PermaNull): Implement this properly,
   // For the time being returning 0xDEADF00D will prevent crashing.

src/xenia/kernel/xam/xam_video.cc

@@ -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. *
  ******************************************************************************
  */
@@ -18,13 +18,13 @@ namespace xe {
 namespace kernel {
 namespace xam {
 
-void XGetVideoMode(pointer_t<X_VIDEO_MODE> video_mode) {
+void XGetVideoMode_entry(pointer_t<X_VIDEO_MODE> video_mode) {
   // TODO(benvanik): actually check to see if these are the same.
   xboxkrnl::VdQueryVideoMode(std::move(video_mode));
 }
 DECLARE_XAM_EXPORT1(XGetVideoMode, kVideo, ExportTag::kSketchy);
 
-dword_result_t XGetVideoCapabilities() { return 0; }
+dword_result_t XGetVideoCapabilities_entry() { return 0; }
 DECLARE_XAM_EXPORT1(XGetVideoCapabilities, kVideo, kStub);
 
 void RegisterVideoExports(xe::cpu::ExportResolver* export_resolver,

src/xenia/kernel/xam/xam_voice.cc

@@ -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. *
  ******************************************************************************
  */
@@ -17,25 +17,25 @@ namespace xe {
 namespace kernel {
 namespace xam {
 
-dword_result_t XamVoiceIsActiveProcess() {
+dword_result_t XamVoiceIsActiveProcess_entry() {
   // Returning 0 here will short-circuit a bunch of voice stuff.
   return 0;
 }
 DECLARE_XAM_EXPORT1(XamVoiceIsActiveProcess, kNone, kStub);
 
-dword_result_t XamVoiceCreate(unknown_t unk1,  // 0
-                              unknown_t unk2,  // 0xF
-                              lpdword_t out_voice_ptr) {
+dword_result_t XamVoiceCreate_entry(unknown_t unk1,  // 0
+                                    unknown_t unk2,  // 0xF
+                                    lpdword_t out_voice_ptr) {
   // Null out the ptr.
   out_voice_ptr.Zero();
   return X_ERROR_ACCESS_DENIED;
 }
 DECLARE_XAM_EXPORT1(XamVoiceCreate, kNone, kStub);
 
-dword_result_t XamVoiceClose(lpunknown_t voice_ptr) { return 0; }
+dword_result_t XamVoiceClose_entry(lpunknown_t voice_ptr) { return 0; }
 DECLARE_XAM_EXPORT1(XamVoiceClose, kNone, kStub);
 
-dword_result_t XamVoiceHeadsetPresent(lpunknown_t voice_ptr) { return 0; }
+dword_result_t XamVoiceHeadsetPresent_entry(lpunknown_t voice_ptr) { return 0; }
 DECLARE_XAM_EXPORT1(XamVoiceHeadsetPresent, kNone, kStub);
 
 void RegisterVoiceExports(xe::cpu::ExportResolver* export_resolver,