From bf882714d005472785a6cd845f614f07fb774327 Mon Sep 17 00:00:00 2001 From: Ben Vanik Date: Sat, 12 Jul 2014 16:51:52 -0700 Subject: [PATCH] Cleaning up asserts and file/line macros. --- src/alloy/arena.cc | 2 +- src/alloy/backend/ivm/ivm_intcode.cc | 30 ++--- src/alloy/backend/ivm/ivm_stack.cc | 2 +- src/alloy/backend/x64/x64_code_cache.cc | 4 +- src/alloy/backend/x64/x64_emitter.cc | 14 +-- src/alloy/backend/x64/x64_sequence.inl | 28 ++--- src/alloy/backend/x64/x64_sequences.cc | 114 +++++++++--------- .../passes/constant_propagation_pass.cc | 6 +- .../passes/data_flow_analysis_pass.cc | 10 +- .../passes/register_allocation_pass.cc | 16 +-- src/alloy/compiler/passes/validation_pass.cc | 6 +- src/alloy/core.h | 10 +- src/alloy/frontend/ppc/ppc_disasm.cc | 2 +- src/alloy/frontend/ppc/ppc_emit-private.h | 2 +- src/alloy/frontend/ppc/ppc_emit_altivec.cc | 24 ++-- src/alloy/frontend/ppc/ppc_emit_alu.cc | 32 ++--- src/alloy/frontend/ppc/ppc_hir_builder.cc | 22 ++-- src/alloy/frontend/ppc/ppc_instr.cc | 6 +- src/alloy/hir/block.cc | 4 +- src/alloy/hir/hir_builder.cc | 18 +-- src/alloy/hir/value.cc | 92 +++++++------- src/alloy/hir/value.h | 42 +++---- src/alloy/memory.cc | 2 +- src/alloy/runtime/runtime.cc | 2 +- src/poly/assert.h | 77 ++++++++++++ src/poly/config.h | 2 +- src/poly/cxx_compat.h | 1 + src/poly/math.h | 23 +++- src/poly/poly.h | 1 + src/poly/sources.gypi | 2 + src/xenia/apu/audio_system.cc | 14 +-- src/xenia/apu/nop/nop_audio_system.cc | 2 +- src/xenia/apu/xaudio2/xaudio2_audio_driver.cc | 10 +- src/xenia/apu/xaudio2/xaudio2_audio_system.cc | 6 +- src/xenia/assert.h | 74 ------------ src/xenia/atomic.h | 1 + src/xenia/common.h | 3 +- src/xenia/core/path_posix.cc | 2 +- src/xenia/core/path_win.cc | 4 +- src/xenia/cpu/processor.cc | 4 +- src/xenia/cpu/xenon_memory.cc | 20 +-- src/xenia/cpu/xenon_thread_state.cc | 2 +- src/xenia/emulator.cc | 2 +- src/xenia/export_resolver.cc | 6 +- src/xenia/gpu/command_processor.cc | 26 ++-- src/xenia/gpu/d3d11/d3d11_buffer_resource.cc | 2 +- src/xenia/gpu/d3d11/d3d11_graphics_system.cc | 10 +- src/xenia/gpu/d3d11/d3d11_profiler_display.cc | 12 +- src/xenia/gpu/d3d11/d3d11_shader_resource.cc | 4 +- .../gpu/d3d11/d3d11_shader_translator.cc | 12 +- src/xenia/gpu/d3d11/d3d11_texture_resource.cc | 4 +- src/xenia/gpu/graphics_driver.cc | 12 +- src/xenia/gpu/graphics_system.cc | 8 +- src/xenia/gpu/nop/nop_graphics_system.cc | 6 +- src/xenia/gpu/shader_resource.cc | 18 +-- .../kernel/fs/devices/disc_image_device.cc | 4 +- .../kernel/fs/devices/disc_image_entry.cc | 4 +- .../kernel/fs/devices/host_path_device.cc | 4 +- .../kernel/fs/devices/host_path_entry.cc | 4 +- .../fs/devices/stfs_container_device.cc | 4 +- .../kernel/fs/devices/stfs_container_entry.cc | 4 +- src/xenia/kernel/fs/entry.cc | 2 +- src/xenia/kernel/kernel_state.cc | 6 +- src/xenia/kernel/object_table.cc | 8 +- src/xenia/kernel/objects/xevent.cc | 6 +- src/xenia/kernel/objects/xfile.h | 6 +- src/xenia/kernel/objects/xmutant.cc | 8 +- src/xenia/kernel/objects/xnotify_listener.cc | 2 +- src/xenia/kernel/objects/xsemaphore.cc | 4 +- src/xenia/kernel/objects/xthread.cc | 4 +- src/xenia/kernel/objects/xtimer.cc | 6 +- src/xenia/kernel/util/xex2.cc | 38 +++--- src/xenia/kernel/xam_content.cc | 2 +- src/xenia/kernel/xam_msg.cc | 8 +- src/xenia/kernel/xam_user.cc | 2 +- src/xenia/kernel/xboxkrnl_audio.cc | 8 +- src/xenia/kernel/xboxkrnl_debug.cc | 18 +-- src/xenia/kernel/xboxkrnl_hal.cc | 4 +- src/xenia/kernel/xboxkrnl_io.cc | 32 ++--- src/xenia/kernel/xboxkrnl_memory.cc | 22 ++-- src/xenia/kernel/xboxkrnl_misc.cc | 2 +- src/xenia/kernel/xboxkrnl_modules.cc | 10 +- src/xenia/kernel/xboxkrnl_rtl.cc | 32 ++--- src/xenia/kernel/xboxkrnl_strings.cc | 52 ++++---- src/xenia/kernel/xboxkrnl_threading.cc | 46 +++---- src/xenia/kernel/xboxkrnl_video.cc | 10 +- src/xenia/kernel/xboxkrnl_video.h | 2 +- src/xenia/kernel/xobject.cc | 14 +-- src/xenia/logging.h | 4 +- src/xenia/profiling.h | 4 +- src/xenia/sources.gypi | 1 - src/xenia/ui/window.cc | 2 +- 92 files changed, 636 insertions(+), 613 deletions(-) create mode 100644 src/poly/assert.h delete mode 100644 src/xenia/assert.h diff --git a/src/alloy/arena.cc b/src/alloy/arena.cc index 638adeabf..65f953e33 100644 --- a/src/alloy/arena.cc +++ b/src/alloy/arena.cc @@ -45,7 +45,7 @@ void* Arena::Alloc(size_t size) { if (active_chunk_->capacity - active_chunk_->offset < size + 4096) { Chunk* next = active_chunk_->next; if (!next) { - XEASSERT(size < chunk_size_); // need to support larger chunks + assert_true(size < chunk_size_, "need to support larger chunks"); next = new Chunk(chunk_size_); active_chunk_->next = next; } diff --git a/src/alloy/backend/ivm/ivm_intcode.cc b/src/alloy/backend/ivm/ivm_intcode.cc index 27ea32345..38fc97b06 100644 --- a/src/alloy/backend/ivm/ivm_intcode.cc +++ b/src/alloy/backend/ivm/ivm_intcode.cc @@ -159,8 +159,8 @@ uint32_t AllocOpRegister(TranslationContext& ctx, OpcodeSignatureType sig_type, uint32_t IntCode_INVALID(IntCodeState& ics, const IntCode* i); uint32_t IntCode_INVALID_TYPE(IntCodeState& ics, const IntCode* i); int DispatchToC(TranslationContext& ctx, Instr* i, IntCodeFn fn) { - XEASSERT(fn != IntCode_INVALID); - XEASSERT(fn != IntCode_INVALID_TYPE); + assert_true(fn != IntCode_INVALID); + assert_true(fn != IntCode_INVALID_TYPE); const OpcodeInfo* op = i->opcode; uint32_t sig = op->signature; @@ -194,11 +194,11 @@ int DispatchToC(TranslationContext& ctx, Instr* i, IntCodeFn fn) { } uint32_t IntCode_INVALID(IntCodeState& ics, const IntCode* i) { - XEASSERTALWAYS(); + assert_always(); return IA_NEXT; } uint32_t IntCode_INVALID_TYPE(IntCodeState& ics, const IntCode* i) { - XEASSERTALWAYS(); + assert_always(); return IA_NEXT; } int TranslateInvalid(TranslationContext& ctx, Instr* i) { @@ -368,7 +368,7 @@ uint32_t IntCode_CALL_XX(IntCodeState& ics, const IntCode* i, uint32_t reg) { if (!fn) { ics.thread_state->runtime()->ResolveFunction(symbol_info->address(), &fn); } - XEASSERTNOTNULL(fn); + assert_not_null(fn); // TODO(benvanik): proper tail call support, somehow. uint64_t return_address = (i->flags & CALL_TAIL) ? ics.return_address : ics.call_return_address; @@ -444,7 +444,7 @@ uint32_t IntCode_CALL_INDIRECT_XX(IntCodeState& ics, const IntCode* i, // Real call. Function* fn = NULL; ics.thread_state->runtime()->ResolveFunction(target, &fn); - XEASSERTNOTNULL(fn); + assert_not_null(fn); // TODO(benvanik): proper tail call support, somehow. uint64_t return_address = (i->flags & CALL_TAIL) ? ics.return_address : ics.call_return_address; @@ -2309,17 +2309,17 @@ uint32_t IntCode_ADD_I64_I64(IntCodeState& ics, const IntCode* i) { return IA_NEXT; } uint32_t IntCode_ADD_F32_F32(IntCodeState& ics, const IntCode* i) { - XEASSERT(!i->flags); + assert_true(!i->flags); ics.rf[i->dest_reg].f32 = ics.rf[i->src1_reg].f32 + ics.rf[i->src2_reg].f32; return IA_NEXT; } uint32_t IntCode_ADD_F64_F64(IntCodeState& ics, const IntCode* i) { - XEASSERT(!i->flags); + assert_true(!i->flags); ics.rf[i->dest_reg].f64 = ics.rf[i->src1_reg].f64 + ics.rf[i->src2_reg].f64; return IA_NEXT; } uint32_t IntCode_ADD_V128_V128(IntCodeState& ics, const IntCode* i) { - XEASSERT(!i->flags); + assert_true(!i->flags); const vec128_t& src1 = ics.rf[i->src1_reg].v128; const vec128_t& src2 = ics.rf[i->src2_reg].v128; vec128_t& dest = ics.rf[i->dest_reg].v128; @@ -2380,13 +2380,13 @@ uint32_t IntCode_ADD_CARRY_I64_I64(IntCodeState& ics, const IntCode* i) { return IA_NEXT; } uint32_t IntCode_ADD_CARRY_F32_F32(IntCodeState& ics, const IntCode* i) { - XEASSERT(!i->flags); + assert_true(!i->flags); ics.rf[i->dest_reg].f32 = ics.rf[i->src1_reg].f32 + ics.rf[i->src2_reg].f32 + ics.rf[i->src3_reg].i8; return IA_NEXT; } uint32_t IntCode_ADD_CARRY_F64_F64(IntCodeState& ics, const IntCode* i) { - XEASSERT(!i->flags); + assert_true(!i->flags); ics.rf[i->dest_reg].f64 = ics.rf[i->src1_reg].f64 + ics.rf[i->src2_reg].f64 + ics.rf[i->src3_reg].i8; return IA_NEXT; @@ -2570,12 +2570,12 @@ uint32_t IntCode_SUB_I64_I64(IntCodeState& ics, const IntCode* i) { return IA_NEXT; } uint32_t IntCode_SUB_F32_F32(IntCodeState& ics, const IntCode* i) { - XEASSERT(!i->flags); + assert_true(!i->flags); ics.rf[i->dest_reg].f32 = ics.rf[i->src1_reg].f32 - ics.rf[i->src2_reg].f32; return IA_NEXT; } uint32_t IntCode_SUB_F64_F64(IntCodeState& ics, const IntCode* i) { - XEASSERT(!i->flags); + assert_true(!i->flags); ics.rf[i->dest_reg].f64 = ics.rf[i->src1_reg].f64 - ics.rf[i->src2_reg].f64; return IA_NEXT; } @@ -3564,7 +3564,7 @@ int Translate_BYTE_SWAP(TranslationContext& ctx, Instr* i) { uint32_t IntCode_CNTLZ_I8(IntCodeState& ics, const IntCode* i) { // CHECK - XEASSERTALWAYS(); + assert_always(); DWORD index; DWORD mask = ics.rf[i->src1_reg].i8; BOOLEAN is_nonzero = _BitScanReverse(&index, mask); @@ -3573,7 +3573,7 @@ uint32_t IntCode_CNTLZ_I8(IntCodeState& ics, const IntCode* i) { } uint32_t IntCode_CNTLZ_I16(IntCodeState& ics, const IntCode* i) { // CHECK - XEASSERTALWAYS(); + assert_always(); DWORD index; DWORD mask = ics.rf[i->src1_reg].i16; BOOLEAN is_nonzero = _BitScanReverse(&index, mask); diff --git a/src/alloy/backend/ivm/ivm_stack.cc b/src/alloy/backend/ivm/ivm_stack.cc index 62eb85e20..5177ed351 100644 --- a/src/alloy/backend/ivm/ivm_stack.cc +++ b/src/alloy/backend/ivm/ivm_stack.cc @@ -32,7 +32,7 @@ Register* IVMStack::Alloc(size_t register_count) { if (active_chunk_->capacity - active_chunk_->offset < size) { Chunk* next = active_chunk_->next; if (!next) { - XEASSERT(size < chunk_size_); // need to support larger chunks + assert_true(size < chunk_size_, "need to support larger chunks"); next = new Chunk(chunk_size_); next->prev = active_chunk_; active_chunk_->next = next; diff --git a/src/alloy/backend/x64/x64_code_cache.cc b/src/alloy/backend/x64/x64_code_cache.cc index 71a0b2d30..f204c2200 100644 --- a/src/alloy/backend/x64/x64_code_cache.cc +++ b/src/alloy/backend/x64/x64_code_cache.cc @@ -73,7 +73,7 @@ void* X64CodeCache::PlaceCode(void* machine_code, size_t code_size, if (active_chunk_->capacity - active_chunk_->offset < code_size) { auto next = active_chunk_->next; if (!next) { - XEASSERT(code_size < chunk_size_); // need to support larger chunks + assert_true(code_size < chunk_size_, "need to support larger chunks"); next = new X64CodeChunk(chunk_size_); active_chunk_->next = next; } @@ -197,7 +197,7 @@ void X64CodeChunk::AddTableEntry(uint8_t* code, size_t code_size, size_t new_size = old_size * 2; auto new_table = (RUNTIME_FUNCTION*)xe_realloc(fn_table, old_size, new_size); - XEASSERTNOTNULL(new_table); + assert_not_null(new_table); if (!new_table) { return; } diff --git a/src/alloy/backend/x64/x64_emitter.cc b/src/alloy/backend/x64/x64_emitter.cc index 4b5383295..bb409622c 100644 --- a/src/alloy/backend/x64/x64_emitter.cc +++ b/src/alloy/backend/x64/x64_emitter.cc @@ -140,7 +140,7 @@ int X64Emitter::Emit(HIRBuilder* builder, size_t& out_stack_size) { // Adding or changing anything here must be matched! const bool emit_prolog = true; const size_t stack_size = StackLayout::GUEST_STACK_SIZE + stack_offset; - XEASSERT((stack_size + 8) % 16 == 0); + assert_true((stack_size + 8) % 16 == 0); out_stack_size = stack_size; stack_size_ = stack_size; if (emit_prolog) { @@ -167,7 +167,7 @@ int X64Emitter::Emit(HIRBuilder* builder, size_t& out_stack_size) { const Instr* new_tail = instr; if (!SelectSequence(*this, instr, &new_tail)) { // No sequence found! - XEASSERTALWAYS(); + assert_always(); XELOGE("Unable to process HIR opcode %s", instr->opcode->name); break; } @@ -231,7 +231,7 @@ void X64Emitter::Trap(uint16_t trap_type) { void X64Emitter::UnimplementedInstr(const hir::Instr* i) { // TODO(benvanik): notify debugger. db(0xCC); - XEASSERTALWAYS(); + assert_always(); } // Total size of ResolveFunctionSymbol call site in bytes. @@ -259,7 +259,7 @@ uint64_t ResolveFunctionSymbol(void* raw_context, uint64_t symbol_info_ptr) { // Resolve function. This will demand compile as required. Function* fn = NULL; thread_state->runtime()->ResolveFunction(symbol_info->address(), &fn); - XEASSERTNOTNULL(fn); + assert_not_null(fn); auto x64_fn = static_cast(fn); uint64_t addr = reinterpret_cast(x64_fn->machine_code()); @@ -307,7 +307,7 @@ void X64Emitter::Call(const hir::Instr* instr, // 5b ReloadECX(); size_t total_size = getSize() - start; - XEASSERT(total_size == TOTAL_RESOLVE_SIZE); + assert_true(total_size == TOTAL_RESOLVE_SIZE); // EDX overwritten, don't bother reloading. } @@ -334,7 +334,7 @@ uint64_t ResolveFunctionAddress(void* raw_context, uint64_t target_address) { Function* fn = NULL; thread_state->runtime()->ResolveFunction(target_address, &fn); - XEASSERTNOTNULL(fn); + assert_not_null(fn); auto x64_fn = static_cast(fn); return reinterpret_cast(x64_fn->machine_code()); } @@ -375,7 +375,7 @@ uint64_t UndefinedCallExtern(void* raw_context, uint64_t symbol_info_ptr) { } void X64Emitter::CallExtern(const hir::Instr* instr, const FunctionInfo* symbol_info) { - XEASSERT(symbol_info->behavior() == FunctionInfo::BEHAVIOR_EXTERN); + assert_true(symbol_info->behavior() == FunctionInfo::BEHAVIOR_EXTERN); if (!symbol_info->extern_handler()) { CallNative(UndefinedCallExtern, reinterpret_cast(symbol_info)); } else { diff --git a/src/alloy/backend/x64/x64_sequence.inl b/src/alloy/backend/x64/x64_sequence.inl index eae1096eb..50466b3af 100644 --- a/src/alloy/backend/x64/x64_sequence.inl +++ b/src/alloy/backend/x64/x64_sequence.inl @@ -133,7 +133,7 @@ struct ValueOp : Op, KEY_TYPE> { bool is_constant; virtual bool ConstantFitsIn32Reg() const { return true; } const REG_TYPE& reg() const { - XEASSERT(!is_constant); + assert_true(!is_constant); return reg_; } operator const REG_TYPE&() const { @@ -184,28 +184,28 @@ protected: template struct I8 : ValueOp, KEY_TYPE_V_I8, Reg8, int8_t, TAG> { const int8_t constant() const { - XEASSERT(is_constant); + assert_true(is_constant); return value->constant.i8; } }; template struct I16 : ValueOp, KEY_TYPE_V_I16, Reg16, int16_t, TAG> { const int16_t constant() const { - XEASSERT(is_constant); + assert_true(is_constant); return value->constant.i16; } }; template struct I32 : ValueOp, KEY_TYPE_V_I32, Reg32, int32_t, TAG> { const int32_t constant() const { - XEASSERT(is_constant); + assert_true(is_constant); return value->constant.i32; } }; template struct I64 : ValueOp, KEY_TYPE_V_I64, Reg64, int64_t, TAG> { const int64_t constant() const { - XEASSERT(is_constant); + assert_true(is_constant); return value->constant.i64; } bool ConstantFitsIn32Reg() const override { @@ -223,21 +223,21 @@ struct I64 : ValueOp, KEY_TYPE_V_I64, Reg64, int64_t, TAG> { template struct F32 : ValueOp, KEY_TYPE_V_F32, Xmm, float, TAG> { const float constant() const { - XEASSERT(is_constant); + assert_true(is_constant); return value->constant.f32; } }; template struct F64 : ValueOp, KEY_TYPE_V_F64, Xmm, double, TAG> { const double constant() const { - XEASSERT(is_constant); + assert_true(is_constant); return value->constant.f64; } }; template struct V128 : ValueOp, KEY_TYPE_V_V128, Xmm, vec128_t, TAG> { const vec128_t& constant() const { - XEASSERT(is_constant); + assert_true(is_constant); return value->constant.v128; } }; @@ -542,7 +542,7 @@ struct SingleSequence : public Sequence, T> { X64Emitter& e, const EmitArgType& i, const REG_REG_FN& reg_reg_fn, const REG_CONST_FN& reg_const_fn) { if (i.src1.is_constant) { - XEASSERT(!i.src2.is_constant); + assert_true(!i.src2.is_constant); if (i.dest == i.src2) { if (i.src1.ConstantFitsIn32Reg()) { reg_const_fn(e, i.dest, static_cast(i.src1.constant())); @@ -584,7 +584,7 @@ struct SingleSequence : public Sequence, T> { X64Emitter& e, const EmitArgType& i, const REG_REG_FN& reg_reg_fn, const REG_CONST_FN& reg_const_fn) { if (i.src1.is_constant) { - XEASSERT(!i.src2.is_constant); + assert_true(!i.src2.is_constant); if (i.dest == i.src2) { auto temp = GetTempReg(e); e.mov(temp, i.src2); @@ -632,7 +632,7 @@ struct SingleSequence : public Sequence, T> { static void EmitCommutativeBinaryXmmOp( X64Emitter& e, const EmitArgType& i, const FN& fn) { if (i.src1.is_constant) { - XEASSERT(!i.src2.is_constant); + assert_true(!i.src2.is_constant); e.LoadConstantXmm(e.xmm0, i.src1.constant()); fn(e, i.dest, e.xmm0, i.src2); } else if (i.src2.is_constant) { @@ -647,7 +647,7 @@ struct SingleSequence : public Sequence, T> { static void EmitAssociativeBinaryXmmOp( X64Emitter& e, const EmitArgType& i, const FN& fn) { if (i.src1.is_constant) { - XEASSERT(!i.src2.is_constant); + assert_true(!i.src2.is_constant); e.LoadConstantXmm(e.xmm0, i.src1.constant()); fn(e, i.dest, e.xmm0, i.src2); } else if (i.src2.is_constant) { @@ -663,7 +663,7 @@ struct SingleSequence : public Sequence, T> { X64Emitter& e, const EmitArgType& i, const REG_REG_FN& reg_reg_fn, const REG_CONST_FN& reg_const_fn) { if (i.src1.is_constant) { - XEASSERT(!i.src2.is_constant); + assert_true(!i.src2.is_constant); if (i.src1.ConstantFitsIn32Reg()) { reg_const_fn(e, i.src2, static_cast(i.src1.constant())); } else { @@ -688,7 +688,7 @@ struct SingleSequence : public Sequence, T> { X64Emitter& e, const EmitArgType& i, const REG_REG_FN& reg_reg_fn, const REG_CONST_FN& reg_const_fn) { if (i.src1.is_constant) { - XEASSERT(!i.src2.is_constant); + assert_true(!i.src2.is_constant); if (i.src1.ConstantFitsIn32Reg()) { reg_const_fn(e, i.dest, i.src2, static_cast(i.src1.constant()), true); } else { diff --git a/src/alloy/backend/x64/x64_sequences.cc b/src/alloy/backend/x64/x64_sequences.cc index 496ffac17..f59f465db 100644 --- a/src/alloy/backend/x64/x64_sequences.cc +++ b/src/alloy/backend/x64/x64_sequences.cc @@ -1016,7 +1016,7 @@ EMITTER(LOAD_VECTOR_SHL_I8, MATCH(I, I8<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { if (i.src1.is_constant) { auto sh = i.src1.constant(); - XEASSERT(sh < XECOUNT(lvsl_table)); + assert_true(sh < XECOUNT(lvsl_table)); e.mov(e.rax, (uintptr_t)&lvsl_table[sh]); e.vmovaps(i.dest, e.ptr[e.rax]); } else { @@ -1068,7 +1068,7 @@ EMITTER(LOAD_VECTOR_SHR_I8, MATCH(I, I8<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { if (i.src1.is_constant) { auto sh = i.src1.constant(); - XEASSERT(sh < XECOUNT(lvsr_table)); + assert_true(sh < XECOUNT(lvsr_table)); e.mov(e.rax, (uintptr_t)&lvsr_table[sh]); e.vmovaps(i.dest, e.ptr[e.rax]); } else { @@ -2176,28 +2176,28 @@ EMITTER_ASSOCIATIVE_COMPARE_FLT_XX(UGE, setae); // https://code.google.com/p/corkami/wiki/x86oddities EMITTER(DID_CARRY_I8, MATCH(I, I8<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.src1.is_constant); + assert_true(!i.src1.is_constant); e.LoadEflags(); e.setc(i.dest); } }; EMITTER(DID_CARRY_I16, MATCH(I, I16<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.src1.is_constant); + assert_true(!i.src1.is_constant); e.LoadEflags(); e.setc(i.dest); } }; EMITTER(DID_CARRY_I32, MATCH(I, I32<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.src1.is_constant); + assert_true(!i.src1.is_constant); e.LoadEflags(); e.setc(i.dest); } }; EMITTER(DID_CARRY_I64, MATCH(I, I64<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.src1.is_constant); + assert_true(!i.src1.is_constant); e.LoadEflags(); e.setc(i.dest); } @@ -2629,8 +2629,8 @@ EMITTER(VECTOR_ADD, MATCH(I, V128<>, V128<>>)) { if (saturate) { if (is_unsigned) { // We reuse all these temps... - XEASSERT(src1 != e.xmm0 && src1 != e.xmm1 && src1 != e.xmm2); - XEASSERT(src2 != e.xmm0 && src2 != e.xmm1 && src2 != e.xmm2); + assert_true(src1 != e.xmm0 && src1 != e.xmm1 && src1 != e.xmm2); + assert_true(src2 != e.xmm0 && src2 != e.xmm1 && src2 != e.xmm2); // Clamp to 0xFFFFFFFF. // Wish there was a vpaddusd... // | A | B | C | D | @@ -2655,7 +2655,7 @@ EMITTER(VECTOR_ADD, MATCH(I, V128<>, V128<>>)) { // dest.f[n] = xmm1.f[n] ? xmm1.f[n] : dest.f[n]; e.vblendvps(dest, dest, e.xmm1, e.xmm1); } else { - XEASSERTALWAYS(); + assert_always(); } } else { e.vpaddd(dest, src1, src2); @@ -2664,7 +2664,7 @@ EMITTER(VECTOR_ADD, MATCH(I, V128<>, V128<>>)) { case FLOAT32_TYPE: e.vaddps(dest, src1, src2); break; - default: XEASSERTUNHANDLEDCASE(part_type); break; + default: assert_unhandled_case(part_type); break; } }); } @@ -2728,7 +2728,7 @@ EMITTER(SUB_I64, MATCH(I, I64<>, I64<>>)) { }; EMITTER(SUB_F32, MATCH(I, F32<>, F32<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.instr->flags); + assert_true(!i.instr->flags); EmitAssociativeBinaryXmmOp(e, i, [](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) { e.vsubss(dest, src1, src2); @@ -2737,7 +2737,7 @@ EMITTER(SUB_F32, MATCH(I, F32<>, F32<>>)) { }; EMITTER(SUB_F64, MATCH(I, F64<>, F64<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.instr->flags); + assert_true(!i.instr->flags); EmitAssociativeBinaryXmmOp(e, i, [](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) { e.vsubsd(dest, src1, src2); @@ -2746,7 +2746,7 @@ EMITTER(SUB_F64, MATCH(I, F64<>, F64<>>)) { }; EMITTER(SUB_V128, MATCH(I, V128<>, V128<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.instr->flags); + assert_true(!i.instr->flags); EmitAssociativeBinaryXmmOp(e, i, [](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) { e.vsubps(dest, src1, src2); @@ -2774,7 +2774,7 @@ EMITTER(MUL_I8, MATCH(I, I8<>, I8<>>)) { // dest hi, dest low = src * edx // TODO(benvanik): place src2 in edx? if (i.src1.is_constant) { - XEASSERT(!i.src2.is_constant); + assert_true(!i.src2.is_constant); e.movzx(e.edx, i.src2); e.mov(e.eax, static_cast(i.src1.constant())); e.mulx(e.edx, i.dest.reg().cvt32(), e.eax); @@ -2793,7 +2793,7 @@ EMITTER(MUL_I16, MATCH(I, I16<>, I16<>>)) { // dest hi, dest low = src * edx // TODO(benvanik): place src2 in edx? if (i.src1.is_constant) { - XEASSERT(!i.src2.is_constant); + assert_true(!i.src2.is_constant); e.movzx(e.edx, i.src2); e.mov(e.ax, static_cast(i.src1.constant())); e.mulx(e.edx, i.dest.reg().cvt32(), e.eax); @@ -2813,7 +2813,7 @@ EMITTER(MUL_I32, MATCH(I, I32<>, I32<>>)) { // dest hi, dest low = src * edx // TODO(benvanik): place src2 in edx? if (i.src1.is_constant) { - XEASSERT(!i.src2.is_constant); + assert_true(!i.src2.is_constant); e.mov(e.edx, i.src2); e.mov(e.eax, i.src1.constant()); e.mulx(e.edx, i.dest, e.eax); @@ -2833,7 +2833,7 @@ EMITTER(MUL_I64, MATCH(I, I64<>, I64<>>)) { // dest hi, dest low = src * rdx // TODO(benvanik): place src2 in edx? if (i.src1.is_constant) { - XEASSERT(!i.src2.is_constant); + assert_true(!i.src2.is_constant); e.mov(e.rdx, i.src2); e.mov(e.rax, i.src1.constant()); e.mulx(e.rdx, i.dest, e.rax); @@ -2850,7 +2850,7 @@ EMITTER(MUL_I64, MATCH(I, I64<>, I64<>>)) { }; EMITTER(MUL_F32, MATCH(I, F32<>, F32<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.instr->flags); + assert_true(!i.instr->flags); EmitCommutativeBinaryXmmOp(e, i, [](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) { e.vmulss(dest, src1, src2); @@ -2859,7 +2859,7 @@ EMITTER(MUL_F32, MATCH(I, F32<>, F32<>>)) { }; EMITTER(MUL_F64, MATCH(I, F64<>, F64<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.instr->flags); + assert_true(!i.instr->flags); EmitCommutativeBinaryXmmOp(e, i, [](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) { e.vmulsd(dest, src1, src2); @@ -2868,7 +2868,7 @@ EMITTER(MUL_F64, MATCH(I, F64<>, F64<>>)) { }; EMITTER(MUL_V128, MATCH(I, V128<>, V128<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.instr->flags); + assert_true(!i.instr->flags); EmitCommutativeBinaryXmmOp(e, i, [](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) { e.vmulps(dest, src1, src2); @@ -2993,7 +2993,7 @@ EMITTER(DIV_I8, MATCH(I, I8<>, I8<>>)) { // NOTE: RDX clobbered. bool clobbered_rcx = false; if (i.src2.is_constant) { - XEASSERT(!i.src1.is_constant); + assert_true(!i.src1.is_constant); clobbered_rcx = true; e.mov(e.cl, i.src2.constant()); if (i.instr->flags & ARITHMETIC_UNSIGNED) { @@ -3032,7 +3032,7 @@ EMITTER(DIV_I16, MATCH(I, I16<>, I16<>>)) { // NOTE: RDX clobbered. bool clobbered_rcx = false; if (i.src2.is_constant) { - XEASSERT(!i.src1.is_constant); + assert_true(!i.src1.is_constant); clobbered_rcx = true; e.mov(e.cx, i.src2.constant()); if (i.instr->flags & ARITHMETIC_UNSIGNED) { @@ -3081,7 +3081,7 @@ EMITTER(DIV_I32, MATCH(I, I32<>, I32<>>)) { // NOTE: RDX clobbered. bool clobbered_rcx = false; if (i.src2.is_constant) { - XEASSERT(!i.src1.is_constant); + assert_true(!i.src1.is_constant); clobbered_rcx = true; e.mov(e.ecx, i.src2.constant()); if (i.instr->flags & ARITHMETIC_UNSIGNED) { @@ -3130,7 +3130,7 @@ EMITTER(DIV_I64, MATCH(I, I64<>, I64<>>)) { // NOTE: RDX clobbered. bool clobbered_rcx = false; if (i.src2.is_constant) { - XEASSERT(!i.src1.is_constant); + assert_true(!i.src1.is_constant); clobbered_rcx = true; e.mov(e.rcx, i.src2.constant()); if (i.instr->flags & ARITHMETIC_UNSIGNED) { @@ -3176,7 +3176,7 @@ EMITTER(DIV_I64, MATCH(I, I64<>, I64<>>)) { }; EMITTER(DIV_F32, MATCH(I, F32<>, F32<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.instr->flags); + assert_true(!i.instr->flags); EmitAssociativeBinaryXmmOp(e, i, [](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) { e.vdivss(dest, src1, src2); @@ -3185,7 +3185,7 @@ EMITTER(DIV_F32, MATCH(I, F32<>, F32<>>)) { }; EMITTER(DIV_F64, MATCH(I, F64<>, F64<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.instr->flags); + assert_true(!i.instr->flags); EmitAssociativeBinaryXmmOp(e, i, [](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) { e.vdivsd(dest, src1, src2); @@ -3194,7 +3194,7 @@ EMITTER(DIV_F64, MATCH(I, F64<>, F64<>>)) { }; EMITTER(DIV_V128, MATCH(I, V128<>, V128<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.instr->flags); + assert_true(!i.instr->flags); EmitAssociativeBinaryXmmOp(e, i, [](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) { e.vdivps(dest, src1, src2); @@ -3380,7 +3380,7 @@ EMITTER(NEG_F64, MATCH(I, F64<>>)) { }; EMITTER(NEG_V128, MATCH(I, V128<>>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERT(!i.instr->flags); + assert_true(!i.instr->flags); e.vxorps(i.dest, i.src1, e.GetXmmConstPtr(XMMSignMaskPS)); } }; @@ -3483,7 +3483,7 @@ EMITTER(POW2_F32, MATCH(I, F32<>>)) { return _mm_load_ss(&result); } static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERTALWAYS(); + assert_always(); e.lea(e.r8, e.StashXmm(i.src1)); e.CallNativeSafe(EmulatePow2); e.vmovaps(i.dest, e.xmm0); @@ -3495,7 +3495,7 @@ EMITTER(POW2_F64, MATCH(I, F64<>>)) { return _mm_load_sd(&result); } static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERTALWAYS(); + assert_always(); e.lea(e.r8, e.StashXmm(i.src1)); e.CallNativeSafe(EmulatePow2); e.vmovaps(i.dest, e.xmm0); @@ -3534,7 +3534,7 @@ EMITTER(LOG2_F32, MATCH(I, F32<>>)) { return _mm_load_ss(&result); } static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERTALWAYS(); + assert_always(); e.lea(e.r8, e.StashXmm(i.src1)); e.CallNativeSafe(EmulateLog2); e.vmovaps(i.dest, e.xmm0); @@ -3546,7 +3546,7 @@ EMITTER(LOG2_F64, MATCH(I, F64<>>)) { return _mm_load_sd(&result); } static void Emit(X64Emitter& e, const EmitArgType& i) { - XEASSERTALWAYS(); + assert_always(); e.lea(e.r8, e.StashXmm(i.src1)); e.CallNativeSafe(EmulateLog2); e.vmovaps(i.dest, e.xmm0); @@ -3958,7 +3958,7 @@ EMITTER(VECTOR_SHL_V128, MATCH(I, V128<>, V128<>>)) { EmitInt32(e, i); break; default: - XEASSERTALWAYS(); + assert_always(); break; } } @@ -3990,7 +3990,7 @@ EMITTER(VECTOR_SHL_V128, MATCH(I, V128<>, V128<>>)) { } } else { // Counts differ, so pre-mask and load constant. - XEASSERTALWAYS(); + assert_always(); } } else { // Fully variable shift. @@ -4046,11 +4046,11 @@ EMITTER(VECTOR_SHL_V128, MATCH(I, V128<>, V128<>>)) { e.vpsllw(i.dest, i.src1, shamt.s8[0] & 0xF); } else { // Counts differ, so pre-mask and load constant. - XEASSERTALWAYS(); + assert_always(); } } else { // Fully variable shift. - XEASSERTALWAYS(); + assert_always(); } } static void EmitInt32(X64Emitter& e, const EmitArgType& i) { @@ -4105,7 +4105,7 @@ EMITTER(VECTOR_SHR_V128, MATCH(I, V128<>, V128<>>)) { EmitInt32(e, i); break; default: - XEASSERTALWAYS(); + assert_always(); break; } } @@ -4137,11 +4137,11 @@ EMITTER(VECTOR_SHR_V128, MATCH(I, V128<>, V128<>>)) { } } else { // Counts differ, so pre-mask and load constant. - XEASSERTALWAYS(); + assert_always(); } } else { // Fully variable shift. - XEASSERTALWAYS(); + assert_always(); } } static void EmitInt16(X64Emitter& e, const EmitArgType& i) { @@ -4159,11 +4159,11 @@ EMITTER(VECTOR_SHR_V128, MATCH(I, V128<>, V128<>>)) { e.vpsrlw(i.dest, i.src1, shamt.s8[0] & 0xF); } else { // Counts differ, so pre-mask and load constant. - XEASSERTALWAYS(); + assert_always(); } } else { // Fully variable shift. - XEASSERTALWAYS(); + assert_always(); } } static void EmitInt32(X64Emitter& e, const EmitArgType& i) { @@ -4215,7 +4215,7 @@ EMITTER(VECTOR_SHA_V128, MATCH(I, V128<>, V128<>>)) { e.vpsravd(i.dest, i.src1, e.xmm0); break; default: - XEASSERTALWAYS(); + assert_always(); break; } } @@ -4375,14 +4375,14 @@ EMITTER(EXTRACT_I8, MATCH(I, V128<>, I8<>>)) { if (i.src2.is_constant) { e.vpextrb(i.dest.reg().cvt32(), i.src1, VEC128_B(i.src2.constant())); } else { - XEASSERTALWAYS(); + assert_always(); // TODO(benvanik): try out hlide's version: // e.mov(e.eax, 0x80808003); // e.xor(e.al, i.src2); // e.and(e.al, 15); // e.vmovd(e.xmm0, e.eax); // e.vpshufb(e.xmm0, i.src1, e.xmm0); - // e.vmovd(i.dest.reg().cvt32(), e.xmm0); + // e.vmovd(i.dest.reg().cvt32(), e.xmm0); } } }; @@ -4443,7 +4443,7 @@ EMITTER(EXTRACT_F32, MATCH(I, V128<>, I8<>>)) { if (i.src2.is_constant) { e.vextractps(i.dest, i.src1, VEC128_F(i.src2.constant())); } else { - XEASSERTALWAYS(); + assert_always(); // TODO(benvanik): try out hlide's version: // e.mov(e.eax, 3); // e.and(e.al, i.src2); // eax = [(i&3), 0, 0, 0] @@ -4573,7 +4573,7 @@ EMITTER(PERMUTE_I32, MATCH(I, I32<>, V128<>, V128<>>)) { } } else { // Permute by non-constant. - XEASSERTALWAYS(); + assert_always(); } } }; @@ -4650,9 +4650,9 @@ EMITTER(SWIZZLE, MATCH(I, V128<>, OffsetOp>)) { static void Emit(X64Emitter& e, const EmitArgType& i) { auto element_type = i.instr->flags; if (element_type == INT8_TYPE) { - XEASSERTALWAYS(); + assert_always(); } else if (element_type == INT16_TYPE) { - XEASSERTALWAYS(); + assert_always(); } else if (element_type == INT32_TYPE || element_type == FLOAT32_TYPE) { uint8_t swizzle_mask = static_cast(i.src2.value); swizzle_mask = @@ -4662,9 +4662,9 @@ EMITTER(SWIZZLE, MATCH(I, V128<>, OffsetOp>)) { (((swizzle_mask >> 0) & 0x3) << 6); e.vpshufd(i.dest, i.src1, swizzle_mask); } else if (element_type == INT64_TYPE || element_type == FLOAT64_TYPE) { - XEASSERTALWAYS(); + assert_always(); } else { - XEASSERTALWAYS(); + assert_always(); } } }; @@ -4703,7 +4703,7 @@ EMITTER(PACK, MATCH(I, V128<>>)) { case PACK_TYPE_S16_IN_32_HI: EmitS16_IN_32_HI(e, i); break; - default: XEASSERTUNHANDLEDCASE(i.instr->flags); break; + default: assert_unhandled_case(i.instr->flags); break; } } static void EmitD3DCOLOR(X64Emitter& e, const EmitArgType& i) { @@ -4755,19 +4755,19 @@ EMITTER(PACK, MATCH(I, V128<>>)) { e.vpblendw(i.dest, e.xmm0, B11110000); } static void EmitSHORT_2(X64Emitter& e, const EmitArgType& i) { - XEASSERTALWAYS(); + assert_always(); } static void EmitS8_IN_16_LO(X64Emitter& e, const EmitArgType& i) { - XEASSERTALWAYS(); + assert_always(); } static void EmitS8_IN_16_HI(X64Emitter& e, const EmitArgType& i) { - XEASSERTALWAYS(); + assert_always(); } static void EmitS16_IN_32_LO(X64Emitter& e, const EmitArgType& i) { - XEASSERTALWAYS(); + assert_always(); } static void EmitS16_IN_32_HI(X64Emitter& e, const EmitArgType& i) { - XEASSERTALWAYS(); + assert_always(); } }; EMITTER_OPCODE_TABLE( @@ -4805,7 +4805,7 @@ EMITTER(UNPACK, MATCH(I, V128<>>)) { case PACK_TYPE_S16_IN_32_HI: EmitS16_IN_32_HI(e, i); break; - default: XEASSERTUNHANDLEDCASE(i.instr->flags); break; + default: assert_unhandled_case(i.instr->flags); break; } } static void EmitD3DCOLOR(X64Emitter& e, const EmitArgType& i) { diff --git a/src/alloy/compiler/passes/constant_propagation_pass.cc b/src/alloy/compiler/passes/constant_propagation_pass.cc index d9f2b8620..330e93fac 100644 --- a/src/alloy/compiler/passes/constant_propagation_pass.cc +++ b/src/alloy/compiler/passes/constant_propagation_pass.cc @@ -277,13 +277,13 @@ int ConstantPropagationPass::Run(HIRBuilder* builder) { break; case OPCODE_DID_CARRY: - XEASSERT(!i->src1.value->IsConstant()); + assert_true(!i->src1.value->IsConstant()); break; case OPCODE_DID_OVERFLOW: - XEASSERT(!i->src1.value->IsConstant()); + assert_true(!i->src1.value->IsConstant()); break; case OPCODE_DID_SATURATE: - XEASSERT(!i->src1.value->IsConstant()); + assert_true(!i->src1.value->IsConstant()); break; case OPCODE_ADD: diff --git a/src/alloy/compiler/passes/data_flow_analysis_pass.cc b/src/alloy/compiler/passes/data_flow_analysis_pass.cc index 4c82d527c..28b0a6d5a 100644 --- a/src/alloy/compiler/passes/data_flow_analysis_pass.cc +++ b/src/alloy/compiler/passes/data_flow_analysis_pass.cc @@ -97,7 +97,7 @@ void DataFlowAnalysisPass::AnalyzeFlow(HIRBuilder* builder, if (v->def && v->def->block != block) { \ incoming_values.set(v->ordinal); \ } \ - XEASSERT(v->ordinal < max_value_estimate); \ + assert_true(v->ordinal < max_value_estimate); \ value_map[v->ordinal] = v; if (GET_OPCODE_SIG_TYPE_SRC1(signature) == OPCODE_SIG_TYPE_V) { SET_INCOMING_VALUE(instr->src1.value); @@ -128,7 +128,7 @@ void DataFlowAnalysisPass::AnalyzeFlow(HIRBuilder* builder, auto outgoing_ordinal = outgoing_values.find_first(); while (outgoing_ordinal != -1) { Value* src_value = value_map[outgoing_ordinal]; - XEASSERTNOTNULL(src_value); + assert_not_null(src_value); if (!src_value->local_slot) { src_value->local_slot = builder->AllocLocal(src_value->type); } @@ -142,7 +142,7 @@ void DataFlowAnalysisPass::AnalyzeFlow(HIRBuilder* builder, while (def_next && def_next->opcode->flags & OPCODE_FLAG_PAIRED_PREV) { def_next = def_next->next; } - XEASSERTNOTNULL(def_next); + assert_not_null(def_next); builder->last_instr()->MoveBefore(def_next); // We don't need it in the incoming list. @@ -153,7 +153,7 @@ void DataFlowAnalysisPass::AnalyzeFlow(HIRBuilder* builder, while (tail && tail->opcode->flags & OPCODE_FLAG_BRANCH) { tail = tail->prev; } - XEASSERTNOTZERO(tail); + assert_not_zero(tail); builder->last_instr()->MoveBefore(tail->next); } @@ -164,7 +164,7 @@ void DataFlowAnalysisPass::AnalyzeFlow(HIRBuilder* builder, auto incoming_ordinal = incoming_values.find_first(); while (incoming_ordinal != -1) { Value* src_value = value_map[incoming_ordinal]; - XEASSERTNOTNULL(src_value); + assert_not_null(src_value); if (!src_value->local_slot) { src_value->local_slot = builder->AllocLocal(src_value->type); } diff --git a/src/alloy/compiler/passes/register_allocation_pass.cc b/src/alloy/compiler/passes/register_allocation_pass.cc index 26840a20f..6f5189ba7 100644 --- a/src/alloy/compiler/passes/register_allocation_pass.cc +++ b/src/alloy/compiler/passes/register_allocation_pass.cc @@ -114,13 +114,13 @@ int RegisterAllocationPass::Run(HIRBuilder* builder) { // dest. has_preferred_reg = true; preferred_reg = instr->src1.value->reg; - XEASSERTNOTNULL(preferred_reg.set); + assert_not_null(preferred_reg.set); } } if (GET_OPCODE_SIG_TYPE_DEST(signature) == OPCODE_SIG_TYPE_V) { // Must not have been set already. - XEASSERTNULL(instr->dest->reg.set); + assert_null(instr->dest->reg.set); // Sort the usage list. We depend on this in future uses of this // variable. @@ -144,7 +144,7 @@ int RegisterAllocationPass::Run(HIRBuilder* builder) { if (!SpillOneRegister(builder, instr->dest->type)) { // Unable to spill anything - this shouldn't happen. XELOGE("Unable to spill any registers"); - XEASSERTALWAYS(); + assert_always(); return 1; } @@ -152,7 +152,7 @@ int RegisterAllocationPass::Run(HIRBuilder* builder) { if (!TryAllocateRegister(instr->dest)) { // Boned. XELOGE("Register allocation failed"); - XEASSERTALWAYS(); + assert_always(); return 1; } } @@ -330,14 +330,14 @@ bool RegisterAllocationPass::SpillOneRegister(HIRBuilder* builder, DumpUsage("SpillOneRegister (pre)"); // Pick the one with the furthest next use. - XEASSERT(!usage_set->upcoming_uses.empty()); + assert_true(!usage_set->upcoming_uses.empty()); auto furthest_usage = std::max_element(usage_set->upcoming_uses.begin(), usage_set->upcoming_uses.end(), RegisterUsage::Comparer()); auto spill_value = furthest_usage->value; Value::Use* prev_use = furthest_usage->use->prev; Value::Use* next_use = furthest_usage->use; - XEASSERTNOTNULL(next_use); + assert_not_null(next_use); usage_set->upcoming_uses.erase(furthest_usage); DumpUsage("SpillOneRegister (post)"); const auto reg = spill_value->reg; @@ -361,11 +361,11 @@ bool RegisterAllocationPass::SpillOneRegister(HIRBuilder* builder, builder->StoreLocal(spill_value->local_slot, spill_value); auto spill_store = builder->last_instr(); auto spill_store_use = spill_store->src2_use; - XEASSERTNULL(spill_store_use->prev); + assert_null(spill_store_use->prev); if (prev_use && prev_use->instr->opcode->flags & OPCODE_FLAG_PAIRED_PREV) { // Instruction is paired. This is bad. We will insert the spill after the // paired instruction. - XEASSERTNOTNULL(prev_use->instr->next); + assert_not_null(prev_use->instr->next); spill_store->MoveBefore(prev_use->instr->next); // Update last use. diff --git a/src/alloy/compiler/passes/validation_pass.cc b/src/alloy/compiler/passes/validation_pass.cc index a199e9416..27e85f7b6 100644 --- a/src/alloy/compiler/passes/validation_pass.cc +++ b/src/alloy/compiler/passes/validation_pass.cc @@ -45,7 +45,7 @@ int ValidationPass::Run(HIRBuilder* builder) { while (block) { auto label = block->label_head; while (label) { - XEASSERT(label->block == block); + assert_true(label->block == block); if (label->block != block) { return 1; } @@ -67,7 +67,7 @@ int ValidationPass::Run(HIRBuilder* builder) { } int ValidationPass::ValidateInstruction(Block* block, Instr* instr) { - XEASSERT(instr->block == block); + assert_true(instr->block == block); if (instr->block != block) { return 1; } @@ -95,7 +95,7 @@ int ValidationPass::ValidateInstruction(Block* block, Instr* instr) { int ValidationPass::ValidateValue(Block* block, Instr* instr, Value* value) { // if (value->def) { // auto def = value->def; - // XEASSERT(def->block == block); + // assert_true(def->block == block); // if (def->block != block) { // return 1; // } diff --git a/src/alloy/core.h b/src/alloy/core.h index b7f5dae91..9e25f171d 100644 --- a/src/alloy/core.h +++ b/src/alloy/core.h @@ -11,7 +11,15 @@ #define ALLOY_CORE_H_ // TODO(benvanik): move the common stuff into here? -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include diff --git a/src/alloy/frontend/ppc/ppc_disasm.cc b/src/alloy/frontend/ppc/ppc_disasm.cc index c362cae2c..41f8c928a 100644 --- a/src/alloy/frontend/ppc/ppc_disasm.cc +++ b/src/alloy/frontend/ppc/ppc_disasm.cc @@ -412,7 +412,7 @@ void Disasm_rld(InstrData& i, StringBuffer* str) { i.MD.Rc ? "." : "", i.MD.RA, i.MD.RT, (i.MD.SH5 << 5) | i.MD.SH, (i.MD.MB5 << 5) | i.MD.MB); } else { - XEASSERTALWAYS(); + assert_always(); } } void Disasm_rlwim(InstrData& i, StringBuffer* str) { diff --git a/src/alloy/frontend/ppc/ppc_emit-private.h b/src/alloy/frontend/ppc/ppc_emit-private.h index 5d717e69b..3acb10ffe 100644 --- a/src/alloy/frontend/ppc/ppc_emit-private.h +++ b/src/alloy/frontend/ppc/ppc_emit-private.h @@ -23,7 +23,7 @@ namespace ppc { RegisterInstrEmit(opcode, (InstrEmitFn)InstrEmit_##name); #define XEINSTRNOTIMPLEMENTED() -//#define XEINSTRNOTIMPLEMENTED XEASSERTALWAYS +//#define XEINSTRNOTIMPLEMENTED assert_trueALWAYS //#define XEINSTRNOTIMPLEMENTED() __debugbreak() } // namespace ppc diff --git a/src/alloy/frontend/ppc/ppc_emit_altivec.cc b/src/alloy/frontend/ppc/ppc_emit_altivec.cc index 583e1c00b..c3a4b5db8 100644 --- a/src/alloy/frontend/ppc/ppc_emit_altivec.cc +++ b/src/alloy/frontend/ppc/ppc_emit_altivec.cc @@ -62,7 +62,7 @@ Value* CalculateEA_0(PPCHIRBuilder& f, uint32_t ra, uint32_t rb); #define VX128_R_VB128 (i.VX128_R.VB128l | (i.VX128_R.VB128h << 5)) unsigned int xerotl(unsigned int value, unsigned int shift) { - XEASSERT(shift < 32); + assert_true(shift < 32); return shift == 0 ? value : ((value << shift) | (value >> (32 - shift))); } @@ -588,7 +588,7 @@ int InstrEmit_vcmpxxfp_(PPCHIRBuilder& f, InstrData& i, vcmpxxfp_op cmpop, v = f.VectorCompareSGE(f.LoadVR(va), f.LoadVR(vb), FLOAT32_TYPE); break; default: - XEASSERTUNHANDLEDCASE(cmpop); + assert_unhandled_case(cmpop); return 1; } if (rc) { @@ -648,7 +648,7 @@ int InstrEmit_vcmpxxi_(PPCHIRBuilder& f, InstrData& i, vcmpxxi_op cmpop, v = f.VectorCompareEQ(f.LoadVR(va), f.LoadVR(vb), INT32_TYPE); break; default: - XEASSERTUNHANDLEDCASE(width); + assert_unhandled_case(width); return 1; } break; @@ -664,7 +664,7 @@ int InstrEmit_vcmpxxi_(PPCHIRBuilder& f, InstrData& i, vcmpxxi_op cmpop, v = f.VectorCompareSGT(f.LoadVR(va), f.LoadVR(vb), INT32_TYPE); break; default: - XEASSERTUNHANDLEDCASE(width); + assert_unhandled_case(width); return 1; } break; @@ -680,12 +680,12 @@ int InstrEmit_vcmpxxi_(PPCHIRBuilder& f, InstrData& i, vcmpxxi_op cmpop, v = f.VectorCompareUGT(f.LoadVR(va), f.LoadVR(vb), INT32_TYPE); break; default: - XEASSERTUNHANDLEDCASE(width); + assert_unhandled_case(width); return 1; } break; default: - XEASSERTUNHANDLEDCASE(cmpop); + assert_unhandled_case(cmpop); return 1; } if (rc) { @@ -1233,7 +1233,7 @@ XEEMITTER(vrlimi128, VX128_4(6, 1808), VX128_4)(PPCHIRBuilder& f, swizzle_mask = SWIZZLE_XYZW_TO_WXYZ; break; default: - XEASSERTALWAYS(); + assert_always(); return 1; } v = f.Swizzle(f.LoadVR(vb), FLOAT32_TYPE, swizzle_mask); @@ -1707,7 +1707,7 @@ XEEMITTER(vupkhsh, 0x1000024E, VX)(PPCHIRBuilder& f, InstrData& i) { } XEEMITTER(vupkhsh128, 0x100002CE, VX)(PPCHIRBuilder& f, InstrData& i) { uint32_t va = VX128_VA128; - XEASSERTZERO(va); + assert_zero(va); return InstrEmit_vupkhsh_(f, VX128_VD128, VX128_VB128); } @@ -1722,7 +1722,7 @@ XEEMITTER(vupklsh, 0x100002CE, VX)(PPCHIRBuilder& f, InstrData& i) { } XEEMITTER(vupklsh128, 0x100002CE, VX)(PPCHIRBuilder& f, InstrData& i) { uint32_t va = VX128_VA128; - XEASSERTZERO(va); + assert_zero(va); return InstrEmit_vupklsh_(f, VX128_VD128, VX128_VB128); } @@ -1784,7 +1784,7 @@ XEEMITTER(vpkd3d128, VX128_4(6, 1552), VX128_4)(PPCHIRBuilder& f, v = f.Pack(v, PACK_TYPE_FLOAT16_4); break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); return 1; } // http://hlssmod.net/he_code/public/pixelwriter.h @@ -1819,7 +1819,7 @@ XEEMITTER(vpkd3d128, VX128_4(6, 1552), VX128_4)(PPCHIRBuilder& f, control = (control & ~mask) | (src & mask); break; default: - XEASSERTUNHANDLEDCASE(pack); + assert_unhandled_case(pack); return 1; } v = f.Permute(f.LoadConstant(control), f.LoadVR(vd), v, INT32_TYPE); @@ -1851,7 +1851,7 @@ XEEMITTER(vupkd3d128, VX128_3(6, 2032), VX128_3)(PPCHIRBuilder& f, v = f.Unpack(v, PACK_TYPE_FLOAT16_4); break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); return 1; } f.StoreVR(vd, v); diff --git a/src/alloy/frontend/ppc/ppc_emit_alu.cc b/src/alloy/frontend/ppc/ppc_emit_alu.cc index cf8245064..da8bf65a6 100644 --- a/src/alloy/frontend/ppc/ppc_emit_alu.cc +++ b/src/alloy/frontend/ppc/ppc_emit_alu.cc @@ -28,7 +28,7 @@ XEEMITTER(addx, 0x7C000214, XO)(PPCHIRBuilder& f, InstrData& i) { Value* v = f.Add(f.LoadGPR(i.XO.RA), f.LoadGPR(i.XO.RB)); f.StoreGPR(i.XO.RT, v); if (i.XO.OE) { - XEASSERTALWAYS(); + assert_always(); // e.update_xer_with_overflow(EFLAGS OF?); } if (i.XO.Rc) { @@ -45,7 +45,7 @@ XEEMITTER(addcx, 0x7C000014, XO)(PPCHIRBuilder& f, InstrData& i) { f.StoreCA(f.DidCarry(v)); f.StoreGPR(i.XO.RT, v); if (i.XO.OE) { - XEASSERTALWAYS(); + assert_always(); // e.update_xer_with_overflow(EFLAGS OF?); } if (i.XO.Rc) { @@ -61,7 +61,7 @@ XEEMITTER(addex, 0x7C000114, XO)(PPCHIRBuilder& f, InstrData& i) { f.StoreCA(f.DidCarry(v)); f.StoreGPR(i.XO.RT, v); if (i.XO.OE) { - XEASSERTALWAYS(); + assert_always(); // e.update_xer_with_overflow(EFLAGS OF?); } if (i.XO.Rc) { @@ -124,7 +124,7 @@ XEEMITTER(addmex, 0x7C0001D4, XO)(PPCHIRBuilder& f, InstrData& i) { if (i.XO.OE) { // With XER[SO] update too. // e.update_xer_with_overflow_and_carry(b.CreateExtractValue(v, 1)); - XEASSERTALWAYS(); + assert_always(); } else { // Just CA update. f.StoreCA(f.DidCarry(v)); @@ -143,7 +143,7 @@ XEEMITTER(addzex, 0x7C000194, XO)(PPCHIRBuilder& f, InstrData& i) { if (i.XO.OE) { // With XER[SO] update too. // e.update_xer_with_overflow_and_carry(b.CreateExtractValue(v, 1)); - XEASSERTALWAYS(); + assert_always(); } else { // Just CA update. f.StoreCA(f.DidCarry(v)); @@ -172,7 +172,7 @@ XEEMITTER(divdx, 0x7C0003D2, XO)(PPCHIRBuilder& f, InstrData& i) { if (i.XO.OE) { // If we are OE=1 we need to clear the overflow bit. // e.update_xer_with_overflow(e.get_uint64(0)); - XEASSERTALWAYS(); + assert_always(); return 1; } if (i.XO.Rc) { @@ -198,7 +198,7 @@ XEEMITTER(divdux, 0x7C000392, XO)(PPCHIRBuilder& f, InstrData& i) { if (i.XO.OE) { // If we are OE=1 we need to clear the overflow bit. // e.update_xer_with_overflow(e.get_uint64(0)); - XEASSERTALWAYS(); + assert_always(); return 1; } if (i.XO.Rc) { @@ -226,7 +226,7 @@ XEEMITTER(divwx, 0x7C0003D6, XO)(PPCHIRBuilder& f, InstrData& i) { if (i.XO.OE) { // If we are OE=1 we need to clear the overflow bit. // e.update_xer_with_overflow(e.get_uint64(0)); - XEASSERTALWAYS(); + assert_always(); return 1; } if (i.XO.Rc) { @@ -255,7 +255,7 @@ XEEMITTER(divwux, 0x7C000396, XO)(PPCHIRBuilder& f, InstrData& i) { if (i.XO.OE) { // If we are OE=1 we need to clear the overflow bit. // e.update_xer_with_overflow(e.get_uint64(0)); - XEASSERTALWAYS(); + assert_always(); return 1; } if (i.XO.Rc) { @@ -379,7 +379,7 @@ XEEMITTER(negx, 0x7C0000D0, XO)(PPCHIRBuilder& f, InstrData& i) { // if RA == 0x8000000000000000 then no-op and set OV=1 // This may just magically do that... - XEASSERTALWAYS(); + assert_always(); // Function* ssub_with_overflow = Intrinsic::getDeclaration( // e.gen_module(), Intrinsic::ssub_with_overflow, jit_type_nint); // jit_value_t v = b.CreateCall2(ssub_with_overflow, @@ -408,7 +408,7 @@ XEEMITTER(subfx, 0x7C000050, XO)(PPCHIRBuilder& f, InstrData& i) { Value* v = f.Sub(f.LoadGPR(i.XO.RB), f.LoadGPR(i.XO.RA)); f.StoreGPR(i.XO.RT, v); if (i.XO.OE) { - XEASSERTALWAYS(); + assert_always(); // e.update_xer_with_overflow(EFLAGS??); } if (i.XO.Rc) { @@ -424,7 +424,7 @@ XEEMITTER(subfcx, 0x7C000010, XO)(PPCHIRBuilder& f, InstrData& i) { f.StoreCA(f.DidCarry(v)); f.StoreGPR(i.XO.RT, v); if (i.XO.OE) { - XEASSERTALWAYS(); + assert_always(); // e.update_xer_with_overflow(EFLAGS??); } if (i.XO.Rc) { @@ -449,7 +449,7 @@ XEEMITTER(subfex, 0x7C000110, XO)(PPCHIRBuilder& f, InstrData& i) { f.StoreCA(f.DidCarry(v)); f.StoreGPR(i.XO.RT, v); if (i.XO.OE) { - XEASSERTALWAYS(); + assert_always(); // e.update_xer_with_overflow_and_carry(b.CreateExtractValue(v, 1)); } if (i.XO.Rc) { @@ -463,7 +463,7 @@ XEEMITTER(subfmex, 0x7C0001D0, XO)(PPCHIRBuilder& f, InstrData& i) { Value* v = f.AddWithCarry(f.Not(f.LoadGPR(i.XO.RA)), f.LoadConstant((int64_t)-1), f.LoadCA()); if (i.XO.OE) { - XEASSERTALWAYS(); + assert_always(); // e.update_xer_with_overflow_and_carry(b.CreateExtractValue(v, 1)); } else { f.StoreCA(f.DidCarry(v)); @@ -480,7 +480,7 @@ XEEMITTER(subfzex, 0x7C000190, XO)(PPCHIRBuilder& f, InstrData& i) { Value* v = f.AddWithCarry(f.Not(f.LoadGPR(i.XO.RA)), f.LoadZero(INT64_TYPE), f.LoadCA()); if (i.XO.OE) { - XEASSERTALWAYS(); + assert_always(); // e.update_xer_with_overflow_and_carry(b.CreateExtractValue(v, 1)); } else { f.StoreCA(f.DidCarry(v)); @@ -1112,7 +1112,7 @@ XEEMITTER(sradix, 0x7C000674, XS)(PPCHIRBuilder& f, InstrData& i) { // CA is set if any bits are shifted out of the right and if the result // is negative. - XEASSERT(sh); + assert_true(sh); uint64_t mask = XEMASK(64 - sh, 63); Value* ca = f.And(f.Truncate(f.Shr(v, 63), INT8_TYPE), f.IsTrue(f.And(v, f.LoadConstant(mask)))); diff --git a/src/alloy/frontend/ppc/ppc_hir_builder.cc b/src/alloy/frontend/ppc/ppc_hir_builder.cc index 1d737917f..c0fc5c54c 100644 --- a/src/alloy/frontend/ppc/ppc_hir_builder.cc +++ b/src/alloy/frontend/ppc/ppc_hir_builder.cc @@ -206,7 +206,7 @@ Value* PPCHIRBuilder::LoadLR() { } void PPCHIRBuilder::StoreLR(Value* value) { - XEASSERT(value->type == INT64_TYPE); + assert_true(value->type == INT64_TYPE); StoreContext(offsetof(PPCContext, lr), value); } @@ -215,12 +215,12 @@ Value* PPCHIRBuilder::LoadCTR() { } void PPCHIRBuilder::StoreCTR(Value* value) { - XEASSERT(value->type == INT64_TYPE); + assert_true(value->type == INT64_TYPE); StoreContext(offsetof(PPCContext, ctr), value); } Value* PPCHIRBuilder::LoadCR(uint32_t n) { - XEASSERTALWAYS(); + assert_always(); return 0; } @@ -230,7 +230,7 @@ Value* PPCHIRBuilder::LoadCRField(uint32_t n, uint32_t bit) { void PPCHIRBuilder::StoreCR(uint32_t n, Value* value) { // TODO(benvanik): split bits out and store in values. - XEASSERTALWAYS(); + assert_always(); } void PPCHIRBuilder::UpdateCR(uint32_t n, Value* lhs, bool is_signed) { @@ -271,23 +271,23 @@ Value* PPCHIRBuilder::LoadFPSCR() { } void PPCHIRBuilder::StoreFPSCR(Value* value) { - XEASSERT(value->type == INT64_TYPE); + assert_true(value->type == INT64_TYPE); StoreContext(offsetof(PPCContext, fpscr), value); } Value* PPCHIRBuilder::LoadXER() { - XEASSERTALWAYS(); + assert_always(); return NULL; } -void PPCHIRBuilder::StoreXER(Value* value) { XEASSERTALWAYS(); } +void PPCHIRBuilder::StoreXER(Value* value) { assert_always(); } Value* PPCHIRBuilder::LoadCA() { return LoadContext(offsetof(PPCContext, xer_ca), INT8_TYPE); } void PPCHIRBuilder::StoreCA(Value* value) { - XEASSERT(value->type == INT8_TYPE); + assert_true(value->type == INT8_TYPE); StoreContext(offsetof(PPCContext, xer_ca), value); } @@ -305,7 +305,7 @@ Value* PPCHIRBuilder::LoadGPR(uint32_t reg) { } void PPCHIRBuilder::StoreGPR(uint32_t reg, Value* value) { - XEASSERT(value->type == INT64_TYPE); + assert_true(value->type == INT64_TYPE); StoreContext(offsetof(PPCContext, r) + reg * 8, value); } @@ -314,7 +314,7 @@ Value* PPCHIRBuilder::LoadFPR(uint32_t reg) { } void PPCHIRBuilder::StoreFPR(uint32_t reg, Value* value) { - XEASSERT(value->type == FLOAT64_TYPE); + assert_true(value->type == FLOAT64_TYPE); StoreContext(offsetof(PPCContext, f) + reg * 8, value); } @@ -323,7 +323,7 @@ Value* PPCHIRBuilder::LoadVR(uint32_t reg) { } void PPCHIRBuilder::StoreVR(uint32_t reg, Value* value) { - XEASSERT(value->type == VEC128_TYPE); + assert_true(value->type == VEC128_TYPE); StoreContext(offsetof(PPCContext, v) + reg * 16, value); } diff --git a/src/alloy/frontend/ppc/ppc_instr.cc b/src/alloy/frontend/ppc/ppc_instr.cc index c7029158a..251d07afe 100644 --- a/src/alloy/frontend/ppc/ppc_instr.cc +++ b/src/alloy/frontend/ppc/ppc_instr.cc @@ -146,7 +146,7 @@ void InstrAccessBits::MarkAccess(InstrRegister& reg) { } break; default: - XEASSERTUNHANDLEDCASE(reg.set); + assert_unhandled_case(reg.set); break; } } @@ -384,11 +384,11 @@ InstrType* GetInstrType(uint32_t code) { int RegisterInstrEmit(uint32_t code, InstrEmitFn emit) { InstrType* instr_type = GetInstrType(code); - XEASSERTNOTNULL(instr_type); + assert_not_null(instr_type); if (!instr_type) { return 1; } - XEASSERTNULL(instr_type->emit); + assert_null(instr_type->emit); instr_type->emit = emit; return 0; } diff --git a/src/alloy/hir/block.cc b/src/alloy/hir/block.cc index 66160338f..0327c3163 100644 --- a/src/alloy/hir/block.cc +++ b/src/alloy/hir/block.cc @@ -23,12 +23,12 @@ void Block::AssertNoCycles() { while ((hare = hare->next)) { if (hare == tortoise) { // Cycle! - XEASSERTALWAYS(); + assert_always(); } hare = hare->next; if (hare == tortoise) { // Cycle! - XEASSERTALWAYS(); + assert_always(); } tortoise = tortoise->next; if (!hare || !tortoise) { diff --git a/src/alloy/hir/hir_builder.cc b/src/alloy/hir/hir_builder.cc index d25aaac23..2a2b011e1 100644 --- a/src/alloy/hir/hir_builder.cc +++ b/src/alloy/hir/hir_builder.cc @@ -114,7 +114,7 @@ void HIRBuilder::DumpValue(StringBuffer* str, Value* value) { value->constant.v128.w); break; default: - XEASSERTALWAYS(); + assert_always(); break; } } else { @@ -276,12 +276,12 @@ void HIRBuilder::AssertNoCycles() { while ((hare = hare->next)) { if (hare == tortoise) { // Cycle! - XEASSERTALWAYS(); + assert_always(); } hare = hare->next; if (hare == tortoise) { // Cycle! - XEASSERTALWAYS(); + assert_always(); } tortoise = tortoise->next; if (!hare || !tortoise) { @@ -937,7 +937,7 @@ Value* HIRBuilder::LoadConstant(const vec128_t& value) { } Value* HIRBuilder::LoadVectorShl(Value* sh) { - XEASSERT(sh->type == INT8_TYPE); + assert_true(sh->type == INT8_TYPE); Instr* i = AppendInstr(OPCODE_LOAD_VECTOR_SHL_info, 0, AllocValue(VEC128_TYPE)); i->set_src1(sh); @@ -946,7 +946,7 @@ Value* HIRBuilder::LoadVectorShl(Value* sh) { } Value* HIRBuilder::LoadVectorShr(Value* sh) { - XEASSERT(sh->type == INT8_TYPE); + assert_true(sh->type == INT8_TYPE); Instr* i = AppendInstr(OPCODE_LOAD_VECTOR_SHR_info, 0, AllocValue(VEC128_TYPE)); i->set_src1(sh); @@ -1050,7 +1050,7 @@ Value* HIRBuilder::Min(Value* value1, Value* value2) { } Value* HIRBuilder::Select(Value* cond, Value* value1, Value* value2) { - XEASSERT(cond->type == INT8_TYPE); // for now + assert_true(cond->type == INT8_TYPE); // for now ASSERT_TYPES_EQUAL(value1, value2); if (cond->IsConstant()) { @@ -1233,7 +1233,7 @@ Value* HIRBuilder::Add(Value* value1, Value* value2, Value* HIRBuilder::AddWithCarry(Value* value1, Value* value2, Value* value3, uint32_t arithmetic_flags) { ASSERT_TYPES_EQUAL(value1, value2); - XEASSERT(value3->type == INT8_TYPE); + assert_true(value3->type == INT8_TYPE); Instr* i = AppendInstr(OPCODE_ADD_CARRY_info, arithmetic_flags, AllocValue(value1->type)); @@ -1250,7 +1250,7 @@ Value* HIRBuilder::VectorAdd(Value* value1, Value* value2, TypeName part_type, // This is shady. uint32_t flags = part_type | (arithmetic_flags << 8); - XEASSERTZERO(flags >> 16); + assert_zero(flags >> 16); Instr* i = AppendInstr(OPCODE_VECTOR_ADD_info, (uint16_t)flags, AllocValue(value1->type)); @@ -1701,7 +1701,7 @@ Value* HIRBuilder::Permute(Value* control, Value* value1, Value* value2, Value* HIRBuilder::Swizzle(Value* value, TypeName part_type, uint32_t swizzle_mask) { // For now. - XEASSERT(part_type == INT32_TYPE || part_type == FLOAT32_TYPE); + assert_true(part_type == INT32_TYPE || part_type == FLOAT32_TYPE); if (swizzle_mask == SWIZZLE_XYZW_TO_XYZW) { return Assign(value); diff --git a/src/alloy/hir/value.cc b/src/alloy/hir/value.cc index a7b7bddef..d25b6bea0 100644 --- a/src/alloy/hir/value.cc +++ b/src/alloy/hir/value.cc @@ -36,7 +36,7 @@ void Value::RemoveUse(Use* use) { } uint32_t Value::AsUint32() { - XEASSERT(IsConstant()); + assert_true(IsConstant()); switch (type) { case INT8_TYPE: return constant.i8; @@ -47,13 +47,13 @@ uint32_t Value::AsUint32() { case INT64_TYPE: return (uint32_t)constant.i64; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); return 0; } } uint64_t Value::AsUint64() { - XEASSERT(IsConstant()); + assert_true(IsConstant()); switch (type) { case INT8_TYPE: return constant.i8; @@ -64,14 +64,14 @@ uint64_t Value::AsUint64() { case INT64_TYPE: return constant.i64; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); return 0; } } void Value::Cast(TypeName target_type) { // TODO(benvanik): big matrix. - XEASSERTALWAYS(); + assert_always(); } void Value::ZeroExtend(TypeName target_type) { @@ -89,7 +89,7 @@ void Value::ZeroExtend(TypeName target_type) { constant.i64 = constant.i64 & 0xFFFFFFFF; return; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } @@ -109,7 +109,7 @@ void Value::SignExtend(TypeName target_type) { constant.i64 = constant.i8; return; default: - XEASSERTUNHANDLEDCASE(target_type); + assert_unhandled_case(target_type); return; } case INT16_TYPE: @@ -122,7 +122,7 @@ void Value::SignExtend(TypeName target_type) { constant.i64 = constant.i16; return; default: - XEASSERTUNHANDLEDCASE(target_type); + assert_unhandled_case(target_type); return; } case INT32_TYPE: @@ -132,11 +132,11 @@ void Value::SignExtend(TypeName target_type) { constant.i64 = constant.i32; return; default: - XEASSERTUNHANDLEDCASE(target_type); + assert_unhandled_case(target_type); return; } default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); return; } } @@ -150,7 +150,7 @@ void Value::Truncate(TypeName target_type) { constant.i64 = constant.i64 & 0xFF; return; default: - XEASSERTUNHANDLEDCASE(target_type); + assert_unhandled_case(target_type); return; } case INT32_TYPE: @@ -164,7 +164,7 @@ void Value::Truncate(TypeName target_type) { constant.i64 = constant.i64 & 0xFFFF; return; default: - XEASSERTUNHANDLEDCASE(target_type); + assert_unhandled_case(target_type); return; } case INT64_TYPE: @@ -182,29 +182,29 @@ void Value::Truncate(TypeName target_type) { constant.i64 = constant.i64 & 0xFFFFFFFF; return; default: - XEASSERTUNHANDLEDCASE(target_type); + assert_unhandled_case(target_type); return; } default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); return; } } void Value::Convert(TypeName target_type, RoundMode round_mode) { // TODO(benvanik): big matrix. - XEASSERTALWAYS(); + assert_always(); } void Value::Round(RoundMode round_mode) { // TODO(benvanik): big matrix. - XEASSERTALWAYS(); + assert_always(); } bool Value::Add(Value* other) { #define CHECK_DID_CARRY(v1, v2) (((uint64_t)v2) > ~((uint64_t)v1)) #define ADD_DID_CARRY(a, b) CHECK_DID_CARRY(a, b) - XEASSERT(type == other->type); + assert_true(type == other->type); bool did_carry = false; switch (type) { case INT8_TYPE: @@ -230,7 +230,7 @@ bool Value::Add(Value* other) { constant.f64 += other->constant.f64; break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } return did_carry; @@ -238,7 +238,7 @@ bool Value::Add(Value* other) { bool Value::Sub(Value* other) { #define SUB_DID_CARRY(a, b) (b > a) - XEASSERT(type == other->type); + assert_true(type == other->type); bool did_carry = false; switch (type) { case INT8_TYPE: @@ -264,14 +264,14 @@ bool Value::Sub(Value* other) { constant.f64 -= other->constant.f64; break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } return did_carry; } void Value::Mul(Value* other) { - XEASSERT(type == other->type); + assert_true(type == other->type); switch (type) { case INT8_TYPE: constant.i8 *= other->constant.i8; @@ -292,13 +292,13 @@ void Value::Mul(Value* other) { constant.f64 *= other->constant.f64; break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } void Value::Div(Value* other) { - XEASSERT(type == other->type); + assert_true(type == other->type); switch (type) { case INT8_TYPE: constant.i8 /= other->constant.i8; @@ -319,19 +319,19 @@ void Value::Div(Value* other) { constant.f64 /= other->constant.f64; break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } void Value::MulAdd(Value* dest, Value* value1, Value* value2, Value* value3) { // TODO(benvanik): big matrix. - XEASSERTALWAYS(); + assert_always(); } void Value::MulSub(Value* dest, Value* value1, Value* value2, Value* value3) { // TODO(benvanik): big matrix. - XEASSERTALWAYS(); + assert_always(); } void Value::Neg() { @@ -355,7 +355,7 @@ void Value::Neg() { constant.f64 = -constant.f64; break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } @@ -381,7 +381,7 @@ void Value::Abs() { constant.f64 = abs(constant.f64); break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } @@ -395,7 +395,7 @@ void Value::Sqrt() { constant.f64 = 1.0 / sqrt(constant.f64); break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } @@ -409,13 +409,13 @@ void Value::RSqrt() { constant.f64 = sqrt(constant.f64); break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } void Value::And(Value* other) { - XEASSERT(type == other->type); + assert_true(type == other->type); switch (type) { case INT8_TYPE: constant.i8 &= other->constant.i8; @@ -430,13 +430,13 @@ void Value::And(Value* other) { constant.i64 &= other->constant.i64; break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } void Value::Or(Value* other) { - XEASSERT(type == other->type); + assert_true(type == other->type); switch (type) { case INT8_TYPE: constant.i8 |= other->constant.i8; @@ -451,13 +451,13 @@ void Value::Or(Value* other) { constant.i64 |= other->constant.i64; break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } void Value::Xor(Value* other) { - XEASSERT(type == other->type); + assert_true(type == other->type); switch (type) { case INT8_TYPE: constant.i8 ^= other->constant.i8; @@ -472,7 +472,7 @@ void Value::Xor(Value* other) { constant.i64 ^= other->constant.i64; break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } @@ -496,13 +496,13 @@ void Value::Not() { constant.v128.high = ~constant.v128.high; break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } void Value::Shl(Value* other) { - XEASSERT(other->type == INT8_TYPE); + assert_true(other->type == INT8_TYPE); switch (type) { case INT8_TYPE: constant.i8 <<= other->constant.i8; @@ -517,13 +517,13 @@ void Value::Shl(Value* other) { constant.i64 <<= other->constant.i8; break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } void Value::Shr(Value* other) { - XEASSERT(other->type == INT8_TYPE); + assert_true(other->type == INT8_TYPE); switch (type) { case INT8_TYPE: constant.i8 = (uint8_t)constant.i8 >> other->constant.i8; @@ -538,13 +538,13 @@ void Value::Shr(Value* other) { constant.i64 = (uint16_t)constant.i64 >> other->constant.i8; break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } void Value::Sha(Value* other) { - XEASSERT(other->type == INT8_TYPE); + assert_true(other->type == INT8_TYPE); switch (type) { case INT8_TYPE: constant.i8 = constant.i8 >> other->constant.i8; @@ -559,7 +559,7 @@ void Value::Sha(Value* other) { constant.i64 = constant.i64 >> other->constant.i8; break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } @@ -584,7 +584,7 @@ void Value::ByteSwap() { } break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } @@ -604,14 +604,14 @@ void Value::CountLeadingZeros(const Value* other) { constant.i8 = poly::lzcnt(constant.i64); break; default: - XEASSERTUNHANDLEDCASE(type); + assert_unhandled_case(type); break; } } bool Value::Compare(Opcode opcode, Value* other) { // TODO(benvanik): big matrix. - XEASSERTALWAYS(); + assert_always(); return false; } diff --git a/src/alloy/hir/value.h b/src/alloy/hir/value.h index bd4e37acf..38e4947e9 100644 --- a/src/alloy/hir/value.h +++ b/src/alloy/hir/value.h @@ -48,7 +48,7 @@ static size_t GetTypeSize(TypeName type_name) { case VEC128_TYPE: return 16; default: - XEASSERTUNHANDLEDCASE(type_name); + assert_unhandled_case(type_name); return 0; } } @@ -177,13 +177,13 @@ class Value { inline bool IsConstant() const { return !!(flags & VALUE_IS_CONSTANT); } bool IsConstantTrue() const { if (type == VEC128_TYPE) { - XEASSERTALWAYS(); + assert_always(); } return (flags & VALUE_IS_CONSTANT) && !!constant.i64; } bool IsConstantFalse() const { if (type == VEC128_TYPE) { - XEASSERTALWAYS(); + assert_always(); } return (flags & VALUE_IS_CONSTANT) && !constant.i64; } @@ -196,20 +196,20 @@ class Value { } bool IsConstantEQ(Value* other) const { if (type == VEC128_TYPE) { - XEASSERTALWAYS(); + assert_always(); } return (flags & VALUE_IS_CONSTANT) && (other->flags & VALUE_IS_CONSTANT) && constant.i64 == other->constant.i64; } bool IsConstantNE(Value* other) const { if (type == VEC128_TYPE) { - XEASSERTALWAYS(); + assert_always(); } return (flags & VALUE_IS_CONSTANT) && (other->flags & VALUE_IS_CONSTANT) && constant.i64 != other->constant.i64; } bool IsConstantSLT(Value* other) const { - XEASSERT(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); + assert_true(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); switch (type) { case INT8_TYPE: return constant.i8 < other->constant.i8; @@ -224,12 +224,12 @@ class Value { case FLOAT64_TYPE: return constant.f64 < other->constant.f64; default: - XEASSERTALWAYS(); + assert_always(); return false; } } bool IsConstantSLE(Value* other) const { - XEASSERT(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); + assert_true(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); switch (type) { case INT8_TYPE: return constant.i8 <= other->constant.i8; @@ -244,12 +244,12 @@ class Value { case FLOAT64_TYPE: return constant.f64 <= other->constant.f64; default: - XEASSERTALWAYS(); + assert_always(); return false; } } bool IsConstantSGT(Value* other) const { - XEASSERT(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); + assert_true(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); switch (type) { case INT8_TYPE: return constant.i8 > other->constant.i8; @@ -264,12 +264,12 @@ class Value { case FLOAT64_TYPE: return constant.f64 > other->constant.f64; default: - XEASSERTALWAYS(); + assert_always(); return false; } } bool IsConstantSGE(Value* other) const { - XEASSERT(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); + assert_true(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); switch (type) { case INT8_TYPE: return constant.i8 >= other->constant.i8; @@ -284,12 +284,12 @@ class Value { case FLOAT64_TYPE: return constant.f64 >= other->constant.f64; default: - XEASSERTALWAYS(); + assert_always(); return false; } } bool IsConstantULT(Value* other) const { - XEASSERT(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); + assert_true(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); switch (type) { case INT8_TYPE: return (uint8_t)constant.i8 < (uint8_t)other->constant.i8; @@ -304,12 +304,12 @@ class Value { case FLOAT64_TYPE: return constant.f64 < other->constant.f64; default: - XEASSERTALWAYS(); + assert_always(); return false; } } bool IsConstantULE(Value* other) const { - XEASSERT(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); + assert_true(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); switch (type) { case INT8_TYPE: return (uint8_t)constant.i8 <= (uint8_t)other->constant.i8; @@ -324,12 +324,12 @@ class Value { case FLOAT64_TYPE: return constant.f64 <= other->constant.f64; default: - XEASSERTALWAYS(); + assert_always(); return false; } } bool IsConstantUGT(Value* other) const { - XEASSERT(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); + assert_true(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); switch (type) { case INT8_TYPE: return (uint8_t)constant.i8 > (uint8_t)other->constant.i8; @@ -344,12 +344,12 @@ class Value { case FLOAT64_TYPE: return constant.f64 > other->constant.f64; default: - XEASSERTALWAYS(); + assert_always(); return false; } } bool IsConstantUGE(Value* other) const { - XEASSERT(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); + assert_true(flags & VALUE_IS_CONSTANT && other->flags & VALUE_IS_CONSTANT); switch (type) { case INT8_TYPE: return (uint8_t)constant.i8 >= (uint8_t)other->constant.i8; @@ -364,7 +364,7 @@ class Value { case FLOAT64_TYPE: return constant.f64 >= other->constant.f64; default: - XEASSERTALWAYS(); + assert_always(); return false; } } diff --git a/src/alloy/memory.cc b/src/alloy/memory.cc index 9fabfb9ba..59568ee49 100644 --- a/src/alloy/memory.cc +++ b/src/alloy/memory.cc @@ -48,7 +48,7 @@ void Memory::Copy(uint64_t dest, uint64_t src, size_t size) { uint64_t Memory::SearchAligned(uint64_t start, uint64_t end, const uint32_t* values, size_t value_count) { - XEASSERT(start <= end); + assert_true(start <= end); const uint32_t* p = (const uint32_t*)(membase_ + start); const uint32_t* pe = (const uint32_t*)(membase_ + end); while (p != pe) { diff --git a/src/alloy/runtime/runtime.cc b/src/alloy/runtime/runtime.cc index 5d8f4bc23..66e514ae8 100644 --- a/src/alloy/runtime/runtime.cc +++ b/src/alloy/runtime/runtime.cc @@ -50,7 +50,7 @@ Runtime::~Runtime() { int Runtime::Initialize(Frontend* frontend, Backend* backend) { // Must be initialized by subclass before calling into this. - XEASSERTNOTNULL(memory_); + assert_not_null(memory_); // Create debugger first. Other types hook up to it. debugger_ = new Debugger(this); diff --git a/src/poly/assert.h b/src/poly/assert.h new file mode 100644 index 000000000..50e083d16 --- /dev/null +++ b/src/poly/assert.h @@ -0,0 +1,77 @@ +/** + ****************************************************************************** + * Xenia : Xbox 360 Emulator Research Project * + ****************************************************************************** + * Copyright 2014 Ben Vanik. All rights reserved. * + * Released under the BSD license - see LICENSE in the root for more details. * + ****************************************************************************** + */ + +#ifndef POLY_ASSERT_H_ +#define POLY_ASSERT_H_ + +#include + +#include +#include + +namespace poly { + +#define static_assert_size(type, size) \ + static_assert(sizeof(type) == size, \ + "bad definition for "## #type##": must be "## #size##" bytes") + +// We rely on assert being compiled out in NDEBUG. +#define poly_assert assert + +#define __POLY_EXPAND(x) x +#define __POLY_ARGC(...) \ + __POLY_EXPAND(__POLY_ARGC_IMPL(__VA_ARGS__, 15, 14, 13, 12, 11, 10, 9, 8, 7, \ + 6, 5, 4, 3, 2, 1, 0)) +#define __POLY_ARGC_IMPL(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, \ + x13, x14, x15, N, ...) \ + N +#define __POLY_MACRO_DISPATCH(func, ...) \ + __POLY_MACRO_DISPATCH_(func, __POLY_ARGC(__VA_ARGS__)) +#define __POLY_MACRO_DISPATCH_(func, nargs) __POLY_MACRO_DISPATCH__(func, nargs) +#define __POLY_MACRO_DISPATCH__(func, nargs) func##nargs + +#define assert_always(...) poly_assert(false) + +#define assert_true(...) \ + __POLY_MACRO_DISPATCH(assert_true, __VA_ARGS__)(__VA_ARGS__) +#define assert_true1(expr) poly_assert(expr) +#define assert_true2(expr, message) poly_assert((expr) || !message) + +#define assert_false(...) \ + __POLY_MACRO_DISPATCH(assert_false, __VA_ARGS__)(__VA_ARGS__) +#define assert_false1(expr) poly_assert(!(expr)) +#define assert_false2(expr, message) poly_assert(!(expr) || !message) + +#define assert_zero(...) \ + __POLY_MACRO_DISPATCH(assert_zero, __VA_ARGS__)(__VA_ARGS__) +#define assert_zero1(expr) poly_assert((expr) == 0) +#define assert_zero2(expr, message) poly_assert((expr) == 0 || !message) + +#define assert_not_zero(...) \ + __POLY_MACRO_DISPATCH(assert_not_zero, __VA_ARGS__)(__VA_ARGS__) +#define assert_not_zero1(expr) poly_assert((expr) != 0) +#define assert_not_zero2(expr, message) poly_assert((expr) != 0 || !message) + +#define assert_null(...) \ + __POLY_MACRO_DISPATCH(assert_null, __VA_ARGS__)(__VA_ARGS__) +#define assert_null1(expr) poly_assert((expr) == nullptr) +#define assert_null2(expr, message) poly_assert((expr) == nullptr || !message) + +#define assert_not_null(...) \ + __POLY_MACRO_DISPATCH(assert_not_null, __VA_ARGS__)(__VA_ARGS__) +#define assert_not_null1(expr) poly_assert((expr) != nullptr) +#define assert_not_null2(expr, message) \ + poly_assert((expr) != nullptr || !message) + +#define assert_unhandled_case(variable) \ + assert_always("unhandled switch("## #variable##") case") + +} // namespace poly + +#endif // POLY_ASSERT_H_ diff --git a/src/poly/config.h b/src/poly/config.h index dead1d518..bdba0f17b 100644 --- a/src/poly/config.h +++ b/src/poly/config.h @@ -11,7 +11,7 @@ #define POLY_CONFIG_H_ #if defined(DEBUG) || defined(_DEBUG) -#define XE_DEBUG 1 +#define XE_DEBUG 1 #endif // DEBUG #endif // POLY_CONFIG_H_ diff --git a/src/poly/cxx_compat.h b/src/poly/cxx_compat.h index 080152245..d2d03897f 100644 --- a/src/poly/cxx_compat.h +++ b/src/poly/cxx_compat.h @@ -16,6 +16,7 @@ // http://en.cppreference.com/w/cpp/language/storage_duration #if XE_COMPILER_MSVC // VC++2014 may have this. +#define _ALLOW_KEYWORD_MACROS 1 #define thread_local __declspec(thread) #elif XE_LIKE_OSX // Clang supports it on OSX but the runtime doesn't. diff --git a/src/poly/math.h b/src/poly/math.h index 5fcce51fd..7a20fade4 100644 --- a/src/poly/math.h +++ b/src/poly/math.h @@ -25,15 +25,25 @@ namespace poly { // return value is the size of the input operand (8, 16, 32, or 64). If the most // significant bit of value is one, the return value is zero. #if XE_COMPILER_MSVC -inline uint8_t lzcnt(uint8_t v) { return static_cast(__lzcnt16(v) - 8); } +inline uint8_t lzcnt(uint8_t v) { + return static_cast(__lzcnt16(v) - 8); +} inline uint8_t lzcnt(uint16_t v) { return static_cast(__lzcnt16(v)); } inline uint8_t lzcnt(uint32_t v) { return static_cast(__lzcnt(v)); } inline uint8_t lzcnt(uint64_t v) { return static_cast(__lzcnt64(v)); } #else -inline uint8_t lzcnt(uint8_t v) { return static_cast(__builtin_clzs(v) - 8); } -inline uint8_t lzcnt(uint16_t v) { return static_cast(__builtin_clzs(v)); } -inline uint8_t lzcnt(uint32_t v) { return static_cast(__builtin_clz(v)); } -inline uint8_t lzcnt(uint64_t v) { return static_cast(__builtin_clzll(v)); } +inline uint8_t lzcnt(uint8_t v) { + return static_cast(__builtin_clzs(v) - 8); +} +inline uint8_t lzcnt(uint16_t v) { + return static_cast(__builtin_clzs(v)); +} +inline uint8_t lzcnt(uint32_t v) { + return static_cast(__builtin_clz(v)); +} +inline uint8_t lzcnt(uint64_t v) { + return static_cast(__builtin_clzll(v)); +} #endif // XE_COMPILER_MSVC inline uint8_t lzcnt(int8_t v) { return lzcnt(static_cast(v)); } inline uint8_t lzcnt(int16_t v) { return lzcnt(static_cast(v)); } @@ -49,7 +59,8 @@ inline bool bit_scan_forward(uint32_t v, uint32_t* out_first_set_index) { return _BitScanForward(reinterpret_cast(out_first_set_index), v) != 0; } inline bool bit_scan_forward(uint64_t v, uint32_t* out_first_set_index) { - return _BitScanForward64(reinterpret_cast(out_first_set_index), v) != 0; + return _BitScanForward64(reinterpret_cast(out_first_set_index), v) != + 0; } #else inline bool bit_scan_forward(uint32_t v, uint32_t* out_first_set_index) { diff --git a/src/poly/poly.h b/src/poly/poly.h index 6c70dedd7..52cc74b79 100644 --- a/src/poly/poly.h +++ b/src/poly/poly.h @@ -10,6 +10,7 @@ #ifndef POLY_POLY_H_ #define POLY_POLY_H_ +#include #include #include #include diff --git a/src/poly/sources.gypi b/src/poly/sources.gypi index dcf5478f5..7a29bd85b 100644 --- a/src/poly/sources.gypi +++ b/src/poly/sources.gypi @@ -1,9 +1,11 @@ # Copyright 2014 Ben Vanik. All Rights Reserved. { 'sources': [ + 'assert.h', 'config.h', 'cxx_compat.h', 'math.h', + 'platform.h', 'poly-private.h', 'poly.cc', 'poly.h', diff --git a/src/xenia/apu/audio_system.cc b/src/xenia/apu/audio_system.cc index 68b9ccbee..214620494 100644 --- a/src/xenia/apu/audio_system.cc +++ b/src/xenia/apu/audio_system.cc @@ -82,7 +82,7 @@ void AudioSystem::ThreadStart() { auto result = WaitForMultipleObjectsEx(maximum_client_count_, client_wait_handles_, FALSE, INFINITE, FALSE); if (result == WAIT_FAILED) { DWORD err = GetLastError(); - XEASSERTALWAYS(); + assert_always(); break; } @@ -131,7 +131,7 @@ void AudioSystem::Shutdown() { X_STATUS AudioSystem::RegisterClient( uint32_t callback, uint32_t callback_arg, size_t* out_index) { - XEASSERTTRUE(unused_clients_.size()); + assert_true(unused_clients_.size()); xe_mutex_lock(lock_); auto index = unused_clients_.front(); @@ -143,7 +143,7 @@ X_STATUS AudioSystem::RegisterClient( if (XFAILED(result)) { return result; } - XEASSERTNOTNULL(driver != NULL); + assert_not_null(driver); unused_clients_.pop(); @@ -165,8 +165,8 @@ void AudioSystem::SubmitFrame(size_t index, uint32_t samples_ptr) { SCOPE_profile_cpu_f("apu"); xe_mutex_lock(lock_); - XEASSERTTRUE(index < maximum_client_count_); - XEASSERTTRUE(clients_[index].driver != NULL); + assert_true(index < maximum_client_count_); + assert_true(clients_[index].driver != NULL); (clients_[index].driver)->SubmitFrame(samples_ptr); ResetEvent(client_wait_handles_[index]); xe_mutex_unlock(lock_); @@ -176,7 +176,7 @@ void AudioSystem::UnregisterClient(size_t index) { SCOPE_profile_cpu_f("apu"); xe_mutex_lock(lock_); - XEASSERTTRUE(index < maximum_client_count_); + assert_true(index < maximum_client_count_); DestroyDriver(clients_[index].driver); clients_[index] = { 0 }; unused_clients_.push(index); @@ -199,4 +199,4 @@ void AudioSystem::WriteRegister(uint64_t addr, uint64_t value) { uint32_t r = addr & 0xFFFF; XELOGAPU("WriteRegister(%.4X, %.8X)", r, value); // 1804h is written to with 0x02000000 and 0x03000000 around a lock operation -} \ No newline at end of file +} diff --git a/src/xenia/apu/nop/nop_audio_system.cc b/src/xenia/apu/nop/nop_audio_system.cc index fae7b153f..d384c3de3 100644 --- a/src/xenia/apu/nop/nop_audio_system.cc +++ b/src/xenia/apu/nop/nop_audio_system.cc @@ -29,5 +29,5 @@ X_STATUS NopAudioSystem::CreateDriver(size_t index, HANDLE wait_handle, AudioDri } void NopAudioSystem::DestroyDriver(AudioDriver* driver) { - XEASSERTALWAYS(); + assert_always(); } diff --git a/src/xenia/apu/xaudio2/xaudio2_audio_driver.cc b/src/xenia/apu/xaudio2/xaudio2_audio_driver.cc index 0155753c4..7be6c9d55 100644 --- a/src/xenia/apu/xaudio2/xaudio2_audio_driver.cc +++ b/src/xenia/apu/xaudio2/xaudio2_audio_driver.cc @@ -67,7 +67,7 @@ void XAudio2AudioDriver::Initialize() { hr = XAudio2Create(&audio_, 0, XAUDIO2_DEFAULT_PROCESSOR); if (FAILED(hr)) { XELOGE("XAudio2Create failed with %.8X", hr); - XEASSERTALWAYS(); + assert_always(); return; } @@ -83,7 +83,7 @@ void XAudio2AudioDriver::Initialize() { hr = audio_->CreateMasteringVoice(&mastering_voice_); if (FAILED(hr)) { XELOGE("CreateMasteringVoice failed with %.8X", hr); - XEASSERTALWAYS(); + assert_always(); return; } @@ -106,14 +106,14 @@ void XAudio2AudioDriver::Initialize() { voice_callback_); if (FAILED(hr)) { XELOGE("CreateSourceVoice failed with %.8X", hr); - XEASSERTALWAYS(); + assert_always(); return; } hr = pcm_voice_->Start(); if (FAILED(hr)) { XELOGE("Start failed with %.8X", hr); - XEASSERTALWAYS(); + assert_always(); return; } @@ -148,7 +148,7 @@ void XAudio2AudioDriver::SubmitFrame(uint32_t frame_ptr) { hr = pcm_voice_->SubmitSourceBuffer(&buffer); if (FAILED(hr)) { XELOGE("SubmitSourceBuffer failed with %.8X", hr); - XEASSERTALWAYS(); + assert_always(); return; } } diff --git a/src/xenia/apu/xaudio2/xaudio2_audio_system.cc b/src/xenia/apu/xaudio2/xaudio2_audio_system.cc index 465c51b5e..f87197cb4 100644 --- a/src/xenia/apu/xaudio2/xaudio2_audio_system.cc +++ b/src/xenia/apu/xaudio2/xaudio2_audio_system.cc @@ -31,7 +31,7 @@ void XAudio2AudioSystem::Initialize() { } X_STATUS XAudio2AudioSystem::CreateDriver(size_t index, HANDLE wait, AudioDriver** out_driver) { - XEASSERTNOTNULL(out_driver); + assert_not_null(out_driver); auto driver = new XAudio2AudioDriver(emulator_, wait); driver->Initialize(); *out_driver = driver; @@ -39,9 +39,9 @@ X_STATUS XAudio2AudioSystem::CreateDriver(size_t index, HANDLE wait, AudioDriver } void XAudio2AudioSystem::DestroyDriver(AudioDriver* driver) { - XEASSERTNOTNULL(driver); + assert_not_null(driver); auto xdriver = static_cast(driver); xdriver->Shutdown(); - XEASSERTNOTNULL(xdriver); + assert_not_null(xdriver); delete xdriver; } diff --git a/src/xenia/assert.h b/src/xenia/assert.h deleted file mode 100644 index 4f765bbd8..000000000 --- a/src/xenia/assert.h +++ /dev/null @@ -1,74 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2013 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_ASSERT_H_ -#define XENIA_ASSERT_H_ - -#include - -#include -#include -#include -#include -#include - - -#if 0 && XE_COMPILER_MSVC && defined(UNICODE) && UNICODE -// http://msdn.microsoft.com/en-us/library/b0084kay.aspx -#if !defined(__WFILE__) -#define WIDEN2(x) L##x -#define WIDEN(x) WIDEN2(x) -#define __WFILE__ WIDEN(__FILE__) -#define __WFUNCTION__ WIDEN(__FUNCTION__) -#endif -#define XE_CURRENT_FILE __WFILE__ -#define XE_CURRENT_FUNCTION __WFUNCTION__ -#else -#define XE_CURRENT_FILE __FILE__ -#define XE_CURRENT_FUNCTION __FUNCTION__ -#endif // MSVC -#define XE_CURRENT_LINE __LINE__ - - -#define __XE_ASSERT(expr) assert(expr) -#if XE_OPTION_ENABLE_ASSERTS -#define XEASSERTCORE(expr) __XE_ASSERT(expr) -#else -#define XEASSERTCORE(expr) XE_EMPTY_MACRO -#endif // ENABLE_ASSERTS - -#define XEASSERTALWAYS() XEASSERTCORE( 0 ) -#define XEASSERT(expr) XEASSERTCORE( (expr) ) -#define XEASSERTTRUE(expr) XEASSERTCORE( (expr) ) -#define XEASSERTFALSE(expr) XEASSERTCORE(!(expr) ) -#define XEASSERTZERO(expr) XEASSERTCORE( (expr) == 0 ) -#define XEASSERTNOTZERO(expr) XEASSERTCORE( (expr) != 0 ) -#define XEASSERTNULL(expr) XEASSERTCORE( (expr) == NULL ) -#define XEASSERTNOTNULL(expr) XEASSERTCORE( (expr) != NULL ) -#define XEASSERTUNHANDLEDCASE(var) XEASSERTALWAYS() - - -#if XE_COMPILER_MSVC -// http://msdn.microsoft.com/en-us/library/bb918086.aspx -// TODO(benvanik): if 2010+, use static_assert? -// http://msdn.microsoft.com/en-us/library/dd293588.aspx -#define XESTATICASSERT(expr, message) _STATIC_ASSERT(expr) -//#elif XE_COMPILER_GNUC -// http://stackoverflow.com/questions/3385515/static-assert-in-c -//#define XESTATICASSERT(expr, message) ({ extern int __attribute__((error("assertion failure: '" #expr "' not true - " #message))) compile_time_check(); ((expr)?0:compile_time_check()),0; }) -#else -// http://stackoverflow.com/questions/3385515/static-assert-in-c -#define XESTATICASSERT3(expr, L) typedef char static_assertion_##L[(expr)?1:-1] -#define XESTATICASSERT2(expr, L) XESTATICASSERT3(expr, L) -#define XESTATICASSERT(expr, message) XESTATICASSERT2(expr, __LINE__) -#endif // MSVC - -#define XEASSERTSTRUCTSIZE(target, size) XESTATICASSERT(sizeof(target) == size, "bad definition for " ## target ## ": must be " ## size ## " bytes") - -#endif // XENIA_ASSERT_H_ diff --git a/src/xenia/atomic.h b/src/xenia/atomic.h index 10403280d..bd1ebc14d 100644 --- a/src/xenia/atomic.h +++ b/src/xenia/atomic.h @@ -13,6 +13,7 @@ #include #include +#include // These functions are modeled off of the Apple OSAtomic routines diff --git a/src/xenia/common.h b/src/xenia/common.h index 0e8cac0a2..c76f9eae1 100644 --- a/src/xenia/common.h +++ b/src/xenia/common.h @@ -10,7 +10,8 @@ #ifndef XENIA_COMMON_H_ #define XENIA_COMMON_H_ -#include +#include + #include #include #include diff --git a/src/xenia/core/path_posix.cc b/src/xenia/core/path_posix.cc index b8bedda56..0dc9aadec 100644 --- a/src/xenia/core/path_posix.cc +++ b/src/xenia/core/path_posix.cc @@ -12,5 +12,5 @@ const xechar_t* xe_path_get_tmp(const xechar_t* prefix) { // - XEASSERTALWAYS(); + assert_always(); } diff --git a/src/xenia/core/path_win.cc b/src/xenia/core/path_win.cc index e1361d945..ded9bf388 100644 --- a/src/xenia/core/path_win.cc +++ b/src/xenia/core/path_win.cc @@ -11,7 +11,7 @@ const xechar_t* xe_path_get_tmp(const xechar_t* prefix) { - // - XEASSERTALWAYS(); + // + assert_always(); return NULL; } diff --git a/src/xenia/cpu/processor.cc b/src/xenia/cpu/processor.cc index 7aa67ccdf..b263e1aad 100644 --- a/src/xenia/cpu/processor.cc +++ b/src/xenia/cpu/processor.cc @@ -68,7 +68,7 @@ Processor::~Processor() { } int Processor::Setup() { - XEASSERTNULL(runtime_); + assert_null(runtime_); runtime_ = new XenonRuntime(memory_, export_resolver_); if (!runtime_) { @@ -127,7 +127,7 @@ uint64_t Processor::Execute( SCOPE_profile_cpu_f("cpu"); PPCContext* context = thread_state->context(); - XEASSERT(arg_count <= 5); + assert_true(arg_count <= 5); for (size_t i = 0; i < arg_count; ++i) { context->r[3 + i] = args[i]; } diff --git a/src/xenia/cpu/xenon_memory.cc b/src/xenia/cpu/xenon_memory.cc index c20130fae..2993f4850 100644 --- a/src/xenia/cpu/xenon_memory.cc +++ b/src/xenia/cpu/xenon_memory.cc @@ -174,7 +174,7 @@ LONG CALLBACK CheckMMIOHandler(PEXCEPTION_POINTERS ex_info) { auto action = ex_info->ExceptionRecord->ExceptionInformation[0]; if (action == 0) { uint64_t value = range.read(range.context, address & 0xFFFFFFFF); - XEASSERT((disasm.Argument1.ArgType & BE::REGISTER_TYPE) == + assert_true((disasm.Argument1.ArgType & BE::REGISTER_TYPE) == BE::REGISTER_TYPE); uint64_t* reg_ptr = GetContextRegPtr(disasm.Argument1.ArgType, ex_info->ContextRecord); @@ -203,7 +203,7 @@ LONG CALLBACK CheckMMIOHandler(PEXCEPTION_POINTERS ex_info) { } else if ((disasm.Argument2.ArgType & BE::CONSTANT_TYPE) == BE::CONSTANT_TYPE) { value = disasm.Instruction.Immediat; } else { - XEASSERTALWAYS(); + assert_always(); } switch (disasm.Argument2.ArgSize) { case 8: @@ -290,7 +290,7 @@ int XenonMemory::Initialize() { NULL); if (!mapping_) { XELOGE("Unable to reserve the 4gb guest address space."); - XEASSERTNOTNULL(mapping_); + assert_not_null(mapping_); XEFAIL(); } @@ -306,7 +306,7 @@ int XenonMemory::Initialize() { } if (!mapping_base_) { XELOGE("Unable to find a continuous block in the 64bit address space."); - XEASSERTALWAYS(); + assert_always(); XEFAIL(); } membase_ = mapping_base_; @@ -362,7 +362,7 @@ int XenonMemory::MapViews(uint8_t* mapping_base) { 0xC0000000, 0xDFFFFFFF, 0x00000000, // - physical 16mb pages 0xE0000000, 0xFFFFFFFF, 0x00000000, // - physical 4k pages }; - XEASSERT(XECOUNT(map_info) == XECOUNT(views_.all_views)); + assert_true(XECOUNT(map_info) == XECOUNT(views_.all_views)); for (size_t n = 0; n < XECOUNT(map_info); n++) { views_.all_views[n] = (uint8_t*)MapViewOfFileEx( mapping_, @@ -398,14 +398,14 @@ bool XenonMemory::AddMappedRange(uint64_t address, uint64_t mask, protect = PAGE_READONLY; } else { // Write-only memory is not supported. - XEASSERTALWAYS(); + assert_always(); } if (!VirtualAlloc(Translate(address), size, MEM_COMMIT, protect)) { return false; } - XEASSERT(g_mapped_range_count_ + 1 < XECOUNT(g_mapped_ranges_)); + assert_true(g_mapped_range_count_ + 1 < XECOUNT(g_mapped_ranges_)); g_mapped_ranges_[g_mapped_range_count_++] = { reinterpret_cast(mapping_base_) | address, 0xFFFFFFFF00000000 | mask, @@ -518,13 +518,13 @@ uint64_t XenonMemory::HeapAlloc( if (base_address >= XENON_MEMORY_VIRTUAL_HEAP_LOW && base_address < XENON_MEMORY_VIRTUAL_HEAP_HIGH) { // Overlapping managed heap. - XEASSERTALWAYS(); + assert_always(); return 0; } if (base_address >= XENON_MEMORY_PHYSICAL_HEAP_LOW && base_address < XENON_MEMORY_PHYSICAL_HEAP_HIGH) { // Overlapping managed heap. - XEASSERTALWAYS(); + assert_always(); return 0; } @@ -534,7 +534,7 @@ uint64_t XenonMemory::HeapAlloc( void* pv = VirtualAlloc(p, size, MEM_COMMIT, PAGE_READWRITE); if (!pv) { // Failed. - XEASSERTALWAYS(); + assert_always(); return 0; } diff --git a/src/xenia/cpu/xenon_thread_state.cc b/src/xenia/cpu/xenon_thread_state.cc index c4dd94069..e5ed16da5 100644 --- a/src/xenia/cpu/xenon_thread_state.cc +++ b/src/xenia/cpu/xenon_thread_state.cc @@ -32,7 +32,7 @@ XenonThreadState::XenonThreadState( // Allocate with 64b alignment. context_ = (PPCContext*)xe_malloc_aligned(sizeof(PPCContext)); - XEASSERT(((uint64_t)context_ & 0xF) == 0); + assert_true(((uint64_t)context_ & 0xF) == 0); xe_zero_struct(context_, sizeof(PPCContext)); // Stash pointers to common structures that callbacks may need. diff --git a/src/xenia/emulator.cc b/src/xenia/emulator.cc index deb33c9c3..64c9ac00b 100644 --- a/src/xenia/emulator.cc +++ b/src/xenia/emulator.cc @@ -127,7 +127,7 @@ XECLEANUP: } void Emulator::set_main_window(Window* window) { - XEASSERTNULL(main_window_); + assert_null(main_window_); main_window_ = window; window->closed.AddListener([](UIEvent& e) { diff --git a/src/xenia/export_resolver.cc b/src/xenia/export_resolver.cc index 9d09b63ec..8d37240e3 100644 --- a/src/xenia/export_resolver.cc +++ b/src/xenia/export_resolver.cc @@ -78,7 +78,7 @@ KernelExport* ExportResolver::GetExportByOrdinal(const char* library_name, KernelExport* ExportResolver::GetExportByName(const char* library_name, const char* name) { // TODO(benvanik): lookup by name. - XEASSERTALWAYS(); + assert_always(); return NULL; } @@ -86,7 +86,7 @@ void ExportResolver::SetVariableMapping(const char* library_name, const uint32_t ordinal, uint32_t value) { KernelExport* kernel_export = GetExportByOrdinal(library_name, ordinal); - XEASSERTNOTNULL(kernel_export); + assert_not_null(kernel_export); kernel_export->is_implemented = true; kernel_export->variable_ptr = value; } @@ -96,7 +96,7 @@ void ExportResolver::SetFunctionMapping( void* shim_data, xe_kernel_export_shim_fn shim, xe_kernel_export_impl_fn impl) { KernelExport* kernel_export = GetExportByOrdinal(library_name, ordinal); - XEASSERTNOTNULL(kernel_export); + assert_not_null(kernel_export); kernel_export->is_implemented = true; kernel_export->function_data.shim_data = shim_data; kernel_export->function_data.shim = shim; diff --git a/src/xenia/gpu/command_processor.cc b/src/xenia/gpu/command_processor.cc index 23c27c5a9..d84c7e236 100644 --- a/src/xenia/gpu/command_processor.cc +++ b/src/xenia/gpu/command_processor.cc @@ -144,10 +144,10 @@ void CommandProcessor::ExecutePrimaryBuffer( uint32_t n = 0; while (args.ptr != end_ptr) { n += ExecutePacket(args); - XEASSERT(args.ptr < args.max_address); + assert_true(args.ptr < args.max_address); } if (end_index > start_index) { - XEASSERT(n == (end_index - start_index)); + assert_true(n == (end_index - start_index)); } XETRACECP(" ExecutePrimaryBuffer End"); @@ -164,7 +164,7 @@ void CommandProcessor::ExecuteIndirectBuffer(uint32_t ptr, uint32_t length) { args.ptr_mask = 0; for (uint32_t n = 0; n < length;) { n += ExecutePacket(args); - XEASSERT(n <= length); + assert_true(n <= length); } XETRACECP(" ExecuteIndirectBuffer End"); @@ -343,7 +343,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) { value = GpuSwap(value, endianness); } else { // Register. - XEASSERT(poll_reg_addr < RegisterFile::kRegisterCount); + assert_true(poll_reg_addr < RegisterFile::kRegisterCount); value = regs->values[poll_reg_addr].u32; if (poll_reg_addr == XE_GPU_REG_COHER_STATUS_HOST) { MakeCoherent(); @@ -438,7 +438,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) { value = GpuSwap(value, endianness); } else { // Register. - XEASSERT(poll_reg_addr < RegisterFile::kRegisterCount); + assert_true(poll_reg_addr < RegisterFile::kRegisterCount); value = regs->values[poll_reg_addr].u32; } bool matched = false; @@ -496,7 +496,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) { // Just an event flag? Where does this write? } else { // Write to an address. - XEASSERTALWAYS(); + assert_always(); ADVANCE_PTR(count - 1); } } @@ -564,7 +564,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) { draw_command_.index_buffer = nullptr; } else { // Unknown source select. - XEASSERTALWAYS(); + assert_always(); } driver_->Draw(draw_command_); } else { @@ -584,7 +584,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) { uint32_t index_count = d0 >> 16; uint32_t prim_type = d0 & 0x3F; uint32_t src_sel = (d0 >> 6) & 0x3; - XEASSERT(src_sel == 0x2); // 'SrcSel=AutoIndex' + assert_true(src_sel == 0x2); // 'SrcSel=AutoIndex' if (!driver_->PrepareDraw(draw_command_)) { draw_command_.prim_type = (XE_GPU_PRIMITIVE_TYPE)prim_type; draw_command_.start_index = 0; @@ -619,7 +619,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) { } break; default: - XEASSERTALWAYS(); + assert_always(); break; } } @@ -660,7 +660,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) { uint32_t start_size = READ_PTR(); uint32_t start = start_size >> 16; uint32_t size = start_size & 0xFFFF; // dwords - XEASSERT(start == 0); + assert_true(start == 0); driver_->LoadShader((XE_GPU_SHADER_TYPE)type, GpuToCpu(packet_ptr, addr), size * 4, start); } @@ -675,9 +675,9 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) { uint32_t start_size = READ_PTR(); uint32_t start = start_size >> 16; uint32_t size = start_size & 0xFFFF; // dwords - XEASSERT(start == 0); + assert_true(start == 0); // TODO(benvanik): figure out if this could wrap. - XEASSERT(args.ptr + size * 4 < args.max_address); + assert_true(args.ptr + size * 4 < args.max_address); driver_->LoadShader((XE_GPU_SHADER_TYPE)type, args.ptr, size * 4, start); ADVANCE_PTR(size); @@ -751,7 +751,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) { void CommandProcessor::WriteRegister( uint32_t packet_ptr, uint32_t index, uint32_t value) { RegisterFile* regs = driver_->register_file(); - XEASSERT(index < RegisterFile::kRegisterCount); + assert_true(index < RegisterFile::kRegisterCount); regs->values[index].u32 = value; // If this is a COHER register, set the dirty flag. diff --git a/src/xenia/gpu/d3d11/d3d11_buffer_resource.cc b/src/xenia/gpu/d3d11/d3d11_buffer_resource.cc index 8f03cfe58..1b1654c59 100644 --- a/src/xenia/gpu/d3d11/d3d11_buffer_resource.cc +++ b/src/xenia/gpu/d3d11/d3d11_buffer_resource.cc @@ -53,7 +53,7 @@ int D3D11IndexBufferResource::InvalidateRegion( SCOPE_profile_cpu_f("gpu"); // All that's done so far: - XEASSERT(info_.endianness == 0x2); + assert_true(info_.endianness == 0x2); D3D11_MAPPED_SUBRESOURCE res; HRESULT hr = resource_cache_->context()->Map( diff --git a/src/xenia/gpu/d3d11/d3d11_graphics_system.cc b/src/xenia/gpu/d3d11/d3d11_graphics_system.cc index 8e6fc5a7e..11d113ca4 100644 --- a/src/xenia/gpu/d3d11/d3d11_graphics_system.cc +++ b/src/xenia/gpu/d3d11/d3d11_graphics_system.cc @@ -33,8 +33,8 @@ D3D11GraphicsSystem::~D3D11GraphicsSystem() { void D3D11GraphicsSystem::Initialize() { GraphicsSystem::Initialize(); - XEASSERTNULL(timer_queue_); - XEASSERTNULL(vsync_timer_); + assert_null(timer_queue_); + assert_null(vsync_timer_); timer_queue_ = CreateTimerQueue(); CreateTimerQueueTimer( @@ -111,7 +111,7 @@ void D3D11GraphicsSystem::Initialize() { // Create the window. // This will pump through the run-loop and and be where our swapping // will take place. - XEASSERTNULL(window_); + assert_null(window_); window_ = new D3D11Window(run_loop_, dxgi_factory_, device_); if (window_->Initialize("Xenia D3D11", 1280, 720)) { XELOGE("Failed to create D3D11Window"); @@ -126,7 +126,7 @@ void D3D11GraphicsSystem::Initialize() { // Create the driver. // This runs in the worker thread and builds command lines to present // in the window. - XEASSERTNULL(driver_); + assert_null(driver_); driver_ = new D3D11GraphicsDriver( memory_, window_->swap_chain(), device_); if (driver_->Initialize()) { @@ -180,7 +180,7 @@ void __stdcall D3D11GraphicsSystem::VsyncCallback(D3D11GraphicsSystem* gs, void D3D11GraphicsSystem::Shutdown() { GraphicsSystem::Shutdown(); - + if (vsync_timer_) { DeleteTimerQueueTimer(timer_queue_, vsync_timer_, NULL); } diff --git a/src/xenia/gpu/d3d11/d3d11_profiler_display.cc b/src/xenia/gpu/d3d11/d3d11_profiler_display.cc index 276b73c40..8bcefd0e7 100644 --- a/src/xenia/gpu/d3d11/d3d11_profiler_display.cc +++ b/src/xenia/gpu/d3d11/d3d11_profiler_display.cc @@ -140,7 +140,7 @@ D3D11ProfilerDisplay::D3D11ProfilerDisplay(D3D11Window* window) : window_(window !SetupShaders() || !SetupFont()) { // Hrm. - XEASSERTALWAYS(); + assert_always(); } // Pass through mouse events. @@ -183,7 +183,7 @@ bool D3D11ProfilerDisplay::SetupState() { blend_desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; blend_desc.RenderTarget[0].RenderTargetWriteMask = 0x0F; hr = device->CreateBlendState(&blend_desc, &blend_state_); - XEASSERT(SUCCEEDED(hr)); + assert_true(SUCCEEDED(hr)); D3D11_DEPTH_STENCIL_DESC depth_stencil_desc; xe_zero_struct(&depth_stencil_desc, sizeof(depth_stencil_desc)); @@ -191,7 +191,7 @@ bool D3D11ProfilerDisplay::SetupState() { depth_stencil_desc.StencilEnable = false; depth_stencil_desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO; hr = device->CreateDepthStencilState(&depth_stencil_desc, &depth_stencil_state_); - XEASSERT(SUCCEEDED(hr)); + assert_true(SUCCEEDED(hr)); return true; } @@ -484,7 +484,7 @@ D3D11ProfilerDisplay::Vertex* D3D11ProfilerDisplay::AllocateVertices( if (draw_state_.vertex_index + count > XECOUNT(draw_state_.vertex_buffer)) { Flush(); } - XEASSERT(draw_state_.vertex_index + count <= XECOUNT(draw_state_.vertex_buffer)); + assert_true(draw_state_.vertex_index + count <= XECOUNT(draw_state_.vertex_buffer)); size_t head = draw_state_.vertex_index; draw_state_.vertex_index += count; @@ -493,7 +493,7 @@ D3D11ProfilerDisplay::Vertex* D3D11ProfilerDisplay::AllocateVertices( draw_state_.commands[draw_state_.command_index - 1].primitive == primitive) { draw_state_.commands[draw_state_.command_index - 1].vertex_count += count; } else { - XEASSERT(draw_state_.command_index < XECOUNT(draw_state_.commands)); + assert_true(draw_state_.command_index < XECOUNT(draw_state_.commands)); draw_state_.commands[draw_state_.command_index].primitive = primitive; draw_state_.commands[draw_state_.command_index].vertex_count = count; ++draw_state_.command_index; @@ -511,7 +511,7 @@ void D3D11ProfilerDisplay::Flush() { context->Map(vertex_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &res); memcpy(res.pData, draw_state_.vertex_buffer, sizeof(Vertex) * draw_state_.vertex_index); context->Unmap(vertex_buffer_, 0); - + uint32_t stride = 20; uint32_t offset = 0; context->IASetVertexBuffers(0, 1, &vertex_buffer_, &stride, &offset); diff --git a/src/xenia/gpu/d3d11/d3d11_shader_resource.cc b/src/xenia/gpu/d3d11/d3d11_shader_resource.cc index e4be7e2cf..b5c28c9f2 100644 --- a/src/xenia/gpu/d3d11/d3d11_shader_resource.cc +++ b/src/xenia/gpu/d3d11/d3d11_shader_resource.cc @@ -252,7 +252,7 @@ int D3D11VertexShaderResource::CreateInputLayout(const void* byte_code, vtx_format = DXGI_FORMAT_R32G32B32A32_FLOAT; break; default: - XEASSERTALWAYS(); + assert_always(); break; } element_descs[el_index].SemanticName = "XE_VF"; @@ -299,7 +299,7 @@ int D3D11VertexShaderResource::DemandGeometryShader( shader = new D3D11QuadListGeometryShader(device); break; default: - XEASSERTALWAYS(); + assert_always(); return 1; } if (!shader) { diff --git a/src/xenia/gpu/d3d11/d3d11_shader_translator.cc b/src/xenia/gpu/d3d11/d3d11_shader_translator.cc index b23c0d5a5..1d7c74940 100644 --- a/src/xenia/gpu/d3d11/d3d11_shader_translator.cc +++ b/src/xenia/gpu/d3d11/d3d11_shader_translator.cc @@ -58,7 +58,7 @@ const char* GetFormatTypeName(const VertexBufferResource::DeclElement& el) { return "float4"; default: XELOGE("Unknown vertex format: %d", el.format); - XEASSERTALWAYS(); + assert_always(); return "float4"; } } @@ -141,7 +141,7 @@ int D3D11ShaderTranslator::TranslateVertexShader( append( "struct VS_OUTPUT {\n"); if (alloc_counts.positions) { - XEASSERT(alloc_counts.positions == 1); + assert_true(alloc_counts.positions == 1); append( " float4 oPos : SV_POSITION;\n"); } @@ -244,7 +244,7 @@ int D3D11ShaderTranslator::TranslatePixelShader( append( "struct VS_OUTPUT {\n"); if (alloc_counts.positions) { - XEASSERT(alloc_counts.positions == 1); + assert_true(alloc_counts.positions == 1); append( " float4 oPos : SV_POSITION;\n"); } @@ -417,7 +417,7 @@ void D3D11ShaderTranslator::AppendDestRegName(uint32_t num, uint32_t dst_exp) { default: // TODO(benvanik): other render targets? // TODO(benvanik): depth? - XEASSERTALWAYS(); + assert_always(); break; } break; @@ -1272,7 +1272,7 @@ int D3D11ShaderTranslator::GetFormatComponentCount(uint32_t format) { return 4; default: XELOGE("Unknown vertex format: %d", format); - XEASSERTALWAYS(); + assert_always(); return 4; } } @@ -1348,7 +1348,7 @@ int D3D11ShaderTranslator::TranslateExec(const instr_cf_exec_t& cf) { case TEX_SET_GRADIENTS_H: case TEX_SET_GRADIENTS_V: default: - XEASSERTALWAYS(); + assert_always(); break; } } else { diff --git a/src/xenia/gpu/d3d11/d3d11_texture_resource.cc b/src/xenia/gpu/d3d11/d3d11_texture_resource.cc index a90c60b0d..301638ffd 100644 --- a/src/xenia/gpu/d3d11/d3d11_texture_resource.cc +++ b/src/xenia/gpu/d3d11/d3d11_texture_resource.cc @@ -136,13 +136,13 @@ int D3D11TextureResource::CreateHandle2D() { int D3D11TextureResource::CreateHandle3D() { XELOGE("D3D11: CreateTexture3D not yet implemented"); - XEASSERTALWAYS(); + assert_always(); return 1; } int D3D11TextureResource::CreateHandleCube() { XELOGE("D3D11: CreateTextureCube not yet implemented"); - XEASSERTALWAYS(); + assert_always(); return 1; } diff --git a/src/xenia/gpu/graphics_driver.cc b/src/xenia/gpu/graphics_driver.cc index e398839b8..46642a0d3 100644 --- a/src/xenia/gpu/graphics_driver.cc +++ b/src/xenia/gpu/graphics_driver.cc @@ -157,7 +157,7 @@ int GraphicsDriver::PopulateShaders(DrawCommand& command) { XELOGE("No pixel shader bound; ignoring"); return 1; } - + xe_gpu_program_cntl_t program_cntl; program_cntl.dword_0 = register_file_[XE_GPU_REG_SQ_PROGRAM_CNTL].u32; if (!vertex_shader_->is_prepared()) { @@ -181,7 +181,7 @@ int GraphicsDriver::PopulateShaders(DrawCommand& command) { int GraphicsDriver::PopulateInputAssembly(DrawCommand& command) { SCOPE_profile_cpu_f("gpu"); - + const auto& buffer_inputs = command.vertex_shader->buffer_inputs(); command.vertex_buffer_count = buffer_inputs.count; for (size_t n = 0; n < buffer_inputs.count; n++) { @@ -201,10 +201,10 @@ int GraphicsDriver::PopulateInputAssembly(DrawCommand& command) { fetch = &group->vertex_fetch_2; break; } - XEASSERTNOTNULL(fetch); + assert_not_null(fetch); // If this assert doesn't hold, maybe we just abort? - XEASSERT(fetch->type == 0x3); - XEASSERTNOTZERO(fetch->size); + assert_true(fetch->type == 0x3); + assert_not_zero(fetch->size); const auto& info = desc.info; @@ -278,7 +278,7 @@ int GraphicsDriver::PopulateSamplerSet( XELOGW("D3D11: unknown texture format %d", info.format); return 0; // invalid texture used } - + // TODO(benvanik): quick validate without refetching intraframe. // Fetch texture from the cache. MemoryRange memory_range; diff --git a/src/xenia/gpu/graphics_system.cc b/src/xenia/gpu/graphics_system.cc index 86905cc48..abd03e2d6 100644 --- a/src/xenia/gpu/graphics_system.cc +++ b/src/xenia/gpu/graphics_system.cc @@ -72,7 +72,7 @@ void GraphicsSystem::ThreadStart() { // Initialize driver and ringbuffer. Initialize(); - XEASSERTNOTNULL(driver_); + assert_not_null(driver_); SetEvent(thread_wait_); // Main run loop. @@ -128,7 +128,7 @@ void GraphicsSystem::InitializeRingBuffer(uint32_t ptr, uint32_t page_count) { while (!driver_) { Sleep(0); } - XEASSERTNOTNULL(driver_); + assert_not_null(driver_); command_processor_->Initialize(driver_, ptr, page_count); } @@ -154,7 +154,7 @@ uint64_t GraphicsSystem::ReadRegister(uint64_t addr) { return 1; } - XEASSERT(r >= 0 && r < RegisterFile::kRegisterCount); + assert_true(r >= 0 && r < RegisterFile::kRegisterCount); return regs->values[r].u32; } @@ -175,7 +175,7 @@ void GraphicsSystem::WriteRegister(uint64_t addr, uint64_t value) { break; } - XEASSERT(r >= 0 && r < RegisterFile::kRegisterCount); + assert_true(r >= 0 && r < RegisterFile::kRegisterCount); regs->values[r].u32 = (uint32_t)value; } diff --git a/src/xenia/gpu/nop/nop_graphics_system.cc b/src/xenia/gpu/nop/nop_graphics_system.cc index 9ae31bb3a..8e470375d 100644 --- a/src/xenia/gpu/nop/nop_graphics_system.cc +++ b/src/xenia/gpu/nop/nop_graphics_system.cc @@ -40,11 +40,11 @@ NopGraphicsSystem::~NopGraphicsSystem() { void NopGraphicsSystem::Initialize() { GraphicsSystem::Initialize(); - XEASSERTNULL(driver_); + assert_null(driver_); driver_ = new NopGraphicsDriver(memory_); - XEASSERTNULL(timer_queue_); - XEASSERTNULL(vsync_timer_); + assert_null(timer_queue_); + assert_null(vsync_timer_); timer_queue_ = CreateTimerQueue(); CreateTimerQueueTimer( diff --git a/src/xenia/gpu/shader_resource.cc b/src/xenia/gpu/shader_resource.cc index 07b64efbe..dfbac3648 100644 --- a/src/xenia/gpu/shader_resource.cc +++ b/src/xenia/gpu/shader_resource.cc @@ -29,7 +29,7 @@ ShaderResource::ShaderResource(const MemoryRange& memory_range, // Verify. dword_count_ = memory_range.length / 4; - XEASSERT(dword_count_ <= 512); + assert_true(dword_count_ <= 512); // Copy bytes and swap. size_t byte_size = dword_count_ * sizeof(uint32_t); @@ -122,7 +122,7 @@ void ShaderResource::GatherExec(const instr_cf_exec_t* cf) { case TEX_SET_GRADIENTS_H: case TEX_SET_GRADIENTS_V: default: - XEASSERTALWAYS(); + assert_always(); break; } } else { @@ -145,7 +145,7 @@ void ShaderResource::GatherExec(const instr_cf_exec_t* cf) { } void ShaderResource::GatherVertexFetch(const instr_fetch_vtx_t* vtx) { - XEASSERT(type_ == XE_GPU_SHADER_TYPE_VERTEX); + assert_true(type_ == XE_GPU_SHADER_TYPE_VERTEX); // dst_reg/dst_swiz // src_reg/src_swiz @@ -188,16 +188,16 @@ void ShaderResource::GatherVertexFetch(const instr_fetch_vtx_t* vtx) { auto& desc = inputs.descs[n]; auto& info = desc.info; if (desc.fetch_slot == fetch_slot) { - XEASSERT(info.element_count <= XECOUNT(info.elements)); + assert_true(info.element_count <= XECOUNT(info.elements)); // It may not hold that all strides are equal, but I hope it does. - XEASSERT(!vtx->stride || info.stride_words == vtx->stride); + assert_true(!vtx->stride || info.stride_words == vtx->stride); el = &info.elements[info.element_count++]; break; } } if (!el) { - XEASSERTNOTZERO(vtx->stride); - XEASSERT(inputs.count + 1 < XECOUNT(inputs.descs)); + assert_not_zero(vtx->stride); + assert_true(inputs.count + 1 < XECOUNT(inputs.descs)); auto& desc = inputs.descs[inputs.count++]; desc.input_index = inputs.count - 1; desc.fetch_slot = fetch_slot; @@ -243,7 +243,7 @@ void ShaderResource::GatherVertexFetch(const instr_fetch_vtx_t* vtx) { break; default: XELOGE("Unknown vertex format: %d", el->format); - XEASSERTALWAYS(); + assert_always(); break; } } @@ -251,7 +251,7 @@ void ShaderResource::GatherVertexFetch(const instr_fetch_vtx_t* vtx) { void ShaderResource::GatherTextureFetch(const xenos::instr_fetch_tex_t* tex) { // TODO(benvanik): check dest_swiz to see if we are writing anything. - XEASSERT(sampler_inputs_.count + 1 < XECOUNT(sampler_inputs_.descs)); + assert_true(sampler_inputs_.count + 1 < XECOUNT(sampler_inputs_.descs)); auto& input = sampler_inputs_.descs[sampler_inputs_.count++]; input.input_index = sampler_inputs_.count - 1; input.fetch_slot = tex->const_idx & 0xF; // ? diff --git a/src/xenia/kernel/fs/devices/disc_image_device.cc b/src/xenia/kernel/fs/devices/disc_image_device.cc index f46e3e1d7..e3e2a8c4b 100644 --- a/src/xenia/kernel/fs/devices/disc_image_device.cc +++ b/src/xenia/kernel/fs/devices/disc_image_device.cc @@ -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; } diff --git a/src/xenia/kernel/fs/devices/disc_image_entry.cc b/src/xenia/kernel/fs/devices/disc_image_entry.cc index 2b4b51834..a11f98088 100644 --- a/src/xenia/kernel/fs/devices/disc_image_entry.cc +++ b/src/xenia/kernel/fs/devices/disc_image_entry.cc @@ -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(); diff --git a/src/xenia/kernel/fs/devices/host_path_device.cc b/src/xenia/kernel/fs/devices/host_path_device.cc index 675563416..b4cbf5046 100644 --- a/src/xenia/kernel/fs/devices/host_path_device.cc +++ b/src/xenia/kernel/fs/devices/host_path_device.cc @@ -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; diff --git a/src/xenia/kernel/fs/devices/host_path_entry.cc b/src/xenia/kernel/fs/devices/host_path_entry.cc index 037563625..a7f908bd3 100644 --- a/src/xenia/kernel/fs/devices/host_path_entry.cc +++ b/src/xenia/kernel/fs/devices/host_path_entry.cc @@ -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; diff --git a/src/xenia/kernel/fs/devices/stfs_container_device.cc b/src/xenia/kernel/fs/devices/stfs_container_device.cc index d557c2a1d..b055e8820 100644 --- a/src/xenia/kernel/fs/devices/stfs_container_device.cc +++ b/src/xenia/kernel/fs/devices/stfs_container_device.cc @@ -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; } diff --git a/src/xenia/kernel/fs/devices/stfs_container_entry.cc b/src/xenia/kernel/fs/devices/stfs_container_entry.cc index a91d1234b..318b11bf7 100644 --- a/src/xenia/kernel/fs/devices/stfs_container_entry.cc +++ b/src/xenia/kernel/fs/devices/stfs_container_entry.cc @@ -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(); diff --git a/src/xenia/kernel/fs/entry.cc b/src/xenia/kernel/fs/entry.cc index c7c28819b..0658d0f7b 100644 --- a/src/xenia/kernel/fs/entry.cc +++ b/src/xenia/kernel/fs/entry.cc @@ -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()); diff --git a/src/xenia/kernel/kernel_state.cc b/src/xenia/kernel/kernel_state.cc index bc10751d7..025fcc990 100644 --- a/src/xenia/kernel/kernel_state.cc +++ b/src/xenia/kernel/kernel_state.cc @@ -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; } } diff --git a/src/xenia/kernel/object_table.cc b/src/xenia/kernel/object_table.cc index 47940a6fb..746821bf0 100644 --- a/src/xenia/kernel/object_table.cc +++ b/src/xenia/kernel/object_table.cc @@ -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 diff --git a/src/xenia/kernel/objects/xevent.cc b/src/xenia/kernel/objects/xevent.cc index ff0b73cc1..e1034d787 100644 --- a/src/xenia/kernel/objects/xevent.cc +++ b/src/xenia/kernel/objects/xevent.cc @@ -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; } diff --git a/src/xenia/kernel/objects/xfile.h b/src/xenia/kernel/objects/xfile.h index 9eafe88fe..61852af41 100644 --- a/src/xenia/kernel/objects/xfile.h +++ b/src/xenia/kernel/objects/xfile.h @@ -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: diff --git a/src/xenia/kernel/objects/xmutant.cc b/src/xenia/kernel/objects/xmutant.cc index 02ff6f27b..99eecc04a 100644 --- a/src/xenia/kernel/objects/xmutant.cc +++ b/src/xenia/kernel/objects/xmutant.cc @@ -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; diff --git a/src/xenia/kernel/objects/xnotify_listener.cc b/src/xenia/kernel/objects/xnotify_listener.cc index 7e9ffb704..2f874c988 100644 --- a/src/xenia/kernel/objects/xnotify_listener.cc +++ b/src/xenia/kernel/objects/xnotify_listener.cc @@ -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); diff --git a/src/xenia/kernel/objects/xsemaphore.cc b/src/xenia/kernel/objects/xsemaphore.cc index 642a88181..c0594e8a2 100644 --- a/src/xenia/kernel/objects/xsemaphore.cc +++ b/src/xenia/kernel/objects/xsemaphore.cc @@ -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. diff --git a/src/xenia/kernel/objects/xthread.cc b/src/xenia/kernel/objects/xthread.cc index d8e4bac85..47566c20d 100644 --- a/src/xenia/kernel/objects/xthread.cc +++ b/src/xenia/kernel/objects/xthread.cc @@ -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. diff --git a/src/xenia/kernel/objects/xtimer.cc b/src/xenia/kernel/objects/xtimer.cc index f38aae6c0..70c8bdd90 100644 --- a/src/xenia/kernel/objects/xtimer.cc +++ b/src/xenia/kernel/objects/xtimer.cc @@ -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. diff --git a/src/xenia/kernel/util/xex2.cc b/src/xenia/kernel/util/xex2.cc index 1aca590e3..50cf442cf 100644 --- a/src/xenia/kernel/util/xex2.cc +++ b/src/xenia/kernel/util/xex2.cc @@ -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, diff --git a/src/xenia/kernel/xam_content.cc b/src/xenia/kernel/xam_content.cc index 5f53bc4ea..4b045c1dd 100644 --- a/src/xenia/kernel/xam_content.cc +++ b/src/xenia/kernel/xam_content.cc @@ -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. diff --git a/src/xenia/kernel/xam_msg.cc b/src/xenia/kernel/xam_msg.cc index 7215e94d1..ded24cee1 100644 --- a/src/xenia/kernel/xam_msg.cc +++ b/src/xenia/kernel/xam_msg.cc @@ -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; } diff --git a/src/xenia/kernel/xam_user.cc b/src/xenia/kernel/xam_user.cc index 005475812..85ebc4835 100644 --- a/src/xenia/kernel/xam_user.cc +++ b/src/xenia/kernel/xam_user.cc @@ -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. diff --git a/src/xenia/kernel/xboxkrnl_audio.cc b/src/xenia/kernel/xboxkrnl_audio.cc index e048dad1a..76495c0bb 100644 --- a/src/xenia/kernel/xboxkrnl_audio.cc +++ b/src/xenia/kernel/xboxkrnl_audio.cc @@ -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); diff --git a/src/xenia/kernel/xboxkrnl_debug.cc b/src/xenia/kernel/xboxkrnl_debug.cc index c0a9e7771..9db006604 100644 --- a/src/xenia/kernel/xboxkrnl_debug.cc +++ b/src/xenia/kernel/xboxkrnl_debug.cc @@ -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); diff --git a/src/xenia/kernel/xboxkrnl_hal.cc b/src/xenia/kernel/xboxkrnl_hal.cc index 9234cbe81..e083ceca5 100644 --- a/src/xenia/kernel/xboxkrnl_hal.cc +++ b/src/xenia/kernel/xboxkrnl_hal.cc @@ -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. diff --git a/src/xenia/kernel/xboxkrnl_io.cc b/src/xenia/kernel/xboxkrnl_io.cc index cb3f4f2ca..2a07b4dbc 100644 --- a/src/xenia/kernel/xboxkrnl_io.cc +++ b/src/xenia/kernel/xboxkrnl_io.cc @@ -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; } diff --git a/src/xenia/kernel/xboxkrnl_memory.cc b/src/xenia/kernel/xboxkrnl_memory.cc index 5b1c8c579..ab153a625 100644 --- a/src/xenia/kernel/xboxkrnl_memory.cc +++ b/src/xenia/kernel/xboxkrnl_memory.cc @@ -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); diff --git a/src/xenia/kernel/xboxkrnl_misc.cc b/src/xenia/kernel/xboxkrnl_misc.cc index 946aa30e9..1354d4806 100644 --- a/src/xenia/kernel/xboxkrnl_misc.cc +++ b/src/xenia/kernel/xboxkrnl_misc.cc @@ -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( diff --git a/src/xenia/kernel/xboxkrnl_modules.cc b/src/xenia/kernel/xboxkrnl_modules.cc index 319cc0ec2..b45724f4a 100644 --- a/src/xenia/kernel/xboxkrnl_modules.cc +++ b/src/xenia/kernel/xboxkrnl_modules.cc @@ -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 diff --git a/src/xenia/kernel/xboxkrnl_rtl.cc b/src/xenia/kernel/xboxkrnl_rtl.cc index f5d00f19a..5b632a6b3 100644 --- a/src/xenia/kernel/xboxkrnl_rtl.cc +++ b/src/xenia/kernel/xboxkrnl_rtl.cc @@ -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 diff --git a/src/xenia/kernel/xboxkrnl_strings.cc b/src/xenia/kernel/xboxkrnl_strings.cc index caccdaf9c..f6815c01e 100644 --- a/src/xenia/kernel/xboxkrnl_strings.cc +++ b/src/xenia/kernel/xboxkrnl_strings.cc @@ -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; diff --git a/src/xenia/kernel/xboxkrnl_threading.cc b/src/xenia/kernel/xboxkrnl_threading.cc index 064f34d7b..8e10a84ce 100644 --- a/src/xenia/kernel/xboxkrnl_threading.cc +++ b/src/xenia/kernel/xboxkrnl_threading.cc @@ -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; diff --git a/src/xenia/kernel/xboxkrnl_video.cc b/src/xenia/kernel/xboxkrnl_video.cc index 6519a067c..fa7d319c1 100644 --- a/src/xenia/kernel/xboxkrnl_video.cc +++ b/src/xenia/kernel/xboxkrnl_video.cc @@ -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; diff --git a/src/xenia/kernel/xboxkrnl_video.h b/src/xenia/kernel/xboxkrnl_video.h index 1a30d0849..6c62811af 100644 --- a/src/xenia/kernel/xboxkrnl_video.h +++ b/src/xenia/kernel/xboxkrnl_video.h @@ -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(); diff --git a/src/xenia/kernel/xobject.cc b/src/xenia/kernel/xobject.cc index 82564c3c2..df99a1d2e 100644 --- a/src/xenia/kernel/xobject.cc +++ b/src/xenia/kernel/xobject.cc @@ -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(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; } diff --git a/src/xenia/logging.h b/src/xenia/logging.h index 9c5579f9a..c030f4465 100644 --- a/src/xenia/logging.h +++ b/src/xenia/logging.h @@ -32,14 +32,14 @@ void xe_handle_fatal( #if XE_OPTION_ENABLE_LOGGING #define XELOGCORE(level, fmt, ...) xe_log_line( \ - XE_CURRENT_FILE, XE_CURRENT_LINE, XE_CURRENT_FUNCTION, level, \ + __FILE__, __LINE__, __FUNCTION__, level, \ fmt, ##__VA_ARGS__) #else #define XELOGCORE(level, fmt, ...) XE_EMPTY_MACRO #endif // ENABLE_LOGGING #define XEFATAL(fmt, ...) do { \ - xe_handle_fatal(XE_CURRENT_FILE, XE_CURRENT_LINE, XE_CURRENT_FUNCTION, \ + xe_handle_fatal(__FILE__, __LINE__, __FUNCTION__, \ fmt, ##__VA_ARGS__); \ } while (false); diff --git a/src/xenia/profiling.h b/src/xenia/profiling.h index 4577dbb8f..3747bbd9b 100644 --- a/src/xenia/profiling.h +++ b/src/xenia/profiling.h @@ -55,7 +55,7 @@ namespace xe { // Enters a CPU profiling scope by function name, active for the duration of // the containing block. No previous definition required. #define SCOPE_profile_cpu_f(group_name) \ - MICROPROFILE_SCOPEI(group_name, XE_CURRENT_FUNCTION, xe::Profiler::GetColor(XE_CURRENT_FUNCTION)) + MICROPROFILE_SCOPEI(group_name, __FUNCTION__, xe::Profiler::GetColor(__FUNCTION__)) // Enters a previously defined GPU profiling scope, active for the duration // of the containing block. @@ -70,7 +70,7 @@ namespace xe { // Enters a GPU profiling scope by function name, active for the duration of // the containing block. No previous definition required. #define SCOPE_profile_gpu_f(group_name) \ - MICROPROFILE_SCOPEGPUI(group_name, XE_CURRENT_FUNCTION, xe::Profiler::GetColor(XE_CURRENT_FUNCTION)) + MICROPROFILE_SCOPEGPUI(group_name, __FUNCTION__, xe::Profiler::GetColor(__FUNCTION__)) // Tracks a CPU value counter. #define COUNT_profile_cpu(name, count) MICROPROFILE_META_CPU(name, count) diff --git a/src/xenia/sources.gypi b/src/xenia/sources.gypi index 4fdccb166..a60ec1749 100644 --- a/src/xenia/sources.gypi +++ b/src/xenia/sources.gypi @@ -1,7 +1,6 @@ # Copyright 2013 Ben Vanik. All Rights Reserved. { 'sources': [ - 'assert.h', 'atomic.h', 'byte_order.h', 'common.h', diff --git a/src/xenia/ui/window.cc b/src/xenia/ui/window.cc index 651423b74..0a37b1f1c 100644 --- a/src/xenia/ui/window.cc +++ b/src/xenia/ui/window.cc @@ -100,7 +100,7 @@ bool Window::OnResize(uint32_t width, uint32_t height) { } void Window::EndResizing() { - XEASSERT(resizing_); + assert_true(resizing_); resizing_ = false; auto e = UIEvent(this); resized(e);