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

Cleaning up asserts and file/line macros.

Browse Source
This commit is contained in:
Ben Vanik
2014-07-12 16:51:52 -07:00
parent 840357413c
commit bf882714d0
92 changed files with 636 additions and 613 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/xenia/kernel/fs/devices/disc_image_device.cc
View File

@@ -98,11 +98,11 @@ Entry* DiscImageDevice::ResolvePath(const char* path) {
}
X_STATUS DiscImageDevice::QueryVolume(XVolumeInfo* out_info, size_t length) {
XEASSERTALWAYS();
assert_always();
return X_STATUS_NOT_IMPLEMENTED;
}
X_STATUS DiscImageDevice::QueryFileSystemAttributes(XFileSystemAttributeInfo* out_info, size_t length) {
XEASSERTALWAYS();
assert_always();
return X_STATUS_NOT_IMPLEMENTED;
}

4
src/xenia/kernel/fs/devices/disc_image_entry.cc
View File

@@ -53,7 +53,7 @@ DiscImageEntry::~DiscImageEntry() {
}
X_STATUS DiscImageEntry::QueryInfo(XFileInfo* out_info) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
out_info->creation_time = 0;
out_info->last_access_time = 0;
out_info->last_write_time = 0;
@@ -66,7 +66,7 @@ X_STATUS DiscImageEntry::QueryInfo(XFileInfo* out_info) {
X_STATUS DiscImageEntry::QueryDirectory(
XDirectoryInfo* out_info, size_t length, const char* file_name, bool restart) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
if (restart == true && gdfx_entry_iterator_ != gdfx_entry_->children.end()) {
gdfx_entry_iterator_ = gdfx_entry_->children.end();

4
src/xenia/kernel/fs/devices/host_path_device.cc
View File

@@ -67,7 +67,7 @@ Entry* HostPathDevice::ResolvePath(const char* path) {
// TODO(gibbed): call into HostPathDevice?
X_STATUS HostPathDevice::QueryVolume(XVolumeInfo* out_info, size_t length) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
const char* name = "test"; // TODO(gibbed): actual value
auto end = (uint8_t*)out_info + length;
@@ -86,7 +86,7 @@ X_STATUS HostPathDevice::QueryVolume(XVolumeInfo* out_info, size_t length) {
// TODO(gibbed): call into HostPathDevice?
X_STATUS HostPathDevice::QueryFileSystemAttributes(XFileSystemAttributeInfo* out_info, size_t length) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
const char* name = "test"; // TODO(gibbed): actual value
auto end = (uint8_t*)out_info + length;

4
src/xenia/kernel/fs/devices/host_path_entry.cc
View File

@@ -54,7 +54,7 @@ HostPathEntry::~HostPathEntry() {
#define COMBINE_TIME(t) (((uint64_t)t.dwHighDateTime << 32) | t.dwLowDateTime)
X_STATUS HostPathEntry::QueryInfo(XFileInfo* out_info) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
WIN32_FILE_ATTRIBUTE_DATA data;
if (!GetFileAttributesEx(
@@ -75,7 +75,7 @@ X_STATUS HostPathEntry::QueryInfo(XFileInfo* out_info) {
X_STATUS HostPathEntry::QueryDirectory(
XDirectoryInfo* out_info, size_t length, const char* file_name, bool restart) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
WIN32_FIND_DATA ffd;

4
src/xenia/kernel/fs/devices/stfs_container_device.cc
View File

@@ -100,11 +100,11 @@ Entry* STFSContainerDevice::ResolvePath(const char* path) {
X_STATUS STFSContainerDevice::QueryVolume(XVolumeInfo* out_info, size_t length) {
XEASSERTALWAYS();
assert_always();
return X_STATUS_NOT_IMPLEMENTED;
}
X_STATUS STFSContainerDevice::QueryFileSystemAttributes(XFileSystemAttributeInfo* out_info, size_t length) {
XEASSERTALWAYS();
assert_always();
return X_STATUS_NOT_IMPLEMENTED;
}

4
src/xenia/kernel/fs/devices/stfs_container_entry.cc
View File

@@ -32,7 +32,7 @@ STFSContainerEntry::~STFSContainerEntry() {
}
X_STATUS STFSContainerEntry::QueryInfo(XFileInfo* out_info) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
out_info->creation_time = stfs_entry_->update_timestamp;
out_info->last_access_time = stfs_entry_->access_timestamp;
out_info->last_write_time = stfs_entry_->update_timestamp;
@@ -45,7 +45,7 @@ X_STATUS STFSContainerEntry::QueryInfo(XFileInfo* out_info) {
X_STATUS STFSContainerEntry::QueryDirectory(
XDirectoryInfo* out_info, size_t length, const char* file_name, bool restart) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
if (restart && stfs_entry_iterator_ != stfs_entry_->children.end()) {
stfs_entry_iterator_ = stfs_entry_->children.end();

2
src/xenia/kernel/fs/entry.cc
View File

@@ -26,7 +26,7 @@ MemoryMapping::~MemoryMapping() {
Entry::Entry(Type type, Device* device, const char* path) :
type_(type),
device_(device) {
XEASSERTNOTNULL(device);
assert_not_null(device);
path_ = xestrdupa(path);
// TODO(benvanik): *shudder*
absolute_path_ = xestrdupa((std::string(device->path()) + std::string(path)).c_str());

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

@@ -42,7 +42,7 @@ KernelState::KernelState(Emulator* emulator) :
object_table_ = new ObjectTable();
object_mutex_ = xe_mutex_alloc(10000);
XEASSERTNULL(shared_kernel_state_);
assert_null(shared_kernel_state_);
shared_kernel_state_ = this;
}
@@ -55,7 +55,7 @@ KernelState::~KernelState() {
delete dispatcher_;
XEASSERT(shared_kernel_state_ == this);
assert_true(shared_kernel_state_ == this);
shared_kernel_state_ = NULL;
}
@@ -81,7 +81,7 @@ XModule* KernelState::GetModule(const char* name) {
return NULL;
} else {
// TODO(benvanik): support user modules/loading/etc.
XEASSERTALWAYS();
assert_always();
return NULL;
}
}

8
src/xenia/kernel/object_table.cc
View File

@@ -22,7 +22,7 @@ ObjectTable::ObjectTable() :
table_(NULL),
last_free_entry_(0) {
table_mutex_ = xe_mutex_alloc(0);
XEASSERTNOTNULL(table_mutex_);
assert_not_null(table_mutex_);
}
ObjectTable::~ObjectTable() {
@@ -88,7 +88,7 @@ X_STATUS ObjectTable::FindFreeSlot(uint32_t* out_slot) {
}
X_STATUS ObjectTable::AddHandle(XObject* object, X_HANDLE* out_handle) {
XEASSERTNOTNULL(out_handle);
assert_not_null(out_handle);
X_STATUS result = X_STATUS_SUCCESS;
@@ -156,7 +156,7 @@ X_STATUS ObjectTable::RemoveHandle(X_HANDLE handle) {
}
X_STATUS ObjectTable::GetObject(X_HANDLE handle, XObject** out_object) {
XEASSERTNOTNULL(out_object);
assert_not_null(out_object);
X_STATUS result = X_STATUS_SUCCESS;
@@ -197,7 +197,7 @@ X_STATUS ObjectTable::GetObject(X_HANDLE handle, XObject** out_object) {
X_HANDLE ObjectTable::TranslateHandle(X_HANDLE handle) {
if (handle == 0xFFFFFFFF) {
// CurrentProcess
//XEASSERTALWAYS();
//assert_always();
return 0;
} else if (handle == 0xFFFFFFFE) {
// CurrentThread

6
src/xenia/kernel/objects/xevent.cc
View File

@@ -26,13 +26,13 @@ XEvent::~XEvent() {
}
void XEvent::Initialize(bool manual_reset, bool initial_state) {
XEASSERTNULL(handle_);
assert_null(handle_);
handle_ = CreateEvent(NULL, manual_reset, initial_state, NULL);
}
void XEvent::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) {
XEASSERTNULL(handle_);
assert_null(handle_);
bool manual_reset;
switch (header.type_flags >> 24) {
@@ -43,7 +43,7 @@ void XEvent::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) {
manual_reset = false;
break;
default:
XEASSERTALWAYS();
assert_always();
return;
}

6
src/xenia/kernel/objects/xfile.h
View File

@@ -81,7 +81,7 @@ public:
} while (info->next_entry_offset != 0);
}
};
XEASSERTSTRUCTSIZE(XDirectoryInfo, 72);
static_assert_size(XDirectoryInfo, 72);
// http://msdn.microsoft.com/en-us/library/windows/hardware/ff540287(v=vs.85).aspx
class XVolumeInfo {
@@ -102,7 +102,7 @@ public:
xe_copy_memory(dst + 20, this->label_length, this->label, this->label_length);
}
};
XEASSERTSTRUCTSIZE(XVolumeInfo, 24);
static_assert_size(XVolumeInfo, 24);
// http://msdn.microsoft.com/en-us/library/windows/hardware/ff540251(v=vs.85).aspx
class XFileSystemAttributeInfo {
@@ -121,7 +121,7 @@ public:
xe_copy_memory(dst + 12, this->fs_name_length, this->fs_name, this->fs_name_length);
}
};
XEASSERTSTRUCTSIZE(XFileSystemAttributeInfo, 16);
static_assert_size(XFileSystemAttributeInfo, 16);
class XFile : public XObject {
public:

8
src/xenia/kernel/objects/xmutant.cc
View File

@@ -26,22 +26,22 @@ XMutant::~XMutant() {
}
void XMutant::Initialize(bool initial_owner) {
XEASSERTNULL(handle_);
assert_null(handle_);
handle_ = CreateMutex(NULL, initial_owner ? TRUE : FALSE, NULL);
}
void XMutant::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) {
XEASSERTNULL(handle_);
assert_null(handle_);
// Haven't seen this yet, but it's possible.
XEASSERTALWAYS();
assert_always();
}
X_STATUS XMutant::ReleaseMutant(
uint32_t priority_increment, bool abandon, bool wait) {
// TODO(benvanik): abandoning.
XEASSERTFALSE(abandon);
assert_false(abandon);
BOOL result = ReleaseMutex(handle_);
if (result) {
return X_STATUS_SUCCESS;

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

@@ -28,7 +28,7 @@ XNotifyListener::~XNotifyListener() {
}
void XNotifyListener::Initialize(uint64_t mask) {
XEASSERTNULL(wait_handle_);
assert_null(wait_handle_);
lock_ = xe_mutex_alloc();
wait_handle_ = CreateEvent(NULL, TRUE, FALSE, NULL);

4
src/xenia/kernel/objects/xsemaphore.cc
View File

@@ -26,13 +26,13 @@ XSemaphore::~XSemaphore() {
}
void XSemaphore::Initialize(int32_t initial_count, int32_t maximum_count) {
XEASSERTNULL(handle_);
assert_null(handle_);
handle_ = CreateSemaphore(NULL, initial_count, maximum_count, NULL);
}
void XSemaphore::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) {
XEASSERTNULL(handle_);
assert_null(handle_);
// NOT IMPLEMENTED
// We expect Initialize to be called shortly.

4
src/xenia/kernel/objects/xthread.cc
View File

@@ -334,7 +334,7 @@ X_STATUS XThread::PlatformCreate() {
this);
#else
// TODO(benvanik): pthread_create_suspended_np on linux
XEASSERTALWAYS();
assert_always();
#endif // OSX
} else {
result_code = pthread_create(
@@ -552,7 +552,7 @@ X_STATUS XThread::Delay(
if (timeout_ticks > 0) {
// Absolute time, based on January 1, 1601.
// TODO(benvanik): convert time to relative time.
XEASSERTALWAYS();
assert_always();
timeout_ms = 0;
} else if (timeout_ticks < 0) {
// Relative time.

6
src/xenia/kernel/objects/xtimer.cc
View File

@@ -28,7 +28,7 @@ XTimer::~XTimer() {
}
void XTimer::Initialize(uint32_t timer_type) {
XEASSERTNULL(handle_);
assert_null(handle_);
bool manual_reset = false;
switch (timer_type) {
@@ -39,7 +39,7 @@ void XTimer::Initialize(uint32_t timer_type) {
manual_reset = false;
break;
default:
XEASSERTALWAYS();
assert_always();
break;
}
@@ -71,7 +71,7 @@ X_STATUS XTimer::SetTimer(
void XTimer::CompletionRoutine(
XTimer* timer, DWORD timer_low, DWORD timer_high) {
XEASSERT(timer->current_routine_);
assert_true(timer->current_routine_);
// Queue APC to call back routine with (arg, low, high).
// TODO(benvanik): APC dispatch.

38
src/xenia/kernel/util/xex2.cc
View File

@@ -238,7 +238,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
{
const size_t max_count = XECOUNT(header->import_libraries);
size_t count = XEGETUINT32BE(pp + 0x08);
XEASSERT(count <= max_count);
assert_true(count <= max_count);
if (count > max_count) {
XELOGW("ignoring %zu extra entries in XEX_HEADER_IMPORT_LIBRARIES",
(max_count - count));
@@ -260,7 +260,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
const uint16_t name_index = XEGETUINT16BE(pp + 0x24) & 0xFF;
for (size_t i = 0, j = 0; i < string_table_size;) {
XEASSERT(j <= 0xFF);
assert_true(j <= 0xFF);
if (j == name_index) {
XEIGNORE(xestrcpya(library->name, XECOUNT(library->name),
string_table + i));
@@ -293,7 +293,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
{
const size_t max_count = XECOUNT(header->static_libraries);
size_t count = (opt_header->length - 4) / 16;
XEASSERT(count <= max_count);
assert_true(count <= max_count);
if (count > max_count) {
XELOGW("ignoring %zu extra entries in XEX_HEADER_STATIC_LIBRARIES",
(max_count - count));
@@ -326,7 +326,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
switch (fmt->compression_type) {
case XEX_COMPRESSION_NONE:
// TODO: XEX_COMPRESSION_NONE
XEASSERTALWAYS();
assert_always();
break;
case XEX_COMPRESSION_BASIC:
{
@@ -368,7 +368,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
break;
case XEX_COMPRESSION_DELTA:
// TODO: XEX_COMPRESSION_DELTA
XEASSERTALWAYS();
assert_always();
break;
}
}
@@ -460,7 +460,7 @@ typedef struct mspack_memory_file_t {
} mspack_memory_file;
mspack_memory_file *mspack_memory_open(struct mspack_system *sys,
void* buffer, const size_t buffer_size) {
XEASSERT(buffer_size < INT_MAX);
assert_true(buffer_size < INT_MAX);
if (buffer_size >= INT_MAX) {
return NULL;
}
@@ -575,7 +575,7 @@ int xe_xex2_read_image_uncompressed(const xe_xex2_header_t *header,
uncompressed_size);
return 0;
default:
XEASSERTALWAYS();
assert_always();
return 1;
}
@@ -642,7 +642,7 @@ int xe_xex2_read_image_basic_compressed(const xe_xex2_header_t *header,
}
break;
default:
XEASSERTALWAYS();
assert_always();
return 1;
}
@@ -701,7 +701,7 @@ int xe_xex2_read_image_compressed(const xe_xex2_header_t *header,
(uint8_t*)input_buffer, input_size);
break;
default:
XEASSERTALWAYS();
assert_always();
return false;
}
@@ -809,7 +809,7 @@ int xe_xex2_read_image(xe_xex2_ref xex, const uint8_t *xex_addr,
return xe_xex2_read_image_compressed(
header, xex_addr, xex_length, memory);
default:
XEASSERTALWAYS();
assert_always();
return 1;
}
}
@@ -922,7 +922,7 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
break;
}
}
XEASSERT(library_index != (size_t)-1);
assert_true(library_index != (size_t)-1);
// Records:
// The number of records does not correspond to the number of imports!
@@ -947,9 +947,9 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
// Allocate storage.
xe_xex2_import_info_t *infos = (xe_xex2_import_info_t*)xe_calloc(
info_count * sizeof(xe_xex2_import_info_t));
XEEXPECTNOTNULL(infos);
assert_not_null(infos);
XEASSERTNOTZERO(info_count);
assert_not_zero(info_count);
// Construct infos.
for (size_t n = 0, i = 0; n < library->record_count; n++) {
@@ -958,7 +958,7 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
const uint32_t type = (value & 0xFF000000) >> 24;
// Verify library index matches given library.
//XEASSERT(library_index == ((value >> 16) & 0xFF));
//assert_true(library_index == ((value >> 16) & 0xFF));
switch (type) {
case 0x00:
@@ -971,14 +971,14 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
case 0x01:
{
// Thunk for previous record.
XEASSERT(i > 0);
assert_true(i > 0);
xe_xex2_import_info_t* info = &infos[i - 1];
XEASSERT(info->ordinal == (value & 0xFFFF));
assert_true(info->ordinal == (value & 0xFFFF));
info->thunk_address = record;
}
break;
default:
//XEASSERTALWAYS();
//assert_always();
break;
}
}
@@ -986,10 +986,6 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
xex->library_imports[library_index].count = info_count;
xex->library_imports[library_index].infos = infos;
return 0;
XECLEANUP:
xe_free(infos);
return 1;
}
int xe_xex2_get_import_infos(xe_xex2_ref xex,

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

@@ -33,7 +33,7 @@ SHIM_CALL XamContentGetLicenseMask_shim(
mask_ptr,
overlapped_ptr);
XEASSERTZERO(overlapped_ptr);
assert_zero(overlapped_ptr);
// Arcade games seem to call this and check the result mask for random bits.
// If we fail, the games seem to use a hardcoded mask, which is likely trial.

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

@@ -44,8 +44,8 @@ SHIM_CALL XMsgInProcessCall_shim(
uint32_t a = SHIM_MEM_32(arg1 + 0); // 0x00000002
uint32_t b = SHIM_MEM_32(arg1 + 4); // out ptr to 4b - expect 0
XELOGD("XMPGetStatusEx(%.8X, %.8X)", a, b);
XEASSERTZERO(arg2);
XEASSERT(a == 2);
assert_zero(arg2);
assert_true(a == 2);
SHIM_SET_MEM_32(b, 0);
handled = true;
} else if (message == 0x0007001A) {
@@ -59,8 +59,8 @@ SHIM_CALL XMsgInProcessCall_shim(
uint32_t a = SHIM_MEM_32(arg1 + 0); // 0x00000002
uint32_t b = SHIM_MEM_32(arg1 + 4); // out ptr to 4b - expect 0
XELOGD("XMPGetStatus(%.8X, %.8X)", a, b);
XEASSERTZERO(arg2);
XEASSERT(a == 2);
assert_zero(arg2);
assert_true(a == 2);
SHIM_SET_MEM_32(b, 0);
handled = true;
}

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

@@ -136,7 +136,7 @@ SHIM_CALL XamUserReadProfileSettings_shim(
// 0xfffe07d1 = profile?
// TODO(benvanik): implement overlapped support
XEASSERTZERO(overlapped_ptr);
assert_zero(overlapped_ptr);
// First call asks for size (fill buffer_size_ptr).
// Second call asks for buffer contents with that size.

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

@@ -75,7 +75,7 @@ SHIM_CALL XAudioGetVoiceCategoryVolumeChangeMask_shim(
"XAudioGetVoiceCategoryVolumeChangeMask(%.8X, %.8X)",
driver_ptr, out_ptr);
XEASSERT((driver_ptr & 0xFFFF0000) == 0x41550000);
assert_true((driver_ptr & 0xFFFF0000) == 0x41550000);
auto audio_system = state->emulator()->audio_system();
@@ -124,7 +124,7 @@ SHIM_CALL XAudioRegisterRenderDriverClient_shim(
return;
}
XEASSERTTRUE(!(index & ~0x0000FFFF));
assert_true(!(index & ~0x0000FFFF));
SHIM_SET_MEM_32(driver_ptr, 0x41550000 | (index & 0x0000FFFF));
SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
}
@@ -138,7 +138,7 @@ SHIM_CALL XAudioUnregisterRenderDriverClient_shim(
"XAudioUnregisterRenderDriverClient(%.8X)",
driver_ptr);
XEASSERT((driver_ptr & 0xFFFF0000) == 0x41550000);
assert_true((driver_ptr & 0xFFFF0000) == 0x41550000);
auto audio_system = state->emulator()->audio_system();
audio_system->UnregisterClient(driver_ptr & 0x0000FFFF);
@@ -155,7 +155,7 @@ SHIM_CALL XAudioSubmitRenderDriverFrame_shim(
"XAudioSubmitRenderDriverFrame(%.8X, %.8X)",
driver_ptr, samples_ptr);
XEASSERT((driver_ptr & 0xFFFF0000) == 0x41550000);
assert_true((driver_ptr & 0xFFFF0000) == 0x41550000);
auto audio_system = state->emulator()->audio_system();
audio_system->SubmitFrame(driver_ptr & 0x0000FFFF, samples_ptr);

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

@@ -168,7 +168,7 @@ SHIM_CALL DbgPrint_shim(
local[0] = '\0';
strncat(local, start, end + 1 - start);
XEASSERT(arg_size == 8 || arg_size == 4);
assert_true(arg_size == 8 || arg_size == 4);
if (arg_size == 8) {
if (arg_extras == 0) {
uint64_t value = arg_index < 7
@@ -179,7 +179,7 @@ SHIM_CALL DbgPrint_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (arg_size == 4) {
@@ -192,13 +192,13 @@ SHIM_CALL DbgPrint_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
}
else if (*end == 'n')
{
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = arg_index < 7
? SHIM_GET_ARG_32(1 + arg_index)
@@ -207,7 +207,7 @@ SHIM_CALL DbgPrint_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (*end == 's' ||
@@ -216,7 +216,7 @@ SHIM_CALL DbgPrint_shim(
local[0] = '\0';
strncat(local, start, end + 1 - start);
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = arg_index < 7
? SHIM_GET_ARG_32(1 + arg_index)
@@ -227,11 +227,11 @@ SHIM_CALL DbgPrint_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else {
XEASSERT(false);
assert_true(false);
break;
}
@@ -271,7 +271,7 @@ SHIM_CALL RtlRaiseException_shim(
// SetThreadName. FFS.
uint32_t thread_info_ptr = record_ptr + 20;
uint32_t type = SHIM_MEM_32(thread_info_ptr + 0);
XEASSERT(type == 0x1000);
assert_true(type == 0x1000);
uint32_t name_ptr = SHIM_MEM_32(thread_info_ptr + 4);
uint32_t thread_id = SHIM_MEM_32(thread_info_ptr + 8);

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

@@ -25,13 +25,13 @@ namespace kernel {
void xeHalReturnToFirmware(uint32_t routine) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// void
// IN FIRMWARE_REENTRY Routine
// Routine must be 1 'HalRebootRoutine'
XEASSERT(routine == 1);
assert_true(routine == 1);
// TODO(benvank): diediedie much more gracefully
// Not sure how to blast back up the stack in LLVM without exceptions, though.

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

@@ -70,8 +70,8 @@ SHIM_CALL NtCreateFile_shim(
attrs.root_directory != 0) {
result = state->object_table()->GetObject(
attrs.root_directory, (XObject**)&root_file);
XEASSERT(XSUCCEEDED(result));
XEASSERT(root_file->type() == XObject::Type::kTypeFile);
assert_true(XSUCCEEDED(result));
assert_true(root_file->type() == XObject::Type::kTypeFile);
auto root_path = root_file->absolute_path();
auto target_path = xestrdupa((std::string(root_path) + std::string(object_name)).c_str());
@@ -147,9 +147,9 @@ SHIM_CALL NtOpenFile_shim(
if (attrs.root_directory != 0xFFFFFFFD) { // ObDosDevices
result = state->object_table()->GetObject(
attrs.root_directory, (XObject**)&root_file);
XEASSERT(XSUCCEEDED(result));
XEASSERT(root_file->type() == XObject::Type::kTypeFile);
XEASSERTALWAYS();
assert_true(XSUCCEEDED(result));
assert_true(root_file->type() == XObject::Type::kTypeFile);
assert_always();
}
// Resolve the file using the virtual file system.
@@ -226,7 +226,7 @@ SHIM_CALL NtReadFile_shim(
byte_offset);
// Async not supported yet.
XEASSERTNULL(apc_routine_ptr);
assert_zero(apc_routine_ptr);
X_STATUS result = X_STATUS_SUCCESS;
uint32_t info = 0;
@@ -338,13 +338,13 @@ SHIM_CALL NtSetInformationFile_shim(
// struct FILE_POSITION_INFORMATION {
// LARGE_INTEGER CurrentByteOffset;
// };
XEASSERT(length == 8);
assert_true(length == 8);
info = 8;
file->set_position(SHIM_MEM_64(file_info_ptr));
break;
default:
// Unsupported, for now.
XEASSERTALWAYS();
assert_always();
info = 0;
break;
}
@@ -394,7 +394,7 @@ SHIM_CALL NtQueryInformationFile_shim(
switch (file_info_class) {
case XFileInternalInformation:
// Internal unique file pointer. Not sure why anyone would want this.
XEASSERT(length == 8);
assert_true(length == 8);
info = 8;
// TODO(benvanik): use pointer to fs:: entry?
SHIM_SET_MEM_64(file_info_ptr, hash_combine(0, file->absolute_path()));
@@ -403,7 +403,7 @@ SHIM_CALL NtQueryInformationFile_shim(
// struct FILE_POSITION_INFORMATION {
// LARGE_INTEGER CurrentByteOffset;
// };
XEASSERT(length == 8);
assert_true(length == 8);
info = 8;
SHIM_SET_MEM_64(file_info_ptr, file->position());
break;
@@ -418,7 +418,7 @@ SHIM_CALL NtQueryInformationFile_shim(
// ULONG FileAttributes;
// ULONG Unknown;
// };
XEASSERT(length == 56);
assert_true(length == 56);
XFileInfo file_info;
result = file->QueryInfo(&file_info);
if (XSUCCEEDED(result)) {
@@ -447,7 +447,7 @@ SHIM_CALL NtQueryInformationFile_shim(
break;
default:
// Unsupported, for now.
XEASSERTALWAYS();
assert_always();
info = 0;
break;
}
@@ -489,9 +489,9 @@ SHIM_CALL NtQueryFullAttributesFile_shim(
if (attrs.root_directory != 0xFFFFFFFD) { // ObDosDevices
result = state->object_table()->GetObject(
attrs.root_directory, (XObject**)&root_file);
XEASSERT(XSUCCEEDED(result));
XEASSERT(root_file->type() == XObject::Type::kTypeFile);
XEASSERTALWAYS();
assert_true(XSUCCEEDED(result));
assert_true(root_file->type() == XObject::Type::kTypeFile);
assert_always();
}
// Resolve the file using the virtual file system.
@@ -560,7 +560,7 @@ SHIM_CALL NtQueryVolumeInformationFile_shim(
}
default:
// Unsupported, for now.
XEASSERTALWAYS();
assert_always();
info = 0;
break;
}

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

@@ -29,7 +29,7 @@ X_STATUS xeNtAllocateVirtualMemory(
uint32_t allocation_type, uint32_t protect_bits,
uint32_t unknown) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// NTSTATUS
// _Inout_ PVOID *BaseAddress,
@@ -39,7 +39,7 @@ X_STATUS xeNtAllocateVirtualMemory(
// ? handle?
// I've only seen zero.
XEASSERT(unknown == 0);
assert_true(unknown == 0);
// This allocates memory from the kernel heap, which is initialized on startup
// and shared by both the kernel implementation and user code.
@@ -73,7 +73,7 @@ X_STATUS xeNtAllocateVirtualMemory(
// already happened.
if (*base_addr_ptr) {
// Having a pointer already means that this is likely a follow-on COMMIT.
XEASSERT(!(allocation_type & X_MEM_RESERVE) &&
assert_true(!(allocation_type & X_MEM_RESERVE) &&
(allocation_type & X_MEM_COMMIT));
return X_STATUS_SUCCESS;
}
@@ -127,7 +127,7 @@ X_STATUS xeNtFreeVirtualMemory(
uint32_t* base_addr_ptr, uint32_t* region_size_ptr,
uint32_t free_type, uint32_t unknown) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// NTSTATUS
// _Inout_ PVOID *BaseAddress,
@@ -136,7 +136,7 @@ X_STATUS xeNtFreeVirtualMemory(
// ? handle?
// I've only seen zero.
XEASSERT(unknown == 0);
assert_true(unknown == 0);
if (!*base_addr_ptr) {
return X_STATUS_MEMORY_NOT_ALLOCATED;
@@ -193,7 +193,7 @@ uint32_t xeMmAllocatePhysicalMemoryEx(
uint32_t type, uint32_t region_size, uint32_t protect_bits,
uint32_t min_addr_range, uint32_t max_addr_range, uint32_t alignment) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// Type will usually be 0 (user request?), where 1 and 2 are sometimes made
// by D3D/etc.
@@ -230,8 +230,8 @@ uint32_t xeMmAllocatePhysicalMemoryEx(
// and the memory must be allocated there. I haven't seen a game do this,
// and instead they all do min=0 / max=-1 to indicate the system should pick.
// If we have to suport arbitrary placement things will get nasty.
XEASSERT(min_addr_range == 0);
XEASSERT(max_addr_range == 0xFFFFFFFF);
assert_true(min_addr_range == 0);
assert_true(max_addr_range == 0xFFFFFFFF);
// Allocate.
uint32_t flags = MEMORY_FLAG_PHYSICAL;
@@ -280,7 +280,7 @@ SHIM_CALL MmAllocatePhysicalMemoryEx_shim(
void xeMmFreePhysicalMemory(uint32_t type, uint32_t base_address) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// base_address = result of MmAllocatePhysicalMemory.
@@ -310,7 +310,7 @@ SHIM_CALL MmFreePhysicalMemory_shim(
uint32_t xeMmQueryAddressProtect(uint32_t base_address) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
uint32_t access = state->memory()->QueryProtect(base_address);
@@ -334,7 +334,7 @@ SHIM_CALL MmQueryAddressProtect_shim(
uint32_t xeMmQueryAllocationSize(uint32_t base_address) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
size_t size = state->memory()->QuerySize(base_address);

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

@@ -28,7 +28,7 @@ void xeKeBugCheckEx(uint32_t code, uint32_t param1, uint32_t param2, uint32_t pa
XELOGD("*** STOP: 0x%.8X (0x%.8X, 0x%.8X, 0x%.8X, 0x%.8X)", code, param1, param2, param3, param4);
fflush(stdout);
DebugBreak();
XEASSERTALWAYS();
assert_always();
}
SHIM_CALL KeBugCheck_shim(

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

@@ -43,7 +43,7 @@ X_STATUS xeExGetXConfigSetting(
value = 0x00001000; // USA/Canada
break;
default:
XEASSERTUNHANDLEDCASE(setting);
assert_unhandled_case(setting);
return X_STATUS_INVALID_PARAMETER_2;
}
break;
@@ -80,12 +80,12 @@ X_STATUS xeExGetXConfigSetting(
value = 0;
break;
default:
XEASSERTUNHANDLEDCASE(setting);
assert_unhandled_case(setting);
return X_STATUS_INVALID_PARAMETER_2;
}
break;
default:
XEASSERTUNHANDLEDCASE(category);
assert_unhandled_case(category);
return X_STATUS_INVALID_PARAMETER_1;
}
@@ -134,7 +134,7 @@ SHIM_CALL ExGetXConfigSetting_shim(
int xeXexCheckExecutablePriviledge(uint32_t privilege) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// BOOL
// DWORD Privilege
@@ -176,7 +176,7 @@ SHIM_CALL XexCheckExecutablePrivilege_shim(
int xeXexGetModuleHandle(const char* module_name,
X_HANDLE* module_handle_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// BOOL
// LPCSZ ModuleName

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

@@ -30,7 +30,7 @@ namespace kernel {
uint32_t xeRtlCompareMemory(uint32_t source1_ptr, uint32_t source2_ptr,
uint32_t length) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// SIZE_T
// _In_ const VOID *Source1,
@@ -74,7 +74,7 @@ SHIM_CALL RtlCompareMemory_shim(
uint32_t xeRtlCompareMemoryUlong(uint32_t source_ptr, uint32_t length,
uint32_t pattern) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// SIZE_T
// _In_ PVOID Source,
@@ -124,7 +124,7 @@ SHIM_CALL RtlCompareMemoryUlong_shim(
void xeRtlFillMemoryUlong(uint32_t destination_ptr, uint32_t length,
uint32_t pattern) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Out_ PVOID Destination,
@@ -172,7 +172,7 @@ SHIM_CALL RtlFillMemoryUlong_shim(
// http://msdn.microsoft.com/en-us/library/ff561918
void xeRtlInitAnsiString(uint32_t destination_ptr, uint32_t source_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Out_ PANSI_STRING DestinationString,
@@ -207,7 +207,7 @@ SHIM_CALL RtlInitAnsiString_shim(
// http://msdn.microsoft.com/en-us/library/ff561899
void xeRtlFreeAnsiString(uint32_t string_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Inout_ PANSI_STRING AnsiString
@@ -242,7 +242,7 @@ SHIM_CALL RtlFreeAnsiString_shim(
// http://msdn.microsoft.com/en-us/library/ff561934
void xeRtlInitUnicodeString(uint32_t destination_ptr, uint32_t source_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Out_ PUNICODE_STRING DestinationString,
@@ -281,7 +281,7 @@ SHIM_CALL RtlInitUnicodeString_shim(
// http://msdn.microsoft.com/en-us/library/ff561903
void xeRtlFreeUnicodeString(uint32_t string_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Inout_ PUNICODE_STRING UnicodeString
@@ -310,7 +310,7 @@ SHIM_CALL RtlFreeUnicodeString_shim(
X_STATUS xeRtlUnicodeStringToAnsiString(
uint32_t destination_ptr, uint32_t source_ptr, uint32_t alloc_dest) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// NTSTATUS
// _Inout_ PANSI_STRING DestinationString,
@@ -318,7 +318,7 @@ X_STATUS xeRtlUnicodeStringToAnsiString(
// _In_ BOOLEAN AllocateDestinationString
XELOGE("RtlUnicodeStringToAnsiString not yet implemented");
XEASSERTALWAYS();
assert_always();
if (alloc_dest) {
// Allocate a new buffer to place the string into.
@@ -438,7 +438,7 @@ SHIM_CALL RtlNtStatusToDosError_shim(
uint32_t xeRtlImageXexHeaderField(uint32_t xex_header_base_ptr,
uint32_t image_field) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// PVOID
// PVOID XexHeaderBase
@@ -525,11 +525,11 @@ typedef struct {
#pragma pack(pop)
}
XEASSERTSTRUCTSIZE(X_RTL_CRITICAL_SECTION, 28);
static_assert_size(X_RTL_CRITICAL_SECTION, 28);
void xeRtlInitializeCriticalSection(uint32_t cs_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Out_ LPCRITICAL_SECTION lpCriticalSection
@@ -556,7 +556,7 @@ SHIM_CALL RtlInitializeCriticalSection_shim(
X_STATUS xeRtlInitializeCriticalSectionAndSpinCount(
uint32_t cs_ptr, uint32_t spin_count) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// NTSTATUS
// _Out_ LPCRITICAL_SECTION lpCriticalSection,
@@ -597,7 +597,7 @@ SHIM_CALL RtlInitializeCriticalSectionAndSpinCount_shim(
// TODO(benvanik): remove the need for passing in thread_id.
void xeRtlEnterCriticalSection(uint32_t cs_ptr, uint32_t thread_id) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Inout_ LPCRITICAL_SECTION lpCriticalSection
@@ -651,7 +651,7 @@ SHIM_CALL RtlEnterCriticalSection_shim(
// TODO(benvanik): remove the need for passing in thread_id.
uint32_t xeRtlTryEnterCriticalSection(uint32_t cs_ptr, uint32_t thread_id) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// DWORD
// _Inout_ LPCRITICAL_SECTION lpCriticalSection
@@ -689,7 +689,7 @@ SHIM_CALL RtlTryEnterCriticalSection_shim(
void xeRtlLeaveCriticalSection(uint32_t cs_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Inout_ LPCRITICAL_SECTION lpCriticalSection

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

@@ -173,7 +173,7 @@ SHIM_CALL vsprintf_shim(
local[0] = '\0';
strncat(local, start, end + 1 - start);
XEASSERT(arg_size == 8 || arg_size == 4);
assert_true(arg_size == 8 || arg_size == 4);
if (arg_size == 8) {
if (arg_extras == 0) {
uint64_t value = SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
@@ -182,7 +182,7 @@ SHIM_CALL vsprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (arg_size == 4) {
@@ -193,20 +193,20 @@ SHIM_CALL vsprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
}
else if (*end == 'n')
{
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
SHIM_SET_MEM_32(value, (uint32_t)((b - buffer) / sizeof(char)));
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (*end == 's' ||
@@ -215,7 +215,7 @@ SHIM_CALL vsprintf_shim(
local[0] = '\0';
strncat(local, start, end + 1 - start);
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
const void* pointer = (const void*)SHIM_MEM_ADDR(value);
@@ -224,11 +224,11 @@ SHIM_CALL vsprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else {
XEASSERT(false);
assert_true(false);
break;
}
format = end;
@@ -386,7 +386,7 @@ SHIM_CALL _vsnprintf_shim(
local[0] = '\0';
strncat(local, start, end + 1 - start);
XEASSERT(arg_size == 8 || arg_size == 4);
assert_true(arg_size == 8 || arg_size == 4);
if (arg_size == 8) {
if (arg_extras == 0) {
uint64_t value = SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
@@ -395,7 +395,7 @@ SHIM_CALL _vsnprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (arg_size == 4) {
@@ -406,20 +406,20 @@ SHIM_CALL _vsnprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
}
else if (*end == 'n')
{
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
SHIM_SET_MEM_32(value, (uint32_t)((b - buffer) / sizeof(char)));
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (*end == 's' ||
@@ -428,7 +428,7 @@ SHIM_CALL _vsnprintf_shim(
local[0] = '\0';
strncat(local, start, end + 1 - start);
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
const void* pointer = (const void*)SHIM_MEM_ADDR(value);
@@ -437,11 +437,11 @@ SHIM_CALL _vsnprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else {
XEASSERT(false);
assert_true(false);
break;
}
format = end;
@@ -612,7 +612,7 @@ SHIM_CALL _vswprintf_shim(
local[0] = '\0';
wcsncat(local, start, end + 1 - start);
XEASSERT(arg_size == 8 || arg_size == 4);
assert_true(arg_size == 8 || arg_size == 4);
if (arg_size == 8) {
if (arg_extras == 0) {
uint64_t value = SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
@@ -621,7 +621,7 @@ SHIM_CALL _vswprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (arg_size == 4) {
@@ -632,20 +632,20 @@ SHIM_CALL _vswprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
}
else if (*end == 'n')
{
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
SHIM_SET_MEM_32(value, (uint32_t)((b - buffer) / sizeof(wchar_t)));
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (*end == 'p') {
@@ -653,7 +653,7 @@ SHIM_CALL _vswprintf_shim(
local[0] = '\0';
wcsncat(local, start, end + 1 - start);
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
const void* pointer = (void*)SHIM_MEM_ADDR(value);
@@ -662,7 +662,7 @@ SHIM_CALL _vswprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (*end == 's') {
@@ -670,7 +670,7 @@ SHIM_CALL _vswprintf_shim(
local[0] = '\0';
wcsncat(local, start, end + 1 - start);
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
const wchar_t* data = (const wchar_t*)SHIM_MEM_ADDR(value);
@@ -687,11 +687,11 @@ SHIM_CALL _vswprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else {
XEASSERT(false);
assert_true(false);
break;
}
format = end;

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

@@ -69,7 +69,7 @@ X_STATUS xeExCreateThread(
uint32_t xapi_thread_startup,
uint32_t start_address, uint32_t start_context, uint32_t creation_flags) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// DWORD
// LPHANDLE Handle,
@@ -158,7 +158,7 @@ SHIM_CALL ExTerminateThread_shim(
X_STATUS xeNtResumeThread(uint32_t handle, uint32_t* out_suspend_count) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
X_STATUS result = X_STATUS_SUCCESS;
@@ -198,7 +198,7 @@ SHIM_CALL NtResumeThread_shim(
X_STATUS xeKeResumeThread(void* thread_ptr, uint32_t* out_suspend_count) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
X_STATUS result = X_STATUS_SUCCESS;
@@ -236,7 +236,7 @@ SHIM_CALL KeResumeThread_shim(
X_STATUS xeNtSuspendThread(uint32_t handle, uint32_t* out_suspend_count) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
X_STATUS result = X_STATUS_SUCCESS;
@@ -276,7 +276,7 @@ SHIM_CALL NtSuspendThread_shim(
uint32_t xeKeSetAffinityThread(void* thread_ptr, uint32_t affinity) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XThread* thread = (XThread*)XObject::GetObject(state, thread_ptr);
if (thread) {
@@ -326,7 +326,7 @@ SHIM_CALL KeQueryBasePriorityThread_shim(
uint32_t xeKeSetBasePriorityThread(void* thread_ptr, int32_t increment) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
int32_t prev_priority = 0;
@@ -358,7 +358,7 @@ SHIM_CALL KeSetBasePriorityThread_shim(
uint32_t xeKeGetCurrentProcessType() {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// DWORD
@@ -595,7 +595,7 @@ SHIM_CALL KeTlsSetValue_shim(
X_STATUS xeNtCreateEvent(uint32_t* handle_ptr, void* obj_attributes,
uint32_t event_type, uint32_t initial_state) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XEvent* ev = new XEvent(state);
ev->Initialize(!event_type, !!initial_state);
@@ -638,10 +638,10 @@ SHIM_CALL NtCreateEvent_shim(
int32_t xeKeSetEvent(void* event_ptr, uint32_t increment, uint32_t wait) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XEvent* ev = (XEvent*)XObject::GetObject(state, event_ptr);
XEASSERTNOTNULL(ev);
assert_not_null(ev);
if (!ev) {
return 0;
}
@@ -708,7 +708,7 @@ SHIM_CALL KePulseEvent_shim(
void* event_ptr = SHIM_MEM_ADDR(event_ref);
XEvent* ev = (XEvent*)XObject::GetObject(state, event_ptr);
XEASSERTNOTNULL(ev);
assert_not_null(ev);
if (ev) {
result = ev->Pulse(increment, !!wait);
}
@@ -746,10 +746,10 @@ SHIM_CALL NtPulseEvent_shim(
int32_t xeKeResetEvent(void* event_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XEvent* ev = (XEvent*)XEvent::GetObject(state, event_ptr);
XEASSERTNOTNULL(ev);
assert_not_null(ev);
if (!ev) {
return 0;
}
@@ -825,11 +825,11 @@ SHIM_CALL NtCreateSemaphore_shim(
void xeKeInitializeSemaphore(
void* semaphore_ptr, int32_t count, int32_t limit) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XSemaphore* sem = (XSemaphore*)XSemaphore::GetObject(
state, semaphore_ptr, 5 /* SemaphoreObject */);
XEASSERTNOTNULL(sem);
assert_not_null(sem);
if (!sem) {
return;
}
@@ -856,10 +856,10 @@ SHIM_CALL KeInitializeSemaphore_shim(
int32_t xeKeReleaseSemaphore(
void* semaphore_ptr, int32_t increment, int32_t adjustment, bool wait) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XSemaphore* sem = (XSemaphore*)XSemaphore::GetObject(state, semaphore_ptr);
XEASSERTNOTNULL(sem);
assert_not_null(sem);
if (!sem) {
return 0;
}
@@ -954,7 +954,7 @@ SHIM_CALL NtReleaseMutant_shim(
// Whatever arg 1 is all games seem to set it to 0, so whether it's
// abandon or wait we just say false. Which is good, cause they are
// both ignored.
XEASSERTZERO(unknown);
assert_zero(unknown);
uint32_t priority_increment = 0;
bool abandon = false;
bool wait = false;
@@ -1016,8 +1016,8 @@ SHIM_CALL NtSetTimerEx_shim(
uint32_t period_ms = SHIM_GET_ARG_32(6);
uint32_t unk_zero = SHIM_GET_ARG_32(7);
XEASSERT(unk_one == 1);
XEASSERT(unk_zero == 0);
assert_true(unk_one == 1);
assert_true(unk_zero == 0);
uint64_t due_time = SHIM_MEM_64(due_time_ptr);
@@ -1075,7 +1075,7 @@ X_STATUS xeKeWaitForSingleObject(
void* object_ptr, uint32_t wait_reason, uint32_t processor_mode,
uint32_t alertable, uint64_t* opt_timeout) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XObject* object = XObject::GetObject(state, object_ptr);
if (!object) {
@@ -1153,7 +1153,7 @@ SHIM_CALL KeWaitForMultipleObjects_shim(
count, objects_ptr, wait_type, wait_reason, processor_mode,
alertable, timeout_ptr, wait_block_array_ptr);
XEASSERT(wait_type >= 0 && wait_type <= 1);
assert_true(wait_type >= 0 && wait_type <= 1);
X_STATUS result = X_STATUS_SUCCESS;
@@ -1192,7 +1192,7 @@ SHIM_CALL NtWaitForMultipleObjectsEx_shim(
count, handles_ptr, wait_type, wait_mode,
alertable, timeout_ptr);
XEASSERT(wait_type >= 0 && wait_type <= 1);
assert_true(wait_type >= 0 && wait_type <= 1);
X_STATUS result = X_STATUS_SUCCESS;

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

@@ -146,7 +146,7 @@ SHIM_CALL VdQueryVideoMode_shim(
void xeVdInitializeEngines(uint32_t unk0, uint32_t callback, uint32_t unk1,
uint32_t unk2_ptr, uint32_t unk3_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
GraphicsSystem* gs = state->emulator()->graphics_system();
if (!gs) {
return;
@@ -188,7 +188,7 @@ SHIM_CALL VdShutdownEngines_shim(
void xeVdSetGraphicsInterruptCallback(uint32_t callback, uint32_t user_data) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
GraphicsSystem* gs = state->emulator()->graphics_system();
if (!gs) {
return;
@@ -217,7 +217,7 @@ SHIM_CALL VdSetGraphicsInterruptCallback_shim(
void xeVdInitializeRingBuffer(uint32_t ptr, uint32_t page_count) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
GraphicsSystem* gs = state->emulator()->graphics_system();
if (!gs) {
return;
@@ -249,7 +249,7 @@ SHIM_CALL VdInitializeRingBuffer_shim(
void xeVdEnableRingBufferRPtrWriteBack(uint32_t ptr, uint32_t block_size) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
GraphicsSystem* gs = state->emulator()->graphics_system();
if (!gs) {
return;
@@ -317,7 +317,7 @@ SHIM_CALL VdGetSystemCommandBuffer_shim(
void xeVdSetSystemCommandBufferGpuIdentifierAddress(uint32_t unk) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
GraphicsSystem* gs = state->emulator()->graphics_system();
if (!gs) {
return;

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

@@ -36,7 +36,7 @@ typedef struct {
}
X_VIDEO_MODE;
#pragma pack(pop)
XEASSERTSTRUCTSIZE(X_VIDEO_MODE, 48);
static_assert_size(X_VIDEO_MODE, 48);
void xeVdGetCurrentDisplayGamma(uint32_t* arg0, float* arg1);
uint32_t xeVdQueryVideoFlags();

14
src/xenia/kernel/xobject.cc
View File

@@ -29,8 +29,8 @@ XObject::XObject(KernelState* kernel_state, Type type) :
}
XObject::~XObject() {
XEASSERTZERO(handle_ref_count_);
XEASSERTZERO(pointer_ref_count_);
assert_zero(handle_ref_count_);
assert_zero(pointer_ref_count_);
}
Memory* XObject::memory() const {
@@ -62,7 +62,7 @@ void XObject::Retain() {
void XObject::Release() {
if (!xe_atomic_dec_32(&pointer_ref_count_)) {
XEASSERT(pointer_ref_count_ >= handle_ref_count_);
assert_true(pointer_ref_count_ >= handle_ref_count_);
delete this;
}
}
@@ -75,7 +75,7 @@ uint32_t XObject::TimeoutTicksToMs(int64_t timeout_ticks) {
if (timeout_ticks > 0) {
// Absolute time, based on January 1, 1601.
// TODO(benvanik): convert time to relative time.
XEASSERTALWAYS();
assert_always();
return 0;
} else if (timeout_ticks < 0) {
// Relative time.
@@ -135,7 +135,7 @@ X_STATUS XObject::WaitMultiple(
void** wait_handles = (void**)alloca(sizeof(void*) * count);
for (uint32_t n = 0; n < count; n++) {
wait_handles[n] = objects[n]->GetWaitHandle();
XEASSERTNOTNULL(wait_handles[n]);
assert_not_null(wait_handles[n]);
}
DWORD timeout_ms = opt_timeout ?
@@ -167,7 +167,7 @@ void XObject::SetNativePointer(uint32_t native_ptr) {
header.wait_list_flink = XESWAP32(header_be->wait_list_flink);
header.wait_list_blink = XESWAP32(header_be->wait_list_blink);
XEASSERT(!(header.wait_list_blink & 0x1));
assert_true(!(header.wait_list_blink & 0x1));
// Stash pointer in struct.
uint64_t object_ptr = reinterpret_cast<uint64_t>(this);
@@ -252,7 +252,7 @@ XObject* XObject::GetObject(KernelState* kernel_state, void* native_ptr,
case 23: // ProfileObject
case 24: // ThreadedDpcObject
default:
XEASSERTALWAYS();
assert_always();
XObject::UnlockType();
return NULL;
}