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