../deps/v8/src/handles/handles-inl.h

Bug Summary

File:	out/../deps/v8/src/handles/handles-inl.h
Warning:	line 184, column 27 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name objects-printer.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D V8_GYP_BUILD -D V8_TYPED_ARRAY_MAX_SIZE_IN_HEAP=64 -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D V8_TARGET_ARCH_X64 -D V8_HAVE_TARGET_OS -D V8_TARGET_OS_LINUX -D V8_EMBEDDER_STRING="-node.8" -D ENABLE_DISASSEMBLER -D V8_PROMISE_INTERNAL_FIELD_COUNT=1 -D V8_SHORT_BUILTIN_CALLS -D OBJECT_PRINT -D V8_INTL_SUPPORT -D V8_ATOMIC_OBJECT_FIELD_WRITES -D V8_ENABLE_LAZY_SOURCE_POSITIONS -D V8_USE_SIPHASH -D V8_SHARED_RO_HEAP -D V8_WIN64_UNWINDING_INFO -D V8_ENABLE_REGEXP_INTERPRETER_THREADED_DISPATCH -D V8_SNAPSHOT_COMPRESSION -D V8_ENABLE_WEBASSEMBLY -D V8_ENABLE_JAVASCRIPT_PROMISE_HOOKS -D V8_ALLOCATION_FOLDING -D V8_ALLOCATION_SITE_TRACKING -D V8_SCRIPTORMODULE_LEGACY_LIFETIME -D V8_ADVANCED_BIGINT_ALGORITHMS -D ICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_STATIC -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_STATIC_IMPLEMENTATION=1 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/v8 -I ../deps/v8/include -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/inspector-generated-output-root -I ../deps/v8/third_party/inspector_protocol -I /home/maurizio/node-v18.6.0/out/Release/obj/gen -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/generate-bytecode-output-root -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/common -I ../deps/v8/third_party/zlib -I ../deps/v8/third_party/zlib/google -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-return-type -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/v8/src/diagnostics/objects-printer.cc

../deps/v8/src/diagnostics/objects-printer.cc

→

1// Copyright 2012 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.

5#include <iomanip>
6#include <memory>

8#include "src/common/globals.h"
9#include "src/diagnostics/disasm.h"
10#include "src/diagnostics/disassembler.h"
11#include "src/execution/isolate-utils-inl.h"
12#include "src/heap/heap-inl.h"                // For InOldSpace.
13#include "src/heap/heap-write-barrier-inl.h"  // For GetIsolateFromWritableObj.
14#include "src/ic/handler-configuration-inl.h"
15#include "src/init/bootstrapper.h"
16#include "src/interpreter/bytecodes.h"
17#include "src/objects/all-objects-inl.h"
18#include "src/objects/code-kind.h"
19#include "src/regexp/regexp.h"
20#include "src/snapshot/embedded/embedded-data.h"
21#include "src/utils/ostreams.h"

23#if V8_ENABLE_WEBASSEMBLY1
24#include "src/debug/debug-wasm-objects-inl.h"
25#include "src/wasm/wasm-code-manager.h"
26#include "src/wasm/wasm-engine.h"
27#include "src/wasm/wasm-objects-inl.h"
28#endif  // V8_ENABLE_WEBASSEMBLY

