Cleaning up asserts and file/line macros.

2014-07-12 16:51:52 -07:00
parent 840357413c
commit bf882714d0
92 changed files with 636 additions and 613 deletions
--- 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;
      }
--- 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);
--- 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;
--- 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;
    }
--- 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<X64Function*>(fn);
  uint64_t addr = reinterpret_cast<uint64_t>(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<X64Function*>(fn);
  return reinterpret_cast<uint64_t>(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<uint64_t>(symbol_info));
  } else {
--- a/src/alloy/backend/x64/x64_sequence.inl
+++ b/src/alloy/backend/x64/x64_sequence.inl
@@ -133,7 +133,7 @@ struct ValueOp : Op<ValueOp<T, KEY_TYPE, REG_TYPE, CONST_TYPE, TAG>, 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 <int TAG = -1>
 struct I8 : ValueOp<I8<TAG>, 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 <int TAG = -1>
 struct I16 : ValueOp<I16<TAG>, 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 <int TAG = -1>
 struct I32 : ValueOp<I32<TAG>, 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 <int TAG = -1>
 struct I64 : ValueOp<I64<TAG>, 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<I64<TAG>, KEY_TYPE_V_I64, Reg64, int64_t, TAG> {
 template <int TAG = -1>
 struct F32 : ValueOp<F32<TAG>, KEY_TYPE_V_F32, Xmm, float, TAG> {
  const float constant() const {
-    XEASSERT(is_constant);
+    assert_true(is_constant);
    return value->constant.f32;
  }
 };
 template <int TAG = -1>
 struct F64 : ValueOp<F64<TAG>, KEY_TYPE_V_F64, Xmm, double, TAG> {
  const double constant() const {
-    XEASSERT(is_constant);
+    assert_true(is_constant);
    return value->constant.f64;
  }
 };
 template <int TAG = -1>
 struct V128 : ValueOp<V128<TAG>, 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<SingleSequence<SEQ, T>, 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<int32_t>(i.src1.constant()));
@@ -584,7 +584,7 @@ struct SingleSequence : public Sequence<SingleSequence<SEQ, T>, 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<decltype(i.src2)::reg_type>(e);
        e.mov(temp, i.src2);
@@ -632,7 +632,7 @@ struct SingleSequence : public Sequence<SingleSequence<SEQ, T>, 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<SingleSequence<SEQ, T>, 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<SingleSequence<SEQ, T>, 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<int32_t>(i.src1.constant()));
      } else {
@@ -688,7 +688,7 @@ struct SingleSequence : public Sequence<SingleSequence<SEQ, T>, 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<int32_t>(i.src1.constant()), true);
      } else {
--- 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<OPCODE_LOAD_VECTOR_SHL, V128<>, 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<OPCODE_LOAD_VECTOR_SHR, V128<>, 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<OPCODE_DID_CARRY, I8<>, 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<OPCODE_DID_CARRY, I8<>, 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<OPCODE_DID_CARRY, I8<>, 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<OPCODE_DID_CARRY, I8<>, 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<OPCODE_VECTOR_ADD, V128<>, 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<OPCODE_VECTOR_ADD, V128<>, 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<OPCODE_VECTOR_ADD, V128<>, 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<OPCODE_SUB, I64<>, I64<>, I64<>>)) {
 };
 EMITTER(SUB_F32, MATCH(I<OPCODE_SUB, F32<>, 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<OPCODE_SUB, F32<>, F32<>, F32<>>)) {
 };
 EMITTER(SUB_F64, MATCH(I<OPCODE_SUB, F64<>, 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<OPCODE_SUB, F64<>, F64<>, F64<>>)) {
 };
 EMITTER(SUB_V128, MATCH(I<OPCODE_SUB, V128<>, 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<OPCODE_MUL, I8<>, 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<uint8_t>(i.src1.constant()));
      e.mulx(e.edx, i.dest.reg().cvt32(), e.eax);
@@ -2793,7 +2793,7 @@ EMITTER(MUL_I16, MATCH(I<OPCODE_MUL, I16<>, 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<uint16_t>(i.src1.constant()));
      e.mulx(e.edx, i.dest.reg().cvt32(), e.eax);
@@ -2813,7 +2813,7 @@ EMITTER(MUL_I32, MATCH(I<OPCODE_MUL, I32<>, 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<OPCODE_MUL, I64<>, 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<OPCODE_MUL, I64<>, I64<>, I64<>>)) {
 };
 EMITTER(MUL_F32, MATCH(I<OPCODE_MUL, F32<>, 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<OPCODE_MUL, F32<>, F32<>, F32<>>)) {
 };
 EMITTER(MUL_F64, MATCH(I<OPCODE_MUL, F64<>, 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<OPCODE_MUL, F64<>, F64<>, F64<>>)) {
 };
 EMITTER(MUL_V128, MATCH(I<OPCODE_MUL, V128<>, 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<OPCODE_DIV, I8<>, 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<OPCODE_DIV, I16<>, 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<OPCODE_DIV, I32<>, 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<OPCODE_DIV, I64<>, 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<OPCODE_DIV, I64<>, I64<>, I64<>>)) {
 };
 EMITTER(DIV_F32, MATCH(I<OPCODE_DIV, F32<>, 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<OPCODE_DIV, F32<>, F32<>, F32<>>)) {
 };
 EMITTER(DIV_F64, MATCH(I<OPCODE_DIV, F64<>, 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<OPCODE_DIV, F64<>, F64<>, F64<>>)) {
 };
 EMITTER(DIV_V128, MATCH(I<OPCODE_DIV, V128<>, 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<OPCODE_NEG, F64<>, F64<>>)) {
 };
 EMITTER(NEG_V128, MATCH(I<OPCODE_NEG, V128<>, 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<OPCODE_POW2, F32<>, 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<OPCODE_POW2, F64<>, 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<OPCODE_LOG2, F32<>, 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<OPCODE_LOG2, F64<>, 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<OPCODE_VECTOR_SHL, V128<>, V128<>, V128<>>)) {
      EmitInt32(e, i);
      break;
    default:
-      XEASSERTALWAYS();
+      assert_always();
      break;
    }
  }
@@ -3990,7 +3990,7 @@ EMITTER(VECTOR_SHL_V128, MATCH(I<OPCODE_VECTOR_SHL, V128<>, 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<OPCODE_VECTOR_SHL, V128<>, 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<OPCODE_VECTOR_SHR, V128<>, V128<>, V128<>>)) {
      EmitInt32(e, i);
      break;
    default:
-      XEASSERTALWAYS();
+      assert_always();
      break;
    }
  }
