Modified: trunk/Source/_javascript_Core/ftl/FTLOutput.cpp (202006 => 202007)
--- trunk/Source/_javascript_Core/ftl/FTLOutput.cpp 2016-06-13 22:00:49 UTC (rev 202006)
+++ trunk/Source/_javascript_Core/ftl/FTLOutput.cpp 2016-06-13 22:17:50 UTC (rev 202007)
@@ -78,16 +78,136 @@
m_block = block;
}
+LValue Output::framePointer()
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::FramePointer, origin());
+}
+
SlotBaseValue* Output::lockedStackSlot(size_t bytes)
{
return m_block->appendNew<SlotBaseValue>(m_proc, origin(), m_proc.addStackSlot(bytes));
}
+LValue Output::constBool(bool value)
+{
+ return m_block->appendNew<B3::Const32Value>(m_proc, origin(), value);
+}
+
+LValue Output::constInt32(int32_t value)
+{
+ return m_block->appendNew<B3::Const32Value>(m_proc, origin(), value);
+}
+
+LValue Output::constInt64(int64_t value)
+{
+ return m_block->appendNew<B3::Const64Value>(m_proc, origin(), value);
+}
+
+LValue Output::constDouble(double value)
+{
+ return m_block->appendNew<B3::ConstDoubleValue>(m_proc, origin(), value);
+}
+
+LValue Output::phi(LType type)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Phi, type, origin());
+}
+
+LValue Output::add(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Add, origin(), left, right);
+}
+
+LValue Output::sub(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Sub, origin(), left, right);
+}
+
+LValue Output::mul(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Mul, origin(), left, right);
+}
+
+LValue Output::div(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Div, origin(), left, right);
+}
+
+LValue Output::chillDiv(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::ChillDiv, origin(), left, right);
+}
+
+LValue Output::mod(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Mod, origin(), left, right);
+}
+
+LValue Output::chillMod(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::ChillMod, origin(), left, right);
+}
+
LValue Output::neg(LValue value)
{
return m_block->appendNew<Value>(m_proc, B3::Neg, origin(), value);
}
+LValue Output::doubleAdd(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Add, origin(), left, right);
+}
+
+LValue Output::doubleSub(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Sub, origin(), left, right);
+}
+
+LValue Output::doubleMul(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Mul, origin(), left, right);
+}
+
+LValue Output::doubleDiv(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Div, origin(), left, right);
+}
+
+LValue Output::doubleMod(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Mod, origin(), left, right);
+}
+
+LValue Output::bitAnd(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::BitAnd, origin(), left, right);
+}
+
+LValue Output::bitOr(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::BitOr, origin(), left, right);
+}
+
+LValue Output::bitXor(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::BitXor, origin(), left, right);
+}
+
+LValue Output::shl(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Shl, origin(), left, castToInt32(right));
+}
+
+LValue Output::aShr(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::SShr, origin(), left, castToInt32(right));
+}
+
+LValue Output::lShr(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::ZShr, origin(), left, castToInt32(right));
+}
+
LValue Output::bitNot(LValue value)
{
return m_block->appendNew<B3::Value>(m_proc, B3::BitXor, origin(),
@@ -100,13 +220,60 @@
return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), value, int32Zero);
}
-LValue Output::load(TypedPointer pointer, LType type)
+LValue Output::ctlz32(LValue operand)
{
- LValue load = m_block->appendNew<MemoryValue>(m_proc, Load, type, origin(), pointer.value());
- m_heaps->decorateMemory(pointer.heap(), load);
- return load;
+ return m_block->appendNew<B3::Value>(m_proc, B3::Clz, origin(), operand);
}
+LValue Output::doubleAbs(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Abs, origin(), value);
+}
+
+LValue Output::doubleCeil(LValue operand)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Ceil, origin(), operand);
+}
+
+LValue Output::doubleFloor(LValue operand)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Floor, origin(), operand);
+}
+
+LValue Output::doubleTrunc(LValue value)
+{
+ if (MacroAssembler::supportsFloatingPointRounding()) {
+ PatchpointValue* result = patchpoint(Double);
+ result->append(value, ValueRep::SomeRegister);
+ result->setGenerator(
+ [] (CCallHelpers& jit, const StackmapGenerationParams& params) {
+ jit.roundTowardZeroDouble(params[1].fpr(), params[0].fpr());
+ });
+ result->effects = Effects::none();
+ return result;
+ }
+ double (*truncDouble)(double) = trunc;
+ return callWithoutSideEffects(Double, truncDouble, value);
+}
+
+LValue Output::doubleSin(LValue value)
+{
+ double (*sinDouble)(double) = sin;
+ return callWithoutSideEffects(B3::Double, sinDouble, value);
+}
+
+LValue Output::doubleCos(LValue value)
+{
+ double (*cosDouble)(double) = cos;
+ return callWithoutSideEffects(B3::Double, cosDouble, value);
+}
+
+LValue Output::doublePow(LValue xOperand, LValue yOperand)
+{
+ double (*powDouble)(double, double) = pow;
+ return callWithoutSideEffects(B3::Double, powDouble, xOperand, yOperand);
+}
+
LValue Output::doublePowi(LValue x, LValue y)
{
// FIXME: powDoubleInt32() should be inlined here since Output knows about block layout and
@@ -117,6 +284,17 @@
return result.second;
}
+LValue Output::doubleSqrt(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Sqrt, origin(), value);
+}
+
+LValue Output::doubleLog(LValue value)
+{
+ double (*logDouble)(double) = log;
+ return callWithoutSideEffects(B3::Double, logDouble, value);
+}
+
bool Output::hasSensibleDoubleToInt()
{
return optimizeForX86();
@@ -146,27 +324,51 @@
return result;
}
-LValue Output::doubleTrunc(LValue value)
+LValue Output::signExt32To64(LValue value)
{
- if (MacroAssembler::supportsFloatingPointRounding()) {
- PatchpointValue* result = patchpoint(Double);
- result->append(value, ValueRep::SomeRegister);
- result->setGenerator(
- [] (CCallHelpers& jit, const StackmapGenerationParams& params) {
- jit.roundTowardZeroDouble(params[1].fpr(), params[0].fpr());
- });
- result->effects = Effects::none();
- return result;
- }
- double (*truncDouble)(double) = trunc;
- return callWithoutSideEffects(Double, truncDouble, value);
+ return m_block->appendNew<B3::Value>(m_proc, B3::SExt32, origin(), value);
}
+LValue Output::zeroExt(LValue value, LType type)
+{
+ if (value->type() == type)
+ return value;
+ return m_block->appendNew<B3::Value>(m_proc, B3::ZExt32, origin(), value);
+}
+
+LValue Output::intToDouble(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::IToD, origin(), value);
+}
+
LValue Output::unsignedToDouble(LValue value)
{
return intToDouble(zeroExt(value, Int64));
}
+LValue Output::castToInt32(LValue value)
+{
+ return value->type() == B3::Int32 ? value :
+ m_block->appendNew<B3::Value>(m_proc, B3::Trunc, origin(), value);
+}
+
+LValue Output::doubleToFloat(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::DoubleToFloat, origin(), value);
+}
+
+LValue Output::floatToDouble(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::FloatToDouble, origin(), value);
+}
+
+LValue Output::load(TypedPointer pointer, LType type)
+{
+ LValue load = m_block->appendNew<MemoryValue>(m_proc, Load, type, origin(), pointer.value());
+ m_heaps->decorateMemory(pointer.heap(), load);
+ return load;
+}
+
LValue Output::load8SignExt32(TypedPointer pointer)
{
LValue load = m_block->appendNew<MemoryValue>(m_proc, Load8S, Int32, origin(), pointer.value());
@@ -239,6 +441,146 @@
return add(base, accumulatedOffset);
}
+LValue Output::equal(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), left, right);
+}
+
+LValue Output::notEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), left, right);
+}
+
+LValue Output::above(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Above, origin(), left, right);
+}
+
+LValue Output::aboveOrEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::AboveEqual, origin(), left, right);
+}
+
+LValue Output::below(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Below, origin(), left, right);
+}
+
+LValue Output::belowOrEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::BelowEqual, origin(), left, right);
+}
+
+LValue Output::greaterThan(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::GreaterThan, origin(), left, right);
+}
+
+LValue Output::greaterThanOrEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::GreaterEqual, origin(), left, right);
+}
+
+LValue Output::lessThan(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::LessThan, origin(), left, right);
+}
+
+LValue Output::lessThanOrEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::LessEqual, origin(), left, right);
+}
+
+LValue Output::doubleEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), left, right);
+}
+
+LValue Output::doubleEqualOrUnordered(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::EqualOrUnordered, origin(), left, right);
+}
+
+LValue Output::doubleNotEqualOrUnordered(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), left, right);
+}
+
+LValue Output::doubleLessThan(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::LessThan, origin(), left, right);
+}
+
+LValue Output::doubleLessThanOrEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::LessEqual, origin(), left, right);
+}
+
+LValue Output::doubleGreaterThan(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::GreaterThan, origin(), left, right);
+}
+
+LValue Output::doubleGreaterThanOrEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::GreaterEqual, origin(), left, right);
+}
+
+LValue Output::doubleNotEqualAndOrdered(LValue left, LValue right)
+{
+ return logicalNot(doubleEqualOrUnordered(left, right));
+}
+
+LValue Output::doubleLessThanOrUnordered(LValue left, LValue right)
+{
+ return logicalNot(doubleGreaterThanOrEqual(left, right));
+}
+
+LValue Output::doubleLessThanOrEqualOrUnordered(LValue left, LValue right)
+{
+ return logicalNot(doubleGreaterThan(left, right));
+}
+
+LValue Output::doubleGreaterThanOrUnordered(LValue left, LValue right)
+{
+ return logicalNot(doubleLessThanOrEqual(left, right));
+}
+
+LValue Output::doubleGreaterThanOrEqualOrUnordered(LValue left, LValue right)
+{
+ return logicalNot(doubleLessThan(left, right));
+}
+
+LValue Output::isZero32(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), value, int32Zero);
+}
+
+LValue Output::notZero32(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), value, int32Zero);
+}
+
+LValue Output::isZero64(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), value, int64Zero);
+}
+
+LValue Output::notZero64(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), value, int64Zero);
+}
+
+LValue Output::select(LValue value, LValue taken, LValue notTaken)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Select, origin(), value, taken, notTaken);
+}
+
+void Output::jump(LBasicBlock destination)
+{
+ m_block->appendNew<B3::ControlValue>(m_proc, B3::Jump, origin(), B3::FrequentedBlock(destination));
+}
+
void Output::branch(LValue condition, LBasicBlock taken, Weight takenWeight, LBasicBlock notTaken, Weight notTakenWeight)
{
m_block->appendNew<ControlValue>(
@@ -259,6 +601,63 @@
check(condition, taken, taken.weight().inverse());
}
+void Output::ret(LValue value)
+{
+ m_block->appendNew<B3::ControlValue>(m_proc, B3::Return, origin(), value);
+}
+
+void Output::unreachable()
+{
+ m_block->appendNew<B3::ControlValue>(m_proc, B3::Oops, origin());
+}
+
+CheckValue* Output::speculate(LValue value)
+{
+ return m_block->appendNew<B3::CheckValue>(m_proc, B3::Check, origin(), value);
+}
+
+CheckValue* Output::speculateAdd(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::CheckValue>(m_proc, B3::CheckAdd, origin(), left, right);
+}
+
+CheckValue* Output::speculateSub(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::CheckValue>(m_proc, B3::CheckSub, origin(), left, right);
+}
+
+CheckValue* Output::speculateMul(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::CheckValue>(m_proc, B3::CheckMul, origin(), left, right);
+}
+
+PatchpointValue* Output::patchpoint(LType type)
+{
+ return m_block->appendNew<B3::PatchpointValue>(m_proc, type, origin());
+}
+
+void Output::trap()
+{
+ m_block->appendNew<B3::ControlValue>(m_proc, B3::Oops, origin());
+}
+
+ValueFromBlock Output::anchor(LValue value)
+{
+ B3::UpsilonValue* upsilon = m_block->appendNew<B3::UpsilonValue>(m_proc, origin(), value);
+ return ValueFromBlock(upsilon, m_block);
+}
+
+LValue Output::bitCast(LValue value, LType type)
+{
+ ASSERT_UNUSED(type, type == int64 || type == doubleType);
+ return m_block->appendNew<B3::Value>(m_proc, B3::BitwiseCast, origin(), value);
+}
+
+LValue Output::fround(LValue doubleValue)
+{
+ return floatToDouble(doubleToFloat(doubleValue));
+}
+
LValue Output::load(TypedPointer pointer, LoadType type)
{
switch (type) {
Modified: trunk/Source/_javascript_Core/ftl/FTLOutput.h (202006 => 202007)
--- trunk/Source/_javascript_Core/ftl/FTLOutput.h 2016-06-13 22:00:49 UTC (rev 202006)
+++ trunk/Source/_javascript_Core/ftl/FTLOutput.h 2016-06-13 22:17:50 UTC (rev 202007)
@@ -99,20 +99,20 @@
void setOrigin(DFG::Node* node) { m_origin = node; }
B3::Origin origin() { return B3::Origin(m_origin); }
- LValue framePointer() { return m_block->appendNew<B3::Value>(m_proc, B3::FramePointer, origin()); }
+ LValue framePointer();
B3::SlotBaseValue* lockedStackSlot(size_t bytes);
- LValue constBool(bool value) { return m_block->appendNew<B3::Const32Value>(m_proc, origin(), value); }
- LValue constInt32(int32_t value) { return m_block->appendNew<B3::Const32Value>(m_proc, origin(), value); }
+ LValue constBool(bool value);
+ LValue constInt32(int32_t value);
template<typename T>
LValue constIntPtr(T* value) { return m_block->appendNew<B3::ConstPtrValue>(m_proc, origin(), value); }
template<typename T>
LValue constIntPtr(T value) { return m_block->appendNew<B3::ConstPtrValue>(m_proc, origin(), value); }
- LValue constInt64(int64_t value) { return m_block->appendNew<B3::Const64Value>(m_proc, origin(), value); }
- LValue constDouble(double value) { return m_block->appendNew<B3::ConstDoubleValue>(m_proc, origin(), value); }
+ LValue constInt64(int64_t value);
+ LValue constDouble(double value);
- LValue phi(LType type) { return m_block->appendNew<B3::Value>(m_proc, B3::Phi, type, origin()); }
+ LValue phi(LType);
template<typename... Params>
LValue phi(LType, ValueFromBlock, Params... theRest);
template<typename VectorType>
@@ -121,93 +121,61 @@
template<typename... Params>
void addIncomingToPhi(LValue phi, ValueFromBlock, Params... theRest);
- LValue add(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Add, origin(), left, right); }
- LValue sub(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Sub, origin(), left, right); }
- LValue mul(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Mul, origin(), left, right); }
- LValue div(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Div, origin(), left, right); }
- LValue chillDiv(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::ChillDiv, origin(), left, right); }
- LValue mod(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Mod, origin(), left, right); }
- LValue chillMod(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::ChillMod, origin(), left, right); }
+ LValue add(LValue, LValue);
+ LValue sub(LValue, LValue);
+ LValue mul(LValue, LValue);
+ LValue div(LValue, LValue);
+ LValue chillDiv(LValue, LValue);
+ LValue mod(LValue, LValue);
+ LValue chillMod(LValue, LValue);
LValue neg(LValue);
- LValue doubleAdd(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Add, origin(), left, right); }
- LValue doubleSub(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Sub, origin(), left, right); }
- LValue doubleMul(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Mul, origin(), left, right); }
- LValue doubleDiv(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Div, origin(), left, right); }
- LValue doubleMod(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Mod, origin(), left, right); }
+ LValue doubleAdd(LValue, LValue);
+ LValue doubleSub(LValue, LValue);
+ LValue doubleMul(LValue, LValue);
+ LValue doubleDiv(LValue, LValue);
+ LValue doubleMod(LValue, LValue);
LValue doubleNeg(LValue value) { return neg(value); }
- LValue bitAnd(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::BitAnd, origin(), left, right); }
- LValue bitOr(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::BitOr, origin(), left, right); }
- LValue bitXor(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::BitXor, origin(), left, right); }
- LValue shl(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Shl, origin(), left, castToInt32(right)); }
- LValue aShr(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::SShr, origin(), left, castToInt32(right)); }
- LValue lShr(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::ZShr, origin(), left, castToInt32(right)); }
+ LValue bitAnd(LValue, LValue);
+ LValue bitOr(LValue, LValue);
+ LValue bitXor(LValue, LValue);
+ LValue shl(LValue, LValue shiftAmount);
+ LValue aShr(LValue, LValue shiftAmount);
+ LValue lShr(LValue, LValue shiftAmount);
LValue bitNot(LValue);
LValue logicalNot(LValue);
- LValue ctlz32(LValue operand) { return m_block->appendNew<B3::Value>(m_proc, B3::Clz, origin(), operand); }
- LValue addWithOverflow32(LValue left, LValue right) { CRASH(); }
- LValue subWithOverflow32(LValue left, LValue right) { CRASH(); }
- LValue mulWithOverflow32(LValue left, LValue right) { CRASH(); }
- LValue addWithOverflow64(LValue left, LValue right) { CRASH(); }
- LValue subWithOverflow64(LValue left, LValue right) { CRASH(); }
- LValue mulWithOverflow64(LValue left, LValue right) { CRASH(); }
- LValue doubleAbs(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::Abs, origin(), value); }
- LValue doubleCeil(LValue operand) { return m_block->appendNew<B3::Value>(m_proc, B3::Ceil, origin(), operand); }
- LValue doubleFloor(LValue operand) { return m_block->appendNew<B3::Value>(m_proc, B3::Floor, origin(), operand); }
+ LValue ctlz32(LValue);
+ LValue doubleAbs(LValue);
+ LValue doubleCeil(LValue);
+ LValue doubleFloor(LValue);
LValue doubleTrunc(LValue);
- LValue doubleSin(LValue value)
- {
- double (*sinDouble)(double) = sin;
- return callWithoutSideEffects(B3::Double, sinDouble, value);
- }
- LValue doubleCos(LValue value)
- {
- double (*cosDouble)(double) = cos;
- return callWithoutSideEffects(B3::Double, cosDouble, value);
- }
+ LValue doubleSin(LValue);
+ LValue doubleCos(LValue);
- LValue doublePow(LValue xOperand, LValue yOperand)
- {
- double (*powDouble)(double, double) = pow;
- return callWithoutSideEffects(B3::Double, powDouble, xOperand, yOperand);
- }
+ LValue doublePow(LValue base, LValue exponent);
+ LValue doublePowi(LValue base, LValue exponent);
- LValue doublePowi(LValue xOperand, LValue yOperand);
+ LValue doubleSqrt(LValue);
- LValue doubleSqrt(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::Sqrt, origin(), value); }
+ LValue doubleLog(LValue);
- LValue doubleLog(LValue value)
- {
- double (*logDouble)(double) = log;
- return callWithoutSideEffects(B3::Double, logDouble, value);
- }
-
static bool hasSensibleDoubleToInt();
LValue doubleToInt(LValue);
LValue doubleToUInt(LValue);
- LValue signExt32To64(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::SExt32, origin(), value); }
- LValue zeroExt(LValue value, LType type)
- {
- if (value->type() == type)
- return value;
- return m_block->appendNew<B3::Value>(m_proc, B3::ZExt32, origin(), value);
- }
+ LValue signExt32To64(LValue);
+ LValue zeroExt(LValue, LType);
LValue zeroExtPtr(LValue value) { return zeroExt(value, B3::Int64); }
- LValue intToDouble(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::IToD, origin(), value); }
+ LValue intToDouble(LValue);
LValue unsignedToDouble(LValue);
- LValue castToInt32(LValue value)
- {
- return value->type() == B3::Int32 ? value :
- m_block->appendNew<B3::Value>(m_proc, B3::Trunc, origin(), value);
- }
- LValue doubleToFloat(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::DoubleToFloat, origin(), value); }
- LValue floatToDouble(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::FloatToDouble, origin(), value); }
+ LValue castToInt32(LValue);
+ LValue doubleToFloat(LValue);
+ LValue floatToDouble(LValue);
LValue bitCast(LValue, LType);
- LValue fround(LValue doubleValue);
+ LValue fround(LValue);
LValue load(TypedPointer, LType);
void store(LValue, TypedPointer);
@@ -221,8 +189,8 @@
LValue loadPtr(TypedPointer pointer) { return load(pointer, B3::pointerType()); }
LValue loadFloat(TypedPointer pointer) { return load(pointer, B3::Float); }
LValue loadDouble(TypedPointer pointer) { return load(pointer, B3::Double); }
- void store32As8(LValue value, TypedPointer pointer);
- void store32As16(LValue value, TypedPointer pointer);
+ void store32As8(LValue, TypedPointer);
+ void store32As16(LValue, TypedPointer);
void store32(LValue value, TypedPointer pointer)
{
ASSERT(value->type() == B3::Int32);
@@ -330,34 +298,34 @@
LValue load32NonNegative(TypedPointer pointer) { return load32(pointer); }
LValue load32NonNegative(LValue base, const AbstractHeap& field) { return load32(base, field); }
- LValue equal(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), left, right); }
- LValue notEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), left, right); }
- LValue above(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Above, origin(), left, right); }
- LValue aboveOrEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::AboveEqual, origin(), left, right); }
- LValue below(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Below, origin(), left, right); }
- LValue belowOrEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::BelowEqual, origin(), left, right); }
- LValue greaterThan(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::GreaterThan, origin(), left, right); }
- LValue greaterThanOrEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::GreaterEqual, origin(), left, right); }
- LValue lessThan(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::LessThan, origin(), left, right); }
- LValue lessThanOrEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::LessEqual, origin(), left, right); }
+ LValue equal(LValue, LValue);
+ LValue notEqual(LValue, LValue);
+ LValue above(LValue, LValue);
+ LValue aboveOrEqual(LValue, LValue);
+ LValue below(LValue, LValue);
+ LValue belowOrEqual(LValue, LValue);
+ LValue greaterThan(LValue, LValue);
+ LValue greaterThanOrEqual(LValue, LValue);
+ LValue lessThan(LValue, LValue);
+ LValue lessThanOrEqual(LValue, LValue);
- LValue doubleEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), left, right); }
- LValue doubleEqualOrUnordered(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::EqualOrUnordered, origin(), left, right); }
- LValue doubleNotEqualOrUnordered(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), left, right); }
- LValue doubleLessThan(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::LessThan, origin(), left, right); }
- LValue doubleLessThanOrEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::LessEqual, origin(), left, right); }
- LValue doubleGreaterThan(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::GreaterThan, origin(), left, right); }
- LValue doubleGreaterThanOrEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::GreaterEqual, origin(), left, right); }
- LValue doubleNotEqualAndOrdered(LValue left, LValue right) { return logicalNot(doubleEqualOrUnordered(left, right)); }
- LValue doubleLessThanOrUnordered(LValue left, LValue right) { return logicalNot(doubleGreaterThanOrEqual(left, right)); }
- LValue doubleLessThanOrEqualOrUnordered(LValue left, LValue right) { return logicalNot(doubleGreaterThan(left, right)); }
- LValue doubleGreaterThanOrUnordered(LValue left, LValue right) { return logicalNot(doubleLessThanOrEqual(left, right)); }
- LValue doubleGreaterThanOrEqualOrUnordered(LValue left, LValue right) { return logicalNot(doubleLessThan(left, right)); }
+ LValue doubleEqual(LValue, LValue);
+ LValue doubleEqualOrUnordered(LValue, LValue);
+ LValue doubleNotEqualOrUnordered(LValue, LValue);
+ LValue doubleLessThan(LValue, LValue);
+ LValue doubleLessThanOrEqual(LValue, LValue);
+ LValue doubleGreaterThan(LValue, LValue);
+ LValue doubleGreaterThanOrEqual(LValue, LValue);
+ LValue doubleNotEqualAndOrdered(LValue, LValue);
+ LValue doubleLessThanOrUnordered(LValue, LValue);
+ LValue doubleLessThanOrEqualOrUnordered(LValue, LValue);
+ LValue doubleGreaterThanOrUnordered(LValue, LValue);
+ LValue doubleGreaterThanOrEqualOrUnordered(LValue, LValue);
- LValue isZero32(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), value, int32Zero); }
- LValue notZero32(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), value, int32Zero); }
- LValue isZero64(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), value, int64Zero); }
- LValue notZero64(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), value, int64Zero); }
+ LValue isZero32(LValue);
+ LValue notZero32(LValue);
+ LValue isZero64(LValue);
+ LValue notZero64(LValue);
LValue isNull(LValue value) { return isZero64(value); }
LValue notNull(LValue value) { return notZero64(value); }
@@ -368,8 +336,7 @@
LValue testIsZeroPtr(LValue value, LValue mask) { return isNull(bitAnd(value, mask)); }
LValue testNonZeroPtr(LValue value, LValue mask) { return notNull(bitAnd(value, mask)); }
- LValue select(LValue value, LValue taken, LValue notTaken) { return m_block->appendNew<B3::Value>(m_proc, B3::Select, origin(), value, taken, notTaken); }
- LValue extractValue(LValue aggVal, unsigned index) { CRASH(); }
+ LValue select(LValue value, LValue taken, LValue notTaken);
template<typename VectorType>
LValue call(LType type, LValue function, const VectorType& vector)
@@ -394,7 +361,7 @@
template<typename FunctionType>
LValue operation(FunctionType function) { return constIntPtr(bitwise_cast<void*>(function)); }
- void jump(LBasicBlock destination) { m_block->appendNew<B3::ControlValue>(m_proc, B3::Jump, origin(), B3::FrequentedBlock(destination)); }
+ void jump(LBasicBlock);
void branch(LValue condition, LBasicBlock taken, Weight takenWeight, LBasicBlock notTaken, Weight notTakenWeight);
void branch(LValue condition, WeightedTarget taken, WeightedTarget notTaken)
{
@@ -420,46 +387,21 @@
}
}
- void ret(LValue value) { m_block->appendNew<B3::ControlValue>(m_proc, B3::Return, origin(), value); }
+ void ret(LValue);
- void unreachable() { m_block->appendNew<B3::ControlValue>(m_proc, B3::Oops, origin()); }
+ void unreachable();
- B3::CheckValue* speculate(LValue value)
- {
- return m_block->appendNew<B3::CheckValue>(m_proc, B3::Check, origin(), value);
- }
+ B3::CheckValue* speculate(LValue);
+ B3::CheckValue* speculateAdd(LValue, LValue);
+ B3::CheckValue* speculateSub(LValue, LValue);
+ B3::CheckValue* speculateMul(LValue, LValue);
- B3::CheckValue* speculateAdd(LValue left, LValue right)
- {
- return m_block->appendNew<B3::CheckValue>(m_proc, B3::CheckAdd, origin(), left, right);
- }
+ B3::PatchpointValue* patchpoint(LType);
- B3::CheckValue* speculateSub(LValue left, LValue right)
- {
- return m_block->appendNew<B3::CheckValue>(m_proc, B3::CheckSub, origin(), left, right);
- }
+ void trap();
- B3::CheckValue* speculateMul(LValue left, LValue right)
- {
- return m_block->appendNew<B3::CheckValue>(m_proc, B3::CheckMul, origin(), left, right);
- }
+ ValueFromBlock anchor(LValue);
- B3::PatchpointValue* patchpoint(LType type)
- {
- return m_block->appendNew<B3::PatchpointValue>(m_proc, type, origin());
- }
-
- void trap()
- {
- m_block->appendNew<B3::ControlValue>(m_proc, B3::Oops, origin());
- }
-
- ValueFromBlock anchor(LValue value)
- {
- B3::UpsilonValue* upsilon = m_block->appendNew<B3::UpsilonValue>(m_proc, origin(), value);
- return ValueFromBlock(upsilon, m_block);
- }
-
void incrementSuperSamplerCount();
void decrementSuperSamplerCount();
@@ -509,17 +451,6 @@
addIncomingToPhi(phi, theRest...);
}
-inline LValue Output::bitCast(LValue value, LType type)
-{
- ASSERT_UNUSED(type, type == int64 || type == doubleType);
- return m_block->appendNew<B3::Value>(m_proc, B3::BitwiseCast, origin(), value);
-}
-
-inline LValue Output::fround(LValue doubleValue)
-{
- return floatToDouble(doubleToFloat(doubleValue));
-}
-
#if COMPILER(GCC_OR_CLANG)
#pragma GCC diagnostic pop
#endif // COMPILER(GCC_OR_CLANG)
