?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s390x/virtio: old machine leftovers
[qemu.git] / tcg / ppc / tcg-target.inc.c
blob8c1c2dfa9b227b1249b81ada09685a689a8f9413
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
25 #include "tcg-be-ldst.h"
26
27 #if defined _CALL_DARWIN || defined __APPLE__
28 #define TCG_TARGET_CALL_DARWIN
29 #endif
30 #ifdef _CALL_SYSV
31 # define TCG_TARGET_CALL_ALIGN_ARGS 1
32 #endif
33
34 /* For some memory operations, we need a scratch that isn't R0. For the AIX
35 calling convention, we can re-use the TOC register since we'll be reloading
36 it at every call. Otherwise R12 will do nicely as neither a call-saved
37 register nor a parameter register. */
38 #ifdef _CALL_AIX
39 # define TCG_REG_TMP1 TCG_REG_R2
40 #else
41 # define TCG_REG_TMP1 TCG_REG_R12
42 #endif
43
44 /* For the 64-bit target, we don't like the 5 insn sequence needed to build
45 full 64-bit addresses. Better to have a base register to which we can
46 apply a 32-bit displacement.
47
48 There are generally three items of interest:
49 (1) helper functions in the main executable,
50 (2) TranslationBlock data structures,
51 (3) the return address in the epilogue.
52
53 For user-only, we USE_STATIC_CODE_GEN_BUFFER, so the code_gen_buffer
54 will be inside the main executable, and thus near enough to make a
55 pointer to the epilogue be within 2GB of all helper functions.
56
57 For softmmu, we'll let the kernel choose the address of code_gen_buffer,
58 and odds are it'll be somewhere close to the main malloc arena, and so
59 a pointer to the epilogue will be within 2GB of the TranslationBlocks.
60
61 For --enable-pie, everything will be kinda near everything else,
62 somewhere in high memory.
63
64 Thus we choose to keep the return address in a call-saved register. */
65 #define TCG_REG_RA TCG_REG_R31
66 #define USE_REG_RA (TCG_TARGET_REG_BITS == 64)
67
68 /* Shorthand for size of a pointer. Avoid promotion to unsigned. */
69 #define SZP ((int)sizeof(void *))
70
71 /* Shorthand for size of a register. */
72 #define SZR (TCG_TARGET_REG_BITS / 8)
73
74 #define TCG_CT_CONST_S16 0x100
75 #define TCG_CT_CONST_U16 0x200
76 #define TCG_CT_CONST_S32 0x400
77 #define TCG_CT_CONST_U32 0x800
78 #define TCG_CT_CONST_ZERO 0x1000
79 #define TCG_CT_CONST_MONE 0x2000
80
81 static tcg_insn_unit *tb_ret_addr;
82
83 #include "elf.h"
84 static bool have_isa_2_06;
85 #define HAVE_ISA_2_06 have_isa_2_06
86 #define HAVE_ISEL have_isa_2_06
87
88 #ifndef CONFIG_SOFTMMU
89 #define TCG_GUEST_BASE_REG 30
90 #endif
91
92 #ifndef NDEBUG
93 static const char * const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {
94 "r0",
95 "r1",
96 "r2",
97 "r3",
98 "r4",
99 "r5",
100 "r6",
101 "r7",
102 "r8",
103 "r9",
104 "r10",
105 "r11",
106 "r12",
107 "r13",
108 "r14",
109 "r15",
110 "r16",
111 "r17",
112 "r18",
113 "r19",
114 "r20",
115 "r21",
116 "r22",
117 "r23",
118 "r24",
119 "r25",
120 "r26",
121 "r27",
122 "r28",
123 "r29",
124 "r30",
125 "r31"
126 };
127 #endif
128
129 static const int tcg_target_reg_alloc_order[] = {
130 TCG_REG_R14, /* call saved registers */
131 TCG_REG_R15,
132 TCG_REG_R16,
133 TCG_REG_R17,
134 TCG_REG_R18,
135 TCG_REG_R19,
136 TCG_REG_R20,
137 TCG_REG_R21,
138 TCG_REG_R22,
139 TCG_REG_R23,
140 TCG_REG_R24,
141 TCG_REG_R25,
142 TCG_REG_R26,
143 TCG_REG_R27,
144 TCG_REG_R28,
145 TCG_REG_R29,
146 TCG_REG_R30,
147 TCG_REG_R31,
148 TCG_REG_R12, /* call clobbered, non-arguments */
149 TCG_REG_R11,
150 TCG_REG_R2,
151 TCG_REG_R13,
152 TCG_REG_R10, /* call clobbered, arguments */
153 TCG_REG_R9,
154 TCG_REG_R8,
155 TCG_REG_R7,
156 TCG_REG_R6,
157 TCG_REG_R5,
158 TCG_REG_R4,
159 TCG_REG_R3,
160 };
161
162 static const int tcg_target_call_iarg_regs[] = {
163 TCG_REG_R3,
164 TCG_REG_R4,
165 TCG_REG_R5,
166 TCG_REG_R6,
167 TCG_REG_R7,
168 TCG_REG_R8,
169 TCG_REG_R9,
170 TCG_REG_R10
171 };
172
173 static const int tcg_target_call_oarg_regs[] = {
174 TCG_REG_R3,
175 TCG_REG_R4
176 };
177
178 static const int tcg_target_callee_save_regs[] = {
179 #ifdef TCG_TARGET_CALL_DARWIN
180 TCG_REG_R11,
181 #endif
182 TCG_REG_R14,
183 TCG_REG_R15,
184 TCG_REG_R16,
185 TCG_REG_R17,
186 TCG_REG_R18,
187 TCG_REG_R19,
188 TCG_REG_R20,
189 TCG_REG_R21,
190 TCG_REG_R22,
191 TCG_REG_R23,
192 TCG_REG_R24,
193 TCG_REG_R25,
194 TCG_REG_R26,
195 TCG_REG_R27, /* currently used for the global env */
196 TCG_REG_R28,
197 TCG_REG_R29,
198 TCG_REG_R30,
199 TCG_REG_R31
200 };
201
202 static inline bool in_range_b(tcg_target_long target)
203 {
204 return target == sextract64(target, 0, 26);
205 }
206
207 static uint32_t reloc_pc24_val(tcg_insn_unit *pc, tcg_insn_unit *target)
208 {
209 ptrdiff_t disp = tcg_ptr_byte_diff(target, pc);
210 assert(in_range_b(disp));
211 return disp & 0x3fffffc;
212 }
213
214 static void reloc_pc24(tcg_insn_unit *pc, tcg_insn_unit *target)
215 {
216 *pc = (*pc & ~0x3fffffc) | reloc_pc24_val(pc, target);
217 }
218
219 static uint16_t reloc_pc14_val(tcg_insn_unit *pc, tcg_insn_unit *target)
220 {
221 ptrdiff_t disp = tcg_ptr_byte_diff(target, pc);
222 assert(disp == (int16_t) disp);
223 return disp & 0xfffc;
224 }
225
226 static void reloc_pc14(tcg_insn_unit *pc, tcg_insn_unit *target)
227 {
228 *pc = (*pc & ~0xfffc) | reloc_pc14_val(pc, target);
229 }
230
231 static inline void tcg_out_b_noaddr(TCGContext *s, int insn)
232 {
233 unsigned retrans = *s->code_ptr & 0x3fffffc;
234 tcg_out32(s, insn | retrans);
235 }
236
237 static inline void tcg_out_bc_noaddr(TCGContext *s, int insn)
238 {
239 unsigned retrans = *s->code_ptr & 0xfffc;
240 tcg_out32(s, insn | retrans);
241 }
242
243 static void patch_reloc(tcg_insn_unit *code_ptr, int type,
244 intptr_t value, intptr_t addend)
245 {
246 tcg_insn_unit *target = (tcg_insn_unit *)value;
247
248 assert(addend == 0);
249 switch (type) {
250 case R_PPC_REL14:
251 reloc_pc14(code_ptr, target);
252 break;
253 case R_PPC_REL24:
254 reloc_pc24(code_ptr, target);
255 break;
256 default:
257 tcg_abort();
258 }
259 }
260
261 /* parse target specific constraints */
262 static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
263 {
264 const char *ct_str;
265
266 ct_str = *pct_str;
267 switch (ct_str[0]) {
268 case 'A': case 'B': case 'C': case 'D':
269 ct->ct |= TCG_CT_REG;
270 tcg_regset_set_reg(ct->u.regs, 3 + ct_str[0] - 'A');
271 break;
272 case 'r':
273 ct->ct |= TCG_CT_REG;
274 tcg_regset_set32(ct->u.regs, 0, 0xffffffff);
275 break;
276 case 'L': /* qemu_ld constraint */
277 ct->ct |= TCG_CT_REG;
278 tcg_regset_set32(ct->u.regs, 0, 0xffffffff);
279 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R3);
280 #ifdef CONFIG_SOFTMMU
281 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R4);
282 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R5);
283 #endif
284 break;
285 case 'S': /* qemu_st constraint */
286 ct->ct |= TCG_CT_REG;
287 tcg_regset_set32(ct->u.regs, 0, 0xffffffff);
288 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R3);
289 #ifdef CONFIG_SOFTMMU
290 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R4);
291 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R5);
292 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R6);
293 #endif
294 break;
295 case 'I':
296 ct->ct |= TCG_CT_CONST_S16;
297 break;
298 case 'J':
299 ct->ct |= TCG_CT_CONST_U16;
300 break;
301 case 'M':
302 ct->ct |= TCG_CT_CONST_MONE;
303 break;
304 case 'T':
305 ct->ct |= TCG_CT_CONST_S32;
306 break;
307 case 'U':
308 ct->ct |= TCG_CT_CONST_U32;
309 break;
310 case 'Z':
311 ct->ct |= TCG_CT_CONST_ZERO;
312 break;
313 default:
314 return -1;
315 }
316 ct_str++;
317 *pct_str = ct_str;
318 return 0;
319 }
320
321 /* test if a constant matches the constraint */
322 static int tcg_target_const_match(tcg_target_long val, TCGType type,
323 const TCGArgConstraint *arg_ct)
324 {
325 int ct = arg_ct->ct;
326 if (ct & TCG_CT_CONST) {
327 return 1;
328 }
329
330 /* The only 32-bit constraint we use aside from
331 TCG_CT_CONST is TCG_CT_CONST_S16. */
332 if (type == TCG_TYPE_I32) {
333 val = (int32_t)val;
334 }
335
336 if ((ct & TCG_CT_CONST_S16) && val == (int16_t)val) {
337 return 1;
338 } else if ((ct & TCG_CT_CONST_U16) && val == (uint16_t)val) {
339 return 1;
340 } else if ((ct & TCG_CT_CONST_S32) && val == (int32_t)val) {
341 return 1;
342 } else if ((ct & TCG_CT_CONST_U32) && val == (uint32_t)val) {
343 return 1;
344 } else if ((ct & TCG_CT_CONST_ZERO) && val == 0) {
345 return 1;
346 } else if ((ct & TCG_CT_CONST_MONE) && val == -1) {
347 return 1;
348 }
349 return 0;
350 }
351
352 #define OPCD(opc) ((opc)<<26)
353 #define XO19(opc) (OPCD(19)|((opc)<<1))
354 #define MD30(opc) (OPCD(30)|((opc)<<2))
355 #define MDS30(opc) (OPCD(30)|((opc)<<1))
356 #define XO31(opc) (OPCD(31)|((opc)<<1))
357 #define XO58(opc) (OPCD(58)|(opc))
358 #define XO62(opc) (OPCD(62)|(opc))
359
360 #define B OPCD( 18)
361 #define BC OPCD( 16)
362 #define LBZ OPCD( 34)
363 #define LHZ OPCD( 40)
364 #define LHA OPCD( 42)
365 #define LWZ OPCD( 32)
366 #define STB OPCD( 38)
367 #define STH OPCD( 44)
368 #define STW OPCD( 36)
369
370 #define STD XO62( 0)
371 #define STDU XO62( 1)
372 #define STDX XO31(149)
373
374 #define LD XO58( 0)
375 #define LDX XO31( 21)
376 #define LDU XO58( 1)
377 #define LWA XO58( 2)
378 #define LWAX XO31(341)
379
380 #define ADDIC OPCD( 12)
381 #define ADDI OPCD( 14)
382 #define ADDIS OPCD( 15)
383 #define ORI OPCD( 24)
384 #define ORIS OPCD( 25)
385 #define XORI OPCD( 26)
386 #define XORIS OPCD( 27)
387 #define ANDI OPCD( 28)
388 #define ANDIS OPCD( 29)
389 #define MULLI OPCD( 7)
390 #define CMPLI OPCD( 10)
391 #define CMPI OPCD( 11)
392 #define SUBFIC OPCD( 8)
393
394 #define LWZU OPCD( 33)
395 #define STWU OPCD( 37)
396
397 #define RLWIMI OPCD( 20)
398 #define RLWINM OPCD( 21)
399 #define RLWNM OPCD( 23)
400
401 #define RLDICL MD30( 0)
402 #define RLDICR MD30( 1)
403 #define RLDIMI MD30( 3)
404 #define RLDCL MDS30( 8)
405
406 #define BCLR XO19( 16)
407 #define BCCTR XO19(528)
408 #define CRAND XO19(257)
409 #define CRANDC XO19(129)
410 #define CRNAND XO19(225)
411 #define CROR XO19(449)
412 #define CRNOR XO19( 33)
413
414 #define EXTSB XO31(954)
415 #define EXTSH XO31(922)
416 #define EXTSW XO31(986)
417 #define ADD XO31(266)
418 #define ADDE XO31(138)
419 #define ADDME XO31(234)
420 #define ADDZE XO31(202)
421 #define ADDC XO31( 10)
422 #define AND XO31( 28)
423 #define SUBF XO31( 40)
424 #define SUBFC XO31( 8)
425 #define SUBFE XO31(136)
426 #define SUBFME XO31(232)
427 #define SUBFZE XO31(200)
428 #define OR XO31(444)
429 #define XOR XO31(316)
430 #define MULLW XO31(235)
431 #define MULHW XO31( 75)
432 #define MULHWU XO31( 11)
433 #define DIVW XO31(491)
434 #define DIVWU XO31(459)
435 #define CMP XO31( 0)
436 #define CMPL XO31( 32)
437 #define LHBRX XO31(790)
438 #define LWBRX XO31(534)
439 #define LDBRX XO31(532)
440 #define STHBRX XO31(918)
441 #define STWBRX XO31(662)
442 #define STDBRX XO31(660)
443 #define MFSPR XO31(339)
444 #define MTSPR XO31(467)
445 #define SRAWI XO31(824)
446 #define NEG XO31(104)
447 #define MFCR XO31( 19)
448 #define MFOCRF (MFCR | (1u << 20))
449 #define NOR XO31(124)
450 #define CNTLZW XO31( 26)
451 #define CNTLZD XO31( 58)
452 #define ANDC XO31( 60)
453 #define ORC XO31(412)
454 #define EQV XO31(284)
455 #define NAND XO31(476)
456 #define ISEL XO31( 15)
457
458 #define MULLD XO31(233)
459 #define MULHD XO31( 73)
460 #define MULHDU XO31( 9)
461 #define DIVD XO31(489)
462 #define DIVDU XO31(457)
463
464 #define LBZX XO31( 87)
465 #define LHZX XO31(279)
466 #define LHAX XO31(343)
467 #define LWZX XO31( 23)
468 #define STBX XO31(215)
469 #define STHX XO31(407)
470 #define STWX XO31(151)
471
472 #define SPR(a, b) ((((a)<<5)|(b))<<11)
473 #define LR SPR(8, 0)
474 #define CTR SPR(9, 0)
475
476 #define SLW XO31( 24)
477 #define SRW XO31(536)
478 #define SRAW XO31(792)
479
480 #define SLD XO31( 27)
481 #define SRD XO31(539)
482 #define SRAD XO31(794)
483 #define SRADI XO31(413<<1)
484
485 #define TW XO31( 4)
486 #define TRAP (TW | TO(31))
487
488 #define NOP ORI /* ori 0,0,0 */
489
490 #define RT(r) ((r)<<21)
491 #define RS(r) ((r)<<21)
492 #define RA(r) ((r)<<16)
493 #define RB(r) ((r)<<11)
494 #define TO(t) ((t)<<21)
495 #define SH(s) ((s)<<11)
496 #define MB(b) ((b)<<6)
497 #define ME(e) ((e)<<1)
498 #define BO(o) ((o)<<21)
499 #define MB64(b) ((b)<<5)
500 #define FXM(b) (1 << (19 - (b)))
501
502 #define LK 1
503
504 #define TAB(t, a, b) (RT(t) | RA(a) | RB(b))
505 #define SAB(s, a, b) (RS(s) | RA(a) | RB(b))
506 #define TAI(s, a, i) (RT(s) | RA(a) | ((i) & 0xffff))
507 #define SAI(s, a, i) (RS(s) | RA(a) | ((i) & 0xffff))
508
509 #define BF(n) ((n)<<23)
510 #define BI(n, c) (((c)+((n)*4))<<16)
511 #define BT(n, c) (((c)+((n)*4))<<21)
512 #define BA(n, c) (((c)+((n)*4))<<16)
513 #define BB(n, c) (((c)+((n)*4))<<11)
514 #define BC_(n, c) (((c)+((n)*4))<<6)
515
516 #define BO_COND_TRUE BO(12)
517 #define BO_COND_FALSE BO( 4)
518 #define BO_ALWAYS BO(20)
519
520 enum {
521 CR_LT,
522 CR_GT,
523 CR_EQ,
524 CR_SO
525 };
526
527 static const uint32_t tcg_to_bc[] = {
528 [TCG_COND_EQ] = BC | BI(7, CR_EQ) | BO_COND_TRUE,
529 [TCG_COND_NE] = BC | BI(7, CR_EQ) | BO_COND_FALSE,
530 [TCG_COND_LT] = BC | BI(7, CR_LT) | BO_COND_TRUE,
531 [TCG_COND_GE] = BC | BI(7, CR_LT) | BO_COND_FALSE,
532 [TCG_COND_LE] = BC | BI(7, CR_GT) | BO_COND_FALSE,
533 [TCG_COND_GT] = BC | BI(7, CR_GT) | BO_COND_TRUE,
534 [TCG_COND_LTU] = BC | BI(7, CR_LT) | BO_COND_TRUE,
535 [TCG_COND_GEU] = BC | BI(7, CR_LT) | BO_COND_FALSE,
536 [TCG_COND_LEU] = BC | BI(7, CR_GT) | BO_COND_FALSE,
537 [TCG_COND_GTU] = BC | BI(7, CR_GT) | BO_COND_TRUE,
538 };
539
540 /* The low bit here is set if the RA and RB fields must be inverted. */
541 static const uint32_t tcg_to_isel[] = {
542 [TCG_COND_EQ] = ISEL | BC_(7, CR_EQ),
543 [TCG_COND_NE] = ISEL | BC_(7, CR_EQ) | 1,
544 [TCG_COND_LT] = ISEL | BC_(7, CR_LT),
545 [TCG_COND_GE] = ISEL | BC_(7, CR_LT) | 1,
546 [TCG_COND_LE] = ISEL | BC_(7, CR_GT) | 1,
547 [TCG_COND_GT] = ISEL | BC_(7, CR_GT),
548 [TCG_COND_LTU] = ISEL | BC_(7, CR_LT),
549 [TCG_COND_GEU] = ISEL | BC_(7, CR_LT) | 1,
550 [TCG_COND_LEU] = ISEL | BC_(7, CR_GT) | 1,
551 [TCG_COND_GTU] = ISEL | BC_(7, CR_GT),
552 };
553
554 static void tcg_out_mem_long(TCGContext *s, int opi, int opx, TCGReg rt,
555 TCGReg base, tcg_target_long offset);
556
557 static void tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg)
558 {
559 tcg_debug_assert(TCG_TARGET_REG_BITS == 64 || type == TCG_TYPE_I32);
560 if (ret != arg) {
561 tcg_out32(s, OR | SAB(arg, ret, arg));
562 }
563 }
564
565 static inline void tcg_out_rld(TCGContext *s, int op, TCGReg ra, TCGReg rs,
566 int sh, int mb)
567 {
568 assert(TCG_TARGET_REG_BITS == 64);
569 sh = SH(sh & 0x1f) | (((sh >> 5) & 1) << 1);
570 mb = MB64((mb >> 5) | ((mb << 1) & 0x3f));
571 tcg_out32(s, op | RA(ra) | RS(rs) | sh | mb);
572 }
573
574 static inline void tcg_out_rlw(TCGContext *s, int op, TCGReg ra, TCGReg rs,
575 int sh, int mb, int me)
576 {
577 tcg_out32(s, op | RA(ra) | RS(rs) | SH(sh) | MB(mb) | ME(me));
578 }
579
580 static inline void tcg_out_ext32u(TCGContext *s, TCGReg dst, TCGReg src)
581 {
582 tcg_out_rld(s, RLDICL, dst, src, 0, 32);
583 }
584
585 static inline void tcg_out_shli32(TCGContext *s, TCGReg dst, TCGReg src, int c)
586 {
587 tcg_out_rlw(s, RLWINM, dst, src, c, 0, 31 - c);
588 }
589
590 static inline void tcg_out_shli64(TCGContext *s, TCGReg dst, TCGReg src, int c)
591 {
592 tcg_out_rld(s, RLDICR, dst, src, c, 63 - c);
593 }
594
595 static inline void tcg_out_shri32(TCGContext *s, TCGReg dst, TCGReg src, int c)
596 {
597 tcg_out_rlw(s, RLWINM, dst, src, 32 - c, c, 31);
598 }
599
600 static inline void tcg_out_shri64(TCGContext *s, TCGReg dst, TCGReg src, int c)
601 {
602 tcg_out_rld(s, RLDICL, dst, src, 64 - c, c);
603 }
604
605 static void tcg_out_movi32(TCGContext *s, TCGReg ret, int32_t arg)
606 {
607 if (arg == (int16_t) arg) {
608 tcg_out32(s, ADDI | TAI(ret, 0, arg));
609 } else {
610 tcg_out32(s, ADDIS | TAI(ret, 0, arg >> 16));
611 if (arg & 0xffff) {
612 tcg_out32(s, ORI | SAI(ret, ret, arg));
613 }
614 }
615 }
616
617 static void tcg_out_movi(TCGContext *s, TCGType type, TCGReg ret,
618 tcg_target_long arg)
619 {
620 tcg_debug_assert(TCG_TARGET_REG_BITS == 64 || type == TCG_TYPE_I32);
621 if (type == TCG_TYPE_I32 || arg == (int32_t)arg) {
622 tcg_out_movi32(s, ret, arg);
623 } else if (arg == (uint32_t)arg && !(arg & 0x8000)) {
624 tcg_out32(s, ADDI | TAI(ret, 0, arg));
625 tcg_out32(s, ORIS | SAI(ret, ret, arg >> 16));
626 } else {
627 int32_t high;
628
629 if (USE_REG_RA) {
630 intptr_t diff = arg - (intptr_t)tb_ret_addr;
631 if (diff == (int32_t)diff) {
632 tcg_out_mem_long(s, ADDI, ADD, ret, TCG_REG_RA, diff);
633 return;
634 }
635 }
636
637 high = arg >> 31 >> 1;
638 tcg_out_movi32(s, ret, high);
639 if (high) {
640 tcg_out_shli64(s, ret, ret, 32);
641 }
642 if (arg & 0xffff0000) {
643 tcg_out32(s, ORIS | SAI(ret, ret, arg >> 16));
644 }
645 if (arg & 0xffff) {
646 tcg_out32(s, ORI | SAI(ret, ret, arg));
647 }
648 }
649 }
650
651 static bool mask_operand(uint32_t c, int *mb, int *me)
652 {
653 uint32_t lsb, test;
654
655 /* Accept a bit pattern like:
656 0....01....1
657 1....10....0
658 0..01..10..0
659 Keep track of the transitions. */
660 if (c == 0 || c == -1) {
661 return false;
662 }
663 test = c;
664 lsb = test & -test;
665 test += lsb;
666 if (test & (test - 1)) {
667 return false;
668 }
669
670 *me = clz32(lsb);
671 *mb = test ? clz32(test & -test) + 1 : 0;
672 return true;
673 }
674
675 static bool mask64_operand(uint64_t c, int *mb, int *me)
676 {
677 uint64_t lsb;
678
679 if (c == 0) {
680 return false;
681 }
682
683 lsb = c & -c;
684 /* Accept 1..10..0. */
685 if (c == -lsb) {
686 *mb = 0;
687 *me = clz64(lsb);
688 return true;
689 }
690 /* Accept 0..01..1. */
691 if (lsb == 1 && (c & (c + 1)) == 0) {
692 *mb = clz64(c + 1) + 1;
693 *me = 63;
694 return true;
695 }
696 return false;
697 }
698
699 static void tcg_out_andi32(TCGContext *s, TCGReg dst, TCGReg src, uint32_t c)
700 {
701 int mb, me;
702
703 if (mask_operand(c, &mb, &me)) {
704 tcg_out_rlw(s, RLWINM, dst, src, 0, mb, me);
705 } else if ((c & 0xffff) == c) {
706 tcg_out32(s, ANDI | SAI(src, dst, c));
707 return;
708 } else if ((c & 0xffff0000) == c) {
709 tcg_out32(s, ANDIS | SAI(src, dst, c >> 16));
710 return;
711 } else {
712 tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_R0, c);
713 tcg_out32(s, AND | SAB(src, dst, TCG_REG_R0));
714 }
715 }
716
717 static void tcg_out_andi64(TCGContext *s, TCGReg dst, TCGReg src, uint64_t c)
718 {
719 int mb, me;
720
721 assert(TCG_TARGET_REG_BITS == 64);
722 if (mask64_operand(c, &mb, &me)) {
723 if (mb == 0) {
724 tcg_out_rld(s, RLDICR, dst, src, 0, me);
725 } else {
726 tcg_out_rld(s, RLDICL, dst, src, 0, mb);
727 }
728 } else if ((c & 0xffff) == c) {
729 tcg_out32(s, ANDI | SAI(src, dst, c));
730 return;
731 } else if ((c & 0xffff0000) == c) {
732 tcg_out32(s, ANDIS | SAI(src, dst, c >> 16));
733 return;
734 } else {
735 tcg_out_movi(s, TCG_TYPE_I64, TCG_REG_R0, c);
736 tcg_out32(s, AND | SAB(src, dst, TCG_REG_R0));
737 }
738 }
739
740 static void tcg_out_zori32(TCGContext *s, TCGReg dst, TCGReg src, uint32_t c,
741 int op_lo, int op_hi)
742 {
743 if (c >> 16) {
744 tcg_out32(s, op_hi | SAI(src, dst, c >> 16));
745 src = dst;
746 }
747 if (c & 0xffff) {
748 tcg_out32(s, op_lo | SAI(src, dst, c));
749 src = dst;
750 }
751 }
752
753 static void tcg_out_ori32(TCGContext *s, TCGReg dst, TCGReg src, uint32_t c)
754 {
755 tcg_out_zori32(s, dst, src, c, ORI, ORIS);
756 }
757
758 static void tcg_out_xori32(TCGContext *s, TCGReg dst, TCGReg src, uint32_t c)
759 {
760 tcg_out_zori32(s, dst, src, c, XORI, XORIS);
761 }
762
763 static void tcg_out_b(TCGContext *s, int mask, tcg_insn_unit *target)
764 {
765 ptrdiff_t disp = tcg_pcrel_diff(s, target);
766 if (in_range_b(disp)) {
767 tcg_out32(s, B | (disp & 0x3fffffc) | mask);
768 } else {
769 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_R0, (uintptr_t)target);
770 tcg_out32(s, MTSPR | RS(TCG_REG_R0) | CTR);
771 tcg_out32(s, BCCTR | BO_ALWAYS | mask);
772 }
773 }
774
775 static void tcg_out_mem_long(TCGContext *s, int opi, int opx, TCGReg rt,
776 TCGReg base, tcg_target_long offset)
777 {
778 tcg_target_long orig = offset, l0, l1, extra = 0, align = 0;
779 bool is_store = false;
780 TCGReg rs = TCG_REG_TMP1;
781
782 switch (opi) {
783 case LD: case LWA:
784 align = 3;
785 /* FALLTHRU */
786 default:
787 if (rt != TCG_REG_R0) {
788 rs = rt;
789 break;
790 }
791 break;
792 case STD:
793 align = 3;
794 /* FALLTHRU */
795 case STB: case STH: case STW:
796 is_store = true;
797 break;
798 }
799
800 /* For unaligned, or very large offsets, use the indexed form. */
801 if (offset & align || offset != (int32_t)offset) {
802 if (rs == base) {
803 rs = TCG_REG_R0;
804 }
805 tcg_debug_assert(!is_store || rs != rt);
806 tcg_out_movi(s, TCG_TYPE_PTR, rs, orig);
807 tcg_out32(s, opx | TAB(rt, base, rs));
808 return;
809 }
810
811 l0 = (int16_t)offset;
812 offset = (offset - l0) >> 16;
813 l1 = (int16_t)offset;
814
815 if (l1 < 0 && orig >= 0) {
816 extra = 0x4000;
817 l1 = (int16_t)(offset - 0x4000);
818 }
819 if (l1) {
820 tcg_out32(s, ADDIS | TAI(rs, base, l1));
821 base = rs;
822 }
823 if (extra) {
824 tcg_out32(s, ADDIS | TAI(rs, base, extra));
825 base = rs;
826 }
827 if (opi != ADDI || base != rt || l0 != 0) {
828 tcg_out32(s, opi | TAI(rt, base, l0));
829 }
830 }
831
832 static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret,
833 TCGReg arg1, intptr_t arg2)
834 {
835 int opi, opx;
836
837 assert(TCG_TARGET_REG_BITS == 64 || type == TCG_TYPE_I32);
838 if (type == TCG_TYPE_I32) {
839 opi = LWZ, opx = LWZX;
840 } else {
841 opi = LD, opx = LDX;
842 }
843 tcg_out_mem_long(s, opi, opx, ret, arg1, arg2);
844 }
845
846 static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg,
847 TCGReg arg1, intptr_t arg2)
848 {
849 int opi, opx;
850
851 assert(TCG_TARGET_REG_BITS == 64 || type == TCG_TYPE_I32);
852 if (type == TCG_TYPE_I32) {
853 opi = STW, opx = STWX;
854 } else {
855 opi = STD, opx = STDX;
856 }
857 tcg_out_mem_long(s, opi, opx, arg, arg1, arg2);
858 }
859
860 static void tcg_out_cmp(TCGContext *s, int cond, TCGArg arg1, TCGArg arg2,
861 int const_arg2, int cr, TCGType type)
862 {
863 int imm;
864 uint32_t op;
865
866 tcg_debug_assert(TCG_TARGET_REG_BITS == 64 || type == TCG_TYPE_I32);
867
868 /* Simplify the comparisons below wrt CMPI. */
869 if (type == TCG_TYPE_I32) {
870 arg2 = (int32_t)arg2;
871 }
872
873 switch (cond) {
874 case TCG_COND_EQ:
875 case TCG_COND_NE:
876 if (const_arg2) {
877 if ((int16_t) arg2 == arg2) {
878 op = CMPI;
879 imm = 1;
880 break;
881 } else if ((uint16_t) arg2 == arg2) {
882 op = CMPLI;
883 imm = 1;
884 break;
885 }
886 }
887 op = CMPL;
888 imm = 0;
889 break;
890
891 case TCG_COND_LT:
892 case TCG_COND_GE:
893 case TCG_COND_LE:
894 case TCG_COND_GT:
895 if (const_arg2) {
896 if ((int16_t) arg2 == arg2) {
897 op = CMPI;
898 imm = 1;
899 break;
900 }
901 }
902 op = CMP;
903 imm = 0;
904 break;
905
906 case TCG_COND_LTU:
907 case TCG_COND_GEU:
908 case TCG_COND_LEU:
909 case TCG_COND_GTU:
910 if (const_arg2) {
911 if ((uint16_t) arg2 == arg2) {
912 op = CMPLI;
913 imm = 1;
914 break;
915 }
916 }
917 op = CMPL;
918 imm = 0;
919 break;
920
921 default:
922 tcg_abort();
923 }
924 op |= BF(cr) | ((type == TCG_TYPE_I64) << 21);
925
926 if (imm) {
927 tcg_out32(s, op | RA(arg1) | (arg2 & 0xffff));
928 } else {
929 if (const_arg2) {
930 tcg_out_movi(s, type, TCG_REG_R0, arg2);
931 arg2 = TCG_REG_R0;
932 }
933 tcg_out32(s, op | RA(arg1) | RB(arg2));
934 }
935 }
936
937 static void tcg_out_setcond_eq0(TCGContext *s, TCGType type,
938 TCGReg dst, TCGReg src)
939 {
940 if (type == TCG_TYPE_I32) {
941 tcg_out32(s, CNTLZW | RS(src) | RA(dst));
942 tcg_out_shri32(s, dst, dst, 5);
943 } else {
944 tcg_out32(s, CNTLZD | RS(src) | RA(dst));
945 tcg_out_shri64(s, dst, dst, 6);
946 }
947 }
948
949 static void tcg_out_setcond_ne0(TCGContext *s, TCGReg dst, TCGReg src)
950 {
951 /* X != 0 implies X + -1 generates a carry. Extra addition
952 trickery means: R = X-1 + ~X + C = X-1 + (-X+1) + C = C. */
953 if (dst != src) {
954 tcg_out32(s, ADDIC | TAI(dst, src, -1));
955 tcg_out32(s, SUBFE | TAB(dst, dst, src));
956 } else {
957 tcg_out32(s, ADDIC | TAI(TCG_REG_R0, src, -1));
958 tcg_out32(s, SUBFE | TAB(dst, TCG_REG_R0, src));
959 }
960 }
961
962 static TCGReg tcg_gen_setcond_xor(TCGContext *s, TCGReg arg1, TCGArg arg2,
963 bool const_arg2)
964 {
965 if (const_arg2) {
966 if ((uint32_t)arg2 == arg2) {
967 tcg_out_xori32(s, TCG_REG_R0, arg1, arg2);
968 } else {
969 tcg_out_movi(s, TCG_TYPE_I64, TCG_REG_R0, arg2);
970 tcg_out32(s, XOR | SAB(arg1, TCG_REG_R0, TCG_REG_R0));
971 }
972 } else {
973 tcg_out32(s, XOR | SAB(arg1, TCG_REG_R0, arg2));
974 }
975 return TCG_REG_R0;
976 }
977
978 static void tcg_out_setcond(TCGContext *s, TCGType type, TCGCond cond,
979 TCGArg arg0, TCGArg arg1, TCGArg arg2,
980 int const_arg2)
981 {
982 int crop, sh;
983
984 assert(TCG_TARGET_REG_BITS == 64 || type == TCG_TYPE_I32);
985
986 /* Ignore high bits of a potential constant arg2. */
987 if (type == TCG_TYPE_I32) {
988 arg2 = (uint32_t)arg2;
989 }
990
991 /* Handle common and trivial cases before handling anything else. */
992 if (arg2 == 0) {
993 switch (cond) {
994 case TCG_COND_EQ:
995 tcg_out_setcond_eq0(s, type, arg0, arg1);
996 return;
997 case TCG_COND_NE:
998 if (TCG_TARGET_REG_BITS == 64 && type == TCG_TYPE_I32) {
999 tcg_out_ext32u(s, TCG_REG_R0, arg1);
1000 arg1 = TCG_REG_R0;
1001 }
1002 tcg_out_setcond_ne0(s, arg0, arg1);
1003 return;
1004 case TCG_COND_GE:
1005 tcg_out32(s, NOR | SAB(arg1, arg0, arg1));
1006 arg1 = arg0;
1007 /* FALLTHRU */
1008 case TCG_COND_LT:
1009 /* Extract the sign bit. */
1010 if (type == TCG_TYPE_I32) {
1011 tcg_out_shri32(s, arg0, arg1, 31);
1012 } else {
1013 tcg_out_shri64(s, arg0, arg1, 63);
1014 }
1015 return;
1016 default:
1017 break;
1018 }
1019 }
1020
1021 /* If we have ISEL, we can implement everything with 3 or 4 insns.
1022 All other cases below are also at least 3 insns, so speed up the
1023 code generator by not considering them and always using ISEL. */
1024 if (HAVE_ISEL) {
1025 int isel, tab;
1026
1027 tcg_out_cmp(s, cond, arg1, arg2, const_arg2, 7, type);
1028
1029 isel = tcg_to_isel[cond];
1030
1031 tcg_out_movi(s, type, arg0, 1);
1032 if (isel & 1) {
1033 /* arg0 = (bc ? 0 : 1) */
1034 tab = TAB(arg0, 0, arg0);
1035 isel &= ~1;
1036 } else {
1037 /* arg0 = (bc ? 1 : 0) */
1038 tcg_out_movi(s, type, TCG_REG_R0, 0);
1039 tab = TAB(arg0, arg0, TCG_REG_R0);
1040 }
1041 tcg_out32(s, isel | tab);
1042 return;
1043 }
1044
1045 switch (cond) {
1046 case TCG_COND_EQ:
1047 arg1 = tcg_gen_setcond_xor(s, arg1, arg2, const_arg2);
1048 tcg_out_setcond_eq0(s, type, arg0, arg1);
1049 return;
1050
1051 case TCG_COND_NE:
1052 arg1 = tcg_gen_setcond_xor(s, arg1, arg2, const_arg2);
1053 /* Discard the high bits only once, rather than both inputs. */
1054 if (TCG_TARGET_REG_BITS == 64 && type == TCG_TYPE_I32) {
1055 tcg_out_ext32u(s, TCG_REG_R0, arg1);
1056 arg1 = TCG_REG_R0;
1057 }
1058 tcg_out_setcond_ne0(s, arg0, arg1);
1059 return;
1060
1061 case TCG_COND_GT:
1062 case TCG_COND_GTU:
1063 sh = 30;
1064 crop = 0;
1065 goto crtest;
1066
1067 case TCG_COND_LT:
1068 case TCG_COND_LTU:
1069 sh = 29;
1070 crop = 0;
1071 goto crtest;
1072
1073 case TCG_COND_GE:
1074 case TCG_COND_GEU:
1075 sh = 31;
1076 crop = CRNOR | BT(7, CR_EQ) | BA(7, CR_LT) | BB(7, CR_LT);
1077 goto crtest;
1078
1079 case TCG_COND_LE:
1080 case TCG_COND_LEU:
1081 sh = 31;
1082 crop = CRNOR | BT(7, CR_EQ) | BA(7, CR_GT) | BB(7, CR_GT);
1083 crtest:
1084 tcg_out_cmp(s, cond, arg1, arg2, const_arg2, 7, type);
1085 if (crop) {
1086 tcg_out32(s, crop);
1087 }
1088 tcg_out32(s, MFOCRF | RT(TCG_REG_R0) | FXM(7));
1089 tcg_out_rlw(s, RLWINM, arg0, TCG_REG_R0, sh, 31, 31);
1090 break;
1091
1092 default:
1093 tcg_abort();
1094 }
1095 }
1096
1097 static void tcg_out_bc(TCGContext *s, int bc, TCGLabel *l)
1098 {
1099 if (l->has_value) {
1100 tcg_out32(s, bc | reloc_pc14_val(s->code_ptr, l->u.value_ptr));
1101 } else {
1102 tcg_out_reloc(s, s->code_ptr, R_PPC_REL14, l, 0);
1103 tcg_out_bc_noaddr(s, bc);
1104 }
1105 }
1106
1107 static void tcg_out_brcond(TCGContext *s, TCGCond cond,
1108 TCGArg arg1, TCGArg arg2, int const_arg2,
1109 TCGLabel *l, TCGType type)
1110 {
1111 tcg_out_cmp(s, cond, arg1, arg2, const_arg2, 7, type);
1112 tcg_out_bc(s, tcg_to_bc[cond], l);
1113 }
1114
1115 static void tcg_out_movcond(TCGContext *s, TCGType type, TCGCond cond,
1116 TCGArg dest, TCGArg c1, TCGArg c2, TCGArg v1,
1117 TCGArg v2, bool const_c2)
1118 {
1119 /* If for some reason both inputs are zero, don't produce bad code. */
1120 if (v1 == 0 && v2 == 0) {
1121 tcg_out_movi(s, type, dest, 0);
1122 return;
1123 }
1124
1125 tcg_out_cmp(s, cond, c1, c2, const_c2, 7, type);
1126
1127 if (HAVE_ISEL) {
1128 int isel = tcg_to_isel[cond];
1129
1130 /* Swap the V operands if the operation indicates inversion. */
1131 if (isel & 1) {
1132 int t = v1;
1133 v1 = v2;
1134 v2 = t;
1135 isel &= ~1;
1136 }
1137 /* V1 == 0 is handled by isel; V2 == 0 must be handled by hand. */
1138 if (v2 == 0) {
1139 tcg_out_movi(s, type, TCG_REG_R0, 0);
1140 }
1141 tcg_out32(s, isel | TAB(dest, v1, v2));
1142 } else {
1143 if (dest == v2) {
1144 cond = tcg_invert_cond(cond);
1145 v2 = v1;
1146 } else if (dest != v1) {
1147 if (v1 == 0) {
1148 tcg_out_movi(s, type, dest, 0);
1149 } else {
1150 tcg_out_mov(s, type, dest, v1);
1151 }
1152 }
1153 /* Branch forward over one insn */
1154 tcg_out32(s, tcg_to_bc[cond] | 8);
1155 if (v2 == 0) {
1156 tcg_out_movi(s, type, dest, 0);
1157 } else {
1158 tcg_out_mov(s, type, dest, v2);
1159 }
1160 }
1161 }
1162
1163 static void tcg_out_cmp2(TCGContext *s, const TCGArg *args,
1164 const int *const_args)
1165 {
1166 static const struct { uint8_t bit1, bit2; } bits[] = {
1167 [TCG_COND_LT ] = { CR_LT, CR_LT },
1168 [TCG_COND_LE ] = { CR_LT, CR_GT },
1169 [TCG_COND_GT ] = { CR_GT, CR_GT },
1170 [TCG_COND_GE ] = { CR_GT, CR_LT },
1171 [TCG_COND_LTU] = { CR_LT, CR_LT },
1172 [TCG_COND_LEU] = { CR_LT, CR_GT },
1173 [TCG_COND_GTU] = { CR_GT, CR_GT },
1174 [TCG_COND_GEU] = { CR_GT, CR_LT },
1175 };
1176
1177 TCGCond cond = args[4], cond2;
1178 TCGArg al, ah, bl, bh;
1179 int blconst, bhconst;
1180 int op, bit1, bit2;
1181
1182 al = args[0];
1183 ah = args[1];
1184 bl = args[2];
1185 bh = args[3];
1186 blconst = const_args[2];
1187 bhconst = const_args[3];
1188
1189 switch (cond) {
1190 case TCG_COND_EQ:
1191 op = CRAND;
1192 goto do_equality;
1193 case TCG_COND_NE:
1194 op = CRNAND;
1195 do_equality:
1196 tcg_out_cmp(s, cond, al, bl, blconst, 6, TCG_TYPE_I32);
1197 tcg_out_cmp(s, cond, ah, bh, bhconst, 7, TCG_TYPE_I32);
1198 tcg_out32(s, op | BT(7, CR_EQ) | BA(6, CR_EQ) | BB(7, CR_EQ));
1199 break;
1200
1201 case TCG_COND_LT:
1202 case TCG_COND_LE:
1203 case TCG_COND_GT:
1204 case TCG_COND_GE:
1205 case TCG_COND_LTU:
1206 case TCG_COND_LEU:
1207 case TCG_COND_GTU:
1208 case TCG_COND_GEU:
1209 bit1 = bits[cond].bit1;
1210 bit2 = bits[cond].bit2;
1211 op = (bit1 != bit2 ? CRANDC : CRAND);
1212 cond2 = tcg_unsigned_cond(cond);
1213
1214 tcg_out_cmp(s, cond, ah, bh, bhconst, 6, TCG_TYPE_I32);
1215 tcg_out_cmp(s, cond2, al, bl, blconst, 7, TCG_TYPE_I32);
1216 tcg_out32(s, op | BT(7, CR_EQ) | BA(6, CR_EQ) | BB(7, bit2));
1217 tcg_out32(s, CROR | BT(7, CR_EQ) | BA(6, bit1) | BB(7, CR_EQ));
1218 break;
1219
1220 default:
1221 tcg_abort();
1222 }
1223 }
1224
1225 static void tcg_out_setcond2(TCGContext *s, const TCGArg *args,
1226 const int *const_args)
1227 {
1228 tcg_out_cmp2(s, args + 1, const_args + 1);
1229 tcg_out32(s, MFOCRF | RT(TCG_REG_R0) | FXM(7));
1230 tcg_out_rlw(s, RLWINM, args[0], TCG_REG_R0, 31, 31, 31);
1231 }
1232
1233 static void tcg_out_brcond2 (TCGContext *s, const TCGArg *args,
1234 const int *const_args)
1235 {
1236 tcg_out_cmp2(s, args, const_args);
1237 tcg_out_bc(s, BC | BI(7, CR_EQ) | BO_COND_TRUE, arg_label(args[5]));
1238 }
1239
1240 void ppc_tb_set_jmp_target(uintptr_t jmp_addr, uintptr_t addr)
1241 {
1242 tcg_insn_unit i1, i2;
1243 uint64_t pair;
1244 intptr_t diff = addr - jmp_addr;
1245
1246 if (in_range_b(diff)) {
1247 i1 = B | (diff & 0x3fffffc);
1248 i2 = NOP;
1249 } else if (USE_REG_RA) {
1250 intptr_t lo, hi;
1251 diff = addr - (uintptr_t)tb_ret_addr;
1252 lo = (int16_t)diff;
1253 hi = (int32_t)(diff - lo);
1254 assert(diff == hi + lo);
1255 i1 = ADDIS | TAI(TCG_REG_TMP1, TCG_REG_RA, hi >> 16);
1256 i2 = ADDI | TAI(TCG_REG_TMP1, TCG_REG_TMP1, lo);
1257 } else {
1258 assert(TCG_TARGET_REG_BITS == 32 || addr == (int32_t)addr);
1259 i1 = ADDIS | TAI(TCG_REG_TMP1, 0, addr >> 16);
1260 i2 = ORI | SAI(TCG_REG_TMP1, TCG_REG_TMP1, addr);
1261 }
1262 #ifdef HOST_WORDS_BIGENDIAN
1263 pair = (uint64_t)i1 << 32 | i2;
1264 #else
1265 pair = (uint64_t)i2 << 32 | i1;
1266 #endif
1267
1268 /* ??? __atomic_store_8, presuming there's some way to do that
1269 for 32-bit, otherwise this is good enough for 64-bit. */
1270 *(uint64_t *)jmp_addr = pair;
1271 flush_icache_range(jmp_addr, jmp_addr + 8);
1272 }
1273
1274 static void tcg_out_call(TCGContext *s, tcg_insn_unit *target)
1275 {
1276 #ifdef _CALL_AIX
1277 /* Look through the descriptor. If the branch is in range, and we
1278 don't have to spend too much effort on building the toc. */
1279 void *tgt = ((void **)target)[0];
1280 uintptr_t toc = ((uintptr_t *)target)[1];
1281 intptr_t diff = tcg_pcrel_diff(s, tgt);
1282
1283 if (in_range_b(diff) && toc == (uint32_t)toc) {
1284 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_TMP1, toc);
1285 tcg_out_b(s, LK, tgt);
1286 } else {
1287 /* Fold the low bits of the constant into the addresses below. */
1288 intptr_t arg = (intptr_t)target;
1289 int ofs = (int16_t)arg;
1290
1291 if (ofs + 8 < 0x8000) {
1292 arg -= ofs;
1293 } else {
1294 ofs = 0;
1295 }
1296 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_TMP1, arg);
1297 tcg_out_ld(s, TCG_TYPE_PTR, TCG_REG_R0, TCG_REG_TMP1, ofs);
1298 tcg_out32(s, MTSPR | RA(TCG_REG_R0) | CTR);
1299 tcg_out_ld(s, TCG_TYPE_PTR, TCG_REG_R2, TCG_REG_TMP1, ofs + SZP);
1300 tcg_out32(s, BCCTR | BO_ALWAYS | LK);
1301 }
1302 #elif defined(_CALL_ELF) && _CALL_ELF == 2
1303 intptr_t diff;
1304
1305 /* In the ELFv2 ABI, we have to set up r12 to contain the destination
1306 address, which the callee uses to compute its TOC address. */
1307 /* FIXME: when the branch is in range, we could avoid r12 load if we
1308 knew that the destination uses the same TOC, and what its local
1309 entry point offset is. */
1310 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_R12, (intptr_t)target);
1311
1312 diff = tcg_pcrel_diff(s, target);
1313 if (in_range_b(diff)) {
1314 tcg_out_b(s, LK, target);
1315 } else {
1316 tcg_out32(s, MTSPR | RS(TCG_REG_R12) | CTR);
1317 tcg_out32(s, BCCTR | BO_ALWAYS | LK);
1318 }
1319 #else
1320 tcg_out_b(s, LK, target);
1321 #endif
1322 }
1323
1324 static const uint32_t qemu_ldx_opc[16] = {
1325 [MO_UB] = LBZX,
1326 [MO_UW] = LHZX,
1327 [MO_UL] = LWZX,
1328 [MO_Q] = LDX,
1329 [MO_SW] = LHAX,
1330 [MO_SL] = LWAX,
1331 [MO_BSWAP | MO_UB] = LBZX,
1332 [MO_BSWAP | MO_UW] = LHBRX,
1333 [MO_BSWAP | MO_UL] = LWBRX,
1334 [MO_BSWAP | MO_Q] = LDBRX,
1335 };
1336
1337 static const uint32_t qemu_stx_opc[16] = {
1338 [MO_UB] = STBX,
1339 [MO_UW] = STHX,
1340 [MO_UL] = STWX,
1341 [MO_Q] = STDX,
1342 [MO_BSWAP | MO_UB] = STBX,
1343 [MO_BSWAP | MO_UW] = STHBRX,
1344 [MO_BSWAP | MO_UL] = STWBRX,
1345 [MO_BSWAP | MO_Q] = STDBRX,
1346 };
1347
1348 static const uint32_t qemu_exts_opc[4] = {
1349 EXTSB, EXTSH, EXTSW, 0
1350 };
1351
1352 #if defined (CONFIG_SOFTMMU)
1353 /* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr,
1354 * int mmu_idx, uintptr_t ra)
1355 */
1356 static void * const qemu_ld_helpers[16] = {
1357 [MO_UB] = helper_ret_ldub_mmu,
1358 [MO_LEUW] = helper_le_lduw_mmu,
1359 [MO_LEUL] = helper_le_ldul_mmu,
1360 [MO_LEQ] = helper_le_ldq_mmu,
1361 [MO_BEUW] = helper_be_lduw_mmu,
1362 [MO_BEUL] = helper_be_ldul_mmu,
1363 [MO_BEQ] = helper_be_ldq_mmu,
1364 };
1365
1366 /* helper signature: helper_st_mmu(CPUState *env, target_ulong addr,
1367 * uintxx_t val, int mmu_idx, uintptr_t ra)
1368 */
1369 static void * const qemu_st_helpers[16] = {
1370 [MO_UB] = helper_ret_stb_mmu,
1371 [MO_LEUW] = helper_le_stw_mmu,
1372 [MO_LEUL] = helper_le_stl_mmu,
1373 [MO_LEQ] = helper_le_stq_mmu,
1374 [MO_BEUW] = helper_be_stw_mmu,
1375 [MO_BEUL] = helper_be_stl_mmu,
1376 [MO_BEQ] = helper_be_stq_mmu,
1377 };
1378
1379 /* Perform the TLB load and compare. Places the result of the comparison
1380 in CR7, loads the addend of the TLB into R3, and returns the register
1381 containing the guest address (zero-extended into R4). Clobbers R0 and R2. */
1382
1383 static TCGReg tcg_out_tlb_read(TCGContext *s, TCGMemOp opc,
1384 TCGReg addrlo, TCGReg addrhi,
1385 int mem_index, bool is_read)
1386 {
1387 int cmp_off
1388 = (is_read
1389 ? offsetof(CPUArchState, tlb_table[mem_index][0].addr_read)
1390 : offsetof(CPUArchState, tlb_table[mem_index][0].addr_write));
1391 int add_off = offsetof(CPUArchState, tlb_table[mem_index][0].addend);
1392 TCGReg base = TCG_AREG0;
1393 TCGMemOp s_bits = opc & MO_SIZE;
1394
1395 /* Extract the page index, shifted into place for tlb index. */
1396 if (TCG_TARGET_REG_BITS == 64) {
1397 if (TARGET_LONG_BITS == 32) {
1398 /* Zero-extend the address into a place helpful for further use. */
1399 tcg_out_ext32u(s, TCG_REG_R4, addrlo);
1400 addrlo = TCG_REG_R4;
1401 } else {
1402 tcg_out_rld(s, RLDICL, TCG_REG_R3, addrlo,
1403 64 - TARGET_PAGE_BITS, 64 - CPU_TLB_BITS);
1404 }
1405 }
1406
1407 /* Compensate for very large offsets. */
1408 if (add_off >= 0x8000) {
1409 /* Most target env are smaller than 32k; none are larger than 64k.
1410 Simplify the logic here merely to offset by 0x7ff0, giving us a
1411 range just shy of 64k. Check this assumption. */
1412 QEMU_BUILD_BUG_ON(offsetof(CPUArchState,
1413 tlb_table[NB_MMU_MODES - 1][1])
1414 > 0x7ff0 + 0x7fff);
1415 tcg_out32(s, ADDI | TAI(TCG_REG_TMP1, base, 0x7ff0));
1416 base = TCG_REG_TMP1;
1417 cmp_off -= 0x7ff0;
1418 add_off -= 0x7ff0;
1419 }
1420
1421 /* Extraction and shifting, part 2. */
1422 if (TCG_TARGET_REG_BITS == 32 || TARGET_LONG_BITS == 32) {
1423 tcg_out_rlw(s, RLWINM, TCG_REG_R3, addrlo,
1424 32 - (TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS),
1425 32 - (CPU_TLB_BITS + CPU_TLB_ENTRY_BITS),
1426 31 - CPU_TLB_ENTRY_BITS);
1427 } else {
1428 tcg_out_shli64(s, TCG_REG_R3, TCG_REG_R3, CPU_TLB_ENTRY_BITS);
1429 }
1430
1431 tcg_out32(s, ADD | TAB(TCG_REG_R3, TCG_REG_R3, base));
1432
1433 /* Load the tlb comparator. */
1434 if (TCG_TARGET_REG_BITS < TARGET_LONG_BITS) {
1435 tcg_out_ld(s, TCG_TYPE_I32, TCG_REG_R4, TCG_REG_R3, cmp_off);
1436 tcg_out_ld(s, TCG_TYPE_I32, TCG_REG_TMP1, TCG_REG_R3, cmp_off + 4);
1437 } else {
1438 tcg_out_ld(s, TCG_TYPE_TL, TCG_REG_TMP1, TCG_REG_R3, cmp_off);
1439 }
1440
1441 /* Load the TLB addend for use on the fast path. Do this asap
1442 to minimize any load use delay. */
1443 tcg_out_ld(s, TCG_TYPE_PTR, TCG_REG_R3, TCG_REG_R3, add_off);
1444
1445 /* Clear the non-page, non-alignment bits from the address */
1446 if (TCG_TARGET_REG_BITS == 32 || TARGET_LONG_BITS == 32) {
1447 /* We don't support unaligned accesses on 32-bits, preserve
1448 * the bottom bits and thus trigger a comparison failure on
1449 * unaligned accesses
1450 */
1451 tcg_out_rlw(s, RLWINM, TCG_REG_R0, addrlo, 0,
1452 (32 - s_bits) & 31, 31 - TARGET_PAGE_BITS);
1453 } else if (s_bits) {
1454 /* > byte access, we need to handle alignment */
1455 if ((opc & MO_AMASK) == MO_ALIGN) {
1456 /* Alignment required by the front-end, same as 32-bits */
1457 tcg_out_rld(s, RLDICL, TCG_REG_R0, addrlo,
1458 64 - TARGET_PAGE_BITS, TARGET_PAGE_BITS - s_bits);
1459 tcg_out_rld(s, RLDICL, TCG_REG_R0, TCG_REG_R0, TARGET_PAGE_BITS, 0);
1460 } else {
1461 /* We support unaligned accesses, we need to make sure we fail
1462 * if we cross a page boundary. The trick is to add the
1463 * access_size-1 to the address before masking the low bits.
1464 * That will make the address overflow to the next page if we
1465 * cross a page boundary which will then force a mismatch of
1466 * the TLB compare since the next page cannot possibly be in
1467 * the same TLB index.
1468 */
1469 tcg_out32(s, ADDI | TAI(TCG_REG_R0, addrlo, (1 << s_bits) - 1));
1470 tcg_out_rld(s, RLDICR, TCG_REG_R0, TCG_REG_R0,
1471 0, 63 - TARGET_PAGE_BITS);
1472 }
1473 } else {
1474 /* Byte access, just chop off the bits below the page index */
1475 tcg_out_rld(s, RLDICR, TCG_REG_R0, addrlo, 0, 63 - TARGET_PAGE_BITS);
1476 }
1477
1478 if (TCG_TARGET_REG_BITS < TARGET_LONG_BITS) {
1479 tcg_out_cmp(s, TCG_COND_EQ, TCG_REG_R0, TCG_REG_TMP1,
1480 0, 7, TCG_TYPE_I32);
1481 tcg_out_cmp(s, TCG_COND_EQ, addrhi, TCG_REG_R4, 0, 6, TCG_TYPE_I32);
1482 tcg_out32(s, CRAND | BT(7, CR_EQ) | BA(6, CR_EQ) | BB(7, CR_EQ));
1483 } else {
1484 tcg_out_cmp(s, TCG_COND_EQ, TCG_REG_R0, TCG_REG_TMP1,
1485 0, 7, TCG_TYPE_TL);
1486 }
1487
1488 return addrlo;
1489 }
1490
1491 /* Record the context of a call to the out of line helper code for the slow
1492 path for a load or store, so that we can later generate the correct
1493 helper code. */
1494 static void add_qemu_ldst_label(TCGContext *s, bool is_ld, TCGMemOpIdx oi,
1495 TCGReg datalo_reg, TCGReg datahi_reg,
1496 TCGReg addrlo_reg, TCGReg addrhi_reg,
1497 tcg_insn_unit *raddr, tcg_insn_unit *lptr)
1498 {
1499 TCGLabelQemuLdst *label = new_ldst_label(s);
1500
1501 label->is_ld = is_ld;
1502 label->oi = oi;
1503 label->datalo_reg = datalo_reg;
1504 label->datahi_reg = datahi_reg;
1505 label->addrlo_reg = addrlo_reg;
1506 label->addrhi_reg = addrhi_reg;
1507 label->raddr = raddr;
1508 label->label_ptr[0] = lptr;
1509 }
1510
1511 static void tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1512 {
1513 TCGMemOpIdx oi = lb->oi;
1514 TCGMemOp opc = get_memop(oi);
1515 TCGReg hi, lo, arg = TCG_REG_R3;
1516
1517 reloc_pc14(lb->label_ptr[0], s->code_ptr);
1518
1519 tcg_out_mov(s, TCG_TYPE_PTR, arg++, TCG_AREG0);
1520
1521 lo = lb->addrlo_reg;
1522 hi = lb->addrhi_reg;
1523 if (TCG_TARGET_REG_BITS < TARGET_LONG_BITS) {
1524 #ifdef TCG_TARGET_CALL_ALIGN_ARGS
1525 arg |= 1;
1526 #endif
1527 tcg_out_mov(s, TCG_TYPE_I32, arg++, hi);
1528 tcg_out_mov(s, TCG_TYPE_I32, arg++, lo);
1529 } else {
1530 /* If the address needed to be zero-extended, we'll have already
1531 placed it in R4. The only remaining case is 64-bit guest. */
1532 tcg_out_mov(s, TCG_TYPE_TL, arg++, lo);
1533 }
1534
1535 tcg_out_movi(s, TCG_TYPE_I32, arg++, oi);
1536 tcg_out32(s, MFSPR | RT(arg) | LR);
1537
1538 tcg_out_call(s, qemu_ld_helpers[opc & (MO_BSWAP | MO_SIZE)]);
1539
1540 lo = lb->datalo_reg;
1541 hi = lb->datahi_reg;
1542 if (TCG_TARGET_REG_BITS == 32 && (opc & MO_SIZE) == MO_64) {
1543 tcg_out_mov(s, TCG_TYPE_I32, lo, TCG_REG_R4);
1544 tcg_out_mov(s, TCG_TYPE_I32, hi, TCG_REG_R3);
1545 } else if (opc & MO_SIGN) {
1546 uint32_t insn = qemu_exts_opc[opc & MO_SIZE];
1547 tcg_out32(s, insn | RA(lo) | RS(TCG_REG_R3));
1548 } else {
1549 tcg_out_mov(s, TCG_TYPE_REG, lo, TCG_REG_R3);
1550 }
1551
1552 tcg_out_b(s, 0, lb->raddr);
1553 }
1554
1555 static void tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1556 {
1557 TCGMemOpIdx oi = lb->oi;
1558 TCGMemOp opc = get_memop(oi);
1559 TCGMemOp s_bits = opc & MO_SIZE;
1560 TCGReg hi, lo, arg = TCG_REG_R3;
1561
1562 reloc_pc14(lb->label_ptr[0], s->code_ptr);
1563
1564 tcg_out_mov(s, TCG_TYPE_PTR, arg++, TCG_AREG0);
1565
1566 lo = lb->addrlo_reg;
1567 hi = lb->addrhi_reg;
1568 if (TCG_TARGET_REG_BITS < TARGET_LONG_BITS) {
1569 #ifdef TCG_TARGET_CALL_ALIGN_ARGS
1570 arg |= 1;
1571 #endif
1572 tcg_out_mov(s, TCG_TYPE_I32, arg++, hi);
1573 tcg_out_mov(s, TCG_TYPE_I32, arg++, lo);
1574 } else {
1575 /* If the address needed to be zero-extended, we'll have already
1576 placed it in R4. The only remaining case is 64-bit guest. */
1577 tcg_out_mov(s, TCG_TYPE_TL, arg++, lo);
1578 }
1579
1580 lo = lb->datalo_reg;
1581 hi = lb->datahi_reg;
1582 if (TCG_TARGET_REG_BITS == 32) {
1583 switch (s_bits) {
1584 case MO_64:
1585 #ifdef TCG_TARGET_CALL_ALIGN_ARGS
1586 arg |= 1;
1587 #endif
1588 tcg_out_mov(s, TCG_TYPE_I32, arg++, hi);
1589 /* FALLTHRU */
1590 case MO_32:
1591 tcg_out_mov(s, TCG_TYPE_I32, arg++, lo);
1592 break;
1593 default:
1594 tcg_out_rlw(s, RLWINM, arg++, lo, 0, 32 - (8 << s_bits), 31);
1595 break;
1596 }
1597 } else {
1598 if (s_bits == MO_64) {
1599 tcg_out_mov(s, TCG_TYPE_I64, arg++, lo);
1600 } else {
1601 tcg_out_rld(s, RLDICL, arg++, lo, 0, 64 - (8 << s_bits));
1602 }
1603 }
1604
1605 tcg_out_movi(s, TCG_TYPE_I32, arg++, oi);
1606 tcg_out32(s, MFSPR | RT(arg) | LR);
1607
1608 tcg_out_call(s, qemu_st_helpers[opc & (MO_BSWAP | MO_SIZE)]);
1609
1610 tcg_out_b(s, 0, lb->raddr);
1611 }
1612 #endif /* SOFTMMU */
1613
1614 static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args, bool is_64)
1615 {
1616 TCGReg datalo, datahi, addrlo, rbase;
1617 TCGReg addrhi __attribute__((unused));
1618 TCGMemOpIdx oi;
1619 TCGMemOp opc, s_bits;
1620 #ifdef CONFIG_SOFTMMU
1621 int mem_index;
1622 tcg_insn_unit *label_ptr;
1623 #endif
1624
1625 datalo = *args++;
1626 datahi = (TCG_TARGET_REG_BITS == 32 && is_64 ? *args++ : 0);
1627 addrlo = *args++;
1628 addrhi = (TCG_TARGET_REG_BITS < TARGET_LONG_BITS ? *args++ : 0);
1629 oi = *args++;
1630 opc = get_memop(oi);
1631 s_bits = opc & MO_SIZE;
1632
1633 #ifdef CONFIG_SOFTMMU
1634 mem_index = get_mmuidx(oi);
1635 addrlo = tcg_out_tlb_read(s, opc, addrlo, addrhi, mem_index, true);
1636
1637 /* Load a pointer into the current opcode w/conditional branch-link. */
1638 label_ptr = s->code_ptr;
1639 tcg_out_bc_noaddr(s, BC | BI(7, CR_EQ) | BO_COND_FALSE | LK);
1640
1641 rbase = TCG_REG_R3;
1642 #else /* !CONFIG_SOFTMMU */
1643 rbase = guest_base ? TCG_GUEST_BASE_REG : 0;
1644 if (TCG_TARGET_REG_BITS > TARGET_LONG_BITS) {
1645 tcg_out_ext32u(s, TCG_REG_TMP1, addrlo);
1646 addrlo = TCG_REG_TMP1;
1647 }
1648 #endif
1649
1650 if (TCG_TARGET_REG_BITS == 32 && s_bits == MO_64) {
1651 if (opc & MO_BSWAP) {
1652 tcg_out32(s, ADDI | TAI(TCG_REG_R0, addrlo, 4));
1653 tcg_out32(s, LWBRX | TAB(datalo, rbase, addrlo));
1654 tcg_out32(s, LWBRX | TAB(datahi, rbase, TCG_REG_R0));
1655 } else if (rbase != 0) {
1656 tcg_out32(s, ADDI | TAI(TCG_REG_R0, addrlo, 4));
1657 tcg_out32(s, LWZX | TAB(datahi, rbase, addrlo));
1658 tcg_out32(s, LWZX | TAB(datalo, rbase, TCG_REG_R0));
1659 } else if (addrlo == datahi) {
1660 tcg_out32(s, LWZ | TAI(datalo, addrlo, 4));
1661 tcg_out32(s, LWZ | TAI(datahi, addrlo, 0));
1662 } else {
1663 tcg_out32(s, LWZ | TAI(datahi, addrlo, 0));
1664 tcg_out32(s, LWZ | TAI(datalo, addrlo, 4));
1665 }
1666 } else {
1667 uint32_t insn = qemu_ldx_opc[opc & (MO_BSWAP | MO_SSIZE)];
1668 if (!HAVE_ISA_2_06 && insn == LDBRX) {
1669 tcg_out32(s, ADDI | TAI(TCG_REG_R0, addrlo, 4));
1670 tcg_out32(s, LWBRX | TAB(datalo, rbase, addrlo));
1671 tcg_out32(s, LWBRX | TAB(TCG_REG_R0, rbase, TCG_REG_R0));
1672 tcg_out_rld(s, RLDIMI, datalo, TCG_REG_R0, 32, 0);
1673 } else if (insn) {
1674 tcg_out32(s, insn | TAB(datalo, rbase, addrlo));
1675 } else {
1676 insn = qemu_ldx_opc[opc & (MO_SIZE | MO_BSWAP)];
1677 tcg_out32(s, insn | TAB(datalo, rbase, addrlo));
1678 insn = qemu_exts_opc[s_bits];
1679 tcg_out32(s, insn | RA(datalo) | RS(datalo));
1680 }
1681 }
1682
1683 #ifdef CONFIG_SOFTMMU
1684 add_qemu_ldst_label(s, true, oi, datalo, datahi, addrlo, addrhi,
1685 s->code_ptr, label_ptr);
1686 #endif
1687 }
1688
1689 static void tcg_out_qemu_st(TCGContext *s, const TCGArg *args, bool is_64)
1690 {
1691 TCGReg datalo, datahi, addrlo, rbase;
1692 TCGReg addrhi __attribute__((unused));
1693 TCGMemOpIdx oi;
1694 TCGMemOp opc, s_bits;
1695 #ifdef CONFIG_SOFTMMU
1696 int mem_index;
1697 tcg_insn_unit *label_ptr;
1698 #endif
1699
1700 datalo = *args++;
1701 datahi = (TCG_TARGET_REG_BITS == 32 && is_64 ? *args++ : 0);
1702 addrlo = *args++;
1703 addrhi = (TCG_TARGET_REG_BITS < TARGET_LONG_BITS ? *args++ : 0);
1704 oi = *args++;
1705 opc = get_memop(oi);
1706 s_bits = opc & MO_SIZE;
1707
1708 #ifdef CONFIG_SOFTMMU
1709 mem_index = get_mmuidx(oi);
1710 addrlo = tcg_out_tlb_read(s, opc, addrlo, addrhi, mem_index, false);
1711
1712 /* Load a pointer into the current opcode w/conditional branch-link. */
1713 label_ptr = s->code_ptr;
1714 tcg_out_bc_noaddr(s, BC | BI(7, CR_EQ) | BO_COND_FALSE | LK);
1715
1716 rbase = TCG_REG_R3;
1717 #else /* !CONFIG_SOFTMMU */
1718 rbase = guest_base ? TCG_GUEST_BASE_REG : 0;
1719 if (TCG_TARGET_REG_BITS > TARGET_LONG_BITS) {
1720 tcg_out_ext32u(s, TCG_REG_TMP1, addrlo);
1721 addrlo = TCG_REG_TMP1;
1722 }
1723 #endif
1724
1725 if (TCG_TARGET_REG_BITS == 32 && s_bits == MO_64) {
1726 if (opc & MO_BSWAP) {
1727 tcg_out32(s, ADDI | TAI(TCG_REG_R0, addrlo, 4));
1728 tcg_out32(s, STWBRX | SAB(datalo, rbase, addrlo));
1729 tcg_out32(s, STWBRX | SAB(datahi, rbase, TCG_REG_R0));
1730 } else if (rbase != 0) {
1731 tcg_out32(s, ADDI | TAI(TCG_REG_R0, addrlo, 4));
1732 tcg_out32(s, STWX | SAB(datahi, rbase, addrlo));
1733 tcg_out32(s, STWX | SAB(datalo, rbase, TCG_REG_R0));
1734 } else {
1735 tcg_out32(s, STW | TAI(datahi, addrlo, 0));
1736 tcg_out32(s, STW | TAI(datalo, addrlo, 4));
1737 }
1738 } else {
1739 uint32_t insn = qemu_stx_opc[opc & (MO_BSWAP | MO_SIZE)];
1740 if (!HAVE_ISA_2_06 && insn == STDBRX) {
1741 tcg_out32(s, STWBRX | SAB(datalo, rbase, addrlo));
1742 tcg_out32(s, ADDI | TAI(TCG_REG_TMP1, addrlo, 4));
1743 tcg_out_shri64(s, TCG_REG_R0, datalo, 32);
1744 tcg_out32(s, STWBRX | SAB(TCG_REG_R0, rbase, TCG_REG_TMP1));
1745 } else {
1746 tcg_out32(s, insn | SAB(datalo, rbase, addrlo));
1747 }
1748 }
1749
1750 #ifdef CONFIG_SOFTMMU
1751 add_qemu_ldst_label(s, false, oi, datalo, datahi, addrlo, addrhi,
1752 s->code_ptr, label_ptr);
1753 #endif
1754 }
1755
1756 /* Parameters for function call generation, used in tcg.c. */
1757 #define TCG_TARGET_STACK_ALIGN 16
1758 #define TCG_TARGET_EXTEND_ARGS 1
1759
1760 #ifdef _CALL_AIX
1761 # define LINK_AREA_SIZE (6 * SZR)
1762 # define LR_OFFSET (1 * SZR)
1763 # define TCG_TARGET_CALL_STACK_OFFSET (LINK_AREA_SIZE + 8 * SZR)
1764 #elif defined(TCG_TARGET_CALL_DARWIN)
1765 # define LINK_AREA_SIZE (6 * SZR)
1766 # define LR_OFFSET (2 * SZR)
1767 #elif TCG_TARGET_REG_BITS == 64
1768 # if defined(_CALL_ELF) && _CALL_ELF == 2
1769 # define LINK_AREA_SIZE (4 * SZR)
1770 # define LR_OFFSET (1 * SZR)
1771 # endif
1772 #else /* TCG_TARGET_REG_BITS == 32 */
1773 # if defined(_CALL_SYSV)
1774 # define LINK_AREA_SIZE (2 * SZR)
1775 # define LR_OFFSET (1 * SZR)
1776 # endif
1777 #endif
1778 #ifndef LR_OFFSET
1779 # error "Unhandled abi"
1780 #endif
1781 #ifndef TCG_TARGET_CALL_STACK_OFFSET
1782 # define TCG_TARGET_CALL_STACK_OFFSET LINK_AREA_SIZE
1783 #endif
1784
1785 #define CPU_TEMP_BUF_SIZE (CPU_TEMP_BUF_NLONGS * (int)sizeof(long))
1786 #define REG_SAVE_SIZE ((int)ARRAY_SIZE(tcg_target_callee_save_regs) * SZR)
1787
1788 #define FRAME_SIZE ((TCG_TARGET_CALL_STACK_OFFSET \
1789 + TCG_STATIC_CALL_ARGS_SIZE \
1790 + CPU_TEMP_BUF_SIZE \
1791 + REG_SAVE_SIZE \
1792 + TCG_TARGET_STACK_ALIGN - 1) \
1793 & -TCG_TARGET_STACK_ALIGN)
1794
1795 #define REG_SAVE_BOT (FRAME_SIZE - REG_SAVE_SIZE)
1796
1797 static void tcg_target_qemu_prologue(TCGContext *s)
1798 {
1799 int i;
1800
1801 #ifdef _CALL_AIX
1802 void **desc = (void **)s->code_ptr;
1803 desc[0] = desc + 2; /* entry point */
1804 desc[1] = 0; /* environment pointer */
1805 s->code_ptr = (void *)(desc + 2); /* skip over descriptor */
1806 #endif
1807
1808 tcg_set_frame(s, TCG_REG_CALL_STACK, REG_SAVE_BOT - CPU_TEMP_BUF_SIZE,
1809 CPU_TEMP_BUF_SIZE);
1810
1811 /* Prologue */
1812 tcg_out32(s, MFSPR | RT(TCG_REG_R0) | LR);
1813 tcg_out32(s, (SZR == 8 ? STDU : STWU)
1814 | SAI(TCG_REG_R1, TCG_REG_R1, -FRAME_SIZE));
1815
1816 for (i = 0; i < ARRAY_SIZE(tcg_target_callee_save_regs); ++i) {
1817 tcg_out_st(s, TCG_TYPE_REG, tcg_target_callee_save_regs[i],
1818 TCG_REG_R1, REG_SAVE_BOT + i * SZR);
1819 }
1820 tcg_out_st(s, TCG_TYPE_PTR, TCG_REG_R0, TCG_REG_R1, FRAME_SIZE+LR_OFFSET);
1821
1822 #ifndef CONFIG_SOFTMMU
1823 if (guest_base) {
1824 tcg_out_movi(s, TCG_TYPE_PTR, TCG_GUEST_BASE_REG, guest_base);
1825 tcg_regset_set_reg(s->reserved_regs, TCG_GUEST_BASE_REG);
1826 }
1827 #endif
1828
1829 tcg_out_mov(s, TCG_TYPE_PTR, TCG_AREG0, tcg_target_call_iarg_regs[0]);
1830 tcg_out32(s, MTSPR | RS(tcg_target_call_iarg_regs[1]) | CTR);
1831
1832 if (USE_REG_RA) {
1833 #ifdef _CALL_AIX
1834 /* Make the caller load the value as the TOC into R2. */
1835 tb_ret_addr = s->code_ptr + 2;
1836 desc[1] = tb_ret_addr;
1837 tcg_out_mov(s, TCG_TYPE_PTR, TCG_REG_RA, TCG_REG_R2);
1838 tcg_out32(s, BCCTR | BO_ALWAYS);
1839 #elif defined(_CALL_ELF) && _CALL_ELF == 2
1840 /* Compute from the incoming R12 value. */
1841 tb_ret_addr = s->code_ptr + 2;
1842 tcg_out32(s, ADDI | TAI(TCG_REG_RA, TCG_REG_R12,
1843 tcg_ptr_byte_diff(tb_ret_addr, s->code_buf)));
1844 tcg_out32(s, BCCTR | BO_ALWAYS);
1845 #else
1846 /* Reserve max 5 insns for the constant load. */
1847 tb_ret_addr = s->code_ptr + 6;
1848 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_RA, (intptr_t)tb_ret_addr);
1849 tcg_out32(s, BCCTR | BO_ALWAYS);
1850 while (s->code_ptr < tb_ret_addr) {
1851 tcg_out32(s, NOP);
1852 }
1853 #endif
1854 } else {
1855 tcg_out32(s, BCCTR | BO_ALWAYS);
1856 tb_ret_addr = s->code_ptr;
1857 }
1858
1859 /* Epilogue */
1860 assert(tb_ret_addr == s->code_ptr);
1861
1862 tcg_out_ld(s, TCG_TYPE_PTR, TCG_REG_R0, TCG_REG_R1, FRAME_SIZE+LR_OFFSET);
1863 for (i = 0; i < ARRAY_SIZE(tcg_target_callee_save_regs); ++i) {
1864 tcg_out_ld(s, TCG_TYPE_REG, tcg_target_callee_save_regs[i],
1865 TCG_REG_R1, REG_SAVE_BOT + i * SZR);
1866 }
1867 tcg_out32(s, MTSPR | RS(TCG_REG_R0) | LR);
1868 tcg_out32(s, ADDI | TAI(TCG_REG_R1, TCG_REG_R1, FRAME_SIZE));
1869 tcg_out32(s, BCLR | BO_ALWAYS);
1870 }
1871
1872 static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args,
1873 const int *const_args)
1874 {
1875 TCGArg a0, a1, a2;
1876 int c;
1877
1878 switch (opc) {
1879 case INDEX_op_exit_tb:
1880 if (USE_REG_RA) {
1881 ptrdiff_t disp = tcg_pcrel_diff(s, tb_ret_addr);
1882
1883 /* Use a direct branch if we can, otherwise use the value in RA.
1884 Note that the direct branch is always backward, thus we need
1885 to account for the possibility of 5 insns from the movi. */
1886 if (!in_range_b(disp - 20)) {
1887 tcg_out32(s, MTSPR | RS(TCG_REG_RA) | CTR);
1888 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_R3, args[0]);
1889 tcg_out32(s, BCCTR | BO_ALWAYS);
1890 break;
1891 }
1892 }
1893 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_R3, args[0]);
1894 tcg_out_b(s, 0, tb_ret_addr);
1895 break;
1896 case INDEX_op_goto_tb:
1897 tcg_debug_assert(s->tb_jmp_offset);
1898 /* Direct jump. Ensure the next insns are 8-byte aligned. */
1899 if ((uintptr_t)s->code_ptr & 7) {
1900 tcg_out32(s, NOP);
1901 }
1902 s->tb_jmp_offset[args[0]] = tcg_current_code_size(s);
1903 /* To be replaced by either a branch+nop or a load into TMP1. */
1904 s->code_ptr += 2;
1905 tcg_out32(s, MTSPR | RS(TCG_REG_TMP1) | CTR);
1906 tcg_out32(s, BCCTR | BO_ALWAYS);
1907 s->tb_next_offset[args[0]] = tcg_current_code_size(s);
1908 break;
1909 case INDEX_op_br:
1910 {
1911 TCGLabel *l = arg_label(args[0]);
1912
1913 if (l->has_value) {
1914 tcg_out_b(s, 0, l->u.value_ptr);
1915 } else {
1916 tcg_out_reloc(s, s->code_ptr, R_PPC_REL24, l, 0);
1917 tcg_out_b_noaddr(s, B);
1918 }
1919 }
1920 break;
1921 case INDEX_op_ld8u_i32:
1922 case INDEX_op_ld8u_i64:
1923 tcg_out_mem_long(s, LBZ, LBZX, args[0], args[1], args[2]);
1924 break;
1925 case INDEX_op_ld8s_i32:
1926 case INDEX_op_ld8s_i64:
1927 tcg_out_mem_long(s, LBZ, LBZX, args[0], args[1], args[2]);
1928 tcg_out32(s, EXTSB | RS(args[0]) | RA(args[0]));
1929 break;
1930 case INDEX_op_ld16u_i32:
1931 case INDEX_op_ld16u_i64:
1932 tcg_out_mem_long(s, LHZ, LHZX, args[0], args[1], args[2]);
1933 break;
1934 case INDEX_op_ld16s_i32:
1935 case INDEX_op_ld16s_i64:
1936 tcg_out_mem_long(s, LHA, LHAX, args[0], args[1], args[2]);
1937 break;
1938 case INDEX_op_ld_i32:
1939 case INDEX_op_ld32u_i64:
1940 tcg_out_mem_long(s, LWZ, LWZX, args[0], args[1], args[2]);
1941 break;
1942 case INDEX_op_ld32s_i64:
1943 tcg_out_mem_long(s, LWA, LWAX, args[0], args[1], args[2]);
1944 break;
1945 case INDEX_op_ld_i64:
1946 tcg_out_mem_long(s, LD, LDX, args[0], args[1], args[2]);
1947 break;
1948 case INDEX_op_st8_i32:
1949 case INDEX_op_st8_i64:
1950 tcg_out_mem_long(s, STB, STBX, args[0], args[1], args[2]);
1951 break;
1952 case INDEX_op_st16_i32:
1953 case INDEX_op_st16_i64:
1954 tcg_out_mem_long(s, STH, STHX, args[0], args[1], args[2]);
1955 break;
1956 case INDEX_op_st_i32:
1957 case INDEX_op_st32_i64:
1958 tcg_out_mem_long(s, STW, STWX, args[0], args[1], args[2]);
1959 break;
1960 case INDEX_op_st_i64:
1961 tcg_out_mem_long(s, STD, STDX, args[0], args[1], args[2]);
1962 break;
1963
1964 case INDEX_op_add_i32:
1965 a0 = args[0], a1 = args[1], a2 = args[2];
1966 if (const_args[2]) {
1967 do_addi_32:
1968 tcg_out_mem_long(s, ADDI, ADD, a0, a1, (int32_t)a2);
1969 } else {
1970 tcg_out32(s, ADD | TAB(a0, a1, a2));
1971 }
1972 break;
1973 case INDEX_op_sub_i32:
1974 a0 = args[0], a1 = args[1], a2 = args[2];
1975 if (const_args[1]) {
1976 if (const_args[2]) {
1977 tcg_out_movi(s, TCG_TYPE_I32, a0, a1 - a2);
1978 } else {
1979 tcg_out32(s, SUBFIC | TAI(a0, a2, a1));
1980 }
1981 } else if (const_args[2]) {
1982 a2 = -a2;
1983 goto do_addi_32;
1984 } else {
1985 tcg_out32(s, SUBF | TAB(a0, a2, a1));
1986 }
1987 break;
1988
1989 case INDEX_op_and_i32:
1990 a0 = args[0], a1 = args[1], a2 = args[2];
1991 if (const_args[2]) {
1992 tcg_out_andi32(s, a0, a1, a2);
1993 } else {
1994 tcg_out32(s, AND | SAB(a1, a0, a2));
1995 }
1996 break;
1997 case INDEX_op_and_i64:
1998 a0 = args[0], a1 = args[1], a2 = args[2];
1999 if (const_args[2]) {
2000 tcg_out_andi64(s, a0, a1, a2);
2001 } else {
2002 tcg_out32(s, AND | SAB(a1, a0, a2));
2003 }
2004 break;
2005 case INDEX_op_or_i64:
2006 case INDEX_op_or_i32:
2007 a0 = args[0], a1 = args[1], a2 = args[2];
2008 if (const_args[2]) {
2009 tcg_out_ori32(s, a0, a1, a2);
2010 } else {
2011 tcg_out32(s, OR | SAB(a1, a0, a2));
2012 }
2013 break;
2014 case INDEX_op_xor_i64:
2015 case INDEX_op_xor_i32:
2016 a0 = args[0], a1 = args[1], a2 = args[2];
2017 if (const_args[2]) {
2018 tcg_out_xori32(s, a0, a1, a2);
2019 } else {
2020 tcg_out32(s, XOR | SAB(a1, a0, a2));
2021 }
2022 break;
2023 case INDEX_op_andc_i32:
2024 a0 = args[0], a1 = args[1], a2 = args[2];
2025 if (const_args[2]) {
2026 tcg_out_andi32(s, a0, a1, ~a2);
2027 } else {
2028 tcg_out32(s, ANDC | SAB(a1, a0, a2));
2029 }
2030 break;
2031 case INDEX_op_andc_i64:
2032 a0 = args[0], a1 = args[1], a2 = args[2];
2033 if (const_args[2]) {
2034 tcg_out_andi64(s, a0, a1, ~a2);
2035 } else {
2036 tcg_out32(s, ANDC | SAB(a1, a0, a2));
2037 }
2038 break;
2039 case INDEX_op_orc_i32:
2040 if (const_args[2]) {
2041 tcg_out_ori32(s, args[0], args[1], ~args[2]);
2042 break;
2043 }
2044 /* FALLTHRU */
2045 case INDEX_op_orc_i64:
2046 tcg_out32(s, ORC | SAB(args[1], args[0], args[2]));
2047 break;
2048 case INDEX_op_eqv_i32:
2049 if (const_args[2]) {
2050 tcg_out_xori32(s, args[0], args[1], ~args[2]);
2051 break;
2052 }
2053 /* FALLTHRU */
2054 case INDEX_op_eqv_i64:
2055 tcg_out32(s, EQV | SAB(args[1], args[0], args[2]));
2056 break;
2057 case INDEX_op_nand_i32:
2058 case INDEX_op_nand_i64:
2059 tcg_out32(s, NAND | SAB(args[1], args[0], args[2]));
2060 break;
2061 case INDEX_op_nor_i32:
2062 case INDEX_op_nor_i64:
2063 tcg_out32(s, NOR | SAB(args[1], args[0], args[2]));
2064 break;
2065
2066 case INDEX_op_mul_i32:
2067 a0 = args[0], a1 = args[1], a2 = args[2];
2068 if (const_args[2]) {
2069 tcg_out32(s, MULLI | TAI(a0, a1, a2));
2070 } else {
2071 tcg_out32(s, MULLW | TAB(a0, a1, a2));
2072 }
2073 break;
2074
2075 case INDEX_op_div_i32:
2076 tcg_out32(s, DIVW | TAB(args[0], args[1], args[2]));
2077 break;
2078
2079 case INDEX_op_divu_i32:
2080 tcg_out32(s, DIVWU | TAB(args[0], args[1], args[2]));
2081 break;
2082
2083 case INDEX_op_shl_i32:
2084 if (const_args[2]) {
2085 tcg_out_shli32(s, args[0], args[1], args[2]);
2086 } else {
2087 tcg_out32(s, SLW | SAB(args[1], args[0], args[2]));
2088 }
2089 break;
2090 case INDEX_op_shr_i32:
2091 if (const_args[2]) {
2092 tcg_out_shri32(s, args[0], args[1], args[2]);
2093 } else {
2094 tcg_out32(s, SRW | SAB(args[1], args[0], args[2]));
2095 }
2096 break;
2097 case INDEX_op_sar_i32:
2098 if (const_args[2]) {
2099 tcg_out32(s, SRAWI | RS(args[1]) | RA(args[0]) | SH(args[2]));
2100 } else {
2101 tcg_out32(s, SRAW | SAB(args[1], args[0], args[2]));
2102 }
2103 break;
2104 case INDEX_op_rotl_i32:
2105 if (const_args[2]) {
2106 tcg_out_rlw(s, RLWINM, args[0], args[1], args[2], 0, 31);
2107 } else {
2108 tcg_out32(s, RLWNM | SAB(args[1], args[0], args[2])
2109 | MB(0) | ME(31));
2110 }
2111 break;
2112 case INDEX_op_rotr_i32:
2113 if (const_args[2]) {
2114 tcg_out_rlw(s, RLWINM, args[0], args[1], 32 - args[2], 0, 31);
2115 } else {
2116 tcg_out32(s, SUBFIC | TAI(TCG_REG_R0, args[2], 32));
2117 tcg_out32(s, RLWNM | SAB(args[1], args[0], TCG_REG_R0)
2118 | MB(0) | ME(31));
2119 }
2120 break;
2121
2122 case INDEX_op_brcond_i32:
2123 tcg_out_brcond(s, args[2], args[0], args[1], const_args[1],
2124 arg_label(args[3]), TCG_TYPE_I32);
2125 break;
2126 case INDEX_op_brcond_i64:
2127 tcg_out_brcond(s, args[2], args[0], args[1], const_args[1],
2128 arg_label(args[3]), TCG_TYPE_I64);
2129 break;
2130 case INDEX_op_brcond2_i32:
2131 tcg_out_brcond2(s, args, const_args);
2132 break;
2133
2134 case INDEX_op_neg_i32:
2135 case INDEX_op_neg_i64:
2136 tcg_out32(s, NEG | RT(args[0]) | RA(args[1]));
2137 break;
2138
2139 case INDEX_op_not_i32:
2140 case INDEX_op_not_i64:
2141 tcg_out32(s, NOR | SAB(args[1], args[0], args[1]));
2142 break;
2143
2144 case INDEX_op_add_i64:
2145 a0 = args[0], a1 = args[1], a2 = args[2];
2146 if (const_args[2]) {
2147 do_addi_64:
2148 tcg_out_mem_long(s, ADDI, ADD, a0, a1, a2);
2149 } else {
2150 tcg_out32(s, ADD | TAB(a0, a1, a2));
2151 }
2152 break;
2153 case INDEX_op_sub_i64:
2154 a0 = args[0], a1 = args[1], a2 = args[2];
2155 if (const_args[1]) {
2156 if (const_args[2]) {
2157 tcg_out_movi(s, TCG_TYPE_I64, a0, a1 - a2);
2158 } else {
2159 tcg_out32(s, SUBFIC | TAI(a0, a2, a1));
2160 }
2161 } else if (const_args[2]) {
2162 a2 = -a2;
2163 goto do_addi_64;
2164 } else {
2165 tcg_out32(s, SUBF | TAB(a0, a2, a1));
2166 }
2167 break;
2168
2169 case INDEX_op_shl_i64:
2170 if (const_args[2]) {
2171 tcg_out_shli64(s, args[0], args[1], args[2]);
2172 } else {
2173 tcg_out32(s, SLD | SAB(args[1], args[0], args[2]));
2174 }
2175 break;
2176 case INDEX_op_shr_i64:
2177 if (const_args[2]) {
2178 tcg_out_shri64(s, args[0], args[1], args[2]);
2179 } else {
2180 tcg_out32(s, SRD | SAB(args[1], args[0], args[2]));
2181 }
2182 break;
2183 case INDEX_op_sar_i64:
2184 if (const_args[2]) {
2185 int sh = SH(args[2] & 0x1f) | (((args[2] >> 5) & 1) << 1);
2186 tcg_out32(s, SRADI | RA(args[0]) | RS(args[1]) | sh);
2187 } else {
2188 tcg_out32(s, SRAD | SAB(args[1], args[0], args[2]));
2189 }
2190 break;
2191 case INDEX_op_rotl_i64:
2192 if (const_args[2]) {
2193 tcg_out_rld(s, RLDICL, args[0], args[1], args[2], 0);
2194 } else {
2195 tcg_out32(s, RLDCL | SAB(args[1], args[0], args[2]) | MB64(0));
2196 }
2197 break;
2198 case INDEX_op_rotr_i64:
2199 if (const_args[2]) {
2200 tcg_out_rld(s, RLDICL, args[0], args[1], 64 - args[2], 0);
2201 } else {
2202 tcg_out32(s, SUBFIC | TAI(TCG_REG_R0, args[2], 64));
2203 tcg_out32(s, RLDCL | SAB(args[1], args[0], TCG_REG_R0) | MB64(0));
2204 }
2205 break;
2206
2207 case INDEX_op_mul_i64:
2208 a0 = args[0], a1 = args[1], a2 = args[2];
2209 if (const_args[2]) {
2210 tcg_out32(s, MULLI | TAI(a0, a1, a2));
2211 } else {
2212 tcg_out32(s, MULLD | TAB(a0, a1, a2));
2213 }
2214 break;
2215 case INDEX_op_div_i64:
2216 tcg_out32(s, DIVD | TAB(args[0], args[1], args[2]));
2217 break;
2218 case INDEX_op_divu_i64:
2219 tcg_out32(s, DIVDU | TAB(args[0], args[1], args[2]));
2220 break;
2221
2222 case INDEX_op_qemu_ld_i32:
2223 tcg_out_qemu_ld(s, args, false);
2224 break;
2225 case INDEX_op_qemu_ld_i64:
2226 tcg_out_qemu_ld(s, args, true);
2227 break;
2228 case INDEX_op_qemu_st_i32:
2229 tcg_out_qemu_st(s, args, false);
2230 break;
2231 case INDEX_op_qemu_st_i64:
2232 tcg_out_qemu_st(s, args, true);
2233 break;
2234
2235 case INDEX_op_ext8s_i32:
2236 case INDEX_op_ext8s_i64:
2237 c = EXTSB;
2238 goto gen_ext;
2239 case INDEX_op_ext16s_i32:
2240 case INDEX_op_ext16s_i64:
2241 c = EXTSH;
2242 goto gen_ext;
2243 case INDEX_op_ext_i32_i64:
2244 case INDEX_op_ext32s_i64:
2245 c = EXTSW;
2246 goto gen_ext;
2247 gen_ext:
2248 tcg_out32(s, c | RS(args[1]) | RA(args[0]));
2249 break;
2250 case INDEX_op_extu_i32_i64:
2251 tcg_out_ext32u(s, args[0], args[1]);
2252 break;
2253
2254 case INDEX_op_setcond_i32:
2255 tcg_out_setcond(s, TCG_TYPE_I32, args[3], args[0], args[1], args[2],
2256 const_args[2]);
2257 break;
2258 case INDEX_op_setcond_i64:
2259 tcg_out_setcond(s, TCG_TYPE_I64, args[3], args[0], args[1], args[2],
2260 const_args[2]);
2261 break;
2262 case INDEX_op_setcond2_i32:
2263 tcg_out_setcond2(s, args, const_args);
2264 break;
2265
2266 case INDEX_op_bswap16_i32:
2267 case INDEX_op_bswap16_i64:
2268 a0 = args[0], a1 = args[1];
2269 /* a1 = abcd */
2270 if (a0 != a1) {
2271 /* a0 = (a1 r<< 24) & 0xff # 000c */
2272 tcg_out_rlw(s, RLWINM, a0, a1, 24, 24, 31);
2273 /* a0 = (a0 & ~0xff00) | (a1 r<< 8) & 0xff00 # 00dc */
2274 tcg_out_rlw(s, RLWIMI, a0, a1, 8, 16, 23);
2275 } else {
2276 /* r0 = (a1 r<< 8) & 0xff00 # 00d0 */
2277 tcg_out_rlw(s, RLWINM, TCG_REG_R0, a1, 8, 16, 23);
2278 /* a0 = (a1 r<< 24) & 0xff # 000c */
2279 tcg_out_rlw(s, RLWINM, a0, a1, 24, 24, 31);
2280 /* a0 = a0 | r0 # 00dc */
2281 tcg_out32(s, OR | SAB(TCG_REG_R0, a0, a0));
2282 }
2283 break;
2284
2285 case INDEX_op_bswap32_i32:
2286 case INDEX_op_bswap32_i64:
2287 /* Stolen from gcc's builtin_bswap32 */
2288 a1 = args[1];
2289 a0 = args[0] == a1 ? TCG_REG_R0 : args[0];
2290
2291 /* a1 = args[1] # abcd */
2292 /* a0 = rotate_left (a1, 8) # bcda */
2293 tcg_out_rlw(s, RLWINM, a0, a1, 8, 0, 31);
2294 /* a0 = (a0 & ~0xff000000) | ((a1 r<< 24) & 0xff000000) # dcda */
2295 tcg_out_rlw(s, RLWIMI, a0, a1, 24, 0, 7);
2296 /* a0 = (a0 & ~0x0000ff00) | ((a1 r<< 24) & 0x0000ff00) # dcba */
2297 tcg_out_rlw(s, RLWIMI, a0, a1, 24, 16, 23);
2298
2299 if (a0 == TCG_REG_R0) {
2300 tcg_out_mov(s, TCG_TYPE_REG, args[0], a0);
2301 }
2302 break;
2303
2304 case INDEX_op_bswap64_i64:
2305 a0 = args[0], a1 = args[1], a2 = TCG_REG_R0;
2306 if (a0 == a1) {
2307 a0 = TCG_REG_R0;
2308 a2 = a1;
2309 }
2310
2311 /* a1 = # abcd efgh */
2312 /* a0 = rl32(a1, 8) # 0000 fghe */
2313 tcg_out_rlw(s, RLWINM, a0, a1, 8, 0, 31);
2314 /* a0 = dep(a0, rl32(a1, 24), 0xff000000) # 0000 hghe */
2315 tcg_out_rlw(s, RLWIMI, a0, a1, 24, 0, 7);
2316 /* a0 = dep(a0, rl32(a1, 24), 0x0000ff00) # 0000 hgfe */
2317 tcg_out_rlw(s, RLWIMI, a0, a1, 24, 16, 23);
2318
2319 /* a0 = rl64(a0, 32) # hgfe 0000 */
2320 /* a2 = rl64(a1, 32) # efgh abcd */
2321 tcg_out_rld(s, RLDICL, a0, a0, 32, 0);
2322 tcg_out_rld(s, RLDICL, a2, a1, 32, 0);
2323
2324 /* a0 = dep(a0, rl32(a2, 8), 0xffffffff) # hgfe bcda */
2325 tcg_out_rlw(s, RLWIMI, a0, a2, 8, 0, 31);
2326 /* a0 = dep(a0, rl32(a2, 24), 0xff000000) # hgfe dcda */
2327 tcg_out_rlw(s, RLWIMI, a0, a2, 24, 0, 7);
2328 /* a0 = dep(a0, rl32(a2, 24), 0x0000ff00) # hgfe dcba */
2329 tcg_out_rlw(s, RLWIMI, a0, a2, 24, 16, 23);
2330
2331 if (a0 == 0) {
2332 tcg_out_mov(s, TCG_TYPE_REG, args[0], a0);
2333 }
2334 break;
2335
2336 case INDEX_op_deposit_i32:
2337 if (const_args[2]) {
2338 uint32_t mask = ((2u << (args[4] - 1)) - 1) << args[3];
2339 tcg_out_andi32(s, args[0], args[0], ~mask);
2340 } else {
2341 tcg_out_rlw(s, RLWIMI, args[0], args[2], args[3],
2342 32 - args[3] - args[4], 31 - args[3]);
2343 }
2344 break;
2345 case INDEX_op_deposit_i64:
2346 if (const_args[2]) {
2347 uint64_t mask = ((2ull << (args[4] - 1)) - 1) << args[3];
2348 tcg_out_andi64(s, args[0], args[0], ~mask);
2349 } else {
2350 tcg_out_rld(s, RLDIMI, args[0], args[2], args[3],
2351 64 - args[3] - args[4]);
2352 }
2353 break;
2354
2355 case INDEX_op_movcond_i32:
2356 tcg_out_movcond(s, TCG_TYPE_I32, args[5], args[0], args[1], args[2],
2357 args[3], args[4], const_args[2]);
2358 break;
2359 case INDEX_op_movcond_i64:
2360 tcg_out_movcond(s, TCG_TYPE_I64, args[5], args[0], args[1], args[2],
2361 args[3], args[4], const_args[2]);
2362 break;
2363
2364 #if TCG_TARGET_REG_BITS == 64
2365 case INDEX_op_add2_i64:
2366 #else
2367 case INDEX_op_add2_i32:
2368 #endif
2369 /* Note that the CA bit is defined based on the word size of the
2370 environment. So in 64-bit mode it's always carry-out of bit 63.
2371 The fallback code using deposit works just as well for 32-bit. */
2372 a0 = args[0], a1 = args[1];
2373 if (a0 == args[3] || (!const_args[5] && a0 == args[5])) {
2374 a0 = TCG_REG_R0;
2375 }
2376 if (const_args[4]) {
2377 tcg_out32(s, ADDIC | TAI(a0, args[2], args[4]));
2378 } else {
2379 tcg_out32(s, ADDC | TAB(a0, args[2], args[4]));
2380 }
2381 if (const_args[5]) {
2382 tcg_out32(s, (args[5] ? ADDME : ADDZE) | RT(a1) | RA(args[3]));
2383 } else {
2384 tcg_out32(s, ADDE | TAB(a1, args[3], args[5]));
2385 }
2386 if (a0 != args[0]) {
2387 tcg_out_mov(s, TCG_TYPE_REG, args[0], a0);
2388 }
2389 break;
2390
2391 #if TCG_TARGET_REG_BITS == 64
2392 case INDEX_op_sub2_i64:
2393 #else
2394 case INDEX_op_sub2_i32:
2395 #endif
2396 a0 = args[0], a1 = args[1];
2397 if (a0 == args[5] || (!const_args[3] && a0 == args[3])) {
2398 a0 = TCG_REG_R0;
2399 }
2400 if (const_args[2]) {
2401 tcg_out32(s, SUBFIC | TAI(a0, args[4], args[2]));
2402 } else {
2403 tcg_out32(s, SUBFC | TAB(a0, args[4], args[2]));
2404 }
2405 if (const_args[3]) {
2406 tcg_out32(s, (args[3] ? SUBFME : SUBFZE) | RT(a1) | RA(args[5]));
2407 } else {
2408 tcg_out32(s, SUBFE | TAB(a1, args[5], args[3]));
2409 }
2410 if (a0 != args[0]) {
2411 tcg_out_mov(s, TCG_TYPE_REG, args[0], a0);
2412 }
2413 break;
2414
2415 case INDEX_op_muluh_i32:
2416 tcg_out32(s, MULHWU | TAB(args[0], args[1], args[2]));
2417 break;
2418 case INDEX_op_mulsh_i32:
2419 tcg_out32(s, MULHW | TAB(args[0], args[1], args[2]));
2420 break;
2421 case INDEX_op_muluh_i64:
2422 tcg_out32(s, MULHDU | TAB(args[0], args[1], args[2]));
2423 break;
2424 case INDEX_op_mulsh_i64:
2425 tcg_out32(s, MULHD | TAB(args[0], args[1], args[2]));
2426 break;
2427
2428 case INDEX_op_mov_i32: /* Always emitted via tcg_out_mov. */
2429 case INDEX_op_mov_i64:
2430 case INDEX_op_movi_i32: /* Always emitted via tcg_out_movi. */
2431 case INDEX_op_movi_i64:
2432 case INDEX_op_call: /* Always emitted via tcg_out_call. */
2433 default:
2434 tcg_abort();
2435 }
2436 }
2437
2438 static const TCGTargetOpDef ppc_op_defs[] = {
2439 { INDEX_op_exit_tb, { } },
2440 { INDEX_op_goto_tb, { } },
2441 { INDEX_op_br, { } },
2442
2443 { INDEX_op_ld8u_i32, { "r", "r" } },
2444 { INDEX_op_ld8s_i32, { "r", "r" } },
2445 { INDEX_op_ld16u_i32, { "r", "r" } },
2446 { INDEX_op_ld16s_i32, { "r", "r" } },
2447 { INDEX_op_ld_i32, { "r", "r" } },
2448
2449 { INDEX_op_st8_i32, { "r", "r" } },
2450 { INDEX_op_st16_i32, { "r", "r" } },
2451 { INDEX_op_st_i32, { "r", "r" } },
2452
2453 { INDEX_op_add_i32, { "r", "r", "ri" } },
2454 { INDEX_op_mul_i32, { "r", "r", "rI" } },
2455 { INDEX_op_div_i32, { "r", "r", "r" } },
2456 { INDEX_op_divu_i32, { "r", "r", "r" } },
2457 { INDEX_op_sub_i32, { "r", "rI", "ri" } },
2458 { INDEX_op_and_i32, { "r", "r", "ri" } },
2459 { INDEX_op_or_i32, { "r", "r", "ri" } },
2460 { INDEX_op_xor_i32, { "r", "r", "ri" } },
2461 { INDEX_op_andc_i32, { "r", "r", "ri" } },
2462 { INDEX_op_orc_i32, { "r", "r", "ri" } },
2463 { INDEX_op_eqv_i32, { "r", "r", "ri" } },
2464 { INDEX_op_nand_i32, { "r", "r", "r" } },
2465 { INDEX_op_nor_i32, { "r", "r", "r" } },
2466
2467 { INDEX_op_shl_i32, { "r", "r", "ri" } },
2468 { INDEX_op_shr_i32, { "r", "r", "ri" } },
2469 { INDEX_op_sar_i32, { "r", "r", "ri" } },
2470 { INDEX_op_rotl_i32, { "r", "r", "ri" } },
2471 { INDEX_op_rotr_i32, { "r", "r", "ri" } },
2472
2473 { INDEX_op_neg_i32, { "r", "r" } },
2474 { INDEX_op_not_i32, { "r", "r" } },
2475 { INDEX_op_ext8s_i32, { "r", "r" } },
2476 { INDEX_op_ext16s_i32, { "r", "r" } },
2477 { INDEX_op_bswap16_i32, { "r", "r" } },
2478 { INDEX_op_bswap32_i32, { "r", "r" } },
2479
2480 { INDEX_op_brcond_i32, { "r", "ri" } },
2481 { INDEX_op_setcond_i32, { "r", "r", "ri" } },
2482 { INDEX_op_movcond_i32, { "r", "r", "ri", "rZ", "rZ" } },
2483
2484 { INDEX_op_deposit_i32, { "r", "0", "rZ" } },
2485
2486 { INDEX_op_muluh_i32, { "r", "r", "r" } },
2487 { INDEX_op_mulsh_i32, { "r", "r", "r" } },
2488
2489 #if TCG_TARGET_REG_BITS == 64
2490 { INDEX_op_ld8u_i64, { "r", "r" } },
2491 { INDEX_op_ld8s_i64, { "r", "r" } },
2492 { INDEX_op_ld16u_i64, { "r", "r" } },
2493 { INDEX_op_ld16s_i64, { "r", "r" } },
2494 { INDEX_op_ld32u_i64, { "r", "r" } },
2495 { INDEX_op_ld32s_i64, { "r", "r" } },
2496 { INDEX_op_ld_i64, { "r", "r" } },
2497
2498 { INDEX_op_st8_i64, { "r", "r" } },
2499 { INDEX_op_st16_i64, { "r", "r" } },
2500 { INDEX_op_st32_i64, { "r", "r" } },
2501 { INDEX_op_st_i64, { "r", "r" } },
2502
2503 { INDEX_op_add_i64, { "r", "r", "rT" } },
2504 { INDEX_op_sub_i64, { "r", "rI", "rT" } },
2505 { INDEX_op_and_i64, { "r", "r", "ri" } },
2506 { INDEX_op_or_i64, { "r", "r", "rU" } },
2507 { INDEX_op_xor_i64, { "r", "r", "rU" } },
2508 { INDEX_op_andc_i64, { "r", "r", "ri" } },
2509 { INDEX_op_orc_i64, { "r", "r", "r" } },
2510 { INDEX_op_eqv_i64, { "r", "r", "r" } },
2511 { INDEX_op_nand_i64, { "r", "r", "r" } },
2512 { INDEX_op_nor_i64, { "r", "r", "r" } },
2513
2514 { INDEX_op_shl_i64, { "r", "r", "ri" } },
2515 { INDEX_op_shr_i64, { "r", "r", "ri" } },
2516 { INDEX_op_sar_i64, { "r", "r", "ri" } },
2517 { INDEX_op_rotl_i64, { "r", "r", "ri" } },
2518 { INDEX_op_rotr_i64, { "r", "r", "ri" } },
2519
2520 { INDEX_op_mul_i64, { "r", "r", "rI" } },
2521 { INDEX_op_div_i64, { "r", "r", "r" } },
2522 { INDEX_op_divu_i64, { "r", "r", "r" } },
2523
2524 { INDEX_op_neg_i64, { "r", "r" } },
2525 { INDEX_op_not_i64, { "r", "r" } },
2526 { INDEX_op_ext8s_i64, { "r", "r" } },
2527 { INDEX_op_ext16s_i64, { "r", "r" } },
2528 { INDEX_op_ext32s_i64, { "r", "r" } },
2529 { INDEX_op_ext_i32_i64, { "r", "r" } },
2530 { INDEX_op_extu_i32_i64, { "r", "r" } },
2531 { INDEX_op_bswap16_i64, { "r", "r" } },
2532 { INDEX_op_bswap32_i64, { "r", "r" } },
2533 { INDEX_op_bswap64_i64, { "r", "r" } },
2534
2535 { INDEX_op_brcond_i64, { "r", "ri" } },
2536 { INDEX_op_setcond_i64, { "r", "r", "ri" } },
2537 { INDEX_op_movcond_i64, { "r", "r", "ri", "rZ", "rZ" } },
2538
2539 { INDEX_op_deposit_i64, { "r", "0", "rZ" } },
2540
2541 { INDEX_op_mulsh_i64, { "r", "r", "r" } },
2542 { INDEX_op_muluh_i64, { "r", "r", "r" } },
2543 #endif
2544
2545 #if TCG_TARGET_REG_BITS == 32
2546 { INDEX_op_brcond2_i32, { "r", "r", "ri", "ri" } },
2547 { INDEX_op_setcond2_i32, { "r", "r", "r", "ri", "ri" } },
2548 #endif
2549
2550 #if TCG_TARGET_REG_BITS == 64
2551 { INDEX_op_add2_i64, { "r", "r", "r", "r", "rI", "rZM" } },
2552 { INDEX_op_sub2_i64, { "r", "r", "rI", "rZM", "r", "r" } },
2553 #else
2554 { INDEX_op_add2_i32, { "r", "r", "r", "r", "rI", "rZM" } },
2555 { INDEX_op_sub2_i32, { "r", "r", "rI", "rZM", "r", "r" } },
2556 #endif
2557
2558 #if TCG_TARGET_REG_BITS == 64
2559 { INDEX_op_qemu_ld_i32, { "r", "L" } },
2560 { INDEX_op_qemu_st_i32, { "S", "S" } },
2561 { INDEX_op_qemu_ld_i64, { "r", "L" } },
2562 { INDEX_op_qemu_st_i64, { "S", "S" } },
2563 #elif TARGET_LONG_BITS == 32
2564 { INDEX_op_qemu_ld_i32, { "r", "L" } },
2565 { INDEX_op_qemu_st_i32, { "S", "S" } },
2566 { INDEX_op_qemu_ld_i64, { "L", "L", "L" } },
2567 { INDEX_op_qemu_st_i64, { "S", "S", "S" } },
2568 #else
2569 { INDEX_op_qemu_ld_i32, { "r", "L", "L" } },
2570 { INDEX_op_qemu_st_i32, { "S", "S", "S" } },
2571 { INDEX_op_qemu_ld_i64, { "L", "L", "L", "L" } },
2572 { INDEX_op_qemu_st_i64, { "S", "S", "S", "S" } },
2573 #endif
2574
2575 { -1 },
2576 };
2577
2578 static void tcg_target_init(TCGContext *s)
2579 {
2580 unsigned long hwcap = qemu_getauxval(AT_HWCAP);
2581 if (hwcap & PPC_FEATURE_ARCH_2_06) {
2582 have_isa_2_06 = true;
2583 }
2584
2585 tcg_regset_set32(tcg_target_available_regs[TCG_TYPE_I32], 0, 0xffffffff);
2586 tcg_regset_set32(tcg_target_available_regs[TCG_TYPE_I64], 0, 0xffffffff);
2587 tcg_regset_set32(tcg_target_call_clobber_regs, 0,
2588 (1 << TCG_REG_R0) |
2589 (1 << TCG_REG_R2) |
2590 (1 << TCG_REG_R3) |
2591 (1 << TCG_REG_R4) |
2592 (1 << TCG_REG_R5) |
2593 (1 << TCG_REG_R6) |
2594 (1 << TCG_REG_R7) |
2595 (1 << TCG_REG_R8) |
2596 (1 << TCG_REG_R9) |
2597 (1 << TCG_REG_R10) |
2598 (1 << TCG_REG_R11) |
2599 (1 << TCG_REG_R12));
2600
2601 tcg_regset_clear(s->reserved_regs);
2602 tcg_regset_set_reg(s->reserved_regs, TCG_REG_R0); /* tcg temp */
2603 tcg_regset_set_reg(s->reserved_regs, TCG_REG_R1); /* stack pointer */
2604 #if defined(_CALL_SYSV)
2605 tcg_regset_set_reg(s->reserved_regs, TCG_REG_R2); /* toc pointer */
2606 #endif
2607 #if defined(_CALL_SYSV) || TCG_TARGET_REG_BITS == 64
2608 tcg_regset_set_reg(s->reserved_regs, TCG_REG_R13); /* thread pointer */
2609 #endif
2610 tcg_regset_set_reg(s->reserved_regs, TCG_REG_TMP1); /* mem temp */
2611 if (USE_REG_RA) {
2612 tcg_regset_set_reg(s->reserved_regs, TCG_REG_RA); /* return addr */
2613 }
2614
2615 tcg_add_target_add_op_defs(ppc_op_defs);
2616 }
2617
2618 #ifdef __ELF__
2619 typedef struct {
2620 DebugFrameCIE cie;
2621 DebugFrameFDEHeader fde;
2622 uint8_t fde_def_cfa[4];
2623 uint8_t fde_reg_ofs[ARRAY_SIZE(tcg_target_callee_save_regs) * 2 + 3];
2624 } DebugFrame;
2625
2626 /* We're expecting a 2 byte uleb128 encoded value. */
2627 QEMU_BUILD_BUG_ON(FRAME_SIZE >= (1 << 14));
2628
2629 #if TCG_TARGET_REG_BITS == 64
2630 # define ELF_HOST_MACHINE EM_PPC64
2631 #else
2632 # define ELF_HOST_MACHINE EM_PPC
2633 #endif
2634
2635 static DebugFrame debug_frame = {
2636 .cie.len = sizeof(DebugFrameCIE)-4, /* length after .len member */
2637 .cie.id = -1,
2638 .cie.version = 1,
2639 .cie.code_align = 1,
2640 .cie.data_align = (-SZR & 0x7f), /* sleb128 -SZR */
2641 .cie.return_column = 65,
2642
2643 /* Total FDE size does not include the "len" member. */
2644 .fde.len = sizeof(DebugFrame) - offsetof(DebugFrame, fde.cie_offset),
2645
2646 .fde_def_cfa = {
2647 12, TCG_REG_R1, /* DW_CFA_def_cfa r1, ... */
2648 (FRAME_SIZE & 0x7f) | 0x80, /* ... uleb128 FRAME_SIZE */
2649 (FRAME_SIZE >> 7)
2650 },
2651 .fde_reg_ofs = {
2652 /* DW_CFA_offset_extended_sf, lr, LR_OFFSET */
2653 0x11, 65, (LR_OFFSET / -SZR) & 0x7f,
2654 }
2655 };
2656
2657 void tcg_register_jit(void *buf, size_t buf_size)
2658 {
2659 uint8_t *p = &debug_frame.fde_reg_ofs[3];
2660 int i;
2661
2662 for (i = 0; i < ARRAY_SIZE(tcg_target_callee_save_regs); ++i, p += 2) {
2663 p[0] = 0x80 + tcg_target_callee_save_regs[i];
2664 p[1] = (FRAME_SIZE - (REG_SAVE_BOT + i * SZR)) / SZR;
2665 }
2666
2667 debug_frame.fde.func_start = (uintptr_t)buf;
2668 debug_frame.fde.func_len = buf_size;
2669
2670 tcg_register_jit_int(buf, buf_size, &debug_frame, sizeof(debug_frame));
2671 }
2672 #endif /* __ELF__ */
2673
2674 static size_t dcache_bsize = 16;
2675 static size_t icache_bsize = 16;
2676
2677 void flush_icache_range(uintptr_t start, uintptr_t stop)
2678 {
2679 uintptr_t p, start1, stop1;
2680 size_t dsize = dcache_bsize;
2681 size_t isize = icache_bsize;
2682
2683 start1 = start & ~(dsize - 1);
2684 stop1 = (stop + dsize - 1) & ~(dsize - 1);
2685 for (p = start1; p < stop1; p += dsize) {
2686 asm volatile ("dcbst 0,%0" : : "r"(p) : "memory");
2687 }
2688 asm volatile ("sync" : : : "memory");
2689
2690 start &= start & ~(isize - 1);
2691 stop1 = (stop + isize - 1) & ~(isize - 1);
2692 for (p = start1; p < stop1; p += isize) {
2693 asm volatile ("icbi 0,%0" : : "r"(p) : "memory");
2694 }
2695 asm volatile ("sync" : : : "memory");
2696 asm volatile ("isync" : : : "memory");
2697 }
2698
2699 #if defined _AIX
2700 #include <sys/systemcfg.h>
2701
2702 static void __attribute__((constructor)) tcg_cache_init(void)
2703 {
2704 icache_bsize = _system_configuration.icache_line;
2705 dcache_bsize = _system_configuration.dcache_line;
2706 }
2707
2708 #elif defined __linux__
2709 static void __attribute__((constructor)) tcg_cache_init(void)
2710 {
2711 unsigned long dsize = qemu_getauxval(AT_DCACHEBSIZE);
2712 unsigned long isize = qemu_getauxval(AT_ICACHEBSIZE);
2713
2714 if (dsize == 0 || isize == 0) {
2715 if (dsize == 0) {
2716 fprintf(stderr, "getauxval AT_DCACHEBSIZE failed\n");
2717 }
2718 if (isize == 0) {
2719 fprintf(stderr, "getauxval AT_ICACHEBSIZE failed\n");
2720 }
2721 exit(1);
2722 }
2723 dcache_bsize = dsize;
2724 icache_bsize = isize;
2725 }
2726
2727 #elif defined __APPLE__
2728 #include <sys/sysctl.h>
2729
2730 static void __attribute__((constructor)) tcg_cache_init(void)
2731 {
2732 size_t len;
2733 unsigned cacheline;
2734 int name[2] = { CTL_HW, HW_CACHELINE };
2735
2736 len = sizeof(cacheline);
2737 if (sysctl(name, 2, &cacheline, &len, NULL, 0)) {
2738 perror("sysctl CTL_HW HW_CACHELINE failed");
2739 exit(1);
2740 }
2741 dcache_bsize = cacheline;
2742 icache_bsize = cacheline;
2743 }
2744
2745 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2746 #include <sys/sysctl.h>
2747
2748 static void __attribute__((constructor)) tcg_cache_init(void)
2749 {
2750 size_t len = 4;
2751 unsigned cacheline;
2752
2753 if (sysctlbyname ("machdep.cacheline_size", &cacheline, &len, NULL, 0)) {
2754 fprintf(stderr, "sysctlbyname machdep.cacheline_size failed: %s\n",
2755 strerror(errno));
2756 exit(1);
2757 }
2758 dcache_bsize = cacheline;
2759 icache_bsize = cacheline;
2760 }
2761 #endif
QEmu