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/ic/ic-state.h b/src/ic/ic-state.h
index 72fc865..1982fbe 100644
--- a/src/ic/ic-state.h
+++ b/src/ic/ic-state.h
@@ -17,56 +17,51 @@
class ICUtility : public AllStatic {
public:
// Clear the inline cache to initial state.
- static void Clear(Isolate* isolate, Address address,
- ConstantPoolArray* constant_pool);
+ static void Clear(Isolate* isolate, Address address, Address constant_pool);
};
-class CallICState FINAL BASE_EMBEDDED {
+class CallICState final BASE_EMBEDDED {
public:
- explicit CallICState(ExtraICState extra_ic_state);
+ explicit CallICState(ExtraICState extra_ic_state)
+ : bit_field_(extra_ic_state) {}
+ CallICState(int argc, ConvertReceiverMode convert_mode)
+ : bit_field_(ArgcBits::encode(argc) |
+ ConvertModeBits::encode(convert_mode)) {}
- enum CallType { METHOD, FUNCTION };
-
- CallICState(int argc, CallType call_type)
- : argc_(argc), call_type_(call_type) {}
-
- ExtraICState GetExtraICState() const;
+ ExtraICState GetExtraICState() const { return bit_field_; }
static void GenerateAheadOfTime(Isolate*,
void (*Generate)(Isolate*,
const CallICState&));
- int arg_count() const { return argc_; }
- CallType call_type() const { return call_type_; }
-
- bool CallAsMethod() const { return call_type_ == METHOD; }
+ int argc() const { return ArgcBits::decode(bit_field_); }
+ ConvertReceiverMode convert_mode() const {
+ return ConvertModeBits::decode(bit_field_);
+ }
private:
- class ArgcBits : public BitField<int, 0, Code::kArgumentsBits> {};
- class CallTypeBits : public BitField<CallType, Code::kArgumentsBits, 1> {};
+ typedef BitField<int, 0, Code::kArgumentsBits> ArgcBits;
+ typedef BitField<ConvertReceiverMode, Code::kArgumentsBits, 2>
+ ConvertModeBits;
- const int argc_;
- const CallType call_type_;
+ int const bit_field_;
};
std::ostream& operator<<(std::ostream& os, const CallICState& s);
-// Mode to overwrite BinaryExpression values.
-enum OverwriteMode { NO_OVERWRITE, OVERWRITE_LEFT, OVERWRITE_RIGHT };
-
-class BinaryOpICState FINAL BASE_EMBEDDED {
+class BinaryOpICState final BASE_EMBEDDED {
public:
BinaryOpICState(Isolate* isolate, ExtraICState extra_ic_state);
-
- BinaryOpICState(Isolate* isolate, Token::Value op, OverwriteMode mode)
+ BinaryOpICState(Isolate* isolate, Token::Value op, Strength strength)
: op_(op),
- mode_(mode),
+ strong_(is_strong(strength)),
left_kind_(NONE),
right_kind_(NONE),
result_kind_(NONE),
+ fixed_right_arg_(Nothing<int>()),
isolate_(isolate) {
DCHECK_LE(FIRST_TOKEN, op);
DCHECK_LE(op, LAST_TOKEN);
@@ -91,14 +86,6 @@
void (*Generate)(Isolate*,
const BinaryOpICState&));
- bool CanReuseDoubleBox() const {
- return (result_kind_ > SMI && result_kind_ <= NUMBER) &&
- ((mode_ == OVERWRITE_LEFT && left_kind_ > SMI &&
- left_kind_ <= NUMBER) ||
- (mode_ == OVERWRITE_RIGHT && right_kind_ > SMI &&
- right_kind_ <= NUMBER));
- }
-
// Returns true if the IC _could_ create allocation mementos.
bool CouldCreateAllocationMementos() const {
if (left_kind_ == STRING || right_kind_ == STRING) {
@@ -117,6 +104,10 @@
return Max(left_kind_, right_kind_) == GENERIC;
}
+ Strength strength() const {
+ return strong_ ? Strength::STRONG : Strength::WEAK;
+ }
+
// Returns true if the IC should enable the inline smi code (i.e. if either
// parameter may be a smi).
bool UseInlinedSmiCode() const {
@@ -127,12 +118,11 @@
static const int LAST_TOKEN = Token::MOD;
Token::Value op() const { return op_; }
- OverwriteMode mode() const { return mode_; }
Maybe<int> fixed_right_arg() const { return fixed_right_arg_; }
- Type* GetLeftType(Zone* zone) const { return KindToType(left_kind_, zone); }
- Type* GetRightType(Zone* zone) const { return KindToType(right_kind_, zone); }
- Type* GetResultType(Zone* zone) const;
+ Type* GetLeftType() const { return KindToType(left_kind_); }
+ Type* GetRightType() const { return KindToType(right_kind_); }
+ Type* GetResultType() const;
void Update(Handle<Object> left, Handle<Object> right, Handle<Object> result);
@@ -146,7 +136,7 @@
Kind UpdateKind(Handle<Object> object, Kind kind) const;
static const char* KindToString(Kind kind);
- static Type* KindToType(Kind kind, Zone* zone);
+ static Type* KindToType(Kind kind);
static bool KindMaybeSmi(Kind kind) {
return (kind >= SMI && kind <= NUMBER) || kind == GENERIC;
}
@@ -154,17 +144,17 @@
// We truncate the last bit of the token.
STATIC_ASSERT(LAST_TOKEN - FIRST_TOKEN < (1 << 4));
class OpField : public BitField<int, 0, 4> {};
- class OverwriteModeField : public BitField<OverwriteMode, 4, 2> {};
- class ResultKindField : public BitField<Kind, 6, 3> {};
- class LeftKindField : public BitField<Kind, 9, 3> {};
+ class ResultKindField : public BitField<Kind, 4, 3> {};
+ class LeftKindField : public BitField<Kind, 7, 3> {};
+ class StrengthField : public BitField<bool, 10, 1> {};
// When fixed right arg is set, we don't need to store the right kind.
// Thus the two fields can overlap.
- class HasFixedRightArgField : public BitField<bool, 12, 1> {};
- class FixedRightArgValueField : public BitField<int, 13, 4> {};
- class RightKindField : public BitField<Kind, 13, 3> {};
+ class HasFixedRightArgField : public BitField<bool, 11, 1> {};
+ class FixedRightArgValueField : public BitField<int, 12, 4> {};
+ class RightKindField : public BitField<Kind, 12, 3> {};
Token::Value op_;
- OverwriteMode mode_;
+ bool strong_;
Kind left_kind_;
Kind right_kind_;
Kind result_kind_;
@@ -183,16 +173,18 @@
// ... < GENERIC
// SMI < NUMBER
// INTERNALIZED_STRING < STRING
- // KNOWN_OBJECT < OBJECT
+ // INTERNALIZED_STRING < UNIQUE_NAME
+ // KNOWN_RECEIVER < RECEIVER
enum State {
UNINITIALIZED,
+ BOOLEAN,
SMI,
NUMBER,
STRING,
INTERNALIZED_STRING,
- UNIQUE_NAME, // Symbol or InternalizedString
- OBJECT, // JSObject
- KNOWN_OBJECT, // JSObject with specific map (faster check)
+ UNIQUE_NAME, // Symbol or InternalizedString
+ RECEIVER, // JSReceiver
+ KNOWN_RECEIVER, // JSReceiver with specific map (faster check)
GENERIC
};
@@ -209,30 +201,74 @@
};
-class LoadICState FINAL BASE_EMBEDDED {
+class LoadICState final BASE_EMBEDDED {
+ private:
+ class TypeofModeBits : public BitField<TypeofMode, 0, 1> {};
+ class LanguageModeBits
+ : public BitField<LanguageMode, TypeofModeBits::kNext, 2> {};
+ STATIC_ASSERT(static_cast<int>(INSIDE_TYPEOF) == 0);
+ const ExtraICState state_;
+
public:
+ static const uint32_t kNextBitFieldOffset = LanguageModeBits::kNext;
+
+ static const ExtraICState kStrongModeState = STRONG
+ << LanguageModeBits::kShift;
+
explicit LoadICState(ExtraICState extra_ic_state) : state_(extra_ic_state) {}
- explicit LoadICState(ContextualMode mode)
- : state_(ContextualModeBits::encode(mode)) {}
+ explicit LoadICState(TypeofMode typeof_mode, LanguageMode language_mode)
+ : state_(TypeofModeBits::encode(typeof_mode) |
+ LanguageModeBits::encode(language_mode)) {}
ExtraICState GetExtraICState() const { return state_; }
- ContextualMode contextual_mode() const {
- return ContextualModeBits::decode(state_);
+ TypeofMode typeof_mode() const { return TypeofModeBits::decode(state_); }
+
+ LanguageMode language_mode() const {
+ return LanguageModeBits::decode(state_);
}
- static ContextualMode GetContextualMode(ExtraICState state) {
- return LoadICState(state).contextual_mode();
+ static TypeofMode GetTypeofMode(ExtraICState state) {
+ return LoadICState(state).typeof_mode();
}
+ static LanguageMode GetLanguageMode(ExtraICState state) {
+ return LoadICState(state).language_mode();
+ }
+};
+
+
+class StoreICState final BASE_EMBEDDED {
+ public:
+ explicit StoreICState(ExtraICState extra_ic_state) : state_(extra_ic_state) {}
+
+ explicit StoreICState(LanguageMode mode)
+ : state_(LanguageModeState::encode(mode)) {}
+
+ ExtraICState GetExtraICState() const { return state_; }
+
+ LanguageMode language_mode() const {
+ return LanguageModeState::decode(state_);
+ }
+
+ static LanguageMode GetLanguageMode(ExtraICState state) {
+ return StoreICState(state).language_mode();
+ }
+
+ class LanguageModeState : public BitField<LanguageMode, 1, 2> {};
+ STATIC_ASSERT(i::LANGUAGE_END == 3);
+
+ // For convenience, a statically declared encoding of strict mode extra
+ // IC state.
+ static const ExtraICState kStrictModeState = STRICT
+ << LanguageModeState::kShift;
+
private:
- class ContextualModeBits : public BitField<ContextualMode, 0, 1> {};
- STATIC_ASSERT(static_cast<int>(NOT_CONTEXTUAL) == 0);
-
const ExtraICState state_;
};
-}
-}
+
+} // namespace internal
+} // namespace v8
#endif // V8_IC_STATE_H_