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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
|
/*
* Copyright 2018 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.
*/
// Abstracts out operations from specific opcodes.
#ifndef wasm_ir_abstract_h
#define wasm_ir_abstract_h
#include <wasm.h>
namespace wasm {
namespace Abstract {
enum Op {
// Unary
Neg,
// Binary
Add,
Sub,
Mul,
DivU,
DivS,
Rem,
RemU,
RemS,
Shl,
ShrU,
ShrS,
And,
Or,
Xor,
// Relational
Eq,
Ne,
};
// Provide a wasm type and an abstract op and get the concrete one. For example,
// you can provide i32 and Add and receive the specific opcode for a 32-bit
// addition, AddInt32. If the op does not exist, it returns Invalid.
inline UnaryOp getUnary(Type type, Op op) {
switch (type) {
case i32: {
return InvalidUnary;
}
case i64: {
return InvalidUnary;
}
case f32: {
switch (op) {
case Neg:
return NegFloat32;
default:
return InvalidUnary;
}
break;
}
case f64: {
switch (op) {
case Neg:
return NegFloat64;
default:
return InvalidUnary;
}
break;
}
case v128: {
WASM_UNREACHABLE("v128 not implemented yet");
}
case funcref:
case anyref:
case nullref:
case exnref:
case none:
case unreachable: {
return InvalidUnary;
}
}
WASM_UNREACHABLE("invalid type");
}
inline BinaryOp getBinary(Type type, Op op) {
switch (type) {
case i32: {
switch (op) {
case Add:
return AddInt32;
case Sub:
return SubInt32;
case Mul:
return MulInt32;
case DivU:
return DivUInt32;
case DivS:
return DivSInt32;
case RemU:
return RemUInt32;
case RemS:
return RemSInt32;
case Shl:
return ShlInt32;
case ShrU:
return ShrUInt32;
case ShrS:
return ShrSInt32;
case And:
return AndInt32;
case Or:
return OrInt32;
case Xor:
return XorInt32;
case Eq:
return EqInt32;
case Ne:
return NeInt32;
default:
return InvalidBinary;
}
break;
}
case i64: {
switch (op) {
case Add:
return AddInt64;
case Sub:
return SubInt64;
case Mul:
return MulInt64;
case DivU:
return DivUInt64;
case DivS:
return DivSInt64;
case RemU:
return RemUInt64;
case RemS:
return RemSInt64;
case Shl:
return ShlInt64;
case ShrU:
return ShrUInt64;
case ShrS:
return ShrSInt64;
case And:
return AndInt64;
case Or:
return OrInt64;
case Xor:
return XorInt64;
case Eq:
return EqInt64;
case Ne:
return NeInt64;
default:
return InvalidBinary;
}
break;
}
case f32: {
switch (op) {
case Add:
return AddFloat32;
case Sub:
return SubFloat32;
case Mul:
return MulFloat32;
case DivU:
return DivFloat32;
case DivS:
return DivFloat32;
case Eq:
return EqFloat32;
case Ne:
return NeFloat32;
default:
return InvalidBinary;
}
break;
}
case f64: {
switch (op) {
case Add:
return AddFloat64;
case Sub:
return SubFloat64;
case Mul:
return MulFloat64;
case DivU:
return DivFloat64;
case DivS:
return DivFloat64;
case Eq:
return EqFloat64;
case Ne:
return NeFloat64;
default:
return InvalidBinary;
}
break;
}
case v128: {
WASM_UNREACHABLE("v128 not implemented yet");
}
case funcref:
case anyref:
case nullref:
case exnref:
case none:
case unreachable: {
return InvalidBinary;
}
}
WASM_UNREACHABLE("invalid type");
}
} // namespace Abstract
} // namespace wasm
#endif // wasm_ir_abstract_h
|
