// The stream we are printing to.

std::ostream& os;

// The default generator state if no other generator is provided.

std::optional<DefaultTypeNameGenerator> defaultGenerator;

// The function we call to get HeapType names.

HeapTypeNameGenerator generator;

TypePrinter(std::ostream& os, HeapTypeNameGenerator generator)

: os(os), defaultGenerator(), generator(generator) {}

TypePrinter(std::ostream& os)

: TypePrinter(

os, [&](HeapType type) { return defaultGenerator->getNames(type); }) {

defaultGenerator = DefaultTypeNameGenerator{};

}

void printHeapTypeName(HeapType type);

std::ostream& print(Type type);

std::ostream& print(HeapType type);

std::ostream& print(const Tuple& tuple);

std::ostream& print(const Field& field);

std::ostream& print(const Signature& sig);

std::ostream& print(const Continuation& cont);

std::ostream& print(const Struct& struct_,

const std::unordered_map<Index, Name>& fieldNames);

std::ostream& print(const Array& array);

// `group` may or may not be canonical, but any other recursion group it

// reaches must be canonical.

RecGroup group;

RecGroupHasher(RecGroup group) : group(group) {}

// Perform the hash.

size_t operator()() const;

// `topLevelHash` is applied to the top-level group members and observes their

// structure, while `hash(HeapType)` is applied to the children of group

// members and does not observe their structure.

size_t topLevelHash(HeapType type) const;

size_t hash(Type type) const;

size_t hash(HeapType type) const;

size_t hash(const HeapTypeInfo& info) const;

size_t hash(const Tuple& tuple) const;

size_t hash(const Field& field) const;

size_t hash(const Signature& sig) const;

size_t hash(const Continuation& sig) const;

size_t hash(const Struct& struct_) const;

size_t hash(const Array& array) const;

// `newGroup` may or may not be canonical, but `otherGroup` and any other

// recursion group reachable by either of them must be canonical.

RecGroup newGroup, otherGroup;

RecGroupEquator(RecGroup newGroup, RecGroup otherGroup)

: newGroup(newGroup), otherGroup(otherGroup) {}

// Perform the comparison.

bool operator()() const;

// `topLevelEq` is applied to the top-level group members and observes their

// structure, while `eq(HeapType)` is applied to the children of group members

// and does not observe their structure.

bool topLevelEq(HeapType a, HeapType b) const;

bool eq(Type a, Type b) const;

bool eq(HeapType a, HeapType b) const;

bool eq(const HeapTypeInfo& a, const HeapTypeInfo& b) const;

bool eq(const Tuple& a, const Tuple& b) const;

bool eq(const Field& a, const Field& b) const;

bool eq(const Signature& a, const Signature& b) const;

bool eq(const Continuation& a, const Continuation& b) const;

bool eq(const Struct& a, const Struct& b) const;

bool eq(const Array& a, const Array& b) const;

RecGroup group;

bool operator==(const RecGroupStructure& other) const {

return RecGroupEquator{group, other.group}();

}

void walkRoot(Type* type) {

assert(taskList.empty());

taskList.push_back(Task::scan(type));

doWalk();

}

void walkRoot(HeapType* ht) {

assert(taskList.empty());

taskList.push_back(Task::scan(ht));

doWalk();

}

Self& self() { return *static_cast<Self*>(this); }

void scanType(Type* type) {

if (type->isTuple()) {

auto& types = const_cast<Tuple&>(type->getTuple());

for (auto it = types.rbegin(); it != types.rend(); ++it) {

taskList.push_back(Task::scan(&*it));

}

}

}

void scanHeapType(HeapType* ht) {

if (ht->isBasic()) {

return;

}

auto* info = getHeapTypeInfo(*ht);

switch (info->kind) {

case HeapTypeKind::Func:

taskList.push_back(Task::scan(&info->signature.results));

taskList.push_back(Task::scan(&info->signature.params));

break;

case HeapTypeKind::Cont:

taskList.push_back(Task::scan(&info->continuation.type));

break;

case HeapTypeKind::Struct: {

auto& fields = info->struct_.fields;

for (auto field = fields.rbegin(); field != fields.rend(); ++field) {

taskList.push_back(Task::scan(&field->type));

}

break;

}

case HeapTypeKind::Array:

taskList.push_back(Task::scan(&info->array.element.type));

break;

case HeapTypeKind::Basic:

WASM_UNREACHABLE("unexpected kind");

}

}