30namespace v8 {
31namespace internal {

33#ifdef OBJECT_PRINT1

35void Object::Print() const {
// Output into debugger's command window if a debugger is attached.
DbgStdoutStream dbg_os;
this->Print(dbg_os);
dbg_os << std::flush;

StdoutStream os;
this->Print(os);
os << std::flush;
44}

46void Object::Print(std::ostream& os) const {
if (IsSmi()) {
  os << "Smi: " << std::hex << "0x" << Smi::ToInt(*this);
  os << std::dec << " (" << Smi::ToInt(*this) << ")\n";
} else {
  HeapObject::cast(*this).HeapObjectPrint(os);
}
53}

55namespace {

57void PrintHeapObjectHeaderWithoutMap(HeapObject object, std::ostream& os,
                                   const char* id) {
PtrComprCageBase cage_base = GetPtrComprCageBaseSlow(object);
os << reinterpret_cast<void*>(object.ptr()) << ": [";
if (id != nullptr) {
  os << id;
} else {
  os << object.map(cage_base).instance_type();
}
os << "]";
if (ReadOnlyHeap::Contains(object)) {
  os << " in ReadOnlySpace";
} else if (GetHeapFromWritableObject(object)->InOldSpace(object)) {
  os << " in OldSpace";
}
72}

74template <typename T>
75void PrintDictionaryContents(std::ostream& os, T dict) {
DisallowGarbageCollection no_gc;
ReadOnlyRoots roots = dict.GetReadOnlyRoots();

if (dict.Capacity() == 0) {
1
Assuming the condition is false→
2
←
Taking false branch→
  return;
}

83#ifdef V8_ENABLE_SWISS_NAME_DICTIONARY
Isolate* isolate = GetIsolateFromWritableObject(dict);
// IterateEntries for SwissNameDictionary needs to create a handle.
HandleScope scope(isolate);
87#endif
for (InternalIndex i : dict.IterateEntries()) {
3
←
Calling 'SwissNameDictionary::IterateEntries'→
  Object k;
  if (!dict.ToKey(roots, i, &k)) continue;
  os << "\n   ";
  if (k.IsString()) {
    String::cast(k).PrintUC16(os);
  } else {
    os << Brief(k);
  }
  os << ": " << Brief(dict.ValueAt(i)) << " ";
  dict.DetailsAt(i).PrintAsSlowTo(os, !T::kIsOrderedDictionaryType);
}
100}
101}  // namespace

103void HeapObject::PrintHeader(std::ostream& os, const char* id) {
PrintHeapObjectHeaderWithoutMap(*this, os, id);
PtrComprCageBase cage_base = GetPtrComprCageBaseSlow(*this);
if (!IsMap(cage_base)) os << "\n - map: " << Brief(map(cage_base));
107}

109void HeapObject::HeapObjectPrint(std::ostream& os) {
PtrComprCageBase cage_base = GetPtrComprCageBaseSlow(*this);

InstanceType instance_type = map(cage_base).instance_type();

if (instance_type < FIRST_NONSTRING_TYPE) {
  String::cast(*this).StringPrint(os);
  os << "\n";
  return;
}

switch (instance_type) {
  case AWAIT_CONTEXT_TYPE:
  case BLOCK_CONTEXT_TYPE:
  case CATCH_CONTEXT_TYPE:
  case DEBUG_EVALUATE_CONTEXT_TYPE:
  case EVAL_CONTEXT_TYPE:
  case FUNCTION_CONTEXT_TYPE:
  case MODULE_CONTEXT_TYPE:
  case SCRIPT_CONTEXT_TYPE:
  case WITH_CONTEXT_TYPE:
    Context::cast(*this).ContextPrint(os);
    break;
  case SCRIPT_CONTEXT_TABLE_TYPE:
    FixedArray::cast(*this).FixedArrayPrint(os);
    break;
  case NATIVE_CONTEXT_TYPE:
    NativeContext::cast(*this).NativeContextPrint(os);
    break;
  case HASH_TABLE_TYPE:
    ObjectHashTable::cast(*this).ObjectHashTablePrint(os);
    break;
  case NAME_TO_INDEX_HASH_TABLE_TYPE:
    NameToIndexHashTable::cast(*this).NameToIndexHashTablePrint(os);
    break;
  case REGISTERED_SYMBOL_TABLE_TYPE:
    RegisteredSymbolTable::cast(*this).RegisteredSymbolTablePrint(os);
    break;
  case ORDERED_HASH_MAP_TYPE:
    OrderedHashMap::cast(*this).OrderedHashMapPrint(os);
    break;
  case ORDERED_HASH_SET_TYPE:
    OrderedHashSet::cast(*this).OrderedHashSetPrint(os);
    break;
  case ORDERED_NAME_DICTIONARY_TYPE:
    OrderedNameDictionary::cast(*this).OrderedNameDictionaryPrint(os);
    break;
  case NAME_DICTIONARY_TYPE:
    NameDictionary::cast(*this).NameDictionaryPrint(os);
    break;
  case GLOBAL_DICTIONARY_TYPE:
    GlobalDictionary::cast(*this).GlobalDictionaryPrint(os);
    break;
  case SIMPLE_NUMBER_DICTIONARY_TYPE:
    FixedArray::cast(*this).FixedArrayPrint(os);
    break;
  case NUMBER_DICTIONARY_TYPE:
    NumberDictionary::cast(*this).NumberDictionaryPrint(os);
    break;
  case EPHEMERON_HASH_TABLE_TYPE:
    EphemeronHashTable::cast(*this).EphemeronHashTablePrint(os);
    break;
  case OBJECT_BOILERPLATE_DESCRIPTION_TYPE:
    ObjectBoilerplateDescription::cast(*this)
        .ObjectBoilerplateDescriptionPrint(os);
    break;
  case TRANSITION_ARRAY_TYPE:
    TransitionArray::cast(*this).TransitionArrayPrint(os);
    break;
  case CLOSURE_FEEDBACK_CELL_ARRAY_TYPE:
    ClosureFeedbackCellArray::cast(*this).ClosureFeedbackCellArrayPrint(os);
    break;

  case FILLER_TYPE:
    os << "filler";
    break;
  case JS_API_OBJECT_TYPE:
  case JS_ARRAY_ITERATOR_PROTOTYPE_TYPE:
  case JS_CONTEXT_EXTENSION_OBJECT_TYPE:
  case JS_ERROR_TYPE:
  case JS_ITERATOR_PROTOTYPE_TYPE:
  case JS_MAP_ITERATOR_PROTOTYPE_TYPE:
  case JS_OBJECT_PROTOTYPE_TYPE:
  case JS_PROMISE_PROTOTYPE_TYPE:
  case JS_REG_EXP_PROTOTYPE_TYPE:
  case JS_SET_ITERATOR_PROTOTYPE_TYPE:
  case JS_SET_PROTOTYPE_TYPE:
  case JS_SPECIAL_API_OBJECT_TYPE:
  case JS_STRING_ITERATOR_PROTOTYPE_TYPE:
  case JS_TYPED_ARRAY_PROTOTYPE_TYPE:
    JSObject::cast(*this).JSObjectPrint(os);
    break;
201#if V8_ENABLE_WEBASSEMBLY1
  case WASM_INSTANCE_OBJECT_TYPE:
    WasmInstanceObject::cast(*this).WasmInstanceObjectPrint(os);
    break;
  case WASM_VALUE_OBJECT_TYPE:
    WasmValueObject::cast(*this).WasmValueObjectPrint(os);
    break;
208#endif  // V8_ENABLE_WEBASSEMBLY
  case CODE_TYPE:
    Code::cast(*this).CodePrint(os);
    break;
  case CODE_DATA_CONTAINER_TYPE:
    CodeDataContainer::cast(*this).CodeDataContainerPrint(os);
    break;
  case JS_SET_KEY_VALUE_ITERATOR_TYPE:
  case JS_SET_VALUE_ITERATOR_TYPE:
    JSSetIterator::cast(*this).JSSetIteratorPrint(os);
    break;
  case JS_MAP_KEY_ITERATOR_TYPE:
  case JS_MAP_KEY_VALUE_ITERATOR_TYPE:
  case JS_MAP_VALUE_ITERATOR_TYPE:
    JSMapIterator::cast(*this).JSMapIteratorPrint(os);
    break;
224#define MAKE_TORQUE_CASE(Name, TYPE)   \
case TYPE:                           \
  Name::cast(*this).Name##Print(os); \
  break;
    // Every class that has its fields defined in a .tq file and corresponds
    // to exactly one InstanceType value is included in the following list.
    TORQUE_INSTANCE_CHECKERS_SINGLE_FULLY_DEFINED(MAKE_TORQUE_CASE)MAKE_TORQUE_CASE(Symbol, SYMBOL_TYPE) MAKE_TORQUE_CASE(HeapNumber
, HEAP_NUMBER_TYPE) MAKE_TORQUE_CASE(Oddball, ODDBALL_TYPE) MAKE_TORQUE_CASE
(PromiseFulfillReactionJobTask, PROMISE_FULFILL_REACTION_JOB_TASK_TYPE
) MAKE_TORQUE_CASE(PromiseRejectReactionJobTask, PROMISE_REJECT_REACTION_JOB_TASK_TYPE
) MAKE_TORQUE_CASE(CallableTask, CALLABLE_TASK_TYPE) MAKE_TORQUE_CASE
(CallbackTask, CALLBACK_TASK_TYPE) MAKE_TORQUE_CASE(PromiseResolveThenableJobTask
, PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE) MAKE_TORQUE_CASE(FunctionTemplateInfo
, FUNCTION_TEMPLATE_INFO_TYPE) MAKE_TORQUE_CASE(ObjectTemplateInfo
, OBJECT_TEMPLATE_INFO_TYPE) MAKE_TORQUE_CASE(AccessCheckInfo
, ACCESS_CHECK_INFO_TYPE) MAKE_TORQUE_CASE(AccessorInfo, ACCESSOR_INFO_TYPE
) MAKE_TORQUE_CASE(AccessorPair, ACCESSOR_PAIR_TYPE) MAKE_TORQUE_CASE
(AliasedArgumentsEntry, ALIASED_ARGUMENTS_ENTRY_TYPE) MAKE_TORQUE_CASE
(AllocationMemento, ALLOCATION_MEMENTO_TYPE) MAKE_TORQUE_CASE
(ArrayBoilerplateDescription, ARRAY_BOILERPLATE_DESCRIPTION_TYPE
) MAKE_TORQUE_CASE(AsmWasmData, ASM_WASM_DATA_TYPE) MAKE_TORQUE_CASE
(AsyncGeneratorRequest, ASYNC_GENERATOR_REQUEST_TYPE) MAKE_TORQUE_CASE
(BreakPoint, BREAK_POINT_TYPE) MAKE_TORQUE_CASE(BreakPointInfo
, BREAK_POINT_INFO_TYPE) MAKE_TORQUE_CASE(CachedTemplateObject
, CACHED_TEMPLATE_OBJECT_TYPE) MAKE_TORQUE_CASE(CallHandlerInfo
, CALL_HANDLER_INFO_TYPE) MAKE_TORQUE_CASE(CallSiteInfo, CALL_SITE_INFO_TYPE
) MAKE_TORQUE_CASE(ClassPositions, CLASS_POSITIONS_TYPE) MAKE_TORQUE_CASE
(DebugInfo, DEBUG_INFO_TYPE) MAKE_TORQUE_CASE(EnumCache, ENUM_CACHE_TYPE
) MAKE_TORQUE_CASE(ErrorStackData, ERROR_STACK_DATA_TYPE) MAKE_TORQUE_CASE
(FeedbackCell, FEEDBACK_CELL_TYPE) MAKE_TORQUE_CASE(FunctionTemplateRareData
, FUNCTION_TEMPLATE_RARE_DATA_TYPE) MAKE_TORQUE_CASE(InterceptorInfo
, INTERCEPTOR_INFO_TYPE) MAKE_TORQUE_CASE(InterpreterData, INTERPRETER_DATA_TYPE
) MAKE_TORQUE_CASE(ModuleRequest, MODULE_REQUEST_TYPE) MAKE_TORQUE_CASE
(PromiseCapability, PROMISE_CAPABILITY_TYPE) MAKE_TORQUE_CASE
(PromiseOnStack, PROMISE_ON_STACK_TYPE) MAKE_TORQUE_CASE(PromiseReaction
, PROMISE_REACTION_TYPE) MAKE_TORQUE_CASE(PropertyDescriptorObject
, PROPERTY_DESCRIPTOR_OBJECT_TYPE) MAKE_TORQUE_CASE(PrototypeInfo
, PROTOTYPE_INFO_TYPE) MAKE_TORQUE_CASE(RegExpBoilerplateDescription
, REG_EXP_BOILERPLATE_DESCRIPTION_TYPE) MAKE_TORQUE_CASE(Script
, SCRIPT_TYPE) MAKE_TORQUE_CASE(ScriptOrModule, SCRIPT_OR_MODULE_TYPE
) MAKE_TORQUE_CASE(SourceTextModuleInfoEntry, SOURCE_TEXT_MODULE_INFO_ENTRY_TYPE
) MAKE_TORQUE_CASE(StackFrameInfo, STACK_FRAME_INFO_TYPE) MAKE_TORQUE_CASE
(TemplateObjectDescription, TEMPLATE_OBJECT_DESCRIPTION_TYPE)
 MAKE_TORQUE_CASE(Tuple2, TUPLE2_TYPE) MAKE_TORQUE_CASE(WasmContinuationObject
, WASM_CONTINUATION_OBJECT_TYPE) MAKE_TORQUE_CASE(WasmExceptionTag
, WASM_EXCEPTION_TAG_TYPE) MAKE_TORQUE_CASE(WasmIndirectFunctionTable
, WASM_INDIRECT_FUNCTION_TABLE_TYPE) MAKE_TORQUE_CASE(ByteArray
, BYTE_ARRAY_TYPE) MAKE_TORQUE_CASE(BytecodeArray, BYTECODE_ARRAY_TYPE
) MAKE_TORQUE_CASE(FixedDoubleArray, FIXED_DOUBLE_ARRAY_TYPE)
 MAKE_TORQUE_CASE(InternalClassWithSmiElements, INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE
) MAKE_TORQUE_CASE(SloppyArgumentsElements, SLOPPY_ARGUMENTS_ELEMENTS_TYPE
) MAKE_TORQUE_CASE(TurbofanBitsetType, TURBOFAN_BITSET_TYPE_TYPE
) MAKE_TORQUE_CASE(TurbofanHeapConstantType, TURBOFAN_HEAP_CONSTANT_TYPE_TYPE
) MAKE_TORQUE_CASE(TurbofanOtherNumberConstantType, TURBOFAN_OTHER_NUMBER_CONSTANT_TYPE_TYPE
) MAKE_TORQUE_CASE(TurbofanRangeType, TURBOFAN_RANGE_TYPE_TYPE
) MAKE_TORQUE_CASE(TurbofanUnionType, TURBOFAN_UNION_TYPE_TYPE
) MAKE_TORQUE_CASE(WasmInternalFunction, WASM_INTERNAL_FUNCTION_TYPE
) MAKE_TORQUE_CASE(WasmTypeInfo, WASM_TYPE_INFO_TYPE) MAKE_TORQUE_CASE
(UncompiledDataWithPreparseDataAndJob, UNCOMPILED_DATA_WITH_PREPARSE_DATA_AND_JOB_TYPE
) MAKE_TORQUE_CASE(UncompiledDataWithoutPreparseDataWithJob, UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_WITH_JOB_TYPE
) MAKE_TORQUE_CASE(WasmCapiFunctionData, WASM_CAPI_FUNCTION_DATA_TYPE
) MAKE_TORQUE_CASE(WasmExportedFunctionData, WASM_EXPORTED_FUNCTION_DATA_TYPE
) MAKE_TORQUE_CASE(WasmJSFunctionData, WASM_JS_FUNCTION_DATA_TYPE
) MAKE_TORQUE_CASE(ExportedSubClass, EXPORTED_SUB_CLASS_TYPE)
 MAKE_TORQUE_CASE(ExportedSubClass2, EXPORTED_SUB_CLASS2_TYPE
) MAKE_TORQUE_CASE(SmallOrderedHashMap, SMALL_ORDERED_HASH_MAP_TYPE
) MAKE_TORQUE_CASE(SmallOrderedHashSet, SMALL_ORDERED_HASH_SET_TYPE
) MAKE_TORQUE_CASE(SmallOrderedNameDictionary, SMALL_ORDERED_NAME_DICTIONARY_TYPE
) MAKE_TORQUE_CASE(AbstractInternalClassSubclass1, ABSTRACT_INTERNAL_CLASS_SUBCLASS1_TYPE
) MAKE_TORQUE_CASE(AbstractInternalClassSubclass2, ABSTRACT_INTERNAL_CLASS_SUBCLASS2_TYPE
) MAKE_TORQUE_CASE(StrongDescriptorArray, STRONG_DESCRIPTOR_ARRAY_TYPE
) MAKE_TORQUE_CASE(SourceTextModule, SOURCE_TEXT_MODULE_TYPE)
 MAKE_TORQUE_CASE(SyntheticModule, SYNTHETIC_MODULE_TYPE) MAKE_TORQUE_CASE
(Cell, CELL_TYPE) MAKE_TORQUE_CASE(CoverageInfo, COVERAGE_INFO_TYPE
) MAKE_TORQUE_CASE(EmbedderDataArray, EMBEDDER_DATA_ARRAY_TYPE
) MAKE_TORQUE_CASE(FeedbackVector, FEEDBACK_VECTOR_TYPE) MAKE_TORQUE_CASE
(FreeSpace, FREE_SPACE_TYPE) MAKE_TORQUE_CASE(InternalClass, INTERNAL_CLASS_TYPE
) MAKE_TORQUE_CASE(InternalClassWithStructElements, INTERNAL_CLASS_WITH_STRUCT_ELEMENTS_TYPE
) MAKE_TORQUE_CASE(Map, MAP_TYPE) MAKE_TORQUE_CASE(MegaDomHandler
, MEGA_DOM_HANDLER_TYPE) MAKE_TORQUE_CASE(OnHeapBasicBlockProfilerData
, ON_HEAP_BASIC_BLOCK_PROFILER_DATA_TYPE) MAKE_TORQUE_CASE(PreparseData
, PREPARSE_DATA_TYPE) MAKE_TORQUE_CASE(PropertyArray, PROPERTY_ARRAY_TYPE
) MAKE_TORQUE_CASE(PropertyCell, PROPERTY_CELL_TYPE) MAKE_TORQUE_CASE
(ScopeInfo, SCOPE_INFO_TYPE) MAKE_TORQUE_CASE(SharedFunctionInfo
, SHARED_FUNCTION_INFO_TYPE) MAKE_TORQUE_CASE(SmiBox, SMI_BOX_TYPE
) MAKE_TORQUE_CASE(SmiPair, SMI_PAIR_TYPE) MAKE_TORQUE_CASE(SortState
, SORT_STATE_TYPE) MAKE_TORQUE_CASE(SwissNameDictionary, SWISS_NAME_DICTIONARY_TYPE
) MAKE_TORQUE_CASE(WasmApiFunctionRef, WASM_API_FUNCTION_REF_TYPE
) MAKE_TORQUE_CASE(WasmOnFulfilledData, WASM_ON_FULFILLED_DATA_TYPE
) MAKE_TORQUE_CASE(WeakArrayList, WEAK_ARRAY_LIST_TYPE) MAKE_TORQUE_CASE
(WeakCell, WEAK_CELL_TYPE) MAKE_TORQUE_CASE(WasmArray, WASM_ARRAY_TYPE
) MAKE_TORQUE_CASE(WasmStruct, WASM_STRUCT_TYPE) MAKE_TORQUE_CASE
(JSProxy, JS_PROXY_TYPE) MAKE_TORQUE_CASE(JSGlobalObject, JS_GLOBAL_OBJECT_TYPE
) MAKE_TORQUE_CASE(JSGlobalProxy, JS_GLOBAL_PROXY_TYPE) MAKE_TORQUE_CASE
(JSModuleNamespace, JS_MODULE_NAMESPACE_TYPE) MAKE_TORQUE_CASE
(JSPrimitiveWrapper, JS_PRIMITIVE_WRAPPER_TYPE) MAKE_TORQUE_CASE
(JSDataView, JS_DATA_VIEW_TYPE) MAKE_TORQUE_CASE(JSTypedArray
, JS_TYPED_ARRAY_TYPE) MAKE_TORQUE_CASE(JSArrayBuffer, JS_ARRAY_BUFFER_TYPE
) MAKE_TORQUE_CASE(JSPromise, JS_PROMISE_TYPE) MAKE_TORQUE_CASE
(JSBoundFunction, JS_BOUND_FUNCTION_TYPE) MAKE_TORQUE_CASE(JSWrappedFunction
, JS_WRAPPED_FUNCTION_TYPE) MAKE_TORQUE_CASE(JSAsyncFunctionObject
, JS_ASYNC_FUNCTION_OBJECT_TYPE) MAKE_TORQUE_CASE(JSAsyncGeneratorObject
, JS_ASYNC_GENERATOR_OBJECT_TYPE) MAKE_TORQUE_CASE(JSMap, JS_MAP_TYPE
) MAKE_TORQUE_CASE(JSSet, JS_SET_TYPE) MAKE_TORQUE_CASE(JSWeakMap
, JS_WEAK_MAP_TYPE) MAKE_TORQUE_CASE(JSWeakSet, JS_WEAK_SET_TYPE
) MAKE_TORQUE_CASE(JSArgumentsObject, JS_ARGUMENTS_OBJECT_TYPE
) MAKE_TORQUE_CASE(JSArray, JS_ARRAY_TYPE) MAKE_TORQUE_CASE(JSArrayIterator
, JS_ARRAY_ITERATOR_TYPE) MAKE_TORQUE_CASE(JSAsyncFromSyncIterator
, JS_ASYNC_FROM_SYNC_ITERATOR_TYPE) MAKE_TORQUE_CASE(JSCollator
, JS_COLLATOR_TYPE) MAKE_TORQUE_CASE(JSDate, JS_DATE_TYPE) MAKE_TORQUE_CASE
(JSDateTimeFormat, JS_DATE_TIME_FORMAT_TYPE) MAKE_TORQUE_CASE
(JSDisplayNames, JS_DISPLAY_NAMES_TYPE) MAKE_TORQUE_CASE(JSExternalObject
, JS_EXTERNAL_OBJECT_TYPE) MAKE_TORQUE_CASE(JSFinalizationRegistry
, JS_FINALIZATION_REGISTRY_TYPE) MAKE_TORQUE_CASE(JSListFormat
, JS_LIST_FORMAT_TYPE) MAKE_TORQUE_CASE(JSLocale, JS_LOCALE_TYPE
) MAKE_TORQUE_CASE(JSMessageObject, JS_MESSAGE_OBJECT_TYPE) MAKE_TORQUE_CASE
(JSNumberFormat, JS_NUMBER_FORMAT_TYPE) MAKE_TORQUE_CASE(JSPluralRules
, JS_PLURAL_RULES_TYPE) MAKE_TORQUE_CASE(JSRegExp, JS_REG_EXP_TYPE
) MAKE_TORQUE_CASE(JSRegExpStringIterator, JS_REG_EXP_STRING_ITERATOR_TYPE
) MAKE_TORQUE_CASE(JSRelativeTimeFormat, JS_RELATIVE_TIME_FORMAT_TYPE
) MAKE_TORQUE_CASE(JSSegmentIterator, JS_SEGMENT_ITERATOR_TYPE
) MAKE_TORQUE_CASE(JSSegmenter, JS_SEGMENTER_TYPE) MAKE_TORQUE_CASE
(JSSegments, JS_SEGMENTS_TYPE) MAKE_TORQUE_CASE(JSShadowRealm
, JS_SHADOW_REALM_TYPE) MAKE_TORQUE_CASE(JSSharedStruct, JS_SHARED_STRUCT_TYPE
) MAKE_TORQUE_CASE(JSStringIterator, JS_STRING_ITERATOR_TYPE)
 MAKE_TORQUE_CASE(JSTemporalCalendar, JS_TEMPORAL_CALENDAR_TYPE
) MAKE_TORQUE_CASE(JSTemporalDuration, JS_TEMPORAL_DURATION_TYPE
) MAKE_TORQUE_CASE(JSTemporalInstant, JS_TEMPORAL_INSTANT_TYPE
) MAKE_TORQUE_CASE(JSTemporalPlainDate, JS_TEMPORAL_PLAIN_DATE_TYPE
) MAKE_TORQUE_CASE(JSTemporalPlainDateTime, JS_TEMPORAL_PLAIN_DATE_TIME_TYPE
) MAKE_TORQUE_CASE(JSTemporalPlainMonthDay, JS_TEMPORAL_PLAIN_MONTH_DAY_TYPE
) MAKE_TORQUE_CASE(JSTemporalPlainTime, JS_TEMPORAL_PLAIN_TIME_TYPE
) MAKE_TORQUE_CASE(JSTemporalPlainYearMonth, JS_TEMPORAL_PLAIN_YEAR_MONTH_TYPE
) MAKE_TORQUE_CASE(JSTemporalTimeZone, JS_TEMPORAL_TIME_ZONE_TYPE
) MAKE_TORQUE_CASE(JSTemporalZonedDateTime, JS_TEMPORAL_ZONED_DATE_TIME_TYPE
) MAKE_TORQUE_CASE(JSV8BreakIterator, JS_V8_BREAK_ITERATOR_TYPE
) MAKE_TORQUE_CASE(JSWeakRef, JS_WEAK_REF_TYPE) MAKE_TORQUE_CASE
(WasmGlobalObject, WASM_GLOBAL_OBJECT_TYPE) MAKE_TORQUE_CASE(
WasmMemoryObject, WASM_MEMORY_OBJECT_TYPE) MAKE_TORQUE_CASE(WasmModuleObject
, WASM_MODULE_OBJECT_TYPE) MAKE_TORQUE_CASE(WasmSuspenderObject
, WASM_SUSPENDER_OBJECT_TYPE) MAKE_TORQUE_CASE(WasmTableObject
, WASM_TABLE_OBJECT_TYPE) MAKE_TORQUE_CASE(WasmTagObject, WASM_TAG_OBJECT_TYPE
)
    TORQUE_INSTANCE_CHECKERS_MULTIPLE_FULLY_DEFINED(MAKE_TORQUE_CASE)MAKE_TORQUE_CASE(FixedArray, FIXED_ARRAY_TYPE) MAKE_TORQUE_CASE
(Foreign, FOREIGN_TYPE) MAKE_TORQUE_CASE(UncompiledDataWithPreparseData
, UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE) MAKE_TORQUE_CASE(UncompiledDataWithoutPreparseData
, UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE) MAKE_TORQUE_CASE
(WasmFunctionData, WASM_FUNCTION_DATA_TYPE) MAKE_TORQUE_CASE(
ExportedSubClassBase, EXPORTED_SUB_CLASS_BASE_TYPE) MAKE_TORQUE_CASE
(DescriptorArray, DESCRIPTOR_ARRAY_TYPE) MAKE_TORQUE_CASE(WeakFixedArray
, WEAK_FIXED_ARRAY_TYPE) MAKE_TORQUE_CASE(JSObject, JS_OBJECT_TYPE
) MAKE_TORQUE_CASE(JSFunction, JS_FUNCTION_TYPE) MAKE_TORQUE_CASE
(JSGeneratorObject, JS_GENERATOR_OBJECT_TYPE)
232#undef MAKE_TORQUE_CASE

  case ALLOCATION_SITE_TYPE:
    AllocationSite::cast(*this).AllocationSitePrint(os);
    break;
  case LOAD_HANDLER_TYPE:
    LoadHandler::cast(*this).LoadHandlerPrint(os);
    break;
  case STORE_HANDLER_TYPE:
    StoreHandler::cast(*this).StoreHandlerPrint(os);
    break;
  case FEEDBACK_METADATA_TYPE:
    FeedbackMetadata::cast(*this).FeedbackMetadataPrint(os);
    break;
  case BIG_INT_BASE_TYPE:
    BigIntBase::cast(*this).BigIntBasePrint(os);
    break;
  case JS_CLASS_CONSTRUCTOR_TYPE:
  case JS_PROMISE_CONSTRUCTOR_TYPE:
  case JS_REG_EXP_CONSTRUCTOR_TYPE:
  case JS_ARRAY_CONSTRUCTOR_TYPE:
253#define TYPED_ARRAY_CONSTRUCTORS_SWITCH(Type, type, TYPE, Ctype) \
case TYPE##_TYPED_ARRAY_CONSTRUCTOR_TYPE:
    TYPED_ARRAYS(TYPED_ARRAY_CONSTRUCTORS_SWITCH)TYPED_ARRAY_CONSTRUCTORS_SWITCH(Uint8, uint8, UINT8, uint8_t)
 TYPED_ARRAY_CONSTRUCTORS_SWITCH(Int8, int8, INT8, int8_t) TYPED_ARRAY_CONSTRUCTORS_SWITCH
(Uint16, uint16, UINT16, uint16_t) TYPED_ARRAY_CONSTRUCTORS_SWITCH
(Int16, int16, INT16, int16_t) TYPED_ARRAY_CONSTRUCTORS_SWITCH
(Uint32, uint32, UINT32, uint32_t) TYPED_ARRAY_CONSTRUCTORS_SWITCH
(Int32, int32, INT32, int32_t) TYPED_ARRAY_CONSTRUCTORS_SWITCH
(Float32, float32, FLOAT32, float) TYPED_ARRAY_CONSTRUCTORS_SWITCH
(Float64, float64, FLOAT64, double) TYPED_ARRAY_CONSTRUCTORS_SWITCH
(Uint8Clamped, uint8_clamped, UINT8_CLAMPED, uint8_t) TYPED_ARRAY_CONSTRUCTORS_SWITCH
(BigUint64, biguint64, BIGUINT64, uint64_t) TYPED_ARRAY_CONSTRUCTORS_SWITCH
(BigInt64, bigint64, BIGINT64, int64_t)
256#undef TYPED_ARRAY_CONSTRUCTORS_SWITCH
    JSFunction::cast(*this).JSFunctionPrint(os);
    break;
  case INTERNALIZED_STRING_TYPE:
  case EXTERNAL_INTERNALIZED_STRING_TYPE:
  case ONE_BYTE_INTERNALIZED_STRING_TYPE:
  case EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE:
  case UNCACHED_EXTERNAL_INTERNALIZED_STRING_TYPE:
  case UNCACHED_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE:
  case STRING_TYPE:
  case CONS_STRING_TYPE:
  case EXTERNAL_STRING_TYPE:
  case SLICED_STRING_TYPE:
  case THIN_STRING_TYPE:
  case ONE_BYTE_STRING_TYPE:
  case CONS_ONE_BYTE_STRING_TYPE:
  case EXTERNAL_ONE_BYTE_STRING_TYPE:
  case SLICED_ONE_BYTE_STRING_TYPE:
  case THIN_ONE_BYTE_STRING_TYPE:
  case UNCACHED_EXTERNAL_STRING_TYPE:
  case UNCACHED_EXTERNAL_ONE_BYTE_STRING_TYPE:
  case SHARED_STRING_TYPE:
  case SHARED_ONE_BYTE_STRING_TYPE:
  case SHARED_THIN_STRING_TYPE:
  case SHARED_THIN_ONE_BYTE_STRING_TYPE:
  case JS_LAST_DUMMY_API_OBJECT_TYPE:
    // TODO(all): Handle these types too.
    os << "UNKNOWN TYPE " << map().instance_type();
    UNREACHABLE()V8_Fatal("unreachable code");
}
286}

288void ByteArray::ByteArrayPrint(std::ostream& os) {
PrintHeader(os, "ByteArray");
os << "\n - length: " << length()
   << "\n - data-start: " << static_cast<void*>(GetDataStartAddress())
   << "\n";
293}

295void BytecodeArray::BytecodeArrayPrint(std::ostream& os) {
PrintHeader(os, "BytecodeArray");
os << "\n";
Disassemble(os);
299}

301void FreeSpace::FreeSpacePrint(std::ostream& os) {
os << "free space, size " << Size() << "\n";
303}

305bool JSObject::PrintProperties(std::ostream& os) {
if (HasFastProperties()) {
  DescriptorArray descs = map().instance_descriptors(GetIsolate());
  int nof_inobject_properties = map().GetInObjectProperties();
  for (InternalIndex i : map().IterateOwnDescriptors()) {
    os << "\n    ";
    descs.GetKey(i).NamePrint(os);
    os << ": ";
    PropertyDetails details = descs.GetDetails(i);
    switch (details.location()) {
      case PropertyLocation::kField: {
        FieldIndex field_index = FieldIndex::ForDescriptor(map(), i);
        os << Brief(RawFastPropertyAt(field_index));
        break;
      }
      case PropertyLocation::kDescriptor:
        os << Brief(descs.GetStrongValue(i));
        break;
    }
    os << " ";
    details.PrintAsFastTo(os, PropertyDetails::kForProperties);
    if (details.location() == PropertyLocation::kField) {
      int field_index = details.field_index();
      if (field_index < nof_inobject_properties) {
        os << ", location: in-object";
      } else {
        field_index -= nof_inobject_properties;
        os << ", location: properties[" << field_index << "]";
      }
    } else {
      os << ", location: descriptor";
    }
  }
  return map().NumberOfOwnDescriptors() > 0;
} else if (IsJSGlobalObject()) {
  PrintDictionaryContents(
      os, JSGlobalObject::cast(*this).global_dictionary(kAcquireLoad));
} else if (V8_ENABLE_SWISS_NAME_DICTIONARY_BOOLfalse) {
  PrintDictionaryContents(os, property_dictionary_swiss());
} else {
  PrintDictionaryContents(os, property_dictionary());
}
return true;
348}

350namespace {

352template <class T>
353bool IsTheHoleAt(T array, int index) {
return false;
355}

357template <>
358bool IsTheHoleAt(FixedDoubleArray array, int index) {
return array.is_the_hole(index);
360}

362template <class T>
363double GetScalarElement(T array, int index) {
if (IsTheHoleAt(array, index)) {
  return std::numeric_limits<double>::quiet_NaN();
}
return array.get_scalar(index);
368}

370template <class T>
371void DoPrintElements(std::ostream& os, Object object, int length) {
const bool print_the_hole = std::is_same<T, FixedDoubleArray>::value;
T array = T::cast(object);
if (length == 0) return;
int previous_index = 0;
double previous_value = GetScalarElement(array, 0);
double value = 0.0;
int i;
for (i = 1; i <= length; i++) {
  if (i < length) value = GetScalarElement(array, i);
  bool values_are_nan = std::isnan(previous_value) && std::isnan(value);
  if (i != length && (previous_value == value || values_are_nan) &&
      IsTheHoleAt(array, i - 1) == IsTheHoleAt(array, i)) {
    continue;
  }
  os << "\n";
  std::stringstream ss;
  ss << previous_index;
  if (previous_index != i - 1) {
    ss << '-' << (i - 1);
  }
  os << std::setw(12) << ss.str() << ": ";
  if (print_the_hole && IsTheHoleAt(array, i - 1)) {
    os << "<the_hole>";
  } else {
    os << previous_value;
  }
  previous_index = i;
  previous_value = value;
}
401}

403template <typename ElementType>
404void PrintTypedArrayElements(std::ostream& os, const ElementType* data_ptr,
                           size_t length, bool is_on_heap) {
if (length == 0) return;
size_t previous_index = 0;
if (i::FLAG_mock_arraybuffer_allocator && !is_on_heap) {
  // Don't try to print data that's not actually allocated.
  os << "\n    0-" << length << ": <mocked array buffer bytes>";
  return;
}

ElementType previous_value = data_ptr[0];
ElementType value = 0;
for (size_t i = 1; i <= length; i++) {
  if (i < length) value = data_ptr[i];
  if (i != length && previous_value == value) {
    continue;
  }
  os << "\n";
  std::stringstream ss;
  ss << previous_index;
  if (previous_index != i - 1) {
    ss << '-' << (i - 1);
  }
  os << std::setw(12) << ss.str() << ": " << +previous_value;
  previous_index = i;
  previous_value = value;
}
431}

433template <typename T>
434void PrintFixedArrayElements(std::ostream& os, T array) {
// Print in array notation for non-sparse arrays.
Object previous_value = array.length() > 0 ? array.get(0) : Object();
Object value;
int previous_index = 0;
int i;
for (i = 1; i <= array.length(); i++) {
  if (i < array.length()) value = array.get(i);
  if (previous_value == value && i != array.length()) {
    continue;
  }
  os << "\n";
  std::stringstream ss;
  ss << previous_index;
  if (previous_index != i - 1) {
    ss << '-' << (i - 1);
  }
  os << std::setw(12) << ss.str() << ": " << Brief(previous_value);
  previous_index = i;
  previous_value = value;
}
455}

457void PrintDictionaryElements(std::ostream& os, FixedArrayBase elements) {
// Print some internal fields
NumberDictionary dict = NumberDictionary::cast(elements);
if (dict.requires_slow_elements()) {
  os << "\n   - requires_slow_elements";
} else {
  os << "\n   - max_number_key: " << dict.max_number_key();
}
PrintDictionaryContents(os, dict);
466}

468void PrintSloppyArgumentElements(std::ostream& os, ElementsKind kind,
                               SloppyArgumentsElements elements) {
FixedArray arguments_store = elements.arguments();
os << "\n    0: context: " << Brief(elements.context())
   << "\n    1: arguments_store: " << Brief(arguments_store)
   << "\n    parameter to context slot map:";
for (int i = 0; i < elements.length(); i++) {
  Object mapped_entry = elements.mapped_entries(i, kRelaxedLoad);
  os << "\n    " << i << ": param(" << i << "): " << Brief(mapped_entry);
  if (mapped_entry.IsTheHole()) {
    os << " in the arguments_store[" << i << "]";
  } else {
    os << " in the context";
  }
}
if (arguments_store.length() == 0) return;
os << "\n }"
   << "\n - arguments_store: " << Brief(arguments_store) << " "
   << ElementsKindToString(arguments_store.map().elements_kind()) << " {";
if (kind == FAST_SLOPPY_ARGUMENTS_ELEMENTS) {
  PrintFixedArrayElements(os, arguments_store);
} else {
  DCHECK_EQ(kind, SLOW_SLOPPY_ARGUMENTS_ELEMENTS)((void) 0);
  PrintDictionaryElements(os, arguments_store);
}
493}

495void PrintEmbedderData(Isolate* isolate, std::ostream& os,
                     EmbedderDataSlot slot) {
DisallowGarbageCollection no_gc;
Object value = slot.load_tagged();
os << Brief(value);
void* raw_pointer;
if (slot.ToAlignedPointer(isolate, &raw_pointer)) {
  os << ", aligned pointer: " << raw_pointer;
}
504}

506}  // namespace

508void JSObject::PrintElements(std::ostream& os) {
// Don't call GetElementsKind, its validation code can cause the printer to
// fail when debugging.
os << " - elements: " << Brief(elements()) << " {";
switch (map().elements_kind()) {
  case HOLEY_SMI_ELEMENTS:
  case PACKED_SMI_ELEMENTS:
  case HOLEY_ELEMENTS:
  case HOLEY_FROZEN_ELEMENTS:
  case HOLEY_SEALED_ELEMENTS:
  case HOLEY_NONEXTENSIBLE_ELEMENTS:
  case PACKED_ELEMENTS:
  case PACKED_FROZEN_ELEMENTS:
  case PACKED_SEALED_ELEMENTS:
  case PACKED_NONEXTENSIBLE_ELEMENTS:
  case FAST_STRING_WRAPPER_ELEMENTS: {
    PrintFixedArrayElements(os, FixedArray::cast(elements()));
    break;
  }
  case HOLEY_DOUBLE_ELEMENTS:
  case PACKED_DOUBLE_ELEMENTS: {
    DoPrintElements<FixedDoubleArray>(os, elements(), elements().length());
    break;
  }

533#define PRINT_ELEMENTS(Type, type, TYPE, elementType)                         \
case TYPE##_ELEMENTS: {                                                     \
  size_t length = JSTypedArray::cast(*this).GetLength();                    \
  bool is_on_heap = JSTypedArray::cast(*this).is_on_heap();                 \
  const elementType* data_ptr =                                             \
      static_cast<const elementType*>(JSTypedArray::cast(*this).DataPtr()); \
  PrintTypedArrayElements<elementType>(os, data_ptr, length, is_on_heap);   \
  break;                                                                    \
}
    TYPED_ARRAYS(PRINT_ELEMENTS)PRINT_ELEMENTS(Uint8, uint8, UINT8, uint8_t) PRINT_ELEMENTS(Int8
, int8, INT8, int8_t) PRINT_ELEMENTS(Uint16, uint16, UINT16, uint16_t
) PRINT_ELEMENTS(Int16, int16, INT16, int16_t) PRINT_ELEMENTS
(Uint32, uint32, UINT32, uint32_t) PRINT_ELEMENTS(Int32, int32
, INT32, int32_t) PRINT_ELEMENTS(Float32, float32, FLOAT32, float
) PRINT_ELEMENTS(Float64, float64, FLOAT64, double) PRINT_ELEMENTS
(Uint8Clamped, uint8_clamped, UINT8_CLAMPED, uint8_t) PRINT_ELEMENTS
(BigUint64, biguint64, BIGUINT64, uint64_t) PRINT_ELEMENTS(BigInt64
, bigint64, BIGINT64, int64_t)
    RAB_GSAB_TYPED_ARRAYS(PRINT_ELEMENTS)PRINT_ELEMENTS(RabGsabUint8, rab_gsab_uint8, RAB_GSAB_UINT8, uint8_t
) PRINT_ELEMENTS(RabGsabInt8, rab_gsab_int8, RAB_GSAB_INT8, int8_t
) PRINT_ELEMENTS(RabGsabUint16, rab_gsab_uint16, RAB_GSAB_UINT16
, uint16_t) PRINT_ELEMENTS(RabGsabInt16, rab_gsab_int16, RAB_GSAB_INT16
, int16_t) PRINT_ELEMENTS(RabGsabUint32, rab_gsab_uint32, RAB_GSAB_UINT32
, uint32_t) PRINT_ELEMENTS(RabGsabInt32, rab_gsab_int32, RAB_GSAB_INT32
, int32_t) PRINT_ELEMENTS(RabGsabFloat32, rab_gsab_float32, RAB_GSAB_FLOAT32
, float) PRINT_ELEMENTS(RabGsabFloat64, rab_gsab_float64, RAB_GSAB_FLOAT64
, double) PRINT_ELEMENTS(RabGsabUint8Clamped, rab_gsab_uint8_clamped
, RAB_GSAB_UINT8_CLAMPED, uint8_t) PRINT_ELEMENTS(RabGsabBigUint64
, rab_gsab_biguint64, RAB_GSAB_BIGUINT64, uint64_t) PRINT_ELEMENTS
(RabGsabBigInt64, rab_gsab_bigint64, RAB_GSAB_BIGINT64, int64_t
)
544#undef PRINT_ELEMENTS

  case DICTIONARY_ELEMENTS:
  case SLOW_STRING_WRAPPER_ELEMENTS:
    PrintDictionaryElements(os, elements());
    break;
  case FAST_SLOPPY_ARGUMENTS_ELEMENTS:
  case SLOW_SLOPPY_ARGUMENTS_ELEMENTS:
    PrintSloppyArgumentElements(os, map().elements_kind(),
                                SloppyArgumentsElements::cast(elements()));
    break;
  case WASM_ARRAY_ELEMENTS:
    // WasmArrayPrint() should be called intead.
    UNREACHABLE()V8_Fatal("unreachable code");
  case NO_ELEMENTS:
    break;
}
os << "\n }\n";
562}

564static void JSObjectPrintHeader(std::ostream& os, JSObject obj,
                              const char* id) {
Isolate* isolate = obj.GetIsolate();
obj.PrintHeader(os, id);
// Don't call GetElementsKind, its validation code can cause the printer to
// fail when debugging.
os << " [";
if (obj.HasFastProperties()) {
  os << "FastProperties";
} else {
  os << "DictionaryProperties";
}
PrototypeIterator iter(isolate, obj);
os << "]\n - prototype: " << Brief(iter.GetCurrent());
os << "\n - elements: " << Brief(obj.elements()) << " ["
   << ElementsKindToString(obj.map().elements_kind());
if (obj.elements().IsCowArray()) os << " (COW)";
os << "]";
Object hash = obj.GetHash();
if (hash.IsSmi()) {
  os << "\n - hash: " << Brief(hash);
}
if (obj.GetEmbedderFieldCount() > 0) {
  os << "\n - embedder fields: " << obj.GetEmbedderFieldCount();
}
589}

591static void JSObjectPrintBody(std::ostream& os, JSObject obj,
                            bool print_elements = true) {
os << "\n - properties: ";
Object properties_or_hash = obj.raw_properties_or_hash(kRelaxedLoad);
if (!properties_or_hash.IsSmi()) {
  os << Brief(properties_or_hash);
}
os << "\n - All own properties (excluding elements): {";
if (obj.PrintProperties(os)) os << "\n ";
os << "}\n";

if (print_elements) {
  size_t length = obj.IsJSTypedArray() ? JSTypedArray::cast(obj).GetLength()
                                       : obj.elements().length();
  if (length > 0) obj.PrintElements(os);
}
int embedder_fields = obj.GetEmbedderFieldCount();
if (embedder_fields > 0) {
  Isolate* isolate = GetIsolateForSandbox(obj);
  os << " - embedder fields = {";
  for (int i = 0; i < embedder_fields; i++) {
    os << "\n    ";
    PrintEmbedderData(isolate, os, EmbedderDataSlot(obj, i));
  }
  os << "\n }\n";
}
617}

619void JSObject::JSObjectPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, nullptr);
JSObjectPrintBody(os, *this);
622}

