// Copyright 2012 the V8 project authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

#include <iomanip>

#include <memory>

#include "src/common/globals.h"

#include "src/diagnostics/disasm.h"

#include "src/diagnostics/disassembler.h"

#include "src/execution/isolate-utils-inl.h"

#include "src/heap/heap-inl.h" // For InOldSpace.

#include "src/heap/heap-write-barrier-inl.h" // For GetIsolateFromWritableObj.

#include "src/ic/handler-configuration-inl.h"

#include "src/init/bootstrapper.h"

#include "src/interpreter/bytecodes.h"

#include "src/objects/all-objects-inl.h"

#include "src/objects/code-kind.h"

#include "src/regexp/regexp.h"

#include "src/snapshot/embedded/embedded-data.h"

#include "src/utils/ostreams.h"

#if V8_ENABLE_WEBASSEMBLY

#include "src/debug/debug-wasm-objects-inl.h"

#include "src/wasm/wasm-code-manager.h"

#include "src/wasm/wasm-engine.h"

#include "src/wasm/wasm-objects-inl.h"

#endif // V8_ENABLE_WEBASSEMBLY

namespace v8 {

namespace internal {

#ifdef OBJECT_PRINT

void 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;

}

void 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);

}

}

namespace {

void PrintHeapObjectHeaderWithoutMap(HeapObject object, std::ostream& os,

const char* id) {

os << reinterpret_cast<void*>(object.ptr()) << ": [";

if (id != nullptr) {

os << id;

} else {

os << object.map().instance_type();

}

os << "]";

if (ReadOnlyHeap::Contains(object)) {

os << " in ReadOnlySpace";

} else if (GetHeapFromWritableObject(object)->InOldSpace(object)) {

os << " in OldSpace";

}

}

template <typename T>

void PrintDictionaryContents(std::ostream& os, T dict) {

DisallowGarbageCollection no_gc;

ReadOnlyRoots roots = dict.GetReadOnlyRoots();

if (dict.Capacity() == 0) {

return;

}

#ifdef V8_ENABLE_SWISS_NAME_DICTIONARY

Isolate* isolate = GetIsolateFromWritableObject(dict);

// IterateEntries for SwissNameDictionary needs to create a handle.

HandleScope scope(isolate);

#endif

for (InternalIndex i : dict.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);

}

}

} // namespace

void HeapObject::PrintHeader(std::ostream& os, const char* id) {

PrintHeapObjectHeaderWithoutMap(*this, os, id);

if (!IsMap()) os << "\n - map: " << Brief(map());

}

void HeapObject::HeapObjectPrint(std::ostream& os) {

InstanceType instance_type = map().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:

case SCRIPT_CONTEXT_TABLE_TYPE:

Context::cast(*this).ContextPrint(os);

break;

case NATIVE_CONTEXT_TYPE:

NativeContext::cast(*this).NativeContextPrint(os);

break;

case HASH_TABLE_TYPE:

ObjectHashTable::cast(*this).ObjectHashTablePrint(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;

#if V8_ENABLE_WEBASSEMBLY

case WASM_INSTANCE_OBJECT_TYPE:

WasmInstanceObject::cast(*this).WasmInstanceObjectPrint(os);

break;

case WASM_VALUE_OBJECT_TYPE:

WasmValueObject::cast(*this).WasmValueObjectPrint(os);

break;

#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;

#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)

TORQUE_INSTANCE_CHECKERS_MULTIPLE_FULLY_DEFINED(MAKE_TORQUE_CASE)

#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 JS_PROMISE_CONSTRUCTOR_TYPE:

case JS_REG_EXP_CONSTRUCTOR_TYPE:

case JS_ARRAY_CONSTRUCTOR_TYPE:

#define TYPED_ARRAY_CONSTRUCTORS_SWITCH(Type, type, TYPE, Ctype) \

case TYPE##_TYPED_ARRAY_CONSTRUCTOR_TYPE:

TYPED_ARRAYS(TYPED_ARRAY_CONSTRUCTORS_SWITCH)

#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:

// TODO(all): Handle these types too.

os << "UNKNOWN TYPE " << map().instance_type();

UNREACHABLE();

}

}