struct Task {

enum Kind {

ScanType,

ScanHeapType,

} kind;

union {

Type* type;

HeapType* heapType;

};

static Task scan(Type* type) { return Task(type, ScanType); }

static Task scan(HeapType* ht) { return Task(ht, ScanHeapType); }

private:

Task(Type* type, Kind kind) : kind(kind), type(type) {}

Task(HeapType* ht, Kind kind) : kind(kind), heapType(ht) {}

};

std::vector<Task> taskList;

void doWalk() {

while (!taskList.empty()) {

auto curr = taskList.back();

taskList.pop_back();

switch (curr.kind) {

case Task::ScanType:

self().scanType(curr.type);

break;

case Task::ScanHeapType:

self().scanHeapType(curr.heapType);

break;

}

}

}

void scanType(Type* type) {

isTopLevel = false;

if (type->isRef()) {

this->self().noteChild(type->getHeapType());

} else {

TypeGraphWalkerBase<Self>::scanType(type);

}

}

void scanHeapType(HeapType* type) {

if (isTopLevel) {

isTopLevel = false;

TypeGraphWalkerBase<Self>::scanHeapType(type);

} else {

this->self().noteChild(*type);

}

}

bool isTopLevel = true;

if (type.isBasic()) {

return HeapType::BasicHeapType(type.getID());

}

auto* info = getHeapTypeInfo(type);

switch (info->kind) {

case HeapTypeKind::Func:

return HeapTypes::func.getBasic(info->share);

case HeapTypeKind::Cont:

return HeapTypes::cont.getBasic(info->share);

case HeapTypeKind::Struct:

return HeapTypes::struct_.getBasic(info->share);

case HeapTypeKind::Array:

return HeapTypes::array.getBasic(info->share);

case HeapTypeKind::Basic:

break;

}

WASM_UNREACHABLE("unexpected kind");