624void JSGeneratorObject::JSGeneratorObjectPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSGeneratorObject");
os << "\n - function: " << Brief(function());
os << "\n - context: " << Brief(context());
os << "\n - receiver: " << Brief(receiver());
if (is_executing() || is_closed()) {
  os << "\n - input: " << Brief(input_or_debug_pos());
} else {
  DCHECK(is_suspended())((void) 0);
  os << "\n - debug pos: " << Brief(input_or_debug_pos());
}
const char* mode = "(invalid)";
switch (resume_mode()) {
  case kNext:
    mode = ".next()";
    break;
  case kReturn:
    mode = ".return()";
    break;
  case kThrow:
    mode = ".throw()";
    break;
}
os << "\n - resume mode: " << mode;
os << "\n - continuation: " << continuation();
if (is_closed()) os << " (closed)";
if (is_executing()) os << " (executing)";
if (is_suspended()) os << " (suspended)";
if (is_suspended()) {
  DisallowGarbageCollection no_gc;
  SharedFunctionInfo fun_info = function().shared();
  if (fun_info.HasSourceCode()) {
    Script script = Script::cast(fun_info.script());
    String script_name = script.name().IsString()
                             ? String::cast(script.name())
                             : GetReadOnlyRoots().empty_string();

    os << "\n - source position: ";
    // Can't collect source positions here if not available as that would
    // allocate memory.
    Isolate* isolate = GetIsolate();
    if (fun_info.HasBytecodeArray() &&
        fun_info.GetBytecodeArray(isolate).HasSourcePositionTable()) {
      os << source_position();
      os << " (";
      script_name.PrintUC16(os);
      int lin = script.GetLineNumber(source_position()) + 1;
      int col = script.GetColumnNumber(source_position()) + 1;
      os << ", lin " << lin;
      os << ", col " << col;
    } else {
      os << "unavailable";
    }
    os << ")";
  }
}
os << "\n - register file: " << Brief(parameters_and_registers());
JSObjectPrintBody(os, *this);
682}

684void JSArray::JSArrayPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSArray");
os << "\n - length: " << Brief(this->length());
JSObjectPrintBody(os, *this);
688}

690void JSPromise::JSPromisePrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSPromise");
os << "\n - status: " << JSPromise::Status(status());
if (status() == Promise::kPending) {
  os << "\n - reactions: " << Brief(reactions());
} else {
  os << "\n - result: " << Brief(result());
}
os << "\n - has_handler: " << has_handler();
os << "\n - handled_hint: " << handled_hint();
os << "\n - is_silent: " << is_silent();
JSObjectPrintBody(os, *this);
702}

704void JSRegExp::JSRegExpPrint(std::ostream& os) {
Isolate* isolate = GetIsolate();
JSObjectPrintHeader(os, *this, "JSRegExp");
os << "\n - data: " << Brief(data());
os << "\n - source: " << Brief(source());
os << "\n - flags: " << Brief(*JSRegExp::StringFromFlags(isolate, flags()));
JSObjectPrintBody(os, *this);
711}

713void JSRegExpStringIterator::JSRegExpStringIteratorPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSRegExpStringIterator");
os << "\n - regex: " << Brief(iterating_reg_exp());
os << "\n - string: " << Brief(iterated_string());
os << "\n - done: " << done();
os << "\n - global: " << global();
os << "\n - unicode: " << unicode();
JSObjectPrintBody(os, *this);
721}

723void Symbol::SymbolPrint(std::ostream& os) {
PrintHeader(os, "Symbol");
os << "\n - hash: " << hash();
os << "\n - description: " << Brief(description());
if (description().IsUndefined()) {
  os << " (" << PrivateSymbolToName() << ")";
}
os << "\n - private: " << is_private();
os << "\n - private_name: " << is_private_name();
os << "\n - private_brand: " << is_private_brand();
os << "\n";
734}

736void DescriptorArray::DescriptorArrayPrint(std::ostream& os) {
PrintHeader(os, "DescriptorArray");
os << "\n - enum_cache: ";
if (enum_cache().keys().length() == 0) {
  os << "empty";
} else {
  os << enum_cache().keys().length();
  os << "\n   - keys: " << Brief(enum_cache().keys());
  os << "\n   - indices: " << Brief(enum_cache().indices());
}
os << "\n - nof slack descriptors: " << number_of_slack_descriptors();
os << "\n - nof descriptors: " << number_of_descriptors();
int16_t raw_marked = raw_number_of_marked_descriptors();
os << "\n - raw marked descriptors: mc epoch "
   << NumberOfMarkedDescriptors::Epoch::decode(raw_marked) << ", marked "
   << NumberOfMarkedDescriptors::Marked::decode(raw_marked);
PrintDescriptors(os);
753}

755namespace {
756void PrintFixedArrayWithHeader(std::ostream& os, FixedArray array,
                             const char* type) {
array.PrintHeader(os, type);
os << "\n - length: " << array.length();
PrintFixedArrayElements(os, array);
os << "\n";
762}

764template <typename T>
765void PrintWeakArrayElements(std::ostream& os, T* array) {
// Print in array notation for non-sparse arrays.
MaybeObject previous_value =
    array->length() > 0 ? array->Get(0) : MaybeObject(kNullAddress);
MaybeObject value;
int previous_index = 0;
int i;
for (i = 1; i <= array->length(); i++) {
  if (i < array->length()) value = array->Get(i);
  if (previous_value == value && i != array->length()) {
    continue;
  }
  os << "\n";
  std::stringstream ss;
  ss << previous_index;
  if (previous_index != i - 1) {
    ss << '-' << (i - 1);
  }
  os << std::setw(12) << ss.str() << ": " << Brief(previous_value);
  previous_index = i;
  previous_value = value;
}
787}

789}  // namespace

791void ObjectBoilerplateDescription::ObjectBoilerplateDescriptionPrint(
  std::ostream& os) {
PrintFixedArrayWithHeader(os, *this, "ObjectBoilerplateDescription");
794}

796void EmbedderDataArray::EmbedderDataArrayPrint(std::ostream& os) {
Isolate* isolate = GetIsolateForSandbox(*this);
PrintHeader(os, "EmbedderDataArray");
os << "\n - length: " << length();
EmbedderDataSlot start(*this, 0);
EmbedderDataSlot end(*this, length());
for (EmbedderDataSlot slot = start; slot < end; ++slot) {
  os << "\n    ";
  PrintEmbedderData(isolate, os, slot);
}
os << "\n";
807}

809void FixedArray::FixedArrayPrint(std::ostream& os) {
PrintFixedArrayWithHeader(os, *this, "FixedArray");
811}

813namespace {
814const char* SideEffectType2String(SideEffectType type) {
switch (type) {
  case SideEffectType::kHasSideEffect:
    return "kHasSideEffect";
  case SideEffectType::kHasNoSideEffect:
    return "kHasNoSideEffect";
  case SideEffectType::kHasSideEffectToReceiver:
    return "kHasSideEffectToReceiver";
}
823}
824}  // namespace

826void AccessorInfo::AccessorInfoPrint(std::ostream& os) {
TorqueGeneratedAccessorInfo<AccessorInfo, Struct>::AccessorInfoPrint(os);
os << " - all_can_read: " << all_can_read();
os << "\n - all_can_write: " << all_can_write();
os << "\n - is_special_data_property: " << is_special_data_property();
os << "\n - is_sloppy: " << is_sloppy();
os << "\n - replace_on_access: " << replace_on_access();
os << "\n - getter_side_effect_type: "
   << SideEffectType2String(getter_side_effect_type());
os << "\n - setter_side_effect_type: "
   << SideEffectType2String(setter_side_effect_type());
os << "\n - initial_attributes: " << initial_property_attributes();
os << '\n';
839}

841namespace {
842void PrintContextWithHeader(std::ostream& os, Context context,
                          const char* type) {
context.PrintHeader(os, type);
os << "\n - type: " << context.map().instance_type();
os << "\n - scope_info: " << Brief(context.scope_info());
os << "\n - previous: " << Brief(context.unchecked_previous());
os << "\n - native_context: " << Brief(context.native_context());
if (context.scope_info().HasContextExtensionSlot()) {
  os << "\n - extension: " << context.extension();
}
os << "\n - length: " << context.length();
os << "\n - elements:";
PrintFixedArrayElements(os, context);
os << "\n";
856}
857}  // namespace

859void Context::ContextPrint(std::ostream& os) {
PrintContextWithHeader(os, *this, "Context");
861}

863void NativeContext::NativeContextPrint(std::ostream& os) {
PrintContextWithHeader(os, *this, "NativeContext");
os << " - microtask_queue: " << microtask_queue() << "\n";
866}

868namespace {
869using DataPrinter = std::function<void(InternalIndex)>;

871// Prints the data associated with each key (but no headers or other meta
872// data) in a hash table. Works on different hash table types, like the
873// subtypes of HashTable and OrderedHashTable. |print_data_at| is given an
874// index into the table (where a valid key resides) and prints the data at
875// that index, like just the value (in case of a hash map), or value and
876// property details (in case of a property dictionary). No leading space
877// required or trailing newline required. It can be null/non-callable
878// std::function to indicate that there is no associcated data to be printed
879// (for example in case of a hash set).
880template <typename T>
881void PrintTableContentsGeneric(std::ostream& os, T dict,
                             DataPrinter print_data_at) {
DisallowGarbageCollection no_gc;
ReadOnlyRoots roots = dict.GetReadOnlyRoots();

for (InternalIndex i : dict.IterateEntries()) {
  Object k;
  if (!dict.ToKey(roots, i, &k)) continue;
  os << "\n   " << std::setw(12) << i.as_int() << ": ";
  if (k.IsString()) {
    String::cast(k).PrintUC16(os);
  } else {
    os << Brief(k);
  }
  if (print_data_at) {
    os << " -> ";
    print_data_at(i);
  }
}
900}

902// Used for ordered and unordered dictionaries.
903template <typename T>
904void PrintDictionaryContentsFull(std::ostream& os, T dict) {
os << "\n - elements: {";
auto print_value_and_property_details = [&](InternalIndex i) {
  os << Brief(dict.ValueAt(i)) << " ";
  dict.DetailsAt(i).PrintAsSlowTo(os, !T::kIsOrderedDictionaryType);
};
PrintTableContentsGeneric(os, dict, print_value_and_property_details);
os << "\n }\n";
912}

914// Used for ordered and unordered hash maps.
915template <typename T>
916void PrintHashMapContentsFull(std::ostream& os, T dict) {
os << "\n - elements: {";
auto print_value = [&](InternalIndex i) { os << Brief(dict.ValueAt(i)); };
PrintTableContentsGeneric(os, dict, print_value);
os << "\n }\n";
921}

923// Used for ordered and unordered hash sets.
924template <typename T>
925void PrintHashSetContentsFull(std::ostream& os, T dict) {
os << "\n - elements: {";
// Passing non-callable std::function as there are no values to print.
PrintTableContentsGeneric(os, dict, nullptr);
os << "\n }\n";
930}

932// Used for subtypes of OrderedHashTable.
933template <typename T>
934void PrintOrderedHashTableHeaderAndBuckets(std::ostream& os, T table,
                                         const char* type) {
DisallowGarbageCollection no_gc;

PrintHeapObjectHeaderWithoutMap(table, os, type);
os << "\n - FixedArray length: " << table.length();
os << "\n - elements: " << table.NumberOfElements();
os << "\n - deleted: " << table.NumberOfDeletedElements();
os << "\n - buckets: " << table.NumberOfBuckets();
os << "\n - capacity: " << table.Capacity();

os << "\n - buckets: {";
for (int bucket = 0; bucket < table.NumberOfBuckets(); bucket++) {
  Object entry = table.get(T::HashTableStartIndex() + bucket);
  DCHECK(entry.IsSmi())((void) 0);
  os << "\n   " << std::setw(12) << bucket << ": " << Brief(entry);
}
os << "\n }";
952}

954// Used for subtypes of HashTable.
955template <typename T>
956void PrintHashTableHeader(std::ostream& os, T table, const char* type) {
PrintHeapObjectHeaderWithoutMap(table, os, type);
os << "\n - FixedArray length: " << table.length();
os << "\n - elements: " << table.NumberOfElements();
os << "\n - deleted: " << table.NumberOfDeletedElements();
os << "\n - capacity: " << table.Capacity();
962}
963}  // namespace

965void ObjectHashTable::ObjectHashTablePrint(std::ostream& os) {
PrintHashTableHeader(os, *this, "ObjectHashTable");
PrintHashMapContentsFull(os, *this);
968}

970void NameToIndexHashTable::NameToIndexHashTablePrint(std::ostream& os) {
PrintHashTableHeader(os, *this, "NameToIndexHashTable");
PrintHashMapContentsFull(os, *this);
973}

975void RegisteredSymbolTable::RegisteredSymbolTablePrint(std::ostream& os) {
PrintHashTableHeader(os, *this, "RegisteredSymbolTable");
PrintHashMapContentsFull(os, *this);
978}

980void NumberDictionary::NumberDictionaryPrint(std::ostream& os) {
PrintHashTableHeader(os, *this, "NumberDictionary");
PrintDictionaryContentsFull(os, *this);
983}

985void EphemeronHashTable::EphemeronHashTablePrint(std::ostream& os) {
PrintHashTableHeader(os, *this, "EphemeronHashTable");
PrintHashMapContentsFull(os, *this);
988}

990void NameDictionary::NameDictionaryPrint(std::ostream& os) {
PrintHashTableHeader(os, *this, "NameDictionary");
PrintDictionaryContentsFull(os, *this);
993}

995void GlobalDictionary::GlobalDictionaryPrint(std::ostream& os) {
PrintHashTableHeader(os, *this, "GlobalDictionary");
PrintDictionaryContentsFull(os, *this);
998}

1000void SmallOrderedHashSet::SmallOrderedHashSetPrint(std::ostream& os) {
PrintHeader(os, "SmallOrderedHashSet");
// TODO(turbofan): Print all fields.
1003}

1005void SmallOrderedHashMap::SmallOrderedHashMapPrint(std::ostream& os) {
PrintHeader(os, "SmallOrderedHashMap");
// TODO(turbofan): Print all fields.
1008}

1010void SmallOrderedNameDictionary::SmallOrderedNameDictionaryPrint(
  std::ostream& os) {
PrintHeader(os, "SmallOrderedNameDictionary");
// TODO(turbofan): Print all fields.
1014}

1016void OrderedHashSet::OrderedHashSetPrint(std::ostream& os) {
PrintOrderedHashTableHeaderAndBuckets(os, *this, "OrderedHashSet");
PrintHashSetContentsFull(os, *this);
1019}

1021void OrderedHashMap::OrderedHashMapPrint(std::ostream& os) {
PrintOrderedHashTableHeaderAndBuckets(os, *this, "OrderedHashMap");
PrintHashMapContentsFull(os, *this);
1024}

1026void OrderedNameDictionary::OrderedNameDictionaryPrint(std::ostream& os) {
PrintOrderedHashTableHeaderAndBuckets(os, *this, "OrderedNameDictionary");
PrintDictionaryContentsFull(os, *this);
1029}

1031void print_hex_byte(std::ostream& os, int value) {
os << "0x" << std::setfill('0') << std::setw(2) << std::right << std::hex
   << (value & 0xff) << std::setfill(' ');
1034}

1036void SwissNameDictionary::SwissNameDictionaryPrint(std::ostream& os) {
this->PrintHeader(os, "SwissNameDictionary");
os << "\n - meta table ByteArray: "
   << reinterpret_cast<void*>(this->meta_table().ptr());
os << "\n - capacity: " << this->Capacity();
os << "\n - elements: " << this->NumberOfElements();
os << "\n - deleted: " << this->NumberOfDeletedElements();

std::ios_base::fmtflags sav_flags = os.flags();
os << "\n - ctrl table (omitting buckets where key is hole value): {";
for (int i = 0; i < this->Capacity() + kGroupWidth; i++) {
  ctrl_t ctrl = CtrlTable()[i];

  if (ctrl == Ctrl::kEmpty) continue;

  os << "\n   " << std::setw(12) << std::dec << i << ": ";
  switch (ctrl) {
    case Ctrl::kEmpty:
      UNREACHABLE()V8_Fatal("unreachable code");
    case Ctrl::kDeleted:
      print_hex_byte(os, ctrl);
      os << " (= kDeleted)";
      break;
    case Ctrl::kSentinel:
      print_hex_byte(os, ctrl);
      os << " (= kSentinel)";
      break;
    default:
      print_hex_byte(os, ctrl);
      os << " (= H2 of a key)";
      break;
  }
}
os << "\n }";

os << "\n - enumeration table: {";
for (int enum_index = 0; enum_index < this->UsedCapacity(); enum_index++) {
  int entry = EntryForEnumerationIndex(enum_index);
  os << "\n   " << std::setw(12) << std::dec << enum_index << ": " << entry;
}
os << "\n }";

os << "\n - data table (omitting slots where key is the hole): {";
for (int bucket = 0; bucket < this->Capacity(); ++bucket) {
  Object k;
  if (!this->ToKey(this->GetReadOnlyRoots(), bucket, &k)) continue;

  Object value = this->ValueAtRaw(bucket);
  PropertyDetails details = this->DetailsAt(bucket);
  os << "\n   " << std::setw(12) << std::dec << bucket << ": ";
  if (k.IsString()) {
    String::cast(k).PrintUC16(os);
  } else {
    os << Brief(k);
  }
  os << " -> " << Brief(value);
  details.PrintAsSlowTo(os, false);
}
os << "\n }\n";
os.flags(sav_flags);
1096}

1098void PropertyArray::PropertyArrayPrint(std::ostream& os) {
PrintHeader(os, "PropertyArray");
os << "\n - length: " << length();
os << "\n - hash: " << Hash();
PrintFixedArrayElements(os, *this);
os << "\n";
1104}

1106void FixedDoubleArray::FixedDoubleArrayPrint(std::ostream& os) {
PrintHeader(os, "FixedDoubleArray");
os << "\n - length: " << length();
DoPrintElements<FixedDoubleArray>(os, *this, length());
os << "\n";
1111}

1113void WeakFixedArray::WeakFixedArrayPrint(std::ostream& os) {
PrintHeader(os, "WeakFixedArray");
os << "\n - length: " << length() << "\n";
PrintWeakArrayElements(os, this);
os << "\n";
1118}

1120void WeakArrayList::WeakArrayListPrint(std::ostream& os) {
PrintHeader(os, "WeakArrayList");
os << "\n - capacity: " << capacity();
os << "\n - length: " << length() << "\n";
PrintWeakArrayElements(os, this);
os << "\n";
1126}

1128void TransitionArray::TransitionArrayPrint(std::ostream& os) {
PrintHeader(os, "TransitionArray");
PrintInternal(os);
1131}

1133void FeedbackCell::FeedbackCellPrint(std::ostream& os) {
PrintHeader(os, "FeedbackCell");
ReadOnlyRoots roots = GetReadOnlyRoots();
if (map() == roots.no_closures_cell_map()) {
  os << "\n - no closures";
} else if (map() == roots.one_closure_cell_map()) {
  os << "\n - one closure";
} else if (map() == roots.many_closures_cell_map()) {
  os << "\n - many closures";
} else {
  os << "\n - Invalid FeedbackCell map";
}
os << "\n - value: " << Brief(value());
os << "\n - interrupt_budget: " << interrupt_budget();
os << "\n";
1148}

1150void FeedbackVectorSpec::Print() {
StdoutStream os;

FeedbackVectorSpecPrint(os);

os << std::flush;
1156}

1158void FeedbackVectorSpec::FeedbackVectorSpecPrint(std::ostream& os) {
os << " - slot_count: " << slot_count();
if (slot_count() == 0) {
  os << " (empty)\n";
  return;
}

for (int slot = 0; slot < slot_count();) {
  FeedbackSlotKind kind = GetKind(FeedbackSlot(slot));
  int entry_size = FeedbackMetadata::GetSlotSize(kind);
  DCHECK_LT(0, entry_size)((void) 0);
  os << "\n Slot #" << slot << " " << kind;
  slot += entry_size;
}
os << "\n";
1173}

1175void FeedbackMetadata::FeedbackMetadataPrint(std::ostream& os) {
PrintHeader(os, "FeedbackMetadata");
os << "\n - slot_count: " << slot_count();
os << "\n - create_closure_slot_count: " << create_closure_slot_count();

FeedbackMetadataIterator iter(*this);
while (iter.HasNext()) {
  FeedbackSlot slot = iter.Next();
  FeedbackSlotKind kind = iter.kind();
  os << "\n Slot " << slot << " " << kind;
}
os << "\n";
1187}

1189void ClosureFeedbackCellArray::ClosureFeedbackCellArrayPrint(std::ostream& os) {
PrintFixedArrayWithHeader(os, *this, "ClosureFeedbackCellArray");
1191}

1193void FeedbackVector::FeedbackVectorPrint(std::ostream& os) {
PrintHeader(os, "FeedbackVector");
os << "\n - length: " << length();
if (length() == 0) {
  os << " (empty)\n";
  return;
}

os << "\n - shared function info: " << Brief(shared_function_info());
if (has_optimized_code()) {
  os << "\n - optimized code: " << Brief(optimized_code());
} else {
  os << "\n - no optimized code";
}
os << "\n - tiering state: " << tiering_state();
os << "\n - maybe has optimized code: " << maybe_has_optimized_code();
os << "\n - invocation count: " << invocation_count();
os << "\n - profiler ticks: " << profiler_ticks();
os << "\n - closure feedback cell array: ";
closure_feedback_cell_array().ClosureFeedbackCellArrayPrint(os);

FeedbackMetadataIterator iter(metadata());
while (iter.HasNext()) {
  FeedbackSlot slot = iter.Next();
  FeedbackSlotKind kind = iter.kind();

  os << "\n - slot " << slot << " " << kind << " ";
  FeedbackSlotPrint(os, slot);

  int entry_size = iter.entry_size();
  if (entry_size > 0) os << " {";
  for (int i = 0; i < entry_size; i++) {
    FeedbackSlot slot_with_offset = slot.WithOffset(i);
    os << "\n     [" << slot_with_offset.ToInt()
       << "]: " << Brief(Get(slot_with_offset));
  }
  if (entry_size > 0) os << "\n  }";
}
os << "\n";
1232}