void ByteArray::ByteArrayPrint(std::ostream& os) {

PrintHeader(os, "ByteArray");

os << "\n - length: " << length()

<< "\n - data-start: " << static_cast<void*>(GetDataStartAddress())

<< "\n";

}

void BytecodeArray::BytecodeArrayPrint(std::ostream& os) {

PrintHeader(os, "BytecodeArray");

os << "\n";

Disassemble(os);

}

void FreeSpace::FreeSpacePrint(std::ostream& os) {

os << "free space, size " << Size() << "\n";

}

bool 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 kField: {

FieldIndex field_index = FieldIndex::ForDescriptor(map(), i);

os << Brief(RawFastPropertyAt(field_index));

break;

}

case kDescriptor:

os << Brief(descs.GetStrongValue(i));

break;

}

os << " ";

details.PrintAsFastTo(os, PropertyDetails::kForProperties);

if (details.location() == 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_BOOL) {

PrintDictionaryContents(os, property_dictionary_swiss());

} else {

PrintDictionaryContents(os, property_dictionary());

}

return true;

}

namespace {

template <class T>

bool IsTheHoleAt(T array, int index) {

return false;

}

template <>

bool IsTheHoleAt(FixedDoubleArray array, int index) {

return array.is_the_hole(index);

}

template <class T>

double GetScalarElement(T array, int index) {

if (IsTheHoleAt(array, index)) {

return std::numeric_limits<double>::quiet_NaN();

}

return array.get_scalar(index);

}

template <class T>

void 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;

}

}

template <typename ElementType>

void 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;

}

}

template <typename T>

void 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;

}

}

void 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);

}

void 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);

PrintDictionaryElements(os, arguments_store);

}

}

void 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;

}

}

} // namespace

void 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;

}

#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)

RAB_GSAB_TYPED_ARRAYS(PRINT_ELEMENTS)

#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();

case NO_ELEMENTS:

break;

}

os << "\n }\n";

}

static 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();

}

}

static 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 = GetIsolateForHeapSandbox(obj);

os << " - embedder fields = {";

for (int i = 0; i < embedder_fields; i++) {

os << "\n ";

PrintEmbedderData(isolate, os, EmbedderDataSlot(obj, i));

}

os << "\n }\n";

}

}

void JSObject::JSObjectPrint(std::ostream& os) {

JSObjectPrintHeader(os, *this, nullptr);

JSObjectPrintBody(os, *this);

}

void 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());

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);

}

void JSArray::JSArrayPrint(std::ostream& os) {

JSObjectPrintHeader(os, *this, "JSArray");

os << "\n - length: " << Brief(this->length());

JSObjectPrintBody(os, *this);

}

void 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);

}

void JSRegExp::JSRegExpPrint(std::ostream& os) {

JSObjectPrintHeader(os, *this, "JSRegExp");

os << "\n - data: " << Brief(data());

os << "\n - source: " << Brief(source());

JSObjectPrintBody(os, *this);

}

void 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);

}

void 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";

}

void 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);

}

namespace {

void PrintFixedArrayWithHeader(std::ostream& os, FixedArray array,

const char* type) {

array.PrintHeader(os, type);

os << "\n - length: " << array.length();

PrintFixedArrayElements(os, array);

os << "\n";

}

template <typename T>

void 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;

}

}

} // namespace

void ObjectBoilerplateDescription::ObjectBoilerplateDescriptionPrint(

std::ostream& os) {

PrintFixedArrayWithHeader(os, *this, "ObjectBoilerplateDescription");

}

void EmbedderDataArray::EmbedderDataArrayPrint(std::ostream& os) {

Isolate* isolate = GetIsolateForHeapSandbox(*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";

}

void FixedArray::FixedArrayPrint(std::ostream& os) {

PrintFixedArrayWithHeader(os, *this, "FixedArray");

}

namespace {

const char* SideEffectType2String(SideEffectType type) {

switch (type) {

case SideEffectType::kHasSideEffect:

return "kHasSideEffect";

case SideEffectType::kHasNoSideEffect:

return "kHasNoSideEffect";

case SideEffectType::kHasSideEffectToReceiver:

return "kHasSideEffectToReceiver";

}

}

} // namespace

void 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';

}

