blob: 8737e3bfa11b51e704cf6c681a27de59c675c090 (
plain)
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
|
// Copyright 2020 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_HEAP_LOCAL_FACTORY_H_
#define V8_HEAP_LOCAL_FACTORY_H_
#include <map>
#include <vector>
#include "src/base/logging.h"
#include "src/common/globals.h"
#include "src/handles/handles.h"
#include "src/heap/factory-base.h"
#include "src/heap/heap.h"
#include "src/heap/read-only-heap.h"
#include "src/heap/spaces.h"
#include "src/objects/heap-object.h"
#include "src/objects/map.h"
#include "src/objects/objects.h"
#include "src/objects/shared-function-info.h"
#include "src/roots/roots.h"
namespace v8 {
namespace internal {
class AstValueFactory;
class AstRawString;
class AstConsString;
class LocalIsolate;
class V8_EXPORT_PRIVATE LocalFactory : public FactoryBase<LocalFactory> {
public:
explicit LocalFactory(Isolate* isolate);
ReadOnlyRoots read_only_roots() const { return roots_; }
#define ROOT_ACCESSOR(Type, name, CamelName) inline Handle<Type> name();
READ_ONLY_ROOT_LIST(ROOT_ACCESSOR)
// AccessorInfos appear mutable, but they're actually not mutated once they
// finish initializing. In particular, the root accessors are not mutated and
// are safe to access (as long as the off-thread job doesn't try to mutate
// them).
ACCESSOR_INFO_ROOT_LIST(ROOT_ACCESSOR)
#undef ROOT_ACCESSOR
// The parser shouldn't allow the LocalFactory to get into a state where
// it generates errors.
Handle<Object> NewInvalidStringLengthError() { UNREACHABLE(); }
Handle<Object> NewRangeError(MessageTemplate template_index) {
UNREACHABLE();
}
private:
friend class FactoryBase<LocalFactory>;
// ------
// Customization points for FactoryBase.
HeapObject AllocateRaw(int size, AllocationType allocation,
AllocationAlignment alignment = kTaggedAligned);
LocalIsolate* isolate() {
// Downcast to the privately inherited sub-class using c-style casts to
// avoid undefined behavior (as static_cast cannot cast across private
// bases).
// NOLINTNEXTLINE (google-readability-casting)
return (LocalIsolate*)this; // NOLINT(readability/casting)
}
// This is the real Isolate that will be used for allocating and accessing
// external pointer entries when V8_HEAP_SANDBOX is enabled.
Isolate* isolate_for_heap_sandbox() {
#ifdef V8_HEAP_SANDBOX
return isolate_for_heap_sandbox_;
#else
return nullptr;
#endif // V8_HEAP_SANDBOX
}
inline bool CanAllocateInReadOnlySpace() { return false; }
inline bool EmptyStringRootIsInitialized() { return true; }
inline AllocationType AllocationTypeForInPlaceInternalizableString();
// ------
void AddToScriptList(Handle<Script> shared);
// ------
ReadOnlyRoots roots_;
#ifdef V8_HEAP_SANDBOX
Isolate* isolate_for_heap_sandbox_;
#endif
#ifdef DEBUG
bool a_script_was_added_to_the_script_list_ = false;
#endif
};
} // namespace internal
} // namespace v8
#endif // V8_HEAP_LOCAL_FACTORY_H_
|
