IRType GlobOpt::GetIRTypeFromValueType(const ValueType &valueType)
{
if (valueType.IsFloat())
{
return TyFloat64;
}
else if (valueType.IsInt())
{
return TyInt32;
}
else if (valueType.IsSimd128Float32x4())
{
return TySimd128F4;
}
else
{
Assert(valueType.IsSimd128Int32x4());
return TySimd128I4;
}
}
IR::BailOutKind GlobOpt::GetBailOutKindFromValueType(const ValueType &valueType)
{
if (valueType.IsFloat())
{
// if required valueType is Float, then allow coercion from any primitive except String.
return IR::BailOutPrimitiveButString;
}
else if (valueType.IsInt())
{
return IR::BailOutIntOnly;
}
else if (valueType.IsSimd128Float32x4())
{
return IR::BailOutSimd128F4Only;
}
else
{
Assert(valueType.IsSimd128Int32x4());
return IR::BailOutSimd128I4Only;
}
}
bool
GlobOpt::Simd128DoTypeSpec(IR::Instr *instr, const Value *src1Val, const Value *src2Val, const Value *dstVal)
{
bool doTypeSpec = true;
// TODO: Some operations require additional opnd constraints (e.g. shuffle/swizzle).
if (Js::IsSimd128Opcode(instr->m_opcode))
{
ThreadContext::SimdFuncSignature simdFuncSignature;
instr->m_func->GetScriptContext()->GetThreadContext()->GetSimdFuncSignatureFromOpcode(instr->m_opcode, simdFuncSignature);
if (!simdFuncSignature.valid)
{
// not implemented yet.
return false;
}
// special handling for Load/Store
if (Js::IsSimd128Load(instr->m_opcode) || Js::IsSimd128Store(instr->m_opcode))
{
return Simd128DoTypeSpecLoadStore(instr, src1Val, src2Val, dstVal, &simdFuncSignature);
}
const uint argCount = simdFuncSignature.argCount;
switch (argCount)
{
case 2:
Assert(src2Val);
doTypeSpec = doTypeSpec && Simd128CanTypeSpecOpnd(src2Val->GetValueInfo()->Type(), simdFuncSignature.args[1]) && Simd128ValidateIfLaneIndex(instr, instr->GetSrc2(), 1);
// fall-through
case 1:
Assert(src1Val);
doTypeSpec = doTypeSpec && Simd128CanTypeSpecOpnd(src1Val->GetValueInfo()->Type(), simdFuncSignature.args[0]) && Simd128ValidateIfLaneIndex(instr, instr->GetSrc1(), 0);
break;
default:
{
// extended args
Assert(argCount > 2);
// Check if all args have been type specialized.
int arg = argCount - 1;
IR::Instr * eaInstr = GetExtendedArg(instr);
while (arg>=0)
{
Assert(eaInstr);
Assert(eaInstr->m_opcode == Js::OpCode::ExtendArg_A);
ValueType expectedType = simdFuncSignature.args[arg];
IR::Opnd * opnd = eaInstr->GetSrc1();
StackSym * sym = opnd->GetStackSym();
// In Forward Prepass: Check liveness through liveness bits, not IR type, since in prepass no actual type-spec happens.
// In the Forward Pass: Check IRType since Sym can be null, because of const prop.
if (expectedType.IsSimd128Float32x4())
{
if (sym && !IsSimd128F4TypeSpecialized(sym, ¤tBlock->globOptData) ||
!sym && opnd->GetType() != TySimd128F4)
{
return false;
}
}
else if (expectedType.IsSimd128Int32x4())
{
if (sym && !IsSimd128I4TypeSpecialized(sym, ¤tBlock->globOptData) ||
!sym && opnd->GetType() != TySimd128I4)
{
return false;
}
}
else if (expectedType.IsFloat())
{
if (sym && !IsFloat64TypeSpecialized(sym, ¤tBlock->globOptData) ||
!sym&& opnd->GetType() != TyFloat64)
{
return false;
}
}
else if (expectedType.IsInt())
{
if ((sym && !IsInt32TypeSpecialized(sym, ¤tBlock->globOptData) && !currentBlock->globOptData.liveLossyInt32Syms->Test(sym->m_id)) ||
!sym && opnd->GetType() != TyInt32)
{
return false;
}
// Extra check if arg is a lane index
if (!Simd128ValidateIfLaneIndex(instr, opnd, arg))
{
return false;
}
}
else
{
Assert(UNREACHED);
}
eaInstr = GetExtendedArg(eaInstr);
arg--;
}
// all args are type-spec'd
doTypeSpec = true;
}
}
}
else
{
Assert(instr->m_opcode == Js::OpCode::ExtendArg_A);
// For ExtendArg, the expected type is encoded in the dst(link) operand.
doTypeSpec = doTypeSpec && Simd128CanTypeSpecOpnd(src1Val->GetValueInfo()->Type(), instr->GetDst()->GetValueType());
}
return doTypeSpec;
}
bool
GlobOpt::Simd128DoTypeSpecLoadStore(IR::Instr *instr, const Value *src1Val, const Value *src2Val, const Value *dstVal, const ThreadContext::SimdFuncSignature *simdFuncSignature)
{
IR::Opnd *baseOpnd = nullptr, *indexOpnd = nullptr, *valueOpnd = nullptr;
IR::Opnd *src, *dst;
bool doTypeSpec = true;
// value = Ld [arr + index]
// [arr + index] = St value
src = instr->GetSrc1();
dst = instr->GetDst();
Assert(dst && src && !instr->GetSrc2());
if (Js::IsSimd128Load(instr->m_opcode))
{
Assert(src->IsIndirOpnd());
baseOpnd = instr->GetSrc1()->AsIndirOpnd()->GetBaseOpnd();
indexOpnd = instr->GetSrc1()->AsIndirOpnd()->GetIndexOpnd();
valueOpnd = instr->GetDst();
}
else if (Js::IsSimd128Store(instr->m_opcode))
{
Assert(dst->IsIndirOpnd());
baseOpnd = instr->GetDst()->AsIndirOpnd()->GetBaseOpnd();
indexOpnd = instr->GetDst()->AsIndirOpnd()->GetIndexOpnd();
valueOpnd = instr->GetSrc1();
// St(arr, index, value). Make sure value can be Simd128 type-spec'd
doTypeSpec = doTypeSpec && Simd128CanTypeSpecOpnd(FindValue(valueOpnd->AsRegOpnd()->m_sym)->GetValueInfo()->Type(), simdFuncSignature->args[2]);
}
else
{
Assert(UNREACHED);
}
// array and index operands should have been type-specialized in OptArraySrc: ValueTypes should be definite at this point. If not, don't type-spec.
// We can be in a loop prepass, where opnd ValueInfo is not set yet. Get the ValueInfo from the Value Table instead.
ValueType baseOpndType = FindValue(baseOpnd->AsRegOpnd()->m_sym)->GetValueInfo()->Type();
if (IsLoopPrePass())
{
doTypeSpec = doTypeSpec && (baseOpndType.IsObject() && baseOpndType.IsTypedArray());
// indexOpnd might be missing if loading from [0]
if (indexOpnd != nullptr)
{
ValueType indexOpndType = FindValue(indexOpnd->AsRegOpnd()->m_sym)->GetValueInfo()->Type();
doTypeSpec = doTypeSpec && indexOpndType.IsLikelyInt();
}
}
else
{
doTypeSpec = doTypeSpec && (baseOpndType.IsObject() && baseOpndType.IsTypedArray());
if (indexOpnd != nullptr)
{
ValueType indexOpndType = FindValue(indexOpnd->AsRegOpnd()->m_sym)->GetValueInfo()->Type();
doTypeSpec = doTypeSpec && indexOpndType.IsInt();
}
}
return doTypeSpec;
}
bool IntBounds::RequiresIntBoundedValueInfo(const ValueType valueType) const
{
Assert(valueType.IsLikelyInt());
return !valueType.IsInt() || RequiresIntBoundedValueInfo();
}