Line data Source code
1 : // Copyright 2016 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/ast/context-slot-cache.h"
6 :
7 : #include <stdlib.h>
8 :
9 : #include "src/ast/scopes.h"
10 : #include "src/bootstrapper.h"
11 : // FIXME(mstarzinger, marja): This is weird, but required because of the missing
12 : // (disallowed) include: src/factory.h -> src/objects-inl.h
13 : #include "src/objects-inl.h"
14 : // FIXME(mstarzinger, marja): This is weird, but required because of the missing
15 : // (disallowed) include: src/feedback-vector.h ->
16 : // src/feedback-vector-inl.h
17 : #include "src/feedback-vector-inl.h"
18 :
19 : namespace v8 {
20 : namespace internal {
21 :
22 22922509 : int ContextSlotCache::Hash(Object* data, String* name) {
23 : // Uses only lower 32 bits if pointers are larger.
24 : uintptr_t addr_hash =
25 22922509 : static_cast<uint32_t>(reinterpret_cast<uintptr_t>(data)) >> 2;
26 22922509 : return static_cast<int>((addr_hash ^ name->Hash()) % kLength);
27 : }
28 :
29 18659693 : int ContextSlotCache::Lookup(Object* data, String* name, VariableMode* mode,
30 : InitializationFlag* init_flag,
31 : MaybeAssignedFlag* maybe_assigned_flag) {
32 18659693 : int index = Hash(data, name);
33 18659692 : Key& key = keys_[index];
34 18659692 : if ((key.data == data) && key.name->Equals(name)) {
35 14396874 : Value result(values_[index]);
36 28793748 : if (mode != nullptr) *mode = result.mode();
37 28793748 : if (init_flag != nullptr) *init_flag = result.initialization_flag();
38 14396874 : if (maybe_assigned_flag != nullptr)
39 14396874 : *maybe_assigned_flag = result.maybe_assigned_flag();
40 14396874 : return result.index() + kNotFound;
41 : }
42 : return kNotFound;
43 : }
44 :
45 4262819 : void ContextSlotCache::Update(Handle<Object> data, Handle<String> name,
46 : VariableMode mode, InitializationFlag init_flag,
47 : MaybeAssignedFlag maybe_assigned_flag,
48 : int slot_index) {
49 : DisallowHeapAllocation no_gc;
50 : Handle<String> internalized_name;
51 : DCHECK(slot_index > kNotFound);
52 4262819 : if (StringTable::InternalizeStringIfExists(name->GetIsolate(), name)
53 8525638 : .ToHandle(&internalized_name)) {
54 4262819 : int index = Hash(*data, *internalized_name);
55 4262819 : Key& key = keys_[index];
56 : key.data = *data;
57 4262819 : key.name = *internalized_name;
58 : // Please note value only takes a uint as index.
59 : values_[index] =
60 : Value(mode, init_flag, maybe_assigned_flag, slot_index - kNotFound)
61 8525638 : .raw();
62 : #ifdef DEBUG
63 : ValidateEntry(data, name, mode, init_flag, maybe_assigned_flag, slot_index);
64 : #endif
65 : }
66 4262819 : }
67 :
68 53389 : void ContextSlotCache::Clear() {
69 53389 : for (int index = 0; index < kLength; index++) keys_[index].data = nullptr;
70 53389 : }
71 :
72 : #ifdef DEBUG
73 :
74 : void ContextSlotCache::ValidateEntry(Handle<Object> data, Handle<String> name,
75 : VariableMode mode,
76 : InitializationFlag init_flag,
77 : MaybeAssignedFlag maybe_assigned_flag,
78 : int slot_index) {
79 : DisallowHeapAllocation no_gc;
80 : Handle<String> internalized_name;
81 : if (StringTable::InternalizeStringIfExists(name->GetIsolate(), name)
82 : .ToHandle(&internalized_name)) {
83 : int index = Hash(*data, *name);
84 : Key& key = keys_[index];
85 : DCHECK(key.data == *data);
86 : DCHECK(key.name->Equals(*name));
87 : Value result(values_[index]);
88 : DCHECK(result.mode() == mode);
89 : DCHECK(result.initialization_flag() == init_flag);
90 : DCHECK(result.maybe_assigned_flag() == maybe_assigned_flag);
91 : DCHECK(result.index() + kNotFound == slot_index);
92 : }
93 : }
94 :
95 : #endif // DEBUG
96 :
97 : } // namespace internal
98 : } // namespace v8
|