1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
/*
* Copyright 2022 WebAssembly Community Group participants
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef wasm_wasm_type_printing_h
#define wasm_wasm_type_printing_h
#include <cstddef>
#include <iostream>
#include <unordered_map>
#include "support/name.h"
#include "support/utilities.h"
#include "wasm-type.h"
#include "wasm.h"
namespace wasm {
// CRTP base that all other type name generators should subclass. Provides the
// ability to use the generator as a function to print Types and HeapTypes to
// streams.
template<typename Subclass> struct TypeNameGeneratorBase {
TypeNames getNames(HeapType type) {
static_assert(&TypeNameGeneratorBase<Subclass>::getNames !=
&Subclass::getNames,
"Derived class must implement getNames");
WASM_UNREACHABLE("Derived class must implement getNames");
}
HeapType::Printed operator()(HeapType type) {
return type.print(
[&](HeapType ht) { return static_cast<Subclass*>(this)->getNames(ht); });
}
Type::Printed operator()(Type type) {
return type.print(
[&](HeapType ht) { return static_cast<Subclass*>(this)->getNames(ht); });
}
};
// Generates names like "func.0", "struct.1", "array.2", etc. Struct fields are
// not given names.
struct DefaultTypeNameGenerator
: TypeNameGeneratorBase<DefaultTypeNameGenerator> {
size_t funcCount = 0;
size_t contCount = 0;
size_t structCount = 0;
size_t arrayCount = 0;
// Cached names for types that have already been seen.
std::unordered_map<HeapType, TypeNames> nameCache;
TypeNames getNames(HeapType type);
};
// Generates names based on the indices of types in some collection, falling
// back to the given FallbackGenerator when encountering a type not in the
// collection. Struct fields are not given names.
template<typename FallbackGenerator = DefaultTypeNameGenerator>
struct IndexedTypeNameGenerator
: TypeNameGeneratorBase<IndexedTypeNameGenerator<FallbackGenerator>> {
DefaultTypeNameGenerator defaultGenerator;
FallbackGenerator& fallback;
std::unordered_map<HeapType, TypeNames> names;
template<typename T>
IndexedTypeNameGenerator(T& types,
FallbackGenerator& fallback,
const std::string& prefix = "")
: fallback(fallback) {
for (size_t i = 0; i < types.size(); ++i) {
names.insert({types[i], {prefix + std::to_string(i), {}}});
}
}
template<typename T>
IndexedTypeNameGenerator(T& types, const std::string& prefix = "")
: IndexedTypeNameGenerator(types, defaultGenerator, prefix) {}
TypeNames getNames(HeapType type) {
if (auto it = names.find(type); it != names.end()) {
return it->second;
} else {
return fallback.getNames(type);
}
}
};
// Deduction guide.
template<typename T> IndexedTypeNameGenerator(T&) -> IndexedTypeNameGenerator<>;
// Prints heap types stored in a module, falling back to the given
// FallbackGenerator if the module does not have a name for type type.
template<typename FallbackGenerator = DefaultTypeNameGenerator>
struct ModuleTypeNameGenerator
: TypeNameGeneratorBase<ModuleTypeNameGenerator<FallbackGenerator>> {
const Module& wasm;
DefaultTypeNameGenerator defaultGenerator;
FallbackGenerator& fallback;
ModuleTypeNameGenerator(const Module& wasm, FallbackGenerator& fallback)
: wasm(wasm), fallback(fallback) {}
// TODO: Use C++20 `requires` to clean this up.
template<class T = FallbackGenerator>
ModuleTypeNameGenerator(
const Module& wasm,
std::enable_if_t<std::is_same_v<T, DefaultTypeNameGenerator>>* = nullptr)
: ModuleTypeNameGenerator(wasm, defaultGenerator) {}
TypeNames getNames(HeapType type) {
if (auto it = wasm.typeNames.find(type); it != wasm.typeNames.end()) {
return it->second;
}
return fallback.getNames(type);
}
};
// Deduction guide.
ModuleTypeNameGenerator(const Module&) -> ModuleTypeNameGenerator<>;
} // namespace wasm
#endif // wasm_wasm_type_printing_h
|
