1 // Copyright 2017 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef V8_WASM_BASELINE_S390_LIFTOFF_ASSEMBLER_S390_H_
6 #define V8_WASM_BASELINE_S390_LIFTOFF_ASSEMBLER_S390_H_
7
8 #include "src/wasm/baseline/liftoff-assembler.h"
9
10
11 namespace v8 {
12 namespace internal {
13 namespace wasm {
14
15 namespace liftoff {
16
17 // half
18 // slot Frame
19 // -----+--------------------+---------------------------
20 // n+3 | parameter n |
21 // ... | ... |
22 // 4 | parameter 1 | or parameter 2
23 // 3 | parameter 0 | or parameter 1
24 // 2 | (result address) | or parameter 0
25 // -----+--------------------+---------------------------
26 // 1 | return addr (lr) |
27 // 0 | previous frame (fp)|
28 // -----+--------------------+ <-- frame ptr (fp)
29 // -1 | 0xa: WASM |
30 // -2 | instance |
31 // -----+--------------------+---------------------------
32 // -3 | slot 0 (high) | ^
33 // -4 | slot 0 (low) | |
34 // -5 | slot 1 (high) | Frame slots
35 // -6 | slot 1 (low) | |
36 // | | v
37 // -----+--------------------+ <-- stack ptr (sp)
38 //
39 constexpr int32_t kInstanceOffset = 2 * kSystemPointerSize;
40
GetHalfStackSlot(int offset,RegPairHalf half)41 inline MemOperand GetHalfStackSlot(int offset, RegPairHalf half) {
42 int32_t half_offset =
43 half == kLowWord ? 0 : LiftoffAssembler::kStackSlotSize / 2;
44 return MemOperand(fp, -offset + half_offset);
45 }
46
47 } // namespace liftoff
48
PrepareStackFrame()49 int LiftoffAssembler::PrepareStackFrame() {
50 bailout(kUnsupportedArchitecture, "PrepareStackFrame");
51 return 0;
52 }
53
PrepareTailCall(int num_callee_stack_params,int stack_param_delta)54 void LiftoffAssembler::PrepareTailCall(int num_callee_stack_params,
55 int stack_param_delta) {
56 bailout(kUnsupportedArchitecture, "PrepareTailCall");
57 }
58
PatchPrepareStackFrame(int offset,int frame_size)59 void LiftoffAssembler::PatchPrepareStackFrame(int offset, int frame_size) {
60 bailout(kUnsupportedArchitecture, "PatchPrepareStackFrame");
61 }
62
FinishCode()63 void LiftoffAssembler::FinishCode() {}
64
AbortCompilation()65 void LiftoffAssembler::AbortCompilation() {}
66
67 // static
StaticStackFrameSize()68 constexpr int LiftoffAssembler::StaticStackFrameSize() {
69 return liftoff::kInstanceOffset;
70 }
71
SlotSizeForType(ValueType type)72 int LiftoffAssembler::SlotSizeForType(ValueType type) {
73 switch (type.kind()) {
74 case ValueType::kS128:
75 return type.element_size_bytes();
76 default:
77 return kStackSlotSize;
78 }
79 }
80
NeedsAlignment(ValueType type)81 bool LiftoffAssembler::NeedsAlignment(ValueType type) {
82 return (type.kind() == ValueType::kS128 || type.is_reference_type());
83 }
84
LoadConstant(LiftoffRegister reg,WasmValue value,RelocInfo::Mode rmode)85 void LiftoffAssembler::LoadConstant(LiftoffRegister reg, WasmValue value,
86 RelocInfo::Mode rmode) {
87 bailout(kUnsupportedArchitecture, "LoadConstant");
88 }
89
LoadFromInstance(Register dst,int offset,int size)90 void LiftoffAssembler::LoadFromInstance(Register dst, int offset, int size) {
91 bailout(kUnsupportedArchitecture, "LoadFromInstance");
92 }
93
LoadTaggedPointerFromInstance(Register dst,int offset)94 void LiftoffAssembler::LoadTaggedPointerFromInstance(Register dst, int offset) {
95 bailout(kUnsupportedArchitecture, "LoadTaggedPointerFromInstance");
96 }
97
SpillInstance(Register instance)98 void LiftoffAssembler::SpillInstance(Register instance) {
99 bailout(kUnsupportedArchitecture, "SpillInstance");
100 }
101
FillInstanceInto(Register dst)102 void LiftoffAssembler::FillInstanceInto(Register dst) {
103 bailout(kUnsupportedArchitecture, "FillInstanceInto");
104 }
105
LoadTaggedPointer(Register dst,Register src_addr,Register offset_reg,int32_t offset_imm,LiftoffRegList pinned)106 void LiftoffAssembler::LoadTaggedPointer(Register dst, Register src_addr,
107 Register offset_reg,
108 int32_t offset_imm,
109 LiftoffRegList pinned) {
110 bailout(kUnsupportedArchitecture, "LoadTaggedPointer");
111 }
112
StoreTaggedPointer(Register dst_addr,int32_t offset_imm,LiftoffRegister src,LiftoffRegList pinned)113 void LiftoffAssembler::StoreTaggedPointer(Register dst_addr,
114 int32_t offset_imm,
115 LiftoffRegister src,
116 LiftoffRegList pinned) {
117 bailout(kRefTypes, "GlobalSet");
118 }
119
Load(LiftoffRegister dst,Register src_addr,Register offset_reg,uint32_t offset_imm,LoadType type,LiftoffRegList pinned,uint32_t * protected_load_pc,bool is_load_mem)120 void LiftoffAssembler::Load(LiftoffRegister dst, Register src_addr,
121 Register offset_reg, uint32_t offset_imm,
122 LoadType type, LiftoffRegList pinned,
123 uint32_t* protected_load_pc, bool is_load_mem) {
124 bailout(kUnsupportedArchitecture, "Load");
125 }
126
Store(Register dst_addr,Register offset_reg,uint32_t offset_imm,LiftoffRegister src,StoreType type,LiftoffRegList pinned,uint32_t * protected_store_pc,bool is_store_mem)127 void LiftoffAssembler::Store(Register dst_addr, Register offset_reg,
128 uint32_t offset_imm, LiftoffRegister src,
129 StoreType type, LiftoffRegList pinned,
130 uint32_t* protected_store_pc, bool is_store_mem) {
131 bailout(kUnsupportedArchitecture, "Store");
132 }
133
AtomicLoad(LiftoffRegister dst,Register src_addr,Register offset_reg,uint32_t offset_imm,LoadType type,LiftoffRegList pinned)134 void LiftoffAssembler::AtomicLoad(LiftoffRegister dst, Register src_addr,
135 Register offset_reg, uint32_t offset_imm,
136 LoadType type, LiftoffRegList pinned) {
137 bailout(kAtomics, "AtomicLoad");
138 }
139
AtomicStore(Register dst_addr,Register offset_reg,uint32_t offset_imm,LiftoffRegister src,StoreType type,LiftoffRegList pinned)140 void LiftoffAssembler::AtomicStore(Register dst_addr, Register offset_reg,
141 uint32_t offset_imm, LiftoffRegister src,
142 StoreType type, LiftoffRegList pinned) {
143 bailout(kAtomics, "AtomicStore");
144 }
145
AtomicAdd(Register dst_addr,Register offset_reg,uint32_t offset_imm,LiftoffRegister value,LiftoffRegister result,StoreType type)146 void LiftoffAssembler::AtomicAdd(Register dst_addr, Register offset_reg,
147 uint32_t offset_imm, LiftoffRegister value,
148 LiftoffRegister result, StoreType type) {
149 bailout(kAtomics, "AtomicAdd");
150 }
151
AtomicSub(Register dst_addr,Register offset_reg,uint32_t offset_imm,LiftoffRegister value,LiftoffRegister result,StoreType type)152 void LiftoffAssembler::AtomicSub(Register dst_addr, Register offset_reg,
153 uint32_t offset_imm, LiftoffRegister value,
154 LiftoffRegister result, StoreType type) {
155 bailout(kAtomics, "AtomicSub");
156 }
157
AtomicAnd(Register dst_addr,Register offset_reg,uint32_t offset_imm,LiftoffRegister value,LiftoffRegister result,StoreType type)158 void LiftoffAssembler::AtomicAnd(Register dst_addr, Register offset_reg,
159 uint32_t offset_imm, LiftoffRegister value,
160 LiftoffRegister result, StoreType type) {
161 bailout(kAtomics, "AtomicAnd");
162 }
163
AtomicOr(Register dst_addr,Register offset_reg,uint32_t offset_imm,LiftoffRegister value,LiftoffRegister result,StoreType type)164 void LiftoffAssembler::AtomicOr(Register dst_addr, Register offset_reg,
165 uint32_t offset_imm, LiftoffRegister value,
166 LiftoffRegister result, StoreType type) {
167 bailout(kAtomics, "AtomicOr");
168 }
169
AtomicXor(Register dst_addr,Register offset_reg,uint32_t offset_imm,LiftoffRegister value,LiftoffRegister result,StoreType type)170 void LiftoffAssembler::AtomicXor(Register dst_addr, Register offset_reg,
171 uint32_t offset_imm, LiftoffRegister value,
172 LiftoffRegister result, StoreType type) {
173 bailout(kAtomics, "AtomicXor");
174 }
175
AtomicExchange(Register dst_addr,Register offset_reg,uint32_t offset_imm,LiftoffRegister value,LiftoffRegister result,StoreType type)176 void LiftoffAssembler::AtomicExchange(Register dst_addr, Register offset_reg,
177 uint32_t offset_imm,
178 LiftoffRegister value,
179 LiftoffRegister result, StoreType type) {
180 bailout(kAtomics, "AtomicExchange");
181 }
182
AtomicCompareExchange(Register dst_addr,Register offset_reg,uint32_t offset_imm,LiftoffRegister expected,LiftoffRegister new_value,LiftoffRegister result,StoreType type)183 void LiftoffAssembler::AtomicCompareExchange(
184 Register dst_addr, Register offset_reg, uint32_t offset_imm,
185 LiftoffRegister expected, LiftoffRegister new_value, LiftoffRegister result,
186 StoreType type) {
187 bailout(kAtomics, "AtomicCompareExchange");
188 }
189
AtomicFence()190 void LiftoffAssembler::AtomicFence() { bailout(kAtomics, "AtomicFence"); }
191
LoadCallerFrameSlot(LiftoffRegister dst,uint32_t caller_slot_idx,ValueType type)192 void LiftoffAssembler::LoadCallerFrameSlot(LiftoffRegister dst,
193 uint32_t caller_slot_idx,
194 ValueType type) {
195 bailout(kUnsupportedArchitecture, "LoadCallerFrameSlot");
196 }
197
StoreCallerFrameSlot(LiftoffRegister src,uint32_t caller_slot_idx,ValueType type)198 void LiftoffAssembler::StoreCallerFrameSlot(LiftoffRegister src,
199 uint32_t caller_slot_idx,
200 ValueType type) {
201 bailout(kUnsupportedArchitecture, "StoreCallerFrameSlot");
202 }
203
LoadReturnStackSlot(LiftoffRegister dst,int offset,ValueType type)204 void LiftoffAssembler::LoadReturnStackSlot(LiftoffRegister dst, int offset,
205 ValueType type) {
206 bailout(kUnsupportedArchitecture, "LoadReturnStackSlot");
207 }
208
MoveStackValue(uint32_t dst_offset,uint32_t src_offset,ValueType type)209 void LiftoffAssembler::MoveStackValue(uint32_t dst_offset, uint32_t src_offset,
210 ValueType type) {
211 bailout(kUnsupportedArchitecture, "MoveStackValue");
212 }
213
Move(Register dst,Register src,ValueType type)214 void LiftoffAssembler::Move(Register dst, Register src, ValueType type) {
215 bailout(kUnsupportedArchitecture, "Move Register");
216 }
217
Move(DoubleRegister dst,DoubleRegister src,ValueType type)218 void LiftoffAssembler::Move(DoubleRegister dst, DoubleRegister src,
219 ValueType type) {
220 bailout(kUnsupportedArchitecture, "Move DoubleRegister");
221 }
222
Spill(int offset,LiftoffRegister reg,ValueType type)223 void LiftoffAssembler::Spill(int offset, LiftoffRegister reg, ValueType type) {
224 bailout(kUnsupportedArchitecture, "Spill register");
225 }
226
Spill(int offset,WasmValue value)227 void LiftoffAssembler::Spill(int offset, WasmValue value) {
228 bailout(kUnsupportedArchitecture, "Spill value");
229 }
230
Fill(LiftoffRegister reg,int offset,ValueType type)231 void LiftoffAssembler::Fill(LiftoffRegister reg, int offset, ValueType type) {
232 bailout(kUnsupportedArchitecture, "Fill");
233 }
234
FillI64Half(Register,int offset,RegPairHalf)235 void LiftoffAssembler::FillI64Half(Register, int offset, RegPairHalf) {
236 bailout(kUnsupportedArchitecture, "FillI64Half");
237 }
238
FillStackSlotsWithZero(int start,int size)239 void LiftoffAssembler::FillStackSlotsWithZero(int start, int size) {
240 DCHECK_LT(0, size);
241 RecordUsedSpillOffset(start + size);
242
243 // We need a zero reg. Always use r0 for that, and push it before to restore
244 // its value afterwards.
245 push(r0);
246 mov(r0, Operand(0));
247
248 if (size <= 5 * kStackSlotSize) {
249 // Special straight-line code for up to five slots. Generates two
250 // instructions per slot.
251 uint32_t remainder = size;
252 for (; remainder >= kStackSlotSize; remainder -= kStackSlotSize) {
253 StoreP(r0, liftoff::GetHalfStackSlot(start + remainder, kLowWord));
254 StoreP(r0, liftoff::GetHalfStackSlot(start + remainder, kHighWord));
255 }
256 DCHECK(remainder == 4 || remainder == 0);
257 if (remainder) {
258 StoreP(r0, liftoff::GetHalfStackSlot(start + remainder, kLowWord));
259 }
260 } else {
261 // General case for bigger counts (9 instructions).
262 // Use r3 for start address (inclusive), r4 for end address (exclusive).
263 push(r3);
264 push(r4);
265 SubP(r3, fp, Operand(start + size));
266 SubP(r4, fp, Operand(start));
267
268 Label loop;
269 bind(&loop);
270 StoreP(r0, MemOperand(r0));
271 la(r0, MemOperand(r0, kSystemPointerSize));
272 CmpLogicalP(r3, r4);
273 bne(&loop);
274
275 pop(r4);
276 pop(r3);
277 }
278
279 pop(r0);
280 }
281
282 #define UNIMPLEMENTED_I32_BINOP(name) \
283 void LiftoffAssembler::emit_##name(Register dst, Register lhs, \
284 Register rhs) { \
285 bailout(kUnsupportedArchitecture, "i32 binop: " #name); \
286 }
287 #define UNIMPLEMENTED_I32_BINOP_I(name) \
288 UNIMPLEMENTED_I32_BINOP(name) \
289 void LiftoffAssembler::emit_##name##i(Register dst, Register lhs, \
290 int32_t imm) { \
291 bailout(kUnsupportedArchitecture, "i32 binop_i: " #name); \
292 }
293 #define UNIMPLEMENTED_I64_BINOP(name) \
294 void LiftoffAssembler::emit_##name(LiftoffRegister dst, LiftoffRegister lhs, \
295 LiftoffRegister rhs) { \
296 bailout(kUnsupportedArchitecture, "i64 binop: " #name); \
297 }
298 #define UNIMPLEMENTED_I64_BINOP_I(name) \
299 UNIMPLEMENTED_I64_BINOP(name) \
300 void LiftoffAssembler::emit_##name##i(LiftoffRegister dst, \
301 LiftoffRegister lhs, int32_t imm) { \
302 bailout(kUnsupportedArchitecture, "i64 binop_i: " #name); \
303 }
304 #define UNIMPLEMENTED_GP_UNOP(name) \
305 void LiftoffAssembler::emit_##name(Register dst, Register src) { \
306 bailout(kUnsupportedArchitecture, "gp unop: " #name); \
307 }
308 #define UNIMPLEMENTED_FP_BINOP(name) \
309 void LiftoffAssembler::emit_##name(DoubleRegister dst, DoubleRegister lhs, \
310 DoubleRegister rhs) { \
311 bailout(kUnsupportedArchitecture, "fp binop: " #name); \
312 }
313 #define UNIMPLEMENTED_FP_UNOP(name) \
314 void LiftoffAssembler::emit_##name(DoubleRegister dst, DoubleRegister src) { \
315 bailout(kUnsupportedArchitecture, "fp unop: " #name); \
316 }
317 #define UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(name) \
318 bool LiftoffAssembler::emit_##name(DoubleRegister dst, DoubleRegister src) { \
319 bailout(kUnsupportedArchitecture, "fp unop: " #name); \
320 return true; \
321 }
322 #define UNIMPLEMENTED_I32_SHIFTOP(name) \
323 void LiftoffAssembler::emit_##name(Register dst, Register src, \
324 Register amount) { \
325 bailout(kUnsupportedArchitecture, "i32 shiftop: " #name); \
326 } \
327 void LiftoffAssembler::emit_##name##i(Register dst, Register src, \
328 int32_t amount) { \
329 bailout(kUnsupportedArchitecture, "i32 shiftop: " #name); \
330 }
331 #define UNIMPLEMENTED_I64_SHIFTOP(name) \
332 void LiftoffAssembler::emit_##name(LiftoffRegister dst, LiftoffRegister src, \
333 Register amount) { \
334 bailout(kUnsupportedArchitecture, "i64 shiftop: " #name); \
335 } \
336 void LiftoffAssembler::emit_##name##i(LiftoffRegister dst, \
337 LiftoffRegister src, int32_t amount) { \
338 bailout(kUnsupportedArchitecture, "i64 shiftop: " #name); \
339 }
340
341 UNIMPLEMENTED_I32_BINOP_I(i32_add)
UNIMPLEMENTED_I32_BINOP(i32_sub)342 UNIMPLEMENTED_I32_BINOP(i32_sub)
343 UNIMPLEMENTED_I32_BINOP(i32_mul)
344 UNIMPLEMENTED_I32_BINOP_I(i32_and)
345 UNIMPLEMENTED_I32_BINOP_I(i32_or)
346 UNIMPLEMENTED_I32_BINOP_I(i32_xor)
347 UNIMPLEMENTED_I32_SHIFTOP(i32_shl)
348 UNIMPLEMENTED_I32_SHIFTOP(i32_sar)
349 UNIMPLEMENTED_I32_SHIFTOP(i32_shr)
350 UNIMPLEMENTED_I64_BINOP_I(i64_add)
351 UNIMPLEMENTED_I64_BINOP(i64_sub)
352 UNIMPLEMENTED_I64_BINOP(i64_mul)
353 #ifdef V8_TARGET_ARCH_S390X
354 UNIMPLEMENTED_I64_BINOP_I(i64_and)
355 UNIMPLEMENTED_I64_BINOP_I(i64_or)
356 UNIMPLEMENTED_I64_BINOP_I(i64_xor)
357 #endif
358 UNIMPLEMENTED_I64_SHIFTOP(i64_shl)
359 UNIMPLEMENTED_I64_SHIFTOP(i64_sar)
360 UNIMPLEMENTED_I64_SHIFTOP(i64_shr)
361 UNIMPLEMENTED_GP_UNOP(i32_clz)
362 UNIMPLEMENTED_GP_UNOP(i32_ctz)
363 UNIMPLEMENTED_FP_BINOP(f32_add)
364 UNIMPLEMENTED_FP_BINOP(f32_sub)
365 UNIMPLEMENTED_FP_BINOP(f32_mul)
366 UNIMPLEMENTED_FP_BINOP(f32_div)
367 UNIMPLEMENTED_FP_BINOP(f32_min)
368 UNIMPLEMENTED_FP_BINOP(f32_max)
369 UNIMPLEMENTED_FP_BINOP(f32_copysign)
370 UNIMPLEMENTED_FP_UNOP(f32_abs)
371 UNIMPLEMENTED_FP_UNOP(f32_neg)
372 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f32_ceil)
373 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f32_floor)
374 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f32_trunc)
375 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f32_nearest_int)
376 UNIMPLEMENTED_FP_UNOP(f32_sqrt)
377 UNIMPLEMENTED_FP_BINOP(f64_add)
378 UNIMPLEMENTED_FP_BINOP(f64_sub)
379 UNIMPLEMENTED_FP_BINOP(f64_mul)
380 UNIMPLEMENTED_FP_BINOP(f64_div)
381 UNIMPLEMENTED_FP_BINOP(f64_min)
382 UNIMPLEMENTED_FP_BINOP(f64_max)
383 UNIMPLEMENTED_FP_BINOP(f64_copysign)
384 UNIMPLEMENTED_FP_UNOP(f64_abs)
385 UNIMPLEMENTED_FP_UNOP(f64_neg)
386 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f64_ceil)
387 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f64_floor)
388 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f64_trunc)
389 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f64_nearest_int)
390 UNIMPLEMENTED_FP_UNOP(f64_sqrt)
391
392 #undef UNIMPLEMENTED_I32_BINOP
393 #undef UNIMPLEMENTED_I32_BINOP_I
394 #undef UNIMPLEMENTED_I64_BINOP
395 #undef UNIMPLEMENTED_I64_BINOP_I
396 #undef UNIMPLEMENTED_GP_UNOP
397 #undef UNIMPLEMENTED_FP_BINOP
398 #undef UNIMPLEMENTED_FP_UNOP
399 #undef UNIMPLEMENTED_FP_UNOP_RETURN_TRUE
400 #undef UNIMPLEMENTED_I32_SHIFTOP
401 #undef UNIMPLEMENTED_I64_SHIFTOP
402
403 bool LiftoffAssembler::emit_i32_popcnt(Register dst, Register src) {
404 bailout(kUnsupportedArchitecture, "i32_popcnt");
405 return true;
406 }
407
emit_i64_popcnt(LiftoffRegister dst,LiftoffRegister src)408 bool LiftoffAssembler::emit_i64_popcnt(LiftoffRegister dst,
409 LiftoffRegister src) {
410 bailout(kUnsupportedArchitecture, "i64_popcnt");
411 return true;
412 }
413
emit_i32_divs(Register dst,Register lhs,Register rhs,Label * trap_div_by_zero,Label * trap_div_unrepresentable)414 void LiftoffAssembler::emit_i32_divs(Register dst, Register lhs, Register rhs,
415 Label* trap_div_by_zero,
416 Label* trap_div_unrepresentable) {
417 bailout(kUnsupportedArchitecture, "i32_divs");
418 }
419
emit_i32_divu(Register dst,Register lhs,Register rhs,Label * trap_div_by_zero)420 void LiftoffAssembler::emit_i32_divu(Register dst, Register lhs, Register rhs,
421 Label* trap_div_by_zero) {
422 bailout(kUnsupportedArchitecture, "i32_divu");
423 }
424
emit_i32_rems(Register dst,Register lhs,Register rhs,Label * trap_div_by_zero)425 void LiftoffAssembler::emit_i32_rems(Register dst, Register lhs, Register rhs,
426 Label* trap_div_by_zero) {
427 bailout(kUnsupportedArchitecture, "i32_rems");
428 }
429
emit_i32_remu(Register dst,Register lhs,Register rhs,Label * trap_div_by_zero)430 void LiftoffAssembler::emit_i32_remu(Register dst, Register lhs, Register rhs,
431 Label* trap_div_by_zero) {
432 bailout(kUnsupportedArchitecture, "i32_remu");
433 }
434
emit_i64_divs(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs,Label * trap_div_by_zero,Label * trap_div_unrepresentable)435 bool LiftoffAssembler::emit_i64_divs(LiftoffRegister dst, LiftoffRegister lhs,
436 LiftoffRegister rhs,
437 Label* trap_div_by_zero,
438 Label* trap_div_unrepresentable) {
439 bailout(kUnsupportedArchitecture, "i64_divs");
440 return true;
441 }
442
emit_i64_divu(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs,Label * trap_div_by_zero)443 bool LiftoffAssembler::emit_i64_divu(LiftoffRegister dst, LiftoffRegister lhs,
444 LiftoffRegister rhs,
445 Label* trap_div_by_zero) {
446 bailout(kUnsupportedArchitecture, "i64_divu");
447 return true;
448 }
449
emit_i64_rems(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs,Label * trap_div_by_zero)450 bool LiftoffAssembler::emit_i64_rems(LiftoffRegister dst, LiftoffRegister lhs,
451 LiftoffRegister rhs,
452 Label* trap_div_by_zero) {
453 bailout(kUnsupportedArchitecture, "i64_rems");
454 return true;
455 }
456
emit_i64_remu(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs,Label * trap_div_by_zero)457 bool LiftoffAssembler::emit_i64_remu(LiftoffRegister dst, LiftoffRegister lhs,
458 LiftoffRegister rhs,
459 Label* trap_div_by_zero) {
460 bailout(kUnsupportedArchitecture, "i64_remu");
461 return true;
462 }
463
emit_i64_clz(LiftoffRegister dst,LiftoffRegister src)464 void LiftoffAssembler::emit_i64_clz(LiftoffRegister dst, LiftoffRegister src) {
465 bailout(kUnsupportedArchitecture, "i64_clz");
466 }
467
emit_i64_ctz(LiftoffRegister dst,LiftoffRegister src)468 void LiftoffAssembler::emit_i64_ctz(LiftoffRegister dst, LiftoffRegister src) {
469 bailout(kUnsupportedArchitecture, "i64_ctz");
470 }
471
emit_u32_to_intptr(Register dst,Register src)472 void LiftoffAssembler::emit_u32_to_intptr(Register dst, Register src) {
473 #ifdef V8_TARGET_ARCH_S390X
474 bailout(kUnsupportedArchitecture, "emit_u32_to_intptr");
475 #else
476 // This is a nop on s390.
477 #endif
478 }
479
emit_type_conversion(WasmOpcode opcode,LiftoffRegister dst,LiftoffRegister src,Label * trap)480 bool LiftoffAssembler::emit_type_conversion(WasmOpcode opcode,
481 LiftoffRegister dst,
482 LiftoffRegister src, Label* trap) {
483 bailout(kUnsupportedArchitecture, "emit_type_conversion");
484 return true;
485 }
486
emit_i32_signextend_i8(Register dst,Register src)487 void LiftoffAssembler::emit_i32_signextend_i8(Register dst, Register src) {
488 bailout(kUnsupportedArchitecture, "emit_i32_signextend_i8");
489 }
490
emit_i32_signextend_i16(Register dst,Register src)491 void LiftoffAssembler::emit_i32_signextend_i16(Register dst, Register src) {
492 bailout(kUnsupportedArchitecture, "emit_i32_signextend_i16");
493 }
494
emit_i64_signextend_i8(LiftoffRegister dst,LiftoffRegister src)495 void LiftoffAssembler::emit_i64_signextend_i8(LiftoffRegister dst,
496 LiftoffRegister src) {
497 bailout(kUnsupportedArchitecture, "emit_i64_signextend_i8");
498 }
499
emit_i64_signextend_i16(LiftoffRegister dst,LiftoffRegister src)500 void LiftoffAssembler::emit_i64_signextend_i16(LiftoffRegister dst,
501 LiftoffRegister src) {
502 bailout(kUnsupportedArchitecture, "emit_i64_signextend_i16");
503 }
504
emit_i64_signextend_i32(LiftoffRegister dst,LiftoffRegister src)505 void LiftoffAssembler::emit_i64_signextend_i32(LiftoffRegister dst,
506 LiftoffRegister src) {
507 bailout(kUnsupportedArchitecture, "emit_i64_signextend_i32");
508 }
509
emit_jump(Label * label)510 void LiftoffAssembler::emit_jump(Label* label) {
511 bailout(kUnsupportedArchitecture, "emit_jump");
512 }
513
emit_jump(Register target)514 void LiftoffAssembler::emit_jump(Register target) {
515 bailout(kUnsupportedArchitecture, "emit_jump");
516 }
517
emit_cond_jump(Condition cond,Label * label,ValueType type,Register lhs,Register rhs)518 void LiftoffAssembler::emit_cond_jump(Condition cond, Label* label,
519 ValueType type, Register lhs,
520 Register rhs) {
521 bailout(kUnsupportedArchitecture, "emit_cond_jump");
522 }
523
emit_i32_eqz(Register dst,Register src)524 void LiftoffAssembler::emit_i32_eqz(Register dst, Register src) {
525 bailout(kUnsupportedArchitecture, "emit_i32_eqz");
526 }
527
emit_i32_set_cond(Condition cond,Register dst,Register lhs,Register rhs)528 void LiftoffAssembler::emit_i32_set_cond(Condition cond, Register dst,
529 Register lhs, Register rhs) {
530 bailout(kUnsupportedArchitecture, "emit_i32_set_cond");
531 }
532
emit_i64_eqz(Register dst,LiftoffRegister src)533 void LiftoffAssembler::emit_i64_eqz(Register dst, LiftoffRegister src) {
534 bailout(kUnsupportedArchitecture, "emit_i64_eqz");
535 }
536
emit_i64_set_cond(Condition cond,Register dst,LiftoffRegister lhs,LiftoffRegister rhs)537 void LiftoffAssembler::emit_i64_set_cond(Condition cond, Register dst,
538 LiftoffRegister lhs,
539 LiftoffRegister rhs) {
540 bailout(kUnsupportedArchitecture, "emit_i64_set_cond");
541 }
542
emit_f32_set_cond(Condition cond,Register dst,DoubleRegister lhs,DoubleRegister rhs)543 void LiftoffAssembler::emit_f32_set_cond(Condition cond, Register dst,
544 DoubleRegister lhs,
545 DoubleRegister rhs) {
546 bailout(kUnsupportedArchitecture, "emit_f32_set_cond");
547 }
548
emit_f64_set_cond(Condition cond,Register dst,DoubleRegister lhs,DoubleRegister rhs)549 void LiftoffAssembler::emit_f64_set_cond(Condition cond, Register dst,
550 DoubleRegister lhs,
551 DoubleRegister rhs) {
552 bailout(kUnsupportedArchitecture, "emit_f64_set_cond");
553 }
554
emit_select(LiftoffRegister dst,Register condition,LiftoffRegister true_value,LiftoffRegister false_value,ValueType type)555 bool LiftoffAssembler::emit_select(LiftoffRegister dst, Register condition,
556 LiftoffRegister true_value,
557 LiftoffRegister false_value,
558 ValueType type) {
559 return false;
560 }
561
LoadTransform(LiftoffRegister dst,Register src_addr,Register offset_reg,uint32_t offset_imm,LoadType type,LoadTransformationKind transform,uint32_t * protected_load_pc)562 void LiftoffAssembler::LoadTransform(LiftoffRegister dst, Register src_addr,
563 Register offset_reg, uint32_t offset_imm,
564 LoadType type,
565 LoadTransformationKind transform,
566 uint32_t* protected_load_pc) {
567 bailout(kSimd, "Load transform unimplemented");
568 }
569
emit_i8x16_swizzle(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)570 void LiftoffAssembler::emit_i8x16_swizzle(LiftoffRegister dst,
571 LiftoffRegister lhs,
572 LiftoffRegister rhs) {
573 bailout(kUnsupportedArchitecture, "emit_i8x16_swizzle");
574 }
575
emit_f64x2_splat(LiftoffRegister dst,LiftoffRegister src)576 void LiftoffAssembler::emit_f64x2_splat(LiftoffRegister dst,
577 LiftoffRegister src) {
578 bailout(kUnsupportedArchitecture, "emit_f64x2splat");
579 }
580
emit_f64x2_extract_lane(LiftoffRegister dst,LiftoffRegister lhs,uint8_t imm_lane_idx)581 void LiftoffAssembler::emit_f64x2_extract_lane(LiftoffRegister dst,
582 LiftoffRegister lhs,
583 uint8_t imm_lane_idx) {
584 bailout(kUnsupportedArchitecture, "emit_f64x2extractlane");
585 }
586
emit_f64x2_replace_lane(LiftoffRegister dst,LiftoffRegister src1,LiftoffRegister src2,uint8_t imm_lane_idx)587 void LiftoffAssembler::emit_f64x2_replace_lane(LiftoffRegister dst,
588 LiftoffRegister src1,
589 LiftoffRegister src2,
590 uint8_t imm_lane_idx) {
591 bailout(kUnsupportedArchitecture, "emit_f64x2replacelane");
592 }
593
emit_f64x2_abs(LiftoffRegister dst,LiftoffRegister src)594 void LiftoffAssembler::emit_f64x2_abs(LiftoffRegister dst,
595 LiftoffRegister src) {
596 bailout(kUnsupportedArchitecture, "emit_f64x2_abs");
597 }
598
emit_f64x2_neg(LiftoffRegister dst,LiftoffRegister src)599 void LiftoffAssembler::emit_f64x2_neg(LiftoffRegister dst,
600 LiftoffRegister src) {
601 bailout(kUnsupportedArchitecture, "emit_f64x2neg");
602 }
603
emit_f64x2_sqrt(LiftoffRegister dst,LiftoffRegister src)604 void LiftoffAssembler::emit_f64x2_sqrt(LiftoffRegister dst,
605 LiftoffRegister src) {
606 bailout(kUnsupportedArchitecture, "emit_f64x2sqrt");
607 }
608
emit_f64x2_ceil(LiftoffRegister dst,LiftoffRegister src)609 bool LiftoffAssembler::emit_f64x2_ceil(LiftoffRegister dst,
610 LiftoffRegister src) {
611 bailout(kSimd, "f64x2.ceil");
612 return true;
613 }
614
emit_f64x2_floor(LiftoffRegister dst,LiftoffRegister src)615 bool LiftoffAssembler::emit_f64x2_floor(LiftoffRegister dst,
616 LiftoffRegister src) {
617 bailout(kSimd, "f64x2.floor");
618 return true;
619 }
620
emit_f64x2_trunc(LiftoffRegister dst,LiftoffRegister src)621 bool LiftoffAssembler::emit_f64x2_trunc(LiftoffRegister dst,
622 LiftoffRegister src) {
623 bailout(kSimd, "f64x2.trunc");
624 return true;
625 }
626
emit_f64x2_nearest_int(LiftoffRegister dst,LiftoffRegister src)627 bool LiftoffAssembler::emit_f64x2_nearest_int(LiftoffRegister dst,
628 LiftoffRegister src) {
629 bailout(kSimd, "f64x2.nearest_int");
630 return true;
631 }
632
emit_f64x2_add(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)633 void LiftoffAssembler::emit_f64x2_add(LiftoffRegister dst, LiftoffRegister lhs,
634 LiftoffRegister rhs) {
635 bailout(kUnsupportedArchitecture, "emit_f64x2add");
636 }
637
emit_f64x2_sub(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)638 void LiftoffAssembler::emit_f64x2_sub(LiftoffRegister dst, LiftoffRegister lhs,
639 LiftoffRegister rhs) {
640 bailout(kUnsupportedArchitecture, "emit_f64x2sub");
641 }
642
emit_f64x2_mul(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)643 void LiftoffAssembler::emit_f64x2_mul(LiftoffRegister dst, LiftoffRegister lhs,
644 LiftoffRegister rhs) {
645 bailout(kUnsupportedArchitecture, "emit_f64x2mul");
646 }
647
emit_f64x2_div(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)648 void LiftoffAssembler::emit_f64x2_div(LiftoffRegister dst, LiftoffRegister lhs,
649 LiftoffRegister rhs) {
650 bailout(kUnsupportedArchitecture, "emit_f64x2div");
651 }
652
emit_f64x2_min(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)653 void LiftoffAssembler::emit_f64x2_min(LiftoffRegister dst, LiftoffRegister lhs,
654 LiftoffRegister rhs) {
655 bailout(kUnsupportedArchitecture, "emit_f64x2min");
656 }
657
emit_f64x2_max(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)658 void LiftoffAssembler::emit_f64x2_max(LiftoffRegister dst, LiftoffRegister lhs,
659 LiftoffRegister rhs) {
660 bailout(kUnsupportedArchitecture, "emit_f64x2max");
661 }
662
emit_f64x2_pmin(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)663 void LiftoffAssembler::emit_f64x2_pmin(LiftoffRegister dst, LiftoffRegister lhs,
664 LiftoffRegister rhs) {
665 bailout(kSimd, "pmin unimplemented");
666 }
667
emit_f64x2_pmax(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)668 void LiftoffAssembler::emit_f64x2_pmax(LiftoffRegister dst, LiftoffRegister lhs,
669 LiftoffRegister rhs) {
670 bailout(kSimd, "pmax unimplemented");
671 }
672
emit_f32x4_splat(LiftoffRegister dst,LiftoffRegister src)673 void LiftoffAssembler::emit_f32x4_splat(LiftoffRegister dst,
674 LiftoffRegister src) {
675 bailout(kUnsupportedArchitecture, "emit_f32x4_splat");
676 }
677
emit_f32x4_extract_lane(LiftoffRegister dst,LiftoffRegister lhs,uint8_t imm_lane_idx)678 void LiftoffAssembler::emit_f32x4_extract_lane(LiftoffRegister dst,
679 LiftoffRegister lhs,
680 uint8_t imm_lane_idx) {
681 bailout(kUnsupportedArchitecture, "emit_f32x4extractlane");
682 }
683
emit_f32x4_replace_lane(LiftoffRegister dst,LiftoffRegister src1,LiftoffRegister src2,uint8_t imm_lane_idx)684 void LiftoffAssembler::emit_f32x4_replace_lane(LiftoffRegister dst,
685 LiftoffRegister src1,
686 LiftoffRegister src2,
687 uint8_t imm_lane_idx) {
688 bailout(kUnsupportedArchitecture, "emit_f32x4replacelane");
689 }
690
emit_f32x4_abs(LiftoffRegister dst,LiftoffRegister src)691 void LiftoffAssembler::emit_f32x4_abs(LiftoffRegister dst,
692 LiftoffRegister src) {
693 bailout(kUnsupportedArchitecture, "emit_f32x4_abs");
694 }
695
emit_f32x4_neg(LiftoffRegister dst,LiftoffRegister src)696 void LiftoffAssembler::emit_f32x4_neg(LiftoffRegister dst,
697 LiftoffRegister src) {
698 bailout(kUnsupportedArchitecture, "emit_f32x4neg");
699 }
700
emit_f32x4_sqrt(LiftoffRegister dst,LiftoffRegister src)701 void LiftoffAssembler::emit_f32x4_sqrt(LiftoffRegister dst,
702 LiftoffRegister src) {
703 bailout(kUnsupportedArchitecture, "emit_f32x4sqrt");
704 }
705
emit_f32x4_ceil(LiftoffRegister dst,LiftoffRegister src)706 bool LiftoffAssembler::emit_f32x4_ceil(LiftoffRegister dst,
707 LiftoffRegister src) {
708 bailout(kSimd, "f32x4.ceil");
709 return true;
710 }
711
emit_f32x4_floor(LiftoffRegister dst,LiftoffRegister src)712 bool LiftoffAssembler::emit_f32x4_floor(LiftoffRegister dst,
713 LiftoffRegister src) {
714 bailout(kSimd, "f32x4.floor");
715 return true;
716 }
717
emit_f32x4_trunc(LiftoffRegister dst,LiftoffRegister src)718 bool LiftoffAssembler::emit_f32x4_trunc(LiftoffRegister dst,
719 LiftoffRegister src) {
720 bailout(kSimd, "f32x4.trunc");
721 return true;
722 }
723
emit_f32x4_nearest_int(LiftoffRegister dst,LiftoffRegister src)724 bool LiftoffAssembler::emit_f32x4_nearest_int(LiftoffRegister dst,
725 LiftoffRegister src) {
726 bailout(kSimd, "f32x4.nearest_int");
727 return true;
728 }
729
emit_f32x4_add(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)730 void LiftoffAssembler::emit_f32x4_add(LiftoffRegister dst, LiftoffRegister lhs,
731 LiftoffRegister rhs) {
732 bailout(kUnsupportedArchitecture, "emit_f32x4add");
733 }
734
emit_f32x4_sub(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)735 void LiftoffAssembler::emit_f32x4_sub(LiftoffRegister dst, LiftoffRegister lhs,
736 LiftoffRegister rhs) {
737 bailout(kUnsupportedArchitecture, "emit_f32x4sub");
738 }
739
emit_f32x4_mul(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)740 void LiftoffAssembler::emit_f32x4_mul(LiftoffRegister dst, LiftoffRegister lhs,
741 LiftoffRegister rhs) {
742 bailout(kUnsupportedArchitecture, "emit_f32x4mul");
743 }
744
emit_f32x4_div(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)745 void LiftoffAssembler::emit_f32x4_div(LiftoffRegister dst, LiftoffRegister lhs,
746 LiftoffRegister rhs) {
747 bailout(kUnsupportedArchitecture, "emit_f32x4div");
748 }
749
emit_f32x4_min(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)750 void LiftoffAssembler::emit_f32x4_min(LiftoffRegister dst, LiftoffRegister lhs,
751 LiftoffRegister rhs) {
752 bailout(kUnsupportedArchitecture, "emit_f32x4min");
753 }
754
emit_f32x4_max(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)755 void LiftoffAssembler::emit_f32x4_max(LiftoffRegister dst, LiftoffRegister lhs,
756 LiftoffRegister rhs) {
757 bailout(kUnsupportedArchitecture, "emit_f32x4max");
758 }
759
emit_f32x4_pmin(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)760 void LiftoffAssembler::emit_f32x4_pmin(LiftoffRegister dst, LiftoffRegister lhs,
761 LiftoffRegister rhs) {
762 bailout(kSimd, "pmin unimplemented");
763 }
764
emit_f32x4_pmax(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)765 void LiftoffAssembler::emit_f32x4_pmax(LiftoffRegister dst, LiftoffRegister lhs,
766 LiftoffRegister rhs) {
767 bailout(kSimd, "pmax unimplemented");
768 }
769
emit_i64x2_splat(LiftoffRegister dst,LiftoffRegister src)770 void LiftoffAssembler::emit_i64x2_splat(LiftoffRegister dst,
771 LiftoffRegister src) {
772 bailout(kUnsupportedArchitecture, "emit_i64x2splat");
773 }
774
emit_i64x2_extract_lane(LiftoffRegister dst,LiftoffRegister lhs,uint8_t imm_lane_idx)775 void LiftoffAssembler::emit_i64x2_extract_lane(LiftoffRegister dst,
776 LiftoffRegister lhs,
777 uint8_t imm_lane_idx) {
778 bailout(kUnsupportedArchitecture, "emit_i64x2extractlane");
779 }
780
emit_i64x2_replace_lane(LiftoffRegister dst,LiftoffRegister src1,LiftoffRegister src2,uint8_t imm_lane_idx)781 void LiftoffAssembler::emit_i64x2_replace_lane(LiftoffRegister dst,
782 LiftoffRegister src1,
783 LiftoffRegister src2,
784 uint8_t imm_lane_idx) {
785 bailout(kUnsupportedArchitecture, "emit_i64x2replacelane");
786 }
787
emit_i64x2_neg(LiftoffRegister dst,LiftoffRegister src)788 void LiftoffAssembler::emit_i64x2_neg(LiftoffRegister dst,
789 LiftoffRegister src) {
790 bailout(kUnsupportedArchitecture, "emit_i64x2neg");
791 }
792
emit_i64x2_shl(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)793 void LiftoffAssembler::emit_i64x2_shl(LiftoffRegister dst, LiftoffRegister lhs,
794 LiftoffRegister rhs) {
795 bailout(kSimd, "i64x2_shl");
796 }
797
emit_i64x2_shli(LiftoffRegister dst,LiftoffRegister lhs,int32_t rhs)798 void LiftoffAssembler::emit_i64x2_shli(LiftoffRegister dst, LiftoffRegister lhs,
799 int32_t rhs) {
800 bailout(kSimd, "i64x2_shli");
801 }
802
emit_i64x2_shr_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)803 void LiftoffAssembler::emit_i64x2_shr_s(LiftoffRegister dst,
804 LiftoffRegister lhs,
805 LiftoffRegister rhs) {
806 bailout(kSimd, "i64x2_shr_s");
807 }
808
emit_i64x2_shri_s(LiftoffRegister dst,LiftoffRegister lhs,int32_t rhs)809 void LiftoffAssembler::emit_i64x2_shri_s(LiftoffRegister dst,
810 LiftoffRegister lhs, int32_t rhs) {
811 bailout(kSimd, "i64x2_shri_s");
812 }
813
emit_i64x2_shr_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)814 void LiftoffAssembler::emit_i64x2_shr_u(LiftoffRegister dst,
815 LiftoffRegister lhs,
816 LiftoffRegister rhs) {
817 bailout(kSimd, "i64x2_shr_u");
818 }
819
emit_i64x2_shri_u(LiftoffRegister dst,LiftoffRegister lhs,int32_t rhs)820 void LiftoffAssembler::emit_i64x2_shri_u(LiftoffRegister dst,
821 LiftoffRegister lhs, int32_t rhs) {
822 bailout(kSimd, "i64x2_shri_u");
823 }
824
emit_i64x2_add(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)825 void LiftoffAssembler::emit_i64x2_add(LiftoffRegister dst, LiftoffRegister lhs,
826 LiftoffRegister rhs) {
827 bailout(kUnsupportedArchitecture, "emit_i64x2add");
828 }
829
emit_i64x2_sub(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)830 void LiftoffAssembler::emit_i64x2_sub(LiftoffRegister dst, LiftoffRegister lhs,
831 LiftoffRegister rhs) {
832 bailout(kUnsupportedArchitecture, "emit_i64x2sub");
833 }
834
emit_i64x2_mul(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)835 void LiftoffAssembler::emit_i64x2_mul(LiftoffRegister dst, LiftoffRegister lhs,
836 LiftoffRegister rhs) {
837 bailout(kUnsupportedArchitecture, "emit_i64x2mul");
838 }
839
emit_i32x4_splat(LiftoffRegister dst,LiftoffRegister src)840 void LiftoffAssembler::emit_i32x4_splat(LiftoffRegister dst,
841 LiftoffRegister src) {
842 bailout(kUnsupportedArchitecture, "emit_i32x4_splat");
843 }
844
emit_i32x4_extract_lane(LiftoffRegister dst,LiftoffRegister lhs,uint8_t imm_lane_idx)845 void LiftoffAssembler::emit_i32x4_extract_lane(LiftoffRegister dst,
846 LiftoffRegister lhs,
847 uint8_t imm_lane_idx) {
848 bailout(kUnsupportedArchitecture, "emit_i32x4extractlane");
849 }
850
emit_i32x4_replace_lane(LiftoffRegister dst,LiftoffRegister src1,LiftoffRegister src2,uint8_t imm_lane_idx)851 void LiftoffAssembler::emit_i32x4_replace_lane(LiftoffRegister dst,
852 LiftoffRegister src1,
853 LiftoffRegister src2,
854 uint8_t imm_lane_idx) {
855 bailout(kUnsupportedArchitecture, "emit_i32x4replacelane");
856 }
857
emit_i32x4_neg(LiftoffRegister dst,LiftoffRegister src)858 void LiftoffAssembler::emit_i32x4_neg(LiftoffRegister dst,
859 LiftoffRegister src) {
860 bailout(kUnsupportedArchitecture, "emit_i32x4neg");
861 }
862
emit_v32x4_anytrue(LiftoffRegister dst,LiftoffRegister src)863 void LiftoffAssembler::emit_v32x4_anytrue(LiftoffRegister dst,
864 LiftoffRegister src) {
865 bailout(kSimd, "v32x4_anytrue");
866 }
867
emit_v32x4_alltrue(LiftoffRegister dst,LiftoffRegister src)868 void LiftoffAssembler::emit_v32x4_alltrue(LiftoffRegister dst,
869 LiftoffRegister src) {
870 bailout(kSimd, "v32x4_alltrue");
871 }
872
emit_i32x4_bitmask(LiftoffRegister dst,LiftoffRegister src)873 void LiftoffAssembler::emit_i32x4_bitmask(LiftoffRegister dst,
874 LiftoffRegister src) {
875 bailout(kSimd, "i32x4_bitmask");
876 }
877
emit_i32x4_shl(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)878 void LiftoffAssembler::emit_i32x4_shl(LiftoffRegister dst, LiftoffRegister lhs,
879 LiftoffRegister rhs) {
880 bailout(kSimd, "i32x4_shl");
881 }
882
emit_i32x4_shli(LiftoffRegister dst,LiftoffRegister lhs,int32_t rhs)883 void LiftoffAssembler::emit_i32x4_shli(LiftoffRegister dst, LiftoffRegister lhs,
884 int32_t rhs) {
885 bailout(kSimd, "i32x4_shli");
886 }
887
emit_i32x4_shr_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)888 void LiftoffAssembler::emit_i32x4_shr_s(LiftoffRegister dst,
889 LiftoffRegister lhs,
890 LiftoffRegister rhs) {
891 bailout(kSimd, "i32x4_shr_s");
892 }
893
emit_i32x4_shri_s(LiftoffRegister dst,LiftoffRegister lhs,int32_t rhs)894 void LiftoffAssembler::emit_i32x4_shri_s(LiftoffRegister dst,
895 LiftoffRegister lhs, int32_t rhs) {
896 bailout(kSimd, "i32x4_shri_s");
897 }
898
emit_i32x4_shr_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)899 void LiftoffAssembler::emit_i32x4_shr_u(LiftoffRegister dst,
900 LiftoffRegister lhs,
901 LiftoffRegister rhs) {
902 bailout(kSimd, "i32x4_shr_u");
903 }
904
emit_i32x4_shri_u(LiftoffRegister dst,LiftoffRegister lhs,int32_t rhs)905 void LiftoffAssembler::emit_i32x4_shri_u(LiftoffRegister dst,
906 LiftoffRegister lhs, int32_t rhs) {
907 bailout(kSimd, "i32x4_shri_u");
908 }
909
emit_i32x4_add(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)910 void LiftoffAssembler::emit_i32x4_add(LiftoffRegister dst, LiftoffRegister lhs,
911 LiftoffRegister rhs) {
912 bailout(kUnsupportedArchitecture, "emit_i32x4add");
913 }
914
emit_i32x4_sub(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)915 void LiftoffAssembler::emit_i32x4_sub(LiftoffRegister dst, LiftoffRegister lhs,
916 LiftoffRegister rhs) {
917 bailout(kUnsupportedArchitecture, "emit_i32x4sub");
918 }
919
emit_i32x4_mul(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)920 void LiftoffAssembler::emit_i32x4_mul(LiftoffRegister dst, LiftoffRegister lhs,
921 LiftoffRegister rhs) {
922 bailout(kUnsupportedArchitecture, "emit_i32x4mul");
923 }
924
emit_i32x4_min_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)925 void LiftoffAssembler::emit_i32x4_min_s(LiftoffRegister dst,
926 LiftoffRegister lhs,
927 LiftoffRegister rhs) {
928 bailout(kUnsupportedArchitecture, "emit_i32x4_min_s");
929 }
930
emit_i32x4_min_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)931 void LiftoffAssembler::emit_i32x4_min_u(LiftoffRegister dst,
932 LiftoffRegister lhs,
933 LiftoffRegister rhs) {
934 bailout(kUnsupportedArchitecture, "emit_i32x4_min_u");
935 }
936
emit_i32x4_max_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)937 void LiftoffAssembler::emit_i32x4_max_s(LiftoffRegister dst,
938 LiftoffRegister lhs,
939 LiftoffRegister rhs) {
940 bailout(kUnsupportedArchitecture, "emit_i32x4_max_s");
941 }
942
emit_i32x4_max_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)943 void LiftoffAssembler::emit_i32x4_max_u(LiftoffRegister dst,
944 LiftoffRegister lhs,
945 LiftoffRegister rhs) {
946 bailout(kUnsupportedArchitecture, "emit_i32x4_max_u");
947 }
948
emit_i32x4_dot_i16x8_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)949 void LiftoffAssembler::emit_i32x4_dot_i16x8_s(LiftoffRegister dst,
950 LiftoffRegister lhs,
951 LiftoffRegister rhs) {
952 bailout(kSimd, "i32x4_dot_i16x8_s");
953 }
954
emit_i16x8_splat(LiftoffRegister dst,LiftoffRegister src)955 void LiftoffAssembler::emit_i16x8_splat(LiftoffRegister dst,
956 LiftoffRegister src) {
957 bailout(kUnsupportedArchitecture, "emit_i16x8splat");
958 }
959
emit_i16x8_neg(LiftoffRegister dst,LiftoffRegister src)960 void LiftoffAssembler::emit_i16x8_neg(LiftoffRegister dst,
961 LiftoffRegister src) {
962 bailout(kUnsupportedArchitecture, "emit_i16x8neg");
963 }
964
emit_v16x8_anytrue(LiftoffRegister dst,LiftoffRegister src)965 void LiftoffAssembler::emit_v16x8_anytrue(LiftoffRegister dst,
966 LiftoffRegister src) {
967 bailout(kSimd, "v16x8_anytrue");
968 }
969
emit_v16x8_alltrue(LiftoffRegister dst,LiftoffRegister src)970 void LiftoffAssembler::emit_v16x8_alltrue(LiftoffRegister dst,
971 LiftoffRegister src) {
972 bailout(kSimd, "v16x8_alltrue");
973 }
974
emit_i16x8_bitmask(LiftoffRegister dst,LiftoffRegister src)975 void LiftoffAssembler::emit_i16x8_bitmask(LiftoffRegister dst,
976 LiftoffRegister src) {
977 bailout(kSimd, "i16x8_bitmask");
978 }
979
emit_i16x8_shl(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)980 void LiftoffAssembler::emit_i16x8_shl(LiftoffRegister dst, LiftoffRegister lhs,
981 LiftoffRegister rhs) {
982 bailout(kSimd, "i16x8_shl");
983 }
984
emit_i16x8_shli(LiftoffRegister dst,LiftoffRegister lhs,int32_t rhs)985 void LiftoffAssembler::emit_i16x8_shli(LiftoffRegister dst, LiftoffRegister lhs,
986 int32_t rhs) {
987 bailout(kSimd, "i16x8_shli");
988 }
989
emit_i16x8_shr_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)990 void LiftoffAssembler::emit_i16x8_shr_s(LiftoffRegister dst,
991 LiftoffRegister lhs,
992 LiftoffRegister rhs) {
993 bailout(kSimd, "i16x8_shr_s");
994 }
995
emit_i16x8_shri_s(LiftoffRegister dst,LiftoffRegister lhs,int32_t rhs)996 void LiftoffAssembler::emit_i16x8_shri_s(LiftoffRegister dst,
997 LiftoffRegister lhs, int32_t rhs) {
998 bailout(kSimd, "i16x8_shri_s");
999 }
1000
emit_i16x8_shr_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1001 void LiftoffAssembler::emit_i16x8_shr_u(LiftoffRegister dst,
1002 LiftoffRegister lhs,
1003 LiftoffRegister rhs) {
1004 bailout(kSimd, "i16x8_shr_u");
1005 }
1006
emit_i16x8_shri_u(LiftoffRegister dst,LiftoffRegister lhs,int32_t rhs)1007 void LiftoffAssembler::emit_i16x8_shri_u(LiftoffRegister dst,
1008 LiftoffRegister lhs, int32_t rhs) {
1009 bailout(kSimd, "i16x8_shri_u");
1010 }
1011
emit_i16x8_add(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1012 void LiftoffAssembler::emit_i16x8_add(LiftoffRegister dst, LiftoffRegister lhs,
1013 LiftoffRegister rhs) {
1014 bailout(kUnsupportedArchitecture, "emit_i16x8add");
1015 }
1016
emit_i16x8_add_sat_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1017 void LiftoffAssembler::emit_i16x8_add_sat_s(LiftoffRegister dst,
1018 LiftoffRegister lhs,
1019 LiftoffRegister rhs) {
1020 bailout(kUnsupportedArchitecture, "emit_i16x8addsaturate_s");
1021 }
1022
emit_i16x8_sub(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1023 void LiftoffAssembler::emit_i16x8_sub(LiftoffRegister dst, LiftoffRegister lhs,
1024 LiftoffRegister rhs) {
1025 bailout(kUnsupportedArchitecture, "emit_i16x8sub");
1026 }
1027
emit_i16x8_sub_sat_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1028 void LiftoffAssembler::emit_i16x8_sub_sat_s(LiftoffRegister dst,
1029 LiftoffRegister lhs,
1030 LiftoffRegister rhs) {
1031 bailout(kUnsupportedArchitecture, "emit_i16x8subsaturate_s");
1032 }
1033
emit_i16x8_sub_sat_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1034 void LiftoffAssembler::emit_i16x8_sub_sat_u(LiftoffRegister dst,
1035 LiftoffRegister lhs,
1036 LiftoffRegister rhs) {
1037 bailout(kUnsupportedArchitecture, "emit_i16x8subsaturate_u");
1038 }
1039
emit_i16x8_mul(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1040 void LiftoffAssembler::emit_i16x8_mul(LiftoffRegister dst, LiftoffRegister lhs,
1041 LiftoffRegister rhs) {
1042 bailout(kUnsupportedArchitecture, "emit_i16x8mul");
1043 }
1044
emit_i16x8_add_sat_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1045 void LiftoffAssembler::emit_i16x8_add_sat_u(LiftoffRegister dst,
1046 LiftoffRegister lhs,
1047 LiftoffRegister rhs) {
1048 bailout(kUnsupportedArchitecture, "emit_i16x8addsaturate_u");
1049 }
1050
emit_i16x8_min_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1051 void LiftoffAssembler::emit_i16x8_min_s(LiftoffRegister dst,
1052 LiftoffRegister lhs,
1053 LiftoffRegister rhs) {
1054 bailout(kUnsupportedArchitecture, "emit_i16x8_min_s");
1055 }
1056
emit_i16x8_min_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1057 void LiftoffAssembler::emit_i16x8_min_u(LiftoffRegister dst,
1058 LiftoffRegister lhs,
1059 LiftoffRegister rhs) {
1060 bailout(kUnsupportedArchitecture, "emit_i16x8_min_u");
1061 }
1062
emit_i16x8_max_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1063 void LiftoffAssembler::emit_i16x8_max_s(LiftoffRegister dst,
1064 LiftoffRegister lhs,
1065 LiftoffRegister rhs) {
1066 bailout(kUnsupportedArchitecture, "emit_i16x8_max_s");
1067 }
1068
emit_i16x8_max_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1069 void LiftoffAssembler::emit_i16x8_max_u(LiftoffRegister dst,
1070 LiftoffRegister lhs,
1071 LiftoffRegister rhs) {
1072 bailout(kUnsupportedArchitecture, "emit_i16x8_max_u");
1073 }
1074
emit_i16x8_extract_lane_u(LiftoffRegister dst,LiftoffRegister lhs,uint8_t imm_lane_idx)1075 void LiftoffAssembler::emit_i16x8_extract_lane_u(LiftoffRegister dst,
1076 LiftoffRegister lhs,
1077 uint8_t imm_lane_idx) {
1078 bailout(kUnsupportedArchitecture, "emit_i16x8extractlane_u");
1079 }
1080
emit_i16x8_replace_lane(LiftoffRegister dst,LiftoffRegister src1,LiftoffRegister src2,uint8_t imm_lane_idx)1081 void LiftoffAssembler::emit_i16x8_replace_lane(LiftoffRegister dst,
1082 LiftoffRegister src1,
1083 LiftoffRegister src2,
1084 uint8_t imm_lane_idx) {
1085 bailout(kUnsupportedArchitecture, "emit_i16x8replacelane");
1086 }
1087
emit_i16x8_extract_lane_s(LiftoffRegister dst,LiftoffRegister lhs,uint8_t imm_lane_idx)1088 void LiftoffAssembler::emit_i16x8_extract_lane_s(LiftoffRegister dst,
1089 LiftoffRegister lhs,
1090 uint8_t imm_lane_idx) {
1091 bailout(kUnsupportedArchitecture, "emit_i16x8extractlane_s");
1092 }
1093
emit_i8x16_shuffle(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs,const uint8_t shuffle[16],bool is_swizzle)1094 void LiftoffAssembler::emit_i8x16_shuffle(LiftoffRegister dst,
1095 LiftoffRegister lhs,
1096 LiftoffRegister rhs,
1097 const uint8_t shuffle[16],
1098 bool is_swizzle) {
1099 bailout(kSimd, "i8x16_shuffle");
1100 }
1101
emit_i8x16_splat(LiftoffRegister dst,LiftoffRegister src)1102 void LiftoffAssembler::emit_i8x16_splat(LiftoffRegister dst,
1103 LiftoffRegister src) {
1104 bailout(kUnsupportedArchitecture, "emit_i8x16splat");
1105 }
1106
emit_i8x16_extract_lane_u(LiftoffRegister dst,LiftoffRegister lhs,uint8_t imm_lane_idx)1107 void LiftoffAssembler::emit_i8x16_extract_lane_u(LiftoffRegister dst,
1108 LiftoffRegister lhs,
1109 uint8_t imm_lane_idx) {
1110 bailout(kUnsupportedArchitecture, "emit_i8x16extractlane_u");
1111 }
1112
emit_i8x16_extract_lane_s(LiftoffRegister dst,LiftoffRegister lhs,uint8_t imm_lane_idx)1113 void LiftoffAssembler::emit_i8x16_extract_lane_s(LiftoffRegister dst,
1114 LiftoffRegister lhs,
1115 uint8_t imm_lane_idx) {
1116 bailout(kUnsupportedArchitecture, "emit_i8x16extractlane_s");
1117 }
1118
emit_i8x16_replace_lane(LiftoffRegister dst,LiftoffRegister src1,LiftoffRegister src2,uint8_t imm_lane_idx)1119 void LiftoffAssembler::emit_i8x16_replace_lane(LiftoffRegister dst,
1120 LiftoffRegister src1,
1121 LiftoffRegister src2,
1122 uint8_t imm_lane_idx) {
1123 bailout(kUnsupportedArchitecture, "emit_i8x16replacelane");
1124 }
1125
emit_i8x16_neg(LiftoffRegister dst,LiftoffRegister src)1126 void LiftoffAssembler::emit_i8x16_neg(LiftoffRegister dst,
1127 LiftoffRegister src) {
1128 bailout(kUnsupportedArchitecture, "emit_i8x16neg");
1129 }
1130
emit_v8x16_anytrue(LiftoffRegister dst,LiftoffRegister src)1131 void LiftoffAssembler::emit_v8x16_anytrue(LiftoffRegister dst,
1132 LiftoffRegister src) {
1133 bailout(kSimd, "v8x16_anytrue");
1134 }
1135
emit_v8x16_alltrue(LiftoffRegister dst,LiftoffRegister src)1136 void LiftoffAssembler::emit_v8x16_alltrue(LiftoffRegister dst,
1137 LiftoffRegister src) {
1138 bailout(kSimd, "v8x16_alltrue");
1139 }
1140
emit_i8x16_bitmask(LiftoffRegister dst,LiftoffRegister src)1141 void LiftoffAssembler::emit_i8x16_bitmask(LiftoffRegister dst,
1142 LiftoffRegister src) {
1143 bailout(kSimd, "i8x16_bitmask");
1144 }
1145
emit_i8x16_shl(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1146 void LiftoffAssembler::emit_i8x16_shl(LiftoffRegister dst, LiftoffRegister lhs,
1147 LiftoffRegister rhs) {
1148 bailout(kSimd, "i8x16_shl");
1149 }
1150
emit_i8x16_shli(LiftoffRegister dst,LiftoffRegister lhs,int32_t rhs)1151 void LiftoffAssembler::emit_i8x16_shli(LiftoffRegister dst, LiftoffRegister lhs,
1152 int32_t rhs) {
1153 bailout(kSimd, "i8x16_shli");
1154 }
1155
emit_i8x16_shr_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1156 void LiftoffAssembler::emit_i8x16_shr_s(LiftoffRegister dst,
1157 LiftoffRegister lhs,
1158 LiftoffRegister rhs) {
1159 bailout(kSimd, "i8x16_shr_s");
1160 }
1161
emit_i8x16_shri_s(LiftoffRegister dst,LiftoffRegister lhs,int32_t rhs)1162 void LiftoffAssembler::emit_i8x16_shri_s(LiftoffRegister dst,
1163 LiftoffRegister lhs, int32_t rhs) {
1164 bailout(kSimd, "i8x16_shri_s");
1165 }
1166
emit_i8x16_shr_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1167 void LiftoffAssembler::emit_i8x16_shr_u(LiftoffRegister dst,
1168 LiftoffRegister lhs,
1169 LiftoffRegister rhs) {
1170 bailout(kSimd, "i8x16_shr_u");
1171 }
1172
emit_i8x16_shri_u(LiftoffRegister dst,LiftoffRegister lhs,int32_t rhs)1173 void LiftoffAssembler::emit_i8x16_shri_u(LiftoffRegister dst,
1174 LiftoffRegister lhs, int32_t rhs) {
1175 bailout(kSimd, "i8x16_shri_u");
1176 }
1177
emit_i8x16_add(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1178 void LiftoffAssembler::emit_i8x16_add(LiftoffRegister dst, LiftoffRegister lhs,
1179 LiftoffRegister rhs) {
1180 bailout(kUnsupportedArchitecture, "emit_i8x16add");
1181 }
1182
emit_i8x16_add_sat_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1183 void LiftoffAssembler::emit_i8x16_add_sat_s(LiftoffRegister dst,
1184 LiftoffRegister lhs,
1185 LiftoffRegister rhs) {
1186 bailout(kUnsupportedArchitecture, "emit_i8x16addsaturate_s");
1187 }
1188
emit_i8x16_sub(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1189 void LiftoffAssembler::emit_i8x16_sub(LiftoffRegister dst, LiftoffRegister lhs,
1190 LiftoffRegister rhs) {
1191 bailout(kUnsupportedArchitecture, "emit_i8x16sub");
1192 }
1193
emit_i8x16_sub_sat_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1194 void LiftoffAssembler::emit_i8x16_sub_sat_s(LiftoffRegister dst,
1195 LiftoffRegister lhs,
1196 LiftoffRegister rhs) {
1197 bailout(kUnsupportedArchitecture, "emit_i8x16subsaturate_s");
1198 }
1199
emit_i8x16_sub_sat_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1200 void LiftoffAssembler::emit_i8x16_sub_sat_u(LiftoffRegister dst,
1201 LiftoffRegister lhs,
1202 LiftoffRegister rhs) {
1203 bailout(kUnsupportedArchitecture, "emit_i8x16subsaturate_u");
1204 }
1205
emit_i8x16_mul(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1206 void LiftoffAssembler::emit_i8x16_mul(LiftoffRegister dst, LiftoffRegister lhs,
1207 LiftoffRegister rhs) {
1208 bailout(kUnsupportedArchitecture, "emit_i8x16mul");
1209 }
1210
emit_i8x16_add_sat_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1211 void LiftoffAssembler::emit_i8x16_add_sat_u(LiftoffRegister dst,
1212 LiftoffRegister lhs,
1213 LiftoffRegister rhs) {
1214 bailout(kUnsupportedArchitecture, "emit_i8x16addsaturate_u");
1215 }
1216
emit_i8x16_min_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1217 void LiftoffAssembler::emit_i8x16_min_s(LiftoffRegister dst,
1218 LiftoffRegister lhs,
1219 LiftoffRegister rhs) {
1220 bailout(kUnsupportedArchitecture, "emit_i8x16_min_s");
1221 }
1222
emit_i8x16_min_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1223 void LiftoffAssembler::emit_i8x16_min_u(LiftoffRegister dst,
1224 LiftoffRegister lhs,
1225 LiftoffRegister rhs) {
1226 bailout(kUnsupportedArchitecture, "emit_i8x16_min_u");
1227 }
1228
emit_i8x16_max_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1229 void LiftoffAssembler::emit_i8x16_max_s(LiftoffRegister dst,
1230 LiftoffRegister lhs,
1231 LiftoffRegister rhs) {
1232 bailout(kUnsupportedArchitecture, "emit_i8x16_max_s");
1233 }
1234
emit_i8x16_max_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1235 void LiftoffAssembler::emit_i8x16_max_u(LiftoffRegister dst,
1236 LiftoffRegister lhs,
1237 LiftoffRegister rhs) {
1238 bailout(kUnsupportedArchitecture, "emit_i8x16_max_u");
1239 }
1240
emit_i8x16_eq(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1241 void LiftoffAssembler::emit_i8x16_eq(LiftoffRegister dst, LiftoffRegister lhs,
1242 LiftoffRegister rhs) {
1243 bailout(kUnsupportedArchitecture, "emit_i8x16_eq");
1244 }
1245
emit_i8x16_ne(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1246 void LiftoffAssembler::emit_i8x16_ne(LiftoffRegister dst, LiftoffRegister lhs,
1247 LiftoffRegister rhs) {
1248 bailout(kUnsupportedArchitecture, "emit_i8x16_ne");
1249 }
1250
emit_i8x16_gt_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1251 void LiftoffAssembler::emit_i8x16_gt_s(LiftoffRegister dst, LiftoffRegister lhs,
1252 LiftoffRegister rhs) {
1253 bailout(kUnsupportedArchitecture, "emit_i8x16gt_s");
1254 }
1255
emit_i8x16_gt_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1256 void LiftoffAssembler::emit_i8x16_gt_u(LiftoffRegister dst, LiftoffRegister lhs,
1257 LiftoffRegister rhs) {
1258 bailout(kUnsupportedArchitecture, "emit_i8x16gt_u");
1259 }
1260
emit_i8x16_ge_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1261 void LiftoffAssembler::emit_i8x16_ge_s(LiftoffRegister dst, LiftoffRegister lhs,
1262 LiftoffRegister rhs) {
1263 bailout(kUnsupportedArchitecture, "emit_i8x16ge_s");
1264 }
1265
emit_i8x16_ge_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1266 void LiftoffAssembler::emit_i8x16_ge_u(LiftoffRegister dst, LiftoffRegister lhs,
1267 LiftoffRegister rhs) {
1268 bailout(kUnsupportedArchitecture, "emit_i8x16ge_u");
1269 }
1270
emit_i16x8_eq(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1271 void LiftoffAssembler::emit_i16x8_eq(LiftoffRegister dst, LiftoffRegister lhs,
1272 LiftoffRegister rhs) {
1273 bailout(kUnsupportedArchitecture, "emit_i16x8_eq");
1274 }
1275
emit_i16x8_ne(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1276 void LiftoffAssembler::emit_i16x8_ne(LiftoffRegister dst, LiftoffRegister lhs,
1277 LiftoffRegister rhs) {
1278 bailout(kUnsupportedArchitecture, "emit_i16x8_ne");
1279 }
1280
emit_i16x8_gt_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1281 void LiftoffAssembler::emit_i16x8_gt_s(LiftoffRegister dst, LiftoffRegister lhs,
1282 LiftoffRegister rhs) {
1283 bailout(kUnsupportedArchitecture, "emit_i16x8gt_s");
1284 }
1285
emit_i16x8_gt_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1286 void LiftoffAssembler::emit_i16x8_gt_u(LiftoffRegister dst, LiftoffRegister lhs,
1287 LiftoffRegister rhs) {
1288 bailout(kUnsupportedArchitecture, "emit_i16x8gt_u");
1289 }
1290
emit_i16x8_ge_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1291 void LiftoffAssembler::emit_i16x8_ge_s(LiftoffRegister dst, LiftoffRegister lhs,
1292 LiftoffRegister rhs) {
1293 bailout(kUnsupportedArchitecture, "emit_i16x8ge_s");
1294 }
1295
emit_i16x8_ge_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1296 void LiftoffAssembler::emit_i16x8_ge_u(LiftoffRegister dst, LiftoffRegister lhs,
1297 LiftoffRegister rhs) {
1298 bailout(kUnsupportedArchitecture, "emit_i16x8ge_u");
1299 }
1300
emit_i32x4_eq(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1301 void LiftoffAssembler::emit_i32x4_eq(LiftoffRegister dst, LiftoffRegister lhs,
1302 LiftoffRegister rhs) {
1303 bailout(kUnsupportedArchitecture, "emit_i32x4_eq");
1304 }
1305
emit_i32x4_ne(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1306 void LiftoffAssembler::emit_i32x4_ne(LiftoffRegister dst, LiftoffRegister lhs,
1307 LiftoffRegister rhs) {
1308 bailout(kUnsupportedArchitecture, "emit_i32x4_ne");
1309 }
1310
emit_i32x4_gt_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1311 void LiftoffAssembler::emit_i32x4_gt_s(LiftoffRegister dst, LiftoffRegister lhs,
1312 LiftoffRegister rhs) {
1313 bailout(kUnsupportedArchitecture, "emit_i32x4gt_s");
1314 }
1315
emit_i32x4_gt_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1316 void LiftoffAssembler::emit_i32x4_gt_u(LiftoffRegister dst, LiftoffRegister lhs,
1317 LiftoffRegister rhs) {
1318 bailout(kUnsupportedArchitecture, "emit_i32x4gt_u");
1319 }
1320
emit_i32x4_ge_s(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1321 void LiftoffAssembler::emit_i32x4_ge_s(LiftoffRegister dst, LiftoffRegister lhs,
1322 LiftoffRegister rhs) {
1323 bailout(kUnsupportedArchitecture, "emit_i32x4ge_s");
1324 }
1325
emit_i32x4_ge_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1326 void LiftoffAssembler::emit_i32x4_ge_u(LiftoffRegister dst, LiftoffRegister lhs,
1327 LiftoffRegister rhs) {
1328 bailout(kUnsupportedArchitecture, "emit_i32x4ge_u");
1329 }
1330
emit_f32x4_eq(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1331 void LiftoffAssembler::emit_f32x4_eq(LiftoffRegister dst, LiftoffRegister lhs,
1332 LiftoffRegister rhs) {
1333 bailout(kUnsupportedArchitecture, "emit_f32x4_eq");
1334 }
1335
emit_f32x4_ne(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1336 void LiftoffAssembler::emit_f32x4_ne(LiftoffRegister dst, LiftoffRegister lhs,
1337 LiftoffRegister rhs) {
1338 bailout(kUnsupportedArchitecture, "emit_f32x4_ne");
1339 }
1340
emit_f32x4_lt(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1341 void LiftoffAssembler::emit_f32x4_lt(LiftoffRegister dst, LiftoffRegister lhs,
1342 LiftoffRegister rhs) {
1343 bailout(kUnsupportedArchitecture, "emit_f32x4_lt");
1344 }
1345
emit_f32x4_le(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1346 void LiftoffAssembler::emit_f32x4_le(LiftoffRegister dst, LiftoffRegister lhs,
1347 LiftoffRegister rhs) {
1348 bailout(kUnsupportedArchitecture, "emit_f32x4_le");
1349 }
1350
emit_f64x2_eq(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1351 void LiftoffAssembler::emit_f64x2_eq(LiftoffRegister dst, LiftoffRegister lhs,
1352 LiftoffRegister rhs) {
1353 bailout(kUnsupportedArchitecture, "emit_f64x2_eq");
1354 }
1355
emit_f64x2_ne(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1356 void LiftoffAssembler::emit_f64x2_ne(LiftoffRegister dst, LiftoffRegister lhs,
1357 LiftoffRegister rhs) {
1358 bailout(kUnsupportedArchitecture, "emit_f64x2_ne");
1359 }
1360
emit_f64x2_lt(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1361 void LiftoffAssembler::emit_f64x2_lt(LiftoffRegister dst, LiftoffRegister lhs,
1362 LiftoffRegister rhs) {
1363 bailout(kUnsupportedArchitecture, "emit_f64x2_lt");
1364 }
1365
emit_f64x2_le(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1366 void LiftoffAssembler::emit_f64x2_le(LiftoffRegister dst, LiftoffRegister lhs,
1367 LiftoffRegister rhs) {
1368 bailout(kUnsupportedArchitecture, "emit_f64x2_le");
1369 }
1370
emit_s128_const(LiftoffRegister dst,const uint8_t imms[16])1371 void LiftoffAssembler::emit_s128_const(LiftoffRegister dst,
1372 const uint8_t imms[16]) {
1373 bailout(kUnsupportedArchitecture, "emit_s128_const");
1374 }
1375
emit_s128_not(LiftoffRegister dst,LiftoffRegister src)1376 void LiftoffAssembler::emit_s128_not(LiftoffRegister dst, LiftoffRegister src) {
1377 bailout(kUnsupportedArchitecture, "emit_s128_not");
1378 }
1379
emit_s128_and(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1380 void LiftoffAssembler::emit_s128_and(LiftoffRegister dst, LiftoffRegister lhs,
1381 LiftoffRegister rhs) {
1382 bailout(kUnsupportedArchitecture, "emit_s128_and");
1383 }
1384
emit_s128_or(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1385 void LiftoffAssembler::emit_s128_or(LiftoffRegister dst, LiftoffRegister lhs,
1386 LiftoffRegister rhs) {
1387 bailout(kUnsupportedArchitecture, "emit_s128_or");
1388 }
1389
emit_s128_xor(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1390 void LiftoffAssembler::emit_s128_xor(LiftoffRegister dst, LiftoffRegister lhs,
1391 LiftoffRegister rhs) {
1392 bailout(kUnsupportedArchitecture, "emit_s128_xor");
1393 }
1394
emit_s128_select(LiftoffRegister dst,LiftoffRegister src1,LiftoffRegister src2,LiftoffRegister mask)1395 void LiftoffAssembler::emit_s128_select(LiftoffRegister dst,
1396 LiftoffRegister src1,
1397 LiftoffRegister src2,
1398 LiftoffRegister mask) {
1399 bailout(kUnsupportedArchitecture, "emit_s128select");
1400 }
1401
emit_i32x4_sconvert_f32x4(LiftoffRegister dst,LiftoffRegister src)1402 void LiftoffAssembler::emit_i32x4_sconvert_f32x4(LiftoffRegister dst,
1403 LiftoffRegister src) {
1404 bailout(kSimd, "i32x4_sconvert_f32x4");
1405 }
1406
emit_i32x4_uconvert_f32x4(LiftoffRegister dst,LiftoffRegister src)1407 void LiftoffAssembler::emit_i32x4_uconvert_f32x4(LiftoffRegister dst,
1408 LiftoffRegister src) {
1409 bailout(kSimd, "i32x4_uconvert_f32x4");
1410 }
1411
emit_f32x4_sconvert_i32x4(LiftoffRegister dst,LiftoffRegister src)1412 void LiftoffAssembler::emit_f32x4_sconvert_i32x4(LiftoffRegister dst,
1413 LiftoffRegister src) {
1414 bailout(kSimd, "f32x4_sconvert_i32x4");
1415 }
1416
emit_f32x4_uconvert_i32x4(LiftoffRegister dst,LiftoffRegister src)1417 void LiftoffAssembler::emit_f32x4_uconvert_i32x4(LiftoffRegister dst,
1418 LiftoffRegister src) {
1419 bailout(kSimd, "f32x4_uconvert_i32x4");
1420 }
1421
emit_i8x16_sconvert_i16x8(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1422 void LiftoffAssembler::emit_i8x16_sconvert_i16x8(LiftoffRegister dst,
1423 LiftoffRegister lhs,
1424 LiftoffRegister rhs) {
1425 bailout(kUnsupportedArchitecture, "emit_i8x16_sconvert_i16x8");
1426 }
1427
emit_i8x16_uconvert_i16x8(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1428 void LiftoffAssembler::emit_i8x16_uconvert_i16x8(LiftoffRegister dst,
1429 LiftoffRegister lhs,
1430 LiftoffRegister rhs) {
1431 bailout(kUnsupportedArchitecture, "emit_i8x16_uconvert_i16x8");
1432 }
1433
emit_i16x8_sconvert_i32x4(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1434 void LiftoffAssembler::emit_i16x8_sconvert_i32x4(LiftoffRegister dst,
1435 LiftoffRegister lhs,
1436 LiftoffRegister rhs) {
1437 bailout(kUnsupportedArchitecture, "emit_i16x8_sconvert_i32x4");
1438 }
1439
emit_i16x8_uconvert_i32x4(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1440 void LiftoffAssembler::emit_i16x8_uconvert_i32x4(LiftoffRegister dst,
1441 LiftoffRegister lhs,
1442 LiftoffRegister rhs) {
1443 bailout(kUnsupportedArchitecture, "emit_i16x8_uconvert_i32x4");
1444 }
1445
emit_i16x8_sconvert_i8x16_low(LiftoffRegister dst,LiftoffRegister src)1446 void LiftoffAssembler::emit_i16x8_sconvert_i8x16_low(LiftoffRegister dst,
1447 LiftoffRegister src) {
1448 bailout(kUnsupportedArchitecture, "emit_i16x8_sconvert_i8x16_low");
1449 }
1450
emit_i16x8_sconvert_i8x16_high(LiftoffRegister dst,LiftoffRegister src)1451 void LiftoffAssembler::emit_i16x8_sconvert_i8x16_high(LiftoffRegister dst,
1452 LiftoffRegister src) {
1453 bailout(kUnsupportedArchitecture, "emit_i16x8_sconvert_i8x16_high");
1454 }
1455
emit_i16x8_uconvert_i8x16_low(LiftoffRegister dst,LiftoffRegister src)1456 void LiftoffAssembler::emit_i16x8_uconvert_i8x16_low(LiftoffRegister dst,
1457 LiftoffRegister src) {
1458 bailout(kUnsupportedArchitecture, "emit_i16x8_uconvert_i8x16_low");
1459 }
1460
emit_i16x8_uconvert_i8x16_high(LiftoffRegister dst,LiftoffRegister src)1461 void LiftoffAssembler::emit_i16x8_uconvert_i8x16_high(LiftoffRegister dst,
1462 LiftoffRegister src) {
1463 bailout(kUnsupportedArchitecture, "emit_i16x8_uconvert_i8x16_high");
1464 }
1465
emit_i32x4_sconvert_i16x8_low(LiftoffRegister dst,LiftoffRegister src)1466 void LiftoffAssembler::emit_i32x4_sconvert_i16x8_low(LiftoffRegister dst,
1467 LiftoffRegister src) {
1468 bailout(kUnsupportedArchitecture, "emit_i32x4_sconvert_i16x8_low");
1469 }
1470
emit_i32x4_sconvert_i16x8_high(LiftoffRegister dst,LiftoffRegister src)1471 void LiftoffAssembler::emit_i32x4_sconvert_i16x8_high(LiftoffRegister dst,
1472 LiftoffRegister src) {
1473 bailout(kUnsupportedArchitecture, "emit_i32x4_sconvert_i16x8_high");
1474 }
1475
emit_i32x4_uconvert_i16x8_low(LiftoffRegister dst,LiftoffRegister src)1476 void LiftoffAssembler::emit_i32x4_uconvert_i16x8_low(LiftoffRegister dst,
1477 LiftoffRegister src) {
1478 bailout(kUnsupportedArchitecture, "emit_i32x4_uconvert_i16x8_low");
1479 }
1480
emit_i32x4_uconvert_i16x8_high(LiftoffRegister dst,LiftoffRegister src)1481 void LiftoffAssembler::emit_i32x4_uconvert_i16x8_high(LiftoffRegister dst,
1482 LiftoffRegister src) {
1483 bailout(kUnsupportedArchitecture, "emit_i32x4_uconvert_i16x8_high");
1484 }
1485
emit_s128_and_not(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1486 void LiftoffAssembler::emit_s128_and_not(LiftoffRegister dst,
1487 LiftoffRegister lhs,
1488 LiftoffRegister rhs) {
1489 bailout(kUnsupportedArchitecture, "emit_s128_and_not");
1490 }
1491
emit_i8x16_rounding_average_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1492 void LiftoffAssembler::emit_i8x16_rounding_average_u(LiftoffRegister dst,
1493 LiftoffRegister lhs,
1494 LiftoffRegister rhs) {
1495 bailout(kUnsupportedArchitecture, "emit_i8x16_rounding_average_u");
1496 }
1497
emit_i16x8_rounding_average_u(LiftoffRegister dst,LiftoffRegister lhs,LiftoffRegister rhs)1498 void LiftoffAssembler::emit_i16x8_rounding_average_u(LiftoffRegister dst,
1499 LiftoffRegister lhs,
1500 LiftoffRegister rhs) {
1501 bailout(kUnsupportedArchitecture, "emit_i16x8_rounding_average_u");
1502 }
1503
emit_i8x16_abs(LiftoffRegister dst,LiftoffRegister src)1504 void LiftoffAssembler::emit_i8x16_abs(LiftoffRegister dst,
1505 LiftoffRegister src) {
1506 bailout(kUnsupportedArchitecture, "emit_i8x16_abs");
1507 }
1508
emit_i16x8_abs(LiftoffRegister dst,LiftoffRegister src)1509 void LiftoffAssembler::emit_i16x8_abs(LiftoffRegister dst,
1510 LiftoffRegister src) {
1511 bailout(kUnsupportedArchitecture, "emit_i16x8_abs");
1512 }
1513
emit_i32x4_abs(LiftoffRegister dst,LiftoffRegister src)1514 void LiftoffAssembler::emit_i32x4_abs(LiftoffRegister dst,
1515 LiftoffRegister src) {
1516 bailout(kUnsupportedArchitecture, "emit_i32x4_abs");
1517 }
1518
StackCheck(Label * ool_code,Register limit_address)1519 void LiftoffAssembler::StackCheck(Label* ool_code, Register limit_address) {
1520 bailout(kUnsupportedArchitecture, "StackCheck");
1521 }
1522
CallTrapCallbackForTesting()1523 void LiftoffAssembler::CallTrapCallbackForTesting() {
1524 bailout(kUnsupportedArchitecture, "CallTrapCallbackForTesting");
1525 }
1526
AssertUnreachable(AbortReason reason)1527 void LiftoffAssembler::AssertUnreachable(AbortReason reason) {
1528 bailout(kUnsupportedArchitecture, "AssertUnreachable");
1529 }
1530
PushRegisters(LiftoffRegList regs)1531 void LiftoffAssembler::PushRegisters(LiftoffRegList regs) {
1532 bailout(kUnsupportedArchitecture, "PushRegisters");
1533 }
1534
PopRegisters(LiftoffRegList regs)1535 void LiftoffAssembler::PopRegisters(LiftoffRegList regs) {
1536 bailout(kUnsupportedArchitecture, "PopRegisters");
1537 }
1538
DropStackSlotsAndRet(uint32_t num_stack_slots)1539 void LiftoffAssembler::DropStackSlotsAndRet(uint32_t num_stack_slots) {
1540 bailout(kUnsupportedArchitecture, "DropStackSlotsAndRet");
1541 }
1542
CallC(const wasm::FunctionSig * sig,const LiftoffRegister * args,const LiftoffRegister * rets,ValueType out_argument_type,int stack_bytes,ExternalReference ext_ref)1543 void LiftoffAssembler::CallC(const wasm::FunctionSig* sig,
1544 const LiftoffRegister* args,
1545 const LiftoffRegister* rets,
1546 ValueType out_argument_type, int stack_bytes,
1547 ExternalReference ext_ref) {
1548 bailout(kUnsupportedArchitecture, "CallC");
1549 }
1550
CallNativeWasmCode(Address addr)1551 void LiftoffAssembler::CallNativeWasmCode(Address addr) {
1552 bailout(kUnsupportedArchitecture, "CallNativeWasmCode");
1553 }
1554
TailCallNativeWasmCode(Address addr)1555 void LiftoffAssembler::TailCallNativeWasmCode(Address addr) {
1556 bailout(kUnsupportedArchitecture, "TailCallNativeWasmCode");
1557 }
1558
CallIndirect(const wasm::FunctionSig * sig,compiler::CallDescriptor * call_descriptor,Register target)1559 void LiftoffAssembler::CallIndirect(const wasm::FunctionSig* sig,
1560 compiler::CallDescriptor* call_descriptor,
1561 Register target) {
1562 bailout(kUnsupportedArchitecture, "CallIndirect");
1563 }
1564
TailCallIndirect(Register target)1565 void LiftoffAssembler::TailCallIndirect(Register target) {
1566 bailout(kUnsupportedArchitecture, "TailCallIndirect");
1567 }
1568
CallRuntimeStub(WasmCode::RuntimeStubId sid)1569 void LiftoffAssembler::CallRuntimeStub(WasmCode::RuntimeStubId sid) {
1570 bailout(kUnsupportedArchitecture, "CallRuntimeStub");
1571 }
1572
AllocateStackSlot(Register addr,uint32_t size)1573 void LiftoffAssembler::AllocateStackSlot(Register addr, uint32_t size) {
1574 bailout(kUnsupportedArchitecture, "AllocateStackSlot");
1575 }
1576
DeallocateStackSlot(uint32_t size)1577 void LiftoffAssembler::DeallocateStackSlot(uint32_t size) {
1578 bailout(kUnsupportedArchitecture, "DeallocateStackSlot");
1579 }
1580
Construct()1581 void LiftoffStackSlots::Construct() {
1582 asm_->bailout(kUnsupportedArchitecture, "LiftoffStackSlots::Construct");
1583 }
1584
1585 } // namespace wasm
1586 } // namespace internal
1587 } // namespace v8
1588
1589 #undef BAILOUT
1590
1591 #endif // V8_WASM_BASELINE_S390_LIFTOFF_ASSEMBLER_S390_H_
1592