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
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
*
* Copyright 2016 Mozilla Foundation
*
* 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.
*/
// This is an INTERNAL header for Wasm baseline compiler: Wasm value stack.
#ifndef wasm_wasm_baseline_stk_h
#define wasm_wasm_baseline_stk_h
#include "wasm/WasmBCDefs.h"
#include "wasm/WasmBCRegDefs.h"
namespace js {
namespace wasm {
// Value stack: stack elements
struct Stk {
private:
Stk() : kind_(Unknown), i64val_(0) {}
public:
enum Kind {
// The Mem opcodes are all clustered at the beginning to
// allow for a quick test within sync().
MemI32, // 32-bit integer stack value ("offs")
MemI64, // 64-bit integer stack value ("offs")
MemF32, // 32-bit floating stack value ("offs")
MemF64, // 64-bit floating stack value ("offs")
#ifdef ENABLE_WASM_SIMD
MemV128, // 128-bit vector stack value ("offs")
#endif
MemRef, // reftype (pointer wide) stack value ("offs")
// The Local opcodes follow the Mem opcodes for a similar
// quick test within hasLocal().
LocalI32, // Local int32 var ("slot")
LocalI64, // Local int64 var ("slot")
LocalF32, // Local float32 var ("slot")
LocalF64, // Local double var ("slot")
#ifdef ENABLE_WASM_SIMD
LocalV128, // Local v128 var ("slot")
#endif
LocalRef, // Local reftype (pointer wide) var ("slot")
RegisterI32, // 32-bit integer register ("i32reg")
RegisterI64, // 64-bit integer register ("i64reg")
RegisterF32, // 32-bit floating register ("f32reg")
RegisterF64, // 64-bit floating register ("f64reg")
#ifdef ENABLE_WASM_SIMD
RegisterV128, // 128-bit vector register ("v128reg")
#endif
RegisterRef, // reftype (pointer wide) register ("refReg")
ConstI32, // 32-bit integer constant ("i32val")
ConstI64, // 64-bit integer constant ("i64val")
ConstF32, // 32-bit floating constant ("f32val")
ConstF64, // 64-bit floating constant ("f64val")
#ifdef ENABLE_WASM_SIMD
ConstV128, // 128-bit vector constant ("v128val")
#endif
ConstRef, // reftype (pointer wide) constant ("refval")
Unknown,
};
Kind kind_;
static const Kind MemLast = MemRef;
static const Kind LocalLast = LocalRef;
union {
RegI32 i32reg_;
RegI64 i64reg_;
RegRef refReg_;
RegF32 f32reg_;
RegF64 f64reg_;
#ifdef ENABLE_WASM_SIMD
RegV128 v128reg_;
#endif
int32_t i32val_;
int64_t i64val_;
intptr_t refval_;
float f32val_;
double f64val_;
#ifdef ENABLE_WASM_SIMD
V128 v128val_;
#endif
uint32_t slot_;
uint32_t offs_;
};
explicit Stk(RegI32 r) : kind_(RegisterI32), i32reg_(r) {}
explicit Stk(RegI64 r) : kind_(RegisterI64), i64reg_(r) {}
explicit Stk(RegRef r) : kind_(RegisterRef), refReg_(r) {}
explicit Stk(RegF32 r) : kind_(RegisterF32), f32reg_(r) {}
explicit Stk(RegF64 r) : kind_(RegisterF64), f64reg_(r) {}
#ifdef ENABLE_WASM_SIMD
explicit Stk(RegV128 r) : kind_(RegisterV128), v128reg_(r) {}
#endif
explicit Stk(int32_t v) : kind_(ConstI32), i32val_(v) {}
explicit Stk(uint32_t v) : kind_(ConstI32), i32val_(int32_t(v)) {}
explicit Stk(int64_t v) : kind_(ConstI64), i64val_(v) {}
explicit Stk(float v) : kind_(ConstF32), f32val_(v) {}
explicit Stk(double v) : kind_(ConstF64), f64val_(v) {}
#ifdef ENABLE_WASM_SIMD
explicit Stk(V128 v) : kind_(ConstV128), v128val_(v) {}
#endif
explicit Stk(Kind k, uint32_t v) : kind_(k), slot_(v) {
MOZ_ASSERT(k > MemLast && k <= LocalLast);
}
static Stk StkRef(intptr_t v) {
Stk s;
s.kind_ = ConstRef;
s.refval_ = v;
return s;
}
static Stk StackResult(ValType type, uint32_t offs) {
Kind k;
switch (type.kind()) {
case ValType::I32:
k = Stk::MemI32;
break;
case ValType::I64:
k = Stk::MemI64;
break;
case ValType::V128:
#ifdef ENABLE_WASM_SIMD
k = Stk::MemV128;
break;
#else
MOZ_CRASH("No SIMD");
#endif
case ValType::F32:
k = Stk::MemF32;
break;
case ValType::F64:
k = Stk::MemF64;
break;
case ValType::Ref:
k = Stk::MemRef;
break;
}
Stk s;
s.setOffs(k, offs);
return s;
}
void setOffs(Kind k, uint32_t v) {
MOZ_ASSERT(k <= MemLast);
kind_ = k;
offs_ = v;
}
Kind kind() const { return kind_; }
bool isMem() const { return kind_ <= MemLast; }
RegI32 i32reg() const {
MOZ_ASSERT(kind_ == RegisterI32);
return i32reg_;
}
RegI64 i64reg() const {
MOZ_ASSERT(kind_ == RegisterI64);
return i64reg_;
}
RegRef refReg() const {
MOZ_ASSERT(kind_ == RegisterRef);
return refReg_;
}
RegF32 f32reg() const {
MOZ_ASSERT(kind_ == RegisterF32);
return f32reg_;
}
RegF64 f64reg() const {
MOZ_ASSERT(kind_ == RegisterF64);
return f64reg_;
}
#ifdef ENABLE_WASM_SIMD
RegV128 v128reg() const {
MOZ_ASSERT(kind_ == RegisterV128);
return v128reg_;
}
#endif
int32_t i32val() const {
MOZ_ASSERT(kind_ == ConstI32);
return i32val_;
}
int64_t i64val() const {
MOZ_ASSERT(kind_ == ConstI64);
return i64val_;
}
intptr_t refval() const {
MOZ_ASSERT(kind_ == ConstRef);
return refval_;
}
// For these two, use an out-param instead of simply returning, to
// use the normal stack and not the x87 FP stack (which has effect on
// NaNs with the signaling bit set).
void f32val(float* out) const {
MOZ_ASSERT(kind_ == ConstF32);
*out = f32val_;
}
void f64val(double* out) const {
MOZ_ASSERT(kind_ == ConstF64);
*out = f64val_;
}
#ifdef ENABLE_WASM_SIMD
// For SIMD, do the same as for floats since we're using float registers to
// hold vectors; this is just conservative.
void v128val(V128* out) const {
MOZ_ASSERT(kind_ == ConstV128);
*out = v128val_;
}
#endif
uint32_t slot() const {
MOZ_ASSERT(kind_ > MemLast && kind_ <= LocalLast);
return slot_;
}
uint32_t offs() const {
MOZ_ASSERT(isMem());
return offs_;
}
#ifdef DEBUG
// Print a stack element (Stk) to stderr. Skip the trailing \n. Printing
// of the actual contents of each stack element (see case ConstI32) can be
// filled in on demand -- even printing just the element `kind_` fields can
// be very useful.
void showStackElem() const {
switch (kind_) {
case MemI32:
fprintf(stderr, "MemI32()");
break;
case MemI64:
fprintf(stderr, "MemI64()");
break;
case MemF32:
fprintf(stderr, "MemF32()");
break;
case MemF64:
fprintf(stderr, "MemF64()");
break;
# ifdef ENABLE_WASM_SIMD
case MemV128:
fprintf(stderr, "MemV128()");
break;
# endif
case MemRef:
fprintf(stderr, "MemRef()");
break;
case LocalI32:
fprintf(stderr, "LocalI32()");
break;
case LocalI64:
fprintf(stderr, "LocalI64()");
break;
case LocalF32:
fprintf(stderr, "LocalF32()");
break;
case LocalF64:
fprintf(stderr, "LocalF64()");
break;
# ifdef ENABLE_WASM_SIMD
case LocalV128:
fprintf(stderr, "LocalV128()");
break;
# endif
case LocalRef:
fprintf(stderr, "LocalRef()");
break;
case RegisterI32:
fprintf(stderr, "RegisterI32()");
break;
case RegisterI64:
fprintf(stderr, "RegisterI64()");
break;
case RegisterF32:
fprintf(stderr, "RegisterF32()");
break;
case RegisterF64:
fprintf(stderr, "RegisterF64()");
break;
# ifdef ENABLE_WASM_SIMD
case RegisterV128:
fprintf(stderr, "RegisterV128()");
break;
# endif
case RegisterRef:
fprintf(stderr, "RegisterRef()");
break;
case ConstI32:
fprintf(stderr, "ConstI32(%d)", (int)i32val_);
break;
case ConstI64:
fprintf(stderr, "ConstI64()");
break;
case ConstF32:
fprintf(stderr, "ConstF32()");
break;
case ConstF64:
fprintf(stderr, "ConstF64()");
break;
# ifdef ENABLE_WASM_SIMD
case ConstV128:
fprintf(stderr, "ConstV128()");
break;
# endif
case ConstRef:
fprintf(stderr, "ConstRef()");
break;
case Unknown:
fprintf(stderr, "Unknown()");
break;
default:
fprintf(stderr, "!! Stk::showStackElem !!");
break;
}
}
#endif
};
using StkVector = Vector<Stk, 0, SystemAllocPolicy>;
} // namespace wasm
} // namespace js
#endif // wasm_wasm_baseline_stk_h
|