1234void FeedbackVector::FeedbackSlotPrint(std::ostream& os, FeedbackSlot slot) {
FeedbackNexus nexus(*this, slot);
nexus.Print(os);
1237}

1239void FeedbackNexus::Print(std::ostream& os) {
switch (kind()) {
  case FeedbackSlotKind::kCall:
  case FeedbackSlotKind::kCloneObject:
  case FeedbackSlotKind::kDefineKeyedOwn:
  case FeedbackSlotKind::kHasKeyed:
  case FeedbackSlotKind::kInstanceOf:
  case FeedbackSlotKind::kLoadGlobalInsideTypeof:
  case FeedbackSlotKind::kLoadGlobalNotInsideTypeof:
  case FeedbackSlotKind::kLoadKeyed:
  case FeedbackSlotKind::kLoadProperty:
  case FeedbackSlotKind::kDefineKeyedOwnPropertyInLiteral:
  case FeedbackSlotKind::kStoreGlobalSloppy:
  case FeedbackSlotKind::kStoreGlobalStrict:
  case FeedbackSlotKind::kStoreInArrayLiteral:
  case FeedbackSlotKind::kSetKeyedSloppy:
  case FeedbackSlotKind::kSetKeyedStrict:
  case FeedbackSlotKind::kSetNamedSloppy:
  case FeedbackSlotKind::kSetNamedStrict:
  case FeedbackSlotKind::kDefineNamedOwn: {
    os << InlineCacheState2String(ic_state());
    break;
  }
  case FeedbackSlotKind::kBinaryOp: {
    os << "BinaryOp:" << GetBinaryOperationFeedback();
    break;
  }
  case FeedbackSlotKind::kCompareOp: {
    os << "CompareOp:" << GetCompareOperationFeedback();
    break;
  }
  case FeedbackSlotKind::kForIn: {
    os << "ForIn:" << GetForInFeedback();
    break;
  }
  case FeedbackSlotKind::kLiteral:
  case FeedbackSlotKind::kTypeProfile:
    break;
  case FeedbackSlotKind::kInvalid:
  case FeedbackSlotKind::kKindsNumber:
    UNREACHABLE()V8_Fatal("unreachable code");
}
1281}

1283void Oddball::OddballPrint(std::ostream& os) {
PrintHeapObjectHeaderWithoutMap(*this, os, "Oddball");
os << ": ";
String s = to_string();
os << s.PrefixForDebugPrint();
s.PrintUC16(os);
os << s.SuffixForDebugPrint();
os << std::endl;
1291}

1293void JSAsyncFunctionObject::JSAsyncFunctionObjectPrint(std::ostream& os) {
JSGeneratorObjectPrint(os);
1295}

1297void JSAsyncGeneratorObject::JSAsyncGeneratorObjectPrint(std::ostream& os) {
JSGeneratorObjectPrint(os);
1299}

1301void JSArgumentsObject::JSArgumentsObjectPrint(std::ostream& os) {
JSObjectPrint(os);
1303}

1305void JSStringIterator::JSStringIteratorPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSStringIterator");
os << "\n - string: " << Brief(string());
os << "\n - index: " << index();
JSObjectPrintBody(os, *this);
1310}

1312void JSAsyncFromSyncIterator::JSAsyncFromSyncIteratorPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSAsyncFromSyncIterator");
os << "\n - sync_iterator: " << Brief(sync_iterator());
os << "\n - next: " << Brief(next());
JSObjectPrintBody(os, *this);
1317}

1319void JSPrimitiveWrapper::JSPrimitiveWrapperPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSPrimitiveWrapper");
os << "\n - value: " << Brief(value());
JSObjectPrintBody(os, *this);
1323}

1325void JSMessageObject::JSMessageObjectPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSMessageObject");
os << "\n - type: " << static_cast<int>(type());
os << "\n - arguments: " << Brief(argument());
os << "\n - start_position: " << start_position();
os << "\n - end_position: " << end_position();
os << "\n - script: " << Brief(script());
os << "\n - stack_frames: " << Brief(stack_frames());
JSObjectPrintBody(os, *this);
1334}

1336void String::StringPrint(std::ostream& os) {
PrintHeapObjectHeaderWithoutMap(*this, os, "String");
os << ": ";
os << PrefixForDebugPrint();
PrintUC16(os, 0, length());
os << SuffixForDebugPrint();
1342}

1344void Name::NamePrint(std::ostream& os) {
if (IsString()) {
  String::cast(*this).StringPrint(os);
} else {
  os << Brief(*this);
}
1350}

1352static const char* const weekdays[] = {"???", "Sun", "Mon", "Tue",
                                     "Wed", "Thu", "Fri", "Sat"};

1355void JSDate::JSDatePrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSDate");
os << "\n - value: " << Brief(value());
if (!year().IsSmi()) {
  os << "\n - time = NaN\n";
} else {
  // TODO(svenpanne) Add some basic formatting to our streams.
  base::ScopedVector<char> buf(100);
  SNPrintF(buf, "\n - time = %s %04d/%02d/%02d %02d:%02d:%02d\n",
           weekdays[weekday().IsSmi() ? Smi::ToInt(weekday()) + 1 : 0],
           year().IsSmi() ? Smi::ToInt(year()) : -1,
           month().IsSmi() ? Smi::ToInt(month()) : -1,
           day().IsSmi() ? Smi::ToInt(day()) : -1,
           hour().IsSmi() ? Smi::ToInt(hour()) : -1,
           min().IsSmi() ? Smi::ToInt(min()) : -1,
           sec().IsSmi() ? Smi::ToInt(sec()) : -1);
  os << buf.begin();
}
JSObjectPrintBody(os, *this);
1374}

1376void JSSet::JSSetPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSSet");
os << "\n - table: " << Brief(table());
JSObjectPrintBody(os, *this);
1380}

1382void JSMap::JSMapPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSMap");
os << "\n - table: " << Brief(table());
JSObjectPrintBody(os, *this);
1386}

1388void JSCollectionIterator::JSCollectionIteratorPrint(std::ostream& os,
                                                   const char* name) {
JSObjectPrintHeader(os, *this, name);
os << "\n - table: " << Brief(table());
os << "\n - index: " << Brief(index());
JSObjectPrintBody(os, *this);
1394}

1396void JSSetIterator::JSSetIteratorPrint(std::ostream& os) {
JSCollectionIteratorPrint(os, "JSSetIterator");
1398}

1400void JSMapIterator::JSMapIteratorPrint(std::ostream& os) {
JSCollectionIteratorPrint(os, "JSMapIterator");
1402}

1404void JSWeakRef::JSWeakRefPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSWeakRef");
os << "\n - target: " << Brief(target());
JSObjectPrintBody(os, *this);
1408}

1410void JSShadowRealm::JSShadowRealmPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSShadowRealm");
os << "\n - native_context: " << Brief(native_context());
JSObjectPrintBody(os, *this);
1414}

1416void JSWrappedFunction::JSWrappedFunctionPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSWrappedFunction");
os << "\n - wrapped_target_function: " << Brief(wrapped_target_function());
JSObjectPrintBody(os, *this);
1420}

1422void JSFinalizationRegistry::JSFinalizationRegistryPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSFinalizationRegistry");
os << "\n - native_context: " << Brief(native_context());
os << "\n - cleanup: " << Brief(cleanup());
os << "\n - active_cells: " << Brief(active_cells());
Object active_cell = active_cells();
while (active_cell.IsWeakCell()) {
  os << "\n   - " << Brief(active_cell);
  active_cell = WeakCell::cast(active_cell).next();
}
os << "\n - cleared_cells: " << Brief(cleared_cells());
Object cleared_cell = cleared_cells();
while (cleared_cell.IsWeakCell()) {
  os << "\n   - " << Brief(cleared_cell);
  cleared_cell = WeakCell::cast(cleared_cell).next();
}
os << "\n - key_map: " << Brief(key_map());
JSObjectPrintBody(os, *this);
1440}

1442void JSSharedStruct::JSSharedStructPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSSharedStruct");
Isolate* isolate = GetIsolateFromWritableObject(*this);
os << "\n - isolate: " << isolate;
if (isolate->is_shared()) os << " (shared)";
JSObjectPrintBody(os, *this);
1448}

1450void JSWeakMap::JSWeakMapPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSWeakMap");
os << "\n - table: " << Brief(table());
JSObjectPrintBody(os, *this);
1454}

1456void JSWeakSet::JSWeakSetPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSWeakSet");
os << "\n - table: " << Brief(table());
JSObjectPrintBody(os, *this);
1460}

1462void JSArrayBuffer::JSArrayBufferPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSArrayBuffer");
os << "\n - backing_store: " << backing_store();
os << "\n - byte_length: " << byte_length();
os << "\n - max_byte_length: " << max_byte_length();
if (is_external()) os << "\n - external";
if (is_detachable()) os << "\n - detachable";
if (was_detached()) os << "\n - detached";
if (is_shared()) os << "\n - shared";
if (is_resizable()) os << "\n - resizable";
JSObjectPrintBody(os, *this, !was_detached());
1473}

1475void JSTypedArray::JSTypedArrayPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSTypedArray");
os << "\n - buffer: " << Brief(buffer());
os << "\n - byte_offset: " << byte_offset();
os << "\n - byte_length: " << byte_length();
os << "\n - length: " << GetLength();
os << "\n - data_ptr: " << DataPtr();
Tagged_t base_ptr = static_cast<Tagged_t>(base_pointer().ptr());
os << "\n   - base_pointer: "
   << reinterpret_cast<void*>(static_cast<Address>(base_ptr));
os << "\n   - external_pointer: "
   << reinterpret_cast<void*>(external_pointer());
if (!buffer().IsJSArrayBuffer()) {
  os << "\n <invalid buffer>\n";
  return;
}
if (WasDetached()) os << "\n - detached";
if (is_length_tracking()) os << "\n - length-tracking";
if (is_backed_by_rab()) os << "\n - backed-by-rab";
JSObjectPrintBody(os, *this, !WasDetached());
1495}

1497void JSArrayIterator::JSArrayIteratorPrint(std::ostream& os) {  // NOLING
JSObjectPrintHeader(os, *this, "JSArrayIterator");
os << "\n - iterated_object: " << Brief(iterated_object());
os << "\n - next_index: " << Brief(next_index());
os << "\n - kind: " << kind();
JSObjectPrintBody(os, *this);
1503}

1505void JSDataView::JSDataViewPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSDataView");
os << "\n - buffer =" << Brief(buffer());
os << "\n - byte_offset: " << byte_offset();
os << "\n - byte_length: " << byte_length();
if (!buffer().IsJSArrayBuffer()) {
  os << "\n <invalid buffer>";
  return;
}
if (WasDetached()) os << "\n - detached";
JSObjectPrintBody(os, *this, !WasDetached());
1516}

1518void JSBoundFunction::JSBoundFunctionPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSBoundFunction");
os << "\n - bound_target_function: " << Brief(bound_target_function());
os << "\n - bound_this: " << Brief(bound_this());
os << "\n - bound_arguments: " << Brief(bound_arguments());
JSObjectPrintBody(os, *this);
1524}

1526void JSFunction::JSFunctionPrint(std::ostream& os) {
Isolate* isolate = GetIsolate();
JSObjectPrintHeader(os, *this, "Function");
os << "\n - function prototype: ";
if (has_prototype_slot()) {
  if (has_prototype()) {
    os << Brief(prototype());
    if (map().has_non_instance_prototype()) {
      os << " (non-instance prototype)";
    }
  }
  os << "\n - initial_map: ";
  if (has_initial_map()) os << Brief(initial_map());
} else {
  os << "<no-prototype-slot>";
}
os << "\n - shared_info: " << Brief(shared());
os << "\n - name: " << Brief(shared().Name());

// Print Builtin name for builtin functions
Builtin builtin = code().builtin_id();
if (Builtins::IsBuiltinId(builtin)) {
  os << "\n - builtin: " << isolate->builtins()->name(builtin);
}

os << "\n - formal_parameter_count: "
   << shared().internal_formal_parameter_count_without_receiver();
os << "\n - kind: " << shared().kind();
os << "\n - context: " << Brief(context());
os << "\n - code: " << Brief(code());
if (code().kind() == CodeKind::FOR_TESTING) {
  os << "\n - FOR_TESTING";
} else if (ActiveTierIsIgnition()) {
  os << "\n - interpreted";
  if (shared().HasBytecodeArray()) {
    os << "\n - bytecode: " << shared().GetBytecodeArray(isolate);
  }
}
1564#if V8_ENABLE_WEBASSEMBLY1
if (WasmExportedFunction::IsWasmExportedFunction(*this)) {
  WasmExportedFunction function = WasmExportedFunction::cast(*this);
  os << "\n - Wasm instance: " << Brief(function.instance());
  os << "\n - Wasm function index: " << function.function_index();
}
if (WasmJSFunction::IsWasmJSFunction(*this)) {
  WasmJSFunction function = WasmJSFunction::cast(*this);
  os << "\n - Wasm wrapper around: " << Brief(function.GetCallable());
}
1574#endif  // V8_ENABLE_WEBASSEMBLY
shared().PrintSourceCode(os);
JSObjectPrintBody(os, *this);
os << " - feedback vector: ";
if (!shared().HasFeedbackMetadata()) {
  os << "feedback metadata is not available in SFI\n";
} else if (has_feedback_vector()) {
  feedback_vector().FeedbackVectorPrint(os);
} else if (has_closure_feedback_cell_array()) {
  os << "No feedback vector, but we have a closure feedback cell array\n";
  closure_feedback_cell_array().ClosureFeedbackCellArrayPrint(os);
} else {
  os << "not available\n";
}
1588}

1590void SharedFunctionInfo::PrintSourceCode(std::ostream& os) {
if (HasSourceCode()) {
  os << "\n - source code: ";
  String source = String::cast(Script::cast(script()).source());
  int start = StartPosition();
  int length = EndPosition() - start;
  std::unique_ptr<char[]> source_string = source.ToCString(
      DISALLOW_NULLS, FAST_STRING_TRAVERSAL, start, length, nullptr);
  os << source_string.get();
}
1600}

1602void SharedFunctionInfo::SharedFunctionInfoPrint(std::ostream& os) {
PrintHeader(os, "SharedFunctionInfo");
os << "\n - name: ";
if (HasSharedName()) {
  os << Brief(Name());
} else {
  os << "<no-shared-name>";
}
if (HasInferredName()) {
  os << "\n - inferred name: " << Brief(inferred_name());
}
if (class_scope_has_private_brand()) {
  os << "\n - class_scope_has_private_brand";
}
if (has_static_private_methods_or_accessors()) {
  os << "\n - has_static_private_methods_or_accessors";
}
if (private_name_lookup_skips_outer_class()) {
  os << "\n - private_name_lookup_skips_outer_class";
}
os << "\n - kind: " << kind();
os << "\n - syntax kind: " << syntax_kind();
os << "\n - function_map_index: " << function_map_index();
os << "\n - formal_parameter_count: "
   << internal_formal_parameter_count_without_receiver();
os << "\n - expected_nof_properties: " << expected_nof_properties();
os << "\n - language_mode: " << language_mode();
os << "\n - data: " << Brief(function_data(kAcquireLoad));
os << "\n - code (from data): ";
os << Brief(GetCode());
PrintSourceCode(os);
// Script files are often large, thus only print their {Brief} representation.
os << "\n - script: " << Brief(script());
os << "\n - function token position: " << function_token_position();
os << "\n - start position: " << StartPosition();
os << "\n - end position: " << EndPosition();
if (HasDebugInfo()) {
  os << "\n - debug info: " << Brief(GetDebugInfo());
} else {
  os << "\n - no debug info";
}
os << "\n - scope info: " << Brief(scope_info());
if (HasOuterScopeInfo()) {
  os << "\n - outer scope info: " << Brief(GetOuterScopeInfo());
}
os << "\n - length: " << length();
os << "\n - feedback_metadata: ";
if (HasFeedbackMetadata()) {
  feedback_metadata().FeedbackMetadataPrint(os);
} else {
  os << "<none>";
}
os << "\n";
1655}

1657void JSGlobalProxy::JSGlobalProxyPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSGlobalProxy");
if (!GetIsolate()->bootstrapper()->IsActive()) {
  os << "\n - native context: " << Brief(native_context());
}
JSObjectPrintBody(os, *this);
1663}

1665void JSGlobalObject::JSGlobalObjectPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSGlobalObject");
if (!GetIsolate()->bootstrapper()->IsActive()) {
  os << "\n - native context: " << Brief(native_context());
}
os << "\n - global proxy: " << Brief(global_proxy());
JSObjectPrintBody(os, *this);
1672}

1674void PropertyCell::PropertyCellPrint(std::ostream& os) {
PrintHeader(os, "PropertyCell");
os << "\n - name: ";
name().NamePrint(os);
os << "\n - value: " << Brief(value(kAcquireLoad));
os << "\n - details: ";
PropertyDetails details = property_details(kAcquireLoad);
details.PrintAsSlowTo(os, true);
os << "\n - cell_type: " << details.cell_type();
os << "\n";
1684}

1686void Code::CodePrint(std::ostream& os) {
PrintHeader(os, "Code");
os << "\n - code_data_container: "
   << Brief(code_data_container(kAcquireLoad));
if (is_builtin()) {
  os << "\n - builtin_id: " << Builtins::name(builtin_id());
}
os << "\n";
1694#ifdef ENABLE_DISASSEMBLER1
Disassemble(nullptr, os, GetIsolate());
1696#endif
1697}

1699void CodeDataContainer::CodeDataContainerPrint(std::ostream& os) {
PrintHeader(os, "CodeDataContainer");
os << "\n - kind_specific_flags: " << kind_specific_flags(kRelaxedLoad);
if (V8_EXTERNAL_CODE_SPACE_BOOLfalse) {
  os << "\n - code: " << Brief(code());
  os << "\n - code_entry_point: "
     << reinterpret_cast<void*>(code_entry_point());
}
os << "\n";
1708}

1710void Foreign::ForeignPrint(std::ostream& os) {
PrintHeader(os, "Foreign");
os << "\n - foreign address : " << reinterpret_cast<void*>(foreign_address());
os << "\n";
1714}

1716void AsyncGeneratorRequest::AsyncGeneratorRequestPrint(std::ostream& os) {
PrintHeader(os, "AsyncGeneratorRequest");
const char* mode = "Invalid!";
switch (resume_mode()) {
  case JSGeneratorObject::kNext:
    mode = ".next()";
    break;
  case JSGeneratorObject::kReturn:
    mode = ".return()";
    break;
  case JSGeneratorObject::kThrow:
    mode = ".throw()";
    break;
}
os << "\n - resume mode: " << mode;
os << "\n - value: " << Brief(value());
os << "\n - next: " << Brief(next());
os << "\n";
1734}

1736static void PrintModuleFields(Module module, std::ostream& os) {
os << "\n - exports: " << Brief(module.exports());
os << "\n - status: " << module.status();
os << "\n - exception: " << Brief(module.exception());
1740}

1742void Module::ModulePrint(std::ostream& os) {
if (this->IsSourceTextModule()) {
  SourceTextModule::cast(*this).SourceTextModulePrint(os);
} else if (this->IsSyntheticModule()) {
  SyntheticModule::cast(*this).SyntheticModulePrint(os);
} else {
  UNREACHABLE()V8_Fatal("unreachable code");
}
1750}

1752void SourceTextModule::SourceTextModulePrint(std::ostream& os) {
PrintHeader(os, "SourceTextModule");
PrintModuleFields(*this, os);
os << "\n - sfi/code/info: " << Brief(code());
Script script = GetScript();
os << "\n - script: " << Brief(script);
os << "\n - origin: " << Brief(script.GetNameOrSourceURL());
os << "\n - requested_modules: " << Brief(requested_modules());
os << "\n - import_meta: " << Brief(import_meta(kAcquireLoad));
os << "\n - cycle_root: " << Brief(cycle_root());
os << "\n - async_evaluating_ordinal: " << async_evaluating_ordinal();
os << "\n";
1764}

1766void JSModuleNamespace::JSModuleNamespacePrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSModuleNamespace");
os << "\n - module: " << Brief(module());
JSObjectPrintBody(os, *this);
1770}

1772void PrototypeInfo::PrototypeInfoPrint(std::ostream& os) {
PrintHeader(os, "PrototypeInfo");
os << "\n - module namespace: " << Brief(module_namespace());
os << "\n - prototype users: " << Brief(prototype_users());
os << "\n - registry slot: " << registry_slot();
os << "\n - object create map: " << Brief(object_create_map());
os << "\n - should_be_fast_map: " << should_be_fast_map();
os << "\n";
1780}

1782void ArrayBoilerplateDescription::ArrayBoilerplateDescriptionPrint(
  std::ostream& os) {
PrintHeader(os, "ArrayBoilerplateDescription");
os << "\n - elements kind: " << ElementsKindToString(elements_kind());
os << "\n - constant elements: " << Brief(constant_elements());
os << "\n";
1788}

1790#if V8_ENABLE_WEBASSEMBLY1
1791void AsmWasmData::AsmWasmDataPrint(std::ostream& os) {
PrintHeader(os, "AsmWasmData");
os << "\n - native module: " << Brief(managed_native_module());
os << "\n - export_wrappers: " << Brief(export_wrappers());
os << "\n - uses bitset: " << uses_bitset().value();
os << "\n";
1797}

1799void WasmTypeInfo::WasmTypeInfoPrint(std::ostream& os) {
PrintHeader(os, "WasmTypeInfo");
os << "\n - type address: " << reinterpret_cast<void*>(foreign_address());
os << "\n - supertypes: " << Brief(supertypes());
os << "\n - subtypes: " << Brief(subtypes());
os << "\n - instance: " << Brief(instance());
os << "\n";
1806}

1808void WasmStruct::WasmStructPrint(std::ostream& os) {
PrintHeader(os, "WasmStruct");
wasm::StructType* struct_type = type();
os << "\n - fields (" << struct_type->field_count() << "):";
for (uint32_t i = 0; i < struct_type->field_count(); i++) {
  wasm::ValueType field = struct_type->field(i);
  os << "\n   - " << field.short_name() << ": ";
  uint32_t field_offset = struct_type->field_offset(i);
  Address field_address = RawFieldAddress(field_offset);
  switch (field.kind()) {
    case wasm::kI32:
      os << base::ReadUnalignedValue<int32_t>(field_address);
      break;
    case wasm::kI64:
      os << base::ReadUnalignedValue<int64_t>(field_address);
      break;
    case wasm::kF32:
      os << base::ReadUnalignedValue<float>(field_address);
      break;
    case wasm::kF64:
      os << base::ReadUnalignedValue<double>(field_address);
      break;
    case wasm::kI8:
      os << base::ReadUnalignedValue<int8_t>(field_address);
      break;
    case wasm::kI16:
      os << base::ReadUnalignedValue<int16_t>(field_address);
      break;
    case wasm::kRef:
    case wasm::kOptRef:
    case wasm::kRtt: {
      Tagged_t raw = base::ReadUnalignedValue<Tagged_t>(field_address);
1840#if V8_COMPRESS_POINTERS
      Address obj = DecompressTaggedPointer(address(), raw);
1842#else
      Address obj = raw;
1844#endif
      os << Brief(Object(obj));
      break;
    }
    case wasm::kS128:
      os << "UNIMPLEMENTED";  // TODO(7748): Implement.
      break;
    case wasm::kBottom:
    case wasm::kVoid:
      UNREACHABLE()V8_Fatal("unreachable code");
  }
}
os << "\n";
1857}

