Var SIMDInt32x4Lib::EntryFromFloat32x4(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
Assert(!(callInfo.Flags & CallFlags_New));
if (args.Info.Count >= 2 && JavascriptSIMDFloat32x4::Is(args[1]))
{
JavascriptSIMDFloat32x4 *instance = JavascriptSIMDFloat32x4::FromVar(args[1]);
Assert(instance);
bool throws = false;
SIMDValue result = SIMDInt32x4Operation::OpFromFloat32x4(instance->GetValue(), throws);
// out of range
if (throws)
{
JavascriptError::ThrowRangeError(scriptContext, JSERR_ArgumentOutOfRange, _u("SIMD.Int32x4.FromFloat32x4"));
}
return JavascriptSIMDInt32x4::New(&result, scriptContext);
}
JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromFloat32x4"));
}
Var JavascriptSIMDFloat64x2::EntryToString(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
Assert(!(callInfo.Flags & CallFlags_New));
if (args.Info.Count == 0 || JavascriptOperators::GetTypeId(args[0]) != TypeIds_SIMDFloat64x2)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_This_NeedSimd, L"SIMDFloat64x2.toString");
}
JavascriptSIMDFloat64x2 *instance = JavascriptSIMDFloat64x2::FromVar(args[0]);
Assert(instance);
wchar_t stringBuffer[SIMD_STRING_BUFFER_MAX];
SIMDValue value = instance->GetValue();
JavascriptSIMDFloat64x2::ToStringBuffer(value, stringBuffer, SIMD_STRING_BUFFER_MAX);
JavascriptString* string = JavascriptString::NewCopySzFromArena(stringBuffer, scriptContext, scriptContext->GeneralAllocator());
return string;
}
Var DataView::EntrySetFloat64(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
BOOL isLittleEndian = FALSE;
Assert(!(callInfo.Flags & CallFlags_New));
if (args.Info.Count == 0 || !DataView::Is(args[0]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_This_NeedDataView);
}
if (args.Info.Count < 3)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_DataView_NeedArgument, L"offset or value");
}
DataView* dataView = DataView::FromVar(args[0]);
uint32 offset = JavascriptConversion::ToUInt32(args[1], scriptContext);
double value = JavascriptConversion::ToNumber(args[2], scriptContext);
if (args.Info.Count > 3)
{
isLittleEndian = JavascriptConversion::ToBoolean(args[3], scriptContext);
}
dataView->SetValue<double>(offset, value, L"DataView.prototype.SetFloat64", isLittleEndian);
return scriptContext->GetLibrary()->GetUndefined();
}
Var AsmJsChangeHeapBuffer(RecyclableObject * function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
Assert(!(callInfo.Flags & CallFlags_New));
if (args.Info.Count < 1 || !ArrayBuffer::Is(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedArrayBufferObject);
}
ArrayBuffer* newArrayBuffer = ArrayBuffer::FromVar(args[1]);
if (newArrayBuffer->IsDetached() || newArrayBuffer->GetByteLength() & 0xffffff || newArrayBuffer->GetByteLength() <= 0xffffff || newArrayBuffer->GetByteLength() > 0x80000000)
{
return JavascriptBoolean::ToVar(FALSE, scriptContext);
}
FrameDisplay* frame = ((ScriptFunction*)function)->GetEnvironment();
Var* moduleArrayBuffer = (Var*)frame->GetItem(0) + AsmJsModuleMemory::MemoryTableBeginOffset;
*moduleArrayBuffer = newArrayBuffer;
return JavascriptBoolean::ToVar(TRUE, scriptContext);
}
Var JavascriptWeakSet::EntryHas(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
if (!JavascriptWeakSet::Is(args[0]))
{
JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, _u("WeakSet.prototype.has"), _u("WeakSet"));
}
JavascriptWeakSet* weakSet = JavascriptWeakSet::FromVar(args[0]);
Var key = (args.Info.Count > 1) ? args[1] : scriptContext->GetLibrary()->GetUndefined();
bool hasValue = false;
if (JavascriptOperators::IsObject(key) && JavascriptOperators::GetTypeId(key) != TypeIds_HostDispatch)
{
DynamicObject* keyObj = DynamicObject::FromVar(key);
hasValue = weakSet->Has(keyObj);
}
return scriptContext->GetLibrary()->CreateBoolean(hasValue);
}
Var SIMDUint16x8Lib::EntrySubSaturate(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
Assert(!(callInfo.Flags & CallFlags_New));
// If any of the args are missing, then it is Undefined type which causes TypeError exception.
// strict type on both operands
if (args.Info.Count >= 3 && JavascriptSIMDUint16x8::Is(args[1]) && JavascriptSIMDUint16x8::Is(args[2]))
{
JavascriptSIMDUint16x8 *a = JavascriptSIMDUint16x8::FromVar(args[1]);
JavascriptSIMDUint16x8 *b = JavascriptSIMDUint16x8::FromVar(args[2]);
Assert(a && b);
SIMDValue result, aValue, bValue;
aValue = a->GetValue();
bValue = b->GetValue();
result = SIMDUint16x8Operation::OpSubSaturate(aValue, bValue);
return JavascriptSIMDUint16x8::New(&result, scriptContext);
}
JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("subSaturate"));
}
// Boolean.prototype.toString as described in ES6 spec (draft 24) 19.3.3.2
Var JavascriptBoolean::EntryToString(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
AssertMsg(args.Info.Count, "Should always have implicit 'this'.");
ScriptContext* scriptContext = function->GetScriptContext();
Assert(!(callInfo.Flags & CallFlags_New));
BOOL bval;
Var aValue = args[0];
if(JavascriptBoolean::Is(aValue))
{
bval = JavascriptBoolean::FromVar(aValue)->GetValue();
}
else if (JavascriptBooleanObject::Is(aValue))
{
JavascriptBooleanObject* booleanObject = JavascriptBooleanObject::FromVar(aValue);
bval = booleanObject->GetValue();
}
else
{
return TryInvokeRemotelyOrThrow(EntryToString, scriptContext, args, JSERR_This_NeedBoolean, _u("Boolean.prototype.toString"));
}
return bval ? scriptContext->GetLibrary()->GetTrueDisplayString() : scriptContext->GetLibrary()->GetFalseDisplayString();
}
Var JavascriptReflect::EntryPreventExtensions(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.preventExtensions"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.preventExtensions"));
}
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.preventExtensions"));
}
Var target = args[1];
RecyclableObject* targetObj = RecyclableObject::FromVar(target);
GlobalObject* globalObject = targetObj->GetLibrary()->GetGlobalObject();
if (globalObject != targetObj && globalObject && (globalObject->ToThis() == targetObj))
{
globalObject->PreventExtensions();
}
return scriptContext->GetLibrary()->GetTrueOrFalse(targetObj->PreventExtensions());
}
Var JavascriptReflect::EntrySet(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
Var undefinedValue = scriptContext->GetLibrary()->GetUndefined();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.set"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.set"));
}
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.set"));
}
Var target = args[1];
Var propertyKey = args.Info.Count > 2 ? args[2] : undefinedValue;
Var value = args.Info.Count > 3 ? args[3] : undefinedValue;
Var receiver = args.Info.Count > 4 ? args[4] : target;
target = JavascriptOperators::ToObject(target, scriptContext);
BOOL result = JavascriptOperators::SetElementIHelper(receiver, RecyclableObject::FromVar(target), propertyKey, value, scriptContext, PropertyOperationFlags::PropertyOperation_None);
return scriptContext->GetLibrary()->GetTrueOrFalse(result);
}
Var JavascriptReflect::EntryGetOwnPropertyDescriptor(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
Var undefinedValue = scriptContext->GetLibrary()->GetUndefined();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.getOwnPropertyDescriptor"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.getOwnPropertyDescriptor"));
}
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.getOwnPropertyDescriptor"));
}
Var target = args[1];
Var propertyKey = args.Info.Count > 2 ? args[2] : undefinedValue;
if (JavascriptOperators::GetTypeId(target) == TypeIds_HostDispatch)
{
Var result;
if (RecyclableObject::FromVar(target)->InvokeBuiltInOperationRemotely(EntryGetOwnPropertyDescriptor, args, &result))
{
return result;
}
}
return JavascriptObject::GetOwnPropertyDescriptorHelper(RecyclableObject::FromVar(target), propertyKey, scriptContext);
}
Var JavascriptReflect::EntryHas(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
Var undefinedValue = scriptContext->GetLibrary()->GetUndefined();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.has"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.has"));
}
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.has"));
}
Var target = args[1];
Var propertyKey = args.Info.Count > 2 ? args[2] : undefinedValue;
BOOL result = JavascriptOperators::OP_HasItem(target, propertyKey, scriptContext);
return scriptContext->GetLibrary()->GetTrueOrFalse(result);
}
Var JavascriptSet::EntryForEach(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Set.prototype.forEach"));
if (!JavascriptSet::Is(args[0]))
{
JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, _u("Set.prototype.forEach"), _u("Set"));
}
JavascriptSet* set = JavascriptSet::FromVar(args[0]);
if (args.Info.Count < 2 || !JavascriptConversion::IsCallable(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedFunction, _u("Set.prototype.forEach"));
}
RecyclableObject* callBackFn = RecyclableObject::FromVar(args[1]);
Var thisArg = (args.Info.Count > 2) ? args[2] : scriptContext->GetLibrary()->GetUndefined();
auto iterator = set->GetIterator();
while (iterator.Next())
{
Var value = iterator.Current();
CALL_FUNCTION(callBackFn, CallInfo(CallFlags_Value, 4), thisArg, value, value, args[0]);
}
return scriptContext->GetLibrary()->GetUndefined();
}
Var JavascriptSet::EntryAdd(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
if (!JavascriptSet::Is(args[0]))
{
JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, _u("Set.prototype.add"), _u("Set"));
}
JavascriptSet* set = JavascriptSet::FromVar(args[0]);
Var value = (args.Info.Count > 1) ? args[1] : scriptContext->GetLibrary()->GetUndefined();
if (JavascriptNumber::Is(value) && JavascriptNumber::IsNegZero(JavascriptNumber::GetValue(value)))
{
// Normalize -0 to +0
value = JavascriptNumber::New(0.0, scriptContext);
}
set->Add(value);
return set;
}
Var SharedArrayBuffer::NewInstance(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
Var newTarget = callInfo.Flags & CallFlags_NewTarget ? args.Values[args.Info.Count] : args[0];
bool isCtorSuperCall = (callInfo.Flags & CallFlags_New) && newTarget != nullptr && !JavascriptOperators::IsUndefined(newTarget);
Assert(isCtorSuperCall || !(callInfo.Flags & CallFlags_New) || args[0] == nullptr);
if (!(callInfo.Flags & CallFlags_New) || (newTarget && JavascriptOperators::IsUndefinedObject(newTarget)))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ClassConstructorCannotBeCalledWithoutNew, _u("SharedArrayBuffer"));
}
uint32 byteLength = 0;
if (args.Info.Count > 1)
{
byteLength = GetByteLengthFromVar(scriptContext, args[1]);
}
RecyclableObject* newArr = scriptContext->GetLibrary()->CreateSharedArrayBuffer(byteLength);
return isCtorSuperCall ?
JavascriptOperators::OrdinaryCreateFromConstructor(RecyclableObject::FromVar(newTarget), newArr, nullptr, scriptContext) :
newArr;
}
Var SIMDUint16x8Lib::EntryReplaceLane(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
Assert(!(callInfo.Flags & CallFlags_New));
// first arg has to be of type Uint16x8, so cannot be missing.
if (args.Info.Count >= 4 && JavascriptSIMDUint16x8::Is(args[1]))
{
// if value arg is missing, then it is undefined.
Var laneVar = args.Info.Count >= 4 ? args[2] : scriptContext->GetLibrary()->GetUndefined();
Var argVal = args.Info.Count >= 4 ? args[3] : scriptContext->GetLibrary()->GetUndefined();
uint16 value = JavascriptConversion::ToInt16(argVal, scriptContext);
SIMDValue result = SIMD128ReplaceLane<JavascriptSIMDUint16x8, 8, uint16>(args[1], laneVar, value, scriptContext);
return JavascriptSIMDUint16x8::New(&result, scriptContext);
}
JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("ReplaceLane"));
}
Var JavascriptReflect::EntrySetPrototypeOf(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.setPrototypeOf"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.setPrototypeOf"));
}
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.setPrototypeOf"));
}
Var target = args[1];
target = JavascriptOperators::ToObject(target, scriptContext);
if (args.Info.Count < 3 || !JavascriptOperators::IsObjectOrNull(args[2]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NotObjectOrNull, _u("Object.setPrototypeOf"));
}
RecyclableObject* newPrototype = RecyclableObject::FromVar(args[2]);
BOOL changeResult = JavascriptObject::ChangePrototype(RecyclableObject::FromVar(target), newPrototype, /*validate*/false, scriptContext);
return scriptContext->GetLibrary()->GetTrueOrFalse(changeResult);
}
Var SIMDUint16x8Lib::EntryUint16x8(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
Assert(!(callInfo.Flags & CallFlags_New));
Var undefinedVar = scriptContext->GetLibrary()->GetUndefined();
uint16 uintSIMDX0 = JavascriptConversion::ToUInt16(args.Info.Count >= 2 ? args[1] : undefinedVar, scriptContext);
uint16 uintSIMDX1 = JavascriptConversion::ToUInt16(args.Info.Count >= 3 ? args[2] : undefinedVar, scriptContext);
uint16 uintSIMDX2 = JavascriptConversion::ToUInt16(args.Info.Count >= 4 ? args[3] : undefinedVar, scriptContext);
uint16 uintSIMDX3 = JavascriptConversion::ToUInt16(args.Info.Count >= 5 ? args[4] : undefinedVar, scriptContext);
uint16 uintSIMDX4 = JavascriptConversion::ToUInt16(args.Info.Count >= 6 ? args[5] : undefinedVar, scriptContext);
uint16 uintSIMDX5 = JavascriptConversion::ToUInt16(args.Info.Count >= 7 ? args[6] : undefinedVar, scriptContext);
uint16 uintSIMDX6 = JavascriptConversion::ToUInt16(args.Info.Count >= 8 ? args[7] : undefinedVar, scriptContext);
uint16 uintSIMDX7 = JavascriptConversion::ToUInt16(args.Info.Count >= 9 ? args[8] : undefinedVar, scriptContext);
SIMDValue lanes = SIMDUint16x8Operation::OpUint16x8(uintSIMDX0, uintSIMDX1, uintSIMDX2, uintSIMDX3
, uintSIMDX4, uintSIMDX5, uintSIMDX6, uintSIMDX7);
return JavascriptSIMDUint16x8::New(&lanes, scriptContext);
}
Var JavascriptReflect::EntryApply(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
Var undefinedValue = scriptContext->GetLibrary()->GetUndefined();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.apply"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.apply"));
}
Var target = args.Info.Count > 1 ? args[1] : undefinedValue;
if (!JavascriptConversion::IsCallable(target))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedFunction, _u("Reflect.apply"));
}
Var thisArgument = args.Info.Count > 2 ? args[2] : undefinedValue;
Var argArray = args.Info.Count > 3 ? args[3] : undefinedValue;
return JavascriptFunction::ApplyHelper(RecyclableObject::FromVar(target), thisArgument, argArray, scriptContext);
}
Var SIMDUint16x8Lib::EntrySelect(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
Assert(!(callInfo.Flags & CallFlags_New));
if (args.Info.Count >= 4 && JavascriptSIMDBool16x8::Is(args[1]) &&
JavascriptSIMDUint16x8::Is(args[2]) && JavascriptSIMDUint16x8::Is(args[3]))
{
JavascriptSIMDBool16x8 *m = JavascriptSIMDBool16x8::FromVar(args[1]);
JavascriptSIMDUint16x8 *t = JavascriptSIMDUint16x8::FromVar(args[2]);
JavascriptSIMDUint16x8 *f = JavascriptSIMDUint16x8::FromVar(args[3]);
Assert(m && t && f);
SIMDValue result, maskValue, trueValue, falseValue;
maskValue = m->GetValue();
trueValue = t->GetValue();
falseValue = f->GetValue();
result = SIMDInt32x4Operation::OpSelect(maskValue, trueValue, falseValue);
return JavascriptSIMDUint16x8::New(&result, scriptContext);
}
JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("select"));
}
Var JavascriptReflect::EntryEnumerate(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.enumerate"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.enumerate"));
}
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.enumerate"));
}
Var target = args[1];
Var iterator = nullptr;
Recycler* recycler = scriptContext->GetRecycler();
ForInObjectEnumeratorWrapper* forinEnumerator = RecyclerNew(recycler, Js::ForInObjectEnumeratorWrapper, RecyclableObject::FromVar(target), scriptContext);
iterator = JavascriptEnumeratorIterator::Create(forinEnumerator, nullptr, scriptContext);
return iterator;
}
Var JavascriptWeakMap::EntryGet(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
if (!JavascriptWeakMap::Is(args[0]))
{
JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, _u("WeakMap.prototype.get"), _u("WeakMap"));
}
JavascriptWeakMap* weakMap = JavascriptWeakMap::FromVar(args[0]);
Var key = (args.Info.Count > 1) ? args[1] : scriptContext->GetLibrary()->GetUndefined();
if (JavascriptOperators::IsObject(key) && JavascriptOperators::GetTypeId(key) != TypeIds_HostDispatch)
{
DynamicObject* keyObj = DynamicObject::FromVar(key);
Var value = nullptr;
if (weakMap->Get(keyObj, &value))
{
return value;
}
}
return scriptContext->GetLibrary()->GetUndefined();
}
Var JavascriptSIMDUint16x8::EntryToString(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
Assert(!(callInfo.Flags & CallFlags_New));
if (args.Info.Count == 0 || JavascriptOperators::GetTypeId(args[0]) != TypeIds_SIMDUint16x8)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_This_NeedSimd, L"SIMDUint16x8.toString");
}
JavascriptSIMDUint16x8* instance = JavascriptSIMDUint16x8::FromVar(args[0]);
Assert(instance);
wchar_t stringBuffer[1024];
SIMDValue value = instance->GetValue();
swprintf_s(stringBuffer, 1024, L"SIMD.Uint16x8(%u, %u, %u, %u, %u, %u, %u, %u)",
value.u16[0], value.u16[1], value.u16[2], value.u16[3], value.u16[4], value.u16[5], value.u16[6], value.u16[7]);
JavascriptString* string = JavascriptString::NewCopySzFromArena(stringBuffer, scriptContext, scriptContext->GeneralAllocator());
return string;
}
Var ObjectPrototypeObject::Entry__proto__getter(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
Assert(!(callInfo.Flags & CallFlags_New));
ScriptContext* scriptContext = function->GetScriptContext();
#if !FLOATVAR
// Mark temp number will stack allocate number that is used as the object ptr.
// So we should box it before call ToObject on it.
Var arg0 = JavascriptNumber::BoxStackNumber(args[0], scriptContext);
#else
Var arg0 = args[0];
#endif
// B.2.2.1.1
// get Object.prototype.__proto__
// The value of the [[Get]] attribute is a built-in function that requires no arguments. It performs the following steps:
// 1. Let O be ToObject(this value).
// 2. ReturnIfAbrupt(O).
RecyclableObject* object;
if (args.Info.Count < 1 || !JavascriptConversion::ToObject(arg0, scriptContext, &object))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_This_NeedObject, _u("Object.prototype.__proto__"));
}
// 3. Return O.[[GetPrototypeOf]]().
return JavascriptObject::GetPrototypeOf(object, scriptContext);
}
Var SIMDUint16x8Lib::EntryShiftRightByScalar(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
Assert(!(callInfo.Flags & CallFlags_New));
if (args.Info.Count >= 3 && JavascriptSIMDUint16x8::Is(args[1]))
{
JavascriptSIMDUint16x8 *a = JavascriptSIMDUint16x8::FromVar(args[1]);
Assert(a);
SIMDValue result, aValue;
aValue = a->GetValue();
Var countVar = args[2]; // {int} bits Bit count
int8 count = JavascriptConversion::ToInt8(countVar, scriptContext);
result = SIMDUint16x8Operation::OpShiftRightByScalar(aValue, count);
return JavascriptSIMDUint16x8::New(&result, scriptContext);
}
JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("shiftRightByScalar"));
}
Var JavascriptWeakSet::EntryAdd(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
if (!JavascriptWeakSet::Is(args[0]))
{
JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, _u("WeakSet.prototype.add"), _u("WeakSet"));
}
JavascriptWeakSet* weakSet = JavascriptWeakSet::FromVar(args[0]);
Var key = (args.Info.Count > 1) ? args[1] : scriptContext->GetLibrary()->GetUndefined();
if (!JavascriptOperators::IsObject(key) || JavascriptOperators::GetTypeId(key) == TypeIds_HostDispatch)
{
// HostDispatch is not expanded so can't have internal property added to it.
// TODO: Support HostDispatch as WeakSet key
JavascriptError::ThrowTypeError(scriptContext, JSERR_WeakMapSetKeyNotAnObject, _u("WeakSet.prototype.add"));
}
DynamicObject* keyObj = DynamicObject::FromVar(key);
weakSet->Add(keyObj);
return weakSet;
}
Var SIMDUint16x8Lib::EntrySwizzle(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
Assert(!(callInfo.Flags & CallFlags_New));
if (args.Info.Count >= 2 && JavascriptSIMDUint16x8::Is(args[1]))
{
// type check on lane indices
if (args.Info.Count < 10)
{
// missing lane args
JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedNumber, _u("Lane index"));
}
Var lanes[8];
for (uint i = 0; i < 8; ++i)
{
lanes[i] = args[i + 2];
}
return SIMD128SlowShuffle<JavascriptSIMDUint16x8>(args[1], args[1], lanes, 8, scriptContext);
}
JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("swizzle"));
}
Var DataView::EntryGetFloat32(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
BOOL isLittleEndian = FALSE;
Assert(!(callInfo.Flags & CallFlags_New));
if (args.Info.Count == 0 || !DataView::Is(args[0]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_This_NeedDataView);
}
if (args.Info.Count < 2)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_DataView_NeedArgument, L"offset");
}
if (args.Info.Count > 2)
{
isLittleEndian = JavascriptConversion::ToBoolean(args[2], scriptContext);
}
DataView* dataView = DataView::FromVar(args[0]);
uint32 offset = JavascriptConversion::ToUInt32(args[1], scriptContext);
return dataView->GetValueWithCheck<float>(offset, L"DataView.prototype.GetFloat32", isLittleEndian);
}
Var SIMDUint16x8Lib::EntryShuffle(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
Assert(!(callInfo.Flags & CallFlags_New));
// If any of the args are missing, then it is Undefined type which causes TypeError exception.
// strict type on both operands
if (args.Info.Count >= 3 && JavascriptSIMDUint16x8::Is(args[1]) && JavascriptSIMDUint16x8::Is(args[2]))
{
// type check on lane indices
if (args.Info.Count < 11)
{
// missing lane args
JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedNumber, _u("Lane index"));
}
Var lanes[8];
for (uint i = 0; i < 8; ++i)
{
lanes[i] = args[i + 3];
}
return SIMD128SlowShuffle<JavascriptSIMDUint16x8>(args[1], args[2], lanes, 16, scriptContext);
}
JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdUint16x8TypeMismatch, _u("shuffle"));
}
Var DataView::EntryGetterByteOffset(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
Assert(!(callInfo.Flags & CallFlags_New));
if (args.Info.Count == 0 || !DataView::Is(args[0]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_This_NeedDataView);
}
DataView* dataView = DataView::FromVar(args[0]);
ArrayBuffer* arrayBuffer = dataView->GetArrayBuffer();
if (arrayBuffer == nullptr)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedArrayBufferObject);
}
else if (arrayBuffer->IsDetached())
{
return TaggedInt::ToVarUnchecked(0);
}
return JavascriptNumber::ToVar(dataView->GetByteOffset(), scriptContext);
}
Var SIMDInt32x4Lib::EntrySwizzle(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
Assert(!(callInfo.Flags & CallFlags_New));
// If any of the args are missing, then it is Undefined type which causes TypeError exception.
// strict type on both operands
if (args.Info.Count >= 2 && JavascriptSIMDInt32x4::Is(args[1]))
{
// type check on lane indices
if (args.Info.Count < 6)
{
// missing lane args
JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedNumber, _u("Lane index"));
}
Var lanes[4];
lanes[0] = args[2];
lanes[1] = args[3];
lanes[2] = args[4];
lanes[3] = args[5];
return SIMDUtils::SIMD128SlowShuffle<JavascriptSIMDInt32x4>(args[1], args[1], lanes, 4, 4, scriptContext);
}
JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("swizzle"));
}