Merge V8 5.3.332.45. DO NOT MERGE
Test: Manual
FPIIM-449
Change-Id: Id3254828b068abdea3cb10442e0172a8c9a98e03
(cherry picked from commit 13e2dadd00298019ed862f2b2fc5068bba730bcf)
diff --git a/src/compiler/machine-operator.h b/src/compiler/machine-operator.h
index 814f6c9..7c443f4 100644
--- a/src/compiler/machine-operator.h
+++ b/src/compiler/machine-operator.h
@@ -113,20 +113,89 @@
kWord64Popcnt = 1u << 19,
kWord32ReverseBits = 1u << 20,
kWord64ReverseBits = 1u << 21,
- kAllOptionalOps = kFloat32Max | kFloat32Min | kFloat64Max | kFloat64Min |
- kFloat32RoundDown | kFloat64RoundDown | kFloat32RoundUp |
- kFloat64RoundUp | kFloat32RoundTruncate |
- kFloat64RoundTruncate | kFloat64RoundTiesAway |
- kFloat32RoundTiesEven | kFloat64RoundTiesEven |
- kWord32Ctz | kWord64Ctz | kWord32Popcnt | kWord64Popcnt |
- kWord32ReverseBits | kWord64ReverseBits
+ kFloat32Neg = 1u << 22,
+ kFloat64Neg = 1u << 23,
+ kAllOptionalOps =
+ kFloat32Max | kFloat32Min | kFloat64Max | kFloat64Min |
+ kFloat32RoundDown | kFloat64RoundDown | kFloat32RoundUp |
+ kFloat64RoundUp | kFloat32RoundTruncate | kFloat64RoundTruncate |
+ kFloat64RoundTiesAway | kFloat32RoundTiesEven | kFloat64RoundTiesEven |
+ kWord32Ctz | kWord64Ctz | kWord32Popcnt | kWord64Popcnt |
+ kWord32ReverseBits | kWord64ReverseBits | kFloat32Neg | kFloat64Neg
};
typedef base::Flags<Flag, unsigned> Flags;
+ class AlignmentRequirements {
+ public:
+ enum UnalignedAccessSupport { kNoSupport, kSomeSupport, kFullSupport };
+
+ bool IsUnalignedLoadSupported(const MachineType& machineType,
+ uint8_t alignment) const {
+ return IsUnalignedSupported(unalignedLoadSupportedTypes_, machineType,
+ alignment);
+ }
+
+ bool IsUnalignedStoreSupported(const MachineType& machineType,
+ uint8_t alignment) const {
+ return IsUnalignedSupported(unalignedStoreSupportedTypes_, machineType,
+ alignment);
+ }
+
+ static AlignmentRequirements FullUnalignedAccessSupport() {
+ return AlignmentRequirements(kFullSupport);
+ }
+ static AlignmentRequirements NoUnalignedAccessSupport() {
+ return AlignmentRequirements(kNoSupport);
+ }
+ static AlignmentRequirements SomeUnalignedAccessSupport(
+ const Vector<MachineType>& unalignedLoadSupportedTypes,
+ const Vector<MachineType>& unalignedStoreSupportedTypes) {
+ return AlignmentRequirements(kSomeSupport, unalignedLoadSupportedTypes,
+ unalignedStoreSupportedTypes);
+ }
+
+ private:
+ explicit AlignmentRequirements(
+ AlignmentRequirements::UnalignedAccessSupport unalignedAccessSupport,
+ Vector<MachineType> unalignedLoadSupportedTypes =
+ Vector<MachineType>(NULL, 0),
+ Vector<MachineType> unalignedStoreSupportedTypes =
+ Vector<MachineType>(NULL, 0))
+ : unalignedSupport_(unalignedAccessSupport),
+ unalignedLoadSupportedTypes_(unalignedLoadSupportedTypes),
+ unalignedStoreSupportedTypes_(unalignedStoreSupportedTypes) {}
+
+ bool IsUnalignedSupported(const Vector<MachineType>& supported,
+ const MachineType& machineType,
+ uint8_t alignment) const {
+ if (unalignedSupport_ == kFullSupport) {
+ return true;
+ } else if (unalignedSupport_ == kNoSupport) {
+ return false;
+ } else {
+ for (MachineType m : supported) {
+ if (m == machineType) {
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+
+ const AlignmentRequirements::UnalignedAccessSupport unalignedSupport_;
+ const Vector<MachineType> unalignedLoadSupportedTypes_;
+ const Vector<MachineType> unalignedStoreSupportedTypes_;
+ };
+
explicit MachineOperatorBuilder(
Zone* zone,
MachineRepresentation word = MachineType::PointerRepresentation(),
- Flags supportedOperators = kNoFlags);
+ Flags supportedOperators = kNoFlags,
+ AlignmentRequirements alignmentRequirements =
+ AlignmentRequirements::NoUnalignedAccessSupport());
+
+ const Operator* Comment(const char* msg);
+ const Operator* DebugBreak();
const Operator* Word32And();
const Operator* Word32Or();
@@ -295,12 +364,42 @@
const OptionalOperator Float32RoundTiesEven();
const OptionalOperator Float64RoundTiesEven();
+ // Floating point neg.
+ const OptionalOperator Float32Neg();
+ const OptionalOperator Float64Neg();
+
+ // Floating point trigonometric functions (double-precision).
+ const Operator* Float64Atan();
+ const Operator* Float64Atan2();
+ const Operator* Float64Atanh();
+
+ // Floating point trigonometric functions (double-precision).
+ const Operator* Float64Cos();
+ const Operator* Float64Sin();
+ const Operator* Float64Tan();
+
+ // Floating point exponential functions (double-precision).
+ const Operator* Float64Exp();
+
+ // Floating point logarithm (double-precision).
+ const Operator* Float64Log();
+ const Operator* Float64Log1p();
+ const Operator* Float64Log2();
+ const Operator* Float64Log10();
+
+ const Operator* Float64Cbrt();
+ const Operator* Float64Expm1();
+
// Floating point bit representation.
const Operator* Float64ExtractLowWord32();
const Operator* Float64ExtractHighWord32();
const Operator* Float64InsertLowWord32();
const Operator* Float64InsertHighWord32();
+ // Change signalling NaN to quiet NaN.
+ // Identity for any input that is not signalling NaN.
+ const Operator* Float64SilenceNaN();
+
// SIMD operators.
const Operator* CreateFloat32x4();
const Operator* Float32x4ExtractLane();
@@ -513,6 +612,18 @@
bool Is64() const { return word() == MachineRepresentation::kWord64; }
MachineRepresentation word() const { return word_; }
+ bool UnalignedLoadSupported(const MachineType& machineType,
+ uint8_t alignment) {
+ return alignment_requirements_.IsUnalignedLoadSupported(machineType,
+ alignment);
+ }
+
+ bool UnalignedStoreSupported(const MachineType& machineType,
+ uint8_t alignment) {
+ return alignment_requirements_.IsUnalignedStoreSupported(machineType,
+ alignment);
+ }
+
// Pseudo operators that translate to 32/64-bit operators depending on the
// word-size of the target machine assumed by this builder.
#define PSEUDO_OP_LIST(V) \
@@ -544,9 +655,11 @@
#undef PSEUDO_OP_LIST
private:
+ Zone* zone_;
MachineOperatorGlobalCache const& cache_;
MachineRepresentation const word_;
Flags const flags_;
+ AlignmentRequirements const alignment_requirements_;
DISALLOW_COPY_AND_ASSIGN(MachineOperatorBuilder);
};