1859void WasmArray::WasmArrayPrint(std::ostream& os) {
PrintHeader(os, "WasmArray");
wasm::ArrayType* array_type = type();
uint32_t len = length();
os << "\n - type: " << array_type->element_type().name();
os << "\n - length: " << len;
Address data_ptr = ptr() + WasmArray::kHeaderSize - kHeapObjectTag;
switch (array_type->element_type().kind()) {
  case wasm::kI32:
    PrintTypedArrayElements(os, reinterpret_cast<int32_t*>(data_ptr), len,
                            true);
    break;
  case wasm::kI64:
    PrintTypedArrayElements(os, reinterpret_cast<int64_t*>(data_ptr), len,
                            true);
    break;
  case wasm::kF32:
    PrintTypedArrayElements(os, reinterpret_cast<float*>(data_ptr), len,
                            true);
    break;
  case wasm::kF64:
    PrintTypedArrayElements(os, reinterpret_cast<double*>(data_ptr), len,
                            true);
    break;
  case wasm::kI8:
    PrintTypedArrayElements(os, reinterpret_cast<int8_t*>(data_ptr), len,
                            true);
    break;
  case wasm::kI16:
    PrintTypedArrayElements(os, reinterpret_cast<int16_t*>(data_ptr), len,
                            true);
    break;
  case wasm::kS128:
  case wasm::kRef:
  case wasm::kOptRef:
  case wasm::kRtt:
    os << "\n   Printing elements of this type is unimplemented, sorry";
    // TODO(7748): Implement.
    break;
  case wasm::kBottom:
  case wasm::kVoid:
    UNREACHABLE()V8_Fatal("unreachable code");
}
os << "\n";
1903}

1905void WasmContinuationObject::WasmContinuationObjectPrint(std::ostream& os) {
PrintHeader(os, "WasmContinuationObject");
os << "\n - parent: " << parent();
os << "\n - jmpbuf: " << jmpbuf();
os << "\n - stack: " << stack();
os << "\n";
1911}

1913void WasmSuspenderObject::WasmSuspenderObjectPrint(std::ostream& os) {
PrintHeader(os, "WasmSuspenderObject");
os << "\n - continuation: " << continuation();
os << "\n - parent: " << parent();
os << "\n - state: " << state();
os << "\n";
1919}

1921void WasmInstanceObject::WasmInstanceObjectPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "WasmInstanceObject");
os << "\n - module_object: " << Brief(module_object());
os << "\n - exports_object: " << Brief(exports_object());
os << "\n - native_context: " << Brief(native_context());
if (has_memory_object()) {
  os << "\n - memory_object: " << Brief(memory_object());
}
if (has_untagged_globals_buffer()) {
  os << "\n - untagged_globals_buffer: " << Brief(untagged_globals_buffer());
}
if (has_tagged_globals_buffer()) {
  os << "\n - tagged_globals_buffer: " << Brief(tagged_globals_buffer());
}
if (has_imported_mutable_globals_buffers()) {
  os << "\n - imported_mutable_globals_buffers: "
     << Brief(imported_mutable_globals_buffers());
}
for (int i = 0; i < tables().length(); i++) {
  os << "\n - table " << i << ": " << Brief(tables().get(i));
}
os << "\n - imported_function_refs: " << Brief(imported_function_refs());
if (has_indirect_function_table_refs()) {
  os << "\n - indirect_function_table_refs: "
     << Brief(indirect_function_table_refs());
}
if (has_managed_native_allocations()) {
  os << "\n - managed_native_allocations: "
     << Brief(managed_native_allocations());
}
if (has_tags_table()) {
  os << "\n - tags table: " << Brief(tags_table());
}
os << "\n - managed object maps: " << Brief(managed_object_maps());
os << "\n - feedback vectors: " << Brief(feedback_vectors());
os << "\n - memory_start: " << static_cast<void*>(memory_start());
os << "\n - memory_size: " << memory_size();
os << "\n - imported_function_targets: "
   << static_cast<void*>(imported_function_targets());
os << "\n - globals_start: " << static_cast<void*>(globals_start());
os << "\n - imported_mutable_globals: "
   << static_cast<void*>(imported_mutable_globals());
os << "\n - indirect_function_table_size: " << indirect_function_table_size();
os << "\n - indirect_function_table_sig_ids: "
   << static_cast<void*>(indirect_function_table_sig_ids());
os << "\n - indirect_function_table_targets: "
   << static_cast<void*>(indirect_function_table_targets());
JSObjectPrintBody(os, *this);
os << "\n";
1970}

1972// Never called directly, as WasmFunctionData is an "abstract" class.
1973void WasmFunctionData::WasmFunctionDataPrint(std::ostream& os) {
os << "\n - internal: " << Brief(internal());
os << "\n - wrapper_code: " << Brief(TorqueGeneratedClass::wrapper_code());
1976}

1978void WasmExportedFunctionData::WasmExportedFunctionDataPrint(std::ostream& os) {
PrintHeader(os, "WasmExportedFunctionData");
WasmFunctionDataPrint(os);
os << "\n - instance: " << Brief(instance());
os << "\n - function_index: " << function_index();
os << "\n - signature: " << Brief(signature());
os << "\n - wrapper_budget: " << wrapper_budget();
os << "\n - suspender: " << suspender();
os << "\n";
1987}

1989void WasmJSFunctionData::WasmJSFunctionDataPrint(std::ostream& os) {
PrintHeader(os, "WasmJSFunctionData");
WasmFunctionDataPrint(os);
os << "\n - serialized_return_count: " << serialized_return_count();
os << "\n - serialized_parameter_count: " << serialized_parameter_count();
os << "\n - serialized_signature: " << Brief(serialized_signature());
os << "\n";
1996}

1998void WasmOnFulfilledData::WasmOnFulfilledDataPrint(std::ostream& os) {
PrintHeader(os, "WasmOnFulfilledData");
os << "\n - suspender: " << Brief(suspender());
os << '\n';
2002}

2004void WasmApiFunctionRef::WasmApiFunctionRefPrint(std::ostream& os) {
PrintHeader(os, "WasmApiFunctionRef");
os << "\n - isolate_root: " << reinterpret_cast<void*>(isolate_root());
os << "\n - native_context: " << Brief(native_context());
os << "\n - callable: " << Brief(callable());
os << "\n - suspender: " << Brief(suspender());
os << "\n";
2011}

2013void WasmInternalFunction::WasmInternalFunctionPrint(std::ostream& os) {
PrintHeader(os, "WasmInternalFunction");
os << "\n - call target: " << reinterpret_cast<void*>(foreign_address());
os << "\n - ref: " << Brief(ref());
os << "\n - external: " << Brief(external());
os << "\n - code: " << Brief(code());
os << "\n";
2020}

2022void WasmCapiFunctionData::WasmCapiFunctionDataPrint(std::ostream& os) {
PrintHeader(os, "WasmCapiFunctionData");
WasmFunctionDataPrint(os);
os << "\n - embedder_data: " << Brief(embedder_data());
os << "\n - serialized_signature: " << Brief(serialized_signature());
os << "\n";
2028}

2030void WasmModuleObject::WasmModuleObjectPrint(std::ostream& os) {
PrintHeader(os, "WasmModuleObject");
os << "\n - module: " << module();
os << "\n - native module: " << native_module();
os << "\n - export wrappers: " << Brief(export_wrappers());
os << "\n - script: " << Brief(script());
os << "\n";
2037}

2039void WasmGlobalObject::WasmGlobalObjectPrint(std::ostream& os) {
PrintHeader(os, "WasmGlobalObject");
if (type().is_reference()) {
  os << "\n - tagged_buffer: " << Brief(tagged_buffer());
} else {
  os << "\n - untagged_buffer: " << Brief(untagged_buffer());
}
os << "\n - offset: " << offset();
os << "\n - raw_type: " << raw_type();
os << "\n - is_mutable: " << is_mutable();
os << "\n - type: " << type();
os << "\n - is_mutable: " << is_mutable();
os << "\n";
2052}

2054void WasmIndirectFunctionTable::WasmIndirectFunctionTablePrint(
  std::ostream& os) {
PrintHeader(os, "WasmIndirectFunctionTable");
os << "\n - size: " << size();
os << "\n - sig_ids: " << static_cast<void*>(sig_ids());
os << "\n - targets: " << static_cast<void*>(targets());
if (has_managed_native_allocations()) {
  os << "\n - managed_native_allocations: "
     << Brief(managed_native_allocations());
}
os << "\n - refs: " << Brief(refs());
os << "\n";
2066}

2068void WasmValueObject::WasmValueObjectPrint(std::ostream& os) {
PrintHeader(os, "WasmValueObject");
os << "\n - value: " << Brief(value());
os << "\n";
2072}
2073#endif  // V8_ENABLE_WEBASSEMBLY

2075void LoadHandler::LoadHandlerPrint(std::ostream& os) {
PrintHeader(os, "LoadHandler");
// TODO(ishell): implement printing based on handler kind
os << "\n - handler: " << Brief(smi_handler());
os << "\n - validity_cell: " << Brief(validity_cell());
int data_count = data_field_count();
if (data_count >= 1) {
  os << "\n - data1: " << Brief(data1());
}
if (data_count >= 2) {
  os << "\n - data2: " << Brief(data2());
}
if (data_count >= 3) {
  os << "\n - data3: " << Brief(data3());
}
os << "\n";
2091}

2093void StoreHandler::StoreHandlerPrint(std::ostream& os) {
PrintHeader(os, "StoreHandler");
// TODO(ishell): implement printing based on handler kind
os << "\n - handler: " << Brief(smi_handler());
os << "\n - validity_cell: " << Brief(validity_cell());
int data_count = data_field_count();
if (data_count >= 1) {
  os << "\n - data1: " << Brief(data1());
}
if (data_count >= 2) {
  os << "\n - data2: " << Brief(data2());
}
if (data_count >= 3) {
  os << "\n - data3: " << Brief(data3());
}
os << "\n";
2109}

2111void CallHandlerInfo::CallHandlerInfoPrint(std::ostream& os) {
PrintHeader(os, "CallHandlerInfo");
os << "\n - callback: " << Brief(callback());
os << "\n - js_callback: " << Brief(js_callback());
os << "\n - data: " << Brief(data());
os << "\n - side_effect_free: "
   << (IsSideEffectFreeCallHandlerInfo() ? "true" : "false");
os << "\n";
2119}

2121void FunctionTemplateInfo::FunctionTemplateInfoPrint(std::ostream& os) {
PrintHeader(os, "FunctionTemplateInfo");
os << "\n - class name: " << Brief(class_name());
os << "\n - tag: " << tag();
os << "\n - serial_number: " << serial_number();
os << "\n - property_list: " << Brief(property_list());
os << "\n - call_code: " << Brief(call_code(kAcquireLoad));
os << "\n - property_accessors: " << Brief(property_accessors());
os << "\n - signature: " << Brief(signature());
os << "\n - cached_property_name: " << Brief(cached_property_name());
os << "\n - undetectable: " << (undetectable() ? "true" : "false");
os << "\n - need_access_check: " << (needs_access_check() ? "true" : "false");
os << "\n - instantiated: " << (instantiated() ? "true" : "false");
os << "\n - rare_data: " << Brief(rare_data(kAcquireLoad));
os << "\n";
2136}

2138void ObjectTemplateInfo::ObjectTemplateInfoPrint(std::ostream& os) {
PrintHeader(os, "ObjectTemplateInfo");
os << "\n - tag: " << tag();
os << "\n - serial_number: " << serial_number();
os << "\n - property_list: " << Brief(property_list());
os << "\n - property_accessors: " << Brief(property_accessors());
os << "\n - constructor: " << Brief(constructor());
os << "\n - embedder_field_count: " << embedder_field_count();
os << "\n - immutable_proto: " << (immutable_proto() ? "true" : "false");
os << "\n";
2148}

2150void AllocationSite::AllocationSitePrint(std::ostream& os) {
PrintHeader(os, "AllocationSite");
if (this->HasWeakNext()) os << "\n - weak_next: " << Brief(weak_next());
os << "\n - dependent code: " << Brief(dependent_code());
os << "\n - nested site: " << Brief(nested_site());
os << "\n - memento found count: "
   << Brief(Smi::FromInt(memento_found_count()));
os << "\n - memento create count: "
   << Brief(Smi::FromInt(memento_create_count()));
os << "\n - pretenure decision: "
   << Brief(Smi::FromInt(pretenure_decision()));
os << "\n - transition_info: ";
if (!PointsToLiteral()) {
  ElementsKind kind = GetElementsKind();
  os << "Array allocation with ElementsKind " << ElementsKindToString(kind);
} else if (boilerplate().IsJSArray()) {
  os << "Array literal with boilerplate " << Brief(boilerplate());
} else {
  os << "Object literal with boilerplate " << Brief(boilerplate());
}
os << "\n";
2171}

2173void AllocationMemento::AllocationMementoPrint(std::ostream& os) {
PrintHeader(os, "AllocationMemento");
os << "\n - allocation site: ";
if (IsValid()) {
  GetAllocationSite().AllocationSitePrint(os);
} else {
  os << "<invalid>\n";
}
2181}

2183void ScriptOrModule::ScriptOrModulePrint(std::ostream& os) {
PrintHeader(os, "ScriptOrModule");
os << "\n - host_defined_options: " << Brief(host_defined_options());
os << "\n - resource_name: " << Brief(resource_name());
2187}

2189void Script::ScriptPrint(std::ostream& os) {
PrintHeader(os, "Script");
os << "\n - source: " << Brief(source());
os << "\n - name: " << Brief(name());
os << "\n - source_url: " << Brief(source_url());
os << "\n - line_offset: " << line_offset();
os << "\n - column_offset: " << column_offset();
os << "\n - type: " << type();
os << "\n - id: " << id();
os << "\n - context data: " << Brief(context_data());
os << "\n - compilation type: " << compilation_type();
os << "\n - line ends: " << Brief(line_ends());
bool is_wasm = false;
2202#if V8_ENABLE_WEBASSEMBLY1
if ((is_wasm = (type() == TYPE_WASM))) {
  if (has_wasm_breakpoint_infos()) {
    os << "\n - wasm_breakpoint_infos: " << Brief(wasm_breakpoint_infos());
  }
}
2208#endif  // V8_ENABLE_WEBASSEMBLY
if (!is_wasm) {
  if (has_eval_from_shared()) {
    os << "\n - eval from shared: " << Brief(eval_from_shared());
  } else if (is_wrapped()) {
    os << "\n - wrapped arguments: " << Brief(wrapped_arguments());
  } else if (type() == TYPE_WEB_SNAPSHOT) {
    os << "\n - shared function info table: "
       << Brief(shared_function_info_table());
  }
  os << "\n - eval from position: " << eval_from_position();
}
os << "\n - shared function infos: " << Brief(shared_function_infos());
os << "\n";
2222}

2224void JSTemporalPlainDate::JSTemporalPlainDatePrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSTemporalPlainDate");
JSObjectPrintBody(os, *this);
2227}

2229void JSTemporalPlainTime::JSTemporalPlainTimePrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSTemporalPlainTime");
JSObjectPrintBody(os, *this);
2232}

2234void JSTemporalPlainDateTime::JSTemporalPlainDateTimePrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSTemporalPlainDateTime");
JSObjectPrintBody(os, *this);
2237}

2239void JSTemporalZonedDateTime::JSTemporalZonedDateTimePrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSTemporalZonedDateTime");
JSObjectPrintBody(os, *this);
2242}

2244void JSTemporalDuration::JSTemporalDurationPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSTemporalDuration");
JSObjectPrintBody(os, *this);
2247}

2249void JSTemporalInstant::JSTemporalInstantPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSTemporalInstant");
JSObjectPrintBody(os, *this);
2252}

2254void JSTemporalPlainYearMonth::JSTemporalPlainYearMonthPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSTemporalPlainYearMonth");
JSObjectPrintBody(os, *this);
2257}

2259void JSTemporalPlainMonthDay::JSTemporalPlainMonthDayPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSTemporalPlainMonthDay");
JSObjectPrintBody(os, *this);
2262}

2264void JSTemporalTimeZone::JSTemporalTimeZonePrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSTemporalTimeZone");
JSObjectPrintBody(os, *this);
2267}

2269void JSTemporalCalendar::JSTemporalCalendarPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSTemporalCalendar");
JSObjectPrintBody(os, *this);
2272}
2273#ifdef V8_INTL_SUPPORT1
2274void JSV8BreakIterator::JSV8BreakIteratorPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSV8BreakIterator");
os << "\n - locale: " << Brief(locale());
os << "\n - break iterator: " << Brief(break_iterator());
os << "\n - unicode string: " << Brief(unicode_string());
os << "\n - bound adopt text: " << Brief(bound_adopt_text());
os << "\n - bound first: " << Brief(bound_first());
os << "\n - bound next: " << Brief(bound_next());
os << "\n - bound current: " << Brief(bound_current());
os << "\n - bound break type: " << Brief(bound_break_type());
os << "\n";
2285}

2287void JSCollator::JSCollatorPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSCollator");
os << "\n - icu collator: " << Brief(icu_collator());
os << "\n - bound compare: " << Brief(bound_compare());
JSObjectPrintBody(os, *this);
2292}

2294void JSDateTimeFormat::JSDateTimeFormatPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSDateTimeFormat");
os << "\n - locale: " << Brief(locale());
os << "\n - icu locale: " << Brief(icu_locale());
os << "\n - icu simple date format: " << Brief(icu_simple_date_format());
os << "\n - icu date interval format: " << Brief(icu_date_interval_format());
os << "\n - bound format: " << Brief(bound_format());
os << "\n - hour cycle: " << HourCycleAsString();
JSObjectPrintBody(os, *this);
2303}

2305void JSDisplayNames::JSDisplayNamesPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSDisplayNames");
os << "\n - internal: " << Brief(internal());
os << "\n - style: " << StyleAsString();
os << "\n - fallback: " << FallbackAsString();
JSObjectPrintBody(os, *this);
2311}

2313void JSListFormat::JSListFormatPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSListFormat");
os << "\n - locale: " << Brief(locale());
os << "\n - style: " << StyleAsString();
os << "\n - type: " << TypeAsString();
os << "\n - icu formatter: " << Brief(icu_formatter());
JSObjectPrintBody(os, *this);
2320}

2322void JSLocale::JSLocalePrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSLocale");
os << "\n - icu locale: " << Brief(icu_locale());
JSObjectPrintBody(os, *this);
2326}

2328void JSNumberFormat::JSNumberFormatPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSNumberFormat");
os << "\n - locale: " << Brief(locale());
os << "\n - icu_number_formatter: " << Brief(icu_number_formatter());
os << "\n - bound_format: " << Brief(bound_format());
JSObjectPrintBody(os, *this);
2334}

2336void JSPluralRules::JSPluralRulesPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSPluralRules");
os << "\n - locale: " << Brief(locale());
os << "\n - type: " << TypeAsString();
os << "\n - icu plural rules: " << Brief(icu_plural_rules());
os << "\n - icu_number_formatter: " << Brief(icu_number_formatter());
JSObjectPrintBody(os, *this);
2343}

2345void JSRelativeTimeFormat::JSRelativeTimeFormatPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSRelativeTimeFormat");
os << "\n - locale: " << Brief(locale());
os << "\n - numberingSystem: " << Brief(numberingSystem());
os << "\n - numeric: " << NumericAsString();
os << "\n - icu formatter: " << Brief(icu_formatter());
os << "\n";
2352}

2354void JSSegmentIterator::JSSegmentIteratorPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSSegmentIterator");
os << "\n - icu break iterator: " << Brief(icu_break_iterator());
os << "\n - granularity: " << GranularityAsString(GetIsolate());
os << "\n";
2359}

2361void JSSegmenter::JSSegmenterPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSSegmenter");
os << "\n - locale: " << Brief(locale());
os << "\n - granularity: " << GranularityAsString(GetIsolate());
os << "\n - icu break iterator: " << Brief(icu_break_iterator());
JSObjectPrintBody(os, *this);
2367}

2369void JSSegments::JSSegmentsPrint(std::ostream& os) {
JSObjectPrintHeader(os, *this, "JSSegments");
os << "\n - icu break iterator: " << Brief(icu_break_iterator());
os << "\n - unicode string: " << Brief(unicode_string());
os << "\n - granularity: " << GranularityAsString(GetIsolate());
JSObjectPrintBody(os, *this);
2375}
2376#endif  // V8_INTL_SUPPORT

2378namespace {
2379void PrintScopeInfoList(ScopeInfo scope_info, std::ostream& os,
                      const char* list_name, int length) {
DisallowGarbageCollection no_gc;
if (length <= 0) return;
os << "\n - " << list_name;
os << " {\n";
for (auto it : ScopeInfo::IterateLocalNames(&scope_info, no_gc)) {
  os << "    - " << it->index() << ": " << it->name() << "\n";
}
os << "  }";
2389}
2390}  // namespace

2392void ScopeInfo::ScopeInfoPrint(std::ostream& os) {
PrintHeader(os, "ScopeInfo");
if (IsEmpty()) {
  os << "\n - empty\n";
  return;
}
int flags = Flags();

os << "\n - parameters: " << ParameterCount();
os << "\n - context locals : " << ContextLocalCount();
if (HasInlinedLocalNames()) {
  os << "\n - inlined local names";
} else {
  os << "\n - local names in a hashtable: "
     << Brief(context_local_names_hashtable());
}

os << "\n - scope type: " << scope_type();
if (SloppyEvalCanExtendVars()) os << "\n - sloppy eval";
os << "\n - language mode: " << language_mode();
if (is_declaration_scope()) os << "\n - declaration scope";
if (HasReceiver()) {
  os << "\n - receiver: " << ReceiverVariableBits::decode(flags);
}
if (ClassScopeHasPrivateBrand()) os << "\n - class scope has private brand";
if (HasSavedClassVariable()) os << "\n - has saved class variable";
if (HasNewTarget()) os << "\n - needs new target";
if (HasFunctionName()) {
  os << "\n - function name(" << FunctionVariableBits::decode(flags) << "): ";
  FunctionName().ShortPrint(os);
}
if (IsAsmModule()) os << "\n - asm module";
if (HasSimpleParameters()) os << "\n - simple parameters";
if (PrivateNameLookupSkipsOuterClass())
  os << "\n - private name lookup skips outer class";
os << "\n - function kind: " << function_kind();
if (HasOuterScopeInfo()) {
  os << "\n - outer scope info: " << Brief(OuterScopeInfo());
}
if (HasLocalsBlockList()) {
  os << "\n - locals blocklist: " << Brief(LocalsBlockList());
}
if (HasFunctionName()) {
  os << "\n - function name: " << Brief(FunctionName());
}
if (HasInferredFunctionName()) {
  os << "\n - inferred function name: " << Brief(InferredFunctionName());
}
if (HasContextExtensionSlot()) {
  os << "\n - has context extension slot";
}

if (HasPositionInfo()) {
  os << "\n - start position: " << StartPosition();
  os << "\n - end position: " << EndPosition();
}
os << "\n - length: " << length();
if (length() > 0) {
  PrintScopeInfoList(*this, os, "context slots", ContextLocalCount());
  // TODO(neis): Print module stuff if present.
}
os << "\n";
2454}