HeapType::BasicHeapType b) {

if (a == b) {

return a;

}

if (HeapType(a).getTop() != HeapType(b).getTop()) {

return {};

}

if (HeapType(a).isBottom()) {

return b;

}

if (HeapType(b).isBottom()) {

return a;

}

// Canonicalize to have `a` be the lesser type.

if (unsigned(a) > unsigned(b)) {

std::swap(a, b);

}

HeapType lubUnshared;

switch (HeapType(a).getBasic(Unshared)) {

case HeapType::ext:

lubUnshared = HeapType::ext;

break;

case HeapType::func:

case HeapType::cont:

case HeapType::exn:

WASM_UNREACHABLE("Unexpected non-bottom type in same hierarchy");

case HeapType::any:

lubUnshared = HeapType::any;

break;

case HeapType::eq:

case HeapType::i31:

case HeapType::struct_:

lubUnshared = HeapType::eq;

break;

case HeapType::array:

case HeapType::string:

case HeapType::waitqueue:

// As the last non-bottom types in their hierarchies, it should not be

// possible for `a` to be array or string. We know that `b` != `a` and

// that `b` is not bottom, but that `b` and `a` are in the same hierarchy,

// so there are no possible value for `b`.

case HeapType::none:

case HeapType::noext:

case HeapType::nofunc:

case HeapType::nocont:

case HeapType::noexn:

case HeapType::nowaitqueue:

// Bottom types already handled.

WASM_UNREACHABLE("unexpected basic type");

}

auto share = HeapType(a).getShared();

return {lubUnshared.getBasic(share)};

std::recursive_mutex mutex;

// Track unique_ptrs for constructed tuples to avoid leaks.

std::vector<std::unique_ptr<Tuple>> constructedTuples;

// Maps from constructed tuples to their canonical Type IDs.

std::unordered_map<std::reference_wrapper<const Tuple>, uintptr_t> typeIDs;

Type insert(const Tuple& info) { return doInsert(info); }

Type insert(std::unique_ptr<Tuple>&& info) { return doInsert(info); }

bool hasCanonical(const Tuple& info, Tuple& canonical);

void clear() {

typeIDs.clear();

constructedTuples.clear();

}

template<typename Ref> Type doInsert(Ref& tupleRef) {

const Tuple& tuple = [&]() {

if constexpr (std::is_same_v<Ref, const Tuple>) {

return tupleRef;

} else if constexpr (std::is_same_v<Ref, std::unique_ptr<Tuple>>) {

return *tupleRef;

}

}();

auto getPtr = [&]() -> std::unique_ptr<Tuple> {

if constexpr (std::is_same_v<Ref, const Tuple>) {

return std::make_unique<Tuple>(tupleRef);

} else if constexpr (std::is_same_v<Ref, std::unique_ptr<Tuple>>) {

return std::move(tupleRef);

}

};

auto insertNew = [&]() {

auto ptr = getPtr();

TypeID id = uintptr_t(ptr.get()) | 1;

assert(id > Type::_last_basic_type);

typeIDs.insert({*ptr, id});

constructedTuples.emplace_back(std::move(ptr));

return Type(id);

};

// Turn e.g. singleton tuple into non-tuple.

if (tuple.size() == 0) {

return Type::none;

}

if (tuple.size() == 1) {

return tuple[0];

}

std::lock_guard<std::recursive_mutex> lock(mutex);

// Check whether we already have a type for this tuple.

auto indexIt = typeIDs.find(std::cref(tuple));

if (indexIt != typeIDs.end()) {

return Type(indexIt->second);

}

// We do not have a type for this tuple already. Create one.

return insertNew();

}

std::mutex mutex;

// Store the structures of all rec groups created so far so we can avoid

// creating duplicates.

std::unordered_set<RecGroupStructure> canonicalGroups;

// Keep the `RecGroupInfos` for the nontrivial groups stored in

// `canonicalGroups` alive.

std::vector<std::unique_ptr<RecGroupInfo>> builtGroups;

RecGroup insert(RecGroup group) {

RecGroupStructure structure{group};

auto [it, inserted] = canonicalGroups.insert(structure);

if (inserted) {

return group;

} else {

return it->group;

}

}

RecGroup insert(std::unique_ptr<RecGroupInfo>&& info) {

RecGroup group{uintptr_t(info.get())};

auto canonical = insert(group);

if (canonical == group) {

builtGroups.emplace_back(std::move(info));

}

return canonical;

}

// Utility for canonicalizing HeapTypes with trivial recursion groups.

HeapType insert(std::unique_ptr<HeapTypeInfo>&& info) {

std::lock_guard<std::mutex> lock(mutex);

assert(!info->recGroup && "Unexpected nontrivial rec group");

auto group = asHeapType(info).getRecGroup();

auto canonical = insert(group);

if (group == canonical) {

std::lock_guard<std::recursive_mutex> storeLock(globalHeapTypeStoreMutex);

globalHeapTypeStore.emplace_back(std::move(info));

}

return canonical[0];

}

void clear() {

canonicalGroups.clear();

builtGroups.clear();

}

#ifndef NDEBUG

for (auto type : tuple) {

assert(type.isSingle());

}

#endif

globalTupleStore.clear();

globalHeapTypeStore.clear();

globalRecGroupStore.clear();

// A variable can get a default value if its type is concrete (unreachable

// and none have no values, hence no default), and if it's a reference, it

// must be nullable.

if (isTuple()) {

for (auto t : *this) {

if (!t.isDefaultable()) {

return false;

}

}

return true;

}

return isConcrete() && !isNonNullable();

// TODO: alignment?

auto getSingleByteSize = [](Type t) {

switch (t.getBasic()) {

case Type::i32:

case Type::f32:

return 4;

case Type::i64:

case Type::f64:

return 8;

case Type::v128:

return 16;

case Type::none:

case Type::unreachable:

break;

}

WASM_UNREACHABLE("invalid type");

};

if (isTuple()) {

unsigned size = 0;

for (const auto& t : *this) {

size += getSingleByteSize(t);

}

return size;

}

return getSingleByteSize(*this);

auto hasSingleByteSize = [](Type t) { return t.isNumber(); };

if (isTuple()) {

for (const auto& t : *this) {

if (!hasSingleByteSize(t)) {

return false;

}

}

return true;

}

return hasSingleByteSize(*this);

assert(!isTuple() && "Unexpected tuple type");

switch ((*begin()).getBasic()) {

case Type::i32:

return f32;

case Type::i64:

return f64;

case Type::f32:

return i32;

case Type::f64:

return i64;

default:

WASM_UNREACHABLE("invalid type");

}

auto getSingleFeatures = [](Type t) -> FeatureSet {

if (t.isRef()) {

return t.getHeapType().getFeatures();

}

switch (t.getBasic()) {

case Type::v128:

return FeatureSet::SIMD;

default:

return FeatureSet::MVP;

}

};

if (isTuple()) {

FeatureSet feats = FeatureSet::Multivalue;

for (const auto& t : *this) {

feats |= getSingleFeatures(t);

}

return feats;

}

return getSingleFeatures(*this);

if (byteSize < 4) {

return Type::i32;

}

if (byteSize == 4) {

return float_ ? Type::f32 : Type::i32;

}

if (byteSize == 8) {

return float_ ? Type::f64 : Type::i64;

}

if (byteSize == 16) {

return Type::v128;

}

WASM_UNREACHABLE("invalid size");

if (a == b) {

return true;

}

if (a == Type::unreachable) {

return true;

}

if (a.isTuple() && b.isTuple()) {

if (a.size() != b.size()) {

return false;

}

for (size_t i = 0; i < a.size(); ++i) {

if (!isSubType(a[i], b[i])) {

return false;

}

}

return true;

}

if (!a.isRef() || !b.isRef()) {

return false;

}

if (a.isNullable() && !b.isNullable()) {

return false;

}

auto heapTypeA = a.getHeapType();

auto heapTypeB = b.getHeapType();

if (b.isExact()) {

if (a.isExact()) {

return heapTypeA == heapTypeB;

}

if (!heapTypeA.isBottom()) {

return false;

}

}

return HeapType::isSubType(heapTypeA, heapTypeB);

HeapTypeChildCollector collector;

collector.walkRoot(this);

return collector.children;

if (a == b) {

return a;

}

if (a == Type::unreachable) {

return b;

}

if (b == Type::unreachable) {

return a;

}

if (a.isTuple() && b.isTuple()) {

auto size = a.size();

if (size != b.size()) {

return Type::none;

}

std::vector<Type> elems;

elems.reserve(size);

for (size_t i = 0; i < size; ++i) {

auto lub = Type::getLeastUpperBound(a[i], b[i]);

if (lub == Type::none) {

return Type::none;

}

elems.push_back(lub);

}

return Type(elems);

}

if (a.isRef() && b.isRef()) {

auto heapTypeA = a.getHeapType();

auto heapTypeB = b.getHeapType();

if (auto heapType = HeapType::getLeastUpperBound(heapTypeA, heapTypeB)) {

auto nullability =

(a.isNullable() || b.isNullable()) ? Nullable : NonNullable;

// If one heap type is bottom, then the exactness comes from the other

// heap type. Otherwise, the LUB can only be exact if both of the inputs

// are the same exact heap type.

auto exactness = heapTypeA.isBottom() ? b.getExactness()

: heapTypeB.isBottom() ? a.getExactness()

: (a.isInexact() || b.isInexact()) ? Inexact

: (heapTypeA != heapTypeB) ? Inexact

: Exact;

return Type(*heapType, nullability, exactness);

}

}

return Type::none;

WASM_UNREACHABLE("unexpected type");

if (a == b) {

return a;

}

if (a.isTuple() && b.isTuple() && a.size() == b.size()) {

std::vector<Type> elems;

size_t size = a.size();

elems.reserve(size);

for (size_t i = 0; i < size; ++i) {

auto glb = Type::getGreatestLowerBound(a[i], b[i]);

if (glb == Type::unreachable) {

return Type::unreachable;

}

elems.push_back(glb);

}

return Tuple(elems);

}

if (!a.isRef() || !b.isRef()) {

return Type::unreachable;

}

auto heapA = a.getHeapType();

auto heapB = b.getHeapType();

if (heapA.getBottom() != heapB.getBottom()) {

return Type::unreachable;

}

auto nullability =

(a.isNonNullable() || b.isNonNullable()) ? NonNullable : Nullable;

auto exactness = (a.isExact() || b.isExact()) ? Exact : Inexact;

HeapType heapType;

if (HeapType::isSubType(heapA, heapB)) {

heapType = heapA;

} else if (HeapType::isSubType(heapB, heapA)) {

heapType = heapB;

} else {

heapType = heapA.getBottom();

}

// If one of the types is exact, but the GLB heap type is different than its

// heap type, then we must make the GLB heap type bottom.

if ((a.isExact() && heapType != heapA) ||

(b.isExact() && heapType != heapB)) {

heapType = heapA.getBottom();

exactness = Inexact;

}

return Type(heapType, nullability, exactness);

if (isBasic()) {

return {};

}

HeapTypeInfo* super = getHeapTypeInfo(*this)->supertype;

if (super != nullptr) {

return HeapType(uintptr_t(super));

}

return {};

auto ret = getDeclaredSuperType();

if (ret) {

return ret;

}

auto share = getShared();

// There may be a basic supertype.

if (isBasic()) {

switch (getBasic(Unshared)) {

case ext:

case noext:

case func:

case nofunc:

case cont:

case nocont:

case any:

case none:

case exn:

case noexn:

return {};

case string:

return HeapType(ext).getBasic(share);

case waitqueue:

case nowaitqueue:

return HeapType(waitqueue).getBasic(share);

case eq:

return HeapType(any).getBasic(share);

case i31:

case struct_:

case array:

return HeapType(eq).getBasic(share);

}

}

auto* info = getHeapTypeInfo(*this);

switch (info->kind) {

case HeapTypeKind::Func:

return HeapType(func).getBasic(share);

case HeapTypeKind::Cont:

return HeapType(cont).getBasic(share);

case HeapTypeKind::Struct:

return HeapType(struct_).getBasic(share);

case HeapTypeKind::Array:

return HeapType(array).getBasic(share);

case HeapTypeKind::Basic:

break;

}

WASM_UNREACHABLE("unexpected kind");

if (isBasic()) {

return std::nullopt;

}

if (auto* desc = getHeapTypeInfo(*this)->descriptor) {

return HeapType(uintptr_t(desc));

}

return std::nullopt;

if (isBasic()) {

return std::nullopt;

}

if (auto* desc = getHeapTypeInfo(*this)->described) {

return HeapType(uintptr_t(desc));

}

return std::nullopt;

size_t depth = 0;

std::optional<HeapType> super;

for (auto curr = *this; (super = curr.getDeclaredSuperType());

curr = *super) {

++depth;

}

// In addition to the explicit supertypes we just traversed over, there is

// implicit supertyping wrt basic types. A signature type always has one more

// super, HeapType::func, etc.

switch (getKind()) {

case HeapTypeKind::Basic:

// Some basic types have supers.

switch (getBasic(Unshared)) {

case HeapType::ext:

case HeapType::func:

case HeapType::cont:

case HeapType::any:

case HeapType::exn:

break;

case HeapType::eq:

case HeapType::string:

case HeapType::waitqueue:

case HeapType::nowaitqueue:

depth++;

break;

case HeapType::i31:

case HeapType::struct_:

case HeapType::array:

depth += 2;

break;

case HeapType::none:

case HeapType::nofunc:

case HeapType::nocont:

case HeapType::noext:

case HeapType::noexn:

// Bottom types are infinitely deep.

depth = size_t(-1l);

}

break;

case HeapTypeKind::Func:

case HeapTypeKind::Cont:

++depth;

break;

case HeapTypeKind::Struct:

// specific struct types <: struct <: eq <: any

depth += 3;

break;

case HeapTypeKind::Array:

// specific array types <: array <: eq <: any

depth += 3;

break;

}

return depth;