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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
|
// Copyright 2011 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_AST_VARIABLES_H_
#define V8_AST_VARIABLES_H_
#include "src/ast/ast-value-factory.h"
#include "src/base/threaded-list.h"
#include "src/common/globals.h"
#include "src/execution/isolate.h"
#include "src/zone/zone.h"
namespace v8 {
namespace internal {
// The AST refers to variables via VariableProxies - placeholders for the actual
// variables. Variables themselves are never directly referred to from the AST,
// they are maintained by scopes, and referred to from VariableProxies and Slots
// after binding and variable allocation.
class Variable final : public ZoneObject {
public:
Variable(Scope* scope, const AstRawString* name, VariableMode mode,
VariableKind kind, InitializationFlag initialization_flag,
MaybeAssignedFlag maybe_assigned_flag = kNotAssigned,
IsStaticFlag is_static_flag = IsStaticFlag::kNotStatic)
: scope_(scope),
name_(name),
local_if_not_shadowed_(nullptr),
next_(nullptr),
index_(-1),
initializer_position_(kNoSourcePosition),
bit_field_(MaybeAssignedFlagField::encode(maybe_assigned_flag) |
InitializationFlagField::encode(initialization_flag) |
VariableModeField::encode(mode) |
IsUsedField::encode(false) |
ForceContextAllocationBit::encode(false) |
ForceHoleInitializationField::encode(false) |
LocationField::encode(VariableLocation::UNALLOCATED) |
VariableKindField::encode(kind) |
IsStaticFlagField::encode(is_static_flag)) {
// Var declared variables never need initialization.
DCHECK(!(mode == VariableMode::kVar &&
initialization_flag == kNeedsInitialization));
DCHECK_IMPLIES(is_static_flag == IsStaticFlag::kStatic,
IsConstVariableMode(mode));
}
explicit Variable(Variable* other);
// The source code for an eval() call may refer to a variable that is
// in an outer scope about which we don't know anything (it may not
// be the script scope). scope() is nullptr in that case. Currently the
// scope is only used to follow the context chain length.
Scope* scope() const { return scope_; }
// This is for adjusting the scope of temporaries used when desugaring
// parameter initializers.
void set_scope(Scope* scope) { scope_ = scope; }
Handle<String> name() const { return name_->string(); }
const AstRawString* raw_name() const { return name_; }
VariableMode mode() const { return VariableModeField::decode(bit_field_); }
void set_mode(VariableMode mode) {
bit_field_ = VariableModeField::update(bit_field_, mode);
}
void set_is_static_flag(IsStaticFlag is_static_flag) {
bit_field_ = IsStaticFlagField::update(bit_field_, is_static_flag);
}
IsStaticFlag is_static_flag() const {
return IsStaticFlagField::decode(bit_field_);
}
bool is_static() const { return is_static_flag() == IsStaticFlag::kStatic; }
bool has_forced_context_allocation() const {
return ForceContextAllocationBit::decode(bit_field_);
}
void ForceContextAllocation() {
DCHECK(IsUnallocated() || IsContextSlot() || IsLookupSlot() ||
location() == VariableLocation::MODULE);
bit_field_ = ForceContextAllocationBit::update(bit_field_, true);
}
bool is_used() { return IsUsedField::decode(bit_field_); }
void set_is_used() { bit_field_ = IsUsedField::update(bit_field_, true); }
MaybeAssignedFlag maybe_assigned() const {
return MaybeAssignedFlagField::decode(bit_field_);
}
void clear_maybe_assigned() {
bit_field_ = MaybeAssignedFlagField::update(bit_field_, kNotAssigned);
}
void SetMaybeAssigned() {
if (mode() == VariableMode::kConst) return;
// Private names are only initialized once by us.
if (name_->IsPrivateName()) {
return;
}
// If this variable is dynamically shadowing another variable, then that
// variable could also be assigned (in the non-shadowing case).
if (has_local_if_not_shadowed()) {
// Avoid repeatedly marking the same tree of variables by only recursing
// when this variable's maybe_assigned status actually changes.
if (!maybe_assigned()) {
local_if_not_shadowed()->SetMaybeAssigned();
}
DCHECK_IMPLIES(local_if_not_shadowed()->mode() != VariableMode::kConst,
local_if_not_shadowed()->maybe_assigned());
}
set_maybe_assigned();
}
bool requires_brand_check() const {
return IsPrivateMethodOrAccessorVariableMode(mode());
}
int initializer_position() { return initializer_position_; }
void set_initializer_position(int pos) { initializer_position_ = pos; }
bool IsUnallocated() const {
return location() == VariableLocation::UNALLOCATED;
}
bool IsParameter() const { return location() == VariableLocation::PARAMETER; }
bool IsStackLocal() const { return location() == VariableLocation::LOCAL; }
bool IsStackAllocated() const { return IsParameter() || IsStackLocal(); }
bool IsContextSlot() const { return location() == VariableLocation::CONTEXT; }
bool IsLookupSlot() const { return location() == VariableLocation::LOOKUP; }
bool IsGlobalObjectProperty() const;
// True for 'let' variables declared in the script scope of a REPL script.
bool IsReplGlobalLet() const;
bool is_dynamic() const { return IsDynamicVariableMode(mode()); }
// Returns the InitializationFlag this Variable was created with.
// Scope analysis may allow us to relax this initialization
// requirement, which will be reflected in the return value of
// binding_needs_init().
InitializationFlag initialization_flag() const {
return InitializationFlagField::decode(bit_field_);
}
// Whether this variable needs to be initialized with the hole at
// declaration time. Only returns valid results after scope analysis.
bool binding_needs_init() const {
DCHECK_IMPLIES(initialization_flag() == kNeedsInitialization,
IsLexicalVariableMode(mode()) ||
IsPrivateMethodOrAccessorVariableMode(mode()));
DCHECK_IMPLIES(ForceHoleInitializationField::decode(bit_field_),
initialization_flag() == kNeedsInitialization);
// Always initialize if hole initialization was forced during
// scope analysis.
if (ForceHoleInitializationField::decode(bit_field_)) return true;
// If initialization was not forced, no need for initialization
// for stack allocated variables, since UpdateNeedsHoleCheck()
// in scopes.cc has proven that no VariableProxy refers to
// this variable in such a way that a runtime hole check
// would be generated.
if (IsStackAllocated()) return false;
// Otherwise, defer to the flag set when this Variable was constructed.
return initialization_flag() == kNeedsInitialization;
}
// Called during scope analysis when a VariableProxy is found to
// reference this Variable in such a way that a hole check will
// be required at runtime.
void ForceHoleInitialization() {
DCHECK_EQ(kNeedsInitialization, initialization_flag());
DCHECK(IsLexicalVariableMode(mode()) ||
IsPrivateMethodOrAccessorVariableMode(mode()));
bit_field_ = ForceHoleInitializationField::update(bit_field_, true);
}
bool throw_on_const_assignment(LanguageMode language_mode) const {
return kind() != SLOPPY_FUNCTION_NAME_VARIABLE || is_strict(language_mode);
}
bool is_this() const { return kind() == THIS_VARIABLE; }
bool is_sloppy_function_name() const {
return kind() == SLOPPY_FUNCTION_NAME_VARIABLE;
}
bool is_parameter() const { return kind() == PARAMETER_VARIABLE; }
bool is_sloppy_block_function() {
return kind() == SLOPPY_BLOCK_FUNCTION_VARIABLE;
}
Variable* local_if_not_shadowed() const {
DCHECK((mode() == VariableMode::kDynamicLocal ||
mode() == VariableMode::kDynamic) &&
has_local_if_not_shadowed());
return local_if_not_shadowed_;
}
bool has_local_if_not_shadowed() const {
return local_if_not_shadowed_ != nullptr;
}
void set_local_if_not_shadowed(Variable* local) {
local_if_not_shadowed_ = local;
}
VariableLocation location() const {
return LocationField::decode(bit_field_);
}
VariableKind kind() const { return VariableKindField::decode(bit_field_); }
int index() const { return index_; }
bool IsReceiver() const {
DCHECK(IsParameter());
return index_ == -1;
}
bool IsExport() const {
DCHECK_EQ(location(), VariableLocation::MODULE);
DCHECK_NE(index(), 0);
return index() > 0;
}
void AllocateTo(VariableLocation location, int index) {
DCHECK(IsUnallocated() ||
(this->location() == location && this->index() == index));
DCHECK_IMPLIES(location == VariableLocation::MODULE, index != 0);
bit_field_ = LocationField::update(bit_field_, location);
DCHECK_EQ(location, this->location());
index_ = index;
}
void MakeParameterNonSimple() {
DCHECK(is_parameter());
bit_field_ = VariableModeField::update(bit_field_, VariableMode::kLet);
bit_field_ =
InitializationFlagField::update(bit_field_, kNeedsInitialization);
}
static InitializationFlag DefaultInitializationFlag(VariableMode mode) {
DCHECK(IsDeclaredVariableMode(mode));
return mode == VariableMode::kVar ? kCreatedInitialized
: kNeedsInitialization;
}
// Rewrites the VariableLocation of repl script scope 'lets' to REPL_GLOBAL.
void RewriteLocationForRepl();
using List = base::ThreadedList<Variable>;
private:
Scope* scope_;
const AstRawString* name_;
// If this field is set, this variable references the stored locally bound
// variable, but it might be shadowed by variable bindings introduced by with
// blocks or sloppy 'eval' calls between the reference scope (inclusive) and
// the binding scope (exclusive).
Variable* local_if_not_shadowed_;
Variable* next_;
int index_;
int initializer_position_;
uint16_t bit_field_;
void set_maybe_assigned() {
bit_field_ = MaybeAssignedFlagField::update(bit_field_, kMaybeAssigned);
}
using VariableModeField = base::BitField16<VariableMode, 0, 4>;
using VariableKindField = VariableModeField::Next<VariableKind, 3>;
using LocationField = VariableKindField::Next<VariableLocation, 3>;
using ForceContextAllocationBit = LocationField::Next<bool, 1>;
using IsUsedField = ForceContextAllocationBit::Next<bool, 1>;
using InitializationFlagField = IsUsedField::Next<InitializationFlag, 1>;
using ForceHoleInitializationField = InitializationFlagField::Next<bool, 1>;
using MaybeAssignedFlagField =
ForceHoleInitializationField::Next<MaybeAssignedFlag, 1>;
using IsStaticFlagField = MaybeAssignedFlagField::Next<IsStaticFlag, 1>;
Variable** next() { return &next_; }
friend List;
friend base::ThreadedListTraits<Variable>;
};
} // namespace internal
} // namespace v8
#endif // V8_AST_VARIABLES_H_
|