2456void PreparseData::PreparseDataPrint(std::ostream& os) {
PrintHeader(os, "PreparseData");
os << "\n - data_length: " << data_length();
os << "\n - children_length: " << children_length();
if (data_length() > 0) {
  os << "\n - data-start: " << (address() + kDataStartOffset);
}
if (children_length() > 0) {
  os << "\n - children-start: " << inner_start_offset();
}
for (int i = 0; i < children_length(); ++i) {
  os << "\n - [" << i << "]: " << Brief(get_child(i));
}
os << "\n";
2470}

2472template <HeapObjectReferenceType kRefType, typename StorageType>
2473void TaggedImpl<kRefType, StorageType>::Print() {
StdoutStream os;
this->Print(os);
os << std::flush;
2477}

2479template <HeapObjectReferenceType kRefType, typename StorageType>
2480void TaggedImpl<kRefType, StorageType>::Print(std::ostream& os) {
Smi smi;
HeapObject heap_object;
if (ToSmi(&smi)) {
  smi.SmiPrint(os);
} else if (IsCleared()) {
  os << "[cleared]";
} else if (GetHeapObjectIfWeak(&heap_object)) {
  os << "[weak] ";
  heap_object.HeapObjectPrint(os);
} else if (GetHeapObjectIfStrong(&heap_object)) {
  heap_object.HeapObjectPrint(os);
} else {
  UNREACHABLE()V8_Fatal("unreachable code");
}
2495}

2497void HeapNumber::HeapNumberPrint(std::ostream& os) {
HeapNumberShortPrint(os);
os << "\n";
2500}

2502#endif  // OBJECT_PRINT

2504void HeapNumber::HeapNumberShortPrint(std::ostream& os) {
static constexpr uint64_t kUint64AllBitsSet =
    static_cast<uint64_t>(int64_t{-1});
// Min/max integer values representable by 52 bits of mantissa and 1 sign bit.
static constexpr int64_t kMinSafeInteger =
    static_cast<int64_t>(kUint64AllBitsSet << 53);
static constexpr int64_t kMaxSafeInteger = -(kMinSafeInteger + 1);

double val = value();
if (val == DoubleToInteger(val) &&
    val >= static_cast<double>(kMinSafeInteger) &&
    val <= static_cast<double>(kMaxSafeInteger)) {
  int64_t i = static_cast<int64_t>(val);
  os << i << ".0";
} else {
  os << val;
}
2521}

2523// TODO(cbruni): remove once the new maptracer is in place.
2524void Name::NameShortPrint() {
if (this->IsString()) {
  PrintF("%s", String::cast(*this).ToCString().get());
} else {
  DCHECK(this->IsSymbol())((void) 0);
  Symbol s = Symbol::cast(*this);
  if (s.description().IsUndefined()) {
    PrintF("#<%s>", s.PrivateSymbolToName());
  } else {
    PrintF("<%s>", String::cast(s.description()).ToCString().get());
  }
}
2536}

2538// TODO(cbruni): remove once the new maptracer is in place.
2539int Name::NameShortPrint(base::Vector<char> str) {
if (this->IsString()) {
  return SNPrintF(str, "%s", String::cast(*this).ToCString().get());
} else {
  DCHECK(this->IsSymbol())((void) 0);
  Symbol s = Symbol::cast(*this);
  if (s.description().IsUndefined()) {
    return SNPrintF(str, "#<%s>", s.PrivateSymbolToName());
  } else {
    return SNPrintF(str, "<%s>",
                    String::cast(s.description()).ToCString().get());
  }
}
2552}

2554void Map::PrintMapDetails(std::ostream& os) {
DisallowGarbageCollection no_gc;
this->MapPrint(os);
instance_descriptors().PrintDescriptors(os);
2558}

2560void Map::MapPrint(std::ostream& os) {
2561#ifdef OBJECT_PRINT1
PrintHeader(os, "Map");
2563#else
os << "Map=" << reinterpret_cast<void*>(ptr());
2565#endif
os << "\n - type: " << instance_type();
os << "\n - instance size: ";
if (instance_size() == kVariableSizeSentinel) {
  os << "variable";
} else {
  os << instance_size();
}
if (IsJSObjectMap()) {
  os << "\n - inobject properties: " << GetInObjectProperties();
}
os << "\n - elements kind: " << ElementsKindToString(elements_kind());
os << "\n - unused property fields: " << UnusedPropertyFields();
os << "\n - enum length: ";
if (EnumLength() == kInvalidEnumCacheSentinel) {
  os << "invalid";
} else {
  os << EnumLength();
}
if (is_deprecated()) os << "\n - deprecated_map";
if (is_stable()) os << "\n - stable_map";
if (is_migration_target()) os << "\n - migration_target";
if (is_dictionary_map()) os << "\n - dictionary_map";
if (has_named_interceptor()) os << "\n - named_interceptor";
if (has_indexed_interceptor()) os << "\n - indexed_interceptor";
if (may_have_interesting_symbols()) os << "\n - may_have_interesting_symbols";
if (is_undetectable()) os << "\n - undetectable";
if (is_callable()) os << "\n - callable";
if (is_constructor()) os << "\n - constructor";
if (has_prototype_slot()) {
  os << "\n - has_prototype_slot";
  if (has_non_instance_prototype()) os << " (non-instance prototype)";
}
if (is_access_check_needed()) os << "\n - access_check_needed";
if (!is_extensible()) os << "\n - non-extensible";
if (IsContextMap()) {
  os << "\n - native context: " << Brief(native_context());
} else if (is_prototype_map()) {
  os << "\n - prototype_map";
  os << "\n - prototype info: " << Brief(prototype_info());
} else {
  os << "\n - back pointer: " << Brief(GetBackPointer());
}
os << "\n - prototype_validity cell: " << Brief(prototype_validity_cell());
os << "\n - instance descriptors " << (owns_descriptors() ? "(own) " : "")
   << "#" << NumberOfOwnDescriptors() << ": "
   << Brief(instance_descriptors());

// Read-only maps can't have transitions, which is fortunate because we need
// the isolate to iterate over the transitions.
if (!IsReadOnlyHeapObject(*this)) {
  Isolate* isolate = GetIsolateFromWritableObject(*this);
  TransitionsAccessor transitions(isolate, *this);
  int nof_transitions = transitions.NumberOfTransitions();
  if (nof_transitions > 0) {
    os << "\n - transitions #" << nof_transitions << ": ";
    HeapObject heap_object;
    Smi smi;
    if (raw_transitions()->ToSmi(&smi)) {
      os << Brief(smi);
    } else if (raw_transitions()->GetHeapObject(&heap_object)) {
      os << Brief(heap_object);
    }
2628#ifdef OBJECT_PRINT1
    transitions.PrintTransitions(os);
2630#endif  // OBJECT_PRINT
  }
}
os << "\n - prototype: " << Brief(prototype());
if (!IsContextMap()) {
  os << "\n - constructor: " << Brief(GetConstructor());
}
os << "\n - dependent code: " << Brief(dependent_code());
os << "\n - construction counter: " << construction_counter();
os << "\n";
2640}

2642void DescriptorArray::PrintDescriptors(std::ostream& os) {
for (InternalIndex i : InternalIndex::Range(number_of_descriptors())) {
  Name key = GetKey(i);
  os << "\n  [" << i.as_int() << "]: ";
2646#ifdef OBJECT_PRINT1
  key.NamePrint(os);
2648#else
  key.ShortPrint(os);
2650#endif
  os << " ";
  PrintDescriptorDetails(os, i, PropertyDetails::kPrintFull);
}
os << "\n";
2655}

2657void DescriptorArray::PrintDescriptorDetails(std::ostream& os,
                                           InternalIndex descriptor,
                                           PropertyDetails::PrintMode mode) {
PropertyDetails details = GetDetails(descriptor);
details.PrintAsFastTo(os, mode);
os << " @ ";
switch (details.location()) {
  case PropertyLocation::kField: {
    FieldType field_type = GetFieldType(descriptor);
    field_type.PrintTo(os);
    break;
  }
  case PropertyLocation::kDescriptor:
    Object value = GetStrongValue(descriptor);
    os << Brief(value);
    if (value.IsAccessorPair()) {
      AccessorPair pair = AccessorPair::cast(value);
      os << "(get: " << Brief(pair.getter())
         << ", set: " << Brief(pair.setter()) << ")";
    }
    break;
}
2679}

2681#if defined(DEBUG) || defined(OBJECT_PRINT1)
2682// This method is only meant to be called from gdb for debugging purposes.
2683// Since the string can also be in two-byte encoding, non-Latin1 characters
2684// will be ignored in the output.
2685char* String::ToAsciiArray() {
// Static so that subsequent calls frees previously allocated space.
// This also means that previous results will be overwritten.
static char* buffer = nullptr;
if (buffer != nullptr) delete[] buffer;
buffer = new char[length() + 1];
WriteToFlat(*this, reinterpret_cast<uint8_t*>(buffer), 0, length());
buffer[length()] = 0;
return buffer;
2694}

2696// static
2697void TransitionsAccessor::PrintOneTransition(std::ostream& os, Name key,
                                           Map target) {
os << "\n     ";
2700#ifdef OBJECT_PRINT1
key.NamePrint(os);
2702#else
key.ShortPrint(os);
2704#endif
os << ": ";
ReadOnlyRoots roots = key.GetReadOnlyRoots();
if (key == roots.nonextensible_symbol()) {
  os << "(transition to non-extensible)";
} else if (key == roots.sealed_symbol()) {
  os << "(transition to sealed)";
} else if (key == roots.frozen_symbol()) {
  os << "(transition to frozen)";
} else if (key == roots.elements_transition_symbol()) {
  os << "(transition to " << ElementsKindToString(target.elements_kind())
     << ")";
} else if (key == roots.strict_function_transition_symbol()) {
  os << " (transition to strict function)";
} else {
  DCHECK(!IsSpecialTransition(roots, key))((void) 0);
  os << "(transition to ";
  InternalIndex descriptor = target.LastAdded();
  DescriptorArray descriptors = target.instance_descriptors();
  descriptors.PrintDescriptorDetails(os, descriptor,
                                     PropertyDetails::kForTransitions);
  os << ")";
}
os << " -> " << Brief(target);
2728}

2730void TransitionArray::PrintInternal(std::ostream& os) {
int num_transitions = number_of_transitions();
os << "Transition array #" << num_transitions << ":";
for (int i = 0; i < num_transitions; i++) {
  Name key = GetKey(i);
  Map target = GetTarget(i);
  TransitionsAccessor::PrintOneTransition(os, key, target);
}
os << "\n" << std::flush;
2739}

2741void TransitionsAccessor::PrintTransitions(std::ostream& os) {
switch (encoding()) {
  case kPrototypeInfo:
  case kUninitialized:
  case kMigrationTarget:
    return;
  case kWeakRef: {
    Map target = Map::cast(raw_transitions_->GetHeapObjectAssumeWeak());
    Name key = GetSimpleTransitionKey(target);
    PrintOneTransition(os, key, target);
    break;
  }
  case kFullTransitionArray:
    return transitions().PrintInternal(os);
}
2756}

2758void TransitionsAccessor::PrintTransitionTree() {
StdoutStream os;
os << "map= " << Brief(map_);
DisallowGarbageCollection no_gc;
PrintTransitionTree(os, 0, &no_gc);
os << "\n" << std::flush;
2764}

2766void TransitionsAccessor::PrintTransitionTree(
  std::ostream& os, int level, DisallowGarbageCollection* no_gc) {
ReadOnlyRoots roots = ReadOnlyRoots(isolate_);
int num_transitions = NumberOfTransitions();
if (num_transitions == 0) return;
for (int i = 0; i < num_transitions; i++) {
  Name key = GetKey(i);
  Map target = GetTarget(i);
  os << std::endl
     << "  " << level << "/" << i << ":" << std::setw(level * 2 + 2) << " ";
  std::stringstream ss;
  ss << Brief(target);
  os << std::left << std::setw(50) << ss.str() << ": ";

  if (key == roots.nonextensible_symbol()) {
    os << "to non-extensible";
  } else if (key == roots.sealed_symbol()) {
    os << "to sealed ";
  } else if (key == roots.frozen_symbol()) {
    os << "to frozen";
  } else if (key == roots.elements_transition_symbol()) {
    os << "to " << ElementsKindToString(target.elements_kind());
  } else if (key == roots.strict_function_transition_symbol()) {
    os << "to strict function";
  } else {
2791#ifdef OBJECT_PRINT1
    key.NamePrint(os);
2793#else
    key.ShortPrint(os);
2795#endif
    os << " ";
    DCHECK(!IsSpecialTransition(ReadOnlyRoots(isolate_), key))((void) 0);
    os << "to ";
    InternalIndex descriptor = target.LastAdded();
    DescriptorArray descriptors = target.instance_descriptors(isolate_);
    descriptors.PrintDescriptorDetails(os, descriptor,
                                       PropertyDetails::kForTransitions);
  }
  TransitionsAccessor transitions(isolate_, target);
  transitions.PrintTransitionTree(os, level + 1, no_gc);
}
2807}

2809void JSObject::PrintTransitions(std::ostream& os) {
TransitionsAccessor ta(GetIsolate(), map());
if (ta.NumberOfTransitions() == 0) return;
os << "\n - transitions";
ta.PrintTransitions(os);
2814}

2816#endif  // defined(DEBUG) || defined(OBJECT_PRINT)
2817}  // namespace internal
2818}  // namespace v8

2820namespace {

2822inline i::Object GetObjectFromRaw(void* object) {
i::Address object_ptr = reinterpret_cast<i::Address>(object);
2824#ifdef V8_COMPRESS_POINTERS
if (RoundDown<i::kPtrComprCageBaseAlignment>(object_ptr) == i::kNullAddress) {
  // Try to decompress pointer.
  i::Isolate* isolate = i::Isolate::Current();
  object_ptr =
      i::DecompressTaggedAny(isolate, static_cast<i::Tagged_t>(object_ptr));
}
2831#endif
return i::Object(object_ptr);
2833}

2835}  // namespace

2837//
2838// The following functions are used by our gdb macros.
2839//
2840V8_EXPORT_PRIVATE extern i::Object _v8_internal_Get_Object(void* object) {
return GetObjectFromRaw(object);
2842}

2844V8_EXPORT_PRIVATE extern void _v8_internal_Print_Object(void* object) {
GetObjectFromRaw(object).Print();
2846}

2848V8_EXPORT_PRIVATE extern void _v8_internal_Print_LoadHandler(void* object) {
2849#ifdef OBJECT_PRINT1
i::StdoutStream os;
i::LoadHandler::PrintHandler(GetObjectFromRaw(object), os);
os << std::flush;
2853#endif
2854}

2856V8_EXPORT_PRIVATE extern void _v8_internal_Print_StoreHandler(void* object) {
2857#ifdef OBJECT_PRINT1
i::StdoutStream os;
i::StoreHandler::PrintHandler(GetObjectFromRaw(object), os);
os << std::flush;
2861#endif
2862}

2864V8_EXPORT_PRIVATE extern void _v8_internal_Print_Code(void* object) {
i::Address address = reinterpret_cast<i::Address>(object);
i::Isolate* isolate = i::Isolate::Current();

2868#if V8_ENABLE_WEBASSEMBLY1
{
  i::wasm::WasmCodeRefScope scope;
  if (auto* wasm_code = i::wasm::GetWasmCodeManager()->LookupCode(address)) {
    i::StdoutStream os;
    wasm_code->Disassemble(nullptr, os, address);
    return;
  }
}
2877#endif  // V8_ENABLE_WEBASSEMBLY

if (!isolate->heap()->InSpaceSlow(address, i::CODE_SPACE) &&
    !isolate->heap()->InSpaceSlow(address, i::CODE_LO_SPACE) &&
    !i::OffHeapInstructionStream::PcIsOffHeap(isolate, address) &&
    !i::ReadOnlyHeap::Contains(address)) {
  i::PrintF(
      "%p is not within the current isolate's code, read_only or embedded "
      "spaces\n",
      object);
  return;
}

i::Code code = isolate->FindCodeObject(address);
if (!code.IsCode()) {
  i::PrintF("No code object found containing %p\n", object);
  return;
}
2895#ifdef ENABLE_DISASSEMBLER1
i::StdoutStream os;
code.Disassemble(nullptr, os, isolate, address);
2898#else   // ENABLE_DISASSEMBLER
code.Print();
2900#endif  // ENABLE_DISASSEMBLER
2901}

2903V8_EXPORT_PRIVATE extern void _v8_internal_Print_StackTrace() {
i::Isolate* isolate = i::Isolate::Current();
isolate->PrintStack(stdoutstdout);
2906}

2908V8_EXPORT_PRIVATE extern void _v8_internal_Print_TransitionTree(void* object) {
i::Object o(GetObjectFromRaw(object));
if (!o.IsMap()) {
  printf("Please provide a valid Map\n");
} else {
2913#if defined(DEBUG) || defined(OBJECT_PRINT1)
  i::Map map = i::Map::unchecked_cast(o);
  i::TransitionsAccessor transitions(i::Isolate::Current(), map);
  transitions.PrintTransitionTree();
2917#endif
}
2919}

←

../deps/v8/src/objects/swiss-name-dictionary-inl.h

→

