1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "src/ic/stub-cache.h"
6
7 #include "src/base/bits.h"
8 #include "src/type-info.h"
9
10 namespace v8 {
11 namespace internal {
12
13
StubCache(Isolate * isolate)14 StubCache::StubCache(Isolate* isolate) : isolate_(isolate) {}
15
16
Initialize()17 void StubCache::Initialize() {
18 DCHECK(base::bits::IsPowerOfTwo32(kPrimaryTableSize));
19 DCHECK(base::bits::IsPowerOfTwo32(kSecondaryTableSize));
20 Clear();
21 }
22
23
CommonStubCacheChecks(Name * name,Map * map,Code::Flags flags)24 static Code::Flags CommonStubCacheChecks(Name* name, Map* map,
25 Code::Flags flags) {
26 flags = Code::RemoveTypeAndHolderFromFlags(flags);
27
28 // Validate that the name does not move on scavenge, and that we
29 // can use identity checks instead of structural equality checks.
30 DCHECK(!name->GetHeap()->InNewSpace(name));
31 DCHECK(name->IsUniqueName());
32
33 // The state bits are not important to the hash function because the stub
34 // cache only contains handlers. Make sure that the bits are the least
35 // significant so they will be the ones masked out.
36 DCHECK_EQ(Code::HANDLER, Code::ExtractKindFromFlags(flags));
37 STATIC_ASSERT((Code::ICStateField::kMask & 1) == 1);
38
39 // Make sure that the code type and cache holder are not included in the hash.
40 DCHECK(Code::ExtractTypeFromFlags(flags) == 0);
41 DCHECK(Code::ExtractCacheHolderFromFlags(flags) == 0);
42
43 return flags;
44 }
45
46
Set(Name * name,Map * map,Code * code)47 Code* StubCache::Set(Name* name, Map* map, Code* code) {
48 Code::Flags flags = CommonStubCacheChecks(name, map, code->flags());
49
50 // Compute the primary entry.
51 int primary_offset = PrimaryOffset(name, flags, map);
52 Entry* primary = entry(primary_, primary_offset);
53 Code* old_code = primary->value;
54
55 // If the primary entry has useful data in it, we retire it to the
56 // secondary cache before overwriting it.
57 if (old_code != isolate_->builtins()->builtin(Builtins::kIllegal)) {
58 Map* old_map = primary->map;
59 Code::Flags old_flags =
60 Code::RemoveTypeAndHolderFromFlags(old_code->flags());
61 int seed = PrimaryOffset(primary->key, old_flags, old_map);
62 int secondary_offset = SecondaryOffset(primary->key, old_flags, seed);
63 Entry* secondary = entry(secondary_, secondary_offset);
64 *secondary = *primary;
65 }
66
67 // Update primary cache.
68 primary->key = name;
69 primary->value = code;
70 primary->map = map;
71 isolate()->counters()->megamorphic_stub_cache_updates()->Increment();
72 return code;
73 }
74
75
Get(Name * name,Map * map,Code::Flags flags)76 Code* StubCache::Get(Name* name, Map* map, Code::Flags flags) {
77 flags = CommonStubCacheChecks(name, map, flags);
78 int primary_offset = PrimaryOffset(name, flags, map);
79 Entry* primary = entry(primary_, primary_offset);
80 if (primary->key == name && primary->map == map) {
81 return primary->value;
82 }
83 int secondary_offset = SecondaryOffset(name, flags, primary_offset);
84 Entry* secondary = entry(secondary_, secondary_offset);
85 if (secondary->key == name && secondary->map == map) {
86 return secondary->value;
87 }
88 return NULL;
89 }
90
91
Clear()92 void StubCache::Clear() {
93 Code* empty = isolate_->builtins()->builtin(Builtins::kIllegal);
94 for (int i = 0; i < kPrimaryTableSize; i++) {
95 primary_[i].key = isolate()->heap()->empty_string();
96 primary_[i].map = NULL;
97 primary_[i].value = empty;
98 }
99 for (int j = 0; j < kSecondaryTableSize; j++) {
100 secondary_[j].key = isolate()->heap()->empty_string();
101 secondary_[j].map = NULL;
102 secondary_[j].value = empty;
103 }
104 }
105
106
CollectMatchingMaps(SmallMapList * types,Handle<Name> name,Code::Flags flags,Handle<Context> native_context,Zone * zone)107 void StubCache::CollectMatchingMaps(SmallMapList* types, Handle<Name> name,
108 Code::Flags flags,
109 Handle<Context> native_context,
110 Zone* zone) {
111 for (int i = 0; i < kPrimaryTableSize; i++) {
112 if (primary_[i].key == *name) {
113 Map* map = primary_[i].map;
114 // Map can be NULL, if the stub is constant function call
115 // with a primitive receiver.
116 if (map == NULL) continue;
117
118 int offset = PrimaryOffset(*name, flags, map);
119 if (entry(primary_, offset) == &primary_[i] &&
120 TypeFeedbackOracle::IsRelevantFeedback(map, *native_context)) {
121 types->AddMapIfMissing(Handle<Map>(map), zone);
122 }
123 }
124 }
125
126 for (int i = 0; i < kSecondaryTableSize; i++) {
127 if (secondary_[i].key == *name) {
128 Map* map = secondary_[i].map;
129 // Map can be NULL, if the stub is constant function call
130 // with a primitive receiver.
131 if (map == NULL) continue;
132
133 // Lookup in primary table and skip duplicates.
134 int primary_offset = PrimaryOffset(*name, flags, map);
135
136 // Lookup in secondary table and add matches.
137 int offset = SecondaryOffset(*name, flags, primary_offset);
138 if (entry(secondary_, offset) == &secondary_[i] &&
139 TypeFeedbackOracle::IsRelevantFeedback(map, *native_context)) {
140 types->AddMapIfMissing(Handle<Map>(map), zone);
141 }
142 }
143 }
144 }
145 } // namespace internal
146 } // namespace v8
147