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

Cleaning up asserts and file/line macros.

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

2
src/alloy/frontend/ppc/ppc_disasm.cc
View File

@@ -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) {

2
src/alloy/frontend/ppc/ppc_emit-private.h
View File

@@ -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

24
src/alloy/frontend/ppc/ppc_emit_altivec.cc
View File

@@ -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);

32
src/alloy/frontend/ppc/ppc_emit_alu.cc
View File

@@ -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))));

22
src/alloy/frontend/ppc/ppc_hir_builder.cc
View File

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

6
src/alloy/frontend/ppc/ppc_instr.cc
View File

@@ -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;
}