1// Copyright 2021 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4 
5#ifndef V8_OBJECTS_SWISS_NAME_DICTIONARY_INL_H_
6#define V8_OBJECTS_SWISS_NAME_DICTIONARY_INL_H_
7 
8#include <algorithm>
9 
10#include "src/base/macros.h"
11#include "src/base/optional.h"
12#include "src/execution/isolate-utils-inl.h"
13#include "src/heap/heap.h"
14#include "src/objects/fixed-array-inl.h"
15#include "src/objects/instance-type-inl.h"
16#include "src/objects/js-collection-iterator.h"
17#include "src/objects/objects-inl.h"
18#include "src/objects/smi.h"
19#include "src/objects/swiss-name-dictionary.h"
20 
21// Has to be the last include (doesn't have include guards):
22#include "src/objects/object-macros.h"
23 
24namespace v8 {
25namespace internal {
26 
27#include "torque-generated/src/objects/swiss-name-dictionary-tq-inl.inc"
28 
29CAST_ACCESSOR(SwissNameDictionary)
30OBJECT_CONSTRUCTORS_IMPL(SwissNameDictionary, HeapObject)
31 
32swiss_table::ctrl_t* SwissNameDictionary::CtrlTable() {
33  return reinterpret_cast<ctrl_t*>(
34      field_address(CtrlTableStartOffset(Capacity())));
35}
36 
37uint8_t* SwissNameDictionary::PropertyDetailsTable() {
38  return reinterpret_cast<uint8_t*>(
39      field_address(PropertyDetailsTableStartOffset(Capacity())));
40}
41 
42int SwissNameDictionary::Capacity() {
43  return ReadField<int32_t>(CapacityOffset());
44}
45 
46void SwissNameDictionary::SetCapacity(int capacity) {
47  DCHECK(IsValidCapacity(capacity))((void) 0);
48 
49  WriteField<int32_t>(CapacityOffset(), capacity);
50}
51 
52int SwissNameDictionary::NumberOfElements() {
53  return GetMetaTableField(kMetaTableElementCountFieldIndex);
54}
55 
56int SwissNameDictionary::NumberOfDeletedElements() {
57  return GetMetaTableField(kMetaTableDeletedElementCountFieldIndex);
58}
59 
60void SwissNameDictionary::SetNumberOfElements(int elements) {
61  SetMetaTableField(kMetaTableElementCountFieldIndex, elements);
62}
63 
64void SwissNameDictionary::SetNumberOfDeletedElements(int deleted_elements) {
65  SetMetaTableField(kMetaTableDeletedElementCountFieldIndex, deleted_elements);
66}
67 
68int SwissNameDictionary::UsedCapacity() {
69  return NumberOfElements() + NumberOfDeletedElements();
70}
71 
72// static
73constexpr bool SwissNameDictionary::IsValidCapacity(int capacity) {
74  return capacity == 0 || (capacity >= kInitialCapacity &&
75                           // Must be power of 2.
76                           ((capacity & (capacity - 1)) == 0));
77}
78 
79// static
80constexpr int SwissNameDictionary::DataTableSize(int capacity) {
81  return capacity * kTaggedSize * kDataTableEntryCount;
82}
83 
84// static
85constexpr int SwissNameDictionary::CtrlTableSize(int capacity) {
86  // Doing + |kGroupWidth| due to the copy of first group at the end of control
87  // table.
88  return (capacity + kGroupWidth) * kOneByteSize;
89}
90 
91// static
92constexpr int SwissNameDictionary::SizeFor(int capacity) {
93  DCHECK(IsValidCapacity(capacity))((void) 0);
94  return PropertyDetailsTableStartOffset(capacity) + capacity;
95}
96 
97// We use 7/8th as maximum load factor for non-special cases.
98// For 16-wide groups, that gives an average of two empty slots per group.
99// Similar to Abseil's CapacityToGrowth.
100// static
101constexpr int SwissNameDictionary::MaxUsableCapacity(int capacity) {
102  DCHECK(IsValidCapacity(capacity))((void) 0);
103 
104  if (Group::kWidth == 8 && capacity == 4) {
105    // If the group size is 16 we can fully utilize capacity 4: There will be
106    // enough kEmpty entries in the ctrl table.
107    return 3;
108  }
109  return capacity - capacity / 8;
110}
111 
112// Returns |at_least_space_for| * 8/7 for non-special cases. Similar to Abseil's
113// GrowthToLowerboundCapacity.
114// static
115int SwissNameDictionary::CapacityFor(int at_least_space_for) {
116  if (at_least_space_for <= 4) {
117    if (at_least_space_for == 0) {
118      return 0;
119    } else if (at_least_space_for < 4) {
120      return 4;
121    } else if (kGroupWidth == 16) {
122      DCHECK_EQ(4, at_least_space_for)((void) 0);
123      return 4;
124    } else if (kGroupWidth == 8) {
125      DCHECK_EQ(4, at_least_space_for)((void) 0);
126      return 8;
127    }
128  }
129 
130  int non_normalized = at_least_space_for + at_least_space_for / 7;
131  return base::bits::RoundUpToPowerOfTwo32(non_normalized);
132}
133 
134int SwissNameDictionary::EntryForEnumerationIndex(int enumeration_index) {
135  DCHECK_LT(enumeration_index, UsedCapacity())((void) 0);
136  return GetMetaTableField(kMetaTableEnumerationDataStartIndex +
137                           enumeration_index);
138}
139 
140void SwissNameDictionary::SetEntryForEnumerationIndex(int enumeration_index,
141                                                      int entry) {
142  DCHECK_LT(enumeration_index, UsedCapacity())((void) 0);
143  DCHECK_LT(static_cast<unsigned>(entry), static_cast<unsigned>(Capacity()))((void) 0);
144  DCHECK(IsFull(GetCtrl(entry)))((void) 0);
145 
146  SetMetaTableField(kMetaTableEnumerationDataStartIndex + enumeration_index,
147                    entry);
148}
149 
150template <typename IsolateT>
151InternalIndex SwissNameDictionary::FindEntry(IsolateT* isolate, Object key) {
152  Name name = Name::cast(key);
153  DCHECK(name.IsUniqueName())((void) 0);
154  uint32_t hash = name.hash();
155 
156  // We probe the hash table in groups of |kGroupWidth| buckets. One bucket
157  // corresponds to a 1-byte entry in the control table.
158  // Each group can be uniquely identified by the index of its first bucket,
159  // which must be a value between 0 (inclusive) and Capacity() (exclusive).
160  // Note that logically, groups wrap around after index Capacity() - 1. This
161  // means that probing the group starting at, for example, index Capacity() - 1
162  // means probing CtrlTable()[Capacity() - 1] followed by CtrlTable()[0] to
163  // CtrlTable()[6], assuming a group width of 8. However, in memory, this is
164  // achieved by maintaining an additional |kGroupWidth| bytes after the first
165  // Capacity() entries of the control table. These contain a copy of the first
166  // max(Capacity(), kGroupWidth) entries of the control table. If Capacity() <
167  // |kGroupWidth|, then the remaining |kGroupWidth| - Capacity() control bytes
168  // are left as |kEmpty|.
169  // This means that actually, probing the group starting
170  // at index Capacity() - 1 is achieved by probing CtrlTable()[Capacity() - 1],
171  // followed by CtrlTable()[Capacity()] to CtrlTable()[Capacity() + 7].
172 
173  ctrl_t* ctrl = CtrlTable();
174  auto seq = probe(hash, Capacity());
175  // At this point, seq.offset() denotes the index of the first bucket in the
176  // first group to probe. Note that this doesn't have to be divisible by
177  // |kGroupWidth|, but can have any value between 0 (inclusive) and Capacity()
178  // (exclusive).
179  while (true) {
180    Group g{ctrl + seq.offset()};
181    for (int i : g.Match(swiss_table::H2(hash))) {
182      int candidate_entry = seq.offset(i);
183      Object candidate_key = KeyAt(candidate_entry);
184      // This key matching is SwissNameDictionary specific!
185      if (candidate_key == key) return InternalIndex(candidate_entry);
186    }
187    if (g.MatchEmpty()) return InternalIndex::NotFound();
188 
189    // The following selects the next group to probe. Note that seq.offset()
190    // always advances by a multiple of |kGroupWidth|, modulo Capacity(). This
191    // is done in a way such that we visit Capacity() / |kGroupWidth|
192    // non-overlapping (!) groups before we would visit the same group (or
193    // bucket) again.
194    seq.next();
195 
196    // If the following DCHECK weren't true, we would have probed all Capacity()
197    // different buckets without finding one containing |kEmpty| (which would
198    // haved triggered the g.MatchEmpty() check above). This must not be the
199    // case because the maximum load factor of 7/8 guarantees that there must
200    // always remain empty buckets.
201    //
202    // The only exception from this rule are small tables, where 2 * Capacity()
203    // < |kGroupWidth|, in which case all Capacity() entries can be filled
204    // without leaving empty buckets. The layout of the control
205    // table guarantees that after the first Capacity() entries of the control
206    // table, the control table contains a copy of those first Capacity()
207    // entries, followed by kGroupWidth - 2 * Capacity() entries containing
208    // |kEmpty|. This guarantees that the g.MatchEmpty() check above will
209    // always trigger if the element wasn't found, correctly preventing us from
210    // probing more than one group in this special case.
211    DCHECK_LT(seq.index(), Capacity())((void) 0);
212  }
213}
214 
215template <typename IsolateT>
216InternalIndex SwissNameDictionary::FindEntry(IsolateT* isolate,
217                                             Handle<Object> key) {
218  return FindEntry(isolate, *key);
219}
220 
221Object SwissNameDictionary::LoadFromDataTable(int entry, int data_offset) {
222  return LoadFromDataTable(GetPtrComprCageBase(*this), entry, data_offset);
223}
224 
225Object SwissNameDictionary::LoadFromDataTable(PtrComprCageBase cage_base,
226                                              int entry, int data_offset) {
227  DCHECK_LT(static_cast<unsigned>(entry), static_cast<unsigned>(Capacity()))((void) 0);
228  int offset = DataTableStartOffset() +
229               (entry * kDataTableEntryCount + data_offset) * kTaggedSize;
230  return TaggedField<Object>::Relaxed_Load(cage_base, *this, offset);
231}
232 
233void SwissNameDictionary::StoreToDataTable(int entry, int data_offset,
234                                           Object data) {
235  DCHECK_LT(static_cast<unsigned>(entry), static_cast<unsigned>(Capacity()))((void) 0);
236 
237  int offset = DataTableStartOffset() +
238               (entry * kDataTableEntryCount + data_offset) * kTaggedSize;
239 
240  RELAXED_WRITE_FIELD(*this, offset, data);
241  WRITE_BARRIER(*this, offset, data);
242}
243 
244void SwissNameDictionary::StoreToDataTableNoBarrier(int entry, int data_offset,
245                                                    Object data) {
246  DCHECK_LT(static_cast<unsigned>(entry), static_cast<unsigned>(Capacity()))((void) 0);
247 
248  int offset = DataTableStartOffset() +
249               (entry * kDataTableEntryCount + data_offset) * kTaggedSize;
250 
251  RELAXED_WRITE_FIELD(*this, offset, data);
252}
253 
254void SwissNameDictionary::ClearDataTableEntry(Isolate* isolate, int entry) {
255  ReadOnlyRoots roots(isolate);
256 
257  StoreToDataTable(entry, kDataTableKeyEntryIndex, roots.the_hole_value());
258  StoreToDataTable(entry, kDataTableValueEntryIndex, roots.the_hole_value());
259}
260 
261void SwissNameDictionary::ValueAtPut(int entry, Object value) {
262  DCHECK(!value.IsTheHole())((void) 0);
263  StoreToDataTable(entry, kDataTableValueEntryIndex, value);
264}
265 
266void SwissNameDictionary::ValueAtPut(InternalIndex entry, Object value) {
267  ValueAtPut(entry.as_int(), value);
268}
269 
270void SwissNameDictionary::SetKey(int entry, Object key) {
271  DCHECK(!key.IsTheHole())((void) 0);
272  StoreToDataTable(entry, kDataTableKeyEntryIndex, key);
273}
274 
275void SwissNameDictionary::DetailsAtPut(int entry, PropertyDetails details) {
276  DCHECK_LT(static_cast<unsigned>(entry), static_cast<unsigned>(Capacity()))((void) 0);
277  uint8_t encoded_details = details.ToByte();
278  PropertyDetailsTable()[entry] = encoded_details;
279}
280 
281void SwissNameDictionary::DetailsAtPut(InternalIndex entry,
282                                       PropertyDetails details) {
283  DetailsAtPut(entry.as_int(), details);
284}
285 
286Object SwissNameDictionary::KeyAt(int entry) {
287  return LoadFromDataTable(entry, kDataTableKeyEntryIndex);
288}
289 
290Object SwissNameDictionary::KeyAt(InternalIndex entry) {
291  return KeyAt(entry.as_int());
292}
293 
294Name SwissNameDictionary::NameAt(InternalIndex entry) {
295  return Name::cast(KeyAt(entry));
296}
297 
298// This version can be called on empty buckets.
299Object SwissNameDictionary::ValueAtRaw(int entry) {
300  return LoadFromDataTable(entry, kDataTableValueEntryIndex);
301}
302 
303Object SwissNameDictionary::ValueAt(InternalIndex entry) {
304  DCHECK(IsFull(GetCtrl(entry.as_int())))((void) 0);
305  return ValueAtRaw(entry.as_int());
306}
307 
308base::Optional<Object> SwissNameDictionary::TryValueAt(InternalIndex entry) {
309#if DEBUG
310  Isolate* isolate;
311  GetIsolateFromHeapObject(*this, &isolate);
312  DCHECK_NE(isolate, nullptr)((void) 0);
313  SLOW_DCHECK(!isolate->heap()->IsPendingAllocation(*this))((void)0);
314#endif  // DEBUG
315  // We can read Capacity() in a non-atomic way since we are reading an
316  // initialized object which is not pending allocation.
317  if (static_cast<unsigned>(entry.as_int()) >=
318      static_cast<unsigned>(Capacity())) {
319    return {};
320  }
321  return ValueAtRaw(entry.as_int());
322}
323 
324PropertyDetails SwissNameDictionary::DetailsAt(int entry) {
325  // GetCtrl(entry) does a bounds check for |entry| value.
326  DCHECK(IsFull(GetCtrl(entry)))((void) 0);
327 
328  uint8_t encoded_details = PropertyDetailsTable()[entry];
329  return PropertyDetails::FromByte(encoded_details);
330}
331 
332PropertyDetails SwissNameDictionary::DetailsAt(InternalIndex entry) {
333  return DetailsAt(entry.as_int());
334}
335 
336// static
337template <typename IsolateT>
338Handle<SwissNameDictionary> SwissNameDictionary::EnsureGrowable(
339    IsolateT* isolate, Handle<SwissNameDictionary> table) {
340  int capacity = table->Capacity();
341 
342  if (table->UsedCapacity() < MaxUsableCapacity(capacity)) {
343    // We have room for at least one more entry, nothing to do.
344    return table;
345  }
346 
347  int new_capacity = capacity == 0 ? kInitialCapacity : capacity * 2;
348  return Rehash(isolate, table, new_capacity);
349}
350 
351swiss_table::ctrl_t SwissNameDictionary::GetCtrl(int entry) {
352  DCHECK_LT(static_cast<unsigned>(entry), static_cast<unsigned>(Capacity()))((void) 0);
353 
354  return CtrlTable()[entry];
355}
356 
357void SwissNameDictionary::SetCtrl(int entry, ctrl_t h) {
358  int capacity = Capacity();
359  DCHECK_LT(static_cast<unsigned>(entry), static_cast<unsigned>(capacity))((void) 0);
360 
361  ctrl_t* ctrl = CtrlTable();
362  ctrl[entry] = h;
363 
364  // The ctrl table contains a copy of the first group (i.e., the group starting
365  // at entry 0) after the first |capacity| entries of the ctrl table. This
366  // means that the ctrl table always has size |capacity| + |kGroupWidth|.
367  // However, note that we may have |capacity| < |kGroupWidth|. For example, if
368  // Capacity() == 8 and |kGroupWidth| == 16, then ctrl[0] is copied to ctrl[8],
369  // ctrl[1] to ctrl[9], etc. In this case, ctrl[16] to ctrl[23] remain unused,
370  // which means that their values are always Ctrl::kEmpty.
371  // We achieve the necessary copying without branching here using some bit
372  // magic: We set {copy_entry = entry} in those cases where we don't actually
373  // have to perform a copy (meaning that we just repeat the {ctrl[entry] = h}
374  // from above). If we do need to do some actual copying, we set {copy_entry =
375  // Capacity() + entry}.
376 
377  int mask = capacity - 1;
378  int copy_entry =
379      ((entry - Group::kWidth) & mask) + 1 + ((Group::kWidth - 1) & mask);
380  DCHECK_IMPLIES(entry < static_cast<int>(Group::kWidth),((void) 0)
381                 copy_entry == capacity + entry)((void) 0);
382  DCHECK_IMPLIES(entry >= static_cast<int>(Group::kWidth), copy_entry == entry)((void) 0);
383  ctrl[copy_entry] = h;
384}
385 
386// static
387inline int SwissNameDictionary::FindFirstEmpty(uint32_t hash) {
388  // See SwissNameDictionary::FindEntry for description of probing algorithm.
389 
390  auto seq = probe(hash, Capacity());
391  while (true) {
392    Group g{CtrlTable() + seq.offset()};
393    auto mask = g.MatchEmpty();
394    if (mask) {
395      // Note that picking the lowest bit set here means using the leftmost
396      // empty bucket in the group. Here, "left" means smaller entry/bucket
397      // index.
398      return seq.offset(mask.LowestBitSet());
399    }
400    seq.next();
401    DCHECK_LT(seq.index(), Capacity())((void) 0);
402  }
403}
404 
405void SwissNameDictionary::SetMetaTableField(int field_index, int value) {
406  // See the STATIC_ASSERTs on |kMax1ByteMetaTableCapacity| and
407  // |kMax2ByteMetaTableCapacity| in the .cc file for an explanation of these
408  // constants.
409  int capacity = Capacity();
410  ByteArray meta_table = this->meta_table();
411  if (capacity <= kMax1ByteMetaTableCapacity) {
412    SetMetaTableField<uint8_t>(meta_table, field_index, value);
413  } else if (capacity <= kMax2ByteMetaTableCapacity) {
414    SetMetaTableField<uint16_t>(meta_table, field_index, value);
415  } else {
416    SetMetaTableField<uint32_t>(meta_table, field_index, value);
417  }
418}
419 
420int SwissNameDictionary::GetMetaTableField(int field_index) {
421  // See the STATIC_ASSERTs on |kMax1ByteMetaTableCapacity| and
422  // |kMax2ByteMetaTableCapacity| in the .cc file for an explanation of these
423  // constants.
424  int capacity = Capacity();
425  ByteArray meta_table = this->meta_table();
426  if (capacity <= kMax1ByteMetaTableCapacity) {
427    return GetMetaTableField<uint8_t>(meta_table, field_index);
428  } else if (capacity <= kMax2ByteMetaTableCapacity) {
429    return GetMetaTableField<uint16_t>(meta_table, field_index);
430  } else {
431    return GetMetaTableField<uint32_t>(meta_table, field_index);
432  }
433}
434 
435// static
436template <typename T>
437void SwissNameDictionary::SetMetaTableField(ByteArray meta_table,
438                                            int field_index, int value) {
439  STATIC_ASSERT((std::is_same<T, uint8_t>::value) ||static_assert((std::is_same<T, uint8_t>::value) || (std
::is_same<T, uint16_t>::value) || (std::is_same<T, uint32_t
>::value), "(std::is_same<T, uint8_t>::value) || (std::is_same<T, uint16_t>::value) || (std::is_same<T, uint32_t>::value)"
)
440                (std::is_same<T, uint16_t>::value) ||static_assert((std::is_same<T, uint8_t>::value) || (std
::is_same<T, uint16_t>::value) || (std::is_same<T, uint32_t
>::value), "(std::is_same<T, uint8_t>::value) || (std::is_same<T, uint16_t>::value) || (std::is_same<T, uint32_t>::value)"
)
441                (std::is_same<T, uint32_t>::value))static_assert((std::is_same<T, uint8_t>::value) || (std
::is_same<T, uint16_t>::value) || (std::is_same<T, uint32_t
>::value), "(std::is_same<T, uint8_t>::value) || (std::is_same<T, uint16_t>::value) || (std::is_same<T, uint32_t>::value)"
);
442  DCHECK_LE(value, std::numeric_limits<T>::max())((void) 0);
443  DCHECK_LT(meta_table.GetDataStartAddress() + field_index * sizeof(T),((void) 0)
444            meta_table.GetDataEndAddress())((void) 0);
445  T* raw_data = reinterpret_cast<T*>(meta_table.GetDataStartAddress());
446  raw_data[field_index] = value;
447}
448 
449// static
450template <typename T>
451int SwissNameDictionary::GetMetaTableField(ByteArray meta_table,
452                                           int field_index) {
453  STATIC_ASSERT((std::is_same<T, uint8_t>::value) ||static_assert((std::is_same<T, uint8_t>::value) || (std
::is_same<T, uint16_t>::value) || (std::is_same<T, uint32_t
>::value), "(std::is_same<T, uint8_t>::value) || (std::is_same<T, uint16_t>::value) || (std::is_same<T, uint32_t>::value)"
)
454                (std::is_same<T, uint16_t>::value) ||static_assert((std::is_same<T, uint8_t>::value) || (std
::is_same<T, uint16_t>::value) || (std::is_same<T, uint32_t
>::value), "(std::is_same<T, uint8_t>::value) || (std::is_same<T, uint16_t>::value) || (std::is_same<T, uint32_t>::value)"
)
455                (std::is_same<T, uint32_t>::value))static_assert((std::is_same<T, uint8_t>::value) || (std
::is_same<T, uint16_t>::value) || (std::is_same<T, uint32_t
>::value), "(std::is_same<T, uint8_t>::value) || (std::is_same<T, uint16_t>::value) || (std::is_same<T, uint32_t>::value)"
);
456  DCHECK_LT(meta_table.GetDataStartAddress() + field_index * sizeof(T),((void) 0)
457            meta_table.GetDataEndAddress())((void) 0);
458  T* raw_data = reinterpret_cast<T*>(meta_table.GetDataStartAddress());
459  return raw_data[field_index];
460}
461 
462constexpr int SwissNameDictionary::MetaTableSizePerEntryFor(int capacity) {
463  DCHECK(IsValidCapacity(capacity))((void) 0);
464 
465  // See the STATIC_ASSERTs on |kMax1ByteMetaTableCapacity| and
466  // |kMax2ByteMetaTableCapacity| in the .cc file for an explanation of these
467  // constants.
468  if (capacity <= kMax1ByteMetaTableCapacity) {
469    return sizeof(uint8_t);
470  } else if (capacity <= kMax2ByteMetaTableCapacity) {
471    return sizeof(uint16_t);
472  } else {
473    return sizeof(uint32_t);
474  }
475}
476 
477constexpr int SwissNameDictionary::MetaTableSizeFor(int capacity) {
478  DCHECK(IsValidCapacity(capacity))((void) 0);
479 
480  int per_entry_size = MetaTableSizePerEntryFor(capacity);
481 
482  // The enumeration table only needs to have as many slots as there can be
483  // present + deleted entries in the hash table (= maximum load factor *
484  // capactiy). Two more slots to store the number of present and deleted
485  // entries.
486  return per_entry_size * (MaxUsableCapacity(capacity) + 2);
487}
488 
489bool SwissNameDictionary::IsKey(ReadOnlyRoots roots, Object key_candidate) {
490  return key_candidate != roots.the_hole_value();
491}
492 
493bool SwissNameDictionary::ToKey(ReadOnlyRoots roots, int entry,
494                                Object* out_key) {
495  Object k = KeyAt(entry);
496  if (!IsKey(roots, k)) return false;
497  *out_key = k;
498  return true;
499}
500 
501bool SwissNameDictionary::ToKey(ReadOnlyRoots roots, InternalIndex entry,
502                                Object* out_key) {
503  return ToKey(roots, entry.as_int(), out_key);
504}
505 
506// static
507template <typename IsolateT>
508Handle<SwissNameDictionary> SwissNameDictionary::Add(
509    IsolateT* isolate, Handle<SwissNameDictionary> original_table,
510    Handle<Name> key, Handle<Object> value, PropertyDetails details,
511    InternalIndex* entry_out) {
512  DCHECK(original_table->FindEntry(isolate, *key).is_not_found())((void) 0);
513 
514  Handle<SwissNameDictionary> table = EnsureGrowable(isolate, original_table);
515 
516  int nof = table->NumberOfElements();
517  int nod = table->NumberOfDeletedElements();
518  int new_enum_index = nof + nod;
519 
520  int new_entry = table->AddInternal(*key, *value, details);
521 
522  table->SetNumberOfElements(nof + 1);
523  table->SetEntryForEnumerationIndex(new_enum_index, new_entry);
524 
525  if (entry_out) {
526    *entry_out = InternalIndex(new_entry);
527  }
528 
529  return table;
530}
531 
532int SwissNameDictionary::AddInternal(Name key, Object value,
533                                     PropertyDetails details) {
534  DisallowHeapAllocation no_gc;
535 
536  DCHECK(key.IsUniqueName())((void) 0);
537  DCHECK_LE(UsedCapacity(), MaxUsableCapacity(Capacity()))((void) 0);
538 
539  uint32_t hash = key.hash();
540 
541  // For now we don't re-use deleted buckets (due to enumeration table
542  // complications), which is why we only look for empty buckets here, not
543  // deleted ones.
544  int target = FindFirstEmpty(hash);
545 
546  SetCtrl(target, swiss_table::H2(hash));
547  SetKey(target, key);
548  ValueAtPut(target, value);
549  DetailsAtPut(target, details);
550 
551  // Note that we do not update the number of elements or the enumeration table
552  // in this function.
553 
554  return target;
555}
556 
557template <typename IsolateT>
558void SwissNameDictionary::Initialize(IsolateT* isolate, ByteArray meta_table,
559                                     int capacity) {
560  DCHECK(IsValidCapacity(capacity))((void) 0);
561  DisallowHeapAllocation no_gc;
562  ReadOnlyRoots roots(isolate);
563 
564  SetCapacity(capacity);
565  SetHash(PropertyArray::kNoHashSentinel);
566 
567  memset(CtrlTable(), Ctrl::kEmpty, CtrlTableSize(capacity));
568 
569  MemsetTagged(RawField(DataTableStartOffset()), roots.the_hole_value(),
570               capacity * kDataTableEntryCount);
571 
572  set_meta_table(meta_table);
573 
574  SetNumberOfElements(0);
575  SetNumberOfDeletedElements(0);
576 
577  // We leave the enumeration table PropertyDetails table and uninitialized.
578}
579 
580SwissNameDictionary::IndexIterator::IndexIterator(
581    Handle<SwissNameDictionary> dict, int start)
582    : enum_index_{start}, dict_{dict} {
583  if (!COMPRESS_POINTERS_IN_ISOLATE_CAGE_BOOLfalse && dict.is_null()) {
584    used_capacity_ = 0;
585  } else {
586    used_capacity_ = dict->UsedCapacity();
587  }
588}
589 
590SwissNameDictionary::IndexIterator&
591SwissNameDictionary::IndexIterator::operator++() {
592  DCHECK_LT(enum_index_, used_capacity_)((void) 0);
593  ++enum_index_;
594  return *this;
595}
596 
597bool SwissNameDictionary::IndexIterator::operator==(
598    const SwissNameDictionary::IndexIterator& b) const {
599  DCHECK_LE(enum_index_, used_capacity_)((void) 0);
600  DCHECK_LE(b.enum_index_, used_capacity_)((void) 0);
601  DCHECK(dict_.equals(b.dict_))((void) 0);
602 
603  return this->enum_index_ == b.enum_index_;
604}
605 
606bool SwissNameDictionary::IndexIterator::operator!=(
607    const IndexIterator& b) const {
608  return !(*this == b);
609}
610 
611InternalIndex SwissNameDictionary::IndexIterator::operator*() {
612  DCHECK_LE(enum_index_, used_capacity_)((void) 0);
613 
614  if (enum_index_ == used_capacity_) return InternalIndex::NotFound();
615 
616  return InternalIndex(dict_->EntryForEnumerationIndex(enum_index_));
617}
618 
619SwissNameDictionary::IndexIterable::IndexIterable(
620    Handle<SwissNameDictionary> dict)
621    : dict_{dict} {}
622 
623SwissNameDictionary::IndexIterator SwissNameDictionary::IndexIterable::begin() {
624  return IndexIterator(dict_, 0);
625}
626 
627SwissNameDictionary::IndexIterator SwissNameDictionary::IndexIterable::end() {
628  if (!COMPRESS_POINTERS_IN_ISOLATE_CAGE_BOOLfalse && dict_.is_null()) {
629    return IndexIterator(dict_, 0);
630  } else {
631    DCHECK(!dict_.is_null())((void) 0);
632    return IndexIterator(dict_, dict_->UsedCapacity());
633  }
634}
635 
636SwissNameDictionary::IndexIterable
637SwissNameDictionary::IterateEntriesOrdered() {
638  // If we are supposed to iterate the empty dictionary (which is non-writable)
639  // and pointer compression with a per-Isolate cage is disabled, we have no
640  // simple way to get the isolate, which we would need to create a handle.
641  // TODO(emrich): Consider always using roots.empty_swiss_dictionary_handle()
642  // in the condition once this function gets Isolate as a parameter in order to
643  // avoid empty dict checks.
644  if (!COMPRESS_POINTERS_IN_ISOLATE_CAGE_BOOLfalse && Capacity() == 0)
5
←
Assuming the condition is false→
6
←
Taking false branch→
645    return IndexIterable(Handle<SwissNameDictionary>::null());
646 
647  Isolate* isolate;
648  GetIsolateFromHeapObject(*this, &isolate);
7
←
Calling 'GetIsolateFromHeapObject'→
11
←
Returning from 'GetIsolateFromHeapObject'→
649  DCHECK_NE(isolate, nullptr)((void) 0);
650  return IndexIterable(handle(*this, isolate));
12
←
Passing null pointer value via 2nd parameter 'isolate'→
13
←
Calling 'handle<v8::internal::SwissNameDictionary>'→
651}
652 
653SwissNameDictionary::IndexIterable SwissNameDictionary::IterateEntries() {
654  return IterateEntriesOrdered();
4
←
Calling 'SwissNameDictionary::IterateEntriesOrdered'→
655}
656 
657void SwissNameDictionary::SetHash(int32_t hash) {
658  WriteField(PrefixOffset(), hash);
659}
660 
661int SwissNameDictionary::Hash() { return ReadField<int32_t>(PrefixOffset()); }
662 
663// static
664constexpr int SwissNameDictionary::MaxCapacity() {
665  int const_size =
666      DataTableStartOffset() + ByteArray::kHeaderSize +
667      // Size for present and deleted element count at max capacity:
668      2 * sizeof(uint32_t);
669  int per_entry_size =
670      // size of data table entries:
671      kDataTableEntryCount * kTaggedSize +
672      // ctrl table entry size:
673      kOneByteSize +
674      // PropertyDetails table entry size:
675      kOneByteSize +
676      // Enumeration table entry size at maximum capacity:
677      sizeof(uint32_t);
678 
679  int result = (FixedArray::kMaxSize - const_size) / per_entry_size;
680  DCHECK_GE(Smi::kMaxValue, result)((void) 0);
681 
682  return result;
683}
684 
685// static
686constexpr int SwissNameDictionary::PrefixOffset() {
687  return HeapObject::kHeaderSize;
688}
689 
690// static
691constexpr int SwissNameDictionary::CapacityOffset() {
692  return PrefixOffset() + sizeof(uint32_t);
693}
694 
695// static
696constexpr int SwissNameDictionary::MetaTablePointerOffset() {
697  return CapacityOffset() + sizeof(int32_t);
698}
699 
700// static
701constexpr int SwissNameDictionary::DataTableStartOffset() {
702  return MetaTablePointerOffset() + kTaggedSize;
703}
704 
705// static
706constexpr int SwissNameDictionary::DataTableEndOffset(int capacity) {
707  return CtrlTableStartOffset(capacity);
708}
709 
710// static
711constexpr int SwissNameDictionary::CtrlTableStartOffset(int capacity) {
712  return DataTableStartOffset() + DataTableSize(capacity);
713}
714 
715// static
716constexpr int SwissNameDictionary::PropertyDetailsTableStartOffset(
717    int capacity) {
718  return CtrlTableStartOffset(capacity) + CtrlTableSize(capacity);
719}
720 
721// static
722bool SwissNameDictionary::IsEmpty(ctrl_t c) { return c == Ctrl::kEmpty; }
723 
724// static
725bool SwissNameDictionary::IsFull(ctrl_t c) {
726  STATIC_ASSERT(Ctrl::kEmpty < 0)static_assert(Ctrl::kEmpty < 0, "Ctrl::kEmpty < 0");
727  STATIC_ASSERT(Ctrl::kDeleted < 0)static_assert(Ctrl::kDeleted < 0, "Ctrl::kDeleted < 0");
728  STATIC_ASSERT(Ctrl::kSentinel < 0)static_assert(Ctrl::kSentinel < 0, "Ctrl::kSentinel < 0"
);
729  return c >= 0;
730}
731 
732// static
733bool SwissNameDictionary::IsDeleted(ctrl_t c) { return c == Ctrl::kDeleted; }
734 
735// static
736bool SwissNameDictionary::IsEmptyOrDeleted(ctrl_t c) {
737  STATIC_ASSERT(Ctrl::kDeleted < Ctrl::kSentinel)static_assert(Ctrl::kDeleted < Ctrl::kSentinel, "Ctrl::kDeleted < Ctrl::kSentinel"
);
738  STATIC_ASSERT(Ctrl::kEmpty < Ctrl::kSentinel)static_assert(Ctrl::kEmpty < Ctrl::kSentinel, "Ctrl::kEmpty < Ctrl::kSentinel"
);
739  STATIC_ASSERT(Ctrl::kSentinel < 0)static_assert(Ctrl::kSentinel < 0, "Ctrl::kSentinel < 0"
);
740  return c < Ctrl::kSentinel;
741}
742 
743// static
744swiss_table::ProbeSequence<SwissNameDictionary::kGroupWidth>
745SwissNameDictionary::probe(uint32_t hash, int capacity) {
746  // If |capacity| is 0, we must produce 1 here, such that the - 1 below
747  // yields 0, which is the correct modulo mask for a table of capacity 0.
748  int non_zero_capacity = capacity | (capacity == 0);
749  return swiss_table::ProbeSequence<SwissNameDictionary::kGroupWidth>(
750      swiss_table::H1(hash), static_cast<uint32_t>(non_zero_capacity - 1));
751}
752 
753ACCESSORS_CHECKED2(SwissNameDictionary, meta_table, ByteArray,
754                   MetaTablePointerOffset(), true,
755                   value.length() >= kMetaTableEnumerationDataStartIndex)
756 
757}  // namespace internal
758}  // namespace v8
759 
760#endif  // V8_OBJECTS_SWISS_NAME_DICTIONARY_INL_H_

