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

Basic constant propagation.

Browse Source
This commit is contained in:
Ben Vanik
2013-12-07 05:52:51 -08:00
parent 57432d5996
commit 3b268f07ef
10 changed files with 584 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
src/alloy/hir/function_builder.cc
View File

@@ -1024,21 +1024,6 @@ Value* FunctionBuilder::AddWithCarry(
uint32_t arithmetic_flags) {
ASSERT_TYPES_EQUAL(value1, value2);
XEASSERT(value3->type == INT8_TYPE);
// TODO(benvanik): optimize when flags set.
if (!arithmetic_flags) {
if (value3->IsConstantZero()) {
return Add(value1, value2);
} else if (value1->IsConstantZero()) {
return Add(value2, value3);
} else if (value2->IsConstantZero()) {
return Add(value1, value3);
} else if (value1->IsConstant() && value2->IsConstant()) {
Value* dest = CloneValue(value1);
dest->Add(value2);
return Add(dest, value3);
}
}
Instr* i = AppendInstr(
OPCODE_ADD_CARRY_info, arithmetic_flags,
@@ -1053,19 +1038,6 @@ Value* FunctionBuilder::Sub(
Value* value1, Value* value2, uint32_t arithmetic_flags) {
ASSERT_TYPES_EQUAL(value1, value2);
// TODO(benvanik): optimize when flags set.
if (!arithmetic_flags) {
if (value1->IsConstantZero()) {
return Neg(value1);
} else if (value2->IsConstantZero()) {
return value1;
} else if (value1->IsConstant() && value2->IsConstant()) {
Value* dest = CloneValue(value1);
dest->Sub(value2);
return dest;
}
}
Instr* i = AppendInstr(
OPCODE_SUB_info, arithmetic_flags,
AllocValue(value1->type));
@@ -1078,12 +1050,6 @@ Value* FunctionBuilder::Sub(
Value* FunctionBuilder::Mul(Value* value1, Value* value2) {
ASSERT_TYPES_EQUAL(value1, value2);
if (value1->IsConstant() && value2->IsConstant()) {
Value* dest = CloneValue(value1);
dest->Mul(value2);
return dest;
}
Instr* i = AppendInstr(
OPCODE_MUL_info, 0,
AllocValue(value1->type));
@@ -1096,12 +1062,6 @@ Value* FunctionBuilder::Mul(Value* value1, Value* value2) {
Value* FunctionBuilder::Div(Value* value1, Value* value2) {
ASSERT_TYPES_EQUAL(value1, value2);
if (value1->IsConstant() && value2->IsConstant()) {
Value* dest = CloneValue(value1);
dest->Div(value2);
return dest;
}
Instr* i = AppendInstr(
OPCODE_DIV_info, 0,
AllocValue(value1->type));
@@ -1114,12 +1074,6 @@ Value* FunctionBuilder::Div(Value* value1, Value* value2) {
Value* FunctionBuilder::Rem(Value* value1, Value* value2) {
ASSERT_TYPES_EQUAL(value1, value2);
if (value1->IsConstant() && value2->IsConstant()) {
Value* dest = CloneValue(value1);
dest->Rem(value2);
return dest;
}
Instr* i = AppendInstr(
OPCODE_REM_info, 0,
AllocValue(value1->type));
@@ -1135,12 +1089,7 @@ Value* FunctionBuilder::MulAdd(Value* value1, Value* value2, Value* value3) {
bool c1 = value1->IsConstant();
bool c2 = value2->IsConstant();
bool c3 = value3->IsConstant();
if (c1 && c2 && c3) {
Value* dest = AllocValue(value1->type);
Value::MulAdd(dest, value1, value2, value3);
return dest;
} else if (c1 && c2) {
if (c1 && c2) {
Value* dest = CloneValue(value1);
dest->Mul(value2);
return Add(dest, value3);
@@ -1161,12 +1110,7 @@ Value* FunctionBuilder::MulSub(Value* value1, Value* value2, Value* value3) {
bool c1 = value1->IsConstant();
bool c2 = value2->IsConstant();
bool c3 = value3->IsConstant();
if (c1 && c2 && c3) {
Value* dest = AllocValue(value1->type);
Value::MulSub(dest, value1, value2, value3);
return dest;
} else if (c1 && c2) {
if (c1 && c2) {
Value* dest = CloneValue(value1);
dest->Mul(value2);
return Sub(dest, value3);
@@ -1184,12 +1128,6 @@ Value* FunctionBuilder::MulSub(Value* value1, Value* value2, Value* value3) {
Value* FunctionBuilder::Neg(Value* value) {
ASSERT_NON_VECTOR_TYPE(value);
if (value->IsConstant()) {
Value* dest = CloneValue(value);
dest->Neg();
return dest;
}
Instr* i = AppendInstr(
OPCODE_NEG_info, 0,
AllocValue(value->type));
@@ -1201,12 +1139,6 @@ Value* FunctionBuilder::Neg(Value* value) {
Value* FunctionBuilder::Abs(Value* value) {
ASSERT_NON_VECTOR_TYPE(value);
if (value->IsConstant()) {
Value* dest = CloneValue(value);
dest->Abs();
return dest;
}
Instr* i = AppendInstr(
OPCODE_ABS_info, 0,
AllocValue(value->type));
@@ -1218,12 +1150,6 @@ Value* FunctionBuilder::Abs(Value* value) {
Value* FunctionBuilder::Sqrt(Value* value) {
ASSERT_FLOAT_TYPE(value);
if (value->IsConstant()) {
Value* dest = CloneValue(value);
dest->Sqrt();
return dest;
}
Instr* i = AppendInstr(
OPCODE_SQRT_info, 0,
AllocValue(value->type));
@@ -1276,14 +1202,12 @@ Value* FunctionBuilder::And(Value* value1, Value* value2) {
ASSERT_INTEGER_TYPE(value2);
ASSERT_TYPES_EQUAL(value1, value2);
if (value1->IsConstantZero()) {
if (value1 == value2) {
return value1;
} else if (value1->IsConstantZero()) {
return value1;
} else if (value2->IsConstantZero()) {
return value2;
} else if (value1->IsConstant() && value2->IsConstant()) {
Value* dest = CloneValue(value1);
dest->And(value2);
return dest;
}
Instr* i = AppendInstr(
@@ -1300,14 +1224,12 @@ Value* FunctionBuilder::Or(Value* value1, Value* value2) {
ASSERT_INTEGER_TYPE(value2);
ASSERT_TYPES_EQUAL(value1, value2);
if (value1->IsConstantZero()) {
if (value1 == value2) {
return value1;
} else if (value1->IsConstantZero()) {
return value2;
} else if (value2->IsConstantZero()) {
return value1;
} else if (value1->IsConstant() && value2->IsConstant()) {
Value* dest = CloneValue(value1);
dest->Or(value2);
return dest;
}
Instr* i = AppendInstr(
@@ -1324,10 +1246,8 @@ Value* FunctionBuilder::Xor(Value* value1, Value* value2) {
ASSERT_INTEGER_TYPE(value2);
ASSERT_TYPES_EQUAL(value1, value2);
if (value1->IsConstant() && value2->IsConstant()) {
Value* dest = CloneValue(value1);
dest->Xor(value2);
return dest;
if (value1 == value2) {
return LoadZero(value1->type);
}
Instr* i = AppendInstr(
@@ -1368,11 +1288,6 @@ Value* FunctionBuilder::Shl(Value* value1, Value* value2) {
if (value2->type != INT8_TYPE) {
value2 = Truncate(value2, INT8_TYPE);
}
if (value1->IsConstant() && value2->IsConstant()) {
Value* dest = CloneValue(value1);
dest->Shl(value2);
return dest;
}
Instr* i = AppendInstr(
OPCODE_SHL_info, 0,
@@ -1410,11 +1325,6 @@ Value* FunctionBuilder::Shr(Value* value1, Value* value2) {
if (value2->type != INT8_TYPE) {
value2 = Truncate(value2, INT8_TYPE);
}
if (value1->IsConstant() && value2->IsConstant()) {
Value* dest = CloneValue(value1);
dest->Shr(value2);
return dest;
}
Instr* i = AppendInstr(
OPCODE_SHR_info, 0,
@@ -1438,11 +1348,6 @@ Value* FunctionBuilder::Sha(Value* value1, Value* value2) {
if (value2->type != INT8_TYPE) {
value2 = Truncate(value2, INT8_TYPE);
}
if (value1->IsConstant() && value2->IsConstant()) {
Value* dest = CloneValue(value1);
dest->Sha(value2);
return dest;
}
Instr* i = AppendInstr(
OPCODE_SHA_info, 0,
@@ -1481,11 +1386,6 @@ Value* FunctionBuilder::ByteSwap(Value* value) {
if (value->type == INT8_TYPE) {
return value;
}
if (value->IsConstant()) {
Value* dest = CloneValue(value);
dest->ByteSwap();
return dest;
}
Instr* i = AppendInstr(
OPCODE_BYTE_SWAP_info, 0,

1
src/alloy/hir/instr.cc
View File

@@ -50,7 +50,6 @@ void Instr::set_src3(Value* value) {
void Instr::Remove() {
if (dest) {
XEASSERT(!dest->use_head);
dest->def = NULL;
}
if (src1_use) {

339
src/alloy/hir/value.cc
View File

@@ -122,23 +122,111 @@ void Value::Round(RoundMode round_mode) {
}
void Value::Add(Value* other) {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
XEASSERT(type == other->type);
switch (type) {
case INT8_TYPE:
constant.i8 += other->constant.i8;
break;
case INT16_TYPE:
constant.i16 += other->constant.i16;
break;
case INT32_TYPE:
constant.i32 += other->constant.i32;
break;
case INT64_TYPE:
constant.i64 += other->constant.i64;
break;
case FLOAT32_TYPE:
constant.f32 += other->constant.f32;
break;
case FLOAT64_TYPE:
constant.f64 += other->constant.f64;
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::Sub(Value* other) {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
XEASSERT(type == other->type);
switch (type) {
case INT8_TYPE:
constant.i8 -= other->constant.i8;
break;
case INT16_TYPE:
constant.i16 -= other->constant.i16;
break;
case INT32_TYPE:
constant.i32 -= other->constant.i32;
break;
case INT64_TYPE:
constant.i64 -= other->constant.i64;
break;
case FLOAT32_TYPE:
constant.f32 -= other->constant.f32;
break;
case FLOAT64_TYPE:
constant.f64 -= other->constant.f64;
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::Mul(Value* other) {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
XEASSERT(type == other->type);
switch (type) {
case INT8_TYPE:
constant.i8 *= other->constant.i8;
break;
case INT16_TYPE:
constant.i16 *= other->constant.i16;
break;
case INT32_TYPE:
constant.i32 *= other->constant.i32;
break;
case INT64_TYPE:
constant.i64 *= other->constant.i64;
break;
case FLOAT32_TYPE:
constant.f32 *= other->constant.f32;
break;
case FLOAT64_TYPE:
constant.f64 *= other->constant.f64;
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::Div(Value* other) {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
XEASSERT(type == other->type);
switch (type) {
case INT8_TYPE:
constant.i8 /= other->constant.i8;
break;
case INT16_TYPE:
constant.i16 /= other->constant.i16;
break;
case INT32_TYPE:
constant.i32 /= other->constant.i32;
break;
case INT64_TYPE:
constant.i64 /= other->constant.i64;
break;
case FLOAT32_TYPE:
constant.f32 /= other->constant.f32;
break;
case FLOAT64_TYPE:
constant.f64 /= other->constant.f64;
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::Rem(Value* other) {
@@ -157,58 +245,249 @@ void Value::MulSub(Value* dest, Value* value1, Value* value2, Value* value3) {
}
void Value::Neg() {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
switch (type) {
case INT8_TYPE:
constant.i8 = -constant.i8;
break;
case INT16_TYPE:
constant.i16 = -constant.i16;
break;
case INT32_TYPE:
constant.i32 = -constant.i32;
break;
case INT64_TYPE:
constant.i64 = -constant.i64;
break;
case FLOAT32_TYPE:
constant.f32 = -constant.f32;
break;
case FLOAT64_TYPE:
constant.f64 = -constant.f64;
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::Abs() {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
switch (type) {
case INT8_TYPE:
constant.i8 = abs(constant.i8);
break;
case INT16_TYPE:
constant.i16 = abs(constant.i16);
break;
case INT32_TYPE:
constant.i32 = abs(constant.i32);
break;
case INT64_TYPE:
constant.i64 = abs(constant.i64);
break;
case FLOAT32_TYPE:
constant.f32 = abs(constant.f32);
break;
case FLOAT64_TYPE:
constant.f64 = abs(constant.f64);
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::Sqrt() {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
switch (type) {
case FLOAT32_TYPE:
constant.f32 = 1.0f / sqrtf(constant.f32);
break;
case FLOAT64_TYPE:
constant.f64 = 1.0 / sqrt(constant.f64);
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::RSqrt() {
switch (type) {
case FLOAT32_TYPE:
constant.f32 = sqrt(constant.f32);
break;
case FLOAT64_TYPE:
constant.f64 = sqrt(constant.f64);
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::And(Value* other) {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
XEASSERT(type == other->type);
switch (type) {
case INT8_TYPE:
constant.i8 &= other->constant.i8;
break;
case INT16_TYPE:
constant.i16 &= other->constant.i16;
break;
case INT32_TYPE:
constant.i32 &= other->constant.i32;
break;
case INT64_TYPE:
constant.i64 &= other->constant.i64;
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::Or(Value* other) {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
XEASSERT(type == other->type);
switch (type) {
case INT8_TYPE:
constant.i8 |= other->constant.i8;
break;
case INT16_TYPE:
constant.i16 |= other->constant.i16;
break;
case INT32_TYPE:
constant.i32 |= other->constant.i32;
break;
case INT64_TYPE:
constant.i64 |= other->constant.i64;
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::Xor(Value* other) {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
XEASSERT(type == other->type);
switch (type) {
case INT8_TYPE:
constant.i8 ^= other->constant.i8;
break;
case INT16_TYPE:
constant.i16 ^= other->constant.i16;
break;
case INT32_TYPE:
constant.i32 ^= other->constant.i32;
break;
case INT64_TYPE:
constant.i64 ^= other->constant.i64;
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::Not() {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
switch (type) {
case INT8_TYPE:
constant.i8 = ~constant.i8;
break;
case INT16_TYPE:
constant.i16 = ~constant.i16;
break;
case INT32_TYPE:
constant.i32 = ~constant.i32;
break;
case INT64_TYPE:
constant.i64 = ~constant.i64;
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::Shl(Value* other) {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
XEASSERT(type == other->type);
switch (type) {
case INT8_TYPE:
constant.i8 <<= other->constant.i8;
break;
case INT16_TYPE:
constant.i16 <<= other->constant.i16;
break;
case INT32_TYPE:
constant.i32 <<= other->constant.i32;
break;
case INT64_TYPE:
constant.i64 <<= other->constant.i64;
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::Shr(Value* other) {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
XEASSERT(type == other->type);
switch (type) {
case INT8_TYPE:
constant.i8 = (uint8_t)constant.i8 >> other->constant.i8;
break;
case INT16_TYPE:
constant.i16 = (uint16_t)constant.i16 >> other->constant.i8;
break;
case INT32_TYPE:
constant.i32 = (uint32_t)constant.i32 >> other->constant.i8;
break;
case INT64_TYPE:
constant.i64 = (uint16_t)constant.i64 >> other->constant.i8;
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::Sha(Value* other) {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
XEASSERT(type == other->type);
switch (type) {
case INT8_TYPE:
constant.i8 = constant.i8 >> other->constant.i8;
break;
case INT16_TYPE:
constant.i16 = constant.i16 >> other->constant.i8;
break;
case INT32_TYPE:
constant.i32 = constant.i32 >> other->constant.i8;
break;
case INT64_TYPE:
constant.i64 = constant.i64 >> other->constant.i8;
break;
default:
XEASSERTALWAYS();
break;
}
}
void Value::ByteSwap() {
// TODO(benvanik): big matrix.
XEASSERTALWAYS();
switch (type) {
case INT8_TYPE:
constant.i8 = constant.i8;
break;
case INT16_TYPE:
constant.i16 = XESWAP16(constant.i16);
break;
case INT32_TYPE:
constant.i32 = XESWAP32(constant.i32);
break;
case INT64_TYPE:
constant.i64 = XESWAP64(constant.i64);
break;
default:
XEASSERTALWAYS();
break;
}
}
bool Value::Compare(Opcode opcode, Value* other) {

6
src/alloy/hir/value.h
View File

@@ -128,6 +128,11 @@ public:
flags |= VALUE_IS_CONSTANT;
constant.v128 = value;
}
void set_from(const Value* other) {
type = other->type;
flags = other->flags;
constant.v128 = other->constant.v128;
}
inline bool IsConstant() const {
return !!(flags & VALUE_IS_CONSTANT);
@@ -184,6 +189,7 @@ public:
void Neg();
void Abs();
void Sqrt();
void RSqrt();
void And(Value* other);
void Or(Value* other);
void Xor(Value* other);