1951c6300SRichard Henderson /* 2951c6300SRichard Henderson * Tiny Code Generator for QEMU 3951c6300SRichard Henderson * 4951c6300SRichard Henderson * Copyright (c) 2008 Fabrice Bellard 5951c6300SRichard Henderson * 6951c6300SRichard Henderson * Permission is hereby granted, free of charge, to any person obtaining a copy 7951c6300SRichard Henderson * of this software and associated documentation files (the "Software"), to deal 8951c6300SRichard Henderson * in the Software without restriction, including without limitation the rights 9951c6300SRichard Henderson * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10951c6300SRichard Henderson * copies of the Software, and to permit persons to whom the Software is 11951c6300SRichard Henderson * furnished to do so, subject to the following conditions: 12951c6300SRichard Henderson * 13951c6300SRichard Henderson * The above copyright notice and this permission notice shall be included in 14951c6300SRichard Henderson * all copies or substantial portions of the Software. 15951c6300SRichard Henderson * 16951c6300SRichard Henderson * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17951c6300SRichard Henderson * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18951c6300SRichard Henderson * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19951c6300SRichard Henderson * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20951c6300SRichard Henderson * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21951c6300SRichard Henderson * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22951c6300SRichard Henderson * THE SOFTWARE. 23951c6300SRichard Henderson */ 24951c6300SRichard Henderson 25757e725bSPeter Maydell #include "qemu/osdep.h" 2633c11879SPaolo Bonzini #include "qemu-common.h" 2733c11879SPaolo Bonzini #include "cpu.h" 2863c91552SPaolo Bonzini #include "exec/exec-all.h" 29951c6300SRichard Henderson #include "tcg.h" 30951c6300SRichard Henderson #include "tcg-op.h" 31b32dc337SPranith Kumar #include "tcg-mo.h" 32dcdaadb6SLluís Vilanova #include "trace-tcg.h" 33dcdaadb6SLluís Vilanova #include "trace/mem.h" 34951c6300SRichard Henderson 353a13c3f3SRichard Henderson /* Reduce the number of ifdefs below. This assumes that all uses of 363a13c3f3SRichard Henderson TCGV_HIGH and TCGV_LOW are properly protected by a conditional that 373a13c3f3SRichard Henderson the compiler can eliminate. */ 383a13c3f3SRichard Henderson #if TCG_TARGET_REG_BITS == 64 393a13c3f3SRichard Henderson extern TCGv_i32 TCGV_LOW_link_error(TCGv_i64); 403a13c3f3SRichard Henderson extern TCGv_i32 TCGV_HIGH_link_error(TCGv_i64); 413a13c3f3SRichard Henderson #define TCGV_LOW TCGV_LOW_link_error 423a13c3f3SRichard Henderson #define TCGV_HIGH TCGV_HIGH_link_error 433a13c3f3SRichard Henderson #endif 44951c6300SRichard Henderson 45b7e8b17aSRichard Henderson void tcg_gen_op1(TCGOpcode opc, TCGArg a1) 46951c6300SRichard Henderson { 47b7e8b17aSRichard Henderson TCGOp *op = tcg_emit_op(opc); 4875e8b9b7SRichard Henderson op->args[0] = a1; 49951c6300SRichard Henderson } 50951c6300SRichard Henderson 51b7e8b17aSRichard Henderson void tcg_gen_op2(TCGOpcode opc, TCGArg a1, TCGArg a2) 52951c6300SRichard Henderson { 53b7e8b17aSRichard Henderson TCGOp *op = tcg_emit_op(opc); 5475e8b9b7SRichard Henderson op->args[0] = a1; 5575e8b9b7SRichard Henderson op->args[1] = a2; 56951c6300SRichard Henderson } 57951c6300SRichard Henderson 58b7e8b17aSRichard Henderson void tcg_gen_op3(TCGOpcode opc, TCGArg a1, TCGArg a2, TCGArg a3) 59951c6300SRichard Henderson { 60b7e8b17aSRichard Henderson TCGOp *op = tcg_emit_op(opc); 6175e8b9b7SRichard Henderson op->args[0] = a1; 6275e8b9b7SRichard Henderson op->args[1] = a2; 6375e8b9b7SRichard Henderson op->args[2] = a3; 64951c6300SRichard Henderson } 65951c6300SRichard Henderson 66b7e8b17aSRichard Henderson void tcg_gen_op4(TCGOpcode opc, TCGArg a1, TCGArg a2, TCGArg a3, TCGArg a4) 67951c6300SRichard Henderson { 68b7e8b17aSRichard Henderson TCGOp *op = tcg_emit_op(opc); 6975e8b9b7SRichard Henderson op->args[0] = a1; 7075e8b9b7SRichard Henderson op->args[1] = a2; 7175e8b9b7SRichard Henderson op->args[2] = a3; 7275e8b9b7SRichard Henderson op->args[3] = a4; 73951c6300SRichard Henderson } 74951c6300SRichard Henderson 75b7e8b17aSRichard Henderson void tcg_gen_op5(TCGOpcode opc, TCGArg a1, TCGArg a2, TCGArg a3, 76b7e8b17aSRichard Henderson TCGArg a4, TCGArg a5) 77951c6300SRichard Henderson { 78b7e8b17aSRichard Henderson TCGOp *op = tcg_emit_op(opc); 7975e8b9b7SRichard Henderson op->args[0] = a1; 8075e8b9b7SRichard Henderson op->args[1] = a2; 8175e8b9b7SRichard Henderson op->args[2] = a3; 8275e8b9b7SRichard Henderson op->args[3] = a4; 8375e8b9b7SRichard Henderson op->args[4] = a5; 84951c6300SRichard Henderson } 85951c6300SRichard Henderson 86b7e8b17aSRichard Henderson void tcg_gen_op6(TCGOpcode opc, TCGArg a1, TCGArg a2, TCGArg a3, 87b7e8b17aSRichard Henderson TCGArg a4, TCGArg a5, TCGArg a6) 88951c6300SRichard Henderson { 89b7e8b17aSRichard Henderson TCGOp *op = tcg_emit_op(opc); 9075e8b9b7SRichard Henderson op->args[0] = a1; 9175e8b9b7SRichard Henderson op->args[1] = a2; 9275e8b9b7SRichard Henderson op->args[2] = a3; 9375e8b9b7SRichard Henderson op->args[3] = a4; 9475e8b9b7SRichard Henderson op->args[4] = a5; 9575e8b9b7SRichard Henderson op->args[5] = a6; 96951c6300SRichard Henderson } 97951c6300SRichard Henderson 98f65e19bcSPranith Kumar void tcg_gen_mb(TCGBar mb_type) 99f65e19bcSPranith Kumar { 100b1311c4aSEmilio G. Cota if (tcg_ctx->tb_cflags & CF_PARALLEL) { 101b7e8b17aSRichard Henderson tcg_gen_op1(INDEX_op_mb, mb_type); 102f65e19bcSPranith Kumar } 103f65e19bcSPranith Kumar } 104f65e19bcSPranith Kumar 105951c6300SRichard Henderson /* 32 bit ops */ 106951c6300SRichard Henderson 107951c6300SRichard Henderson void tcg_gen_addi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2) 108951c6300SRichard Henderson { 109951c6300SRichard Henderson /* some cases can be optimized here */ 110951c6300SRichard Henderson if (arg2 == 0) { 111951c6300SRichard Henderson tcg_gen_mov_i32(ret, arg1); 112951c6300SRichard Henderson } else { 113951c6300SRichard Henderson TCGv_i32 t0 = tcg_const_i32(arg2); 114951c6300SRichard Henderson tcg_gen_add_i32(ret, arg1, t0); 115951c6300SRichard Henderson tcg_temp_free_i32(t0); 116951c6300SRichard Henderson } 117951c6300SRichard Henderson } 118951c6300SRichard Henderson 119951c6300SRichard Henderson void tcg_gen_subfi_i32(TCGv_i32 ret, int32_t arg1, TCGv_i32 arg2) 120951c6300SRichard Henderson { 121951c6300SRichard Henderson if (arg1 == 0 && TCG_TARGET_HAS_neg_i32) { 122951c6300SRichard Henderson /* Don't recurse with tcg_gen_neg_i32. */ 123951c6300SRichard Henderson tcg_gen_op2_i32(INDEX_op_neg_i32, ret, arg2); 124951c6300SRichard Henderson } else { 125951c6300SRichard Henderson TCGv_i32 t0 = tcg_const_i32(arg1); 126951c6300SRichard Henderson tcg_gen_sub_i32(ret, t0, arg2); 127951c6300SRichard Henderson tcg_temp_free_i32(t0); 128951c6300SRichard Henderson } 129951c6300SRichard Henderson } 130951c6300SRichard Henderson 131951c6300SRichard Henderson void tcg_gen_subi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2) 132951c6300SRichard Henderson { 133951c6300SRichard Henderson /* some cases can be optimized here */ 134951c6300SRichard Henderson if (arg2 == 0) { 135951c6300SRichard Henderson tcg_gen_mov_i32(ret, arg1); 136951c6300SRichard Henderson } else { 137951c6300SRichard Henderson TCGv_i32 t0 = tcg_const_i32(arg2); 138951c6300SRichard Henderson tcg_gen_sub_i32(ret, arg1, t0); 139951c6300SRichard Henderson tcg_temp_free_i32(t0); 140951c6300SRichard Henderson } 141951c6300SRichard Henderson } 142951c6300SRichard Henderson 143474b2e8fSRichard Henderson void tcg_gen_andi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2) 144951c6300SRichard Henderson { 145951c6300SRichard Henderson TCGv_i32 t0; 146951c6300SRichard Henderson /* Some cases can be optimized here. */ 147951c6300SRichard Henderson switch (arg2) { 148951c6300SRichard Henderson case 0: 149951c6300SRichard Henderson tcg_gen_movi_i32(ret, 0); 150951c6300SRichard Henderson return; 151474b2e8fSRichard Henderson case -1: 152951c6300SRichard Henderson tcg_gen_mov_i32(ret, arg1); 153951c6300SRichard Henderson return; 154474b2e8fSRichard Henderson case 0xff: 155951c6300SRichard Henderson /* Don't recurse with tcg_gen_ext8u_i32. */ 156951c6300SRichard Henderson if (TCG_TARGET_HAS_ext8u_i32) { 157951c6300SRichard Henderson tcg_gen_op2_i32(INDEX_op_ext8u_i32, ret, arg1); 158951c6300SRichard Henderson return; 159951c6300SRichard Henderson } 160951c6300SRichard Henderson break; 161474b2e8fSRichard Henderson case 0xffff: 162951c6300SRichard Henderson if (TCG_TARGET_HAS_ext16u_i32) { 163951c6300SRichard Henderson tcg_gen_op2_i32(INDEX_op_ext16u_i32, ret, arg1); 164951c6300SRichard Henderson return; 165951c6300SRichard Henderson } 166951c6300SRichard Henderson break; 167951c6300SRichard Henderson } 168951c6300SRichard Henderson t0 = tcg_const_i32(arg2); 169951c6300SRichard Henderson tcg_gen_and_i32(ret, arg1, t0); 170951c6300SRichard Henderson tcg_temp_free_i32(t0); 171951c6300SRichard Henderson } 172951c6300SRichard Henderson 173951c6300SRichard Henderson void tcg_gen_ori_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2) 174951c6300SRichard Henderson { 175951c6300SRichard Henderson /* Some cases can be optimized here. */ 176951c6300SRichard Henderson if (arg2 == -1) { 177951c6300SRichard Henderson tcg_gen_movi_i32(ret, -1); 178951c6300SRichard Henderson } else if (arg2 == 0) { 179951c6300SRichard Henderson tcg_gen_mov_i32(ret, arg1); 180951c6300SRichard Henderson } else { 181951c6300SRichard Henderson TCGv_i32 t0 = tcg_const_i32(arg2); 182951c6300SRichard Henderson tcg_gen_or_i32(ret, arg1, t0); 183951c6300SRichard Henderson tcg_temp_free_i32(t0); 184951c6300SRichard Henderson } 185951c6300SRichard Henderson } 186951c6300SRichard Henderson 187951c6300SRichard Henderson void tcg_gen_xori_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2) 188951c6300SRichard Henderson { 189951c6300SRichard Henderson /* Some cases can be optimized here. */ 190951c6300SRichard Henderson if (arg2 == 0) { 191951c6300SRichard Henderson tcg_gen_mov_i32(ret, arg1); 192951c6300SRichard Henderson } else if (arg2 == -1 && TCG_TARGET_HAS_not_i32) { 193951c6300SRichard Henderson /* Don't recurse with tcg_gen_not_i32. */ 194951c6300SRichard Henderson tcg_gen_op2_i32(INDEX_op_not_i32, ret, arg1); 195951c6300SRichard Henderson } else { 196951c6300SRichard Henderson TCGv_i32 t0 = tcg_const_i32(arg2); 197951c6300SRichard Henderson tcg_gen_xor_i32(ret, arg1, t0); 198951c6300SRichard Henderson tcg_temp_free_i32(t0); 199951c6300SRichard Henderson } 200951c6300SRichard Henderson } 201951c6300SRichard Henderson 202474b2e8fSRichard Henderson void tcg_gen_shli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2) 203951c6300SRichard Henderson { 204474b2e8fSRichard Henderson tcg_debug_assert(arg2 >= 0 && arg2 < 32); 205951c6300SRichard Henderson if (arg2 == 0) { 206951c6300SRichard Henderson tcg_gen_mov_i32(ret, arg1); 207951c6300SRichard Henderson } else { 208951c6300SRichard Henderson TCGv_i32 t0 = tcg_const_i32(arg2); 209951c6300SRichard Henderson tcg_gen_shl_i32(ret, arg1, t0); 210951c6300SRichard Henderson tcg_temp_free_i32(t0); 211951c6300SRichard Henderson } 212951c6300SRichard Henderson } 213951c6300SRichard Henderson 214474b2e8fSRichard Henderson void tcg_gen_shri_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2) 215951c6300SRichard Henderson { 216474b2e8fSRichard Henderson tcg_debug_assert(arg2 >= 0 && arg2 < 32); 217951c6300SRichard Henderson if (arg2 == 0) { 218951c6300SRichard Henderson tcg_gen_mov_i32(ret, arg1); 219951c6300SRichard Henderson } else { 220951c6300SRichard Henderson TCGv_i32 t0 = tcg_const_i32(arg2); 221951c6300SRichard Henderson tcg_gen_shr_i32(ret, arg1, t0); 222951c6300SRichard Henderson tcg_temp_free_i32(t0); 223951c6300SRichard Henderson } 224951c6300SRichard Henderson } 225951c6300SRichard Henderson 226474b2e8fSRichard Henderson void tcg_gen_sari_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2) 227951c6300SRichard Henderson { 228474b2e8fSRichard Henderson tcg_debug_assert(arg2 >= 0 && arg2 < 32); 229951c6300SRichard Henderson if (arg2 == 0) { 230951c6300SRichard Henderson tcg_gen_mov_i32(ret, arg1); 231951c6300SRichard Henderson } else { 232951c6300SRichard Henderson TCGv_i32 t0 = tcg_const_i32(arg2); 233951c6300SRichard Henderson tcg_gen_sar_i32(ret, arg1, t0); 234951c6300SRichard Henderson tcg_temp_free_i32(t0); 235951c6300SRichard Henderson } 236951c6300SRichard Henderson } 237951c6300SRichard Henderson 23842a268c2SRichard Henderson void tcg_gen_brcond_i32(TCGCond cond, TCGv_i32 arg1, TCGv_i32 arg2, TCGLabel *l) 239951c6300SRichard Henderson { 240951c6300SRichard Henderson if (cond == TCG_COND_ALWAYS) { 24142a268c2SRichard Henderson tcg_gen_br(l); 242951c6300SRichard Henderson } else if (cond != TCG_COND_NEVER) { 243d88a117eSRichard Henderson l->refs++; 24442a268c2SRichard Henderson tcg_gen_op4ii_i32(INDEX_op_brcond_i32, arg1, arg2, cond, label_arg(l)); 245951c6300SRichard Henderson } 246951c6300SRichard Henderson } 247951c6300SRichard Henderson 24842a268c2SRichard Henderson void tcg_gen_brcondi_i32(TCGCond cond, TCGv_i32 arg1, int32_t arg2, TCGLabel *l) 249951c6300SRichard Henderson { 25037ed3bf1SRichard Henderson if (cond == TCG_COND_ALWAYS) { 25137ed3bf1SRichard Henderson tcg_gen_br(l); 25237ed3bf1SRichard Henderson } else if (cond != TCG_COND_NEVER) { 253951c6300SRichard Henderson TCGv_i32 t0 = tcg_const_i32(arg2); 25442a268c2SRichard Henderson tcg_gen_brcond_i32(cond, arg1, t0, l); 255951c6300SRichard Henderson tcg_temp_free_i32(t0); 256951c6300SRichard Henderson } 25737ed3bf1SRichard Henderson } 258951c6300SRichard Henderson 259951c6300SRichard Henderson void tcg_gen_setcond_i32(TCGCond cond, TCGv_i32 ret, 260951c6300SRichard Henderson TCGv_i32 arg1, TCGv_i32 arg2) 261951c6300SRichard Henderson { 262951c6300SRichard Henderson if (cond == TCG_COND_ALWAYS) { 263951c6300SRichard Henderson tcg_gen_movi_i32(ret, 1); 264951c6300SRichard Henderson } else if (cond == TCG_COND_NEVER) { 265951c6300SRichard Henderson tcg_gen_movi_i32(ret, 0); 266951c6300SRichard Henderson } else { 267951c6300SRichard Henderson tcg_gen_op4i_i32(INDEX_op_setcond_i32, ret, arg1, arg2, cond); 268951c6300SRichard Henderson } 269951c6300SRichard Henderson } 270951c6300SRichard Henderson 271951c6300SRichard Henderson void tcg_gen_setcondi_i32(TCGCond cond, TCGv_i32 ret, 272951c6300SRichard Henderson TCGv_i32 arg1, int32_t arg2) 273951c6300SRichard Henderson { 274951c6300SRichard Henderson TCGv_i32 t0 = tcg_const_i32(arg2); 275951c6300SRichard Henderson tcg_gen_setcond_i32(cond, ret, arg1, t0); 276951c6300SRichard Henderson tcg_temp_free_i32(t0); 277951c6300SRichard Henderson } 278951c6300SRichard Henderson 279951c6300SRichard Henderson void tcg_gen_muli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2) 280951c6300SRichard Henderson { 281b2e3ae94SRichard Henderson if (arg2 == 0) { 282b2e3ae94SRichard Henderson tcg_gen_movi_i32(ret, 0); 283b2e3ae94SRichard Henderson } else if (is_power_of_2(arg2)) { 284b2e3ae94SRichard Henderson tcg_gen_shli_i32(ret, arg1, ctz32(arg2)); 285b2e3ae94SRichard Henderson } else { 286951c6300SRichard Henderson TCGv_i32 t0 = tcg_const_i32(arg2); 287951c6300SRichard Henderson tcg_gen_mul_i32(ret, arg1, t0); 288951c6300SRichard Henderson tcg_temp_free_i32(t0); 289951c6300SRichard Henderson } 290b2e3ae94SRichard Henderson } 291951c6300SRichard Henderson 292951c6300SRichard Henderson void tcg_gen_div_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2) 293951c6300SRichard Henderson { 294951c6300SRichard Henderson if (TCG_TARGET_HAS_div_i32) { 295951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_div_i32, ret, arg1, arg2); 296951c6300SRichard Henderson } else if (TCG_TARGET_HAS_div2_i32) { 297951c6300SRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 298951c6300SRichard Henderson tcg_gen_sari_i32(t0, arg1, 31); 299951c6300SRichard Henderson tcg_gen_op5_i32(INDEX_op_div2_i32, ret, t0, arg1, t0, arg2); 300951c6300SRichard Henderson tcg_temp_free_i32(t0); 301951c6300SRichard Henderson } else { 302951c6300SRichard Henderson gen_helper_div_i32(ret, arg1, arg2); 303951c6300SRichard Henderson } 304951c6300SRichard Henderson } 305951c6300SRichard Henderson 306951c6300SRichard Henderson void tcg_gen_rem_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2) 307951c6300SRichard Henderson { 308951c6300SRichard Henderson if (TCG_TARGET_HAS_rem_i32) { 309951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_rem_i32, ret, arg1, arg2); 310951c6300SRichard Henderson } else if (TCG_TARGET_HAS_div_i32) { 311951c6300SRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 312951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_div_i32, t0, arg1, arg2); 313951c6300SRichard Henderson tcg_gen_mul_i32(t0, t0, arg2); 314951c6300SRichard Henderson tcg_gen_sub_i32(ret, arg1, t0); 315951c6300SRichard Henderson tcg_temp_free_i32(t0); 316951c6300SRichard Henderson } else if (TCG_TARGET_HAS_div2_i32) { 317951c6300SRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 318951c6300SRichard Henderson tcg_gen_sari_i32(t0, arg1, 31); 319951c6300SRichard Henderson tcg_gen_op5_i32(INDEX_op_div2_i32, t0, ret, arg1, t0, arg2); 320951c6300SRichard Henderson tcg_temp_free_i32(t0); 321951c6300SRichard Henderson } else { 322951c6300SRichard Henderson gen_helper_rem_i32(ret, arg1, arg2); 323951c6300SRichard Henderson } 324951c6300SRichard Henderson } 325951c6300SRichard Henderson 326951c6300SRichard Henderson void tcg_gen_divu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2) 327951c6300SRichard Henderson { 328951c6300SRichard Henderson if (TCG_TARGET_HAS_div_i32) { 329951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_divu_i32, ret, arg1, arg2); 330951c6300SRichard Henderson } else if (TCG_TARGET_HAS_div2_i32) { 331951c6300SRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 332951c6300SRichard Henderson tcg_gen_movi_i32(t0, 0); 333951c6300SRichard Henderson tcg_gen_op5_i32(INDEX_op_divu2_i32, ret, t0, arg1, t0, arg2); 334951c6300SRichard Henderson tcg_temp_free_i32(t0); 335951c6300SRichard Henderson } else { 336951c6300SRichard Henderson gen_helper_divu_i32(ret, arg1, arg2); 337951c6300SRichard Henderson } 338951c6300SRichard Henderson } 339951c6300SRichard Henderson 340951c6300SRichard Henderson void tcg_gen_remu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2) 341951c6300SRichard Henderson { 342951c6300SRichard Henderson if (TCG_TARGET_HAS_rem_i32) { 343951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_remu_i32, ret, arg1, arg2); 344951c6300SRichard Henderson } else if (TCG_TARGET_HAS_div_i32) { 345951c6300SRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 346951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_divu_i32, t0, arg1, arg2); 347951c6300SRichard Henderson tcg_gen_mul_i32(t0, t0, arg2); 348951c6300SRichard Henderson tcg_gen_sub_i32(ret, arg1, t0); 349951c6300SRichard Henderson tcg_temp_free_i32(t0); 350951c6300SRichard Henderson } else if (TCG_TARGET_HAS_div2_i32) { 351951c6300SRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 352951c6300SRichard Henderson tcg_gen_movi_i32(t0, 0); 353951c6300SRichard Henderson tcg_gen_op5_i32(INDEX_op_divu2_i32, t0, ret, arg1, t0, arg2); 354951c6300SRichard Henderson tcg_temp_free_i32(t0); 355951c6300SRichard Henderson } else { 356951c6300SRichard Henderson gen_helper_remu_i32(ret, arg1, arg2); 357951c6300SRichard Henderson } 358951c6300SRichard Henderson } 359951c6300SRichard Henderson 360951c6300SRichard Henderson void tcg_gen_andc_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2) 361951c6300SRichard Henderson { 362951c6300SRichard Henderson if (TCG_TARGET_HAS_andc_i32) { 363951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_andc_i32, ret, arg1, arg2); 364951c6300SRichard Henderson } else { 365951c6300SRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 366951c6300SRichard Henderson tcg_gen_not_i32(t0, arg2); 367951c6300SRichard Henderson tcg_gen_and_i32(ret, arg1, t0); 368951c6300SRichard Henderson tcg_temp_free_i32(t0); 369951c6300SRichard Henderson } 370951c6300SRichard Henderson } 371951c6300SRichard Henderson 372951c6300SRichard Henderson void tcg_gen_eqv_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2) 373951c6300SRichard Henderson { 374951c6300SRichard Henderson if (TCG_TARGET_HAS_eqv_i32) { 375951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_eqv_i32, ret, arg1, arg2); 376951c6300SRichard Henderson } else { 377951c6300SRichard Henderson tcg_gen_xor_i32(ret, arg1, arg2); 378951c6300SRichard Henderson tcg_gen_not_i32(ret, ret); 379951c6300SRichard Henderson } 380951c6300SRichard Henderson } 381951c6300SRichard Henderson 382951c6300SRichard Henderson void tcg_gen_nand_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2) 383951c6300SRichard Henderson { 384951c6300SRichard Henderson if (TCG_TARGET_HAS_nand_i32) { 385951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_nand_i32, ret, arg1, arg2); 386951c6300SRichard Henderson } else { 387951c6300SRichard Henderson tcg_gen_and_i32(ret, arg1, arg2); 388951c6300SRichard Henderson tcg_gen_not_i32(ret, ret); 389951c6300SRichard Henderson } 390951c6300SRichard Henderson } 391951c6300SRichard Henderson 392951c6300SRichard Henderson void tcg_gen_nor_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2) 393951c6300SRichard Henderson { 394951c6300SRichard Henderson if (TCG_TARGET_HAS_nor_i32) { 395951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_nor_i32, ret, arg1, arg2); 396951c6300SRichard Henderson } else { 397951c6300SRichard Henderson tcg_gen_or_i32(ret, arg1, arg2); 398951c6300SRichard Henderson tcg_gen_not_i32(ret, ret); 399951c6300SRichard Henderson } 400951c6300SRichard Henderson } 401951c6300SRichard Henderson 402951c6300SRichard Henderson void tcg_gen_orc_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2) 403951c6300SRichard Henderson { 404951c6300SRichard Henderson if (TCG_TARGET_HAS_orc_i32) { 405951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_orc_i32, ret, arg1, arg2); 406951c6300SRichard Henderson } else { 407951c6300SRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 408951c6300SRichard Henderson tcg_gen_not_i32(t0, arg2); 409951c6300SRichard Henderson tcg_gen_or_i32(ret, arg1, t0); 410951c6300SRichard Henderson tcg_temp_free_i32(t0); 411951c6300SRichard Henderson } 412951c6300SRichard Henderson } 413951c6300SRichard Henderson 4140e28d006SRichard Henderson void tcg_gen_clz_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2) 4150e28d006SRichard Henderson { 4160e28d006SRichard Henderson if (TCG_TARGET_HAS_clz_i32) { 4170e28d006SRichard Henderson tcg_gen_op3_i32(INDEX_op_clz_i32, ret, arg1, arg2); 4180e28d006SRichard Henderson } else if (TCG_TARGET_HAS_clz_i64) { 4190e28d006SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 4200e28d006SRichard Henderson TCGv_i64 t2 = tcg_temp_new_i64(); 4210e28d006SRichard Henderson tcg_gen_extu_i32_i64(t1, arg1); 4220e28d006SRichard Henderson tcg_gen_extu_i32_i64(t2, arg2); 4230e28d006SRichard Henderson tcg_gen_addi_i64(t2, t2, 32); 4240e28d006SRichard Henderson tcg_gen_clz_i64(t1, t1, t2); 4250e28d006SRichard Henderson tcg_gen_extrl_i64_i32(ret, t1); 4260e28d006SRichard Henderson tcg_temp_free_i64(t1); 4270e28d006SRichard Henderson tcg_temp_free_i64(t2); 4280e28d006SRichard Henderson tcg_gen_subi_i32(ret, ret, 32); 4290e28d006SRichard Henderson } else { 4300e28d006SRichard Henderson gen_helper_clz_i32(ret, arg1, arg2); 4310e28d006SRichard Henderson } 4320e28d006SRichard Henderson } 4330e28d006SRichard Henderson 4340e28d006SRichard Henderson void tcg_gen_clzi_i32(TCGv_i32 ret, TCGv_i32 arg1, uint32_t arg2) 4350e28d006SRichard Henderson { 4360e28d006SRichard Henderson TCGv_i32 t = tcg_const_i32(arg2); 4370e28d006SRichard Henderson tcg_gen_clz_i32(ret, arg1, t); 4380e28d006SRichard Henderson tcg_temp_free_i32(t); 4390e28d006SRichard Henderson } 4400e28d006SRichard Henderson 4410e28d006SRichard Henderson void tcg_gen_ctz_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2) 4420e28d006SRichard Henderson { 4430e28d006SRichard Henderson if (TCG_TARGET_HAS_ctz_i32) { 4440e28d006SRichard Henderson tcg_gen_op3_i32(INDEX_op_ctz_i32, ret, arg1, arg2); 4450e28d006SRichard Henderson } else if (TCG_TARGET_HAS_ctz_i64) { 4460e28d006SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 4470e28d006SRichard Henderson TCGv_i64 t2 = tcg_temp_new_i64(); 4480e28d006SRichard Henderson tcg_gen_extu_i32_i64(t1, arg1); 4490e28d006SRichard Henderson tcg_gen_extu_i32_i64(t2, arg2); 4500e28d006SRichard Henderson tcg_gen_ctz_i64(t1, t1, t2); 4510e28d006SRichard Henderson tcg_gen_extrl_i64_i32(ret, t1); 4520e28d006SRichard Henderson tcg_temp_free_i64(t1); 4530e28d006SRichard Henderson tcg_temp_free_i64(t2); 45414e99210SRichard Henderson } else if (TCG_TARGET_HAS_ctpop_i32 45514e99210SRichard Henderson || TCG_TARGET_HAS_ctpop_i64 45614e99210SRichard Henderson || TCG_TARGET_HAS_clz_i32 45714e99210SRichard Henderson || TCG_TARGET_HAS_clz_i64) { 45814e99210SRichard Henderson TCGv_i32 z, t = tcg_temp_new_i32(); 45914e99210SRichard Henderson 46014e99210SRichard Henderson if (TCG_TARGET_HAS_ctpop_i32 || TCG_TARGET_HAS_ctpop_i64) { 46114e99210SRichard Henderson tcg_gen_subi_i32(t, arg1, 1); 46214e99210SRichard Henderson tcg_gen_andc_i32(t, t, arg1); 46314e99210SRichard Henderson tcg_gen_ctpop_i32(t, t); 46414e99210SRichard Henderson } else { 46514e99210SRichard Henderson /* Since all non-x86 hosts have clz(0) == 32, don't fight it. */ 46614e99210SRichard Henderson tcg_gen_neg_i32(t, arg1); 46714e99210SRichard Henderson tcg_gen_and_i32(t, t, arg1); 46814e99210SRichard Henderson tcg_gen_clzi_i32(t, t, 32); 46914e99210SRichard Henderson tcg_gen_xori_i32(t, t, 31); 47014e99210SRichard Henderson } 47114e99210SRichard Henderson z = tcg_const_i32(0); 47214e99210SRichard Henderson tcg_gen_movcond_i32(TCG_COND_EQ, ret, arg1, z, arg2, t); 47314e99210SRichard Henderson tcg_temp_free_i32(t); 47414e99210SRichard Henderson tcg_temp_free_i32(z); 4750e28d006SRichard Henderson } else { 4760e28d006SRichard Henderson gen_helper_ctz_i32(ret, arg1, arg2); 4770e28d006SRichard Henderson } 4780e28d006SRichard Henderson } 4790e28d006SRichard Henderson 4800e28d006SRichard Henderson void tcg_gen_ctzi_i32(TCGv_i32 ret, TCGv_i32 arg1, uint32_t arg2) 4810e28d006SRichard Henderson { 48214e99210SRichard Henderson if (!TCG_TARGET_HAS_ctz_i32 && TCG_TARGET_HAS_ctpop_i32 && arg2 == 32) { 48314e99210SRichard Henderson /* This equivalence has the advantage of not requiring a fixup. */ 48414e99210SRichard Henderson TCGv_i32 t = tcg_temp_new_i32(); 48514e99210SRichard Henderson tcg_gen_subi_i32(t, arg1, 1); 48614e99210SRichard Henderson tcg_gen_andc_i32(t, t, arg1); 48714e99210SRichard Henderson tcg_gen_ctpop_i32(ret, t); 48814e99210SRichard Henderson tcg_temp_free_i32(t); 48914e99210SRichard Henderson } else { 4900e28d006SRichard Henderson TCGv_i32 t = tcg_const_i32(arg2); 4910e28d006SRichard Henderson tcg_gen_ctz_i32(ret, arg1, t); 4920e28d006SRichard Henderson tcg_temp_free_i32(t); 4930e28d006SRichard Henderson } 49414e99210SRichard Henderson } 4950e28d006SRichard Henderson 496086920c2SRichard Henderson void tcg_gen_clrsb_i32(TCGv_i32 ret, TCGv_i32 arg) 497086920c2SRichard Henderson { 498086920c2SRichard Henderson if (TCG_TARGET_HAS_clz_i32) { 499086920c2SRichard Henderson TCGv_i32 t = tcg_temp_new_i32(); 500086920c2SRichard Henderson tcg_gen_sari_i32(t, arg, 31); 501086920c2SRichard Henderson tcg_gen_xor_i32(t, t, arg); 502086920c2SRichard Henderson tcg_gen_clzi_i32(t, t, 32); 503086920c2SRichard Henderson tcg_gen_subi_i32(ret, t, 1); 504086920c2SRichard Henderson tcg_temp_free_i32(t); 505086920c2SRichard Henderson } else { 506086920c2SRichard Henderson gen_helper_clrsb_i32(ret, arg); 507086920c2SRichard Henderson } 508086920c2SRichard Henderson } 509086920c2SRichard Henderson 510a768e4e9SRichard Henderson void tcg_gen_ctpop_i32(TCGv_i32 ret, TCGv_i32 arg1) 511a768e4e9SRichard Henderson { 512a768e4e9SRichard Henderson if (TCG_TARGET_HAS_ctpop_i32) { 513a768e4e9SRichard Henderson tcg_gen_op2_i32(INDEX_op_ctpop_i32, ret, arg1); 514a768e4e9SRichard Henderson } else if (TCG_TARGET_HAS_ctpop_i64) { 515a768e4e9SRichard Henderson TCGv_i64 t = tcg_temp_new_i64(); 516a768e4e9SRichard Henderson tcg_gen_extu_i32_i64(t, arg1); 517a768e4e9SRichard Henderson tcg_gen_ctpop_i64(t, t); 518a768e4e9SRichard Henderson tcg_gen_extrl_i64_i32(ret, t); 519a768e4e9SRichard Henderson tcg_temp_free_i64(t); 520a768e4e9SRichard Henderson } else { 521a768e4e9SRichard Henderson gen_helper_ctpop_i32(ret, arg1); 522a768e4e9SRichard Henderson } 523a768e4e9SRichard Henderson } 524a768e4e9SRichard Henderson 525951c6300SRichard Henderson void tcg_gen_rotl_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2) 526951c6300SRichard Henderson { 527951c6300SRichard Henderson if (TCG_TARGET_HAS_rot_i32) { 528951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_rotl_i32, ret, arg1, arg2); 529951c6300SRichard Henderson } else { 530951c6300SRichard Henderson TCGv_i32 t0, t1; 531951c6300SRichard Henderson 532951c6300SRichard Henderson t0 = tcg_temp_new_i32(); 533951c6300SRichard Henderson t1 = tcg_temp_new_i32(); 534951c6300SRichard Henderson tcg_gen_shl_i32(t0, arg1, arg2); 535951c6300SRichard Henderson tcg_gen_subfi_i32(t1, 32, arg2); 536951c6300SRichard Henderson tcg_gen_shr_i32(t1, arg1, t1); 537951c6300SRichard Henderson tcg_gen_or_i32(ret, t0, t1); 538951c6300SRichard Henderson tcg_temp_free_i32(t0); 539951c6300SRichard Henderson tcg_temp_free_i32(t1); 540951c6300SRichard Henderson } 541951c6300SRichard Henderson } 542951c6300SRichard Henderson 543951c6300SRichard Henderson void tcg_gen_rotli_i32(TCGv_i32 ret, TCGv_i32 arg1, unsigned arg2) 544951c6300SRichard Henderson { 545951c6300SRichard Henderson tcg_debug_assert(arg2 < 32); 546951c6300SRichard Henderson /* some cases can be optimized here */ 547951c6300SRichard Henderson if (arg2 == 0) { 548951c6300SRichard Henderson tcg_gen_mov_i32(ret, arg1); 549951c6300SRichard Henderson } else if (TCG_TARGET_HAS_rot_i32) { 550951c6300SRichard Henderson TCGv_i32 t0 = tcg_const_i32(arg2); 551951c6300SRichard Henderson tcg_gen_rotl_i32(ret, arg1, t0); 552951c6300SRichard Henderson tcg_temp_free_i32(t0); 553951c6300SRichard Henderson } else { 554951c6300SRichard Henderson TCGv_i32 t0, t1; 555951c6300SRichard Henderson t0 = tcg_temp_new_i32(); 556951c6300SRichard Henderson t1 = tcg_temp_new_i32(); 557951c6300SRichard Henderson tcg_gen_shli_i32(t0, arg1, arg2); 558951c6300SRichard Henderson tcg_gen_shri_i32(t1, arg1, 32 - arg2); 559951c6300SRichard Henderson tcg_gen_or_i32(ret, t0, t1); 560951c6300SRichard Henderson tcg_temp_free_i32(t0); 561951c6300SRichard Henderson tcg_temp_free_i32(t1); 562951c6300SRichard Henderson } 563951c6300SRichard Henderson } 564951c6300SRichard Henderson 565951c6300SRichard Henderson void tcg_gen_rotr_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2) 566951c6300SRichard Henderson { 567951c6300SRichard Henderson if (TCG_TARGET_HAS_rot_i32) { 568951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_rotr_i32, ret, arg1, arg2); 569951c6300SRichard Henderson } else { 570951c6300SRichard Henderson TCGv_i32 t0, t1; 571951c6300SRichard Henderson 572951c6300SRichard Henderson t0 = tcg_temp_new_i32(); 573951c6300SRichard Henderson t1 = tcg_temp_new_i32(); 574951c6300SRichard Henderson tcg_gen_shr_i32(t0, arg1, arg2); 575951c6300SRichard Henderson tcg_gen_subfi_i32(t1, 32, arg2); 576951c6300SRichard Henderson tcg_gen_shl_i32(t1, arg1, t1); 577951c6300SRichard Henderson tcg_gen_or_i32(ret, t0, t1); 578951c6300SRichard Henderson tcg_temp_free_i32(t0); 579951c6300SRichard Henderson tcg_temp_free_i32(t1); 580951c6300SRichard Henderson } 581951c6300SRichard Henderson } 582951c6300SRichard Henderson 583951c6300SRichard Henderson void tcg_gen_rotri_i32(TCGv_i32 ret, TCGv_i32 arg1, unsigned arg2) 584951c6300SRichard Henderson { 585951c6300SRichard Henderson tcg_debug_assert(arg2 < 32); 586951c6300SRichard Henderson /* some cases can be optimized here */ 587951c6300SRichard Henderson if (arg2 == 0) { 588951c6300SRichard Henderson tcg_gen_mov_i32(ret, arg1); 589951c6300SRichard Henderson } else { 590951c6300SRichard Henderson tcg_gen_rotli_i32(ret, arg1, 32 - arg2); 591951c6300SRichard Henderson } 592951c6300SRichard Henderson } 593951c6300SRichard Henderson 594951c6300SRichard Henderson void tcg_gen_deposit_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2, 595951c6300SRichard Henderson unsigned int ofs, unsigned int len) 596951c6300SRichard Henderson { 597951c6300SRichard Henderson uint32_t mask; 598951c6300SRichard Henderson TCGv_i32 t1; 599951c6300SRichard Henderson 600951c6300SRichard Henderson tcg_debug_assert(ofs < 32); 6010d0d309dSRichard Henderson tcg_debug_assert(len > 0); 602951c6300SRichard Henderson tcg_debug_assert(len <= 32); 603951c6300SRichard Henderson tcg_debug_assert(ofs + len <= 32); 604951c6300SRichard Henderson 6050d0d309dSRichard Henderson if (len == 32) { 606951c6300SRichard Henderson tcg_gen_mov_i32(ret, arg2); 607951c6300SRichard Henderson return; 608951c6300SRichard Henderson } 609951c6300SRichard Henderson if (TCG_TARGET_HAS_deposit_i32 && TCG_TARGET_deposit_i32_valid(ofs, len)) { 610951c6300SRichard Henderson tcg_gen_op5ii_i32(INDEX_op_deposit_i32, ret, arg1, arg2, ofs, len); 611951c6300SRichard Henderson return; 612951c6300SRichard Henderson } 613951c6300SRichard Henderson 614951c6300SRichard Henderson mask = (1u << len) - 1; 615951c6300SRichard Henderson t1 = tcg_temp_new_i32(); 616951c6300SRichard Henderson 617951c6300SRichard Henderson if (ofs + len < 32) { 618951c6300SRichard Henderson tcg_gen_andi_i32(t1, arg2, mask); 619951c6300SRichard Henderson tcg_gen_shli_i32(t1, t1, ofs); 620951c6300SRichard Henderson } else { 621951c6300SRichard Henderson tcg_gen_shli_i32(t1, arg2, ofs); 622951c6300SRichard Henderson } 623951c6300SRichard Henderson tcg_gen_andi_i32(ret, arg1, ~(mask << ofs)); 624951c6300SRichard Henderson tcg_gen_or_i32(ret, ret, t1); 625951c6300SRichard Henderson 626951c6300SRichard Henderson tcg_temp_free_i32(t1); 627951c6300SRichard Henderson } 628951c6300SRichard Henderson 62907cc68d5SRichard Henderson void tcg_gen_deposit_z_i32(TCGv_i32 ret, TCGv_i32 arg, 63007cc68d5SRichard Henderson unsigned int ofs, unsigned int len) 63107cc68d5SRichard Henderson { 63207cc68d5SRichard Henderson tcg_debug_assert(ofs < 32); 63307cc68d5SRichard Henderson tcg_debug_assert(len > 0); 63407cc68d5SRichard Henderson tcg_debug_assert(len <= 32); 63507cc68d5SRichard Henderson tcg_debug_assert(ofs + len <= 32); 63607cc68d5SRichard Henderson 63707cc68d5SRichard Henderson if (ofs + len == 32) { 63807cc68d5SRichard Henderson tcg_gen_shli_i32(ret, arg, ofs); 63907cc68d5SRichard Henderson } else if (ofs == 0) { 64007cc68d5SRichard Henderson tcg_gen_andi_i32(ret, arg, (1u << len) - 1); 64107cc68d5SRichard Henderson } else if (TCG_TARGET_HAS_deposit_i32 64207cc68d5SRichard Henderson && TCG_TARGET_deposit_i32_valid(ofs, len)) { 64307cc68d5SRichard Henderson TCGv_i32 zero = tcg_const_i32(0); 64407cc68d5SRichard Henderson tcg_gen_op5ii_i32(INDEX_op_deposit_i32, ret, zero, arg, ofs, len); 64507cc68d5SRichard Henderson tcg_temp_free_i32(zero); 64607cc68d5SRichard Henderson } else { 64707cc68d5SRichard Henderson /* To help two-operand hosts we prefer to zero-extend first, 64807cc68d5SRichard Henderson which allows ARG to stay live. */ 64907cc68d5SRichard Henderson switch (len) { 65007cc68d5SRichard Henderson case 16: 65107cc68d5SRichard Henderson if (TCG_TARGET_HAS_ext16u_i32) { 65207cc68d5SRichard Henderson tcg_gen_ext16u_i32(ret, arg); 65307cc68d5SRichard Henderson tcg_gen_shli_i32(ret, ret, ofs); 65407cc68d5SRichard Henderson return; 65507cc68d5SRichard Henderson } 65607cc68d5SRichard Henderson break; 65707cc68d5SRichard Henderson case 8: 65807cc68d5SRichard Henderson if (TCG_TARGET_HAS_ext8u_i32) { 65907cc68d5SRichard Henderson tcg_gen_ext8u_i32(ret, arg); 66007cc68d5SRichard Henderson tcg_gen_shli_i32(ret, ret, ofs); 66107cc68d5SRichard Henderson return; 66207cc68d5SRichard Henderson } 66307cc68d5SRichard Henderson break; 66407cc68d5SRichard Henderson } 66507cc68d5SRichard Henderson /* Otherwise prefer zero-extension over AND for code size. */ 66607cc68d5SRichard Henderson switch (ofs + len) { 66707cc68d5SRichard Henderson case 16: 66807cc68d5SRichard Henderson if (TCG_TARGET_HAS_ext16u_i32) { 66907cc68d5SRichard Henderson tcg_gen_shli_i32(ret, arg, ofs); 67007cc68d5SRichard Henderson tcg_gen_ext16u_i32(ret, ret); 67107cc68d5SRichard Henderson return; 67207cc68d5SRichard Henderson } 67307cc68d5SRichard Henderson break; 67407cc68d5SRichard Henderson case 8: 67507cc68d5SRichard Henderson if (TCG_TARGET_HAS_ext8u_i32) { 67607cc68d5SRichard Henderson tcg_gen_shli_i32(ret, arg, ofs); 67707cc68d5SRichard Henderson tcg_gen_ext8u_i32(ret, ret); 67807cc68d5SRichard Henderson return; 67907cc68d5SRichard Henderson } 68007cc68d5SRichard Henderson break; 68107cc68d5SRichard Henderson } 68207cc68d5SRichard Henderson tcg_gen_andi_i32(ret, arg, (1u << len) - 1); 68307cc68d5SRichard Henderson tcg_gen_shli_i32(ret, ret, ofs); 68407cc68d5SRichard Henderson } 68507cc68d5SRichard Henderson } 68607cc68d5SRichard Henderson 6877ec8bab3SRichard Henderson void tcg_gen_extract_i32(TCGv_i32 ret, TCGv_i32 arg, 6887ec8bab3SRichard Henderson unsigned int ofs, unsigned int len) 6897ec8bab3SRichard Henderson { 6907ec8bab3SRichard Henderson tcg_debug_assert(ofs < 32); 6917ec8bab3SRichard Henderson tcg_debug_assert(len > 0); 6927ec8bab3SRichard Henderson tcg_debug_assert(len <= 32); 6937ec8bab3SRichard Henderson tcg_debug_assert(ofs + len <= 32); 6947ec8bab3SRichard Henderson 6957ec8bab3SRichard Henderson /* Canonicalize certain special cases, even if extract is supported. */ 6967ec8bab3SRichard Henderson if (ofs + len == 32) { 6977ec8bab3SRichard Henderson tcg_gen_shri_i32(ret, arg, 32 - len); 6987ec8bab3SRichard Henderson return; 6997ec8bab3SRichard Henderson } 7007ec8bab3SRichard Henderson if (ofs == 0) { 7017ec8bab3SRichard Henderson tcg_gen_andi_i32(ret, arg, (1u << len) - 1); 7027ec8bab3SRichard Henderson return; 7037ec8bab3SRichard Henderson } 7047ec8bab3SRichard Henderson 7057ec8bab3SRichard Henderson if (TCG_TARGET_HAS_extract_i32 7067ec8bab3SRichard Henderson && TCG_TARGET_extract_i32_valid(ofs, len)) { 7077ec8bab3SRichard Henderson tcg_gen_op4ii_i32(INDEX_op_extract_i32, ret, arg, ofs, len); 7087ec8bab3SRichard Henderson return; 7097ec8bab3SRichard Henderson } 7107ec8bab3SRichard Henderson 7117ec8bab3SRichard Henderson /* Assume that zero-extension, if available, is cheaper than a shift. */ 7127ec8bab3SRichard Henderson switch (ofs + len) { 7137ec8bab3SRichard Henderson case 16: 7147ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext16u_i32) { 7157ec8bab3SRichard Henderson tcg_gen_ext16u_i32(ret, arg); 7167ec8bab3SRichard Henderson tcg_gen_shri_i32(ret, ret, ofs); 7177ec8bab3SRichard Henderson return; 7187ec8bab3SRichard Henderson } 7197ec8bab3SRichard Henderson break; 7207ec8bab3SRichard Henderson case 8: 7217ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext8u_i32) { 7227ec8bab3SRichard Henderson tcg_gen_ext8u_i32(ret, arg); 7237ec8bab3SRichard Henderson tcg_gen_shri_i32(ret, ret, ofs); 7247ec8bab3SRichard Henderson return; 7257ec8bab3SRichard Henderson } 7267ec8bab3SRichard Henderson break; 7277ec8bab3SRichard Henderson } 7287ec8bab3SRichard Henderson 7297ec8bab3SRichard Henderson /* ??? Ideally we'd know what values are available for immediate AND. 7307ec8bab3SRichard Henderson Assume that 8 bits are available, plus the special case of 16, 7317ec8bab3SRichard Henderson so that we get ext8u, ext16u. */ 7327ec8bab3SRichard Henderson switch (len) { 7337ec8bab3SRichard Henderson case 1 ... 8: case 16: 7347ec8bab3SRichard Henderson tcg_gen_shri_i32(ret, arg, ofs); 7357ec8bab3SRichard Henderson tcg_gen_andi_i32(ret, ret, (1u << len) - 1); 7367ec8bab3SRichard Henderson break; 7377ec8bab3SRichard Henderson default: 7387ec8bab3SRichard Henderson tcg_gen_shli_i32(ret, arg, 32 - len - ofs); 7397ec8bab3SRichard Henderson tcg_gen_shri_i32(ret, ret, 32 - len); 7407ec8bab3SRichard Henderson break; 7417ec8bab3SRichard Henderson } 7427ec8bab3SRichard Henderson } 7437ec8bab3SRichard Henderson 7447ec8bab3SRichard Henderson void tcg_gen_sextract_i32(TCGv_i32 ret, TCGv_i32 arg, 7457ec8bab3SRichard Henderson unsigned int ofs, unsigned int len) 7467ec8bab3SRichard Henderson { 7477ec8bab3SRichard Henderson tcg_debug_assert(ofs < 32); 7487ec8bab3SRichard Henderson tcg_debug_assert(len > 0); 7497ec8bab3SRichard Henderson tcg_debug_assert(len <= 32); 7507ec8bab3SRichard Henderson tcg_debug_assert(ofs + len <= 32); 7517ec8bab3SRichard Henderson 7527ec8bab3SRichard Henderson /* Canonicalize certain special cases, even if extract is supported. */ 7537ec8bab3SRichard Henderson if (ofs + len == 32) { 7547ec8bab3SRichard Henderson tcg_gen_sari_i32(ret, arg, 32 - len); 7557ec8bab3SRichard Henderson return; 7567ec8bab3SRichard Henderson } 7577ec8bab3SRichard Henderson if (ofs == 0) { 7587ec8bab3SRichard Henderson switch (len) { 7597ec8bab3SRichard Henderson case 16: 7607ec8bab3SRichard Henderson tcg_gen_ext16s_i32(ret, arg); 7617ec8bab3SRichard Henderson return; 7627ec8bab3SRichard Henderson case 8: 7637ec8bab3SRichard Henderson tcg_gen_ext8s_i32(ret, arg); 7647ec8bab3SRichard Henderson return; 7657ec8bab3SRichard Henderson } 7667ec8bab3SRichard Henderson } 7677ec8bab3SRichard Henderson 7687ec8bab3SRichard Henderson if (TCG_TARGET_HAS_sextract_i32 7697ec8bab3SRichard Henderson && TCG_TARGET_extract_i32_valid(ofs, len)) { 7707ec8bab3SRichard Henderson tcg_gen_op4ii_i32(INDEX_op_sextract_i32, ret, arg, ofs, len); 7717ec8bab3SRichard Henderson return; 7727ec8bab3SRichard Henderson } 7737ec8bab3SRichard Henderson 7747ec8bab3SRichard Henderson /* Assume that sign-extension, if available, is cheaper than a shift. */ 7757ec8bab3SRichard Henderson switch (ofs + len) { 7767ec8bab3SRichard Henderson case 16: 7777ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext16s_i32) { 7787ec8bab3SRichard Henderson tcg_gen_ext16s_i32(ret, arg); 7797ec8bab3SRichard Henderson tcg_gen_sari_i32(ret, ret, ofs); 7807ec8bab3SRichard Henderson return; 7817ec8bab3SRichard Henderson } 7827ec8bab3SRichard Henderson break; 7837ec8bab3SRichard Henderson case 8: 7847ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext8s_i32) { 7857ec8bab3SRichard Henderson tcg_gen_ext8s_i32(ret, arg); 7867ec8bab3SRichard Henderson tcg_gen_sari_i32(ret, ret, ofs); 7877ec8bab3SRichard Henderson return; 7887ec8bab3SRichard Henderson } 7897ec8bab3SRichard Henderson break; 7907ec8bab3SRichard Henderson } 7917ec8bab3SRichard Henderson switch (len) { 7927ec8bab3SRichard Henderson case 16: 7937ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext16s_i32) { 7947ec8bab3SRichard Henderson tcg_gen_shri_i32(ret, arg, ofs); 7957ec8bab3SRichard Henderson tcg_gen_ext16s_i32(ret, ret); 7967ec8bab3SRichard Henderson return; 7977ec8bab3SRichard Henderson } 7987ec8bab3SRichard Henderson break; 7997ec8bab3SRichard Henderson case 8: 8007ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext8s_i32) { 8017ec8bab3SRichard Henderson tcg_gen_shri_i32(ret, arg, ofs); 8027ec8bab3SRichard Henderson tcg_gen_ext8s_i32(ret, ret); 8037ec8bab3SRichard Henderson return; 8047ec8bab3SRichard Henderson } 8057ec8bab3SRichard Henderson break; 8067ec8bab3SRichard Henderson } 8077ec8bab3SRichard Henderson 8087ec8bab3SRichard Henderson tcg_gen_shli_i32(ret, arg, 32 - len - ofs); 8097ec8bab3SRichard Henderson tcg_gen_sari_i32(ret, ret, 32 - len); 8107ec8bab3SRichard Henderson } 8117ec8bab3SRichard Henderson 8122089fcc9SDavid Hildenbrand /* 8132089fcc9SDavid Hildenbrand * Extract 32-bits from a 64-bit input, ah:al, starting from ofs. 8142089fcc9SDavid Hildenbrand * Unlike tcg_gen_extract_i32 above, len is fixed at 32. 8152089fcc9SDavid Hildenbrand */ 8162089fcc9SDavid Hildenbrand void tcg_gen_extract2_i32(TCGv_i32 ret, TCGv_i32 al, TCGv_i32 ah, 8172089fcc9SDavid Hildenbrand unsigned int ofs) 8182089fcc9SDavid Hildenbrand { 8192089fcc9SDavid Hildenbrand tcg_debug_assert(ofs <= 32); 8202089fcc9SDavid Hildenbrand if (ofs == 0) { 8212089fcc9SDavid Hildenbrand tcg_gen_mov_i32(ret, al); 8222089fcc9SDavid Hildenbrand } else if (ofs == 32) { 8232089fcc9SDavid Hildenbrand tcg_gen_mov_i32(ret, ah); 8242089fcc9SDavid Hildenbrand } else if (al == ah) { 8252089fcc9SDavid Hildenbrand tcg_gen_rotri_i32(ret, al, ofs); 826*fce1296fSRichard Henderson } else if (TCG_TARGET_HAS_extract2_i32) { 827*fce1296fSRichard Henderson tcg_gen_op4i_i32(INDEX_op_extract2_i32, ret, al, ah, ofs); 8282089fcc9SDavid Hildenbrand } else { 8292089fcc9SDavid Hildenbrand TCGv_i32 t0 = tcg_temp_new_i32(); 8302089fcc9SDavid Hildenbrand tcg_gen_shri_i32(t0, al, ofs); 8312089fcc9SDavid Hildenbrand tcg_gen_deposit_i32(ret, t0, ah, 32 - ofs, ofs); 8322089fcc9SDavid Hildenbrand tcg_temp_free_i32(t0); 8332089fcc9SDavid Hildenbrand } 8342089fcc9SDavid Hildenbrand } 8352089fcc9SDavid Hildenbrand 836951c6300SRichard Henderson void tcg_gen_movcond_i32(TCGCond cond, TCGv_i32 ret, TCGv_i32 c1, 837951c6300SRichard Henderson TCGv_i32 c2, TCGv_i32 v1, TCGv_i32 v2) 838951c6300SRichard Henderson { 83937ed3bf1SRichard Henderson if (cond == TCG_COND_ALWAYS) { 84037ed3bf1SRichard Henderson tcg_gen_mov_i32(ret, v1); 84137ed3bf1SRichard Henderson } else if (cond == TCG_COND_NEVER) { 84237ed3bf1SRichard Henderson tcg_gen_mov_i32(ret, v2); 84337ed3bf1SRichard Henderson } else if (TCG_TARGET_HAS_movcond_i32) { 844951c6300SRichard Henderson tcg_gen_op6i_i32(INDEX_op_movcond_i32, ret, c1, c2, v1, v2, cond); 845951c6300SRichard Henderson } else { 846951c6300SRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 847951c6300SRichard Henderson TCGv_i32 t1 = tcg_temp_new_i32(); 848951c6300SRichard Henderson tcg_gen_setcond_i32(cond, t0, c1, c2); 849951c6300SRichard Henderson tcg_gen_neg_i32(t0, t0); 850951c6300SRichard Henderson tcg_gen_and_i32(t1, v1, t0); 851951c6300SRichard Henderson tcg_gen_andc_i32(ret, v2, t0); 852951c6300SRichard Henderson tcg_gen_or_i32(ret, ret, t1); 853951c6300SRichard Henderson tcg_temp_free_i32(t0); 854951c6300SRichard Henderson tcg_temp_free_i32(t1); 855951c6300SRichard Henderson } 856951c6300SRichard Henderson } 857951c6300SRichard Henderson 858951c6300SRichard Henderson void tcg_gen_add2_i32(TCGv_i32 rl, TCGv_i32 rh, TCGv_i32 al, 859951c6300SRichard Henderson TCGv_i32 ah, TCGv_i32 bl, TCGv_i32 bh) 860951c6300SRichard Henderson { 861951c6300SRichard Henderson if (TCG_TARGET_HAS_add2_i32) { 862951c6300SRichard Henderson tcg_gen_op6_i32(INDEX_op_add2_i32, rl, rh, al, ah, bl, bh); 863951c6300SRichard Henderson } else { 864951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 865951c6300SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 866951c6300SRichard Henderson tcg_gen_concat_i32_i64(t0, al, ah); 867951c6300SRichard Henderson tcg_gen_concat_i32_i64(t1, bl, bh); 868951c6300SRichard Henderson tcg_gen_add_i64(t0, t0, t1); 869951c6300SRichard Henderson tcg_gen_extr_i64_i32(rl, rh, t0); 870951c6300SRichard Henderson tcg_temp_free_i64(t0); 871951c6300SRichard Henderson tcg_temp_free_i64(t1); 872951c6300SRichard Henderson } 873951c6300SRichard Henderson } 874951c6300SRichard Henderson 875951c6300SRichard Henderson void tcg_gen_sub2_i32(TCGv_i32 rl, TCGv_i32 rh, TCGv_i32 al, 876951c6300SRichard Henderson TCGv_i32 ah, TCGv_i32 bl, TCGv_i32 bh) 877951c6300SRichard Henderson { 878951c6300SRichard Henderson if (TCG_TARGET_HAS_sub2_i32) { 879951c6300SRichard Henderson tcg_gen_op6_i32(INDEX_op_sub2_i32, rl, rh, al, ah, bl, bh); 880951c6300SRichard Henderson } else { 881951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 882951c6300SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 883951c6300SRichard Henderson tcg_gen_concat_i32_i64(t0, al, ah); 884951c6300SRichard Henderson tcg_gen_concat_i32_i64(t1, bl, bh); 885951c6300SRichard Henderson tcg_gen_sub_i64(t0, t0, t1); 886951c6300SRichard Henderson tcg_gen_extr_i64_i32(rl, rh, t0); 887951c6300SRichard Henderson tcg_temp_free_i64(t0); 888951c6300SRichard Henderson tcg_temp_free_i64(t1); 889951c6300SRichard Henderson } 890951c6300SRichard Henderson } 891951c6300SRichard Henderson 892951c6300SRichard Henderson void tcg_gen_mulu2_i32(TCGv_i32 rl, TCGv_i32 rh, TCGv_i32 arg1, TCGv_i32 arg2) 893951c6300SRichard Henderson { 894951c6300SRichard Henderson if (TCG_TARGET_HAS_mulu2_i32) { 895951c6300SRichard Henderson tcg_gen_op4_i32(INDEX_op_mulu2_i32, rl, rh, arg1, arg2); 896951c6300SRichard Henderson } else if (TCG_TARGET_HAS_muluh_i32) { 897951c6300SRichard Henderson TCGv_i32 t = tcg_temp_new_i32(); 898951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_mul_i32, t, arg1, arg2); 899951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_muluh_i32, rh, arg1, arg2); 900951c6300SRichard Henderson tcg_gen_mov_i32(rl, t); 901951c6300SRichard Henderson tcg_temp_free_i32(t); 902951c6300SRichard Henderson } else { 903951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 904951c6300SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 905951c6300SRichard Henderson tcg_gen_extu_i32_i64(t0, arg1); 906951c6300SRichard Henderson tcg_gen_extu_i32_i64(t1, arg2); 907951c6300SRichard Henderson tcg_gen_mul_i64(t0, t0, t1); 908951c6300SRichard Henderson tcg_gen_extr_i64_i32(rl, rh, t0); 909951c6300SRichard Henderson tcg_temp_free_i64(t0); 910951c6300SRichard Henderson tcg_temp_free_i64(t1); 911951c6300SRichard Henderson } 912951c6300SRichard Henderson } 913951c6300SRichard Henderson 914951c6300SRichard Henderson void tcg_gen_muls2_i32(TCGv_i32 rl, TCGv_i32 rh, TCGv_i32 arg1, TCGv_i32 arg2) 915951c6300SRichard Henderson { 916951c6300SRichard Henderson if (TCG_TARGET_HAS_muls2_i32) { 917951c6300SRichard Henderson tcg_gen_op4_i32(INDEX_op_muls2_i32, rl, rh, arg1, arg2); 918951c6300SRichard Henderson } else if (TCG_TARGET_HAS_mulsh_i32) { 919951c6300SRichard Henderson TCGv_i32 t = tcg_temp_new_i32(); 920951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_mul_i32, t, arg1, arg2); 921951c6300SRichard Henderson tcg_gen_op3_i32(INDEX_op_mulsh_i32, rh, arg1, arg2); 922951c6300SRichard Henderson tcg_gen_mov_i32(rl, t); 923951c6300SRichard Henderson tcg_temp_free_i32(t); 924951c6300SRichard Henderson } else if (TCG_TARGET_REG_BITS == 32) { 925951c6300SRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 926951c6300SRichard Henderson TCGv_i32 t1 = tcg_temp_new_i32(); 927951c6300SRichard Henderson TCGv_i32 t2 = tcg_temp_new_i32(); 928951c6300SRichard Henderson TCGv_i32 t3 = tcg_temp_new_i32(); 929951c6300SRichard Henderson tcg_gen_mulu2_i32(t0, t1, arg1, arg2); 930951c6300SRichard Henderson /* Adjust for negative inputs. */ 931951c6300SRichard Henderson tcg_gen_sari_i32(t2, arg1, 31); 932951c6300SRichard Henderson tcg_gen_sari_i32(t3, arg2, 31); 933951c6300SRichard Henderson tcg_gen_and_i32(t2, t2, arg2); 934951c6300SRichard Henderson tcg_gen_and_i32(t3, t3, arg1); 935951c6300SRichard Henderson tcg_gen_sub_i32(rh, t1, t2); 936951c6300SRichard Henderson tcg_gen_sub_i32(rh, rh, t3); 937951c6300SRichard Henderson tcg_gen_mov_i32(rl, t0); 938951c6300SRichard Henderson tcg_temp_free_i32(t0); 939951c6300SRichard Henderson tcg_temp_free_i32(t1); 940951c6300SRichard Henderson tcg_temp_free_i32(t2); 941951c6300SRichard Henderson tcg_temp_free_i32(t3); 942951c6300SRichard Henderson } else { 943951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 944951c6300SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 945951c6300SRichard Henderson tcg_gen_ext_i32_i64(t0, arg1); 946951c6300SRichard Henderson tcg_gen_ext_i32_i64(t1, arg2); 947951c6300SRichard Henderson tcg_gen_mul_i64(t0, t0, t1); 948951c6300SRichard Henderson tcg_gen_extr_i64_i32(rl, rh, t0); 949951c6300SRichard Henderson tcg_temp_free_i64(t0); 950951c6300SRichard Henderson tcg_temp_free_i64(t1); 951951c6300SRichard Henderson } 952951c6300SRichard Henderson } 953951c6300SRichard Henderson 9545087abfbSRichard Henderson void tcg_gen_mulsu2_i32(TCGv_i32 rl, TCGv_i32 rh, TCGv_i32 arg1, TCGv_i32 arg2) 9555087abfbSRichard Henderson { 9565087abfbSRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 9575087abfbSRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 9585087abfbSRichard Henderson TCGv_i32 t1 = tcg_temp_new_i32(); 9595087abfbSRichard Henderson TCGv_i32 t2 = tcg_temp_new_i32(); 9605087abfbSRichard Henderson tcg_gen_mulu2_i32(t0, t1, arg1, arg2); 9615087abfbSRichard Henderson /* Adjust for negative input for the signed arg1. */ 9625087abfbSRichard Henderson tcg_gen_sari_i32(t2, arg1, 31); 9635087abfbSRichard Henderson tcg_gen_and_i32(t2, t2, arg2); 9645087abfbSRichard Henderson tcg_gen_sub_i32(rh, t1, t2); 9655087abfbSRichard Henderson tcg_gen_mov_i32(rl, t0); 9665087abfbSRichard Henderson tcg_temp_free_i32(t0); 9675087abfbSRichard Henderson tcg_temp_free_i32(t1); 9685087abfbSRichard Henderson tcg_temp_free_i32(t2); 9695087abfbSRichard Henderson } else { 9705087abfbSRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 9715087abfbSRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 9725087abfbSRichard Henderson tcg_gen_ext_i32_i64(t0, arg1); 9735087abfbSRichard Henderson tcg_gen_extu_i32_i64(t1, arg2); 9745087abfbSRichard Henderson tcg_gen_mul_i64(t0, t0, t1); 9755087abfbSRichard Henderson tcg_gen_extr_i64_i32(rl, rh, t0); 9765087abfbSRichard Henderson tcg_temp_free_i64(t0); 9775087abfbSRichard Henderson tcg_temp_free_i64(t1); 9785087abfbSRichard Henderson } 9795087abfbSRichard Henderson } 9805087abfbSRichard Henderson 981951c6300SRichard Henderson void tcg_gen_ext8s_i32(TCGv_i32 ret, TCGv_i32 arg) 982951c6300SRichard Henderson { 983951c6300SRichard Henderson if (TCG_TARGET_HAS_ext8s_i32) { 984951c6300SRichard Henderson tcg_gen_op2_i32(INDEX_op_ext8s_i32, ret, arg); 985951c6300SRichard Henderson } else { 986951c6300SRichard Henderson tcg_gen_shli_i32(ret, arg, 24); 987951c6300SRichard Henderson tcg_gen_sari_i32(ret, ret, 24); 988951c6300SRichard Henderson } 989951c6300SRichard Henderson } 990951c6300SRichard Henderson 991951c6300SRichard Henderson void tcg_gen_ext16s_i32(TCGv_i32 ret, TCGv_i32 arg) 992951c6300SRichard Henderson { 993951c6300SRichard Henderson if (TCG_TARGET_HAS_ext16s_i32) { 994951c6300SRichard Henderson tcg_gen_op2_i32(INDEX_op_ext16s_i32, ret, arg); 995951c6300SRichard Henderson } else { 996951c6300SRichard Henderson tcg_gen_shli_i32(ret, arg, 16); 997951c6300SRichard Henderson tcg_gen_sari_i32(ret, ret, 16); 998951c6300SRichard Henderson } 999951c6300SRichard Henderson } 1000951c6300SRichard Henderson 1001951c6300SRichard Henderson void tcg_gen_ext8u_i32(TCGv_i32 ret, TCGv_i32 arg) 1002951c6300SRichard Henderson { 1003951c6300SRichard Henderson if (TCG_TARGET_HAS_ext8u_i32) { 1004951c6300SRichard Henderson tcg_gen_op2_i32(INDEX_op_ext8u_i32, ret, arg); 1005951c6300SRichard Henderson } else { 1006951c6300SRichard Henderson tcg_gen_andi_i32(ret, arg, 0xffu); 1007951c6300SRichard Henderson } 1008951c6300SRichard Henderson } 1009951c6300SRichard Henderson 1010951c6300SRichard Henderson void tcg_gen_ext16u_i32(TCGv_i32 ret, TCGv_i32 arg) 1011951c6300SRichard Henderson { 1012951c6300SRichard Henderson if (TCG_TARGET_HAS_ext16u_i32) { 1013951c6300SRichard Henderson tcg_gen_op2_i32(INDEX_op_ext16u_i32, ret, arg); 1014951c6300SRichard Henderson } else { 1015951c6300SRichard Henderson tcg_gen_andi_i32(ret, arg, 0xffffu); 1016951c6300SRichard Henderson } 1017951c6300SRichard Henderson } 1018951c6300SRichard Henderson 1019951c6300SRichard Henderson /* Note: we assume the two high bytes are set to zero */ 1020951c6300SRichard Henderson void tcg_gen_bswap16_i32(TCGv_i32 ret, TCGv_i32 arg) 1021951c6300SRichard Henderson { 1022951c6300SRichard Henderson if (TCG_TARGET_HAS_bswap16_i32) { 1023951c6300SRichard Henderson tcg_gen_op2_i32(INDEX_op_bswap16_i32, ret, arg); 1024951c6300SRichard Henderson } else { 1025951c6300SRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 1026951c6300SRichard Henderson 1027951c6300SRichard Henderson tcg_gen_ext8u_i32(t0, arg); 1028951c6300SRichard Henderson tcg_gen_shli_i32(t0, t0, 8); 1029951c6300SRichard Henderson tcg_gen_shri_i32(ret, arg, 8); 1030951c6300SRichard Henderson tcg_gen_or_i32(ret, ret, t0); 1031951c6300SRichard Henderson tcg_temp_free_i32(t0); 1032951c6300SRichard Henderson } 1033951c6300SRichard Henderson } 1034951c6300SRichard Henderson 1035951c6300SRichard Henderson void tcg_gen_bswap32_i32(TCGv_i32 ret, TCGv_i32 arg) 1036951c6300SRichard Henderson { 1037951c6300SRichard Henderson if (TCG_TARGET_HAS_bswap32_i32) { 1038951c6300SRichard Henderson tcg_gen_op2_i32(INDEX_op_bswap32_i32, ret, arg); 1039951c6300SRichard Henderson } else { 1040a686dc71SRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 1041a686dc71SRichard Henderson TCGv_i32 t1 = tcg_temp_new_i32(); 1042a686dc71SRichard Henderson TCGv_i32 t2 = tcg_const_i32(0x00ff00ff); 1043951c6300SRichard Henderson 1044a686dc71SRichard Henderson /* arg = abcd */ 1045a686dc71SRichard Henderson tcg_gen_shri_i32(t0, arg, 8); /* t0 = .abc */ 1046a686dc71SRichard Henderson tcg_gen_and_i32(t1, arg, t2); /* t1 = .b.d */ 1047a686dc71SRichard Henderson tcg_gen_and_i32(t0, t0, t2); /* t0 = .a.c */ 1048a686dc71SRichard Henderson tcg_gen_shli_i32(t1, t1, 8); /* t1 = b.d. */ 1049a686dc71SRichard Henderson tcg_gen_or_i32(ret, t0, t1); /* ret = badc */ 1050951c6300SRichard Henderson 1051a686dc71SRichard Henderson tcg_gen_shri_i32(t0, ret, 16); /* t0 = ..ba */ 1052a686dc71SRichard Henderson tcg_gen_shli_i32(t1, ret, 16); /* t1 = dc.. */ 1053a686dc71SRichard Henderson tcg_gen_or_i32(ret, t0, t1); /* ret = dcba */ 1054951c6300SRichard Henderson 1055951c6300SRichard Henderson tcg_temp_free_i32(t0); 1056951c6300SRichard Henderson tcg_temp_free_i32(t1); 1057a686dc71SRichard Henderson tcg_temp_free_i32(t2); 1058951c6300SRichard Henderson } 1059951c6300SRichard Henderson } 1060951c6300SRichard Henderson 1061b87fb8cdSRichard Henderson void tcg_gen_smin_i32(TCGv_i32 ret, TCGv_i32 a, TCGv_i32 b) 1062b87fb8cdSRichard Henderson { 1063b87fb8cdSRichard Henderson tcg_gen_movcond_i32(TCG_COND_LT, ret, a, b, a, b); 1064b87fb8cdSRichard Henderson } 1065b87fb8cdSRichard Henderson 1066b87fb8cdSRichard Henderson void tcg_gen_umin_i32(TCGv_i32 ret, TCGv_i32 a, TCGv_i32 b) 1067b87fb8cdSRichard Henderson { 1068b87fb8cdSRichard Henderson tcg_gen_movcond_i32(TCG_COND_LTU, ret, a, b, a, b); 1069b87fb8cdSRichard Henderson } 1070b87fb8cdSRichard Henderson 1071b87fb8cdSRichard Henderson void tcg_gen_smax_i32(TCGv_i32 ret, TCGv_i32 a, TCGv_i32 b) 1072b87fb8cdSRichard Henderson { 1073b87fb8cdSRichard Henderson tcg_gen_movcond_i32(TCG_COND_LT, ret, a, b, b, a); 1074b87fb8cdSRichard Henderson } 1075b87fb8cdSRichard Henderson 1076b87fb8cdSRichard Henderson void tcg_gen_umax_i32(TCGv_i32 ret, TCGv_i32 a, TCGv_i32 b) 1077b87fb8cdSRichard Henderson { 1078b87fb8cdSRichard Henderson tcg_gen_movcond_i32(TCG_COND_LTU, ret, a, b, b, a); 1079b87fb8cdSRichard Henderson } 1080b87fb8cdSRichard Henderson 1081951c6300SRichard Henderson /* 64-bit ops */ 1082951c6300SRichard Henderson 1083951c6300SRichard Henderson #if TCG_TARGET_REG_BITS == 32 1084951c6300SRichard Henderson /* These are all inline for TCG_TARGET_REG_BITS == 64. */ 1085951c6300SRichard Henderson 1086951c6300SRichard Henderson void tcg_gen_discard_i64(TCGv_i64 arg) 1087951c6300SRichard Henderson { 1088951c6300SRichard Henderson tcg_gen_discard_i32(TCGV_LOW(arg)); 1089951c6300SRichard Henderson tcg_gen_discard_i32(TCGV_HIGH(arg)); 1090951c6300SRichard Henderson } 1091951c6300SRichard Henderson 1092951c6300SRichard Henderson void tcg_gen_mov_i64(TCGv_i64 ret, TCGv_i64 arg) 1093951c6300SRichard Henderson { 1094951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg)); 1095951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg)); 1096951c6300SRichard Henderson } 1097951c6300SRichard Henderson 1098951c6300SRichard Henderson void tcg_gen_movi_i64(TCGv_i64 ret, int64_t arg) 1099951c6300SRichard Henderson { 1100951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_LOW(ret), arg); 1101951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), arg >> 32); 1102951c6300SRichard Henderson } 1103951c6300SRichard Henderson 1104951c6300SRichard Henderson void tcg_gen_ld8u_i64(TCGv_i64 ret, TCGv_ptr arg2, tcg_target_long offset) 1105951c6300SRichard Henderson { 1106951c6300SRichard Henderson tcg_gen_ld8u_i32(TCGV_LOW(ret), arg2, offset); 1107951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 1108951c6300SRichard Henderson } 1109951c6300SRichard Henderson 1110951c6300SRichard Henderson void tcg_gen_ld8s_i64(TCGv_i64 ret, TCGv_ptr arg2, tcg_target_long offset) 1111951c6300SRichard Henderson { 1112951c6300SRichard Henderson tcg_gen_ld8s_i32(TCGV_LOW(ret), arg2, offset); 11133ff91d7eSJoseph Myers tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31); 1114951c6300SRichard Henderson } 1115951c6300SRichard Henderson 1116951c6300SRichard Henderson void tcg_gen_ld16u_i64(TCGv_i64 ret, TCGv_ptr arg2, tcg_target_long offset) 1117951c6300SRichard Henderson { 1118951c6300SRichard Henderson tcg_gen_ld16u_i32(TCGV_LOW(ret), arg2, offset); 1119951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 1120951c6300SRichard Henderson } 1121951c6300SRichard Henderson 1122951c6300SRichard Henderson void tcg_gen_ld16s_i64(TCGv_i64 ret, TCGv_ptr arg2, tcg_target_long offset) 1123951c6300SRichard Henderson { 1124951c6300SRichard Henderson tcg_gen_ld16s_i32(TCGV_LOW(ret), arg2, offset); 1125951c6300SRichard Henderson tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31); 1126951c6300SRichard Henderson } 1127951c6300SRichard Henderson 1128951c6300SRichard Henderson void tcg_gen_ld32u_i64(TCGv_i64 ret, TCGv_ptr arg2, tcg_target_long offset) 1129951c6300SRichard Henderson { 1130951c6300SRichard Henderson tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset); 1131951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 1132951c6300SRichard Henderson } 1133951c6300SRichard Henderson 1134951c6300SRichard Henderson void tcg_gen_ld32s_i64(TCGv_i64 ret, TCGv_ptr arg2, tcg_target_long offset) 1135951c6300SRichard Henderson { 1136951c6300SRichard Henderson tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset); 1137951c6300SRichard Henderson tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31); 1138951c6300SRichard Henderson } 1139951c6300SRichard Henderson 1140951c6300SRichard Henderson void tcg_gen_ld_i64(TCGv_i64 ret, TCGv_ptr arg2, tcg_target_long offset) 1141951c6300SRichard Henderson { 1142951c6300SRichard Henderson /* Since arg2 and ret have different types, 1143951c6300SRichard Henderson they cannot be the same temporary */ 1144cf811fffSPeter Maydell #ifdef HOST_WORDS_BIGENDIAN 1145951c6300SRichard Henderson tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset); 1146951c6300SRichard Henderson tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset + 4); 1147951c6300SRichard Henderson #else 1148951c6300SRichard Henderson tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset); 1149951c6300SRichard Henderson tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset + 4); 1150951c6300SRichard Henderson #endif 1151951c6300SRichard Henderson } 1152951c6300SRichard Henderson 1153951c6300SRichard Henderson void tcg_gen_st_i64(TCGv_i64 arg1, TCGv_ptr arg2, tcg_target_long offset) 1154951c6300SRichard Henderson { 1155cf811fffSPeter Maydell #ifdef HOST_WORDS_BIGENDIAN 1156951c6300SRichard Henderson tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset); 1157951c6300SRichard Henderson tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset + 4); 1158951c6300SRichard Henderson #else 1159951c6300SRichard Henderson tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset); 1160951c6300SRichard Henderson tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset + 4); 1161951c6300SRichard Henderson #endif 1162951c6300SRichard Henderson } 1163951c6300SRichard Henderson 1164951c6300SRichard Henderson void tcg_gen_and_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1165951c6300SRichard Henderson { 1166951c6300SRichard Henderson tcg_gen_and_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2)); 1167951c6300SRichard Henderson tcg_gen_and_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2)); 1168951c6300SRichard Henderson } 1169951c6300SRichard Henderson 1170951c6300SRichard Henderson void tcg_gen_or_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1171951c6300SRichard Henderson { 1172951c6300SRichard Henderson tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2)); 1173951c6300SRichard Henderson tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2)); 1174951c6300SRichard Henderson } 1175951c6300SRichard Henderson 1176951c6300SRichard Henderson void tcg_gen_xor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1177951c6300SRichard Henderson { 1178951c6300SRichard Henderson tcg_gen_xor_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2)); 1179951c6300SRichard Henderson tcg_gen_xor_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2)); 1180951c6300SRichard Henderson } 1181951c6300SRichard Henderson 1182951c6300SRichard Henderson void tcg_gen_shl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1183951c6300SRichard Henderson { 1184951c6300SRichard Henderson gen_helper_shl_i64(ret, arg1, arg2); 1185951c6300SRichard Henderson } 1186951c6300SRichard Henderson 1187951c6300SRichard Henderson void tcg_gen_shr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1188951c6300SRichard Henderson { 1189951c6300SRichard Henderson gen_helper_shr_i64(ret, arg1, arg2); 1190951c6300SRichard Henderson } 1191951c6300SRichard Henderson 1192951c6300SRichard Henderson void tcg_gen_sar_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1193951c6300SRichard Henderson { 1194951c6300SRichard Henderson gen_helper_sar_i64(ret, arg1, arg2); 1195951c6300SRichard Henderson } 1196951c6300SRichard Henderson 1197951c6300SRichard Henderson void tcg_gen_mul_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1198951c6300SRichard Henderson { 1199951c6300SRichard Henderson TCGv_i64 t0; 1200951c6300SRichard Henderson TCGv_i32 t1; 1201951c6300SRichard Henderson 1202951c6300SRichard Henderson t0 = tcg_temp_new_i64(); 1203951c6300SRichard Henderson t1 = tcg_temp_new_i32(); 1204951c6300SRichard Henderson 1205951c6300SRichard Henderson tcg_gen_mulu2_i32(TCGV_LOW(t0), TCGV_HIGH(t0), 1206951c6300SRichard Henderson TCGV_LOW(arg1), TCGV_LOW(arg2)); 1207951c6300SRichard Henderson 1208951c6300SRichard Henderson tcg_gen_mul_i32(t1, TCGV_LOW(arg1), TCGV_HIGH(arg2)); 1209951c6300SRichard Henderson tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1); 1210951c6300SRichard Henderson tcg_gen_mul_i32(t1, TCGV_HIGH(arg1), TCGV_LOW(arg2)); 1211951c6300SRichard Henderson tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1); 1212951c6300SRichard Henderson 1213951c6300SRichard Henderson tcg_gen_mov_i64(ret, t0); 1214951c6300SRichard Henderson tcg_temp_free_i64(t0); 1215951c6300SRichard Henderson tcg_temp_free_i32(t1); 1216951c6300SRichard Henderson } 1217951c6300SRichard Henderson #endif /* TCG_TARGET_REG_SIZE == 32 */ 1218951c6300SRichard Henderson 1219951c6300SRichard Henderson void tcg_gen_addi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2) 1220951c6300SRichard Henderson { 1221951c6300SRichard Henderson /* some cases can be optimized here */ 1222951c6300SRichard Henderson if (arg2 == 0) { 1223951c6300SRichard Henderson tcg_gen_mov_i64(ret, arg1); 1224951c6300SRichard Henderson } else { 1225951c6300SRichard Henderson TCGv_i64 t0 = tcg_const_i64(arg2); 1226951c6300SRichard Henderson tcg_gen_add_i64(ret, arg1, t0); 1227951c6300SRichard Henderson tcg_temp_free_i64(t0); 1228951c6300SRichard Henderson } 1229951c6300SRichard Henderson } 1230951c6300SRichard Henderson 1231951c6300SRichard Henderson void tcg_gen_subfi_i64(TCGv_i64 ret, int64_t arg1, TCGv_i64 arg2) 1232951c6300SRichard Henderson { 1233951c6300SRichard Henderson if (arg1 == 0 && TCG_TARGET_HAS_neg_i64) { 1234951c6300SRichard Henderson /* Don't recurse with tcg_gen_neg_i64. */ 1235951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_neg_i64, ret, arg2); 1236951c6300SRichard Henderson } else { 1237951c6300SRichard Henderson TCGv_i64 t0 = tcg_const_i64(arg1); 1238951c6300SRichard Henderson tcg_gen_sub_i64(ret, t0, arg2); 1239951c6300SRichard Henderson tcg_temp_free_i64(t0); 1240951c6300SRichard Henderson } 1241951c6300SRichard Henderson } 1242951c6300SRichard Henderson 1243951c6300SRichard Henderson void tcg_gen_subi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2) 1244951c6300SRichard Henderson { 1245951c6300SRichard Henderson /* some cases can be optimized here */ 1246951c6300SRichard Henderson if (arg2 == 0) { 1247951c6300SRichard Henderson tcg_gen_mov_i64(ret, arg1); 1248951c6300SRichard Henderson } else { 1249951c6300SRichard Henderson TCGv_i64 t0 = tcg_const_i64(arg2); 1250951c6300SRichard Henderson tcg_gen_sub_i64(ret, arg1, t0); 1251951c6300SRichard Henderson tcg_temp_free_i64(t0); 1252951c6300SRichard Henderson } 1253951c6300SRichard Henderson } 1254951c6300SRichard Henderson 1255474b2e8fSRichard Henderson void tcg_gen_andi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2) 1256951c6300SRichard Henderson { 12573a13c3f3SRichard Henderson TCGv_i64 t0; 12583a13c3f3SRichard Henderson 12593a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1260951c6300SRichard Henderson tcg_gen_andi_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2); 1261951c6300SRichard Henderson tcg_gen_andi_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32); 12623a13c3f3SRichard Henderson return; 12633a13c3f3SRichard Henderson } 12643a13c3f3SRichard Henderson 1265951c6300SRichard Henderson /* Some cases can be optimized here. */ 1266951c6300SRichard Henderson switch (arg2) { 1267951c6300SRichard Henderson case 0: 1268951c6300SRichard Henderson tcg_gen_movi_i64(ret, 0); 1269951c6300SRichard Henderson return; 1270474b2e8fSRichard Henderson case -1: 1271951c6300SRichard Henderson tcg_gen_mov_i64(ret, arg1); 1272951c6300SRichard Henderson return; 1273474b2e8fSRichard Henderson case 0xff: 1274951c6300SRichard Henderson /* Don't recurse with tcg_gen_ext8u_i64. */ 1275951c6300SRichard Henderson if (TCG_TARGET_HAS_ext8u_i64) { 1276951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_ext8u_i64, ret, arg1); 1277951c6300SRichard Henderson return; 1278951c6300SRichard Henderson } 1279951c6300SRichard Henderson break; 1280474b2e8fSRichard Henderson case 0xffff: 1281951c6300SRichard Henderson if (TCG_TARGET_HAS_ext16u_i64) { 1282951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_ext16u_i64, ret, arg1); 1283951c6300SRichard Henderson return; 1284951c6300SRichard Henderson } 1285951c6300SRichard Henderson break; 1286474b2e8fSRichard Henderson case 0xffffffffu: 1287951c6300SRichard Henderson if (TCG_TARGET_HAS_ext32u_i64) { 1288951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_ext32u_i64, ret, arg1); 1289951c6300SRichard Henderson return; 1290951c6300SRichard Henderson } 1291951c6300SRichard Henderson break; 1292951c6300SRichard Henderson } 1293951c6300SRichard Henderson t0 = tcg_const_i64(arg2); 1294951c6300SRichard Henderson tcg_gen_and_i64(ret, arg1, t0); 1295951c6300SRichard Henderson tcg_temp_free_i64(t0); 1296951c6300SRichard Henderson } 1297951c6300SRichard Henderson 1298951c6300SRichard Henderson void tcg_gen_ori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2) 1299951c6300SRichard Henderson { 13003a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1301951c6300SRichard Henderson tcg_gen_ori_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2); 1302951c6300SRichard Henderson tcg_gen_ori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32); 13033a13c3f3SRichard Henderson return; 13043a13c3f3SRichard Henderson } 1305951c6300SRichard Henderson /* Some cases can be optimized here. */ 1306951c6300SRichard Henderson if (arg2 == -1) { 1307951c6300SRichard Henderson tcg_gen_movi_i64(ret, -1); 1308951c6300SRichard Henderson } else if (arg2 == 0) { 1309951c6300SRichard Henderson tcg_gen_mov_i64(ret, arg1); 1310951c6300SRichard Henderson } else { 1311951c6300SRichard Henderson TCGv_i64 t0 = tcg_const_i64(arg2); 1312951c6300SRichard Henderson tcg_gen_or_i64(ret, arg1, t0); 1313951c6300SRichard Henderson tcg_temp_free_i64(t0); 1314951c6300SRichard Henderson } 1315951c6300SRichard Henderson } 1316951c6300SRichard Henderson 1317951c6300SRichard Henderson void tcg_gen_xori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2) 1318951c6300SRichard Henderson { 13193a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1320951c6300SRichard Henderson tcg_gen_xori_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2); 1321951c6300SRichard Henderson tcg_gen_xori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32); 13223a13c3f3SRichard Henderson return; 13233a13c3f3SRichard Henderson } 1324951c6300SRichard Henderson /* Some cases can be optimized here. */ 1325951c6300SRichard Henderson if (arg2 == 0) { 1326951c6300SRichard Henderson tcg_gen_mov_i64(ret, arg1); 1327951c6300SRichard Henderson } else if (arg2 == -1 && TCG_TARGET_HAS_not_i64) { 1328951c6300SRichard Henderson /* Don't recurse with tcg_gen_not_i64. */ 1329951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_not_i64, ret, arg1); 1330951c6300SRichard Henderson } else { 1331951c6300SRichard Henderson TCGv_i64 t0 = tcg_const_i64(arg2); 1332951c6300SRichard Henderson tcg_gen_xor_i64(ret, arg1, t0); 1333951c6300SRichard Henderson tcg_temp_free_i64(t0); 1334951c6300SRichard Henderson } 1335951c6300SRichard Henderson } 1336951c6300SRichard Henderson 1337951c6300SRichard Henderson static inline void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, 1338951c6300SRichard Henderson unsigned c, bool right, bool arith) 1339951c6300SRichard Henderson { 1340951c6300SRichard Henderson tcg_debug_assert(c < 64); 1341951c6300SRichard Henderson if (c == 0) { 1342951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1)); 1343951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1)); 1344951c6300SRichard Henderson } else if (c >= 32) { 1345951c6300SRichard Henderson c -= 32; 1346951c6300SRichard Henderson if (right) { 1347951c6300SRichard Henderson if (arith) { 1348951c6300SRichard Henderson tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 1349951c6300SRichard Henderson tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31); 1350951c6300SRichard Henderson } else { 1351951c6300SRichard Henderson tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 1352951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 1353951c6300SRichard Henderson } 1354951c6300SRichard Henderson } else { 1355951c6300SRichard Henderson tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c); 1356951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_LOW(ret), 0); 1357951c6300SRichard Henderson } 1358951c6300SRichard Henderson } else { 1359951c6300SRichard Henderson TCGv_i32 t0, t1; 1360951c6300SRichard Henderson 1361951c6300SRichard Henderson t0 = tcg_temp_new_i32(); 1362951c6300SRichard Henderson t1 = tcg_temp_new_i32(); 1363951c6300SRichard Henderson if (right) { 1364951c6300SRichard Henderson tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c); 1365951c6300SRichard Henderson if (arith) { 1366951c6300SRichard Henderson tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c); 1367951c6300SRichard Henderson } else { 1368951c6300SRichard Henderson tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c); 1369951c6300SRichard Henderson } 1370951c6300SRichard Henderson tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c); 1371951c6300SRichard Henderson tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0); 1372951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_HIGH(ret), t1); 1373951c6300SRichard Henderson } else { 1374951c6300SRichard Henderson tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c); 1375951c6300SRichard Henderson /* Note: ret can be the same as arg1, so we use t1 */ 1376951c6300SRichard Henderson tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c); 1377951c6300SRichard Henderson tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c); 1378951c6300SRichard Henderson tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0); 1379951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_LOW(ret), t1); 1380951c6300SRichard Henderson } 1381951c6300SRichard Henderson tcg_temp_free_i32(t0); 1382951c6300SRichard Henderson tcg_temp_free_i32(t1); 1383951c6300SRichard Henderson } 1384951c6300SRichard Henderson } 1385951c6300SRichard Henderson 1386474b2e8fSRichard Henderson void tcg_gen_shli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2) 1387951c6300SRichard Henderson { 1388474b2e8fSRichard Henderson tcg_debug_assert(arg2 >= 0 && arg2 < 64); 13893a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 13903a13c3f3SRichard Henderson tcg_gen_shifti_i64(ret, arg1, arg2, 0, 0); 13913a13c3f3SRichard Henderson } else if (arg2 == 0) { 1392951c6300SRichard Henderson tcg_gen_mov_i64(ret, arg1); 1393951c6300SRichard Henderson } else { 1394951c6300SRichard Henderson TCGv_i64 t0 = tcg_const_i64(arg2); 1395951c6300SRichard Henderson tcg_gen_shl_i64(ret, arg1, t0); 1396951c6300SRichard Henderson tcg_temp_free_i64(t0); 1397951c6300SRichard Henderson } 1398951c6300SRichard Henderson } 1399951c6300SRichard Henderson 1400474b2e8fSRichard Henderson void tcg_gen_shri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2) 1401951c6300SRichard Henderson { 1402474b2e8fSRichard Henderson tcg_debug_assert(arg2 >= 0 && arg2 < 64); 14033a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 14043a13c3f3SRichard Henderson tcg_gen_shifti_i64(ret, arg1, arg2, 1, 0); 14053a13c3f3SRichard Henderson } else if (arg2 == 0) { 1406951c6300SRichard Henderson tcg_gen_mov_i64(ret, arg1); 1407951c6300SRichard Henderson } else { 1408951c6300SRichard Henderson TCGv_i64 t0 = tcg_const_i64(arg2); 1409951c6300SRichard Henderson tcg_gen_shr_i64(ret, arg1, t0); 1410951c6300SRichard Henderson tcg_temp_free_i64(t0); 1411951c6300SRichard Henderson } 1412951c6300SRichard Henderson } 1413951c6300SRichard Henderson 1414474b2e8fSRichard Henderson void tcg_gen_sari_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2) 1415951c6300SRichard Henderson { 1416474b2e8fSRichard Henderson tcg_debug_assert(arg2 >= 0 && arg2 < 64); 14173a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 14183a13c3f3SRichard Henderson tcg_gen_shifti_i64(ret, arg1, arg2, 1, 1); 14193a13c3f3SRichard Henderson } else if (arg2 == 0) { 1420951c6300SRichard Henderson tcg_gen_mov_i64(ret, arg1); 1421951c6300SRichard Henderson } else { 1422951c6300SRichard Henderson TCGv_i64 t0 = tcg_const_i64(arg2); 1423951c6300SRichard Henderson tcg_gen_sar_i64(ret, arg1, t0); 1424951c6300SRichard Henderson tcg_temp_free_i64(t0); 1425951c6300SRichard Henderson } 1426951c6300SRichard Henderson } 1427951c6300SRichard Henderson 142842a268c2SRichard Henderson void tcg_gen_brcond_i64(TCGCond cond, TCGv_i64 arg1, TCGv_i64 arg2, TCGLabel *l) 1429951c6300SRichard Henderson { 1430951c6300SRichard Henderson if (cond == TCG_COND_ALWAYS) { 143142a268c2SRichard Henderson tcg_gen_br(l); 1432951c6300SRichard Henderson } else if (cond != TCG_COND_NEVER) { 1433d88a117eSRichard Henderson l->refs++; 14343a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1435951c6300SRichard Henderson tcg_gen_op6ii_i32(INDEX_op_brcond2_i32, TCGV_LOW(arg1), 1436951c6300SRichard Henderson TCGV_HIGH(arg1), TCGV_LOW(arg2), 143742a268c2SRichard Henderson TCGV_HIGH(arg2), cond, label_arg(l)); 14383a13c3f3SRichard Henderson } else { 143942a268c2SRichard Henderson tcg_gen_op4ii_i64(INDEX_op_brcond_i64, arg1, arg2, cond, 144042a268c2SRichard Henderson label_arg(l)); 14413a13c3f3SRichard Henderson } 1442951c6300SRichard Henderson } 1443951c6300SRichard Henderson } 1444951c6300SRichard Henderson 144542a268c2SRichard Henderson void tcg_gen_brcondi_i64(TCGCond cond, TCGv_i64 arg1, int64_t arg2, TCGLabel *l) 1446951c6300SRichard Henderson { 1447951c6300SRichard Henderson if (cond == TCG_COND_ALWAYS) { 144842a268c2SRichard Henderson tcg_gen_br(l); 1449951c6300SRichard Henderson } else if (cond != TCG_COND_NEVER) { 1450951c6300SRichard Henderson TCGv_i64 t0 = tcg_const_i64(arg2); 145142a268c2SRichard Henderson tcg_gen_brcond_i64(cond, arg1, t0, l); 1452951c6300SRichard Henderson tcg_temp_free_i64(t0); 1453951c6300SRichard Henderson } 1454951c6300SRichard Henderson } 1455951c6300SRichard Henderson 1456951c6300SRichard Henderson void tcg_gen_setcond_i64(TCGCond cond, TCGv_i64 ret, 1457951c6300SRichard Henderson TCGv_i64 arg1, TCGv_i64 arg2) 1458951c6300SRichard Henderson { 1459951c6300SRichard Henderson if (cond == TCG_COND_ALWAYS) { 1460951c6300SRichard Henderson tcg_gen_movi_i64(ret, 1); 1461951c6300SRichard Henderson } else if (cond == TCG_COND_NEVER) { 1462951c6300SRichard Henderson tcg_gen_movi_i64(ret, 0); 1463951c6300SRichard Henderson } else { 14643a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1465951c6300SRichard Henderson tcg_gen_op6i_i32(INDEX_op_setcond2_i32, TCGV_LOW(ret), 1466951c6300SRichard Henderson TCGV_LOW(arg1), TCGV_HIGH(arg1), 1467951c6300SRichard Henderson TCGV_LOW(arg2), TCGV_HIGH(arg2), cond); 1468951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 14693a13c3f3SRichard Henderson } else { 1470951c6300SRichard Henderson tcg_gen_op4i_i64(INDEX_op_setcond_i64, ret, arg1, arg2, cond); 14713a13c3f3SRichard Henderson } 1472951c6300SRichard Henderson } 1473951c6300SRichard Henderson } 1474951c6300SRichard Henderson 1475951c6300SRichard Henderson void tcg_gen_setcondi_i64(TCGCond cond, TCGv_i64 ret, 1476951c6300SRichard Henderson TCGv_i64 arg1, int64_t arg2) 1477951c6300SRichard Henderson { 1478951c6300SRichard Henderson TCGv_i64 t0 = tcg_const_i64(arg2); 1479951c6300SRichard Henderson tcg_gen_setcond_i64(cond, ret, arg1, t0); 1480951c6300SRichard Henderson tcg_temp_free_i64(t0); 1481951c6300SRichard Henderson } 1482951c6300SRichard Henderson 1483951c6300SRichard Henderson void tcg_gen_muli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2) 1484951c6300SRichard Henderson { 1485b2e3ae94SRichard Henderson if (arg2 == 0) { 1486b2e3ae94SRichard Henderson tcg_gen_movi_i64(ret, 0); 1487b2e3ae94SRichard Henderson } else if (is_power_of_2(arg2)) { 1488b2e3ae94SRichard Henderson tcg_gen_shli_i64(ret, arg1, ctz64(arg2)); 1489b2e3ae94SRichard Henderson } else { 1490951c6300SRichard Henderson TCGv_i64 t0 = tcg_const_i64(arg2); 1491951c6300SRichard Henderson tcg_gen_mul_i64(ret, arg1, t0); 1492951c6300SRichard Henderson tcg_temp_free_i64(t0); 1493951c6300SRichard Henderson } 1494b2e3ae94SRichard Henderson } 1495951c6300SRichard Henderson 1496951c6300SRichard Henderson void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1497951c6300SRichard Henderson { 1498951c6300SRichard Henderson if (TCG_TARGET_HAS_div_i64) { 1499951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_div_i64, ret, arg1, arg2); 1500951c6300SRichard Henderson } else if (TCG_TARGET_HAS_div2_i64) { 1501951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 1502951c6300SRichard Henderson tcg_gen_sari_i64(t0, arg1, 63); 1503951c6300SRichard Henderson tcg_gen_op5_i64(INDEX_op_div2_i64, ret, t0, arg1, t0, arg2); 1504951c6300SRichard Henderson tcg_temp_free_i64(t0); 1505951c6300SRichard Henderson } else { 1506951c6300SRichard Henderson gen_helper_div_i64(ret, arg1, arg2); 1507951c6300SRichard Henderson } 1508951c6300SRichard Henderson } 1509951c6300SRichard Henderson 1510951c6300SRichard Henderson void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1511951c6300SRichard Henderson { 1512951c6300SRichard Henderson if (TCG_TARGET_HAS_rem_i64) { 1513951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_rem_i64, ret, arg1, arg2); 1514951c6300SRichard Henderson } else if (TCG_TARGET_HAS_div_i64) { 1515951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 1516951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_div_i64, t0, arg1, arg2); 1517951c6300SRichard Henderson tcg_gen_mul_i64(t0, t0, arg2); 1518951c6300SRichard Henderson tcg_gen_sub_i64(ret, arg1, t0); 1519951c6300SRichard Henderson tcg_temp_free_i64(t0); 1520951c6300SRichard Henderson } else if (TCG_TARGET_HAS_div2_i64) { 1521951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 1522951c6300SRichard Henderson tcg_gen_sari_i64(t0, arg1, 63); 1523951c6300SRichard Henderson tcg_gen_op5_i64(INDEX_op_div2_i64, t0, ret, arg1, t0, arg2); 1524951c6300SRichard Henderson tcg_temp_free_i64(t0); 1525951c6300SRichard Henderson } else { 1526951c6300SRichard Henderson gen_helper_rem_i64(ret, arg1, arg2); 1527951c6300SRichard Henderson } 1528951c6300SRichard Henderson } 1529951c6300SRichard Henderson 1530951c6300SRichard Henderson void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1531951c6300SRichard Henderson { 1532951c6300SRichard Henderson if (TCG_TARGET_HAS_div_i64) { 1533951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_divu_i64, ret, arg1, arg2); 1534951c6300SRichard Henderson } else if (TCG_TARGET_HAS_div2_i64) { 1535951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 1536951c6300SRichard Henderson tcg_gen_movi_i64(t0, 0); 1537951c6300SRichard Henderson tcg_gen_op5_i64(INDEX_op_divu2_i64, ret, t0, arg1, t0, arg2); 1538951c6300SRichard Henderson tcg_temp_free_i64(t0); 1539951c6300SRichard Henderson } else { 1540951c6300SRichard Henderson gen_helper_divu_i64(ret, arg1, arg2); 1541951c6300SRichard Henderson } 1542951c6300SRichard Henderson } 1543951c6300SRichard Henderson 1544951c6300SRichard Henderson void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1545951c6300SRichard Henderson { 1546951c6300SRichard Henderson if (TCG_TARGET_HAS_rem_i64) { 1547951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_remu_i64, ret, arg1, arg2); 1548951c6300SRichard Henderson } else if (TCG_TARGET_HAS_div_i64) { 1549951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 1550951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_divu_i64, t0, arg1, arg2); 1551951c6300SRichard Henderson tcg_gen_mul_i64(t0, t0, arg2); 1552951c6300SRichard Henderson tcg_gen_sub_i64(ret, arg1, t0); 1553951c6300SRichard Henderson tcg_temp_free_i64(t0); 1554951c6300SRichard Henderson } else if (TCG_TARGET_HAS_div2_i64) { 1555951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 1556951c6300SRichard Henderson tcg_gen_movi_i64(t0, 0); 1557951c6300SRichard Henderson tcg_gen_op5_i64(INDEX_op_divu2_i64, t0, ret, arg1, t0, arg2); 1558951c6300SRichard Henderson tcg_temp_free_i64(t0); 1559951c6300SRichard Henderson } else { 1560951c6300SRichard Henderson gen_helper_remu_i64(ret, arg1, arg2); 1561951c6300SRichard Henderson } 1562951c6300SRichard Henderson } 1563951c6300SRichard Henderson 1564951c6300SRichard Henderson void tcg_gen_ext8s_i64(TCGv_i64 ret, TCGv_i64 arg) 1565951c6300SRichard Henderson { 15663a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1567951c6300SRichard Henderson tcg_gen_ext8s_i32(TCGV_LOW(ret), TCGV_LOW(arg)); 1568951c6300SRichard Henderson tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31); 15693a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_ext8s_i64) { 1570951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_ext8s_i64, ret, arg); 1571951c6300SRichard Henderson } else { 1572951c6300SRichard Henderson tcg_gen_shli_i64(ret, arg, 56); 1573951c6300SRichard Henderson tcg_gen_sari_i64(ret, ret, 56); 1574951c6300SRichard Henderson } 1575951c6300SRichard Henderson } 1576951c6300SRichard Henderson 1577951c6300SRichard Henderson void tcg_gen_ext16s_i64(TCGv_i64 ret, TCGv_i64 arg) 1578951c6300SRichard Henderson { 15793a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1580951c6300SRichard Henderson tcg_gen_ext16s_i32(TCGV_LOW(ret), TCGV_LOW(arg)); 1581951c6300SRichard Henderson tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31); 15823a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_ext16s_i64) { 1583951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_ext16s_i64, ret, arg); 1584951c6300SRichard Henderson } else { 1585951c6300SRichard Henderson tcg_gen_shli_i64(ret, arg, 48); 1586951c6300SRichard Henderson tcg_gen_sari_i64(ret, ret, 48); 1587951c6300SRichard Henderson } 1588951c6300SRichard Henderson } 1589951c6300SRichard Henderson 1590951c6300SRichard Henderson void tcg_gen_ext32s_i64(TCGv_i64 ret, TCGv_i64 arg) 1591951c6300SRichard Henderson { 15923a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1593951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg)); 1594951c6300SRichard Henderson tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31); 15953a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_ext32s_i64) { 1596951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_ext32s_i64, ret, arg); 1597951c6300SRichard Henderson } else { 1598951c6300SRichard Henderson tcg_gen_shli_i64(ret, arg, 32); 1599951c6300SRichard Henderson tcg_gen_sari_i64(ret, ret, 32); 1600951c6300SRichard Henderson } 1601951c6300SRichard Henderson } 1602951c6300SRichard Henderson 1603951c6300SRichard Henderson void tcg_gen_ext8u_i64(TCGv_i64 ret, TCGv_i64 arg) 1604951c6300SRichard Henderson { 16053a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1606951c6300SRichard Henderson tcg_gen_ext8u_i32(TCGV_LOW(ret), TCGV_LOW(arg)); 1607951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 16083a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_ext8u_i64) { 1609951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_ext8u_i64, ret, arg); 1610951c6300SRichard Henderson } else { 1611951c6300SRichard Henderson tcg_gen_andi_i64(ret, arg, 0xffu); 1612951c6300SRichard Henderson } 1613951c6300SRichard Henderson } 1614951c6300SRichard Henderson 1615951c6300SRichard Henderson void tcg_gen_ext16u_i64(TCGv_i64 ret, TCGv_i64 arg) 1616951c6300SRichard Henderson { 16173a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1618951c6300SRichard Henderson tcg_gen_ext16u_i32(TCGV_LOW(ret), TCGV_LOW(arg)); 1619951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 16203a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_ext16u_i64) { 1621951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_ext16u_i64, ret, arg); 1622951c6300SRichard Henderson } else { 1623951c6300SRichard Henderson tcg_gen_andi_i64(ret, arg, 0xffffu); 1624951c6300SRichard Henderson } 1625951c6300SRichard Henderson } 1626951c6300SRichard Henderson 1627951c6300SRichard Henderson void tcg_gen_ext32u_i64(TCGv_i64 ret, TCGv_i64 arg) 1628951c6300SRichard Henderson { 16293a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1630951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg)); 1631951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 16323a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_ext32u_i64) { 1633951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_ext32u_i64, ret, arg); 1634951c6300SRichard Henderson } else { 1635951c6300SRichard Henderson tcg_gen_andi_i64(ret, arg, 0xffffffffu); 1636951c6300SRichard Henderson } 1637951c6300SRichard Henderson } 1638951c6300SRichard Henderson 1639951c6300SRichard Henderson /* Note: we assume the six high bytes are set to zero */ 1640951c6300SRichard Henderson void tcg_gen_bswap16_i64(TCGv_i64 ret, TCGv_i64 arg) 1641951c6300SRichard Henderson { 16423a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1643951c6300SRichard Henderson tcg_gen_bswap16_i32(TCGV_LOW(ret), TCGV_LOW(arg)); 1644951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 16453a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_bswap16_i64) { 1646951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_bswap16_i64, ret, arg); 1647951c6300SRichard Henderson } else { 1648951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 1649951c6300SRichard Henderson 1650951c6300SRichard Henderson tcg_gen_ext8u_i64(t0, arg); 1651951c6300SRichard Henderson tcg_gen_shli_i64(t0, t0, 8); 1652951c6300SRichard Henderson tcg_gen_shri_i64(ret, arg, 8); 1653951c6300SRichard Henderson tcg_gen_or_i64(ret, ret, t0); 1654951c6300SRichard Henderson tcg_temp_free_i64(t0); 1655951c6300SRichard Henderson } 1656951c6300SRichard Henderson } 1657951c6300SRichard Henderson 1658951c6300SRichard Henderson /* Note: we assume the four high bytes are set to zero */ 1659951c6300SRichard Henderson void tcg_gen_bswap32_i64(TCGv_i64 ret, TCGv_i64 arg) 1660951c6300SRichard Henderson { 16613a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1662951c6300SRichard Henderson tcg_gen_bswap32_i32(TCGV_LOW(ret), TCGV_LOW(arg)); 1663951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 16643a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_bswap32_i64) { 1665951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_bswap32_i64, ret, arg); 1666951c6300SRichard Henderson } else { 1667a686dc71SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 1668a686dc71SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 1669a686dc71SRichard Henderson TCGv_i64 t2 = tcg_const_i64(0x00ff00ff); 1670951c6300SRichard Henderson 1671a686dc71SRichard Henderson /* arg = ....abcd */ 1672a686dc71SRichard Henderson tcg_gen_shri_i64(t0, arg, 8); /* t0 = .....abc */ 1673a686dc71SRichard Henderson tcg_gen_and_i64(t1, arg, t2); /* t1 = .....b.d */ 1674a686dc71SRichard Henderson tcg_gen_and_i64(t0, t0, t2); /* t0 = .....a.c */ 1675a686dc71SRichard Henderson tcg_gen_shli_i64(t1, t1, 8); /* t1 = ....b.d. */ 1676a686dc71SRichard Henderson tcg_gen_or_i64(ret, t0, t1); /* ret = ....badc */ 1677951c6300SRichard Henderson 1678a686dc71SRichard Henderson tcg_gen_shli_i64(t1, ret, 48); /* t1 = dc...... */ 1679a686dc71SRichard Henderson tcg_gen_shri_i64(t0, ret, 16); /* t0 = ......ba */ 1680a686dc71SRichard Henderson tcg_gen_shri_i64(t1, t1, 32); /* t1 = ....dc.. */ 1681a686dc71SRichard Henderson tcg_gen_or_i64(ret, t0, t1); /* ret = ....dcba */ 1682951c6300SRichard Henderson 1683951c6300SRichard Henderson tcg_temp_free_i64(t0); 1684951c6300SRichard Henderson tcg_temp_free_i64(t1); 1685a686dc71SRichard Henderson tcg_temp_free_i64(t2); 1686951c6300SRichard Henderson } 1687951c6300SRichard Henderson } 1688951c6300SRichard Henderson 1689951c6300SRichard Henderson void tcg_gen_bswap64_i64(TCGv_i64 ret, TCGv_i64 arg) 1690951c6300SRichard Henderson { 16913a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 1692951c6300SRichard Henderson TCGv_i32 t0, t1; 1693951c6300SRichard Henderson t0 = tcg_temp_new_i32(); 1694951c6300SRichard Henderson t1 = tcg_temp_new_i32(); 1695951c6300SRichard Henderson 1696951c6300SRichard Henderson tcg_gen_bswap32_i32(t0, TCGV_LOW(arg)); 1697951c6300SRichard Henderson tcg_gen_bswap32_i32(t1, TCGV_HIGH(arg)); 1698951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_LOW(ret), t1); 1699951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_HIGH(ret), t0); 1700951c6300SRichard Henderson tcg_temp_free_i32(t0); 1701951c6300SRichard Henderson tcg_temp_free_i32(t1); 17023a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_bswap64_i64) { 1703951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_bswap64_i64, ret, arg); 1704951c6300SRichard Henderson } else { 1705951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 1706951c6300SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 17079e821eabSRichard Henderson TCGv_i64 t2 = tcg_temp_new_i64(); 1708951c6300SRichard Henderson 17099e821eabSRichard Henderson /* arg = abcdefgh */ 17109e821eabSRichard Henderson tcg_gen_movi_i64(t2, 0x00ff00ff00ff00ffull); 17119e821eabSRichard Henderson tcg_gen_shri_i64(t0, arg, 8); /* t0 = .abcdefg */ 17129e821eabSRichard Henderson tcg_gen_and_i64(t1, arg, t2); /* t1 = .b.d.f.h */ 17139e821eabSRichard Henderson tcg_gen_and_i64(t0, t0, t2); /* t0 = .a.c.e.g */ 17149e821eabSRichard Henderson tcg_gen_shli_i64(t1, t1, 8); /* t1 = b.d.f.h. */ 17159e821eabSRichard Henderson tcg_gen_or_i64(ret, t0, t1); /* ret = badcfehg */ 1716951c6300SRichard Henderson 17179e821eabSRichard Henderson tcg_gen_movi_i64(t2, 0x0000ffff0000ffffull); 17189e821eabSRichard Henderson tcg_gen_shri_i64(t0, ret, 16); /* t0 = ..badcfe */ 17199e821eabSRichard Henderson tcg_gen_and_i64(t1, ret, t2); /* t1 = ..dc..hg */ 17209e821eabSRichard Henderson tcg_gen_and_i64(t0, t0, t2); /* t0 = ..ba..fe */ 17219e821eabSRichard Henderson tcg_gen_shli_i64(t1, t1, 16); /* t1 = dc..hg.. */ 17229e821eabSRichard Henderson tcg_gen_or_i64(ret, t0, t1); /* ret = dcbahgfe */ 1723951c6300SRichard Henderson 17249e821eabSRichard Henderson tcg_gen_shri_i64(t0, ret, 32); /* t0 = ....dcba */ 17259e821eabSRichard Henderson tcg_gen_shli_i64(t1, ret, 32); /* t1 = hgfe.... */ 17269e821eabSRichard Henderson tcg_gen_or_i64(ret, t0, t1); /* ret = hgfedcba */ 1727951c6300SRichard Henderson 1728951c6300SRichard Henderson tcg_temp_free_i64(t0); 1729951c6300SRichard Henderson tcg_temp_free_i64(t1); 17309e821eabSRichard Henderson tcg_temp_free_i64(t2); 1731951c6300SRichard Henderson } 1732951c6300SRichard Henderson } 1733951c6300SRichard Henderson 1734951c6300SRichard Henderson void tcg_gen_not_i64(TCGv_i64 ret, TCGv_i64 arg) 1735951c6300SRichard Henderson { 17363a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 17373a13c3f3SRichard Henderson tcg_gen_not_i32(TCGV_LOW(ret), TCGV_LOW(arg)); 17383a13c3f3SRichard Henderson tcg_gen_not_i32(TCGV_HIGH(ret), TCGV_HIGH(arg)); 17393a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_not_i64) { 1740951c6300SRichard Henderson tcg_gen_op2_i64(INDEX_op_not_i64, ret, arg); 1741951c6300SRichard Henderson } else { 1742951c6300SRichard Henderson tcg_gen_xori_i64(ret, arg, -1); 1743951c6300SRichard Henderson } 1744951c6300SRichard Henderson } 1745951c6300SRichard Henderson 1746951c6300SRichard Henderson void tcg_gen_andc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1747951c6300SRichard Henderson { 17483a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 17493a13c3f3SRichard Henderson tcg_gen_andc_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2)); 17503a13c3f3SRichard Henderson tcg_gen_andc_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2)); 17513a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_andc_i64) { 1752951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_andc_i64, ret, arg1, arg2); 1753951c6300SRichard Henderson } else { 1754951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 1755951c6300SRichard Henderson tcg_gen_not_i64(t0, arg2); 1756951c6300SRichard Henderson tcg_gen_and_i64(ret, arg1, t0); 1757951c6300SRichard Henderson tcg_temp_free_i64(t0); 1758951c6300SRichard Henderson } 1759951c6300SRichard Henderson } 1760951c6300SRichard Henderson 1761951c6300SRichard Henderson void tcg_gen_eqv_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1762951c6300SRichard Henderson { 17633a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 17643a13c3f3SRichard Henderson tcg_gen_eqv_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2)); 17653a13c3f3SRichard Henderson tcg_gen_eqv_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2)); 17663a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_eqv_i64) { 1767951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_eqv_i64, ret, arg1, arg2); 1768951c6300SRichard Henderson } else { 1769951c6300SRichard Henderson tcg_gen_xor_i64(ret, arg1, arg2); 1770951c6300SRichard Henderson tcg_gen_not_i64(ret, ret); 1771951c6300SRichard Henderson } 1772951c6300SRichard Henderson } 1773951c6300SRichard Henderson 1774951c6300SRichard Henderson void tcg_gen_nand_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1775951c6300SRichard Henderson { 17763a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 17773a13c3f3SRichard Henderson tcg_gen_nand_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2)); 17783a13c3f3SRichard Henderson tcg_gen_nand_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2)); 17793a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_nand_i64) { 1780951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_nand_i64, ret, arg1, arg2); 1781951c6300SRichard Henderson } else { 1782951c6300SRichard Henderson tcg_gen_and_i64(ret, arg1, arg2); 1783951c6300SRichard Henderson tcg_gen_not_i64(ret, ret); 1784951c6300SRichard Henderson } 1785951c6300SRichard Henderson } 1786951c6300SRichard Henderson 1787951c6300SRichard Henderson void tcg_gen_nor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1788951c6300SRichard Henderson { 17893a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 17903a13c3f3SRichard Henderson tcg_gen_nor_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2)); 17913a13c3f3SRichard Henderson tcg_gen_nor_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2)); 17923a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_nor_i64) { 1793951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_nor_i64, ret, arg1, arg2); 1794951c6300SRichard Henderson } else { 1795951c6300SRichard Henderson tcg_gen_or_i64(ret, arg1, arg2); 1796951c6300SRichard Henderson tcg_gen_not_i64(ret, ret); 1797951c6300SRichard Henderson } 1798951c6300SRichard Henderson } 1799951c6300SRichard Henderson 1800951c6300SRichard Henderson void tcg_gen_orc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1801951c6300SRichard Henderson { 18023a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 18033a13c3f3SRichard Henderson tcg_gen_orc_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2)); 18043a13c3f3SRichard Henderson tcg_gen_orc_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2)); 18053a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_orc_i64) { 1806951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_orc_i64, ret, arg1, arg2); 1807951c6300SRichard Henderson } else { 1808951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 1809951c6300SRichard Henderson tcg_gen_not_i64(t0, arg2); 1810951c6300SRichard Henderson tcg_gen_or_i64(ret, arg1, t0); 1811951c6300SRichard Henderson tcg_temp_free_i64(t0); 1812951c6300SRichard Henderson } 1813951c6300SRichard Henderson } 1814951c6300SRichard Henderson 18150e28d006SRichard Henderson void tcg_gen_clz_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 18160e28d006SRichard Henderson { 18170e28d006SRichard Henderson if (TCG_TARGET_HAS_clz_i64) { 18180e28d006SRichard Henderson tcg_gen_op3_i64(INDEX_op_clz_i64, ret, arg1, arg2); 18190e28d006SRichard Henderson } else { 18200e28d006SRichard Henderson gen_helper_clz_i64(ret, arg1, arg2); 18210e28d006SRichard Henderson } 18220e28d006SRichard Henderson } 18230e28d006SRichard Henderson 18240e28d006SRichard Henderson void tcg_gen_clzi_i64(TCGv_i64 ret, TCGv_i64 arg1, uint64_t arg2) 18250e28d006SRichard Henderson { 18260e28d006SRichard Henderson if (TCG_TARGET_REG_BITS == 32 18270e28d006SRichard Henderson && TCG_TARGET_HAS_clz_i32 18280e28d006SRichard Henderson && arg2 <= 0xffffffffu) { 18290e28d006SRichard Henderson TCGv_i32 t = tcg_const_i32((uint32_t)arg2 - 32); 18300e28d006SRichard Henderson tcg_gen_clz_i32(t, TCGV_LOW(arg1), t); 18310e28d006SRichard Henderson tcg_gen_addi_i32(t, t, 32); 18320e28d006SRichard Henderson tcg_gen_clz_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), t); 18330e28d006SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 18340e28d006SRichard Henderson tcg_temp_free_i32(t); 18350e28d006SRichard Henderson } else { 18360e28d006SRichard Henderson TCGv_i64 t = tcg_const_i64(arg2); 18370e28d006SRichard Henderson tcg_gen_clz_i64(ret, arg1, t); 18380e28d006SRichard Henderson tcg_temp_free_i64(t); 18390e28d006SRichard Henderson } 18400e28d006SRichard Henderson } 18410e28d006SRichard Henderson 18420e28d006SRichard Henderson void tcg_gen_ctz_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 18430e28d006SRichard Henderson { 18440e28d006SRichard Henderson if (TCG_TARGET_HAS_ctz_i64) { 18450e28d006SRichard Henderson tcg_gen_op3_i64(INDEX_op_ctz_i64, ret, arg1, arg2); 184614e99210SRichard Henderson } else if (TCG_TARGET_HAS_ctpop_i64 || TCG_TARGET_HAS_clz_i64) { 184714e99210SRichard Henderson TCGv_i64 z, t = tcg_temp_new_i64(); 184814e99210SRichard Henderson 184914e99210SRichard Henderson if (TCG_TARGET_HAS_ctpop_i64) { 185014e99210SRichard Henderson tcg_gen_subi_i64(t, arg1, 1); 185114e99210SRichard Henderson tcg_gen_andc_i64(t, t, arg1); 185214e99210SRichard Henderson tcg_gen_ctpop_i64(t, t); 185314e99210SRichard Henderson } else { 185414e99210SRichard Henderson /* Since all non-x86 hosts have clz(0) == 64, don't fight it. */ 185514e99210SRichard Henderson tcg_gen_neg_i64(t, arg1); 185614e99210SRichard Henderson tcg_gen_and_i64(t, t, arg1); 185714e99210SRichard Henderson tcg_gen_clzi_i64(t, t, 64); 185814e99210SRichard Henderson tcg_gen_xori_i64(t, t, 63); 185914e99210SRichard Henderson } 186014e99210SRichard Henderson z = tcg_const_i64(0); 186114e99210SRichard Henderson tcg_gen_movcond_i64(TCG_COND_EQ, ret, arg1, z, arg2, t); 186214e99210SRichard Henderson tcg_temp_free_i64(t); 186314e99210SRichard Henderson tcg_temp_free_i64(z); 18640e28d006SRichard Henderson } else { 18650e28d006SRichard Henderson gen_helper_ctz_i64(ret, arg1, arg2); 18660e28d006SRichard Henderson } 18670e28d006SRichard Henderson } 18680e28d006SRichard Henderson 18690e28d006SRichard Henderson void tcg_gen_ctzi_i64(TCGv_i64 ret, TCGv_i64 arg1, uint64_t arg2) 18700e28d006SRichard Henderson { 18710e28d006SRichard Henderson if (TCG_TARGET_REG_BITS == 32 18720e28d006SRichard Henderson && TCG_TARGET_HAS_ctz_i32 18730e28d006SRichard Henderson && arg2 <= 0xffffffffu) { 18740e28d006SRichard Henderson TCGv_i32 t32 = tcg_const_i32((uint32_t)arg2 - 32); 18750e28d006SRichard Henderson tcg_gen_ctz_i32(t32, TCGV_HIGH(arg1), t32); 18760e28d006SRichard Henderson tcg_gen_addi_i32(t32, t32, 32); 18770e28d006SRichard Henderson tcg_gen_ctz_i32(TCGV_LOW(ret), TCGV_LOW(arg1), t32); 18780e28d006SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 18790e28d006SRichard Henderson tcg_temp_free_i32(t32); 188014e99210SRichard Henderson } else if (!TCG_TARGET_HAS_ctz_i64 188114e99210SRichard Henderson && TCG_TARGET_HAS_ctpop_i64 188214e99210SRichard Henderson && arg2 == 64) { 188314e99210SRichard Henderson /* This equivalence has the advantage of not requiring a fixup. */ 188414e99210SRichard Henderson TCGv_i64 t = tcg_temp_new_i64(); 188514e99210SRichard Henderson tcg_gen_subi_i64(t, arg1, 1); 188614e99210SRichard Henderson tcg_gen_andc_i64(t, t, arg1); 188714e99210SRichard Henderson tcg_gen_ctpop_i64(ret, t); 188814e99210SRichard Henderson tcg_temp_free_i64(t); 18890e28d006SRichard Henderson } else { 18900e28d006SRichard Henderson TCGv_i64 t64 = tcg_const_i64(arg2); 18910e28d006SRichard Henderson tcg_gen_ctz_i64(ret, arg1, t64); 18920e28d006SRichard Henderson tcg_temp_free_i64(t64); 18930e28d006SRichard Henderson } 18940e28d006SRichard Henderson } 18950e28d006SRichard Henderson 1896086920c2SRichard Henderson void tcg_gen_clrsb_i64(TCGv_i64 ret, TCGv_i64 arg) 1897086920c2SRichard Henderson { 1898086920c2SRichard Henderson if (TCG_TARGET_HAS_clz_i64 || TCG_TARGET_HAS_clz_i32) { 1899086920c2SRichard Henderson TCGv_i64 t = tcg_temp_new_i64(); 1900086920c2SRichard Henderson tcg_gen_sari_i64(t, arg, 63); 1901086920c2SRichard Henderson tcg_gen_xor_i64(t, t, arg); 1902086920c2SRichard Henderson tcg_gen_clzi_i64(t, t, 64); 1903086920c2SRichard Henderson tcg_gen_subi_i64(ret, t, 1); 1904086920c2SRichard Henderson tcg_temp_free_i64(t); 1905086920c2SRichard Henderson } else { 1906086920c2SRichard Henderson gen_helper_clrsb_i64(ret, arg); 1907086920c2SRichard Henderson } 1908086920c2SRichard Henderson } 1909086920c2SRichard Henderson 1910a768e4e9SRichard Henderson void tcg_gen_ctpop_i64(TCGv_i64 ret, TCGv_i64 arg1) 1911a768e4e9SRichard Henderson { 1912a768e4e9SRichard Henderson if (TCG_TARGET_HAS_ctpop_i64) { 1913a768e4e9SRichard Henderson tcg_gen_op2_i64(INDEX_op_ctpop_i64, ret, arg1); 1914a768e4e9SRichard Henderson } else if (TCG_TARGET_REG_BITS == 32 && TCG_TARGET_HAS_ctpop_i32) { 1915a768e4e9SRichard Henderson tcg_gen_ctpop_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1)); 1916a768e4e9SRichard Henderson tcg_gen_ctpop_i32(TCGV_LOW(ret), TCGV_LOW(arg1)); 1917a768e4e9SRichard Henderson tcg_gen_add_i32(TCGV_LOW(ret), TCGV_LOW(ret), TCGV_HIGH(ret)); 1918a768e4e9SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 1919a768e4e9SRichard Henderson } else { 1920a768e4e9SRichard Henderson gen_helper_ctpop_i64(ret, arg1); 1921a768e4e9SRichard Henderson } 1922a768e4e9SRichard Henderson } 1923a768e4e9SRichard Henderson 1924951c6300SRichard Henderson void tcg_gen_rotl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1925951c6300SRichard Henderson { 1926951c6300SRichard Henderson if (TCG_TARGET_HAS_rot_i64) { 1927951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_rotl_i64, ret, arg1, arg2); 1928951c6300SRichard Henderson } else { 1929951c6300SRichard Henderson TCGv_i64 t0, t1; 1930951c6300SRichard Henderson t0 = tcg_temp_new_i64(); 1931951c6300SRichard Henderson t1 = tcg_temp_new_i64(); 1932951c6300SRichard Henderson tcg_gen_shl_i64(t0, arg1, arg2); 1933951c6300SRichard Henderson tcg_gen_subfi_i64(t1, 64, arg2); 1934951c6300SRichard Henderson tcg_gen_shr_i64(t1, arg1, t1); 1935951c6300SRichard Henderson tcg_gen_or_i64(ret, t0, t1); 1936951c6300SRichard Henderson tcg_temp_free_i64(t0); 1937951c6300SRichard Henderson tcg_temp_free_i64(t1); 1938951c6300SRichard Henderson } 1939951c6300SRichard Henderson } 1940951c6300SRichard Henderson 1941951c6300SRichard Henderson void tcg_gen_rotli_i64(TCGv_i64 ret, TCGv_i64 arg1, unsigned arg2) 1942951c6300SRichard Henderson { 1943951c6300SRichard Henderson tcg_debug_assert(arg2 < 64); 1944951c6300SRichard Henderson /* some cases can be optimized here */ 1945951c6300SRichard Henderson if (arg2 == 0) { 1946951c6300SRichard Henderson tcg_gen_mov_i64(ret, arg1); 1947951c6300SRichard Henderson } else if (TCG_TARGET_HAS_rot_i64) { 1948951c6300SRichard Henderson TCGv_i64 t0 = tcg_const_i64(arg2); 1949951c6300SRichard Henderson tcg_gen_rotl_i64(ret, arg1, t0); 1950951c6300SRichard Henderson tcg_temp_free_i64(t0); 1951951c6300SRichard Henderson } else { 1952951c6300SRichard Henderson TCGv_i64 t0, t1; 1953951c6300SRichard Henderson t0 = tcg_temp_new_i64(); 1954951c6300SRichard Henderson t1 = tcg_temp_new_i64(); 1955951c6300SRichard Henderson tcg_gen_shli_i64(t0, arg1, arg2); 1956951c6300SRichard Henderson tcg_gen_shri_i64(t1, arg1, 64 - arg2); 1957951c6300SRichard Henderson tcg_gen_or_i64(ret, t0, t1); 1958951c6300SRichard Henderson tcg_temp_free_i64(t0); 1959951c6300SRichard Henderson tcg_temp_free_i64(t1); 1960951c6300SRichard Henderson } 1961951c6300SRichard Henderson } 1962951c6300SRichard Henderson 1963951c6300SRichard Henderson void tcg_gen_rotr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2) 1964951c6300SRichard Henderson { 1965951c6300SRichard Henderson if (TCG_TARGET_HAS_rot_i64) { 1966951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_rotr_i64, ret, arg1, arg2); 1967951c6300SRichard Henderson } else { 1968951c6300SRichard Henderson TCGv_i64 t0, t1; 1969951c6300SRichard Henderson t0 = tcg_temp_new_i64(); 1970951c6300SRichard Henderson t1 = tcg_temp_new_i64(); 1971951c6300SRichard Henderson tcg_gen_shr_i64(t0, arg1, arg2); 1972951c6300SRichard Henderson tcg_gen_subfi_i64(t1, 64, arg2); 1973951c6300SRichard Henderson tcg_gen_shl_i64(t1, arg1, t1); 1974951c6300SRichard Henderson tcg_gen_or_i64(ret, t0, t1); 1975951c6300SRichard Henderson tcg_temp_free_i64(t0); 1976951c6300SRichard Henderson tcg_temp_free_i64(t1); 1977951c6300SRichard Henderson } 1978951c6300SRichard Henderson } 1979951c6300SRichard Henderson 1980951c6300SRichard Henderson void tcg_gen_rotri_i64(TCGv_i64 ret, TCGv_i64 arg1, unsigned arg2) 1981951c6300SRichard Henderson { 1982951c6300SRichard Henderson tcg_debug_assert(arg2 < 64); 1983951c6300SRichard Henderson /* some cases can be optimized here */ 1984951c6300SRichard Henderson if (arg2 == 0) { 1985951c6300SRichard Henderson tcg_gen_mov_i64(ret, arg1); 1986951c6300SRichard Henderson } else { 1987951c6300SRichard Henderson tcg_gen_rotli_i64(ret, arg1, 64 - arg2); 1988951c6300SRichard Henderson } 1989951c6300SRichard Henderson } 1990951c6300SRichard Henderson 1991951c6300SRichard Henderson void tcg_gen_deposit_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2, 1992951c6300SRichard Henderson unsigned int ofs, unsigned int len) 1993951c6300SRichard Henderson { 1994951c6300SRichard Henderson uint64_t mask; 1995951c6300SRichard Henderson TCGv_i64 t1; 1996951c6300SRichard Henderson 1997951c6300SRichard Henderson tcg_debug_assert(ofs < 64); 19980d0d309dSRichard Henderson tcg_debug_assert(len > 0); 1999951c6300SRichard Henderson tcg_debug_assert(len <= 64); 2000951c6300SRichard Henderson tcg_debug_assert(ofs + len <= 64); 2001951c6300SRichard Henderson 20020d0d309dSRichard Henderson if (len == 64) { 2003951c6300SRichard Henderson tcg_gen_mov_i64(ret, arg2); 2004951c6300SRichard Henderson return; 2005951c6300SRichard Henderson } 2006951c6300SRichard Henderson if (TCG_TARGET_HAS_deposit_i64 && TCG_TARGET_deposit_i64_valid(ofs, len)) { 2007951c6300SRichard Henderson tcg_gen_op5ii_i64(INDEX_op_deposit_i64, ret, arg1, arg2, ofs, len); 2008951c6300SRichard Henderson return; 2009951c6300SRichard Henderson } 2010951c6300SRichard Henderson 20113a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 2012951c6300SRichard Henderson if (ofs >= 32) { 2013951c6300SRichard Henderson tcg_gen_deposit_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 2014951c6300SRichard Henderson TCGV_LOW(arg2), ofs - 32, len); 2015951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1)); 2016951c6300SRichard Henderson return; 2017951c6300SRichard Henderson } 2018951c6300SRichard Henderson if (ofs + len <= 32) { 2019951c6300SRichard Henderson tcg_gen_deposit_i32(TCGV_LOW(ret), TCGV_LOW(arg1), 2020951c6300SRichard Henderson TCGV_LOW(arg2), ofs, len); 2021951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1)); 2022951c6300SRichard Henderson return; 2023951c6300SRichard Henderson } 20243a13c3f3SRichard Henderson } 2025951c6300SRichard Henderson 2026951c6300SRichard Henderson mask = (1ull << len) - 1; 2027951c6300SRichard Henderson t1 = tcg_temp_new_i64(); 2028951c6300SRichard Henderson 2029951c6300SRichard Henderson if (ofs + len < 64) { 2030951c6300SRichard Henderson tcg_gen_andi_i64(t1, arg2, mask); 2031951c6300SRichard Henderson tcg_gen_shli_i64(t1, t1, ofs); 2032951c6300SRichard Henderson } else { 2033951c6300SRichard Henderson tcg_gen_shli_i64(t1, arg2, ofs); 2034951c6300SRichard Henderson } 2035951c6300SRichard Henderson tcg_gen_andi_i64(ret, arg1, ~(mask << ofs)); 2036951c6300SRichard Henderson tcg_gen_or_i64(ret, ret, t1); 2037951c6300SRichard Henderson 2038951c6300SRichard Henderson tcg_temp_free_i64(t1); 2039951c6300SRichard Henderson } 2040951c6300SRichard Henderson 204107cc68d5SRichard Henderson void tcg_gen_deposit_z_i64(TCGv_i64 ret, TCGv_i64 arg, 204207cc68d5SRichard Henderson unsigned int ofs, unsigned int len) 204307cc68d5SRichard Henderson { 204407cc68d5SRichard Henderson tcg_debug_assert(ofs < 64); 204507cc68d5SRichard Henderson tcg_debug_assert(len > 0); 204607cc68d5SRichard Henderson tcg_debug_assert(len <= 64); 204707cc68d5SRichard Henderson tcg_debug_assert(ofs + len <= 64); 204807cc68d5SRichard Henderson 204907cc68d5SRichard Henderson if (ofs + len == 64) { 205007cc68d5SRichard Henderson tcg_gen_shli_i64(ret, arg, ofs); 205107cc68d5SRichard Henderson } else if (ofs == 0) { 205207cc68d5SRichard Henderson tcg_gen_andi_i64(ret, arg, (1ull << len) - 1); 205307cc68d5SRichard Henderson } else if (TCG_TARGET_HAS_deposit_i64 205407cc68d5SRichard Henderson && TCG_TARGET_deposit_i64_valid(ofs, len)) { 205507cc68d5SRichard Henderson TCGv_i64 zero = tcg_const_i64(0); 205607cc68d5SRichard Henderson tcg_gen_op5ii_i64(INDEX_op_deposit_i64, ret, zero, arg, ofs, len); 205707cc68d5SRichard Henderson tcg_temp_free_i64(zero); 205807cc68d5SRichard Henderson } else { 205907cc68d5SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 206007cc68d5SRichard Henderson if (ofs >= 32) { 206107cc68d5SRichard Henderson tcg_gen_deposit_z_i32(TCGV_HIGH(ret), TCGV_LOW(arg), 206207cc68d5SRichard Henderson ofs - 32, len); 206307cc68d5SRichard Henderson tcg_gen_movi_i32(TCGV_LOW(ret), 0); 206407cc68d5SRichard Henderson return; 206507cc68d5SRichard Henderson } 206607cc68d5SRichard Henderson if (ofs + len <= 32) { 206707cc68d5SRichard Henderson tcg_gen_deposit_z_i32(TCGV_LOW(ret), TCGV_LOW(arg), ofs, len); 206807cc68d5SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 206907cc68d5SRichard Henderson return; 207007cc68d5SRichard Henderson } 207107cc68d5SRichard Henderson } 207207cc68d5SRichard Henderson /* To help two-operand hosts we prefer to zero-extend first, 207307cc68d5SRichard Henderson which allows ARG to stay live. */ 207407cc68d5SRichard Henderson switch (len) { 207507cc68d5SRichard Henderson case 32: 207607cc68d5SRichard Henderson if (TCG_TARGET_HAS_ext32u_i64) { 207707cc68d5SRichard Henderson tcg_gen_ext32u_i64(ret, arg); 207807cc68d5SRichard Henderson tcg_gen_shli_i64(ret, ret, ofs); 207907cc68d5SRichard Henderson return; 208007cc68d5SRichard Henderson } 208107cc68d5SRichard Henderson break; 208207cc68d5SRichard Henderson case 16: 208307cc68d5SRichard Henderson if (TCG_TARGET_HAS_ext16u_i64) { 208407cc68d5SRichard Henderson tcg_gen_ext16u_i64(ret, arg); 208507cc68d5SRichard Henderson tcg_gen_shli_i64(ret, ret, ofs); 208607cc68d5SRichard Henderson return; 208707cc68d5SRichard Henderson } 208807cc68d5SRichard Henderson break; 208907cc68d5SRichard Henderson case 8: 209007cc68d5SRichard Henderson if (TCG_TARGET_HAS_ext8u_i64) { 209107cc68d5SRichard Henderson tcg_gen_ext8u_i64(ret, arg); 209207cc68d5SRichard Henderson tcg_gen_shli_i64(ret, ret, ofs); 209307cc68d5SRichard Henderson return; 209407cc68d5SRichard Henderson } 209507cc68d5SRichard Henderson break; 209607cc68d5SRichard Henderson } 209707cc68d5SRichard Henderson /* Otherwise prefer zero-extension over AND for code size. */ 209807cc68d5SRichard Henderson switch (ofs + len) { 209907cc68d5SRichard Henderson case 32: 210007cc68d5SRichard Henderson if (TCG_TARGET_HAS_ext32u_i64) { 210107cc68d5SRichard Henderson tcg_gen_shli_i64(ret, arg, ofs); 210207cc68d5SRichard Henderson tcg_gen_ext32u_i64(ret, ret); 210307cc68d5SRichard Henderson return; 210407cc68d5SRichard Henderson } 210507cc68d5SRichard Henderson break; 210607cc68d5SRichard Henderson case 16: 210707cc68d5SRichard Henderson if (TCG_TARGET_HAS_ext16u_i64) { 210807cc68d5SRichard Henderson tcg_gen_shli_i64(ret, arg, ofs); 210907cc68d5SRichard Henderson tcg_gen_ext16u_i64(ret, ret); 211007cc68d5SRichard Henderson return; 211107cc68d5SRichard Henderson } 211207cc68d5SRichard Henderson break; 211307cc68d5SRichard Henderson case 8: 211407cc68d5SRichard Henderson if (TCG_TARGET_HAS_ext8u_i64) { 211507cc68d5SRichard Henderson tcg_gen_shli_i64(ret, arg, ofs); 211607cc68d5SRichard Henderson tcg_gen_ext8u_i64(ret, ret); 211707cc68d5SRichard Henderson return; 211807cc68d5SRichard Henderson } 211907cc68d5SRichard Henderson break; 212007cc68d5SRichard Henderson } 212107cc68d5SRichard Henderson tcg_gen_andi_i64(ret, arg, (1ull << len) - 1); 212207cc68d5SRichard Henderson tcg_gen_shli_i64(ret, ret, ofs); 212307cc68d5SRichard Henderson } 212407cc68d5SRichard Henderson } 212507cc68d5SRichard Henderson 21267ec8bab3SRichard Henderson void tcg_gen_extract_i64(TCGv_i64 ret, TCGv_i64 arg, 21277ec8bab3SRichard Henderson unsigned int ofs, unsigned int len) 21287ec8bab3SRichard Henderson { 21297ec8bab3SRichard Henderson tcg_debug_assert(ofs < 64); 21307ec8bab3SRichard Henderson tcg_debug_assert(len > 0); 21317ec8bab3SRichard Henderson tcg_debug_assert(len <= 64); 21327ec8bab3SRichard Henderson tcg_debug_assert(ofs + len <= 64); 21337ec8bab3SRichard Henderson 21347ec8bab3SRichard Henderson /* Canonicalize certain special cases, even if extract is supported. */ 21357ec8bab3SRichard Henderson if (ofs + len == 64) { 21367ec8bab3SRichard Henderson tcg_gen_shri_i64(ret, arg, 64 - len); 21377ec8bab3SRichard Henderson return; 21387ec8bab3SRichard Henderson } 21397ec8bab3SRichard Henderson if (ofs == 0) { 21407ec8bab3SRichard Henderson tcg_gen_andi_i64(ret, arg, (1ull << len) - 1); 21417ec8bab3SRichard Henderson return; 21427ec8bab3SRichard Henderson } 21437ec8bab3SRichard Henderson 21447ec8bab3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 21457ec8bab3SRichard Henderson /* Look for a 32-bit extract within one of the two words. */ 21467ec8bab3SRichard Henderson if (ofs >= 32) { 21477ec8bab3SRichard Henderson tcg_gen_extract_i32(TCGV_LOW(ret), TCGV_HIGH(arg), ofs - 32, len); 21487ec8bab3SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 21497ec8bab3SRichard Henderson return; 21507ec8bab3SRichard Henderson } 21517ec8bab3SRichard Henderson if (ofs + len <= 32) { 21527ec8bab3SRichard Henderson tcg_gen_extract_i32(TCGV_LOW(ret), TCGV_LOW(arg), ofs, len); 21537ec8bab3SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 21547ec8bab3SRichard Henderson return; 21557ec8bab3SRichard Henderson } 21567ec8bab3SRichard Henderson /* The field is split across two words. One double-word 21577ec8bab3SRichard Henderson shift is better than two double-word shifts. */ 21587ec8bab3SRichard Henderson goto do_shift_and; 21597ec8bab3SRichard Henderson } 21607ec8bab3SRichard Henderson 21617ec8bab3SRichard Henderson if (TCG_TARGET_HAS_extract_i64 21627ec8bab3SRichard Henderson && TCG_TARGET_extract_i64_valid(ofs, len)) { 21637ec8bab3SRichard Henderson tcg_gen_op4ii_i64(INDEX_op_extract_i64, ret, arg, ofs, len); 21647ec8bab3SRichard Henderson return; 21657ec8bab3SRichard Henderson } 21667ec8bab3SRichard Henderson 21677ec8bab3SRichard Henderson /* Assume that zero-extension, if available, is cheaper than a shift. */ 21687ec8bab3SRichard Henderson switch (ofs + len) { 21697ec8bab3SRichard Henderson case 32: 21707ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext32u_i64) { 21717ec8bab3SRichard Henderson tcg_gen_ext32u_i64(ret, arg); 21727ec8bab3SRichard Henderson tcg_gen_shri_i64(ret, ret, ofs); 21737ec8bab3SRichard Henderson return; 21747ec8bab3SRichard Henderson } 21757ec8bab3SRichard Henderson break; 21767ec8bab3SRichard Henderson case 16: 21777ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext16u_i64) { 21787ec8bab3SRichard Henderson tcg_gen_ext16u_i64(ret, arg); 21797ec8bab3SRichard Henderson tcg_gen_shri_i64(ret, ret, ofs); 21807ec8bab3SRichard Henderson return; 21817ec8bab3SRichard Henderson } 21827ec8bab3SRichard Henderson break; 21837ec8bab3SRichard Henderson case 8: 21847ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext8u_i64) { 21857ec8bab3SRichard Henderson tcg_gen_ext8u_i64(ret, arg); 21867ec8bab3SRichard Henderson tcg_gen_shri_i64(ret, ret, ofs); 21877ec8bab3SRichard Henderson return; 21887ec8bab3SRichard Henderson } 21897ec8bab3SRichard Henderson break; 21907ec8bab3SRichard Henderson } 21917ec8bab3SRichard Henderson 21927ec8bab3SRichard Henderson /* ??? Ideally we'd know what values are available for immediate AND. 21937ec8bab3SRichard Henderson Assume that 8 bits are available, plus the special cases of 16 and 32, 21947ec8bab3SRichard Henderson so that we get ext8u, ext16u, and ext32u. */ 21957ec8bab3SRichard Henderson switch (len) { 21967ec8bab3SRichard Henderson case 1 ... 8: case 16: case 32: 21977ec8bab3SRichard Henderson do_shift_and: 21987ec8bab3SRichard Henderson tcg_gen_shri_i64(ret, arg, ofs); 21997ec8bab3SRichard Henderson tcg_gen_andi_i64(ret, ret, (1ull << len) - 1); 22007ec8bab3SRichard Henderson break; 22017ec8bab3SRichard Henderson default: 22027ec8bab3SRichard Henderson tcg_gen_shli_i64(ret, arg, 64 - len - ofs); 22037ec8bab3SRichard Henderson tcg_gen_shri_i64(ret, ret, 64 - len); 22047ec8bab3SRichard Henderson break; 22057ec8bab3SRichard Henderson } 22067ec8bab3SRichard Henderson } 22077ec8bab3SRichard Henderson 22087ec8bab3SRichard Henderson void tcg_gen_sextract_i64(TCGv_i64 ret, TCGv_i64 arg, 22097ec8bab3SRichard Henderson unsigned int ofs, unsigned int len) 22107ec8bab3SRichard Henderson { 22117ec8bab3SRichard Henderson tcg_debug_assert(ofs < 64); 22127ec8bab3SRichard Henderson tcg_debug_assert(len > 0); 22137ec8bab3SRichard Henderson tcg_debug_assert(len <= 64); 22147ec8bab3SRichard Henderson tcg_debug_assert(ofs + len <= 64); 22157ec8bab3SRichard Henderson 22167ec8bab3SRichard Henderson /* Canonicalize certain special cases, even if sextract is supported. */ 22177ec8bab3SRichard Henderson if (ofs + len == 64) { 22187ec8bab3SRichard Henderson tcg_gen_sari_i64(ret, arg, 64 - len); 22197ec8bab3SRichard Henderson return; 22207ec8bab3SRichard Henderson } 22217ec8bab3SRichard Henderson if (ofs == 0) { 22227ec8bab3SRichard Henderson switch (len) { 22237ec8bab3SRichard Henderson case 32: 22247ec8bab3SRichard Henderson tcg_gen_ext32s_i64(ret, arg); 22257ec8bab3SRichard Henderson return; 22267ec8bab3SRichard Henderson case 16: 22277ec8bab3SRichard Henderson tcg_gen_ext16s_i64(ret, arg); 22287ec8bab3SRichard Henderson return; 22297ec8bab3SRichard Henderson case 8: 22307ec8bab3SRichard Henderson tcg_gen_ext8s_i64(ret, arg); 22317ec8bab3SRichard Henderson return; 22327ec8bab3SRichard Henderson } 22337ec8bab3SRichard Henderson } 22347ec8bab3SRichard Henderson 22357ec8bab3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 22367ec8bab3SRichard Henderson /* Look for a 32-bit extract within one of the two words. */ 22377ec8bab3SRichard Henderson if (ofs >= 32) { 22387ec8bab3SRichard Henderson tcg_gen_sextract_i32(TCGV_LOW(ret), TCGV_HIGH(arg), ofs - 32, len); 22397ec8bab3SRichard Henderson } else if (ofs + len <= 32) { 22407ec8bab3SRichard Henderson tcg_gen_sextract_i32(TCGV_LOW(ret), TCGV_LOW(arg), ofs, len); 22417ec8bab3SRichard Henderson } else if (ofs == 0) { 22427ec8bab3SRichard Henderson tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg)); 22437ec8bab3SRichard Henderson tcg_gen_sextract_i32(TCGV_HIGH(ret), TCGV_HIGH(arg), 0, len - 32); 22447ec8bab3SRichard Henderson return; 22457ec8bab3SRichard Henderson } else if (len > 32) { 22467ec8bab3SRichard Henderson TCGv_i32 t = tcg_temp_new_i32(); 22477ec8bab3SRichard Henderson /* Extract the bits for the high word normally. */ 22487ec8bab3SRichard Henderson tcg_gen_sextract_i32(t, TCGV_HIGH(arg), ofs + 32, len - 32); 22497ec8bab3SRichard Henderson /* Shift the field down for the low part. */ 22507ec8bab3SRichard Henderson tcg_gen_shri_i64(ret, arg, ofs); 22517ec8bab3SRichard Henderson /* Overwrite the shift into the high part. */ 22527ec8bab3SRichard Henderson tcg_gen_mov_i32(TCGV_HIGH(ret), t); 22537ec8bab3SRichard Henderson tcg_temp_free_i32(t); 22547ec8bab3SRichard Henderson return; 22557ec8bab3SRichard Henderson } else { 22567ec8bab3SRichard Henderson /* Shift the field down for the low part, such that the 22577ec8bab3SRichard Henderson field sits at the MSB. */ 22587ec8bab3SRichard Henderson tcg_gen_shri_i64(ret, arg, ofs + len - 32); 22597ec8bab3SRichard Henderson /* Shift the field down from the MSB, sign extending. */ 22607ec8bab3SRichard Henderson tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_LOW(ret), 32 - len); 22617ec8bab3SRichard Henderson } 22627ec8bab3SRichard Henderson /* Sign-extend the field from 32 bits. */ 22637ec8bab3SRichard Henderson tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31); 22647ec8bab3SRichard Henderson return; 22657ec8bab3SRichard Henderson } 22667ec8bab3SRichard Henderson 22677ec8bab3SRichard Henderson if (TCG_TARGET_HAS_sextract_i64 22687ec8bab3SRichard Henderson && TCG_TARGET_extract_i64_valid(ofs, len)) { 22697ec8bab3SRichard Henderson tcg_gen_op4ii_i64(INDEX_op_sextract_i64, ret, arg, ofs, len); 22707ec8bab3SRichard Henderson return; 22717ec8bab3SRichard Henderson } 22727ec8bab3SRichard Henderson 22737ec8bab3SRichard Henderson /* Assume that sign-extension, if available, is cheaper than a shift. */ 22747ec8bab3SRichard Henderson switch (ofs + len) { 22757ec8bab3SRichard Henderson case 32: 22767ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext32s_i64) { 22777ec8bab3SRichard Henderson tcg_gen_ext32s_i64(ret, arg); 22787ec8bab3SRichard Henderson tcg_gen_sari_i64(ret, ret, ofs); 22797ec8bab3SRichard Henderson return; 22807ec8bab3SRichard Henderson } 22817ec8bab3SRichard Henderson break; 22827ec8bab3SRichard Henderson case 16: 22837ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext16s_i64) { 22847ec8bab3SRichard Henderson tcg_gen_ext16s_i64(ret, arg); 22857ec8bab3SRichard Henderson tcg_gen_sari_i64(ret, ret, ofs); 22867ec8bab3SRichard Henderson return; 22877ec8bab3SRichard Henderson } 22887ec8bab3SRichard Henderson break; 22897ec8bab3SRichard Henderson case 8: 22907ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext8s_i64) { 22917ec8bab3SRichard Henderson tcg_gen_ext8s_i64(ret, arg); 22927ec8bab3SRichard Henderson tcg_gen_sari_i64(ret, ret, ofs); 22937ec8bab3SRichard Henderson return; 22947ec8bab3SRichard Henderson } 22957ec8bab3SRichard Henderson break; 22967ec8bab3SRichard Henderson } 22977ec8bab3SRichard Henderson switch (len) { 22987ec8bab3SRichard Henderson case 32: 22997ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext32s_i64) { 23007ec8bab3SRichard Henderson tcg_gen_shri_i64(ret, arg, ofs); 23017ec8bab3SRichard Henderson tcg_gen_ext32s_i64(ret, ret); 23027ec8bab3SRichard Henderson return; 23037ec8bab3SRichard Henderson } 23047ec8bab3SRichard Henderson break; 23057ec8bab3SRichard Henderson case 16: 23067ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext16s_i64) { 23077ec8bab3SRichard Henderson tcg_gen_shri_i64(ret, arg, ofs); 23087ec8bab3SRichard Henderson tcg_gen_ext16s_i64(ret, ret); 23097ec8bab3SRichard Henderson return; 23107ec8bab3SRichard Henderson } 23117ec8bab3SRichard Henderson break; 23127ec8bab3SRichard Henderson case 8: 23137ec8bab3SRichard Henderson if (TCG_TARGET_HAS_ext8s_i64) { 23147ec8bab3SRichard Henderson tcg_gen_shri_i64(ret, arg, ofs); 23157ec8bab3SRichard Henderson tcg_gen_ext8s_i64(ret, ret); 23167ec8bab3SRichard Henderson return; 23177ec8bab3SRichard Henderson } 23187ec8bab3SRichard Henderson break; 23197ec8bab3SRichard Henderson } 23207ec8bab3SRichard Henderson tcg_gen_shli_i64(ret, arg, 64 - len - ofs); 23217ec8bab3SRichard Henderson tcg_gen_sari_i64(ret, ret, 64 - len); 23227ec8bab3SRichard Henderson } 23237ec8bab3SRichard Henderson 23242089fcc9SDavid Hildenbrand /* 23252089fcc9SDavid Hildenbrand * Extract 64 bits from a 128-bit input, ah:al, starting from ofs. 23262089fcc9SDavid Hildenbrand * Unlike tcg_gen_extract_i64 above, len is fixed at 64. 23272089fcc9SDavid Hildenbrand */ 23282089fcc9SDavid Hildenbrand void tcg_gen_extract2_i64(TCGv_i64 ret, TCGv_i64 al, TCGv_i64 ah, 23292089fcc9SDavid Hildenbrand unsigned int ofs) 23302089fcc9SDavid Hildenbrand { 23312089fcc9SDavid Hildenbrand tcg_debug_assert(ofs <= 64); 23322089fcc9SDavid Hildenbrand if (ofs == 0) { 23332089fcc9SDavid Hildenbrand tcg_gen_mov_i64(ret, al); 23342089fcc9SDavid Hildenbrand } else if (ofs == 64) { 23352089fcc9SDavid Hildenbrand tcg_gen_mov_i64(ret, ah); 23362089fcc9SDavid Hildenbrand } else if (al == ah) { 23372089fcc9SDavid Hildenbrand tcg_gen_rotri_i64(ret, al, ofs); 2338*fce1296fSRichard Henderson } else if (TCG_TARGET_HAS_extract2_i64) { 2339*fce1296fSRichard Henderson tcg_gen_op4i_i64(INDEX_op_extract2_i64, ret, al, ah, ofs); 23402089fcc9SDavid Hildenbrand } else { 23412089fcc9SDavid Hildenbrand TCGv_i64 t0 = tcg_temp_new_i64(); 23422089fcc9SDavid Hildenbrand tcg_gen_shri_i64(t0, al, ofs); 23432089fcc9SDavid Hildenbrand tcg_gen_deposit_i64(ret, t0, ah, 64 - ofs, ofs); 23442089fcc9SDavid Hildenbrand tcg_temp_free_i64(t0); 23452089fcc9SDavid Hildenbrand } 23462089fcc9SDavid Hildenbrand } 23472089fcc9SDavid Hildenbrand 2348951c6300SRichard Henderson void tcg_gen_movcond_i64(TCGCond cond, TCGv_i64 ret, TCGv_i64 c1, 2349951c6300SRichard Henderson TCGv_i64 c2, TCGv_i64 v1, TCGv_i64 v2) 2350951c6300SRichard Henderson { 235137ed3bf1SRichard Henderson if (cond == TCG_COND_ALWAYS) { 235237ed3bf1SRichard Henderson tcg_gen_mov_i64(ret, v1); 235337ed3bf1SRichard Henderson } else if (cond == TCG_COND_NEVER) { 235437ed3bf1SRichard Henderson tcg_gen_mov_i64(ret, v2); 235537ed3bf1SRichard Henderson } else if (TCG_TARGET_REG_BITS == 32) { 2356951c6300SRichard Henderson TCGv_i32 t0 = tcg_temp_new_i32(); 2357951c6300SRichard Henderson TCGv_i32 t1 = tcg_temp_new_i32(); 2358951c6300SRichard Henderson tcg_gen_op6i_i32(INDEX_op_setcond2_i32, t0, 2359951c6300SRichard Henderson TCGV_LOW(c1), TCGV_HIGH(c1), 2360951c6300SRichard Henderson TCGV_LOW(c2), TCGV_HIGH(c2), cond); 2361951c6300SRichard Henderson 2362951c6300SRichard Henderson if (TCG_TARGET_HAS_movcond_i32) { 2363951c6300SRichard Henderson tcg_gen_movi_i32(t1, 0); 2364951c6300SRichard Henderson tcg_gen_movcond_i32(TCG_COND_NE, TCGV_LOW(ret), t0, t1, 2365951c6300SRichard Henderson TCGV_LOW(v1), TCGV_LOW(v2)); 2366951c6300SRichard Henderson tcg_gen_movcond_i32(TCG_COND_NE, TCGV_HIGH(ret), t0, t1, 2367951c6300SRichard Henderson TCGV_HIGH(v1), TCGV_HIGH(v2)); 2368951c6300SRichard Henderson } else { 2369951c6300SRichard Henderson tcg_gen_neg_i32(t0, t0); 2370951c6300SRichard Henderson 2371951c6300SRichard Henderson tcg_gen_and_i32(t1, TCGV_LOW(v1), t0); 2372951c6300SRichard Henderson tcg_gen_andc_i32(TCGV_LOW(ret), TCGV_LOW(v2), t0); 2373951c6300SRichard Henderson tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t1); 2374951c6300SRichard Henderson 2375951c6300SRichard Henderson tcg_gen_and_i32(t1, TCGV_HIGH(v1), t0); 2376951c6300SRichard Henderson tcg_gen_andc_i32(TCGV_HIGH(ret), TCGV_HIGH(v2), t0); 2377951c6300SRichard Henderson tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t1); 2378951c6300SRichard Henderson } 2379951c6300SRichard Henderson tcg_temp_free_i32(t0); 2380951c6300SRichard Henderson tcg_temp_free_i32(t1); 23813a13c3f3SRichard Henderson } else if (TCG_TARGET_HAS_movcond_i64) { 2382951c6300SRichard Henderson tcg_gen_op6i_i64(INDEX_op_movcond_i64, ret, c1, c2, v1, v2, cond); 2383951c6300SRichard Henderson } else { 2384951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 2385951c6300SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 2386951c6300SRichard Henderson tcg_gen_setcond_i64(cond, t0, c1, c2); 2387951c6300SRichard Henderson tcg_gen_neg_i64(t0, t0); 2388951c6300SRichard Henderson tcg_gen_and_i64(t1, v1, t0); 2389951c6300SRichard Henderson tcg_gen_andc_i64(ret, v2, t0); 2390951c6300SRichard Henderson tcg_gen_or_i64(ret, ret, t1); 2391951c6300SRichard Henderson tcg_temp_free_i64(t0); 2392951c6300SRichard Henderson tcg_temp_free_i64(t1); 2393951c6300SRichard Henderson } 2394951c6300SRichard Henderson } 2395951c6300SRichard Henderson 2396951c6300SRichard Henderson void tcg_gen_add2_i64(TCGv_i64 rl, TCGv_i64 rh, TCGv_i64 al, 2397951c6300SRichard Henderson TCGv_i64 ah, TCGv_i64 bl, TCGv_i64 bh) 2398951c6300SRichard Henderson { 2399951c6300SRichard Henderson if (TCG_TARGET_HAS_add2_i64) { 2400951c6300SRichard Henderson tcg_gen_op6_i64(INDEX_op_add2_i64, rl, rh, al, ah, bl, bh); 2401951c6300SRichard Henderson } else { 2402951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 2403951c6300SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 2404951c6300SRichard Henderson tcg_gen_add_i64(t0, al, bl); 2405951c6300SRichard Henderson tcg_gen_setcond_i64(TCG_COND_LTU, t1, t0, al); 2406951c6300SRichard Henderson tcg_gen_add_i64(rh, ah, bh); 2407951c6300SRichard Henderson tcg_gen_add_i64(rh, rh, t1); 2408951c6300SRichard Henderson tcg_gen_mov_i64(rl, t0); 2409951c6300SRichard Henderson tcg_temp_free_i64(t0); 2410951c6300SRichard Henderson tcg_temp_free_i64(t1); 2411951c6300SRichard Henderson } 2412951c6300SRichard Henderson } 2413951c6300SRichard Henderson 2414951c6300SRichard Henderson void tcg_gen_sub2_i64(TCGv_i64 rl, TCGv_i64 rh, TCGv_i64 al, 2415951c6300SRichard Henderson TCGv_i64 ah, TCGv_i64 bl, TCGv_i64 bh) 2416951c6300SRichard Henderson { 2417951c6300SRichard Henderson if (TCG_TARGET_HAS_sub2_i64) { 2418951c6300SRichard Henderson tcg_gen_op6_i64(INDEX_op_sub2_i64, rl, rh, al, ah, bl, bh); 2419951c6300SRichard Henderson } else { 2420951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 2421951c6300SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 2422951c6300SRichard Henderson tcg_gen_sub_i64(t0, al, bl); 2423951c6300SRichard Henderson tcg_gen_setcond_i64(TCG_COND_LTU, t1, al, bl); 2424951c6300SRichard Henderson tcg_gen_sub_i64(rh, ah, bh); 2425951c6300SRichard Henderson tcg_gen_sub_i64(rh, rh, t1); 2426951c6300SRichard Henderson tcg_gen_mov_i64(rl, t0); 2427951c6300SRichard Henderson tcg_temp_free_i64(t0); 2428951c6300SRichard Henderson tcg_temp_free_i64(t1); 2429951c6300SRichard Henderson } 2430951c6300SRichard Henderson } 2431951c6300SRichard Henderson 2432951c6300SRichard Henderson void tcg_gen_mulu2_i64(TCGv_i64 rl, TCGv_i64 rh, TCGv_i64 arg1, TCGv_i64 arg2) 2433951c6300SRichard Henderson { 2434951c6300SRichard Henderson if (TCG_TARGET_HAS_mulu2_i64) { 2435951c6300SRichard Henderson tcg_gen_op4_i64(INDEX_op_mulu2_i64, rl, rh, arg1, arg2); 2436951c6300SRichard Henderson } else if (TCG_TARGET_HAS_muluh_i64) { 2437951c6300SRichard Henderson TCGv_i64 t = tcg_temp_new_i64(); 2438951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_mul_i64, t, arg1, arg2); 2439951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_muluh_i64, rh, arg1, arg2); 2440951c6300SRichard Henderson tcg_gen_mov_i64(rl, t); 2441951c6300SRichard Henderson tcg_temp_free_i64(t); 2442951c6300SRichard Henderson } else { 2443951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 2444951c6300SRichard Henderson tcg_gen_mul_i64(t0, arg1, arg2); 2445951c6300SRichard Henderson gen_helper_muluh_i64(rh, arg1, arg2); 2446951c6300SRichard Henderson tcg_gen_mov_i64(rl, t0); 2447951c6300SRichard Henderson tcg_temp_free_i64(t0); 2448951c6300SRichard Henderson } 2449951c6300SRichard Henderson } 2450951c6300SRichard Henderson 2451951c6300SRichard Henderson void tcg_gen_muls2_i64(TCGv_i64 rl, TCGv_i64 rh, TCGv_i64 arg1, TCGv_i64 arg2) 2452951c6300SRichard Henderson { 2453951c6300SRichard Henderson if (TCG_TARGET_HAS_muls2_i64) { 2454951c6300SRichard Henderson tcg_gen_op4_i64(INDEX_op_muls2_i64, rl, rh, arg1, arg2); 2455951c6300SRichard Henderson } else if (TCG_TARGET_HAS_mulsh_i64) { 2456951c6300SRichard Henderson TCGv_i64 t = tcg_temp_new_i64(); 2457951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_mul_i64, t, arg1, arg2); 2458951c6300SRichard Henderson tcg_gen_op3_i64(INDEX_op_mulsh_i64, rh, arg1, arg2); 2459951c6300SRichard Henderson tcg_gen_mov_i64(rl, t); 2460951c6300SRichard Henderson tcg_temp_free_i64(t); 2461951c6300SRichard Henderson } else if (TCG_TARGET_HAS_mulu2_i64 || TCG_TARGET_HAS_muluh_i64) { 2462951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 2463951c6300SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 2464951c6300SRichard Henderson TCGv_i64 t2 = tcg_temp_new_i64(); 2465951c6300SRichard Henderson TCGv_i64 t3 = tcg_temp_new_i64(); 2466951c6300SRichard Henderson tcg_gen_mulu2_i64(t0, t1, arg1, arg2); 2467951c6300SRichard Henderson /* Adjust for negative inputs. */ 2468951c6300SRichard Henderson tcg_gen_sari_i64(t2, arg1, 63); 2469951c6300SRichard Henderson tcg_gen_sari_i64(t3, arg2, 63); 2470951c6300SRichard Henderson tcg_gen_and_i64(t2, t2, arg2); 2471951c6300SRichard Henderson tcg_gen_and_i64(t3, t3, arg1); 2472951c6300SRichard Henderson tcg_gen_sub_i64(rh, t1, t2); 2473951c6300SRichard Henderson tcg_gen_sub_i64(rh, rh, t3); 2474951c6300SRichard Henderson tcg_gen_mov_i64(rl, t0); 2475951c6300SRichard Henderson tcg_temp_free_i64(t0); 2476951c6300SRichard Henderson tcg_temp_free_i64(t1); 2477951c6300SRichard Henderson tcg_temp_free_i64(t2); 2478951c6300SRichard Henderson tcg_temp_free_i64(t3); 2479951c6300SRichard Henderson } else { 2480951c6300SRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 2481951c6300SRichard Henderson tcg_gen_mul_i64(t0, arg1, arg2); 2482951c6300SRichard Henderson gen_helper_mulsh_i64(rh, arg1, arg2); 2483951c6300SRichard Henderson tcg_gen_mov_i64(rl, t0); 2484951c6300SRichard Henderson tcg_temp_free_i64(t0); 2485951c6300SRichard Henderson } 2486951c6300SRichard Henderson } 2487951c6300SRichard Henderson 24885087abfbSRichard Henderson void tcg_gen_mulsu2_i64(TCGv_i64 rl, TCGv_i64 rh, TCGv_i64 arg1, TCGv_i64 arg2) 24895087abfbSRichard Henderson { 24905087abfbSRichard Henderson TCGv_i64 t0 = tcg_temp_new_i64(); 24915087abfbSRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 24925087abfbSRichard Henderson TCGv_i64 t2 = tcg_temp_new_i64(); 24935087abfbSRichard Henderson tcg_gen_mulu2_i64(t0, t1, arg1, arg2); 24945087abfbSRichard Henderson /* Adjust for negative input for the signed arg1. */ 24955087abfbSRichard Henderson tcg_gen_sari_i64(t2, arg1, 63); 24965087abfbSRichard Henderson tcg_gen_and_i64(t2, t2, arg2); 24975087abfbSRichard Henderson tcg_gen_sub_i64(rh, t1, t2); 24985087abfbSRichard Henderson tcg_gen_mov_i64(rl, t0); 24995087abfbSRichard Henderson tcg_temp_free_i64(t0); 25005087abfbSRichard Henderson tcg_temp_free_i64(t1); 25015087abfbSRichard Henderson tcg_temp_free_i64(t2); 25025087abfbSRichard Henderson } 25035087abfbSRichard Henderson 2504b87fb8cdSRichard Henderson void tcg_gen_smin_i64(TCGv_i64 ret, TCGv_i64 a, TCGv_i64 b) 2505b87fb8cdSRichard Henderson { 2506b87fb8cdSRichard Henderson tcg_gen_movcond_i64(TCG_COND_LT, ret, a, b, a, b); 2507b87fb8cdSRichard Henderson } 2508b87fb8cdSRichard Henderson 2509b87fb8cdSRichard Henderson void tcg_gen_umin_i64(TCGv_i64 ret, TCGv_i64 a, TCGv_i64 b) 2510b87fb8cdSRichard Henderson { 2511b87fb8cdSRichard Henderson tcg_gen_movcond_i64(TCG_COND_LTU, ret, a, b, a, b); 2512b87fb8cdSRichard Henderson } 2513b87fb8cdSRichard Henderson 2514b87fb8cdSRichard Henderson void tcg_gen_smax_i64(TCGv_i64 ret, TCGv_i64 a, TCGv_i64 b) 2515b87fb8cdSRichard Henderson { 2516b87fb8cdSRichard Henderson tcg_gen_movcond_i64(TCG_COND_LT, ret, a, b, b, a); 2517b87fb8cdSRichard Henderson } 2518b87fb8cdSRichard Henderson 2519b87fb8cdSRichard Henderson void tcg_gen_umax_i64(TCGv_i64 ret, TCGv_i64 a, TCGv_i64 b) 2520b87fb8cdSRichard Henderson { 2521b87fb8cdSRichard Henderson tcg_gen_movcond_i64(TCG_COND_LTU, ret, a, b, b, a); 2522b87fb8cdSRichard Henderson } 2523b87fb8cdSRichard Henderson 2524951c6300SRichard Henderson /* Size changing operations. */ 2525951c6300SRichard Henderson 2526609ad705SRichard Henderson void tcg_gen_extrl_i64_i32(TCGv_i32 ret, TCGv_i64 arg) 2527951c6300SRichard Henderson { 25283a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 2529951c6300SRichard Henderson tcg_gen_mov_i32(ret, TCGV_LOW(arg)); 2530609ad705SRichard Henderson } else if (TCG_TARGET_HAS_extrl_i64_i32) { 2531b7e8b17aSRichard Henderson tcg_gen_op2(INDEX_op_extrl_i64_i32, 2532ae8b75dcSRichard Henderson tcgv_i32_arg(ret), tcgv_i64_arg(arg)); 2533951c6300SRichard Henderson } else { 2534dc41aa7dSRichard Henderson tcg_gen_mov_i32(ret, (TCGv_i32)arg); 2535609ad705SRichard Henderson } 2536609ad705SRichard Henderson } 2537609ad705SRichard Henderson 2538609ad705SRichard Henderson void tcg_gen_extrh_i64_i32(TCGv_i32 ret, TCGv_i64 arg) 2539609ad705SRichard Henderson { 2540609ad705SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 2541609ad705SRichard Henderson tcg_gen_mov_i32(ret, TCGV_HIGH(arg)); 2542609ad705SRichard Henderson } else if (TCG_TARGET_HAS_extrh_i64_i32) { 2543b7e8b17aSRichard Henderson tcg_gen_op2(INDEX_op_extrh_i64_i32, 2544ae8b75dcSRichard Henderson tcgv_i32_arg(ret), tcgv_i64_arg(arg)); 2545951c6300SRichard Henderson } else { 2546951c6300SRichard Henderson TCGv_i64 t = tcg_temp_new_i64(); 2547609ad705SRichard Henderson tcg_gen_shri_i64(t, arg, 32); 2548dc41aa7dSRichard Henderson tcg_gen_mov_i32(ret, (TCGv_i32)t); 2549951c6300SRichard Henderson tcg_temp_free_i64(t); 2550951c6300SRichard Henderson } 2551951c6300SRichard Henderson } 2552951c6300SRichard Henderson 2553951c6300SRichard Henderson void tcg_gen_extu_i32_i64(TCGv_i64 ret, TCGv_i32 arg) 2554951c6300SRichard Henderson { 25553a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 2556951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_LOW(ret), arg); 2557951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 25583a13c3f3SRichard Henderson } else { 2559b7e8b17aSRichard Henderson tcg_gen_op2(INDEX_op_extu_i32_i64, 2560ae8b75dcSRichard Henderson tcgv_i64_arg(ret), tcgv_i32_arg(arg)); 25613a13c3f3SRichard Henderson } 2562951c6300SRichard Henderson } 2563951c6300SRichard Henderson 2564951c6300SRichard Henderson void tcg_gen_ext_i32_i64(TCGv_i64 ret, TCGv_i32 arg) 2565951c6300SRichard Henderson { 25663a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 2567951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_LOW(ret), arg); 2568951c6300SRichard Henderson tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31); 25693a13c3f3SRichard Henderson } else { 2570b7e8b17aSRichard Henderson tcg_gen_op2(INDEX_op_ext_i32_i64, 2571ae8b75dcSRichard Henderson tcgv_i64_arg(ret), tcgv_i32_arg(arg)); 25723a13c3f3SRichard Henderson } 2573951c6300SRichard Henderson } 2574951c6300SRichard Henderson 2575951c6300SRichard Henderson void tcg_gen_concat_i32_i64(TCGv_i64 dest, TCGv_i32 low, TCGv_i32 high) 2576951c6300SRichard Henderson { 25773a13c3f3SRichard Henderson TCGv_i64 tmp; 25783a13c3f3SRichard Henderson 25793a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 2580951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_LOW(dest), low); 2581951c6300SRichard Henderson tcg_gen_mov_i32(TCGV_HIGH(dest), high); 25823a13c3f3SRichard Henderson return; 25833a13c3f3SRichard Henderson } 25843a13c3f3SRichard Henderson 25853a13c3f3SRichard Henderson tmp = tcg_temp_new_i64(); 2586951c6300SRichard Henderson /* These extensions are only needed for type correctness. 2587951c6300SRichard Henderson We may be able to do better given target specific information. */ 2588951c6300SRichard Henderson tcg_gen_extu_i32_i64(tmp, high); 2589951c6300SRichard Henderson tcg_gen_extu_i32_i64(dest, low); 2590951c6300SRichard Henderson /* If deposit is available, use it. Otherwise use the extra 2591951c6300SRichard Henderson knowledge that we have of the zero-extensions above. */ 2592951c6300SRichard Henderson if (TCG_TARGET_HAS_deposit_i64 && TCG_TARGET_deposit_i64_valid(32, 32)) { 2593951c6300SRichard Henderson tcg_gen_deposit_i64(dest, dest, tmp, 32, 32); 2594951c6300SRichard Henderson } else { 2595951c6300SRichard Henderson tcg_gen_shli_i64(tmp, tmp, 32); 2596951c6300SRichard Henderson tcg_gen_or_i64(dest, dest, tmp); 2597951c6300SRichard Henderson } 2598951c6300SRichard Henderson tcg_temp_free_i64(tmp); 2599951c6300SRichard Henderson } 2600951c6300SRichard Henderson 2601951c6300SRichard Henderson void tcg_gen_extr_i64_i32(TCGv_i32 lo, TCGv_i32 hi, TCGv_i64 arg) 2602951c6300SRichard Henderson { 26033a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 2604951c6300SRichard Henderson tcg_gen_mov_i32(lo, TCGV_LOW(arg)); 2605951c6300SRichard Henderson tcg_gen_mov_i32(hi, TCGV_HIGH(arg)); 26063a13c3f3SRichard Henderson } else { 2607609ad705SRichard Henderson tcg_gen_extrl_i64_i32(lo, arg); 2608609ad705SRichard Henderson tcg_gen_extrh_i64_i32(hi, arg); 26093a13c3f3SRichard Henderson } 2610951c6300SRichard Henderson } 2611951c6300SRichard Henderson 2612951c6300SRichard Henderson void tcg_gen_extr32_i64(TCGv_i64 lo, TCGv_i64 hi, TCGv_i64 arg) 2613951c6300SRichard Henderson { 2614951c6300SRichard Henderson tcg_gen_ext32u_i64(lo, arg); 2615951c6300SRichard Henderson tcg_gen_shri_i64(hi, arg, 32); 2616951c6300SRichard Henderson } 2617951c6300SRichard Henderson 2618951c6300SRichard Henderson /* QEMU specific operations. */ 2619951c6300SRichard Henderson 262007ea28b4SRichard Henderson void tcg_gen_exit_tb(TranslationBlock *tb, unsigned idx) 262107ea28b4SRichard Henderson { 262207ea28b4SRichard Henderson uintptr_t val = (uintptr_t)tb + idx; 262307ea28b4SRichard Henderson 262407ea28b4SRichard Henderson if (tb == NULL) { 262507ea28b4SRichard Henderson tcg_debug_assert(idx == 0); 262607ea28b4SRichard Henderson } else if (idx <= TB_EXIT_IDXMAX) { 262707ea28b4SRichard Henderson #ifdef CONFIG_DEBUG_TCG 262807ea28b4SRichard Henderson /* This is an exit following a goto_tb. Verify that we have 262907ea28b4SRichard Henderson seen this numbered exit before, via tcg_gen_goto_tb. */ 263007ea28b4SRichard Henderson tcg_debug_assert(tcg_ctx->goto_tb_issue_mask & (1 << idx)); 263107ea28b4SRichard Henderson #endif 2632d7f425fdSRichard Henderson /* When not chaining, exit without indicating a link. */ 2633d7f425fdSRichard Henderson if (qemu_loglevel_mask(CPU_LOG_TB_NOCHAIN)) { 2634d7f425fdSRichard Henderson val = 0; 2635d7f425fdSRichard Henderson } 263607ea28b4SRichard Henderson } else { 263707ea28b4SRichard Henderson /* This is an exit via the exitreq label. */ 263807ea28b4SRichard Henderson tcg_debug_assert(idx == TB_EXIT_REQUESTED); 263907ea28b4SRichard Henderson } 264007ea28b4SRichard Henderson 264107ea28b4SRichard Henderson tcg_gen_op1i(INDEX_op_exit_tb, val); 264207ea28b4SRichard Henderson } 264307ea28b4SRichard Henderson 2644951c6300SRichard Henderson void tcg_gen_goto_tb(unsigned idx) 2645951c6300SRichard Henderson { 2646951c6300SRichard Henderson /* We only support two chained exits. */ 264707ea28b4SRichard Henderson tcg_debug_assert(idx <= TB_EXIT_IDXMAX); 2648951c6300SRichard Henderson #ifdef CONFIG_DEBUG_TCG 2649951c6300SRichard Henderson /* Verify that we havn't seen this numbered exit before. */ 2650b1311c4aSEmilio G. Cota tcg_debug_assert((tcg_ctx->goto_tb_issue_mask & (1 << idx)) == 0); 2651b1311c4aSEmilio G. Cota tcg_ctx->goto_tb_issue_mask |= 1 << idx; 2652951c6300SRichard Henderson #endif 2653d7f425fdSRichard Henderson /* When not chaining, we simply fall through to the "fallback" exit. */ 2654d7f425fdSRichard Henderson if (!qemu_loglevel_mask(CPU_LOG_TB_NOCHAIN)) { 2655951c6300SRichard Henderson tcg_gen_op1i(INDEX_op_goto_tb, idx); 2656951c6300SRichard Henderson } 2657d7f425fdSRichard Henderson } 2658951c6300SRichard Henderson 26597f11636dSEmilio G. Cota void tcg_gen_lookup_and_goto_ptr(void) 2660cedbcb01SEmilio G. Cota { 2661cedbcb01SEmilio G. Cota if (TCG_TARGET_HAS_goto_ptr && !qemu_loglevel_mask(CPU_LOG_TB_NOCHAIN)) { 2662cedbcb01SEmilio G. Cota TCGv_ptr ptr = tcg_temp_new_ptr(); 26631c2adb95SRichard Henderson gen_helper_lookup_tb_ptr(ptr, cpu_env); 2664ae8b75dcSRichard Henderson tcg_gen_op1i(INDEX_op_goto_ptr, tcgv_ptr_arg(ptr)); 2665cedbcb01SEmilio G. Cota tcg_temp_free_ptr(ptr); 2666cedbcb01SEmilio G. Cota } else { 266707ea28b4SRichard Henderson tcg_gen_exit_tb(NULL, 0); 2668cedbcb01SEmilio G. Cota } 2669cedbcb01SEmilio G. Cota } 2670cedbcb01SEmilio G. Cota 2671951c6300SRichard Henderson static inline TCGMemOp tcg_canonicalize_memop(TCGMemOp op, bool is64, bool st) 2672951c6300SRichard Henderson { 26731f00b27fSSergey Sorokin /* Trigger the asserts within as early as possible. */ 26741f00b27fSSergey Sorokin (void)get_alignment_bits(op); 26751f00b27fSSergey Sorokin 2676951c6300SRichard Henderson switch (op & MO_SIZE) { 2677951c6300SRichard Henderson case MO_8: 2678951c6300SRichard Henderson op &= ~MO_BSWAP; 2679951c6300SRichard Henderson break; 2680951c6300SRichard Henderson case MO_16: 2681951c6300SRichard Henderson break; 2682951c6300SRichard Henderson case MO_32: 2683951c6300SRichard Henderson if (!is64) { 2684951c6300SRichard Henderson op &= ~MO_SIGN; 2685951c6300SRichard Henderson } 2686951c6300SRichard Henderson break; 2687951c6300SRichard Henderson case MO_64: 2688951c6300SRichard Henderson if (!is64) { 2689951c6300SRichard Henderson tcg_abort(); 2690951c6300SRichard Henderson } 2691951c6300SRichard Henderson break; 2692951c6300SRichard Henderson } 2693951c6300SRichard Henderson if (st) { 2694951c6300SRichard Henderson op &= ~MO_SIGN; 2695951c6300SRichard Henderson } 2696951c6300SRichard Henderson return op; 2697951c6300SRichard Henderson } 2698951c6300SRichard Henderson 2699c45cb8bbSRichard Henderson static void gen_ldst_i32(TCGOpcode opc, TCGv_i32 val, TCGv addr, 2700c45cb8bbSRichard Henderson TCGMemOp memop, TCGArg idx) 2701951c6300SRichard Henderson { 270259227d5dSRichard Henderson TCGMemOpIdx oi = make_memop_idx(memop, idx); 2703951c6300SRichard Henderson #if TARGET_LONG_BITS == 32 270459227d5dSRichard Henderson tcg_gen_op3i_i32(opc, val, addr, oi); 2705951c6300SRichard Henderson #else 2706c45cb8bbSRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 270759227d5dSRichard Henderson tcg_gen_op4i_i32(opc, val, TCGV_LOW(addr), TCGV_HIGH(addr), oi); 2708c45cb8bbSRichard Henderson } else { 2709ae8b75dcSRichard Henderson tcg_gen_op3(opc, tcgv_i32_arg(val), tcgv_i64_arg(addr), oi); 2710c45cb8bbSRichard Henderson } 2711951c6300SRichard Henderson #endif 2712c45cb8bbSRichard Henderson } 2713c45cb8bbSRichard Henderson 2714c45cb8bbSRichard Henderson static void gen_ldst_i64(TCGOpcode opc, TCGv_i64 val, TCGv addr, 2715c45cb8bbSRichard Henderson TCGMemOp memop, TCGArg idx) 2716c45cb8bbSRichard Henderson { 271759227d5dSRichard Henderson TCGMemOpIdx oi = make_memop_idx(memop, idx); 2718c45cb8bbSRichard Henderson #if TARGET_LONG_BITS == 32 2719c45cb8bbSRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 272059227d5dSRichard Henderson tcg_gen_op4i_i32(opc, TCGV_LOW(val), TCGV_HIGH(val), addr, oi); 2721c45cb8bbSRichard Henderson } else { 2722ae8b75dcSRichard Henderson tcg_gen_op3(opc, tcgv_i64_arg(val), tcgv_i32_arg(addr), oi); 2723c45cb8bbSRichard Henderson } 2724c45cb8bbSRichard Henderson #else 2725c45cb8bbSRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 272659227d5dSRichard Henderson tcg_gen_op5i_i32(opc, TCGV_LOW(val), TCGV_HIGH(val), 272759227d5dSRichard Henderson TCGV_LOW(addr), TCGV_HIGH(addr), oi); 2728c45cb8bbSRichard Henderson } else { 272959227d5dSRichard Henderson tcg_gen_op3i_i64(opc, val, addr, oi); 2730c45cb8bbSRichard Henderson } 2731c45cb8bbSRichard Henderson #endif 2732c45cb8bbSRichard Henderson } 2733951c6300SRichard Henderson 2734b32dc337SPranith Kumar static void tcg_gen_req_mo(TCGBar type) 2735b32dc337SPranith Kumar { 2736b32dc337SPranith Kumar #ifdef TCG_GUEST_DEFAULT_MO 2737b32dc337SPranith Kumar type &= TCG_GUEST_DEFAULT_MO; 2738b32dc337SPranith Kumar #endif 2739b32dc337SPranith Kumar type &= ~TCG_TARGET_DEFAULT_MO; 2740b32dc337SPranith Kumar if (type) { 2741b32dc337SPranith Kumar tcg_gen_mb(type | TCG_BAR_SC); 2742b32dc337SPranith Kumar } 2743b32dc337SPranith Kumar } 2744b32dc337SPranith Kumar 2745951c6300SRichard Henderson void tcg_gen_qemu_ld_i32(TCGv_i32 val, TCGv addr, TCGArg idx, TCGMemOp memop) 2746951c6300SRichard Henderson { 2747e1dcf352SRichard Henderson TCGMemOp orig_memop; 2748e1dcf352SRichard Henderson 2749b32dc337SPranith Kumar tcg_gen_req_mo(TCG_MO_LD_LD | TCG_MO_ST_LD); 2750951c6300SRichard Henderson memop = tcg_canonicalize_memop(memop, 0, 0); 27511c2adb95SRichard Henderson trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, 2752dcdaadb6SLluís Vilanova addr, trace_mem_get_info(memop, 0)); 2753e1dcf352SRichard Henderson 2754e1dcf352SRichard Henderson orig_memop = memop; 2755e1dcf352SRichard Henderson if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) { 2756e1dcf352SRichard Henderson memop &= ~MO_BSWAP; 2757e1dcf352SRichard Henderson /* The bswap primitive requires zero-extended input. */ 2758e1dcf352SRichard Henderson if ((memop & MO_SSIZE) == MO_SW) { 2759e1dcf352SRichard Henderson memop &= ~MO_SIGN; 2760e1dcf352SRichard Henderson } 2761e1dcf352SRichard Henderson } 2762e1dcf352SRichard Henderson 2763c45cb8bbSRichard Henderson gen_ldst_i32(INDEX_op_qemu_ld_i32, val, addr, memop, idx); 2764e1dcf352SRichard Henderson 2765e1dcf352SRichard Henderson if ((orig_memop ^ memop) & MO_BSWAP) { 2766e1dcf352SRichard Henderson switch (orig_memop & MO_SIZE) { 2767e1dcf352SRichard Henderson case MO_16: 2768e1dcf352SRichard Henderson tcg_gen_bswap16_i32(val, val); 2769e1dcf352SRichard Henderson if (orig_memop & MO_SIGN) { 2770e1dcf352SRichard Henderson tcg_gen_ext16s_i32(val, val); 2771e1dcf352SRichard Henderson } 2772e1dcf352SRichard Henderson break; 2773e1dcf352SRichard Henderson case MO_32: 2774e1dcf352SRichard Henderson tcg_gen_bswap32_i32(val, val); 2775e1dcf352SRichard Henderson break; 2776e1dcf352SRichard Henderson default: 2777e1dcf352SRichard Henderson g_assert_not_reached(); 2778e1dcf352SRichard Henderson } 2779e1dcf352SRichard Henderson } 2780951c6300SRichard Henderson } 2781951c6300SRichard Henderson 2782951c6300SRichard Henderson void tcg_gen_qemu_st_i32(TCGv_i32 val, TCGv addr, TCGArg idx, TCGMemOp memop) 2783951c6300SRichard Henderson { 2784e1dcf352SRichard Henderson TCGv_i32 swap = NULL; 2785e1dcf352SRichard Henderson 2786b32dc337SPranith Kumar tcg_gen_req_mo(TCG_MO_LD_ST | TCG_MO_ST_ST); 2787951c6300SRichard Henderson memop = tcg_canonicalize_memop(memop, 0, 1); 27881c2adb95SRichard Henderson trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, 2789dcdaadb6SLluís Vilanova addr, trace_mem_get_info(memop, 1)); 2790e1dcf352SRichard Henderson 2791e1dcf352SRichard Henderson if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) { 2792e1dcf352SRichard Henderson swap = tcg_temp_new_i32(); 2793e1dcf352SRichard Henderson switch (memop & MO_SIZE) { 2794e1dcf352SRichard Henderson case MO_16: 2795e1dcf352SRichard Henderson tcg_gen_ext16u_i32(swap, val); 2796e1dcf352SRichard Henderson tcg_gen_bswap16_i32(swap, swap); 2797e1dcf352SRichard Henderson break; 2798e1dcf352SRichard Henderson case MO_32: 2799e1dcf352SRichard Henderson tcg_gen_bswap32_i32(swap, val); 2800e1dcf352SRichard Henderson break; 2801e1dcf352SRichard Henderson default: 2802e1dcf352SRichard Henderson g_assert_not_reached(); 2803e1dcf352SRichard Henderson } 2804e1dcf352SRichard Henderson val = swap; 2805e1dcf352SRichard Henderson memop &= ~MO_BSWAP; 2806e1dcf352SRichard Henderson } 2807e1dcf352SRichard Henderson 2808c45cb8bbSRichard Henderson gen_ldst_i32(INDEX_op_qemu_st_i32, val, addr, memop, idx); 2809e1dcf352SRichard Henderson 2810e1dcf352SRichard Henderson if (swap) { 2811e1dcf352SRichard Henderson tcg_temp_free_i32(swap); 2812e1dcf352SRichard Henderson } 2813951c6300SRichard Henderson } 2814951c6300SRichard Henderson 2815951c6300SRichard Henderson void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, TCGMemOp memop) 2816951c6300SRichard Henderson { 2817e1dcf352SRichard Henderson TCGMemOp orig_memop; 2818e1dcf352SRichard Henderson 28193a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32 && (memop & MO_SIZE) < MO_64) { 2820951c6300SRichard Henderson tcg_gen_qemu_ld_i32(TCGV_LOW(val), addr, idx, memop); 2821951c6300SRichard Henderson if (memop & MO_SIGN) { 2822951c6300SRichard Henderson tcg_gen_sari_i32(TCGV_HIGH(val), TCGV_LOW(val), 31); 2823951c6300SRichard Henderson } else { 2824951c6300SRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(val), 0); 2825951c6300SRichard Henderson } 2826951c6300SRichard Henderson return; 2827951c6300SRichard Henderson } 2828951c6300SRichard Henderson 2829e1dcf352SRichard Henderson tcg_gen_req_mo(TCG_MO_LD_LD | TCG_MO_ST_LD); 2830c45cb8bbSRichard Henderson memop = tcg_canonicalize_memop(memop, 1, 0); 28311c2adb95SRichard Henderson trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, 2832dcdaadb6SLluís Vilanova addr, trace_mem_get_info(memop, 0)); 2833e1dcf352SRichard Henderson 2834e1dcf352SRichard Henderson orig_memop = memop; 2835e1dcf352SRichard Henderson if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) { 2836e1dcf352SRichard Henderson memop &= ~MO_BSWAP; 2837e1dcf352SRichard Henderson /* The bswap primitive requires zero-extended input. */ 2838e1dcf352SRichard Henderson if ((memop & MO_SIGN) && (memop & MO_SIZE) < MO_64) { 2839e1dcf352SRichard Henderson memop &= ~MO_SIGN; 2840e1dcf352SRichard Henderson } 2841e1dcf352SRichard Henderson } 2842e1dcf352SRichard Henderson 2843c45cb8bbSRichard Henderson gen_ldst_i64(INDEX_op_qemu_ld_i64, val, addr, memop, idx); 2844e1dcf352SRichard Henderson 2845e1dcf352SRichard Henderson if ((orig_memop ^ memop) & MO_BSWAP) { 2846e1dcf352SRichard Henderson switch (orig_memop & MO_SIZE) { 2847e1dcf352SRichard Henderson case MO_16: 2848e1dcf352SRichard Henderson tcg_gen_bswap16_i64(val, val); 2849e1dcf352SRichard Henderson if (orig_memop & MO_SIGN) { 2850e1dcf352SRichard Henderson tcg_gen_ext16s_i64(val, val); 2851e1dcf352SRichard Henderson } 2852e1dcf352SRichard Henderson break; 2853e1dcf352SRichard Henderson case MO_32: 2854e1dcf352SRichard Henderson tcg_gen_bswap32_i64(val, val); 2855e1dcf352SRichard Henderson if (orig_memop & MO_SIGN) { 2856e1dcf352SRichard Henderson tcg_gen_ext32s_i64(val, val); 2857e1dcf352SRichard Henderson } 2858e1dcf352SRichard Henderson break; 2859e1dcf352SRichard Henderson case MO_64: 2860e1dcf352SRichard Henderson tcg_gen_bswap64_i64(val, val); 2861e1dcf352SRichard Henderson break; 2862e1dcf352SRichard Henderson default: 2863e1dcf352SRichard Henderson g_assert_not_reached(); 2864e1dcf352SRichard Henderson } 2865e1dcf352SRichard Henderson } 2866951c6300SRichard Henderson } 2867951c6300SRichard Henderson 2868951c6300SRichard Henderson void tcg_gen_qemu_st_i64(TCGv_i64 val, TCGv addr, TCGArg idx, TCGMemOp memop) 2869951c6300SRichard Henderson { 2870e1dcf352SRichard Henderson TCGv_i64 swap = NULL; 2871e1dcf352SRichard Henderson 28723a13c3f3SRichard Henderson if (TCG_TARGET_REG_BITS == 32 && (memop & MO_SIZE) < MO_64) { 2873951c6300SRichard Henderson tcg_gen_qemu_st_i32(TCGV_LOW(val), addr, idx, memop); 2874951c6300SRichard Henderson return; 2875951c6300SRichard Henderson } 2876951c6300SRichard Henderson 2877e1dcf352SRichard Henderson tcg_gen_req_mo(TCG_MO_LD_ST | TCG_MO_ST_ST); 2878c45cb8bbSRichard Henderson memop = tcg_canonicalize_memop(memop, 1, 1); 28791c2adb95SRichard Henderson trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, 2880dcdaadb6SLluís Vilanova addr, trace_mem_get_info(memop, 1)); 2881e1dcf352SRichard Henderson 2882e1dcf352SRichard Henderson if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) { 2883e1dcf352SRichard Henderson swap = tcg_temp_new_i64(); 2884e1dcf352SRichard Henderson switch (memop & MO_SIZE) { 2885e1dcf352SRichard Henderson case MO_16: 2886e1dcf352SRichard Henderson tcg_gen_ext16u_i64(swap, val); 2887e1dcf352SRichard Henderson tcg_gen_bswap16_i64(swap, swap); 2888e1dcf352SRichard Henderson break; 2889e1dcf352SRichard Henderson case MO_32: 2890e1dcf352SRichard Henderson tcg_gen_ext32u_i64(swap, val); 2891e1dcf352SRichard Henderson tcg_gen_bswap32_i64(swap, swap); 2892e1dcf352SRichard Henderson break; 2893e1dcf352SRichard Henderson case MO_64: 2894e1dcf352SRichard Henderson tcg_gen_bswap64_i64(swap, val); 2895e1dcf352SRichard Henderson break; 2896e1dcf352SRichard Henderson default: 2897e1dcf352SRichard Henderson g_assert_not_reached(); 2898e1dcf352SRichard Henderson } 2899e1dcf352SRichard Henderson val = swap; 2900e1dcf352SRichard Henderson memop &= ~MO_BSWAP; 2901e1dcf352SRichard Henderson } 2902e1dcf352SRichard Henderson 2903c45cb8bbSRichard Henderson gen_ldst_i64(INDEX_op_qemu_st_i64, val, addr, memop, idx); 2904e1dcf352SRichard Henderson 2905e1dcf352SRichard Henderson if (swap) { 2906e1dcf352SRichard Henderson tcg_temp_free_i64(swap); 2907e1dcf352SRichard Henderson } 2908951c6300SRichard Henderson } 2909c482cb11SRichard Henderson 2910c482cb11SRichard Henderson static void tcg_gen_ext_i32(TCGv_i32 ret, TCGv_i32 val, TCGMemOp opc) 2911c482cb11SRichard Henderson { 2912c482cb11SRichard Henderson switch (opc & MO_SSIZE) { 2913c482cb11SRichard Henderson case MO_SB: 2914c482cb11SRichard Henderson tcg_gen_ext8s_i32(ret, val); 2915c482cb11SRichard Henderson break; 2916c482cb11SRichard Henderson case MO_UB: 2917c482cb11SRichard Henderson tcg_gen_ext8u_i32(ret, val); 2918c482cb11SRichard Henderson break; 2919c482cb11SRichard Henderson case MO_SW: 2920c482cb11SRichard Henderson tcg_gen_ext16s_i32(ret, val); 2921c482cb11SRichard Henderson break; 2922c482cb11SRichard Henderson case MO_UW: 2923c482cb11SRichard Henderson tcg_gen_ext16u_i32(ret, val); 2924c482cb11SRichard Henderson break; 2925c482cb11SRichard Henderson default: 2926c482cb11SRichard Henderson tcg_gen_mov_i32(ret, val); 2927c482cb11SRichard Henderson break; 2928c482cb11SRichard Henderson } 2929c482cb11SRichard Henderson } 2930c482cb11SRichard Henderson 2931c482cb11SRichard Henderson static void tcg_gen_ext_i64(TCGv_i64 ret, TCGv_i64 val, TCGMemOp opc) 2932c482cb11SRichard Henderson { 2933c482cb11SRichard Henderson switch (opc & MO_SSIZE) { 2934c482cb11SRichard Henderson case MO_SB: 2935c482cb11SRichard Henderson tcg_gen_ext8s_i64(ret, val); 2936c482cb11SRichard Henderson break; 2937c482cb11SRichard Henderson case MO_UB: 2938c482cb11SRichard Henderson tcg_gen_ext8u_i64(ret, val); 2939c482cb11SRichard Henderson break; 2940c482cb11SRichard Henderson case MO_SW: 2941c482cb11SRichard Henderson tcg_gen_ext16s_i64(ret, val); 2942c482cb11SRichard Henderson break; 2943c482cb11SRichard Henderson case MO_UW: 2944c482cb11SRichard Henderson tcg_gen_ext16u_i64(ret, val); 2945c482cb11SRichard Henderson break; 2946c482cb11SRichard Henderson case MO_SL: 2947c482cb11SRichard Henderson tcg_gen_ext32s_i64(ret, val); 2948c482cb11SRichard Henderson break; 2949c482cb11SRichard Henderson case MO_UL: 2950c482cb11SRichard Henderson tcg_gen_ext32u_i64(ret, val); 2951c482cb11SRichard Henderson break; 2952c482cb11SRichard Henderson default: 2953c482cb11SRichard Henderson tcg_gen_mov_i64(ret, val); 2954c482cb11SRichard Henderson break; 2955c482cb11SRichard Henderson } 2956c482cb11SRichard Henderson } 2957c482cb11SRichard Henderson 2958c482cb11SRichard Henderson #ifdef CONFIG_SOFTMMU 2959c482cb11SRichard Henderson typedef void (*gen_atomic_cx_i32)(TCGv_i32, TCGv_env, TCGv, 2960c482cb11SRichard Henderson TCGv_i32, TCGv_i32, TCGv_i32); 2961c482cb11SRichard Henderson typedef void (*gen_atomic_cx_i64)(TCGv_i64, TCGv_env, TCGv, 2962c482cb11SRichard Henderson TCGv_i64, TCGv_i64, TCGv_i32); 2963c482cb11SRichard Henderson typedef void (*gen_atomic_op_i32)(TCGv_i32, TCGv_env, TCGv, 2964c482cb11SRichard Henderson TCGv_i32, TCGv_i32); 2965c482cb11SRichard Henderson typedef void (*gen_atomic_op_i64)(TCGv_i64, TCGv_env, TCGv, 2966c482cb11SRichard Henderson TCGv_i64, TCGv_i32); 2967c482cb11SRichard Henderson #else 2968c482cb11SRichard Henderson typedef void (*gen_atomic_cx_i32)(TCGv_i32, TCGv_env, TCGv, TCGv_i32, TCGv_i32); 2969c482cb11SRichard Henderson typedef void (*gen_atomic_cx_i64)(TCGv_i64, TCGv_env, TCGv, TCGv_i64, TCGv_i64); 2970c482cb11SRichard Henderson typedef void (*gen_atomic_op_i32)(TCGv_i32, TCGv_env, TCGv, TCGv_i32); 2971c482cb11SRichard Henderson typedef void (*gen_atomic_op_i64)(TCGv_i64, TCGv_env, TCGv, TCGv_i64); 2972c482cb11SRichard Henderson #endif 2973c482cb11SRichard Henderson 2974df79b996SRichard Henderson #ifdef CONFIG_ATOMIC64 2975df79b996SRichard Henderson # define WITH_ATOMIC64(X) X, 2976df79b996SRichard Henderson #else 2977df79b996SRichard Henderson # define WITH_ATOMIC64(X) 2978df79b996SRichard Henderson #endif 2979df79b996SRichard Henderson 2980c482cb11SRichard Henderson static void * const table_cmpxchg[16] = { 2981c482cb11SRichard Henderson [MO_8] = gen_helper_atomic_cmpxchgb, 2982c482cb11SRichard Henderson [MO_16 | MO_LE] = gen_helper_atomic_cmpxchgw_le, 2983c482cb11SRichard Henderson [MO_16 | MO_BE] = gen_helper_atomic_cmpxchgw_be, 2984c482cb11SRichard Henderson [MO_32 | MO_LE] = gen_helper_atomic_cmpxchgl_le, 2985c482cb11SRichard Henderson [MO_32 | MO_BE] = gen_helper_atomic_cmpxchgl_be, 2986df79b996SRichard Henderson WITH_ATOMIC64([MO_64 | MO_LE] = gen_helper_atomic_cmpxchgq_le) 2987df79b996SRichard Henderson WITH_ATOMIC64([MO_64 | MO_BE] = gen_helper_atomic_cmpxchgq_be) 2988c482cb11SRichard Henderson }; 2989c482cb11SRichard Henderson 2990c482cb11SRichard Henderson void tcg_gen_atomic_cmpxchg_i32(TCGv_i32 retv, TCGv addr, TCGv_i32 cmpv, 2991c482cb11SRichard Henderson TCGv_i32 newv, TCGArg idx, TCGMemOp memop) 2992c482cb11SRichard Henderson { 2993c482cb11SRichard Henderson memop = tcg_canonicalize_memop(memop, 0, 0); 2994c482cb11SRichard Henderson 2995b1311c4aSEmilio G. Cota if (!(tcg_ctx->tb_cflags & CF_PARALLEL)) { 2996c482cb11SRichard Henderson TCGv_i32 t1 = tcg_temp_new_i32(); 2997c482cb11SRichard Henderson TCGv_i32 t2 = tcg_temp_new_i32(); 2998c482cb11SRichard Henderson 2999c482cb11SRichard Henderson tcg_gen_ext_i32(t2, cmpv, memop & MO_SIZE); 3000c482cb11SRichard Henderson 3001c482cb11SRichard Henderson tcg_gen_qemu_ld_i32(t1, addr, idx, memop & ~MO_SIGN); 3002c482cb11SRichard Henderson tcg_gen_movcond_i32(TCG_COND_EQ, t2, t1, t2, newv, t1); 3003c482cb11SRichard Henderson tcg_gen_qemu_st_i32(t2, addr, idx, memop); 3004c482cb11SRichard Henderson tcg_temp_free_i32(t2); 3005c482cb11SRichard Henderson 3006c482cb11SRichard Henderson if (memop & MO_SIGN) { 3007c482cb11SRichard Henderson tcg_gen_ext_i32(retv, t1, memop); 3008c482cb11SRichard Henderson } else { 3009c482cb11SRichard Henderson tcg_gen_mov_i32(retv, t1); 3010c482cb11SRichard Henderson } 3011c482cb11SRichard Henderson tcg_temp_free_i32(t1); 3012c482cb11SRichard Henderson } else { 3013c482cb11SRichard Henderson gen_atomic_cx_i32 gen; 3014c482cb11SRichard Henderson 3015c482cb11SRichard Henderson gen = table_cmpxchg[memop & (MO_SIZE | MO_BSWAP)]; 3016c482cb11SRichard Henderson tcg_debug_assert(gen != NULL); 3017c482cb11SRichard Henderson 3018c482cb11SRichard Henderson #ifdef CONFIG_SOFTMMU 3019c482cb11SRichard Henderson { 3020c482cb11SRichard Henderson TCGv_i32 oi = tcg_const_i32(make_memop_idx(memop & ~MO_SIGN, idx)); 30211c2adb95SRichard Henderson gen(retv, cpu_env, addr, cmpv, newv, oi); 3022c482cb11SRichard Henderson tcg_temp_free_i32(oi); 3023c482cb11SRichard Henderson } 3024c482cb11SRichard Henderson #else 30251c2adb95SRichard Henderson gen(retv, cpu_env, addr, cmpv, newv); 3026c482cb11SRichard Henderson #endif 3027c482cb11SRichard Henderson 3028c482cb11SRichard Henderson if (memop & MO_SIGN) { 3029c482cb11SRichard Henderson tcg_gen_ext_i32(retv, retv, memop); 3030c482cb11SRichard Henderson } 3031c482cb11SRichard Henderson } 3032c482cb11SRichard Henderson } 3033c482cb11SRichard Henderson 3034c482cb11SRichard Henderson void tcg_gen_atomic_cmpxchg_i64(TCGv_i64 retv, TCGv addr, TCGv_i64 cmpv, 3035c482cb11SRichard Henderson TCGv_i64 newv, TCGArg idx, TCGMemOp memop) 3036c482cb11SRichard Henderson { 3037c482cb11SRichard Henderson memop = tcg_canonicalize_memop(memop, 1, 0); 3038c482cb11SRichard Henderson 3039b1311c4aSEmilio G. Cota if (!(tcg_ctx->tb_cflags & CF_PARALLEL)) { 3040c482cb11SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 3041c482cb11SRichard Henderson TCGv_i64 t2 = tcg_temp_new_i64(); 3042c482cb11SRichard Henderson 3043c482cb11SRichard Henderson tcg_gen_ext_i64(t2, cmpv, memop & MO_SIZE); 3044c482cb11SRichard Henderson 3045c482cb11SRichard Henderson tcg_gen_qemu_ld_i64(t1, addr, idx, memop & ~MO_SIGN); 3046c482cb11SRichard Henderson tcg_gen_movcond_i64(TCG_COND_EQ, t2, t1, t2, newv, t1); 3047c482cb11SRichard Henderson tcg_gen_qemu_st_i64(t2, addr, idx, memop); 3048c482cb11SRichard Henderson tcg_temp_free_i64(t2); 3049c482cb11SRichard Henderson 3050c482cb11SRichard Henderson if (memop & MO_SIGN) { 3051c482cb11SRichard Henderson tcg_gen_ext_i64(retv, t1, memop); 3052c482cb11SRichard Henderson } else { 3053c482cb11SRichard Henderson tcg_gen_mov_i64(retv, t1); 3054c482cb11SRichard Henderson } 3055c482cb11SRichard Henderson tcg_temp_free_i64(t1); 3056c482cb11SRichard Henderson } else if ((memop & MO_SIZE) == MO_64) { 3057df79b996SRichard Henderson #ifdef CONFIG_ATOMIC64 3058c482cb11SRichard Henderson gen_atomic_cx_i64 gen; 3059c482cb11SRichard Henderson 3060c482cb11SRichard Henderson gen = table_cmpxchg[memop & (MO_SIZE | MO_BSWAP)]; 3061c482cb11SRichard Henderson tcg_debug_assert(gen != NULL); 3062c482cb11SRichard Henderson 3063c482cb11SRichard Henderson #ifdef CONFIG_SOFTMMU 3064c482cb11SRichard Henderson { 3065c482cb11SRichard Henderson TCGv_i32 oi = tcg_const_i32(make_memop_idx(memop, idx)); 30661c2adb95SRichard Henderson gen(retv, cpu_env, addr, cmpv, newv, oi); 3067c482cb11SRichard Henderson tcg_temp_free_i32(oi); 3068c482cb11SRichard Henderson } 3069c482cb11SRichard Henderson #else 30701c2adb95SRichard Henderson gen(retv, cpu_env, addr, cmpv, newv); 3071c482cb11SRichard Henderson #endif 3072df79b996SRichard Henderson #else 30731c2adb95SRichard Henderson gen_helper_exit_atomic(cpu_env); 307479b1af90SRichard Henderson /* Produce a result, so that we have a well-formed opcode stream 307579b1af90SRichard Henderson with respect to uses of the result in the (dead) code following. */ 307679b1af90SRichard Henderson tcg_gen_movi_i64(retv, 0); 3077df79b996SRichard Henderson #endif /* CONFIG_ATOMIC64 */ 3078c482cb11SRichard Henderson } else { 3079c482cb11SRichard Henderson TCGv_i32 c32 = tcg_temp_new_i32(); 3080c482cb11SRichard Henderson TCGv_i32 n32 = tcg_temp_new_i32(); 3081c482cb11SRichard Henderson TCGv_i32 r32 = tcg_temp_new_i32(); 3082c482cb11SRichard Henderson 3083c482cb11SRichard Henderson tcg_gen_extrl_i64_i32(c32, cmpv); 3084c482cb11SRichard Henderson tcg_gen_extrl_i64_i32(n32, newv); 3085c482cb11SRichard Henderson tcg_gen_atomic_cmpxchg_i32(r32, addr, c32, n32, idx, memop & ~MO_SIGN); 3086c482cb11SRichard Henderson tcg_temp_free_i32(c32); 3087c482cb11SRichard Henderson tcg_temp_free_i32(n32); 3088c482cb11SRichard Henderson 3089c482cb11SRichard Henderson tcg_gen_extu_i32_i64(retv, r32); 3090c482cb11SRichard Henderson tcg_temp_free_i32(r32); 3091c482cb11SRichard Henderson 3092c482cb11SRichard Henderson if (memop & MO_SIGN) { 3093c482cb11SRichard Henderson tcg_gen_ext_i64(retv, retv, memop); 3094c482cb11SRichard Henderson } 3095c482cb11SRichard Henderson } 3096c482cb11SRichard Henderson } 3097c482cb11SRichard Henderson 3098c482cb11SRichard Henderson static void do_nonatomic_op_i32(TCGv_i32 ret, TCGv addr, TCGv_i32 val, 3099c482cb11SRichard Henderson TCGArg idx, TCGMemOp memop, bool new_val, 3100c482cb11SRichard Henderson void (*gen)(TCGv_i32, TCGv_i32, TCGv_i32)) 3101c482cb11SRichard Henderson { 3102c482cb11SRichard Henderson TCGv_i32 t1 = tcg_temp_new_i32(); 3103c482cb11SRichard Henderson TCGv_i32 t2 = tcg_temp_new_i32(); 3104c482cb11SRichard Henderson 3105c482cb11SRichard Henderson memop = tcg_canonicalize_memop(memop, 0, 0); 3106c482cb11SRichard Henderson 3107c482cb11SRichard Henderson tcg_gen_qemu_ld_i32(t1, addr, idx, memop & ~MO_SIGN); 3108c482cb11SRichard Henderson gen(t2, t1, val); 3109c482cb11SRichard Henderson tcg_gen_qemu_st_i32(t2, addr, idx, memop); 3110c482cb11SRichard Henderson 3111c482cb11SRichard Henderson tcg_gen_ext_i32(ret, (new_val ? t2 : t1), memop); 3112c482cb11SRichard Henderson tcg_temp_free_i32(t1); 3113c482cb11SRichard Henderson tcg_temp_free_i32(t2); 3114c482cb11SRichard Henderson } 3115c482cb11SRichard Henderson 3116c482cb11SRichard Henderson static void do_atomic_op_i32(TCGv_i32 ret, TCGv addr, TCGv_i32 val, 3117c482cb11SRichard Henderson TCGArg idx, TCGMemOp memop, void * const table[]) 3118c482cb11SRichard Henderson { 3119c482cb11SRichard Henderson gen_atomic_op_i32 gen; 3120c482cb11SRichard Henderson 3121c482cb11SRichard Henderson memop = tcg_canonicalize_memop(memop, 0, 0); 3122c482cb11SRichard Henderson 3123c482cb11SRichard Henderson gen = table[memop & (MO_SIZE | MO_BSWAP)]; 3124c482cb11SRichard Henderson tcg_debug_assert(gen != NULL); 3125c482cb11SRichard Henderson 3126c482cb11SRichard Henderson #ifdef CONFIG_SOFTMMU 3127c482cb11SRichard Henderson { 3128c482cb11SRichard Henderson TCGv_i32 oi = tcg_const_i32(make_memop_idx(memop & ~MO_SIGN, idx)); 31291c2adb95SRichard Henderson gen(ret, cpu_env, addr, val, oi); 3130c482cb11SRichard Henderson tcg_temp_free_i32(oi); 3131c482cb11SRichard Henderson } 3132c482cb11SRichard Henderson #else 31331c2adb95SRichard Henderson gen(ret, cpu_env, addr, val); 3134c482cb11SRichard Henderson #endif 3135c482cb11SRichard Henderson 3136c482cb11SRichard Henderson if (memop & MO_SIGN) { 3137c482cb11SRichard Henderson tcg_gen_ext_i32(ret, ret, memop); 3138c482cb11SRichard Henderson } 3139c482cb11SRichard Henderson } 3140c482cb11SRichard Henderson 3141c482cb11SRichard Henderson static void do_nonatomic_op_i64(TCGv_i64 ret, TCGv addr, TCGv_i64 val, 3142c482cb11SRichard Henderson TCGArg idx, TCGMemOp memop, bool new_val, 3143c482cb11SRichard Henderson void (*gen)(TCGv_i64, TCGv_i64, TCGv_i64)) 3144c482cb11SRichard Henderson { 3145c482cb11SRichard Henderson TCGv_i64 t1 = tcg_temp_new_i64(); 3146c482cb11SRichard Henderson TCGv_i64 t2 = tcg_temp_new_i64(); 3147c482cb11SRichard Henderson 3148c482cb11SRichard Henderson memop = tcg_canonicalize_memop(memop, 1, 0); 3149c482cb11SRichard Henderson 3150c482cb11SRichard Henderson tcg_gen_qemu_ld_i64(t1, addr, idx, memop & ~MO_SIGN); 3151c482cb11SRichard Henderson gen(t2, t1, val); 3152c482cb11SRichard Henderson tcg_gen_qemu_st_i64(t2, addr, idx, memop); 3153c482cb11SRichard Henderson 3154c482cb11SRichard Henderson tcg_gen_ext_i64(ret, (new_val ? t2 : t1), memop); 3155c482cb11SRichard Henderson tcg_temp_free_i64(t1); 3156c482cb11SRichard Henderson tcg_temp_free_i64(t2); 3157c482cb11SRichard Henderson } 3158c482cb11SRichard Henderson 3159c482cb11SRichard Henderson static void do_atomic_op_i64(TCGv_i64 ret, TCGv addr, TCGv_i64 val, 3160c482cb11SRichard Henderson TCGArg idx, TCGMemOp memop, void * const table[]) 3161c482cb11SRichard Henderson { 3162c482cb11SRichard Henderson memop = tcg_canonicalize_memop(memop, 1, 0); 3163c482cb11SRichard Henderson 3164c482cb11SRichard Henderson if ((memop & MO_SIZE) == MO_64) { 3165df79b996SRichard Henderson #ifdef CONFIG_ATOMIC64 3166c482cb11SRichard Henderson gen_atomic_op_i64 gen; 3167c482cb11SRichard Henderson 3168c482cb11SRichard Henderson gen = table[memop & (MO_SIZE | MO_BSWAP)]; 3169c482cb11SRichard Henderson tcg_debug_assert(gen != NULL); 3170c482cb11SRichard Henderson 3171c482cb11SRichard Henderson #ifdef CONFIG_SOFTMMU 3172c482cb11SRichard Henderson { 3173c482cb11SRichard Henderson TCGv_i32 oi = tcg_const_i32(make_memop_idx(memop & ~MO_SIGN, idx)); 31741c2adb95SRichard Henderson gen(ret, cpu_env, addr, val, oi); 3175c482cb11SRichard Henderson tcg_temp_free_i32(oi); 3176c482cb11SRichard Henderson } 3177c482cb11SRichard Henderson #else 31781c2adb95SRichard Henderson gen(ret, cpu_env, addr, val); 3179c482cb11SRichard Henderson #endif 3180df79b996SRichard Henderson #else 31811c2adb95SRichard Henderson gen_helper_exit_atomic(cpu_env); 318279b1af90SRichard Henderson /* Produce a result, so that we have a well-formed opcode stream 318379b1af90SRichard Henderson with respect to uses of the result in the (dead) code following. */ 318479b1af90SRichard Henderson tcg_gen_movi_i64(ret, 0); 3185df79b996SRichard Henderson #endif /* CONFIG_ATOMIC64 */ 3186c482cb11SRichard Henderson } else { 3187c482cb11SRichard Henderson TCGv_i32 v32 = tcg_temp_new_i32(); 3188c482cb11SRichard Henderson TCGv_i32 r32 = tcg_temp_new_i32(); 3189c482cb11SRichard Henderson 3190c482cb11SRichard Henderson tcg_gen_extrl_i64_i32(v32, val); 3191c482cb11SRichard Henderson do_atomic_op_i32(r32, addr, v32, idx, memop & ~MO_SIGN, table); 3192c482cb11SRichard Henderson tcg_temp_free_i32(v32); 3193c482cb11SRichard Henderson 3194c482cb11SRichard Henderson tcg_gen_extu_i32_i64(ret, r32); 3195c482cb11SRichard Henderson tcg_temp_free_i32(r32); 3196c482cb11SRichard Henderson 3197c482cb11SRichard Henderson if (memop & MO_SIGN) { 3198c482cb11SRichard Henderson tcg_gen_ext_i64(ret, ret, memop); 3199c482cb11SRichard Henderson } 3200c482cb11SRichard Henderson } 3201c482cb11SRichard Henderson } 3202c482cb11SRichard Henderson 3203c482cb11SRichard Henderson #define GEN_ATOMIC_HELPER(NAME, OP, NEW) \ 3204c482cb11SRichard Henderson static void * const table_##NAME[16] = { \ 3205c482cb11SRichard Henderson [MO_8] = gen_helper_atomic_##NAME##b, \ 3206c482cb11SRichard Henderson [MO_16 | MO_LE] = gen_helper_atomic_##NAME##w_le, \ 3207c482cb11SRichard Henderson [MO_16 | MO_BE] = gen_helper_atomic_##NAME##w_be, \ 3208c482cb11SRichard Henderson [MO_32 | MO_LE] = gen_helper_atomic_##NAME##l_le, \ 3209c482cb11SRichard Henderson [MO_32 | MO_BE] = gen_helper_atomic_##NAME##l_be, \ 3210df79b996SRichard Henderson WITH_ATOMIC64([MO_64 | MO_LE] = gen_helper_atomic_##NAME##q_le) \ 3211df79b996SRichard Henderson WITH_ATOMIC64([MO_64 | MO_BE] = gen_helper_atomic_##NAME##q_be) \ 3212c482cb11SRichard Henderson }; \ 3213c482cb11SRichard Henderson void tcg_gen_atomic_##NAME##_i32 \ 3214c482cb11SRichard Henderson (TCGv_i32 ret, TCGv addr, TCGv_i32 val, TCGArg idx, TCGMemOp memop) \ 3215c482cb11SRichard Henderson { \ 3216b1311c4aSEmilio G. Cota if (tcg_ctx->tb_cflags & CF_PARALLEL) { \ 3217c482cb11SRichard Henderson do_atomic_op_i32(ret, addr, val, idx, memop, table_##NAME); \ 3218c482cb11SRichard Henderson } else { \ 3219c482cb11SRichard Henderson do_nonatomic_op_i32(ret, addr, val, idx, memop, NEW, \ 3220c482cb11SRichard Henderson tcg_gen_##OP##_i32); \ 3221c482cb11SRichard Henderson } \ 3222c482cb11SRichard Henderson } \ 3223c482cb11SRichard Henderson void tcg_gen_atomic_##NAME##_i64 \ 3224c482cb11SRichard Henderson (TCGv_i64 ret, TCGv addr, TCGv_i64 val, TCGArg idx, TCGMemOp memop) \ 3225c482cb11SRichard Henderson { \ 3226b1311c4aSEmilio G. Cota if (tcg_ctx->tb_cflags & CF_PARALLEL) { \ 3227c482cb11SRichard Henderson do_atomic_op_i64(ret, addr, val, idx, memop, table_##NAME); \ 3228c482cb11SRichard Henderson } else { \ 3229c482cb11SRichard Henderson do_nonatomic_op_i64(ret, addr, val, idx, memop, NEW, \ 3230c482cb11SRichard Henderson tcg_gen_##OP##_i64); \ 3231c482cb11SRichard Henderson } \ 3232c482cb11SRichard Henderson } 3233c482cb11SRichard Henderson 3234c482cb11SRichard Henderson GEN_ATOMIC_HELPER(fetch_add, add, 0) 3235c482cb11SRichard Henderson GEN_ATOMIC_HELPER(fetch_and, and, 0) 3236c482cb11SRichard Henderson GEN_ATOMIC_HELPER(fetch_or, or, 0) 3237c482cb11SRichard Henderson GEN_ATOMIC_HELPER(fetch_xor, xor, 0) 32385507c2bfSRichard Henderson GEN_ATOMIC_HELPER(fetch_smin, smin, 0) 32395507c2bfSRichard Henderson GEN_ATOMIC_HELPER(fetch_umin, umin, 0) 32405507c2bfSRichard Henderson GEN_ATOMIC_HELPER(fetch_smax, smax, 0) 32415507c2bfSRichard Henderson GEN_ATOMIC_HELPER(fetch_umax, umax, 0) 3242c482cb11SRichard Henderson 3243c482cb11SRichard Henderson GEN_ATOMIC_HELPER(add_fetch, add, 1) 3244c482cb11SRichard Henderson GEN_ATOMIC_HELPER(and_fetch, and, 1) 3245c482cb11SRichard Henderson GEN_ATOMIC_HELPER(or_fetch, or, 1) 3246c482cb11SRichard Henderson GEN_ATOMIC_HELPER(xor_fetch, xor, 1) 32475507c2bfSRichard Henderson GEN_ATOMIC_HELPER(smin_fetch, smin, 1) 32485507c2bfSRichard Henderson GEN_ATOMIC_HELPER(umin_fetch, umin, 1) 32495507c2bfSRichard Henderson GEN_ATOMIC_HELPER(smax_fetch, smax, 1) 32505507c2bfSRichard Henderson GEN_ATOMIC_HELPER(umax_fetch, umax, 1) 3251c482cb11SRichard Henderson 3252c482cb11SRichard Henderson static void tcg_gen_mov2_i32(TCGv_i32 r, TCGv_i32 a, TCGv_i32 b) 3253c482cb11SRichard Henderson { 3254c482cb11SRichard Henderson tcg_gen_mov_i32(r, b); 3255c482cb11SRichard Henderson } 3256c482cb11SRichard Henderson 3257c482cb11SRichard Henderson static void tcg_gen_mov2_i64(TCGv_i64 r, TCGv_i64 a, TCGv_i64 b) 3258c482cb11SRichard Henderson { 3259c482cb11SRichard Henderson tcg_gen_mov_i64(r, b); 3260c482cb11SRichard Henderson } 3261c482cb11SRichard Henderson 3262c482cb11SRichard Henderson GEN_ATOMIC_HELPER(xchg, mov2, 0) 3263c482cb11SRichard Henderson 3264c482cb11SRichard Henderson #undef GEN_ATOMIC_HELPER 3265