←

../deps/v8/src/execution/isolate-utils-inl.h

→

1// Copyright 2019 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4 
5#ifndef V8_EXECUTION_ISOLATE_UTILS_INL_H_
6#define V8_EXECUTION_ISOLATE_UTILS_INL_H_
7 
8#include "src/common/ptr-compr-inl.h"
9#include "src/execution/isolate-utils.h"
10#include "src/execution/isolate.h"
11#include "src/heap/heap-write-barrier-inl.h"
12 
13namespace v8 {
14namespace internal {
15 
16#ifdef V8_COMPRESS_POINTERS_IN_ISOLATE_CAGE
17 
18// Aliases for GetPtrComprCageBase when
19// V8_COMPRESS_POINTERS_IN_ISOLATE_CAGE. Each Isolate has its own cage, whose
20// base address is also the Isolate root.
21V8_INLINEinline __attribute__((always_inline)) constexpr Address GetIsolateRootAddress(Address on_heap_addr) {
22  return GetPtrComprCageBaseAddress(on_heap_addr);
23}
24 
25V8_INLINEinline __attribute__((always_inline)) Address GetIsolateRootAddress(PtrComprCageBase cage_base) {
26  return cage_base.address();
27}
28 
29#else
30 
31V8_INLINEinline __attribute__((always_inline)) Address GetIsolateRootAddress(Address on_heap_addr) { UNREACHABLE()V8_Fatal("unreachable code"); }
32 
33V8_INLINEinline __attribute__((always_inline)) Address GetIsolateRootAddress(PtrComprCageBase cage_base) {
34  UNREACHABLE()V8_Fatal("unreachable code");
35}
36 
37#endif  // V8_COMPRESS_POINTERS_IN_ISOLATE_CAGE
38 
39V8_INLINEinline __attribute__((always_inline)) Heap* GetHeapFromWritableObject(HeapObject object) {
40  // Avoid using the below GetIsolateFromWritableObject because we want to be
41  // able to get the heap, but not the isolate, for off-thread objects.
42 
43#if defined V8_ENABLE_THIRD_PARTY_HEAP
44  return Heap::GetIsolateFromWritableObject(object)->heap();
45#elif defined(V8_COMPRESS_POINTERS_IN_ISOLATE_CAGE) && \
46    !defined(V8_EXTERNAL_CODE_SPACE)
47  Isolate* isolate =
48      Isolate::FromRootAddress(GetIsolateRootAddress(object.ptr()));
49  DCHECK_NOT_NULL(isolate)((void) 0);
50  return isolate->heap();
51#else
52  heap_internals::MemoryChunk* chunk =
53      heap_internals::MemoryChunk::FromHeapObject(object);
54  return chunk->GetHeap();
55#endif  // V8_COMPRESS_POINTERS_IN_ISOLATE_CAGE, V8_ENABLE_THIRD_PARTY_HEAP
56}
57 
58V8_INLINEinline __attribute__((always_inline)) Isolate* GetIsolateFromWritableObject(HeapObject object) {
59#ifdef V8_ENABLE_THIRD_PARTY_HEAP
60  return Heap::GetIsolateFromWritableObject(object);
61#elif defined(V8_COMPRESS_POINTERS_IN_ISOLATE_CAGE) && \
62    !defined(V8_EXTERNAL_CODE_SPACE)
63  Isolate* isolate =
64      Isolate::FromRootAddress(GetIsolateRootAddress(object.ptr()));
65  DCHECK_NOT_NULL(isolate)((void) 0);
66  return isolate;
67#else
68  return Isolate::FromHeap(GetHeapFromWritableObject(object));
69#endif  // V8_COMPRESS_POINTERS_IN_ISOLATE_CAGE, V8_ENABLE_THIRD_PARTY_HEAP
70}
71 
72V8_INLINEinline __attribute__((always_inline)) bool GetIsolateFromHeapObject(HeapObject object, Isolate** isolate) {
73#ifdef V8_ENABLE_THIRD_PARTY_HEAP
74  *isolate = Heap::GetIsolateFromWritableObject(object);
75  return true;
76#elif defined V8_COMPRESS_POINTERS_IN_ISOLATE_CAGE
77  *isolate = GetIsolateFromWritableObject(object);
78  return true;
79#else
80  heap_internals::MemoryChunk* chunk =
81      heap_internals::MemoryChunk::FromHeapObject(object);
82  if (chunk->InReadOnlySpace()) {
8
←
Assuming the condition is true→
9
←
Taking true branch→
83    *isolate = nullptr;
10
←
Null pointer value stored to 'isolate'→
84    return false;
85  }
86  *isolate = Isolate::FromHeap(chunk->GetHeap());
87  return true;
88#endif  // V8_COMPRESS_POINTERS_IN_ISOLATE_CAGE, V8_ENABLE_THIRD_PARTY_HEAP
89}
90 
91// Use this function instead of Internals::GetIsolateForSandbox for internal
92// code, as this function is fully inlinable.
93V8_INLINEinline __attribute__((always_inline)) static Isolate* GetIsolateForSandbox(HeapObject object) {
94#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
95  return GetIsolateFromWritableObject(object);
96#else
97  // Not used in non-sandbox mode.
98  return nullptr;
99#endif
100}
101 
102// This is an external code space friendly version of GetPtrComprCageBase(..)
103// which also works for objects located in external code space.
104//
105// NOTE: it's supposed to be used only for the cases where performance doesn't
106// matter. For example, in debug only code or in debugging macros.
107// In production code the preferred way is to use precomputed cage base value
108// which is a result of PtrComprCageBase{isolate} or GetPtrComprCageBase()
109// applied to a heap object which is known to not be a part of external code
110// space.
111V8_INLINEinline __attribute__((always_inline)) PtrComprCageBase GetPtrComprCageBaseSlow(HeapObject object) {
112  if (V8_EXTERNAL_CODE_SPACE_BOOLfalse) {
113    Isolate* isolate;
114    if (GetIsolateFromHeapObject(object, &isolate)) {
115      return PtrComprCageBase{isolate};
116    }
117    // If the Isolate can't be obtained then the heap object is a read-only
118    // one and therefore not a Code object, so fallback to auto-computing cage
119    // base value.
120  }
121  return GetPtrComprCageBase(object);
122}
123 
124}  // namespace internal
125}  // namespace v8
126 
127#endif  // V8_EXECUTION_ISOLATE_UTILS_INL_H_

←

../deps/v8/src/handles/handles-inl.h

1// Copyright 2006-2008 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4 
5#ifndef V8_HANDLES_HANDLES_INL_H_
6#define V8_HANDLES_HANDLES_INL_H_
7 
8#include "src/base/sanitizer/msan.h"
9#include "src/execution/isolate.h"
10#include "src/execution/local-isolate.h"
11#include "src/handles/handles.h"
12#include "src/handles/local-handles-inl.h"
13#include "src/objects/objects.h"
14 
15namespace v8 {
16namespace internal {
17 
18class LocalHeap;
19 
20HandleBase::HandleBase(Address object, Isolate* isolate)
21    : location_(HandleScope::GetHandle(isolate, object)) {}
18
←
Passing null pointer value via 1st parameter 'isolate'→
19
←
Calling 'HandleScope::GetHandle'→
22 
23HandleBase::HandleBase(Address object, LocalIsolate* isolate)
24    : location_(LocalHandleScope::GetHandle(isolate->heap(), object)) {}
25 
26HandleBase::HandleBase(Address object, LocalHeap* local_heap)
27    : location_(LocalHandleScope::GetHandle(local_heap, object)) {}
28 
29bool HandleBase::is_identical_to(const HandleBase that) const {
30  SLOW_DCHECK((this->location_ == nullptr || this->IsDereferenceAllowed()) &&((void)0)
31              (that.location_ == nullptr || that.IsDereferenceAllowed()))((void)0);
32  if (this->location_ == that.location_) return true;
33  if (this->location_ == nullptr || that.location_ == nullptr) return false;
34  return Object(*this->location_) == Object(*that.location_);
35}
36 
37// Allocate a new handle for the object, do not canonicalize.
38template <typename T>
39Handle<T> Handle<T>::New(T object, Isolate* isolate) {
40  return Handle(HandleScope::CreateHandle(isolate, object.ptr()));
41}
42 
43template <typename T>
44template <typename S>
45const Handle<T> Handle<T>::cast(Handle<S> that) {
46  T::cast(*FullObjectSlot(that.location()));
47  return Handle<T>(that.location_);
48}
49 
50template <typename T>
51Handle<T>::Handle(T object, Isolate* isolate)
52    : HandleBase(object.ptr(), isolate) {}
16
←
Passing null pointer value via 2nd parameter 'isolate'→
17
←
Calling constructor for 'HandleBase'→
53 
54template <typename T>
55Handle<T>::Handle(T object, LocalIsolate* isolate)
56    : HandleBase(object.ptr(), isolate) {}
57 
58template <typename T>
59Handle<T>::Handle(T object, LocalHeap* local_heap)
60    : HandleBase(object.ptr(), local_heap) {}
61 
62template <typename T>
63V8_INLINEinline __attribute__((always_inline)) Handle<T> handle(T object, Isolate* isolate) {
64  return Handle<T>(object, isolate);
14
←
Passing null pointer value via 2nd parameter 'isolate'→
15
←
Calling constructor for 'Handle<v8::internal::SwissNameDictionary>'→
65}
66 
67template <typename T>
68V8_INLINEinline __attribute__((always_inline)) Handle<T> handle(T object, LocalIsolate* isolate) {
69  return Handle<T>(object, isolate);
70}
71 
72template <typename T>
73V8_INLINEinline __attribute__((always_inline)) Handle<T> handle(T object, LocalHeap* local_heap) {
74  return Handle<T>(object, local_heap);
75}
76 
77template <typename T>
78inline std::ostream& operator<<(std::ostream& os, Handle<T> handle) {
79  return os << Brief(*handle);
80}
81 
82HandleScope::HandleScope(Isolate* isolate) {
83  HandleScopeData* data = isolate->handle_scope_data();
84  isolate_ = isolate;
85  prev_next_ = data->next;
86  prev_limit_ = data->limit;
87  data->level++;
88}
89 
90HandleScope::HandleScope(HandleScope&& other) V8_NOEXCEPTnoexcept
91    : isolate_(other.isolate_),
92      prev_next_(other.prev_next_),
93      prev_limit_(other.prev_limit_) {
94  other.isolate_ = nullptr;
95}
96 
97HandleScope::~HandleScope() {
98  if (V8_UNLIKELY(isolate_ == nullptr)(__builtin_expect(!!(isolate_ == nullptr), 0))) return;
99  CloseScope(isolate_, prev_next_, prev_limit_);
100}
101 
102HandleScope& HandleScope::operator=(HandleScope&& other) V8_NOEXCEPTnoexcept {
103  if (isolate_ == nullptr) {
104    isolate_ = other.isolate_;
105  } else {
106    DCHECK_EQ(isolate_, other.isolate_)((void) 0);
107    CloseScope(isolate_, prev_next_, prev_limit_);
108  }
109  prev_next_ = other.prev_next_;
110  prev_limit_ = other.prev_limit_;
111  other.isolate_ = nullptr;
112  return *this;
113}
114 
115void HandleScope::CloseScope(Isolate* isolate, Address* prev_next,
116                             Address* prev_limit) {
117#ifdef DEBUG
118  int before = FLAG_check_handle_count ? NumberOfHandles(isolate) : 0;
119#endif
120  DCHECK_NOT_NULL(isolate)((void) 0);
121  HandleScopeData* current = isolate->handle_scope_data();
122 
123  std::swap(current->next, prev_next);
124  current->level--;
125  Address* limit = prev_next;
126  if (V8_UNLIKELY(current->limit != prev_limit)(__builtin_expect(!!(current->limit != prev_limit), 0))) {
127    current->limit = prev_limit;
128    limit = prev_limit;
129    DeleteExtensions(isolate);
130  }
131#ifdef ENABLE_HANDLE_ZAPPING
132  ZapRange(current->next, limit);
133#endif
134  MSAN_ALLOCATED_UNINITIALIZED_MEMORY(static_assert((std::is_pointer<decltype(current->next)>
::value || std::is_same<v8::base::Address, decltype(current
->next)>::value), "static type violation"); static_assert
(std::is_convertible<decltype(static_cast<size_t>(reinterpret_cast
<Address>(limit) - reinterpret_cast<Address>(current
->next))), size_t>::value, "static type violation"); do
 { ::v8::base::Use unused_tmp_array_for_use_macro[]{current->
next, static_cast<size_t>(reinterpret_cast<Address>
(limit) - reinterpret_cast<Address>(current->next))}
; (void)unused_tmp_array_for_use_macro; } while (false)
135      current->next,static_assert((std::is_pointer<decltype(current->next)>
::value || std::is_same<v8::base::Address, decltype(current
->next)>::value), "static type violation"); static_assert
(std::is_convertible<decltype(static_cast<size_t>(reinterpret_cast
<Address>(limit) - reinterpret_cast<Address>(current
->next))), size_t>::value, "static type violation"); do
 { ::v8::base::Use unused_tmp_array_for_use_macro[]{current->
next, static_cast<size_t>(reinterpret_cast<Address>
(limit) - reinterpret_cast<Address>(current->next))}
; (void)unused_tmp_array_for_use_macro; } while (false)
136      static_cast<size_t>(reinterpret_cast<Address>(limit) -static_assert((std::is_pointer<decltype(current->next)>
::value || std::is_same<v8::base::Address, decltype(current
->next)>::value), "static type violation"); static_assert
(std::is_convertible<decltype(static_cast<size_t>(reinterpret_cast
<Address>(limit) - reinterpret_cast<Address>(current
->next))), size_t>::value, "static type violation"); do
 { ::v8::base::Use unused_tmp_array_for_use_macro[]{current->
next, static_cast<size_t>(reinterpret_cast<Address>
(limit) - reinterpret_cast<Address>(current->next))}
; (void)unused_tmp_array_for_use_macro; } while (false)
137                          reinterpret_cast<Address>(current->next)))static_assert((std::is_pointer<decltype(current->next)>
::value || std::is_same<v8::base::Address, decltype(current
->next)>::value), "static type violation"); static_assert
(std::is_convertible<decltype(static_cast<size_t>(reinterpret_cast
<Address>(limit) - reinterpret_cast<Address>(current
->next))), size_t>::value, "static type violation"); do
 { ::v8::base::Use unused_tmp_array_for_use_macro[]{current->
next, static_cast<size_t>(reinterpret_cast<Address>
(limit) - reinterpret_cast<Address>(current->next))}
; (void)unused_tmp_array_for_use_macro; } while (false);
138#ifdef DEBUG
139  int after = FLAG_check_handle_count ? NumberOfHandles(isolate) : 0;
140  DCHECK_LT(after - before, kCheckHandleThreshold)((void) 0);
141  DCHECK_LT(before, kCheckHandleThreshold)((void) 0);
142#endif
143}
144 
145template <typename T>
146Handle<T> HandleScope::CloseAndEscape(Handle<T> handle_value) {
147  HandleScopeData* current = isolate_->handle_scope_data();
148  T value = *handle_value;
149  // Throw away all handles in the current scope.
150  CloseScope(isolate_, prev_next_, prev_limit_);
151  // Allocate one handle in the parent scope.
152  DCHECK(current->level > current->sealed_level)((void) 0);
153  Handle<T> result(value, isolate_);
154  // Reinitialize the current scope (so that it's ready
155  // to be used or closed again).
156  prev_next_ = current->next;
157  prev_limit_ = current->limit;
158  current->level++;
159  return result;
160}
161 
162Address* HandleScope::CreateHandle(Isolate* isolate, Address value) {
163  DCHECK(AllowHandleAllocation::IsAllowed())((void) 0);
164  HandleScopeData* data = isolate->handle_scope_data();
165  Address* result = data->next;
166  if (result == data->limit) {
167    result = Extend(isolate);
168  }
169  // Update the current next field, set the value in the created handle,
170  // and return the result.
171  DCHECK_LT(reinterpret_cast<Address>(result),((void) 0)
172            reinterpret_cast<Address>(data->limit))((void) 0);
173  data->next = reinterpret_cast<Address*>(reinterpret_cast<Address>(result) +
174                                          sizeof(Address));
175  *result = value;
176  return result;
177}
178 
179Address* HandleScope::GetHandle(Isolate* isolate, Address value) {
180  DCHECK(AllowHandleAllocation::IsAllowed())((void) 0);
181  DCHECK(isolate->main_thread_local_heap()->IsRunning())((void) 0);
182  DCHECK_WITH_MSG(isolate->thread_id() == ThreadId::Current(),void(0);
183                  "main-thread handle can only be created on the main thread.")void(0);;
184  HandleScopeData* data = isolate->handle_scope_data();
20
←
Called C++ object pointer is null
185  CanonicalHandleScope* canonical = data->canonical_scope;
186  return canonical ? canonical->Lookup(value) : CreateHandle(isolate, value);
187}
188 
189#ifdef DEBUG
190inline SealHandleScope::SealHandleScope(Isolate* isolate) : isolate_(isolate) {
191  // Make sure the current thread is allowed to create handles to begin with.
192  DCHECK(AllowHandleAllocation::IsAllowed())((void) 0);
193  HandleScopeData* current = isolate_->handle_scope_data();
194  // Shrink the current handle scope to make it impossible to do
195  // handle allocations without an explicit handle scope.
196  prev_limit_ = current->limit;
197  current->limit = current->next;
198  prev_sealed_level_ = current->sealed_level;
199  current->sealed_level = current->level;
200}
201 
202inline SealHandleScope::~SealHandleScope() {
203  // Restore state in current handle scope to re-enable handle
204  // allocations.
205  HandleScopeData* current = isolate_->handle_scope_data();
206  DCHECK_EQ(current->next, current->limit)((void) 0);
207  current->limit = prev_limit_;
208  DCHECK_EQ(current->level, current->sealed_level)((void) 0);
209  current->sealed_level = prev_sealed_level_;
210}
211 
212#endif
213 
214}  // namespace internal
215}  // namespace v8
216 
217#endif  // V8_HANDLES_HANDLES_INL_H_