Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/src/compiler/operator.h b/src/compiler/operator.h
index fb144ce..fa85d59 100644
--- a/src/compiler/operator.h
+++ b/src/compiler/operator.h
@@ -9,6 +9,7 @@
#include "src/base/flags.h"
#include "src/base/functional.h"
+#include "src/handles.h"
#include "src/zone.h"
namespace v8 {
@@ -29,7 +30,7 @@
// meaningful to the operator itself.
class Operator : public ZoneObject {
public:
- typedef uint8_t Opcode;
+ typedef uint16_t Opcode;
// Properties inform the operator-independent optimizer about legal
// transformations for nodes that have this operator.
@@ -44,6 +45,7 @@
// create new scheduling dependencies.
kNoThrow = 1 << 6, // Can never generate an exception.
kFoldable = kNoRead | kNoWrite,
+ kKontrol = kFoldable | kNoThrow,
kEliminatable = kNoWrite | kNoThrow,
kPure = kNoRead | kNoWrite | kNoThrow | kIdempotent
};
@@ -84,6 +86,9 @@
Properties properties() const { return properties_; }
+ // TODO(bmeurer): Use bit fields below?
+ static const size_t kMaxControlOutputCount = (1u << 16) - 1;
+
// TODO(titzer): convert return values here to size_t.
int ValueInputCount() const { return value_in_; }
int EffectInputCount() const { return effect_in_; }
@@ -93,7 +98,15 @@
int EffectOutputCount() const { return effect_out_; }
int ControlOutputCount() const { return control_out_; }
- static inline size_t ZeroIfPure(Properties properties) {
+ static size_t ZeroIfEliminatable(Properties properties) {
+ return (properties & kEliminatable) == kEliminatable ? 0 : 1;
+ }
+
+ static size_t ZeroIfNoThrow(Properties properties) {
+ return (properties & kNoThrow) == kNoThrow ? 0 : 2;
+ }
+
+ static size_t ZeroIfPure(Properties properties) {
return (properties & kPure) == kPure ? 0 : 1;
}
@@ -113,7 +126,7 @@
uint16_t control_in_;
uint16_t value_out_;
uint8_t effect_out_;
- uint8_t control_out_;
+ uint16_t control_out_;
DISALLOW_COPY_AND_ASSIGN(Operator);
};
@@ -123,10 +136,19 @@
std::ostream& operator<<(std::ostream& os, const Operator& op);
+// Default equality function for below Operator1<*> class.
+template <typename T>
+struct OpEqualTo : public std::equal_to<T> {};
+
+
+// Default hashing function for below Operator1<*> class.
+template <typename T>
+struct OpHash : public base::hash<T> {};
+
+
// A templatized implementation of Operator that has one static parameter of
-// type {T}.
-template <typename T, typename Pred = std::equal_to<T>,
- typename Hash = base::hash<T>>
+// type {T} with the proper default equality and hashing functions.
+template <typename T, typename Pred = OpEqualTo<T>, typename Hash = OpHash<T>>
class Operator1 : public Operator {
public:
Operator1(Opcode opcode, Properties properties, const char* mnemonic,
@@ -141,12 +163,13 @@
T const& parameter() const { return parameter_; }
- bool Equals(const Operator* other) const FINAL {
+ bool Equals(const Operator* other) const final {
if (opcode() != other->opcode()) return false;
- const Operator1<T>* that = static_cast<const Operator1<T>*>(other);
+ const Operator1<T, Pred, Hash>* that =
+ reinterpret_cast<const Operator1<T, Pred, Hash>*>(other);
return this->pred_(this->parameter(), that->parameter());
}
- size_t HashCode() const FINAL {
+ size_t HashCode() const final {
return base::hash_combine(this->opcode(), this->hash_(this->parameter()));
}
virtual void PrintParameter(std::ostream& os) const {
@@ -154,7 +177,7 @@
}
protected:
- void PrintTo(std::ostream& os) const FINAL {
+ void PrintTo(std::ostream& os) const final {
os << mnemonic();
PrintParameter(os);
}
@@ -169,22 +192,38 @@
// Helper to extract parameters from Operator1<*> operator.
template <typename T>
inline T const& OpParameter(const Operator* op) {
- return static_cast<const Operator1<T>*>(op)->parameter();
+ return reinterpret_cast<const Operator1<T, OpEqualTo<T>, OpHash<T>>*>(op)
+ ->parameter();
}
+
// NOTE: We have to be careful to use the right equal/hash functions below, for
-// float/double we always use the ones operating on the bit level.
+// float/double we always use the ones operating on the bit level, for Handle<>
+// we always use the ones operating on the location level.
template <>
-inline float const& OpParameter(const Operator* op) {
- return static_cast<const Operator1<float, base::bit_equal_to<float>,
- base::bit_hash<float>>*>(op)->parameter();
-}
+struct OpEqualTo<float> : public base::bit_equal_to<float> {};
+template <>
+struct OpHash<float> : public base::bit_hash<float> {};
template <>
-inline double const& OpParameter(const Operator* op) {
- return static_cast<const Operator1<double, base::bit_equal_to<double>,
- base::bit_hash<double>>*>(op)->parameter();
-}
+struct OpEqualTo<double> : public base::bit_equal_to<double> {};
+template <>
+struct OpHash<double> : public base::bit_hash<double> {};
+
+template <>
+struct OpEqualTo<Handle<HeapObject>> : public Handle<HeapObject>::equal_to {};
+template <>
+struct OpHash<Handle<HeapObject>> : public Handle<HeapObject>::hash {};
+
+template <>
+struct OpEqualTo<Handle<String>> : public Handle<String>::equal_to {};
+template <>
+struct OpHash<Handle<String>> : public Handle<String>::hash {};
+
+template <>
+struct OpEqualTo<Handle<ScopeInfo>> : public Handle<ScopeInfo>::equal_to {};
+template <>
+struct OpHash<Handle<ScopeInfo>> : public Handle<ScopeInfo>::hash {};
} // namespace compiler
} // namespace internal