1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <codecvt>
17 #include <iomanip>
18 #include <iostream>
19 #include <string>
20
21 #include "ecmascript/dfx/hprof/heap_snapshot.h"
22 #include "ecmascript/global_dictionary-inl.h"
23 #include "ecmascript/vtable.h"
24 #include "ecmascript/linked_hash_table.h"
25 #include "ecmascript/tagged_tree.h"
26 #include "ecmascript/mem/object_xray.h"
27 #ifdef ARK_SUPPORT_INTL
28 #include "ecmascript/js_bigint.h"
29 #include "ecmascript/js_collator.h"
30 #include "ecmascript/js_date_time_format.h"
31 #include "ecmascript/js_intl.h"
32 #include "ecmascript/js_locale.h"
33 #include "ecmascript/js_relative_time_format.h"
34 #include "ecmascript/js_segmenter.h"
35 #include "ecmascript/js_segments.h"
36 #include "ecmascript/js_segment_iterator.h"
37 #endif
38
39 namespace panda::ecmascript {
40 using MicroJobQueue = panda::ecmascript::job::MicroJobQueue;
41 using PendingJob = panda::ecmascript::job::PendingJob;
42 using ExtraProfileTypeInfo = panda::ecmascript::pgo::ExtraProfileTypeInfo;
43
44 static constexpr uint32_t DUMP_TYPE_OFFSET = 12;
45 static constexpr uint32_t DUMP_PROPERTY_OFFSET = 20;
46 static constexpr uint32_t DUMP_ELEMENT_OFFSET = 2;
47
HasEdge(std::vector<Reference> &vec, JSTaggedValue toValue)48 static bool HasEdge(std::vector<Reference> &vec, JSTaggedValue toValue)
49 {
50 for (auto &ref : vec) {
51 if (ref.value_ == toValue) {
52 return true;
53 }
54 }
55 return false;
56 }
57
AddAnonymousEdge(TaggedObject *obj, std::vector<Reference> &vec)58 static void AddAnonymousEdge(TaggedObject *obj, std::vector<Reference> &vec)
59 {
60 auto hclass = obj->GetClass();
61 if (hclass == nullptr) {
62 return;
63 }
64 ObjectXRay::VisitObjectBody<VisitType::SNAPSHOT_VISIT>(obj, hclass,
65 [&vec]([[maybe_unused]]TaggedObject *root, ObjectSlot start, ObjectSlot end, VisitObjectArea area) {
66 if (area != VisitObjectArea::NORMAL) {
67 return;
68 }
69 uint32_t cnt = 0;
70 for (auto slot = start; slot != end; slot++) {
71 JSTaggedValue toValue = JSTaggedValue(slot.GetTaggedType());
72 if (!toValue.IsHeapObject()) {
73 continue;
74 }
75 if (HasEdge(vec, toValue)) {
76 continue;
77 }
78 std::string name = "anonymous-slot" + std::to_string(cnt);
79 cnt += 1;
80 vec.emplace_back(ConvertToString(name), toValue);
81 }
82 }
83 );
84 }
85
DumpJSType(JSType type)86 CString JSHClass::DumpJSType(JSType type)
87 {
88 switch (type) {
89 case JSType::HCLASS:
90 return "JSHClass";
91 case JSType::TAGGED_ARRAY:
92 return "TaggedArray";
93 case JSType::LEXICAL_ENV:
94 return "LexicalEnv";
95 case JSType::SENDABLE_ENV:
96 return "SendableEnv";
97 case JSType::TAGGED_DICTIONARY:
98 return "TaggedDictionary";
99 case JSType::CONSTANT_POOL:
100 return "ConstantPool";
101 case JSType::PROFILE_TYPE_INFO:
102 return "ProfileTypeInfo";
103 case JSType::COW_TAGGED_ARRAY:
104 return "COWArray";
105 case JSType::MUTANT_TAGGED_ARRAY:
106 return "MutantTaggedArray";
107 case JSType::COW_MUTANT_TAGGED_ARRAY:
108 return "COWMutantTaggedArray";
109 case JSType::LINE_STRING:
110 case JSType::CONSTANT_STRING:
111 case JSType::TREE_STRING:
112 case JSType::SLICED_STRING:
113 return "BaseString";
114 case JSType::JS_NATIVE_POINTER:
115 return "NativePointer";
116 case JSType::JS_OBJECT:
117 return "Object";
118 case JSType::JS_SHARED_OBJECT:
119 return "SharedObject";
120 case JSType::JS_FUNCTION_BASE:
121 return "Function Base";
122 case JSType::JS_FUNCTION:
123 return "Function";
124 case JSType::JS_SHARED_FUNCTION:
125 return "Shared Function";
126 case JSType::JS_ERROR:
127 return "Error";
128 case JSType::NATIVE_MODULE_FAILURE_INFO:
129 return "NativeModuleFailureInfo";
130 case JSType::JS_EVAL_ERROR:
131 return "Eval Error";
132 case JSType::JS_RANGE_ERROR:
133 return "Range Error";
134 case JSType::JS_TYPE_ERROR:
135 return "Type Error";
136 case JSType::JS_AGGREGATE_ERROR:
137 return "Aggregate Error";
138 case JSType::JS_REFERENCE_ERROR:
139 return "Reference Error";
140 case JSType::JS_URI_ERROR:
141 return "Uri Error";
142 case JSType::JS_SYNTAX_ERROR:
143 return "Syntax Error";
144 case JSType::JS_OOM_ERROR:
145 return "OutOfMemory Error";
146 case JSType::JS_TERMINATION_ERROR:
147 return "Termination Error";
148 case JSType::JS_REG_EXP:
149 return "Regexp";
150 case JSType::JS_SET:
151 return "Set";
152 case JSType::JS_SHARED_SET:
153 return "SharedSet";
154 case JSType::JS_MAP:
155 return "Map";
156 case JSType::JS_SHARED_MAP:
157 return "SharedMap";
158 case JSType::JS_WEAK_SET:
159 return "WeakSet";
160 case JSType::JS_WEAK_MAP:
161 return "WeakMap";
162 case JSType::JS_WEAK_REF:
163 return "WeakRef";
164 case JSType::JS_FINALIZATION_REGISTRY:
165 return "JSFinalizationRegistry";
166 case JSType::CELL_RECORD:
167 return "CellRecord";
168 case JSType::JS_DATE:
169 return "Date";
170 case JSType::JS_BOUND_FUNCTION:
171 return "Bound Function";
172 case JSType::JS_ARRAY:
173 return "Array";
174 case JSType::JS_SHARED_ARRAY:
175 return "SharedArray";
176 case JSType::JS_SHARED_ARRAY_ITERATOR:
177 return "SharedArrayIterator";
178 case JSType::JS_TYPED_ARRAY:
179 return "Typed Array";
180 case JSType::JS_INT8_ARRAY:
181 return "Int8 Array";
182 case JSType::JS_UINT8_ARRAY:
183 return "Uint8 Array";
184 case JSType::JS_UINT8_CLAMPED_ARRAY:
185 return "Uint8 Clamped Array";
186 case JSType::JS_INT16_ARRAY:
187 return "Int16 Array";
188 case JSType::JS_UINT16_ARRAY:
189 return "Uint16 Array";
190 case JSType::JS_INT32_ARRAY:
191 return "Int32 Array";
192 case JSType::JS_UINT32_ARRAY:
193 return "Uint32 Array";
194 case JSType::BIGINT:
195 return "BigInt";
196 case JSType::JS_FLOAT32_ARRAY:
197 return "Float32 Array";
198 case JSType::JS_FLOAT64_ARRAY:
199 return "Float64 Array";
200 case JSType::JS_BIGINT64_ARRAY:
201 return "BigInt64 Array";
202 case JSType::JS_BIGUINT64_ARRAY:
203 return "BigUint64 Array";
204 case JSType::JS_SHARED_TYPED_ARRAY:
205 return "Shared Typed Array";
206 case JSType::JS_SHARED_INT8_ARRAY:
207 return "Shared Int8 Array";
208 case JSType::JS_SHARED_UINT8_ARRAY:
209 return "Shared Uint8 Array";
210 case JSType::JS_SHARED_UINT8_CLAMPED_ARRAY:
211 return "Shared Uint8 Clamped Array";
212 case JSType::JS_SHARED_INT16_ARRAY:
213 return "Shared Int16 Array";
214 case JSType::JS_SHARED_UINT16_ARRAY:
215 return "Shared Uint16 Array";
216 case JSType::JS_SHARED_INT32_ARRAY:
217 return "Shared Int32 Array";
218 case JSType::JS_SHARED_UINT32_ARRAY:
219 return "Shared Uint32 Array";
220 case JSType::JS_SHARED_FLOAT32_ARRAY:
221 return "Shared Float32 Array";
222 case JSType::JS_SHARED_FLOAT64_ARRAY:
223 return "Shared Float64 Array";
224 case JSType::JS_SHARED_BIGINT64_ARRAY:
225 return "Shared BigInt64 Array";
226 case JSType::JS_SHARED_BIGUINT64_ARRAY:
227 return "Shared BigUint64 Array";
228 case JSType::BYTE_ARRAY:
229 return "ByteArray";
230 case JSType::JS_ARGUMENTS:
231 return "Arguments";
232 case JSType::JS_PROXY:
233 return "Proxy";
234 case JSType::JS_PRIMITIVE_REF:
235 return "Primitive";
236 case JSType::JS_DATA_VIEW:
237 return "DataView";
238 case JSType::JS_ITERATOR:
239 return "Iterator";
240 case JSType::JS_ASYNCITERATOR:
241 return "AsyncIterator";
242 case JSType::JS_FORIN_ITERATOR:
243 return "ForinInterator";
244 case JSType::JS_MAP_ITERATOR:
245 return "MapIterator";
246 case JSType::JS_SHARED_MAP_ITERATOR:
247 return "SharedMapIterator";
248 case JSType::JS_SET_ITERATOR:
249 return "SetIterator";
250 case JSType::JS_SHARED_SET_ITERATOR:
251 return "SharedSetIterator";
252 case JSType::JS_ARRAY_ITERATOR:
253 return "ArrayIterator";
254 case JSType::JS_STRING_ITERATOR:
255 return "StringIterator";
256 case JSType::JS_REG_EXP_ITERATOR:
257 return "RegExpIterator";
258 case JSType::JS_ARRAY_BUFFER:
259 return "ArrayBuffer";
260 case JSType::JS_SENDABLE_ARRAY_BUFFER:
261 return "SendableArrayBuffer";
262 case JSType::JS_SHARED_ARRAY_BUFFER:
263 return "SharedArrayBuffer";
264 case JSType::JS_PROXY_REVOC_FUNCTION:
265 return "ProxyRevocFunction";
266 case JSType::PROMISE_REACTIONS:
267 return "PromiseReaction";
268 case JSType::PROMISE_CAPABILITY:
269 return "PromiseCapability";
270 case JSType::PROMISE_ITERATOR_RECORD:
271 return "PromiseIteratorRecord";
272 case JSType::PROMISE_RECORD:
273 return "PromiseRecord";
274 case JSType::RESOLVING_FUNCTIONS_RECORD:
275 return "ResolvingFunctionsRecord";
276 case JSType::ASYNC_GENERATOR_REQUEST:
277 return "AsyncGeneratorRequest";
278 case JSType::ASYNC_ITERATOR_RECORD:
279 return "AsyncIteratorRecord";
280 case JSType::JS_ASYNC_FROM_SYNC_ITERATOR:
281 return "AsyncFromSyncIterator";
282 case JSType::JS_ASYNC_FROM_SYNC_ITER_UNWARP_FUNCTION:
283 return "AsyncFromSyncIterUnwarpFunction";
284 case JSType::JS_PROMISE:
285 return "Promise";
286 case JSType::JS_PROMISE_REACTIONS_FUNCTION:
287 return "PromiseReactionsFunction";
288 case JSType::JS_PROMISE_EXECUTOR_FUNCTION:
289 return "PromiseExecutorFunction";
290 case JSType::JS_ASYNC_MODULE_FULFILLED_FUNCTION:
291 return "AsyncModuleFulfilledFunction";
292 case JSType::JS_ASYNC_MODULE_REJECTED_FUNCTION:
293 return "AsyncModuleRejectedFunction";
294 case JSType::JS_PROMISE_ALL_RESOLVE_ELEMENT_FUNCTION:
295 return "PromiseAllResolveElementFunction";
296 case JSType::JS_PROMISE_ANY_REJECT_ELEMENT_FUNCTION:
297 return "PromiseAnyRejectElementFunction";
298 case JSType::JS_PROMISE_ALL_SETTLED_ELEMENT_FUNCTION:
299 return "PromiseAllSettledElementFunction";
300 case JSType::JS_PROMISE_FINALLY_FUNCTION:
301 return "PromiseFinallyFunction";
302 case JSType::JS_PROMISE_VALUE_THUNK_OR_THROWER_FUNCTION:
303 return "PromiseValueThunkOrThrowerFunction";
304 case JSType::JS_ASYNC_GENERATOR_RESUME_NEXT_RETURN_PROCESSOR_RST_FTN:
305 return "AsyncGeneratorResumeNextReturnProcessorRstFtn";
306 case JSType::MICRO_JOB_QUEUE:
307 return "MicroJobQueue";
308 case JSType::PENDING_JOB:
309 return "PendingJob";
310 case JSType::COMPLETION_RECORD:
311 return "CompletionRecord";
312 case JSType::GLOBAL_ENV:
313 return "GlobalEnv";
314 case JSType::ACCESSOR_DATA:
315 return "AccessorData";
316 case JSType::INTERNAL_ACCESSOR:
317 return "InternalAccessor";
318 case JSType::SYMBOL:
319 return "Symbol";
320 case JSType::PROPERTY_BOX:
321 return "PropertyBox";
322 case JSType::JS_ASYNC_FUNCTION:
323 return "AsyncFunction";
324 case JSType::JS_SHARED_ASYNC_FUNCTION:
325 return "SharedAsyncFunction";
326 case JSType::JS_ASYNC_AWAIT_STATUS_FUNCTION:
327 return "AsyncAwaitStatusFunction";
328 case JSType::JS_ASYNC_FUNC_OBJECT:
329 return "AsyncFunctionObject";
330 case JSType::JS_REALM:
331 return "Realm";
332 case JSType::JS_GLOBAL_OBJECT:
333 return "GlobalObject";
334 case JSType::JS_INTL:
335 return "JSIntl";
336 case JSType::JS_LOCALE:
337 return "JSLocale";
338 case JSType::JS_DATE_TIME_FORMAT:
339 return "JSDateTimeFormat";
340 case JSType::JS_RELATIVE_TIME_FORMAT:
341 return "JSRelativeTimeFormat";
342 case JSType::JS_NUMBER_FORMAT:
343 return "JSNumberFormat";
344 case JSType::JS_COLLATOR:
345 return "JSCollator";
346 case JSType::JS_PLURAL_RULES:
347 return "JSPluralRules";
348 case JSType::JS_DISPLAYNAMES:
349 return "JSDisplayNames";
350 case JSType::JS_SEGMENTER:
351 return "JSSegmenter";
352 case JSType::JS_SEGMENTS:
353 return "JSSegments";
354 case JSType::JS_SEGMENT_ITERATOR:
355 return "JSSegmentIterator";
356 case JSType::JS_LIST_FORMAT:
357 return "JSListFormat";
358 case JSType::JS_GENERATOR_OBJECT:
359 return "JSGeneratorObject";
360 case JSType::JS_ASYNC_GENERATOR_OBJECT:
361 return "JSAsyncGeneratorObject";
362 case JSType::JS_GENERATOR_CONTEXT:
363 return "JSGeneratorContext";
364 case JSType::PROTO_CHANGE_MARKER:
365 return "ProtoChangeMarker";
366 case JSType::MARKER_CELL:
367 return "MarkerCell";
368 case JSType::PROTOTYPE_INFO:
369 return "PrototypeInfo";
370 case JSType::PROGRAM:
371 return "program";
372 case JSType::MACHINE_CODE_OBJECT:
373 return "MachineCode";
374 case JSType::CLASS_INFO_EXTRACTOR:
375 return "ClassInfoExtractor";
376 case JSType::JS_API_ARRAY_LIST:
377 return "ArrayList";
378 case JSType::JS_API_ARRAYLIST_ITERATOR:
379 return "JSArraylistIterator";
380 case JSType::LINKED_NODE:
381 return "LinkedNode";
382 case JSType::RB_TREENODE:
383 return "RBTreeNode";
384 case JSType::JS_API_HASH_MAP:
385 return "HashMap";
386 case JSType::JS_API_HASH_SET:
387 return "HashSet";
388 case JSType::JS_API_HASHMAP_ITERATOR:
389 return "HashMapIterator";
390 case JSType::JS_API_HASHSET_ITERATOR:
391 return "HashSetIterator";
392 case JSType::JS_API_LIGHT_WEIGHT_MAP:
393 return "LightWeightMap";
394 case JSType::JS_API_LIGHT_WEIGHT_MAP_ITERATOR:
395 return "LightWeightMapIterator";
396 case JSType::JS_API_LIGHT_WEIGHT_SET:
397 return "LightWeightSet";
398 case JSType::JS_API_LIGHT_WEIGHT_SET_ITERATOR:
399 return "LightWeightSetIterator";
400 case JSType::JS_API_TREE_MAP:
401 return "TreeMap";
402 case JSType::JS_API_TREE_SET:
403 return "TreeSet";
404 case JSType::JS_API_TREEMAP_ITERATOR:
405 return "TreeMapIterator";
406 case JSType::JS_API_TREESET_ITERATOR:
407 return "TreeSetIterator";
408 case JSType::JS_API_VECTOR:
409 return "Vector";
410 case JSType::JS_API_VECTOR_ITERATOR:
411 return "VectorIterator";
412 case JSType::JS_API_BITVECTOR:
413 return "BitVector";
414 case JSType::JS_API_BITVECTOR_ITERATOR:
415 return "BitVectorIterator";
416 case JSType::JS_API_QUEUE:
417 return "Queue";
418 case JSType::JS_API_QUEUE_ITERATOR:
419 return "QueueIterator";
420 case JSType::JS_API_PLAIN_ARRAY:
421 return "PlainArray";
422 case JSType::JS_API_PLAIN_ARRAY_ITERATOR:
423 return "PlainArrayIterator";
424 case JSType::JS_API_DEQUE:
425 return "Deque";
426 case JSType::JS_API_DEQUE_ITERATOR:
427 return "DequeIterator";
428 case JSType::JS_API_STACK:
429 return "Stack";
430 case JSType::JS_API_STACK_ITERATOR:
431 return "StackIterator";
432 case JSType::JS_API_LIST:
433 return "List";
434 case JSType::JS_API_LIST_ITERATOR:
435 return "ListIterator";
436 case JSType::JS_API_LINKED_LIST:
437 return "LinkedList";
438 case JSType::JS_API_LINKED_LIST_ITERATOR:
439 return "LinkedListIterator";
440 case JSType::JS_CJS_EXPORTS:
441 return "CommonJSExports";
442 case JSType::JS_CJS_MODULE:
443 return "CommonJSModule";
444 case JSType::JS_CJS_REQUIRE:
445 return "CommonJSRequire";
446 case JSType::METHOD:
447 return "Method";
448 case JSType::AOT_LITERAL_INFO:
449 return "AOTLiteralInfo";
450 case JSType::CLASS_LITERAL:
451 return "ClassLiteral";
452 case JSType::PROFILE_TYPE_INFO_CELL_0:
453 case JSType::PROFILE_TYPE_INFO_CELL_1:
454 case JSType::PROFILE_TYPE_INFO_CELL_N:
455 return "ProfileTypeInfoCell";
456 case JSType::FUNCTION_TEMPLATE:
457 return "FunctionTemplate";
458 case JSType::VTABLE:
459 return "VTable";
460 case JSType::EXTRA_PROFILE_TYPE_INFO:
461 return "ExtraProfileTypeInfo";
462 case JSType::SOURCE_TEXT_MODULE_RECORD:
463 return "SourceTextModuleRecord";
464 case JSType::RESOLVEDBINDING_RECORD:
465 return "ResolvedBindingRecord";
466 case JSType::RESOLVEDINDEXBINDING_RECORD:
467 return "ResolvedIndexBindingRecord";
468 case JSType::RESOLVEDRECORDINDEXBINDING_RECORD:
469 return "ResolvedRecordIndexBindingRecord";
470 case JSType::RESOLVEDRECORDBINDING_RECORD:
471 return "ResolvedRecordBindingRecord";
472 case JSType::IMPORTENTRY_RECORD:
473 return "ImportEntry";
474 case JSType::LOCAL_EXPORTENTRY_RECORD:
475 return "LocalExportEntry";
476 case JSType::STAR_EXPORTENTRY_RECORD:
477 return "StarExportEntry";
478 default: {
479 CString ret = "unknown type ";
480 return ret.append(std::to_string(static_cast<char>(type)));
481 }
482 }
483 }
484
DumpArrayClass(const TaggedArray *arr, std::ostream &os)485 static void DumpArrayClass(const TaggedArray *arr, std::ostream &os)
486 {
487 DISALLOW_GARBAGE_COLLECTION;
488 uint32_t len = arr->GetLength();
489 os << " <TaggedArray[" << std::dec << len << "]>\n";
490 for (uint32_t i = 0; i < len; i++) {
491 JSTaggedValue val(arr->Get(i));
492 if (!val.IsHole()) {
493 os << std::right << std::setw(DUMP_PROPERTY_OFFSET) << i << ": ";
494 val.DumpTaggedValue(os);
495 os << "\n";
496 }
497 }
498 }
499
DumpMutantTaggedArray(const MutantTaggedArray *arr, std::ostream &os)500 static void DumpMutantTaggedArray(const MutantTaggedArray *arr, std::ostream &os)
501 {
502 DISALLOW_GARBAGE_COLLECTION;
503 uint32_t len = arr->GetLength();
504 os << " <MutantTaggedArray[" << std::dec << len << "]>\n";
505 for (uint32_t i = 0; i < len; i++) {
506 JSTaggedValue val(arr->Get(i));
507 os << std::right << std::setw(DUMP_PROPERTY_OFFSET) << i << ": ";
508 os << std::left << std::setw(DUMP_TYPE_OFFSET) << "[JSTaggedType] : " << val.GetRawData();
509 os << "\n";
510 }
511 }
512
DumpCOWMutantTaggedArray(const COWMutantTaggedArray *arr, std::ostream &os)513 static void DumpCOWMutantTaggedArray(const COWMutantTaggedArray *arr, std::ostream &os)
514 {
515 DISALLOW_GARBAGE_COLLECTION;
516 uint32_t len = arr->GetLength();
517 os << " <COWMutantTaggedArray[" << std::dec << len << "]>\n";
518 for (uint32_t i = 0; i < len; i++) {
519 JSTaggedValue val(arr->Get(i));
520 os << std::right << std::setw(DUMP_PROPERTY_OFFSET) << i << ": ";
521 os << std::left << std::setw(DUMP_TYPE_OFFSET) << "[JSTaggedType] : " << val.GetRawData();
522 os << "\n";
523 }
524 }
525
DumpConstantPoolClass(const ConstantPool *pool, std::ostream &os)526 static void DumpConstantPoolClass(const ConstantPool *pool, std::ostream &os)
527 {
528 DISALLOW_GARBAGE_COLLECTION;
529 uint32_t len = pool->GetCacheLength();
530 os << " <ConstantPool[" << std::dec << len << "]>\n";
531 for (uint32_t i = 0; i < len; i++) {
532 JSTaggedValue val(pool->GetObjectFromCache(i));
533 if (!val.IsHole()) {
534 os << std::right << std::setw(DUMP_PROPERTY_OFFSET) << i << ": ";
535 val.DumpTaggedValue(os);
536 os << "\n";
537 }
538 }
539 }
540
DumpStringClass(const EcmaString *str, std::ostream &os)541 static void DumpStringClass(const EcmaString *str, std::ostream &os)
542 {
543 DISALLOW_GARBAGE_COLLECTION;
544 CString string = ConvertToString(str);
545 os << string;
546 }
547
DumpPropertyKey(JSTaggedValue key, std::ostream &os)548 static void DumpPropertyKey(JSTaggedValue key, std::ostream &os)
549 {
550 if (key.IsString()) {
551 DumpStringClass(EcmaString::Cast(key.GetTaggedObject()), os);
552 } else if (key.IsSymbol()) {
553 JSSymbol *sym = JSSymbol::Cast(key.GetTaggedObject());
554 if (sym->GetDescription().IsString()) {
555 os << "Symbol(\"";
556 DumpStringClass(EcmaString::Cast(sym->GetDescription().GetTaggedObject()), os);
557 os << "\")";
558 } else {
559 os << "Symbol(" << sym << ")";
560 }
561 } else {
562 LOG_ECMA(FATAL) << "this branch is unreachable";
563 UNREACHABLE();
564 }
565 }
566
DumpAttr(const PropertyAttributes &attr, bool fastMode, std::ostream &os)567 static void DumpAttr(const PropertyAttributes &attr, bool fastMode, std::ostream &os)
568 {
569 if (attr.IsAccessor()) {
570 os << "(Accessor) ";
571 }
572
573 os << "Attr(";
574 os << "[Raw: " << std::hex << attr.GetValue() << "] ";
575 if (attr.IsNoneAttributes()) {
576 os << "NONE";
577 }
578 if (attr.IsWritable()) {
579 os << "W";
580 }
581 if (attr.IsEnumerable()) {
582 os << "E";
583 }
584 if (attr.IsConfigurable()) {
585 os << "C";
586 }
587
588 os << ")";
589
590 os << " Rep: " << static_cast<int>(attr.GetRepresentation());
591
592 os << " InlinedProps: " << attr.IsInlinedProps();
593
594 if (fastMode) {
595 os << " Order: " << std::dec << attr.GetOffset();
596 os << " SortedIndex: " << std::dec << attr.GetSortedIndex();
597 } else {
598 os << " Order: " << std::dec << attr.GetDictionaryOrder();
599 }
600 }
601
DumpHClass(const JSHClass *jshclass, std::ostream &os, bool withDetail)602 static void DumpHClass(const JSHClass *jshclass, std::ostream &os, bool withDetail)
603 {
604 DISALLOW_GARBAGE_COLLECTION;
605 os << "JSHClass :" << std::setw(DUMP_TYPE_OFFSET);
606 os << "Type :" << JSHClass::DumpJSType(jshclass->GetObjectType()) << "\n";
607
608 os << " - Prototype :" << std::setw(DUMP_TYPE_OFFSET);
609 jshclass->GetPrototype().DumpTaggedValue(os);
610 os << "\n";
611 os << " - PropertyDescriptors :" << std::setw(DUMP_TYPE_OFFSET);
612 JSTaggedValue attrs = jshclass->GetLayout();
613 attrs.DumpTaggedValue(os);
614 os << "\n";
615 if (withDetail && !attrs.IsNull()) {
616 LayoutInfo *layout = LayoutInfo::Cast(jshclass->GetLayout().GetTaggedObject());
617 int element = static_cast<int>(jshclass->NumberOfProps());
618 for (int i = 0; i < element; i++) {
619 JSTaggedValue key = layout->GetKey(i);
620 PropertyAttributes attr = layout->GetAttr(i);
621 os << std::right << std::setw(DUMP_PROPERTY_OFFSET);
622 os << "[" << i << "]: ";
623 DumpPropertyKey(key, os);
624 os << " : ";
625 DumpAttr(attr, true, os);
626 os << "\n";
627 }
628 }
629
630 os << " - Transitions :" << std::setw(DUMP_TYPE_OFFSET);
631 JSTaggedValue transtions = jshclass->GetTransitions();
632 transtions.DumpTaggedValue(os);
633 os << "\n";
634 if (withDetail && !transtions.IsWeakForHeapObject() && transtions.IsDictionary()) {
635 transtions.Dump(os);
636 }
637
638 os << " - ProtoChangeMarker :" << std::setw(DUMP_TYPE_OFFSET);
639 JSTaggedValue marker = jshclass->GetProtoChangeMarker();
640 marker.DumpTaggedValue(os);
641 if (marker.IsHeapObject()) {
642 ProtoChangeMarker::Cast(marker.GetTaggedObject())->Dump(os);
643 } else {
644 os << "\n";
645 }
646
647 os << " - ProtoChangeDetails :" << std::setw(DUMP_TYPE_OFFSET);
648 JSTaggedValue details = jshclass->GetProtoChangeDetails();
649 details.DumpTaggedValue(os);
650 if (details.IsHeapObject()) {
651 ProtoChangeDetails::Cast(details.GetTaggedObject())->Dump(os);
652 } else {
653 os << "\n";
654 }
655
656 os << " - ProfileType : " << std::hex << jshclass->GetProfileType() << "\n";
657
658 os << " - Flags : " << std::setw(DUMP_TYPE_OFFSET);
659 os << "IsCtor :" << std::boolalpha << jshclass->IsConstructor();
660 os << "| IsCallable :" << std::boolalpha << jshclass->IsCallable();
661 os << "| IsExtensible :" << std::boolalpha << jshclass->IsExtensible();
662 os << "| ElementsKind :" << Elements::GetString(jshclass->GetElementsKind());
663 os << "| NumberOfProps :" << std::dec << jshclass->NumberOfProps();
664 os << "| InlinedProperties :" << std::dec << jshclass->GetInlinedProperties();
665 os << "| IsTS :" << std::boolalpha << jshclass->IsTS();
666 os << "| Level :" << std::dec << static_cast<int>(jshclass->GetLevel());
667 os << "\n";
668 }
669
DumpClass(TaggedObject *obj, std::ostream &os)670 static void DumpClass(TaggedObject *obj, std::ostream &os)
671 {
672 ASSERT(obj->GetClass()->GetObjectType() == JSType::HCLASS);
673 DumpHClass(JSHClass::Cast(obj), os, true);
674 }
675
DumpObject(TaggedObject *obj, std::ostream &os)676 static void DumpObject(TaggedObject *obj, std::ostream &os)
677 {
678 DISALLOW_GARBAGE_COLLECTION;
679 auto jsHclass = obj->GetClass();
680 JSType type = jsHclass->GetObjectType();
681
682 bool needDumpHClass = false;
683 switch (type) {
684 case JSType::HCLASS:
685 return DumpClass(obj, os);
686 case JSType::TAGGED_ARRAY:
687 case JSType::TAGGED_DICTIONARY:
688 case JSType::TEMPLATE_MAP:
689 case JSType::LEXICAL_ENV:
690 case JSType::SENDABLE_ENV:
691 case JSType::COW_TAGGED_ARRAY:
692 case JSType::AOT_LITERAL_INFO:
693 DumpArrayClass(TaggedArray::Cast(obj), os);
694 break;
695 case JSType::MUTANT_TAGGED_ARRAY:
696 DumpMutantTaggedArray(MutantTaggedArray::Cast(obj), os);
697 break;
698 case JSType::COW_MUTANT_TAGGED_ARRAY:
699 DumpCOWMutantTaggedArray(COWMutantTaggedArray::Cast(obj), os);
700 break;
701 case JSType::CONSTANT_POOL:
702 DumpConstantPoolClass(ConstantPool::Cast(obj), os);
703 break;
704 case JSType::PROFILE_TYPE_INFO:
705 ProfileTypeInfo::Cast(obj)->Dump(os);
706 break;
707 case JSType::PROFILE_TYPE_INFO_CELL_0:
708 case JSType::PROFILE_TYPE_INFO_CELL_1:
709 case JSType::PROFILE_TYPE_INFO_CELL_N:
710 ProfileTypeInfoCell::Cast(obj)->Dump(os);
711 break;
712 case JSType::FUNCTION_TEMPLATE:
713 FunctionTemplate::Cast(obj)->Dump(os);
714 break;
715 case JSType::VTABLE:
716 VTable::Cast(obj)->Dump(os);
717 break;
718 case JSType::EXTRA_PROFILE_TYPE_INFO:
719 ExtraProfileTypeInfo::Cast(obj)->Dump(os);
720 break;
721 case JSType::LINE_STRING:
722 case JSType::CONSTANT_STRING:
723 case JSType::TREE_STRING:
724 case JSType::SLICED_STRING:
725 DumpStringClass(EcmaString::Cast(obj), os);
726 os << "\n";
727 break;
728 case JSType::JS_NATIVE_POINTER:
729 break;
730 case JSType::JS_OBJECT:
731 case JSType::JS_SHARED_OBJECT:
732 case JSType::JS_GLOBAL_OBJECT:
733 case JSType::JS_ERROR:
734 case JSType::JS_EVAL_ERROR:
735 case JSType::JS_RANGE_ERROR:
736 case JSType::JS_TYPE_ERROR:
737 case JSType::JS_AGGREGATE_ERROR:
738 case JSType::JS_REFERENCE_ERROR:
739 case JSType::JS_URI_ERROR:
740 case JSType::JS_SYNTAX_ERROR:
741 case JSType::JS_OOM_ERROR:
742 case JSType::JS_TERMINATION_ERROR:
743 case JSType::JS_ARGUMENTS:
744 needDumpHClass = true;
745 JSObject::Cast(obj)->Dump(os);
746 break;
747 case JSType::JS_FUNCTION_BASE:
748 needDumpHClass = true;
749 JSFunctionBase::Cast(obj)->Dump(os);
750 break;
751 case JSType::GLOBAL_ENV:
752 GlobalEnv::Cast(obj)->Dump(os);
753 break;
754 case JSType::ACCESSOR_DATA:
755 break;
756 case JSType::JS_SHARED_FUNCTION:
757 case JSType::JS_FUNCTION:
758 needDumpHClass = true;
759 JSFunction::Cast(obj)->Dump(os);
760 break;
761 case JSType::JS_BOUND_FUNCTION:
762 needDumpHClass = true;
763 JSBoundFunction::Cast(obj)->Dump(os);
764 break;
765 case JSType::JS_SET:
766 needDumpHClass = true;
767 JSSet::Cast(obj)->Dump(os);
768 break;
769 case JSType::JS_SHARED_SET:
770 needDumpHClass = true;
771 JSSharedSet::Cast(obj)->Dump(os);
772 break;
773 case JSType::JS_MAP:
774 needDumpHClass = true;
775 JSMap::Cast(obj)->Dump(os);
776 break;
777 case JSType::JS_SHARED_MAP:
778 needDumpHClass = true;
779 JSSharedMap::Cast(obj)->Dump(os);
780 break;
781 case JSType::JS_WEAK_SET:
782 needDumpHClass = true;
783 JSWeakSet::Cast(obj)->Dump(os);
784 break;
785 case JSType::JS_WEAK_MAP:
786 needDumpHClass = true;
787 JSWeakMap::Cast(obj)->Dump(os);
788 break;
789 case JSType::JS_WEAK_REF:
790 needDumpHClass = true;
791 JSWeakRef::Cast(obj)->Dump(os);
792 break;
793 case JSType::JS_FINALIZATION_REGISTRY:
794 JSFinalizationRegistry::Cast(obj)->Dump(os);
795 break;
796 case JSType::CELL_RECORD:
797 CellRecord::Cast(obj)->Dump(os);
798 break;
799 case JSType::JS_REG_EXP:
800 needDumpHClass = true;
801 JSRegExp::Cast(obj)->Dump(os);
802 break;
803 case JSType::JS_DATE:
804 needDumpHClass = true;
805 JSDate::Cast(obj)->Dump(os);
806 break;
807 case JSType::JS_ARRAY:
808 needDumpHClass = true;
809 JSArray::Cast(obj)->Dump(os);
810 break;
811 case JSType::JS_SHARED_ARRAY:
812 needDumpHClass = true;
813 JSSharedArray::Cast(obj)->Dump(os);
814 break;
815 case JSType::JS_TYPED_ARRAY:
816 case JSType::JS_INT8_ARRAY:
817 case JSType::JS_UINT8_ARRAY:
818 case JSType::JS_UINT8_CLAMPED_ARRAY:
819 case JSType::JS_INT16_ARRAY:
820 case JSType::JS_UINT16_ARRAY:
821 case JSType::JS_INT32_ARRAY:
822 case JSType::JS_UINT32_ARRAY:
823 case JSType::JS_FLOAT32_ARRAY:
824 case JSType::JS_FLOAT64_ARRAY:
825 case JSType::JS_BIGINT64_ARRAY:
826 case JSType::JS_BIGUINT64_ARRAY:
827 needDumpHClass = true;
828 JSTypedArray::Cast(obj)->Dump(os);
829 break;
830 case JSType::JS_SHARED_TYPED_ARRAY:
831 case JSType::JS_SHARED_INT8_ARRAY:
832 case JSType::JS_SHARED_UINT8_ARRAY:
833 case JSType::JS_SHARED_UINT8_CLAMPED_ARRAY:
834 case JSType::JS_SHARED_INT16_ARRAY:
835 case JSType::JS_SHARED_UINT16_ARRAY:
836 case JSType::JS_SHARED_INT32_ARRAY:
837 case JSType::JS_SHARED_UINT32_ARRAY:
838 case JSType::JS_SHARED_FLOAT32_ARRAY:
839 case JSType::JS_SHARED_FLOAT64_ARRAY:
840 case JSType::JS_SHARED_BIGINT64_ARRAY:
841 case JSType::JS_SHARED_BIGUINT64_ARRAY:
842 needDumpHClass = true;
843 JSSharedTypedArray::Cast(obj)->Dump(os);
844 break;
845 case JSType::BIGINT:
846 BigInt::Cast(obj)->Dump(os);
847 break;
848 case JSType::BYTE_ARRAY:
849 ByteArray::Cast(obj)->Dump(os);
850 break;
851 case JSType::JS_PROXY:
852 needDumpHClass = true;
853 JSProxy::Cast(obj)->Dump(os);
854 break;
855 case JSType::JS_PRIMITIVE_REF:
856 JSPrimitiveRef::Cast(obj)->Dump(os);
857 break;
858 case JSType::SYMBOL:
859 JSSymbol::Cast(obj)->Dump(os);
860 break;
861 case JSType::JS_DATA_VIEW:
862 JSDataView::Cast(obj)->Dump(os);
863 break;
864 case JSType::JS_ARRAY_BUFFER:
865 JSArrayBuffer::Cast(obj)->Dump(os);
866 break;
867 case JSType::JS_SENDABLE_ARRAY_BUFFER:
868 JSSendableArrayBuffer::Cast(obj)->Dump(os);
869 break;
870 case JSType::JS_SHARED_ARRAY_BUFFER:
871 JSArrayBuffer::Cast(obj)->Dump(os);
872 break;
873 case JSType::PROMISE_REACTIONS:
874 PromiseReaction::Cast(obj)->Dump(os);
875 break;
876 case JSType::PROMISE_CAPABILITY:
877 PromiseCapability::Cast(obj)->Dump(os);
878 break;
879 case JSType::PROMISE_ITERATOR_RECORD:
880 PromiseIteratorRecord::Cast(obj)->Dump(os);
881 break;
882 case JSType::PROMISE_RECORD:
883 PromiseRecord::Cast(obj)->Dump(os);
884 break;
885 case JSType::RESOLVING_FUNCTIONS_RECORD:
886 ResolvingFunctionsRecord::Cast(obj)->Dump(os);
887 break;
888 case JSType::JS_PROMISE:
889 needDumpHClass = true;
890 JSPromise::Cast(obj)->Dump(os);
891 break;
892 case JSType::JS_PROMISE_REACTIONS_FUNCTION:
893 JSPromiseReactionsFunction::Cast(obj)->Dump(os);
894 break;
895 case JSType::JS_PROMISE_EXECUTOR_FUNCTION:
896 JSPromiseExecutorFunction::Cast(obj)->Dump(os);
897 break;
898 case JSType::JS_ASYNC_MODULE_FULFILLED_FUNCTION:
899 JSAsyncModuleFulfilledFunction::Cast(obj)->Dump(os);
900 break;
901 case JSType::JS_ASYNC_MODULE_REJECTED_FUNCTION:
902 JSAsyncModuleRejectedFunction::Cast(obj)->Dump(os);
903 break;
904 case JSType::ASYNC_GENERATOR_REQUEST:
905 AsyncGeneratorRequest::Cast(obj)->Dump(os);
906 break;
907 case JSType::ASYNC_ITERATOR_RECORD:
908 AsyncIteratorRecord::Cast(obj)->Dump(os);
909 break;
910 case JSType::JS_ASYNC_FROM_SYNC_ITERATOR:
911 JSAsyncFromSyncIterator::Cast(obj)->Dump(os);
912 break;
913 case JSType::JS_ASYNC_FROM_SYNC_ITER_UNWARP_FUNCTION:
914 JSAsyncFromSyncIterUnwarpFunction::Cast(obj)->Dump(os);
915 break;
916 case JSType::JS_PROMISE_ALL_RESOLVE_ELEMENT_FUNCTION:
917 JSPromiseAllResolveElementFunction::Cast(obj)->Dump(os);
918 break;
919 case JSType::JS_PROMISE_ANY_REJECT_ELEMENT_FUNCTION:
920 JSPromiseAnyRejectElementFunction::Cast(obj)->Dump(os);
921 break;
922 case JSType::JS_PROMISE_ALL_SETTLED_ELEMENT_FUNCTION:
923 JSPromiseAllSettledElementFunction::Cast(obj)->Dump(os);
924 break;
925 case JSType::JS_PROMISE_FINALLY_FUNCTION:
926 JSPromiseFinallyFunction::Cast(obj)->Dump(os);
927 break;
928 case JSType::JS_PROMISE_VALUE_THUNK_OR_THROWER_FUNCTION:
929 JSPromiseValueThunkOrThrowerFunction::Cast(obj)->Dump(os);
930 break;
931 case JSType::MICRO_JOB_QUEUE:
932 MicroJobQueue::Cast(obj)->Dump(os);
933 break;
934 case JSType::PENDING_JOB:
935 PendingJob::Cast(obj)->Dump(os);
936 break;
937 case JSType::COMPLETION_RECORD:
938 CompletionRecord::Cast(obj)->Dump(os);
939 break;
940 case JSType::JS_PROXY_REVOC_FUNCTION:
941 JSProxyRevocFunction::Cast(obj)->Dump(os);
942 break;
943 case JSType::JS_ASYNC_FUNCTION:
944 case JSType::JS_SHARED_ASYNC_FUNCTION:
945 needDumpHClass = true;
946 JSAsyncFunction::Cast(obj)->Dump(os);
947 break;
948 case JSType::JS_ASYNC_AWAIT_STATUS_FUNCTION:
949 JSAsyncAwaitStatusFunction::Cast(obj)->Dump(os);
950 break;
951 case JSType::JS_GENERATOR_FUNCTION:
952 JSGeneratorFunction::Cast(obj)->Dump(os);
953 break;
954 case JSType::JS_ASYNC_GENERATOR_FUNCTION:
955 needDumpHClass = true;
956 JSAsyncGeneratorFunction::Cast(obj)->Dump(os);
957 break;
958 case JSType::JS_ASYNC_GENERATOR_RESUME_NEXT_RETURN_PROCESSOR_RST_FTN:
959 JSAsyncGeneratorResNextRetProRstFtn::Cast(obj)->Dump(os);
960 break;
961 case JSType::JS_INTL_BOUND_FUNCTION:
962 JSIntlBoundFunction::Cast(obj)->Dump(os);
963 break;
964 case JSType::JS_ITERATOR:
965 break;
966 case JSType::JS_ASYNCITERATOR:
967 break;
968 case JSType::JS_FORIN_ITERATOR:
969 JSForInIterator::Cast(obj)->Dump(os);
970 break;
971 case JSType::JS_MAP_ITERATOR:
972 JSMapIterator::Cast(obj)->Dump(os);
973 break;
974 case JSType::JS_SHARED_MAP_ITERATOR:
975 JSSharedMapIterator::Cast(obj)->Dump(os);
976 break;
977 case JSType::JS_SET_ITERATOR:
978 JSSetIterator::Cast(obj)->Dump(os);
979 break;
980 case JSType::JS_SHARED_SET_ITERATOR:
981 JSSharedSetIterator::Cast(obj)->Dump(os);
982 break;
983 case JSType::JS_REG_EXP_ITERATOR:
984 JSRegExpIterator::Cast(obj)->Dump(os);
985 break;
986 case JSType::JS_ARRAY_ITERATOR:
987 JSArrayIterator::Cast(obj)->Dump(os);
988 break;
989 case JSType::JS_SHARED_ARRAY_ITERATOR:
990 JSSharedArrayIterator::Cast(obj)->Dump(os);
991 break;
992 case JSType::JS_STRING_ITERATOR:
993 JSStringIterator::Cast(obj)->Dump(os);
994 break;
995 case JSType::PROTOTYPE_HANDLER:
996 PrototypeHandler::Cast(obj)->Dump(os);
997 break;
998 case JSType::TRANSITION_HANDLER:
999 TransitionHandler::Cast(obj)->Dump(os);
1000 break;
1001 case JSType::TRANS_WITH_PROTO_HANDLER:
1002 TransWithProtoHandler::Cast(obj)->Dump(os);
1003 break;
1004 case JSType::STORE_TS_HANDLER:
1005 StoreTSHandler::Cast(obj)->Dump(os);
1006 break;
1007 case JSType::PROPERTY_BOX:
1008 PropertyBox::Cast(obj)->Dump(os);
1009 break;
1010 case JSType::JS_REALM:
1011 needDumpHClass = true;
1012 JSRealm::Cast(obj)->Dump(os);
1013 break;
1014 #ifdef ARK_SUPPORT_INTL
1015 case JSType::JS_INTL:
1016 needDumpHClass = true;
1017 JSIntl::Cast(obj)->Dump(os);
1018 break;
1019 case JSType::JS_LOCALE:
1020 needDumpHClass = true;
1021 JSLocale::Cast(obj)->Dump(os);
1022 break;
1023 case JSType::JS_DATE_TIME_FORMAT:
1024 JSDateTimeFormat::Cast(obj)->Dump(os);
1025 break;
1026 case JSType::JS_RELATIVE_TIME_FORMAT:
1027 JSRelativeTimeFormat::Cast(obj)->Dump(os);
1028 break;
1029 case JSType::JS_NUMBER_FORMAT:
1030 JSNumberFormat::Cast(obj)->Dump(os);
1031 break;
1032 case JSType::JS_COLLATOR:
1033 needDumpHClass = true;
1034 JSCollator::Cast(obj)->Dump(os);
1035 break;
1036 case JSType::JS_PLURAL_RULES:
1037 JSPluralRules::Cast(obj)->Dump(os);
1038 break;
1039 case JSType::JS_DISPLAYNAMES:
1040 JSDisplayNames::Cast(obj)->Dump(os);
1041 break;
1042 case JSType::JS_SEGMENTER:
1043 JSSegmenter::Cast(obj)->Dump(os);
1044 break;
1045 case JSType::JS_SEGMENTS:
1046 JSSegments::Cast(obj)->Dump(os);
1047 break;
1048 case JSType::JS_SEGMENT_ITERATOR:
1049 JSSegmentIterator::Cast(obj)->Dump(os);
1050 break;
1051 case JSType::JS_LIST_FORMAT:
1052 JSListFormat::Cast(obj)->Dump(os);
1053 break;
1054 #else
1055 case JSType::JS_INTL:
1056 case JSType::JS_LOCALE:
1057 case JSType::JS_DATE_TIME_FORMAT:
1058 case JSType::JS_RELATIVE_TIME_FORMAT:
1059 case JSType::JS_NUMBER_FORMAT:
1060 case JSType::JS_COLLATOR:
1061 case JSType::JS_PLURAL_RULES:
1062 case JSType::JS_DISPLAYNAMES:
1063 case JSType::JS_SEGMENTER:
1064 case JSType::JS_SEGMENTS:
1065 case JSType::JS_SEGMENT_ITERATOR:
1066 case JSType::JS_LIST_FORMAT:
1067 break;
1068 #endif
1069 case JSType::JS_GENERATOR_OBJECT:
1070 needDumpHClass = true;
1071 JSGeneratorObject::Cast(obj)->Dump(os);
1072 break;
1073 case JSType::JS_ASYNC_GENERATOR_OBJECT:
1074 needDumpHClass = true;
1075 JSAsyncGeneratorObject::Cast(obj)->Dump(os);
1076 break;
1077 case JSType::JS_ASYNC_FUNC_OBJECT:
1078 needDumpHClass = true;
1079 JSAsyncFuncObject::Cast(obj)->Dump(os);
1080 break;
1081 case JSType::JS_GENERATOR_CONTEXT:
1082 GeneratorContext::Cast(obj)->Dump(os);
1083 break;
1084 case JSType::PROTOTYPE_INFO:
1085 ProtoChangeDetails::Cast(obj)->Dump(os);
1086 break;
1087 case JSType::TRACK_INFO:
1088 TrackInfo::Cast(obj)->Dump(os);
1089 break;
1090 case JSType::PROTO_CHANGE_MARKER:
1091 ProtoChangeMarker::Cast(obj)->Dump(os);
1092 break;
1093 case JSType::MARKER_CELL:
1094 MarkerCell::Cast(obj)->Dump(os);
1095 break;
1096 case JSType::PROGRAM:
1097 Program::Cast(obj)->Dump(os);
1098 break;
1099 case JSType::MACHINE_CODE_OBJECT:
1100 MachineCode::Cast(obj)->Dump(os);
1101 break;
1102 case JSType::CLASS_INFO_EXTRACTOR:
1103 ClassInfoExtractor::Cast(obj)->Dump(os);
1104 break;
1105 case JSType::JS_API_ARRAY_LIST:
1106 JSAPIArrayList::Cast(obj)->Dump(os);
1107 break;
1108 case JSType::JS_API_ARRAYLIST_ITERATOR:
1109 JSAPIArrayListIterator::Cast(obj)->Dump(os);
1110 break;
1111 case JSType::JS_API_BITVECTOR:
1112 JSAPIBitVector::Cast(obj)->Dump(os);
1113 break;
1114 case JSType::JS_API_BITVECTOR_ITERATOR:
1115 JSAPIBitVectorIterator::Cast(obj)->Dump(os);
1116 break;
1117 case JSType::JS_API_LIGHT_WEIGHT_MAP:
1118 JSAPILightWeightMap::Cast(obj)->Dump(os);
1119 break;
1120 case JSType::JS_API_LIGHT_WEIGHT_MAP_ITERATOR:
1121 JSAPILightWeightMapIterator::Cast(obj)->Dump(os);
1122 break;
1123 case JSType::JS_API_LIGHT_WEIGHT_SET:
1124 JSAPILightWeightSet::Cast(obj)->Dump(os);
1125 break;
1126 case JSType::JS_API_LIGHT_WEIGHT_SET_ITERATOR:
1127 JSAPILightWeightSetIterator::Cast(obj)->Dump(os);
1128 break;
1129 case JSType::LINKED_NODE:
1130 LinkedNode::Cast(obj)->Dump(os);
1131 break;
1132 case JSType::RB_TREENODE:
1133 break;
1134 case JSType::JS_API_HASH_MAP:
1135 JSAPIHashMap::Cast(obj)->Dump(os);
1136 break;
1137 case JSType::JS_API_HASH_SET:
1138 JSAPIHashSet::Cast(obj)->Dump(os);
1139 break;
1140 case JSType::JS_API_HASHMAP_ITERATOR:
1141 JSAPIHashMapIterator::Cast(obj)->Dump(os);
1142 break;
1143 case JSType::JS_API_HASHSET_ITERATOR:
1144 JSAPIHashSetIterator::Cast(obj)->Dump(os);
1145 break;
1146 case JSType::JS_API_TREE_MAP:
1147 JSAPITreeMap::Cast(obj)->Dump(os);
1148 break;
1149 case JSType::JS_API_TREE_SET:
1150 JSAPITreeSet::Cast(obj)->Dump(os);
1151 break;
1152 case JSType::JS_API_TREEMAP_ITERATOR:
1153 JSAPITreeMapIterator::Cast(obj)->Dump(os);
1154 break;
1155 case JSType::JS_API_TREESET_ITERATOR:
1156 JSAPITreeSetIterator::Cast(obj)->Dump(os);
1157 break;
1158 case JSType::JS_API_VECTOR:
1159 JSAPIVector::Cast(obj)->Dump(os);
1160 break;
1161 case JSType::JS_API_VECTOR_ITERATOR:
1162 JSAPIVectorIterator::Cast(obj)->Dump(os);
1163 break;
1164 case JSType::JS_API_QUEUE:
1165 JSAPIQueue::Cast(obj)->Dump(os);
1166 break;
1167 case JSType::JS_API_QUEUE_ITERATOR:
1168 JSAPIQueueIterator::Cast(obj)->Dump(os);
1169 break;
1170 case JSType::JS_API_DEQUE:
1171 JSAPIDeque::Cast(obj)->Dump(os);
1172 break;
1173 case JSType::JS_API_DEQUE_ITERATOR:
1174 JSAPIDequeIterator::Cast(obj)->Dump(os);
1175 break;
1176 case JSType::JS_API_STACK:
1177 JSAPIStack::Cast(obj)->Dump(os);
1178 break;
1179 case JSType::JS_API_STACK_ITERATOR:
1180 JSAPIStackIterator::Cast(obj)->Dump(os);
1181 break;
1182 case JSType::JS_API_LIST:
1183 JSAPIList::Cast(obj)->Dump(os);
1184 break;
1185 case JSType::JS_API_LIST_ITERATOR:
1186 JSAPIListIterator::Cast(obj)->Dump(os);
1187 break;
1188 case JSType::JS_API_LINKED_LIST:
1189 JSAPILinkedList::Cast(obj)->Dump(os);
1190 break;
1191 case JSType::JS_API_LINKED_LIST_ITERATOR:
1192 JSAPILinkedListIterator::Cast(obj)->Dump(os);
1193 break;
1194 case JSType::SOURCE_TEXT_MODULE_RECORD:
1195 SourceTextModule::Cast(obj)->Dump(os);
1196 break;
1197 case JSType::IMPORTENTRY_RECORD:
1198 ImportEntry::Cast(obj)->Dump(os);
1199 break;
1200 case JSType::LOCAL_EXPORTENTRY_RECORD:
1201 LocalExportEntry::Cast(obj)->Dump(os);
1202 break;
1203 case JSType::INDIRECT_EXPORTENTRY_RECORD:
1204 IndirectExportEntry::Cast(obj)->Dump(os);
1205 break;
1206 case JSType::STAR_EXPORTENTRY_RECORD:
1207 StarExportEntry::Cast(obj)->Dump(os);
1208 break;
1209 case JSType::RESOLVEDBINDING_RECORD:
1210 ResolvedBinding::Cast(obj)->Dump(os);
1211 break;
1212 case JSType::RESOLVEDINDEXBINDING_RECORD:
1213 ResolvedIndexBinding::Cast(obj)->Dump(os);
1214 break;
1215 case JSType::RESOLVEDRECORDINDEXBINDING_RECORD:
1216 ResolvedRecordIndexBinding::Cast(obj)->Dump(os);
1217 break;
1218 case JSType::RESOLVEDRECORDBINDING_RECORD:
1219 ResolvedRecordBinding::Cast(obj)->Dump(os);
1220 break;
1221 case JSType::NATIVE_MODULE_FAILURE_INFO:
1222 NativeModuleFailureInfo::Cast(obj)->Dump(os);
1223 break;
1224 case JSType::JS_MODULE_NAMESPACE:
1225 ModuleNamespace::Cast(obj)->Dump(os);
1226 break;
1227 case JSType::JS_API_PLAIN_ARRAY:
1228 JSAPIPlainArray::Cast(obj)->Dump(os);
1229 break;
1230 case JSType::JS_API_PLAIN_ARRAY_ITERATOR:
1231 JSAPIPlainArrayIterator::Cast(obj)->Dump(os);
1232 break;
1233 case JSType::JS_CJS_MODULE:
1234 CjsModule::Cast(obj)->Dump(os);
1235 break;
1236 case JSType::JS_CJS_REQUIRE:
1237 CjsRequire::Cast(obj)->Dump(os);
1238 break;
1239 case JSType::JS_CJS_EXPORTS:
1240 CjsExports::Cast(obj)->Dump(os);
1241 break;
1242 case JSType::METHOD:
1243 Method::Cast(obj)->Dump(os);
1244 break;
1245 case JSType::CLASS_LITERAL:
1246 ClassLiteral::Cast(obj)->Dump(os);
1247 break;
1248 default:
1249 LOG_ECMA(FATAL) << "this branch is unreachable";
1250 UNREACHABLE();
1251 break;
1252 }
1253
1254 if (needDumpHClass) {
1255 DumpHClass(jsHclass, os, false);
1256 }
1257 }
1258
DumpSpecialValue(std::ostream &os) const1259 void JSTaggedValue::DumpSpecialValue(std::ostream &os) const
1260 {
1261 ASSERT(IsSpecial());
1262 os << "[Special Value] : ";
1263 switch (GetRawData()) {
1264 case VALUE_HOLE:
1265 os << "Hole";
1266 break;
1267 case VALUE_NULL:
1268 os << "Null";
1269 break;
1270 case VALUE_FALSE:
1271 os << "False";
1272 break;
1273 case VALUE_TRUE:
1274 os << "True";
1275 break;
1276 case VALUE_UNDEFINED:
1277 os << "Undefined";
1278 break;
1279 case VALUE_EXCEPTION:
1280 os << "Exception";
1281 break;
1282 default:
1283 LOG_ECMA(FATAL) << "this branch is unreachable";
1284 UNREACHABLE();
1285 break;
1286 }
1287 }
1288
DumpHeapObjectType(std::ostream &os) const1289 void JSTaggedValue::DumpHeapObjectType(std::ostream &os) const
1290 {
1291 ASSERT(IsWeak() || IsHeapObject());
1292 bool isWeak = IsWeak();
1293 TaggedObject *obj = isWeak ? GetTaggedWeakRef() : GetTaggedObject();
1294 if (isWeak) {
1295 os << " [Weak Ref] ";
1296 }
1297
1298 JSType type = obj->GetClass()->GetObjectType();
1299 if (type >= JSType::STRING_FIRST && type <= JSType::STRING_LAST) {
1300 CString string = ConvertToString(EcmaString::Cast(obj));
1301 os << std::left << std::setw(DUMP_TYPE_OFFSET) << "[" + string + "]";
1302 } else if (type == JSType::METHOD) {
1303 std::ostringstream address;
1304 address << obj;
1305 CString addrStr = CString(address.str());
1306 Method *method = Method::Cast(obj);
1307
1308 os << std::left << std::setw(DUMP_TYPE_OFFSET)
1309 << "[" + JSHClass::DumpJSType(type) + "(" + addrStr + "-" + method->GetMethodName() + ")]";
1310 } else {
1311 std::ostringstream address;
1312 address << obj;
1313 CString addrStr = CString(address.str());
1314
1315 os << std::left << std::setw(DUMP_TYPE_OFFSET) << "[" + JSHClass::DumpJSType(type) + "(" + addrStr + ")]";
1316 }
1317 }
1318
DumpTaggedValue(std::ostream &os) const1319 void JSTaggedValue::DumpTaggedValue(std::ostream &os) const
1320 {
1321 if (IsInt()) {
1322 os << std::left << std::setw(DUMP_TYPE_OFFSET) << "[Int] : " << std::hex << "0x" << GetInt() << std::dec << " ("
1323 << GetInt() << ")";
1324 } else if (IsDouble()) {
1325 os << std::left << std::setw(DUMP_TYPE_OFFSET) << "[Double] : " << GetDouble();
1326 } else if (IsSpecial()) {
1327 DumpSpecialValue(os);
1328 } else {
1329 DumpHeapObjectType(os);
1330 }
1331 }
1332
DumpTaggedValueType(std::ostream &os) const1333 void JSTaggedValue::DumpTaggedValueType(std::ostream &os) const
1334 {
1335 if (IsInt()) {
1336 os << "[Int]";
1337 } else if (IsDouble()) {
1338 os << "[Double]";
1339 } else if (IsSpecial()) {
1340 DumpSpecialValue(os);
1341 } else {
1342 ASSERT(IsWeak() || IsHeapObject());
1343 TaggedObject *obj = IsWeak() ? GetTaggedWeakRef() : GetTaggedObject();
1344 os << "[" + JSHClass::DumpJSType(obj->GetClass()->GetObjectType()) + "]";
1345 }
1346 }
1347
Dump(std::ostream &os) const1348 void JSTaggedValue::Dump(std::ostream &os) const
1349 {
1350 DumpTaggedValue(os);
1351 os << "\n";
1352
1353 if (IsHeapObject()) {
1354 TaggedObject *obj = IsWeak() ? GetTaggedWeakRef() : GetTaggedObject();
1355 DumpObject(obj, os);
1356 }
1357 }
1358
D() const1359 void JSTaggedValue::D() const
1360 {
1361 Dump(std::cout);
1362 }
1363
DV(JSTaggedType val)1364 void JSTaggedValue::DV(JSTaggedType val)
1365 {
1366 JSTaggedValue(val).D();
1367 }
1368
DumpStack()1369 void JSThread::DumpStack()
1370 {
1371 FrameHandler handler(this);
1372 handler.DumpStack(std::cout);
1373 }
1374
Dump(std::ostream &os) const1375 void NumberDictionary::Dump(std::ostream &os) const
1376 {
1377 DISALLOW_GARBAGE_COLLECTION;
1378 int size = Size();
1379 for (int hashIndex = 0; hashIndex < size; hashIndex++) {
1380 JSTaggedValue key(GetKey(hashIndex));
1381 if (!key.IsUndefined() && !key.IsHole()) {
1382 JSTaggedValue val(GetValue(hashIndex));
1383 os << std::right << std::setw(DUMP_PROPERTY_OFFSET)
1384 << static_cast<uint32_t>(JSTaggedNumber(key).GetNumber()) << ": ";
1385 val.DumpTaggedValue(os);
1386 os << " ";
1387 DumpAttr(GetAttributes(hashIndex), false, os);
1388 os << "\n";
1389 }
1390 }
1391 }
1392
Dump(std::ostream &os) const1393 void NameDictionary::Dump(std::ostream &os) const
1394 {
1395 DISALLOW_GARBAGE_COLLECTION;
1396 int size = Size();
1397 for (int hashIndex = 0; hashIndex < size; hashIndex++) {
1398 JSTaggedValue key(GetKey(hashIndex));
1399 if (!key.IsUndefined() && !key.IsHole()) {
1400 JSTaggedValue val(GetValue(hashIndex));
1401 os << std::right << std::setw(DUMP_PROPERTY_OFFSET);
1402 DumpPropertyKey(key, os);
1403 os << ": ";
1404 val.DumpTaggedValue(os);
1405 os << " ";
1406 DumpAttr(GetAttributes(hashIndex), false, os);
1407 os << "\n";
1408 }
1409 }
1410 }
1411
Dump(std::ostream &os) const1412 void GlobalDictionary::Dump(std::ostream &os) const
1413 {
1414 DISALLOW_GARBAGE_COLLECTION;
1415 int size = Size();
1416 for (int hashIndex = 0; hashIndex < size; hashIndex++) {
1417 JSTaggedValue key(GetKey(hashIndex));
1418 if (!key.IsUndefined() && !key.IsHole()) {
1419 JSTaggedValue val(GetValue(hashIndex));
1420 os << std::right << std::setw(DUMP_PROPERTY_OFFSET);
1421 DumpPropertyKey(key, os);
1422 os << " : ";
1423 val.DumpTaggedValue(os);
1424 os << " ";
1425 DumpAttr(GetAttributes(hashIndex), false, os);
1426 os << "\n";
1427 }
1428 }
1429 }
1430
Dump(std::ostream &os) const1431 void LayoutInfo::Dump(std::ostream &os) const
1432 {
1433 DISALLOW_GARBAGE_COLLECTION;
1434 int num = NumberOfElements();
1435 for (int i = 0; i < num; i++) {
1436 JSTaggedValue key = GetKey(i);
1437 PropertyAttributes attr = GetAttr(i);
1438 os << std::right << std::setw(DUMP_PROPERTY_OFFSET);
1439 os << "[" << i << "]: ";
1440 DumpPropertyKey(key, os);
1441 os << " : ";
1442 DumpAttr(attr, true, os);
1443 os << "\n";
1444 }
1445 }
1446
Dump(std::ostream &os) const1447 void TransitionsDictionary::Dump(std::ostream &os) const
1448 {
1449 DISALLOW_GARBAGE_COLLECTION;
1450 int size = Size();
1451 for (int hashIndex = 0; hashIndex < size; hashIndex++) {
1452 JSTaggedValue key(GetKey(hashIndex));
1453 if (!key.IsUndefined() && !key.IsHole()) {
1454 os << std::right << std::setw(DUMP_PROPERTY_OFFSET);
1455 DumpPropertyKey(key, os);
1456 os << " : ";
1457 GetValue(hashIndex).DumpTaggedValue(os);
1458 os << " : ";
1459 GetAttributes(hashIndex).DumpTaggedValue(os);
1460 os << "\n";
1461 }
1462 }
1463 }
1464
Dump(std::ostream &os) const1465 void LinkedHashSet::Dump(std::ostream &os) const
1466 {
1467 DISALLOW_GARBAGE_COLLECTION;
1468 int capacity = NumberOfElements() + NumberOfDeletedElements();
1469 for (int hashIndex = 0; hashIndex < capacity; hashIndex++) {
1470 JSTaggedValue key(GetKey(hashIndex));
1471 if (!key.IsUndefined() && !key.IsHole()) {
1472 os << std::right << std::setw(DUMP_PROPERTY_OFFSET);
1473 key.DumpTaggedValue(os);
1474 os << "\n";
1475 }
1476 }
1477 }
1478
Dump(std::ostream &os) const1479 void LinkedHashMap::Dump(std::ostream &os) const
1480 {
1481 DISALLOW_GARBAGE_COLLECTION;
1482 int capacity = NumberOfElements() + NumberOfDeletedElements();
1483 for (int hashIndex = 0; hashIndex < capacity; hashIndex++) {
1484 JSTaggedValue key(GetKey(hashIndex));
1485 if (!key.IsUndefined() && !key.IsHole()) {
1486 JSTaggedValue val(GetValue(hashIndex));
1487 os << std::right << std::setw(DUMP_PROPERTY_OFFSET);
1488 key.DumpTaggedValue(os);
1489 os << ": ";
1490 val.DumpTaggedValue(os);
1491 os << "\n";
1492 }
1493 }
1494 }
1495
Dump(std::ostream &os) const1496 void TaggedDoubleList::Dump(std::ostream &os) const
1497 {
1498 DISALLOW_GARBAGE_COLLECTION;
1499 int capacity = NumberOfNodes();
1500 os << " - node num: " << std::dec << capacity << "\n";
1501 os << " - delete node num: " << std::dec << NumberOfDeletedNodes() << "\n";
1502 os << "head-next: ";
1503 // 5 : 5 first element next ptr
1504 GetElement(5).Dump(os);
1505 os << "head-pre: ";
1506 // 6 : 6 first element per ptr
1507 GetElement(6).Dump(os);
1508 os << "\n";
1509 int i = 0;
1510 int next = GetElement(5).GetInt();
1511 while (capacity > i) {
1512 os << " value: ";
1513 GetElement(next).DumpTaggedValue(os);
1514 os << " next: ";
1515 // 1 : 1 current element next ptr offset
1516 GetElement(next + 1).Dump(os);
1517 os << " pre: ";
1518 // 2 : 2 current element pre ptr offset
1519 GetElement(next + 2).Dump(os);
1520 os << "\n";
1521 next = GetElement(next + 1).GetInt();
1522 i++;
1523 }
1524 }
1525
Dump(std::ostream &os) const1526 void TaggedSingleList::Dump(std::ostream &os) const
1527 {
1528 DISALLOW_GARBAGE_COLLECTION;
1529 int capacity = NumberOfNodes();
1530 os << "head-next: ";
1531 // 5 : 5 first element next ptr
1532 GetElement(5).Dump(os);
1533 os << "\n";
1534 int i = 0;
1535 int next = GetElement(5).GetInt();
1536 while (capacity > i) {
1537 os << " value: ";
1538 GetElement(next).DumpTaggedValue(os);
1539 os << " next: ";
1540 // 1 : 1 current element next ptr offset
1541 GetElement(next + 1).Dump(os);
1542 os << "\n";
1543 next = GetElement(next + 1).GetInt();
1544 i++;
1545 }
1546 }
1547
Dump(std::ostream &os) const1548 void JSObject::Dump(std::ostream &os) const
1549 {
1550 DISALLOW_GARBAGE_COLLECTION;
1551 JSHClass *jshclass = GetJSHClass();
1552 os << " - hclass: " << std::hex << jshclass << "\n";
1553 os << " - prototype: ";
1554 jshclass->GetPrototype().DumpTaggedValue(os);
1555 os << "\n";
1556
1557 JSTaggedType hashField = Barriers::GetValue<JSTaggedType>(this, HASH_OFFSET);
1558 JSTaggedValue value(hashField);
1559 os << " - hash: " << std::hex << hashField;
1560 value.Dump(os);
1561
1562 TaggedArray *elements = TaggedArray::Cast(GetElements().GetTaggedObject());
1563 os << " - elements: " << std::hex << elements;
1564 if (elements->GetLength() == 0) {
1565 os << " NONE\n";
1566 } else if (!elements->IsDictionaryMode()) {
1567 DumpArrayClass(elements, os);
1568 } else {
1569 NumberDictionary *dict = NumberDictionary::Cast(elements);
1570 os << " <NumberDictionary[" << std::dec << dict->EntriesCount() << "]>\n";
1571 dict->Dump(os);
1572 }
1573
1574 TaggedArray *properties = TaggedArray::Cast(GetProperties().GetTaggedObject());
1575 os << " - properties: " << std::hex << properties;
1576 if (IsJSGlobalObject()) {
1577 GlobalDictionary *dict = GlobalDictionary::Cast(properties);
1578 os << " <GlobalDictionary[" << std::dec << dict->EntriesCount() << "]>\n";
1579 dict->Dump(os);
1580 return;
1581 }
1582
1583 if (!properties->IsDictionaryMode()) {
1584 JSTaggedValue attrs = jshclass->GetLayout();
1585 if (attrs.IsNull()) {
1586 return;
1587 }
1588
1589 LayoutInfo *layoutInfo = LayoutInfo::Cast(attrs.GetTaggedObject());
1590 int propNumber = static_cast<int>(jshclass->NumberOfProps());
1591 os << " <LayoutInfo[" << std::dec << propNumber << "]>\n";
1592 for (int i = 0; i < propNumber; i++) {
1593 JSTaggedValue key = layoutInfo->GetKey(i);
1594 PropertyAttributes attr = layoutInfo->GetAttr(i);
1595 ASSERT(i == static_cast<int>(attr.GetOffset()));
1596 os << " " << std::right << std::setw(DUMP_PROPERTY_OFFSET);
1597 DumpPropertyKey(key, os);
1598 os << ": (";
1599 JSTaggedValue val;
1600 if (attr.IsInlinedProps()) {
1601 val = GetPropertyInlinedPropsWithRep(i, attr);
1602 } else {
1603 val = properties->Get(i - static_cast<int>(jshclass->GetInlinedProperties()));
1604 }
1605 val.DumpTaggedValue(os);
1606 os << ") ";
1607 DumpAttr(attr, true, os);
1608 os << "\n";
1609 }
1610 } else {
1611 NameDictionary *dict = NameDictionary::Cast(properties);
1612 os << " <NameDictionary[" << std::dec << dict->EntriesCount() << "]>\n";
1613 dict->Dump(os);
1614 }
1615 }
1616
Dump(std::ostream &os) const1617 void TaggedArray::Dump(std::ostream &os) const
1618 {
1619 DumpArrayClass(this, os);
1620 }
1621
Dump(std::ostream &os) const1622 void AccessorData::Dump(std::ostream &os) const
1623 {
1624 auto *hclass = GetClass();
1625 if (hclass->GetObjectType() == JSType::INTERNAL_ACCESSOR) {
1626 os << " - Getter: " << InternalAccessor::ConstCast(this)->GetGetter() << "\n";
1627 os << " - Setter: " << InternalAccessor::ConstCast(this)->GetSetter() << "\n";
1628 return;
1629 }
1630
1631 os << " - Getter: ";
1632 GetGetter().DumpTaggedValue(os);
1633 os << "\n";
1634
1635 os << " - Setter: ";
1636 GetSetter().DumpTaggedValue(os);
1637 os << "\n";
1638 }
1639
Dump(std::ostream &os) const1640 void Program::Dump(std::ostream &os) const
1641 {
1642 os << " - MainFunction: ";
1643 GetMainFunction().Dump(os);
1644 os << "\n";
1645 }
1646
Dump(std::ostream &os) const1647 void LinkedNode::Dump(std::ostream &os) const
1648 {
1649 os << " - Next: ";
1650
1651 os << "\n";
1652 }
1653
Dump(std::ostream &os) const1654 void ConstantPool::Dump(std::ostream &os) const
1655 {
1656 DumpArrayClass(this, os);
1657 }
1658
Dump(std::ostream &os) const1659 void ProfileTypeInfo::Dump(std::ostream &os) const
1660 {
1661 DISALLOW_GARBAGE_COLLECTION;
1662 uint32_t len = GetIcSlotLength();
1663 os << " <ProfileTypeInfo[" << std::dec << len << "]>\n";
1664 for (uint32_t i = 0; i < len; i++) {
1665 JSTaggedValue val(Get(i));
1666 if (!val.IsHole()) {
1667 os << std::right << std::setw(DUMP_PROPERTY_OFFSET) << i << ": ";
1668 val.DumpTaggedValue(os);
1669 os << "\n";
1670 }
1671 }
1672 }
1673
Dump(std::ostream &os) const1674 void ExtraProfileTypeInfo::Dump(std::ostream &os) const
1675 {
1676 DISALLOW_GARBAGE_COLLECTION;
1677 os << " - Receiver: ";
1678 GetReceiverObject().Dump(os);
1679 os << " - Holder: ";
1680 GetHolderObject().Dump(os);
1681 os << "\n";
1682 }
1683
Dump(std::ostream &os) const1684 void ProfileTypeInfoCell::Dump(std::ostream &os) const
1685 {
1686 DISALLOW_GARBAGE_COLLECTION;
1687 os << " - Value: ";
1688 GetValue().Dump(os);
1689 os << " - Handle: ";
1690 GetHandle().Dump(os);
1691 os << "\n";
1692 }
1693
Dump(std::ostream &os) const1694 void FunctionTemplate::Dump(std::ostream &os) const
1695 {
1696 DISALLOW_GARBAGE_COLLECTION;
1697 os << " - Method: ";
1698 GetMethod().Dump(os);
1699 os << " - Module: ";
1700 GetModule().Dump(os);
1701 os << " - RawProfileTypeInfo: ";
1702 GetRawProfileTypeInfo().Dump(os);
1703 os << " - length : " << GetLength() << "\n";
1704 }
1705
Dump(std::ostream &os) const1706 void VTable::Dump(std::ostream &os) const
1707 {
1708 DISALLOW_GARBAGE_COLLECTION;
1709 uint32_t num = GetNumberOfTuples();
1710
1711 for (uint32_t i = 0; i < num; i++) {
1712 os << std::right << std::setw(DUMP_PROPERTY_OFFSET);
1713 os << "[" << i << "]: [ name :";
1714 JSTaggedValue name = GetTupleItem(i, VTable::TupleItem::NAME);
1715 DumpPropertyKey(name, os);
1716 os << ", type :" << (IsAccessor(i) ? "Accessor" : "Function");
1717 JSTaggedValue owner = GetTupleItem(i, VTable::TupleItem::OWNER);
1718 os << ", owner :";
1719 owner.DumpTaggedValue(os);
1720 JSTaggedValue offset = GetTupleItem(i, VTable::TupleItem::OFFSET);
1721 os << ", offset :" << offset.GetInt();
1722 os << " ] ";
1723 os << "\n";
1724 }
1725 }
1726
Dump(std::ostream &os) const1727 void JSFunction::Dump(std::ostream &os) const
1728 {
1729 os << " - ProtoOrHClass: ";
1730 GetProtoOrHClass().Dump(os);
1731 os << "\n";
1732 os << " - LexicalEnv: ";
1733 if (GetClass()->IsJSSharedFunction()) {
1734 os << GetLexicalEnv().GetRawData()<< "\n";
1735 } else {
1736 GetLexicalEnv().Dump(os);
1737 os << "\n";
1738 }
1739 os << " - RawProfileTypeInfo: ";
1740 GetRawProfileTypeInfo().Dump(os);
1741 os << "\n";
1742 os << " - HomeObject: ";
1743 GetHomeObject().Dump(os);
1744 os << "\n";
1745 os << " - FunctionExtraInfo: ";
1746 GetFunctionExtraInfo().Dump(os);
1747 os << "\n";
1748 os << " - Method: ";
1749 GetMethod().Dump(os);
1750 os << "\n";
1751 os << " - Module: ";
1752 GetModule().Dump(os);
1753 os << "\n";
1754 os << " - ProtoTransRootHClass: ";
1755 GetProtoTransRootHClass().Dump(os);
1756 os << "\n";
1757 JSObject::Dump(os);
1758 }
1759
Dump(std::ostream &os) const1760 void JSHClass::Dump(std::ostream &os) const
1761 {
1762 DumpHClass(this, os, true);
1763 }
1764
Dump(std::ostream &os) const1765 void JSBoundFunction::Dump(std::ostream &os) const
1766 {
1767 os << " - BoundTarget: ";
1768 GetBoundTarget().DumpTaggedValue(os);
1769 os << "\n";
1770
1771 os << " - BoundThis: ";
1772 GetBoundThis().DumpTaggedValue(os);
1773 os << "\n";
1774
1775 os << " - BoundArguments: ";
1776 GetBoundArguments().DumpTaggedValue(os);
1777 os << "\n";
1778
1779 JSObject::Dump(os);
1780 }
1781
Dump(std::ostream &os) const1782 void JSPrimitiveRef::Dump(std::ostream &os) const
1783 {
1784 os << " - SubValue : ";
1785 GetValue().DumpTaggedValue(os);
1786 os << "\n";
1787 JSObject::Dump(os);
1788 }
1789
Dump(std::ostream &os) const1790 void BigInt::Dump(std::ostream &os) const
1791 {
1792 os << " - length : " << GetLength() << "\n";
1793 os << " - Sign : " << GetSign() << "\n";
1794 os << " - value : " << ToStdString(DECIMAL) << "\n";
1795 }
1796
Dump(std::ostream &os) const1797 void JSDate::Dump(std::ostream &os) const
1798 {
1799 os << " - time: " << GetTime().GetDouble() << "\n";
1800 os << " - localOffset: " << GetLocalOffset().GetDouble() << "\n";
1801 JSObject::Dump(os);
1802 }
1803
Dump(std::ostream &os) const1804 void JSMap::Dump(std::ostream &os) const
1805 {
1806 LinkedHashMap *map = LinkedHashMap::Cast(GetLinkedMap().GetTaggedObject());
1807 os << " - elements: " << std::dec << map->NumberOfElements() << "\n";
1808 os << " - deleted-elements: " << std::dec << map->NumberOfDeletedElements() << "\n";
1809 os << " - capacity: " << std::dec << map->Capacity() << "\n";
1810 JSObject::Dump(os);
1811
1812 os << " <NameDictionary[" << map->NumberOfElements() << "]>\n";
1813 map->Dump(os);
1814 }
1815
Dump(std::ostream &os) const1816 void JSSharedMap::Dump(std::ostream &os) const
1817 {
1818 LinkedHashMap *map = LinkedHashMap::Cast(GetLinkedMap().GetTaggedObject());
1819 os << " - modRecord: " << std::dec << GetModRecord() << "\n";
1820 os << " - elements: " << std::dec << map->NumberOfElements() << "\n";
1821 os << " - deleted-elements: " << std::dec << map->NumberOfDeletedElements() << "\n";
1822 os << " - capacity: " << std::dec << map->Capacity() << "\n";
1823 JSObject::Dump(os);
1824
1825 os << " <NameDictionary[" << map->NumberOfElements() << "]>\n";
1826 map->Dump(os);
1827 }
1828
Dump(std::ostream &os) const1829 void JSAPITreeMap::Dump(std::ostream &os) const
1830 {
1831 TaggedTreeMap *map = TaggedTreeMap::Cast(GetTreeMap().GetTaggedObject());
1832 os << " - elements: " << std::dec << map->NumberOfElements() << "\n";
1833 os << " - deleted-elements: " << std::dec << map->NumberOfDeletedElements() << "\n";
1834 os << " - capacity: " << std::dec << map->Capacity() << "\n";
1835 JSObject::Dump(os);
1836
1837 os << " <TaggedTree[" << map->NumberOfElements() << "]>\n";
1838 map->Dump(os);
1839 }
1840
DumpForSnapshot(std::vector<Reference> &vec) const1841 void JSAPITreeMap::DumpForSnapshot(std::vector<Reference> &vec) const
1842 {
1843 if (!(GetTreeMap().IsInvalidValue())) {
1844 TaggedTreeMap *map = TaggedTreeMap::Cast(GetTreeMap().GetTaggedObject());
1845 vec.emplace_back("treemap", GetTreeMap());
1846 map->DumpForSnapshot(vec);
1847 }
1848
1849 JSObject::DumpForSnapshot(vec);
1850 }
1851
Dump(std::ostream &os) const1852 void JSAPITreeMapIterator::Dump(std::ostream &os) const
1853 {
1854 TaggedTreeMap *map =
1855 TaggedTreeMap::Cast(JSAPITreeMap::Cast(GetIteratedMap().GetTaggedObject())->GetTreeMap().GetTaggedObject());
1856 os << " - elements: " << std::dec << map->NumberOfElements() << "\n";
1857 os << " - deleted-elements: " << std::dec << map->NumberOfDeletedElements() << "\n";
1858 os << " - capacity: " << std::dec << map->Capacity() << "\n";
1859 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
1860 os << " - IterationKind: " << std::dec << static_cast<int>(GetIterationKind()) << "\n";
1861 JSObject::Dump(os);
1862
1863 os << " <TaggedTree[" << map->NumberOfElements() << "]>\n";
1864 map->Dump(os);
1865 }
1866
DumpForSnapshot(std::vector<Reference> &vec) const1867 void JSAPITreeMapIterator::DumpForSnapshot(std::vector<Reference> &vec) const
1868 {
1869 if (!(GetIteratedMap().IsInvalidValue())) {
1870 TaggedTreeMap *map =
1871 TaggedTreeMap::Cast(JSAPITreeMap::Cast(GetIteratedMap().GetTaggedObject())->GetTreeMap().GetTaggedObject());
1872 vec.emplace_back("iteratedmap", GetIteratedMap());
1873 map->DumpForSnapshot(vec);
1874 }
1875
1876 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
1877 vec.emplace_back(CString("IterationKind"), JSTaggedValue(static_cast<int>(GetIterationKind())));
1878 JSObject::DumpForSnapshot(vec);
1879 }
1880
1881 template <typename T>
DumpTaggedTreeEntry(T tree, std::ostream &os, int index, bool isMap = false)1882 void DumpTaggedTreeEntry(T tree, std::ostream &os, int index, bool isMap = false)
1883 {
1884 DISALLOW_GARBAGE_COLLECTION;
1885 JSTaggedValue parent(tree->GetParent(index));
1886 JSTaggedValue val(tree->GetValue(index));
1887 JSTaggedValue color(static_cast<int>(tree->GetColor(index)));
1888 JSTaggedValue left = tree->GetLeftChild(index);
1889 JSTaggedValue right = tree->GetRightChild(index);
1890 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << "[entry] " << index << ": ";
1891 os << "\n";
1892 if (isMap) {
1893 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << " [key]: {";
1894 JSTaggedValue key(tree->GetKey(index));
1895 key.DumpTaggedValue(os);
1896 os << std::right << "};";
1897 os << "\n";
1898 }
1899 os << std::left << std::setw(DUMP_TYPE_OFFSET) << " [value]: {";
1900 val.DumpTaggedValue(os);
1901 os << std::right << "};";
1902 os << "\n";
1903 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << " [parent]: {";
1904 parent.DumpTaggedValue(os);
1905 os << std::right << "};";
1906 os << "\n";
1907 os << std::left << std::setw(DUMP_TYPE_OFFSET) << " [color]: {";
1908 color.DumpTaggedValue(os);
1909 os << std::right << "};";
1910 os << "\n";
1911 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << " [left]: {";
1912 left.DumpTaggedValue(os);
1913 os << std::right << "}; ";
1914 os << std::left << std::setw(DUMP_TYPE_OFFSET) << " [right]: {";
1915 right.DumpTaggedValue(os);
1916 os << std::right << "};";
1917 os << "\n";
1918 }
Dump(std::ostream &os) const1919 void TaggedTreeMap::Dump(std::ostream &os) const
1920 {
1921 DISALLOW_GARBAGE_COLLECTION;
1922 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << "[Elements]: {";
1923 JSTaggedValue node = TaggedArray::Get(0);
1924 node.DumpTaggedValue(os);
1925 os << std::right << "}" << "\n";
1926 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << "[Delete]: {";
1927 node = TaggedArray::Get(1);
1928 node.DumpTaggedValue(os);
1929 os << std::right << "}" << "\n";
1930 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << "[Capacity]: {";
1931 node = TaggedArray::Get(2); // 2 means the three element
1932 node.DumpTaggedValue(os);
1933 os << std::right << "}" << "\n";
1934 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << "[RootNode]: {";
1935 node = TaggedArray::Get(3); // 3 means the three element
1936 node.DumpTaggedValue(os);
1937 os << std::right << "}" << "\n";
1938
1939 uint32_t capacity = NumberOfElements() + NumberOfDeletedElements();
1940 for (uint32_t index = 0; index < capacity; index++) {
1941 if (GetKey(index).IsHole()) {
1942 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << "[entry] " << index << ": ";
1943 GetKey(index).DumpTaggedValue(os);
1944 os << "\n";
1945 } else {
1946 DumpTaggedTreeEntry(const_cast<TaggedTreeMap *>(this), os, index, true);
1947 }
1948 }
1949 }
1950
Dump(std::ostream &os) const1951 void JSAPITreeSet::Dump(std::ostream &os) const
1952 {
1953 TaggedTreeSet *set = TaggedTreeSet::Cast(GetTreeSet().GetTaggedObject());
1954 os << " - elements: " << std::dec << set->NumberOfElements() << "\n";
1955 os << " - deleted-elements: " << std::dec << set->NumberOfDeletedElements() << "\n";
1956 os << " - capacity: " << std::dec << set->Capacity() << "\n";
1957 JSObject::Dump(os);
1958
1959 os << " <TaggedTree[" << set->NumberOfElements() << "]>\n";
1960 set->Dump(os);
1961 }
1962
DumpForSnapshot(std::vector<Reference> &vec) const1963 void JSAPITreeSet::DumpForSnapshot(std::vector<Reference> &vec) const
1964 {
1965 if (!(GetTreeSet().IsInvalidValue())) {
1966 TaggedTreeSet *set = TaggedTreeSet::Cast(GetTreeSet().GetTaggedObject());
1967 vec.emplace_back("treeset", GetTreeSet());
1968 set->DumpForSnapshot(vec);
1969 }
1970
1971 JSObject::DumpForSnapshot(vec);
1972 }
1973
Dump(std::ostream &os) const1974 void JSAPITreeSetIterator::Dump(std::ostream &os) const
1975 {
1976 TaggedTreeSet *set =
1977 TaggedTreeSet::Cast(JSAPITreeSet::Cast(GetIteratedSet().GetTaggedObject())->GetTreeSet().GetTaggedObject());
1978 os << " - elements: " << std::dec << set->NumberOfElements() << "\n";
1979 os << " - deleted-elements: " << std::dec << set->NumberOfDeletedElements() << "\n";
1980 os << " - capacity: " << std::dec << set->Capacity() << "\n";
1981 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
1982 os << " - IterationKind: " << std::dec << static_cast<int>(GetIterationKind()) << "\n";
1983 JSObject::Dump(os);
1984
1985 os << " <TaggedTree[" << set->NumberOfElements() << "]>\n";
1986 set->Dump(os);
1987 }
1988
DumpForSnapshot(std::vector<Reference> &vec) const1989 void JSAPITreeSetIterator::DumpForSnapshot(std::vector<Reference> &vec) const
1990 {
1991 if (!(GetIteratedSet().IsInvalidValue())) {
1992 TaggedTreeSet *set =
1993 TaggedTreeSet::Cast(JSAPITreeSet::Cast(GetIteratedSet().GetTaggedObject())->GetTreeSet().GetTaggedObject());
1994 vec.emplace_back("iteratedset", GetIteratedSet());
1995 set->DumpForSnapshot(vec);
1996 }
1997
1998 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
1999 vec.emplace_back(CString("IterationKind"), JSTaggedValue(static_cast<int>(GetIterationKind())));
2000 JSObject::DumpForSnapshot(vec);
2001 }
2002
Dump(std::ostream &os) const2003 void TaggedTreeSet::Dump(std::ostream &os) const
2004 {
2005 DISALLOW_GARBAGE_COLLECTION;
2006 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << "[Elements]: {";
2007 JSTaggedValue node = TaggedArray::Get(0);
2008 node.DumpTaggedValue(os);
2009 os << std::right << "}" << "\n";
2010 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << "[Delete]: {";
2011 node = TaggedArray::Get(1);
2012 node.DumpTaggedValue(os);
2013 os << std::right << "}" << "\n";
2014 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << "[Capacity]: {";
2015 node = TaggedArray::Get(2); // 2 means the three element
2016 node.DumpTaggedValue(os);
2017 os << std::right << "}" << "\n";
2018 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << "[RootNode]: {";
2019 node = TaggedArray::Get(3); // 3 means the three element
2020 node.DumpTaggedValue(os);
2021 os << std::right << "}" << "\n";
2022
2023 uint32_t capacity = NumberOfElements() + NumberOfDeletedElements();
2024 for (uint32_t index = 0; index < capacity; index++) {
2025 if (GetKey(index).IsHole()) {
2026 os << std::left << std::setw(DUMP_ELEMENT_OFFSET) << "[entry] " << index << ": ";
2027 GetKey(index).DumpTaggedValue(os);
2028 os << "\n";
2029 } else {
2030 DumpTaggedTreeEntry(const_cast<TaggedTreeSet *>(this), os, index);
2031 }
2032 }
2033 }
2034
Dump(std::ostream &os) const2035 void JSAPIPlainArray::Dump(std::ostream &os) const
2036 {
2037 TaggedArray *keys = TaggedArray::Cast(GetKeys().GetTaggedObject());
2038 TaggedArray *values = TaggedArray::Cast(GetValues().GetTaggedObject());
2039 uint32_t len = static_cast<uint32_t>(GetLength());
2040 for (uint32_t i = 0; i < len; i++) {
2041 os << " - keys: ";
2042 keys->Get(i).DumpTaggedValue(os);
2043 os << "\n";
2044 os << " - values: ";
2045 values->Get(i).DumpTaggedValue(os);
2046 os << "\n";
2047 }
2048 os << " - length: " << std::dec << len << "\n";
2049 JSObject::Dump(os);
2050 }
2051
Dump(std::ostream &os) const2052 void JSAPIPlainArrayIterator::Dump(std::ostream &os) const
2053 {
2054 JSAPIPlainArray *array = JSAPIPlainArray::Cast(GetIteratedPlainArray().GetTaggedObject());
2055 os << " - length: " << std::dec << array->GetSize() << "\n";
2056 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2057 JSObject::Dump(os);
2058 }
2059
DumpForSnapshot(std::vector<Reference> &vec) const2060 void JSAPIPlainArrayIterator::DumpForSnapshot(std::vector<Reference> &vec) const
2061 {
2062 if (!(GetIteratedPlainArray().IsInvalidValue())) {
2063 JSAPIPlainArray *array = JSAPIPlainArray::Cast(GetIteratedPlainArray().GetTaggedObject());
2064 vec.emplace_back("iteratedplainarray", GetIteratedPlainArray());
2065 array->DumpForSnapshot(vec);
2066 }
2067
2068 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
2069 JSObject::DumpForSnapshot(vec);
2070 }
2071
Dump(std::ostream &os) const2072 void JSForInIterator::Dump(std::ostream &os) const
2073 {
2074 os << " - Object : ";
2075 GetObject().DumpTaggedValue(os);
2076 os << " - CachedHclass : ";
2077 GetCachedHclass().DumpTaggedValue(os);
2078 os << "\n";
2079 os << " - Keys : ";
2080 GetKeys().DumpTaggedValue(os);
2081 os << "\n";
2082 os << " - Index : " << GetIndex();
2083 os << "\n";
2084 os << " - Length : " << GetLength();
2085 os << "\n";
2086 JSObject::Dump(os);
2087 }
2088
Dump(std::ostream &os) const2089 void JSMapIterator::Dump(std::ostream &os) const
2090 {
2091 LinkedHashMap *map = LinkedHashMap::Cast(GetIteratedMap().GetTaggedObject());
2092 os << " - elements: " << std::dec << map->NumberOfElements() << "\n";
2093 os << " - deleted-elements: " << std::dec << map->NumberOfDeletedElements() << "\n";
2094 os << " - capacity: " << std::dec << map->Capacity() << "\n";
2095 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2096 os << " - IterationKind: " << std::dec << static_cast<int>(GetIterationKind()) << "\n";
2097 JSObject::Dump(os);
2098
2099 os << " <NameDictionary[" << map->NumberOfElements() << "]>\n";
2100 map->Dump(os);
2101 }
2102
Dump(std::ostream &os) const2103 void JSSharedMapIterator::Dump(std::ostream &os) const
2104 {
2105 JSSharedMap *iteratedMap = JSSharedMap::Cast(GetIteratedMap().GetTaggedObject());
2106 LinkedHashMap *map = LinkedHashMap::Cast(iteratedMap->GetLinkedMap().GetTaggedObject());
2107 os << " - elements: " << std::dec << map->NumberOfElements() << "\n";
2108 os << " - deleted-elements: " << std::dec << map->NumberOfDeletedElements() << "\n";
2109 os << " - capacity: " << std::dec << map->Capacity() << "\n";
2110 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2111 os << " - IterationKind: " << std::dec << static_cast<int>(GetIterationKind()) << "\n";
2112 JSObject::Dump(os);
2113
2114 os << " <NameDictionary[" << map->NumberOfElements() << "]>\n";
2115 map->Dump(os);
2116 }
2117
Dump(std::ostream &os) const2118 void JSSet::Dump(std::ostream &os) const
2119 {
2120 LinkedHashSet *set = LinkedHashSet::Cast(GetLinkedSet().GetTaggedObject());
2121 os << " - elements: " << std::dec << set->NumberOfElements() << "\n";
2122 os << " - deleted-elements: " << std::dec << set->NumberOfDeletedElements() << "\n";
2123 os << " - capacity: " << std::dec << set->Capacity() << "\n";
2124 JSObject::Dump(os);
2125
2126 os << " <NameDictionary[" << set->NumberOfElements() << "]>\n";
2127 set->Dump(os);
2128 }
2129
Dump(std::ostream &os) const2130 void JSSharedSet::Dump(std::ostream &os) const
2131 {
2132 LinkedHashSet *set = LinkedHashSet::Cast(GetLinkedSet().GetTaggedObject());
2133 os << " - modRecord: " << std::dec << GetModRecord() << "\n";
2134 os << " - elements: " << std::dec << set->NumberOfElements() << "\n";
2135 os << " - deleted-elements: " << std::dec << set->NumberOfDeletedElements() << "\n";
2136 os << " - capacity: " << std::dec << set->Capacity() << "\n";
2137 JSObject::Dump(os);
2138
2139 os << " <NameDictionary[" << set->NumberOfElements() << "]>\n";
2140 set->Dump(os);
2141 }
2142
Dump(std::ostream &os) const2143 void JSWeakMap::Dump(std::ostream &os) const
2144 {
2145 LinkedHashMap *map = LinkedHashMap::Cast(GetLinkedMap().GetTaggedObject());
2146 os << " - length: " << std::dec << GetSize() << "\n";
2147 os << " - elements: " << std::dec << map->NumberOfElements() << "\n";
2148 os << " - deleted-elements: " << std::dec << map->NumberOfDeletedElements() << "\n";
2149 os << " - capacity: " << std::dec << map->Capacity() << "\n";
2150 JSObject::Dump(os);
2151
2152 os << " <NameDictionary[" << map->NumberOfElements() << "]>\n";
2153 map->Dump(os);
2154 }
2155
Dump(std::ostream &os) const2156 void JSWeakSet::Dump(std::ostream &os) const
2157 {
2158 LinkedHashSet *set = LinkedHashSet::Cast(GetLinkedSet().GetTaggedObject());
2159 os << " - size: " << std::dec << GetSize() << "\n";
2160 os << " - elements: " << std::dec << set->NumberOfElements() << "\n";
2161 os << " - deleted-elements: " << std::dec << set->NumberOfDeletedElements() << "\n";
2162 os << " - capacity: " << std::dec << set->Capacity() << "\n";
2163 JSObject::Dump(os);
2164
2165 os << " <NameDictionary[" << set->NumberOfElements() << "]>\n";
2166 set->Dump(os);
2167 }
2168
Dump(std::ostream &os) const2169 void JSWeakRef::Dump(std::ostream &os) const
2170 {
2171 os << " - WeakObject : ";
2172 GetWeakObject().DumpTaggedValue(os);
2173 os << "\n";
2174 JSObject::Dump(os);
2175 }
2176
Dump(std::ostream &os) const2177 void JSFinalizationRegistry::Dump(std::ostream &os) const
2178 {
2179 os << " - CleanupCallback : ";
2180 GetCleanupCallback().DumpTaggedValue(os);
2181 os << "\n";
2182 os << " - NoUnregister : ";
2183 GetNoUnregister().Dump(os);
2184 os << "\n";
2185 os << " - MaybeUnregister : ";
2186 LinkedHashMap *map = LinkedHashMap::Cast(GetMaybeUnregister().GetTaggedObject());
2187 os << " - elements: " << std::dec << map->NumberOfElements() << "\n";
2188 os << " - deleted-elements: " << std::dec << map->NumberOfDeletedElements() << "\n";
2189 os << " - capacity: " << std::dec << map->Capacity() << "\n";
2190 JSObject::Dump(os);
2191 }
2192
Dump(std::ostream &os) const2193 void CellRecord::Dump(std::ostream &os) const
2194 {
2195 os << " - WeakRefTarget : ";
2196 GetFromWeakRefTarget().DumpTaggedValue(os);
2197 os << "\n";
2198 os << " - HeldValue : ";
2199 GetHeldValue().DumpTaggedValue(os);
2200 os << "\n";
2201 }
2202
Dump(std::ostream &os) const2203 void JSSetIterator::Dump(std::ostream &os) const
2204 {
2205 LinkedHashSet *set = LinkedHashSet::Cast(GetIteratedSet().GetTaggedObject());
2206 os << " - elements: " << std::dec << set->NumberOfElements() << "\n";
2207 os << " - deleted-elements: " << std::dec << set->NumberOfDeletedElements() << "\n";
2208 os << " - capacity: " << std::dec << set->Capacity() << "\n";
2209 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2210 os << " - IterationKind: " << std::dec << static_cast<int>(GetIterationKind()) << "\n";
2211 JSObject::Dump(os);
2212
2213 os << " <NameDictionary[" << set->NumberOfElements() << "]>\n";
2214 set->Dump(os);
2215 }
2216
Dump(std::ostream &os) const2217 void JSSharedSetIterator::Dump(std::ostream &os) const
2218 {
2219 JSSharedSet *iteratedSet = JSSharedSet::Cast(GetIteratedSet().GetTaggedObject());
2220 LinkedHashSet *set = LinkedHashSet::Cast(iteratedSet->GetLinkedSet().GetTaggedObject());
2221 os << " - elements: " << std::dec << set->NumberOfElements() << "\n";
2222 os << " - deleted-elements: " << std::dec << set->NumberOfDeletedElements() << "\n";
2223 os << " - capacity: " << std::dec << set->Capacity() << "\n";
2224 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2225 os << " - IterationKind: " << std::dec << static_cast<int>(GetIterationKind()) << "\n";
2226 JSObject::Dump(os);
2227
2228 os << " <NameDictionary[" << set->NumberOfElements() << "]>\n";
2229 set->Dump(os);
2230 }
2231
Dump(std::ostream &os) const2232 void JSRegExpIterator::Dump(std::ostream &os) const
2233 {
2234 os << " - IteratingRegExp: ";
2235 GetIteratingRegExp().Dump(os);
2236 os << "\n";
2237 os << " - IteratedString: ";
2238 GetIteratedString().Dump(os);
2239 os << "\n";
2240 os << " - Global: " << std::dec << GetGlobal() << "\n";
2241 os << " - Unicode: " << std::dec << GetUnicode() << "\n";
2242 os << " - Done: " << std::dec << GetDone() << "\n";
2243 JSObject::Dump(os);
2244 }
2245
Dump(std::ostream &os) const2246 void JSArray::Dump(std::ostream &os) const
2247 {
2248 os << " - length: " << std::dec << GetArrayLength() << "\n";
2249 JSObject::Dump(os);
2250 }
2251
Dump(std::ostream &os) const2252 void JSSharedArray::Dump(std::ostream &os) const
2253 {
2254 os << " - length: " << std::dec << GetArrayLength() << "\n";
2255 JSObject::Dump(os);
2256 }
2257
Dump(std::ostream &os) const2258 void JSArrayIterator::Dump(std::ostream &os) const
2259 {
2260 JSArray *array = JSArray::Cast(GetIteratedArray().GetTaggedObject());
2261 os << " - length: " << std::dec << array->GetArrayLength() << "\n";
2262 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2263 os << " - IterationKind: " << std::dec << static_cast<int>(GetIterationKind()) << "\n";
2264 JSObject::Dump(os);
2265 }
2266
Dump(std::ostream &os) const2267 void JSSharedArrayIterator::Dump(std::ostream &os) const
2268 {
2269 JSSharedArray *array = JSSharedArray::Cast(GetIteratedArray().GetTaggedObject());
2270 os << " - length: " << std::dec << array->GetArrayLength() << "\n";
2271 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2272 os << " - IterationKind: " << std::dec << static_cast<int>(GetIterationKind()) << "\n";
2273 JSObject::Dump(os);
2274 }
2275
Dump(std::ostream &os) const2276 void JSAPIArrayList::Dump(std::ostream &os) const
2277 {
2278 os << " - length: " << std::dec << GetSize() << "\n";
2279 JSObject::Dump(os);
2280 }
2281
Dump(std::ostream &os) const2282 void JSAPIArrayListIterator::Dump(std::ostream &os) const
2283 {
2284 JSAPIArrayList *arrayList = JSAPIArrayList::Cast(GetIteratedArrayList().GetTaggedObject());
2285 os << " - length: " << std::dec << arrayList->GetSize() << "\n";
2286 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2287 JSObject::Dump(os);
2288 }
2289
Dump(std::ostream &os) const2290 void JSAPIDeque::Dump(std::ostream &os) const
2291 {
2292 os << " - first: " << std::dec << GetFirst() << "\n";
2293 os << " - last: " << std::dec << GetLast() << "\n";
2294 JSObject::Dump(os);
2295 }
2296
Dump(std::ostream &os) const2297 void JSAPIDequeIterator::Dump(std::ostream &os) const
2298 {
2299 JSAPIDeque *deque = JSAPIDeque::Cast(GetIteratedDeque().GetTaggedObject());
2300 os << " - length: " << std::dec << deque->GetSize() << "\n";
2301 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2302 JSObject::Dump(os);
2303 }
2304
Dump(std::ostream &os) const2305 void JSAPILightWeightMap::Dump(std::ostream &os) const
2306 {
2307 uint32_t capacity = GetSize();
2308 os << " - length: " << std::dec << capacity << "\n";
2309 uint32_t i = 0;
2310 TaggedArray *hashArray = TaggedArray::Cast(GetHashes().GetTaggedObject());
2311 TaggedArray *keyArray = TaggedArray::Cast(GetKeys().GetTaggedObject());
2312 TaggedArray *valueArray = TaggedArray::Cast(GetValues().GetTaggedObject());
2313 while (capacity > i) {
2314 os << " hash: ";
2315 hashArray->Get(i).DumpTaggedValue(os);
2316 os << " key: ";
2317 keyArray->Get(i).DumpTaggedValue(os);
2318 os << " value: ";
2319 valueArray->Get(i).DumpTaggedValue(os);
2320 os << "\n";
2321 i++;
2322 }
2323 JSObject::Dump(os);
2324 }
2325
Dump(std::ostream &os) const2326 void JSAPILightWeightMapIterator::Dump(std::ostream &os) const
2327 {
2328 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2329 os << " - IterationKind: " << std::dec << static_cast<int>(GetIterationKind()) << "\n";
2330 JSObject::Dump(os);
2331 }
2332
Dump(std::ostream &os) const2333 void JSAPIHashMap::Dump(std::ostream &os) const
2334 {
2335 TaggedHashArray *hashArray = TaggedHashArray::Cast(GetTable().GetTaggedObject());
2336 os << " - elements: " << std::dec << GetSize() << "\n";
2337 os << " - table capacity: " << std::dec << static_cast<int>(hashArray->GetLength()) << "\n";
2338 JSObject::Dump(os);
2339 }
2340
DumpForSnapshot(std::vector<Reference> &vec) const2341 void JSAPIHashMap::DumpForSnapshot(std::vector<Reference> &vec) const
2342 {
2343 if (!(GetTable().IsInvalidValue())) {
2344 TaggedHashArray *map = TaggedHashArray::Cast(GetTable().GetTaggedObject());
2345 vec.emplace_back("hashmap", GetTable());
2346 map->DumpForSnapshot(vec);
2347 }
2348
2349 JSObject::DumpForSnapshot(vec);
2350 }
2351
Dump(std::ostream &os) const2352 void JSAPIHashSet::Dump(std::ostream &os) const
2353 {
2354 TaggedHashArray *hashArray = TaggedHashArray::Cast(GetTable().GetTaggedObject());
2355 os << " - elements: " << std::dec << GetSize() << "\n";
2356 os << " - table capacity: " << std::dec << static_cast<int>(hashArray->GetLength()) << "\n";
2357 JSObject::Dump(os);
2358 }
2359
DumpForSnapshot(std::vector<Reference> &vec) const2360 void JSAPIHashSet::DumpForSnapshot(std::vector<Reference> &vec) const
2361 {
2362 if (!(GetTable().IsInvalidValue())) {
2363 TaggedHashArray *set = TaggedHashArray::Cast(GetTable().GetTaggedObject());
2364 vec.emplace_back("hashset", GetTable());
2365 set->DumpForSnapshot(vec);
2366 }
2367
2368 JSObject::DumpForSnapshot(vec);
2369 }
2370
Dump(std::ostream &os) const2371 void JSAPIHashMapIterator::Dump(std::ostream &os) const
2372 {
2373 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2374 os << " - IterationKind: " << std::dec << static_cast<int>(GetIterationKind()) << "\n";
2375 JSObject::Dump(os);
2376 }
2377
DumpForSnapshot(std::vector<Reference> &vec) const2378 void JSAPIHashMapIterator::DumpForSnapshot(std::vector<Reference> &vec) const
2379 {
2380 vec.emplace_back(CString("IteratedHashMap"), JSTaggedValue(GetIteratedHashMap()));
2381 vec.emplace_back(CString("TaggedQueue"), JSTaggedValue(GetTaggedQueue()));
2382 vec.emplace_back(CString("CurrentNodeResult"), JSTaggedValue(GetCurrentNodeResult()));
2383 vec.emplace_back(CString("BitField"), JSTaggedValue(GetBitField()));
2384 JSObject::DumpForSnapshot(vec);
2385 }
2386
Dump(std::ostream &os) const2387 void JSAPIHashSetIterator::Dump(std::ostream &os) const
2388 {
2389 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2390 os << " - IterationKind: " << std::dec << static_cast<int>(GetIterationKind()) << "\n";
2391 JSObject::Dump(os);
2392 }
2393
DumpForSnapshot(std::vector<Reference> &vec) const2394 void JSAPIHashSetIterator::DumpForSnapshot(std::vector<Reference> &vec) const
2395 {
2396 JSObject::DumpForSnapshot(vec);
2397 }
2398
Dump(std::ostream &os) const2399 void JSAPILightWeightSet::Dump(std::ostream &os) const
2400 {
2401 TaggedArray *keys = TaggedArray::Cast(GetHashes().GetTaggedObject());
2402 TaggedArray *values = TaggedArray::Cast(GetValues().GetTaggedObject());
2403 uint32_t len = GetLength();
2404 for (uint32_t i = 0; i < len; i++) {
2405 os << " - keys: ";
2406 keys->Get(i).DumpTaggedValue(os);
2407 os << "\n";
2408 os << " - values: ";
2409 values->Get(i).DumpTaggedValue(os);
2410 os << "\n";
2411 }
2412 os << " - length: " << std::dec << len << "\n";
2413 JSObject::Dump(os);
2414 }
2415
Dump(std::ostream &os) const2416 void JSAPILightWeightSetIterator::Dump(std::ostream &os) const
2417 {
2418 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2419 os << " - IterationKind: " << std::dec << static_cast<int>(GetIterationKind()) << "\n";
2420 JSObject::Dump(os);
2421 }
2422
Dump(std::ostream &os) const2423 void JSAPIList::Dump(std::ostream &os) const
2424 {
2425 TaggedSingleList *list = TaggedSingleList::Cast(GetSingleList().GetTaggedObject());
2426 os << " - length: " << std::dec << list->GetCapacityFromTaggedArray() << "\n";
2427 os << " - node num: " << std::dec << list->NumberOfNodes() << "\n";
2428 os << " - delete node num: " << std::dec << list->NumberOfDeletedNodes() << "\n";
2429 os << " - is odered list: " << std::dec << this->IsOrderedList() << "\n";
2430 JSObject::Dump(os);
2431 list->Dump(os);
2432 }
2433
DumpForSnapshot(std::vector<Reference> &vec) const2434 void JSAPIList::DumpForSnapshot(std::vector<Reference> &vec) const
2435 {
2436 if (!(GetSingleList().IsInvalidValue())) {
2437 TaggedSingleList *list = TaggedSingleList::Cast(GetSingleList().GetTaggedObject());
2438 list->DumpForSnapshot(vec);
2439 }
2440 JSObject::DumpForSnapshot(vec);
2441 }
2442
Dump(std::ostream &os) const2443 void JSAPIListIterator::Dump(std::ostream &os) const
2444 {
2445 TaggedSingleList *list = TaggedSingleList::Cast(GetIteratedList().GetTaggedObject());
2446 os << " - length: " << std::dec << list->GetCapacityFromTaggedArray() << "\n";
2447 os << " - node num: " << std::dec << list->NumberOfNodes() << "\n";
2448 os << " - delete node num: " << std::dec << list->NumberOfDeletedNodes() << "\n";
2449 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2450 JSObject::Dump(os);
2451 list->Dump(os);
2452 }
2453
DumpForSnapshot(std::vector<Reference> &vec) const2454 void JSAPIListIterator::DumpForSnapshot(std::vector<Reference> &vec) const
2455 {
2456 if (!(GetIteratedList().IsInvalidValue())) {
2457 TaggedSingleList *list = TaggedSingleList::Cast(GetIteratedList().GetTaggedObject());
2458 vec.emplace_back("iteratedlist", GetIteratedList());
2459 list->DumpForSnapshot(vec);
2460 }
2461 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
2462 JSObject::DumpForSnapshot(vec);
2463 }
2464
Dump(std::ostream &os) const2465 void JSAPILinkedList::Dump(std::ostream &os) const
2466 {
2467 TaggedDoubleList *linkedList = TaggedDoubleList::Cast(GetDoubleList().GetTaggedObject());
2468 os << " - length: " << std::dec << linkedList->GetCapacityFromTaggedArray() << "\n";
2469 os << " - node num: " << std::dec << linkedList->NumberOfNodes() << "\n";
2470 os << " - delete node num: " << std::dec << linkedList->NumberOfDeletedNodes() << "\n";
2471 JSObject::Dump(os);
2472 linkedList->Dump(os);
2473 }
2474
DumpForSnapshot(std::vector<Reference> &vec) const2475 void JSAPILinkedList::DumpForSnapshot(std::vector<Reference> &vec) const
2476 {
2477 if (!(GetDoubleList().IsInvalidValue())) {
2478 TaggedDoubleList *list = TaggedDoubleList::Cast(GetDoubleList().GetTaggedObject());
2479 list->DumpForSnapshot(vec);
2480 }
2481
2482 JSObject::DumpForSnapshot(vec);
2483 }
2484
Dump(std::ostream &os) const2485 void JSAPILinkedListIterator::Dump(std::ostream &os) const
2486 {
2487 TaggedDoubleList *linkedList = TaggedDoubleList::Cast(GetIteratedLinkedList().GetTaggedObject());
2488 os << " - length: " << std::dec << linkedList->GetCapacityFromTaggedArray() << "\n";
2489 os << " - node num: " << std::dec << linkedList->NumberOfNodes() << "\n";
2490 os << " - delete node num: " << std::dec << linkedList->NumberOfDeletedNodes() << "\n";
2491 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2492 JSObject::Dump(os);
2493 linkedList->Dump(os);
2494 }
2495
DumpForSnapshot(std::vector<Reference> &vec) const2496 void JSAPILinkedListIterator::DumpForSnapshot(std::vector<Reference> &vec) const
2497 {
2498 if (!(GetIteratedLinkedList().IsInvalidValue())) {
2499 TaggedDoubleList *linkedList = TaggedDoubleList::Cast(GetIteratedLinkedList().GetTaggedObject());
2500 vec.emplace_back("iteratedlist", GetIteratedLinkedList());
2501 linkedList->DumpForSnapshot(vec);
2502 }
2503
2504 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
2505 JSObject::DumpForSnapshot(vec);
2506 }
2507
Dump(std::ostream &os) const2508 void JSAPIQueue::Dump(std::ostream &os) const
2509 {
2510 os << " - length: " << std::dec << GetSize() << "\n";
2511 os << " - front: " << std::dec << GetFront() << "\n";
2512 os << " - tail: " << std::dec << GetTail() << "\n";
2513 JSObject::Dump(os);
2514 }
2515
Dump(std::ostream &os) const2516 void JSAPIQueueIterator::Dump(std::ostream &os) const
2517 {
2518 JSAPIQueue *queue = JSAPIQueue::Cast(GetIteratedQueue().GetTaggedObject());
2519 os << " - length: " << std::dec << queue->GetSize() << "\n";
2520 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2521 JSObject::Dump(os);
2522 }
2523
Dump(std::ostream &os) const2524 void JSAPIStack::Dump(std::ostream &os) const
2525 {
2526 os << " - top: " << std::dec << GetTop() << "\n";
2527 JSObject::Dump(os);
2528 }
2529
Dump(std::ostream &os) const2530 void JSAPIStackIterator::Dump(std::ostream &os) const
2531 {
2532 JSAPIStack *stack = JSAPIStack::Cast(GetIteratedStack().GetTaggedObject());
2533 os << " - length: " << std::dec << stack->GetSize() << "\n";
2534 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2535 JSObject::Dump(os);
2536 }
2537
Dump(std::ostream &os) const2538 void JSAPIVector::Dump(std::ostream &os) const
2539 {
2540 os << " - length: " << std::dec << GetSize() << "\n";
2541 JSObject::Dump(os);
2542 }
2543
Dump(std::ostream &os) const2544 void JSAPIVectorIterator::Dump(std::ostream &os) const
2545 {
2546 JSAPIVector *vector = JSAPIVector::Cast(GetIteratedVector().GetTaggedObject());
2547 os << " - length: " << std::dec << vector->GetSize() << "\n";
2548 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2549 JSObject::Dump(os);
2550 }
2551
Dump(std::ostream &os) const2552 void JSAPIBitVector::Dump(std::ostream &os) const
2553 {
2554 os << " - length: " << std::dec << GetSize() << "\n";
2555 JSObject::Dump(os);
2556 }
2557
Dump(std::ostream &os) const2558 void JSAPIBitVectorIterator::Dump(std::ostream &os) const
2559 {
2560 JSAPIBitVector *bitVector = JSAPIBitVector::Cast(GetIteratedBitVector().GetTaggedObject());
2561 os << " - length: " << std::dec << bitVector->GetSize() << "\n";
2562 os << " - nextIndex: " << std::dec << GetNextIndex() << "\n";
2563 JSObject::Dump(os);
2564 }
2565
Dump(std::ostream &os) const2566 void JSStringIterator::Dump(std::ostream &os) const
2567 {
2568 EcmaString *str = EcmaString::Cast(GetIteratedString().GetTaggedObject());
2569 os << " - IteratedString: " << EcmaStringAccessor(str).ToCString() << "\n";
2570 os << " - StringIteratorNextIndex: " << std::dec << GetStringIteratorNextIndex() << "\n";
2571 JSObject::Dump(os);
2572 }
Dump(std::ostream &os) const2573 void JSTypedArray::Dump(std::ostream &os) const
2574 {
2575 os << " - viewed-array-buffer: ";
2576 GetViewedArrayBufferOrByteArray().Dump(os);
2577 os << " - typed-array-name: ";
2578 GetTypedArrayName().Dump(os);
2579 os << " - byte-length: " << GetByteLength();
2580 os << " - byte-offset: " << GetByteOffset();
2581 os << " - array-length: " << GetArrayLength();
2582 JSObject::Dump(os);
2583 }
2584
Dump(std::ostream &os) const2585 void JSSharedTypedArray::Dump(std::ostream &os) const
2586 {
2587 os << " - viewed-array-buffer: ";
2588 GetViewedArrayBufferOrByteArray().Dump(os);
2589 os << " - typed-array-name: ";
2590 GetTypedArrayName().Dump(os);
2591 os << " - byte-length: " << GetByteLength();
2592 os << " - byte-offset: " << GetByteOffset();
2593 os << " - array-length: " << GetArrayLength();
2594 JSObject::Dump(os);
2595 }
2596
Dump(std::ostream &os) const2597 void ByteArray::Dump(std::ostream &os) const
2598 {
2599 os << " - array-length: " << GetArrayLength();
2600 os << " - byte-length: " << GetByteLength();
2601 }
2602
Dump(std::ostream &os) const2603 void JSRegExp::Dump(std::ostream &os) const
2604 {
2605 os << "\n";
2606 os << " - ByteCodeBuffer: ";
2607 GetByteCodeBuffer().Dump(os);
2608 os << "\n";
2609 os << " - OriginalSource: ";
2610 GetOriginalSource().Dump(os);
2611 os << "\n";
2612 os << " - OriginalFlags: ";
2613 GetOriginalFlags().Dump(os);
2614 os << "\n";
2615 os << " - GroupName: ";
2616 GetGroupName().Dump(os);
2617 os << "\n";
2618 os << " - Length: " << GetLength();
2619 os << "\n";
2620 JSObject::Dump(os);
2621 }
2622
Dump(std::ostream &os) const2623 void JSProxy::Dump(std::ostream &os) const
2624 {
2625 os << " - Target: ";
2626 os << "\n";
2627 JSObject::Cast(GetTarget().GetTaggedObject())->Dump(os);
2628 os << " - Handler: ";
2629 os << "\n";
2630 JSObject::Cast(GetHandler().GetTaggedObject())->Dump(os);
2631 os << "\n";
2632 }
2633
Dump(std::ostream &os) const2634 void JSSymbol::Dump(std::ostream &os) const
2635 {
2636 os << " - hash-field: " << GetHashField();
2637 os << "\n - flags: " << GetFlags();
2638 os << "\n - description: ";
2639 JSTaggedValue description = GetDescription();
2640 description.Dump(os);
2641 }
2642
Dump(std::ostream &os) const2643 void LexicalEnv::Dump(std::ostream &os) const
2644 {
2645 DumpArrayClass(this, os);
2646 }
2647
Dump(std::ostream &os) const2648 void SendableEnv::Dump(std::ostream &os) const
2649 {
2650 DumpArrayClass(this, os);
2651 }
2652
Dump(std::ostream &os) const2653 void COWTaggedArray::Dump(std::ostream &os) const
2654 {
2655 DumpArrayClass(this, os);
2656 }
2657
Dump(std::ostream &os) const2658 void MutantTaggedArray::Dump(std::ostream &os) const
2659 {
2660 DumpMutantTaggedArray(this, os);
2661 }
2662
Dump(std::ostream &os) const2663 void COWMutantTaggedArray::Dump(std::ostream &os) const
2664 {
2665 DumpCOWMutantTaggedArray(this, os);
2666 }
2667
2668 // NOLINTNEXTLINE(readability-function-size)
Dump(std::ostream &os) const2669 void GlobalEnv::Dump(std::ostream &os) const
2670 {
2671 auto globalConst = GetJSThread()->GlobalConstants();
2672 os << " - ObjectFunction: ";
2673 GetObjectFunction().GetTaggedValue().Dump(os);
2674 os << " - FunctionFunction: ";
2675 GetFunctionFunction().GetTaggedValue().Dump(os);
2676 os << " - NumberFunction: ";
2677 GetNumberFunction().GetTaggedValue().Dump(os);
2678 os << " - BigIntFunction: ";
2679 GetBigIntFunction().GetTaggedValue().Dump(os);
2680 os << " - DateFunction: ";
2681 GetDateFunction().GetTaggedValue().Dump(os);
2682 os << " - BooleanFunction: ";
2683 GetBooleanFunction().GetTaggedValue().Dump(os);
2684 os << " - ErrorFunction: ";
2685 GetErrorFunction().GetTaggedValue().Dump(os);
2686 os << " - ArrayFunction: ";
2687 GetArrayFunction().GetTaggedValue().Dump(os);
2688 os << " - TypedArrayFunction: ";
2689 GetTypedArrayFunction().GetTaggedValue().Dump(os);
2690 os << " - Int8ArrayFunction: ";
2691 GetInt8ArrayFunction().GetTaggedValue().Dump(os);
2692 os << " - Uint8ArrayFunction: ";
2693 GetUint8ArrayFunction().GetTaggedValue().Dump(os);
2694 os << " - Uint8ClampedArrayFunction: ";
2695 GetUint8ClampedArrayFunction().GetTaggedValue().Dump(os);
2696 os << " - Int16ArrayFunction: ";
2697 GetInt16ArrayFunction().GetTaggedValue().Dump(os);
2698 os << " - ArrayBufferFunction: ";
2699 GetArrayBufferFunction().GetTaggedValue().Dump(os);
2700 os << " - SharedArrayBufferFunction: ";
2701 GetSharedArrayBufferFunction().GetTaggedValue().Dump(os);
2702 os << " - SymbolFunction: ";
2703 GetSymbolFunction().GetTaggedValue().Dump(os);
2704 os << " - RangeErrorFunction: ";
2705 GetRangeErrorFunction().GetTaggedValue().Dump(os);
2706 os << " - ReferenceErrorFunction: ";
2707 GetReferenceErrorFunction().GetTaggedValue().Dump(os);
2708 os << " - TypeErrorFunction: ";
2709 GetTypeErrorFunction().GetTaggedValue().Dump(os);
2710 os << " - AggregateErrorFunction: ";
2711 GetAggregateErrorFunction().GetTaggedValue().Dump(os);
2712 os << " - URIErrorFunction: ";
2713 GetURIErrorFunction().GetTaggedValue().Dump(os);
2714 os << " - SyntaxErrorFunction: ";
2715 GetSyntaxErrorFunction().GetTaggedValue().Dump(os);
2716 os << " - EvalErrorFunction: ";
2717 GetEvalErrorFunction().GetTaggedValue().Dump(os);
2718 os << " - OOMErrorFunction: ";
2719 GetOOMErrorFunction().GetTaggedValue().Dump(os);
2720 os << " - TerminationErrorFunction: ";
2721 GetTerminationErrorFunction().GetTaggedValue().Dump(os);
2722 os << " - RegExpFunction: ";
2723 GetRegExpFunction().GetTaggedValue().Dump(os);
2724 os << " - BuiltinsSetFunction: ";
2725 GetBuiltinsSetFunction().GetTaggedValue().Dump(os);
2726 os << " - BuiltinsMapFunction: ";
2727 GetBuiltinsMapFunction().GetTaggedValue().Dump(os);
2728 os << " - BuiltinsWeakSetFunction: ";
2729 GetBuiltinsWeakSetFunction().GetTaggedValue().Dump(os);
2730 os << " - BuiltinsWeakMapFunction: ";
2731 GetBuiltinsWeakMapFunction().GetTaggedValue().Dump(os);
2732 os << " - BuiltinsWeakRefFunction: ";
2733 GetBuiltinsWeakRefFunction().GetTaggedValue().Dump(os);
2734 os << " - BuiltinsFinalizationRegistryFunction: ";
2735 GetBuiltinsFinalizationRegistryFunction().GetTaggedValue().Dump(os);
2736 os << " - MathFunction: ";
2737 GetMathFunction().GetTaggedValue().Dump(os);
2738 os << " - AtomicsFunction: ";
2739 GetAtomicsFunction().GetTaggedValue().Dump(os);
2740 os << " - JsonFunction: ";
2741 GetJsonFunction().GetTaggedValue().Dump(os);
2742 os << " - StringFunction: ";
2743 GetStringFunction().GetTaggedValue().Dump(os);
2744 os << " - ProxyFunction: ";
2745 GetProxyFunction().GetTaggedValue().Dump(os);
2746 os << " - ReflectFunction: ";
2747 GetReflectFunction().GetTaggedValue().Dump(os);
2748 os << " - AsyncFunction: ";
2749 GetAsyncFunction().GetTaggedValue().Dump(os);
2750 os << " - AsyncFunctionPrototype: ";
2751 GetAsyncFunctionPrototype().GetTaggedValue().Dump(os);
2752 os << " - JSGlobalObject: ";
2753 GetJSGlobalObject().GetTaggedValue().Dump(os);
2754 os << " - GlobalPatch: ";
2755 GetGlobalPatch().GetTaggedValue().Dump(os);
2756 os << " - EmptyArray: ";
2757 globalConst->GetEmptyArray().Dump(os);
2758 os << " - EmptyString ";
2759 globalConst->GetEmptyString().Dump(os);
2760 os << " - EmptyTaggedQueue: ";
2761 globalConst->GetEmptyTaggedQueue().Dump(os);
2762 os << " - EmptyProfileTypeInfoCell: ";
2763 globalConst->GetEmptyProfileTypeInfoCell().Dump(os);
2764 os << " - PrototypeString: ";
2765 globalConst->GetPrototypeString().Dump(os);
2766 os << " - HasInstanceSymbol: ";
2767 GetHasInstanceSymbol().GetTaggedValue().Dump(os);
2768 os << " - IsConcatSpreadableSymbol: ";
2769 GetIsConcatSpreadableSymbol().GetTaggedValue().Dump(os);
2770 os << " - ToStringTagSymbol: ";
2771 GetToStringTagSymbol().GetTaggedValue().Dump(os);
2772 os << " - IteratorSymbol: ";
2773 GetIteratorSymbol().GetTaggedValue().Dump(os);
2774 os << " - AsyncIteratorSymbol: ";
2775 GetAsyncIteratorSymbol().GetTaggedValue().Dump(os);
2776 os << " - MatchSymbol: ";
2777 GetMatchSymbol().GetTaggedValue().Dump(os);
2778 os << " - MatchAllSymbol: ";
2779 GetMatchAllSymbol().GetTaggedValue().Dump(os);
2780 os << " - ReplaceSymbol: ";
2781 GetReplaceSymbol().GetTaggedValue().Dump(os);
2782 os << " - SearchSymbol: ";
2783 GetSearchSymbol().GetTaggedValue().Dump(os);
2784 os << " - SpeciesSymbol: ";
2785 GetSpeciesSymbol().GetTaggedValue().Dump(os);
2786 os << " - SplitSymbol: ";
2787 GetSplitSymbol().GetTaggedValue().Dump(os);
2788 os << " - ToPrimitiveSymbol: ";
2789 GetToPrimitiveSymbol().GetTaggedValue().Dump(os);
2790 os << " - UnscopablesSymbol: ";
2791 GetUnscopablesSymbol().GetTaggedValue().Dump(os);
2792 os << " - HoleySymbol: ";
2793 GetHoleySymbol().GetTaggedValue().Dump(os);
2794 os << " - NativeBindingSymbol: ";
2795 GetNativeBindingSymbol().GetTaggedValue().Dump(os);
2796 os << " - ConstructorString: ";
2797 globalConst->GetConstructorString().Dump(os);
2798 os << " - IteratorPrototype: ";
2799 GetIteratorPrototype().GetTaggedValue().Dump(os);
2800 os << " - ForinIteratorPrototype: ";
2801 GetForinIteratorPrototype().GetTaggedValue().Dump(os);
2802 os << " - StringIterator: ";
2803 GetStringIterator().GetTaggedValue().Dump(os);
2804 os << " - MapIteratorPrototype: ";
2805 GetMapIteratorPrototype().GetTaggedValue().Dump(os);
2806 os << " - SetIteratorPrototype: ";
2807 GetSetIteratorPrototype().GetTaggedValue().Dump(os);
2808 os << " - RegExpIteratorPrototype: ";
2809 GetRegExpIteratorPrototype().GetTaggedValue().Dump(os);
2810 os << " - ArrayIteratorPrototype: ";
2811 GetArrayIteratorPrototype().GetTaggedValue().Dump(os);
2812 os << " - StringIteratorPrototype: ";
2813 GetStringIteratorPrototype().GetTaggedValue().Dump(os);
2814 os << " - LengthString: ";
2815 globalConst->GetLengthString().Dump(os);
2816 os << " - ValueString: ";
2817 globalConst->GetValueString().Dump(os);
2818 os << " - WritableString: ";
2819 globalConst->GetWritableString().Dump(os);
2820 os << " - GetString: ";
2821 globalConst->GetGetString().Dump(os);
2822 os << " - SetString: ";
2823 globalConst->GetSetString().Dump(os);
2824 os << " - EnumerableString: ";
2825 globalConst->GetEnumerableString().Dump(os);
2826 os << " - ConfigurableString: ";
2827 globalConst->GetConfigurableString().Dump(os);
2828 os << " - NameString: ";
2829 globalConst->GetNameString().Dump(os);
2830 os << " - ValueOfString: ";
2831 globalConst->GetValueOfString().Dump(os);
2832 os << " - ToStringString: ";
2833 globalConst->GetToStringString().Dump(os);
2834 os << " - ToLocaleStringString: ";
2835 globalConst->GetToLocaleStringString().Dump(os);
2836 os << " - UndefinedString: ";
2837 globalConst->GetUndefinedString().Dump(os);
2838 os << " - NullString: ";
2839 globalConst->GetNullString().Dump(os);
2840 os << " - TrueString: ";
2841 globalConst->GetTrueString().Dump(os);
2842 os << " - FalseString: ";
2843 globalConst->GetFalseString().Dump(os);
2844 os << " - RegisterSymbols: ";
2845 GetRegisterSymbols().GetTaggedValue().Dump(os);
2846 os << " - ThrowTypeError: ";
2847 GetThrowTypeError().GetTaggedValue().Dump(os);
2848 os << " - GetPrototypeOfString: ";
2849 globalConst->GetGetPrototypeOfString().Dump(os);
2850 os << " - SetPrototypeOfString: ";
2851 globalConst->GetSetPrototypeOfString().Dump(os);
2852 os << " - IsExtensibleString: ";
2853 globalConst->GetIsExtensibleString().Dump(os);
2854 os << " - PreventExtensionsString: ";
2855 globalConst->GetPreventExtensionsString().Dump(os);
2856 os << " - GetOwnPropertyDescriptorString: ";
2857 globalConst->GetGetOwnPropertyDescriptorString().Dump(os);
2858 os << " - DefinePropertyString: ";
2859 globalConst->GetDefinePropertyString().Dump(os);
2860 os << " - HasString: ";
2861 globalConst->GetHasString().Dump(os);
2862 os << " - DeletePropertyString: ";
2863 globalConst->GetDeletePropertyString().Dump(os);
2864 os << " - EnumerateString: ";
2865 globalConst->GetEnumerateString().Dump(os);
2866 os << " - OwnKeysString: ";
2867 globalConst->GetOwnKeysString().Dump(os);
2868 os << " - ApplyString: ";
2869 globalConst->GetApplyString().Dump(os);
2870 os << " - ProxyString: ";
2871 globalConst->GetProxyString().Dump(os);
2872 os << " - RevokeString: ";
2873 globalConst->GetRevokeString().Dump(os);
2874 os << " - ProxyConstructString: ";
2875 globalConst->GetProxyConstructString().Dump(os);
2876 os << " - ProxyCallString: ";
2877 globalConst->GetProxyCallString().Dump(os);
2878 os << " - DoneString: ";
2879 globalConst->GetDoneString().Dump(os);
2880 os << " - NegativeZeroString: ";
2881 globalConst->GetNegativeZeroString().Dump(os);
2882 os << " - NextString: ";
2883 globalConst->GetNextString().Dump(os);
2884 os << " - PromiseThenString: ";
2885 globalConst->GetPromiseThenString().Dump(os);
2886 os << " - PromiseFunction: ";
2887 GetPromiseFunction().GetTaggedValue().Dump(os);
2888 os << " - PromiseReactionJob: ";
2889 GetPromiseReactionJob().GetTaggedValue().Dump(os);
2890 os << " - PromiseResolveThenableJob: ";
2891 GetPromiseResolveThenableJob().GetTaggedValue().Dump(os);
2892 os << " - DynamicImportJob: ";
2893 GetDynamicImportJob().GetTaggedValue().Dump(os);
2894 os << " - ScriptJobString: ";
2895 globalConst->GetScriptJobString().Dump(os);
2896 os << " - PromiseString: ";
2897 globalConst->GetPromiseString().Dump(os);
2898 os << " - IdentityString: ";
2899 globalConst->GetIdentityString().Dump(os);
2900 os << " - AsyncFunctionString: ";
2901 globalConst->GetAsyncFunctionString().Dump(os);
2902 os << " - ThrowerString: ";
2903 globalConst->GetThrowerString().Dump(os);
2904 os << " - Undefined: ";
2905 globalConst->GetUndefined().Dump(os);
2906 }
2907
Dump(std::ostream &os) const2908 void JSDataView::Dump(std::ostream &os) const
2909 {
2910 os << " - data-view: ";
2911 GetDataView().Dump(os);
2912 os << " - buffer: ";
2913 GetViewedArrayBuffer().Dump(os);
2914 os << "- byte-length: " << GetByteLength();
2915 os << "\n - byte-offset: " << GetByteOffset();
2916 }
2917
Dump(std::ostream &os) const2918 void JSArrayBuffer::Dump(std::ostream &os) const
2919 {
2920 os << " - byte-length: " << GetArrayBufferByteLength();
2921 os << " - buffer-data: ";
2922 GetArrayBufferData().Dump(os);
2923 os << " - Shared: " << GetShared();
2924 }
2925
Dump(std::ostream &os) const2926 void JSSendableArrayBuffer::Dump(std::ostream &os) const
2927 {
2928 os << " - byte-length: " << GetArrayBufferByteLength();
2929 os << " - buffer-data: ";
2930 GetArrayBufferData().Dump(os);
2931 os << " - Shared: " << GetShared();
2932 }
2933
Dump(std::ostream &os) const2934 void PromiseReaction::Dump(std::ostream &os) const
2935 {
2936 os << " - promise-capability: ";
2937 GetPromiseCapability().Dump(os);
2938 os << " - type: " << static_cast<int>(GetType());
2939 os << " - handler: ";
2940 GetHandler().Dump(os);
2941 }
2942
Dump(std::ostream &os) const2943 void PromiseCapability::Dump(std::ostream &os) const
2944 {
2945 os << " - promise: ";
2946 GetPromise().Dump(os);
2947 os << " - resolve: ";
2948 GetResolve().Dump(os);
2949 os << " - reject: ";
2950 GetReject().Dump(os);
2951 }
2952
Dump(std::ostream &os) const2953 void PromiseIteratorRecord::Dump(std::ostream &os) const
2954 {
2955 os << " - iterator: ";
2956 GetIterator().Dump(os);
2957 os << " - done: " << GetDone();
2958 }
2959
Dump(std::ostream &os) const2960 void PromiseRecord::Dump(std::ostream &os) const
2961 {
2962 os << " - value: ";
2963 GetValue().Dump(os);
2964 }
2965
Dump(std::ostream &os) const2966 void ResolvingFunctionsRecord::Dump(std::ostream &os) const
2967 {
2968 os << " - resolve-function: ";
2969 GetResolveFunction().Dump(os);
2970 os << " - reject-function: ";
2971 GetRejectFunction().Dump(os);
2972 }
2973
Dump(std::ostream &os) const2974 void AsyncGeneratorRequest::Dump(std::ostream &os) const
2975 {
2976 os << " - completion: ";
2977 GetCompletion().Dump(os);
2978 os << " - capability: ";
2979 GetCapability().Dump(os);
2980 }
2981
Dump(std::ostream &os) const2982 void AsyncIteratorRecord::Dump(std::ostream &os) const
2983 {
2984 os << " - completion: ";
2985 GetIterator().Dump(os);
2986 os << " - nextmethod: ";
2987 GetNextMethod().Dump(os);
2988 os << " - done: " << GetDone();
2989 }
2990
Dump(std::ostream &os) const2991 void JSAsyncFromSyncIterator::Dump(std::ostream &os) const
2992 {
2993 os << " - sync-iterator-record: ";
2994 GetSyncIteratorRecord().Dump(os);
2995 JSObject::Dump(os);
2996 }
2997
Dump(std::ostream &os) const2998 void JSAsyncFromSyncIterUnwarpFunction::Dump(std::ostream &os) const
2999 {
3000 os << " - done: " ;
3001 GetDone().Dump(os);
3002 JSObject::Dump(os);
3003 }
3004
Dump(std::ostream &os) const3005 void JSPromise::Dump(std::ostream &os) const
3006 {
3007 os << " - promise-state: " << static_cast<int>(GetPromiseState());
3008 os << "\n - promise-result: ";
3009 GetPromiseResult().Dump(os);
3010 os << " - promise-fulfill-reactions: ";
3011 GetPromiseFulfillReactions().Dump(os);
3012 os << " - promise-reject-reactions: ";
3013 GetPromiseRejectReactions().Dump(os);
3014 os << " - promise-is-handled: " << GetPromiseIsHandled();
3015 JSObject::Dump(os);
3016 }
3017
Dump(std::ostream &os) const3018 void JSPromiseReactionsFunction::Dump(std::ostream &os) const
3019 {
3020 os << " - promise: ";
3021 GetPromise().Dump(os);
3022 os << " - already-resolved: ";
3023 GetAlreadyResolved().Dump(os);
3024 JSObject::Dump(os);
3025 }
3026
Dump(std::ostream &os) const3027 void JSPromiseExecutorFunction::Dump(std::ostream &os) const
3028 {
3029 os << " - capability: ";
3030 GetCapability().Dump(os);
3031 JSObject::Dump(os);
3032 }
3033
Dump(std::ostream &os) const3034 void JSAsyncModuleFulfilledFunction::Dump(std::ostream &os) const
3035 {
3036 os << " - module: ";
3037 GetModule().Dump(os);
3038 JSObject::Dump(os);
3039 }
3040
Dump(std::ostream &os) const3041 void JSAsyncModuleRejectedFunction::Dump(std::ostream &os) const
3042 {
3043 os << " - module: ";
3044 GetModule().Dump(os);
3045 JSObject::Dump(os);
3046 }
3047
Dump(std::ostream &os) const3048 void JSPromiseAllResolveElementFunction::Dump(std::ostream &os) const
3049 {
3050 os << " - index: ";
3051 GetIndex().Dump(os);
3052 os << " - values: ";
3053 GetValues().Dump(os);
3054 os << " - capability: ";
3055 GetCapabilities().Dump(os);
3056 os << " - remaining-elements: ";
3057 GetRemainingElements().Dump(os);
3058 os << " - already-called: ";
3059 GetAlreadyCalled().Dump(os);
3060 JSObject::Dump(os);
3061 }
3062
Dump(std::ostream &os) const3063 void JSPromiseAnyRejectElementFunction::Dump(std::ostream &os) const
3064 {
3065 os << " - index: ";
3066 JSTaggedValue(GetIndex()).Dump(os);
3067 os << " - errors: ";
3068 GetErrors().Dump(os);
3069 os << " - capability: ";
3070 GetCapability().Dump(os);
3071 os << " - remaining-elements: ";
3072 GetRemainingElements().Dump(os);
3073 os << " - already-called: ";
3074 GetAlreadyCalled().Dump(os);
3075 JSObject::Dump(os);
3076 }
3077
Dump(std::ostream &os) const3078 void JSPromiseAllSettledElementFunction::Dump(std::ostream &os) const
3079 {
3080 os << " - already-called: ";
3081 GetAlreadyCalled().Dump(os);
3082 os << " - index: ";
3083 JSTaggedValue(GetIndex()).Dump(os);
3084 os << " - values: ";
3085 GetValues().Dump(os);
3086 os << " - capability: ";
3087 GetCapability().Dump(os);
3088 os << " - remaining-elements: ";
3089 GetRemainingElements().Dump(os);
3090 JSObject::Dump(os);
3091 }
3092
Dump(std::ostream &os) const3093 void JSPromiseFinallyFunction::Dump(std::ostream &os) const
3094 {
3095 os << " - constructor: ";
3096 GetConstructor().Dump(os);
3097 os << " - onFinally: ";
3098 GetOnFinally().Dump(os);
3099 JSObject::Dump(os);
3100 }
3101
Dump(std::ostream &os) const3102 void JSPromiseValueThunkOrThrowerFunction::Dump(std::ostream &os) const
3103 {
3104 os << " - result: ";
3105 GetResult().Dump(os);
3106 JSObject::Dump(os);
3107 }
3108
Dump(std::ostream &os) const3109 void JSAsyncGeneratorResNextRetProRstFtn::Dump(std::ostream &os) const
3110 {
3111 os << " - AsyncGeneratorObject";
3112 GetAsyncGeneratorObject().Dump(os);
3113 JSObject::Dump(os);
3114 }
3115
Dump(std::ostream &os) const3116 void MicroJobQueue::Dump(std::ostream &os) const
3117 {
3118 os << " - promise-job-queue: ";
3119 GetPromiseJobQueue().Dump(os);
3120 os << " - script-job-queue: ";
3121 GetScriptJobQueue().Dump(os);
3122 }
3123
Dump(std::ostream &os) const3124 void PendingJob::Dump(std::ostream &os) const
3125 {
3126 os << " - job: ";
3127 GetJob().Dump(os);
3128 os << "\n";
3129 os << " - arguments: ";
3130 GetArguments().Dump(os);
3131 #if defined(ENABLE_HITRACE)
3132 os << "\n";
3133 os << " - chainId: " << GetChainId();
3134 os << "\n";
3135 os << " - spanId: " << GetSpanId();
3136 os << "\n";
3137 os << " - parentSpanId: " << GetParentSpanId();
3138 os << "\n";
3139 os << " - flags: " << GetFlags();
3140 os << "\n";
3141 #endif
3142 }
3143
Dump(std::ostream &os) const3144 void CompletionRecord::Dump(std::ostream &os) const
3145 {
3146 os << " - type: " << static_cast<int>(GetType());
3147 os << " - value: ";
3148 GetValue().Dump(os);
3149 }
3150
Dump(std::ostream &os) const3151 void JSProxyRevocFunction::Dump(std::ostream &os) const
3152 {
3153 os << " - RevocableProxy: ";
3154 os << "\n";
3155 GetRevocableProxy().Dump(os);
3156 os << "\n";
3157 }
3158
Dump(std::ostream &os) const3159 void JSAsyncFunction::Dump(std::ostream &os) const
3160 {
3161 JSFunction::Dump(os);
3162 }
3163
Dump(std::ostream &os) const3164 void JSAsyncAwaitStatusFunction::Dump(std::ostream &os) const
3165 {
3166 os << " - AsyncContext: ";
3167 os << "\n";
3168 GetAsyncContext().Dump(os);
3169 os << "\n";
3170 }
3171
Dump(std::ostream &os) const3172 void JSGeneratorFunction::Dump(std::ostream &os) const
3173 {
3174 JSFunction::Dump(os);
3175 }
3176
Dump(std::ostream &os) const3177 void JSAsyncGeneratorFunction::Dump(std::ostream &os) const
3178 {
3179 JSFunction::Dump(os);
3180 }
3181
Dump(std::ostream &os) const3182 void JSIntlBoundFunction::Dump(std::ostream &os) const
3183 {
3184 JSObject::Dump(os);
3185 }
3186
Dump(std::ostream &os) const3187 void PropertyBox::Dump(std::ostream &os) const
3188 {
3189 os << " - Value: ";
3190 GetValue().Dump(os);
3191 os << "\n";
3192 }
3193
Dump(std::ostream &os) const3194 void PrototypeHandler::Dump(std::ostream &os) const
3195 {
3196 os << " - HandlerInfo: ";
3197 GetHandlerInfo().Dump(os);
3198 os << "\n";
3199 os << " - ProtoCell: ";
3200 GetHandlerInfo().Dump(os);
3201 os << "\n";
3202 os << " - Holder: ";
3203 GetHandlerInfo().Dump(os);
3204 os << "\n";
3205 }
3206
Dump(std::ostream &os) const3207 void TransitionHandler::Dump(std::ostream &os) const
3208 {
3209 os << " - HandlerInfo: ";
3210 GetHandlerInfo().Dump(os);
3211 os << "\n";
3212 os << " - TransitionHClass: ";
3213 GetTransitionHClass().Dump(os);
3214 os << "\n";
3215 }
3216
Dump(std::ostream &os) const3217 void TransWithProtoHandler::Dump(std::ostream &os) const
3218 {
3219 os << " - HandlerInfo: ";
3220 GetHandlerInfo().Dump(os);
3221 os << "\n";
3222 os << " - TransitionHClass: ";
3223 GetTransitionHClass().Dump(os);
3224 os << "\n";
3225 os << " - Holder: ";
3226 GetHandlerInfo().Dump(os);
3227 os << "\n";
3228 }
3229
Dump(std::ostream &os) const3230 void StoreTSHandler::Dump(std::ostream &os) const
3231 {
3232 os << " - HandlerInfo: ";
3233 GetHandlerInfo().Dump(os);
3234 os << "\n";
3235 os << " - ProtoCell: ";
3236 GetHandlerInfo().Dump(os);
3237 os << "\n";
3238 os << " - Holder: ";
3239 GetHandlerInfo().Dump(os);
3240 os << "\n";
3241 }
3242
Dump(std::ostream &os) const3243 void JSRealm::Dump(std::ostream &os) const
3244 {
3245 os << " - Value: ";
3246 GetValue().Dump(os);
3247 os << "\n";
3248 os << " - GlobalEnv: ";
3249 GetGlobalEnv().Dump(os);
3250 os << "\n";
3251 JSObject::Dump(os);
3252 }
3253 #ifdef ARK_SUPPORT_INTL
Dump(std::ostream &os) const3254 void JSIntl::Dump(std::ostream &os) const
3255 {
3256 os << " - FallbackSymbol: ";
3257 GetFallbackSymbol().Dump(os);
3258 os << "\n";
3259 JSObject::Dump(os);
3260 }
3261
Dump(std::ostream &os) const3262 void JSLocale::Dump(std::ostream &os) const
3263 {
3264 os << " - IcuField: ";
3265 GetIcuField().Dump(os);
3266 os << "\n";
3267 JSObject::Dump(os);
3268 }
3269
Dump(std::ostream &os) const3270 void JSDateTimeFormat::Dump(std::ostream &os) const
3271 {
3272 os << " - Locale: ";
3273 GetLocale().Dump(os);
3274 os << "\n";
3275 os << " - Calendar: ";
3276 GetCalendar().Dump(os);
3277 os << "\n";
3278 os << " - NumberingSystem: ";
3279 GetNumberingSystem().Dump(os);
3280 os << "\n";
3281 os << " - TimeZone: ";
3282 GetTimeZone().Dump(os);
3283 os << "\n";
3284 os << " - HourCycle: " << static_cast<int>(GetHourCycle());
3285 os << "\n";
3286 os << " - LocaleIcu: ";
3287 GetLocaleIcu().Dump(os);
3288 os << "\n";
3289 os << " - SimpleDateTimeFormatIcu: ";
3290 GetSimpleDateTimeFormatIcu().Dump(os);
3291 os << "\n";
3292 os << " - Iso8601: ";
3293 GetIso8601().Dump(os);
3294 os << "\n";
3295 os << " - DateStyle: " << static_cast<int>(GetDateStyle());
3296 os << "\n";
3297 os << " - TimeStyle: " << static_cast<int>(GetTimeStyle());
3298 os << "\n";
3299 os << " - BoundFormat: ";
3300 GetBoundFormat().Dump(os);
3301 os << "\n";
3302 JSObject::Dump(os);
3303 }
3304
Dump(std::ostream &os) const3305 void JSRelativeTimeFormat::Dump(std::ostream &os) const
3306 {
3307 os << " - Locale: ";
3308 GetLocale().Dump(os);
3309 os << "\n";
3310 os << " - NumberingSystem: ";
3311 GetNumberingSystem().Dump(os);
3312 os << "\n";
3313 os << " - Style: " << static_cast<int>(GetStyle());
3314 os << "\n";
3315 os << " - Numeric: " << static_cast<int>(GetNumeric());
3316 os << "\n";
3317 os << " - IcuField: ";
3318 GetIcuField().Dump(os);
3319 os << "\n";
3320 JSObject::Dump(os);
3321 }
3322
Dump(std::ostream &os) const3323 void JSNumberFormat::Dump(std::ostream &os) const
3324 {
3325 os << " - Locale: ";
3326 GetLocale().Dump(os);
3327 os << "\n" << " - NumberingSystem: ";
3328 GetNumberingSystem().Dump(os);
3329 os << "\n" << " - Style: " << static_cast<int>(GetStyle());
3330 os << "\n" << " - Currency: ";
3331 GetCurrency().Dump(os);
3332 os << "\n" << " - CurrencyDisplay: " << static_cast<int>(GetCurrencyDisplay());
3333 os << "\n" << " - CurrencySign: " << static_cast<int>(GetCurrencySign());
3334 os << "\n" << " - Unit: ";
3335 GetUnit().Dump(os);
3336 os << "\n" << " - UnitDisplay: " << static_cast<int>(GetUnitDisplay());
3337 os << "\n" << " - MinimumIntegerDigits: ";
3338 GetMinimumIntegerDigits().Dump(os);
3339 os << "\n" << " - MinimumFractionDigits: ";
3340 GetMinimumFractionDigits().Dump(os);
3341 os << "\n" << " - MaximumFractionDigits: ";
3342 GetMaximumFractionDigits().Dump(os);
3343 os << "\n" << " - MinimumSignificantDigits: ";
3344 GetMinimumSignificantDigits().Dump(os);
3345 os << "\n" << " - MaximumSignificantDigits: ";
3346 GetMaximumSignificantDigits().Dump(os);
3347 os << "\n" << " - UseGrouping: ";
3348 GetUseGrouping().Dump(os);
3349 os << "\n" << " - RoundingType: " << static_cast<int>(GetRoundingType());
3350 os << "\n" << " - Notation: " << static_cast<int>(GetNotation());
3351 os << "\n" << " - CompactDisplay: " << static_cast<int>(GetCompactDisplay());
3352 os << "\n" << " - SignDisplay: " << static_cast<int>(GetSignDisplay());
3353 os << "\n" << " - BoundFormat: ";
3354 GetBoundFormat().Dump(os);
3355 os << "\n" << " - IcuField: ";
3356 GetIcuField().Dump(os);
3357 os << "\n";
3358 JSObject::Dump(os);
3359 }
3360
Dump(std::ostream &os) const3361 void JSCollator::Dump(std::ostream &os) const
3362 {
3363 os << " - IcuField: ";
3364 GetIcuField().Dump(os);
3365 os << "\n - Locale: ";
3366 GetLocale().Dump(os);
3367 os << "\n - Usage: " << static_cast<int>(GetUsage());
3368 os << "\n - Sensitivity: " << static_cast<int>(GetSensitivity());
3369 os << "\n - IgnorePunctuation: " << GetIgnorePunctuation();
3370 os << "\n - Collation: ";
3371 GetCollation().Dump(os);
3372 os << "\n - Numeric: " << GetNumeric();
3373 os << "\n - CaseFirst: " << static_cast<int>(GetCaseFirst());
3374 os << "\n - BoundCompare: ";
3375 GetBoundCompare().Dump(os);
3376 os << "\n";
3377 JSObject::Dump(os);
3378 }
3379
Dump(std::ostream &os) const3380 void JSPluralRules::Dump(std::ostream &os) const
3381 {
3382 os << " - Locale: ";
3383 GetLocale().Dump(os);
3384 os << "\n";
3385 os << " - Type: " << static_cast<int>(GetType());
3386 os << "\n";
3387 os << " - MinimumIntegerDigits: ";
3388 GetMinimumIntegerDigits().Dump(os);
3389 os << "\n";
3390 os << " - MinimumFractionDigits: ";
3391 GetMinimumFractionDigits().Dump(os);
3392 os << "\n";
3393 os << " - MaximumFractionDigits: ";
3394 GetMaximumFractionDigits().Dump(os);
3395 os << "\n";
3396 os << " - MinimumSignificantDigits: ";
3397 GetMinimumSignificantDigits().Dump(os);
3398 os << "\n";
3399 os << " - MaximumSignificantDigits: ";
3400 GetMaximumSignificantDigits().Dump(os);
3401 os << "\n";
3402 os << " - RoundingType: " << static_cast<int>(GetRoundingType());
3403 os << "\n";
3404 os << " - IcuPR: ";
3405 GetIcuPR().Dump(os);
3406 os << "\n";
3407 os << " - IcuNF: ";
3408 GetIcuNF().Dump(os);
3409 os << "\n";
3410 JSObject::Dump(os);
3411 }
3412
Dump(std::ostream &os) const3413 void JSDisplayNames::Dump(std::ostream &os) const
3414 {
3415 os << " - Locale: ";
3416 GetLocale().Dump(os);
3417 os << "\n";
3418 os << " - Type: "<< static_cast<int>(GetType());
3419 os << "\n";
3420 os << " - Style: "<< static_cast<int>(GetStyle());
3421 os << "\n";
3422 os << " - Fallback: "<< static_cast<int>(GetFallback());
3423 os << "\n";
3424 os << " - IcuLDN: ";
3425 GetIcuLDN().Dump(os);
3426 os << "\n";
3427 JSObject::Dump(os);
3428 }
3429
Dump(std::ostream &os) const3430 void JSSegmenter::Dump(std::ostream &os) const
3431 {
3432 os << " - Locale: ";
3433 GetLocale().Dump(os);
3434 os << "\n";
3435 os << " - Granularity: "<< static_cast<int>(GetGranularity());
3436 os << "\n";
3437 os << " - IcuField: ";
3438 GetIcuField().Dump(os);
3439 os << "\n";
3440 JSObject::Dump(os);
3441 }
3442
Dump(std::ostream &os) const3443 void JSSegments::Dump(std::ostream &os) const
3444 {
3445 os << " - SegmentsString: ";
3446 GetSegmentsString().Dump(os);
3447 os << "\n";
3448 os << " - UnicodeString: ";
3449 GetUnicodeString().Dump(os);
3450 os << "\n";
3451 os << " - Granularity: "<< static_cast<int>(GetGranularity());
3452 os << "\n";
3453 os << " - IcuField: ";
3454 GetIcuField().Dump(os);
3455 os << "\n";
3456 JSObject::Dump(os);
3457 }
3458
Dump(std::ostream &os) const3459 void JSSegmentIterator::Dump(std::ostream &os) const
3460 {
3461 os << " - IteratedString: ";
3462 GetIteratedString().Dump(os);
3463 os << "\n";
3464 os << " - UnicodeString: ";
3465 GetUnicodeString().Dump(os);
3466 os << "\n";
3467 os << " - Granularity: "<< static_cast<int>(GetGranularity());
3468 os << "\n";
3469 os << " - IcuField: ";
3470 GetIcuField().Dump(os);
3471 os << "\n";
3472 JSObject::Dump(os);
3473 }
3474
Dump(std::ostream &os) const3475 void JSListFormat::Dump(std::ostream &os) const
3476 {
3477 os << " - Locale: ";
3478 GetLocale().Dump(os);
3479 os << "\n";
3480 os << " - Type: "<< static_cast<int>(GetType());
3481 os << "\n";
3482 os << " - Style: "<< static_cast<int>(GetStyle());
3483 os << "\n";
3484 os << " - IcuLF: ";
3485 GetIcuLF().Dump(os);
3486 os << "\n";
3487 JSObject::Dump(os);
3488 }
3489 #endif
Dump(std::ostream &os) const3490 void JSGeneratorObject::Dump(std::ostream &os) const
3491 {
3492 os << " - GeneratorContext: ";
3493 GetGeneratorContext().Dump(os);
3494 os << "\n";
3495 os << " - ResumeResult: ";
3496 GetResumeResult().Dump(os);
3497 os << "\n";
3498 os << " - GeneratorState: " << static_cast<uint8_t>(GetGeneratorState());
3499 os << "\n";
3500 os << " - ResumeMode: " << static_cast<uint8_t>(GetResumeMode());
3501 os << "\n";
3502 JSObject::Dump(os);
3503 }
3504
Dump(std::ostream &os) const3505 void JSAsyncGeneratorObject::Dump(std::ostream &os) const
3506 {
3507 os << " - GeneratorContext: ";
3508 GetGeneratorContext().Dump(os);
3509 os << "\n";
3510 os << " - AsyncGeneratorQueue: ";
3511 GetAsyncGeneratorQueue().Dump(os);
3512 os << "\n";
3513 os << " - GeneratorBrand: ";
3514 GetGeneratorBrand().Dump(os);
3515 os << "\n";
3516 os << " - ResumeResult: ";
3517 GetResumeResult().Dump(os);
3518 os << "\n";
3519 os << " - AsyncGeneratorState: " << static_cast<uint8_t>(GetAsyncGeneratorState());
3520 os << "\n";
3521 os << " - ResumeMode: " << static_cast<uint8_t>(GetResumeMode());
3522 os << "\n";
3523 JSObject::Dump(os);
3524 }
3525
Dump(std::ostream &os) const3526 void JSAsyncFuncObject::Dump(std::ostream &os) const
3527 {
3528 os << " - Promise: ";
3529 GetPromise().Dump(os);
3530 os << "\n";
3531 }
3532
Dump(std::ostream &os) const3533 void GeneratorContext::Dump(std::ostream &os) const
3534 {
3535 os << " - RegsArray: ";
3536 GetRegsArray().Dump(os);
3537 os << "\n";
3538 os << " - Method: ";
3539 GetMethod().Dump(os);
3540 os << "\n";
3541 os << " - This: ";
3542 GetThis().Dump(os);
3543 os << "\n";
3544 os << " - Acc: ";
3545 GetAcc().Dump(os);
3546 os << "\n";
3547 os << " - GeneratorObject: ";
3548 GetGeneratorObject().Dump(os);
3549 os << "\n";
3550 os << " - LexicalEnv: ";
3551 GetLexicalEnv().Dump(os);
3552 os << "\n";
3553 os << " - NRegs: " << GetNRegs();
3554 os << "\n";
3555 os << " - BCOffset: " << GetBCOffset();
3556 os << "\n";
3557 }
3558
Dump(std::ostream &os) const3559 void ProtoChangeMarker::Dump(std::ostream &os) const
3560 {
3561 os << " - HasChanged: " << GetHasChanged() << "\n";
3562 os << " - HasAccessorChanged: " << GetAccessorHasChanged() << "\n";
3563 }
3564
Dump(std::ostream &os) const3565 void MarkerCell::Dump(std::ostream &os) const
3566 {
3567 os << " - IsDetectorInvalid: " << GetIsDetectorInvalid() << "\n";
3568 }
3569
Dump(std::ostream &os) const3570 void ProtoChangeDetails::Dump(std::ostream &os) const
3571 {
3572 os << " - ChangeListener: ";
3573 GetChangeListener().Dump(os);
3574 os << " \t- RegisterIndex: " << GetRegisterIndex();
3575 os << "\n";
3576 }
3577
Dump(std::ostream &os) const3578 void TrackInfo::Dump(std::ostream &os) const
3579 {
3580 os << " - ElementsKind: " << static_cast<uint32_t>(GetElementsKind()) << "\n";
3581 os << " - ArrayLength: " << static_cast<uint32_t>(GetArrayLength()) << "\n";
3582 os << " - SpaceFlag: " << static_cast<uint32_t>(GetSpaceFlag()) << "\n";
3583 }
3584
Dump(std::ostream &os) const3585 void MachineCode::Dump(std::ostream &os) const
3586 {
3587 os << " - InstructionSizeInBytes: " << GetInstructionSizeInBytes();
3588 os << "\n";
3589 }
3590
Dump(std::ostream &os) const3591 void ClassInfoExtractor::Dump(std::ostream &os) const
3592 {
3593 os << " - NonStaticKeys: ";
3594 GetNonStaticKeys().Dump(os);
3595 os << "\n";
3596 os << " - NonStaticProperties: ";
3597 GetNonStaticProperties().Dump(os);
3598 os << "\n";
3599 os << " - NonStaticElements: ";
3600 GetNonStaticElements().Dump(os);
3601 os << "\n";
3602 os << " - StaticKeys: ";
3603 GetStaticKeys().Dump(os);
3604 os << "\n";
3605 os << " - StaticProperties: ";
3606 GetStaticProperties().Dump(os);
3607 os << "\n";
3608 os << " - StaticElements: ";
3609 GetStaticElements().Dump(os);
3610 os << "\n";
3611 }
3612
Dump(std::ostream &os) const3613 void SourceTextModule::Dump(std::ostream &os) const
3614 {
3615 os << " - Environment: ";
3616 GetEnvironment().Dump(os);
3617 os << "\n";
3618 os << " - Namespace: ";
3619 GetNamespace().Dump(os);
3620 os << "\n";
3621 os << " - EcmaModuleFilename: ";
3622 os << GetEcmaModuleFilenameString();
3623 os << "\n";
3624 os << " - EcmaModuleRecordName: ";
3625 os << GetEcmaModuleRecordNameString();
3626 os << "\n";
3627 os << " - RequestedModules: ";
3628 GetRequestedModules().Dump(os);
3629 os << "\n";
3630 os << " - ImportEntries: ";
3631 GetImportEntries().Dump(os);
3632 os << "\n";
3633 os << " - LocalExportEntries: ";
3634 GetLocalExportEntries().Dump(os);
3635 os << "\n";
3636 os << " - IndirectExportEntries: ";
3637 GetIndirectExportEntries().Dump(os);
3638 os << "\n";
3639 os << " - StarExportEntries: ";
3640 GetStarExportEntries().Dump(os);
3641 os << "\n";
3642 os << " - Status: ";
3643 os << static_cast<int32_t>(GetStatus());
3644 os << "\n";
3645 os << " - EvaluationError: ";
3646 os << GetEvaluationError();
3647 os << "\n";
3648 os << " - DFSIndex: ";
3649 os << GetDFSIndex();
3650 os << "\n";
3651 os << " - DFSAncestorIndex: ";
3652 os << GetDFSAncestorIndex();
3653 os << "\n";
3654 os << " - NameDictionary: ";
3655 GetNameDictionary().Dump(os);
3656 os << "\n";
3657 os << " - CycleRoot: ";
3658 // avoid infinite dump
3659 if (GetCycleRoot() != JSTaggedValue(this)) {
3660 GetCycleRoot().Dump(os);
3661 } else {
3662 os << "this";
3663 }
3664 os << "\n";
3665 os << " - TopLevelCapability: ";
3666 GetTopLevelCapability().Dump(os);
3667 os << "\n";
3668 os << " - AsyncParentModules: ";
3669 GetAsyncParentModules().Dump(os);
3670 os << "\n";
3671 os << " - SendableEnv: ";
3672 GetSendableEnv().Dump(os);
3673 os << "\n";
3674 os << " - HasTLA: ";
3675 os << GetHasTLA();
3676 os << "\n";
3677 os << " - AsyncEvaluatingOrdinal: ";
3678 os << GetAsyncEvaluatingOrdinal();
3679 os << "\n";
3680 os << " - PendingAsyncDependencies: ";
3681 os << GetPendingAsyncDependencies();
3682 os << "\n";
3683 }
3684
Dump(std::ostream &os) const3685 void ImportEntry::Dump(std::ostream &os) const
3686 {
3687 os << " - ModuleRequest: ";
3688 GetModuleRequest().Dump(os);
3689 os << "\n";
3690 os << " - ImportName: ";
3691 GetImportName().Dump(os);
3692 os << "\n";
3693 os << " - LocalName: ";
3694 GetLocalName().Dump(os);
3695 os << "\n";
3696 }
3697
Dump(std::ostream &os) const3698 void LocalExportEntry::Dump(std::ostream &os) const
3699 {
3700 os << " - ExportName: ";
3701 GetExportName().Dump(os);
3702 os << "\n";
3703 os << " - LocalName: ";
3704 GetLocalName().Dump(os);
3705 os << "\n";
3706 os << " - LocalIndex: " << GetLocalIndex();
3707 os << "\n";
3708 }
3709
Dump(std::ostream &os) const3710 void IndirectExportEntry::Dump(std::ostream &os) const
3711 {
3712 os << " - ExportName: ";
3713 GetExportName().Dump(os);
3714 os << "\n";
3715 os << " - ModuleRequest: ";
3716 GetModuleRequest().Dump(os);
3717 os << "\n";
3718 os << " - ImportName: ";
3719 GetImportName().Dump(os);
3720 os << "\n";
3721 }
3722
Dump(std::ostream &os) const3723 void StarExportEntry::Dump(std::ostream &os) const
3724 {
3725 os << " - ModuleRequest: ";
3726 GetModuleRequest().Dump(os);
3727 os << "\n";
3728 }
3729
Dump(std::ostream &os) const3730 void ResolvedBinding::Dump(std::ostream &os) const
3731 {
3732 os << " - Module: ";
3733 GetModule().Dump(os);
3734 os << "\n";
3735 os << " - BindingName: ";
3736 GetBindingName().Dump(os);
3737 os << "\n";
3738 }
3739
Dump(std::ostream &os) const3740 void ResolvedIndexBinding::Dump(std::ostream &os) const
3741 {
3742 os << " - Module: ";
3743 GetModule().Dump(os);
3744 os << "\n";
3745 os << " - Index: ";
3746 GetIndex();
3747 os << "\n";
3748 }
3749
Dump(std::ostream &os) const3750 void ResolvedRecordIndexBinding::Dump(std::ostream &os) const
3751 {
3752 os << " - Module: ";
3753 GetModuleRecord().Dump(os);
3754 os << "\n";
3755 os << " - AbcFileName: ";
3756 GetAbcFileName().Dump(os);
3757 os << "\n";
3758 os << " - Index: ";
3759 GetIndex();
3760 os << "\n";
3761 }
3762
Dump(std::ostream &os) const3763 void ResolvedRecordBinding::Dump(std::ostream &os) const
3764 {
3765 os << " - Module: ";
3766 GetModuleRecord().Dump(os);
3767 os << "\n";
3768 os << " - BindingName: ";
3769 GetBindingName().Dump(os);
3770 os << "\n";
3771 }
3772
Dump(std::ostream &os) const3773 void ModuleNamespace::Dump(std::ostream &os) const
3774 {
3775 os << " - Exports: ";
3776 GetExports().Dump(os);
3777 os << "\n";
3778 }
3779
Dump(std::ostream &os) const3780 void NativeModuleFailureInfo::Dump(std::ostream &os) const
3781 {
3782 os << " - ArkNativeModuleFailureInfo: ";
3783 GetArkNativeModuleFailureInfo().Dump(os);
3784 os << "\n";
3785 }
3786
Dump(std::ostream &os) const3787 void CjsModule::Dump(std::ostream &os) const
3788 {
3789 os << " - current module path: ";
3790 GetPath().Dump(os);
3791 os << "\n";
3792 os << " - current module filename: ";
3793 GetFilename().Dump(os);
3794 os << "\n";
3795 }
3796
Dump(std::ostream &os) const3797 void CjsRequire::Dump(std::ostream &os) const
3798 {
3799 os << " --- CjsRequire is JSFunction: ";
3800 os << "\n";
3801 }
3802
Dump(std::ostream &os) const3803 void CjsExports::Dump(std::ostream &os) const
3804 {
3805 DISALLOW_GARBAGE_COLLECTION;
3806 JSHClass *jshclass = GetJSHClass();
3807 os << " - hclass: " << std::hex << jshclass << "\n";
3808 os << " - prototype: ";
3809 jshclass->GetPrototype().DumpTaggedValue(os);
3810 os << "\n";
3811
3812 TaggedArray *properties = TaggedArray::Cast(GetProperties().GetTaggedObject());
3813 os << " - properties: " << std::hex << properties;
3814
3815 if (!properties->IsDictionaryMode()) {
3816 JSTaggedValue attrs = jshclass->GetLayout();
3817 if (attrs.IsNull()) {
3818 return;
3819 }
3820
3821 LayoutInfo *layoutInfo = LayoutInfo::Cast(attrs.GetTaggedObject());
3822 int propNumber = static_cast<int>(jshclass->NumberOfProps());
3823 os << " <LayoutInfo[" << std::dec << propNumber << "]>\n";
3824 for (int i = 0; i < propNumber; i++) {
3825 JSTaggedValue key = layoutInfo->GetKey(i);
3826 PropertyAttributes attr = layoutInfo->GetAttr(i);
3827 ASSERT(i == static_cast<int>(attr.GetOffset()));
3828 os << " " << std::right << std::setw(DUMP_PROPERTY_OFFSET);
3829 DumpPropertyKey(key, os);
3830 os << ": (";
3831 JSTaggedValue val;
3832 if (attr.IsInlinedProps()) {
3833 val = GetPropertyInlinedPropsWithRep(i, attr);
3834 } else {
3835 val = properties->Get(i - static_cast<int>(jshclass->GetInlinedProperties()));
3836 }
3837 val.DumpTaggedValue(os);
3838 os << ") ";
3839 DumpAttr(attr, true, os);
3840 os << "\n";
3841 }
3842 } else {
3843 NameDictionary *dict = NameDictionary::Cast(properties);
3844 os << " <NameDictionary[" << std::dec << dict->EntriesCount() << "]>\n";
3845 dict->Dump(os);
3846 }
3847 }
3848
Dump(std::ostream &os) const3849 void JSFunctionBase::Dump(std::ostream &os) const
3850 {
3851 os << " - Method: ";
3852 GetMethod().Dump(os);
3853 os << "\n";
3854 }
3855
Dump(std::ostream &os) const3856 void Method::Dump(std::ostream &os) const
3857 {
3858 os << " - MethodName: ";
3859 os << GetMethodName();
3860 os << "\n";
3861 os << " - ConstantPool: ";
3862 GetConstantPool().Dump(os);
3863 os << "\n";
3864 os << " - FunctionKind: " << static_cast<int>(GetFunctionKind());
3865 os << "\n";
3866 os << " - CodeEntryOrLiteral: " << std::hex << GetCodeEntryOrLiteral() << "\n";
3867 os << "\n";
3868 }
3869
Dump(std::ostream &os) const3870 void ClassLiteral::Dump(std::ostream &os) const
3871 {
3872 os << " - ClassLiteral: ";
3873 os << "\n";
3874 os << " - IsAOTUsed: " << std::boolalpha << GetIsAOTUsed();
3875 os << "\n";
3876 os << " - Array: ";
3877 GetArray().Dump(os);
3878 os << "\n";
3879 }
3880
3881 // ########################################################################################
3882 // Dump for Snapshot
3883 // ########################################################################################
DumpArrayClass(const TaggedArray *arr, std::vector<Reference> &vec)3884 static void DumpArrayClass(const TaggedArray *arr, std::vector<Reference> &vec)
3885 {
3886 DISALLOW_GARBAGE_COLLECTION;
3887 uint32_t len = arr->GetLength();
3888 vec.reserve(vec.size() + len);
3889 for (uint32_t i = 0; i < len; i++) {
3890 JSTaggedValue val(arr->Get(i));
3891 CString str = ToCString(i);
3892 vec.emplace_back(str, val);
3893 }
3894 }
3895
DumpMutantTaggedArrayClass(const MutantTaggedArray *arr, std::vector<Reference> &vec)3896 static void DumpMutantTaggedArrayClass(const MutantTaggedArray *arr, std::vector<Reference> &vec)
3897 {
3898 DISALLOW_GARBAGE_COLLECTION;
3899 uint32_t len = arr->GetLength();
3900 vec.reserve(vec.size() + len);
3901 for (uint32_t i = 0; i < len; i++) {
3902 JSTaggedValue val(arr->Get(i));
3903 CString str = ToCString(i);
3904 vec.emplace_back(str, val);
3905 }
3906 }
3907
DumpCOWMutantTaggedArrayClass(const COWMutantTaggedArray *arr, std::vector<Reference> &vec)3908 static void DumpCOWMutantTaggedArrayClass(const COWMutantTaggedArray *arr, std::vector<Reference> &vec)
3909 {
3910 DISALLOW_GARBAGE_COLLECTION;
3911 uint32_t len = arr->GetLength();
3912 vec.reserve(vec.size() + len);
3913 for (uint32_t i = 0; i < len; i++) {
3914 JSTaggedValue val(arr->Get(i));
3915 CString str = ToCString(i);
3916 vec.emplace_back(str, val);
3917 }
3918 }
3919
DumpElementClass(const TaggedArray *arr, std::vector<Reference> &vec)3920 static void DumpElementClass(const TaggedArray *arr, std::vector<Reference> &vec)
3921 {
3922 DISALLOW_GARBAGE_COLLECTION;
3923 uint32_t len = arr->GetLength();
3924 vec.reserve(vec.size() + len);
3925 for (uint32_t i = 0; i < len; i++) {
3926 JSTaggedValue val(arr->Get(i));
3927 vec.emplace_back(i, val, Reference::ReferenceType::ELEMENT);
3928 }
3929 }
3930
DumpConstantPoolClass(const ConstantPool *arr, std::vector<Reference> &vec)3931 static void DumpConstantPoolClass(const ConstantPool *arr, std::vector<Reference> &vec)
3932 {
3933 DISALLOW_GARBAGE_COLLECTION;
3934 uint32_t len = arr->GetCacheLength();
3935 vec.reserve(vec.size() + len);
3936 for (uint32_t i = 0; i < len; i++) {
3937 JSTaggedValue val(arr->GetObjectFromCache(i));
3938 CString str = ToCString(i);
3939 vec.emplace_back(str, val);
3940 }
3941 }
3942
DumpStringClass([[maybe_unused]] const EcmaString *str, [[maybe_unused]] std::vector<Reference> &vec)3943 static void DumpStringClass([[maybe_unused]] const EcmaString *str, [[maybe_unused]] std::vector<Reference> &vec)
3944 {
3945 // Before EcmaString dump self node, it need not show, so delete.
3946 // If some properties need be shown, add here.
3947 }
3948
DumpObject(TaggedObject *obj, std::vector<Reference> &vec, bool isVmMode)3949 static void DumpObject(TaggedObject *obj, std::vector<Reference> &vec, bool isVmMode)
3950 {
3951 JSTaggedValue objValue(obj);
3952 DISALLOW_GARBAGE_COLLECTION;
3953 auto jsHclass = obj->GetClass();
3954 JSType type = jsHclass->GetObjectType();
3955 vec.emplace_back("hclass", JSTaggedValue(jsHclass));
3956 switch (type) {
3957 case JSType::HCLASS:
3958 JSHClass::Cast(obj)->DumpForSnapshot(vec);
3959 break;
3960 case JSType::TAGGED_ARRAY:
3961 case JSType::TAGGED_DICTIONARY:
3962 case JSType::LEXICAL_ENV:
3963 case JSType::SENDABLE_ENV:
3964 case JSType::COW_TAGGED_ARRAY:
3965 case JSType::AOT_LITERAL_INFO:
3966 DumpArrayClass(TaggedArray::Cast(obj), vec);
3967 break;
3968 case JSType::MUTANT_TAGGED_ARRAY:
3969 DumpMutantTaggedArrayClass(MutantTaggedArray::Cast(obj), vec);
3970 break;
3971 case JSType::COW_MUTANT_TAGGED_ARRAY:
3972 DumpCOWMutantTaggedArrayClass(COWMutantTaggedArray::Cast(obj), vec);
3973 break;
3974 case JSType::CONSTANT_POOL:
3975 DumpConstantPoolClass(ConstantPool::Cast(obj), vec);
3976 break;
3977 case JSType::PROFILE_TYPE_INFO_CELL_0:
3978 case JSType::PROFILE_TYPE_INFO_CELL_1:
3979 case JSType::PROFILE_TYPE_INFO_CELL_N:
3980 ProfileTypeInfoCell::Cast(obj)->DumpForSnapshot(vec);
3981 break;
3982 case JSType::FUNCTION_TEMPLATE:
3983 FunctionTemplate::Cast(obj)->DumpForSnapshot(vec);
3984 break;
3985 case JSType::VTABLE:
3986 VTable::Cast(obj)->DumpForSnapshot(vec);
3987 break;
3988 case JSType::PROFILE_TYPE_INFO:
3989 ProfileTypeInfo::Cast(obj)->DumpForSnapshot(vec);
3990 break;
3991 case JSType::LINE_STRING:
3992 case JSType::CONSTANT_STRING:
3993 case JSType::TREE_STRING:
3994 case JSType::SLICED_STRING:
3995 DumpStringClass(EcmaString::Cast(obj), vec);
3996 break;
3997 case JSType::JS_NATIVE_POINTER:
3998 break;
3999 case JSType::JS_OBJECT:
4000 case JSType::JS_ERROR:
4001 case JSType::JS_EVAL_ERROR:
4002 case JSType::JS_RANGE_ERROR:
4003 case JSType::JS_TYPE_ERROR:
4004 case JSType::JS_AGGREGATE_ERROR:
4005 case JSType::JS_REFERENCE_ERROR:
4006 case JSType::JS_URI_ERROR:
4007 case JSType::JS_SYNTAX_ERROR:
4008 case JSType::JS_OOM_ERROR:
4009 case JSType::JS_TERMINATION_ERROR:
4010 case JSType::JS_ARGUMENTS:
4011 case JSType::JS_GLOBAL_OBJECT:
4012 case JSType::JS_SHARED_OBJECT:
4013 JSObject::Cast(obj)->DumpForSnapshot(vec);
4014 break;
4015 case JSType::JS_FUNCTION_BASE:
4016 case JSType::JS_FUNCTION:
4017 case JSType::JS_SHARED_FUNCTION:
4018 JSFunction::Cast(obj)->DumpForSnapshot(vec);
4019 break;
4020 case JSType::JS_BOUND_FUNCTION:
4021 JSBoundFunction::Cast(obj)->DumpForSnapshot(vec);
4022 break;
4023 case JSType::JS_SET:
4024 JSSet::Cast(obj)->DumpForSnapshot(vec);
4025 break;
4026 case JSType::JS_SHARED_SET:
4027 JSSharedSet::Cast(obj)->DumpForSnapshot(vec);
4028 break;
4029 case JSType::JS_MAP:
4030 JSMap::Cast(obj)->DumpForSnapshot(vec);
4031 break;
4032 case JSType::JS_SHARED_MAP:
4033 JSSharedMap::Cast(obj)->DumpForSnapshot(vec);
4034 break;
4035 case JSType::JS_WEAK_SET:
4036 JSWeakSet::Cast(obj)->DumpForSnapshot(vec);
4037 break;
4038 case JSType::JS_WEAK_MAP:
4039 JSWeakMap::Cast(obj)->DumpForSnapshot(vec);
4040 break;
4041 case JSType::JS_WEAK_REF:
4042 JSWeakRef::Cast(obj)->DumpForSnapshot(vec);
4043 break;
4044 case JSType::JS_FINALIZATION_REGISTRY:
4045 JSFinalizationRegistry::Cast(obj)->DumpForSnapshot(vec);
4046 break;
4047 case JSType::CELL_RECORD:
4048 CellRecord::Cast(obj)->DumpForSnapshot(vec);
4049 break;
4050 case JSType::JS_REG_EXP:
4051 JSRegExp::Cast(obj)->DumpForSnapshot(vec);
4052 break;
4053 case JSType::JS_DATE:
4054 JSDate::Cast(obj)->DumpForSnapshot(vec);
4055 break;
4056 case JSType::JS_ARRAY:
4057 JSArray::Cast(obj)->DumpForSnapshot(vec);
4058 break;
4059 case JSType::JS_SHARED_ARRAY:
4060 JSSharedArray::Cast(obj)->DumpForSnapshot(vec);
4061 break;
4062 case JSType::JS_TYPED_ARRAY:
4063 case JSType::JS_INT8_ARRAY:
4064 case JSType::JS_UINT8_ARRAY:
4065 case JSType::JS_UINT8_CLAMPED_ARRAY:
4066 case JSType::JS_INT16_ARRAY:
4067 case JSType::JS_UINT16_ARRAY:
4068 case JSType::JS_INT32_ARRAY:
4069 case JSType::JS_UINT32_ARRAY:
4070 case JSType::JS_FLOAT32_ARRAY:
4071 case JSType::JS_FLOAT64_ARRAY:
4072 case JSType::JS_BIGINT64_ARRAY:
4073 case JSType::JS_BIGUINT64_ARRAY:
4074 JSTypedArray::Cast(obj)->DumpForSnapshot(vec);
4075 break;
4076 case JSType::JS_SHARED_TYPED_ARRAY:
4077 case JSType::JS_SHARED_INT8_ARRAY:
4078 case JSType::JS_SHARED_UINT8_ARRAY:
4079 case JSType::JS_SHARED_UINT8_CLAMPED_ARRAY:
4080 case JSType::JS_SHARED_INT16_ARRAY:
4081 case JSType::JS_SHARED_UINT16_ARRAY:
4082 case JSType::JS_SHARED_INT32_ARRAY:
4083 case JSType::JS_SHARED_UINT32_ARRAY:
4084 case JSType::JS_SHARED_FLOAT32_ARRAY:
4085 case JSType::JS_SHARED_FLOAT64_ARRAY:
4086 case JSType::JS_SHARED_BIGINT64_ARRAY:
4087 case JSType::JS_SHARED_BIGUINT64_ARRAY:
4088 JSSharedTypedArray::Cast(obj)->DumpForSnapshot(vec);
4089 break;
4090 case JSType::BIGINT:
4091 BigInt::Cast(obj)->DumpForSnapshot(vec);
4092 break;
4093 case JSType::BYTE_ARRAY:
4094 ByteArray::Cast(obj)->DumpForSnapshot(vec);
4095 break;
4096 case JSType::JS_PROXY:
4097 JSProxy::Cast(obj)->DumpForSnapshot(vec);
4098 break;
4099 case JSType::JS_PRIMITIVE_REF:
4100 JSPrimitiveRef::Cast(obj)->DumpForSnapshot(vec);
4101 break;
4102 case JSType::SYMBOL:
4103 JSSymbol::Cast(obj)->DumpForSnapshot(vec);
4104 break;
4105 case JSType::ACCESSOR_DATA:
4106 case JSType::INTERNAL_ACCESSOR:
4107 AccessorData::Cast(obj)->DumpForSnapshot(vec);
4108 break;
4109 case JSType::JS_DATA_VIEW:
4110 JSDataView::Cast(obj)->DumpForSnapshot(vec);
4111 break;
4112 case JSType::PROMISE_REACTIONS:
4113 PromiseReaction::Cast(obj)->DumpForSnapshot(vec);
4114 break;
4115 case JSType::PROMISE_CAPABILITY:
4116 PromiseCapability::Cast(obj)->DumpForSnapshot(vec);
4117 break;
4118 case JSType::PROMISE_ITERATOR_RECORD:
4119 PromiseIteratorRecord::Cast(obj)->DumpForSnapshot(vec);
4120 break;
4121 case JSType::PROMISE_RECORD:
4122 PromiseRecord::Cast(obj)->DumpForSnapshot(vec);
4123 break;
4124 case JSType::RESOLVING_FUNCTIONS_RECORD:
4125 ResolvingFunctionsRecord::Cast(obj)->DumpForSnapshot(vec);
4126 break;
4127 case JSType::JS_PROMISE:
4128 JSPromise::Cast(obj)->DumpForSnapshot(vec);
4129 break;
4130 case JSType::JS_PROMISE_REACTIONS_FUNCTION:
4131 JSPromiseReactionsFunction::Cast(obj)->DumpForSnapshot(vec);
4132 break;
4133 case JSType::JS_PROMISE_EXECUTOR_FUNCTION:
4134 JSPromiseExecutorFunction::Cast(obj)->DumpForSnapshot(vec);
4135 break;
4136 case JSType::JS_ASYNC_MODULE_FULFILLED_FUNCTION:
4137 JSAsyncModuleFulfilledFunction::Cast(obj)->DumpForSnapshot(vec);
4138 break;
4139 case JSType::JS_ASYNC_MODULE_REJECTED_FUNCTION:
4140 JSAsyncModuleRejectedFunction::Cast(obj)->DumpForSnapshot(vec);
4141 break;
4142 case JSType::ASYNC_GENERATOR_REQUEST:
4143 AsyncGeneratorRequest::Cast(obj)->DumpForSnapshot(vec);
4144 break;
4145 case JSType::ASYNC_ITERATOR_RECORD:
4146 AsyncIteratorRecord::Cast(obj)->DumpForSnapshot(vec);
4147 break;
4148 case JSType::JS_ASYNC_FROM_SYNC_ITERATOR:
4149 JSAsyncFromSyncIterator::Cast(obj)->DumpForSnapshot(vec);
4150 break;
4151 case JSType::JS_ASYNC_FROM_SYNC_ITER_UNWARP_FUNCTION:
4152 JSAsyncFromSyncIterUnwarpFunction::Cast(obj)->DumpForSnapshot(vec);
4153 break;
4154 case JSType::JS_PROMISE_ALL_RESOLVE_ELEMENT_FUNCTION:
4155 JSPromiseAllResolveElementFunction::Cast(obj)->DumpForSnapshot(vec);
4156 break;
4157 case JSType::JS_PROMISE_ANY_REJECT_ELEMENT_FUNCTION:
4158 JSPromiseAnyRejectElementFunction::Cast(obj)->DumpForSnapshot(vec);
4159 break;
4160 case JSType::JS_PROMISE_ALL_SETTLED_ELEMENT_FUNCTION:
4161 JSPromiseAllSettledElementFunction::Cast(obj)->DumpForSnapshot(vec);
4162 break;
4163 case JSType::JS_PROMISE_FINALLY_FUNCTION:
4164 JSPromiseFinallyFunction::Cast(obj)->DumpForSnapshot(vec);
4165 break;
4166 case JSType::JS_PROMISE_VALUE_THUNK_OR_THROWER_FUNCTION:
4167 JSPromiseValueThunkOrThrowerFunction::Cast(obj)->DumpForSnapshot(vec);
4168 break;
4169 case JSType::JS_ASYNC_GENERATOR_RESUME_NEXT_RETURN_PROCESSOR_RST_FTN:
4170 JSAsyncGeneratorResNextRetProRstFtn::Cast(obj)->DumpForSnapshot(vec);
4171 break;
4172 case JSType::MICRO_JOB_QUEUE:
4173 MicroJobQueue::Cast(obj)->DumpForSnapshot(vec);
4174 break;
4175 case JSType::PENDING_JOB:
4176 PendingJob::Cast(obj)->DumpForSnapshot(vec);
4177 break;
4178 case JSType::COMPLETION_RECORD:
4179 CompletionRecord::Cast(obj)->DumpForSnapshot(vec);
4180 break;
4181 case JSType::JS_ITERATOR:
4182 case JSType::JS_ASYNCITERATOR:
4183 case JSType::JS_FORIN_ITERATOR:
4184 case JSType::JS_MAP_ITERATOR:
4185 case JSType::JS_SHARED_MAP_ITERATOR:
4186 case JSType::JS_SET_ITERATOR:
4187 case JSType::JS_SHARED_SET_ITERATOR:
4188 case JSType::JS_ARRAY_ITERATOR:
4189 case JSType::JS_SHARED_ARRAY_ITERATOR:
4190 case JSType::JS_STRING_ITERATOR:
4191 case JSType::JS_REG_EXP_ITERATOR:
4192 case JSType::JS_ARRAY_BUFFER:
4193 JSArrayBuffer::Cast(obj)->DumpForSnapshot(vec);
4194 break;
4195 case JSType::JS_SHARED_ARRAY_BUFFER:
4196 JSArrayBuffer::Cast(obj)->DumpForSnapshot(vec);
4197 break;
4198 case JSType::JS_SENDABLE_ARRAY_BUFFER:
4199 JSSendableArrayBuffer::Cast(obj)->DumpForSnapshot(vec);
4200 break;
4201 case JSType::JS_PROXY_REVOC_FUNCTION:
4202 JSProxyRevocFunction::Cast(obj)->DumpForSnapshot(vec);
4203 break;
4204 case JSType::JS_ASYNC_FUNCTION:
4205 case JSType::JS_SHARED_ASYNC_FUNCTION:
4206 JSAsyncFunction::Cast(obj)->DumpForSnapshot(vec);
4207 break;
4208 case JSType::JS_ASYNC_AWAIT_STATUS_FUNCTION:
4209 JSAsyncAwaitStatusFunction::Cast(obj)->DumpForSnapshot(vec);
4210 break;
4211 case JSType::JS_GENERATOR_FUNCTION:
4212 JSGeneratorFunction::Cast(obj)->DumpForSnapshot(vec);
4213 break;
4214 case JSType::JS_ASYNC_GENERATOR_FUNCTION:
4215 JSAsyncGeneratorFunction::Cast(obj)->DumpForSnapshot(vec);
4216 break;
4217 case JSType::JS_INTL_BOUND_FUNCTION:
4218 JSIntlBoundFunction::Cast(obj)->DumpForSnapshot(vec);
4219 break;
4220 case JSType::JS_REALM:
4221 JSRealm::Cast(obj)->DumpForSnapshot(vec);
4222 break;
4223 #ifdef ARK_SUPPORT_INTL
4224 case JSType::JS_INTL:
4225 JSIntl::Cast(obj)->DumpForSnapshot(vec);
4226 break;
4227 case JSType::JS_LOCALE:
4228 JSLocale::Cast(obj)->DumpForSnapshot(vec);
4229 break;
4230 case JSType::JS_DATE_TIME_FORMAT:
4231 JSDateTimeFormat::Cast(obj)->DumpForSnapshot(vec);
4232 break;
4233 case JSType::JS_RELATIVE_TIME_FORMAT:
4234 JSRelativeTimeFormat::Cast(obj)->DumpForSnapshot(vec);
4235 break;
4236 case JSType::JS_NUMBER_FORMAT:
4237 JSNumberFormat::Cast(obj)->DumpForSnapshot(vec);
4238 break;
4239 case JSType::JS_COLLATOR:
4240 JSCollator::Cast(obj)->DumpForSnapshot(vec);
4241 break;
4242 case JSType::JS_PLURAL_RULES:
4243 JSPluralRules::Cast(obj)->DumpForSnapshot(vec);
4244 break;
4245 case JSType::JS_DISPLAYNAMES:
4246 JSDisplayNames::Cast(obj)->DumpForSnapshot(vec);
4247 break;
4248 case JSType::JS_SEGMENTER:
4249 JSSegmenter::Cast(obj)->DumpForSnapshot(vec);
4250 break;
4251 case JSType::JS_SEGMENTS:
4252 JSSegments::Cast(obj)->DumpForSnapshot(vec);
4253 break;
4254 case JSType::JS_SEGMENT_ITERATOR:
4255 JSSegmentIterator::Cast(obj)->DumpForSnapshot(vec);
4256 break;
4257 case JSType::JS_LIST_FORMAT:
4258 JSListFormat::Cast(obj)->DumpForSnapshot(vec);
4259 break;
4260 #else
4261 case JSType::JS_INTL:
4262 case JSType::JS_LOCALE:
4263 case JSType::JS_DATE_TIME_FORMAT:
4264 case JSType::JS_RELATIVE_TIME_FORMAT:
4265 case JSType::JS_NUMBER_FORMAT:
4266 case JSType::JS_COLLATOR:
4267 case JSType::JS_PLURAL_RULES:
4268 case JSType::JS_DISPLAYNAMES:
4269 case JSType::JS_SEGMENTER:
4270 case JSType::JS_SEGMENTS:
4271 case JSType::JS_SEGMENT_ITERATOR:
4272 case JSType::JS_LIST_FORMAT:
4273 break;
4274 #endif
4275 case JSType::JS_CJS_MODULE:
4276 CjsModule::Cast(obj)->DumpForSnapshot(vec);
4277 break;
4278 case JSType::JS_CJS_EXPORTS:
4279 CjsExports::Cast(obj)->DumpForSnapshot(vec);
4280 break;
4281 case JSType::JS_CJS_REQUIRE:
4282 CjsRequire::Cast(obj)->DumpForSnapshot(vec);
4283 break;
4284 case JSType::JS_GENERATOR_OBJECT:
4285 JSGeneratorObject::Cast(obj)->DumpForSnapshot(vec);
4286 break;
4287 case JSType::JS_ASYNC_GENERATOR_OBJECT:
4288 JSAsyncGeneratorObject::Cast(obj)->DumpForSnapshot(vec);
4289 break;
4290 case JSType::JS_ASYNC_FUNC_OBJECT:
4291 JSAsyncFuncObject::Cast(obj)->DumpForSnapshot(vec);
4292 break;
4293 case JSType::JS_GENERATOR_CONTEXT:
4294 GeneratorContext::Cast(obj)->DumpForSnapshot(vec);
4295 break;
4296 case JSType::JS_API_ARRAY_LIST:
4297 JSAPIArrayList::Cast(obj)->DumpForSnapshot(vec);
4298 break;
4299 case JSType::JS_API_ARRAYLIST_ITERATOR:
4300 JSAPIArrayListIterator::Cast(obj)->DumpForSnapshot(vec);
4301 break;
4302 case JSType::LINKED_NODE:
4303 LinkedNode::Cast(obj)->DumpForSnapshot(vec);
4304 break;
4305 case JSType::RB_TREENODE:
4306 break;
4307 case JSType::JS_API_HASH_MAP:
4308 JSAPIHashMap::Cast(obj)->DumpForSnapshot(vec);
4309 break;
4310 case JSType::JS_API_HASH_SET:
4311 JSAPIHashSet::Cast(obj)->DumpForSnapshot(vec);
4312 break;
4313 case JSType::JS_API_HASHMAP_ITERATOR:
4314 JSAPIHashMapIterator::Cast(obj)->DumpForSnapshot(vec);
4315 break;
4316 case JSType::JS_API_HASHSET_ITERATOR:
4317 JSAPIHashSetIterator::Cast(obj)->DumpForSnapshot(vec);
4318 break;
4319 case JSType::JS_API_LIGHT_WEIGHT_MAP:
4320 JSAPILightWeightMap::Cast(obj)->DumpForSnapshot(vec);
4321 break;
4322 case JSType::JS_API_LIGHT_WEIGHT_MAP_ITERATOR:
4323 JSAPILightWeightMapIterator::Cast(obj)->DumpForSnapshot(vec);
4324 break;
4325 case JSType::JS_API_LIGHT_WEIGHT_SET:
4326 JSAPILightWeightSet::Cast(obj)->DumpForSnapshot(vec);
4327 break;
4328 case JSType::JS_API_LIGHT_WEIGHT_SET_ITERATOR:
4329 JSAPILightWeightSetIterator::Cast(obj)->DumpForSnapshot(vec);
4330 break;
4331 case JSType::JS_API_TREE_MAP:
4332 JSAPITreeMap::Cast(obj)->DumpForSnapshot(vec);
4333 break;
4334 case JSType::JS_API_TREE_SET:
4335 JSAPITreeSet::Cast(obj)->DumpForSnapshot(vec);
4336 break;
4337 case JSType::JS_API_TREEMAP_ITERATOR:
4338 JSAPITreeMapIterator::Cast(obj)->DumpForSnapshot(vec);
4339 break;
4340 case JSType::JS_API_TREESET_ITERATOR:
4341 JSAPITreeSetIterator::Cast(obj)->DumpForSnapshot(vec);
4342 break;
4343 case JSType::JS_API_VECTOR:
4344 JSAPIVector::Cast(obj)->DumpForSnapshot(vec);
4345 break;
4346 case JSType::JS_API_VECTOR_ITERATOR:
4347 JSAPIVectorIterator::Cast(obj)->DumpForSnapshot(vec);
4348 break;
4349 case JSType::JS_API_BITVECTOR:
4350 JSAPIBitVector::Cast(obj)->DumpForSnapshot(vec);
4351 break;
4352 case JSType::JS_API_BITVECTOR_ITERATOR:
4353 JSAPIBitVectorIterator::Cast(obj)->DumpForSnapshot(vec);
4354 break;
4355 case JSType::JS_API_QUEUE:
4356 JSAPIQueue::Cast(obj)->DumpForSnapshot(vec);
4357 break;
4358 case JSType::JS_API_QUEUE_ITERATOR:
4359 JSAPIQueueIterator::Cast(obj)->DumpForSnapshot(vec);
4360 break;
4361 case JSType::JS_API_DEQUE:
4362 JSAPIDeque::Cast(obj)->DumpForSnapshot(vec);
4363 break;
4364 case JSType::JS_API_DEQUE_ITERATOR:
4365 JSAPIDequeIterator::Cast(obj)->DumpForSnapshot(vec);
4366 break;
4367 case JSType::JS_API_STACK:
4368 JSAPIStack::Cast(obj)->DumpForSnapshot(vec);
4369 break;
4370 case JSType::JS_API_STACK_ITERATOR:
4371 JSAPIStackIterator::Cast(obj)->DumpForSnapshot(vec);
4372 break;
4373 case JSType::JS_API_LIST:
4374 JSAPIList::Cast(obj)->DumpForSnapshot(vec);
4375 break;
4376 case JSType::JS_API_LINKED_LIST:
4377 JSAPILinkedList::Cast(obj)->DumpForSnapshot(vec);
4378 break;
4379 case JSType::JS_API_LIST_ITERATOR:
4380 JSAPIListIterator::Cast(obj)->DumpForSnapshot(vec);
4381 break;
4382 case JSType::JS_API_LINKED_LIST_ITERATOR:
4383 JSAPILinkedListIterator::Cast(obj)->DumpForSnapshot(vec);
4384 break;
4385 case JSType::SOURCE_TEXT_MODULE_RECORD:
4386 SourceTextModule::Cast(obj)->DumpForSnapshot(vec);
4387 break;
4388 case JSType::IMPORTENTRY_RECORD:
4389 ImportEntry::Cast(obj)->DumpForSnapshot(vec);
4390 break;
4391 case JSType::LOCAL_EXPORTENTRY_RECORD:
4392 LocalExportEntry::Cast(obj)->DumpForSnapshot(vec);
4393 break;
4394 case JSType::INDIRECT_EXPORTENTRY_RECORD:
4395 IndirectExportEntry::Cast(obj)->DumpForSnapshot(vec);
4396 break;
4397 case JSType::STAR_EXPORTENTRY_RECORD:
4398 StarExportEntry::Cast(obj)->DumpForSnapshot(vec);
4399 break;
4400 case JSType::RESOLVEDBINDING_RECORD:
4401 ResolvedBinding::Cast(obj)->DumpForSnapshot(vec);
4402 break;
4403 case JSType::RESOLVEDINDEXBINDING_RECORD:
4404 ResolvedIndexBinding::Cast(obj)->DumpForSnapshot(vec);
4405 break;
4406 case JSType::RESOLVEDRECORDINDEXBINDING_RECORD:
4407 ResolvedRecordIndexBinding::Cast(obj)->DumpForSnapshot(vec);
4408 break;
4409 case JSType::RESOLVEDRECORDBINDING_RECORD:
4410 ResolvedRecordBinding::Cast(obj)->DumpForSnapshot(vec);
4411 break;
4412 case JSType::JS_MODULE_NAMESPACE:
4413 ModuleNamespace::Cast(obj)->DumpForSnapshot(vec);
4414 break;
4415 case JSType::NATIVE_MODULE_FAILURE_INFO:
4416 NativeModuleFailureInfo::Cast(obj)->DumpForSnapshot(vec);
4417 break;
4418 case JSType::JS_API_PLAIN_ARRAY:
4419 JSAPIPlainArray::Cast(obj)->DumpForSnapshot(vec);
4420 break;
4421 case JSType::JS_API_PLAIN_ARRAY_ITERATOR:
4422 JSAPIPlainArrayIterator::Cast(obj)->DumpForSnapshot(vec);
4423 break;
4424 default:
4425 break;
4426 }
4427 if (isVmMode) {
4428 switch (type) {
4429 case JSType::PROPERTY_BOX:
4430 PropertyBox::Cast(obj)->DumpForSnapshot(vec);
4431 break;
4432 case JSType::TEMPLATE_MAP:
4433 DumpArrayClass(TaggedArray::Cast(obj), vec);
4434 break;
4435 case JSType::GLOBAL_ENV:
4436 GlobalEnv::Cast(obj)->DumpForSnapshot(vec);
4437 break;
4438 case JSType::PROTO_CHANGE_MARKER:
4439 ProtoChangeMarker::Cast(obj)->DumpForSnapshot(vec);
4440 break;
4441 case JSType::MARKER_CELL:
4442 MarkerCell::Cast(obj)->DumpForSnapshot(vec);
4443 break;
4444 case JSType::PROTOTYPE_INFO:
4445 ProtoChangeDetails::Cast(obj)->DumpForSnapshot(vec);
4446 break;
4447 case JSType::TRACK_INFO:
4448 TrackInfo::Cast(obj)->DumpForSnapshot(vec);
4449 break;
4450 case JSType::PROGRAM:
4451 Program::Cast(obj)->DumpForSnapshot(vec);
4452 break;
4453 case JSType::MACHINE_CODE_OBJECT:
4454 MachineCode::Cast(obj)->DumpForSnapshot(vec);
4455 break;
4456 case JSType::TRANSITION_HANDLER:
4457 TransitionHandler::Cast(obj)->DumpForSnapshot(vec);
4458 break;
4459 case JSType::TRANS_WITH_PROTO_HANDLER:
4460 TransWithProtoHandler::Cast(obj)->DumpForSnapshot(vec);
4461 break;
4462 case JSType::STORE_TS_HANDLER:
4463 StoreTSHandler::Cast(obj)->DumpForSnapshot(vec);
4464 break;
4465 case JSType::PROTOTYPE_HANDLER:
4466 PrototypeHandler::Cast(obj)->DumpForSnapshot(vec);
4467 break;
4468 case JSType::CLASS_INFO_EXTRACTOR:
4469 ClassInfoExtractor::Cast(obj)->DumpForSnapshot(vec);
4470 break;
4471 case JSType::METHOD:
4472 Method::Cast(obj)->DumpForSnapshot(vec);
4473 break;
4474 case JSType::CLASS_LITERAL:
4475 ClassLiteral::Cast(obj)->DumpForSnapshot(vec);
4476 break;
4477 default:
4478 break;
4479 }
4480 } else {
4481 vec.pop_back();
4482 }
4483 AddAnonymousEdge(obj, vec);
4484 }
4485
EcmaStringToStd(CString &res, EcmaString *str)4486 static inline void EcmaStringToStd(CString &res, EcmaString *str)
4487 {
4488 if (EcmaStringAccessor(str).GetLength() == 0) {
4489 CString emptyStr = "EmptyString";
4490 res.append(emptyStr);
4491 }
4492
4493 CString string = ConvertToString(str);
4494 res.append(string);
4495 }
4496
KeyToStd(CString &res, JSTaggedValue key)4497 static void KeyToStd(CString &res, JSTaggedValue key)
4498 {
4499 if (key.IsInt()) {
4500 res = std::to_string(key.GetInt());
4501 } else if (key.IsDouble()) {
4502 res = std::to_string(key.GetDouble());
4503 } else if (key.IsBoolean()) {
4504 res = key.IsTrue() ? "true" : "false";
4505 } else if (key.IsHeapObject()) {
4506 if (key.IsWeak()) {
4507 key.RemoveWeakTag();
4508 }
4509 if (key.IsString()) {
4510 EcmaStringToStd(res, EcmaString::Cast(key.GetTaggedObject()));
4511 } else if (key.IsSymbol()) {
4512 JSSymbol *sym = JSSymbol::Cast(key.GetTaggedObject());
4513 JSTaggedValue desc = sym->GetDescription();
4514 if (desc.IsString()) {
4515 EcmaStringToStd(res, EcmaString::Cast(desc.GetTaggedObject()));
4516 }
4517 }
4518 }
4519 }
4520
DumpForSnapshot(std::vector<Reference> &vec) const4521 void JSAPIPlainArray::DumpForSnapshot(std::vector<Reference> &vec) const
4522 {
4523 DISALLOW_GARBAGE_COLLECTION;
4524 TaggedArray *keys = TaggedArray::Cast(GetKeys().GetTaggedObject());
4525 TaggedArray *values = TaggedArray::Cast(GetValues().GetTaggedObject());
4526 uint32_t len = static_cast<uint32_t>(GetLength());
4527 vec.reserve(vec.size() + len);
4528 for (uint32_t i = 0; i < len; i++) {
4529 CString str;
4530 KeyToStd(str, keys->Get(i));
4531 vec.emplace_back(str, values->Get(i));
4532 }
4533 JSObject::DumpForSnapshot(vec);
4534 }
4535
DumpForSnapshot(std::vector<Reference> &vec, bool isVmMode) const4536 void JSTaggedValue::DumpForSnapshot(std::vector<Reference> &vec, bool isVmMode) const
4537 {
4538 if (IsHeapObject()) {
4539 return DumpObject(GetTaggedObject(), vec, isVmMode);
4540 }
4541 LOG_ECMA(FATAL) << "this branch is unreachable";
4542 UNREACHABLE();
4543 }
4544
DumpForSnapshot(std::vector<Reference> &vec) const4545 void NumberDictionary::DumpForSnapshot(std::vector<Reference> &vec) const
4546 {
4547 DISALLOW_GARBAGE_COLLECTION;
4548 int size = Size();
4549 vec.reserve(vec.size() + size);
4550 for (int hashIndex = 0; hashIndex < size; hashIndex++) {
4551 JSTaggedValue key(GetKey(hashIndex));
4552 if (!key.IsUndefined() && !key.IsHole() && !key.IsNull()) {
4553 JSTaggedValue val(GetValue(hashIndex));
4554 vec.emplace_back(
4555 static_cast<uint32_t>(JSTaggedNumber(key).GetNumber()), val, Reference::ReferenceType::ELEMENT);
4556 }
4557 }
4558 }
4559
DumpForSnapshot(std::vector<Reference> &vec) const4560 void NameDictionary::DumpForSnapshot(std::vector<Reference> &vec) const
4561 {
4562 DISALLOW_GARBAGE_COLLECTION;
4563 int size = Size();
4564 vec.reserve(vec.size() + size);
4565 for (int hashIndex = 0; hashIndex < size; hashIndex++) {
4566 JSTaggedValue key(GetKey(hashIndex));
4567 if (!key.IsUndefined() && !key.IsHole() && !key.IsNull()) {
4568 JSTaggedValue val(GetValue(hashIndex));
4569 CString str;
4570 KeyToStd(str, key);
4571 vec.emplace_back(str, val);
4572 }
4573 }
4574 }
4575
DumpForSnapshot(std::vector<Reference> &vec) const4576 void GlobalDictionary::DumpForSnapshot(std::vector<Reference> &vec) const
4577 {
4578 DISALLOW_GARBAGE_COLLECTION;
4579 int size = Size();
4580 vec.reserve(vec.size() + size);
4581 for (int hashIndex = 0; hashIndex < size; hashIndex++) {
4582 JSTaggedValue key(GetKey(hashIndex));
4583 if (!key.IsUndefined() && !key.IsHole() && !key.IsNull()) {
4584 CString str;
4585 KeyToStd(str, key);
4586 JSTaggedValue val = GetValue(hashIndex);
4587 vec.emplace_back(str, val);
4588 }
4589 }
4590 }
4591
DumpForSnapshot(std::vector<Reference> &vec) const4592 void LinkedHashSet::DumpForSnapshot(std::vector<Reference> &vec) const
4593 {
4594 DISALLOW_GARBAGE_COLLECTION;
4595 int capacity = NumberOfElements() + NumberOfDeletedElements();
4596 vec.reserve(vec.size() + capacity);
4597 for (int hashIndex = 0; hashIndex < capacity; hashIndex++) {
4598 JSTaggedValue key(GetKey(hashIndex));
4599 if (!key.IsUndefined() && !key.IsHole() && !key.IsNull()) {
4600 CString str;
4601 KeyToStd(str, key);
4602 vec.emplace_back(str, JSTaggedValue::Hole());
4603 }
4604 }
4605 }
4606
DumpForSnapshot(std::vector<Reference> &vec) const4607 void LinkedHashMap::DumpForSnapshot(std::vector<Reference> &vec) const
4608 {
4609 DISALLOW_GARBAGE_COLLECTION;
4610 int capacity = NumberOfElements() + NumberOfDeletedElements();
4611 vec.reserve(vec.size() + capacity);
4612 for (int hashIndex = 0; hashIndex < capacity; hashIndex++) {
4613 JSTaggedValue key(GetKey(hashIndex));
4614 if (!key.IsUndefined() && !key.IsHole() && !key.IsNull()) {
4615 JSTaggedValue val = GetValue(hashIndex);
4616 CString str;
4617 KeyToStd(str, key);
4618 vec.emplace_back(str, val);
4619 }
4620 }
4621 }
4622
Dump(std::ostream &os) const4623 void TaggedHashArray::Dump(std::ostream &os) const
4624 {
4625 DumpArrayClass(this, os);
4626 }
4627
DumpForSnapshot(std::vector<Reference> &vec) const4628 void TaggedHashArray::DumpForSnapshot(std::vector<Reference> &vec) const
4629 {
4630 DISALLOW_GARBAGE_COLLECTION;
4631 int capacity = static_cast<int>(GetLength());
4632 vec.reserve(vec.size() + capacity);
4633 for (int hashIndex = 0; hashIndex < capacity; hashIndex++) {
4634 JSTaggedValue value = Get(hashIndex);
4635 if (!value.IsUndefined() && !value.IsHole() && !value.IsNull()) {
4636 LinkedNode *node = LinkedNode::Cast(value.GetTaggedObject());
4637 node->DumpForSnapshot(vec);
4638 }
4639 }
4640 }
4641
4642 template <typename T>
DumpForSnapshotTaggedTreeEntry(T tree, int index, std::vector<Reference> &vec, bool isMap = false)4643 void DumpForSnapshotTaggedTreeEntry(T tree, int index, std::vector<Reference> &vec, bool isMap = false)
4644 {
4645 DISALLOW_GARBAGE_COLLECTION;
4646 if (isMap) {
4647 vec.emplace_back("key", JSTaggedValue(tree->GetKey(index)));
4648 }
4649 vec.emplace_back("value", JSTaggedValue(tree->GetValue(index)));
4650 vec.emplace_back("parent", JSTaggedValue(tree->GetParent(index)));
4651 vec.emplace_back("color", JSTaggedValue(static_cast<int>(tree->GetColor(index))));
4652 vec.emplace_back("left", tree->GetLeftChild(index));
4653 vec.emplace_back("right", tree->GetRightChild(index));
4654 }
4655
DumpForSnapshot(std::vector<Reference> &vec) const4656 void TaggedTreeMap::DumpForSnapshot(std::vector<Reference> &vec) const
4657 {
4658 DISALLOW_GARBAGE_COLLECTION;
4659 vec.emplace_back("Elements", TaggedArray::Get(NUMBER_OF_ELEMENTS_INDEX));
4660 vec.emplace_back("Delete", TaggedArray::Get(NUMBER_OF_HOLE_ENTRIES_INDEX));
4661 vec.emplace_back("Capacity", TaggedArray::Get(CAPACITY_INDEX));
4662 vec.emplace_back("RootNode", TaggedArray::Get(ROOT_INDEX));
4663 vec.emplace_back("CompareFunction", TaggedArray::Get(COMPARE_FUNCTION_INDEX));
4664 uint32_t capacity = NumberOfElements() + NumberOfDeletedElements();
4665 vec.reserve(vec.size() + capacity);
4666 for (uint32_t index = 0; index < capacity; index++) {
4667 JSTaggedValue key(GetKey(index));
4668 if (!key.IsUndefined() && !key.IsHole() && !key.IsNull()) {
4669 JSTaggedValue val = GetValue(index);
4670 CString str;
4671 KeyToStd(str, key);
4672 vec.emplace_back(str, val);
4673 } else {
4674 DumpForSnapshotTaggedTreeEntry(const_cast<TaggedTreeMap *>(this), index, vec, true);
4675 }
4676 }
4677 }
4678
DumpForSnapshot(std::vector<Reference> &vec) const4679 void TaggedTreeSet::DumpForSnapshot(std::vector<Reference> &vec) const
4680 {
4681 DISALLOW_GARBAGE_COLLECTION;
4682 vec.emplace_back("Elements", TaggedArray::Get(NUMBER_OF_ELEMENTS_INDEX));
4683 vec.emplace_back("Delete", TaggedArray::Get(NUMBER_OF_HOLE_ENTRIES_INDEX));
4684 vec.emplace_back("Capacity", TaggedArray::Get(CAPACITY_INDEX));
4685 vec.emplace_back("RootNode", TaggedArray::Get(ROOT_INDEX));
4686 vec.emplace_back("CompareFunction", TaggedArray::Get(COMPARE_FUNCTION_INDEX));
4687 uint32_t capacity = NumberOfElements() + NumberOfDeletedElements();
4688 vec.reserve(vec.size() + capacity);
4689 for (uint32_t index = 0; index < capacity; index++) {
4690 JSTaggedValue key(GetKey(index));
4691 if (!key.IsUndefined() && !key.IsHole() && !key.IsNull()) {
4692 CString str;
4693 KeyToStd(str, key);
4694 vec.emplace_back(str, JSTaggedValue::Hole());
4695 } else {
4696 DumpForSnapshotTaggedTreeEntry(const_cast<TaggedTreeSet *>(this), index, vec, true);
4697 }
4698 }
4699 }
4700
DumpForSnapshot(std::vector<Reference> &vec) const4701 void TaggedDoubleList::DumpForSnapshot(std::vector<Reference> &vec) const
4702 {
4703 DISALLOW_GARBAGE_COLLECTION;
4704 int capacity = NumberOfNodes();
4705 vec.reserve(vec.size() + capacity);
4706 for (int index = 0; index < capacity; index++) {
4707 JSTaggedValue val = GetElement(index);
4708 CString str;
4709 KeyToStd(str, JSTaggedValue(index));
4710 vec.emplace_back(str, val);
4711 }
4712 }
4713
DumpForSnapshot(std::vector<Reference> &vec) const4714 void TaggedSingleList::DumpForSnapshot(std::vector<Reference> &vec) const
4715 {
4716 DISALLOW_GARBAGE_COLLECTION;
4717 int capacity = NumberOfNodes();
4718 vec.reserve(vec.size() + capacity);
4719 for (int index = 0; index < capacity; index++) {
4720 JSTaggedValue val = GetElement(index);
4721 CString str;
4722 KeyToStd(str, JSTaggedValue(index));
4723 vec.emplace_back(str, val);
4724 }
4725 }
4726
DumpForSnapshot(std::vector<Reference> &vec) const4727 void JSObject::DumpForSnapshot(std::vector<Reference> &vec) const
4728 {
4729 DISALLOW_GARBAGE_COLLECTION;
4730 JSHClass *jshclass = GetJSHClass();
4731 if (jshclass != nullptr) {
4732 vec.emplace_back(CString("__proto__"), jshclass->GetPrototype());
4733 }
4734 vec.emplace_back(CString("ArkInternalHash"), JSTaggedValue(GetHash()));
4735
4736 TaggedArray *elements = TaggedArray::Cast(GetElements().GetTaggedObject());
4737 vec.emplace_back("(object elements)", JSTaggedValue(elements));
4738 if (elements->GetLength() == 0) {
4739 } else if (!elements->IsDictionaryMode()) {
4740 DumpElementClass(elements, vec);
4741 } else {
4742 NumberDictionary *dict = NumberDictionary::Cast(elements);
4743 dict->DumpForSnapshot(vec);
4744 }
4745
4746 TaggedArray *properties = TaggedArray::Cast(GetProperties().GetTaggedObject());
4747 if (IsJSGlobalObject()) {
4748 GlobalDictionary *dict = GlobalDictionary::Cast(properties);
4749 dict->DumpForSnapshot(vec);
4750 return;
4751 }
4752 vec.emplace_back("(object properties)", JSTaggedValue(properties));
4753 if ((!properties->IsDictionaryMode()) && (jshclass != nullptr)) {
4754 JSTaggedValue attrs = jshclass->GetLayout();
4755 if (attrs.IsNull()) {
4756 return;
4757 }
4758
4759 LayoutInfo *layoutInfo = LayoutInfo::Cast(attrs.GetTaggedObject());
4760 int propNumber = static_cast<int>(jshclass->NumberOfProps());
4761 vec.reserve(vec.size() + propNumber);
4762 for (int i = 0; i < propNumber; i++) {
4763 JSTaggedValue key = layoutInfo->GetKey(i);
4764 PropertyAttributes attr = layoutInfo->GetAttr(i);
4765 ASSERT(i == static_cast<int>(attr.GetOffset()));
4766 JSTaggedValue val;
4767 if (attr.IsInlinedProps()) {
4768 val = GetPropertyInlinedPropsWithRep(i, attr);
4769 } else {
4770 val = properties->Get(i - static_cast<int>(jshclass->GetInlinedProperties()));
4771 }
4772
4773 CString str;
4774 KeyToStd(str, key);
4775 vec.emplace_back(str, val);
4776 }
4777 } else {
4778 NameDictionary *dict = NameDictionary::Cast(properties);
4779 dict->DumpForSnapshot(vec);
4780 }
4781 }
4782
DumpForSnapshot([[maybe_unused]] std::vector<Reference> &vec) const4783 void JSHClass::DumpForSnapshot([[maybe_unused]] std::vector<Reference> &vec) const
4784 {
4785 vec.emplace_back(CString("__proto__"), GetPrototype());
4786 vec.emplace_back(CString("Layout"), GetLayout());
4787 vec.emplace_back(CString("Transitions"), GetTransitions());
4788 vec.emplace_back(CString("Parent"), GetParent());
4789 vec.emplace_back(CString("ProtoChangeMarker"), GetProtoChangeMarker());
4790 vec.emplace_back(CString("ProtoChangeDetails"), GetProtoChangeDetails());
4791 vec.emplace_back(CString("EnumCache"), GetEnumCache());
4792 vec.emplace_back(CString("BitField"), JSTaggedValue(GetBitField()));
4793 vec.emplace_back(CString("BitField1"), JSTaggedValue(GetBitField1()));
4794 }
4795
DumpForSnapshot(std::vector<Reference> &vec) const4796 void JSFunction::DumpForSnapshot(std::vector<Reference> &vec) const
4797 {
4798 vec.emplace_back(CString("ProtoOrHClass"), GetProtoOrHClass());
4799 vec.emplace_back(CString("LexicalEnv"), GetLexicalEnv());
4800 vec.emplace_back(CString("RawProfileTypeInfo"), GetRawProfileTypeInfo());
4801 vec.emplace_back(CString("HomeObject"), GetHomeObject());
4802 vec.emplace_back(CString("Module"), GetModule());
4803 vec.emplace_back(CString("ProtoTransRootHClass"), GetProtoTransRootHClass());
4804 vec.emplace_back(CString("Method"), GetMethod());
4805 if ((!GetMethod().IsNull()) && (!GetMethod().IsUndefined())) {
4806 vec.emplace_back(CString("FunctionKind"), JSTaggedValue(static_cast<int>(GetFunctionKind())));
4807 }
4808 vec.emplace_back(CString("FunctionExtraInfo"), GetFunctionExtraInfo());
4809 vec.emplace_back(CString("Method"), GetMethod());
4810 JSObject::DumpForSnapshot(vec);
4811 }
4812
DumpForSnapshot(std::vector<Reference> &vec) const4813 void Method::DumpForSnapshot(std::vector<Reference> &vec) const
4814 {
4815 vec.emplace_back(CString("MethodName"), JSTaggedValue(GetMethodName()));
4816 vec.emplace_back(CString("ConstantPool"), GetConstantPool());
4817 }
4818
DumpForSnapshot(std::vector<Reference> &vec) const4819 void Program::DumpForSnapshot(std::vector<Reference> &vec) const
4820 {
4821 vec.emplace_back(CString("MainFunction"), GetMainFunction());
4822 }
4823
DumpForSnapshot(std::vector<Reference> &vec) const4824 void LinkedNode::DumpForSnapshot(std::vector<Reference> &vec) const
4825 {
4826 JSTaggedValue next = GetNext();
4827 if (next.IsUndefined() && !next.IsHole() && !next.IsNull()) {
4828 LinkedNode *nextNode = LinkedNode::Cast(next.GetTaggedObject());
4829 nextNode->DumpForSnapshot(vec);
4830 }
4831 JSTaggedValue key = GetKey();
4832 CString str;
4833 KeyToStd(str, key);
4834 vec.emplace_back(str, GetValue());
4835 }
4836
DumpForSnapshot(std::vector<Reference> &vec) const4837 void ConstantPool::DumpForSnapshot(std::vector<Reference> &vec) const
4838 {
4839 DumpArrayClass(this, vec);
4840 }
4841
DumpForSnapshot(std::vector<Reference> &vec) const4842 void ProfileTypeInfoCell::DumpForSnapshot(std::vector<Reference> &vec) const
4843 {
4844 vec.emplace_back(CString("Value"), GetValue());
4845 vec.emplace_back(CString("Handle"), GetHandle());
4846 }
4847
DumpForSnapshot(std::vector<Reference> &vec) const4848 void FunctionTemplate::DumpForSnapshot(std::vector<Reference> &vec) const
4849 {
4850 vec.emplace_back(CString("Method"), GetMethod());
4851 vec.emplace_back(CString("Module"), GetModule());
4852 vec.emplace_back(CString("RawProfileTypeInfo"), GetRawProfileTypeInfo());
4853 vec.emplace_back(CString("Length"), JSTaggedValue(GetLength()));
4854 }
4855
DumpForSnapshot(std::vector<Reference> &vec) const4856 void ExtraProfileTypeInfo::DumpForSnapshot(std::vector<Reference> &vec) const
4857 {
4858 vec.emplace_back(CString("Receiver"), GetReceiverObject());
4859 vec.emplace_back(CString("Holder"), GetHolderObject());
4860 }
4861
DumpForSnapshot(std::vector<Reference> &vec) const4862 void VTable::DumpForSnapshot(std::vector<Reference> &vec) const
4863 {
4864 DumpArrayClass(this, vec);
4865 }
4866
DumpForSnapshot(std::vector<Reference> &vec) const4867 void ProfileTypeInfo::DumpForSnapshot(std::vector<Reference> &vec) const
4868 {
4869 DISALLOW_GARBAGE_COLLECTION;
4870 uint32_t len = GetIcSlotLength();
4871 vec.reserve(vec.size() + len);
4872 for (uint32_t i = 0; i < len; i++) {
4873 JSTaggedValue val(Get(i));
4874 CString str = ToCString(i);
4875 vec.emplace_back(str, val);
4876 }
4877 }
4878
DumpForSnapshot(std::vector<Reference> &vec) const4879 void COWTaggedArray::DumpForSnapshot(std::vector<Reference> &vec) const
4880 {
4881 DumpArrayClass(this, vec);
4882 }
4883
DumpForSnapshot(std::vector<Reference> &vec) const4884 void MutantTaggedArray::DumpForSnapshot(std::vector<Reference> &vec) const
4885 {
4886 DumpMutantTaggedArrayClass(this, vec);
4887 }
4888
DumpForSnapshot(std::vector<Reference> &vec) const4889 void COWMutantTaggedArray::DumpForSnapshot(std::vector<Reference> &vec) const
4890 {
4891 DumpCOWMutantTaggedArrayClass(this, vec);
4892 }
4893
DumpForSnapshot(std::vector<Reference> &vec) const4894 void JSBoundFunction::DumpForSnapshot(std::vector<Reference> &vec) const
4895 {
4896 JSObject::DumpForSnapshot(vec);
4897
4898 vec.emplace_back(CString("BoundTarget"), GetBoundTarget());
4899 vec.emplace_back(CString("BoundThis"), GetBoundThis());
4900 vec.emplace_back(CString("BoundArguments"), GetBoundArguments());
4901 }
4902
DumpForSnapshot(std::vector<Reference> &vec) const4903 void JSPrimitiveRef::DumpForSnapshot(std::vector<Reference> &vec) const
4904 {
4905 vec.emplace_back(CString("subValue"), GetValue());
4906 JSObject::DumpForSnapshot(vec);
4907 }
4908
DumpForSnapshot(std::vector<Reference> &vec) const4909 void BigInt::DumpForSnapshot(std::vector<Reference> &vec) const
4910 {
4911 vec.emplace_back(CString("Length"), JSTaggedValue(GetLength()));
4912 vec.emplace_back(CString("Sign"), JSTaggedValue(GetSign()));
4913 }
4914
DumpForSnapshot(std::vector<Reference> &vec) const4915 void JSDate::DumpForSnapshot(std::vector<Reference> &vec) const
4916 {
4917 vec.emplace_back(CString("time"), GetTime());
4918 vec.emplace_back(CString("localOffset"), GetLocalOffset());
4919
4920 JSObject::DumpForSnapshot(vec);
4921 }
4922
DumpForSnapshot(std::vector<Reference> &vec) const4923 void JSMap::DumpForSnapshot(std::vector<Reference> &vec) const
4924 {
4925 if (!(GetLinkedMap().IsInvalidValue())) {
4926 LinkedHashMap *map = LinkedHashMap::Cast(GetLinkedMap().GetTaggedObject());
4927 vec.emplace_back("linkedmap", GetLinkedMap());
4928 map->DumpForSnapshot(vec);
4929 }
4930
4931 JSObject::DumpForSnapshot(vec);
4932 }
4933
DumpForSnapshot(std::vector<Reference> &vec) const4934 void JSSharedMap::DumpForSnapshot(std::vector<Reference> &vec) const
4935 {
4936 LinkedHashMap *map = LinkedHashMap::Cast(GetLinkedMap().GetTaggedObject());
4937 vec.emplace_back("linkedmap", GetLinkedMap());
4938 vec.emplace_back("ModRecord", JSTaggedValue(GetModRecord()));
4939 map->DumpForSnapshot(vec);
4940
4941 JSObject::DumpForSnapshot(vec);
4942 }
4943
DumpForSnapshot(std::vector<Reference> &vec) const4944 void JSForInIterator::DumpForSnapshot(std::vector<Reference> &vec) const
4945 {
4946 vec.emplace_back(CString("Object"), GetObject());
4947 vec.emplace_back(CString("CachedHclass"), GetCachedHclass());
4948 vec.emplace_back(CString("Keys"), GetKeys());
4949 vec.emplace_back(CString("Index"), JSTaggedValue(GetIndex()));
4950 vec.emplace_back(CString("Length"), JSTaggedValue(GetLength()));
4951 JSObject::DumpForSnapshot(vec);
4952 }
4953
DumpForSnapshot(std::vector<Reference> &vec) const4954 void JSMapIterator::DumpForSnapshot(std::vector<Reference> &vec) const
4955 {
4956 if (!(GetIteratedMap().IsInvalidValue())) {
4957 LinkedHashMap *map = LinkedHashMap::Cast(GetIteratedMap().GetTaggedObject());
4958 vec.emplace_back("iteratedmap", GetIteratedMap());
4959 map->DumpForSnapshot(vec);
4960 }
4961
4962 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
4963 vec.emplace_back(CString("IterationKind"), JSTaggedValue(static_cast<int>(GetIterationKind())));
4964 JSObject::DumpForSnapshot(vec);
4965 }
4966
DumpForSnapshot(std::vector<Reference> &vec) const4967 void JSSharedMapIterator::DumpForSnapshot(std::vector<Reference> &vec) const
4968 {
4969 JSSharedMap *iteratedMap = JSSharedMap::Cast(GetIteratedMap().GetTaggedObject());
4970 LinkedHashMap *map = LinkedHashMap::Cast(iteratedMap->GetLinkedMap().GetTaggedObject());
4971 vec.emplace_back("iteratedmap", GetIteratedMap());
4972 map->DumpForSnapshot(vec);
4973 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
4974 vec.emplace_back(CString("IterationKind"), JSTaggedValue(static_cast<int>(GetIterationKind())));
4975 JSObject::DumpForSnapshot(vec);
4976 }
4977
DumpForSnapshot(std::vector<Reference> &vec) const4978 void JSSet::DumpForSnapshot(std::vector<Reference> &vec) const
4979 {
4980 if (!(GetLinkedSet().IsInvalidValue())) {
4981 LinkedHashSet *set = LinkedHashSet::Cast(GetLinkedSet().GetTaggedObject());
4982 vec.emplace_back("linkedset", GetLinkedSet());
4983 set->DumpForSnapshot(vec);
4984 }
4985
4986 JSObject::DumpForSnapshot(vec);
4987 }
4988
DumpForSnapshot(std::vector<Reference> &vec) const4989 void JSSharedSet::DumpForSnapshot(std::vector<Reference> &vec) const
4990 {
4991 LinkedHashSet *set = LinkedHashSet::Cast(GetLinkedSet().GetTaggedObject());
4992 vec.emplace_back("linkedset", GetLinkedSet());
4993 vec.emplace_back("ModRecord", JSTaggedValue(GetModRecord()));
4994 set->DumpForSnapshot(vec);
4995
4996 JSObject::DumpForSnapshot(vec);
4997 }
4998
DumpForSnapshot(std::vector<Reference> &vec) const4999 void JSWeakMap::DumpForSnapshot(std::vector<Reference> &vec) const
5000 {
5001 if (!(GetLinkedMap().IsInvalidValue())) {
5002 LinkedHashMap *map = LinkedHashMap::Cast(GetLinkedMap().GetTaggedObject());
5003 vec.emplace_back("linkedmap", GetLinkedMap());
5004 map->DumpForSnapshot(vec);
5005 }
5006
5007 JSObject::DumpForSnapshot(vec);
5008 }
5009
DumpForSnapshot(std::vector<Reference> &vec) const5010 void JSWeakSet::DumpForSnapshot(std::vector<Reference> &vec) const
5011 {
5012 if (!(GetLinkedSet().IsInvalidValue())) {
5013 LinkedHashSet *set = LinkedHashSet::Cast(GetLinkedSet().GetTaggedObject());
5014 vec.emplace_back("linkeset", GetLinkedSet());
5015 set->DumpForSnapshot(vec);
5016 }
5017
5018 JSObject::DumpForSnapshot(vec);
5019 }
5020
DumpForSnapshot(std::vector<Reference> &vec) const5021 void JSWeakRef::DumpForSnapshot(std::vector<Reference> &vec) const
5022 {
5023 vec.emplace_back(CString("WeakObject"), GetWeakObject());
5024 JSObject::DumpForSnapshot(vec);
5025 }
5026
DumpForSnapshot(std::vector<Reference> &vec) const5027 void JSFinalizationRegistry::DumpForSnapshot(std::vector<Reference> &vec) const
5028 {
5029 vec.emplace_back(CString("CleanupCallback"), GetCleanupCallback());
5030 if (!(GetMaybeUnregister().IsInvalidValue())) {
5031 LinkedHashMap *map = LinkedHashMap::Cast(GetMaybeUnregister().GetTaggedObject());
5032 map->DumpForSnapshot(vec);
5033 }
5034
5035 vec.emplace_back(CString("MaybeUnregister"), GetMaybeUnregister());
5036 vec.emplace_back(CString("Next"), GetNext());
5037 vec.emplace_back(CString("Prev"), GetPrev());
5038 JSObject::DumpForSnapshot(vec);
5039 }
5040
DumpForSnapshot(std::vector<Reference> &vec) const5041 void CellRecord::DumpForSnapshot(std::vector<Reference> &vec) const
5042 {
5043 vec.emplace_back(CString("WeakRefTarget"), GetWeakRefTarget());
5044 vec.emplace_back(CString("HeldValue"), GetHeldValue());
5045 }
5046
DumpForSnapshot(std::vector<Reference> &vec) const5047 void JSSetIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5048 {
5049 if (!(GetIteratedSet().IsInvalidValue())) {
5050 LinkedHashSet *set = LinkedHashSet::Cast(GetIteratedSet().GetTaggedObject());
5051 vec.emplace_back("iteratedset", GetIteratedSet());
5052 set->DumpForSnapshot(vec);
5053 }
5054
5055 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
5056 vec.emplace_back(CString("IterationKind"), JSTaggedValue(static_cast<int>(GetIterationKind())));
5057 JSObject::DumpForSnapshot(vec);
5058 }
5059
DumpForSnapshot(std::vector<Reference> &vec) const5060 void JSSharedSetIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5061 {
5062 JSSharedSet *iteratedSet = JSSharedSet::Cast(GetIteratedSet().GetTaggedObject());
5063 LinkedHashSet *set = LinkedHashSet::Cast(iteratedSet->GetLinkedSet().GetTaggedObject());
5064 vec.emplace_back("iteratedset", GetIteratedSet());
5065 set->DumpForSnapshot(vec);
5066 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
5067 vec.emplace_back(CString("IterationKind"), JSTaggedValue(static_cast<int>(GetIterationKind())));
5068 JSObject::DumpForSnapshot(vec);
5069 }
5070
DumpForSnapshot(std::vector<Reference> &vec) const5071 void JSArray::DumpForSnapshot(std::vector<Reference> &vec) const
5072 {
5073 vec.emplace_back(CString("Length"), JSTaggedValue(GetLength()));
5074 JSObject::DumpForSnapshot(vec);
5075 }
5076
DumpForSnapshot(std::vector<Reference> &vec) const5077 void JSSharedArray::DumpForSnapshot(std::vector<Reference> &vec) const
5078 {
5079 vec.emplace_back("ModRecord: ", JSTaggedValue(GetModRecord()));
5080 JSObject::DumpForSnapshot(vec);
5081 }
5082
DumpForSnapshot(std::vector<Reference> &vec) const5083 void JSAPIArrayList::DumpForSnapshot(std::vector<Reference> &vec) const
5084 {
5085 vec.emplace_back(CString("Length"), JSTaggedValue(GetLength()));
5086 JSObject::DumpForSnapshot(vec);
5087 }
5088
DumpForSnapshot(std::vector<Reference> &vec) const5089 void JSAPIArrayListIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5090 {
5091 if (!(GetIteratedArrayList().IsInvalidValue())) {
5092 JSAPIArrayList *arraylist = JSAPIArrayList::Cast(GetIteratedArrayList().GetTaggedObject());
5093 vec.emplace_back("iteratedlist", GetIteratedArrayList());
5094 arraylist->DumpForSnapshot(vec);
5095 }
5096 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
5097 JSObject::DumpForSnapshot(vec);
5098 }
5099
DumpForSnapshot(std::vector<Reference> &vec) const5100 void JSAPILightWeightMap::DumpForSnapshot(std::vector<Reference> &vec) const
5101 {
5102 DISALLOW_GARBAGE_COLLECTION;
5103 vec.emplace_back("Hashes", GetHashes());
5104 TaggedArray *keys = TaggedArray::Cast(GetKeys().GetTaggedObject());
5105 TaggedArray *values = TaggedArray::Cast(GetValues().GetTaggedObject());
5106 uint32_t len = static_cast<uint32_t>(GetLength());
5107 vec.reserve(vec.size() + len);
5108 for (uint32_t i = 0; i < len; i++) {
5109 CString str;
5110 KeyToStd(str, keys->Get(i));
5111 vec.emplace_back(str, values->Get(i));
5112 }
5113 JSObject::DumpForSnapshot(vec);
5114 }
5115
DumpForSnapshot(std::vector<Reference> &vec) const5116 void JSAPILightWeightMapIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5117 {
5118 if (!(GetIteratedLightWeightMap().IsInvalidValue())) {
5119 JSAPILightWeightMap *map =
5120 JSAPILightWeightMap::Cast(GetIteratedLightWeightMap().GetTaggedObject());
5121 vec.emplace_back("iteratedmap", GetIteratedLightWeightMap());
5122 map->DumpForSnapshot(vec);
5123 }
5124
5125 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
5126 vec.emplace_back(CString("IterationKind"), JSTaggedValue(static_cast<int>(GetIterationKind())));
5127 vec.emplace_back(CString("BitField"), JSTaggedValue(GetBitField()));
5128 JSObject::DumpForSnapshot(vec);
5129 }
5130
DumpForSnapshot(std::vector<Reference> &vec) const5131 void JSAPIQueue::DumpForSnapshot(std::vector<Reference> &vec) const
5132 {
5133 vec.emplace_back(CString("Length"), JSTaggedValue(GetLength()));
5134 JSObject::DumpForSnapshot(vec);
5135 }
5136
DumpForSnapshot(std::vector<Reference> &vec) const5137 void JSAPIQueueIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5138 {
5139 if (!(GetIteratedQueue().IsInvalidValue())) {
5140 JSAPIQueue *queue = JSAPIQueue::Cast(GetIteratedQueue().GetTaggedObject());
5141 vec.emplace_back("iteratedqueue", GetIteratedQueue());
5142 queue->DumpForSnapshot(vec);
5143 }
5144
5145 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
5146 JSObject::DumpForSnapshot(vec);
5147 }
5148
DumpForSnapshot(std::vector<Reference> &vec) const5149 void JSAPIDeque::DumpForSnapshot(std::vector<Reference> &vec) const
5150 {
5151 JSObject::DumpForSnapshot(vec);
5152 }
5153
DumpForSnapshot(std::vector<Reference> &vec) const5154 void JSAPIDequeIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5155 {
5156 if (!(GetIteratedDeque().IsInvalidValue())) {
5157 JSAPIDeque *deque = JSAPIDeque::Cast(GetIteratedDeque().GetTaggedObject());
5158 vec.emplace_back("iterateddeque", GetIteratedDeque());
5159 deque->DumpForSnapshot(vec);
5160 }
5161
5162 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
5163 JSObject::DumpForSnapshot(vec);
5164 }
5165
DumpForSnapshot(std::vector<Reference> &vec) const5166 void JSAPILightWeightSet::DumpForSnapshot(std::vector<Reference> &vec) const
5167 {
5168 DISALLOW_GARBAGE_COLLECTION;
5169 TaggedArray *hashes = TaggedArray::Cast(GetHashes().GetTaggedObject());
5170 TaggedArray *values = TaggedArray::Cast(GetValues().GetTaggedObject());
5171 uint32_t len = GetLength();
5172 vec.reserve(vec.size() + len);
5173 for (uint32_t i = 0; i < len; i++) {
5174 CString str;
5175 KeyToStd(str, hashes->Get(i));
5176 vec.emplace_back(str, values->Get(i));
5177 }
5178 JSObject::DumpForSnapshot(vec);
5179 }
5180
DumpForSnapshot(std::vector<Reference> &vec) const5181 void JSAPILightWeightSetIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5182 {
5183 if (!(GetIteratedLightWeightSet().IsInvalidValue())) {
5184 JSAPILightWeightSet *set =
5185 JSAPILightWeightSet::Cast(GetIteratedLightWeightSet().GetTaggedObject());
5186 vec.emplace_back("iteratedset", GetIteratedLightWeightSet());
5187 set->DumpForSnapshot(vec);
5188 }
5189
5190 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
5191 vec.emplace_back(CString("IterationKind"), JSTaggedValue(static_cast<int>(GetIterationKind())));
5192 JSObject::DumpForSnapshot(vec);
5193 }
5194
DumpForSnapshot(std::vector<Reference> &vec) const5195 void JSAPIStack::DumpForSnapshot(std::vector<Reference> &vec) const
5196 {
5197 JSObject::DumpForSnapshot(vec);
5198 }
5199
DumpForSnapshot(std::vector<Reference> &vec) const5200 void JSAPIStackIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5201 {
5202 if (!(GetIteratedStack().IsInvalidValue())) {
5203 JSAPIStack *stack = JSAPIStack::Cast(GetIteratedStack().GetTaggedObject());
5204 vec.emplace_back("iteratedstack", GetIteratedStack());
5205 stack->DumpForSnapshot(vec);
5206 }
5207
5208 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
5209 JSObject::DumpForSnapshot(vec);
5210 }
5211
DumpForSnapshot(std::vector<Reference> &vec) const5212 void JSArrayIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5213 {
5214 if (!(GetIteratedArray().IsInvalidValue())) {
5215 JSArray *array = JSArray::Cast(GetIteratedArray().GetTaggedObject());
5216 vec.emplace_back("iteratedarray", GetIteratedArray());
5217 array->DumpForSnapshot(vec);
5218 }
5219
5220 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
5221 vec.emplace_back(CString("IterationKind"), JSTaggedValue(static_cast<int>(GetIterationKind())));
5222 vec.emplace_back(CString("BitField"), JSTaggedValue(GetBitField()));
5223 JSObject::DumpForSnapshot(vec);
5224 }
5225
DumpForSnapshot(std::vector<Reference> &vec) const5226 void JSSharedArrayIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5227 {
5228 JSSharedArray *array = JSSharedArray::Cast(GetIteratedArray().GetTaggedObject());
5229 vec.emplace_back("iteratedarray", GetIteratedArray());
5230 array->DumpForSnapshot(vec);
5231 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
5232 vec.emplace_back(CString("IterationKind"), JSTaggedValue(static_cast<int>(GetIterationKind())));
5233 JSObject::DumpForSnapshot(vec);
5234 }
5235
DumpForSnapshot(std::vector<Reference> &vec) const5236 void JSAPIVector::DumpForSnapshot(std::vector<Reference> &vec) const
5237 {
5238 JSObject::DumpForSnapshot(vec);
5239 }
5240
DumpForSnapshot(std::vector<Reference> &vec) const5241 void JSAPIVectorIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5242 {
5243 if (!(GetIteratedVector().IsInvalidValue())) {
5244 JSAPIVector *vector = JSAPIVector::Cast(GetIteratedVector().GetTaggedObject());
5245 vec.emplace_back("iteratedvector", GetIteratedVector());
5246 vector->DumpForSnapshot(vec);
5247 }
5248
5249 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
5250 JSObject::DumpForSnapshot(vec);
5251 }
5252
DumpForSnapshot(std::vector<Reference> &vec) const5253 void JSAPIBitVector::DumpForSnapshot(std::vector<Reference> &vec) const
5254 {
5255 JSObject::DumpForSnapshot(vec);
5256 }
5257
DumpForSnapshot(std::vector<Reference> &vec) const5258 void JSAPIBitVectorIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5259 {
5260 JSAPIVector *vector = JSAPIVector::Cast(GetIteratedBitVector().GetTaggedObject());
5261 vec.emplace_back("iteratedbitvector", GetIteratedBitVector());
5262 vector->DumpForSnapshot(vec);
5263 vec.emplace_back(CString("NextIndex"), JSTaggedValue(GetNextIndex()));
5264 JSObject::DumpForSnapshot(vec);
5265 }
5266
DumpForSnapshot(std::vector<Reference> &vec) const5267 void JSStringIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5268 {
5269 vec.emplace_back(CString("IteratedString"), GetIteratedString());
5270 vec.emplace_back(CString("StringIteratorNextIndex"), JSTaggedValue(GetStringIteratorNextIndex()));
5271 JSObject::DumpForSnapshot(vec);
5272 }
5273
DumpForSnapshot(std::vector<Reference> &vec) const5274 void JSTypedArray::DumpForSnapshot(std::vector<Reference> &vec) const
5275 {
5276 // please update the NUM_OF_ITEMS if you change the items below
5277 constexpr int16_t NUM_OF_ITEMS = 5;
5278 vec.reserve(vec.size() + NUM_OF_ITEMS);
5279 vec.emplace_back(CString("viewed-array-buffer"), GetViewedArrayBufferOrByteArray());
5280 vec.emplace_back(CString("typed-array-name"), GetTypedArrayName());
5281 vec.emplace_back(CString("byte-length"), JSTaggedValue(GetByteLength()));
5282 vec.emplace_back(CString("byte-offset"), JSTaggedValue(GetByteOffset()));
5283 vec.emplace_back(CString("array-length"), JSTaggedValue(GetArrayLength()));
5284 JSObject::DumpForSnapshot(vec);
5285 }
5286
DumpForSnapshot(std::vector<Reference> &vec) const5287 void JSSharedTypedArray::DumpForSnapshot(std::vector<Reference> &vec) const
5288 {
5289 // please update the NUM_OF_ITEMS if you change the items below
5290 constexpr int16_t NUM_OF_ITEMS = 5;
5291 vec.reserve(vec.size() + NUM_OF_ITEMS);
5292 vec.emplace_back(CString("viewed-array-buffer"), GetViewedArrayBufferOrByteArray());
5293 vec.emplace_back(CString("typed-array-name"), GetTypedArrayName());
5294 vec.emplace_back(CString("byte-length"), JSTaggedValue(GetByteLength()));
5295 vec.emplace_back(CString("byte-offset"), JSTaggedValue(GetByteOffset()));
5296 vec.emplace_back(CString("array-length"), JSTaggedValue(GetArrayLength()));
5297 JSObject::DumpForSnapshot(vec);
5298 }
5299
DumpForSnapshot(std::vector<Reference> &vec) const5300 void ByteArray::DumpForSnapshot(std::vector<Reference> &vec) const
5301 {
5302 vec.emplace_back(CString("array-length"), JSTaggedValue(GetArrayLength()));
5303 vec.emplace_back(CString("byte-length"), JSTaggedValue(GetByteLength()));
5304 }
5305
DumpForSnapshot(std::vector<Reference> &vec) const5306 void JSRegExp::DumpForSnapshot(std::vector<Reference> &vec) const
5307 {
5308 vec.emplace_back(CString("ByteCodeBuffer"), GetByteCodeBuffer());
5309 vec.emplace_back(CString("originalSource"), GetOriginalSource());
5310 vec.emplace_back(CString("originalFlags"), GetOriginalFlags());
5311 vec.emplace_back(CString("groupName"), GetGroupName());
5312 JSObject::DumpForSnapshot(vec);
5313 }
5314
DumpForSnapshot(std::vector<Reference> &vec) const5315 void JSRegExpIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5316 {
5317 vec.emplace_back(CString("IteratingRegExp"), GetIteratingRegExp());
5318 vec.emplace_back(CString("IteratedString"), GetIteratedString());
5319 vec.emplace_back(CString("Global"), JSTaggedValue(GetGlobal()));
5320 vec.emplace_back(CString("Unicode"), JSTaggedValue(GetUnicode()));
5321 vec.emplace_back(CString("Done"), JSTaggedValue(GetDone()));
5322 JSObject::DumpForSnapshot(vec);
5323 }
5324
DumpForSnapshot(std::vector<Reference> &vec) const5325 void JSProxy::DumpForSnapshot(std::vector<Reference> &vec) const
5326 {
5327 vec.emplace_back(CString("target"), GetTarget());
5328 vec.emplace_back(CString("handler"), GetHandler());
5329 vec.emplace_back(CString("Method"), GetMethod());
5330 vec.emplace_back(CString("PrivateField"), GetPrivateField());
5331 vec.emplace_back(CString("BitField"), JSTaggedValue(GetBitField()));
5332 }
5333
DumpForSnapshot(std::vector<Reference> &vec) const5334 void JSSymbol::DumpForSnapshot(std::vector<Reference> &vec) const
5335 {
5336 vec.emplace_back(CString("hash-field"), JSTaggedValue(GetHashField()));
5337 vec.emplace_back(CString("flags"), JSTaggedValue(GetFlags()));
5338 vec.emplace_back(CString("description"), GetDescription());
5339 }
5340
DumpForSnapshot(std::vector<Reference> &vec) const5341 void AccessorData::DumpForSnapshot(std::vector<Reference> &vec) const
5342 {
5343 if (GetClass()->GetObjectType() == JSType::INTERNAL_ACCESSOR) {
5344 vec.emplace_back(CString("getter"), JSTaggedValue(InternalAccessor::ConstCast(this)->GetGetter()));
5345 vec.emplace_back(CString("setter"), JSTaggedValue(InternalAccessor::ConstCast(this)->GetSetter()));
5346 return;
5347 }
5348
5349 vec.emplace_back(CString("getter"), GetGetter());
5350 vec.emplace_back(CString("setter"), GetSetter());
5351 }
5352
DumpForSnapshot(std::vector<Reference> &vec) const5353 void LexicalEnv::DumpForSnapshot(std::vector<Reference> &vec) const
5354 {
5355 DumpArrayClass(this, vec);
5356 }
5357
DumpForSnapshot(std::vector<Reference> &vec) const5358 void SendableEnv::DumpForSnapshot(std::vector<Reference> &vec) const
5359 {
5360 DumpArrayClass(this, vec);
5361 }
5362
DumpForSnapshot(std::vector<Reference> &vec) const5363 void GlobalEnv::DumpForSnapshot(std::vector<Reference> &vec) const
5364 {
5365 auto globalConst = GetJSThread()->GlobalConstants();
5366 #define DUMP_ENV_FIELD(type, name, _) vec.emplace_back(#name, GetRaw##name().GetTaggedValue());
5367 #define DUMP_CONST_FIELD(type, name, ...) vec.emplace_back(#name, globalConst->Get##name());
5368 #define DUMP_CONST_STRING(name, ...) vec.emplace_back(#name, globalConst->Get##name());
5369
5370 GLOBAL_ENV_FIELDS(DUMP_ENV_FIELD)
5371
5372 GLOBAL_ENV_CONSTANT_CLASS(DUMP_CONST_FIELD)
5373
5374 GLOBAL_ENV_CONSTANT_SPECIAL(DUMP_CONST_FIELD)
5375
5376 GLOBAL_ENV_CONSTANT_CONSTANT(DUMP_CONST_FIELD)
5377
5378 GLOBAL_ENV_CACHES(DUMP_CONST_FIELD)
5379
5380 #undef DUMP_FIELD
5381 #undef DUMP_CONST_FIELD
5382 #undef DUMP_CONST_STRING
5383 }
5384
DumpForSnapshot(std::vector<Reference> &vec) const5385 void JSDataView::DumpForSnapshot(std::vector<Reference> &vec) const
5386 {
5387 vec.emplace_back(CString("data-view"), GetDataView());
5388 vec.emplace_back(CString("buffer"), GetViewedArrayBuffer());
5389 vec.emplace_back(CString("byte-length"), JSTaggedValue(GetByteLength()));
5390 vec.emplace_back(CString("byte-offset"), JSTaggedValue(GetByteOffset()));
5391 JSObject::DumpForSnapshot(vec);
5392 }
5393
DumpForSnapshot(std::vector<Reference> &vec) const5394 void JSArrayBuffer::DumpForSnapshot(std::vector<Reference> &vec) const
5395 {
5396 vec.emplace_back(CString("buffer-data"), GetArrayBufferData());
5397 vec.emplace_back(CString("byte-length"), JSTaggedValue(GetArrayBufferByteLength()));
5398 vec.emplace_back(CString("shared"), JSTaggedValue(GetShared()));
5399 JSObject::DumpForSnapshot(vec);
5400 }
5401
DumpForSnapshot(std::vector<Reference> &vec) const5402 void JSSendableArrayBuffer::DumpForSnapshot(std::vector<Reference> &vec) const
5403 {
5404 vec.emplace_back(CString("buffer-data"), GetArrayBufferData());
5405 vec.emplace_back(CString("byte-length"), JSTaggedValue(GetArrayBufferByteLength()));
5406 vec.emplace_back(CString("shared"), JSTaggedValue(GetShared()));
5407 JSObject::DumpForSnapshot(vec);
5408 }
5409
DumpForSnapshot(std::vector<Reference> &vec) const5410 void PromiseReaction::DumpForSnapshot(std::vector<Reference> &vec) const
5411 {
5412 vec.emplace_back(CString("promise-capability"), GetPromiseCapability());
5413 vec.emplace_back(CString("handler"), GetHandler());
5414 vec.emplace_back(CString("type"), JSTaggedValue(static_cast<int>(GetType())));
5415 }
5416
DumpForSnapshot(std::vector<Reference> &vec) const5417 void PromiseCapability::DumpForSnapshot(std::vector<Reference> &vec) const
5418 {
5419 vec.emplace_back(CString("promise"), GetPromise());
5420 vec.emplace_back(CString("resolve"), GetResolve());
5421 vec.emplace_back(CString("reject"), GetReject());
5422 }
5423
DumpForSnapshot(std::vector<Reference> &vec) const5424 void PromiseIteratorRecord::DumpForSnapshot(std::vector<Reference> &vec) const
5425 {
5426 vec.emplace_back(CString("iterator"), GetIterator());
5427 vec.emplace_back(CString("done"), JSTaggedValue(GetDone()));
5428 }
5429
DumpForSnapshot(std::vector<Reference> &vec) const5430 void PromiseRecord::DumpForSnapshot(std::vector<Reference> &vec) const
5431 {
5432 vec.emplace_back(CString("value"), GetValue());
5433 }
5434
DumpForSnapshot(std::vector<Reference> &vec) const5435 void ResolvingFunctionsRecord::DumpForSnapshot(std::vector<Reference> &vec) const
5436 {
5437 vec.emplace_back(CString("resolve-function"), GetResolveFunction());
5438 vec.emplace_back(CString("reject-function"), GetRejectFunction());
5439 }
5440
DumpForSnapshot(std::vector<Reference> &vec) const5441 void AsyncGeneratorRequest::DumpForSnapshot(std::vector<Reference> &vec) const
5442 {
5443 vec.emplace_back(CString("completion"), GetCompletion());
5444 vec.emplace_back(CString("capability"), GetCapability());
5445 }
5446
DumpForSnapshot(std::vector<Reference> &vec) const5447 void AsyncIteratorRecord::DumpForSnapshot(std::vector<Reference> &vec) const
5448 {
5449 vec.emplace_back(CString("iterator"), GetIterator());
5450 vec.emplace_back(CString("nextmethod"), GetNextMethod());
5451 vec.emplace_back(CString("done"), JSTaggedValue(GetDone()));
5452 }
5453
DumpForSnapshot(std::vector<Reference> &vec) const5454 void JSAsyncFromSyncIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5455 {
5456 vec.emplace_back(CString("synciteratorrecord"), GetSyncIteratorRecord());
5457 JSObject::DumpForSnapshot(vec);
5458 }
5459
DumpForSnapshot(std::vector<Reference> &vec) const5460 void JSAsyncFromSyncIterUnwarpFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5461 {
5462 vec.emplace_back(CString("done"), JSTaggedValue(GetDone()));
5463 JSFunction::DumpForSnapshot(vec);
5464 }
5465
DumpForSnapshot(std::vector<Reference> &vec) const5466 void JSPromise::DumpForSnapshot(std::vector<Reference> &vec) const
5467 {
5468 vec.emplace_back(CString("promise-state"), JSTaggedValue(static_cast<int>(GetPromiseState())));
5469 vec.emplace_back(CString("promise-result"), GetPromiseResult());
5470 vec.emplace_back(CString("promise-fulfill-reactions"), GetPromiseFulfillReactions());
5471 vec.emplace_back(CString("promise-reject-reactions"), GetPromiseRejectReactions());
5472 vec.emplace_back(CString("promise-is-handled"), JSTaggedValue(GetPromiseIsHandled()));
5473 JSObject::DumpForSnapshot(vec);
5474 }
5475
DumpForSnapshot(std::vector<Reference> &vec) const5476 void JSPromiseReactionsFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5477 {
5478 vec.emplace_back(CString("promise"), GetPromise());
5479 vec.emplace_back(CString("already-resolved"), GetAlreadyResolved());
5480 JSFunction::DumpForSnapshot(vec);
5481 }
5482
DumpForSnapshot(std::vector<Reference> &vec) const5483 void JSAsyncGeneratorResNextRetProRstFtn::DumpForSnapshot(std::vector<Reference> &vec) const
5484 {
5485 vec.emplace_back(CString("async-generator-object"), GetAsyncGeneratorObject());
5486 JSFunction::DumpForSnapshot(vec);
5487 }
5488
DumpForSnapshot(std::vector<Reference> &vec) const5489 void JSPromiseExecutorFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5490 {
5491 vec.emplace_back(CString("capability"), GetCapability());
5492 JSFunction::DumpForSnapshot(vec);
5493 }
5494
DumpForSnapshot(std::vector<Reference> &vec) const5495 void JSAsyncModuleFulfilledFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5496 {
5497 vec.emplace_back(CString("module"), GetModule());
5498 JSFunction::DumpForSnapshot(vec);
5499 }
5500
DumpForSnapshot(std::vector<Reference> &vec) const5501 void JSAsyncModuleRejectedFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5502 {
5503 vec.emplace_back(CString("module"), GetModule());
5504 JSFunction::DumpForSnapshot(vec);
5505 }
5506
DumpForSnapshot(std::vector<Reference> &vec) const5507 void JSPromiseAllResolveElementFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5508 {
5509 vec.emplace_back(CString("index"), GetIndex());
5510 vec.emplace_back(CString("values"), GetValues());
5511 vec.emplace_back(CString("capabilities"), GetCapabilities());
5512 vec.emplace_back(CString("remaining-elements"), GetRemainingElements());
5513 vec.emplace_back(CString("already-called"), GetAlreadyCalled());
5514 JSFunction::DumpForSnapshot(vec);
5515 }
5516
DumpForSnapshot(std::vector<Reference> &vec) const5517 void JSPromiseAnyRejectElementFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5518 {
5519 vec.emplace_back(CString("index"), JSTaggedValue(GetIndex()));
5520 vec.emplace_back(CString("errors"), GetErrors());
5521 vec.emplace_back(CString("capability"), GetCapability());
5522 vec.emplace_back(CString("remaining-elements"), GetRemainingElements());
5523 vec.emplace_back(CString("already-called"), GetAlreadyCalled());
5524 JSFunction::DumpForSnapshot(vec);
5525 }
5526
DumpForSnapshot(std::vector<Reference> &vec) const5527 void JSPromiseAllSettledElementFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5528 {
5529 vec.emplace_back(CString("already-called"), GetAlreadyCalled());
5530 vec.emplace_back(CString("index"), JSTaggedValue(GetIndex()));
5531 vec.emplace_back(CString("values"), GetValues());
5532 vec.emplace_back(CString("capability"), GetCapability());
5533 vec.emplace_back(CString("remaining-elements"), GetRemainingElements());
5534 JSFunction::DumpForSnapshot(vec);
5535 }
5536
DumpForSnapshot(std::vector<Reference> &vec) const5537 void JSPromiseFinallyFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5538 {
5539 vec.emplace_back(CString("constructor"), GetConstructor());
5540 vec.emplace_back(CString("onFinally"), GetOnFinally());
5541 JSFunction::DumpForSnapshot(vec);
5542 }
5543
DumpForSnapshot(std::vector<Reference> &vec) const5544 void JSPromiseValueThunkOrThrowerFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5545 {
5546 vec.emplace_back(CString("result"), GetResult());
5547 JSFunction::DumpForSnapshot(vec);
5548 }
5549
DumpForSnapshot(std::vector<Reference> &vec) const5550 void MicroJobQueue::DumpForSnapshot(std::vector<Reference> &vec) const
5551 {
5552 vec.emplace_back(CString("promise-job-queue"), GetPromiseJobQueue());
5553 vec.emplace_back(CString("script-job-queue"), GetScriptJobQueue());
5554 }
5555
DumpForSnapshot(std::vector<Reference> &vec) const5556 void PendingJob::DumpForSnapshot(std::vector<Reference> &vec) const
5557 {
5558 vec.emplace_back(CString("job"), GetJob());
5559 vec.emplace_back(CString("arguments"), GetArguments());
5560 }
5561
DumpForSnapshot(std::vector<Reference> &vec) const5562 void CompletionRecord::DumpForSnapshot(std::vector<Reference> &vec) const
5563 {
5564 vec.emplace_back(CString("value"), GetValue());
5565 vec.emplace_back(CString("type"), JSTaggedValue(static_cast<int>(GetType())));
5566 }
5567
DumpForSnapshot(std::vector<Reference> &vec) const5568 void JSProxyRevocFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5569 {
5570 vec.emplace_back(CString("RevocableProxy"), GetRevocableProxy());
5571 JSFunction::DumpForSnapshot(vec);
5572 }
5573
DumpForSnapshot(std::vector<Reference> &vec) const5574 void JSAsyncFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5575 {
5576 JSFunction::DumpForSnapshot(vec);
5577 }
5578
DumpForSnapshot(std::vector<Reference> &vec) const5579 void JSAsyncAwaitStatusFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5580 {
5581 vec.emplace_back(CString("AsyncContext"), GetAsyncContext());
5582 JSFunction::DumpForSnapshot(vec);
5583 }
5584
DumpForSnapshot(std::vector<Reference> &vec) const5585 void JSGeneratorFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5586 {
5587 JSFunction::DumpForSnapshot(vec);
5588 }
5589
DumpForSnapshot(std::vector<Reference> &vec) const5590 void JSAsyncGeneratorFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5591 {
5592 JSFunction::DumpForSnapshot(vec);
5593 }
5594
DumpForSnapshot(std::vector<Reference> &vec) const5595 void JSIntlBoundFunction::DumpForSnapshot(std::vector<Reference> &vec) const
5596 {
5597 vec.emplace_back(CString("NumberFormat"), GetNumberFormat());
5598 vec.emplace_back(CString("DateTimeFormat"), GetDateTimeFormat());
5599 vec.emplace_back(CString("Collator"), GetCollator());
5600 JSFunction::DumpForSnapshot(vec);
5601 }
5602
DumpForSnapshot(std::vector<Reference> &vec) const5603 void PropertyBox::DumpForSnapshot(std::vector<Reference> &vec) const
5604 {
5605 vec.emplace_back(CString("Value"), GetValue());
5606 }
5607
DumpForSnapshot(std::vector<Reference> &vec) const5608 void PrototypeHandler::DumpForSnapshot(std::vector<Reference> &vec) const
5609 {
5610 vec.emplace_back(CString("HandlerInfo"), GetHandlerInfo());
5611 vec.emplace_back(CString("ProtoCell"), GetProtoCell());
5612 vec.emplace_back(CString("Holder"), GetHolder());
5613 }
5614
DumpForSnapshot(std::vector<Reference> &vec) const5615 void TransitionHandler::DumpForSnapshot(std::vector<Reference> &vec) const
5616 {
5617 vec.emplace_back(CString("HandlerInfo"), GetHandlerInfo());
5618 vec.emplace_back(CString("TransitionHClass"), GetTransitionHClass());
5619 }
5620
DumpForSnapshot(std::vector<Reference> &vec) const5621 void TransWithProtoHandler::DumpForSnapshot(std::vector<Reference> &vec) const
5622 {
5623 vec.emplace_back(CString("HandlerInfo"), GetHandlerInfo());
5624 vec.emplace_back(CString("TransitionHClass"), GetTransitionHClass());
5625 vec.emplace_back(CString("ProtoCell"), GetProtoCell());
5626 }
5627
DumpForSnapshot(std::vector<Reference> &vec) const5628 void StoreTSHandler::DumpForSnapshot(std::vector<Reference> &vec) const
5629 {
5630 vec.emplace_back(CString("HandlerInfo"), GetHandlerInfo());
5631 vec.emplace_back(CString("ProtoCell"), GetProtoCell());
5632 vec.emplace_back(CString("Holder"), GetHolder());
5633 }
5634
DumpForSnapshot(std::vector<Reference> &vec) const5635 void JSRealm::DumpForSnapshot(std::vector<Reference> &vec) const
5636 {
5637 vec.emplace_back(CString("Value"), GetValue());
5638 vec.emplace_back(CString("GLobalEnv"), GetGlobalEnv());
5639 JSObject::DumpForSnapshot(vec);
5640 }
5641 #ifdef ARK_SUPPORT_INTL
DumpForSnapshot(std::vector<Reference> &vec) const5642 void JSIntl::DumpForSnapshot(std::vector<Reference> &vec) const
5643 {
5644 vec.emplace_back(CString("FallbackSymbol"), GetFallbackSymbol());
5645 JSObject::DumpForSnapshot(vec);
5646 }
5647
DumpForSnapshot(std::vector<Reference> &vec) const5648 void JSLocale::DumpForSnapshot(std::vector<Reference> &vec) const
5649 {
5650 vec.emplace_back(CString("IcuField"), GetIcuField());
5651 JSObject::DumpForSnapshot(vec);
5652 }
5653
DumpForSnapshot(std::vector<Reference> &vec) const5654 void JSDateTimeFormat::DumpForSnapshot(std::vector<Reference> &vec) const
5655 {
5656 // please update the NUM_OF_ITEMS if you change the items below
5657 constexpr int16_t NUM_OF_ITEMS = 11;
5658 vec.reserve(vec.size() + NUM_OF_ITEMS);
5659 vec.emplace_back(CString("Locale"), GetLocale());
5660 vec.emplace_back(CString("Calendar"), GetCalendar());
5661 vec.emplace_back(CString("NumberingSystem"), GetNumberingSystem());
5662 vec.emplace_back(CString("TimeZone"), GetTimeZone());
5663 vec.emplace_back(CString("HourCycle"), JSTaggedValue(static_cast<int>(GetHourCycle())));
5664 vec.emplace_back(CString("LocaleIcu"), GetLocaleIcu());
5665 vec.emplace_back(CString("SimpleDateTimeFormatIcu"), GetSimpleDateTimeFormatIcu());
5666 vec.emplace_back(CString("Iso8601"), GetIso8601());
5667 vec.emplace_back(CString("DateStyle"), JSTaggedValue(static_cast<int>(GetDateStyle())));
5668 vec.emplace_back(CString("TimeStyle"), JSTaggedValue(static_cast<int>(GetTimeStyle())));
5669 vec.emplace_back(CString("BoundFormat"), GetBoundFormat());
5670 JSObject::DumpForSnapshot(vec);
5671 }
5672
DumpForSnapshot(std::vector<Reference> &vec) const5673 void JSRelativeTimeFormat::DumpForSnapshot(std::vector<Reference> &vec) const
5674 {
5675 vec.emplace_back(CString("Locale"), GetLocale());
5676 vec.emplace_back(CString("NumberingSystem"), GetNumberingSystem());
5677 vec.emplace_back(CString("Style"), JSTaggedValue(static_cast<int>(GetStyle())));
5678 vec.emplace_back(CString("Numeric"), JSTaggedValue(static_cast<int>(GetNumeric())));
5679 vec.emplace_back(CString("IcuField"), GetIcuField());
5680 JSObject::DumpForSnapshot(vec);
5681 }
5682
DumpForSnapshot(std::vector<Reference> &vec) const5683 void JSNumberFormat::DumpForSnapshot(std::vector<Reference> &vec) const
5684 {
5685 // please update the NUM_OF_ITEMS if you change the items below
5686 constexpr int16_t NUM_OF_ITEMS = 20;
5687 vec.reserve(vec.size() + NUM_OF_ITEMS);
5688 vec.emplace_back(CString("Locale"), GetLocale());
5689 vec.emplace_back(CString("NumberingSystem"), GetNumberingSystem());
5690 vec.emplace_back(CString("Style"), JSTaggedValue(static_cast<int>(GetStyle())));
5691 vec.emplace_back(CString("Currency"), GetCurrency());
5692 vec.emplace_back(CString("CurrencyDisplay"), JSTaggedValue(static_cast<int>(GetCurrencyDisplay())));
5693 vec.emplace_back(CString("CurrencySign"), JSTaggedValue(static_cast<int>(GetCurrencySign())));
5694 vec.emplace_back(CString("Unit"), GetUnit());
5695 vec.emplace_back(CString("UnitDisplay"), JSTaggedValue(static_cast<int>(GetUnitDisplay())));
5696 vec.emplace_back(CString("MinimumIntegerDigits"), GetMinimumIntegerDigits());
5697 vec.emplace_back(CString("MinimumFractionDigits"), GetMinimumFractionDigits());
5698 vec.emplace_back(CString("MaximumFractionDigits"), GetMaximumFractionDigits());
5699 vec.emplace_back(CString("MinimumSignificantDigits"), GetMinimumSignificantDigits());
5700 vec.emplace_back(CString("MaximumSignificantDigits"), GetMaximumSignificantDigits());
5701 vec.emplace_back(CString("UseGrouping"), GetUseGrouping());
5702 vec.emplace_back(CString("RoundingType"), JSTaggedValue(static_cast<int>(GetRoundingType())));
5703 vec.emplace_back(CString("Notation"), JSTaggedValue(static_cast<int>(GetNotation())));
5704 vec.emplace_back(CString("CompactDisplay"), JSTaggedValue(static_cast<int>(GetCompactDisplay())));
5705 vec.emplace_back(CString("SignDisplay"), JSTaggedValue(static_cast<int>(GetSignDisplay())));
5706 vec.emplace_back(CString("BoundFormat"), GetBoundFormat());
5707 vec.emplace_back(CString("IcuField"), GetIcuField());
5708 JSObject::DumpForSnapshot(vec);
5709 }
5710
DumpForSnapshot(std::vector<Reference> &vec) const5711 void JSCollator::DumpForSnapshot(std::vector<Reference> &vec) const
5712 {
5713 // please update the NUM_OF_ITEMS if you change the items below
5714 constexpr int16_t NUM_OF_ITEMS = 9;
5715 vec.reserve(vec.size() + NUM_OF_ITEMS);
5716 vec.emplace_back(CString("IcuField"), GetIcuField());
5717 vec.emplace_back(CString("Locale"), GetLocale());
5718 vec.emplace_back(CString("Collation"), GetCollation());
5719 vec.emplace_back(CString("BoundCompare"), GetBoundCompare());
5720 vec.emplace_back(CString("CaseFirst"), JSTaggedValue(static_cast<int>(GetCaseFirst())));
5721 vec.emplace_back(CString("Usage"), JSTaggedValue(static_cast<int>(GetUsage())));
5722 vec.emplace_back(CString("Sensitivity"), JSTaggedValue(static_cast<int>(GetSensitivity())));
5723 vec.emplace_back(CString("IgnorePunctuation"), JSTaggedValue(GetIgnorePunctuation()));
5724 vec.emplace_back(CString("Numeric"), JSTaggedValue(GetNumeric()));
5725 JSObject::DumpForSnapshot(vec);
5726 }
5727
DumpForSnapshot(std::vector<Reference> &vec) const5728 void JSPluralRules::DumpForSnapshot(std::vector<Reference> &vec) const
5729 {
5730 // please update the NUM_OF_ITEMS if you change the items below
5731 constexpr int16_t NUM_OF_ITEMS = 10;
5732 vec.reserve(vec.size() + NUM_OF_ITEMS);
5733 vec.emplace_back(CString("Locale"), GetLocale());
5734 vec.emplace_back(CString("MinimumIntegerDigits"), GetMinimumIntegerDigits());
5735 vec.emplace_back(CString("MinimumFractionDigits"), GetMinimumFractionDigits());
5736 vec.emplace_back(CString("MaximumFractionDigits"), GetMaximumFractionDigits());
5737 vec.emplace_back(CString("MinimumSignificantDigits"), GetMinimumSignificantDigits());
5738 vec.emplace_back(CString("MaximumSignificantDigits"), GetMaximumSignificantDigits());
5739 vec.emplace_back(CString("RoundingType"), JSTaggedValue(static_cast<int>(GetRoundingType())));
5740 vec.emplace_back(CString("IcuPR"), GetIcuPR());
5741 vec.emplace_back(CString("IcuNF"), GetIcuNF());
5742 vec.emplace_back(CString("Type"), JSTaggedValue(static_cast<int>(GetType())));
5743 JSObject::DumpForSnapshot(vec);
5744 }
5745
DumpForSnapshot(std::vector<Reference> &vec) const5746 void JSDisplayNames::DumpForSnapshot(std::vector<Reference> &vec) const
5747 {
5748 vec.emplace_back(CString("Locale"), GetLocale());
5749 vec.emplace_back(CString("Type"), JSTaggedValue(static_cast<int>(GetType())));
5750 vec.emplace_back(CString("Style"), JSTaggedValue(static_cast<int>(GetStyle())));
5751 vec.emplace_back(CString("Fallback"), JSTaggedValue(static_cast<int>(GetFallback())));
5752 vec.emplace_back(CString("IcuLDN"), GetIcuLDN());
5753 JSObject::DumpForSnapshot(vec);
5754 }
5755
DumpForSnapshot(std::vector<Reference> &vec) const5756 void JSSegmenter::DumpForSnapshot(std::vector<Reference> &vec) const
5757 {
5758 vec.emplace_back(CString("Locale"), GetLocale());
5759 vec.emplace_back(CString("Granularity"), JSTaggedValue(static_cast<int>(GetGranularity())));
5760 vec.emplace_back(CString("IcuField"), GetIcuField());
5761 JSObject::DumpForSnapshot(vec);
5762 }
5763
DumpForSnapshot(std::vector<Reference> &vec) const5764 void JSSegments::DumpForSnapshot(std::vector<Reference> &vec) const
5765 {
5766 vec.emplace_back(CString("SegmentsString"), GetSegmentsString());
5767 vec.emplace_back(CString("UnicodeString"), GetUnicodeString());
5768 vec.emplace_back(CString("Granularity"), JSTaggedValue(static_cast<int>(GetGranularity())));
5769 vec.emplace_back(CString("IcuField"), GetIcuField());
5770 JSObject::DumpForSnapshot(vec);
5771 }
5772
DumpForSnapshot(std::vector<Reference> &vec) const5773 void JSSegmentIterator::DumpForSnapshot(std::vector<Reference> &vec) const
5774 {
5775 vec.emplace_back(CString("IteratedString"), GetIteratedString());
5776 vec.emplace_back(CString("UnicodeString"), GetUnicodeString());
5777 vec.emplace_back(CString("Granularity"), JSTaggedValue(static_cast<int>(GetGranularity())));
5778 vec.emplace_back(CString("IcuField"), GetIcuField());
5779 JSObject::DumpForSnapshot(vec);
5780 }
5781
DumpForSnapshot(std::vector<Reference> &vec) const5782 void JSListFormat::DumpForSnapshot(std::vector<Reference> &vec) const
5783 {
5784 vec.emplace_back(CString("Locale"), GetLocale());
5785 vec.emplace_back(CString("Type"), JSTaggedValue(static_cast<int>(GetType())));
5786 vec.emplace_back(CString("Style"), JSTaggedValue(static_cast<int>(GetStyle())));
5787 vec.emplace_back(CString("IcuLF"), GetIcuLF());
5788 JSObject::DumpForSnapshot(vec);
5789 }
5790 #endif
DumpForSnapshot(std::vector<Reference> &vec) const5791 void JSGeneratorObject::DumpForSnapshot(std::vector<Reference> &vec) const
5792 {
5793 vec.emplace_back(CString("GeneratorContext"), GetGeneratorContext());
5794 vec.emplace_back(CString("ResumeResult"), GetResumeResult());
5795 vec.emplace_back(CString("GeneratorState"), JSTaggedValue(static_cast<int>(GetGeneratorState())));
5796 vec.emplace_back(CString("ResumeMode"), JSTaggedValue(static_cast<int>(GetResumeMode())));
5797 JSObject::DumpForSnapshot(vec);
5798 }
5799
DumpForSnapshot(std::vector<Reference> &vec) const5800 void JSAsyncGeneratorObject::DumpForSnapshot(std::vector<Reference> &vec) const
5801 {
5802 vec.emplace_back(CString("GeneratorContext"), GetGeneratorContext());
5803 vec.emplace_back(CString("AsyncGeneratorQueue"), GetAsyncGeneratorQueue());
5804 vec.emplace_back(CString("GeneratorBrand"), GetGeneratorBrand());
5805 vec.emplace_back(CString("ResumeResult"), GetResumeResult());
5806 vec.emplace_back(CString("AsyncGeneratorState"), JSTaggedValue(static_cast<int>(GetAsyncGeneratorState())));
5807 vec.emplace_back(CString("ResumeMode"), JSTaggedValue(static_cast<int>(GetResumeMode())));
5808 JSObject::DumpForSnapshot(vec);
5809 }
5810
DumpForSnapshot(std::vector<Reference> &vec) const5811 void JSAsyncFuncObject::DumpForSnapshot(std::vector<Reference> &vec) const
5812 {
5813 vec.emplace_back(CString("Promise"), GetPromise());
5814 JSObject::DumpForSnapshot(vec);
5815 }
5816
DumpForSnapshot(std::vector<Reference> &vec) const5817 void GeneratorContext::DumpForSnapshot(std::vector<Reference> &vec) const
5818 {
5819 // please update the NUM_OF_ITEMS if you change the items below
5820 constexpr int16_t NUM_OF_ITEMS = 8;
5821 vec.reserve(vec.size() + NUM_OF_ITEMS);
5822 vec.emplace_back(CString("RegsArray"), GetRegsArray());
5823 vec.emplace_back(CString("Method"), GetMethod());
5824 vec.emplace_back(CString("This"), GetThis());
5825 vec.emplace_back(CString("Acc"), GetAcc());
5826 vec.emplace_back(CString("GeneratorObject"), GetGeneratorObject());
5827 vec.emplace_back(CString("LexicalEnv"), GetLexicalEnv());
5828 vec.emplace_back(CString("NRegs"), JSTaggedValue(GetNRegs()));
5829 vec.emplace_back(CString("BCOffset"), JSTaggedValue(GetBCOffset()));
5830 }
5831
DumpForSnapshot(std::vector<Reference> &vec) const5832 void ProtoChangeMarker::DumpForSnapshot(std::vector<Reference> &vec) const
5833 {
5834 vec.emplace_back(CString("Promise"), JSTaggedValue(GetHasChanged()));
5835 }
5836
DumpForSnapshot(std::vector<Reference> &vec) const5837 void MarkerCell::DumpForSnapshot(std::vector<Reference> &vec) const
5838 {
5839 vec.emplace_back(CString("IsDetectorInvalid"), JSTaggedValue(GetIsDetectorInvalid()));
5840 }
5841
DumpForSnapshot(std::vector<Reference> &vec) const5842 void ProtoChangeDetails::DumpForSnapshot(std::vector<Reference> &vec) const
5843 {
5844 vec.emplace_back(CString("ChangeListener"), GetChangeListener());
5845 vec.emplace_back(CString("RegisterIndex"), JSTaggedValue(GetRegisterIndex()));
5846 }
5847
DumpForSnapshot(std::vector<Reference> &vec) const5848 void MachineCode::DumpForSnapshot(std::vector<Reference> &vec) const
5849 {
5850 vec.emplace_back(CString("InstructionSizeInBytes"), JSTaggedValue(GetInstructionSizeInBytes()));
5851 }
5852
DumpForSnapshot(std::vector<Reference> &vec) const5853 void TrackInfo::DumpForSnapshot(std::vector<Reference> &vec) const
5854 {
5855 vec.emplace_back("ElementsKind", JSTaggedValue(static_cast<uint32_t>(GetElementsKind())));
5856
5857 vec.emplace_back(CString("CachedHClass"), GetCachedHClass());
5858 vec.emplace_back(CString("CachedFunc"), GetCachedFunc());
5859 vec.emplace_back(CString("ArrayLength"), JSTaggedValue(GetArrayLength()));
5860 }
5861
DumpForSnapshot(std::vector<Reference> &vec) const5862 void ClassInfoExtractor::DumpForSnapshot(std::vector<Reference> &vec) const
5863 {
5864 // please update the NUM_OF_ITEMS if you change the items below
5865 constexpr int16_t NUM_OF_ITEMS = 6;
5866 vec.reserve(vec.size() + NUM_OF_ITEMS);
5867 vec.emplace_back(CString("NonStaticKeys"), GetNonStaticKeys());
5868 vec.emplace_back(CString("NonStaticProperties"), GetNonStaticProperties());
5869 vec.emplace_back(CString("NonStaticElements"), GetNonStaticElements());
5870 vec.emplace_back(CString("StaticKeys"), GetStaticKeys());
5871 vec.emplace_back(CString("StaticProperties"), GetStaticProperties());
5872 vec.emplace_back(CString("StaticElements"), GetStaticElements());
5873 vec.emplace_back(CString("ConstructorMethod"), GetConstructorMethod());
5874 vec.emplace_back(CString("BitField"), JSTaggedValue(GetBitField()));
5875 }
5876
DumpForSnapshot(std::vector<Reference> &vec) const5877 void SourceTextModule::DumpForSnapshot(std::vector<Reference> &vec) const
5878 {
5879 // please update the NUM_OF_ITEMS if you change the items below
5880 constexpr int16_t NUM_OF_ITEMS = 14;
5881 vec.reserve(vec.size() + NUM_OF_ITEMS);
5882 vec.emplace_back(CString("Environment"), GetEnvironment());
5883 vec.emplace_back(CString("Namespace"), GetNamespace());
5884 vec.emplace_back(CString("RequestedModules"), GetRequestedModules());
5885 vec.emplace_back(CString("ImportEntries"), GetImportEntries());
5886 vec.emplace_back(CString("LocalExportEntries"), GetLocalExportEntries());
5887 vec.emplace_back(CString("IndirectExportEntries"), GetIndirectExportEntries());
5888 vec.emplace_back(CString("StarExportEntries"), GetStarExportEntries());
5889 vec.emplace_back(CString("Status"), JSTaggedValue(static_cast<int32_t>(GetStatus())));
5890 vec.emplace_back(CString("EvaluationError"), JSTaggedValue(GetEvaluationError()));
5891 vec.emplace_back(CString("DFSIndex"), JSTaggedValue(GetDFSIndex()));
5892 vec.emplace_back(CString("DFSAncestorIndex"), JSTaggedValue(GetDFSAncestorIndex()));
5893 vec.emplace_back(CString("NameDictionary"), GetNameDictionary());
5894 vec.emplace_back(CString("CycleRoot"), GetCycleRoot());
5895 vec.emplace_back(CString("TopLevelCapability"), GetTopLevelCapability());
5896 vec.emplace_back(CString("AsyncParentModules"), GetAsyncParentModules());
5897 vec.emplace_back(CString("SendableEnv"), GetSendableEnv());
5898 vec.emplace_back(CString("HasTLA"), JSTaggedValue(GetHasTLA()));
5899 vec.emplace_back(CString("AsyncEvaluatingOrdinal"), JSTaggedValue(GetAsyncEvaluatingOrdinal()));
5900 vec.emplace_back(CString("PendingAsyncDependencies"), JSTaggedValue(GetPendingAsyncDependencies()));
5901 }
5902
DumpForSnapshot(std::vector<Reference> &vec) const5903 void ImportEntry::DumpForSnapshot(std::vector<Reference> &vec) const
5904 {
5905 vec.emplace_back(CString("ModuleRequest"), GetModuleRequest());
5906 vec.emplace_back(CString("ImportName"), GetImportName());
5907 vec.emplace_back(CString("LocalName"), GetLocalName());
5908 }
5909
DumpForSnapshot(std::vector<Reference> &vec) const5910 void LocalExportEntry::DumpForSnapshot(std::vector<Reference> &vec) const
5911 {
5912 vec.emplace_back(CString("ExportName"), GetExportName());
5913 vec.emplace_back(CString("LocalName"), GetLocalName());
5914 }
5915
DumpForSnapshot(std::vector<Reference> &vec) const5916 void IndirectExportEntry::DumpForSnapshot(std::vector<Reference> &vec) const
5917 {
5918 vec.emplace_back(CString("ExportName"), GetExportName());
5919 vec.emplace_back(CString("ModuleRequest"), GetModuleRequest());
5920 vec.emplace_back(CString("ImportName"), GetImportName());
5921 }
5922
DumpForSnapshot(std::vector<Reference> &vec) const5923 void StarExportEntry::DumpForSnapshot(std::vector<Reference> &vec) const
5924 {
5925 vec.emplace_back(CString("ModuleRequest"), GetModuleRequest());
5926 }
5927
DumpForSnapshot(std::vector<Reference> &vec) const5928 void ResolvedBinding::DumpForSnapshot(std::vector<Reference> &vec) const
5929 {
5930 vec.emplace_back(CString("Module"), GetModule());
5931 vec.emplace_back(CString("BindingName"), GetBindingName());
5932 }
5933
DumpForSnapshot(std::vector<Reference> &vec) const5934 void ResolvedIndexBinding::DumpForSnapshot(std::vector<Reference> &vec) const
5935 {
5936 vec.emplace_back(CString("Module"), GetModule());
5937 vec.emplace_back(CString("Index"), JSTaggedValue(GetIndex()));
5938 }
5939
DumpForSnapshot(std::vector<Reference> &vec) const5940 void ResolvedRecordIndexBinding::DumpForSnapshot(std::vector<Reference> &vec) const
5941 {
5942 vec.emplace_back(CString("ModuleRecord"), GetModuleRecord());
5943 vec.emplace_back(CString("AbcFileName"), GetAbcFileName());
5944 vec.emplace_back(CString("Index"), JSTaggedValue(GetIndex()));
5945 }
5946
DumpForSnapshot(std::vector<Reference> &vec) const5947 void ResolvedRecordBinding::DumpForSnapshot(std::vector<Reference> &vec) const
5948 {
5949 vec.emplace_back(CString("ModuleRecord"), GetModuleRecord());
5950 vec.emplace_back(CString("BindingName"), GetBindingName());
5951 }
5952
DumpForSnapshot(std::vector<Reference> &vec) const5953 void ModuleNamespace::DumpForSnapshot(std::vector<Reference> &vec) const
5954 {
5955 vec.emplace_back(CString("Module"), GetModule());
5956 vec.emplace_back(CString("Exports"), GetExports());
5957 vec.emplace_back(CString("DeregisterProcession"), GetDeregisterProcession());
5958 JSObject::DumpForSnapshot(vec);
5959 }
5960
DumpForSnapshot(std::vector<Reference> &vec) const5961 void NativeModuleFailureInfo::DumpForSnapshot(std::vector<Reference> &vec) const
5962 {
5963 vec.emplace_back(CString("ArkNativeModuleFailureInfo"), GetArkNativeModuleFailureInfo());
5964 JSObject::DumpForSnapshot(vec);
5965 }
5966
DumpForSnapshot(std::vector<Reference> &vec) const5967 void CjsModule::DumpForSnapshot(std::vector<Reference> &vec) const
5968 {
5969 vec.emplace_back(CString("Id"), GetId());
5970 vec.emplace_back(CString("Path"), GetPath());
5971 vec.emplace_back(CString("Exports"), GetExports());
5972 vec.emplace_back(CString("Filename"), GetFilename());
5973 vec.emplace_back(CString("BitField"), JSTaggedValue(GetBitField()));
5974 JSObject::DumpForSnapshot(vec);
5975 }
5976
DumpForSnapshot(std::vector<Reference> &vec) const5977 void CjsExports::DumpForSnapshot(std::vector<Reference> &vec) const
5978 {
5979 vec.emplace_back(CString("Exports"), GetExports());
5980 JSObject::DumpForSnapshot(vec);
5981 }
5982
DumpForSnapshot(std::vector<Reference> &vec) const5983 void CjsRequire::DumpForSnapshot(std::vector<Reference> &vec) const
5984 {
5985 vec.emplace_back(CString("Cache"), GetCache());
5986 vec.emplace_back(CString("Parent"), GetParent());
5987 JSObject::DumpForSnapshot(vec);
5988 }
5989
DumpForSnapshot(std::vector<Reference> &vec) const5990 void ClassLiteral::DumpForSnapshot(std::vector<Reference> &vec) const
5991 {
5992 vec.emplace_back(CString("Array"), GetArray());
5993 vec.emplace_back(CString("IsAOTUsed"), JSTaggedValue(GetIsAOTUsed()));
5994 if (!GetArray().IsUndefined()) {
5995 DumpArrayClass(TaggedArray::Cast(GetArray().GetTaggedObject()), vec);
5996 }
5997 }
5998 } // namespace panda::ecmascript
5999