EncodedJSValue JSC_HOST_CALL mathProtoFuncHypot(ExecState* exec) { VM& vm = exec->vm(); auto scope = DECLARE_THROW_SCOPE(vm); unsigned argsCount = exec->argumentCount(); double max = 0; Vector<double, 8> args; args.reserveInitialCapacity(argsCount); for (unsigned i = 0; i < argsCount; ++i) { args.uncheckedAppend(exec->uncheckedArgument(i).toNumber(exec)); RETURN_IF_EXCEPTION(scope, encodedJSValue()); if (std::isinf(args[i])) return JSValue::encode(jsDoubleNumber(+std::numeric_limits<double>::infinity())); max = std::max(fabs(args[i]), max); } if (!max) max = 1; // Kahan summation algorithm significantly reduces the numerical error in the total obtained. double sum = 0; double compensation = 0; for (double argument : args) { double scaledArgument = argument / max; double summand = scaledArgument * scaledArgument - compensation; double preliminary = sum + summand; compensation = (preliminary - sum) - summand; sum = preliminary; } return JSValue::encode(jsDoubleNumber(sqrt(sum) * max)); }
EncodedJSValue JSC_HOST_CALL mathProtoFuncLog1p(ExecState* exec) { double value = exec->argument(0).toNumber(exec); if (value == 0) return JSValue::encode(jsDoubleNumber(value)); return JSValue::encode(jsDoubleNumber(log1p(value))); }
BytecodeIntrinsicRegistry::BytecodeIntrinsicRegistry(VM& vm) : m_vm(vm) , m_bytecodeIntrinsicMap() { JSC_COMMON_BYTECODE_INTRINSIC_FUNCTIONS_EACH_NAME(INITIALIZE_BYTECODE_INTRINSIC_NAMES_TO_SET) JSC_COMMON_BYTECODE_INTRINSIC_CONSTANTS_EACH_NAME(INITIALIZE_BYTECODE_INTRINSIC_NAMES_TO_SET) m_undefined.set(m_vm, jsUndefined()); m_Infinity.set(m_vm, jsDoubleNumber(std::numeric_limits<double>::infinity())); m_arrayIterationKindKey.set(m_vm, jsNumber(ArrayIterateKey)); m_arrayIterationKindValue.set(m_vm, jsNumber(ArrayIterateValue)); m_arrayIterationKindKeyValue.set(m_vm, jsNumber(ArrayIterateKeyValue)); m_MAX_STRING_LENGTH.set(m_vm, jsNumber(JSString::MaxLength)); m_promiseStatePending.set(m_vm, jsNumber(static_cast<unsigned>(JSPromise::Status::Pending))); m_promiseStateFulfilled.set(m_vm, jsNumber(static_cast<unsigned>(JSPromise::Status::Fulfilled))); m_promiseStateRejected.set(m_vm, jsNumber(static_cast<unsigned>(JSPromise::Status::Rejected))); m_symbolIterator.set(m_vm, Symbol::create(m_vm, static_cast<SymbolImpl&>(*m_vm.propertyNames->iteratorSymbol.impl()))); m_symbolMatch.set(m_vm, Symbol::create(m_vm, static_cast<SymbolImpl&>(*m_vm.propertyNames->matchSymbol.impl()))); m_symbolReplace.set(m_vm, Symbol::create(m_vm, static_cast<SymbolImpl&>(*m_vm.propertyNames->replaceSymbol.impl()))); m_symbolSearch.set(m_vm, Symbol::create(m_vm, static_cast<SymbolImpl&>(*m_vm.propertyNames->searchSymbol.impl()))); m_symbolSpecies.set(m_vm, Symbol::create(m_vm, static_cast<SymbolImpl&>(*m_vm.propertyNames->speciesSymbol.impl()))); m_symbolSplit.set(m_vm, Symbol::create(m_vm, static_cast<SymbolImpl&>(*m_vm.propertyNames->splitSymbol.impl()))); m_GeneratorResumeModeNormal.set(m_vm, jsNumber(static_cast<int32_t>(JSGeneratorFunction::GeneratorResumeMode::NormalMode))); m_GeneratorResumeModeThrow.set(m_vm, jsNumber(static_cast<int32_t>(JSGeneratorFunction::GeneratorResumeMode::ThrowMode))); m_GeneratorResumeModeReturn.set(m_vm, jsNumber(static_cast<int32_t>(JSGeneratorFunction::GeneratorResumeMode::ReturnMode))); m_GeneratorStateCompleted.set(m_vm, jsNumber(static_cast<int32_t>(JSGeneratorFunction::GeneratorState::Completed))); m_GeneratorStateExecuting.set(m_vm, jsNumber(static_cast<int32_t>(JSGeneratorFunction::GeneratorState::Executing))); }
void AbstractValue::fixTypeForRepresentation(Graph& graph, NodeFlags representation, Node* node) { if (representation == NodeResultDouble) { if (m_value) { ASSERT(m_value.isNumber()); if (m_value.isInt32()) m_value = jsDoubleNumber(m_value.asNumber()); } if (m_type & SpecMachineInt) { m_type &= ~SpecMachineInt; m_type |= SpecInt52AsDouble; } if (m_type & ~SpecFullDouble) DFG_CRASH(graph, node, toCString("Abstract value ", *this, " for double node has type outside SpecFullDouble.\n").data()); } else if (representation == NodeResultInt52) { if (m_type & SpecInt52AsDouble) { m_type &= ~SpecInt52AsDouble; m_type |= SpecInt52; } if (m_type & ~SpecMachineInt) DFG_CRASH(graph, node, toCString("Abstract value ", *this, " for int52 node has type outside SpecMachineInt.\n").data()); } else { if (m_type & SpecInt52) { m_type &= ~SpecInt52; m_type |= SpecInt52AsDouble; } if (m_type & ~SpecBytecodeTop) DFG_CRASH(graph, node, toCString("Abstract value ", *this, " for value node has type outside SpecBytecodeTop.\n").data()); } checkConsistency(); }
void NumberConstructor::finishCreation(VM& vm, NumberPrototype* numberPrototype) { Base::finishCreation(vm, NumberPrototype::info()->className); ASSERT(inherits(info())); // Number.Prototype putDirectWithoutTransition(vm, vm.propertyNames->prototype, numberPrototype, DontEnum | DontDelete | ReadOnly); // no. of arguments for constructor putDirectWithoutTransition(vm, vm.propertyNames->length, jsNumber(1), ReadOnly | DontEnum | DontDelete); putDirectWithoutTransition(vm, Identifier(&vm, "EPSILON"), jsDoubleNumber(std::numeric_limits<double>::epsilon()), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier(&vm, "MAX_VALUE"), jsDoubleNumber(1.7976931348623157E+308), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier(&vm, "MIN_VALUE"), jsDoubleNumber(5E-324), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier(&vm, "MAX_SAFE_INTEGER"), jsDoubleNumber(9007199254740991.0), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier(&vm, "MIN_SAFE_INTEGER"), jsDoubleNumber(-9007199254740991.0), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier(&vm, "NEGATIVE_INFINITY"), jsDoubleNumber(-std::numeric_limits<double>::infinity()), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier(&vm, "POSITIVE_INFINITY"), jsDoubleNumber(std::numeric_limits<double>::infinity()), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier(&vm, "NaN"), jsNaN(), DontDelete | DontEnum | ReadOnly); putDirectNativeFunctionWithoutTransition(vm, numberPrototype->globalObject(), Identifier(&vm, "isFinite"), 1, numberConstructorFuncIsFinite, NoIntrinsic, DontEnum | Function); putDirectNativeFunctionWithoutTransition(vm, numberPrototype->globalObject(), Identifier(&vm, "isInteger"), 1, numberConstructorFuncIsInteger, NoIntrinsic, DontEnum | Function); putDirectNativeFunctionWithoutTransition(vm, numberPrototype->globalObject(), Identifier(&vm, "isNaN"), 1, numberConstructorFuncIsNaN, NoIntrinsic, DontEnum | Function); putDirectNativeFunctionWithoutTransition(vm, numberPrototype->globalObject(), Identifier(&vm, "isSafeInteger"), 1, numberConstructorFuncIsSafeInteger, NoIntrinsic, DontEnum | Function); putDirectNativeFunctionWithoutTransition(vm, numberPrototype->globalObject(), Identifier(&vm, "parseFloat"), 1, globalFuncParseFloat, NoIntrinsic, DontEnum | Function); putDirectNativeFunctionWithoutTransition(vm, numberPrototype->globalObject(), Identifier(&vm, "parseInt"), 1, globalFuncParseInt, NoIntrinsic, DontEnum | Function); }
void JITCode::reconstruct( ExecState* exec, CodeBlock* codeBlock, CodeOrigin codeOrigin, unsigned streamIndex, Operands<JSValue>& result) { Operands<ValueRecovery> recoveries; reconstruct(codeBlock, codeOrigin, streamIndex, recoveries); result = Operands<JSValue>(OperandsLike, recoveries); for (size_t i = result.size(); i--;) { int operand = result.operandForIndex(i); if (operandIsArgument(operand) && !VirtualRegister(operand).toArgument() && codeBlock->codeType() == FunctionCode && codeBlock->specializationKind() == CodeForConstruct) { // Ugh. If we're in a constructor, the 'this' argument may hold garbage. It will // also never be used. It doesn't matter what we put into the value for this, // but it has to be an actual value that can be grokked by subsequent DFG passes, // so we sanitize it here by turning it into Undefined. result[i] = jsUndefined(); continue; } ValueRecovery recovery = recoveries[i]; JSValue value; switch (recovery.technique()) { case AlreadyInJSStack: case AlreadyInJSStackAsUnboxedCell: case AlreadyInJSStackAsUnboxedBoolean: value = exec->r(operand).jsValue(); break; case AlreadyInJSStackAsUnboxedInt32: value = jsNumber(exec->r(operand).unboxedInt32()); break; case AlreadyInJSStackAsUnboxedInt52: value = jsNumber(exec->r(operand).unboxedInt52()); break; case AlreadyInJSStackAsUnboxedDouble: value = jsDoubleNumber(exec->r(operand).unboxedDouble()); break; case Constant: value = recovery.constant(); break; default: RELEASE_ASSERT_NOT_REACHED(); break; } result[i] = value; } }
JSC::JSValue JSMediaStreamTrack::getSettings(ExecState& state) { JSValue thisValue = state.thisValue(); JSMediaStreamTrack* castedThis = jsDynamicCast<JSMediaStreamTrack*>(thisValue); if (UNLIKELY(!castedThis)) return JSValue::decode(throwThisTypeError(state, "MediaStreamTrack", "getSettings")); JSObject* object = constructEmptyObject(&state); auto& impl = castedThis->wrapped(); RefPtr<MediaSourceSettings> settings = WTF::getPtr(impl.getSettings()); if (settings->supportsWidth()) object->putDirect(state.vm(), Identifier::fromString(&state, "width"), jsNumber(settings->width()), DontDelete | ReadOnly); if (settings->supportsHeight()) object->putDirect(state.vm(), Identifier::fromString(&state, "height"), jsNumber(settings->height()), DontDelete | ReadOnly); if (settings->supportsAspectRatio()) object->putDirect(state.vm(), Identifier::fromString(&state, "aspectRatio"), jsDoubleNumber(settings->aspectRatio()), DontDelete | ReadOnly); if (settings->supportsFrameRate()) object->putDirect(state.vm(), Identifier::fromString(&state, "frameRate"), jsDoubleNumber(settings->frameRate()), DontDelete | ReadOnly); if (settings->supportsFacingMode()) object->putDirect(state.vm(), Identifier::fromString(&state, "facingMode"), jsStringWithCache(&state, settings->facingMode()), DontDelete | ReadOnly); if (settings->supportsVolume()) object->putDirect(state.vm(), Identifier::fromString(&state, "volume"), jsDoubleNumber(settings->volume()), DontDelete | ReadOnly); if (settings->supportsSampleRate()) object->putDirect(state.vm(), Identifier::fromString(&state, "sampleRate"), jsNumber(settings->sampleRate()), DontDelete | ReadOnly); if (settings->supportsSampleSize()) object->putDirect(state.vm(), Identifier::fromString(&state, "sampleSize"), jsNumber(settings->sampleSize()), DontDelete | ReadOnly); if (settings->supportsEchoCancellation()) object->putDirect(state.vm(), Identifier::fromString(&state, "echoCancellation"), jsBoolean(settings->echoCancellation()), DontDelete | ReadOnly); if (settings->supportsDeviceId()) object->putDirect(state.vm(), Identifier::fromString(&state, "deviceId"), jsStringWithCache(&state, settings->deviceId()), DontDelete | ReadOnly); if (settings->supportsGroupId()) object->putDirect(state.vm(), Identifier::fromString(&state, "groupId"), jsStringWithCache(&state, settings->groupId()), DontDelete | ReadOnly); return object; }
void AbstractValue::fixTypeForRepresentation(NodeFlags representation) { if (representation == NodeResultDouble) { if (m_value) { ASSERT(m_value.isNumber()); if (m_value.isInt32()) m_value = jsDoubleNumber(m_value.asNumber()); } if (m_type & SpecMachineInt) { m_type &= ~SpecMachineInt; m_type |= SpecInt52AsDouble; } if (m_type & ~SpecFullDouble) { startCrashing(); dataLog("Abstract value ", *this, " for double node has type outside SpecFullDouble.\n"); CRASH(); } } else if (representation == NodeResultInt52) { if (m_type & SpecInt52AsDouble) { m_type &= ~SpecInt52AsDouble; m_type |= SpecInt52; } if (m_type & ~SpecMachineInt) { startCrashing(); dataLog("Abstract value ", *this, " for int52 node has type outside SpecMachineInt.\n"); CRASH(); } } else { if (m_type & SpecInt52) { m_type &= ~SpecInt52; m_type |= SpecInt52AsDouble; } if (m_type & ~SpecBytecodeTop) { startCrashing(); dataLog("Abstract value ", *this, " for value node has type outside SpecBytecodeTop.\n"); CRASH(); } } checkConsistency(); }
void NumberConstructor::finishCreation(VM& vm, NumberPrototype* numberPrototype) { Base::finishCreation(vm, NumberPrototype::info()->className); ASSERT(inherits(info())); // Number.Prototype putDirectWithoutTransition(vm, vm.propertyNames->prototype, numberPrototype, DontEnum | DontDelete | ReadOnly); // no. of arguments for constructor putDirectWithoutTransition(vm, vm.propertyNames->length, jsNumber(1), ReadOnly | DontEnum | DontDelete); putDirectWithoutTransition(vm, Identifier::fromString(&vm, "EPSILON"), jsDoubleNumber(std::numeric_limits<double>::epsilon()), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier::fromString(&vm, "MAX_VALUE"), jsDoubleNumber(1.7976931348623157E+308), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier::fromString(&vm, "MIN_VALUE"), jsDoubleNumber(5E-324), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier::fromString(&vm, "MAX_SAFE_INTEGER"), jsDoubleNumber(maxSafeInteger()), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier::fromString(&vm, "MIN_SAFE_INTEGER"), jsDoubleNumber(minSafeInteger()), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier::fromString(&vm, "NEGATIVE_INFINITY"), jsDoubleNumber(-std::numeric_limits<double>::infinity()), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier::fromString(&vm, "POSITIVE_INFINITY"), jsDoubleNumber(std::numeric_limits<double>::infinity()), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier::fromString(&vm, "NaN"), jsNaN(), DontDelete | DontEnum | ReadOnly); putDirectWithoutTransition(vm, Identifier::fromString(&vm, "parseInt"), numberPrototype->globalObject()->parseIntFunction(), DontEnum); }
EncodedJSValue JSC_HOST_CALL mathProtoFuncTan(ExecState* exec) { return JSValue::encode(jsDoubleNumber(tan(exec->argument(0).toNumber(exec)))); }
EncodedJSValue JSC_HOST_CALL mathProtoFuncRandom(ExecState* exec) { return JSValue::encode(jsDoubleNumber(exec->lexicalGlobalObject()->weakRandomNumber())); }
EncodedJSValue JSC_HOST_CALL mathProtoFuncATan2(ExecState* exec) { double arg0 = exec->argument(0).toNumber(exec); double arg1 = exec->argument(1).toNumber(exec); return JSValue::encode(jsDoubleNumber(atan2(arg0, arg1))); }
JSValue JSC_HOST_CALL mathProtoFuncTan(ExecState* exec, JSObject*, JSValue, const ArgList& args) { return jsDoubleNumber(exec, tan(args.at(0).toNumber(exec))); }
JSValue JSC_HOST_CALL mathProtoFuncRandom(ExecState* exec, JSObject*, JSValue, const ArgList&) { return jsDoubleNumber(exec, exec->globalData().weakRandom.get()); }
EncodedJSValue JSC_HOST_CALL mathProtoFuncFround(ExecState* exec) { return JSValue::encode(jsDoubleNumber(static_cast<float>(exec->argument(0).toNumber(exec)))); }
JSValue JSC_HOST_CALL mathProtoFuncRandom(ExecState* exec, JSObject*, JSValue, const ArgList&) { return jsDoubleNumber(exec, exec->lexicalGlobalObject()->weakRandomNumber()); }