]> git.proxmox.com Git - mirror_qemu.git/blob - tcg/mips/tcg-target.c
projects / mirror_qemu.git / blob
? search:


ae2b274d85b0fb436c2ec0e1d9dbc9f3aab08455
[mirror_qemu.git] / tcg / mips / tcg-target.c
1 /*
2 * Tiny Code Generator for QEMU
3 *
4 * Copyright (c) 2008-2009 Arnaud Patard <arnaud.patard@rtp-net.org>
5 * Copyright (c) 2009 Aurelien Jarno <aurelien@aurel32.net>
6 * Based on i386/tcg-target.c - Copyright (c) 2008 Fabrice Bellard
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 * THE SOFTWARE.
25 */
26
27 #if defined(TCG_TARGET_WORDS_BIGENDIAN) == defined(TARGET_WORDS_BIGENDIAN)
28 # define TCG_NEED_BSWAP 0
29 #else
30 # define TCG_NEED_BSWAP 1
31 #endif
32
33 #ifndef NDEBUG
34 static const char * const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {
35 "zero",
36 "at",
37 "v0",
38 "v1",
39 "a0",
40 "a1",
41 "a2",
42 "a3",
43 "t0",
44 "t1",
45 "t2",
46 "t3",
47 "t4",
48 "t5",
49 "t6",
50 "t7",
51 "s0",
52 "s1",
53 "s2",
54 "s3",
55 "s4",
56 "s5",
57 "s6",
58 "s7",
59 "t8",
60 "t9",
61 "k0",
62 "k1",
63 "gp",
64 "sp",
65 "fp",
66 "ra",
67 };
68 #endif
69
70 /* check if we really need so many registers :P */
71 static const TCGReg tcg_target_reg_alloc_order[] = {
72 TCG_REG_S0,
73 TCG_REG_S1,
74 TCG_REG_S2,
75 TCG_REG_S3,
76 TCG_REG_S4,
77 TCG_REG_S5,
78 TCG_REG_S6,
79 TCG_REG_S7,
80 TCG_REG_T1,
81 TCG_REG_T2,
82 TCG_REG_T3,
83 TCG_REG_T4,
84 TCG_REG_T5,
85 TCG_REG_T6,
86 TCG_REG_T7,
87 TCG_REG_T8,
88 TCG_REG_T9,
89 TCG_REG_A0,
90 TCG_REG_A1,
91 TCG_REG_A2,
92 TCG_REG_A3,
93 TCG_REG_V0,
94 TCG_REG_V1
95 };
96
97 static const TCGReg tcg_target_call_iarg_regs[4] = {
98 TCG_REG_A0,
99 TCG_REG_A1,
100 TCG_REG_A2,
101 TCG_REG_A3
102 };
103
104 static const TCGReg tcg_target_call_oarg_regs[2] = {
105 TCG_REG_V0,
106 TCG_REG_V1
107 };
108
109 static uint8_t *tb_ret_addr;
110
111 static inline uint32_t reloc_lo16_val (void *pc, tcg_target_long target)
112 {
113 return target & 0xffff;
114 }
115
116 static inline void reloc_lo16 (void *pc, tcg_target_long target)
117 {
118 *(uint32_t *) pc = (*(uint32_t *) pc & ~0xffff)
119 | reloc_lo16_val(pc, target);
120 }
121
122 static inline uint32_t reloc_hi16_val (void *pc, tcg_target_long target)
123 {
124 return (target >> 16) & 0xffff;
125 }
126
127 static inline void reloc_hi16 (void *pc, tcg_target_long target)
128 {
129 *(uint32_t *) pc = (*(uint32_t *) pc & ~0xffff)
130 | reloc_hi16_val(pc, target);
131 }
132
133 static inline uint32_t reloc_pc16_val (void *pc, tcg_target_long target)
134 {
135 int32_t disp;
136
137 disp = target - (tcg_target_long) pc - 4;
138 if (disp != (disp << 14) >> 14) {
139 tcg_abort ();
140 }
141
142 return (disp >> 2) & 0xffff;
143 }
144
145 static inline void reloc_pc16 (void *pc, tcg_target_long target)
146 {
147 *(uint32_t *) pc = (*(uint32_t *) pc & ~0xffff)
148 | reloc_pc16_val(pc, target);
149 }
150
151 static inline uint32_t reloc_26_val (void *pc, tcg_target_long target)
152 {
153 if ((((tcg_target_long)pc + 4) & 0xf0000000) != (target & 0xf0000000)) {
154 tcg_abort ();
155 }
156
157 return (target >> 2) & 0x3ffffff;
158 }
159
160 static inline void reloc_pc26 (void *pc, tcg_target_long target)
161 {
162 *(uint32_t *) pc = (*(uint32_t *) pc & ~0x3ffffff)
163 | reloc_26_val(pc, target);
164 }
165
166 static void patch_reloc(uint8_t *code_ptr, int type,
167 tcg_target_long value, tcg_target_long addend)
168 {
169 value += addend;
170 switch(type) {
171 case R_MIPS_LO16:
172 reloc_lo16(code_ptr, value);
173 break;
174 case R_MIPS_HI16:
175 reloc_hi16(code_ptr, value);
176 break;
177 case R_MIPS_PC16:
178 reloc_pc16(code_ptr, value);
179 break;
180 case R_MIPS_26:
181 reloc_pc26(code_ptr, value);
182 break;
183 default:
184 tcg_abort();
185 }
186 }
187
188 /* parse target specific constraints */
189 static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
190 {
191 const char *ct_str;
192
193 ct_str = *pct_str;
194 switch(ct_str[0]) {
195 case 'r':
196 ct->ct |= TCG_CT_REG;
197 tcg_regset_set(ct->u.regs, 0xffffffff);
198 break;
199 case 'C':
200 ct->ct |= TCG_CT_REG;
201 tcg_regset_clear(ct->u.regs);
202 tcg_regset_set_reg(ct->u.regs, TCG_REG_T9);
203 break;
204 case 'L': /* qemu_ld output arg constraint */
205 ct->ct |= TCG_CT_REG;
206 tcg_regset_set(ct->u.regs, 0xffffffff);
207 tcg_regset_reset_reg(ct->u.regs, TCG_REG_V0);
208 break;
209 case 'l': /* qemu_ld input arg constraint */
210 ct->ct |= TCG_CT_REG;
211 tcg_regset_set(ct->u.regs, 0xffffffff);
212 #if defined(CONFIG_SOFTMMU)
213 tcg_regset_reset_reg(ct->u.regs, TCG_REG_A0);
214 # if (TARGET_LONG_BITS == 64)
215 tcg_regset_reset_reg(ct->u.regs, TCG_REG_A2);
216 # endif
217 #endif
218 break;
219 case 'S': /* qemu_st constraint */
220 ct->ct |= TCG_CT_REG;
221 tcg_regset_set(ct->u.regs, 0xffffffff);
222 tcg_regset_reset_reg(ct->u.regs, TCG_REG_A0);
223 #if defined(CONFIG_SOFTMMU)
224 # if (TARGET_LONG_BITS == 32)
225 tcg_regset_reset_reg(ct->u.regs, TCG_REG_A1);
226 # endif
227 tcg_regset_reset_reg(ct->u.regs, TCG_REG_A2);
228 # if TARGET_LONG_BITS == 64
229 tcg_regset_reset_reg(ct->u.regs, TCG_REG_A3);
230 # endif
231 #endif
232 break;
233 case 'I':
234 ct->ct |= TCG_CT_CONST_U16;
235 break;
236 case 'J':
237 ct->ct |= TCG_CT_CONST_S16;
238 break;
239 case 'Z':
240 /* We are cheating a bit here, using the fact that the register
241 ZERO is also the register number 0. Hence there is no need
242 to check for const_args in each instruction. */
243 ct->ct |= TCG_CT_CONST_ZERO;
244 break;
245 default:
246 return -1;
247 }
248 ct_str++;
249 *pct_str = ct_str;
250 return 0;
251 }
252
253 /* test if a constant matches the constraint */
254 static inline int tcg_target_const_match(tcg_target_long val,
255 const TCGArgConstraint *arg_ct)
256 {
257 int ct;
258 ct = arg_ct->ct;
259 if (ct & TCG_CT_CONST)
260 return 1;
261 else if ((ct & TCG_CT_CONST_ZERO) && val == 0)
262 return 1;
263 else if ((ct & TCG_CT_CONST_U16) && val == (uint16_t)val)
264 return 1;
265 else if ((ct & TCG_CT_CONST_S16) && val == (int16_t)val)
266 return 1;
267 else
268 return 0;
269 }
270
271 /* instruction opcodes */
272 enum {
273 OPC_BEQ = 0x04 << 26,
274 OPC_BNE = 0x05 << 26,
275 OPC_BLEZ = 0x06 << 26,
276 OPC_BGTZ = 0x07 << 26,
277 OPC_ADDIU = 0x09 << 26,
278 OPC_SLTI = 0x0A << 26,
279 OPC_SLTIU = 0x0B << 26,
280 OPC_ANDI = 0x0C << 26,
281 OPC_ORI = 0x0D << 26,
282 OPC_XORI = 0x0E << 26,
283 OPC_LUI = 0x0F << 26,
284 OPC_LB = 0x20 << 26,
285 OPC_LH = 0x21 << 26,
286 OPC_LW = 0x23 << 26,
287 OPC_LBU = 0x24 << 26,
288 OPC_LHU = 0x25 << 26,
289 OPC_LWU = 0x27 << 26,
290 OPC_SB = 0x28 << 26,
291 OPC_SH = 0x29 << 26,
292 OPC_SW = 0x2B << 26,
293
294 OPC_SPECIAL = 0x00 << 26,
295 OPC_SLL = OPC_SPECIAL | 0x00,
296 OPC_SRL = OPC_SPECIAL | 0x02,
297 OPC_ROTR = OPC_SPECIAL | (0x01 << 21) | 0x02,
298 OPC_SRA = OPC_SPECIAL | 0x03,
299 OPC_SLLV = OPC_SPECIAL | 0x04,
300 OPC_SRLV = OPC_SPECIAL | 0x06,
301 OPC_ROTRV = OPC_SPECIAL | (0x01 << 6) | 0x06,
302 OPC_SRAV = OPC_SPECIAL | 0x07,
303 OPC_JR = OPC_SPECIAL | 0x08,
304 OPC_JALR = OPC_SPECIAL | 0x09,
305 OPC_MOVZ = OPC_SPECIAL | 0x0A,
306 OPC_MOVN = OPC_SPECIAL | 0x0B,
307 OPC_MFHI = OPC_SPECIAL | 0x10,
308 OPC_MFLO = OPC_SPECIAL | 0x12,
309 OPC_MULT = OPC_SPECIAL | 0x18,
310 OPC_MULTU = OPC_SPECIAL | 0x19,
311 OPC_DIV = OPC_SPECIAL | 0x1A,
312 OPC_DIVU = OPC_SPECIAL | 0x1B,
313 OPC_ADDU = OPC_SPECIAL | 0x21,
314 OPC_SUBU = OPC_SPECIAL | 0x23,
315 OPC_AND = OPC_SPECIAL | 0x24,
316 OPC_OR = OPC_SPECIAL | 0x25,
317 OPC_XOR = OPC_SPECIAL | 0x26,
318 OPC_NOR = OPC_SPECIAL | 0x27,
319 OPC_SLT = OPC_SPECIAL | 0x2A,
320 OPC_SLTU = OPC_SPECIAL | 0x2B,
321
322 OPC_REGIMM = 0x01 << 26,
323 OPC_BLTZ = OPC_REGIMM | (0x00 << 16),
324 OPC_BGEZ = OPC_REGIMM | (0x01 << 16),
325
326 OPC_SPECIAL2 = 0x1c << 26,
327 OPC_MUL = OPC_SPECIAL2 | 0x002,
328
329 OPC_SPECIAL3 = 0x1f << 26,
330 OPC_INS = OPC_SPECIAL3 | 0x004,
331 OPC_WSBH = OPC_SPECIAL3 | 0x0a0,
332 OPC_SEB = OPC_SPECIAL3 | 0x420,
333 OPC_SEH = OPC_SPECIAL3 | 0x620,
334 };
335
336 /*
337 * Type reg
338 */
339 static inline void tcg_out_opc_reg(TCGContext *s, int opc,
340 TCGReg rd, TCGReg rs, TCGReg rt)
341 {
342 int32_t inst;
343
344 inst = opc;
345 inst |= (rs & 0x1F) << 21;
346 inst |= (rt & 0x1F) << 16;
347 inst |= (rd & 0x1F) << 11;
348 tcg_out32(s, inst);
349 }
350
351 /*
352 * Type immediate
353 */
354 static inline void tcg_out_opc_imm(TCGContext *s, int opc,
355 TCGReg rt, TCGReg rs, TCGArg imm)
356 {
357 int32_t inst;
358
359 inst = opc;
360 inst |= (rs & 0x1F) << 21;
361 inst |= (rt & 0x1F) << 16;
362 inst |= (imm & 0xffff);
363 tcg_out32(s, inst);
364 }
365
366 /*
367 * Type branch
368 */
369 static inline void tcg_out_opc_br(TCGContext *s, int opc,
370 TCGReg rt, TCGReg rs)
371 {
372 /* We pay attention here to not modify the branch target by reading
373 the existing value and using it again. This ensure that caches and
374 memory are kept coherent during retranslation. */
375 uint16_t offset = (uint16_t)(*(uint32_t *) s->code_ptr);
376
377 tcg_out_opc_imm(s, opc, rt, rs, offset);
378 }
379
380 /*
381 * Type sa
382 */
383 static inline void tcg_out_opc_sa(TCGContext *s, int opc,
384 TCGReg rd, TCGReg rt, TCGArg sa)
385 {
386 int32_t inst;
387
388 inst = opc;
389 inst |= (rt & 0x1F) << 16;
390 inst |= (rd & 0x1F) << 11;
391 inst |= (sa & 0x1F) << 6;
392 tcg_out32(s, inst);
393
394 }
395
396 static inline void tcg_out_nop(TCGContext *s)
397 {
398 tcg_out32(s, 0);
399 }
400
401 static inline void tcg_out_mov(TCGContext *s, TCGType type,
402 TCGReg ret, TCGReg arg)
403 {
404 /* Simple reg-reg move, optimising out the 'do nothing' case */
405 if (ret != arg) {
406 tcg_out_opc_reg(s, OPC_ADDU, ret, arg, TCG_REG_ZERO);
407 }
408 }
409
410 static inline void tcg_out_movi(TCGContext *s, TCGType type,
411 TCGReg reg, tcg_target_long arg)
412 {
413 if (arg == (int16_t)arg) {
414 tcg_out_opc_imm(s, OPC_ADDIU, reg, TCG_REG_ZERO, arg);
415 } else if (arg == (uint16_t)arg) {
416 tcg_out_opc_imm(s, OPC_ORI, reg, TCG_REG_ZERO, arg);
417 } else {
418 tcg_out_opc_imm(s, OPC_LUI, reg, 0, arg >> 16);
419 tcg_out_opc_imm(s, OPC_ORI, reg, reg, arg & 0xffff);
420 }
421 }
422
423 static inline void tcg_out_bswap16(TCGContext *s, TCGReg ret, TCGReg arg)
424 {
425 #if defined(__mips_isa_rev) && (__mips_isa_rev >= 2)
426 tcg_out_opc_reg(s, OPC_WSBH, ret, 0, arg);
427 #else
428 /* ret and arg can't be register at */
429 if (ret == TCG_REG_AT || arg == TCG_REG_AT) {
430 tcg_abort();
431 }
432
433 tcg_out_opc_sa(s, OPC_SRL, TCG_REG_AT, arg, 8);
434 tcg_out_opc_sa(s, OPC_SLL, ret, arg, 8);
435 tcg_out_opc_imm(s, OPC_ANDI, ret, ret, 0xff00);
436 tcg_out_opc_reg(s, OPC_OR, ret, ret, TCG_REG_AT);
437 #endif
438 }
439
440 static inline void tcg_out_bswap16s(TCGContext *s, TCGReg ret, TCGReg arg)
441 {
442 #if defined(__mips_isa_rev) && (__mips_isa_rev >= 2)
443 tcg_out_opc_reg(s, OPC_WSBH, ret, 0, arg);
444 tcg_out_opc_reg(s, OPC_SEH, ret, 0, ret);
445 #else
446 /* ret and arg can't be register at */
447 if (ret == TCG_REG_AT || arg == TCG_REG_AT) {
448 tcg_abort();
449 }
450
451 tcg_out_opc_sa(s, OPC_SRL, TCG_REG_AT, arg, 8);
452 tcg_out_opc_sa(s, OPC_SLL, ret, arg, 24);
453 tcg_out_opc_sa(s, OPC_SRA, ret, ret, 16);
454 tcg_out_opc_reg(s, OPC_OR, ret, ret, TCG_REG_AT);
455 #endif
456 }
457
458 static inline void tcg_out_bswap32(TCGContext *s, TCGReg ret, TCGReg arg)
459 {
460 #if defined(__mips_isa_rev) && (__mips_isa_rev >= 2)
461 tcg_out_opc_reg(s, OPC_WSBH, ret, 0, arg);
462 tcg_out_opc_sa(s, OPC_ROTR, ret, ret, 16);
463 #else
464 /* ret and arg must be different and can't be register at */
465 if (ret == arg || ret == TCG_REG_AT || arg == TCG_REG_AT) {
466 tcg_abort();
467 }
468
469 tcg_out_opc_sa(s, OPC_SLL, ret, arg, 24);
470
471 tcg_out_opc_sa(s, OPC_SRL, TCG_REG_AT, arg, 24);
472 tcg_out_opc_reg(s, OPC_OR, ret, ret, TCG_REG_AT);
473
474 tcg_out_opc_imm(s, OPC_ANDI, TCG_REG_AT, arg, 0xff00);
475 tcg_out_opc_sa(s, OPC_SLL, TCG_REG_AT, TCG_REG_AT, 8);
476 tcg_out_opc_reg(s, OPC_OR, ret, ret, TCG_REG_AT);
477
478 tcg_out_opc_sa(s, OPC_SRL, TCG_REG_AT, arg, 8);
479 tcg_out_opc_imm(s, OPC_ANDI, TCG_REG_AT, TCG_REG_AT, 0xff00);
480 tcg_out_opc_reg(s, OPC_OR, ret, ret, TCG_REG_AT);
481 #endif
482 }
483
484 static inline void tcg_out_ext8s(TCGContext *s, TCGReg ret, TCGReg arg)
485 {
486 #if defined(__mips_isa_rev) && (__mips_isa_rev >= 2)
487 tcg_out_opc_reg(s, OPC_SEB, ret, 0, arg);
488 #else
489 tcg_out_opc_sa(s, OPC_SLL, ret, arg, 24);
490 tcg_out_opc_sa(s, OPC_SRA, ret, ret, 24);
491 #endif
492 }
493
494 static inline void tcg_out_ext16s(TCGContext *s, TCGReg ret, TCGReg arg)
495 {
496 #if defined(__mips_isa_rev) && (__mips_isa_rev >= 2)
497 tcg_out_opc_reg(s, OPC_SEH, ret, 0, arg);
498 #else
499 tcg_out_opc_sa(s, OPC_SLL, ret, arg, 16);
500 tcg_out_opc_sa(s, OPC_SRA, ret, ret, 16);
501 #endif
502 }
503
504 static inline void tcg_out_ldst(TCGContext *s, int opc, TCGArg arg,
505 TCGReg arg1, TCGArg arg2)
506 {
507 if (arg2 == (int16_t) arg2) {
508 tcg_out_opc_imm(s, opc, arg, arg1, arg2);
509 } else {
510 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_AT, arg2);
511 tcg_out_opc_reg(s, OPC_ADDU, TCG_REG_AT, TCG_REG_AT, arg1);
512 tcg_out_opc_imm(s, opc, arg, TCG_REG_AT, 0);
513 }
514 }
515
516 static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg arg,
517 TCGReg arg1, tcg_target_long arg2)
518 {
519 tcg_out_ldst(s, OPC_LW, arg, arg1, arg2);
520 }
521
522 static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg,
523 TCGReg arg1, tcg_target_long arg2)
524 {
525 tcg_out_ldst(s, OPC_SW, arg, arg1, arg2);
526 }
527
528 static inline void tcg_out_addi(TCGContext *s, TCGReg reg, TCGArg val)
529 {
530 if (val == (int16_t)val) {
531 tcg_out_opc_imm(s, OPC_ADDIU, reg, reg, val);
532 } else {
533 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_AT, val);
534 tcg_out_opc_reg(s, OPC_ADDU, reg, reg, TCG_REG_AT);
535 }
536 }
537
538 /* Helper routines for marshalling helper function arguments into
539 * the correct registers and stack.
540 * arg_num is where we want to put this argument, and is updated to be ready
541 * for the next call. arg is the argument itself. Note that arg_num 0..3 is
542 * real registers, 4+ on stack.
543 *
544 * We provide routines for arguments which are: immediate, 32 bit
545 * value in register, 16 and 8 bit values in register (which must be zero
546 * extended before use) and 64 bit value in a lo:hi register pair.
547 */
548 #define DEFINE_TCG_OUT_CALL_IARG(NAME, ARGPARAM) \
549 static inline void NAME(TCGContext *s, int *arg_num, ARGPARAM) \
550 { \
551 if (*arg_num < 4) { \
552 DEFINE_TCG_OUT_CALL_IARG_GET_ARG(tcg_target_call_iarg_regs[*arg_num]); \
553 } else { \
554 DEFINE_TCG_OUT_CALL_IARG_GET_ARG(TCG_REG_AT); \
555 tcg_out_st(s, TCG_TYPE_I32, TCG_REG_AT, TCG_REG_SP, 4 * (*arg_num)); \
556 } \
557 (*arg_num)++; \
558 }
559 #define DEFINE_TCG_OUT_CALL_IARG_GET_ARG(A) \
560 tcg_out_opc_imm(s, OPC_ANDI, A, arg, 0xff);
561 DEFINE_TCG_OUT_CALL_IARG(tcg_out_call_iarg_reg8, TCGReg arg)
562 #undef DEFINE_TCG_OUT_CALL_IARG_GET_ARG
563 #define DEFINE_TCG_OUT_CALL_IARG_GET_ARG(A) \
564 tcg_out_opc_imm(s, OPC_ANDI, A, arg, 0xffff);
565 DEFINE_TCG_OUT_CALL_IARG(tcg_out_call_iarg_reg16, TCGReg arg)
566 #undef DEFINE_TCG_OUT_CALL_IARG_GET_ARG
567 #define DEFINE_TCG_OUT_CALL_IARG_GET_ARG(A) \
568 tcg_out_movi(s, TCG_TYPE_I32, A, arg);
569 DEFINE_TCG_OUT_CALL_IARG(tcg_out_call_iarg_imm32, TCGArg arg)
570 #undef DEFINE_TCG_OUT_CALL_IARG_GET_ARG
571
572 /* We don't use the macro for this one to avoid an unnecessary reg-reg
573 move when storing to the stack. */
574 static inline void tcg_out_call_iarg_reg32(TCGContext *s, int *arg_num,
575 TCGReg arg)
576 {
577 if (*arg_num < 4) {
578 tcg_out_mov(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[*arg_num], arg);
579 } else {
580 tcg_out_st(s, TCG_TYPE_I32, arg, TCG_REG_SP, 4 * (*arg_num));
581 }
582 (*arg_num)++;
583 }
584
585 static inline void tcg_out_call_iarg_reg64(TCGContext *s, int *arg_num,
586 TCGReg arg_low, TCGReg arg_high)
587 {
588 (*arg_num) = (*arg_num + 1) & ~1;
589
590 #if defined(TCG_TARGET_WORDS_BIGENDIAN)
591 tcg_out_call_iarg_reg32(s, arg_num, arg_high);
592 tcg_out_call_iarg_reg32(s, arg_num, arg_low);
593 #else
594 tcg_out_call_iarg_reg32(s, arg_num, arg_low);
595 tcg_out_call_iarg_reg32(s, arg_num, arg_high);
596 #endif
597 }
598
599 static void tcg_out_brcond(TCGContext *s, TCGCond cond, TCGArg arg1,
600 TCGArg arg2, int label_index)
601 {
602 TCGLabel *l = &s->labels[label_index];
603
604 switch (cond) {
605 case TCG_COND_EQ:
606 tcg_out_opc_br(s, OPC_BEQ, arg1, arg2);
607 break;
608 case TCG_COND_NE:
609 tcg_out_opc_br(s, OPC_BNE, arg1, arg2);
610 break;
611 case TCG_COND_LT:
612 if (arg2 == 0) {
613 tcg_out_opc_br(s, OPC_BLTZ, 0, arg1);
614 } else {
615 tcg_out_opc_reg(s, OPC_SLT, TCG_REG_AT, arg1, arg2);
616 tcg_out_opc_br(s, OPC_BNE, TCG_REG_AT, TCG_REG_ZERO);
617 }
618 break;
619 case TCG_COND_LTU:
620 tcg_out_opc_reg(s, OPC_SLTU, TCG_REG_AT, arg1, arg2);
621 tcg_out_opc_br(s, OPC_BNE, TCG_REG_AT, TCG_REG_ZERO);
622 break;
623 case TCG_COND_GE:
624 if (arg2 == 0) {
625 tcg_out_opc_br(s, OPC_BGEZ, 0, arg1);
626 } else {
627 tcg_out_opc_reg(s, OPC_SLT, TCG_REG_AT, arg1, arg2);
628 tcg_out_opc_br(s, OPC_BEQ, TCG_REG_AT, TCG_REG_ZERO);
629 }
630 break;
631 case TCG_COND_GEU:
632 tcg_out_opc_reg(s, OPC_SLTU, TCG_REG_AT, arg1, arg2);
633 tcg_out_opc_br(s, OPC_BEQ, TCG_REG_AT, TCG_REG_ZERO);
634 break;
635 case TCG_COND_LE:
636 if (arg2 == 0) {
637 tcg_out_opc_br(s, OPC_BLEZ, 0, arg1);
638 } else {
639 tcg_out_opc_reg(s, OPC_SLT, TCG_REG_AT, arg2, arg1);
640 tcg_out_opc_br(s, OPC_BEQ, TCG_REG_AT, TCG_REG_ZERO);
641 }
642 break;
643 case TCG_COND_LEU:
644 tcg_out_opc_reg(s, OPC_SLTU, TCG_REG_AT, arg2, arg1);
645 tcg_out_opc_br(s, OPC_BEQ, TCG_REG_AT, TCG_REG_ZERO);
646 break;
647 case TCG_COND_GT:
648 if (arg2 == 0) {
649 tcg_out_opc_br(s, OPC_BGTZ, 0, arg1);
650 } else {
651 tcg_out_opc_reg(s, OPC_SLT, TCG_REG_AT, arg2, arg1);
652 tcg_out_opc_br(s, OPC_BNE, TCG_REG_AT, TCG_REG_ZERO);
653 }
654 break;
655 case TCG_COND_GTU:
656 tcg_out_opc_reg(s, OPC_SLTU, TCG_REG_AT, arg2, arg1);
657 tcg_out_opc_br(s, OPC_BNE, TCG_REG_AT, TCG_REG_ZERO);
658 break;
659 default:
660 tcg_abort();
661 break;
662 }
663 if (l->has_value) {
664 reloc_pc16(s->code_ptr - 4, l->u.value);
665 } else {
666 tcg_out_reloc(s, s->code_ptr - 4, R_MIPS_PC16, label_index, 0);
667 }
668 tcg_out_nop(s);
669 }
670
671 /* XXX: we implement it at the target level to avoid having to
672 handle cross basic blocks temporaries */
673 static void tcg_out_brcond2(TCGContext *s, TCGCond cond, TCGArg arg1,
674 TCGArg arg2, TCGArg arg3, TCGArg arg4,
675 int label_index)
676 {
677 void *label_ptr;
678
679 switch(cond) {
680 case TCG_COND_NE:
681 tcg_out_brcond(s, TCG_COND_NE, arg2, arg4, label_index);
682 tcg_out_brcond(s, TCG_COND_NE, arg1, arg3, label_index);
683 return;
684 case TCG_COND_EQ:
685 break;
686 case TCG_COND_LT:
687 case TCG_COND_LE:
688 tcg_out_brcond(s, TCG_COND_LT, arg2, arg4, label_index);
689 break;
690 case TCG_COND_GT:
691 case TCG_COND_GE:
692 tcg_out_brcond(s, TCG_COND_GT, arg2, arg4, label_index);
693 break;
694 case TCG_COND_LTU:
695 case TCG_COND_LEU:
696 tcg_out_brcond(s, TCG_COND_LTU, arg2, arg4, label_index);
697 break;
698 case TCG_COND_GTU:
699 case TCG_COND_GEU:
700 tcg_out_brcond(s, TCG_COND_GTU, arg2, arg4, label_index);
701 break;
702 default:
703 tcg_abort();
704 }
705
706 label_ptr = s->code_ptr;
707 tcg_out_opc_br(s, OPC_BNE, arg2, arg4);
708 tcg_out_nop(s);
709
710 switch(cond) {
711 case TCG_COND_EQ:
712 tcg_out_brcond(s, TCG_COND_EQ, arg1, arg3, label_index);
713 break;
714 case TCG_COND_LT:
715 case TCG_COND_LTU:
716 tcg_out_brcond(s, TCG_COND_LTU, arg1, arg3, label_index);
717 break;
718 case TCG_COND_LE:
719 case TCG_COND_LEU:
720 tcg_out_brcond(s, TCG_COND_LEU, arg1, arg3, label_index);
721 break;
722 case TCG_COND_GT:
723 case TCG_COND_GTU:
724 tcg_out_brcond(s, TCG_COND_GTU, arg1, arg3, label_index);
725 break;
726 case TCG_COND_GE:
727 case TCG_COND_GEU:
728 tcg_out_brcond(s, TCG_COND_GEU, arg1, arg3, label_index);
729 break;
730 default:
731 tcg_abort();
732 }
733
734 reloc_pc16(label_ptr, (tcg_target_long) s->code_ptr);
735 }
736
737 static void tcg_out_movcond(TCGContext *s, TCGCond cond, TCGReg ret,
738 TCGArg c1, TCGArg c2, TCGArg v)
739 {
740 switch (cond) {
741 case TCG_COND_EQ:
742 if (c1 == 0) {
743 tcg_out_opc_reg(s, OPC_MOVZ, ret, v, c2);
744 } else if (c2 == 0) {
745 tcg_out_opc_reg(s, OPC_MOVZ, ret, v, c1);
746 } else {
747 tcg_out_opc_reg(s, OPC_XOR, TCG_REG_AT, c1, c2);
748 tcg_out_opc_reg(s, OPC_MOVZ, ret, v, TCG_REG_AT);
749 }
750 break;
751 case TCG_COND_NE:
752 if (c1 == 0) {
753 tcg_out_opc_reg(s, OPC_MOVN, ret, v, c2);
754 } else if (c2 == 0) {
755 tcg_out_opc_reg(s, OPC_MOVN, ret, v, c1);
756 } else {
757 tcg_out_opc_reg(s, OPC_XOR, TCG_REG_AT, c1, c2);
758 tcg_out_opc_reg(s, OPC_MOVN, ret, v, TCG_REG_AT);
759 }
760 break;
761 case TCG_COND_LT:
762 tcg_out_opc_reg(s, OPC_SLT, TCG_REG_AT, c1, c2);
763 tcg_out_opc_reg(s, OPC_MOVN, ret, v, TCG_REG_AT);
764 break;
765 case TCG_COND_LTU:
766 tcg_out_opc_reg(s, OPC_SLTU, TCG_REG_AT, c1, c2);
767 tcg_out_opc_reg(s, OPC_MOVN, ret, v, TCG_REG_AT);
768 break;
769 case TCG_COND_GE:
770 tcg_out_opc_reg(s, OPC_SLT, TCG_REG_AT, c1, c2);
771 tcg_out_opc_reg(s, OPC_MOVZ, ret, v, TCG_REG_AT);
772 break;
773 case TCG_COND_GEU:
774 tcg_out_opc_reg(s, OPC_SLTU, TCG_REG_AT, c1, c2);
775 tcg_out_opc_reg(s, OPC_MOVZ, ret, v, TCG_REG_AT);
776 break;
777 case TCG_COND_LE:
778 tcg_out_opc_reg(s, OPC_SLT, TCG_REG_AT, c2, c1);
779 tcg_out_opc_reg(s, OPC_MOVZ, ret, v, TCG_REG_AT);
780 break;
781 case TCG_COND_LEU:
782 tcg_out_opc_reg(s, OPC_SLTU, TCG_REG_AT, c2, c1);
783 tcg_out_opc_reg(s, OPC_MOVZ, ret, v, TCG_REG_AT);
784 break;
785 case TCG_COND_GT:
786 tcg_out_opc_reg(s, OPC_SLT, TCG_REG_AT, c2, c1);
787 tcg_out_opc_reg(s, OPC_MOVN, ret, v, TCG_REG_AT);
788 break;
789 case TCG_COND_GTU:
790 tcg_out_opc_reg(s, OPC_SLTU, TCG_REG_AT, c2, c1);
791 tcg_out_opc_reg(s, OPC_MOVN, ret, v, TCG_REG_AT);
792 break;
793 default:
794 tcg_abort();
795 break;
796 }
797 }
798
799 static void tcg_out_setcond(TCGContext *s, TCGCond cond, TCGReg ret,
800 TCGArg arg1, TCGArg arg2)
801 {
802 switch (cond) {
803 case TCG_COND_EQ:
804 if (arg1 == 0) {
805 tcg_out_opc_imm(s, OPC_SLTIU, ret, arg2, 1);
806 } else if (arg2 == 0) {
807 tcg_out_opc_imm(s, OPC_SLTIU, ret, arg1, 1);
808 } else {
809 tcg_out_opc_reg(s, OPC_XOR, ret, arg1, arg2);
810 tcg_out_opc_imm(s, OPC_SLTIU, ret, ret, 1);
811 }
812 break;
813 case TCG_COND_NE:
814 if (arg1 == 0) {
815 tcg_out_opc_reg(s, OPC_SLTU, ret, TCG_REG_ZERO, arg2);
816 } else if (arg2 == 0) {
817 tcg_out_opc_reg(s, OPC_SLTU, ret, TCG_REG_ZERO, arg1);
818 } else {
819 tcg_out_opc_reg(s, OPC_XOR, ret, arg1, arg2);
820 tcg_out_opc_reg(s, OPC_SLTU, ret, TCG_REG_ZERO, ret);
821 }
822 break;
823 case TCG_COND_LT:
824 tcg_out_opc_reg(s, OPC_SLT, ret, arg1, arg2);
825 break;
826 case TCG_COND_LTU:
827 tcg_out_opc_reg(s, OPC_SLTU, ret, arg1, arg2);
828 break;
829 case TCG_COND_GE:
830 tcg_out_opc_reg(s, OPC_SLT, ret, arg1, arg2);
831 tcg_out_opc_imm(s, OPC_XORI, ret, ret, 1);
832 break;
833 case TCG_COND_GEU:
834 tcg_out_opc_reg(s, OPC_SLTU, ret, arg1, arg2);
835 tcg_out_opc_imm(s, OPC_XORI, ret, ret, 1);
836 break;
837 case TCG_COND_LE:
838 tcg_out_opc_reg(s, OPC_SLT, ret, arg2, arg1);
839 tcg_out_opc_imm(s, OPC_XORI, ret, ret, 1);
840 break;
841 case TCG_COND_LEU:
842 tcg_out_opc_reg(s, OPC_SLTU, ret, arg2, arg1);
843 tcg_out_opc_imm(s, OPC_XORI, ret, ret, 1);
844 break;
845 case TCG_COND_GT:
846 tcg_out_opc_reg(s, OPC_SLT, ret, arg2, arg1);
847 break;
848 case TCG_COND_GTU:
849 tcg_out_opc_reg(s, OPC_SLTU, ret, arg2, arg1);
850 break;
851 default:
852 tcg_abort();
853 break;
854 }
855 }
856
857 /* XXX: we implement it at the target level to avoid having to
858 handle cross basic blocks temporaries */
859 static void tcg_out_setcond2(TCGContext *s, TCGCond cond, TCGReg ret,
860 TCGArg arg1, TCGArg arg2, TCGArg arg3, TCGArg arg4)
861 {
862 switch (cond) {
863 case TCG_COND_EQ:
864 tcg_out_setcond(s, TCG_COND_EQ, TCG_REG_AT, arg2, arg4);
865 tcg_out_setcond(s, TCG_COND_EQ, TCG_REG_T0, arg1, arg3);
866 tcg_out_opc_reg(s, OPC_AND, ret, TCG_REG_AT, TCG_REG_T0);
867 return;
868 case TCG_COND_NE:
869 tcg_out_setcond(s, TCG_COND_NE, TCG_REG_AT, arg2, arg4);
870 tcg_out_setcond(s, TCG_COND_NE, TCG_REG_T0, arg1, arg3);
871 tcg_out_opc_reg(s, OPC_OR, ret, TCG_REG_AT, TCG_REG_T0);
872 return;
873 case TCG_COND_LT:
874 case TCG_COND_LE:
875 tcg_out_setcond(s, TCG_COND_LT, TCG_REG_AT, arg2, arg4);
876 break;
877 case TCG_COND_GT:
878 case TCG_COND_GE:
879 tcg_out_setcond(s, TCG_COND_GT, TCG_REG_AT, arg2, arg4);
880 break;
881 case TCG_COND_LTU:
882 case TCG_COND_LEU:
883 tcg_out_setcond(s, TCG_COND_LTU, TCG_REG_AT, arg2, arg4);
884 break;
885 case TCG_COND_GTU:
886 case TCG_COND_GEU:
887 tcg_out_setcond(s, TCG_COND_GTU, TCG_REG_AT, arg2, arg4);
888 break;
889 default:
890 tcg_abort();
891 break;
892 }
893
894 tcg_out_setcond(s, TCG_COND_EQ, TCG_REG_T0, arg2, arg4);
895
896 switch(cond) {
897 case TCG_COND_LT:
898 case TCG_COND_LTU:
899 tcg_out_setcond(s, TCG_COND_LTU, ret, arg1, arg3);
900 break;
901 case TCG_COND_LE:
902 case TCG_COND_LEU:
903 tcg_out_setcond(s, TCG_COND_LEU, ret, arg1, arg3);
904 break;
905 case TCG_COND_GT:
906 case TCG_COND_GTU:
907 tcg_out_setcond(s, TCG_COND_GTU, ret, arg1, arg3);
908 break;
909 case TCG_COND_GE:
910 case TCG_COND_GEU:
911 tcg_out_setcond(s, TCG_COND_GEU, ret, arg1, arg3);
912 break;
913 default:
914 tcg_abort();
915 }
916
917 tcg_out_opc_reg(s, OPC_AND, ret, ret, TCG_REG_T0);
918 tcg_out_opc_reg(s, OPC_OR, ret, ret, TCG_REG_AT);
919 }
920
921 #if defined(CONFIG_SOFTMMU)
922
923 #include "../../softmmu_defs.h"
924
925 /* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr,
926 int mmu_idx) */
927 static const void * const qemu_ld_helpers[4] = {
928 helper_ldb_mmu,
929 helper_ldw_mmu,
930 helper_ldl_mmu,
931 helper_ldq_mmu,
932 };
933
934 /* helper signature: helper_st_mmu(CPUState *env, target_ulong addr,
935 uintxx_t val, int mmu_idx) */
936 static const void * const qemu_st_helpers[4] = {
937 helper_stb_mmu,
938 helper_stw_mmu,
939 helper_stl_mmu,
940 helper_stq_mmu,
941 };
942 #endif
943
944 static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args,
945 int opc)
946 {
947 TCGReg addr_regl, data_regl, data_regh, data_reg1, data_reg2;
948 #if defined(CONFIG_SOFTMMU)
949 void *label1_ptr, *label2_ptr;
950 int arg_num;
951 int mem_index, s_bits;
952 int addr_meml;
953 # if TARGET_LONG_BITS == 64
954 uint8_t *label3_ptr;
955 TCGReg addr_regh;
956 int addr_memh;
957 # endif
958 #endif
959 data_regl = *args++;
960 if (opc == 3)
961 data_regh = *args++;
962 else
963 data_regh = 0;
964 addr_regl = *args++;
965 #if defined(CONFIG_SOFTMMU)
966 # if TARGET_LONG_BITS == 64
967 addr_regh = *args++;
968 # if defined(TCG_TARGET_WORDS_BIGENDIAN)
969 addr_memh = 0;
970 addr_meml = 4;
971 # else
972 addr_memh = 4;
973 addr_meml = 0;
974 # endif
975 # else
976 addr_meml = 0;
977 # endif
978 mem_index = *args;
979 s_bits = opc & 3;
980 #endif
981
982 if (opc == 3) {
983 #if defined(TCG_TARGET_WORDS_BIGENDIAN)
984 data_reg1 = data_regh;
985 data_reg2 = data_regl;
986 #else
987 data_reg1 = data_regl;
988 data_reg2 = data_regh;
989 #endif
990 } else {
991 data_reg1 = data_regl;
992 data_reg2 = 0;
993 }
994 #if defined(CONFIG_SOFTMMU)
995 tcg_out_opc_sa(s, OPC_SRL, TCG_REG_A0, addr_regl, TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS);
996 tcg_out_opc_imm(s, OPC_ANDI, TCG_REG_A0, TCG_REG_A0, (CPU_TLB_SIZE - 1) << CPU_TLB_ENTRY_BITS);
997 tcg_out_opc_reg(s, OPC_ADDU, TCG_REG_A0, TCG_REG_A0, TCG_AREG0);
998 tcg_out_opc_imm(s, OPC_LW, TCG_REG_AT, TCG_REG_A0,
999 offsetof(CPUArchState, tlb_table[mem_index][0].addr_read) + addr_meml);
1000 tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_T0, TARGET_PAGE_MASK | ((1 << s_bits) - 1));
1001 tcg_out_opc_reg(s, OPC_AND, TCG_REG_T0, TCG_REG_T0, addr_regl);
1002
1003 # if TARGET_LONG_BITS == 64
1004 label3_ptr = s->code_ptr;
1005 tcg_out_opc_br(s, OPC_BNE, TCG_REG_T0, TCG_REG_AT);
1006 tcg_out_nop(s);
1007
1008 tcg_out_opc_imm(s, OPC_LW, TCG_REG_AT, TCG_REG_A0,
1009 offsetof(CPUArchState, tlb_table[mem_index][0].addr_read) + addr_memh);
1010
1011 label1_ptr = s->code_ptr;
1012 tcg_out_opc_br(s, OPC_BEQ, addr_regh, TCG_REG_AT);
1013 tcg_out_nop(s);
1014
1015 reloc_pc16(label3_ptr, (tcg_target_long) s->code_ptr);
1016 # else
1017 label1_ptr = s->code_ptr;
1018 tcg_out_opc_br(s, OPC_BEQ, TCG_REG_T0, TCG_REG_AT);
1019 tcg_out_nop(s);
1020 # endif
1021
1022 /* slow path */
1023 arg_num = 0;
1024 tcg_out_call_iarg_reg32(s, &arg_num, TCG_AREG0);
1025 # if TARGET_LONG_BITS == 64
1026 tcg_out_call_iarg_reg64(s, &arg_num, addr_regl, addr_regh);
1027 # else
1028 tcg_out_call_iarg_reg32(s, &arg_num, addr_regl);
1029 # endif
1030 tcg_out_call_iarg_imm32(s, &arg_num, mem_index);
1031 tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_T9, (tcg_target_long)qemu_ld_helpers[s_bits]);
1032 tcg_out_opc_reg(s, OPC_JALR, TCG_REG_RA, TCG_REG_T9, 0);
1033 tcg_out_nop(s);
1034
1035 switch(opc) {
1036 case 0:
1037 tcg_out_opc_imm(s, OPC_ANDI, data_reg1, TCG_REG_V0, 0xff);
1038 break;
1039 case 0 | 4:
1040 tcg_out_ext8s(s, data_reg1, TCG_REG_V0);
1041 break;
1042 case 1:
1043 tcg_out_opc_imm(s, OPC_ANDI, data_reg1, TCG_REG_V0, 0xffff);
1044 break;
1045 case 1 | 4:
1046 tcg_out_ext16s(s, data_reg1, TCG_REG_V0);
1047 break;
1048 case 2:
1049 tcg_out_mov(s, TCG_TYPE_I32, data_reg1, TCG_REG_V0);
1050 break;
1051 case 3:
1052 tcg_out_mov(s, TCG_TYPE_I32, data_reg2, TCG_REG_V1);
1053 tcg_out_mov(s, TCG_TYPE_I32, data_reg1, TCG_REG_V0);
1054 break;
1055 default:
1056 tcg_abort();
1057 }
1058
1059 label2_ptr = s->code_ptr;
1060 tcg_out_opc_br(s, OPC_BEQ, TCG_REG_ZERO, TCG_REG_ZERO);
1061 tcg_out_nop(s);
1062
1063 /* label1: fast path */
1064 reloc_pc16(label1_ptr, (tcg_target_long) s->code_ptr);
1065
1066 tcg_out_opc_imm(s, OPC_LW, TCG_REG_A0, TCG_REG_A0,
1067 offsetof(CPUArchState, tlb_table[mem_index][0].addend));
1068 tcg_out_opc_reg(s, OPC_ADDU, TCG_REG_V0, TCG_REG_A0, addr_regl);
1069 #else
1070 if (GUEST_BASE == (int16_t)GUEST_BASE) {
1071 tcg_out_opc_imm(s, OPC_ADDIU, TCG_REG_V0, addr_regl, GUEST_BASE);
1072 } else {
1073 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_V0, GUEST_BASE);
1074 tcg_out_opc_reg(s, OPC_ADDU, TCG_REG_V0, TCG_REG_V0, addr_regl);
1075 }
1076 #endif
1077
1078 switch(opc) {
1079 case 0:
1080 tcg_out_opc_imm(s, OPC_LBU, data_reg1, TCG_REG_V0, 0);
1081 break;
1082 case 0 | 4:
1083 tcg_out_opc_imm(s, OPC_LB, data_reg1, TCG_REG_V0, 0);
1084 break;
1085 case 1:
1086 if (TCG_NEED_BSWAP) {
1087 tcg_out_opc_imm(s, OPC_LHU, TCG_REG_T0, TCG_REG_V0, 0);
1088 tcg_out_bswap16(s, data_reg1, TCG_REG_T0);
1089 } else {
1090 tcg_out_opc_imm(s, OPC_LHU, data_reg1, TCG_REG_V0, 0);
1091 }
1092 break;
1093 case 1 | 4:
1094 if (TCG_NEED_BSWAP) {
1095 tcg_out_opc_imm(s, OPC_LHU, TCG_REG_T0, TCG_REG_V0, 0);
1096 tcg_out_bswap16s(s, data_reg1, TCG_REG_T0);
1097 } else {
1098 tcg_out_opc_imm(s, OPC_LH, data_reg1, TCG_REG_V0, 0);
1099 }
1100 break;
1101 case 2:
1102 if (TCG_NEED_BSWAP) {
1103 tcg_out_opc_imm(s, OPC_LW, TCG_REG_T0, TCG_REG_V0, 0);
1104 tcg_out_bswap32(s, data_reg1, TCG_REG_T0);
1105 } else {
1106 tcg_out_opc_imm(s, OPC_LW, data_reg1, TCG_REG_V0, 0);
1107 }
1108 break;
1109 case 3:
1110 if (TCG_NEED_BSWAP) {
1111 tcg_out_opc_imm(s, OPC_LW, TCG_REG_T0, TCG_REG_V0, 4);
1112 tcg_out_bswap32(s, data_reg1, TCG_REG_T0);
1113 tcg_out_opc_imm(s, OPC_LW, TCG_REG_T0, TCG_REG_V0, 0);
1114 tcg_out_bswap32(s, data_reg2, TCG_REG_T0);
1115 } else {
1116 tcg_out_opc_imm(s, OPC_LW, data_reg1, TCG_REG_V0, 0);
1117 tcg_out_opc_imm(s, OPC_LW, data_reg2, TCG_REG_V0, 4);
1118 }
1119 break;
1120 default:
1121 tcg_abort();
1122 }
1123
1124 #if defined(CONFIG_SOFTMMU)
1125 reloc_pc16(label2_ptr, (tcg_target_long) s->code_ptr);
1126 #endif
1127 }
1128
1129 static void tcg_out_qemu_st(TCGContext *s, const TCGArg *args,
1130 int opc)
1131 {
1132 TCGReg addr_regl, data_regl, data_regh, data_reg1, data_reg2;
1133 #if defined(CONFIG_SOFTMMU)
1134 uint8_t *label1_ptr, *label2_ptr;
1135 int arg_num;
1136 int mem_index, s_bits;
1137 int addr_meml;
1138 #endif
1139 #if TARGET_LONG_BITS == 64
1140 # if defined(CONFIG_SOFTMMU)
1141 uint8_t *label3_ptr;
1142 TCGReg addr_regh;
1143 int addr_memh;
1144 # endif
1145 #endif
1146 data_regl = *args++;
1147 if (opc == 3) {
1148 data_regh = *args++;
1149 } else {
1150 data_regh = 0;
1151 }
1152 addr_regl = *args++;
1153 #if defined(CONFIG_SOFTMMU)
1154 # if TARGET_LONG_BITS == 64
1155 addr_regh = *args++;
1156 # if defined(TCG_TARGET_WORDS_BIGENDIAN)
1157 addr_memh = 0;
1158 addr_meml = 4;
1159 # else
1160 addr_memh = 4;
1161 addr_meml = 0;
1162 # endif
1163 # else
1164 addr_meml = 0;
1165 # endif
1166 mem_index = *args;
1167 s_bits = opc;
1168 #endif
1169
1170 if (opc == 3) {
1171 #if defined(TCG_TARGET_WORDS_BIGENDIAN)
1172 data_reg1 = data_regh;
1173 data_reg2 = data_regl;
1174 #else
1175 data_reg1 = data_regl;
1176 data_reg2 = data_regh;
1177 #endif
1178 } else {
1179 data_reg1 = data_regl;
1180 data_reg2 = 0;
1181 }
1182
1183 #if defined(CONFIG_SOFTMMU)
1184 tcg_out_opc_sa(s, OPC_SRL, TCG_REG_A0, addr_regl, TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS);
1185 tcg_out_opc_imm(s, OPC_ANDI, TCG_REG_A0, TCG_REG_A0, (CPU_TLB_SIZE - 1) << CPU_TLB_ENTRY_BITS);
1186 tcg_out_opc_reg(s, OPC_ADDU, TCG_REG_A0, TCG_REG_A0, TCG_AREG0);
1187 tcg_out_opc_imm(s, OPC_LW, TCG_REG_AT, TCG_REG_A0,
1188 offsetof(CPUArchState, tlb_table[mem_index][0].addr_write) + addr_meml);
1189 tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_T0, TARGET_PAGE_MASK | ((1 << s_bits) - 1));
1190 tcg_out_opc_reg(s, OPC_AND, TCG_REG_T0, TCG_REG_T0, addr_regl);
1191
1192 # if TARGET_LONG_BITS == 64
1193 label3_ptr = s->code_ptr;
1194 tcg_out_opc_br(s, OPC_BNE, TCG_REG_T0, TCG_REG_AT);
1195 tcg_out_nop(s);
1196
1197 tcg_out_opc_imm(s, OPC_LW, TCG_REG_AT, TCG_REG_A0,
1198 offsetof(CPUArchState, tlb_table[mem_index][0].addr_write) + addr_memh);
1199
1200 label1_ptr = s->code_ptr;
1201 tcg_out_opc_br(s, OPC_BEQ, addr_regh, TCG_REG_AT);
1202 tcg_out_nop(s);
1203
1204 reloc_pc16(label3_ptr, (tcg_target_long) s->code_ptr);
1205 # else
1206 label1_ptr = s->code_ptr;
1207 tcg_out_opc_br(s, OPC_BEQ, TCG_REG_T0, TCG_REG_AT);
1208 tcg_out_nop(s);
1209 # endif
1210
1211 /* slow path */
1212 arg_num = 0;
1213 tcg_out_call_iarg_reg32(s, &arg_num, TCG_AREG0);
1214 # if TARGET_LONG_BITS == 64
1215 tcg_out_call_iarg_reg64(s, &arg_num, addr_regl, addr_regh);
1216 # else
1217 tcg_out_call_iarg_reg32(s, &arg_num, addr_regl);
1218 # endif
1219 switch(opc) {
1220 case 0:
1221 tcg_out_call_iarg_reg8(s, &arg_num, data_regl);
1222 break;
1223 case 1:
1224 tcg_out_call_iarg_reg16(s, &arg_num, data_regl);
1225 break;
1226 case 2:
1227 tcg_out_call_iarg_reg32(s, &arg_num, data_regl);
1228 break;
1229 case 3:
1230 tcg_out_call_iarg_reg64(s, &arg_num, data_regl, data_regh);
1231 break;
1232 default:
1233 tcg_abort();
1234 }
1235 tcg_out_call_iarg_imm32(s, &arg_num, mem_index);
1236 tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_T9, (tcg_target_long)qemu_st_helpers[s_bits]);
1237 tcg_out_opc_reg(s, OPC_JALR, TCG_REG_RA, TCG_REG_T9, 0);
1238 tcg_out_nop(s);
1239
1240 label2_ptr = s->code_ptr;
1241 tcg_out_opc_br(s, OPC_BEQ, TCG_REG_ZERO, TCG_REG_ZERO);
1242 tcg_out_nop(s);
1243
1244 /* label1: fast path */
1245 reloc_pc16(label1_ptr, (tcg_target_long) s->code_ptr);
1246
1247 tcg_out_opc_imm(s, OPC_LW, TCG_REG_A0, TCG_REG_A0,
1248 offsetof(CPUArchState, tlb_table[mem_index][0].addend));
1249 tcg_out_opc_reg(s, OPC_ADDU, TCG_REG_A0, TCG_REG_A0, addr_regl);
1250 #else
1251 if (GUEST_BASE == (int16_t)GUEST_BASE) {
1252 tcg_out_opc_imm(s, OPC_ADDIU, TCG_REG_A0, addr_regl, GUEST_BASE);
1253 } else {
1254 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_A0, GUEST_BASE);
1255 tcg_out_opc_reg(s, OPC_ADDU, TCG_REG_A0, TCG_REG_A0, addr_regl);
1256 }
1257
1258 #endif
1259
1260 switch(opc) {
1261 case 0:
1262 tcg_out_opc_imm(s, OPC_SB, data_reg1, TCG_REG_A0, 0);
1263 break;
1264 case 1:
1265 if (TCG_NEED_BSWAP) {
1266 tcg_out_opc_imm(s, OPC_ANDI, TCG_REG_T0, data_reg1, 0xffff);
1267 tcg_out_bswap16(s, TCG_REG_T0, TCG_REG_T0);
1268 tcg_out_opc_imm(s, OPC_SH, TCG_REG_T0, TCG_REG_A0, 0);
1269 } else {
1270 tcg_out_opc_imm(s, OPC_SH, data_reg1, TCG_REG_A0, 0);
1271 }
1272 break;
1273 case 2:
1274 if (TCG_NEED_BSWAP) {
1275 tcg_out_bswap32(s, TCG_REG_T0, data_reg1);
1276 tcg_out_opc_imm(s, OPC_SW, TCG_REG_T0, TCG_REG_A0, 0);
1277 } else {
1278 tcg_out_opc_imm(s, OPC_SW, data_reg1, TCG_REG_A0, 0);
1279 }
1280 break;
1281 case 3:
1282 if (TCG_NEED_BSWAP) {
1283 tcg_out_bswap32(s, TCG_REG_T0, data_reg2);
1284 tcg_out_opc_imm(s, OPC_SW, TCG_REG_T0, TCG_REG_A0, 0);
1285 tcg_out_bswap32(s, TCG_REG_T0, data_reg1);
1286 tcg_out_opc_imm(s, OPC_SW, TCG_REG_T0, TCG_REG_A0, 4);
1287 } else {
1288 tcg_out_opc_imm(s, OPC_SW, data_reg1, TCG_REG_A0, 0);
1289 tcg_out_opc_imm(s, OPC_SW, data_reg2, TCG_REG_A0, 4);
1290 }
1291 break;
1292 default:
1293 tcg_abort();
1294 }
1295
1296 #if defined(CONFIG_SOFTMMU)
1297 reloc_pc16(label2_ptr, (tcg_target_long) s->code_ptr);
1298 #endif
1299 }
1300
1301 static inline void tcg_out_op(TCGContext *s, TCGOpcode opc,
1302 const TCGArg *args, const int *const_args)
1303 {
1304 switch(opc) {
1305 case INDEX_op_exit_tb:
1306 tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_V0, args[0]);
1307 tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_AT, (tcg_target_long)tb_ret_addr);
1308 tcg_out_opc_reg(s, OPC_JR, 0, TCG_REG_AT, 0);
1309 tcg_out_nop(s);
1310 break;
1311 case INDEX_op_goto_tb:
1312 if (s->tb_jmp_offset) {
1313 /* direct jump method */
1314 tcg_abort();
1315 } else {
1316 /* indirect jump method */
1317 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_AT, (tcg_target_long)(s->tb_next + args[0]));
1318 tcg_out_ld(s, TCG_TYPE_PTR, TCG_REG_AT, TCG_REG_AT, 0);
1319 tcg_out_opc_reg(s, OPC_JR, 0, TCG_REG_AT, 0);
1320 }
1321 tcg_out_nop(s);
1322 s->tb_next_offset[args[0]] = s->code_ptr - s->code_buf;
1323 break;
1324 case INDEX_op_call:
1325 tcg_out_opc_reg(s, OPC_JALR, TCG_REG_RA, args[0], 0);
1326 tcg_out_nop(s);
1327 break;
1328 case INDEX_op_br:
1329 tcg_out_brcond(s, TCG_COND_EQ, TCG_REG_ZERO, TCG_REG_ZERO, args[0]);
1330 break;
1331
1332 case INDEX_op_mov_i32:
1333 tcg_out_mov(s, TCG_TYPE_I32, args[0], args[1]);
1334 break;
1335 case INDEX_op_movi_i32:
1336 tcg_out_movi(s, TCG_TYPE_I32, args[0], args[1]);
1337 break;
1338
1339 case INDEX_op_ld8u_i32:
1340 tcg_out_ldst(s, OPC_LBU, args[0], args[1], args[2]);
1341 break;
1342 case INDEX_op_ld8s_i32:
1343 tcg_out_ldst(s, OPC_LB, args[0], args[1], args[2]);
1344 break;
1345 case INDEX_op_ld16u_i32:
1346 tcg_out_ldst(s, OPC_LHU, args[0], args[1], args[2]);
1347 break;
1348 case INDEX_op_ld16s_i32:
1349 tcg_out_ldst(s, OPC_LH, args[0], args[1], args[2]);
1350 break;
1351 case INDEX_op_ld_i32:
1352 tcg_out_ldst(s, OPC_LW, args[0], args[1], args[2]);
1353 break;
1354 case INDEX_op_st8_i32:
1355 tcg_out_ldst(s, OPC_SB, args[0], args[1], args[2]);
1356 break;
1357 case INDEX_op_st16_i32:
1358 tcg_out_ldst(s, OPC_SH, args[0], args[1], args[2]);
1359 break;
1360 case INDEX_op_st_i32:
1361 tcg_out_ldst(s, OPC_SW, args[0], args[1], args[2]);
1362 break;
1363
1364 case INDEX_op_add_i32:
1365 if (const_args[2]) {
1366 tcg_out_opc_imm(s, OPC_ADDIU, args[0], args[1], args[2]);
1367 } else {
1368 tcg_out_opc_reg(s, OPC_ADDU, args[0], args[1], args[2]);
1369 }
1370 break;
1371 case INDEX_op_add2_i32:
1372 if (const_args[4]) {
1373 tcg_out_opc_imm(s, OPC_ADDIU, TCG_REG_AT, args[2], args[4]);
1374 } else {
1375 tcg_out_opc_reg(s, OPC_ADDU, TCG_REG_AT, args[2], args[4]);
1376 }
1377 tcg_out_opc_reg(s, OPC_SLTU, TCG_REG_T0, TCG_REG_AT, args[2]);
1378 if (const_args[5]) {
1379 tcg_out_opc_imm(s, OPC_ADDIU, args[1], args[3], args[5]);
1380 } else {
1381 tcg_out_opc_reg(s, OPC_ADDU, args[1], args[3], args[5]);
1382 }
1383 tcg_out_opc_reg(s, OPC_ADDU, args[1], args[1], TCG_REG_T0);
1384 tcg_out_mov(s, TCG_TYPE_I32, args[0], TCG_REG_AT);
1385 break;
1386 case INDEX_op_sub_i32:
1387 if (const_args[2]) {
1388 tcg_out_opc_imm(s, OPC_ADDIU, args[0], args[1], -args[2]);
1389 } else {
1390 tcg_out_opc_reg(s, OPC_SUBU, args[0], args[1], args[2]);
1391 }
1392 break;
1393 case INDEX_op_sub2_i32:
1394 if (const_args[4]) {
1395 tcg_out_opc_imm(s, OPC_ADDIU, TCG_REG_AT, args[2], -args[4]);
1396 } else {
1397 tcg_out_opc_reg(s, OPC_SUBU, TCG_REG_AT, args[2], args[4]);
1398 }
1399 tcg_out_opc_reg(s, OPC_SLTU, TCG_REG_T0, args[2], TCG_REG_AT);
1400 if (const_args[5]) {
1401 tcg_out_opc_imm(s, OPC_ADDIU, args[1], args[3], -args[5]);
1402 } else {
1403 tcg_out_opc_reg(s, OPC_SUBU, args[1], args[3], args[5]);
1404 }
1405 tcg_out_opc_reg(s, OPC_SUBU, args[1], args[1], TCG_REG_T0);
1406 tcg_out_mov(s, TCG_TYPE_I32, args[0], TCG_REG_AT);
1407 break;
1408 case INDEX_op_mul_i32:
1409 #if defined(__mips_isa_rev) && (__mips_isa_rev >= 1)
1410 tcg_out_opc_reg(s, OPC_MUL, args[0], args[1], args[2]);
1411 #else
1412 tcg_out_opc_reg(s, OPC_MULT, 0, args[1], args[2]);
1413 tcg_out_opc_reg(s, OPC_MFLO, args[0], 0, 0);
1414 #endif
1415 break;
1416 case INDEX_op_mulu2_i32:
1417 tcg_out_opc_reg(s, OPC_MULTU, 0, args[2], args[3]);
1418 tcg_out_opc_reg(s, OPC_MFLO, args[0], 0, 0);
1419 tcg_out_opc_reg(s, OPC_MFHI, args[1], 0, 0);
1420 break;
1421 case INDEX_op_div_i32:
1422 tcg_out_opc_reg(s, OPC_DIV, 0, args[1], args[2]);
1423 tcg_out_opc_reg(s, OPC_MFLO, args[0], 0, 0);
1424 break;
1425 case INDEX_op_divu_i32:
1426 tcg_out_opc_reg(s, OPC_DIVU, 0, args[1], args[2]);
1427 tcg_out_opc_reg(s, OPC_MFLO, args[0], 0, 0);
1428 break;
1429 case INDEX_op_rem_i32:
1430 tcg_out_opc_reg(s, OPC_DIV, 0, args[1], args[2]);
1431 tcg_out_opc_reg(s, OPC_MFHI, args[0], 0, 0);
1432 break;
1433 case INDEX_op_remu_i32:
1434 tcg_out_opc_reg(s, OPC_DIVU, 0, args[1], args[2]);
1435 tcg_out_opc_reg(s, OPC_MFHI, args[0], 0, 0);
1436 break;
1437
1438 case INDEX_op_and_i32:
1439 if (const_args[2]) {
1440 tcg_out_opc_imm(s, OPC_ANDI, args[0], args[1], args[2]);
1441 } else {
1442 tcg_out_opc_reg(s, OPC_AND, args[0], args[1], args[2]);
1443 }
1444 break;
1445 case INDEX_op_or_i32:
1446 if (const_args[2]) {
1447 tcg_out_opc_imm(s, OPC_ORI, args[0], args[1], args[2]);
1448 } else {
1449 tcg_out_opc_reg(s, OPC_OR, args[0], args[1], args[2]);
1450 }
1451 break;
1452 case INDEX_op_nor_i32:
1453 tcg_out_opc_reg(s, OPC_NOR, args[0], args[1], args[2]);
1454 break;
1455 case INDEX_op_not_i32:
1456 tcg_out_opc_reg(s, OPC_NOR, args[0], TCG_REG_ZERO, args[1]);
1457 break;
1458 case INDEX_op_xor_i32:
1459 if (const_args[2]) {
1460 tcg_out_opc_imm(s, OPC_XORI, args[0], args[1], args[2]);
1461 } else {
1462 tcg_out_opc_reg(s, OPC_XOR, args[0], args[1], args[2]);
1463 }
1464 break;
1465
1466 case INDEX_op_sar_i32:
1467 if (const_args[2]) {
1468 tcg_out_opc_sa(s, OPC_SRA, args[0], args[1], args[2]);
1469 } else {
1470 tcg_out_opc_reg(s, OPC_SRAV, args[0], args[2], args[1]);
1471 }
1472 break;
1473 case INDEX_op_shl_i32:
1474 if (const_args[2]) {
1475 tcg_out_opc_sa(s, OPC_SLL, args[0], args[1], args[2]);
1476 } else {
1477 tcg_out_opc_reg(s, OPC_SLLV, args[0], args[2], args[1]);
1478 }
1479 break;
1480 case INDEX_op_shr_i32:
1481 if (const_args[2]) {
1482 tcg_out_opc_sa(s, OPC_SRL, args[0], args[1], args[2]);
1483 } else {
1484 tcg_out_opc_reg(s, OPC_SRLV, args[0], args[2], args[1]);
1485 }
1486 break;
1487 case INDEX_op_rotl_i32:
1488 if (const_args[2]) {
1489 tcg_out_opc_sa(s, OPC_ROTR, args[0], args[1], 0x20 - args[2]);
1490 } else {
1491 tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_AT, 32);
1492 tcg_out_opc_reg(s, OPC_SUBU, TCG_REG_AT, TCG_REG_AT, args[2]);
1493 tcg_out_opc_reg(s, OPC_ROTRV, args[0], TCG_REG_AT, args[1]);
1494 }
1495 break;
1496 case INDEX_op_rotr_i32:
1497 if (const_args[2]) {
1498 tcg_out_opc_sa(s, OPC_ROTR, args[0], args[1], args[2]);
1499 } else {
1500 tcg_out_opc_reg(s, OPC_ROTRV, args[0], args[2], args[1]);
1501 }
1502 break;
1503
1504 /* The bswap routines do not work on non-R2 CPU. In that case
1505 we let TCG generating the corresponding code. */
1506 case INDEX_op_bswap16_i32:
1507 tcg_out_bswap16(s, args[0], args[1]);
1508 break;
1509 case INDEX_op_bswap32_i32:
1510 tcg_out_bswap32(s, args[0], args[1]);
1511 break;
1512
1513 case INDEX_op_ext8s_i32:
1514 tcg_out_ext8s(s, args[0], args[1]);
1515 break;
1516 case INDEX_op_ext16s_i32:
1517 tcg_out_ext16s(s, args[0], args[1]);
1518 break;
1519
1520 case INDEX_op_deposit_i32:
1521 tcg_out_opc_imm(s, OPC_INS, args[0], args[2],
1522 ((args[3] + args[4] - 1) << 11) | (args[3] << 6));
1523 break;
1524
1525 case INDEX_op_brcond_i32:
1526 tcg_out_brcond(s, args[2], args[0], args[1], args[3]);
1527 break;
1528 case INDEX_op_brcond2_i32:
1529 tcg_out_brcond2(s, args[4], args[0], args[1], args[2], args[3], args[5]);
1530 break;
1531
1532 case INDEX_op_movcond_i32:
1533 tcg_out_movcond(s, args[5], args[0], args[1], args[2], args[3]);
1534 break;
1535
1536 case INDEX_op_setcond_i32:
1537 tcg_out_setcond(s, args[3], args[0], args[1], args[2]);
1538 break;
1539 case INDEX_op_setcond2_i32:
1540 tcg_out_setcond2(s, args[5], args[0], args[1], args[2], args[3], args[4]);
1541 break;
1542
1543 case INDEX_op_qemu_ld8u:
1544 tcg_out_qemu_ld(s, args, 0);
1545 break;
1546 case INDEX_op_qemu_ld8s:
1547 tcg_out_qemu_ld(s, args, 0 | 4);
1548 break;
1549 case INDEX_op_qemu_ld16u:
1550 tcg_out_qemu_ld(s, args, 1);
1551 break;
1552 case INDEX_op_qemu_ld16s:
1553 tcg_out_qemu_ld(s, args, 1 | 4);
1554 break;
1555 case INDEX_op_qemu_ld32:
1556 tcg_out_qemu_ld(s, args, 2);
1557 break;
1558 case INDEX_op_qemu_ld64:
1559 tcg_out_qemu_ld(s, args, 3);
1560 break;
1561 case INDEX_op_qemu_st8:
1562 tcg_out_qemu_st(s, args, 0);
1563 break;
1564 case INDEX_op_qemu_st16:
1565 tcg_out_qemu_st(s, args, 1);
1566 break;
1567 case INDEX_op_qemu_st32:
1568 tcg_out_qemu_st(s, args, 2);
1569 break;
1570 case INDEX_op_qemu_st64:
1571 tcg_out_qemu_st(s, args, 3);
1572 break;
1573
1574 default:
1575 tcg_abort();
1576 }
1577 }
1578
1579 static const TCGTargetOpDef mips_op_defs[] = {
1580 { INDEX_op_exit_tb, { } },
1581 { INDEX_op_goto_tb, { } },
1582 { INDEX_op_call, { "C" } },
1583 { INDEX_op_br, { } },
1584
1585 { INDEX_op_mov_i32, { "r", "r" } },
1586 { INDEX_op_movi_i32, { "r" } },
1587 { INDEX_op_ld8u_i32, { "r", "r" } },
1588 { INDEX_op_ld8s_i32, { "r", "r" } },
1589 { INDEX_op_ld16u_i32, { "r", "r" } },
1590 { INDEX_op_ld16s_i32, { "r", "r" } },
1591 { INDEX_op_ld_i32, { "r", "r" } },
1592 { INDEX_op_st8_i32, { "rZ", "r" } },
1593 { INDEX_op_st16_i32, { "rZ", "r" } },
1594 { INDEX_op_st_i32, { "rZ", "r" } },
1595
1596 { INDEX_op_add_i32, { "r", "rZ", "rJ" } },
1597 { INDEX_op_mul_i32, { "r", "rZ", "rZ" } },
1598 { INDEX_op_mulu2_i32, { "r", "r", "rZ", "rZ" } },
1599 { INDEX_op_div_i32, { "r", "rZ", "rZ" } },
1600 { INDEX_op_divu_i32, { "r", "rZ", "rZ" } },
1601 { INDEX_op_rem_i32, { "r", "rZ", "rZ" } },
1602 { INDEX_op_remu_i32, { "r", "rZ", "rZ" } },
1603 { INDEX_op_sub_i32, { "r", "rZ", "rJ" } },
1604
1605 { INDEX_op_and_i32, { "r", "rZ", "rI" } },
1606 { INDEX_op_nor_i32, { "r", "rZ", "rZ" } },
1607 { INDEX_op_not_i32, { "r", "rZ" } },
1608 { INDEX_op_or_i32, { "r", "rZ", "rIZ" } },
1609 { INDEX_op_xor_i32, { "r", "rZ", "rIZ" } },
1610
1611 { INDEX_op_shl_i32, { "r", "rZ", "ri" } },
1612 { INDEX_op_shr_i32, { "r", "rZ", "ri" } },
1613 { INDEX_op_sar_i32, { "r", "rZ", "ri" } },
1614 { INDEX_op_rotr_i32, { "r", "rZ", "ri" } },
1615 { INDEX_op_rotl_i32, { "r", "rZ", "ri" } },
1616
1617 { INDEX_op_bswap16_i32, { "r", "r" } },
1618 { INDEX_op_bswap32_i32, { "r", "r" } },
1619
1620 { INDEX_op_ext8s_i32, { "r", "rZ" } },
1621 { INDEX_op_ext16s_i32, { "r", "rZ" } },
1622
1623 { INDEX_op_deposit_i32, { "r", "0", "rZ" } },
1624
1625 { INDEX_op_brcond_i32, { "rZ", "rZ" } },
1626 { INDEX_op_movcond_i32, { "r", "rZ", "rZ", "rZ", "0" } },
1627 { INDEX_op_setcond_i32, { "r", "rZ", "rZ" } },
1628 { INDEX_op_setcond2_i32, { "r", "rZ", "rZ", "rZ", "rZ" } },
1629
1630 { INDEX_op_add2_i32, { "r", "r", "rZ", "rZ", "rJ", "rJ" } },
1631 { INDEX_op_sub2_i32, { "r", "r", "rZ", "rZ", "rJ", "rJ" } },
1632 { INDEX_op_brcond2_i32, { "rZ", "rZ", "rZ", "rZ" } },
1633
1634 #if TARGET_LONG_BITS == 32
1635 { INDEX_op_qemu_ld8u, { "L", "lZ" } },
1636 { INDEX_op_qemu_ld8s, { "L", "lZ" } },
1637 { INDEX_op_qemu_ld16u, { "L", "lZ" } },
1638 { INDEX_op_qemu_ld16s, { "L", "lZ" } },
1639 { INDEX_op_qemu_ld32, { "L", "lZ" } },
1640 { INDEX_op_qemu_ld64, { "L", "L", "lZ" } },
1641
1642 { INDEX_op_qemu_st8, { "SZ", "SZ" } },
1643 { INDEX_op_qemu_st16, { "SZ", "SZ" } },
1644 { INDEX_op_qemu_st32, { "SZ", "SZ" } },
1645 { INDEX_op_qemu_st64, { "SZ", "SZ", "SZ" } },
1646 #else
1647 { INDEX_op_qemu_ld8u, { "L", "lZ", "lZ" } },
1648 { INDEX_op_qemu_ld8s, { "L", "lZ", "lZ" } },
1649 { INDEX_op_qemu_ld16u, { "L", "lZ", "lZ" } },
1650 { INDEX_op_qemu_ld16s, { "L", "lZ", "lZ" } },
1651 { INDEX_op_qemu_ld32, { "L", "lZ", "lZ" } },
1652 { INDEX_op_qemu_ld64, { "L", "L", "lZ", "lZ" } },
1653
1654 { INDEX_op_qemu_st8, { "SZ", "SZ", "SZ" } },
1655 { INDEX_op_qemu_st16, { "SZ", "SZ", "SZ" } },
1656 { INDEX_op_qemu_st32, { "SZ", "SZ", "SZ" } },
1657 { INDEX_op_qemu_st64, { "SZ", "SZ", "SZ", "SZ" } },
1658 #endif
1659 { -1 },
1660 };
1661
1662 static int tcg_target_callee_save_regs[] = {
1663 TCG_REG_S0, /* used for the global env (TCG_AREG0) */
1664 TCG_REG_S1,
1665 TCG_REG_S2,
1666 TCG_REG_S3,
1667 TCG_REG_S4,
1668 TCG_REG_S5,
1669 TCG_REG_S6,
1670 TCG_REG_S7,
1671 TCG_REG_FP,
1672 TCG_REG_RA, /* should be last for ABI compliance */
1673 };
1674
1675 /* Generate global QEMU prologue and epilogue code */
1676 static void tcg_target_qemu_prologue(TCGContext *s)
1677 {
1678 int i, frame_size;
1679
1680 /* reserve some stack space, also for TCG temps. */
1681 frame_size = ARRAY_SIZE(tcg_target_callee_save_regs) * 4
1682 + TCG_STATIC_CALL_ARGS_SIZE
1683 + CPU_TEMP_BUF_NLONGS * sizeof(long);
1684 frame_size = (frame_size + TCG_TARGET_STACK_ALIGN - 1) &
1685 ~(TCG_TARGET_STACK_ALIGN - 1);
1686 tcg_set_frame(s, TCG_REG_SP, ARRAY_SIZE(tcg_target_callee_save_regs) * 4
1687 + TCG_STATIC_CALL_ARGS_SIZE,
1688 CPU_TEMP_BUF_NLONGS * sizeof(long));
1689
1690 /* TB prologue */
1691 tcg_out_addi(s, TCG_REG_SP, -frame_size);
1692 for(i = 0 ; i < ARRAY_SIZE(tcg_target_callee_save_regs) ; i++) {
1693 tcg_out_st(s, TCG_TYPE_I32, tcg_target_callee_save_regs[i],
1694 TCG_REG_SP, TCG_STATIC_CALL_ARGS_SIZE + i * 4);
1695 }
1696
1697 /* Call generated code */
1698 tcg_out_opc_reg(s, OPC_JR, 0, tcg_target_call_iarg_regs[1], 0);
1699 tcg_out_mov(s, TCG_TYPE_PTR, TCG_AREG0, tcg_target_call_iarg_regs[0]);
1700 tb_ret_addr = s->code_ptr;
1701
1702 /* TB epilogue */
1703 for(i = 0 ; i < ARRAY_SIZE(tcg_target_callee_save_regs) ; i++) {
1704 tcg_out_ld(s, TCG_TYPE_I32, tcg_target_callee_save_regs[i],
1705 TCG_REG_SP, TCG_STATIC_CALL_ARGS_SIZE + i * 4);
1706 }
1707
1708 tcg_out_opc_reg(s, OPC_JR, 0, TCG_REG_RA, 0);
1709 tcg_out_addi(s, TCG_REG_SP, frame_size);
1710 }
1711
1712 static void tcg_target_init(TCGContext *s)
1713 {
1714 tcg_regset_set(tcg_target_available_regs[TCG_TYPE_I32], 0xffffffff);
1715 tcg_regset_set(tcg_target_call_clobber_regs,
1716 (1 << TCG_REG_V0) |
1717 (1 << TCG_REG_V1) |
1718 (1 << TCG_REG_A0) |
1719 (1 << TCG_REG_A1) |
1720 (1 << TCG_REG_A2) |
1721 (1 << TCG_REG_A3) |
1722 (1 << TCG_REG_T1) |
1723 (1 << TCG_REG_T2) |
1724 (1 << TCG_REG_T3) |
1725 (1 << TCG_REG_T4) |
1726 (1 << TCG_REG_T5) |
1727 (1 << TCG_REG_T6) |
1728 (1 << TCG_REG_T7) |
1729 (1 << TCG_REG_T8) |
1730 (1 << TCG_REG_T9));
1731
1732 tcg_regset_clear(s->reserved_regs);
1733 tcg_regset_set_reg(s->reserved_regs, TCG_REG_ZERO); /* zero register */
1734 tcg_regset_set_reg(s->reserved_regs, TCG_REG_K0); /* kernel use only */
1735 tcg_regset_set_reg(s->reserved_regs, TCG_REG_K1); /* kernel use only */
1736 tcg_regset_set_reg(s->reserved_regs, TCG_REG_AT); /* internal use */
1737 tcg_regset_set_reg(s->reserved_regs, TCG_REG_T0); /* internal use */
1738 tcg_regset_set_reg(s->reserved_regs, TCG_REG_RA); /* return address */
1739 tcg_regset_set_reg(s->reserved_regs, TCG_REG_SP); /* stack pointer */
1740 tcg_regset_set_reg(s->reserved_regs, TCG_REG_GP); /* global pointer */
1741
1742 tcg_add_target_add_op_defs(mips_op_defs);
1743 }
QEMU mirror