namespace {

void PrintContextWithHeader(std::ostream& os, Context context,

const char* type) {

context.PrintHeader(os, type);

os << "\n - length: " << context.length();

os << "\n - scope_info: " << Brief(context.scope_info());

os << "\n - previous: " << Brief(context.unchecked_previous());

os << "\n - native_context: " << Brief(context.native_context());

PrintFixedArrayElements(os, context);

os << "\n";

}

} // namespace

void Context::ContextPrint(std::ostream& os) {

PrintContextWithHeader(os, *this, "Context");

}

void NativeContext::NativeContextPrint(std::ostream& os) {

PrintContextWithHeader(os, *this, "NativeContext");

os << " - microtask_queue: " << microtask_queue() << "\n";

}

namespace {

using DataPrinter = std::function<void(InternalIndex)>;

// Prints the data associated with each key (but no headers or other meta

// data) in a hash table. Works on different hash table types, like the

// subtypes of HashTable and OrderedHashTable. |print_data_at| is given an

// index into the table (where a valid key resides) and prints the data at

// that index, like just the value (in case of a hash map), or value and

// property details (in case of a property dictionary). No leading space

// required or trailing newline required. It can be null/non-callable

// std::function to indicate that there is no associcated data to be printed

// (for example in case of a hash set).

template <typename T>

void 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);

}

}

}

// Used for ordered and unordered dictionaries.

template <typename T>

void 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";

}

// Used for ordered and unordered hash maps.

template <typename T>

void 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";

}

// Used for ordered and unordered hash sets.

template <typename T>

void 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";

}

// Used for subtypes of OrderedHashTable.

template <typename T>

void 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());

os << "\n " << std::setw(12) << bucket << ": " << Brief(entry);

}

os << "\n }";

}

// Used for subtypes of HashTable.

template <typename T>

void 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();

}

} // namespace

void ObjectHashTable::ObjectHashTablePrint(std::ostream& os) {

PrintHashTableHeader(os, *this, "ObjectHashTable");

PrintHashMapContentsFull(os, *this);

}

void NumberDictionary::NumberDictionaryPrint(std::ostream& os) {

PrintHashTableHeader(os, *this, "NumberDictionary");

PrintDictionaryContentsFull(os, *this);

}

void EphemeronHashTable::EphemeronHashTablePrint(std::ostream& os) {

PrintHashTableHeader(os, *this, "EphemeronHashTable");

PrintHashMapContentsFull(os, *this);

}

void NameDictionary::NameDictionaryPrint(std::ostream& os) {

PrintHashTableHeader(os, *this, "NameDictionary");

PrintDictionaryContentsFull(os, *this);

}

void GlobalDictionary::GlobalDictionaryPrint(std::ostream& os) {

PrintHashTableHeader(os, *this, "GlobalDictionary");

PrintDictionaryContentsFull(os, *this);

}

void SmallOrderedHashSet::SmallOrderedHashSetPrint(std::ostream& os) {

PrintHeader(os, "SmallOrderedHashSet");

// TODO(turbofan): Print all fields.

}

void SmallOrderedHashMap::SmallOrderedHashMapPrint(std::ostream& os) {

PrintHeader(os, "SmallOrderedHashMap");

// TODO(turbofan): Print all fields.

}

void SmallOrderedNameDictionary::SmallOrderedNameDictionaryPrint(

std::ostream& os) {

PrintHeader(os, "SmallOrderedNameDictionary");

// TODO(turbofan): Print all fields.

}

void OrderedHashSet::OrderedHashSetPrint(std::ostream& os) {

PrintOrderedHashTableHeaderAndBuckets(os, *this, "OrderedHashSet");

PrintHashSetContentsFull(os, *this);

}

void OrderedHashMap::OrderedHashMapPrint(std::ostream& os) {

PrintOrderedHashTableHeaderAndBuckets(os, *this, "OrderedHashMap");

PrintHashMapContentsFull(os, *this);

}

void OrderedNameDictionary::OrderedNameDictionaryPrint(std::ostream& os) {

PrintOrderedHashTableHeaderAndBuckets(os, *this, "OrderedNameDictionary");

PrintDictionaryContentsFull(os, *this);

}

void print_hex_byte(std::ostream& os, int value) {

os << "0x" << std::setfill('0') << std::setw(2) << std::right << std::hex

<< (value & 0xff) << std::setfill(' ');

}

void 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();