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