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 #include "src/ast/ast.h"
6
7 #include <cmath> // For isfinite.
8 #include <vector>
9
10 #include "src/ast/prettyprinter.h"
11 #include "src/ast/scopes.h"
12 #include "src/base/hashmap.h"
13 #include "src/base/logging.h"
14 #include "src/builtins/builtins-constructor.h"
15 #include "src/builtins/builtins.h"
16 #include "src/common/assert-scope.h"
17 #include "src/heap/local-factory-inl.h"
18 #include "src/numbers/conversions-inl.h"
19 #include "src/numbers/double.h"
20 #include "src/objects/contexts.h"
21 #include "src/objects/elements-kind.h"
22 #include "src/objects/elements.h"
23 #include "src/objects/fixed-array.h"
24 #include "src/objects/literal-objects-inl.h"
25 #include "src/objects/literal-objects.h"
26 #include "src/objects/map.h"
27 #include "src/objects/objects-inl.h"
28 #include "src/objects/property-details.h"
29 #include "src/objects/property.h"
30 #include "src/strings/string-stream.h"
31 #include "src/zone/zone-list-inl.h"
32
33 namespace v8 {
34 namespace internal {
35
36 // ----------------------------------------------------------------------------
37 // Implementation of other node functionality.
38
39 #ifdef DEBUG
40
NameForNativeContextIntrinsicIndex(uint32_t idx)41 static const char* NameForNativeContextIntrinsicIndex(uint32_t idx) {
42 switch (idx) {
43 #define NATIVE_CONTEXT_FIELDS_IDX(NAME, Type, name) \
44 case Context::NAME: \
45 return #name;
46
47 NATIVE_CONTEXT_FIELDS(NATIVE_CONTEXT_FIELDS_IDX)
48 #undef NATIVE_CONTEXT_FIELDS_IDX
49
50 default:
51 break;
52 }
53
54 return "UnknownIntrinsicIndex";
55 }
56
Print(Isolate * isolate)57 void AstNode::Print(Isolate* isolate) {
58 AllowHandleDereference allow_deref;
59 AstPrinter::PrintOut(isolate, this);
60 }
61
62 #endif // DEBUG
63
64 #define RETURN_NODE(Node) \
65 case k##Node: \
66 return static_cast<Node*>(this);
67
AsIterationStatement()68 IterationStatement* AstNode::AsIterationStatement() {
69 switch (node_type()) {
70 ITERATION_NODE_LIST(RETURN_NODE);
71 default:
72 return nullptr;
73 }
74 }
75
AsMaterializedLiteral()76 MaterializedLiteral* AstNode::AsMaterializedLiteral() {
77 switch (node_type()) {
78 LITERAL_NODE_LIST(RETURN_NODE);
79 default:
80 return nullptr;
81 }
82 }
83
84 #undef RETURN_NODE
85
IsSmiLiteral() const86 bool Expression::IsSmiLiteral() const {
87 return IsLiteral() && AsLiteral()->type() == Literal::kSmi;
88 }
89
IsNumberLiteral() const90 bool Expression::IsNumberLiteral() const {
91 return IsLiteral() && AsLiteral()->IsNumber();
92 }
93
IsStringLiteral() const94 bool Expression::IsStringLiteral() const {
95 return IsLiteral() && AsLiteral()->type() == Literal::kString;
96 }
97
IsPropertyName() const98 bool Expression::IsPropertyName() const {
99 return IsLiteral() && AsLiteral()->IsPropertyName();
100 }
101
IsNullLiteral() const102 bool Expression::IsNullLiteral() const {
103 return IsLiteral() && AsLiteral()->type() == Literal::kNull;
104 }
105
IsTheHoleLiteral() const106 bool Expression::IsTheHoleLiteral() const {
107 return IsLiteral() && AsLiteral()->type() == Literal::kTheHole;
108 }
109
IsCompileTimeValue()110 bool Expression::IsCompileTimeValue() {
111 if (IsLiteral()) return true;
112 MaterializedLiteral* literal = AsMaterializedLiteral();
113 if (literal == nullptr) return false;
114 return literal->IsSimple();
115 }
116
IsUndefinedLiteral() const117 bool Expression::IsUndefinedLiteral() const {
118 if (IsLiteral() && AsLiteral()->type() == Literal::kUndefined) return true;
119
120 const VariableProxy* var_proxy = AsVariableProxy();
121 if (var_proxy == nullptr) return false;
122 Variable* var = var_proxy->var();
123 // The global identifier "undefined" is immutable. Everything
124 // else could be reassigned.
125 return var != nullptr && var->IsUnallocated() &&
126 var_proxy->raw_name()->IsOneByteEqualTo("undefined");
127 }
128
IsLiteralButNotNullOrUndefined() const129 bool Expression::IsLiteralButNotNullOrUndefined() const {
130 return IsLiteral() && !IsNullOrUndefinedLiteral();
131 }
132
ToBooleanIsTrue() const133 bool Expression::ToBooleanIsTrue() const {
134 return IsLiteral() && AsLiteral()->ToBooleanIsTrue();
135 }
136
ToBooleanIsFalse() const137 bool Expression::ToBooleanIsFalse() const {
138 return IsLiteral() && AsLiteral()->ToBooleanIsFalse();
139 }
140
IsPrivateName() const141 bool Expression::IsPrivateName() const {
142 return IsVariableProxy() && AsVariableProxy()->IsPrivateName();
143 }
144
IsValidReferenceExpression() const145 bool Expression::IsValidReferenceExpression() const {
146 return IsProperty() ||
147 (IsVariableProxy() && AsVariableProxy()->IsValidReferenceExpression());
148 }
149
IsAnonymousFunctionDefinition() const150 bool Expression::IsAnonymousFunctionDefinition() const {
151 return (IsFunctionLiteral() &&
152 AsFunctionLiteral()->IsAnonymousFunctionDefinition()) ||
153 (IsClassLiteral() &&
154 AsClassLiteral()->IsAnonymousFunctionDefinition());
155 }
156
IsConciseMethodDefinition() const157 bool Expression::IsConciseMethodDefinition() const {
158 return IsFunctionLiteral() && IsConciseMethod(AsFunctionLiteral()->kind());
159 }
160
IsAccessorFunctionDefinition() const161 bool Expression::IsAccessorFunctionDefinition() const {
162 return IsFunctionLiteral() && IsAccessorFunction(AsFunctionLiteral()->kind());
163 }
164
VariableProxy(Variable * var,int start_position)165 VariableProxy::VariableProxy(Variable* var, int start_position)
166 : Expression(start_position, kVariableProxy),
167 raw_name_(var->raw_name()),
168 next_unresolved_(nullptr) {
169 DCHECK(!var->is_this());
170 bit_field_ |= IsAssignedField::encode(false) |
171 IsResolvedField::encode(false) |
172 HoleCheckModeField::encode(HoleCheckMode::kElided);
173 BindTo(var);
174 }
175
VariableProxy(const VariableProxy * copy_from)176 VariableProxy::VariableProxy(const VariableProxy* copy_from)
177 : Expression(copy_from->position(), kVariableProxy),
178 next_unresolved_(nullptr) {
179 bit_field_ = copy_from->bit_field_;
180 DCHECK(!copy_from->is_resolved());
181 raw_name_ = copy_from->raw_name_;
182 }
183
BindTo(Variable * var)184 void VariableProxy::BindTo(Variable* var) {
185 DCHECK_EQ(raw_name(), var->raw_name());
186 set_var(var);
187 set_is_resolved();
188 var->set_is_used();
189 if (is_assigned()) var->SetMaybeAssigned();
190 }
191
Assignment(NodeType node_type,Token::Value op,Expression * target,Expression * value,int pos)192 Assignment::Assignment(NodeType node_type, Token::Value op, Expression* target,
193 Expression* value, int pos)
194 : Expression(pos, node_type), target_(target), value_(value) {
195 bit_field_ |= TokenField::encode(op);
196 }
197
set_inferred_name(Handle<String> inferred_name)198 void FunctionLiteral::set_inferred_name(Handle<String> inferred_name) {
199 DCHECK(!inferred_name.is_null());
200 inferred_name_ = inferred_name;
201 DCHECK(raw_inferred_name_ == nullptr || raw_inferred_name_->IsEmpty());
202 raw_inferred_name_ = nullptr;
203 scope()->set_has_inferred_function_name(true);
204 }
205
set_raw_inferred_name(AstConsString * raw_inferred_name)206 void FunctionLiteral::set_raw_inferred_name(AstConsString* raw_inferred_name) {
207 DCHECK_NOT_NULL(raw_inferred_name);
208 raw_inferred_name_ = raw_inferred_name;
209 DCHECK(inferred_name_.is_null());
210 inferred_name_ = Handle<String>();
211 scope()->set_has_inferred_function_name(true);
212 }
213
ShouldEagerCompile() const214 bool FunctionLiteral::ShouldEagerCompile() const {
215 return scope()->ShouldEagerCompile();
216 }
217
SetShouldEagerCompile()218 void FunctionLiteral::SetShouldEagerCompile() {
219 scope()->set_should_eager_compile();
220 }
221
AllowsLazyCompilation()222 bool FunctionLiteral::AllowsLazyCompilation() {
223 return scope()->AllowsLazyCompilation();
224 }
225
start_position() const226 int FunctionLiteral::start_position() const {
227 return scope()->start_position();
228 }
229
end_position() const230 int FunctionLiteral::end_position() const { return scope()->end_position(); }
231
language_mode() const232 LanguageMode FunctionLiteral::language_mode() const {
233 return scope()->language_mode();
234 }
235
kind() const236 FunctionKind FunctionLiteral::kind() const { return scope()->function_kind(); }
237
NeedsHomeObject(Expression * expr)238 bool FunctionLiteral::NeedsHomeObject(Expression* expr) {
239 if (expr == nullptr || !expr->IsFunctionLiteral()) return false;
240 DCHECK_NOT_NULL(expr->AsFunctionLiteral()->scope());
241 return expr->AsFunctionLiteral()->scope()->NeedsHomeObject();
242 }
243
GetDebugName() const244 std::unique_ptr<char[]> FunctionLiteral::GetDebugName() const {
245 const AstConsString* cons_string;
246 if (raw_name_ != nullptr && !raw_name_->IsEmpty()) {
247 cons_string = raw_name_;
248 } else if (raw_inferred_name_ != nullptr && !raw_inferred_name_->IsEmpty()) {
249 cons_string = raw_inferred_name_;
250 } else if (!inferred_name_.is_null()) {
251 AllowHandleDereference allow_deref;
252 return inferred_name_->ToCString();
253 } else {
254 char* empty_str = new char[1];
255 empty_str[0] = 0;
256 return std::unique_ptr<char[]>(empty_str);
257 }
258
259 // TODO(rmcilroy): Deal with two-character strings.
260 std::vector<char> result_vec;
261 std::forward_list<const AstRawString*> strings = cons_string->ToRawStrings();
262 for (const AstRawString* string : strings) {
263 if (!string->is_one_byte()) break;
264 for (int i = 0; i < string->length(); i++) {
265 result_vec.push_back(string->raw_data()[i]);
266 }
267 }
268 std::unique_ptr<char[]> result(new char[result_vec.size() + 1]);
269 memcpy(result.get(), result_vec.data(), result_vec.size());
270 result[result_vec.size()] = '\0';
271 return result;
272 }
273
private_name_lookup_skips_outer_class() const274 bool FunctionLiteral::private_name_lookup_skips_outer_class() const {
275 return scope()->private_name_lookup_skips_outer_class();
276 }
277
ObjectLiteralProperty(Expression * key,Expression * value,Kind kind,bool is_computed_name)278 ObjectLiteralProperty::ObjectLiteralProperty(Expression* key, Expression* value,
279 Kind kind, bool is_computed_name)
280 : LiteralProperty(key, value, is_computed_name),
281 kind_(kind),
282 emit_store_(true) {}
283
ObjectLiteralProperty(AstValueFactory * ast_value_factory,Expression * key,Expression * value,bool is_computed_name)284 ObjectLiteralProperty::ObjectLiteralProperty(AstValueFactory* ast_value_factory,
285 Expression* key, Expression* value,
286 bool is_computed_name)
287 : LiteralProperty(key, value, is_computed_name), emit_store_(true) {
288 if (!is_computed_name && key->AsLiteral()->IsString() &&
289 key->AsLiteral()->AsRawString() == ast_value_factory->proto_string()) {
290 kind_ = PROTOTYPE;
291 } else if (value_->AsMaterializedLiteral() != nullptr) {
292 kind_ = MATERIALIZED_LITERAL;
293 } else if (value_->IsLiteral()) {
294 kind_ = CONSTANT;
295 } else {
296 kind_ = COMPUTED;
297 }
298 }
299
NeedsSetFunctionName() const300 bool LiteralProperty::NeedsSetFunctionName() const {
301 return is_computed_name() && (value_->IsAnonymousFunctionDefinition() ||
302 value_->IsConciseMethodDefinition() ||
303 value_->IsAccessorFunctionDefinition());
304 }
305
ClassLiteralProperty(Expression * key,Expression * value,Kind kind,bool is_static,bool is_computed_name,bool is_private)306 ClassLiteralProperty::ClassLiteralProperty(Expression* key, Expression* value,
307 Kind kind, bool is_static,
308 bool is_computed_name,
309 bool is_private)
310 : LiteralProperty(key, value, is_computed_name),
311 kind_(kind),
312 is_static_(is_static),
313 is_private_(is_private),
314 private_or_computed_name_var_(nullptr) {}
315
IsCompileTimeValue() const316 bool ObjectLiteral::Property::IsCompileTimeValue() const {
317 return kind_ == CONSTANT ||
318 (kind_ == MATERIALIZED_LITERAL && value_->IsCompileTimeValue());
319 }
320
set_emit_store(bool emit_store)321 void ObjectLiteral::Property::set_emit_store(bool emit_store) {
322 emit_store_ = emit_store;
323 }
324
emit_store() const325 bool ObjectLiteral::Property::emit_store() const { return emit_store_; }
326
CalculateEmitStore(Zone * zone)327 void ObjectLiteral::CalculateEmitStore(Zone* zone) {
328 const auto GETTER = ObjectLiteral::Property::GETTER;
329 const auto SETTER = ObjectLiteral::Property::SETTER;
330
331 CustomMatcherZoneHashMap table(Literal::Match,
332 ZoneHashMap::kDefaultHashMapCapacity,
333 ZoneAllocationPolicy(zone));
334 for (int i = properties()->length() - 1; i >= 0; i--) {
335 ObjectLiteral::Property* property = properties()->at(i);
336 if (property->is_computed_name()) continue;
337 if (property->IsPrototype()) continue;
338 Literal* literal = property->key()->AsLiteral();
339 DCHECK(!literal->IsNullLiteral());
340
341 uint32_t hash = literal->Hash();
342 ZoneHashMap::Entry* entry = table.LookupOrInsert(literal, hash);
343 if (entry->value == nullptr) {
344 entry->value = property;
345 } else {
346 // We already have a later definition of this property, so we don't need
347 // to emit a store for the current one.
348 //
349 // There are two subtleties here.
350 //
351 // (1) Emitting a store might actually be incorrect. For example, in {get
352 // foo() {}, foo: 42}, the getter store would override the data property
353 // (which, being a non-computed compile-time valued property, is already
354 // part of the initial literal object.
355 //
356 // (2) If the later definition is an accessor (say, a getter), and the
357 // current definition is a complementary accessor (here, a setter), then
358 // we still must emit a store for the current definition.
359
360 auto later_kind =
361 static_cast<ObjectLiteral::Property*>(entry->value)->kind();
362 bool complementary_accessors =
363 (property->kind() == GETTER && later_kind == SETTER) ||
364 (property->kind() == SETTER && later_kind == GETTER);
365 if (!complementary_accessors) {
366 property->set_emit_store(false);
367 if (later_kind == GETTER || later_kind == SETTER) {
368 entry->value = property;
369 }
370 }
371 }
372 }
373 }
374
InitFlagsForPendingNullPrototype(int i)375 void ObjectLiteral::InitFlagsForPendingNullPrototype(int i) {
376 // We still check for __proto__:null after computed property names.
377 for (; i < properties()->length(); i++) {
378 if (properties()->at(i)->IsNullPrototype()) {
379 set_has_null_protoype(true);
380 break;
381 }
382 }
383 }
384
InitDepthAndFlags()385 int ObjectLiteral::InitDepthAndFlags() {
386 if (is_initialized()) return depth();
387 bool is_simple = true;
388 bool has_seen_prototype = false;
389 bool needs_initial_allocation_site = false;
390 int depth_acc = 1;
391 uint32_t nof_properties = 0;
392 uint32_t elements = 0;
393 uint32_t max_element_index = 0;
394 for (int i = 0; i < properties()->length(); i++) {
395 ObjectLiteral::Property* property = properties()->at(i);
396 if (property->IsPrototype()) {
397 has_seen_prototype = true;
398 // __proto__:null has no side-effects and is set directly on the
399 // boilerplate.
400 if (property->IsNullPrototype()) {
401 set_has_null_protoype(true);
402 continue;
403 }
404 DCHECK(!has_null_prototype());
405 is_simple = false;
406 continue;
407 }
408 if (nof_properties == boilerplate_properties_) {
409 DCHECK(property->is_computed_name());
410 is_simple = false;
411 if (!has_seen_prototype) InitFlagsForPendingNullPrototype(i);
412 break;
413 }
414 DCHECK(!property->is_computed_name());
415
416 MaterializedLiteral* literal = property->value()->AsMaterializedLiteral();
417 if (literal != nullptr) {
418 int subliteral_depth = literal->InitDepthAndFlags() + 1;
419 if (subliteral_depth > depth_acc) depth_acc = subliteral_depth;
420 needs_initial_allocation_site |= literal->NeedsInitialAllocationSite();
421 }
422
423 Literal* key = property->key()->AsLiteral();
424 Expression* value = property->value();
425
426 bool is_compile_time_value = value->IsCompileTimeValue();
427 is_simple = is_simple && is_compile_time_value;
428
429 // Keep track of the number of elements in the object literal and
430 // the largest element index. If the largest element index is
431 // much larger than the number of elements, creating an object
432 // literal with fast elements will be a waste of space.
433 uint32_t element_index = 0;
434 if (key->AsArrayIndex(&element_index)) {
435 max_element_index = std::max(element_index, max_element_index);
436 elements++;
437 } else {
438 DCHECK(key->IsPropertyName());
439 }
440
441 nof_properties++;
442 }
443
444 set_depth(depth_acc);
445 set_is_simple(is_simple);
446 set_needs_initial_allocation_site(needs_initial_allocation_site);
447 set_has_elements(elements > 0);
448 set_fast_elements((max_element_index <= 32) ||
449 ((2 * elements) >= max_element_index));
450 return depth_acc;
451 }
452
453 template <typename LocalIsolate>
BuildBoilerplateDescription(LocalIsolate * isolate)454 void ObjectLiteral::BuildBoilerplateDescription(LocalIsolate* isolate) {
455 if (!boilerplate_description_.is_null()) return;
456
457 int index_keys = 0;
458 bool has_seen_proto = false;
459 for (int i = 0; i < properties()->length(); i++) {
460 ObjectLiteral::Property* property = properties()->at(i);
461 if (property->IsPrototype()) {
462 has_seen_proto = true;
463 continue;
464 }
465 if (property->is_computed_name()) continue;
466
467 Literal* key = property->key()->AsLiteral();
468 if (!key->IsPropertyName()) index_keys++;
469 }
470
471 Handle<ObjectBoilerplateDescription> boilerplate_description =
472 isolate->factory()->NewObjectBoilerplateDescription(
473 boilerplate_properties_, properties()->length(), index_keys,
474 has_seen_proto);
475
476 int position = 0;
477 for (int i = 0; i < properties()->length(); i++) {
478 ObjectLiteral::Property* property = properties()->at(i);
479 if (property->IsPrototype()) continue;
480
481 if (static_cast<uint32_t>(position) == boilerplate_properties_) {
482 DCHECK(property->is_computed_name());
483 break;
484 }
485 DCHECK(!property->is_computed_name());
486
487 MaterializedLiteral* m_literal = property->value()->AsMaterializedLiteral();
488 if (m_literal != nullptr) {
489 m_literal->BuildConstants(isolate);
490 }
491
492 // Add CONSTANT and COMPUTED properties to boilerplate. Use undefined
493 // value for COMPUTED properties, the real value is filled in at
494 // runtime. The enumeration order is maintained.
495 Literal* key_literal = property->key()->AsLiteral();
496 uint32_t element_index = 0;
497 Handle<Object> key =
498 key_literal->AsArrayIndex(&element_index)
499 ? isolate->factory()
500 ->template NewNumberFromUint<AllocationType::kOld>(
501 element_index)
502 : Handle<Object>::cast(key_literal->AsRawPropertyName()->string());
503
504 Handle<Object> value = GetBoilerplateValue(property->value(), isolate);
505
506 // Add name, value pair to the fixed array.
507 boilerplate_description->set_key_value(position++, *key, *value);
508 }
509
510 boilerplate_description->set_flags(EncodeLiteralType());
511
512 boilerplate_description_ = boilerplate_description;
513 }
514 template EXPORT_TEMPLATE_DEFINE(V8_BASE_EXPORT) void ObjectLiteral::
515 BuildBoilerplateDescription(Isolate* isolate);
516 template EXPORT_TEMPLATE_DEFINE(V8_BASE_EXPORT) void ObjectLiteral::
517 BuildBoilerplateDescription(LocalIsolate* isolate);
518
IsFastCloningSupported() const519 bool ObjectLiteral::IsFastCloningSupported() const {
520 // The CreateShallowObjectLiteratal builtin doesn't copy elements, and object
521 // literals don't support copy-on-write (COW) elements for now.
522 // TODO(mvstanton): make object literals support COW elements.
523 return fast_elements() && is_shallow() &&
524 properties_count() <=
525 ConstructorBuiltins::kMaximumClonedShallowObjectProperties;
526 }
527
InitDepthAndFlags()528 int ArrayLiteral::InitDepthAndFlags() {
529 if (is_initialized()) return depth();
530
531 int constants_length =
532 first_spread_index_ >= 0 ? first_spread_index_ : values()->length();
533
534 // Fill in the literals.
535 bool is_simple = first_spread_index_ < 0;
536 bool is_holey = false;
537 ElementsKind kind = FIRST_FAST_ELEMENTS_KIND;
538 int depth_acc = 1;
539 int array_index = 0;
540 for (; array_index < constants_length; array_index++) {
541 Expression* element = values()->at(array_index);
542 MaterializedLiteral* literal = element->AsMaterializedLiteral();
543 if (literal != nullptr) {
544 int subliteral_depth = literal->InitDepthAndFlags() + 1;
545 if (subliteral_depth > depth_acc) depth_acc = subliteral_depth;
546 }
547
548 if (!element->IsCompileTimeValue()) {
549 is_simple = false;
550
551 // Don't change kind here: non-compile time values resolve to an unknown
552 // elements kind, so we allow them to be considered as any one of them.
553
554 // TODO(leszeks): It would be nice to DCHECK here that GetBoilerplateValue
555 // will return IsUninitialized, but that would require being on the main
556 // thread which we may not be.
557 } else {
558 Literal* literal = element->AsLiteral();
559
560 if (!literal) {
561 // Only arrays and objects are compile-time values but not (primitive)
562 // literals.
563 DCHECK(element->IsObjectLiteral() || element->IsArrayLiteral());
564 kind = PACKED_ELEMENTS;
565 } else {
566 switch (literal->type()) {
567 case Literal::kTheHole:
568 is_holey = true;
569 // The hole is allowed in holey double arrays (and holey Smi
570 // arrays), so ignore it as far as is_all_number is concerned.
571 break;
572 case Literal::kHeapNumber:
573 if (kind == PACKED_SMI_ELEMENTS) kind = PACKED_DOUBLE_ELEMENTS;
574 DCHECK_EQ(kind,
575 GetMoreGeneralElementsKind(kind, PACKED_DOUBLE_ELEMENTS));
576 break;
577 case Literal::kSmi:
578 DCHECK_EQ(kind,
579 GetMoreGeneralElementsKind(kind, PACKED_SMI_ELEMENTS));
580 break;
581 case Literal::kBigInt:
582 case Literal::kString:
583 case Literal::kSymbol:
584 case Literal::kBoolean:
585 case Literal::kUndefined:
586 case Literal::kNull:
587 kind = PACKED_ELEMENTS;
588 break;
589 }
590 }
591 }
592 }
593
594 if (is_holey) {
595 kind = GetHoleyElementsKind(kind);
596 }
597
598 set_depth(depth_acc);
599 set_is_simple(is_simple);
600 set_boilerplate_descriptor_kind(kind);
601
602 // Array literals always need an initial allocation site to properly track
603 // elements transitions.
604 set_needs_initial_allocation_site(true);
605 return depth_acc;
606 }
607
608 template <typename LocalIsolate>
BuildBoilerplateDescription(LocalIsolate * isolate)609 void ArrayLiteral::BuildBoilerplateDescription(LocalIsolate* isolate) {
610 if (!boilerplate_description_.is_null()) return;
611
612 int constants_length =
613 first_spread_index_ >= 0 ? first_spread_index_ : values()->length();
614 ElementsKind kind = boilerplate_descriptor_kind();
615 bool use_doubles = IsDoubleElementsKind(kind);
616
617 Handle<FixedArrayBase> elements;
618 if (use_doubles) {
619 elements = isolate->factory()->NewFixedDoubleArray(constants_length,
620 AllocationType::kOld);
621 } else {
622 elements = isolate->factory()->NewFixedArrayWithHoles(constants_length,
623 AllocationType::kOld);
624 }
625
626 // Fill in the literals.
627 int array_index = 0;
628 for (; array_index < constants_length; array_index++) {
629 Expression* element = values()->at(array_index);
630 DCHECK(!element->IsSpread());
631 if (use_doubles) {
632 Literal* literal = element->AsLiteral();
633
634 if (literal && literal->type() == Literal::kTheHole) {
635 DCHECK(IsHoleyElementsKind(kind));
636 DCHECK(GetBoilerplateValue(element, isolate)->IsTheHole(isolate));
637 FixedDoubleArray::cast(*elements).set_the_hole(array_index);
638 continue;
639 } else if (literal && literal->IsNumber()) {
640 FixedDoubleArray::cast(*elements).set(array_index, literal->AsNumber());
641 } else {
642 DCHECK(GetBoilerplateValue(element, isolate)->IsUninitialized(isolate));
643 FixedDoubleArray::cast(*elements).set(array_index, 0);
644 }
645
646 } else {
647 MaterializedLiteral* m_literal = element->AsMaterializedLiteral();
648 if (m_literal != nullptr) {
649 m_literal->BuildConstants(isolate);
650 }
651
652 // New handle scope here, needs to be after BuildContants().
653 typename LocalIsolate::HandleScopeType scope(isolate);
654
655 Object boilerplate_value = *GetBoilerplateValue(element, isolate);
656 // We shouldn't allocate after creating the boilerplate value.
657 DisallowHeapAllocation no_gc;
658
659 if (boilerplate_value.IsTheHole(isolate)) {
660 DCHECK(IsHoleyElementsKind(kind));
661 continue;
662 }
663
664 if (boilerplate_value.IsUninitialized(isolate)) {
665 boilerplate_value = Smi::zero();
666 }
667
668 DCHECK_EQ(
669 boilerplate_descriptor_kind(),
670 GetMoreGeneralElementsKind(boilerplate_descriptor_kind(),
671 boilerplate_value.OptimalElementsKind(
672 GetIsolateForPtrCompr(*elements))));
673
674 FixedArray::cast(*elements).set(array_index, boilerplate_value);
675 }
676 } // namespace internal
677
678 // Simple and shallow arrays can be lazily copied, we transform the
679 // elements array to a copy-on-write array.
680 if (is_simple() && depth() == 1 && array_index > 0 &&
681 IsSmiOrObjectElementsKind(kind)) {
682 elements->set_map(ReadOnlyRoots(isolate).fixed_cow_array_map());
683 }
684
685 boilerplate_description_ =
686 isolate->factory()->NewArrayBoilerplateDescription(kind, elements);
687 }
688 template EXPORT_TEMPLATE_DEFINE(
689 V8_BASE_EXPORT) void ArrayLiteral::BuildBoilerplateDescription(Isolate*
690 isolate);
691 template EXPORT_TEMPLATE_DEFINE(
692 V8_BASE_EXPORT) void ArrayLiteral::BuildBoilerplateDescription(LocalIsolate*
693 isolate);
694
IsFastCloningSupported() const695 bool ArrayLiteral::IsFastCloningSupported() const {
696 return depth() <= 1 &&
697 values_.length() <=
698 ConstructorBuiltins::kMaximumClonedShallowArrayElements;
699 }
700
IsSimple() const701 bool MaterializedLiteral::IsSimple() const {
702 if (IsArrayLiteral()) return AsArrayLiteral()->is_simple();
703 if (IsObjectLiteral()) return AsObjectLiteral()->is_simple();
704 DCHECK(IsRegExpLiteral());
705 return false;
706 }
707
708 template <typename LocalIsolate>
GetBoilerplateValue(Expression * expression,LocalIsolate * isolate)709 Handle<Object> MaterializedLiteral::GetBoilerplateValue(Expression* expression,
710 LocalIsolate* isolate) {
711 if (expression->IsLiteral()) {
712 return expression->AsLiteral()->BuildValue(isolate);
713 }
714 if (expression->IsCompileTimeValue()) {
715 if (expression->IsObjectLiteral()) {
716 ObjectLiteral* object_literal = expression->AsObjectLiteral();
717 DCHECK(object_literal->is_simple());
718 return object_literal->boilerplate_description();
719 } else {
720 DCHECK(expression->IsArrayLiteral());
721 ArrayLiteral* array_literal = expression->AsArrayLiteral();
722 DCHECK(array_literal->is_simple());
723 return array_literal->boilerplate_description();
724 }
725 }
726 return isolate->factory()->uninitialized_value();
727 }
728 template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
729 Handle<Object> MaterializedLiteral::GetBoilerplateValue(
730 Expression* expression, Isolate* isolate);
731 template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
732 Handle<Object> MaterializedLiteral::GetBoilerplateValue(
733 Expression* expression, LocalIsolate* isolate);
734
InitDepthAndFlags()735 int MaterializedLiteral::InitDepthAndFlags() {
736 if (IsArrayLiteral()) return AsArrayLiteral()->InitDepthAndFlags();
737 if (IsObjectLiteral()) return AsObjectLiteral()->InitDepthAndFlags();
738 DCHECK(IsRegExpLiteral());
739 return 1;
740 }
741
NeedsInitialAllocationSite()742 bool MaterializedLiteral::NeedsInitialAllocationSite() {
743 if (IsArrayLiteral()) {
744 return AsArrayLiteral()->needs_initial_allocation_site();
745 }
746 if (IsObjectLiteral()) {
747 return AsObjectLiteral()->needs_initial_allocation_site();
748 }
749 DCHECK(IsRegExpLiteral());
750 return false;
751 }
752
753 template <typename LocalIsolate>
BuildConstants(LocalIsolate * isolate)754 void MaterializedLiteral::BuildConstants(LocalIsolate* isolate) {
755 if (IsArrayLiteral()) {
756 AsArrayLiteral()->BuildBoilerplateDescription(isolate);
757 return;
758 }
759 if (IsObjectLiteral()) {
760 AsObjectLiteral()->BuildBoilerplateDescription(isolate);
761 return;
762 }
763 DCHECK(IsRegExpLiteral());
764 }
765 template EXPORT_TEMPLATE_DEFINE(
766 V8_BASE_EXPORT) void MaterializedLiteral::BuildConstants(Isolate* isolate);
767 template EXPORT_TEMPLATE_DEFINE(
768 V8_BASE_EXPORT) void MaterializedLiteral::BuildConstants(LocalIsolate*
769 isolate);
770
771 template <typename LocalIsolate>
GetOrBuildDescription(LocalIsolate * isolate)772 Handle<TemplateObjectDescription> GetTemplateObject::GetOrBuildDescription(
773 LocalIsolate* isolate) {
774 Handle<FixedArray> raw_strings = isolate->factory()->NewFixedArray(
775 this->raw_strings()->length(), AllocationType::kOld);
776 bool raw_and_cooked_match = true;
777 for (int i = 0; i < raw_strings->length(); ++i) {
778 if (this->raw_strings()->at(i) != this->cooked_strings()->at(i)) {
779 // If the AstRawStrings don't match, then neither should the allocated
780 // Strings, since the AstValueFactory should have deduplicated them
781 // already.
782 DCHECK_IMPLIES(this->cooked_strings()->at(i) != nullptr,
783 *this->cooked_strings()->at(i)->string() !=
784 *this->raw_strings()->at(i)->string());
785
786 raw_and_cooked_match = false;
787 }
788 raw_strings->set(i, *this->raw_strings()->at(i)->string());
789 }
790 Handle<FixedArray> cooked_strings = raw_strings;
791 if (!raw_and_cooked_match) {
792 cooked_strings = isolate->factory()->NewFixedArray(
793 this->cooked_strings()->length(), AllocationType::kOld);
794 for (int i = 0; i < cooked_strings->length(); ++i) {
795 if (this->cooked_strings()->at(i) != nullptr) {
796 cooked_strings->set(i, *this->cooked_strings()->at(i)->string());
797 } else {
798 cooked_strings->set(i, ReadOnlyRoots(isolate).undefined_value());
799 }
800 }
801 }
802 return isolate->factory()->NewTemplateObjectDescription(raw_strings,
803 cooked_strings);
804 }
805 template EXPORT_TEMPLATE_DEFINE(V8_BASE_EXPORT)
806 Handle<TemplateObjectDescription> GetTemplateObject::GetOrBuildDescription(
807 Isolate* isolate);
808 template EXPORT_TEMPLATE_DEFINE(V8_BASE_EXPORT)
809 Handle<TemplateObjectDescription> GetTemplateObject::GetOrBuildDescription(
810 LocalIsolate* isolate);
811
IsCommutativeOperationWithSmiLiteral(Token::Value op)812 static bool IsCommutativeOperationWithSmiLiteral(Token::Value op) {
813 // Add is not commutative due to potential for string addition.
814 return op == Token::MUL || op == Token::BIT_AND || op == Token::BIT_OR ||
815 op == Token::BIT_XOR;
816 }
817
818 // Check for the pattern: x + 1.
MatchSmiLiteralOperation(Expression * left,Expression * right,Expression ** expr,Smi * literal)819 static bool MatchSmiLiteralOperation(Expression* left, Expression* right,
820 Expression** expr, Smi* literal) {
821 if (right->IsSmiLiteral()) {
822 *expr = left;
823 *literal = right->AsLiteral()->AsSmiLiteral();
824 return true;
825 }
826 return false;
827 }
828
IsSmiLiteralOperation(Expression ** subexpr,Smi * literal)829 bool BinaryOperation::IsSmiLiteralOperation(Expression** subexpr,
830 Smi* literal) {
831 return MatchSmiLiteralOperation(left_, right_, subexpr, literal) ||
832 (IsCommutativeOperationWithSmiLiteral(op()) &&
833 MatchSmiLiteralOperation(right_, left_, subexpr, literal));
834 }
835
IsTypeof(Expression * expr)836 static bool IsTypeof(Expression* expr) {
837 UnaryOperation* maybe_unary = expr->AsUnaryOperation();
838 return maybe_unary != nullptr && maybe_unary->op() == Token::TYPEOF;
839 }
840
841 // Check for the pattern: typeof <expression> equals <string literal>.
MatchLiteralCompareTypeof(Expression * left,Token::Value op,Expression * right,Expression ** expr,Literal ** literal)842 static bool MatchLiteralCompareTypeof(Expression* left, Token::Value op,
843 Expression* right, Expression** expr,
844 Literal** literal) {
845 if (IsTypeof(left) && right->IsStringLiteral() && Token::IsEqualityOp(op)) {
846 *expr = left->AsUnaryOperation()->expression();
847 *literal = right->AsLiteral();
848 return true;
849 }
850 return false;
851 }
852
IsLiteralCompareTypeof(Expression ** expr,Literal ** literal)853 bool CompareOperation::IsLiteralCompareTypeof(Expression** expr,
854 Literal** literal) {
855 return MatchLiteralCompareTypeof(left_, op(), right_, expr, literal) ||
856 MatchLiteralCompareTypeof(right_, op(), left_, expr, literal);
857 }
858
IsVoidOfLiteral(Expression * expr)859 static bool IsVoidOfLiteral(Expression* expr) {
860 UnaryOperation* maybe_unary = expr->AsUnaryOperation();
861 return maybe_unary != nullptr && maybe_unary->op() == Token::VOID &&
862 maybe_unary->expression()->IsLiteral();
863 }
864
865 // Check for the pattern: void <literal> equals <expression> or
866 // undefined equals <expression>
MatchLiteralCompareUndefined(Expression * left,Token::Value op,Expression * right,Expression ** expr)867 static bool MatchLiteralCompareUndefined(Expression* left, Token::Value op,
868 Expression* right, Expression** expr) {
869 if (IsVoidOfLiteral(left) && Token::IsEqualityOp(op)) {
870 *expr = right;
871 return true;
872 }
873 if (left->IsUndefinedLiteral() && Token::IsEqualityOp(op)) {
874 *expr = right;
875 return true;
876 }
877 return false;
878 }
879
IsLiteralCompareUndefined(Expression ** expr)880 bool CompareOperation::IsLiteralCompareUndefined(Expression** expr) {
881 return MatchLiteralCompareUndefined(left_, op(), right_, expr) ||
882 MatchLiteralCompareUndefined(right_, op(), left_, expr);
883 }
884
885 // Check for the pattern: null equals <expression>
MatchLiteralCompareNull(Expression * left,Token::Value op,Expression * right,Expression ** expr)886 static bool MatchLiteralCompareNull(Expression* left, Token::Value op,
887 Expression* right, Expression** expr) {
888 if (left->IsNullLiteral() && Token::IsEqualityOp(op)) {
889 *expr = right;
890 return true;
891 }
892 return false;
893 }
894
IsLiteralCompareNull(Expression ** expr)895 bool CompareOperation::IsLiteralCompareNull(Expression** expr) {
896 return MatchLiteralCompareNull(left_, op(), right_, expr) ||
897 MatchLiteralCompareNull(right_, op(), left_, expr);
898 }
899
GetCallType() const900 Call::CallType Call::GetCallType() const {
901 VariableProxy* proxy = expression()->AsVariableProxy();
902 if (proxy != nullptr) {
903 if (proxy->var()->IsUnallocated()) {
904 return GLOBAL_CALL;
905 } else if (proxy->var()->IsLookupSlot()) {
906 // Calls going through 'with' always use VariableMode::kDynamic rather
907 // than VariableMode::kDynamicLocal or VariableMode::kDynamicGlobal.
908 return proxy->var()->mode() == VariableMode::kDynamic ? WITH_CALL
909 : OTHER_CALL;
910 }
911 }
912
913 if (expression()->IsSuperCallReference()) return SUPER_CALL;
914
915 Property* property = expression()->AsProperty();
916 bool is_optional_chain = false;
917 if (V8_UNLIKELY(property == nullptr && expression()->IsOptionalChain())) {
918 is_optional_chain = true;
919 property = expression()->AsOptionalChain()->expression()->AsProperty();
920 }
921 if (property != nullptr) {
922 if (property->IsPrivateReference()) {
923 if (is_optional_chain) return PRIVATE_OPTIONAL_CHAIN_CALL;
924 return PRIVATE_CALL;
925 }
926 bool is_super = property->IsSuperAccess();
927 // `super?.` is not syntactically valid, so a property load cannot be both
928 // super and an optional chain.
929 DCHECK(!is_super || !is_optional_chain);
930 if (property->key()->IsPropertyName()) {
931 if (is_super) return NAMED_SUPER_PROPERTY_CALL;
932 if (is_optional_chain) return NAMED_OPTIONAL_CHAIN_PROPERTY_CALL;
933 return NAMED_PROPERTY_CALL;
934 } else {
935 if (is_super) return KEYED_SUPER_PROPERTY_CALL;
936 if (is_optional_chain) return KEYED_OPTIONAL_CHAIN_PROPERTY_CALL;
937 return KEYED_PROPERTY_CALL;
938 }
939 }
940
941 return OTHER_CALL;
942 }
943
CaseClause(Zone * zone,Expression * label,const ScopedPtrList<Statement> & statements)944 CaseClause::CaseClause(Zone* zone, Expression* label,
945 const ScopedPtrList<Statement>& statements)
946 : label_(label), statements_(statements.ToConstVector(), zone) {}
947
IsPropertyName() const948 bool Literal::IsPropertyName() const {
949 if (type() != kString) return false;
950 uint32_t index;
951 return !string_->AsArrayIndex(&index);
952 }
953
ToUint32(uint32_t * value) const954 bool Literal::ToUint32(uint32_t* value) const {
955 switch (type()) {
956 case kString:
957 return string_->AsArrayIndex(value);
958 case kSmi:
959 if (smi_ < 0) return false;
960 *value = static_cast<uint32_t>(smi_);
961 return true;
962 case kHeapNumber:
963 return DoubleToUint32IfEqualToSelf(AsNumber(), value);
964 default:
965 return false;
966 }
967 }
968
AsArrayIndex(uint32_t * value) const969 bool Literal::AsArrayIndex(uint32_t* value) const {
970 return ToUint32(value) && *value != kMaxUInt32;
971 }
972
973 template <typename LocalIsolate>
BuildValue(LocalIsolate * isolate) const974 Handle<Object> Literal::BuildValue(LocalIsolate* isolate) const {
975 switch (type()) {
976 case kSmi:
977 return handle(Smi::FromInt(smi_), isolate);
978 case kHeapNumber:
979 return isolate->factory()->template NewNumber<AllocationType::kOld>(
980 number_);
981 case kString:
982 return string_->string();
983 case kSymbol:
984 return isolate->factory()->home_object_symbol();
985 case kBoolean:
986 return isolate->factory()->ToBoolean(boolean_);
987 case kNull:
988 return isolate->factory()->null_value();
989 case kUndefined:
990 return isolate->factory()->undefined_value();
991 case kTheHole:
992 return isolate->factory()->the_hole_value();
993 case kBigInt:
994 // This should never fail: the parser will never create a BigInt
995 // literal that cannot be allocated.
996 return BigIntLiteral(isolate, bigint_.c_str()).ToHandleChecked();
997 }
998 UNREACHABLE();
999 }
1000 template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
1001 Handle<Object> Literal::BuildValue(Isolate* isolate) const;
1002 template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
1003 Handle<Object> Literal::BuildValue(LocalIsolate* isolate) const;
1004
ToBooleanIsTrue() const1005 bool Literal::ToBooleanIsTrue() const {
1006 switch (type()) {
1007 case kSmi:
1008 return smi_ != 0;
1009 case kHeapNumber:
1010 return DoubleToBoolean(number_);
1011 case kString:
1012 return !string_->IsEmpty();
1013 case kNull:
1014 case kUndefined:
1015 return false;
1016 case kBoolean:
1017 return boolean_;
1018 case kBigInt: {
1019 const char* bigint_str = bigint_.c_str();
1020 size_t length = strlen(bigint_str);
1021 DCHECK_GT(length, 0);
1022 if (length == 1 && bigint_str[0] == '0') return false;
1023 // Skip over any radix prefix; BigInts with length > 1 only
1024 // begin with zero if they include a radix.
1025 for (size_t i = (bigint_str[0] == '0') ? 2 : 0; i < length; ++i) {
1026 if (bigint_str[i] != '0') return true;
1027 }
1028 return false;
1029 }
1030 case kSymbol:
1031 return true;
1032 case kTheHole:
1033 UNREACHABLE();
1034 }
1035 UNREACHABLE();
1036 }
1037
Hash()1038 uint32_t Literal::Hash() {
1039 return IsString() ? AsRawString()->Hash()
1040 : ComputeLongHash(double_to_uint64(AsNumber()));
1041 }
1042
1043 // static
Match(void * a,void * b)1044 bool Literal::Match(void* a, void* b) {
1045 Literal* x = static_cast<Literal*>(a);
1046 Literal* y = static_cast<Literal*>(b);
1047 return (x->IsString() && y->IsString() &&
1048 x->AsRawString() == y->AsRawString()) ||
1049 (x->IsNumber() && y->IsNumber() && x->AsNumber() == y->AsNumber());
1050 }
1051
NewNumberLiteral(double number,int pos)1052 Literal* AstNodeFactory::NewNumberLiteral(double number, int pos) {
1053 int int_value;
1054 if (DoubleToSmiInteger(number, &int_value)) {
1055 return NewSmiLiteral(int_value, pos);
1056 }
1057 return zone_->New<Literal>(number, pos);
1058 }
1059
debug_name()1060 const char* CallRuntime::debug_name() {
1061 #ifdef DEBUG
1062 return is_jsruntime() ? NameForNativeContextIntrinsicIndex(context_index_)
1063 : function_->name;
1064 #else
1065 return is_jsruntime() ? "(context function)" : function_->name;
1066 #endif // DEBUG
1067 }
1068
1069 } // namespace internal
1070 } // namespace v8
1071