Line data Source code
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 : #ifndef V8_AST_AST_H_
6 : #define V8_AST_AST_H_
7 :
8 : #include "src/ast/ast-types.h"
9 : #include "src/ast/ast-value-factory.h"
10 : #include "src/ast/modules.h"
11 : #include "src/ast/variables.h"
12 : #include "src/bailout-reason.h"
13 : #include "src/base/flags.h"
14 : #include "src/factory.h"
15 : #include "src/globals.h"
16 : #include "src/isolate.h"
17 : #include "src/label.h"
18 : #include "src/list.h"
19 : #include "src/objects/literal-objects.h"
20 : #include "src/parsing/token.h"
21 : #include "src/runtime/runtime.h"
22 : #include "src/small-pointer-list.h"
23 :
24 : namespace v8 {
25 : namespace internal {
26 :
27 : // The abstract syntax tree is an intermediate, light-weight
28 : // representation of the parsed JavaScript code suitable for
29 : // compilation to native code.
30 :
31 : // Nodes are allocated in a separate zone, which allows faster
32 : // allocation and constant-time deallocation of the entire syntax
33 : // tree.
34 :
35 :
36 : // ----------------------------------------------------------------------------
37 : // Nodes of the abstract syntax tree. Only concrete classes are
38 : // enumerated here.
39 :
40 : #define DECLARATION_NODE_LIST(V) \
41 : V(VariableDeclaration) \
42 : V(FunctionDeclaration)
43 :
44 : #define ITERATION_NODE_LIST(V) \
45 : V(DoWhileStatement) \
46 : V(WhileStatement) \
47 : V(ForStatement) \
48 : V(ForInStatement) \
49 : V(ForOfStatement)
50 :
51 : #define BREAKABLE_NODE_LIST(V) \
52 : V(Block) \
53 : V(SwitchStatement)
54 :
55 : #define STATEMENT_NODE_LIST(V) \
56 : ITERATION_NODE_LIST(V) \
57 : BREAKABLE_NODE_LIST(V) \
58 : V(ExpressionStatement) \
59 : V(EmptyStatement) \
60 : V(SloppyBlockFunctionStatement) \
61 : V(IfStatement) \
62 : V(ContinueStatement) \
63 : V(BreakStatement) \
64 : V(ReturnStatement) \
65 : V(WithStatement) \
66 : V(TryCatchStatement) \
67 : V(TryFinallyStatement) \
68 : V(DebuggerStatement)
69 :
70 : #define LITERAL_NODE_LIST(V) \
71 : V(RegExpLiteral) \
72 : V(ObjectLiteral) \
73 : V(ArrayLiteral)
74 :
75 : #define PROPERTY_NODE_LIST(V) \
76 : V(Assignment) \
77 : V(CountOperation) \
78 : V(Property)
79 :
80 : #define CALL_NODE_LIST(V) \
81 : V(Call) \
82 : V(CallNew)
83 :
84 : #define EXPRESSION_NODE_LIST(V) \
85 : LITERAL_NODE_LIST(V) \
86 : PROPERTY_NODE_LIST(V) \
87 : CALL_NODE_LIST(V) \
88 : V(FunctionLiteral) \
89 : V(ClassLiteral) \
90 : V(NativeFunctionLiteral) \
91 : V(Conditional) \
92 : V(VariableProxy) \
93 : V(Literal) \
94 : V(Suspend) \
95 : V(Throw) \
96 : V(CallRuntime) \
97 : V(UnaryOperation) \
98 : V(BinaryOperation) \
99 : V(CompareOperation) \
100 : V(Spread) \
101 : V(ThisFunction) \
102 : V(SuperPropertyReference) \
103 : V(SuperCallReference) \
104 : V(CaseClause) \
105 : V(EmptyParentheses) \
106 : V(GetIterator) \
107 : V(DoExpression) \
108 : V(RewritableExpression) \
109 : V(ImportCallExpression)
110 :
111 : #define AST_NODE_LIST(V) \
112 : DECLARATION_NODE_LIST(V) \
113 : STATEMENT_NODE_LIST(V) \
114 : EXPRESSION_NODE_LIST(V)
115 :
116 : // Forward declarations
117 : class AstNodeFactory;
118 : class Declaration;
119 : class Module;
120 : class BreakableStatement;
121 : class Expression;
122 : class IterationStatement;
123 : class MaterializedLiteral;
124 : class Statement;
125 : class TypeFeedbackOracle;
126 :
127 : #define DEF_FORWARD_DECLARATION(type) class type;
128 : AST_NODE_LIST(DEF_FORWARD_DECLARATION)
129 : #undef DEF_FORWARD_DECLARATION
130 :
131 : class FeedbackSlotCache {
132 : public:
133 : typedef std::pair<TypeofMode, Variable*> Key;
134 :
135 : explicit FeedbackSlotCache(Zone* zone) : map_(zone) {}
136 :
137 : void Put(TypeofMode typeof_mode, Variable* variable, FeedbackSlot slot) {
138 : Key key = std::make_pair(typeof_mode, variable);
139 : auto entry = std::make_pair(key, slot);
140 : map_.insert(entry);
141 : }
142 :
143 4772403 : FeedbackSlot Get(TypeofMode typeof_mode, Variable* variable) const {
144 4772403 : Key key = std::make_pair(typeof_mode, variable);
145 : auto iter = map_.find(key);
146 4772402 : if (iter != map_.end()) {
147 1740057 : return iter->second;
148 : }
149 3032345 : return FeedbackSlot();
150 : }
151 :
152 : private:
153 : ZoneMap<Key, FeedbackSlot> map_;
154 : };
155 :
156 :
157 3491858 : class AstProperties final BASE_EMBEDDED {
158 : public:
159 : enum Flag {
160 : kNoFlags = 0,
161 : kDontSelfOptimize = 1 << 0,
162 : kMustUseIgnitionTurbo = 1 << 1
163 : };
164 :
165 : typedef base::Flags<Flag> Flags;
166 :
167 13519498 : explicit AstProperties(Zone* zone) : node_count_(0), spec_(zone) {}
168 :
169 : Flags& flags() { return flags_; }
170 : Flags flags() const { return flags_; }
171 : int node_count() { return node_count_; }
172 153642198 : void add_node_count(int count) { node_count_ += count; }
173 :
174 : const FeedbackVectorSpec* get_spec() const { return &spec_; }
175 : FeedbackVectorSpec* get_spec() { return &spec_; }
176 :
177 : private:
178 : Flags flags_;
179 : int node_count_;
180 : FeedbackVectorSpec spec_;
181 : };
182 :
183 : DEFINE_OPERATORS_FOR_FLAGS(AstProperties::Flags)
184 :
185 :
186 : class AstNode: public ZoneObject {
187 : public:
188 : #define DECLARE_TYPE_ENUM(type) k##type,
189 : enum NodeType : uint8_t { AST_NODE_LIST(DECLARE_TYPE_ENUM) };
190 : #undef DECLARE_TYPE_ENUM
191 :
192 430847895 : void* operator new(size_t size, Zone* zone) { return zone->New(size); }
193 :
194 2610048886 : NodeType node_type() const { return NodeTypeField::decode(bit_field_); }
195 167982 : int position() const { return position_; }
196 :
197 : #ifdef DEBUG
198 : void Print();
199 : void Print(Isolate* isolate);
200 : #endif // DEBUG
201 :
202 : // Type testing & conversion functions overridden by concrete subclasses.
203 : #define DECLARE_NODE_FUNCTIONS(type) \
204 : V8_INLINE bool Is##type() const; \
205 : V8_INLINE type* As##type(); \
206 : V8_INLINE const type* As##type() const;
207 : AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
208 : #undef DECLARE_NODE_FUNCTIONS
209 :
210 : BreakableStatement* AsBreakableStatement();
211 : IterationStatement* AsIterationStatement();
212 : MaterializedLiteral* AsMaterializedLiteral();
213 :
214 : private:
215 : // Hidden to prevent accidental usage. It would have to load the
216 : // current zone from the TLS.
217 : void* operator new(size_t size);
218 :
219 : int position_;
220 : class NodeTypeField : public BitField<NodeType, 0, 6> {};
221 :
222 : protected:
223 : uint32_t bit_field_;
224 : static const uint8_t kNextBitFieldIndex = NodeTypeField::kNext;
225 :
226 : AstNode(int position, NodeType type)
227 430847768 : : position_(position), bit_field_(NodeTypeField::encode(type)) {}
228 : };
229 :
230 :
231 : class Statement : public AstNode {
232 : public:
233 105114992 : bool IsEmpty() { return AsEmptyStatement() != NULL; }
234 : bool IsJump() const;
235 :
236 : protected:
237 : Statement(int position, NodeType type) : AstNode(position, type) {}
238 :
239 : static const uint8_t kNextBitFieldIndex = AstNode::kNextBitFieldIndex;
240 : };
241 :
242 :
243 : class SmallMapList final {
244 : public:
245 : SmallMapList() {}
246 : SmallMapList(int capacity, Zone* zone) : list_(capacity, zone) {}
247 :
248 175865 : void Reserve(int capacity, Zone* zone) { list_.Reserve(capacity, zone); }
249 : void Clear() { list_.Clear(); }
250 89 : void Sort() { list_.Sort(); }
251 :
252 : bool is_empty() const { return list_.is_empty(); }
253 : int length() const { return list_.length(); }
254 :
255 196175 : void AddMapIfMissing(Handle<Map> map, Zone* zone) {
256 392350 : if (!Map::TryUpdate(map).ToHandle(&map)) return;
257 251099 : for (int i = 0; i < length(); ++i) {
258 29225 : if (at(i).is_identical_to(map)) return;
259 : }
260 : Add(map, zone);
261 : }
262 :
263 104464 : void FilterForPossibleTransitions(Map* root_map) {
264 209326 : for (int i = list_.length() - 1; i >= 0; i--) {
265 104862 : if (at(i)->FindRootMap() != root_map) {
266 1210 : list_.RemoveElement(list_.at(i));
267 : }
268 : }
269 104464 : }
270 :
271 : void Add(Handle<Map> handle, Zone* zone) {
272 270663 : list_.Add(handle.location(), zone);
273 : }
274 :
275 : Handle<Map> at(int i) const {
276 : return Handle<Map>(list_.at(i));
277 : }
278 :
279 : Handle<Map> first() const { return at(0); }
280 : Handle<Map> last() const { return at(length() - 1); }
281 :
282 : private:
283 : // The list stores pointers to Map*, that is Map**, so it's GC safe.
284 : SmallPointerList<Map*> list_;
285 :
286 : DISALLOW_COPY_AND_ASSIGN(SmallMapList);
287 : };
288 :
289 :
290 : class Expression : public AstNode {
291 : public:
292 : enum Context {
293 : // Not assigned a context yet, or else will not be visited during
294 : // code generation.
295 : kUninitialized,
296 : // Evaluated for its side effects.
297 : kEffect,
298 : // Evaluated for its value (and side effects).
299 : kValue,
300 : // Evaluated for control flow (and side effects).
301 : kTest
302 : };
303 :
304 : // Mark this expression as being in tail position.
305 : void MarkTail();
306 :
307 : // True iff the expression is a valid reference expression.
308 : bool IsValidReferenceExpression() const;
309 :
310 : // Helpers for ToBoolean conversion.
311 : bool ToBooleanIsTrue() const;
312 : bool ToBooleanIsFalse() const;
313 :
314 : // Symbols that cannot be parsed as array indices are considered property
315 : // names. We do not treat symbols that can be array indexes as property
316 : // names because [] for string objects is handled only by keyed ICs.
317 : bool IsPropertyName() const;
318 :
319 : // True iff the expression is a class or function expression without
320 : // a syntactic name.
321 : bool IsAnonymousFunctionDefinition() const;
322 :
323 : // True iff the expression is a literal represented as a smi.
324 : bool IsSmiLiteral() const;
325 :
326 : // True iff the expression is a literal represented as a number.
327 : bool IsNumberLiteral() const;
328 :
329 : // True iff the expression is a string literal.
330 : bool IsStringLiteral() const;
331 :
332 : // True iff the expression is the null literal.
333 : bool IsNullLiteral() const;
334 :
335 : // True if we can prove that the expression is the undefined literal. Note
336 : // that this also checks for loads of the global "undefined" variable.
337 : bool IsUndefinedLiteral() const;
338 :
339 : // True iff the expression is a valid target for an assignment.
340 : bool IsValidReferenceExpressionOrThis() const;
341 :
342 : // TODO(rossberg): this should move to its own AST node eventually.
343 : void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle);
344 : uint16_t to_boolean_types() const {
345 : return ToBooleanTypesField::decode(bit_field_);
346 : }
347 :
348 : SmallMapList* GetReceiverTypes();
349 : KeyedAccessStoreMode GetStoreMode() const;
350 : IcCheckType GetKeyType() const;
351 : bool IsMonomorphic() const;
352 :
353 117408119 : void set_base_id(int id) { base_id_ = id; }
354 : static int num_ids() { return parent_num_ids() + 2; }
355 : BailoutId id() const { return BailoutId(local_id(0)); }
356 : TypeFeedbackId test_id() const { return TypeFeedbackId(local_id(1)); }
357 :
358 : private:
359 25812438 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
360 :
361 : int base_id_;
362 : class ToBooleanTypesField
363 : : public BitField<uint16_t, AstNode::kNextBitFieldIndex, 9> {};
364 :
365 : protected:
366 : Expression(int pos, NodeType type)
367 327216011 : : AstNode(pos, type), base_id_(BailoutId::None().ToInt()) {
368 : bit_field_ = ToBooleanTypesField::update(bit_field_, 0);
369 : }
370 :
371 : static int parent_num_ids() { return 0; }
372 : void set_to_boolean_types(uint16_t types) {
373 2714298 : bit_field_ = ToBooleanTypesField::update(bit_field_, types);
374 : }
375 : int base_id() const {
376 : DCHECK(!BailoutId(base_id_).IsNone());
377 : return base_id_;
378 : }
379 :
380 : static const uint8_t kNextBitFieldIndex = ToBooleanTypesField::kNext;
381 : };
382 :
383 :
384 : class BreakableStatement : public Statement {
385 : public:
386 : enum BreakableType {
387 : TARGET_FOR_ANONYMOUS,
388 : TARGET_FOR_NAMED_ONLY
389 : };
390 :
391 : // The labels associated with this statement. May be NULL;
392 : // if it is != NULL, guaranteed to contain at least one entry.
393 : ZoneList<const AstRawString*>* labels() const { return labels_; }
394 :
395 : // Code generation
396 : Label* break_target() { return &break_target_; }
397 :
398 : // Testers.
399 : bool is_target_for_anonymous() const {
400 : return BreakableTypeField::decode(bit_field_) == TARGET_FOR_ANONYMOUS;
401 : }
402 :
403 8387753 : void set_base_id(int id) { base_id_ = id; }
404 : static int num_ids() { return parent_num_ids() + 2; }
405 : BailoutId EntryId() const { return BailoutId(local_id(0)); }
406 : BailoutId ExitId() const { return BailoutId(local_id(1)); }
407 :
408 : private:
409 2308440 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
410 :
411 : BreakableType breakableType() const {
412 : return BreakableTypeField::decode(bit_field_);
413 : }
414 :
415 : int base_id_;
416 : Label break_target_;
417 : ZoneList<const AstRawString*>* labels_;
418 :
419 : class BreakableTypeField
420 : : public BitField<BreakableType, Statement::kNextBitFieldIndex, 1> {};
421 :
422 : protected:
423 : BreakableStatement(ZoneList<const AstRawString*>* labels,
424 : BreakableType breakable_type, int position, NodeType type)
425 : : Statement(position, type),
426 : base_id_(BailoutId::None().ToInt()),
427 50099318 : labels_(labels) {
428 : DCHECK(labels == NULL || labels->length() > 0);
429 23820101 : bit_field_ |= BreakableTypeField::encode(breakable_type);
430 : }
431 : static int parent_num_ids() { return 0; }
432 :
433 : int base_id() const {
434 : DCHECK(!BailoutId(base_id_).IsNone());
435 : return base_id_;
436 : }
437 :
438 : static const uint8_t kNextBitFieldIndex = BreakableTypeField::kNext;
439 : };
440 :
441 :
442 : class Block final : public BreakableStatement {
443 : public:
444 880818 : ZoneList<Statement*>* statements() { return &statements_; }
445 : bool ignore_completion_value() const {
446 : return IgnoreCompletionField::decode(bit_field_);
447 : }
448 :
449 : static int num_ids() { return parent_num_ids() + 1; }
450 : BailoutId DeclsId() const { return BailoutId(local_id(0)); }
451 :
452 7514678 : bool IsJump() const {
453 12916213 : return !statements_.is_empty() && statements_.last()->IsJump()
454 8074435 : && labels() == NULL; // Good enough as an approximation...
455 : }
456 :
457 : Scope* scope() const { return scope_; }
458 6380002 : void set_scope(Scope* scope) { scope_ = scope; }
459 :
460 : private:
461 : friend class AstNodeFactory;
462 :
463 : Block(Zone* zone, ZoneList<const AstRawString*>* labels, int capacity,
464 : bool ignore_completion_value, int pos)
465 : : BreakableStatement(labels, TARGET_FOR_NAMED_ONLY, pos, kBlock),
466 : statements_(capacity, zone),
467 23820101 : scope_(NULL) {
468 23820100 : bit_field_ |= IgnoreCompletionField::encode(ignore_completion_value);
469 : }
470 : static int parent_num_ids() { return BreakableStatement::num_ids(); }
471 1994152 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
472 :
473 : ZoneList<Statement*> statements_;
474 : Scope* scope_;
475 :
476 : class IgnoreCompletionField
477 : : public BitField<bool, BreakableStatement::kNextBitFieldIndex, 1> {};
478 : };
479 :
480 :
481 : class DoExpression final : public Expression {
482 : public:
483 : Block* block() { return block_; }
484 0 : void set_block(Block* b) { block_ = b; }
485 : VariableProxy* result() { return result_; }
486 0 : void set_result(VariableProxy* v) { result_ = v; }
487 : FunctionLiteral* represented_function() { return represented_function_; }
488 92611 : void set_represented_function(FunctionLiteral* f) {
489 92611 : represented_function_ = f;
490 92611 : }
491 : bool IsAnonymousFunctionDefinition() const;
492 :
493 : private:
494 : friend class AstNodeFactory;
495 :
496 : DoExpression(Block* block, VariableProxy* result, int pos)
497 : : Expression(pos, kDoExpression),
498 : block_(block),
499 : result_(result),
500 435266 : represented_function_(nullptr) {
501 : DCHECK_NOT_NULL(block_);
502 : DCHECK_NOT_NULL(result_);
503 : }
504 : static int parent_num_ids() { return Expression::num_ids(); }
505 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
506 :
507 : Block* block_;
508 : VariableProxy* result_;
509 : FunctionLiteral* represented_function_;
510 : };
511 :
512 :
513 : class Declaration : public AstNode {
514 : public:
515 : typedef ThreadedList<Declaration> List;
516 :
517 99748 : VariableProxy* proxy() const { return proxy_; }
518 : Scope* scope() const { return scope_; }
519 :
520 : protected:
521 : Declaration(VariableProxy* proxy, Scope* scope, int pos, NodeType type)
522 16427514 : : AstNode(pos, type), proxy_(proxy), scope_(scope), next_(nullptr) {}
523 :
524 : private:
525 : VariableProxy* proxy_;
526 : // Nested scope from which the declaration originated.
527 : Scope* scope_;
528 : // Declarations list threaded through the declarations.
529 : Declaration** next() { return &next_; }
530 : Declaration* next_;
531 : friend List;
532 : };
533 :
534 :
535 : class VariableDeclaration final : public Declaration {
536 : private:
537 : friend class AstNodeFactory;
538 :
539 : VariableDeclaration(VariableProxy* proxy, Scope* scope, int pos)
540 : : Declaration(proxy, scope, pos, kVariableDeclaration) {}
541 : };
542 :
543 :
544 : class FunctionDeclaration final : public Declaration {
545 : public:
546 : FunctionLiteral* fun() const { return fun_; }
547 22512 : void set_fun(FunctionLiteral* f) { fun_ = f; }
548 :
549 : private:
550 : friend class AstNodeFactory;
551 :
552 : FunctionDeclaration(VariableProxy* proxy, FunctionLiteral* fun, Scope* scope,
553 : int pos)
554 1752082 : : Declaration(proxy, scope, pos, kFunctionDeclaration), fun_(fun) {
555 : DCHECK(fun != NULL);
556 : }
557 :
558 : FunctionLiteral* fun_;
559 : };
560 :
561 :
562 : class IterationStatement : public BreakableStatement {
563 : public:
564 : Statement* body() const { return body_; }
565 80268 : void set_body(Statement* s) { body_ = s; }
566 :
567 : int suspend_count() const { return suspend_count_; }
568 : int first_suspend_id() const { return first_suspend_id_; }
569 355206 : void set_suspend_count(int suspend_count) { suspend_count_ = suspend_count; }
570 : void set_first_suspend_id(int first_suspend_id) {
571 355206 : first_suspend_id_ = first_suspend_id;
572 : }
573 :
574 : static int num_ids() { return parent_num_ids() + 1; }
575 : BailoutId OsrEntryId() const { return BailoutId(local_id(0)); }
576 :
577 : // Code generation
578 : Label* continue_target() { return &continue_target_; }
579 :
580 : protected:
581 : IterationStatement(ZoneList<const AstRawString*>* labels, int pos,
582 : NodeType type)
583 : : BreakableStatement(labels, TARGET_FOR_ANONYMOUS, pos, type),
584 : body_(NULL),
585 : suspend_count_(0),
586 2274408 : first_suspend_id_(0) {}
587 : static int parent_num_ids() { return BreakableStatement::num_ids(); }
588 1109793 : void Initialize(Statement* body) { body_ = body; }
589 :
590 : static const uint8_t kNextBitFieldIndex =
591 : BreakableStatement::kNextBitFieldIndex;
592 :
593 : private:
594 288615 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
595 :
596 : Statement* body_;
597 : Label continue_target_;
598 : int suspend_count_;
599 : int first_suspend_id_;
600 : };
601 :
602 :
603 : class DoWhileStatement final : public IterationStatement {
604 : public:
605 : void Initialize(Expression* cond, Statement* body) {
606 : IterationStatement::Initialize(body);
607 13845 : cond_ = cond;
608 : }
609 :
610 : Expression* cond() const { return cond_; }
611 0 : void set_cond(Expression* e) { cond_ = e; }
612 :
613 : static int num_ids() { return parent_num_ids() + 2; }
614 : BailoutId ContinueId() const { return BailoutId(local_id(0)); }
615 : BailoutId StackCheckId() const { return BackEdgeId(); }
616 : BailoutId BackEdgeId() const { return BailoutId(local_id(1)); }
617 :
618 : private:
619 : friend class AstNodeFactory;
620 :
621 : DoWhileStatement(ZoneList<const AstRawString*>* labels, int pos)
622 14676 : : IterationStatement(labels, pos, kDoWhileStatement), cond_(NULL) {}
623 : static int parent_num_ids() { return IterationStatement::num_ids(); }
624 8808 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
625 :
626 : Expression* cond_;
627 : };
628 :
629 :
630 : class WhileStatement final : public IterationStatement {
631 : public:
632 : void Initialize(Expression* cond, Statement* body) {
633 : IterationStatement::Initialize(body);
634 111535 : cond_ = cond;
635 : }
636 :
637 : Expression* cond() const { return cond_; }
638 0 : void set_cond(Expression* e) { cond_ = e; }
639 :
640 : static int num_ids() { return parent_num_ids() + 1; }
641 : BailoutId ContinueId() const { return EntryId(); }
642 : BailoutId StackCheckId() const { return BodyId(); }
643 : BailoutId BodyId() const { return BailoutId(local_id(0)); }
644 :
645 : private:
646 : friend class AstNodeFactory;
647 :
648 : WhileStatement(ZoneList<const AstRawString*>* labels, int pos)
649 112260 : : IterationStatement(labels, pos, kWhileStatement), cond_(NULL) {}
650 : static int parent_num_ids() { return IterationStatement::num_ids(); }
651 20044 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
652 :
653 : Expression* cond_;
654 : };
655 :
656 :
657 : class ForStatement final : public IterationStatement {
658 : public:
659 : void Initialize(Statement* init,
660 : Expression* cond,
661 : Statement* next,
662 : Statement* body) {
663 : IterationStatement::Initialize(body);
664 785243 : init_ = init;
665 785243 : cond_ = cond;
666 785243 : next_ = next;
667 : }
668 :
669 : Statement* init() const { return init_; }
670 : Expression* cond() const { return cond_; }
671 : Statement* next() const { return next_; }
672 :
673 0 : void set_init(Statement* s) { init_ = s; }
674 0 : void set_cond(Expression* e) { cond_ = e; }
675 0 : void set_next(Statement* s) { next_ = s; }
676 :
677 : static int num_ids() { return parent_num_ids() + 2; }
678 : BailoutId ContinueId() const { return BailoutId(local_id(0)); }
679 : BailoutId StackCheckId() const { return BodyId(); }
680 : BailoutId BodyId() const { return BailoutId(local_id(1)); }
681 :
682 : private:
683 : friend class AstNodeFactory;
684 :
685 : ForStatement(ZoneList<const AstRawString*>* labels, int pos)
686 : : IterationStatement(labels, pos, kForStatement),
687 : init_(NULL),
688 : cond_(NULL),
689 787600 : next_(NULL) {}
690 : static int parent_num_ids() { return IterationStatement::num_ids(); }
691 276690 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
692 :
693 : Statement* init_;
694 : Expression* cond_;
695 : Statement* next_;
696 : };
697 :
698 :
699 : class ForEachStatement : public IterationStatement {
700 : public:
701 : enum VisitMode {
702 : ENUMERATE, // for (each in subject) body;
703 : ITERATE // for (each of subject) body;
704 : };
705 :
706 : using IterationStatement::Initialize;
707 :
708 : static const char* VisitModeString(VisitMode mode) {
709 5577 : return mode == ITERATE ? "for-of" : "for-in";
710 : }
711 :
712 : protected:
713 : ForEachStatement(ZoneList<const AstRawString*>* labels, int pos,
714 : NodeType type)
715 : : IterationStatement(labels, pos, type) {}
716 : };
717 :
718 :
719 : class ForInStatement final : public ForEachStatement {
720 : public:
721 : void Initialize(Expression* each, Expression* subject, Statement* body) {
722 : ForEachStatement::Initialize(body);
723 65271 : each_ = each;
724 65271 : subject_ = subject;
725 : }
726 :
727 18917 : Expression* enumerable() const {
728 : return subject();
729 : }
730 :
731 : Expression* each() const { return each_; }
732 : Expression* subject() const { return subject_; }
733 :
734 0 : void set_each(Expression* e) { each_ = e; }
735 0 : void set_subject(Expression* e) { subject_ = e; }
736 :
737 : // Type feedback information.
738 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
739 : FeedbackSlotCache* cache);
740 : FeedbackSlot EachFeedbackSlot() const { return each_slot_; }
741 : FeedbackSlot ForInFeedbackSlot() {
742 : DCHECK(!for_in_feedback_slot_.IsInvalid());
743 : return for_in_feedback_slot_;
744 : }
745 :
746 : enum ForInType { FAST_FOR_IN, SLOW_FOR_IN };
747 : ForInType for_in_type() const { return ForInTypeField::decode(bit_field_); }
748 : void set_for_in_type(ForInType type) {
749 2280 : bit_field_ = ForInTypeField::update(bit_field_, type);
750 : }
751 :
752 : static int num_ids() { return parent_num_ids() + 7; }
753 : BailoutId BodyId() const { return BailoutId(local_id(0)); }
754 : BailoutId EnumId() const { return BailoutId(local_id(1)); }
755 : BailoutId ToObjectId() const { return BailoutId(local_id(2)); }
756 : BailoutId PrepareId() const { return BailoutId(local_id(3)); }
757 : BailoutId FilterId() const { return BailoutId(local_id(4)); }
758 : BailoutId AssignmentId() const { return BailoutId(local_id(5)); }
759 : BailoutId IncrementId() const { return BailoutId(local_id(6)); }
760 : BailoutId StackCheckId() const { return BodyId(); }
761 :
762 : private:
763 : friend class AstNodeFactory;
764 :
765 : ForInStatement(ZoneList<const AstRawString*>* labels, int pos)
766 : : ForEachStatement(labels, pos, kForInStatement),
767 : each_(nullptr),
768 71499 : subject_(nullptr) {
769 71499 : bit_field_ = ForInTypeField::update(bit_field_, SLOW_FOR_IN);
770 : }
771 :
772 : static int parent_num_ids() { return ForEachStatement::num_ids(); }
773 25939 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
774 :
775 : Expression* each_;
776 : Expression* subject_;
777 : FeedbackSlot each_slot_;
778 : FeedbackSlot for_in_feedback_slot_;
779 :
780 : class ForInTypeField
781 : : public BitField<ForInType, ForEachStatement::kNextBitFieldIndex, 1> {};
782 : };
783 :
784 :
785 : class ForOfStatement final : public ForEachStatement {
786 : public:
787 : void Initialize(Statement* body, Variable* iterator,
788 : Expression* assign_iterator, Expression* next_result,
789 : Expression* result_done, Expression* assign_each) {
790 : ForEachStatement::Initialize(body);
791 133899 : iterator_ = iterator;
792 133899 : assign_iterator_ = assign_iterator;
793 133899 : next_result_ = next_result;
794 133899 : result_done_ = result_done;
795 133899 : assign_each_ = assign_each;
796 : }
797 :
798 : Variable* iterator() const {
799 : return iterator_;
800 : }
801 :
802 : // iterator = subject[Symbol.iterator]()
803 : Expression* assign_iterator() const {
804 : return assign_iterator_;
805 : }
806 :
807 : // result = iterator.next() // with type check
808 : Expression* next_result() const {
809 : return next_result_;
810 : }
811 :
812 : // result.done
813 : Expression* result_done() const {
814 : return result_done_;
815 : }
816 :
817 : // each = result.value
818 : Expression* assign_each() const {
819 : return assign_each_;
820 : }
821 :
822 0 : void set_assign_iterator(Expression* e) { assign_iterator_ = e; }
823 0 : void set_next_result(Expression* e) { next_result_ = e; }
824 0 : void set_result_done(Expression* e) { result_done_ = e; }
825 0 : void set_assign_each(Expression* e) { assign_each_ = e; }
826 :
827 : private:
828 : friend class AstNodeFactory;
829 :
830 : ForOfStatement(ZoneList<const AstRawString*>* labels, int pos)
831 : : ForEachStatement(labels, pos, kForOfStatement),
832 : iterator_(NULL),
833 : assign_iterator_(NULL),
834 : next_result_(NULL),
835 : result_done_(NULL),
836 151169 : assign_each_(NULL) {}
837 :
838 : Variable* iterator_;
839 : Expression* assign_iterator_;
840 : Expression* next_result_;
841 : Expression* result_done_;
842 : Expression* assign_each_;
843 : };
844 :
845 :
846 : class ExpressionStatement final : public Statement {
847 : public:
848 1492824 : void set_expression(Expression* e) { expression_ = e; }
849 5849170 : Expression* expression() const { return expression_; }
850 37837202 : bool IsJump() const { return expression_->IsThrow(); }
851 :
852 : private:
853 : friend class AstNodeFactory;
854 :
855 : ExpressionStatement(Expression* expression, int pos)
856 38736597 : : Statement(pos, kExpressionStatement), expression_(expression) {}
857 :
858 : Expression* expression_;
859 : };
860 :
861 :
862 : class JumpStatement : public Statement {
863 : public:
864 : bool IsJump() const { return true; }
865 :
866 : protected:
867 : JumpStatement(int pos, NodeType type) : Statement(pos, type) {}
868 : };
869 :
870 :
871 : class ContinueStatement final : public JumpStatement {
872 : public:
873 : IterationStatement* target() const { return target_; }
874 :
875 : private:
876 : friend class AstNodeFactory;
877 :
878 : ContinueStatement(IterationStatement* target, int pos)
879 96521 : : JumpStatement(pos, kContinueStatement), target_(target) {}
880 :
881 : IterationStatement* target_;
882 : };
883 :
884 :
885 : class BreakStatement final : public JumpStatement {
886 : public:
887 : BreakableStatement* target() const { return target_; }
888 :
889 : private:
890 : friend class AstNodeFactory;
891 :
892 : BreakStatement(BreakableStatement* target, int pos)
893 335168 : : JumpStatement(pos, kBreakStatement), target_(target) {}
894 :
895 : BreakableStatement* target_;
896 : };
897 :
898 :
899 : class ReturnStatement final : public JumpStatement {
900 : public:
901 : enum Type { kNormal, kAsyncReturn };
902 : Expression* expression() const { return expression_; }
903 :
904 0 : void set_expression(Expression* e) { expression_ = e; }
905 : Type type() const { return TypeField::decode(bit_field_); }
906 2094887 : bool is_async_return() const { return type() == kAsyncReturn; }
907 :
908 : private:
909 : friend class AstNodeFactory;
910 :
911 : ReturnStatement(Expression* expression, Type type, int pos)
912 7514385 : : JumpStatement(pos, kReturnStatement), expression_(expression) {
913 22280 : bit_field_ |= TypeField::encode(type);
914 : }
915 :
916 : Expression* expression_;
917 :
918 : class TypeField
919 : : public BitField<Type, JumpStatement::kNextBitFieldIndex, 1> {};
920 : };
921 :
922 :
923 : class WithStatement final : public Statement {
924 : public:
925 : Scope* scope() { return scope_; }
926 : Expression* expression() const { return expression_; }
927 0 : void set_expression(Expression* e) { expression_ = e; }
928 : Statement* statement() const { return statement_; }
929 4821 : void set_statement(Statement* s) { statement_ = s; }
930 :
931 : private:
932 : friend class AstNodeFactory;
933 :
934 : WithStatement(Scope* scope, Expression* expression, Statement* statement,
935 : int pos)
936 : : Statement(pos, kWithStatement),
937 : scope_(scope),
938 : expression_(expression),
939 55609 : statement_(statement) {}
940 :
941 : Scope* scope_;
942 : Expression* expression_;
943 : Statement* statement_;
944 : };
945 :
946 :
947 : class CaseClause final : public Expression {
948 : public:
949 583065 : bool is_default() const { return label_ == NULL; }
950 583065 : Expression* label() const {
951 583065 : CHECK(!is_default());
952 583065 : return label_;
953 : }
954 0 : void set_label(Expression* e) { label_ = e; }
955 : Label* body_target() { return &body_target_; }
956 : ZoneList<Statement*>* statements() const { return statements_; }
957 :
958 : static int num_ids() { return parent_num_ids() + 2; }
959 : BailoutId EntryId() const { return BailoutId(local_id(0)); }
960 : TypeFeedbackId CompareId() { return TypeFeedbackId(local_id(1)); }
961 :
962 : AstType* compare_type() { return compare_type_; }
963 28295 : void set_compare_type(AstType* type) { compare_type_ = type; }
964 :
965 : // CaseClause will have both a slot in the feedback vector and the
966 : // TypeFeedbackId to record the type information. TypeFeedbackId is used by
967 : // full codegen and the feedback vector slot is used by interpreter.
968 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
969 : FeedbackSlotCache* cache);
970 :
971 : FeedbackSlot CompareOperationFeedbackSlot() { return feedback_slot_; }
972 :
973 : private:
974 : friend class AstNodeFactory;
975 :
976 : static int parent_num_ids() { return Expression::num_ids(); }
977 : CaseClause(Expression* label, ZoneList<Statement*>* statements, int pos);
978 192115 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
979 :
980 : Expression* label_;
981 : Label body_target_;
982 : ZoneList<Statement*>* statements_;
983 : AstType* compare_type_;
984 : FeedbackSlot feedback_slot_;
985 : };
986 :
987 :
988 : class SwitchStatement final : public BreakableStatement {
989 : public:
990 : void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
991 91680 : tag_ = tag;
992 91680 : cases_ = cases;
993 : }
994 :
995 : Expression* tag() const { return tag_; }
996 : ZoneList<CaseClause*>* cases() const { return cases_; }
997 :
998 0 : void set_tag(Expression* t) { tag_ = t; }
999 :
1000 : private:
1001 : friend class AstNodeFactory;
1002 :
1003 : SwitchStatement(ZoneList<const AstRawString*>* labels, int pos)
1004 : : BreakableStatement(labels, TARGET_FOR_ANONYMOUS, pos, kSwitchStatement),
1005 : tag_(NULL),
1006 92354 : cases_(NULL) {}
1007 :
1008 : Expression* tag_;
1009 : ZoneList<CaseClause*>* cases_;
1010 : };
1011 :
1012 :
1013 : // If-statements always have non-null references to their then- and
1014 : // else-parts. When parsing if-statements with no explicit else-part,
1015 : // the parser implicitly creates an empty statement. Use the
1016 : // HasThenStatement() and HasElseStatement() functions to check if a
1017 : // given if-statement has a then- or an else-part containing code.
1018 : class IfStatement final : public Statement {
1019 : public:
1020 2514841 : bool HasThenStatement() const { return !then_statement()->IsEmpty(); }
1021 5147881 : bool HasElseStatement() const { return !else_statement()->IsEmpty(); }
1022 :
1023 : Expression* condition() const { return condition_; }
1024 : Statement* then_statement() const { return then_statement_; }
1025 : Statement* else_statement() const { return else_statement_; }
1026 :
1027 0 : void set_condition(Expression* e) { condition_ = e; }
1028 3530 : void set_then_statement(Statement* s) { then_statement_ = s; }
1029 3530 : void set_else_statement(Statement* s) { else_statement_ = s; }
1030 :
1031 4817518 : bool IsJump() const {
1032 2314356 : return HasThenStatement() && then_statement()->IsJump()
1033 3868095 : && HasElseStatement() && else_statement()->IsJump();
1034 : }
1035 :
1036 2093040 : void set_base_id(int id) { base_id_ = id; }
1037 : static int num_ids() { return parent_num_ids() + 3; }
1038 : BailoutId IfId() const { return BailoutId(local_id(0)); }
1039 : BailoutId ThenId() const { return BailoutId(local_id(1)); }
1040 : BailoutId ElseId() const { return BailoutId(local_id(2)); }
1041 :
1042 : private:
1043 : friend class AstNodeFactory;
1044 :
1045 : IfStatement(Expression* condition, Statement* then_statement,
1046 : Statement* else_statement, int pos)
1047 : : Statement(pos, kIfStatement),
1048 : base_id_(BailoutId::None().ToInt()),
1049 : condition_(condition),
1050 : then_statement_(then_statement),
1051 6321653 : else_statement_(else_statement) {}
1052 :
1053 : static int parent_num_ids() { return 0; }
1054 : int base_id() const {
1055 : DCHECK(!BailoutId(base_id_).IsNone());
1056 : return base_id_;
1057 : }
1058 2730097 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1059 :
1060 : int base_id_;
1061 : Expression* condition_;
1062 : Statement* then_statement_;
1063 : Statement* else_statement_;
1064 : };
1065 :
1066 :
1067 : class TryStatement : public Statement {
1068 : public:
1069 : Block* try_block() const { return try_block_; }
1070 12429 : void set_try_block(Block* b) { try_block_ = b; }
1071 :
1072 : // Prediction of whether exceptions thrown into the handler for this try block
1073 : // will be caught.
1074 : //
1075 : // This is set in ast-numbering and later compiled into the code's handler
1076 : // table. The runtime uses this information to implement a feature that
1077 : // notifies the debugger when an uncaught exception is thrown, _before_ the
1078 : // exception propagates to the top.
1079 : //
1080 : // Since it's generally undecidable whether an exception will be caught, our
1081 : // prediction is only an approximation.
1082 : HandlerTable::CatchPrediction catch_prediction() const {
1083 : return catch_prediction_;
1084 : }
1085 : void set_catch_prediction(HandlerTable::CatchPrediction prediction) {
1086 213933 : catch_prediction_ = prediction;
1087 : }
1088 :
1089 : protected:
1090 : TryStatement(Block* try_block, int pos, NodeType type)
1091 : : Statement(pos, type),
1092 : catch_prediction_(HandlerTable::UNCAUGHT),
1093 1038936 : try_block_(try_block) {}
1094 :
1095 : HandlerTable::CatchPrediction catch_prediction_;
1096 :
1097 : private:
1098 : Block* try_block_;
1099 : };
1100 :
1101 :
1102 : class TryCatchStatement final : public TryStatement {
1103 : public:
1104 : Scope* scope() { return scope_; }
1105 : Block* catch_block() const { return catch_block_; }
1106 8357 : void set_catch_block(Block* b) { catch_block_ = b; }
1107 :
1108 : // The clear_pending_message flag indicates whether or not to clear the
1109 : // isolate's pending exception message before executing the catch_block. In
1110 : // the normal use case, this flag is always on because the message object
1111 : // is not needed anymore when entering the catch block and should not be kept
1112 : // alive.
1113 : // The use case where the flag is off is when the catch block is guaranteed to
1114 : // rethrow the caught exception (using %ReThrow), which reuses the pending
1115 : // message instead of generating a new one.
1116 : // (When the catch block doesn't rethrow but is guaranteed to perform an
1117 : // ordinary throw, not clearing the old message is safe but not very useful.)
1118 : bool clear_pending_message() const {
1119 : return catch_prediction_ != HandlerTable::UNCAUGHT;
1120 : }
1121 :
1122 : private:
1123 : friend class AstNodeFactory;
1124 :
1125 : TryCatchStatement(Block* try_block, Scope* scope, Block* catch_block,
1126 : HandlerTable::CatchPrediction catch_prediction, int pos)
1127 : : TryStatement(try_block, pos, kTryCatchStatement),
1128 : scope_(scope),
1129 748956 : catch_block_(catch_block) {
1130 543588 : catch_prediction_ = catch_prediction;
1131 : }
1132 :
1133 : Scope* scope_;
1134 : Block* catch_block_;
1135 : };
1136 :
1137 :
1138 : class TryFinallyStatement final : public TryStatement {
1139 : public:
1140 : Block* finally_block() const { return finally_block_; }
1141 301 : void set_finally_block(Block* b) { finally_block_ = b; }
1142 :
1143 : private:
1144 : friend class AstNodeFactory;
1145 :
1146 : TryFinallyStatement(Block* try_block, Block* finally_block, int pos)
1147 : : TryStatement(try_block, pos, kTryFinallyStatement),
1148 289980 : finally_block_(finally_block) {}
1149 :
1150 : Block* finally_block_;
1151 : };
1152 :
1153 :
1154 : class DebuggerStatement final : public Statement {
1155 : private:
1156 : friend class AstNodeFactory;
1157 :
1158 : explicit DebuggerStatement(int pos) : Statement(pos, kDebuggerStatement) {}
1159 : };
1160 :
1161 :
1162 : class EmptyStatement final : public Statement {
1163 : private:
1164 : friend class AstNodeFactory;
1165 : explicit EmptyStatement(int pos) : Statement(pos, kEmptyStatement) {}
1166 : };
1167 :
1168 :
1169 : // Delegates to another statement, which may be overwritten.
1170 : // This was introduced to implement ES2015 Annex B3.3 for conditionally making
1171 : // sloppy-mode block-scoped functions have a var binding, which is changed
1172 : // from one statement to another during parsing.
1173 : class SloppyBlockFunctionStatement final : public Statement {
1174 : public:
1175 : Statement* statement() const { return statement_; }
1176 10232 : void set_statement(Statement* statement) { statement_ = statement; }
1177 :
1178 : private:
1179 : friend class AstNodeFactory;
1180 :
1181 : explicit SloppyBlockFunctionStatement(Statement* statement)
1182 : : Statement(kNoSourcePosition, kSloppyBlockFunctionStatement),
1183 10583 : statement_(statement) {}
1184 :
1185 : Statement* statement_;
1186 : };
1187 :
1188 :
1189 : class Literal final : public Expression {
1190 : public:
1191 : // Returns true if literal represents a property name (i.e. cannot be parsed
1192 : // as array indices).
1193 22554065 : bool IsPropertyName() const { return value_->IsPropertyName(); }
1194 :
1195 575571 : Handle<String> AsPropertyName() {
1196 : DCHECK(IsPropertyName());
1197 : return Handle<String>::cast(value());
1198 : }
1199 :
1200 5546042 : const AstRawString* AsRawPropertyName() {
1201 : DCHECK(IsPropertyName());
1202 11092084 : return value_->AsString();
1203 : }
1204 :
1205 332147 : Smi* AsSmiLiteral() {
1206 : DCHECK(IsSmiLiteral());
1207 332147 : return raw_value()->AsSmi();
1208 : }
1209 :
1210 28009 : bool ToBooleanIsTrue() const { return raw_value()->BooleanValue(); }
1211 35659 : bool ToBooleanIsFalse() const { return !raw_value()->BooleanValue(); }
1212 :
1213 : Handle<Object> value() const { return value_->value(); }
1214 9815027 : const AstValue* raw_value() const { return value_; }
1215 :
1216 : // Support for using Literal as a HashMap key. NOTE: Currently, this works
1217 : // only for string and number literals!
1218 : uint32_t Hash();
1219 : static bool Match(void* literal1, void* literal2);
1220 :
1221 : static int num_ids() { return parent_num_ids() + 1; }
1222 : TypeFeedbackId LiteralFeedbackId() const {
1223 : return TypeFeedbackId(local_id(0));
1224 : }
1225 :
1226 : private:
1227 : friend class AstNodeFactory;
1228 :
1229 : Literal(const AstValue* value, int position)
1230 76686092 : : Expression(position, kLiteral), value_(value) {}
1231 :
1232 : static int parent_num_ids() { return Expression::num_ids(); }
1233 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1234 :
1235 : const AstValue* value_;
1236 : };
1237 :
1238 : // Base class for literals that need space in the type feedback vector.
1239 : class MaterializedLiteral : public Expression {
1240 : public:
1241 : int depth() const {
1242 : // only callable after initialization.
1243 : DCHECK(depth_ >= 1);
1244 1963691 : return depth_;
1245 : }
1246 :
1247 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
1248 : FeedbackSlotCache* cache) {
1249 1145104 : literal_slot_ = spec->AddLiteralSlot();
1250 : }
1251 :
1252 : FeedbackSlot literal_slot() const { return literal_slot_; }
1253 :
1254 : private:
1255 : int depth_ : 31;
1256 : FeedbackSlot literal_slot_;
1257 :
1258 : class IsSimpleField
1259 : : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
1260 :
1261 : protected:
1262 : MaterializedLiteral(int pos, NodeType type)
1263 2484798 : : Expression(pos, type), depth_(0) {
1264 : bit_field_ |= IsSimpleField::encode(false);
1265 : }
1266 :
1267 : // A materialized literal is simple if the values consist of only
1268 : // constants and simple object and array literals.
1269 : bool is_simple() const { return IsSimpleField::decode(bit_field_); }
1270 : void set_is_simple(bool is_simple) {
1271 1366592 : bit_field_ = IsSimpleField::update(bit_field_, is_simple);
1272 : }
1273 : friend class CompileTimeValue;
1274 :
1275 : void set_depth(int depth) {
1276 : DCHECK_LE(1, depth);
1277 1154915 : depth_ = depth;
1278 : }
1279 :
1280 : // Populate the depth field and any flags the literal has.
1281 : void InitDepthAndFlags();
1282 :
1283 : // Populate the constant properties/elements fixed array.
1284 : void BuildConstants(Isolate* isolate);
1285 : friend class ArrayLiteral;
1286 : friend class ObjectLiteral;
1287 :
1288 : // If the expression is a literal, return the literal value;
1289 : // if the expression is a materialized literal and is simple return a
1290 : // compile time value as encoded by CompileTimeValue::GetValue().
1291 : // Otherwise, return undefined literal as the placeholder
1292 : // in the object literal boilerplate.
1293 : Handle<Object> GetBoilerplateValue(Expression* expression, Isolate* isolate);
1294 :
1295 : static const uint8_t kNextBitFieldIndex = IsSimpleField::kNext;
1296 : };
1297 :
1298 : // Common supertype for ObjectLiteralProperty and ClassLiteralProperty
1299 : class LiteralProperty : public ZoneObject {
1300 : public:
1301 : Expression* key() const { return key_; }
1302 14041 : Expression* value() const { return value_; }
1303 0 : void set_key(Expression* e) { key_ = e; }
1304 0 : void set_value(Expression* e) { value_ = e; }
1305 :
1306 : bool is_computed_name() const { return is_computed_name_; }
1307 :
1308 : FeedbackSlot GetSlot(int offset = 0) const {
1309 : DCHECK_LT(offset, static_cast<int>(arraysize(slots_)));
1310 887730 : return slots_[offset];
1311 : }
1312 :
1313 : FeedbackSlot GetStoreDataPropertySlot() const;
1314 :
1315 : void SetSlot(FeedbackSlot slot, int offset = 0) {
1316 : DCHECK_LT(offset, static_cast<int>(arraysize(slots_)));
1317 887888 : slots_[offset] = slot;
1318 : }
1319 :
1320 : void SetStoreDataPropertySlot(FeedbackSlot slot);
1321 :
1322 : bool NeedsSetFunctionName() const;
1323 :
1324 : protected:
1325 : LiteralProperty(Expression* key, Expression* value, bool is_computed_name)
1326 15805389 : : key_(key), value_(value), is_computed_name_(is_computed_name) {}
1327 :
1328 : Expression* key_;
1329 : Expression* value_;
1330 : FeedbackSlot slots_[2];
1331 : bool is_computed_name_;
1332 : };
1333 :
1334 : // Property is used for passing information
1335 : // about an object literal's properties from the parser
1336 : // to the code generator.
1337 : class ObjectLiteralProperty final : public LiteralProperty {
1338 : public:
1339 : enum Kind : uint8_t {
1340 : CONSTANT, // Property with constant value (compile time).
1341 : COMPUTED, // Property with computed value (execution time).
1342 : MATERIALIZED_LITERAL, // Property value is a materialized literal.
1343 : GETTER,
1344 : SETTER, // Property is an accessor function.
1345 : PROTOTYPE, // Property is __proto__.
1346 : SPREAD
1347 : };
1348 :
1349 : Kind kind() const { return kind_; }
1350 :
1351 : // Type feedback information.
1352 : bool IsMonomorphic() const { return !receiver_type_.is_null(); }
1353 : Handle<Map> GetReceiverType() const { return receiver_type_; }
1354 :
1355 : bool IsCompileTimeValue() const;
1356 :
1357 : void set_emit_store(bool emit_store);
1358 : bool emit_store() const;
1359 :
1360 25290 : void set_receiver_type(Handle<Map> map) { receiver_type_ = map; }
1361 :
1362 : private:
1363 : friend class AstNodeFactory;
1364 :
1365 : ObjectLiteralProperty(Expression* key, Expression* value, Kind kind,
1366 : bool is_computed_name);
1367 : ObjectLiteralProperty(AstValueFactory* ast_value_factory, Expression* key,
1368 : Expression* value, bool is_computed_name);
1369 :
1370 : Kind kind_;
1371 : bool emit_store_;
1372 : Handle<Map> receiver_type_;
1373 : };
1374 :
1375 :
1376 : // An object literal has a boilerplate object that is used
1377 : // for minimizing the work when constructing it at runtime.
1378 : class ObjectLiteral final : public MaterializedLiteral {
1379 : public:
1380 : typedef ObjectLiteralProperty Property;
1381 :
1382 : Handle<BoilerplateDescription> constant_properties() const {
1383 : DCHECK(!constant_properties_.is_null());
1384 : return constant_properties_;
1385 : }
1386 819322 : int properties_count() const { return boilerplate_properties_; }
1387 : ZoneList<Property*>* properties() const { return properties_; }
1388 : bool fast_elements() const { return FastElementsField::decode(bit_field_); }
1389 : bool may_store_doubles() const {
1390 : return MayStoreDoublesField::decode(bit_field_);
1391 : }
1392 : bool has_elements() const { return HasElementsField::decode(bit_field_); }
1393 : bool has_shallow_properties() const {
1394 2724445 : return depth() == 1 && !has_elements() && !may_store_doubles();
1395 : }
1396 : bool has_rest_property() const {
1397 : return HasRestPropertyField::decode(bit_field_);
1398 : }
1399 :
1400 : // Decide if a property should be in the object boilerplate.
1401 : static bool IsBoilerplateProperty(Property* property);
1402 :
1403 : // Populate the depth field and flags.
1404 : void InitDepthAndFlags();
1405 :
1406 : // Get the constant properties fixed array, populating it if necessary.
1407 : Handle<BoilerplateDescription> GetOrBuildConstantProperties(
1408 : Isolate* isolate) {
1409 460139 : if (constant_properties_.is_null()) {
1410 400001 : BuildConstantProperties(isolate);
1411 : }
1412 : return constant_properties();
1413 : }
1414 :
1415 : // Populate the constant properties fixed array.
1416 : void BuildConstantProperties(Isolate* isolate);
1417 :
1418 : // Mark all computed expressions that are bound to a key that
1419 : // is shadowed by a later occurrence of the same key. For the
1420 : // marked expressions, no store code is emitted.
1421 : void CalculateEmitStore(Zone* zone);
1422 :
1423 : // Determines whether the {FastCloneShallowObject} builtin can be used.
1424 : bool IsFastCloningSupported() const;
1425 :
1426 : // Assemble bitfield of flags for the CreateObjectLiteral helper.
1427 510768 : int ComputeFlags(bool disable_mementos = false) const {
1428 510768 : int flags = fast_elements() ? kFastElements : kNoFlags;
1429 510768 : if (has_shallow_properties()) {
1430 146124 : flags |= kShallowProperties;
1431 : }
1432 510768 : if (disable_mementos) {
1433 19422 : flags |= kDisableMementos;
1434 : }
1435 510768 : return flags;
1436 : }
1437 :
1438 : enum Flags {
1439 : kNoFlags = 0,
1440 : kFastElements = 1,
1441 : kShallowProperties = 1 << 1,
1442 : kDisableMementos = 1 << 2,
1443 : kHasRestProperty = 1 << 3,
1444 : };
1445 :
1446 : struct Accessors: public ZoneObject {
1447 5042 : Accessors() : getter(NULL), setter(NULL), bailout_id(BailoutId::None()) {}
1448 : ObjectLiteralProperty* getter;
1449 : ObjectLiteralProperty* setter;
1450 : BailoutId bailout_id;
1451 : };
1452 :
1453 : BailoutId CreateLiteralId() const { return BailoutId(local_id(0)); }
1454 :
1455 : // Return an AST id for a property that is used in simulate instructions.
1456 13942 : BailoutId GetIdForPropertySet(int i) { return BailoutId(local_id(i + 1)); }
1457 :
1458 : // Unlike other AST nodes, this number of bailout IDs allocated for an
1459 : // ObjectLiteral can vary, so num_ids() is not a static method.
1460 752293 : int num_ids() const { return parent_num_ids() + 1 + properties()->length(); }
1461 :
1462 : // Object literals need one feedback slot for each non-trivial value, as well
1463 : // as some slots for home objects.
1464 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
1465 : FeedbackSlotCache* cache);
1466 :
1467 : private:
1468 : friend class AstNodeFactory;
1469 :
1470 : ObjectLiteral(ZoneList<Property*>* properties,
1471 : uint32_t boilerplate_properties, int pos,
1472 : bool has_rest_property)
1473 : : MaterializedLiteral(pos, kObjectLiteral),
1474 : boilerplate_properties_(boilerplate_properties),
1475 3181534 : properties_(properties) {
1476 : bit_field_ |= FastElementsField::encode(false) |
1477 : HasElementsField::encode(false) |
1478 : MayStoreDoublesField::encode(false) |
1479 1590767 : HasRestPropertyField::encode(has_rest_property);
1480 : }
1481 :
1482 : static int parent_num_ids() { return MaterializedLiteral::num_ids(); }
1483 158334 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1484 :
1485 : uint32_t boilerplate_properties_;
1486 : Handle<BoilerplateDescription> constant_properties_;
1487 : ZoneList<Property*>* properties_;
1488 :
1489 : class FastElementsField
1490 : : public BitField<bool, MaterializedLiteral::kNextBitFieldIndex, 1> {};
1491 : class HasElementsField : public BitField<bool, FastElementsField::kNext, 1> {
1492 : };
1493 : class MayStoreDoublesField
1494 : : public BitField<bool, HasElementsField::kNext, 1> {};
1495 : class HasRestPropertyField
1496 : : public BitField<bool, MayStoreDoublesField::kNext, 1> {};
1497 : };
1498 :
1499 :
1500 : // A map from property names to getter/setter pairs allocated in the zone.
1501 : class AccessorTable
1502 : : public base::TemplateHashMap<Literal, ObjectLiteral::Accessors,
1503 : bool (*)(void*, void*),
1504 : ZoneAllocationPolicy> {
1505 : public:
1506 : explicit AccessorTable(Zone* zone)
1507 : : base::TemplateHashMap<Literal, ObjectLiteral::Accessors,
1508 : bool (*)(void*, void*), ZoneAllocationPolicy>(
1509 : Literal::Match, ZoneAllocationPolicy(zone)),
1510 491354 : zone_(zone) {}
1511 :
1512 5802 : Iterator lookup(Literal* literal) {
1513 11604 : Iterator it = find(literal, true, ZoneAllocationPolicy(zone_));
1514 10844 : if (it->second == NULL) it->second = new (zone_) ObjectLiteral::Accessors();
1515 5802 : return it;
1516 : }
1517 :
1518 : private:
1519 : Zone* zone_;
1520 : };
1521 :
1522 :
1523 : // Node for capturing a regexp literal.
1524 : class RegExpLiteral final : public MaterializedLiteral {
1525 : public:
1526 33706 : Handle<String> pattern() const { return pattern_->string(); }
1527 : const AstRawString* raw_pattern() const { return pattern_; }
1528 : int flags() const { return flags_; }
1529 :
1530 : private:
1531 : friend class AstNodeFactory;
1532 :
1533 : RegExpLiteral(const AstRawString* pattern, int flags, int pos)
1534 : : MaterializedLiteral(pos, kRegExpLiteral),
1535 : flags_(flags),
1536 97489 : pattern_(pattern) {
1537 : set_depth(1);
1538 : }
1539 :
1540 : int const flags_;
1541 : const AstRawString* const pattern_;
1542 : };
1543 :
1544 :
1545 : // An array literal has a literals object that is used
1546 : // for minimizing the work when constructing it at runtime.
1547 : class ArrayLiteral final : public MaterializedLiteral {
1548 : public:
1549 : Handle<ConstantElementsPair> constant_elements() const {
1550 : return constant_elements_;
1551 : }
1552 : ElementsKind constant_elements_kind() const;
1553 :
1554 : ZoneList<Expression*>* values() const { return values_; }
1555 :
1556 : BailoutId CreateLiteralId() const { return BailoutId(local_id(0)); }
1557 :
1558 : // Return an AST id for an element that is used in simulate instructions.
1559 150928 : BailoutId GetIdForElement(int i) { return BailoutId(local_id(i + 1)); }
1560 :
1561 : // Unlike other AST nodes, this number of bailout IDs allocated for an
1562 : // ArrayLiteral can vary, so num_ids() is not a static method.
1563 309216 : int num_ids() const { return parent_num_ids() + 1 + values()->length(); }
1564 :
1565 : // Populate the depth field and flags.
1566 : void InitDepthAndFlags();
1567 :
1568 : // Get the constant elements fixed array, populating it if necessary.
1569 : Handle<ConstantElementsPair> GetOrBuildConstantElements(Isolate* isolate) {
1570 239703 : if (constant_elements_.is_null()) {
1571 221478 : BuildConstantElements(isolate);
1572 : }
1573 : return constant_elements();
1574 : }
1575 :
1576 : // Populate the constant elements fixed array.
1577 : void BuildConstantElements(Isolate* isolate);
1578 :
1579 : // Determines whether the {FastCloneShallowArray} builtin can be used.
1580 : bool IsFastCloningSupported() const;
1581 :
1582 : // Assemble bitfield of flags for the CreateArrayLiteral helper.
1583 : int ComputeFlags(bool disable_mementos = false) const {
1584 167075 : int flags = depth() == 1 ? kShallowElements : kNoFlags;
1585 : if (disable_mementos) {
1586 14116 : flags |= kDisableMementos;
1587 : }
1588 : return flags;
1589 : }
1590 :
1591 : // Provide a mechanism for iterating through values to rewrite spreads.
1592 3324 : ZoneList<Expression*>::iterator FirstSpread() const {
1593 6648 : return (first_spread_index_ >= 0) ? values_->begin() + first_spread_index_
1594 9972 : : values_->end();
1595 : }
1596 26058 : ZoneList<Expression*>::iterator EndValue() const { return values_->end(); }
1597 :
1598 : // Rewind an array literal omitting everything from the first spread on.
1599 : void RewindSpreads();
1600 :
1601 : enum Flags {
1602 : kNoFlags = 0,
1603 : kShallowElements = 1,
1604 : kDisableMementos = 1 << 1
1605 : };
1606 :
1607 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
1608 : FeedbackSlotCache* cache);
1609 : FeedbackSlot LiteralFeedbackSlot() const { return literal_slot_; }
1610 :
1611 : private:
1612 : friend class AstNodeFactory;
1613 :
1614 : ArrayLiteral(ZoneList<Expression*>* values, int first_spread_index, int pos)
1615 : : MaterializedLiteral(pos, kArrayLiteral),
1616 : first_spread_index_(first_spread_index),
1617 1593084 : values_(values) {}
1618 :
1619 : static int parent_num_ids() { return MaterializedLiteral::num_ids(); }
1620 225055 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1621 :
1622 : int first_spread_index_;
1623 : FeedbackSlot literal_slot_;
1624 : Handle<ConstantElementsPair> constant_elements_;
1625 : ZoneList<Expression*>* values_;
1626 : };
1627 :
1628 :
1629 : class VariableProxy final : public Expression {
1630 : public:
1631 5109410 : bool IsValidReferenceExpression() const {
1632 10218183 : return !is_this() && !is_new_target();
1633 : }
1634 :
1635 2722760 : Handle<String> name() const { return raw_name()->string(); }
1636 227028617 : const AstRawString* raw_name() const {
1637 227028617 : return is_resolved() ? var_->raw_name() : raw_name_;
1638 : }
1639 :
1640 124087 : Variable* var() const {
1641 : DCHECK(is_resolved());
1642 124087 : return var_;
1643 : }
1644 : void set_var(Variable* v) {
1645 : DCHECK(!is_resolved());
1646 : DCHECK_NOT_NULL(v);
1647 107010904 : var_ = v;
1648 : }
1649 :
1650 151969660 : bool is_this() const { return IsThisField::decode(bit_field_); }
1651 :
1652 : bool is_assigned() const { return IsAssignedField::decode(bit_field_); }
1653 10681921 : void set_is_assigned() {
1654 33409724 : bit_field_ = IsAssignedField::update(bit_field_, true);
1655 16704862 : if (is_resolved()) {
1656 : var()->set_maybe_assigned();
1657 : }
1658 5806610 : }
1659 :
1660 : bool is_resolved() const { return IsResolvedField::decode(bit_field_); }
1661 : void set_is_resolved() {
1662 200265519 : bit_field_ = IsResolvedField::update(bit_field_, true);
1663 : }
1664 :
1665 141085670 : bool is_new_target() const { return IsNewTargetField::decode(bit_field_); }
1666 : void set_is_new_target() {
1667 50584 : bit_field_ = IsNewTargetField::update(bit_field_, true);
1668 : }
1669 :
1670 : HoleCheckMode hole_check_mode() const {
1671 : return HoleCheckModeField::decode(bit_field_);
1672 : }
1673 : void set_needs_hole_check() {
1674 : bit_field_ =
1675 1043228 : HoleCheckModeField::update(bit_field_, HoleCheckMode::kRequired);
1676 : }
1677 :
1678 : // Bind this proxy to the variable var.
1679 : void BindTo(Variable* var);
1680 :
1681 28627431 : bool UsesVariableFeedbackSlot() const {
1682 28627431 : return var()->IsUnallocated() || var()->IsLookupSlot();
1683 : }
1684 :
1685 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, TypeofMode typeof_mode,
1686 : FeedbackSlotCache* cache);
1687 :
1688 : FeedbackSlot VariableFeedbackSlot() { return variable_feedback_slot_; }
1689 :
1690 : static int num_ids() { return parent_num_ids() + 1; }
1691 : BailoutId BeforeId() const { return BailoutId(local_id(0)); }
1692 135140276 : void set_next_unresolved(VariableProxy* next) { next_unresolved_ = next; }
1693 : VariableProxy* next_unresolved() { return next_unresolved_; }
1694 :
1695 : private:
1696 : friend class AstNodeFactory;
1697 :
1698 : VariableProxy(Variable* var, int start_position);
1699 : VariableProxy(const AstRawString* name, VariableKind variable_kind,
1700 : int start_position);
1701 : explicit VariableProxy(const VariableProxy* copy_from);
1702 :
1703 : static int parent_num_ids() { return Expression::num_ids(); }
1704 6112246 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1705 :
1706 : class IsThisField : public BitField<bool, Expression::kNextBitFieldIndex, 1> {
1707 : };
1708 : class IsAssignedField : public BitField<bool, IsThisField::kNext, 1> {};
1709 : class IsResolvedField : public BitField<bool, IsAssignedField::kNext, 1> {};
1710 : class IsNewTargetField : public BitField<bool, IsResolvedField::kNext, 1> {};
1711 : class HoleCheckModeField
1712 : : public BitField<HoleCheckMode, IsNewTargetField::kNext, 1> {};
1713 :
1714 : FeedbackSlot variable_feedback_slot_;
1715 : union {
1716 : const AstRawString* raw_name_; // if !is_resolved_
1717 : Variable* var_; // if is_resolved_
1718 : };
1719 : VariableProxy* next_unresolved_;
1720 : };
1721 :
1722 :
1723 : // Left-hand side can only be a property, a global or a (parameter or local)
1724 : // slot.
1725 : enum LhsKind {
1726 : VARIABLE,
1727 : NAMED_PROPERTY,
1728 : KEYED_PROPERTY,
1729 : NAMED_SUPER_PROPERTY,
1730 : KEYED_SUPER_PROPERTY
1731 : };
1732 :
1733 :
1734 : class Property final : public Expression {
1735 : public:
1736 : bool IsValidReferenceExpression() const { return true; }
1737 :
1738 11489988 : Expression* obj() const { return obj_; }
1739 27 : Expression* key() const { return key_; }
1740 :
1741 0 : void set_obj(Expression* e) { obj_ = e; }
1742 0 : void set_key(Expression* e) { key_ = e; }
1743 :
1744 : static int num_ids() { return parent_num_ids() + 1; }
1745 : BailoutId LoadId() const { return BailoutId(local_id(0)); }
1746 :
1747 : bool IsStringAccess() const {
1748 : return IsStringAccessField::decode(bit_field_);
1749 : }
1750 :
1751 : // Type feedback information.
1752 823131 : bool IsMonomorphic() const { return receiver_types_.length() == 1; }
1753 : SmallMapList* GetReceiverTypes() { return &receiver_types_; }
1754 : KeyedAccessStoreMode GetStoreMode() const { return STANDARD_STORE; }
1755 : IcCheckType GetKeyType() const { return KeyTypeField::decode(bit_field_); }
1756 431240 : bool IsUninitialized() const {
1757 1653765 : return !is_for_call() && HasNoTypeInformation();
1758 : }
1759 72399 : bool HasNoTypeInformation() const {
1760 : return GetInlineCacheState() == UNINITIALIZED;
1761 : }
1762 : InlineCacheState GetInlineCacheState() const {
1763 : return InlineCacheStateField::decode(bit_field_);
1764 : }
1765 : void set_is_string_access(bool b) {
1766 80314 : bit_field_ = IsStringAccessField::update(bit_field_, b);
1767 : }
1768 : void set_key_type(IcCheckType key_type) {
1769 40157 : bit_field_ = KeyTypeField::update(bit_field_, key_type);
1770 : }
1771 : void set_inline_cache_state(InlineCacheState state) {
1772 1208018 : bit_field_ = InlineCacheStateField::update(bit_field_, state);
1773 : }
1774 : void mark_for_call() {
1775 11188328 : bit_field_ = IsForCallField::update(bit_field_, true);
1776 : }
1777 : bool is_for_call() const { return IsForCallField::decode(bit_field_); }
1778 :
1779 27453771 : bool IsSuperAccess() { return obj()->IsSuperPropertyReference(); }
1780 :
1781 6642321 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
1782 6642321 : FeedbackSlotCache* cache) {
1783 6642321 : if (key()->IsPropertyName()) {
1784 5974255 : property_feedback_slot_ = spec->AddLoadICSlot();
1785 : } else {
1786 668064 : property_feedback_slot_ = spec->AddKeyedLoadICSlot();
1787 : }
1788 6642319 : }
1789 :
1790 : FeedbackSlot PropertyFeedbackSlot() const { return property_feedback_slot_; }
1791 :
1792 : // Returns the properties assign type.
1793 39778865 : static LhsKind GetAssignType(Property* property) {
1794 27519185 : if (property == NULL) return VARIABLE;
1795 12259681 : bool super_access = property->IsSuperAccess();
1796 12259680 : return (property->key()->IsPropertyName())
1797 : ? (super_access ? NAMED_SUPER_PROPERTY : NAMED_PROPERTY)
1798 12259684 : : (super_access ? KEYED_SUPER_PROPERTY : KEYED_PROPERTY);
1799 : }
1800 :
1801 : private:
1802 : friend class AstNodeFactory;
1803 :
1804 : Property(Expression* obj, Expression* key, int pos)
1805 26399616 : : Expression(pos, kProperty), obj_(obj), key_(key) {
1806 : bit_field_ |= IsForCallField::encode(false) |
1807 : IsStringAccessField::encode(false) |
1808 : InlineCacheStateField::encode(UNINITIALIZED);
1809 : }
1810 :
1811 : static int parent_num_ids() { return Expression::num_ids(); }
1812 2691692 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1813 :
1814 : class IsForCallField
1815 : : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
1816 : class IsStringAccessField : public BitField<bool, IsForCallField::kNext, 1> {
1817 : };
1818 : class KeyTypeField
1819 : : public BitField<IcCheckType, IsStringAccessField::kNext, 1> {};
1820 : class InlineCacheStateField
1821 : : public BitField<InlineCacheState, KeyTypeField::kNext, 4> {};
1822 :
1823 : FeedbackSlot property_feedback_slot_;
1824 : Expression* obj_;
1825 : Expression* key_;
1826 : SmallMapList receiver_types_;
1827 : };
1828 :
1829 :
1830 : class Call final : public Expression {
1831 : public:
1832 : Expression* expression() const { return expression_; }
1833 : ZoneList<Expression*>* arguments() const { return arguments_; }
1834 :
1835 0 : void set_expression(Expression* e) { expression_ = e; }
1836 :
1837 : // Type feedback information.
1838 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
1839 : FeedbackSlotCache* cache);
1840 :
1841 : FeedbackSlot CallFeedbackICSlot() const { return ic_slot_; }
1842 :
1843 609736 : SmallMapList* GetReceiverTypes() {
1844 609736 : if (expression()->IsProperty()) {
1845 609736 : return expression()->AsProperty()->GetReceiverTypes();
1846 : }
1847 : return nullptr;
1848 : }
1849 :
1850 1045548 : bool IsMonomorphic() const {
1851 745193 : if (expression()->IsProperty()) {
1852 600710 : return expression()->AsProperty()->IsMonomorphic();
1853 : }
1854 444838 : return !target_.is_null();
1855 : }
1856 :
1857 : Handle<JSFunction> target() { return target_; }
1858 :
1859 : Handle<AllocationSite> allocation_site() { return allocation_site_; }
1860 :
1861 : void SetKnownGlobalTarget(Handle<JSFunction> target) {
1862 162126 : target_ = target;
1863 : set_is_uninitialized(false);
1864 : }
1865 168005 : void set_target(Handle<JSFunction> target) { target_ = target; }
1866 : void set_allocation_site(Handle<AllocationSite> site) {
1867 73025 : allocation_site_ = site;
1868 : }
1869 :
1870 : static int num_ids() { return parent_num_ids() + 2; }
1871 : BailoutId ReturnId() const { return BailoutId(local_id(0)); }
1872 : BailoutId CallId() const { return BailoutId(local_id(1)); }
1873 :
1874 : bool is_uninitialized() const {
1875 : return IsUninitializedField::decode(bit_field_);
1876 : }
1877 : void set_is_uninitialized(bool b) {
1878 1636476 : bit_field_ = IsUninitializedField::update(bit_field_, b);
1879 : }
1880 :
1881 : bool is_possibly_eval() const {
1882 : return IsPossiblyEvalField::decode(bit_field_);
1883 : }
1884 :
1885 : TailCallMode tail_call_mode() const {
1886 : return IsTailField::decode(bit_field_) ? TailCallMode::kAllow
1887 6864533 : : TailCallMode::kDisallow;
1888 : }
1889 7334 : void MarkTail() { bit_field_ = IsTailField::update(bit_field_, true); }
1890 :
1891 2402291 : bool only_last_arg_is_spread() {
1892 6312057 : return !arguments_->is_empty() && arguments_->last()->IsSpread();
1893 : }
1894 :
1895 : enum CallType {
1896 : GLOBAL_CALL,
1897 : WITH_CALL,
1898 : NAMED_PROPERTY_CALL,
1899 : KEYED_PROPERTY_CALL,
1900 : NAMED_SUPER_PROPERTY_CALL,
1901 : KEYED_SUPER_PROPERTY_CALL,
1902 : SUPER_CALL,
1903 : OTHER_CALL
1904 : };
1905 :
1906 : enum PossiblyEval {
1907 : IS_POSSIBLY_EVAL,
1908 : NOT_EVAL,
1909 : };
1910 :
1911 : // Helpers to determine how to handle the call.
1912 : CallType GetCallType() const;
1913 :
1914 : #ifdef DEBUG
1915 : // Used to assert that the FullCodeGenerator records the return site.
1916 : bool return_is_recorded_;
1917 : #endif
1918 :
1919 : private:
1920 : friend class AstNodeFactory;
1921 :
1922 11753105 : Call(Expression* expression, ZoneList<Expression*>* arguments, int pos,
1923 : PossiblyEval possibly_eval)
1924 : : Expression(pos, kCall),
1925 : expression_(expression),
1926 11753105 : arguments_(arguments) {
1927 : bit_field_ |=
1928 : IsUninitializedField::encode(false) |
1929 23506210 : IsPossiblyEvalField::encode(possibly_eval == IS_POSSIBLY_EVAL);
1930 :
1931 11753102 : if (expression->IsProperty()) {
1932 5594165 : expression->AsProperty()->mark_for_call();
1933 : }
1934 11753101 : }
1935 :
1936 : static int parent_num_ids() { return Expression::num_ids(); }
1937 2453175 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1938 :
1939 : class IsUninitializedField
1940 : : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
1941 : class IsTailField : public BitField<bool, IsUninitializedField::kNext, 1> {};
1942 : class IsPossiblyEvalField : public BitField<bool, IsTailField::kNext, 1> {};
1943 :
1944 : FeedbackSlot ic_slot_;
1945 : Expression* expression_;
1946 : ZoneList<Expression*>* arguments_;
1947 : Handle<JSFunction> target_;
1948 : Handle<AllocationSite> allocation_site_;
1949 : };
1950 :
1951 :
1952 : class CallNew final : public Expression {
1953 : public:
1954 : Expression* expression() const { return expression_; }
1955 : ZoneList<Expression*>* arguments() const { return arguments_; }
1956 :
1957 0 : void set_expression(Expression* e) { expression_ = e; }
1958 :
1959 : // Type feedback information.
1960 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
1961 : FeedbackSlotCache* cache) {
1962 : // CallNew stores feedback in the exact same way as Call. We can
1963 : // piggyback on the type feedback infrastructure for calls.
1964 359312 : callnew_feedback_slot_ = spec->AddCallICSlot();
1965 : }
1966 :
1967 : FeedbackSlot CallNewFeedbackSlot() {
1968 : DCHECK(!callnew_feedback_slot_.IsInvalid());
1969 : return callnew_feedback_slot_;
1970 : }
1971 :
1972 : bool IsMonomorphic() const { return IsMonomorphicField::decode(bit_field_); }
1973 : Handle<JSFunction> target() const { return target_; }
1974 : Handle<AllocationSite> allocation_site() const {
1975 : return allocation_site_;
1976 : }
1977 :
1978 : static int num_ids() { return parent_num_ids() + 1; }
1979 : static int feedback_slots() { return 1; }
1980 : BailoutId ReturnId() const { return BailoutId(local_id(0)); }
1981 :
1982 : void set_allocation_site(Handle<AllocationSite> site) {
1983 32299 : allocation_site_ = site;
1984 : }
1985 : void set_is_monomorphic(bool monomorphic) {
1986 89304 : bit_field_ = IsMonomorphicField::update(bit_field_, monomorphic);
1987 : }
1988 5012 : void set_target(Handle<JSFunction> target) { target_ = target; }
1989 : void SetKnownGlobalTarget(Handle<JSFunction> target) {
1990 12353 : target_ = target;
1991 : set_is_monomorphic(true);
1992 : }
1993 :
1994 221335 : bool only_last_arg_is_spread() {
1995 510805 : return !arguments_->is_empty() && arguments_->last()->IsSpread();
1996 : }
1997 :
1998 : private:
1999 : friend class AstNodeFactory;
2000 :
2001 : CallNew(Expression* expression, ZoneList<Expression*>* arguments, int pos)
2002 : : Expression(pos, kCallNew),
2003 : expression_(expression),
2004 1028428 : arguments_(arguments) {
2005 : bit_field_ |= IsMonomorphicField::encode(false);
2006 : }
2007 :
2008 : static int parent_num_ids() { return Expression::num_ids(); }
2009 128379 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2010 :
2011 : FeedbackSlot callnew_feedback_slot_;
2012 : Expression* expression_;
2013 : ZoneList<Expression*>* arguments_;
2014 : Handle<JSFunction> target_;
2015 : Handle<AllocationSite> allocation_site_;
2016 :
2017 : class IsMonomorphicField
2018 : : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
2019 : };
2020 :
2021 :
2022 : // The CallRuntime class does not represent any official JavaScript
2023 : // language construct. Instead it is used to call a C or JS function
2024 : // with a set of arguments. This is used from the builtins that are
2025 : // implemented in JavaScript (see "v8natives.js").
2026 : class CallRuntime final : public Expression {
2027 : public:
2028 : ZoneList<Expression*>* arguments() const { return arguments_; }
2029 : bool is_jsruntime() const { return function_ == NULL; }
2030 :
2031 : int context_index() const {
2032 : DCHECK(is_jsruntime());
2033 : return context_index_;
2034 : }
2035 : void set_context_index(int index) {
2036 : DCHECK(is_jsruntime());
2037 6984 : context_index_ = index;
2038 : }
2039 : const Runtime::Function* function() const {
2040 : DCHECK(!is_jsruntime());
2041 : return function_;
2042 : }
2043 :
2044 : static int num_ids() { return parent_num_ids() + 1; }
2045 : BailoutId CallId() { return BailoutId(local_id(0)); }
2046 : const char* debug_name();
2047 :
2048 : private:
2049 : friend class AstNodeFactory;
2050 :
2051 : CallRuntime(const Runtime::Function* function,
2052 : ZoneList<Expression*>* arguments, int pos)
2053 : : Expression(pos, kCallRuntime),
2054 : function_(function),
2055 4524778 : arguments_(arguments) {}
2056 : CallRuntime(int context_index, ZoneList<Expression*>* arguments, int pos)
2057 : : Expression(pos, kCallRuntime),
2058 : context_index_(context_index),
2059 : function_(NULL),
2060 489605 : arguments_(arguments) {}
2061 :
2062 : static int parent_num_ids() { return Expression::num_ids(); }
2063 252980 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2064 :
2065 : int context_index_;
2066 : const Runtime::Function* function_;
2067 : ZoneList<Expression*>* arguments_;
2068 : };
2069 :
2070 :
2071 : class UnaryOperation final : public Expression {
2072 : public:
2073 : Token::Value op() const { return OperatorField::decode(bit_field_); }
2074 : Expression* expression() const { return expression_; }
2075 0 : void set_expression(Expression* e) { expression_ = e; }
2076 :
2077 : // For unary not (Token::NOT), the AST ids where true and false will
2078 : // actually be materialized, respectively.
2079 : static int num_ids() { return parent_num_ids() + 2; }
2080 : BailoutId MaterializeTrueId() const { return BailoutId(local_id(0)); }
2081 : BailoutId MaterializeFalseId() const { return BailoutId(local_id(1)); }
2082 :
2083 : void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle);
2084 :
2085 : private:
2086 : friend class AstNodeFactory;
2087 :
2088 : UnaryOperation(Token::Value op, Expression* expression, int pos)
2089 4376550 : : Expression(pos, kUnaryOperation), expression_(expression) {
2090 4376550 : bit_field_ |= OperatorField::encode(op);
2091 : DCHECK(Token::IsUnaryOp(op));
2092 : }
2093 :
2094 : static int parent_num_ids() { return Expression::num_ids(); }
2095 52748 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2096 :
2097 : Expression* expression_;
2098 :
2099 : class OperatorField
2100 : : public BitField<Token::Value, Expression::kNextBitFieldIndex, 7> {};
2101 : };
2102 :
2103 :
2104 : class BinaryOperation final : public Expression {
2105 : public:
2106 : Token::Value op() const { return OperatorField::decode(bit_field_); }
2107 : Expression* left() const { return left_; }
2108 0 : void set_left(Expression* e) { left_ = e; }
2109 : Expression* right() const { return right_; }
2110 0 : void set_right(Expression* e) { right_ = e; }
2111 : Handle<AllocationSite> allocation_site() const { return allocation_site_; }
2112 : void set_allocation_site(Handle<AllocationSite> allocation_site) {
2113 511901 : allocation_site_ = allocation_site;
2114 : }
2115 :
2116 1242 : void MarkTail() {
2117 1242 : switch (op()) {
2118 : case Token::COMMA:
2119 : case Token::AND:
2120 : case Token::OR:
2121 446 : right_->MarkTail();
2122 : default:
2123 : break;
2124 : }
2125 1242 : }
2126 :
2127 : // The short-circuit logical operations need an AST ID for their
2128 : // right-hand subexpression.
2129 : static int num_ids() { return parent_num_ids() + 2; }
2130 : BailoutId RightId() const { return BailoutId(local_id(0)); }
2131 :
2132 : // BinaryOperation will have both a slot in the feedback vector and the
2133 : // TypeFeedbackId to record the type information. TypeFeedbackId is used
2134 : // by full codegen and the feedback vector slot is used by interpreter.
2135 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
2136 : FeedbackSlotCache* cache);
2137 :
2138 : FeedbackSlot BinaryOperationFeedbackSlot() const { return feedback_slot_; }
2139 :
2140 : TypeFeedbackId BinaryOperationFeedbackId() const {
2141 : return TypeFeedbackId(local_id(1));
2142 : }
2143 :
2144 : // Returns true if one side is a Smi literal, returning the other side's
2145 : // sub-expression in |subexpr| and the literal Smi in |literal|.
2146 : bool IsSmiLiteralOperation(Expression** subexpr, Smi** literal);
2147 :
2148 : Maybe<int> fixed_right_arg() const {
2149 381164 : return has_fixed_right_arg_ ? Just(fixed_right_arg_value_) : Nothing<int>();
2150 : }
2151 : void set_fixed_right_arg(Maybe<int> arg) {
2152 511901 : has_fixed_right_arg_ = arg.IsJust();
2153 512195 : if (arg.IsJust()) fixed_right_arg_value_ = arg.FromJust();
2154 : }
2155 :
2156 : void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle);
2157 :
2158 : private:
2159 : friend class AstNodeFactory;
2160 :
2161 : BinaryOperation(Token::Value op, Expression* left, Expression* right, int pos)
2162 : : Expression(pos, kBinaryOperation),
2163 : has_fixed_right_arg_(false),
2164 : fixed_right_arg_value_(0),
2165 : left_(left),
2166 7952078 : right_(right) {
2167 7952078 : bit_field_ |= OperatorField::encode(op);
2168 : DCHECK(Token::IsBinaryOp(op));
2169 : }
2170 :
2171 : static int parent_num_ids() { return Expression::num_ids(); }
2172 1516409 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2173 :
2174 : // TODO(rossberg): the fixed arg should probably be represented as a Constant
2175 : // type for the RHS. Currenty it's actually a Maybe<int>
2176 : bool has_fixed_right_arg_;
2177 : int fixed_right_arg_value_;
2178 : Expression* left_;
2179 : Expression* right_;
2180 : Handle<AllocationSite> allocation_site_;
2181 : FeedbackSlot feedback_slot_;
2182 :
2183 : class OperatorField
2184 : : public BitField<Token::Value, Expression::kNextBitFieldIndex, 7> {};
2185 : };
2186 :
2187 :
2188 : class CountOperation final : public Expression {
2189 : public:
2190 : bool is_prefix() const { return IsPrefixField::decode(bit_field_); }
2191 490153 : bool is_postfix() const { return !is_prefix(); }
2192 :
2193 : Token::Value op() const { return TokenField::decode(bit_field_); }
2194 237928 : Token::Value binary_op() {
2195 237928 : return (op() == Token::INC) ? Token::ADD : Token::SUB;
2196 : }
2197 :
2198 : Expression* expression() const { return expression_; }
2199 0 : void set_expression(Expression* e) { expression_ = e; }
2200 :
2201 1597 : bool IsMonomorphic() const { return receiver_types_.length() == 1; }
2202 : SmallMapList* GetReceiverTypes() { return &receiver_types_; }
2203 : IcCheckType GetKeyType() const { return KeyTypeField::decode(bit_field_); }
2204 : KeyedAccessStoreMode GetStoreMode() const {
2205 : return StoreModeField::decode(bit_field_);
2206 : }
2207 : AstType* type() const { return type_; }
2208 : void set_key_type(IcCheckType type) {
2209 45981 : bit_field_ = KeyTypeField::update(bit_field_, type);
2210 : }
2211 : void set_store_mode(KeyedAccessStoreMode mode) {
2212 91962 : bit_field_ = StoreModeField::update(bit_field_, mode);
2213 : }
2214 45981 : void set_type(AstType* type) { type_ = type; }
2215 :
2216 : static int num_ids() { return parent_num_ids() + 4; }
2217 : BailoutId AssignmentId() const { return BailoutId(local_id(0)); }
2218 : BailoutId ToNumberId() const { return BailoutId(local_id(1)); }
2219 : TypeFeedbackId CountBinOpFeedbackId() const {
2220 : return TypeFeedbackId(local_id(2));
2221 : }
2222 : TypeFeedbackId CountStoreFeedbackId() const {
2223 : return TypeFeedbackId(local_id(3));
2224 : }
2225 :
2226 : // Feedback slot for binary operation is only used by ignition.
2227 : FeedbackSlot CountBinaryOpFeedbackSlot() const {
2228 : return binary_operation_slot_;
2229 : }
2230 :
2231 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
2232 : FeedbackSlotCache* cache);
2233 : FeedbackSlot CountSlot() const { return slot_; }
2234 :
2235 : private:
2236 : friend class AstNodeFactory;
2237 :
2238 : CountOperation(Token::Value op, bool is_prefix, Expression* expr, int pos)
2239 1547929 : : Expression(pos, kCountOperation), type_(NULL), expression_(expr) {
2240 : bit_field_ |=
2241 : IsPrefixField::encode(is_prefix) | KeyTypeField::encode(ELEMENT) |
2242 1547929 : StoreModeField::encode(STANDARD_STORE) | TokenField::encode(op);
2243 : }
2244 :
2245 : static int parent_num_ids() { return Expression::num_ids(); }
2246 318738 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2247 :
2248 : class IsPrefixField
2249 : : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
2250 : class KeyTypeField : public BitField<IcCheckType, IsPrefixField::kNext, 1> {};
2251 : class StoreModeField
2252 : : public BitField<KeyedAccessStoreMode, KeyTypeField::kNext, 3> {};
2253 : class TokenField : public BitField<Token::Value, StoreModeField::kNext, 7> {};
2254 :
2255 : FeedbackSlot slot_;
2256 : FeedbackSlot binary_operation_slot_;
2257 : AstType* type_;
2258 : Expression* expression_;
2259 : SmallMapList receiver_types_;
2260 : };
2261 :
2262 :
2263 : class CompareOperation final : public Expression {
2264 : public:
2265 : Token::Value op() const { return OperatorField::decode(bit_field_); }
2266 : Expression* left() const { return left_; }
2267 : Expression* right() const { return right_; }
2268 :
2269 0 : void set_left(Expression* e) { left_ = e; }
2270 0 : void set_right(Expression* e) { right_ = e; }
2271 :
2272 : // Type feedback information.
2273 : static int num_ids() { return parent_num_ids() + 1; }
2274 : TypeFeedbackId CompareOperationFeedbackId() const {
2275 : return TypeFeedbackId(local_id(0));
2276 : }
2277 : AstType* combined_type() const { return combined_type_; }
2278 506717 : void set_combined_type(AstType* type) { combined_type_ = type; }
2279 :
2280 : // CompareOperation will have both a slot in the feedback vector and the
2281 : // TypeFeedbackId to record the type information. TypeFeedbackId is used
2282 : // by full codegen and the feedback vector slot is used by interpreter.
2283 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
2284 : FeedbackSlotCache* cache);
2285 :
2286 : FeedbackSlot CompareOperationFeedbackSlot() const { return feedback_slot_; }
2287 :
2288 : // Match special cases.
2289 : bool IsLiteralCompareTypeof(Expression** expr, Literal** literal);
2290 : bool IsLiteralCompareUndefined(Expression** expr);
2291 : bool IsLiteralCompareNull(Expression** expr);
2292 :
2293 : private:
2294 : friend class AstNodeFactory;
2295 :
2296 : CompareOperation(Token::Value op, Expression* left, Expression* right,
2297 : int pos)
2298 : : Expression(pos, kCompareOperation),
2299 : left_(left),
2300 : right_(right),
2301 7069284 : combined_type_(AstType::None()) {
2302 7069284 : bit_field_ |= OperatorField::encode(op);
2303 : DCHECK(Token::IsCompareOp(op));
2304 : }
2305 :
2306 : static int parent_num_ids() { return Expression::num_ids(); }
2307 943358 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2308 :
2309 : Expression* left_;
2310 : Expression* right_;
2311 :
2312 : AstType* combined_type_;
2313 : FeedbackSlot feedback_slot_;
2314 : class OperatorField
2315 : : public BitField<Token::Value, Expression::kNextBitFieldIndex, 7> {};
2316 : };
2317 :
2318 :
2319 : class Spread final : public Expression {
2320 : public:
2321 5397 : Expression* expression() const { return expression_; }
2322 0 : void set_expression(Expression* e) { expression_ = e; }
2323 :
2324 : int expression_position() const { return expr_pos_; }
2325 :
2326 : static int num_ids() { return parent_num_ids(); }
2327 :
2328 : private:
2329 : friend class AstNodeFactory;
2330 :
2331 : Spread(Expression* expression, int pos, int expr_pos)
2332 : : Expression(pos, kSpread),
2333 : expr_pos_(expr_pos),
2334 51563 : expression_(expression) {}
2335 :
2336 : static int parent_num_ids() { return Expression::num_ids(); }
2337 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2338 :
2339 : int expr_pos_;
2340 : Expression* expression_;
2341 : };
2342 :
2343 :
2344 : class Conditional final : public Expression {
2345 : public:
2346 : Expression* condition() const { return condition_; }
2347 : Expression* then_expression() const { return then_expression_; }
2348 : Expression* else_expression() const { return else_expression_; }
2349 :
2350 0 : void set_condition(Expression* e) { condition_ = e; }
2351 0 : void set_then_expression(Expression* e) { then_expression_ = e; }
2352 0 : void set_else_expression(Expression* e) { else_expression_ = e; }
2353 :
2354 140 : void MarkTail() {
2355 140 : then_expression_->MarkTail();
2356 140 : else_expression_->MarkTail();
2357 140 : }
2358 :
2359 : static int num_ids() { return parent_num_ids() + 2; }
2360 : BailoutId ThenId() const { return BailoutId(local_id(0)); }
2361 : BailoutId ElseId() const { return BailoutId(local_id(1)); }
2362 :
2363 : private:
2364 : friend class AstNodeFactory;
2365 :
2366 : Conditional(Expression* condition, Expression* then_expression,
2367 : Expression* else_expression, int position)
2368 : : Expression(position, kConditional),
2369 : condition_(condition),
2370 : then_expression_(then_expression),
2371 465734 : else_expression_(else_expression) {}
2372 :
2373 : static int parent_num_ids() { return Expression::num_ids(); }
2374 64301 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2375 :
2376 : Expression* condition_;
2377 : Expression* then_expression_;
2378 : Expression* else_expression_;
2379 : };
2380 :
2381 :
2382 : class Assignment final : public Expression {
2383 : public:
2384 : Assignment* AsSimpleAssignment() { return !is_compound() ? this : NULL; }
2385 :
2386 : Token::Value binary_op() const;
2387 :
2388 : Token::Value op() const { return TokenField::decode(bit_field_); }
2389 : Expression* target() const { return target_; }
2390 : Expression* value() const { return value_; }
2391 :
2392 0 : void set_target(Expression* e) { target_ = e; }
2393 0 : void set_value(Expression* e) { value_ = e; }
2394 :
2395 : BinaryOperation* binary_operation() const { return binary_operation_; }
2396 :
2397 : // This check relies on the definition order of token in token.h.
2398 100764472 : bool is_compound() const { return op() > Token::ASSIGN; }
2399 :
2400 : static int num_ids() { return parent_num_ids() + 2; }
2401 : BailoutId AssignmentId() const { return BailoutId(local_id(0)); }
2402 :
2403 : // Type feedback information.
2404 : TypeFeedbackId AssignmentFeedbackId() { return TypeFeedbackId(local_id(1)); }
2405 : bool IsUninitialized() const {
2406 : return IsUninitializedField::decode(bit_field_);
2407 : }
2408 : bool HasNoTypeInformation() {
2409 : return IsUninitializedField::decode(bit_field_);
2410 : }
2411 72372 : bool IsMonomorphic() const { return receiver_types_.length() == 1; }
2412 : SmallMapList* GetReceiverTypes() { return &receiver_types_; }
2413 : IcCheckType GetKeyType() const { return KeyTypeField::decode(bit_field_); }
2414 : KeyedAccessStoreMode GetStoreMode() const {
2415 : return StoreModeField::decode(bit_field_);
2416 : }
2417 : void set_is_uninitialized(bool b) {
2418 146090 : bit_field_ = IsUninitializedField::update(bit_field_, b);
2419 : }
2420 : void set_key_type(IcCheckType key_type) {
2421 4974 : bit_field_ = KeyTypeField::update(bit_field_, key_type);
2422 : }
2423 : void set_store_mode(KeyedAccessStoreMode mode) {
2424 9948 : bit_field_ = StoreModeField::update(bit_field_, mode);
2425 : }
2426 :
2427 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
2428 : FeedbackSlotCache* cache);
2429 : FeedbackSlot AssignmentSlot() const { return slot_; }
2430 :
2431 : private:
2432 : friend class AstNodeFactory;
2433 :
2434 : Assignment(Token::Value op, Expression* target, Expression* value, int pos);
2435 :
2436 : static int parent_num_ids() { return Expression::num_ids(); }
2437 2911373 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2438 :
2439 : class IsUninitializedField
2440 : : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
2441 : class KeyTypeField
2442 : : public BitField<IcCheckType, IsUninitializedField::kNext, 1> {};
2443 : class StoreModeField
2444 : : public BitField<KeyedAccessStoreMode, KeyTypeField::kNext, 3> {};
2445 : class TokenField : public BitField<Token::Value, StoreModeField::kNext, 7> {};
2446 :
2447 : FeedbackSlot slot_;
2448 : Expression* target_;
2449 : Expression* value_;
2450 : BinaryOperation* binary_operation_;
2451 : SmallMapList receiver_types_;
2452 : };
2453 :
2454 :
2455 : // The RewritableExpression class is a wrapper for AST nodes that wait
2456 : // for some potential rewriting. However, even if such nodes are indeed
2457 : // rewritten, the RewritableExpression wrapper nodes will survive in the
2458 : // final AST and should be just ignored, i.e., they should be treated as
2459 : // equivalent to the wrapped nodes. For this reason and to simplify later
2460 : // phases, RewritableExpressions are considered as exceptions of AST nodes
2461 : // in the following sense:
2462 : //
2463 : // 1. IsRewritableExpression and AsRewritableExpression behave as usual.
2464 : // 2. All other Is* and As* methods are practically delegated to the
2465 : // wrapped node, i.e. IsArrayLiteral() will return true iff the
2466 : // wrapped node is an array literal.
2467 : //
2468 : // Furthermore, an invariant that should be respected is that the wrapped
2469 : // node is not a RewritableExpression.
2470 : class RewritableExpression final : public Expression {
2471 : public:
2472 407921 : Expression* expression() const { return expr_; }
2473 174794 : bool is_rewritten() const { return IsRewrittenField::decode(bit_field_); }
2474 :
2475 : void Rewrite(Expression* new_expression) {
2476 : DCHECK(!is_rewritten());
2477 : DCHECK_NOT_NULL(new_expression);
2478 : DCHECK(!new_expression->IsRewritableExpression());
2479 110763 : expr_ = new_expression;
2480 228054 : bit_field_ = IsRewrittenField::update(bit_field_, true);
2481 : }
2482 :
2483 : static int num_ids() { return parent_num_ids(); }
2484 :
2485 : private:
2486 : friend class AstNodeFactory;
2487 :
2488 : explicit RewritableExpression(Expression* expression)
2489 : : Expression(expression->position(), kRewritableExpression),
2490 263314 : expr_(expression) {
2491 : bit_field_ |= IsRewrittenField::encode(false);
2492 : DCHECK(!expression->IsRewritableExpression());
2493 : }
2494 :
2495 : int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2496 :
2497 : Expression* expr_;
2498 :
2499 : class IsRewrittenField
2500 : : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
2501 : };
2502 :
2503 : // There are several types of Suspend node:
2504 : //
2505 : // Yield
2506 : // YieldStar
2507 : // Await
2508 : //
2509 : // Our Yield is different from the JS yield in that it "returns" its argument as
2510 : // is, without wrapping it in an iterator result object. Such wrapping, if
2511 : // desired, must be done beforehand (see the parser).
2512 : class Suspend final : public Expression {
2513 : public:
2514 : enum OnException { kOnExceptionThrow, kOnExceptionRethrow };
2515 :
2516 : Expression* generator_object() const { return generator_object_; }
2517 : Expression* expression() const { return expression_; }
2518 : OnException on_exception() const {
2519 : return OnExceptionField::decode(bit_field_);
2520 : }
2521 19833 : bool rethrow_on_exception() const {
2522 : return on_exception() == kOnExceptionRethrow;
2523 : }
2524 :
2525 : int suspend_id() const { return suspend_id_; }
2526 : SuspendFlags flags() const { return FlagsField::decode(bit_field_); }
2527 : SuspendFlags suspend_type() const {
2528 : return flags() & SuspendFlags::kSuspendTypeMask;
2529 : }
2530 39666 : SuspendFlags generator_type() const {
2531 : return flags() & SuspendFlags::kGeneratorTypeMask;
2532 : }
2533 : bool is_yield() const { return suspend_type() == SuspendFlags::kYield; }
2534 : bool is_yield_star() const {
2535 : return suspend_type() == SuspendFlags::kYieldStar;
2536 : }
2537 : bool is_await() const { return suspend_type() == SuspendFlags::kAwait; }
2538 : bool is_async_generator() const {
2539 : return generator_type() == SuspendFlags::kAsyncGenerator;
2540 : }
2541 30943 : inline bool IsNonInitialAsyncGeneratorYield() const {
2542 : // Return true if is_async_generator() && !is_await() && yield_id() > 0
2543 30943 : return suspend_id() > 0 && (flags() & SuspendFlags::kAsyncGeneratorAwait) ==
2544 : SuspendFlags::kAsyncGenerator;
2545 : }
2546 :
2547 0 : void set_generator_object(Expression* e) { generator_object_ = e; }
2548 0 : void set_expression(Expression* e) { expression_ = e; }
2549 25371 : void set_suspend_id(int id) { suspend_id_ = id; }
2550 : void set_suspend_type(SuspendFlags type) {
2551 : DCHECK_EQ(0, static_cast<int>(type & ~SuspendFlags::kSuspendTypeMask));
2552 : bit_field_ = FlagsField::update(bit_field_, type);
2553 : }
2554 :
2555 : private:
2556 : friend class AstNodeFactory;
2557 :
2558 : Suspend(Expression* generator_object, Expression* expression, int pos,
2559 : OnException on_exception, SuspendFlags flags)
2560 : : Expression(pos, kSuspend),
2561 : suspend_id_(-1),
2562 : generator_object_(generator_object),
2563 186530 : expression_(expression) {
2564 : bit_field_ |=
2565 186530 : OnExceptionField::encode(on_exception) | FlagsField::encode(flags);
2566 : }
2567 :
2568 : int suspend_id_;
2569 : Expression* generator_object_;
2570 : Expression* expression_;
2571 :
2572 : class OnExceptionField
2573 : : public BitField<OnException, Expression::kNextBitFieldIndex, 1> {};
2574 : class FlagsField
2575 : : public BitField<SuspendFlags, OnExceptionField::kNext,
2576 : static_cast<int>(SuspendFlags::kBitWidth)> {};
2577 : };
2578 :
2579 :
2580 : class Throw final : public Expression {
2581 : public:
2582 : Expression* exception() const { return exception_; }
2583 0 : void set_exception(Expression* e) { exception_ = e; }
2584 :
2585 : private:
2586 : friend class AstNodeFactory;
2587 :
2588 : Throw(Expression* exception, int pos)
2589 759489 : : Expression(pos, kThrow), exception_(exception) {}
2590 :
2591 : Expression* exception_;
2592 : };
2593 :
2594 :
2595 : class FunctionLiteral final : public Expression {
2596 : public:
2597 : enum FunctionType {
2598 : kAnonymousExpression,
2599 : kNamedExpression,
2600 : kDeclaration,
2601 : kAccessorOrMethod
2602 : };
2603 :
2604 : enum IdType { kIdTypeInvalid = -1, kIdTypeTopLevel = 0 };
2605 :
2606 : enum ParameterFlag { kNoDuplicateParameters, kHasDuplicateParameters };
2607 :
2608 : enum EagerCompileHint { kShouldEagerCompile, kShouldLazyCompile };
2609 :
2610 6249647 : Handle<String> name() const { return raw_name_->string(); }
2611 : const AstConsString* raw_name() const { return raw_name_; }
2612 865381 : void set_raw_name(const AstConsString* name) { raw_name_ = name; }
2613 : DeclarationScope* scope() const { return scope_; }
2614 : ZoneList<Statement*>* body() const { return body_; }
2615 8048547 : void set_function_token_position(int pos) { function_token_position_ = pos; }
2616 : int function_token_position() const { return function_token_position_; }
2617 : int start_position() const;
2618 : int end_position() const;
2619 : int SourceSize() const { return end_position() - start_position(); }
2620 6235390 : bool is_declaration() const { return function_type() == kDeclaration; }
2621 6235390 : bool is_named_expression() const {
2622 : return function_type() == kNamedExpression;
2623 : }
2624 7769908 : bool is_anonymous_expression() const {
2625 6235390 : return function_type() == kAnonymousExpression;
2626 : }
2627 : LanguageMode language_mode() const;
2628 :
2629 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
2630 : FeedbackSlotCache* cache) {
2631 5458771 : literal_feedback_slot_ = spec->AddCreateClosureSlot();
2632 : }
2633 :
2634 : FeedbackSlot LiteralFeedbackSlot() const { return literal_feedback_slot_; }
2635 :
2636 : static bool NeedsHomeObject(Expression* expr);
2637 :
2638 : int expected_property_count() {
2639 : // Not valid for lazy functions.
2640 : DCHECK_NOT_NULL(body_);
2641 : return expected_property_count_;
2642 : }
2643 : int parameter_count() { return parameter_count_; }
2644 : int function_length() { return function_length_; }
2645 :
2646 : bool AllowsLazyCompilation();
2647 :
2648 441 : Handle<String> debug_name() const {
2649 441 : if (raw_name_ != NULL && !raw_name_->IsEmpty()) {
2650 : return raw_name_->string();
2651 : }
2652 425 : return inferred_name();
2653 : }
2654 :
2655 6235813 : Handle<String> inferred_name() const {
2656 6235813 : if (!inferred_name_.is_null()) {
2657 : DCHECK(raw_inferred_name_ == NULL);
2658 425 : return inferred_name_;
2659 : }
2660 6235388 : if (raw_inferred_name_ != NULL) {
2661 : return raw_inferred_name_->string();
2662 : }
2663 0 : UNREACHABLE();
2664 : return Handle<String>();
2665 : }
2666 :
2667 : // Only one of {set_inferred_name, set_raw_inferred_name} should be called.
2668 : void set_inferred_name(Handle<String> inferred_name) {
2669 : DCHECK(!inferred_name.is_null());
2670 1297591 : inferred_name_ = inferred_name;
2671 : DCHECK(raw_inferred_name_== NULL || raw_inferred_name_->IsEmpty());
2672 1297591 : raw_inferred_name_ = NULL;
2673 : }
2674 :
2675 : void set_raw_inferred_name(const AstConsString* raw_inferred_name) {
2676 : DCHECK(raw_inferred_name != NULL);
2677 2902909 : raw_inferred_name_ = raw_inferred_name;
2678 : DCHECK(inferred_name_.is_null());
2679 2902909 : inferred_name_ = Handle<String>();
2680 : }
2681 :
2682 : bool pretenure() const { return Pretenure::decode(bit_field_); }
2683 3732050 : void set_pretenure() { bit_field_ = Pretenure::update(bit_field_, true); }
2684 :
2685 : bool has_duplicate_parameters() const {
2686 : // Not valid for lazy functions.
2687 : DCHECK_NOT_NULL(body_);
2688 : return HasDuplicateParameters::decode(bit_field_);
2689 : }
2690 :
2691 : // This is used as a heuristic on when to eagerly compile a function
2692 : // literal. We consider the following constructs as hints that the
2693 : // function will be called immediately:
2694 : // - (function() { ... })();
2695 : // - var x = function() { ... }();
2696 : bool ShouldEagerCompile() const;
2697 : void SetShouldEagerCompile();
2698 :
2699 : // A hint that we expect this function to be called (exactly) once,
2700 : // i.e. we suspect it's an initialization function.
2701 : bool should_be_used_once_hint() const {
2702 : return ShouldNotBeUsedOnceHintField::decode(bit_field_);
2703 : }
2704 : void set_should_be_used_once_hint() {
2705 104 : bit_field_ = ShouldNotBeUsedOnceHintField::update(bit_field_, true);
2706 : }
2707 :
2708 : FunctionType function_type() const {
2709 : return FunctionTypeBits::decode(bit_field_);
2710 : }
2711 : FunctionKind kind() const;
2712 :
2713 3685394 : int ast_node_count() { return ast_properties_.node_count(); }
2714 : AstProperties::Flags flags() const { return ast_properties_.flags(); }
2715 : void set_ast_properties(AstProperties* ast_properties) {
2716 : ast_properties_ = *ast_properties;
2717 : }
2718 : const FeedbackVectorSpec* feedback_vector_spec() const {
2719 : return ast_properties_.get_spec();
2720 : }
2721 1107437 : bool dont_optimize() { return dont_optimize_reason() != kNoReason; }
2722 : BailoutReason dont_optimize_reason() {
2723 : return DontOptimizeReasonField::decode(bit_field_);
2724 : }
2725 : void set_dont_optimize_reason(BailoutReason reason) {
2726 6983704 : bit_field_ = DontOptimizeReasonField::update(bit_field_, reason);
2727 : }
2728 :
2729 : bool IsAnonymousFunctionDefinition() const {
2730 : return is_anonymous_expression();
2731 : }
2732 :
2733 : int suspend_count() { return suspend_count_; }
2734 3491852 : void set_suspend_count(int suspend_count) { suspend_count_ = suspend_count; }
2735 :
2736 3158276 : int return_position() {
2737 6316553 : return std::max(start_position(), end_position() - (has_braces_ ? 1 : 0));
2738 : }
2739 :
2740 : int function_literal_id() const { return function_literal_id_; }
2741 : void set_function_literal_id(int function_literal_id) {
2742 299 : function_literal_id_ = function_literal_id;
2743 : }
2744 :
2745 : private:
2746 : friend class AstNodeFactory;
2747 :
2748 10027664 : FunctionLiteral(Zone* zone, const AstRawString* name,
2749 10027656 : AstValueFactory* ast_value_factory, DeclarationScope* scope,
2750 : ZoneList<Statement*>* body, int expected_property_count,
2751 : int parameter_count, int function_length,
2752 : FunctionType function_type,
2753 : ParameterFlag has_duplicate_parameters,
2754 : EagerCompileHint eager_compile_hint, int position,
2755 : bool has_braces, int function_literal_id)
2756 : : Expression(position, kFunctionLiteral),
2757 : expected_property_count_(expected_property_count),
2758 : parameter_count_(parameter_count),
2759 : function_length_(function_length),
2760 : function_token_position_(kNoSourcePosition),
2761 : suspend_count_(0),
2762 : has_braces_(has_braces),
2763 10027664 : raw_name_(ast_value_factory->NewConsString(name)),
2764 : scope_(scope),
2765 : body_(body),
2766 : raw_inferred_name_(ast_value_factory->empty_cons_string()),
2767 : ast_properties_(zone),
2768 40110637 : function_literal_id_(function_literal_id) {
2769 : bit_field_ |= FunctionTypeBits::encode(function_type) |
2770 10027661 : Pretenure::encode(false) |
2771 : HasDuplicateParameters::encode(has_duplicate_parameters ==
2772 10027661 : kHasDuplicateParameters) |
2773 : ShouldNotBeUsedOnceHintField::encode(false) |
2774 10027661 : DontOptimizeReasonField::encode(kNoReason);
2775 10027661 : if (eager_compile_hint == kShouldEagerCompile) SetShouldEagerCompile();
2776 : DCHECK_EQ(body == nullptr, expected_property_count < 0);
2777 10027660 : }
2778 :
2779 : class FunctionTypeBits
2780 : : public BitField<FunctionType, Expression::kNextBitFieldIndex, 2> {};
2781 : class Pretenure : public BitField<bool, FunctionTypeBits::kNext, 1> {};
2782 : class HasDuplicateParameters : public BitField<bool, Pretenure::kNext, 1> {};
2783 : class ShouldNotBeUsedOnceHintField
2784 : : public BitField<bool, HasDuplicateParameters::kNext, 1> {};
2785 : class DontOptimizeReasonField
2786 : : public BitField<BailoutReason, ShouldNotBeUsedOnceHintField::kNext, 8> {
2787 : };
2788 :
2789 : int expected_property_count_;
2790 : int parameter_count_;
2791 : int function_length_;
2792 : int function_token_position_;
2793 : int suspend_count_;
2794 : bool has_braces_;
2795 :
2796 : const AstConsString* raw_name_;
2797 : DeclarationScope* scope_;
2798 : ZoneList<Statement*>* body_;
2799 : const AstConsString* raw_inferred_name_;
2800 : Handle<String> inferred_name_;
2801 : AstProperties ast_properties_;
2802 : int function_literal_id_;
2803 : FeedbackSlot literal_feedback_slot_;
2804 : };
2805 :
2806 : // Property is used for passing information
2807 : // about a class literal's properties from the parser to the code generator.
2808 : class ClassLiteralProperty final : public LiteralProperty {
2809 : public:
2810 : enum Kind : uint8_t { METHOD, GETTER, SETTER, FIELD };
2811 :
2812 : Kind kind() const { return kind_; }
2813 :
2814 : bool is_static() const { return is_static_; }
2815 :
2816 : private:
2817 : friend class AstNodeFactory;
2818 :
2819 : ClassLiteralProperty(Expression* key, Expression* value, Kind kind,
2820 : bool is_static, bool is_computed_name);
2821 :
2822 : Kind kind_;
2823 : bool is_static_;
2824 : };
2825 :
2826 : class ClassLiteral final : public Expression {
2827 : public:
2828 : typedef ClassLiteralProperty Property;
2829 :
2830 : VariableProxy* class_variable_proxy() const { return class_variable_proxy_; }
2831 : Expression* extends() const { return extends_; }
2832 0 : void set_extends(Expression* e) { extends_ = e; }
2833 : FunctionLiteral* constructor() const { return constructor_; }
2834 0 : void set_constructor(FunctionLiteral* f) { constructor_ = f; }
2835 : ZoneList<Property*>* properties() const { return properties_; }
2836 41550 : int start_position() const { return position(); }
2837 : int end_position() const { return end_position_; }
2838 : bool has_name_static_property() const {
2839 : return HasNameStaticProperty::decode(bit_field_);
2840 : }
2841 : bool has_static_computed_names() const {
2842 : return HasStaticComputedNames::decode(bit_field_);
2843 : }
2844 :
2845 : // Object literals need one feedback slot for each non-trivial value, as well
2846 : // as some slots for home objects.
2847 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
2848 : FeedbackSlotCache* cache);
2849 :
2850 43578 : bool NeedsProxySlot() const {
2851 165659 : return class_variable_proxy() != nullptr &&
2852 82047 : class_variable_proxy()->var()->IsUnallocated();
2853 : }
2854 :
2855 : FeedbackSlot HomeObjectSlot() const { return home_object_slot_; }
2856 : FeedbackSlot ProxySlot() const { return proxy_slot_; }
2857 :
2858 : private:
2859 : friend class AstNodeFactory;
2860 :
2861 : ClassLiteral(VariableProxy* class_variable_proxy, Expression* extends,
2862 : FunctionLiteral* constructor, ZoneList<Property*>* properties,
2863 : int start_position, int end_position,
2864 : bool has_name_static_property, bool has_static_computed_names)
2865 : : Expression(start_position, kClassLiteral),
2866 : end_position_(end_position),
2867 : class_variable_proxy_(class_variable_proxy),
2868 : extends_(extends),
2869 : constructor_(constructor),
2870 185222 : properties_(properties) {
2871 : bit_field_ |= HasNameStaticProperty::encode(has_name_static_property) |
2872 92611 : HasStaticComputedNames::encode(has_static_computed_names);
2873 : }
2874 :
2875 : int end_position_;
2876 : FeedbackSlot home_object_slot_;
2877 : FeedbackSlot proxy_slot_;
2878 : VariableProxy* class_variable_proxy_;
2879 : Expression* extends_;
2880 : FunctionLiteral* constructor_;
2881 : ZoneList<Property*>* properties_;
2882 :
2883 : class HasNameStaticProperty
2884 : : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
2885 : class HasStaticComputedNames
2886 : : public BitField<bool, HasNameStaticProperty::kNext, 1> {};
2887 : };
2888 :
2889 :
2890 : class NativeFunctionLiteral final : public Expression {
2891 : public:
2892 2988 : Handle<String> name() const { return name_->string(); }
2893 : v8::Extension* extension() const { return extension_; }
2894 : FeedbackSlot LiteralFeedbackSlot() const { return literal_feedback_slot_; }
2895 :
2896 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
2897 : FeedbackSlotCache* cache) {
2898 : // TODO(mvstanton): The FeedbackSlotCache can be adapted
2899 : // to always return the same slot for this case.
2900 2988 : literal_feedback_slot_ = spec->AddCreateClosureSlot();
2901 : }
2902 :
2903 : private:
2904 : friend class AstNodeFactory;
2905 :
2906 : NativeFunctionLiteral(const AstRawString* name, v8::Extension* extension,
2907 : int pos)
2908 : : Expression(pos, kNativeFunctionLiteral),
2909 : name_(name),
2910 2988 : extension_(extension) {}
2911 :
2912 : const AstRawString* name_;
2913 : v8::Extension* extension_;
2914 : FeedbackSlot literal_feedback_slot_;
2915 : };
2916 :
2917 :
2918 : class ThisFunction final : public Expression {
2919 : private:
2920 : friend class AstNodeFactory;
2921 : explicit ThisFunction(int pos) : Expression(pos, kThisFunction) {}
2922 : };
2923 :
2924 :
2925 : class SuperPropertyReference final : public Expression {
2926 : public:
2927 : VariableProxy* this_var() const { return this_var_; }
2928 0 : void set_this_var(VariableProxy* v) { this_var_ = v; }
2929 : Expression* home_object() const { return home_object_; }
2930 0 : void set_home_object(Expression* e) { home_object_ = e; }
2931 :
2932 : private:
2933 : friend class AstNodeFactory;
2934 :
2935 : SuperPropertyReference(VariableProxy* this_var, Expression* home_object,
2936 : int pos)
2937 : : Expression(pos, kSuperPropertyReference),
2938 : this_var_(this_var),
2939 6119 : home_object_(home_object) {
2940 : DCHECK(this_var->is_this());
2941 : DCHECK(home_object->IsProperty());
2942 : }
2943 :
2944 : VariableProxy* this_var_;
2945 : Expression* home_object_;
2946 : };
2947 :
2948 :
2949 : class SuperCallReference final : public Expression {
2950 : public:
2951 : VariableProxy* this_var() const { return this_var_; }
2952 0 : void set_this_var(VariableProxy* v) { this_var_ = v; }
2953 : VariableProxy* new_target_var() const { return new_target_var_; }
2954 0 : void set_new_target_var(VariableProxy* v) { new_target_var_ = v; }
2955 : VariableProxy* this_function_var() const { return this_function_var_; }
2956 0 : void set_this_function_var(VariableProxy* v) { this_function_var_ = v; }
2957 :
2958 : private:
2959 : friend class AstNodeFactory;
2960 :
2961 : SuperCallReference(VariableProxy* this_var, VariableProxy* new_target_var,
2962 : VariableProxy* this_function_var, int pos)
2963 : : Expression(pos, kSuperCallReference),
2964 : this_var_(this_var),
2965 : new_target_var_(new_target_var),
2966 21195 : this_function_var_(this_function_var) {
2967 : DCHECK(this_var->is_this());
2968 : DCHECK(new_target_var->raw_name()->IsOneByteEqualTo(".new.target"));
2969 : DCHECK(this_function_var->raw_name()->IsOneByteEqualTo(".this_function"));
2970 : }
2971 :
2972 : VariableProxy* this_var_;
2973 : VariableProxy* new_target_var_;
2974 : VariableProxy* this_function_var_;
2975 : };
2976 :
2977 : // This AST Node is used to represent a dynamic import call --
2978 : // import(argument).
2979 : class ImportCallExpression final : public Expression {
2980 : public:
2981 : Expression* argument() const { return argument_; }
2982 0 : void set_argument(Expression* argument) { argument_ = argument; }
2983 :
2984 : private:
2985 : friend class AstNodeFactory;
2986 :
2987 : ImportCallExpression(Expression* argument, int pos)
2988 948 : : Expression(pos, kImportCallExpression), argument_(argument) {}
2989 :
2990 : Expression* argument_;
2991 : };
2992 :
2993 : // This class is produced when parsing the () in arrow functions without any
2994 : // arguments and is not actually a valid expression.
2995 : class EmptyParentheses final : public Expression {
2996 : private:
2997 : friend class AstNodeFactory;
2998 :
2999 : explicit EmptyParentheses(int pos) : Expression(pos, kEmptyParentheses) {}
3000 : };
3001 :
3002 : // Represents the spec operation `GetIterator()`
3003 : // (defined at https://tc39.github.io/ecma262/#sec-getiterator). Ignition
3004 : // desugars this into a LoadIC / JSLoadNamed, CallIC, and a type-check to
3005 : // validate return value of the Symbol.iterator() call.
3006 : enum class IteratorType { kNormal, kAsync };
3007 : class GetIterator final : public Expression {
3008 : public:
3009 : IteratorType hint() const { return hint_; }
3010 :
3011 : Expression* iterable() const { return iterable_; }
3012 0 : void set_iterable(Expression* iterable) { iterable_ = iterable; }
3013 :
3014 : static int num_ids() { return parent_num_ids(); }
3015 :
3016 42385 : void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
3017 42385 : FeedbackSlotCache* cache) {
3018 42385 : iterator_property_feedback_slot_ = spec->AddLoadICSlot();
3019 42385 : iterator_call_feedback_slot_ = spec->AddCallICSlot();
3020 42385 : if (hint() == IteratorType::kAsync) {
3021 380 : async_iterator_property_feedback_slot_ = spec->AddLoadICSlot();
3022 380 : async_iterator_call_feedback_slot_ = spec->AddCallICSlot();
3023 : }
3024 42385 : }
3025 :
3026 : FeedbackSlot IteratorPropertyFeedbackSlot() const {
3027 : return iterator_property_feedback_slot_;
3028 : }
3029 :
3030 : FeedbackSlot IteratorCallFeedbackSlot() const {
3031 : return iterator_call_feedback_slot_;
3032 : }
3033 :
3034 : FeedbackSlot AsyncIteratorPropertyFeedbackSlot() const {
3035 : return async_iterator_property_feedback_slot_;
3036 : }
3037 :
3038 : FeedbackSlot AsyncIteratorCallFeedbackSlot() const {
3039 : return async_iterator_call_feedback_slot_;
3040 : }
3041 :
3042 : private:
3043 : friend class AstNodeFactory;
3044 :
3045 : explicit GetIterator(Expression* iterable, IteratorType hint, int pos)
3046 213364 : : Expression(pos, kGetIterator), hint_(hint), iterable_(iterable) {}
3047 :
3048 : IteratorType hint_;
3049 : Expression* iterable_;
3050 : FeedbackSlot iterator_property_feedback_slot_;
3051 : FeedbackSlot iterator_call_feedback_slot_;
3052 : FeedbackSlot async_iterator_property_feedback_slot_;
3053 : FeedbackSlot async_iterator_call_feedback_slot_;
3054 : };
3055 :
3056 : // ----------------------------------------------------------------------------
3057 : // Basic visitor
3058 : // Sub-class should parametrize AstVisitor with itself, e.g.:
3059 : // class SpecificVisitor : public AstVisitor<SpecificVisitor> { ... }
3060 :
3061 : template <class Subclass>
3062 : class AstVisitor BASE_EMBEDDED {
3063 : public:
3064 9367524 : void Visit(AstNode* node) { impl()->Visit(node); }
3065 :
3066 : void VisitDeclarations(Declaration::List* declarations) {
3067 5377147 : for (Declaration* decl : *declarations) Visit(decl);
3068 : }
3069 :
3070 3165325 : void VisitStatements(ZoneList<Statement*>* statements) {
3071 18243520 : for (int i = 0; i < statements->length(); i++) {
3072 16125745 : Statement* stmt = statements->at(i);
3073 : Visit(stmt);
3074 7003978 : if (stmt->IsJump()) break;
3075 : }
3076 3165322 : }
3077 :
3078 1696 : void VisitExpressions(ZoneList<Expression*>* expressions) {
3079 11668 : for (int i = 0; i < expressions->length(); i++) {
3080 : // The variable statement visiting code may pass NULL expressions
3081 : // to this code. Maybe this should be handled by introducing an
3082 : // undefined expression or literal? Revisit this code if this
3083 : // changes
3084 9972 : Expression* expression = expressions->at(i);
3085 4138 : if (expression != NULL) Visit(expression);
3086 : }
3087 1696 : }
3088 :
3089 : protected:
3090 : Subclass* impl() { return static_cast<Subclass*>(this); }
3091 : };
3092 :
3093 : #define GENERATE_VISIT_CASE(NodeType) \
3094 : case AstNode::k##NodeType: \
3095 : return this->impl()->Visit##NodeType(static_cast<NodeType*>(node));
3096 :
3097 : #define GENERATE_AST_VISITOR_SWITCH() \
3098 : switch (node->node_type()) { \
3099 : AST_NODE_LIST(GENERATE_VISIT_CASE) \
3100 : }
3101 :
3102 : #define DEFINE_AST_VISITOR_SUBCLASS_MEMBERS() \
3103 : public: \
3104 : void VisitNoStackOverflowCheck(AstNode* node) { \
3105 : GENERATE_AST_VISITOR_SWITCH() \
3106 : } \
3107 : \
3108 : void Visit(AstNode* node) { \
3109 : if (CheckStackOverflow()) return; \
3110 : VisitNoStackOverflowCheck(node); \
3111 : } \
3112 : \
3113 : void SetStackOverflow() { stack_overflow_ = true; } \
3114 : void ClearStackOverflow() { stack_overflow_ = false; } \
3115 : bool HasStackOverflow() const { return stack_overflow_; } \
3116 : \
3117 : bool CheckStackOverflow() { \
3118 : if (stack_overflow_) return true; \
3119 : if (GetCurrentStackPosition() < stack_limit_) { \
3120 : stack_overflow_ = true; \
3121 : return true; \
3122 : } \
3123 : return false; \
3124 : } \
3125 : \
3126 : private: \
3127 : void InitializeAstVisitor(Isolate* isolate) { \
3128 : stack_limit_ = isolate->stack_guard()->real_climit(); \
3129 : stack_overflow_ = false; \
3130 : } \
3131 : \
3132 : void InitializeAstVisitor(uintptr_t stack_limit) { \
3133 : stack_limit_ = stack_limit; \
3134 : stack_overflow_ = false; \
3135 : } \
3136 : \
3137 : uintptr_t stack_limit_; \
3138 : bool stack_overflow_
3139 :
3140 : #define DEFINE_AST_VISITOR_MEMBERS_WITHOUT_STACKOVERFLOW() \
3141 : public: \
3142 : void Visit(AstNode* node) { GENERATE_AST_VISITOR_SWITCH() } \
3143 : \
3144 : private:
3145 :
3146 : #define DEFINE_AST_REWRITER_SUBCLASS_MEMBERS() \
3147 : public: \
3148 : AstNode* Rewrite(AstNode* node) { \
3149 : DCHECK_NULL(replacement_); \
3150 : DCHECK_NOT_NULL(node); \
3151 : Visit(node); \
3152 : if (HasStackOverflow()) return node; \
3153 : if (replacement_ == nullptr) return node; \
3154 : AstNode* result = replacement_; \
3155 : replacement_ = nullptr; \
3156 : return result; \
3157 : } \
3158 : \
3159 : private: \
3160 : void InitializeAstRewriter(Isolate* isolate) { \
3161 : InitializeAstVisitor(isolate); \
3162 : replacement_ = nullptr; \
3163 : } \
3164 : \
3165 : void InitializeAstRewriter(uintptr_t stack_limit) { \
3166 : InitializeAstVisitor(stack_limit); \
3167 : replacement_ = nullptr; \
3168 : } \
3169 : \
3170 : DEFINE_AST_VISITOR_SUBCLASS_MEMBERS(); \
3171 : \
3172 : protected: \
3173 : AstNode* replacement_
3174 : // Generic macro for rewriting things; `GET` is the expression to be
3175 : // rewritten; `SET` is a command that should do the rewriting, i.e.
3176 : // something sensible with the variable called `replacement`.
3177 : #define AST_REWRITE(Type, GET, SET) \
3178 : do { \
3179 : DCHECK(!HasStackOverflow()); \
3180 : DCHECK_NULL(replacement_); \
3181 : Visit(GET); \
3182 : if (HasStackOverflow()) return; \
3183 : if (replacement_ == nullptr) break; \
3184 : Type* replacement = reinterpret_cast<Type*>(replacement_); \
3185 : do { \
3186 : SET; \
3187 : } while (false); \
3188 : replacement_ = nullptr; \
3189 : } while (false)
3190 :
3191 : // Macro for rewriting object properties; it assumes that `object` has
3192 : // `property` with a public getter and setter.
3193 : #define AST_REWRITE_PROPERTY(Type, object, property) \
3194 : do { \
3195 : auto _obj = (object); \
3196 : AST_REWRITE(Type, _obj->property(), _obj->set_##property(replacement)); \
3197 : } while (false)
3198 :
3199 : // Macro for rewriting list elements; it assumes that `list` has methods
3200 : // `at` and `Set`.
3201 : #define AST_REWRITE_LIST_ELEMENT(Type, list, index) \
3202 : do { \
3203 : auto _list = (list); \
3204 : auto _index = (index); \
3205 : AST_REWRITE(Type, _list->at(_index), _list->Set(_index, replacement)); \
3206 : } while (false)
3207 :
3208 :
3209 : // ----------------------------------------------------------------------------
3210 : // AstNode factory
3211 :
3212 : class AstNodeFactory final BASE_EMBEDDED {
3213 : public:
3214 17905297 : explicit AstNodeFactory(AstValueFactory* ast_value_factory)
3215 22884268 : : zone_(nullptr), ast_value_factory_(ast_value_factory) {
3216 22884268 : if (ast_value_factory != nullptr) {
3217 19454495 : zone_ = ast_value_factory->zone();
3218 : }
3219 12794 : }
3220 :
3221 : AstValueFactory* ast_value_factory() const { return ast_value_factory_; }
3222 3429793 : void set_ast_value_factory(AstValueFactory* ast_value_factory) {
3223 3429793 : ast_value_factory_ = ast_value_factory;
3224 3429793 : zone_ = ast_value_factory->zone();
3225 : }
3226 :
3227 83888 : VariableDeclaration* NewVariableDeclaration(VariableProxy* proxy,
3228 : Scope* scope, int pos) {
3229 167776 : return new (zone_) VariableDeclaration(proxy, scope, pos);
3230 : }
3231 :
3232 : FunctionDeclaration* NewFunctionDeclaration(VariableProxy* proxy,
3233 : FunctionLiteral* fun,
3234 : Scope* scope, int pos) {
3235 : return new (zone_) FunctionDeclaration(proxy, fun, scope, pos);
3236 : }
3237 :
3238 23820101 : Block* NewBlock(ZoneList<const AstRawString*>* labels, int capacity,
3239 : bool ignore_completion_value, int pos) {
3240 : return new (zone_)
3241 71460302 : Block(zone_, labels, capacity, ignore_completion_value, pos);
3242 : }
3243 :
3244 : #define STATEMENT_WITH_LABELS(NodeType) \
3245 : NodeType* New##NodeType(ZoneList<const AstRawString*>* labels, int pos) { \
3246 : return new (zone_) NodeType(labels, pos); \
3247 : }
3248 29352 : STATEMENT_WITH_LABELS(DoWhileStatement)
3249 224520 : STATEMENT_WITH_LABELS(WhileStatement)
3250 1575200 : STATEMENT_WITH_LABELS(ForStatement)
3251 184708 : STATEMENT_WITH_LABELS(SwitchStatement)
3252 : #undef STATEMENT_WITH_LABELS
3253 :
3254 179481 : ForEachStatement* NewForEachStatement(ForEachStatement::VisitMode visit_mode,
3255 : ZoneList<const AstRawString*>* labels,
3256 : int pos) {
3257 179481 : switch (visit_mode) {
3258 : case ForEachStatement::ENUMERATE: {
3259 71499 : return new (zone_) ForInStatement(labels, pos);
3260 : }
3261 : case ForEachStatement::ITERATE: {
3262 107982 : return new (zone_) ForOfStatement(labels, pos);
3263 : }
3264 : }
3265 0 : UNREACHABLE();
3266 : return NULL;
3267 : }
3268 :
3269 43187 : ForOfStatement* NewForOfStatement(ZoneList<const AstRawString*>* labels,
3270 : int pos) {
3271 86374 : return new (zone_) ForOfStatement(labels, pos);
3272 : }
3273 :
3274 772437 : ExpressionStatement* NewExpressionStatement(Expression* expression, int pos) {
3275 1544874 : return new (zone_) ExpressionStatement(expression, pos);
3276 : }
3277 :
3278 : ContinueStatement* NewContinueStatement(IterationStatement* target, int pos) {
3279 : return new (zone_) ContinueStatement(target, pos);
3280 : }
3281 :
3282 : BreakStatement* NewBreakStatement(BreakableStatement* target, int pos) {
3283 : return new (zone_) BreakStatement(target, pos);
3284 : }
3285 :
3286 32224 : ReturnStatement* NewReturnStatement(Expression* expression, int pos) {
3287 : return new (zone_)
3288 64448 : ReturnStatement(expression, ReturnStatement::kNormal, pos);
3289 : }
3290 :
3291 : ReturnStatement* NewAsyncReturnStatement(Expression* expression, int pos) {
3292 : return new (zone_)
3293 : ReturnStatement(expression, ReturnStatement::kAsyncReturn, pos);
3294 : }
3295 :
3296 : WithStatement* NewWithStatement(Scope* scope,
3297 : Expression* expression,
3298 : Statement* statement,
3299 : int pos) {
3300 : return new (zone_) WithStatement(scope, expression, statement, pos);
3301 : }
3302 :
3303 : IfStatement* NewIfStatement(Expression* condition,
3304 : Statement* then_statement,
3305 : Statement* else_statement,
3306 : int pos) {
3307 : return new (zone_)
3308 : IfStatement(condition, then_statement, else_statement, pos);
3309 : }
3310 :
3311 : TryCatchStatement* NewTryCatchStatement(Block* try_block, Scope* scope,
3312 : Block* catch_block, int pos) {
3313 : return new (zone_) TryCatchStatement(try_block, scope, catch_block,
3314 : HandlerTable::CAUGHT, pos);
3315 : }
3316 :
3317 : TryCatchStatement* NewTryCatchStatementForReThrow(Block* try_block,
3318 : Scope* scope,
3319 : Block* catch_block,
3320 : int pos) {
3321 : return new (zone_) TryCatchStatement(try_block, scope, catch_block,
3322 : HandlerTable::UNCAUGHT, pos);
3323 : }
3324 :
3325 : TryCatchStatement* NewTryCatchStatementForDesugaring(Block* try_block,
3326 : Scope* scope,
3327 : Block* catch_block,
3328 : int pos) {
3329 : return new (zone_) TryCatchStatement(try_block, scope, catch_block,
3330 : HandlerTable::DESUGARING, pos);
3331 : }
3332 :
3333 : TryCatchStatement* NewTryCatchStatementForAsyncAwait(Block* try_block,
3334 : Scope* scope,
3335 : Block* catch_block,
3336 : int pos) {
3337 : return new (zone_) TryCatchStatement(try_block, scope, catch_block,
3338 : HandlerTable::ASYNC_AWAIT, pos);
3339 : }
3340 :
3341 : TryFinallyStatement* NewTryFinallyStatement(Block* try_block,
3342 : Block* finally_block, int pos) {
3343 : return new (zone_) TryFinallyStatement(try_block, finally_block, pos);
3344 : }
3345 :
3346 : DebuggerStatement* NewDebuggerStatement(int pos) {
3347 : return new (zone_) DebuggerStatement(pos);
3348 : }
3349 :
3350 : EmptyStatement* NewEmptyStatement(int pos) {
3351 : return new (zone_) EmptyStatement(pos);
3352 : }
3353 :
3354 10583 : SloppyBlockFunctionStatement* NewSloppyBlockFunctionStatement() {
3355 : return new (zone_)
3356 21166 : SloppyBlockFunctionStatement(NewEmptyStatement(kNoSourcePosition));
3357 : }
3358 :
3359 : CaseClause* NewCaseClause(
3360 : Expression* label, ZoneList<Statement*>* statements, int pos) {
3361 535223 : return new (zone_) CaseClause(label, statements, pos);
3362 : }
3363 :
3364 36634589 : Literal* NewStringLiteral(const AstRawString* string, int pos) {
3365 73269134 : return new (zone_) Literal(ast_value_factory_->NewString(string), pos);
3366 : }
3367 :
3368 : // A JavaScript symbol (ECMA-262 edition 6).
3369 6119 : Literal* NewSymbolLiteral(AstSymbol symbol, int pos) {
3370 12238 : return new (zone_) Literal(ast_value_factory_->NewSymbol(symbol), pos);
3371 : }
3372 :
3373 4501096 : Literal* NewNumberLiteral(double number, int pos, bool with_dot = false) {
3374 : return new (zone_)
3375 9002192 : Literal(ast_value_factory_->NewNumber(number, with_dot), pos);
3376 : }
3377 :
3378 30000019 : Literal* NewSmiLiteral(uint32_t number, int pos) {
3379 60000045 : return new (zone_) Literal(ast_value_factory_->NewSmi(number), pos);
3380 : }
3381 :
3382 1790858 : Literal* NewBooleanLiteral(bool b, int pos) {
3383 3581716 : return new (zone_) Literal(ast_value_factory_->NewBoolean(b), pos);
3384 : }
3385 :
3386 1052936 : Literal* NewNullLiteral(int pos) {
3387 2105872 : return new (zone_) Literal(ast_value_factory_->NewNull(), pos);
3388 : }
3389 :
3390 1263276 : Literal* NewUndefinedLiteral(int pos) {
3391 2526552 : return new (zone_) Literal(ast_value_factory_->NewUndefined(), pos);
3392 : }
3393 :
3394 1437236 : Literal* NewTheHoleLiteral(int pos) {
3395 2874472 : return new (zone_) Literal(ast_value_factory_->NewTheHole(), pos);
3396 : }
3397 :
3398 1590767 : ObjectLiteral* NewObjectLiteral(
3399 : ZoneList<ObjectLiteral::Property*>* properties,
3400 : uint32_t boilerplate_properties, int pos, bool has_rest_property) {
3401 : return new (zone_) ObjectLiteral(properties, boilerplate_properties, pos,
3402 3181534 : has_rest_property);
3403 : }
3404 :
3405 : ObjectLiteral::Property* NewObjectLiteralProperty(
3406 : Expression* key, Expression* value, ObjectLiteralProperty::Kind kind,
3407 : bool is_computed_name) {
3408 : return new (zone_)
3409 220800 : ObjectLiteral::Property(key, value, kind, is_computed_name);
3410 : }
3411 :
3412 4696999 : ObjectLiteral::Property* NewObjectLiteralProperty(Expression* key,
3413 : Expression* value,
3414 : bool is_computed_name) {
3415 : return new (zone_) ObjectLiteral::Property(ast_value_factory_, key, value,
3416 9393999 : is_computed_name);
3417 : }
3418 :
3419 97489 : RegExpLiteral* NewRegExpLiteral(const AstRawString* pattern, int flags,
3420 : int pos) {
3421 194978 : return new (zone_) RegExpLiteral(pattern, flags, pos);
3422 : }
3423 :
3424 26105 : ArrayLiteral* NewArrayLiteral(ZoneList<Expression*>* values,
3425 : int pos) {
3426 52210 : return new (zone_) ArrayLiteral(values, -1, pos);
3427 : }
3428 :
3429 770437 : ArrayLiteral* NewArrayLiteral(ZoneList<Expression*>* values,
3430 : int first_spread_index, int pos) {
3431 1540874 : return new (zone_) ArrayLiteral(values, first_spread_index, pos);
3432 : }
3433 :
3434 480536 : VariableProxy* NewVariableProxy(Variable* var,
3435 : int start_position = kNoSourcePosition) {
3436 14236844 : return new (zone_) VariableProxy(var, start_position);
3437 : }
3438 :
3439 83888 : VariableProxy* NewVariableProxy(const AstRawString* name,
3440 : VariableKind variable_kind,
3441 : int start_position = kNoSourcePosition) {
3442 : DCHECK_NOT_NULL(name);
3443 124296345 : return new (zone_) VariableProxy(name, variable_kind, start_position);
3444 : }
3445 :
3446 : // Recreates the VariableProxy in this Zone.
3447 : VariableProxy* CopyVariableProxy(VariableProxy* proxy) {
3448 2534705 : return new (zone_) VariableProxy(proxy);
3449 : }
3450 :
3451 157 : Property* NewProperty(Expression* obj, Expression* key, int pos) {
3452 314 : return new (zone_) Property(obj, key, pos);
3453 : }
3454 :
3455 : Call* NewCall(Expression* expression, ZoneList<Expression*>* arguments,
3456 : int pos, Call::PossiblyEval possibly_eval = Call::NOT_EVAL) {
3457 11753107 : return new (zone_) Call(expression, arguments, pos, possibly_eval);
3458 : }
3459 :
3460 1028428 : CallNew* NewCallNew(Expression* expression,
3461 : ZoneList<Expression*>* arguments,
3462 : int pos) {
3463 2056856 : return new (zone_) CallNew(expression, arguments, pos);
3464 : }
3465 :
3466 2557204 : CallRuntime* NewCallRuntime(Runtime::FunctionId id,
3467 : ZoneList<Expression*>* arguments, int pos) {
3468 5114408 : return new (zone_) CallRuntime(Runtime::FunctionForId(id), arguments, pos);
3469 : }
3470 :
3471 1967574 : CallRuntime* NewCallRuntime(const Runtime::Function* function,
3472 : ZoneList<Expression*>* arguments, int pos) {
3473 3935148 : return new (zone_) CallRuntime(function, arguments, pos);
3474 : }
3475 :
3476 344323 : CallRuntime* NewCallRuntime(int context_index,
3477 : ZoneList<Expression*>* arguments, int pos) {
3478 688646 : return new (zone_) CallRuntime(context_index, arguments, pos);
3479 : }
3480 :
3481 : UnaryOperation* NewUnaryOperation(Token::Value op,
3482 : Expression* expression,
3483 : int pos) {
3484 : return new (zone_) UnaryOperation(op, expression, pos);
3485 : }
3486 :
3487 7952078 : BinaryOperation* NewBinaryOperation(Token::Value op,
3488 : Expression* left,
3489 : Expression* right,
3490 : int pos) {
3491 15904156 : return new (zone_) BinaryOperation(op, left, right, pos);
3492 : }
3493 :
3494 1547929 : CountOperation* NewCountOperation(Token::Value op,
3495 : bool is_prefix,
3496 : Expression* expr,
3497 : int pos) {
3498 3095858 : return new (zone_) CountOperation(op, is_prefix, expr, pos);
3499 : }
3500 :
3501 7069283 : CompareOperation* NewCompareOperation(Token::Value op,
3502 : Expression* left,
3503 : Expression* right,
3504 : int pos) {
3505 14138567 : return new (zone_) CompareOperation(op, left, right, pos);
3506 : }
3507 :
3508 : Spread* NewSpread(Expression* expression, int pos, int expr_pos) {
3509 : return new (zone_) Spread(expression, pos, expr_pos);
3510 : }
3511 :
3512 : Conditional* NewConditional(Expression* condition,
3513 : Expression* then_expression,
3514 : Expression* else_expression,
3515 : int position) {
3516 : return new (zone_)
3517 : Conditional(condition, then_expression, else_expression, position);
3518 : }
3519 :
3520 : RewritableExpression* NewRewritableExpression(Expression* expression) {
3521 : DCHECK_NOT_NULL(expression);
3522 : return new (zone_) RewritableExpression(expression);
3523 : }
3524 :
3525 28097094 : Assignment* NewAssignment(Token::Value op,
3526 : Expression* target,
3527 : Expression* value,
3528 563565 : int pos) {
3529 : DCHECK(Token::IsAssignmentOp(op));
3530 :
3531 43339224 : if (op != Token::INIT && target->IsVariableProxy()) {
3532 8483267 : target->AsVariableProxy()->set_is_assigned();
3533 : }
3534 :
3535 56194201 : Assignment* assign = new (zone_) Assignment(op, target, value, pos);
3536 28097090 : if (assign->is_compound()) {
3537 : assign->binary_operation_ =
3538 1127130 : NewBinaryOperation(assign->binary_op(), target, value, pos + 1);
3539 : }
3540 28097090 : return assign;
3541 : }
3542 :
3543 186530 : Suspend* NewSuspend(Expression* generator_object, Expression* expression,
3544 : int pos, Suspend::OnException on_exception,
3545 : SuspendFlags flags) {
3546 186530 : if (!expression) expression = NewUndefinedLiteral(pos);
3547 : return new (zone_)
3548 373060 : Suspend(generator_object, expression, pos, on_exception, flags);
3549 : }
3550 :
3551 378107 : Throw* NewThrow(Expression* exception, int pos) {
3552 756214 : return new (zone_) Throw(exception, pos);
3553 : }
3554 :
3555 8143841 : FunctionLiteral* NewFunctionLiteral(
3556 : const AstRawString* name, DeclarationScope* scope,
3557 : ZoneList<Statement*>* body, int expected_property_count,
3558 : int parameter_count, int function_length,
3559 : FunctionLiteral::ParameterFlag has_duplicate_parameters,
3560 : FunctionLiteral::FunctionType function_type,
3561 : FunctionLiteral::EagerCompileHint eager_compile_hint, int position,
3562 : bool has_braces, int function_literal_id) {
3563 : return new (zone_) FunctionLiteral(
3564 : zone_, name, ast_value_factory_, scope, body, expected_property_count,
3565 : parameter_count, function_length, function_type,
3566 : has_duplicate_parameters, eager_compile_hint, position, has_braces,
3567 16287687 : function_literal_id);
3568 : }
3569 :
3570 : // Creates a FunctionLiteral representing a top-level script, the
3571 : // result of an eval (top-level or otherwise), or the result of calling
3572 : // the Function constructor.
3573 1883811 : FunctionLiteral* NewScriptOrEvalFunctionLiteral(DeclarationScope* scope,
3574 : ZoneList<Statement*>* body,
3575 : int expected_property_count,
3576 : int parameter_count) {
3577 : return new (zone_) FunctionLiteral(
3578 1883811 : zone_, ast_value_factory_->empty_string(), ast_value_factory_, scope,
3579 : body, expected_property_count, parameter_count, parameter_count,
3580 : FunctionLiteral::kAnonymousExpression,
3581 : FunctionLiteral::kNoDuplicateParameters,
3582 : FunctionLiteral::kShouldLazyCompile, 0, true,
3583 3767632 : FunctionLiteral::kIdTypeTopLevel);
3584 : }
3585 :
3586 : ClassLiteral::Property* NewClassLiteralProperty(
3587 : Expression* key, Expression* value, ClassLiteralProperty::Kind kind,
3588 : bool is_static, bool is_computed_name) {
3589 : return new (zone_)
3590 350663 : ClassLiteral::Property(key, value, kind, is_static, is_computed_name);
3591 : }
3592 :
3593 92611 : ClassLiteral* NewClassLiteral(VariableProxy* proxy, Expression* extends,
3594 : FunctionLiteral* constructor,
3595 : ZoneList<ClassLiteral::Property*>* properties,
3596 : int start_position, int end_position,
3597 : bool has_name_static_property,
3598 : bool has_static_computed_names) {
3599 : return new (zone_) ClassLiteral(
3600 : proxy, extends, constructor, properties, start_position, end_position,
3601 185222 : has_name_static_property, has_static_computed_names);
3602 : }
3603 :
3604 2988 : NativeFunctionLiteral* NewNativeFunctionLiteral(const AstRawString* name,
3605 : v8::Extension* extension,
3606 : int pos) {
3607 5976 : return new (zone_) NativeFunctionLiteral(name, extension, pos);
3608 : }
3609 :
3610 435266 : DoExpression* NewDoExpression(Block* block, Variable* result_var, int pos) {
3611 : VariableProxy* result = NewVariableProxy(result_var, pos);
3612 870532 : return new (zone_) DoExpression(block, result, pos);
3613 : }
3614 :
3615 : ThisFunction* NewThisFunction(int pos) {
3616 : return new (zone_) ThisFunction(pos);
3617 : }
3618 :
3619 : SuperPropertyReference* NewSuperPropertyReference(VariableProxy* this_var,
3620 : Expression* home_object,
3621 : int pos) {
3622 : return new (zone_) SuperPropertyReference(this_var, home_object, pos);
3623 : }
3624 :
3625 : SuperCallReference* NewSuperCallReference(VariableProxy* this_var,
3626 : VariableProxy* new_target_var,
3627 : VariableProxy* this_function_var,
3628 : int pos) {
3629 : return new (zone_)
3630 : SuperCallReference(this_var, new_target_var, this_function_var, pos);
3631 : }
3632 :
3633 : EmptyParentheses* NewEmptyParentheses(int pos) {
3634 : return new (zone_) EmptyParentheses(pos);
3635 : }
3636 :
3637 213364 : GetIterator* NewGetIterator(Expression* iterable, IteratorType hint,
3638 : int pos) {
3639 426728 : return new (zone_) GetIterator(iterable, hint, pos);
3640 : }
3641 :
3642 : ImportCallExpression* NewImportCallExpression(Expression* args, int pos) {
3643 : return new (zone_) ImportCallExpression(args, pos);
3644 : }
3645 :
3646 : Zone* zone() const { return zone_; }
3647 16710541 : void set_zone(Zone* zone) { zone_ = zone; }
3648 :
3649 : // Handles use of temporary zones when parsing inner function bodies.
3650 : class BodyScope {
3651 : public:
3652 : BodyScope(AstNodeFactory* factory, Zone* temp_zone, bool use_temp_zone)
3653 7562020 : : factory_(factory), prev_zone_(factory->zone_) {
3654 7562020 : if (use_temp_zone) {
3655 1403478 : factory->zone_ = temp_zone;
3656 : }
3657 : }
3658 :
3659 15124085 : void Reset() { factory_->zone_ = prev_zone_; }
3660 : ~BodyScope() { Reset(); }
3661 :
3662 : private:
3663 : AstNodeFactory* factory_;
3664 : Zone* prev_zone_;
3665 : };
3666 :
3667 : private:
3668 : // This zone may be deallocated upon returning from parsing a function body
3669 : // which we can guarantee is not going to be compiled or have its AST
3670 : // inspected.
3671 : // See ParseFunctionLiteral in parser.cc for preconditions.
3672 : Zone* zone_;
3673 : AstValueFactory* ast_value_factory_;
3674 : };
3675 :
3676 :
3677 : // Type testing & conversion functions overridden by concrete subclasses.
3678 : // Inline functions for AstNode.
3679 :
3680 : #define DECLARE_NODE_FUNCTIONS(type) \
3681 : bool AstNode::Is##type() const { \
3682 : NodeType mine = node_type(); \
3683 : if (mine == AstNode::kRewritableExpression && \
3684 : AstNode::k##type != AstNode::kRewritableExpression) \
3685 : mine = reinterpret_cast<const RewritableExpression*>(this) \
3686 : ->expression() \
3687 : ->node_type(); \
3688 : return mine == AstNode::k##type; \
3689 : } \
3690 : type* AstNode::As##type() { \
3691 : NodeType mine = node_type(); \
3692 : AstNode* result = this; \
3693 : if (mine == AstNode::kRewritableExpression && \
3694 : AstNode::k##type != AstNode::kRewritableExpression) { \
3695 : result = \
3696 : reinterpret_cast<const RewritableExpression*>(this)->expression(); \
3697 : mine = result->node_type(); \
3698 : } \
3699 : return mine == AstNode::k##type ? reinterpret_cast<type*>(result) : NULL; \
3700 : } \
3701 : const type* AstNode::As##type() const { \
3702 : NodeType mine = node_type(); \
3703 : const AstNode* result = this; \
3704 : if (mine == AstNode::kRewritableExpression && \
3705 : AstNode::k##type != AstNode::kRewritableExpression) { \
3706 : result = \
3707 : reinterpret_cast<const RewritableExpression*>(this)->expression(); \
3708 : mine = result->node_type(); \
3709 : } \
3710 : return mine == AstNode::k##type ? reinterpret_cast<const type*>(result) \
3711 : : NULL; \
3712 : }
3713 1304557857 : AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
3714 : #undef DECLARE_NODE_FUNCTIONS
3715 :
3716 :
3717 : } // namespace internal
3718 : } // namespace v8
3719 :
3720 : #endif // V8_AST_AST_H_
|
