From 1bf1084f2b10c3b47fd1a588d85d21ed0eb41d0c Mon Sep 17 00:00:00 2001 From: Lorry Tar Creator Date: Tue, 27 Jun 2017 06:07:23 +0000 Subject: webkitgtk-2.16.5 --- Source/JavaScriptCore/b3/B3Common.h | 175 ++++++++++++++++++++++++++++++++++++ 1 file changed, 175 insertions(+) create mode 100644 Source/JavaScriptCore/b3/B3Common.h (limited to 'Source/JavaScriptCore/b3/B3Common.h') diff --git a/Source/JavaScriptCore/b3/B3Common.h b/Source/JavaScriptCore/b3/B3Common.h new file mode 100644 index 000000000..41e8ee096 --- /dev/null +++ b/Source/JavaScriptCore/b3/B3Common.h @@ -0,0 +1,175 @@ +/* + * Copyright (C) 2015-2016 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#if ENABLE(B3_JIT) + +#include "JSExportMacros.h" +#include + +namespace JSC { namespace B3 { + +inline bool is64Bit() { return sizeof(void*) == 8; } +inline bool is32Bit() { return !is64Bit(); } + +enum B3ComplitationMode { + B3Mode, + AirMode +}; + +JS_EXPORT_PRIVATE bool shouldDumpIR(B3ComplitationMode); +bool shouldDumpIRAtEachPhase(B3ComplitationMode); +bool shouldValidateIR(); +bool shouldValidateIRAtEachPhase(); +bool shouldSaveIRBeforePhase(); +bool shouldMeasurePhaseTiming(); + +template +inline bool isIdentical(InputType left, InputType right) +{ + BitsType leftBits = bitwise_cast(left); + BitsType rightBits = bitwise_cast(right); + return leftBits == rightBits; +} + +inline bool isIdentical(int32_t left, int32_t right) +{ + return isIdentical(left, right); +} + +inline bool isIdentical(int64_t left, int64_t right) +{ + return isIdentical(left, right); +} + +inline bool isIdentical(double left, double right) +{ + return isIdentical(left, right); +} + +inline bool isIdentical(float left, float right) +{ + return isIdentical(left, right); +} + +template +inline bool isRepresentableAsImpl(InputType originalValue) +{ + // Convert the original value to the desired result type. + ResultType result = static_cast(originalValue); + + // Convert the converted value back to the original type. The original value is representable + // using the new type if such round-tripping doesn't lose bits. + InputType newValue = static_cast(result); + + return isIdentical(originalValue, newValue); +} + +template +inline bool isRepresentableAs(int32_t value) +{ + return isRepresentableAsImpl(value); +} + +template +inline bool isRepresentableAs(int64_t value) +{ + return isRepresentableAsImpl(value); +} + +template +inline bool isRepresentableAs(double value) +{ + return isRepresentableAsImpl(value); +} + +template +static IntType chillDiv(IntType numerator, IntType denominator) +{ + if (!denominator) + return 0; + if (denominator == -1 && numerator == std::numeric_limits::min()) + return std::numeric_limits::min(); + return numerator / denominator; +} + +template +static IntType chillMod(IntType numerator, IntType denominator) +{ + if (!denominator) + return 0; + if (denominator == -1 && numerator == std::numeric_limits::min()) + return 0; + return numerator % denominator; +} + +template +static IntType chillUDiv(IntType numerator, IntType denominator) +{ + typedef typename std::make_unsigned::type UnsignedIntType; + UnsignedIntType unsignedNumerator = static_cast(numerator); + UnsignedIntType unsignedDenominator = static_cast(denominator); + if (!unsignedDenominator) + return 0; + return unsignedNumerator / unsignedDenominator; +} + +template +static IntType chillUMod(IntType numerator, IntType denominator) +{ + typedef typename std::make_unsigned::type UnsignedIntType; + UnsignedIntType unsignedNumerator = static_cast(numerator); + UnsignedIntType unsignedDenominator = static_cast(denominator); + if (!unsignedDenominator) + return 0; + return unsignedNumerator % unsignedDenominator; +} + +template +static IntType rotateRight(IntType value, int32_t shift) +{ + typedef typename std::make_unsigned::type UnsignedIntType; + UnsignedIntType uValue = static_cast(value); + int32_t bits = sizeof(IntType) * 8; + int32_t mask = bits - 1; + shift &= mask; + return (uValue >> shift) | (uValue << ((bits - shift) & mask)); +} + +template +static IntType rotateLeft(IntType value, int32_t shift) +{ + typedef typename std::make_unsigned::type UnsignedIntType; + UnsignedIntType uValue = static_cast(value); + int32_t bits = sizeof(IntType) * 8; + int32_t mask = bits - 1; + shift &= mask; + return (uValue << shift) | (uValue >> ((bits - shift) & mask)); +} + +} } // namespace JSC::B3 + +#endif // ENABLE(B3_JIT) -- cgit v1.2.1