V8 API Reference, 7.2.502.16 (for Deno 0.2.4)
liftoff-assembler-s390.h
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 #define BAILOUT(reason) bailout("s390 " reason)
11 
12 namespace v8 {
13 namespace internal {
14 namespace wasm {
15 
16 int LiftoffAssembler::PrepareStackFrame() {
17  BAILOUT("PrepareStackFrame");
18  return 0;
19 }
20 
21 void LiftoffAssembler::PatchPrepareStackFrame(int offset,
22  uint32_t stack_slots) {
23  BAILOUT("PatchPrepareStackFrame");
24 }
25 
26 void LiftoffAssembler::FinishCode() {}
27 
28 void LiftoffAssembler::AbortCompilation() {}
29 
30 void LiftoffAssembler::LoadConstant(LiftoffRegister reg, WasmValue value,
31  RelocInfo::Mode rmode) {
32  BAILOUT("LoadConstant");
33 }
34 
35 void LiftoffAssembler::LoadFromInstance(Register dst, uint32_t offset,
36  int size) {
37  BAILOUT("LoadFromInstance");
38 }
39 
40 void LiftoffAssembler::SpillInstance(Register instance) {
41  BAILOUT("SpillInstance");
42 }
43 
44 void LiftoffAssembler::FillInstanceInto(Register dst) {
45  BAILOUT("FillInstanceInto");
46 }
47 
48 void LiftoffAssembler::Load(LiftoffRegister dst, Register src_addr,
49  Register offset_reg, uint32_t offset_imm,
50  LoadType type, LiftoffRegList pinned,
51  uint32_t* protected_load_pc, bool is_load_mem) {
52  BAILOUT("Load");
53 }
54 
55 void LiftoffAssembler::Store(Register dst_addr, Register offset_reg,
56  uint32_t offset_imm, LiftoffRegister src,
57  StoreType type, LiftoffRegList pinned,
58  uint32_t* protected_store_pc, bool is_store_mem) {
59  BAILOUT("Store");
60 }
61 
62 void LiftoffAssembler::LoadCallerFrameSlot(LiftoffRegister dst,
63  uint32_t caller_slot_idx,
64  ValueType type) {
65  BAILOUT("LoadCallerFrameSlot");
66 }
67 
68 void LiftoffAssembler::MoveStackValue(uint32_t dst_index, uint32_t src_index,
69  ValueType type) {
70  BAILOUT("MoveStackValue");
71 }
72 
73 void LiftoffAssembler::Move(Register dst, Register src, ValueType type) {
74  BAILOUT("Move Register");
75 }
76 
77 void LiftoffAssembler::Move(DoubleRegister dst, DoubleRegister src,
78  ValueType type) {
79  BAILOUT("Move DoubleRegister");
80 }
81 
82 void LiftoffAssembler::Spill(uint32_t index, LiftoffRegister reg,
83  ValueType type) {
84  BAILOUT("Spill register");
85 }
86 
87 void LiftoffAssembler::Spill(uint32_t index, WasmValue value) {
88  BAILOUT("Spill value");
89 }
90 
91 void LiftoffAssembler::Fill(LiftoffRegister reg, uint32_t index,
92  ValueType type) {
93  BAILOUT("Fill");
94 }
95 
96 void LiftoffAssembler::FillI64Half(Register, uint32_t half_index) {
97  BAILOUT("FillI64Half");
98 }
99 
100 #define UNIMPLEMENTED_GP_BINOP(name) \
101  void LiftoffAssembler::emit_##name(Register dst, Register lhs, \
102  Register rhs) { \
103  BAILOUT("gp binop: " #name); \
104  }
105 #define UNIMPLEMENTED_I64_BINOP(name) \
106  void LiftoffAssembler::emit_##name(LiftoffRegister dst, LiftoffRegister lhs, \
107  LiftoffRegister rhs) { \
108  BAILOUT("i64 binop: " #name); \
109  }
110 #define UNIMPLEMENTED_GP_UNOP(name) \
111  bool LiftoffAssembler::emit_##name(Register dst, Register src) { \
112  BAILOUT("gp unop: " #name); \
113  return true; \
114  }
115 #define UNIMPLEMENTED_FP_BINOP(name) \
116  void LiftoffAssembler::emit_##name(DoubleRegister dst, DoubleRegister lhs, \
117  DoubleRegister rhs) { \
118  BAILOUT("fp binop: " #name); \
119  }
120 #define UNIMPLEMENTED_FP_UNOP(name) \
121  void LiftoffAssembler::emit_##name(DoubleRegister dst, DoubleRegister src) { \
122  BAILOUT("fp unop: " #name); \
123  }
124 #define UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(name) \
125  bool LiftoffAssembler::emit_##name(DoubleRegister dst, DoubleRegister src) { \
126  BAILOUT("fp unop: " #name); \
127  return true; \
128  }
129 #define UNIMPLEMENTED_I32_SHIFTOP(name) \
130  void LiftoffAssembler::emit_##name(Register dst, Register src, \
131  Register amount, LiftoffRegList pinned) { \
132  BAILOUT("i32 shiftop: " #name); \
133  }
134 #define UNIMPLEMENTED_I64_SHIFTOP(name) \
135  void LiftoffAssembler::emit_##name(LiftoffRegister dst, LiftoffRegister src, \
136  Register amount, LiftoffRegList pinned) { \
137  BAILOUT("i64 shiftop: " #name); \
138  }
139 
140 UNIMPLEMENTED_GP_BINOP(i32_add)
141 UNIMPLEMENTED_GP_BINOP(i32_sub)
142 UNIMPLEMENTED_GP_BINOP(i32_mul)
143 UNIMPLEMENTED_GP_BINOP(i32_and)
144 UNIMPLEMENTED_GP_BINOP(i32_or)
145 UNIMPLEMENTED_GP_BINOP(i32_xor)
146 UNIMPLEMENTED_I32_SHIFTOP(i32_shl)
147 UNIMPLEMENTED_I32_SHIFTOP(i32_sar)
148 UNIMPLEMENTED_I32_SHIFTOP(i32_shr)
149 UNIMPLEMENTED_I64_BINOP(i64_add)
150 UNIMPLEMENTED_I64_BINOP(i64_sub)
151 UNIMPLEMENTED_I64_BINOP(i64_mul)
152 #ifdef V8_TARGET_ARCH_S390X
153 UNIMPLEMENTED_I64_BINOP(i64_and)
154 UNIMPLEMENTED_I64_BINOP(i64_or)
155 UNIMPLEMENTED_I64_BINOP(i64_xor)
156 #endif
157 UNIMPLEMENTED_I64_SHIFTOP(i64_shl)
158 UNIMPLEMENTED_I64_SHIFTOP(i64_sar)
159 UNIMPLEMENTED_I64_SHIFTOP(i64_shr)
160 UNIMPLEMENTED_GP_UNOP(i32_clz)
161 UNIMPLEMENTED_GP_UNOP(i32_ctz)
162 UNIMPLEMENTED_GP_UNOP(i32_popcnt)
163 UNIMPLEMENTED_FP_BINOP(f32_add)
164 UNIMPLEMENTED_FP_BINOP(f32_sub)
165 UNIMPLEMENTED_FP_BINOP(f32_mul)
166 UNIMPLEMENTED_FP_BINOP(f32_div)
167 UNIMPLEMENTED_FP_BINOP(f32_min)
168 UNIMPLEMENTED_FP_BINOP(f32_max)
169 UNIMPLEMENTED_FP_BINOP(f32_copysign)
170 UNIMPLEMENTED_FP_UNOP(f32_abs)
171 UNIMPLEMENTED_FP_UNOP(f32_neg)
172 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f32_ceil)
173 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f32_floor)
174 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f32_trunc)
175 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f32_nearest_int)
176 UNIMPLEMENTED_FP_UNOP(f32_sqrt)
177 UNIMPLEMENTED_FP_BINOP(f64_add)
178 UNIMPLEMENTED_FP_BINOP(f64_sub)
179 UNIMPLEMENTED_FP_BINOP(f64_mul)
180 UNIMPLEMENTED_FP_BINOP(f64_div)
181 UNIMPLEMENTED_FP_BINOP(f64_min)
182 UNIMPLEMENTED_FP_BINOP(f64_max)
183 UNIMPLEMENTED_FP_BINOP(f64_copysign)
184 UNIMPLEMENTED_FP_UNOP(f64_abs)
185 UNIMPLEMENTED_FP_UNOP(f64_neg)
186 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f64_ceil)
187 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f64_floor)
188 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f64_trunc)
189 UNIMPLEMENTED_FP_UNOP_RETURN_TRUE(f64_nearest_int)
190 UNIMPLEMENTED_FP_UNOP(f64_sqrt)
191 
192 #undef UNIMPLEMENTED_GP_BINOP
193 #undef UNIMPLEMENTED_I64_BINOP
194 #undef UNIMPLEMENTED_GP_UNOP
195 #undef UNIMPLEMENTED_FP_BINOP
196 #undef UNIMPLEMENTED_FP_UNOP
197 #undef UNIMPLEMENTED_FP_UNOP_RETURN_TRUE
198 #undef UNIMPLEMENTED_I32_SHIFTOP
199 #undef UNIMPLEMENTED_I64_SHIFTOP
200 
201 void LiftoffAssembler::emit_i32_divs(Register dst, Register lhs, Register rhs,
202  Label* trap_div_by_zero,
203  Label* trap_div_unrepresentable) {
204  BAILOUT("i32_divs");
205 }
206 
207 void LiftoffAssembler::emit_i32_divu(Register dst, Register lhs, Register rhs,
208  Label* trap_div_by_zero) {
209  BAILOUT("i32_divu");
210 }
211 
212 void LiftoffAssembler::emit_i32_rems(Register dst, Register lhs, Register rhs,
213  Label* trap_div_by_zero) {
214  BAILOUT("i32_rems");
215 }
216 
217 void LiftoffAssembler::emit_i32_remu(Register dst, Register lhs, Register rhs,
218  Label* trap_div_by_zero) {
219  BAILOUT("i32_remu");
220 }
221 
222 void LiftoffAssembler::emit_i32_shr(Register dst, Register lhs, int amount) {
223  BAILOUT("i32_shr");
224 }
225 
226 bool LiftoffAssembler::emit_i64_divs(LiftoffRegister dst, LiftoffRegister lhs,
227  LiftoffRegister rhs,
228  Label* trap_div_by_zero,
229  Label* trap_div_unrepresentable) {
230  BAILOUT("i64_divs");
231  return true;
232 }
233 
234 bool LiftoffAssembler::emit_i64_divu(LiftoffRegister dst, LiftoffRegister lhs,
235  LiftoffRegister rhs,
236  Label* trap_div_by_zero) {
237  BAILOUT("i64_divu");
238  return true;
239 }
240 
241 bool LiftoffAssembler::emit_i64_rems(LiftoffRegister dst, LiftoffRegister lhs,
242  LiftoffRegister rhs,
243  Label* trap_div_by_zero) {
244  BAILOUT("i64_rems");
245  return true;
246 }
247 
248 bool LiftoffAssembler::emit_i64_remu(LiftoffRegister dst, LiftoffRegister lhs,
249  LiftoffRegister rhs,
250  Label* trap_div_by_zero) {
251  BAILOUT("i64_remu");
252  return true;
253 }
254 
255 void LiftoffAssembler::emit_i64_shr(LiftoffRegister dst, LiftoffRegister lhs,
256  int amount) {
257  BAILOUT("i64_shr");
258 }
259 
260 void LiftoffAssembler::emit_i32_to_intptr(Register dst, Register src) {
261 #ifdef V8_TARGET_ARCH_S390X
262  BAILOUT("emit_i32_to_intptr");
263 #else
264 // This is a nop on s390.
265 #endif
266 }
267 
268 bool LiftoffAssembler::emit_type_conversion(WasmOpcode opcode,
269  LiftoffRegister dst,
270  LiftoffRegister src, Label* trap) {
271  BAILOUT("emit_type_conversion");
272  return true;
273 }
274 
275 void LiftoffAssembler::emit_i32_signextend_i8(Register dst, Register src) {
276  BAILOUT("emit_i32_signextend_i8");
277 }
278 
279 void LiftoffAssembler::emit_i32_signextend_i16(Register dst, Register src) {
280  BAILOUT("emit_i32_signextend_i16");
281 }
282 
283 void LiftoffAssembler::emit_i64_signextend_i8(LiftoffRegister dst,
284  LiftoffRegister src) {
285  BAILOUT("emit_i64_signextend_i8");
286 }
287 
288 void LiftoffAssembler::emit_i64_signextend_i16(LiftoffRegister dst,
289  LiftoffRegister src) {
290  BAILOUT("emit_i64_signextend_i16");
291 }
292 
293 void LiftoffAssembler::emit_i64_signextend_i32(LiftoffRegister dst,
294  LiftoffRegister src) {
295  BAILOUT("emit_i64_signextend_i32");
296 }
297 
298 void LiftoffAssembler::emit_jump(Label* label) { BAILOUT("emit_jump"); }
299 
300 void LiftoffAssembler::emit_jump(Register target) { BAILOUT("emit_jump"); }
301 
302 void LiftoffAssembler::emit_cond_jump(Condition cond, Label* label,
303  ValueType type, Register lhs,
304  Register rhs) {
305  BAILOUT("emit_cond_jump");
306 }
307 
308 void LiftoffAssembler::emit_i32_eqz(Register dst, Register src) {
309  BAILOUT("emit_i32_eqz");
310 }
311 
312 void LiftoffAssembler::emit_i32_set_cond(Condition cond, Register dst,
313  Register lhs, Register rhs) {
314  BAILOUT("emit_i32_set_cond");
315 }
316 
317 void LiftoffAssembler::emit_i64_eqz(Register dst, LiftoffRegister src) {
318  BAILOUT("emit_i64_eqz");
319 }
320 
321 void LiftoffAssembler::emit_i64_set_cond(Condition cond, Register dst,
322  LiftoffRegister lhs,
323  LiftoffRegister rhs) {
324  BAILOUT("emit_i64_set_cond");
325 }
326 
327 void LiftoffAssembler::emit_f32_set_cond(Condition cond, Register dst,
328  DoubleRegister lhs,
329  DoubleRegister rhs) {
330  BAILOUT("emit_f32_set_cond");
331 }
332 
333 void LiftoffAssembler::emit_f64_set_cond(Condition cond, Register dst,
334  DoubleRegister lhs,
335  DoubleRegister rhs) {
336  BAILOUT("emit_f64_set_cond");
337 }
338 
339 void LiftoffAssembler::StackCheck(Label* ool_code, Register limit_address) {
340  BAILOUT("StackCheck");
341 }
342 
343 void LiftoffAssembler::CallTrapCallbackForTesting() {
344  BAILOUT("CallTrapCallbackForTesting");
345 }
346 
347 void LiftoffAssembler::AssertUnreachable(AbortReason reason) {
348  BAILOUT("AssertUnreachable");
349 }
350 
351 void LiftoffAssembler::PushRegisters(LiftoffRegList regs) {
352  BAILOUT("PushRegisters");
353 }
354 
355 void LiftoffAssembler::PopRegisters(LiftoffRegList regs) {
356  BAILOUT("PopRegisters");
357 }
358 
359 void LiftoffAssembler::DropStackSlotsAndRet(uint32_t num_stack_slots) {
360  BAILOUT("DropStackSlotsAndRet");
361 }
362 
363 void LiftoffAssembler::CallC(wasm::FunctionSig* sig,
364  const LiftoffRegister* args,
365  const LiftoffRegister* rets,
366  ValueType out_argument_type, int stack_bytes,
367  ExternalReference ext_ref) {
368  BAILOUT("CallC");
369 }
370 
371 void LiftoffAssembler::CallNativeWasmCode(Address addr) {
372  BAILOUT("CallNativeWasmCode");
373 }
374 
375 void LiftoffAssembler::CallIndirect(wasm::FunctionSig* sig,
376  compiler::CallDescriptor* call_descriptor,
377  Register target) {
378  BAILOUT("CallIndirect");
379 }
380 
381 void LiftoffAssembler::CallRuntimeStub(WasmCode::RuntimeStubId sid) {
382  BAILOUT("CallRuntimeStub");
383 }
384 
385 void LiftoffAssembler::AllocateStackSlot(Register addr, uint32_t size) {
386  BAILOUT("AllocateStackSlot");
387 }
388 
389 void LiftoffAssembler::DeallocateStackSlot(uint32_t size) {
390  BAILOUT("DeallocateStackSlot");
391 }
392 
393 void LiftoffStackSlots::Construct() {
394  asm_->BAILOUT("LiftoffStackSlots::Construct");
395 }
396 
397 } // namespace wasm
398 } // namespace internal
399 } // namespace v8
400 
401 #undef BAILOUT
402 
403 #endif // V8_WASM_BASELINE_S390_LIFTOFF_ASSEMBLER_S390_H_
v8
Definition: libplatform.h:13
uint32_t