]> git.proxmox.com Git - qemu.git/blame - tcg/tcg-op.h
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
TCG code generator
[qemu.git] / tcg / tcg-op.h
CommitLineData
c896fe29
FB		 1/*
2 * Tiny Code Generator for QEMU
3 *
4 * Copyright (c) 2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24#include "tcg.h"
25
26/* legacy dyngen operations */
27#include "gen-op.h"
28
29int gen_new_label(void);
30
31static inline void tcg_gen_op1(int opc, TCGArg arg1)
32{
33 *gen_opc_ptr++ = opc;
34 *gen_opparam_ptr++ = arg1;
35}
36
37static inline void tcg_gen_op2(int opc, TCGArg arg1, TCGArg arg2)
38{
39 *gen_opc_ptr++ = opc;
40 *gen_opparam_ptr++ = arg1;
41 *gen_opparam_ptr++ = arg2;
42}
43
44static inline void tcg_gen_op3(int opc, TCGArg arg1, TCGArg arg2, TCGArg arg3)
45{
46 *gen_opc_ptr++ = opc;
47 *gen_opparam_ptr++ = arg1;
48 *gen_opparam_ptr++ = arg2;
49 *gen_opparam_ptr++ = arg3;
50}
51
52static inline void tcg_gen_op4(int opc, TCGArg arg1, TCGArg arg2, TCGArg arg3,
53 TCGArg arg4)
54{
55 *gen_opc_ptr++ = opc;
56 *gen_opparam_ptr++ = arg1;
57 *gen_opparam_ptr++ = arg2;
58 *gen_opparam_ptr++ = arg3;
59 *gen_opparam_ptr++ = arg4;
60}
61
62static inline void tcg_gen_op5(int opc, TCGArg arg1, TCGArg arg2,
63 TCGArg arg3, TCGArg arg4,
64 TCGArg arg5)
65{
66 *gen_opc_ptr++ = opc;
67 *gen_opparam_ptr++ = arg1;
68 *gen_opparam_ptr++ = arg2;
69 *gen_opparam_ptr++ = arg3;
70 *gen_opparam_ptr++ = arg4;
71 *gen_opparam_ptr++ = arg5;
72}
73
74static inline void tcg_gen_op6(int opc, TCGArg arg1, TCGArg arg2,
75 TCGArg arg3, TCGArg arg4,
76 TCGArg arg5, TCGArg arg6)
77{
78 *gen_opc_ptr++ = opc;
79 *gen_opparam_ptr++ = arg1;
80 *gen_opparam_ptr++ = arg2;
81 *gen_opparam_ptr++ = arg3;
82 *gen_opparam_ptr++ = arg4;
83 *gen_opparam_ptr++ = arg5;
84 *gen_opparam_ptr++ = arg6;
85}
86
87static inline void gen_set_label(int n)
88{
89 tcg_gen_op1(INDEX_op_set_label, n);
90}
91
92static inline void tcg_gen_mov_i32(int ret, int arg)
93{
94 tcg_gen_op2(INDEX_op_mov_i32, ret, arg);
95}
96
97static inline void tcg_gen_movi_i32(int ret, int32_t arg)
98{
99 tcg_gen_op2(INDEX_op_movi_i32, ret, arg);
100}
101
102/* helper calls */
103#define TCG_HELPER_CALL_FLAGS 0
104
105static inline void tcg_gen_helper_0_0(void *func)
106{
107 tcg_gen_call(&tcg_ctx,
108 tcg_const_ptr((tcg_target_long)func), TCG_HELPER_CALL_FLAGS,
109 0, NULL, 0, NULL);
110}
111
112static inline void tcg_gen_helper_0_1(void *func, TCGArg arg)
113{
114 tcg_gen_call(&tcg_ctx,
115 tcg_const_ptr((tcg_target_long)func), TCG_HELPER_CALL_FLAGS,
116 0, NULL, 1, &arg);
117}
118
119static inline void tcg_gen_helper_0_2(void *func, TCGArg arg1, TCGArg arg2)
120{
121 TCGArg args[2];
122 args[0] = arg1;
123 args[1] = arg2;
124 tcg_gen_call(&tcg_ctx,
125 tcg_const_ptr((tcg_target_long)func), TCG_HELPER_CALL_FLAGS,
126 0, NULL, 2, args);
127}
128
129static inline void tcg_gen_helper_1_2(void *func, TCGArg ret,
130 TCGArg arg1, TCGArg arg2)
131{
132 TCGArg args[2];
133 args[0] = arg1;
134 args[1] = arg2;
135 tcg_gen_call(&tcg_ctx,
136 tcg_const_ptr((tcg_target_long)func), TCG_HELPER_CALL_FLAGS,
137 1, &ret, 2, args);
138}
139
140/* 32 bit ops */
141
142static inline void tcg_gen_ld8u_i32(int ret, int arg2, tcg_target_long offset)
143{
144 tcg_gen_op3(INDEX_op_ld8u_i32, ret, arg2, offset);
145}
146
147static inline void tcg_gen_ld8s_i32(int ret, int arg2, tcg_target_long offset)
148{
149 tcg_gen_op3(INDEX_op_ld8s_i32, ret, arg2, offset);
150}
151
152static inline void tcg_gen_ld16u_i32(int ret, int arg2, tcg_target_long offset)
153{
154 tcg_gen_op3(INDEX_op_ld16u_i32, ret, arg2, offset);
155}
156
157static inline void tcg_gen_ld16s_i32(int ret, int arg2, tcg_target_long offset)
158{
159 tcg_gen_op3(INDEX_op_ld16s_i32, ret, arg2, offset);
160}
161
162static inline void tcg_gen_ld_i32(int ret, int arg2, tcg_target_long offset)
163{
164 tcg_gen_op3(INDEX_op_ld_i32, ret, arg2, offset);
165}
166
167static inline void tcg_gen_st8_i32(int arg1, int arg2, tcg_target_long offset)
168{
169 tcg_gen_op3(INDEX_op_st8_i32, arg1, arg2, offset);
170}
171
172static inline void tcg_gen_st16_i32(int arg1, int arg2, tcg_target_long offset)
173{
174 tcg_gen_op3(INDEX_op_st16_i32, arg1, arg2, offset);
175}
176
177static inline void tcg_gen_st_i32(int arg1, int arg2, tcg_target_long offset)
178{
179 tcg_gen_op3(INDEX_op_st_i32, arg1, arg2, offset);
180}
181
182static inline void tcg_gen_add_i32(int ret, int arg1, int arg2)
183{
184 tcg_gen_op3(INDEX_op_add_i32, ret, arg1, arg2);
185}
186
187static inline void tcg_gen_addi_i32(int ret, int arg1, int32_t arg2)
188{
189 tcg_gen_add_i32(ret, arg1, tcg_const_i32(arg2));
190}
191
192static inline void tcg_gen_sub_i32(int ret, int arg1, int arg2)
193{
194 tcg_gen_op3(INDEX_op_sub_i32, ret, arg1, arg2);
195}
196
197static inline void tcg_gen_subi_i32(int ret, int arg1, int32_t arg2)
198{
199 tcg_gen_sub_i32(ret, arg1, tcg_const_i32(arg2));
200}
201
202static inline void tcg_gen_and_i32(int ret, int arg1, int arg2)
203{
204 tcg_gen_op3(INDEX_op_and_i32, ret, arg1, arg2);
205}
206
207static inline void tcg_gen_andi_i32(int ret, int arg1, int32_t arg2)
208{
209 /* some cases can be optimized here */
210 if (arg2 == 0) {
211 tcg_gen_movi_i32(ret, 0);
212 } else if (arg2 == 0xffffffff) {
213 tcg_gen_mov_i32(ret, arg1);
214 } else {
215 tcg_gen_and_i32(ret, arg1, tcg_const_i32(arg2));
216 }
217}
218
219static inline void tcg_gen_or_i32(int ret, int arg1, int arg2)
220{
221 tcg_gen_op3(INDEX_op_or_i32, ret, arg1, arg2);
222}
223
224static inline void tcg_gen_ori_i32(int ret, int arg1, int32_t arg2)
225{
226 /* some cases can be optimized here */
227 if (arg2 == 0xffffffff) {
228 tcg_gen_movi_i32(ret, 0);
229 } else if (arg2 == 0) {
230 tcg_gen_mov_i32(ret, arg1);
231 } else {
232 tcg_gen_or_i32(ret, arg1, tcg_const_i32(arg2));
233 }
234}
235
236static inline void tcg_gen_xor_i32(int ret, int arg1, int arg2)
237{
238 tcg_gen_op3(INDEX_op_xor_i32, ret, arg1, arg2);
239}
240
241static inline void tcg_gen_xori_i32(int ret, int arg1, int32_t arg2)
242{
243 /* some cases can be optimized here */
244 if (arg2 == 0) {
245 tcg_gen_mov_i32(ret, arg1);
246 } else {
247 tcg_gen_xor_i32(ret, arg1, tcg_const_i32(arg2));
248 }
249}
250
251static inline void tcg_gen_shl_i32(int ret, int arg1, int arg2)
252{
253 tcg_gen_op3(INDEX_op_shl_i32, ret, arg1, arg2);
254}
255
256static inline void tcg_gen_shli_i32(int ret, int arg1, int32_t arg2)
257{
258 tcg_gen_shl_i32(ret, arg1, tcg_const_i32(arg2));
259}
260
261static inline void tcg_gen_shr_i32(int ret, int arg1, int arg2)
262{
263 tcg_gen_op3(INDEX_op_shr_i32, ret, arg1, arg2);
264}
265
266static inline void tcg_gen_shri_i32(int ret, int arg1, int32_t arg2)
267{
268 tcg_gen_shr_i32(ret, arg1, tcg_const_i32(arg2));
269}
270
271static inline void tcg_gen_sar_i32(int ret, int arg1, int arg2)
272{
273 tcg_gen_op3(INDEX_op_sar_i32, ret, arg1, arg2);
274}
275
276static inline void tcg_gen_sari_i32(int ret, int arg1, int32_t arg2)
277{
278 tcg_gen_sar_i32(ret, arg1, tcg_const_i32(arg2));
279}
280
281static inline void tcg_gen_brcond_i32(int cond, TCGArg arg1, TCGArg arg2,
282 int label_index)
283{
284 tcg_gen_op4(INDEX_op_brcond_i32, arg1, arg2, cond, label_index);
285}
286
287static inline void tcg_gen_mul_i32(int ret, int arg1, int arg2)
288{
289 tcg_gen_op3(INDEX_op_mul_i32, ret, arg1, arg2);
290}
291
292#ifdef TCG_TARGET_HAS_div_i32
293static inline void tcg_gen_div_i32(int ret, int arg1, int arg2)
294{
295 tcg_gen_op3(INDEX_op_div_i32, ret, arg1, arg2);
296}
297
298static inline void tcg_gen_rem_i32(int ret, int arg1, int arg2)
299{
300 tcg_gen_op3(INDEX_op_rem_i32, ret, arg1, arg2);
301}
302
303static inline void tcg_gen_divu_i32(int ret, int arg1, int arg2)
304{
305 tcg_gen_op3(INDEX_op_divu_i32, ret, arg1, arg2);
306}
307
308static inline void tcg_gen_remu_i32(int ret, int arg1, int arg2)
309{
310 tcg_gen_op3(INDEX_op_remu_i32, ret, arg1, arg2);
311}
312#else
313static inline void tcg_gen_div_i32(int ret, int arg1, int arg2)
314{
315 int t0;
316 t0 = tcg_temp_new(TCG_TYPE_I32);
317 tcg_gen_sari_i32(t0, arg1, 31);
318 tcg_gen_op5(INDEX_op_div2_i32, ret, t0, arg1, t0, arg2);
319}
320
321static inline void tcg_gen_rem_i32(int ret, int arg1, int arg2)
322{
323 int t0;
324 t0 = tcg_temp_new(TCG_TYPE_I32);
325 tcg_gen_sari_i32(t0, arg1, 31);
326 tcg_gen_op5(INDEX_op_div2_i32, t0, ret, arg1, t0, arg2);
327}
328
329static inline void tcg_gen_divu_i32(int ret, int arg1, int arg2)
330{
331 int t0;
332 t0 = tcg_temp_new(TCG_TYPE_I32);
333 tcg_gen_movi_i32(t0, 0);
334 tcg_gen_op5(INDEX_op_divu2_i32, ret, t0, arg1, t0, arg2);
335}
336
337static inline void tcg_gen_remu_i32(int ret, int arg1, int arg2)
338{
339 int t0;
340 t0 = tcg_temp_new(TCG_TYPE_I32);
341 tcg_gen_movi_i32(t0, 0);
342 tcg_gen_op5(INDEX_op_divu2_i32, t0, ret, arg1, t0, arg2);
343}
344#endif
345
346#if TCG_TARGET_REG_BITS == 32
347
348static inline void tcg_gen_mov_i64(int ret, int arg)
349{
350 tcg_gen_mov_i32(ret, arg);
351 tcg_gen_mov_i32(ret + 1, arg + 1);
352}
353
354static inline void tcg_gen_movi_i64(int ret, int64_t arg)
355{
356 tcg_gen_movi_i32(ret, arg);
357 tcg_gen_movi_i32(ret + 1, arg >> 32);
358}
359
360static inline void tcg_gen_ld8u_i64(int ret, int arg2, tcg_target_long offset)
361{
362 tcg_gen_ld8u_i32(ret, arg2, offset);
363 tcg_gen_movi_i32(ret + 1, 0);
364}
365
366static inline void tcg_gen_ld8s_i64(int ret, int arg2, tcg_target_long offset)
367{
368 tcg_gen_ld8s_i32(ret, arg2, offset);
369 tcg_gen_sari_i32(ret + 1, ret, 31);
370}
371
372static inline void tcg_gen_ld16u_i64(int ret, int arg2, tcg_target_long offset)
373{
374 tcg_gen_ld16u_i32(ret, arg2, offset);
375 tcg_gen_movi_i32(ret + 1, 0);
376}
377
378static inline void tcg_gen_ld16s_i64(int ret, int arg2, tcg_target_long offset)
379{
380 tcg_gen_ld16s_i32(ret, arg2, offset);
381 tcg_gen_sari_i32(ret + 1, ret, 31);
382}
383
384static inline void tcg_gen_ld32u_i64(int ret, int arg2, tcg_target_long offset)
385{
386 tcg_gen_ld_i32(ret, arg2, offset);
387 tcg_gen_movi_i32(ret + 1, 0);
388}
389
390static inline void tcg_gen_ld32s_i64(int ret, int arg2, tcg_target_long offset)
391{
392 tcg_gen_ld_i32(ret, arg2, offset);
393 tcg_gen_sari_i32(ret + 1, ret, 31);
394}
395
396static inline void tcg_gen_ld_i64(int ret, int arg2, tcg_target_long offset)
397{
398 /* since arg2 and ret have different types, they cannot be the
399 same temporary */
400#ifdef TCG_TARGET_WORDS_BIGENDIAN
401 tcg_gen_ld_i32(ret + 1, arg2, offset);
402 tcg_gen_ld_i32(ret, arg2, offset + 4);
403#else
404 tcg_gen_ld_i32(ret, arg2, offset);
405 tcg_gen_ld_i32(ret + 1, arg2, offset + 4);
406#endif
407}
408
409static inline void tcg_gen_st8_i64(int arg1, int arg2, tcg_target_long offset)
410{
411 tcg_gen_st8_i32(arg1, arg2, offset);
412}
413
414static inline void tcg_gen_st16_i64(int arg1, int arg2, tcg_target_long offset)
415{
416 tcg_gen_st16_i32(arg1, arg2, offset);
417}
418
419static inline void tcg_gen_st32_i64(int arg1, int arg2, tcg_target_long offset)
420{
421 tcg_gen_st_i32(arg1, arg2, offset);
422}
423
424static inline void tcg_gen_st_i64(int arg1, int arg2, tcg_target_long offset)
425{
426#ifdef TCG_TARGET_WORDS_BIGENDIAN
427 tcg_gen_st_i32(arg1 + 1, arg2, offset);
428 tcg_gen_st_i32(arg1, arg2, offset + 4);
429#else
430 tcg_gen_st_i32(arg1, arg2, offset);
431 tcg_gen_st_i32(arg1 + 1, arg2, offset + 4);
432#endif
433}
434
435static inline void tcg_gen_add_i64(int ret, int arg1, int arg2)
436{
437 tcg_gen_op6(INDEX_op_add2_i32, ret, ret + 1,
438 arg1, arg1 + 1, arg2, arg2 + 1);
439}
440
441static inline void tcg_gen_addi_i64(int ret, int arg1, int64_t arg2)
442{
443 tcg_gen_add_i64(ret, arg1, tcg_const_i64(arg2));
444}
445
446static inline void tcg_gen_sub_i64(int ret, int arg1, int arg2)
447{
448 tcg_gen_op6(INDEX_op_sub2_i32, ret, ret + 1,
449 arg1, arg1 + 1, arg2, arg2 + 1);
450}
451
452static inline void tcg_gen_subi_i64(int ret, int arg1, int64_t arg2)
453{
454 tcg_gen_sub_i64(ret, arg1, tcg_const_i64(arg2));
455}
456
457static inline void tcg_gen_and_i64(int ret, int arg1, int arg2)
458{
459 tcg_gen_and_i32(ret, arg1, arg2);
460 tcg_gen_and_i32(ret + 1, arg1 + 1, arg2 + 1);
461}
462
463static inline void tcg_gen_andi_i64(int ret, int arg1, int64_t arg2)
464{
465 tcg_gen_andi_i32(ret, arg1, arg2);
466 tcg_gen_andi_i32(ret + 1, arg1 + 1, arg2 >> 32);
467}
468
469static inline void tcg_gen_or_i64(int ret, int arg1, int arg2)
470{
471 tcg_gen_or_i32(ret, arg1, arg2);
472 tcg_gen_or_i32(ret + 1, arg1 + 1, arg2 + 1);
473}
474
475static inline void tcg_gen_ori_i64(int ret, int arg1, int64_t arg2)
476{
477 tcg_gen_ori_i32(ret, arg1, arg2);
478 tcg_gen_ori_i32(ret + 1, arg1 + 1, arg2 >> 32);
479}
480
481static inline void tcg_gen_xor_i64(int ret, int arg1, int arg2)
482{
483 tcg_gen_xor_i32(ret, arg1, arg2);
484 tcg_gen_xor_i32(ret + 1, arg1 + 1, arg2 + 1);
485}
486
487static inline void tcg_gen_xori_i64(int ret, int arg1, int64_t arg2)
488{
489 tcg_gen_xori_i32(ret, arg1, arg2);
490 tcg_gen_xori_i32(ret + 1, arg1 + 1, arg2 >> 32);
491}
492
493/* XXX: use generic code when basic block handling is OK or CPU
494 specific code (x86) */
495static inline void tcg_gen_shl_i64(int ret, int arg1, int64_t arg2)
496{
497 tcg_gen_helper_1_2(tcg_helper_shl_i64, ret, arg1, arg2);
498}
499
500static inline void tcg_gen_shli_i64(int ret, int arg1, int64_t arg2)
501{
502 tcg_gen_shifti_i64(ret, arg1, arg2, 0, 0);
503}
504
505static inline void tcg_gen_shr_i64(int ret, int arg1, int64_t arg2)
506{
507 tcg_gen_helper_1_2(tcg_helper_shr_i64, ret, arg1, arg2);
508}
509
510static inline void tcg_gen_shri_i64(int ret, int arg1, int64_t arg2)
511{
512 tcg_gen_shifti_i64(ret, arg1, arg2, 1, 0);
513}
514
515static inline void tcg_gen_sar_i64(int ret, int arg1, int64_t arg2)
516{
517 tcg_gen_helper_1_2(tcg_helper_sar_i64, ret, arg1, arg2);
518}
519
520static inline void tcg_gen_sari_i64(int ret, int arg1, int64_t arg2)
521{
522 tcg_gen_shifti_i64(ret, arg1, arg2, 1, 1);
523}
524
525static inline void tcg_gen_brcond_i64(int cond, TCGArg arg1, TCGArg arg2,
526 int label_index)
527{
528 tcg_gen_op6(INDEX_op_brcond2_i32,
529 arg1, arg1 + 1, arg2, arg2 + 1, cond, label_index);
530}
531
532static inline void tcg_gen_mul_i64(int ret, int arg1, int arg2)
533{
534 int t0, t1;
535
536 t0 = tcg_temp_new(TCG_TYPE_I64);
537 t1 = tcg_temp_new(TCG_TYPE_I32);
538
539 tcg_gen_op4(INDEX_op_mulu2_i32, t0, t0 + 1, arg1, arg2);
540
541 tcg_gen_mul_i32(t1, arg1, arg2 + 1);
542 tcg_gen_add_i32(t0 + 1, t0 + 1, t1);
543 tcg_gen_mul_i32(t1, arg1 + 1, arg2);
544 tcg_gen_add_i32(t0 + 1, t0 + 1, t1);
545
546 tcg_gen_mov_i64(ret, t0);
547}
548
549static inline void tcg_gen_div_i64(int ret, int arg1, int64_t arg2)
550{
551 tcg_gen_helper_1_2(tcg_helper_div_i64, ret, arg1, arg2);
552}
553
554static inline void tcg_gen_rem_i64(int ret, int arg1, int64_t arg2)
555{
556 tcg_gen_helper_1_2(tcg_helper_rem_i64, ret, arg1, arg2);
557}
558
559static inline void tcg_gen_divu_i64(int ret, int arg1, int64_t arg2)
560{
561 tcg_gen_helper_1_2(tcg_helper_divu_i64, ret, arg1, arg2);
562}
563
564static inline void tcg_gen_remu_i64(int ret, int arg1, int64_t arg2)
565{
566 tcg_gen_helper_1_2(tcg_helper_remu_i64, ret, arg1, arg2);
567}
568
569#else
570
571static inline void tcg_gen_mov_i64(int ret, int arg)
572{
573 tcg_gen_op2(INDEX_op_mov_i64, ret, arg);
574}
575
576static inline void tcg_gen_movi_i64(int ret, int64_t arg)
577{
578 tcg_gen_op2(INDEX_op_movi_i64, ret, arg);
579}
580
581static inline void tcg_gen_ld8u_i64(int ret, int arg2, tcg_target_long offset)
582{
583 tcg_gen_op3(INDEX_op_ld8u_i64, ret, arg2, offset);
584}
585
586static inline void tcg_gen_ld8s_i64(int ret, int arg2, tcg_target_long offset)
587{
588 tcg_gen_op3(INDEX_op_ld8s_i64, ret, arg2, offset);
589}
590
591static inline void tcg_gen_ld16u_i64(int ret, int arg2, tcg_target_long offset)
592{
593 tcg_gen_op3(INDEX_op_ld16u_i64, ret, arg2, offset);
594}
595
596static inline void tcg_gen_ld16s_i64(int ret, int arg2, tcg_target_long offset)
597{
598 tcg_gen_op3(INDEX_op_ld16s_i64, ret, arg2, offset);
599}
600
601static inline void tcg_gen_ld32u_i64(int ret, int arg2, tcg_target_long offset)
602{
603 tcg_gen_op3(INDEX_op_ld32u_i64, ret, arg2, offset);
604}
605
606static inline void tcg_gen_ld32s_i64(int ret, int arg2, tcg_target_long offset)
607{
608 tcg_gen_op3(INDEX_op_ld32s_i64, ret, arg2, offset);
609}
610
611static inline void tcg_gen_ld_i64(int ret, int arg2, tcg_target_long offset)
612{
613 tcg_gen_op3(INDEX_op_ld_i64, ret, arg2, offset);
614}
615
616static inline void tcg_gen_st8_i64(int arg1, int arg2, tcg_target_long offset)
617{
618 tcg_gen_op3(INDEX_op_st8_i64, arg1, arg2, offset);
619}
620
621static inline void tcg_gen_st16_i64(int arg1, int arg2, tcg_target_long offset)
622{
623 tcg_gen_op3(INDEX_op_st16_i64, arg1, arg2, offset);
624}
625
626static inline void tcg_gen_st32_i64(int arg1, int arg2, tcg_target_long offset)
627{
628 tcg_gen_op3(INDEX_op_st32_i64, arg1, arg2, offset);
629}
630
631static inline void tcg_gen_st_i64(int arg1, int arg2, tcg_target_long offset)
632{
633 tcg_gen_op3(INDEX_op_st_i64, arg1, arg2, offset);
634}
635
636static inline void tcg_gen_add_i64(int ret, int arg1, int arg2)
637{
638 tcg_gen_op3(INDEX_op_add_i64, ret, arg1, arg2);
639}
640
641static inline void tcg_gen_addi_i64(int ret, int arg1, int64_t arg2)
642{
643 tcg_gen_add_i64(ret, arg1, tcg_const_i64(arg2));
644}
645
646static inline void tcg_gen_sub_i64(int ret, int arg1, int arg2)
647{
648 tcg_gen_op3(INDEX_op_sub_i64, ret, arg1, arg2);
649}
650
651static inline void tcg_gen_subi_i64(int ret, int arg1, int64_t arg2)
652{
653 tcg_gen_sub_i64(ret, arg1, tcg_const_i64(arg2));
654}
655
656static inline void tcg_gen_and_i64(int ret, int arg1, int arg2)
657{
658 tcg_gen_op3(INDEX_op_and_i64, ret, arg1, arg2);
659}
660
661static inline void tcg_gen_andi_i64(int ret, int arg1, int64_t arg2)
662{
663 tcg_gen_and_i64(ret, arg1, tcg_const_i64(arg2));
664}
665
666static inline void tcg_gen_or_i64(int ret, int arg1, int arg2)
667{
668 tcg_gen_op3(INDEX_op_or_i64, ret, arg1, arg2);
669}
670
671static inline void tcg_gen_ori_i64(int ret, int arg1, int64_t arg2)
672{
673 tcg_gen_or_i64(ret, arg1, tcg_const_i64(arg2));
674}
675
676static inline void tcg_gen_xor_i64(int ret, int arg1, int arg2)
677{
678 tcg_gen_op3(INDEX_op_xor_i64, ret, arg1, arg2);
679}
680
681static inline void tcg_gen_xori_i64(int ret, int arg1, int64_t arg2)
682{
683 tcg_gen_xor_i64(ret, arg1, tcg_const_i64(arg2));
684}
685
686static inline void tcg_gen_shl_i64(int ret, int arg1, int arg2)
687{
688 tcg_gen_op3(INDEX_op_shl_i64, ret, arg1, arg2);
689}
690
691static inline void tcg_gen_shli_i64(int ret, int arg1, int64_t arg2)
692{
693 tcg_gen_shl_i64(ret, arg1, tcg_const_i64(arg2));
694}
695
696static inline void tcg_gen_shr_i64(int ret, int arg1, int arg2)
697{
698 tcg_gen_op3(INDEX_op_shr_i64, ret, arg1, arg2);
699}
700
701static inline void tcg_gen_shri_i64(int ret, int arg1, int64_t arg2)
702{
703 tcg_gen_shr_i64(ret, arg1, tcg_const_i64(arg2));
704}
705
706static inline void tcg_gen_sar_i64(int ret, int arg1, int arg2)
707{
708 tcg_gen_op3(INDEX_op_sar_i64, ret, arg1, arg2);
709}
710
711static inline void tcg_gen_sari_i64(int ret, int arg1, int64_t arg2)
712{
713 tcg_gen_sar_i64(ret, arg1, tcg_const_i64(arg2));
714}
715
716static inline void tcg_gen_brcond_i64(int cond, TCGArg arg1, TCGArg arg2,
717 int label_index)
718{
719 tcg_gen_op4(INDEX_op_brcond_i64, arg1, arg2, cond, label_index);
720}
721
722static inline void tcg_gen_mul_i64(int ret, int arg1, int arg2)
723{
724 tcg_gen_op3(INDEX_op_mul_i64, ret, arg1, arg2);
725}
726
727#ifdef TCG_TARGET_HAS_div_i64
728static inline void tcg_gen_div_i64(int ret, int arg1, int arg2)
729{
730 tcg_gen_op3(INDEX_op_div_i64, ret, arg1, arg2);
731}
732
733static inline void tcg_gen_rem_i64(int ret, int arg1, int arg2)
734{
735 tcg_gen_op3(INDEX_op_rem_i64, ret, arg1, arg2);
736}
737
738static inline void tcg_gen_divu_i64(int ret, int arg1, int arg2)
739{
740 tcg_gen_op3(INDEX_op_divu_i64, ret, arg1, arg2);
741}
742
743static inline void tcg_gen_remu_i64(int ret, int arg1, int arg2)
744{
745 tcg_gen_op3(INDEX_op_remu_i64, ret, arg1, arg2);
746}
747#else
748static inline void tcg_gen_div_i64(int ret, int arg1, int arg2)
749{
750 int t0;
751 t0 = tcg_temp_new(TCG_TYPE_I64);
752 tcg_gen_sari_i64(t0, arg1, 63);
753 tcg_gen_op5(INDEX_op_div2_i64, ret, t0, arg1, t0, arg2);
754}
755
756static inline void tcg_gen_rem_i64(int ret, int arg1, int arg2)
757{
758 int t0;
759 t0 = tcg_temp_new(TCG_TYPE_I64);
760 tcg_gen_sari_i64(t0, arg1, 63);
761 tcg_gen_op5(INDEX_op_div2_i64, t0, ret, arg1, t0, arg2);
762}
763
764static inline void tcg_gen_divu_i64(int ret, int arg1, int arg2)
765{
766 int t0;
767 t0 = tcg_temp_new(TCG_TYPE_I64);
768 tcg_gen_movi_i64(t0, 0);
769 tcg_gen_op5(INDEX_op_divu2_i64, ret, t0, arg1, t0, arg2);
770}
771
772static inline void tcg_gen_remu_i64(int ret, int arg1, int arg2)
773{
774 int t0;
775 t0 = tcg_temp_new(TCG_TYPE_I64);
776 tcg_gen_movi_i64(t0, 0);
777 tcg_gen_op5(INDEX_op_divu2_i64, t0, ret, arg1, t0, arg2);
778}
779#endif
780
781#endif
782
783/***************************************/
784/* optional operations */
785
786static inline void tcg_gen_ext8s_i32(int ret, int arg)
787{
788#ifdef TCG_TARGET_HAS_ext8s_i32
789 tcg_gen_op2(INDEX_op_ext8s_i32, ret, arg);
790#else
791 tcg_gen_shli_i32(ret, arg, 24);
792 tcg_gen_sari_i32(ret, arg, 24);
793#endif
794}
795
796static inline void tcg_gen_ext16s_i32(int ret, int arg)
797{
798#ifdef TCG_TARGET_HAS_ext16s_i32
799 tcg_gen_op2(INDEX_op_ext16s_i32, ret, arg);
800#else
801 tcg_gen_shli_i32(ret, arg, 16);
802 tcg_gen_sari_i32(ret, arg, 16);
803#endif
804}
805
806/* Note: we assume the two high bytes are set to zero */
807static inline void tcg_gen_bswap16_i32(TCGArg ret, TCGArg arg)
808{
809#ifdef TCG_TARGET_HAS_bswap16_i32
810 tcg_gen_op2(INDEX_op_bswap16_i32, ret, arg);
811#else
812 TCGArg t0, t1;
813 t0 = tcg_temp_new(TCG_TYPE_I32);
814 t1 = tcg_temp_new(TCG_TYPE_I32);
815
816 tcg_gen_shri_i32(t0, arg, 8);
817 tcg_gen_andi_i32(t1, arg, 0x000000ff);
818 tcg_gen_shli_i32(t1, t1, 8);
819 tcg_gen_or_i32(ret, t0, t1);
820#endif
821}
822
823static inline void tcg_gen_bswap_i32(TCGArg ret, TCGArg arg)
824{
825#ifdef TCG_TARGET_HAS_bswap_i32
826 tcg_gen_op2(INDEX_op_bswap_i32, ret, arg);
827#else
828 TCGArg t0, t1;
829 t0 = tcg_temp_new(TCG_TYPE_I32);
830 t1 = tcg_temp_new(TCG_TYPE_I32);
831
832 tcg_gen_shli_i32(t0, arg, 24);
833
834 tcg_gen_andi_i32(t1, arg, 0x0000ff00);
835 tcg_gen_shli_i32(t1, t1, 8);
836 tcg_gen_or_i32(t0, t0, t1);
837
838 tcg_gen_shri_i32(t1, arg, 8);
839 tcg_gen_andi_i32(t1, t1, 0x0000ff00);
840 tcg_gen_or_i32(t0, t0, t1);
841
842 tcg_gen_shri_i32(t1, arg, 24);
843 tcg_gen_or_i32(ret, t0, t1);
844#endif
845}
846
847#if TCG_TARGET_REG_BITS == 32
848static inline void tcg_gen_ext8s_i64(int ret, int arg)
849{
850 tcg_gen_ext8s_i32(ret, arg);
851 tcg_gen_sari_i32(ret + 1, ret, 31);
852}
853
854static inline void tcg_gen_ext16s_i64(int ret, int arg)
855{
856 tcg_gen_ext16s_i32(ret, arg);
857 tcg_gen_sari_i32(ret + 1, ret, 31);
858}
859
860static inline void tcg_gen_ext32s_i64(int ret, int arg)
861{
862 tcg_gen_mov_i32(ret, arg);
863 tcg_gen_sari_i32(ret + 1, ret, 31);
864}
865
866static inline void tcg_gen_trunc_i64_i32(int ret, int arg)
867{
868 tcg_gen_mov_i32(ret, arg);
869}
870
871static inline void tcg_gen_extu_i32_i64(int ret, int arg)
872{
873 tcg_gen_mov_i32(ret, arg);
874 tcg_gen_movi_i32(ret + 1, 0);
875}
876
877static inline void tcg_gen_ext_i32_i64(int ret, int arg)
878{
879 tcg_gen_mov_i32(ret, arg);
880 tcg_gen_sari_i32(ret + 1, ret, 31);
881}
882
883static inline void tcg_gen_bswap_i64(int ret, int arg)
884{
885 int t0, t1;
886 t0 = tcg_temp_new(TCG_TYPE_I32);
887 t1 = tcg_temp_new(TCG_TYPE_I32);
888
889 tcg_gen_bswap_i32(t0, arg);
890 tcg_gen_bswap_i32(t1, arg + 1);
891 tcg_gen_mov_i32(ret, t1);
892 tcg_gen_mov_i32(ret + 1, t0);
893}
894#else
895
896static inline void tcg_gen_ext8s_i64(int ret, int arg)
897{
898#ifdef TCG_TARGET_HAS_ext8s_i64
899 tcg_gen_op2(INDEX_op_ext8s_i64, ret, arg);
900#else
901 tcg_gen_shli_i64(ret, arg, 56);
902 tcg_gen_sari_i64(ret, arg, 56);
903#endif
904}
905
906static inline void tcg_gen_ext16s_i64(int ret, int arg)
907{
908#ifdef TCG_TARGET_HAS_ext16s_i64
909 tcg_gen_op2(INDEX_op_ext16s_i64, ret, arg);
910#else
911 tcg_gen_shli_i64(ret, arg, 48);
912 tcg_gen_sari_i64(ret, arg, 48);
913#endif
914}
915
916static inline void tcg_gen_ext32s_i64(int ret, int arg)
917{
918#ifdef TCG_TARGET_HAS_ext32s_i64
919 tcg_gen_op2(INDEX_op_ext32s_i64, ret, arg);
920#else
921 tcg_gen_shli_i64(ret, arg, 32);
922 tcg_gen_sari_i64(ret, arg, 32);
923#endif
924}
925
926/* Note: we assume the target supports move between 32 and 64 bit
927 registers */
928static inline void tcg_gen_trunc_i64_i32(int ret, int arg)
929{
930 tcg_gen_mov_i32(ret, arg);
931}
932
933/* Note: we assume the target supports move between 32 and 64 bit
934 registers */
935static inline void tcg_gen_extu_i32_i64(int ret, int arg)
936{
937 tcg_gen_andi_i64(ret, arg, 0xffffffff);
938}
939
940/* Note: we assume the target supports move between 32 and 64 bit
941 registers */
942static inline void tcg_gen_ext_i32_i64(int ret, int arg)
943{
944 tcg_gen_ext32s_i64(ret, arg);
945}
946
947static inline void tcg_gen_bswap_i64(TCGArg ret, TCGArg arg)
948{
949#ifdef TCG_TARGET_HAS_bswap_i64
950 tcg_gen_op2(INDEX_op_bswap_i64, ret, arg);
951#else
952 TCGArg t0, t1;
953 t0 = tcg_temp_new(TCG_TYPE_I32);
954 t1 = tcg_temp_new(TCG_TYPE_I32);
955
956 tcg_gen_shli_i64(t0, arg, 56);
957
958 tcg_gen_andi_i64(t1, arg, 0x0000ff00);
959 tcg_gen_shli_i64(t1, t1, 40);
960 tcg_gen_or_i64(t0, t0, t1);
961
962 tcg_gen_andi_i64(t1, arg, 0x00ff0000);
963 tcg_gen_shli_i64(t1, t1, 24);
964 tcg_gen_or_i64(t0, t0, t1);
965
966 tcg_gen_andi_i64(t1, arg, 0xff000000);
967 tcg_gen_shli_i64(t1, t1, 8);
968 tcg_gen_or_i64(t0, t0, t1);
969
970 tcg_gen_shri_i64(t1, arg, 8);
971 tcg_gen_andi_i64(t1, t1, 0xff000000);
972 tcg_gen_or_i64(t0, t0, t1);
973
974 tcg_gen_shri_i64(t1, arg, 24);
975 tcg_gen_andi_i64(t1, t1, 0x00ff0000);
976 tcg_gen_or_i64(t0, t0, t1);
977
978 tcg_gen_shri_i64(t1, arg, 40);
979 tcg_gen_andi_i64(t1, t1, 0x0000ff00);
980 tcg_gen_or_i64(t0, t0, t1);
981
982 tcg_gen_shri_i64(t1, arg, 56);
983 tcg_gen_or_i64(ret, t0, t1);
984#endif
985}
986
987#endif
988
989/***************************************/
990static inline void tcg_gen_macro_2(int ret0, int ret1, int macro_id)
991{
992 tcg_gen_op3(INDEX_op_macro_2, ret0, ret1, macro_id);
993}
994
995/***************************************/
996/* QEMU specific operations. Their type depend on the QEMU CPU
997 type. */
998#ifndef TARGET_LONG_BITS
999#error must include QEMU headers
1000#endif
1001
1002static inline void tcg_gen_exit_tb(tcg_target_long val)
1003{
1004 tcg_gen_op1(INDEX_op_exit_tb, val);
1005}
1006
1007static inline void tcg_gen_goto_tb(int idx)
1008{
1009 tcg_gen_op1(INDEX_op_goto_tb, idx);
1010}
1011
1012#if TCG_TARGET_REG_BITS == 32
1013static inline void tcg_gen_qemu_ld8u(int ret, int addr, int mem_index)
1014{
1015#if TARGET_LONG_BITS == 32
1016 tcg_gen_op3(INDEX_op_qemu_ld8u, ret, addr, mem_index);
1017#else
1018 tcg_gen_op4(INDEX_op_qemu_ld8u, ret, addr, addr + 1, mem_index);
1019 tcg_gen_movi_i32(ret + 1, 0);
1020#endif
1021}
1022
1023static inline void tcg_gen_qemu_ld8s(int ret, int addr, int mem_index)
1024{
1025#if TARGET_LONG_BITS == 32
1026 tcg_gen_op3(INDEX_op_qemu_ld8s, ret, addr, mem_index);
1027#else
1028 tcg_gen_op4(INDEX_op_qemu_ld8s, ret, addr, addr + 1, mem_index);
1029 tcg_gen_ext8s_i32(ret + 1, ret);
1030#endif
1031}
1032
1033static inline void tcg_gen_qemu_ld16u(int ret, int addr, int mem_index)
1034{
1035#if TARGET_LONG_BITS == 32
1036 tcg_gen_op3(INDEX_op_qemu_ld16u, ret, addr, mem_index);
1037#else
1038 tcg_gen_op4(INDEX_op_qemu_ld16u, ret, addr, addr + 1, mem_index);
1039 tcg_gen_movi_i32(ret + 1, 0);
1040#endif
1041}
1042
1043static inline void tcg_gen_qemu_ld16s(int ret, int addr, int mem_index)
1044{
1045#if TARGET_LONG_BITS == 32
1046 tcg_gen_op3(INDEX_op_qemu_ld16s, ret, addr, mem_index);
1047#else
1048 tcg_gen_op4(INDEX_op_qemu_ld16s, ret, addr, addr + 1, mem_index);
1049 tcg_gen_ext16s_i32(ret + 1, ret);
1050#endif
1051}
1052
1053static inline void tcg_gen_qemu_ld32u(int ret, int addr, int mem_index)
1054{
1055#if TARGET_LONG_BITS == 32
1056 tcg_gen_op3(INDEX_op_qemu_ld32u, ret, addr, mem_index);
1057#else
1058 tcg_gen_op4(INDEX_op_qemu_ld32u, ret, addr, addr + 1, mem_index);
1059 tcg_gen_movi_i32(ret + 1, 0);
1060#endif
1061}
1062
1063static inline void tcg_gen_qemu_ld32s(int ret, int addr, int mem_index)
1064{
1065#if TARGET_LONG_BITS == 32
1066 tcg_gen_op3(INDEX_op_qemu_ld32u, ret, addr, mem_index);
1067#else
1068 tcg_gen_op4(INDEX_op_qemu_ld32u, ret, addr, addr + 1, mem_index);
1069 tcg_gen_sari_i32(ret + 1, ret, 31);
1070#endif
1071}
1072
1073static inline void tcg_gen_qemu_ld64(int ret, int addr, int mem_index)
1074{
1075#if TARGET_LONG_BITS == 32
1076 tcg_gen_op4(INDEX_op_qemu_ld64, ret, ret + 1, addr, mem_index);
1077#else
1078 tcg_gen_op5(INDEX_op_qemu_ld64, ret, ret + 1, addr, addr + 1, mem_index);
1079#endif
1080}
1081
1082static inline void tcg_gen_qemu_st8(int arg, int addr, int mem_index)
1083{
1084#if TARGET_LONG_BITS == 32
1085 tcg_gen_op3(INDEX_op_qemu_st8, arg, addr, mem_index);
1086#else
1087 tcg_gen_op4(INDEX_op_qemu_st8, arg, addr, addr + 1, mem_index);
1088#endif
1089}
1090
1091static inline void tcg_gen_qemu_st16(int arg, int addr, int mem_index)
1092{
1093#if TARGET_LONG_BITS == 32
1094 tcg_gen_op3(INDEX_op_qemu_st16, arg, addr, mem_index);
1095#else
1096 tcg_gen_op4(INDEX_op_qemu_st16, arg, addr, addr + 1, mem_index);
1097#endif
1098}
1099
1100static inline void tcg_gen_qemu_st32(int arg, int addr, int mem_index)
1101{
1102#if TARGET_LONG_BITS == 32
1103 tcg_gen_op3(INDEX_op_qemu_st32, arg, addr, mem_index);
1104#else
1105 tcg_gen_op4(INDEX_op_qemu_st32, arg, addr, addr + 1, mem_index);
1106#endif
1107}
1108
1109static inline void tcg_gen_qemu_st64(int arg, int addr, int mem_index)
1110{
1111#if TARGET_LONG_BITS == 32
1112 tcg_gen_op4(INDEX_op_qemu_st64, arg, arg + 1, addr, mem_index);
1113#else
1114 tcg_gen_op5(INDEX_op_qemu_st64, arg, arg + 1, addr, addr + 1, mem_index);
1115#endif
1116}
1117
1118#else /* TCG_TARGET_REG_BITS == 32 */
1119
1120static inline void tcg_gen_qemu_ld8u(int ret, int addr, int mem_index)
1121{
1122 tcg_gen_op3(INDEX_op_qemu_ld8u, ret, addr, mem_index);
1123}
1124
1125static inline void tcg_gen_qemu_ld8s(int ret, int addr, int mem_index)
1126{
1127 tcg_gen_op3(INDEX_op_qemu_ld8s, ret, addr, mem_index);
1128}
1129
1130static inline void tcg_gen_qemu_ld16u(int ret, int addr, int mem_index)
1131{
1132 tcg_gen_op3(INDEX_op_qemu_ld16u, ret, addr, mem_index);
1133}
1134
1135static inline void tcg_gen_qemu_ld16s(int ret, int addr, int mem_index)
1136{
1137 tcg_gen_op3(INDEX_op_qemu_ld16s, ret, addr, mem_index);
1138}
1139
1140static inline void tcg_gen_qemu_ld32u(int ret, int addr, int mem_index)
1141{
1142 tcg_gen_op3(INDEX_op_qemu_ld32u, ret, addr, mem_index);
1143}
1144
1145static inline void tcg_gen_qemu_ld32s(int ret, int addr, int mem_index)
1146{
1147 tcg_gen_op3(INDEX_op_qemu_ld32s, ret, addr, mem_index);
1148}
1149
1150static inline void tcg_gen_qemu_ld64(int ret, int addr, int mem_index)
1151{
1152 tcg_gen_op3(INDEX_op_qemu_ld64, ret, addr, mem_index);
1153}
1154
1155static inline void tcg_gen_qemu_st8(int arg, int addr, int mem_index)
1156{
1157 tcg_gen_op3(INDEX_op_qemu_st8, arg, addr, mem_index);
1158}
1159
1160static inline void tcg_gen_qemu_st16(int arg, int addr, int mem_index)
1161{
1162 tcg_gen_op3(INDEX_op_qemu_st16, arg, addr, mem_index);
1163}
1164
1165static inline void tcg_gen_qemu_st32(int arg, int addr, int mem_index)
1166{
1167 tcg_gen_op3(INDEX_op_qemu_st32, arg, addr, mem_index);
1168}
1169
1170static inline void tcg_gen_qemu_st64(int arg, int addr, int mem_index)
1171{
1172 tcg_gen_op3(INDEX_op_qemu_st64, arg, addr, mem_index);
1173}
1174
1175#endif /* TCG_TARGET_REG_BITS != 32 */
Qemu copy for testing