@@ -4137,11 +4137,11 @@ EMITTER(VECTOR_SHR_V128, MATCH(I<OPCODE_VECTOR_SHR, V128<>, 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<OPCODE_VECTOR_SHR, V128<>, 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<OPCODE_VECTOR_SHA, V128<>, 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<OPCODE_EXTRACT, I8<>, 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<OPCODE_EXTRACT, F32<>, 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<OPCODE_PERMUTE, V128<>, I32<>, V128<>, V128<>>)) {
      }
    } else {
      // Permute by non-constant.
-      XEASSERTALWAYS();
+      assert_always();
    }
  }
 };
@@ -4650,9 +4650,9 @@ EMITTER(SWIZZLE, MATCH(I<OPCODE_SWIZZLE, V128<>, 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<uint8_t>(i.src2.value);
      swizzle_mask =
@@ -4662,9 +4662,9 @@ EMITTER(SWIZZLE, MATCH(I<OPCODE_SWIZZLE, V128<>, 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<OPCODE_PACK, V128<>, 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<OPCODE_PACK, V128<>, 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<OPCODE_UNPACK, V128<>, 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) {
--- 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:
--- 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);
      }
--- 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.
--- 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;
  //  }
--- 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 <xenia/common.h>
+#include <xenia/atomic.h>
+#include <xenia/byte_order.h>
+#include <xenia/config.h>
+#include <xenia/logging.h>
+#include <xenia/malloc.h>
+#include <xenia/platform.h>
+#include <xenia/profiling.h>
+#include <xenia/string.h>
+#include <xenia/types.h>

 #include <poly/poly.h>

--- 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) {
--- 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
--- 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);
--- 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))));
--- 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);
 }

--- 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;
 }
--- 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) {
--- 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);
--- 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;
 }

--- 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;
    }
  }
--- 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) {
--- 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);