Skip to content

V
V8
Commit 0190a00f authored by ishell@chromium.org's avatar ishell@chromium.org Committed by Commit Bot
Browse files
Options

[ic] Rename FeedbackSlotKind values to better reflect reality. 

BUG=v8:5917

Change-Id: I9611ace4ba73f18cb90f95f9c81eeb19c74e06f4
Reviewed-on: https://chromium-review.googlesource.com/439327Reviewed-by: 's avatarMichael Stanton <mvstanton@chromium.org>
Reviewed-by: 's avatarJakob Kummerow <jkummerow@chromium.org>
Reviewed-by: 's avatarBenedikt Meurer <bmeurer@chromium.org>
Commit-Queue: Benedikt Meurer <bmeurer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#43032}
parent 8cbe27e7
Hide whitespace changes
Inline Side-by-side
Showing with 211 additions and 219 deletions
src/compiler/bytecode-graph-builder.cc
View file @ 0190a00f
......@@ -1483,8 +1483,7 @@ BinaryOperationHint BytecodeGraphBuilder::GetBinaryOperationHint(
int operand_index) {
FeedbackSlot slot = feedback_vector()->ToSlot(
bytecode_iterator().GetIndexOperand(operand_index));
DCHECK_EQ(FeedbackSlotKind::INTERPRETER_BINARYOP_IC,
feedback_vector()->GetKind(slot));
DCHECK_EQ(FeedbackSlotKind::kBinaryOp, feedback_vector()->GetKind(slot));
BinaryOpICNexus nexus(feedback_vector(), slot);
return nexus.GetBinaryOperationFeedback();
}
......@@ -1498,8 +1497,7 @@ CompareOperationHint BytecodeGraphBuilder::GetCompareOperationHint() {
}
FeedbackSlot slot =
feedback_vector()->ToSlot(bytecode_iterator().GetIndexOperand(1));
DCHECK_EQ(FeedbackSlotKind::INTERPRETER_COMPARE_IC,
feedback_vector()->GetKind(slot));
DCHECK_EQ(FeedbackSlotKind::kCompareOp, feedback_vector()->GetKind(slot));
CompareICNexus nexus(feedback_vector(), slot);
return nexus.GetCompareOperationFeedback();
}
......
src/feedback-vector-inl.h
View file @ 0190a00f
......@@ -18,7 +18,7 @@ FeedbackSlot FeedbackVectorSpecBase<Derived>::AddSlot(FeedbackSlotKind kind) {
int entries_per_slot = FeedbackMetadata::GetSlotSize(kind);
This()->append(kind);
for (int i = 1; i < entries_per_slot; i++) {
This()->append(FeedbackSlotKind::INVALID);
This()->append(FeedbackSlotKind::kInvalid);
}
return FeedbackSlot(slot);
}
......@@ -48,28 +48,28 @@ FeedbackVector* FeedbackVector::cast(Object* obj) {
int FeedbackMetadata::GetSlotSize(FeedbackSlotKind kind) {
switch (kind) {
case FeedbackSlotKind::GENERAL:
case FeedbackSlotKind::INTERPRETER_COMPARE_IC:
case FeedbackSlotKind::INTERPRETER_BINARYOP_IC:
case FeedbackSlotKind::TO_BOOLEAN_IC:
case FeedbackSlotKind::LITERAL:
case FeedbackSlotKind::CREATE_CLOSURE:
case FeedbackSlotKind::kGeneral:
case FeedbackSlotKind::kCompareOp:
case FeedbackSlotKind::kBinaryOp:
case FeedbackSlotKind::kToBoolean:
case FeedbackSlotKind::kLiteral:
case FeedbackSlotKind::kCreateClosure:
return 1;
case FeedbackSlotKind::CALL_IC:
case FeedbackSlotKind::LOAD_IC:
case FeedbackSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC:
case FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC:
case FeedbackSlotKind::KEYED_LOAD_IC:
case FeedbackSlotKind::STORE_SLOPPY_IC:
case FeedbackSlotKind::STORE_STRICT_IC:
case FeedbackSlotKind::KEYED_STORE_SLOPPY_IC:
case FeedbackSlotKind::KEYED_STORE_STRICT_IC:
case FeedbackSlotKind::STORE_DATA_PROPERTY_IN_LITERAL_IC:
case FeedbackSlotKind::kCall:
case FeedbackSlotKind::kLoadProperty:
case FeedbackSlotKind::kLoadGlobalInsideTypeof:
case FeedbackSlotKind::kLoadGlobalNotInsideTypeof:
case FeedbackSlotKind::kLoadKeyed:
case FeedbackSlotKind::kStorePropertySloppy:
case FeedbackSlotKind::kStorePropertyStrict:
case FeedbackSlotKind::kStoreKeyedSloppy:
case FeedbackSlotKind::kStoreKeyedStrict:
case FeedbackSlotKind::kStoreDataPropertyInLiteral:
return 2;
case FeedbackSlotKind::INVALID:
case FeedbackSlotKind::KINDS_NUMBER:
case FeedbackSlotKind::kInvalid:
case FeedbackSlotKind::kKindsNumber:
UNREACHABLE();
break;
}
......@@ -171,16 +171,16 @@ void FeedbackVector::ComputeCounts(int* with_type_info, int* generic,
Object* const obj = Get(slot);
switch (kind) {
case FeedbackSlotKind::CALL_IC:
case FeedbackSlotKind::LOAD_IC:
case FeedbackSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC:
case FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC:
case FeedbackSlotKind::KEYED_LOAD_IC:
case FeedbackSlotKind::STORE_SLOPPY_IC:
case FeedbackSlotKind::STORE_STRICT_IC:
case FeedbackSlotKind::KEYED_STORE_SLOPPY_IC:
case FeedbackSlotKind::KEYED_STORE_STRICT_IC:
case FeedbackSlotKind::STORE_DATA_PROPERTY_IN_LITERAL_IC: {
case FeedbackSlotKind::kCall:
case FeedbackSlotKind::kLoadProperty:
case FeedbackSlotKind::kLoadGlobalInsideTypeof:
case FeedbackSlotKind::kLoadGlobalNotInsideTypeof:
case FeedbackSlotKind::kLoadKeyed:
case FeedbackSlotKind::kStorePropertySloppy:
case FeedbackSlotKind::kStorePropertyStrict:
case FeedbackSlotKind::kStoreKeyedSloppy:
case FeedbackSlotKind::kStoreKeyedStrict:
case FeedbackSlotKind::kStoreDataPropertyInLiteral: {
if (obj->IsWeakCell() || obj->IsFixedArray() || obj->IsString()) {
with++;
} else if (obj == megamorphic_sentinel) {
......@@ -190,7 +190,7 @@ void FeedbackVector::ComputeCounts(int* with_type_info, int* generic,
total++;
break;
}
case FeedbackSlotKind::INTERPRETER_BINARYOP_IC:
case FeedbackSlotKind::kBinaryOp:
// If we are not running interpreted code, we need to ignore the special
// IC slots for binaryop/compare used by the interpreter.
// TODO(mvstanton): Remove code_is_interpreted when full code is retired
......@@ -207,7 +207,7 @@ void FeedbackVector::ComputeCounts(int* with_type_info, int* generic,
total++;
}
break;
case FeedbackSlotKind::INTERPRETER_COMPARE_IC: {
case FeedbackSlotKind::kCompareOp: {
// If we are not running interpreted code, we need to ignore the special
// IC slots for binaryop/compare used by the interpreter.
// TODO(mvstanton): Remove code_is_interpreted when full code is retired
......@@ -226,13 +226,13 @@ void FeedbackVector::ComputeCounts(int* with_type_info, int* generic,
}
break;
}
case FeedbackSlotKind::TO_BOOLEAN_IC:
case FeedbackSlotKind::CREATE_CLOSURE:
case FeedbackSlotKind::GENERAL:
case FeedbackSlotKind::LITERAL:
case FeedbackSlotKind::kToBoolean:
case FeedbackSlotKind::kCreateClosure:
case FeedbackSlotKind::kGeneral:
case FeedbackSlotKind::kLiteral:
break;
case FeedbackSlotKind::INVALID:
case FeedbackSlotKind::KINDS_NUMBER:
case FeedbackSlotKind::kInvalid:
case FeedbackSlotKind::kKindsNumber:
UNREACHABLE();
break;
}
......
src/feedback-vector.cc
View file @ 0190a00f
......@@ -62,7 +62,7 @@ Handle<FeedbackMetadata> FeedbackMetadata::New(Isolate* isolate,
int entry_size = FeedbackMetadata::GetSlotSize(kind);
for (int j = 1; j < entry_size; j++) {
FeedbackSlotKind kind = spec->GetKind(FeedbackSlot(i + j));
DCHECK_EQ(FeedbackSlotKind::INVALID, kind);
DCHECK_EQ(FeedbackSlotKind::kInvalid, kind);
}
i += entry_size;
}
......@@ -115,41 +115,41 @@ bool FeedbackMetadata::SpecDiffersFrom(
const char* FeedbackMetadata::Kind2String(FeedbackSlotKind kind) {
switch (kind) {
case FeedbackSlotKind::INVALID:
case FeedbackSlotKind::kInvalid:
return "INVALID";
case FeedbackSlotKind::CALL_IC:
case FeedbackSlotKind::kCall:
return "CALL_IC";
case FeedbackSlotKind::LOAD_IC:
case FeedbackSlotKind::kLoadProperty:
return "LOAD_IC";
case FeedbackSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC:
case FeedbackSlotKind::kLoadGlobalInsideTypeof:
return "LOAD_GLOBAL_INSIDE_TYPEOF_IC";
case FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC:
case FeedbackSlotKind::kLoadGlobalNotInsideTypeof:
return "LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC";
case FeedbackSlotKind::KEYED_LOAD_IC:
case FeedbackSlotKind::kLoadKeyed:
return "KEYED_LOAD_IC";
case FeedbackSlotKind::STORE_SLOPPY_IC:
case FeedbackSlotKind::kStorePropertySloppy:
return "STORE_SLOPPY_IC";
case FeedbackSlotKind::STORE_STRICT_IC:
case FeedbackSlotKind::kStorePropertyStrict:
return "STORE_STRICT_IC";
case FeedbackSlotKind::KEYED_STORE_SLOPPY_IC:
case FeedbackSlotKind::kStoreKeyedSloppy:
return "KEYED_STORE_SLOPPY_IC";
case FeedbackSlotKind::KEYED_STORE_STRICT_IC:
case FeedbackSlotKind::kStoreKeyedStrict:
return "KEYED_STORE_STRICT_IC";
case FeedbackSlotKind::INTERPRETER_BINARYOP_IC:
case FeedbackSlotKind::kBinaryOp:
return "INTERPRETER_BINARYOP_IC";
case FeedbackSlotKind::INTERPRETER_COMPARE_IC:
case FeedbackSlotKind::kCompareOp:
return "INTERPRETER_COMPARE_IC";
case FeedbackSlotKind::TO_BOOLEAN_IC:
case FeedbackSlotKind::kToBoolean:
return "TO_BOOLEAN_IC";
case FeedbackSlotKind::STORE_DATA_PROPERTY_IN_LITERAL_IC:
case FeedbackSlotKind::kStoreDataPropertyInLiteral:
return "STORE_DATA_PROPERTY_IN_LITERAL_IC";
case FeedbackSlotKind::CREATE_CLOSURE:
return "CREATE_CLOSURE";
case FeedbackSlotKind::LITERAL:
case FeedbackSlotKind::kCreateClosure:
return "kCreateClosure";
case FeedbackSlotKind::kLiteral:
return "LITERAL";
case FeedbackSlotKind::GENERAL:
case FeedbackSlotKind::kGeneral:
return "STUB";
case FeedbackSlotKind::KINDS_NUMBER:
case FeedbackSlotKind::kKindsNumber:
break;
}
UNREACHABLE();
......@@ -186,41 +186,41 @@ Handle<FeedbackVector> FeedbackVector::New(Isolate* isolate,
Object* extra_value = *uninitialized_sentinel;
switch (kind) {
case FeedbackSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC:
case FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC:
case FeedbackSlotKind::kLoadGlobalInsideTypeof:
case FeedbackSlotKind::kLoadGlobalNotInsideTypeof:
array->set(index, isolate->heap()->empty_weak_cell(),
SKIP_WRITE_BARRIER);
break;
case FeedbackSlotKind::INTERPRETER_COMPARE_IC:
case FeedbackSlotKind::INTERPRETER_BINARYOP_IC:
case FeedbackSlotKind::TO_BOOLEAN_IC:
case FeedbackSlotKind::kCompareOp:
case FeedbackSlotKind::kBinaryOp:
case FeedbackSlotKind::kToBoolean:
array->set(index, Smi::kZero, SKIP_WRITE_BARRIER);
break;
case FeedbackSlotKind::CREATE_CLOSURE: {
case FeedbackSlotKind::kCreateClosure: {
Handle<Cell> cell = factory->NewCell(undefined_value);
array->set(index, *cell);
break;
}
case FeedbackSlotKind::LITERAL:
case FeedbackSlotKind::kLiteral:
array->set(index, *undefined_value, SKIP_WRITE_BARRIER);
break;
case FeedbackSlotKind::CALL_IC:
case FeedbackSlotKind::kCall:
array->set(index, *uninitialized_sentinel, SKIP_WRITE_BARRIER);
extra_value = Smi::kZero;
break;
case FeedbackSlotKind::LOAD_IC:
case FeedbackSlotKind::KEYED_LOAD_IC:
case FeedbackSlotKind::STORE_SLOPPY_IC:
case FeedbackSlotKind::STORE_STRICT_IC:
case FeedbackSlotKind::KEYED_STORE_SLOPPY_IC:
case FeedbackSlotKind::KEYED_STORE_STRICT_IC:
case FeedbackSlotKind::STORE_DATA_PROPERTY_IN_LITERAL_IC:
case FeedbackSlotKind::GENERAL:
case FeedbackSlotKind::kLoadProperty:
case FeedbackSlotKind::kLoadKeyed:
case FeedbackSlotKind::kStorePropertySloppy:
case FeedbackSlotKind::kStorePropertyStrict:
case FeedbackSlotKind::kStoreKeyedSloppy:
case FeedbackSlotKind::kStoreKeyedStrict:
case FeedbackSlotKind::kStoreDataPropertyInLiteral:
case FeedbackSlotKind::kGeneral:
array->set(index, *uninitialized_sentinel, SKIP_WRITE_BARRIER);
break;
case FeedbackSlotKind::INVALID:
case FeedbackSlotKind::KINDS_NUMBER:
case FeedbackSlotKind::kInvalid:
case FeedbackSlotKind::kKindsNumber:
UNREACHABLE();
array->set(index, Smi::kZero, SKIP_WRITE_BARRIER);
break;
......@@ -265,50 +265,50 @@ void FeedbackVector::ClearSlotsImpl(SharedFunctionInfo* shared,
Object* obj = Get(slot);
if (obj != uninitialized_sentinel) {
switch (kind) {
case FeedbackSlotKind::CALL_IC: {
case FeedbackSlotKind::kCall: {
CallICNexus nexus(this, slot);
nexus.Clear(shared->code());
break;
}
case FeedbackSlotKind::LOAD_IC: {
case FeedbackSlotKind::kLoadProperty: {
LoadICNexus nexus(this, slot);
nexus.Clear(shared->code());
break;
}
case FeedbackSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC:
case FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC: {
case FeedbackSlotKind::kLoadGlobalInsideTypeof:
case FeedbackSlotKind::kLoadGlobalNotInsideTypeof: {
LoadGlobalICNexus nexus(this, slot);
nexus.Clear(shared->code());
break;
}
case FeedbackSlotKind::KEYED_LOAD_IC: {
case FeedbackSlotKind::kLoadKeyed: {
KeyedLoadICNexus nexus(this, slot);
nexus.Clear(shared->code());
break;
}
case FeedbackSlotKind::STORE_SLOPPY_IC:
case FeedbackSlotKind::STORE_STRICT_IC: {
case FeedbackSlotKind::kStorePropertySloppy:
case FeedbackSlotKind::kStorePropertyStrict: {
StoreICNexus nexus(this, slot);
nexus.Clear(shared->code());
break;
}
case FeedbackSlotKind::KEYED_STORE_SLOPPY_IC:
case FeedbackSlotKind::KEYED_STORE_STRICT_IC: {
case FeedbackSlotKind::kStoreKeyedSloppy:
case FeedbackSlotKind::kStoreKeyedStrict: {
KeyedStoreICNexus nexus(this, slot);
nexus.Clear(shared->code());
break;
}
case FeedbackSlotKind::INTERPRETER_BINARYOP_IC:
case FeedbackSlotKind::INTERPRETER_COMPARE_IC: {
case FeedbackSlotKind::kBinaryOp:
case FeedbackSlotKind::kCompareOp: {
DCHECK(Get(slot)->IsSmi());
// don't clear these smi slots.
// Set(slot, Smi::kZero);
break;
}
case FeedbackSlotKind::CREATE_CLOSURE: {
case FeedbackSlotKind::kCreateClosure: {
break;
}
case FeedbackSlotKind::GENERAL: {
case FeedbackSlotKind::kGeneral: {
if (obj->IsHeapObject()) {
InstanceType instance_type =
HeapObject::cast(obj)->map()->instance_type();
......@@ -321,18 +321,18 @@ void FeedbackVector::ClearSlotsImpl(SharedFunctionInfo* shared,
}
break;
}
case FeedbackSlotKind::LITERAL: {
case FeedbackSlotKind::kLiteral: {
Set(slot, undefined_value, SKIP_WRITE_BARRIER);
break;
}
case FeedbackSlotKind::STORE_DATA_PROPERTY_IN_LITERAL_IC: {
case FeedbackSlotKind::kStoreDataPropertyInLiteral: {
StoreDataPropertyInLiteralICNexus nexus(this, slot);
nexus.Clear(shared->code());
break;
}
case FeedbackSlotKind::TO_BOOLEAN_IC:
case FeedbackSlotKind::INVALID:
case FeedbackSlotKind::KINDS_NUMBER:
case FeedbackSlotKind::kToBoolean:
case FeedbackSlotKind::kInvalid:
case FeedbackSlotKind::kKindsNumber:
UNREACHABLE();
break;
}
......
src/feedback-vector.h
View file @ 0190a00f
......@@ -20,67 +20,67 @@ enum class FeedbackSlotKind {
// This kind means that the slot points to the middle of other slot
// which occupies more than one feedback vector element.
// There must be no such slots in the system.
INVALID,
CALL_IC,
LOAD_IC,
LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC,
LOAD_GLOBAL_INSIDE_TYPEOF_IC,
KEYED_LOAD_IC,
STORE_SLOPPY_IC,
STORE_STRICT_IC,
KEYED_STORE_SLOPPY_IC,
KEYED_STORE_STRICT_IC,
INTERPRETER_BINARYOP_IC,
INTERPRETER_COMPARE_IC,
TO_BOOLEAN_IC,
STORE_DATA_PROPERTY_IN_LITERAL_IC,
CREATE_CLOSURE,
LITERAL,
kInvalid,
kCall,
kLoadProperty,
kLoadGlobalNotInsideTypeof,
kLoadGlobalInsideTypeof,
kLoadKeyed,
kStorePropertySloppy,
kStorePropertyStrict,
kStoreKeyedSloppy,
kStoreKeyedStrict,
kBinaryOp,
kCompareOp,
kToBoolean,
kStoreDataPropertyInLiteral,
kCreateClosure,
kLiteral,
// This is a general purpose slot that occupies one feedback vector element.
GENERAL,
kGeneral,
KINDS_NUMBER // Last value indicating number of kinds.
kKindsNumber // Last value indicating number of kinds.
};
inline bool IsCallICKind(FeedbackSlotKind kind) {
return kind == FeedbackSlotKind::CALL_IC;
return kind == FeedbackSlotKind::kCall;
}
inline bool IsLoadICKind(FeedbackSlotKind kind) {
return kind == FeedbackSlotKind::LOAD_IC;
return kind == FeedbackSlotKind::kLoadProperty;
}
inline bool IsLoadGlobalICKind(FeedbackSlotKind kind) {
return kind == FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC ||
kind == FeedbackSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC;
return kind == FeedbackSlotKind::kLoadGlobalNotInsideTypeof ||
kind == FeedbackSlotKind::kLoadGlobalInsideTypeof;
}
inline bool IsKeyedLoadICKind(FeedbackSlotKind kind) {
return kind == FeedbackSlotKind::KEYED_LOAD_IC;
return kind == FeedbackSlotKind::kLoadKeyed;
}
inline bool IsStoreICKind(FeedbackSlotKind kind) {
return kind == FeedbackSlotKind::STORE_SLOPPY_IC ||
kind == FeedbackSlotKind::STORE_STRICT_IC;
return kind == FeedbackSlotKind::kStorePropertySloppy ||
kind == FeedbackSlotKind::kStorePropertyStrict;
}
inline bool IsKeyedStoreICKind(FeedbackSlotKind kind) {
return kind == FeedbackSlotKind::KEYED_STORE_SLOPPY_IC ||
kind == FeedbackSlotKind::KEYED_STORE_STRICT_IC;
return kind == FeedbackSlotKind::kStoreKeyedSloppy ||
kind == FeedbackSlotKind::kStoreKeyedStrict;
}
inline TypeofMode GetTypeofModeFromSlotKind(FeedbackSlotKind kind) {
DCHECK(IsLoadGlobalICKind(kind));
return (kind == FeedbackSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC)
return (kind == FeedbackSlotKind::kLoadGlobalInsideTypeof)
? INSIDE_TYPEOF
: NOT_INSIDE_TYPEOF;
}
inline LanguageMode GetLanguageModeFromSlotKind(FeedbackSlotKind kind) {
DCHECK(IsStoreICKind(kind) || IsKeyedStoreICKind(kind));
return (kind == FeedbackSlotKind::STORE_SLOPPY_IC ||
kind == FeedbackSlotKind::KEYED_STORE_SLOPPY_IC)
return (kind == FeedbackSlotKind::kStorePropertySloppy ||
kind == FeedbackSlotKind::kStoreKeyedSloppy)
? SLOPPY
: STRICT;
}
......@@ -90,52 +90,54 @@ std::ostream& operator<<(std::ostream& os, FeedbackSlotKind kind);
template <typename Derived>
class FeedbackVectorSpecBase {
public:
FeedbackSlot AddCallICSlot() { return AddSlot(FeedbackSlotKind::CALL_IC); }
FeedbackSlot AddCallICSlot() { return AddSlot(FeedbackSlotKind::kCall); }
FeedbackSlot AddLoadICSlot() { return AddSlot(FeedbackSlotKind::LOAD_IC); }
FeedbackSlot AddLoadICSlot() {
return AddSlot(FeedbackSlotKind::kLoadProperty);
}
FeedbackSlot AddLoadGlobalICSlot(TypeofMode typeof_mode) {
return AddSlot(typeof_mode == INSIDE_TYPEOF
? FeedbackSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC
: FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC);
? FeedbackSlotKind::kLoadGlobalInsideTypeof
: FeedbackSlotKind::kLoadGlobalNotInsideTypeof);
}
FeedbackSlot AddCreateClosureSlot() {
return AddSlot(FeedbackSlotKind::CREATE_CLOSURE);
return AddSlot(FeedbackSlotKind::kCreateClosure);
}
FeedbackSlot AddKeyedLoadICSlot() {
return AddSlot(FeedbackSlotKind::KEYED_LOAD_IC);
return AddSlot(FeedbackSlotKind::kLoadKeyed);
}
FeedbackSlot AddStoreICSlot(LanguageMode language_mode) {
STATIC_ASSERT(LANGUAGE_END == 2);
return AddSlot(is_strict(language_mode)
? FeedbackSlotKind::STORE_STRICT_IC
: FeedbackSlotKind::STORE_SLOPPY_IC);
? FeedbackSlotKind::kStorePropertyStrict
: FeedbackSlotKind::kStorePropertySloppy);
}
FeedbackSlot AddKeyedStoreICSlot(LanguageMode language_mode) {
STATIC_ASSERT(LANGUAGE_END == 2);
return AddSlot(is_strict(language_mode)
? FeedbackSlotKind::KEYED_STORE_STRICT_IC
: FeedbackSlotKind::KEYED_STORE_SLOPPY_IC);
? FeedbackSlotKind::kStoreKeyedStrict
: FeedbackSlotKind::kStoreKeyedSloppy);
}
FeedbackSlot AddInterpreterBinaryOpICSlot() {
return AddSlot(FeedbackSlotKind::INTERPRETER_BINARYOP_IC);
return AddSlot(FeedbackSlotKind::kBinaryOp);
}
FeedbackSlot AddInterpreterCompareICSlot() {
return AddSlot(FeedbackSlotKind::INTERPRETER_COMPARE_IC);
return AddSlot(FeedbackSlotKind::kCompareOp);
}
FeedbackSlot AddGeneralSlot() { return AddSlot(FeedbackSlotKind::GENERAL); }
FeedbackSlot AddGeneralSlot() { return AddSlot(FeedbackSlotKind::kGeneral); }
FeedbackSlot AddLiteralSlot() { return AddSlot(FeedbackSlotKind::LITERAL); }
FeedbackSlot AddLiteralSlot() { return AddSlot(FeedbackSlotKind::kLiteral); }
FeedbackSlot AddStoreDataPropertyInLiteralICSlot() {
return AddSlot(FeedbackSlotKind::STORE_DATA_PROPERTY_IN_LITERAL_IC);
return AddSlot(FeedbackSlotKind::kStoreDataPropertyInLiteral);
}
#ifdef OBJECT_PRINT
......@@ -240,7 +242,7 @@ class FeedbackMetadata : public FixedArray {
private:
static const int kFeedbackSlotKindBits = 5;
STATIC_ASSERT(static_cast<int>(FeedbackSlotKind::KINDS_NUMBER) <
STATIC_ASSERT(static_cast<int>(FeedbackSlotKind::kKindsNumber) <
(1 << kFeedbackSlotKindBits));
void SetKind(FeedbackSlot slot, FeedbackSlotKind kind);
......@@ -373,12 +375,12 @@ class FeedbackMetadataIterator {
explicit FeedbackMetadataIterator(Handle<FeedbackMetadata> metadata)
: metadata_handle_(metadata),
next_slot_(FeedbackSlot(0)),
slot_kind_(FeedbackSlotKind::INVALID) {}
slot_kind_(FeedbackSlotKind::kInvalid) {}
explicit FeedbackMetadataIterator(FeedbackMetadata* metadata)
: metadata_(metadata),
next_slot_(FeedbackSlot(0)),
slot_kind_(FeedbackSlotKind::INVALID) {}
slot_kind_(FeedbackSlotKind::kInvalid) {}
inline bool HasNext() const;
......@@ -386,8 +388,8 @@ class FeedbackMetadataIterator {
// Returns slot kind of the last slot returned by Next().
FeedbackSlotKind kind() const {
DCHECK_NE(FeedbackSlotKind::INVALID, slot_kind_);
DCHECK_NE(FeedbackSlotKind::KINDS_NUMBER, slot_kind_);
DCHECK_NE(FeedbackSlotKind::kInvalid, slot_kind_);
DCHECK_NE(FeedbackSlotKind::kKindsNumber, slot_kind_);
return slot_kind_;
}
......@@ -655,11 +657,11 @@ class BinaryOpICNexus final : public FeedbackNexus {
public:
BinaryOpICNexus(Handle<FeedbackVector> vector, FeedbackSlot slot)
: FeedbackNexus(vector, slot) {
DCHECK_EQ(FeedbackSlotKind::INTERPRETER_BINARYOP_IC, vector->GetKind(slot));
DCHECK_EQ(FeedbackSlotKind::kBinaryOp, vector->GetKind(slot));
}
BinaryOpICNexus(FeedbackVector* vector, FeedbackSlot slot)
: FeedbackNexus(vector, slot) {
DCHECK_EQ(FeedbackSlotKind::INTERPRETER_BINARYOP_IC, vector->GetKind(slot));
DCHECK_EQ(FeedbackSlotKind::kBinaryOp, vector->GetKind(slot));
}
void Clear(Code* host);
......@@ -684,11 +686,11 @@ class CompareICNexus final : public FeedbackNexus {
public:
CompareICNexus(Handle<FeedbackVector> vector, FeedbackSlot slot)
: FeedbackNexus(vector, slot) {
DCHECK_EQ(FeedbackSlotKind::INTERPRETER_COMPARE_IC, vector->GetKind(slot));
DCHECK_EQ(FeedbackSlotKind::kCompareOp, vector->GetKind(slot));
}
CompareICNexus(FeedbackVector* vector, FeedbackSlot slot)
: FeedbackNexus(vector, slot) {
DCHECK_EQ(FeedbackSlotKind::INTERPRETER_COMPARE_IC, vector->GetKind(slot));
DCHECK_EQ(FeedbackSlotKind::kCompareOp, vector->GetKind(slot));
}
void Clear(Code* host);
......@@ -714,12 +716,12 @@ class StoreDataPropertyInLiteralICNexus : public FeedbackNexus {
StoreDataPropertyInLiteralICNexus(Handle<FeedbackVector> vector,
FeedbackSlot slot)
: FeedbackNexus(vector, slot) {
DCHECK_EQ(FeedbackSlotKind::STORE_DATA_PROPERTY_IN_LITERAL_IC,
DCHECK_EQ(FeedbackSlotKind::kStoreDataPropertyInLiteral,
vector->GetKind(slot));
}
StoreDataPropertyInLiteralICNexus(FeedbackVector* vector, FeedbackSlot slot)
: FeedbackNexus(vector, slot) {
DCHECK_EQ(FeedbackSlotKind::STORE_DATA_PROPERTY_IN_LITERAL_IC,
DCHECK_EQ(FeedbackSlotKind::kStoreDataPropertyInLiteral,
vector->GetKind(slot));
}
......
src/ic/ic.cc
View file @ 0190a00f
......@@ -199,7 +199,7 @@ void IC::TraceIC(const char* type, Handle<Object> name, State old_state,
IC::IC(FrameDepth depth, Isolate* isolate, FeedbackNexus* nexus)
: isolate_(isolate),
vector_set_(false),
kind_(FeedbackSlotKind::INVALID),
kind_(FeedbackSlotKind::kInvalid),
target_maps_set_(false),
nexus_(nexus) {
// To improve the performance of the (much used) IC code, we unfold a few
......@@ -256,14 +256,14 @@ IC::IC(FrameDepth depth, Isolate* isolate, FeedbackNexus* nexus)
Code* target = this->target();
Code::Kind kind = target->kind();
if (kind == Code::BINARY_OP_IC) {
kind_ = FeedbackSlotKind::INTERPRETER_BINARYOP_IC;
kind_ = FeedbackSlotKind::kBinaryOp;
} else if (kind == Code::COMPARE_IC) {
kind_ = FeedbackSlotKind::INTERPRETER_COMPARE_IC;
kind_ = FeedbackSlotKind::kCompareOp;
} else if (kind == Code::TO_BOOLEAN_IC) {
kind_ = FeedbackSlotKind::TO_BOOLEAN_IC;
kind_ = FeedbackSlotKind::kToBoolean;
} else {
UNREACHABLE();
kind_ = FeedbackSlotKind::INVALID;
kind_ = FeedbackSlotKind::kInvalid;
}
DCHECK(!UseVector());
state_ = StateFromCode(target);
......
src/ic/ic.h
View file @ 0190a00f
......@@ -279,7 +279,7 @@ class LoadIC : public IC {
}
static bool ShouldThrowReferenceError(FeedbackSlotKind kind) {
return kind == FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC;
return kind == FeedbackSlotKind::kLoadGlobalNotInsideTypeof;
}
bool ShouldThrowReferenceError() const {
......
src/objects-printer.cc
View file @ 0190a00f
......@@ -752,61 +752,61 @@ void FeedbackVector::FeedbackVectorPrint(std::ostream& os) { // NOLINT
os << "\n Slot " << slot << " " << kind;
os << " ";
switch (kind) {
case FeedbackSlotKind::LOAD_IC: {
case FeedbackSlotKind::kLoadProperty: {
LoadICNexus nexus(this, slot);
os << Code::ICState2String(nexus.StateFromFeedback());
break;
}
case FeedbackSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC:
case FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC: {
case FeedbackSlotKind::kLoadGlobalInsideTypeof:
case FeedbackSlotKind::kLoadGlobalNotInsideTypeof: {
LoadGlobalICNexus nexus(this, slot);
os << Code::ICState2String(nexus.StateFromFeedback());
break;
}
case FeedbackSlotKind::KEYED_LOAD_IC: {
case FeedbackSlotKind::kLoadKeyed: {
KeyedLoadICNexus nexus(this, slot);
os << Code::ICState2String(nexus.StateFromFeedback());
break;
}
case FeedbackSlotKind::CALL_IC: {
case FeedbackSlotKind::kCall: {
CallICNexus nexus(this, slot);
os << Code::ICState2String(nexus.StateFromFeedback());
break;
}
case FeedbackSlotKind::STORE_SLOPPY_IC:
case FeedbackSlotKind::STORE_STRICT_IC: {
case FeedbackSlotKind::kStorePropertySloppy:
case FeedbackSlotKind::kStorePropertyStrict: {
StoreICNexus nexus(this, slot);
os << Code::ICState2String(nexus.StateFromFeedback());
break;
}
case FeedbackSlotKind::KEYED_STORE_SLOPPY_IC:
case FeedbackSlotKind::KEYED_STORE_STRICT_IC: {
case FeedbackSlotKind::kStoreKeyedSloppy:
case FeedbackSlotKind::kStoreKeyedStrict: {
KeyedStoreICNexus nexus(this, slot);
os << Code::ICState2String(nexus.StateFromFeedback());
break;
}
case FeedbackSlotKind::INTERPRETER_BINARYOP_IC: {
case FeedbackSlotKind::kBinaryOp: {
BinaryOpICNexus nexus(this, slot);
os << Code::ICState2String(nexus.StateFromFeedback());
break;
}
case FeedbackSlotKind::INTERPRETER_COMPARE_IC: {
case FeedbackSlotKind::kCompareOp: {
CompareICNexus nexus(this, slot);
os << Code::ICState2String(nexus.StateFromFeedback());
break;
}
case FeedbackSlotKind::STORE_DATA_PROPERTY_IN_LITERAL_IC: {
case FeedbackSlotKind::kStoreDataPropertyInLiteral: {
StoreDataPropertyInLiteralICNexus nexus(this, slot);
os << Code::ICState2String(nexus.StateFromFeedback());
break;
}
case FeedbackSlotKind::CREATE_CLOSURE:
case FeedbackSlotKind::LITERAL:
case FeedbackSlotKind::GENERAL:
case FeedbackSlotKind::kCreateClosure:
case FeedbackSlotKind::kLiteral:
case FeedbackSlotKind::kGeneral:
break;
case FeedbackSlotKind::TO_BOOLEAN_IC:
case FeedbackSlotKind::INVALID:
case FeedbackSlotKind::KINDS_NUMBER:
case FeedbackSlotKind::kToBoolean:
case FeedbackSlotKind::kInvalid:
case FeedbackSlotKind::kKindsNumber:
UNREACHABLE();
break;
}
......
test/cctest/test-feedback-vector.cc
View file @ 0190a00f
......@@ -79,12 +79,12 @@ TEST(VectorStructure) {
index = vector->GetIndex(helper.slot(7));
CHECK_EQ(FeedbackVector::kReservedIndexCount + 3 +
4 * FeedbackMetadata::GetSlotSize(FeedbackSlotKind::CALL_IC),
4 * FeedbackMetadata::GetSlotSize(FeedbackSlotKind::kCall),
index);
CHECK_EQ(helper.slot(7), vector->ToSlot(index));
CHECK_EQ(FeedbackVector::kReservedIndexCount + 3 +
5 * FeedbackMetadata::GetSlotSize(FeedbackSlotKind::CALL_IC),
5 * FeedbackMetadata::GetSlotSize(FeedbackSlotKind::kCall),
vector->length());
}
......@@ -96,7 +96,7 @@ TEST(VectorStructure) {
vector = NewFeedbackVector(isolate, &spec);
FeedbackVectorHelper helper(vector);
CHECK_EQ(1,
FeedbackMetadata::GetSlotSize(FeedbackSlotKind::CREATE_CLOSURE));
FeedbackMetadata::GetSlotSize(FeedbackSlotKind::kCreateClosure));
FeedbackSlot slot = helper.slot(1);
Cell* cell = Cell::cast(vector->Get(slot));
CHECK_EQ(cell->value(), *factory->undefined_value());
......@@ -143,16 +143,16 @@ TEST(VectorICMetadata) {
FeedbackSlotKind kind = vector->GetKind(helper.slot(i));
switch (i % 4) {
case 0:
CHECK_EQ(FeedbackSlotKind::GENERAL, kind);
CHECK_EQ(FeedbackSlotKind::kGeneral, kind);
break;
case 1:
CHECK_EQ(FeedbackSlotKind::CALL_IC, kind);
CHECK_EQ(FeedbackSlotKind::kCall, kind);
break;
case 2:
CHECK_EQ(FeedbackSlotKind::LOAD_IC, kind);
CHECK_EQ(FeedbackSlotKind::kLoadProperty, kind);
break;
case 3:
CHECK_EQ(FeedbackSlotKind::KEYED_LOAD_IC, kind);
CHECK_EQ(FeedbackSlotKind::kLoadKeyed, kind);
break;
}
}
......@@ -390,9 +390,8 @@ TEST(VectorLoadGlobalICSlotSharing) {
Handle<FeedbackVector>(f->feedback_vector(), isolate);
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(2, helper.slot_count());
CHECK_SLOT_KIND(helper, 0,
FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC);
CHECK_SLOT_KIND(helper, 1, FeedbackSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC);
CHECK_SLOT_KIND(helper, 0, FeedbackSlotKind::kLoadGlobalNotInsideTypeof);
CHECK_SLOT_KIND(helper, 1, FeedbackSlotKind::kLoadGlobalInsideTypeof);
FeedbackSlot slot1 = helper.slot(0);
FeedbackSlot slot2 = helper.slot(1);
CHECK_EQ(MONOMORPHIC,
......@@ -485,12 +484,10 @@ TEST(ReferenceContextAllocatesNoSlots) {
handle(f->feedback_vector(), isolate);
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(4, helper.slot_count());
CHECK_SLOT_KIND(helper, 0, FeedbackSlotKind::STORE_SLOPPY_IC);
CHECK_SLOT_KIND(helper, 1,
FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC);
CHECK_SLOT_KIND(helper, 2, FeedbackSlotKind::STORE_SLOPPY_IC);
CHECK_SLOT_KIND(helper, 3,
FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC);
CHECK_SLOT_KIND(helper, 0, FeedbackSlotKind::kStorePropertySloppy);
CHECK_SLOT_KIND(helper, 1, FeedbackSlotKind::kLoadGlobalNotInsideTypeof);
CHECK_SLOT_KIND(helper, 2, FeedbackSlotKind::kStorePropertySloppy);
CHECK_SLOT_KIND(helper, 3, FeedbackSlotKind::kLoadGlobalNotInsideTypeof);
}
{
......@@ -507,9 +504,8 @@ TEST(ReferenceContextAllocatesNoSlots) {
Handle<FeedbackVector> feedback_vector(f->feedback_vector());
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(2, helper.slot_count());
CHECK_SLOT_KIND(helper, 0,
FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC);
CHECK_SLOT_KIND(helper, 1, FeedbackSlotKind::STORE_STRICT_IC);
CHECK_SLOT_KIND(helper, 0, FeedbackSlotKind::kLoadGlobalNotInsideTypeof);
CHECK_SLOT_KIND(helper, 1, FeedbackSlotKind::kStorePropertyStrict);
}
{
......@@ -528,12 +524,11 @@ TEST(ReferenceContextAllocatesNoSlots) {
Handle<FeedbackVector> feedback_vector(f->feedback_vector());
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(5, helper.slot_count());
CHECK_SLOT_KIND(helper, 0, FeedbackSlotKind::CALL_IC);
CHECK_SLOT_KIND(helper, 1,
FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC);
CHECK_SLOT_KIND(helper, 2, FeedbackSlotKind::STORE_SLOPPY_IC);
CHECK_SLOT_KIND(helper, 3, FeedbackSlotKind::CALL_IC);
CHECK_SLOT_KIND(helper, 4, FeedbackSlotKind::LOAD_IC);
CHECK_SLOT_KIND(helper, 0, FeedbackSlotKind::kCall);
CHECK_SLOT_KIND(helper, 1, FeedbackSlotKind::kLoadGlobalNotInsideTypeof);
CHECK_SLOT_KIND(helper, 2, FeedbackSlotKind::kStorePropertySloppy);
CHECK_SLOT_KIND(helper, 3, FeedbackSlotKind::kCall);
CHECK_SLOT_KIND(helper, 4, FeedbackSlotKind::kLoadProperty);
}
{
......@@ -551,10 +546,9 @@ TEST(ReferenceContextAllocatesNoSlots) {
Handle<FeedbackVector> feedback_vector(f->feedback_vector());
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(3, helper.slot_count());
CHECK_SLOT_KIND(helper, 0,
FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC);
CHECK_SLOT_KIND(helper, 1, FeedbackSlotKind::KEYED_STORE_SLOPPY_IC);
CHECK_SLOT_KIND(helper, 2, FeedbackSlotKind::KEYED_LOAD_IC);
CHECK_SLOT_KIND(helper, 0, FeedbackSlotKind::kLoadGlobalNotInsideTypeof);
CHECK_SLOT_KIND(helper, 1, FeedbackSlotKind::kStoreKeyedSloppy);
CHECK_SLOT_KIND(helper, 2, FeedbackSlotKind::kLoadKeyed);
}
{
......@@ -573,10 +567,9 @@ TEST(ReferenceContextAllocatesNoSlots) {
Handle<FeedbackVector> feedback_vector(f->feedback_vector());
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(3, helper.slot_count());
CHECK_SLOT_KIND(helper, 0,
FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC);
CHECK_SLOT_KIND(helper, 1, FeedbackSlotKind::KEYED_STORE_STRICT_IC);
CHECK_SLOT_KIND(helper, 2, FeedbackSlotKind::KEYED_LOAD_IC);
CHECK_SLOT_KIND(helper, 0, FeedbackSlotKind::kLoadGlobalNotInsideTypeof);
CHECK_SLOT_KIND(helper, 1, FeedbackSlotKind::kStoreKeyedStrict);
CHECK_SLOT_KIND(helper, 2, FeedbackSlotKind::kLoadKeyed);
}
{
......@@ -595,14 +588,13 @@ TEST(ReferenceContextAllocatesNoSlots) {
Handle<FeedbackVector> feedback_vector(f->feedback_vector());
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(7, helper.slot_count());
CHECK_SLOT_KIND(helper, 0,
FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC);
CHECK_SLOT_KIND(helper, 1, FeedbackSlotKind::STORE_STRICT_IC);
CHECK_SLOT_KIND(helper, 2, FeedbackSlotKind::STORE_STRICT_IC);
CHECK_SLOT_KIND(helper, 3, FeedbackSlotKind::STORE_STRICT_IC);
CHECK_SLOT_KIND(helper, 4, FeedbackSlotKind::LOAD_IC);
CHECK_SLOT_KIND(helper, 5, FeedbackSlotKind::LOAD_IC);
CHECK_SLOT_KIND(helper, 6, FeedbackSlotKind::INTERPRETER_BINARYOP_IC);
CHECK_SLOT_KIND(helper, 0, FeedbackSlotKind::kLoadGlobalNotInsideTypeof);
CHECK_SLOT_KIND(helper, 1, FeedbackSlotKind::kStorePropertyStrict);
CHECK_SLOT_KIND(helper, 2, FeedbackSlotKind::kStorePropertyStrict);
CHECK_SLOT_KIND(helper, 3, FeedbackSlotKind::kStorePropertyStrict);
CHECK_SLOT_KIND(helper, 4, FeedbackSlotKind::kLoadProperty);
CHECK_SLOT_KIND(helper, 5, FeedbackSlotKind::kLoadProperty);
CHECK_SLOT_KIND(helper, 6, FeedbackSlotKind::kBinaryOp);
}
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment