1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_OBJECTS_STRING_TABLE_H_
#define V8_OBJECTS_STRING_TABLE_H_
#include "src/common/assert-scope.h"
#include "src/objects/string.h"
#include "src/roots/roots.h"
// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"
namespace v8 {
namespace internal {
// A generic key for lookups into the string table, which allows heteromorphic
// lookup and on-demand creation of new strings.
class StringTableKey {
public:
virtual ~StringTableKey() = default;
inline StringTableKey(uint32_t raw_hash_field, int length);
uint32_t raw_hash_field() const {
DCHECK_NE(0, raw_hash_field_);
return raw_hash_field_;
}
inline uint32_t hash() const;
int length() const { return length_; }
protected:
inline void set_raw_hash_field(uint32_t raw_hash_field);
private:
uint32_t raw_hash_field_ = 0;
int length_;
};
class SeqOneByteString;
// StringTable, for internalizing strings. The Lookup methods are designed to be
// thread-safe, in combination with GC safepoints.
//
// The string table layout is defined by its Data implementation class, see
// StringTable::Data for details.
class V8_EXPORT_PRIVATE StringTable {
public:
static constexpr Smi empty_element() { return Smi::FromInt(0); }
static constexpr Smi deleted_element() { return Smi::FromInt(1); }
explicit StringTable(Isolate* isolate);
~StringTable();
int Capacity() const;
int NumberOfElements() const;
// Find string in the string table. If it is not there yet, it is
// added. The return value is the string found.
Handle<String> LookupString(Isolate* isolate, Handle<String> key);
// Find string in the string table, using the given key. If the string is not
// there yet, it is created (by the key) and added. The return value is the
// string found.
template <typename StringTableKey, typename IsolateT>
Handle<String> LookupKey(IsolateT* isolate, StringTableKey* key);
// {raw_string} must be a tagged String pointer.
// Returns a tagged pointer: either a Smi if the string is an array index, an
// internalized string, or a Smi sentinel.
static Address TryStringToIndexOrLookupExisting(Isolate* isolate,
Address raw_string);
void Print(PtrComprCageBase cage_base) const;
size_t GetCurrentMemoryUsage() const;
// The following methods must be called either while holding the write lock,
// or while in a Heap safepoint.
void IterateElements(RootVisitor* visitor);
void DropOldData();
void NotifyElementsRemoved(int count);
void VerifyIfOwnedBy(Isolate* isolate);
private:
class Data;
Data* EnsureCapacity(PtrComprCageBase cage_base, int additional_elements);
std::atomic<Data*> data_;
// Write mutex is mutable so that readers of concurrently mutated values (e.g.
// NumberOfElements) are allowed to lock it while staying const.
mutable base::Mutex write_mutex_;
Isolate* isolate_;
};
} // namespace internal
} // namespace v8
#include "src/objects/object-macros-undef.h"
#endif // V8_OBJECTS_STRING_TABLE_H_
|
