2 * Tiny Code Generator for QEMU
4 * Copyright (c) 2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
26 static const char * const tcg_target_reg_names
[TCG_TARGET_NB_REGS
] = {
38 static const int tcg_target_reg_alloc_order
[] = {
48 static const int tcg_target_call_iarg_regs
[3] = { TCG_REG_EAX
, TCG_REG_EDX
, TCG_REG_ECX
};
49 static const int tcg_target_call_oarg_regs
[2] = { TCG_REG_EAX
, TCG_REG_EDX
};
51 static uint8_t *tb_ret_addr
;
53 static void patch_reloc(uint8_t *code_ptr
, int type
,
54 tcg_target_long value
, tcg_target_long addend
)
59 *(uint32_t *)code_ptr
= value
;
62 *(uint32_t *)code_ptr
= value
- (long)code_ptr
;
65 value
-= (long)code_ptr
;
66 if (value
!= (int8_t)value
) {
69 *(uint8_t *)code_ptr
= value
;
76 /* maximum number of register used for input function arguments */
77 static inline int tcg_target_get_call_iarg_regs_count(int flags
)
79 flags
&= TCG_CALL_TYPE_MASK
;
81 case TCG_CALL_TYPE_STD
:
83 case TCG_CALL_TYPE_REGPARM_1
:
84 case TCG_CALL_TYPE_REGPARM_2
:
85 case TCG_CALL_TYPE_REGPARM
:
86 return flags
- TCG_CALL_TYPE_REGPARM_1
+ 1;
92 /* parse target specific constraints */
93 static int target_parse_constraint(TCGArgConstraint
*ct
, const char **pct_str
)
100 ct
->ct
|= TCG_CT_REG
;
101 tcg_regset_set_reg(ct
->u
.regs
, TCG_REG_EAX
);
104 ct
->ct
|= TCG_CT_REG
;
105 tcg_regset_set_reg(ct
->u
.regs
, TCG_REG_EBX
);
108 ct
->ct
|= TCG_CT_REG
;
109 tcg_regset_set_reg(ct
->u
.regs
, TCG_REG_ECX
);
112 ct
->ct
|= TCG_CT_REG
;
113 tcg_regset_set_reg(ct
->u
.regs
, TCG_REG_EDX
);
116 ct
->ct
|= TCG_CT_REG
;
117 tcg_regset_set_reg(ct
->u
.regs
, TCG_REG_ESI
);
120 ct
->ct
|= TCG_CT_REG
;
121 tcg_regset_set_reg(ct
->u
.regs
, TCG_REG_EDI
);
124 ct
->ct
|= TCG_CT_REG
;
125 tcg_regset_set32(ct
->u
.regs
, 0, 0xf);
128 ct
->ct
|= TCG_CT_REG
;
129 tcg_regset_set32(ct
->u
.regs
, 0, 0xff);
132 /* qemu_ld/st address constraint */
134 ct
->ct
|= TCG_CT_REG
;
135 tcg_regset_set32(ct
->u
.regs
, 0, 0xff);
136 tcg_regset_reset_reg(ct
->u
.regs
, TCG_REG_EAX
);
137 tcg_regset_reset_reg(ct
->u
.regs
, TCG_REG_EDX
);
147 /* test if a constant matches the constraint */
148 static inline int tcg_target_const_match(tcg_target_long val
,
149 const TCGArgConstraint
*arg_ct
)
153 if (ct
& TCG_CT_CONST
)
159 #define P_EXT 0x100 /* 0x0f opcode prefix */
160 #define P_DATA16 0x200 /* 0x66 opcode prefix */
162 #define OPC_ARITH_EvIz (0x81)
163 #define OPC_ARITH_EvIb (0x83)
164 #define OPC_ARITH_GvEv (0x03) /* ... plus (ARITH_FOO << 3) */
165 #define OPC_ADD_GvEv (OPC_ARITH_GvEv | (ARITH_ADD << 3))
166 #define OPC_BSWAP (0xc8 | P_EXT)
167 #define OPC_CALL_Jz (0xe8)
168 #define OPC_CMP_GvEv (OPC_ARITH_GvEv | (ARITH_CMP << 3))
169 #define OPC_DEC_r32 (0x48)
170 #define OPC_IMUL_GvEv (0xaf | P_EXT)
171 #define OPC_IMUL_GvEvIb (0x6b)
172 #define OPC_IMUL_GvEvIz (0x69)
173 #define OPC_INC_r32 (0x40)
174 #define OPC_JCC_long (0x80 | P_EXT) /* ... plus condition code */
175 #define OPC_JCC_short (0x70) /* ... plus condition code */
176 #define OPC_JMP_long (0xe9)
177 #define OPC_JMP_short (0xeb)
178 #define OPC_LEA (0x8d)
179 #define OPC_MOVB_EvGv (0x88) /* stores, more or less */
180 #define OPC_MOVL_EvGv (0x89) /* stores, more or less */
181 #define OPC_MOVL_GvEv (0x8b) /* loads, more or less */
182 #define OPC_MOVL_Iv (0xb8)
183 #define OPC_MOVSBL (0xbe | P_EXT)
184 #define OPC_MOVSWL (0xbf | P_EXT)
185 #define OPC_MOVZBL (0xb6 | P_EXT)
186 #define OPC_MOVZWL (0xb7 | P_EXT)
187 #define OPC_POP_r32 (0x58)
188 #define OPC_PUSH_r32 (0x50)
189 #define OPC_PUSH_Iv (0x68)
190 #define OPC_PUSH_Ib (0x6a)
191 #define OPC_RET (0xc3)
192 #define OPC_SETCC (0x90 | P_EXT) /* ... plus condition code */
193 #define OPC_SHIFT_1 (0xd1)
194 #define OPC_SHIFT_Ib (0xc1)
195 #define OPC_SHIFT_cl (0xd3)
196 #define OPC_TESTL (0x85)
197 #define OPC_XCHG_ax_r32 (0x90)
199 #define OPC_GRP3_Ev (0xf7)
200 #define OPC_GRP5 (0xff)
202 /* Group 1 opcode extensions for 0x80-0x83.
203 These are also used as modifiers for OPC_ARITH. */
213 /* Group 2 opcode extensions for 0xc0, 0xc1, 0xd0-0xd3. */
220 /* Group 3 opcode extensions for 0xf6, 0xf7. To be used with OPC_GRP3. */
228 /* Group 5 opcode extensions for 0xff. To be used with OPC_GRP5. */
229 #define EXT5_CALLN_Ev 2
230 #define EXT5_JMPN_Ev 4
232 /* Condition codes to be added to OPC_JCC_{long,short}. */
251 static const uint8_t tcg_cond_to_jcc
[10] = {
252 [TCG_COND_EQ
] = JCC_JE
,
253 [TCG_COND_NE
] = JCC_JNE
,
254 [TCG_COND_LT
] = JCC_JL
,
255 [TCG_COND_GE
] = JCC_JGE
,
256 [TCG_COND_LE
] = JCC_JLE
,
257 [TCG_COND_GT
] = JCC_JG
,
258 [TCG_COND_LTU
] = JCC_JB
,
259 [TCG_COND_GEU
] = JCC_JAE
,
260 [TCG_COND_LEU
] = JCC_JBE
,
261 [TCG_COND_GTU
] = JCC_JA
,
264 static inline void tcg_out_opc(TCGContext
*s
, int opc
)
266 if (opc
& P_DATA16
) {
275 static inline void tcg_out_modrm(TCGContext
*s
, int opc
, int r
, int rm
)
278 tcg_out8(s
, 0xc0 | (r
<< 3) | rm
);
281 /* Output an opcode with a full "rm + (index<<shift) + offset" address mode.
282 We handle either RM and INDEX missing with a -1 value. */
284 static void tcg_out_modrm_sib_offset(TCGContext
*s
, int opc
, int r
, int rm
,
285 int index
, int shift
, int32_t offset
)
289 if (index
== -1 && rm
== -1) {
290 /* Absolute address. */
292 tcg_out8(s
, (r
<< 3) | 5);
293 tcg_out32(s
, offset
);
299 /* Find the length of the immediate addend. Note that the encoding
300 that would be used for (%ebp) indicates absolute addressing. */
302 mod
= 0, len
= 4, rm
= 5;
303 } else if (offset
== 0 && rm
!= TCG_REG_EBP
) {
305 } else if (offset
== (int8_t)offset
) {
311 /* Use a single byte MODRM format if possible. Note that the encoding
312 that would be used for %esp is the escape to the two byte form. */
313 if (index
== -1 && rm
!= TCG_REG_ESP
) {
314 /* Single byte MODRM format. */
315 tcg_out8(s
, mod
| (r
<< 3) | rm
);
317 /* Two byte MODRM+SIB format. */
319 /* Note that the encoding that would place %esp into the index
320 field indicates no index register. */
324 assert(index
!= TCG_REG_ESP
);
327 tcg_out8(s
, mod
| (r
<< 3) | 4);
328 tcg_out8(s
, (shift
<< 6) | (index
<< 3) | rm
);
333 } else if (len
== 4) {
334 tcg_out32(s
, offset
);
338 /* rm == -1 means no register index */
339 static inline void tcg_out_modrm_offset(TCGContext
*s
, int opc
, int r
, int rm
,
342 tcg_out_modrm_sib_offset(s
, opc
, r
, rm
, -1, 0, offset
);
345 /* Generate dest op= src. Uses the same ARITH_* codes as tgen_arithi. */
346 static inline void tgen_arithr(TCGContext
*s
, int subop
, int dest
, int src
)
348 tcg_out_modrm(s
, OPC_ARITH_GvEv
+ (subop
<< 3), dest
, src
);
351 static inline void tcg_out_mov(TCGContext
*s
, int ret
, int arg
)
354 tcg_out_modrm(s
, OPC_MOVL_GvEv
, ret
, arg
);
358 static inline void tcg_out_movi(TCGContext
*s
, TCGType type
,
359 int ret
, int32_t arg
)
362 tgen_arithr(s
, ARITH_XOR
, ret
, ret
);
364 tcg_out8(s
, OPC_MOVL_Iv
+ ret
);
369 static inline void tcg_out_pushi(TCGContext
*s
, tcg_target_long val
)
371 if (val
== (int8_t)val
) {
372 tcg_out_opc(s
, OPC_PUSH_Ib
);
375 tcg_out_opc(s
, OPC_PUSH_Iv
);
380 static inline void tcg_out_push(TCGContext
*s
, int reg
)
382 tcg_out_opc(s
, OPC_PUSH_r32
+ reg
);
385 static inline void tcg_out_pop(TCGContext
*s
, int reg
)
387 tcg_out_opc(s
, OPC_POP_r32
+ reg
);
390 static inline void tcg_out_ld(TCGContext
*s
, TCGType type
, int ret
,
391 int arg1
, tcg_target_long arg2
)
393 tcg_out_modrm_offset(s
, OPC_MOVL_GvEv
, ret
, arg1
, arg2
);
396 static inline void tcg_out_st(TCGContext
*s
, TCGType type
, int arg
,
397 int arg1
, tcg_target_long arg2
)
399 tcg_out_modrm_offset(s
, OPC_MOVL_EvGv
, arg
, arg1
, arg2
);
402 static void tcg_out_shifti(TCGContext
*s
, int subopc
, int reg
, int count
)
404 /* Propagate an opcode prefix, such as P_DATA16. */
405 int ext
= subopc
& ~0x7;
409 tcg_out_modrm(s
, OPC_SHIFT_1
| ext
, subopc
, reg
);
411 tcg_out_modrm(s
, OPC_SHIFT_Ib
| ext
, subopc
, reg
);
416 static inline void tcg_out_bswap32(TCGContext
*s
, int reg
)
418 tcg_out_opc(s
, OPC_BSWAP
+ reg
);
421 static inline void tcg_out_rolw_8(TCGContext
*s
, int reg
)
423 tcg_out_shifti(s
, SHIFT_ROL
| P_DATA16
, reg
, 8);
426 static inline void tcg_out_ext8u(TCGContext
*s
, int dest
, int src
)
430 tcg_out_modrm(s
, OPC_MOVZBL
, dest
, src
);
433 static void tcg_out_ext8s(TCGContext
*s
, int dest
, int src
)
437 tcg_out_modrm(s
, OPC_MOVSBL
, dest
, src
);
440 static inline void tcg_out_ext16u(TCGContext
*s
, int dest
, int src
)
443 tcg_out_modrm(s
, OPC_MOVZWL
, dest
, src
);
446 static inline void tcg_out_ext16s(TCGContext
*s
, int dest
, int src
)
449 tcg_out_modrm(s
, OPC_MOVSWL
, dest
, src
);
452 static inline void tgen_arithi(TCGContext
*s
, int c
, int r0
,
455 /* ??? While INC is 2 bytes shorter than ADDL $1, they also induce
456 partial flags update stalls on Pentium4 and are not recommended
457 by current Intel optimization manuals. */
458 if (!cf
&& (c
== ARITH_ADD
|| c
== ARITH_SUB
) && (val
== 1 || val
== -1)) {
459 int opc
= ((c
== ARITH_ADD
) ^ (val
< 0) ? OPC_INC_r32
: OPC_DEC_r32
);
460 tcg_out_opc(s
, opc
+ r0
);
461 } else if (val
== (int8_t)val
) {
462 tcg_out_modrm(s
, OPC_ARITH_EvIb
, c
, r0
);
464 } else if (c
== ARITH_AND
&& val
== 0xffu
&& r0
< 4) {
465 tcg_out_ext8u(s
, r0
, r0
);
466 } else if (c
== ARITH_AND
&& val
== 0xffffu
) {
467 tcg_out_ext16u(s
, r0
, r0
);
469 tcg_out_modrm(s
, OPC_ARITH_EvIz
, c
, r0
);
474 static void tcg_out_addi(TCGContext
*s
, int reg
, tcg_target_long val
)
477 tgen_arithi(s
, ARITH_ADD
, reg
, val
, 0);
480 /* Use SMALL != 0 to force a short forward branch. */
481 static void tcg_out_jxx(TCGContext
*s
, int opc
, int label_index
, int small
)
484 TCGLabel
*l
= &s
->labels
[label_index
];
487 val
= l
->u
.value
- (tcg_target_long
)s
->code_ptr
;
489 if ((int8_t)val1
== val1
) {
491 tcg_out8(s
, OPC_JMP_short
);
493 tcg_out8(s
, OPC_JCC_short
+ opc
);
501 tcg_out8(s
, OPC_JMP_long
);
502 tcg_out32(s
, val
- 5);
504 tcg_out_opc(s
, OPC_JCC_long
+ opc
);
505 tcg_out32(s
, val
- 6);
510 tcg_out8(s
, OPC_JMP_short
);
512 tcg_out8(s
, OPC_JCC_short
+ opc
);
514 tcg_out_reloc(s
, s
->code_ptr
, R_386_PC8
, label_index
, -1);
518 tcg_out8(s
, OPC_JMP_long
);
520 tcg_out_opc(s
, OPC_JCC_long
+ opc
);
522 tcg_out_reloc(s
, s
->code_ptr
, R_386_PC32
, label_index
, -4);
527 static void tcg_out_cmp(TCGContext
*s
, TCGArg arg1
, TCGArg arg2
,
533 tcg_out_modrm(s
, OPC_TESTL
, arg1
, arg1
);
535 tgen_arithi(s
, ARITH_CMP
, arg1
, arg2
, 0);
538 tgen_arithr(s
, ARITH_CMP
, arg1
, arg2
);
542 static void tcg_out_brcond(TCGContext
*s
, TCGCond cond
,
543 TCGArg arg1
, TCGArg arg2
, int const_arg2
,
544 int label_index
, int small
)
546 tcg_out_cmp(s
, arg1
, arg2
, const_arg2
);
547 tcg_out_jxx(s
, tcg_cond_to_jcc
[cond
], label_index
, small
);
550 /* XXX: we implement it at the target level to avoid having to
551 handle cross basic blocks temporaries */
552 static void tcg_out_brcond2(TCGContext
*s
, const TCGArg
*args
,
553 const int *const_args
, int small
)
556 label_next
= gen_new_label();
559 tcg_out_brcond(s
, TCG_COND_NE
, args
[0], args
[2], const_args
[2],
561 tcg_out_brcond(s
, TCG_COND_EQ
, args
[1], args
[3], const_args
[3],
565 tcg_out_brcond(s
, TCG_COND_NE
, args
[0], args
[2], const_args
[2],
567 tcg_out_brcond(s
, TCG_COND_NE
, args
[1], args
[3], const_args
[3],
571 tcg_out_brcond(s
, TCG_COND_LT
, args
[1], args
[3], const_args
[3],
573 tcg_out_jxx(s
, JCC_JNE
, label_next
, 1);
574 tcg_out_brcond(s
, TCG_COND_LTU
, args
[0], args
[2], const_args
[2],
578 tcg_out_brcond(s
, TCG_COND_LT
, args
[1], args
[3], const_args
[3],
580 tcg_out_jxx(s
, JCC_JNE
, label_next
, 1);
581 tcg_out_brcond(s
, TCG_COND_LEU
, args
[0], args
[2], const_args
[2],
585 tcg_out_brcond(s
, TCG_COND_GT
, args
[1], args
[3], const_args
[3],
587 tcg_out_jxx(s
, JCC_JNE
, label_next
, 1);
588 tcg_out_brcond(s
, TCG_COND_GTU
, args
[0], args
[2], const_args
[2],
592 tcg_out_brcond(s
, TCG_COND_GT
, args
[1], args
[3], const_args
[3],
594 tcg_out_jxx(s
, JCC_JNE
, label_next
, 1);
595 tcg_out_brcond(s
, TCG_COND_GEU
, args
[0], args
[2], const_args
[2],
599 tcg_out_brcond(s
, TCG_COND_LTU
, args
[1], args
[3], const_args
[3],
601 tcg_out_jxx(s
, JCC_JNE
, label_next
, 1);
602 tcg_out_brcond(s
, TCG_COND_LTU
, args
[0], args
[2], const_args
[2],
606 tcg_out_brcond(s
, TCG_COND_LTU
, args
[1], args
[3], const_args
[3],
608 tcg_out_jxx(s
, JCC_JNE
, label_next
, 1);
609 tcg_out_brcond(s
, TCG_COND_LEU
, args
[0], args
[2], const_args
[2],
613 tcg_out_brcond(s
, TCG_COND_GTU
, args
[1], args
[3], const_args
[3],
615 tcg_out_jxx(s
, JCC_JNE
, label_next
, 1);
616 tcg_out_brcond(s
, TCG_COND_GTU
, args
[0], args
[2], const_args
[2],
620 tcg_out_brcond(s
, TCG_COND_GTU
, args
[1], args
[3], const_args
[3],
622 tcg_out_jxx(s
, JCC_JNE
, label_next
, 1);
623 tcg_out_brcond(s
, TCG_COND_GEU
, args
[0], args
[2], const_args
[2],
629 tcg_out_label(s
, label_next
, (tcg_target_long
)s
->code_ptr
);
632 static void tcg_out_setcond(TCGContext
*s
, TCGCond cond
, TCGArg dest
,
633 TCGArg arg1
, TCGArg arg2
, int const_arg2
)
635 tcg_out_cmp(s
, arg1
, arg2
, const_arg2
);
636 tcg_out_modrm(s
, OPC_SETCC
| tcg_cond_to_jcc
[cond
], 0, dest
);
637 tcg_out_ext8u(s
, dest
, dest
);
640 static void tcg_out_setcond2(TCGContext
*s
, const TCGArg
*args
,
641 const int *const_args
)
644 int label_true
, label_over
;
646 memcpy(new_args
, args
+1, 5*sizeof(TCGArg
));
648 if (args
[0] == args
[1] || args
[0] == args
[2]
649 || (!const_args
[3] && args
[0] == args
[3])
650 || (!const_args
[4] && args
[0] == args
[4])) {
651 /* When the destination overlaps with one of the argument
652 registers, don't do anything tricky. */
653 label_true
= gen_new_label();
654 label_over
= gen_new_label();
656 new_args
[5] = label_true
;
657 tcg_out_brcond2(s
, new_args
, const_args
+1, 1);
659 tcg_out_movi(s
, TCG_TYPE_I32
, args
[0], 0);
660 tcg_out_jxx(s
, JCC_JMP
, label_over
, 1);
661 tcg_out_label(s
, label_true
, (tcg_target_long
)s
->code_ptr
);
663 tcg_out_movi(s
, TCG_TYPE_I32
, args
[0], 1);
664 tcg_out_label(s
, label_over
, (tcg_target_long
)s
->code_ptr
);
666 /* When the destination does not overlap one of the arguments,
667 clear the destination first, jump if cond false, and emit an
668 increment in the true case. This results in smaller code. */
670 tcg_out_movi(s
, TCG_TYPE_I32
, args
[0], 0);
672 label_over
= gen_new_label();
673 new_args
[4] = tcg_invert_cond(new_args
[4]);
674 new_args
[5] = label_over
;
675 tcg_out_brcond2(s
, new_args
, const_args
+1, 1);
677 tgen_arithi(s
, ARITH_ADD
, args
[0], 1, 0);
678 tcg_out_label(s
, label_over
, (tcg_target_long
)s
->code_ptr
);
682 static void tcg_out_calli(TCGContext
*s
, tcg_target_long dest
)
684 tcg_out_opc(s
, OPC_CALL_Jz
);
685 tcg_out32(s
, dest
- (tcg_target_long
)s
->code_ptr
- 4);
688 #if defined(CONFIG_SOFTMMU)
690 #include "../../softmmu_defs.h"
692 static void *qemu_ld_helpers
[4] = {
699 static void *qemu_st_helpers
[4] = {
706 /* Perform the TLB load and compare.
709 ADDRLO_IDX contains the index into ARGS of the low part of the
710 address; the high part of the address is at ADDR_LOW_IDX+1.
712 MEM_INDEX and S_BITS are the memory context and log2 size of the load.
714 WHICH is the offset into the CPUTLBEntry structure of the slot to read.
715 This should be offsetof addr_read or addr_write.
718 LABEL_PTRS is filled with 1 (32-bit addresses) or 2 (64-bit addresses)
719 positions of the displacements of forward jumps to the TLB miss case.
721 EAX is loaded with the low part of the address. In the TLB hit case,
722 it has been adjusted as indicated by the TLB and so is a host address.
723 In the TLB miss case, it continues to hold a guest address.
727 static void tcg_out_tlb_load(TCGContext
*s
, int addrlo_idx
, int mem_index
,
728 int s_bits
, const TCGArg
*args
,
729 uint8_t **label_ptr
, int which
)
731 const int addrlo
= args
[addrlo_idx
];
732 const int r0
= TCG_REG_EAX
;
733 const int r1
= TCG_REG_EDX
;
735 tcg_out_mov(s
, r1
, addrlo
);
736 tcg_out_mov(s
, r0
, addrlo
);
738 tcg_out_shifti(s
, SHIFT_SHR
, r1
, TARGET_PAGE_BITS
- CPU_TLB_ENTRY_BITS
);
740 tgen_arithi(s
, ARITH_AND
, r0
, TARGET_PAGE_MASK
| ((1 << s_bits
) - 1), 0);
741 tgen_arithi(s
, ARITH_AND
, r1
, (CPU_TLB_SIZE
- 1) << CPU_TLB_ENTRY_BITS
, 0);
743 tcg_out_modrm_sib_offset(s
, OPC_LEA
, r1
, TCG_AREG0
, r1
, 0,
744 offsetof(CPUState
, tlb_table
[mem_index
][0])
748 tcg_out_modrm_offset(s
, OPC_CMP_GvEv
, r0
, r1
, 0);
750 tcg_out_mov(s
, r0
, addrlo
);
753 tcg_out8(s
, OPC_JCC_short
+ JCC_JNE
);
754 label_ptr
[0] = s
->code_ptr
;
757 if (TARGET_LONG_BITS
== 64) {
758 /* cmp 4(r1), addrhi */
759 tcg_out_modrm_offset(s
, OPC_CMP_GvEv
, args
[addrlo_idx
+1], r1
, 4);
762 tcg_out8(s
, OPC_JCC_short
+ JCC_JNE
);
763 label_ptr
[1] = s
->code_ptr
;
769 /* add addend(r1), r0 */
770 tcg_out_modrm_offset(s
, OPC_ADD_GvEv
, r0
, r1
,
771 offsetof(CPUTLBEntry
, addend
) - which
);
775 static void tcg_out_qemu_ld_direct(TCGContext
*s
, int datalo
, int datahi
,
776 int base
, tcg_target_long ofs
, int sizeop
)
778 #ifdef TARGET_WORDS_BIGENDIAN
786 tcg_out_modrm_offset(s
, OPC_MOVZBL
, datalo
, base
, ofs
);
790 tcg_out_modrm_offset(s
, OPC_MOVSBL
, datalo
, base
, ofs
);
794 tcg_out_modrm_offset(s
, OPC_MOVZWL
, datalo
, base
, ofs
);
796 tcg_out_rolw_8(s
, datalo
);
801 tcg_out_modrm_offset(s
, OPC_MOVSWL
, datalo
, base
, ofs
);
803 tcg_out_rolw_8(s
, datalo
);
804 tcg_out_modrm(s
, OPC_MOVSWL
, datalo
, datalo
);
808 tcg_out_ld(s
, TCG_TYPE_I32
, datalo
, base
, ofs
);
810 tcg_out_bswap32(s
, datalo
);
819 if (base
!= datalo
) {
820 tcg_out_ld(s
, TCG_TYPE_I32
, datalo
, base
, ofs
);
821 tcg_out_ld(s
, TCG_TYPE_I32
, datahi
, base
, ofs
+ 4);
823 tcg_out_ld(s
, TCG_TYPE_I32
, datahi
, base
, ofs
+ 4);
824 tcg_out_ld(s
, TCG_TYPE_I32
, datalo
, base
, ofs
);
827 tcg_out_bswap32(s
, datalo
);
828 tcg_out_bswap32(s
, datahi
);
836 /* XXX: qemu_ld and qemu_st could be modified to clobber only EDX and
837 EAX. It will be useful once fixed registers globals are less
839 static void tcg_out_qemu_ld(TCGContext
*s
, const TCGArg
*args
,
842 int data_reg
, data_reg2
= 0;
844 #if defined(CONFIG_SOFTMMU)
845 int mem_index
, s_bits
;
846 uint8_t *label_ptr
[3];
856 #if defined(CONFIG_SOFTMMU)
857 mem_index
= args
[addrlo_idx
+ (TARGET_LONG_BITS
/ 32)];
860 tcg_out_tlb_load(s
, addrlo_idx
, mem_index
, s_bits
, args
,
861 label_ptr
, offsetof(CPUTLBEntry
, addr_read
));
864 tcg_out_qemu_ld_direct(s
, data_reg
, data_reg2
, TCG_REG_EAX
, 0, opc
);
867 tcg_out8(s
, OPC_JMP_short
);
868 label_ptr
[2] = s
->code_ptr
;
874 *label_ptr
[0] = s
->code_ptr
- label_ptr
[0] - 1;
875 if (TARGET_LONG_BITS
== 64) {
876 *label_ptr
[1] = s
->code_ptr
- label_ptr
[1] - 1;
879 /* XXX: move that code at the end of the TB */
880 #if TARGET_LONG_BITS == 32
881 tcg_out_movi(s
, TCG_TYPE_I32
, TCG_REG_EDX
, mem_index
);
883 tcg_out_mov(s
, TCG_REG_EDX
, args
[addrlo_idx
+ 1]);
884 tcg_out_movi(s
, TCG_TYPE_I32
, TCG_REG_ECX
, mem_index
);
886 tcg_out_calli(s
, (tcg_target_long
)qemu_ld_helpers
[s_bits
]);
890 tcg_out_ext8s(s
, data_reg
, TCG_REG_EAX
);
893 tcg_out_ext16s(s
, data_reg
, TCG_REG_EAX
);
896 tcg_out_ext8u(s
, data_reg
, TCG_REG_EAX
);
899 tcg_out_ext16u(s
, data_reg
, TCG_REG_EAX
);
903 tcg_out_mov(s
, data_reg
, TCG_REG_EAX
);
906 if (data_reg
== TCG_REG_EDX
) {
907 /* xchg %edx, %eax */
908 tcg_out_opc(s
, OPC_XCHG_ax_r32
+ TCG_REG_EDX
);
909 tcg_out_mov(s
, data_reg2
, TCG_REG_EAX
);
911 tcg_out_mov(s
, data_reg
, TCG_REG_EAX
);
912 tcg_out_mov(s
, data_reg2
, TCG_REG_EDX
);
918 *label_ptr
[2] = s
->code_ptr
- label_ptr
[2] - 1;
920 tcg_out_qemu_ld_direct(s
, data_reg
, data_reg2
,
921 args
[addrlo_idx
], GUEST_BASE
, opc
);
925 static void tcg_out_qemu_st_direct(TCGContext
*s
, int datalo
, int datahi
,
926 int base
, tcg_target_long ofs
, int sizeop
)
928 #ifdef TARGET_WORDS_BIGENDIAN
933 /* ??? Ideally we wouldn't need a scratch register. For user-only,
934 we could perform the bswap twice to restore the original value
935 instead of moving to the scratch. But as it is, the L constraint
936 means that EDX is definitely free here. */
937 int scratch
= TCG_REG_EDX
;
941 tcg_out_modrm_offset(s
, OPC_MOVB_EvGv
, datalo
, base
, ofs
);
945 tcg_out_mov(s
, scratch
, datalo
);
946 tcg_out_rolw_8(s
, scratch
);
950 tcg_out_modrm_offset(s
, OPC_MOVL_EvGv
| P_DATA16
,
955 tcg_out_mov(s
, scratch
, datalo
);
956 tcg_out_bswap32(s
, scratch
);
959 tcg_out_st(s
, TCG_TYPE_I32
, datalo
, base
, ofs
);
963 tcg_out_mov(s
, scratch
, datahi
);
964 tcg_out_bswap32(s
, scratch
);
965 tcg_out_st(s
, TCG_TYPE_I32
, scratch
, base
, ofs
);
966 tcg_out_mov(s
, scratch
, datalo
);
967 tcg_out_bswap32(s
, scratch
);
968 tcg_out_st(s
, TCG_TYPE_I32
, scratch
, base
, ofs
+ 4);
970 tcg_out_st(s
, TCG_TYPE_I32
, datalo
, base
, ofs
);
971 tcg_out_st(s
, TCG_TYPE_I32
, datahi
, base
, ofs
+ 4);
979 static void tcg_out_qemu_st(TCGContext
*s
, const TCGArg
*args
,
982 int data_reg
, data_reg2
= 0;
984 #if defined(CONFIG_SOFTMMU)
985 int mem_index
, s_bits
;
987 uint8_t *label_ptr
[3];
997 #if defined(CONFIG_SOFTMMU)
998 mem_index
= args
[addrlo_idx
+ (TARGET_LONG_BITS
/ 32)];
1001 tcg_out_tlb_load(s
, addrlo_idx
, mem_index
, s_bits
, args
,
1002 label_ptr
, offsetof(CPUTLBEntry
, addr_write
));
1005 tcg_out_qemu_st_direct(s
, data_reg
, data_reg2
, TCG_REG_EAX
, 0, opc
);
1008 tcg_out8(s
, OPC_JMP_short
);
1009 label_ptr
[2] = s
->code_ptr
;
1015 *label_ptr
[0] = s
->code_ptr
- label_ptr
[0] - 1;
1016 if (TARGET_LONG_BITS
== 64) {
1017 *label_ptr
[1] = s
->code_ptr
- label_ptr
[1] - 1;
1020 /* XXX: move that code at the end of the TB */
1021 #if TARGET_LONG_BITS == 32
1023 tcg_out_mov(s
, TCG_REG_EDX
, data_reg
);
1024 tcg_out_mov(s
, TCG_REG_ECX
, data_reg2
);
1025 tcg_out_pushi(s
, mem_index
);
1030 tcg_out_ext8u(s
, TCG_REG_EDX
, data_reg
);
1033 tcg_out_ext16u(s
, TCG_REG_EDX
, data_reg
);
1036 tcg_out_mov(s
, TCG_REG_EDX
, data_reg
);
1039 tcg_out_movi(s
, TCG_TYPE_I32
, TCG_REG_ECX
, mem_index
);
1044 tcg_out_mov(s
, TCG_REG_EDX
, args
[addrlo_idx
+ 1]);
1045 tcg_out_pushi(s
, mem_index
);
1046 tcg_out_push(s
, data_reg2
);
1047 tcg_out_push(s
, data_reg
);
1050 tcg_out_mov(s
, TCG_REG_EDX
, args
[addrlo_idx
+ 1]);
1053 tcg_out_ext8u(s
, TCG_REG_ECX
, data_reg
);
1056 tcg_out_ext16u(s
, TCG_REG_ECX
, data_reg
);
1059 tcg_out_mov(s
, TCG_REG_ECX
, data_reg
);
1062 tcg_out_pushi(s
, mem_index
);
1067 tcg_out_calli(s
, (tcg_target_long
)qemu_st_helpers
[s_bits
]);
1069 if (stack_adjust
== 4) {
1070 /* Pop and discard. This is 2 bytes smaller than the add. */
1071 tcg_out_pop(s
, TCG_REG_ECX
);
1072 } else if (stack_adjust
!= 0) {
1073 tcg_out_addi(s
, TCG_REG_ESP
, stack_adjust
);
1077 *label_ptr
[2] = s
->code_ptr
- label_ptr
[2] - 1;
1079 tcg_out_qemu_st_direct(s
, data_reg
, data_reg2
,
1080 args
[addrlo_idx
], GUEST_BASE
, opc
);
1084 static inline void tcg_out_op(TCGContext
*s
, TCGOpcode opc
,
1085 const TCGArg
*args
, const int *const_args
)
1090 case INDEX_op_exit_tb
:
1091 tcg_out_movi(s
, TCG_TYPE_I32
, TCG_REG_EAX
, args
[0]);
1092 tcg_out8(s
, OPC_JMP_long
); /* jmp tb_ret_addr */
1093 tcg_out32(s
, tb_ret_addr
- s
->code_ptr
- 4);
1095 case INDEX_op_goto_tb
:
1096 if (s
->tb_jmp_offset
) {
1097 /* direct jump method */
1098 tcg_out8(s
, OPC_JMP_long
); /* jmp im */
1099 s
->tb_jmp_offset
[args
[0]] = s
->code_ptr
- s
->code_buf
;
1102 /* indirect jump method */
1103 tcg_out_modrm_offset(s
, OPC_GRP5
, EXT5_JMPN_Ev
, -1,
1104 (tcg_target_long
)(s
->tb_next
+ args
[0]));
1106 s
->tb_next_offset
[args
[0]] = s
->code_ptr
- s
->code_buf
;
1109 if (const_args
[0]) {
1110 tcg_out_calli(s
, args
[0]);
1113 tcg_out_modrm(s
, OPC_GRP5
, EXT5_CALLN_Ev
, args
[0]);
1117 if (const_args
[0]) {
1118 tcg_out8(s
, OPC_JMP_long
);
1119 tcg_out32(s
, args
[0] - (tcg_target_long
)s
->code_ptr
- 4);
1122 tcg_out_modrm(s
, OPC_GRP5
, EXT5_JMPN_Ev
, args
[0]);
1126 tcg_out_jxx(s
, JCC_JMP
, args
[0], 0);
1128 case INDEX_op_movi_i32
:
1129 tcg_out_movi(s
, TCG_TYPE_I32
, args
[0], args
[1]);
1131 case INDEX_op_ld8u_i32
:
1133 tcg_out_modrm_offset(s
, OPC_MOVZBL
, args
[0], args
[1], args
[2]);
1135 case INDEX_op_ld8s_i32
:
1137 tcg_out_modrm_offset(s
, OPC_MOVSBL
, args
[0], args
[1], args
[2]);
1139 case INDEX_op_ld16u_i32
:
1141 tcg_out_modrm_offset(s
, OPC_MOVZWL
, args
[0], args
[1], args
[2]);
1143 case INDEX_op_ld16s_i32
:
1145 tcg_out_modrm_offset(s
, OPC_MOVSWL
, args
[0], args
[1], args
[2]);
1147 case INDEX_op_ld_i32
:
1148 tcg_out_ld(s
, TCG_TYPE_I32
, args
[0], args
[1], args
[2]);
1150 case INDEX_op_st8_i32
:
1152 tcg_out_modrm_offset(s
, OPC_MOVB_EvGv
, args
[0], args
[1], args
[2]);
1154 case INDEX_op_st16_i32
:
1156 tcg_out_modrm_offset(s
, OPC_MOVL_EvGv
| P_DATA16
,
1157 args
[0], args
[1], args
[2]);
1159 case INDEX_op_st_i32
:
1160 tcg_out_st(s
, TCG_TYPE_I32
, args
[0], args
[1], args
[2]);
1162 case INDEX_op_add_i32
:
1163 /* For 3-operand addition, use LEA. */
1164 if (args
[0] != args
[1]) {
1165 TCGArg a0
= args
[0], a1
= args
[1], a2
= args
[2], c3
= 0;
1167 if (const_args
[2]) {
1169 } else if (a0
== a2
) {
1170 /* Watch out for dest = src + dest, since we've removed
1171 the matching constraint on the add. */
1172 tgen_arithr(s
, ARITH_ADD
, a0
, a1
);
1176 tcg_out_modrm_sib_offset(s
, OPC_LEA
, a0
, a1
, a2
, 0, c3
);
1181 case INDEX_op_sub_i32
:
1184 case INDEX_op_and_i32
:
1187 case INDEX_op_or_i32
:
1190 case INDEX_op_xor_i32
:
1194 if (const_args
[2]) {
1195 tgen_arithi(s
, c
, args
[0], args
[2], 0);
1197 tgen_arithr(s
, c
, args
[0], args
[2]);
1200 case INDEX_op_mul_i32
:
1201 if (const_args
[2]) {
1204 if (val
== (int8_t)val
) {
1205 tcg_out_modrm(s
, OPC_IMUL_GvEvIb
, args
[0], args
[0]);
1208 tcg_out_modrm(s
, OPC_IMUL_GvEvIz
, args
[0], args
[0]);
1212 tcg_out_modrm(s
, OPC_IMUL_GvEv
, args
[0], args
[2]);
1215 case INDEX_op_mulu2_i32
:
1216 tcg_out_modrm(s
, OPC_GRP3_Ev
, EXT3_MUL
, args
[3]);
1218 case INDEX_op_div2_i32
:
1219 tcg_out_modrm(s
, OPC_GRP3_Ev
, EXT3_IDIV
, args
[4]);
1221 case INDEX_op_divu2_i32
:
1222 tcg_out_modrm(s
, OPC_GRP3_Ev
, EXT3_DIV
, args
[4]);
1224 case INDEX_op_shl_i32
:
1227 if (const_args
[2]) {
1228 tcg_out_shifti(s
, c
, args
[0], args
[2]);
1230 tcg_out_modrm(s
, OPC_SHIFT_cl
, c
, args
[0]);
1233 case INDEX_op_shr_i32
:
1236 case INDEX_op_sar_i32
:
1239 case INDEX_op_rotl_i32
:
1242 case INDEX_op_rotr_i32
:
1246 case INDEX_op_add2_i32
:
1247 if (const_args
[4]) {
1248 tgen_arithi(s
, ARITH_ADD
, args
[0], args
[4], 1);
1250 tgen_arithr(s
, ARITH_ADD
, args
[0], args
[4]);
1252 if (const_args
[5]) {
1253 tgen_arithi(s
, ARITH_ADC
, args
[1], args
[5], 1);
1255 tgen_arithr(s
, ARITH_ADC
, args
[1], args
[5]);
1258 case INDEX_op_sub2_i32
:
1259 if (const_args
[4]) {
1260 tgen_arithi(s
, ARITH_SUB
, args
[0], args
[4], 1);
1262 tgen_arithr(s
, ARITH_SUB
, args
[0], args
[4]);
1264 if (const_args
[5]) {
1265 tgen_arithi(s
, ARITH_SBB
, args
[1], args
[5], 1);
1267 tgen_arithr(s
, ARITH_SBB
, args
[1], args
[5]);
1270 case INDEX_op_brcond_i32
:
1271 tcg_out_brcond(s
, args
[2], args
[0], args
[1], const_args
[1],
1274 case INDEX_op_brcond2_i32
:
1275 tcg_out_brcond2(s
, args
, const_args
, 0);
1278 case INDEX_op_bswap16_i32
:
1279 tcg_out_rolw_8(s
, args
[0]);
1281 case INDEX_op_bswap32_i32
:
1282 tcg_out_bswap32(s
, args
[0]);
1285 case INDEX_op_neg_i32
:
1286 tcg_out_modrm(s
, OPC_GRP3_Ev
, EXT3_NEG
, args
[0]);
1289 case INDEX_op_not_i32
:
1290 tcg_out_modrm(s
, OPC_GRP3_Ev
, EXT3_NOT
, args
[0]);
1293 case INDEX_op_ext8s_i32
:
1294 tcg_out_ext8s(s
, args
[0], args
[1]);
1296 case INDEX_op_ext16s_i32
:
1297 tcg_out_ext16s(s
, args
[0], args
[1]);
1299 case INDEX_op_ext8u_i32
:
1300 tcg_out_ext8u(s
, args
[0], args
[1]);
1302 case INDEX_op_ext16u_i32
:
1303 tcg_out_ext16u(s
, args
[0], args
[1]);
1306 case INDEX_op_setcond_i32
:
1307 tcg_out_setcond(s
, args
[3], args
[0], args
[1], args
[2], const_args
[2]);
1309 case INDEX_op_setcond2_i32
:
1310 tcg_out_setcond2(s
, args
, const_args
);
1313 case INDEX_op_qemu_ld8u
:
1314 tcg_out_qemu_ld(s
, args
, 0);
1316 case INDEX_op_qemu_ld8s
:
1317 tcg_out_qemu_ld(s
, args
, 0 | 4);
1319 case INDEX_op_qemu_ld16u
:
1320 tcg_out_qemu_ld(s
, args
, 1);
1322 case INDEX_op_qemu_ld16s
:
1323 tcg_out_qemu_ld(s
, args
, 1 | 4);
1325 case INDEX_op_qemu_ld32
:
1326 tcg_out_qemu_ld(s
, args
, 2);
1328 case INDEX_op_qemu_ld64
:
1329 tcg_out_qemu_ld(s
, args
, 3);
1332 case INDEX_op_qemu_st8
:
1333 tcg_out_qemu_st(s
, args
, 0);
1335 case INDEX_op_qemu_st16
:
1336 tcg_out_qemu_st(s
, args
, 1);
1338 case INDEX_op_qemu_st32
:
1339 tcg_out_qemu_st(s
, args
, 2);
1341 case INDEX_op_qemu_st64
:
1342 tcg_out_qemu_st(s
, args
, 3);
1350 static const TCGTargetOpDef x86_op_defs
[] = {
1351 { INDEX_op_exit_tb
, { } },
1352 { INDEX_op_goto_tb
, { } },
1353 { INDEX_op_call
, { "ri" } },
1354 { INDEX_op_jmp
, { "ri" } },
1355 { INDEX_op_br
, { } },
1356 { INDEX_op_mov_i32
, { "r", "r" } },
1357 { INDEX_op_movi_i32
, { "r" } },
1358 { INDEX_op_ld8u_i32
, { "r", "r" } },
1359 { INDEX_op_ld8s_i32
, { "r", "r" } },
1360 { INDEX_op_ld16u_i32
, { "r", "r" } },
1361 { INDEX_op_ld16s_i32
, { "r", "r" } },
1362 { INDEX_op_ld_i32
, { "r", "r" } },
1363 { INDEX_op_st8_i32
, { "q", "r" } },
1364 { INDEX_op_st16_i32
, { "r", "r" } },
1365 { INDEX_op_st_i32
, { "r", "r" } },
1367 { INDEX_op_add_i32
, { "r", "r", "ri" } },
1368 { INDEX_op_sub_i32
, { "r", "0", "ri" } },
1369 { INDEX_op_mul_i32
, { "r", "0", "ri" } },
1370 { INDEX_op_mulu2_i32
, { "a", "d", "a", "r" } },
1371 { INDEX_op_div2_i32
, { "a", "d", "0", "1", "r" } },
1372 { INDEX_op_divu2_i32
, { "a", "d", "0", "1", "r" } },
1373 { INDEX_op_and_i32
, { "r", "0", "ri" } },
1374 { INDEX_op_or_i32
, { "r", "0", "ri" } },
1375 { INDEX_op_xor_i32
, { "r", "0", "ri" } },
1377 { INDEX_op_shl_i32
, { "r", "0", "ci" } },
1378 { INDEX_op_shr_i32
, { "r", "0", "ci" } },
1379 { INDEX_op_sar_i32
, { "r", "0", "ci" } },
1380 { INDEX_op_rotl_i32
, { "r", "0", "ci" } },
1381 { INDEX_op_rotr_i32
, { "r", "0", "ci" } },
1383 { INDEX_op_brcond_i32
, { "r", "ri" } },
1385 { INDEX_op_add2_i32
, { "r", "r", "0", "1", "ri", "ri" } },
1386 { INDEX_op_sub2_i32
, { "r", "r", "0", "1", "ri", "ri" } },
1387 { INDEX_op_brcond2_i32
, { "r", "r", "ri", "ri" } },
1389 { INDEX_op_bswap16_i32
, { "r", "0" } },
1390 { INDEX_op_bswap32_i32
, { "r", "0" } },
1392 { INDEX_op_neg_i32
, { "r", "0" } },
1394 { INDEX_op_not_i32
, { "r", "0" } },
1396 { INDEX_op_ext8s_i32
, { "r", "q" } },
1397 { INDEX_op_ext16s_i32
, { "r", "r" } },
1398 { INDEX_op_ext8u_i32
, { "r", "q" } },
1399 { INDEX_op_ext16u_i32
, { "r", "r" } },
1401 { INDEX_op_setcond_i32
, { "q", "r", "ri" } },
1402 { INDEX_op_setcond2_i32
, { "r", "r", "r", "ri", "ri" } },
1404 #if TARGET_LONG_BITS == 32
1405 { INDEX_op_qemu_ld8u
, { "r", "L" } },
1406 { INDEX_op_qemu_ld8s
, { "r", "L" } },
1407 { INDEX_op_qemu_ld16u
, { "r", "L" } },
1408 { INDEX_op_qemu_ld16s
, { "r", "L" } },
1409 { INDEX_op_qemu_ld32
, { "r", "L" } },
1410 { INDEX_op_qemu_ld64
, { "r", "r", "L" } },
1412 { INDEX_op_qemu_st8
, { "cb", "L" } },
1413 { INDEX_op_qemu_st16
, { "L", "L" } },
1414 { INDEX_op_qemu_st32
, { "L", "L" } },
1415 { INDEX_op_qemu_st64
, { "L", "L", "L" } },
1417 { INDEX_op_qemu_ld8u
, { "r", "L", "L" } },
1418 { INDEX_op_qemu_ld8s
, { "r", "L", "L" } },
1419 { INDEX_op_qemu_ld16u
, { "r", "L", "L" } },
1420 { INDEX_op_qemu_ld16s
, { "r", "L", "L" } },
1421 { INDEX_op_qemu_ld32
, { "r", "L", "L" } },
1422 { INDEX_op_qemu_ld64
, { "r", "r", "L", "L" } },
1424 { INDEX_op_qemu_st8
, { "cb", "L", "L" } },
1425 { INDEX_op_qemu_st16
, { "L", "L", "L" } },
1426 { INDEX_op_qemu_st32
, { "L", "L", "L" } },
1427 { INDEX_op_qemu_st64
, { "L", "L", "L", "L" } },
1432 static int tcg_target_callee_save_regs
[] = {
1433 /* TCG_REG_EBP, */ /* currently used for the global env, so no
1440 /* Generate global QEMU prologue and epilogue code */
1441 void tcg_target_qemu_prologue(TCGContext
*s
)
1443 int i
, frame_size
, push_size
, stack_addend
;
1446 /* save all callee saved registers */
1447 for(i
= 0; i
< ARRAY_SIZE(tcg_target_callee_save_regs
); i
++) {
1448 tcg_out_push(s
, tcg_target_callee_save_regs
[i
]);
1450 /* reserve some stack space */
1451 push_size
= 4 + ARRAY_SIZE(tcg_target_callee_save_regs
) * 4;
1452 frame_size
= push_size
+ TCG_STATIC_CALL_ARGS_SIZE
;
1453 frame_size
= (frame_size
+ TCG_TARGET_STACK_ALIGN
- 1) &
1454 ~(TCG_TARGET_STACK_ALIGN
- 1);
1455 stack_addend
= frame_size
- push_size
;
1456 tcg_out_addi(s
, TCG_REG_ESP
, -stack_addend
);
1458 tcg_out_modrm(s
, OPC_GRP5
, EXT5_JMPN_Ev
, TCG_REG_EAX
); /* jmp *%eax */
1461 tb_ret_addr
= s
->code_ptr
;
1462 tcg_out_addi(s
, TCG_REG_ESP
, stack_addend
);
1463 for(i
= ARRAY_SIZE(tcg_target_callee_save_regs
) - 1; i
>= 0; i
--) {
1464 tcg_out_pop(s
, tcg_target_callee_save_regs
[i
]);
1466 tcg_out_opc(s
, OPC_RET
);
1469 void tcg_target_init(TCGContext
*s
)
1471 #if !defined(CONFIG_USER_ONLY)
1473 if ((1 << CPU_TLB_ENTRY_BITS
) != sizeof(CPUTLBEntry
))
1477 tcg_regset_set32(tcg_target_available_regs
[TCG_TYPE_I32
], 0, 0xff);
1479 tcg_regset_clear(tcg_target_call_clobber_regs
);
1480 tcg_regset_set_reg(tcg_target_call_clobber_regs
, TCG_REG_EAX
);
1481 tcg_regset_set_reg(tcg_target_call_clobber_regs
, TCG_REG_EDX
);
1482 tcg_regset_set_reg(tcg_target_call_clobber_regs
, TCG_REG_ECX
);
1484 tcg_regset_clear(s
->reserved_regs
);
1485 tcg_regset_set_reg(s
->reserved_regs
, TCG_REG_ESP
);
1487 tcg_add_target_add_op_defs(x86_op_defs
);