Lines Matching defs:env
174 addInstr(ISelEnv *env, s390_insn *insn)
176 addHInstr(env->code, insn);
197 lookupIRTemp(ISelEnv *env, IRTemp tmp)
199 vassert(tmp < env->n_vregmap);
200 vassert(! hregIsInvalid(env->vregmap[tmp]));
202 return env->vregmap[tmp];
208 lookupIRTemp128(HReg *hi, HReg *lo, ISelEnv *env, IRTemp tmp)
210 vassert(tmp < env->n_vregmap);
211 vassert(! hregIsInvalid(env->vregmapHI[tmp]));
213 *lo = env->vregmap[tmp];
214 *hi = env->vregmapHI[tmp];
226 newVRegI(ISelEnv *env)
228 return mkVRegI(env->vreg_ctr++);
240 newVRegF(ISelEnv *env)
242 return mkVRegF(env->vreg_ctr++);
298 s390_isel_amode_wrk(ISelEnv *env, IRExpr *expr,
318 return s390_amode_b12((Int)value, s390_isel_int_expr(env, arg1));
321 return s390_amode_b20((Int)value, s390_isel_int_expr(env, arg1));
328 return s390_amode_b12(0, s390_isel_int_expr(env, expr));
333 s390_isel_amode(ISelEnv *env, IRExpr *expr)
338 vassert(typeOfIRExpr(env->type_env, expr) == Ity_I64);
340 am = s390_isel_amode_wrk(env, expr, /* B12, B20 only */ False);
364 s390_isel_amode_b12_b20(ISelEnv *env, IRExpr *expr)
369 vassert(typeOfIRExpr(env->type_env, expr) == Ity_I64);
371 am = s390_isel_amode_wrk(env, expr, /* B12, B20 only */ True);
513 ISelEnv *env, IRExpr *guard,
559 IRType type = typeOfIRExpr(env->type_env, args[i]);
583 tmpregs[argreg] = newVRegI(env);
584 addInstr(env, s390_insn_move(sizeof(ULong), tmpregs[argreg],
587 tmpregs[argreg] = s390_isel_int_expr(env, args[i]);
600 cc = s390_isel_cc(env, guard);
611 addInstr(env, s390_insn_move(size, finalreg, tmpregs[i]));
638 addInstr(env, s390_insn_helper_call(cc, target, n_args,
651 set_bfp_rounding_mode_in_fpc(ISelEnv *env, IRExpr *irrm)
653 vassert(typeOfIRExpr(env->type_env, irrm) == Ity_I32);
656 if (env->previous_bfp_rounding_mode &&
657 env->previous_bfp_rounding_mode->tag == Iex_RdTmp &&
659 env->previous_bfp_rounding_mode->Iex.RdTmp.tmp == irrm->Iex.RdTmp.tmp) {
665 env->previous_bfp_rounding_mode = irrm;
679 HReg ir = s390_isel_int_expr(env, irrm);
681 HReg mode = newVRegI(env);
683 addInstr(env, s390_insn_load_immediate(4, mode, 4));
684 addInstr(env, s390_insn_alu(4, S390_ALU_SUB, mode, s390_opnd_reg(ir)));
685 addInstr(env, s390_insn_alu(4, S390_ALU_AND, mode, s390_opnd_imm(3)));
687 addInstr(env, s390_insn_set_fpc_bfprm(4, mode));
696 get_bfp_rounding_mode(ISelEnv *env, IRExpr *irrm)
712 set_bfp_rounding_mode_in_fpc(env, irrm);
725 set_dfp_rounding_mode_in_fpc(ISelEnv *env, IRExpr *irrm)
727 vassert(typeOfIRExpr(env->type_env, irrm) == Ity_I32);
730 if (env->previous_dfp_rounding_mode &&
731 env->previous_dfp_rounding_mode->tag == Iex_RdTmp &&
733 env->previous_dfp_rounding_mode->Iex.RdTmp.tmp == irrm->Iex.RdTmp.tmp) {
739 env->previous_dfp_rounding_mode = irrm;
757 HReg ir = s390_isel_int_expr(env, irrm);
759 HReg mode = newVRegI(env);
761 addInstr(env, s390_insn_move(4, mode, ir));
762 addInstr(env, s390_insn_alu(4, S390_ALU_LSH, mode, s390_opnd_imm(1)));
763 addInstr(env, s390_insn_alu(4, S390_ALU_AND, mode, s390_opnd_imm(2)));
764 addInstr(env, s390_insn_alu(4, S390_ALU_XOR, mode, s390_opnd_reg(ir)));
766 addInstr(env, s390_insn_set_fpc_dfprm(4, mode));
806 get_dfp_rounding_mode(ISelEnv *env, IRExpr *irrm)
834 set_dfp_rounding_mode_in_fpc(env, irrm);
859 convert_s390_to_vex_bfpcc(ISelEnv *env, HReg cc_s390)
863 cc0 = newVRegI(env);
864 addInstr(env, s390_insn_move(4, cc0, cc_s390));
865 addInstr(env, s390_insn_alu(4, S390_ALU_AND, cc0, s390_opnd_imm(1)));
867 cc1 = newVRegI(env);
868 addInstr(env, s390_insn_move(4, cc1, cc_s390));
869 addInstr(env, s390_insn_alu(4, S390_ALU_RSH, cc1, s390_opnd_imm(1)));
871 b2 = newVRegI(env);
872 addInstr(env, s390_insn_move(4, b2, cc0));
873 addInstr(env, s390_insn_alu(4, S390_ALU_AND, b2, s390_opnd_reg(cc1)));
874 addInstr(env, s390_insn_alu(4, S390_ALU_LSH, b2, s390_opnd_imm(2)));
876 b6 = newVRegI(env);
877 addInstr(env, s390_insn_move(4, b6, cc0));
878 addInstr(env, s390_insn_alu(4, S390_ALU_SUB, b6, s390_opnd_reg(cc1)));
879 addInstr(env, s390_insn_alu(4, S390_ALU_ADD, b6, s390_opnd_imm(1)));
880 addInstr(env, s390_insn_alu(4, S390_ALU_AND, b6, s390_opnd_imm(1)));
881 addInstr(env, s390_insn_alu(4, S390_ALU_LSH, b6, s390_opnd_imm(6)));
883 cc_vex = newVRegI(env);
884 addInstr(env, s390_insn_move(4, cc_vex, cc0));
885 addInstr(env, s390_insn_alu(4, S390_ALU_OR, cc_vex, s390_opnd_reg(b2)));
886 addInstr(env, s390_insn_alu(4, S390_ALU_OR, cc_vex, s390_opnd_reg(b6)));
894 convert_s390_to_vex_dfpcc(ISelEnv *env, HReg cc_s390)
897 return convert_s390_to_vex_bfpcc(env, cc_s390);
905 s390_isel_int128_expr_wrk(HReg *dst_hi, HReg *dst_lo, ISelEnv *env,
908 IRType ty = typeOfIRExpr(env->type_env, expr);
919 lookupIRTemp128(dst_hi, dst_lo, env, expr->Iex.RdTmp.tmp);
946 *dst_hi = s390_isel_int_expr(env, arg1);
947 *dst_lo = s390_isel_int_expr(env, arg2);
954 h1 = s390_isel_int_expr(env, arg1); /* Process 1st operand */
955 op2 = s390_isel_int_expr_RMI(env, arg2); /* Process 2nd operand */
962 addInstr(env, s390_insn_move(8, r11, h1));
965 addInstr(env, s390_insn_divs(8, r10, r11, op2));
971 *dst_hi = newVRegI(env);
972 *dst_lo = newVRegI(env);
973 addInstr(env, s390_insn_move(8, *dst_hi, r10));
974 addInstr(env, s390_insn_move(8, *dst_lo, r11));
987 h1 = s390_isel_int_expr(env, arg1); /* Process 1st operand */
988 op2 = s390_isel_int_expr_RMI(env, arg2); /* Process 2nd operand */
995 addInstr(env
998 addInstr(env, s390_insn_mul(8, r10, r11, op2, is_signed_multiply));
1002 *dst_hi = newVRegI(env);
1003 *dst_lo = newVRegI(env);
1004 addInstr(env, s390_insn_move(8, *dst_hi, r10));
1005 addInstr(env, s390_insn_move(8, *dst_lo, r11));
1013 s390_isel_int128_expr(&hi, &lo, env, arg1);
1014 op2 = s390_isel_int_expr_RMI(env, arg2); /* Process 2nd operand */
1022 addInstr(env, s390_insn_move(8, r10, hi));
1023 addInstr(env, s390_insn_move(8, r11, lo));
1026 addInstr(env, s390_insn_div(8, r10, r11, op2, is_signed_divide));
1032 *dst_hi = newVRegI(env);
1033 *dst_lo = newVRegI(env);
1034 addInstr(env, s390_insn_move(8, *dst_hi, r10));
1035 addInstr(env, s390_insn_move(8, *dst_lo, r11));
1049 s390_isel_int128_expr(HReg *dst_hi, HReg *dst_lo, ISelEnv *env, IRExpr *expr)
1051 s390_isel_int128_expr_wrk(dst_hi, dst_lo, env, expr);
1082 s390_isel_int_expr_wrk(ISelEnv *env, IRExpr *expr)
1084 IRType ty = typeOfIRExpr(env->type_env, expr);
1098 return lookupIRTemp(env, expr->Iex.RdTmp.tmp);
1102 HReg dst = newVRegI(env);
1103 s390_amode *am = s390_isel_amode(env, expr->Iex.Load.addr);
1108 addInstr(env, s390_insn_load(size, dst, am));
1144 h1 = s390_isel_int_expr(env, arg1); /* Process 1st operand */
1145 op2 = s390_isel_int_expr_RMI(env, arg2); /* Process 2nd operand */
1152 addInstr(env, s390_insn_move(arg_size, r11, h1));
1155 addInstr(env, s390_insn_mul(arg_size, r10, r11, op2, is_signed_multiply));
1159 res = newVRegI(env);
1160 addInstr(env, s390_insn_move(arg_size, res, r10));
1162 addInstr(env, s390_insn_alu(size, S390_ALU_LSH, res, value));
1164 addInstr(env, s390_insn_alu(size, S390_ALU_AND, r11, value));
1166 addInstr(env, s390_insn_alu(size, S390_ALU_OR, res, opnd));
1181 h1 = s390_isel_int_expr(env, arg1); /* Process 1st operand */
1182 op2 = s390_isel_int_expr_RMI(env, arg2); /* Process 2nd operand */
1190 addInstr(env, s390_insn_move(8, r10, h1));
1191 addInstr(env, s390_insn_move(8, r11, h1));
1193 addInstr(env, s390_insn_alu(8, S390_ALU_RSH, r10, value));
1196 addInstr(env, s390_insn_div(4, r10, r11, op2, is_signed_divide));
1202 res = newVRegI(env);
1203 addInstr(env, s390_insn_move(8, res, r10));
1205 addInstr(env, s390_insn_alu(8, S390_ALU_LSH, res, value));
1207 addInstr(env, s390_insn_alu(8, S390_ALU_AND, r11, value));
1209 addInstr(env, s390_insn_alu(8, S390_ALU_OR, res, opnd));
1238 res = newVRegI(env);
1239 h1 = s390_isel_float_expr(env, arg2); /* Process operand */
1241 rounding_mode = get_bfp_rounding_mode(env, arg1);
1242 addInstr(env, s390_insn_bfp_convert(size, conv, res, h1,
1251 res = newVRegI(env);
1252 s390_isel_float128_expr(&op_hi, &op_lo, env, arg2); /* operand */
1259 addInstr(env, s390_insn_move(8, f13, op_hi));
1260 addInstr(env, s390_insn_move(8, f15, op_lo));
1262 rounding_mode = get_bfp_rounding_mode(env, arg1);
1263 addInstr(env, s390_insn_bfp128_convert_from(size, conv, res,
1272 res = newVRegI(env);
1273 h1 = s390_isel_dfp_expr(env, arg2); /* Process operand */
1275 rounding_mode = get_dfp_rounding_mode(env, arg1);
1276 addInstr(env, s390_insn_dfp_convert(size, dconv, res, h1,
1285 res = newVRegI(env);
1286 s390_isel_dfp128_expr(&op_hi, &op_lo, env, arg2); /* operand */
1293 addInstr(env, s390_insn_move(8, f13, op_hi));
1294 addInstr(env, s390_insn_move(8, f15, op_lo));
1296 rounding_mode = get_dfp_rounding_mode(env, arg1);
1297 addInstr(env, s390_insn_dfp128_convert_from(size, dconv, res,
1309 res = newVRegI(env);
1310 h1 = s390_isel_int_expr(env, arg1); /* Process 1st operand */
1311 h2 = s390_isel_int_expr(env, arg2); /* Process 2nd operand */
1313 addInstr(env, s390_insn_move(arg_size, res, h1));
1315 addInstr(env, s390_insn_alu(size, S390_ALU_LSH, res, value));
1317 addInstr(env, s390_insn_alu(size, S390_ALU_AND, h2, value));
1319 addInstr(env, s390_insn_alu(size, S390_ALU_OR, res, opnd));
1325 res = newVRegI(env);
1326 h1 = s390_isel_int_expr(env, arg1);
1327 op2 = s390_isel_int_expr_RMI(env, arg2);
1329 addInstr(env, s390_insn_move(size, res, h1));
1330 addInstr(env, s390_insn_compare(size, res, op2, False /* signed */));
1331 addInstr(env, s390_insn_cond_move(size, S390_CC_L, res, op2));
1339 h1 = s390_isel_float_expr(env, arg1);
1340 h2 = s390_isel_float_expr(env, arg2);
1341 cc_s390 = newVRegI(env);
1345 addInstr(env, s390_insn_bfp_compare(size, cc_s390, h1, h2));
1347 return convert_s390_to_vex_bfpcc(env, cc_s390);
1353 s390_isel_float128_expr(&op1_hi, &op1_lo, env, arg1); /* 1st operand */
1354 s390_isel_float128_expr(&op2_hi, &op2_lo, env, arg2); /* 2nd operand */
1355 cc_s390 = newVRegI(env);
1364 addInstr(env, s390_insn_move(8, f12, op1_hi));
1365 addInstr(env, s390_insn_move(8, f14, op1_lo));
1368 addInstr(env, s390_insn_move(8, f13, op2_hi));
1369 addInstr(env, s390_insn_move(8, f15, op2_lo));
1371 res = newVRegI(env);
1372 addInstr(env, s390_insn_bfp128_compare(16, cc_s390, f12, f14, f13, f15));
1374 return convert_s390_to_vex_bfpcc(env, cc_s390);
1382 h1 = s390_isel_dfp_expr(env, arg1);
1383 h2 = s390_isel_dfp_expr(env, arg2);
1384 cc_s390 = newVRegI(env);
1391 addInstr(env, s390_insn_dfp_compare(8, cmp, cc_s390, h1, h2));
1393 return convert_s390_to_vex_dfpcc(env, cc_s390);
1401 s390_isel_dfp128_expr(&op1_hi, &op1_lo, env, arg1); /* 1st operand */
1402 s390_isel_dfp128_expr(&op2_hi, &op2_lo, env, arg2); /* 2nd operand */
1403 cc_s390 = newVRegI(env);
1412 addInstr(env, s390_insn_move(8, f12, op1_hi));
1413 addInstr(env, s390_insn_move(8, f14, op1_lo));
1416 addInstr(env, s390_insn_move(8, f13, op2_hi));
1417 addInstr(env, s390_insn_move(8, f15, op2_lo));
1424 addInstr(env, s390_insn_dfp128_compare(16, cmp, cc_s390, f12, f14,
1427 return convert_s390_to_vex_dfpcc(env, cc_s390);
1496 res = newVRegI(env);
1497 op2 = s390_isel_int_expr_RMI(env, arg2); /* Process 2nd operand */
1499 addInstr(env, insn);
1508 h1 = s390_isel_int_expr(env, arg1); /* Process 1st operand */
1509 op2 = s390_isel_int_expr_RMI(env, arg2); /* Process 2nd operand */
1510 res = newVRegI(env);
1531 addInstr(env, insn);
1535 addInstr(env, insn);
1564 h1 = s390_isel_int_expr(env, arg->Iex.Binop.arg1); /* 1st opnd */
1565 opnd = s390_isel_int_expr_RMI(env, arg->Iex.Binop.arg2); /* 2nd opnd */
1566 dst = newVRegI(env); /* Result goes into a new register */
1567 addInstr(env, s390_insn_move(size, dst, h1));
1568 addInstr(env, s390_insn_alu(size, S390_ALU_MUL, dst, opnd));
1574 dst = newVRegI(env);
1575 h1 = s390_isel_float_expr(env, arg); /* Process the operand */
1576 addInstr(env, s390_insn_move(size, dst, h1));
1582 dst = newVRegI(env);
1583 h1 = s390_isel_dfp_expr(env, arg); /* Process the operand */
1584 addInstr(env, s390_insn_move(size, dst, h1));
1596 dst = newVRegI(env);
1597 h1 = s390_isel_dfp_expr(env, arg); /* Process the operand */
1598 addInstr(env, s390_insn_dfp_unop(size, dfpop, dst, h1));
1611 dst = newVRegI(env);
1612 s390_isel_dfp128_expr(&op_hi, &op_lo, env, arg); /* Process operand */
1619 addInstr(env, s390_insn_move(8, f13, op_hi));
1620 addInstr(env, s390_insn_move(8, f15, op_lo));
1622 addInstr(env, s390_insn_dfp128_unop(size, dfpop, dst, f13, f15));
1627 if (typeOfIRExpr(env->type_env, arg) == Ity_I1) {
1628 s390_cc_t cond = s390_isel_cc(env, arg);
1629 dst = newVRegI(env); /* Result goes into a new register */
1630 addInstr(env, s390_insn_cc2bool(dst, cond));
1637 addInstr(env, s390_insn_alu(4, S390_ALU_AND, dst, mask));
1643 addInstr(env, s390_insn_alu(8, S390_ALU_AND, dst, mask));
1650 addInstr(env, s390_insn_alu(4, S390_ALU_LSH, dst, shift));
1651 addInstr(env, s390_insn_alu(4, S390_ALU_RSHA, dst, shift));
1656 addInstr(env, s390_insn_alu(8, S390_ALU_LSH, dst, shift));
1657 addInstr(env, s390_insn_alu(8, S390_ALU_RSHA, dst, shift));
1672 s390_isel_int128_expr(&dst_hi, &dst_lo, env, arg);
1679 s390_isel_int128_expr(&dst_hi, &dst_lo, env, arg);
1683 dst = newVRegI(env); /* Result goes into a new register */
1684 opnd = s390_isel_int_expr_RMI(env, arg); /* Process the operand */
1730 addInstr(env, s390_opnd_copy(8, dst, opnd));
1736 addInstr(env, s390_opnd_copy(4, dst, opnd));
1742 addInstr(env, s390_opnd_copy(2, dst, opnd));
1753 addInstr(env, s390_opnd_copy(size, dst, opnd));
1761 addInstr(env, s390_insn_unop(size, S390_NEGATE, dst, opnd));
1769 addInstr(env, s390_insn_unop(size, S390_NEGATE, dst, opnd));
1770 addInstr(env, s390_insn_alu(size, S390_ALU_OR, dst, opnd));
1772 addInstr(env, s390_insn_alu(size, S390_ALU_RSHA, dst, shift));
1786 addInstr(env, s390_insn_clz(8, r10, r11, opnd));
1787 addInstr(env, s390_insn_move(8, dst, r10));
1795 addInstr(env, insn);
1802 HReg dst = newVRegI(env);
1809 addInstr(env, s390_insn_load(size, dst, am));
1820 HReg dst = newVRegI(env);
1825 doHelperCall(&addToSp, &rloc, env, NULL, expr->Iex.CCall.cee,
1830 addInstr(env, s390_insn_move(sizeof(ULong), dst, ret));
1841 HReg dst = newVRegI(env);
1853 addInstr(env, s390_insn_load_immediate(size, dst, value));
1866 vassert(typeOfIRExpr(env->type_env, cond_expr) == Ity_I1);
1868 dst = newVRegI(env);
1869 r0 = s390_isel_int_expr_RMI(env, expr->Iex.ITE.iffalse);
1870 r1 = s390_isel_int_expr(env, expr->Iex.ITE.iftrue);
1871 size = sizeofIRType(typeOfIRExpr(env->type_env, expr->Iex.ITE.iftrue));
1873 s390_cc_t cc = s390_isel_cc(env, cond_expr);
1875 addInstr(env, s390_insn_move(size, dst, r1));
1876 addInstr(env, s390_insn_cond_move(size, s390_cc_invert(cc), dst, r0));
1892 s390_isel_int_expr(ISelEnv *env, IRExpr *expr)
1894 HReg dst = s390_isel_int_expr_wrk(env, expr);
1905 s390_isel_int_expr_RMI(ISelEnv *env, IRExpr *expr)
1907 IRType ty = typeOfIRExpr(env->type_env, expr);
1915 dst.variant.am = s390_isel_amode(env, expr->Iex.Load.addr);
1938 dst.variant.reg = s390_isel_int_expr(env, expr);
1949 s390_isel_float128_expr_wrk(HReg *dst_hi, HReg *dst_lo, ISelEnv *env,
1952 IRType ty = typeOfIRExpr(env->type_env, expr);
1959 lookupIRTemp128(dst_hi, dst_lo, env, expr->Iex.RdTmp.tmp);
1973 am_hi = s390_isel_amode(env, addr_hi);
1974 am_lo = s390_isel_amode(env, addr_lo);
1976 *dst_hi = newVRegF(env);
1977 *dst_lo = newVRegF(env);
1978 addInstr(env, s390_insn_load(8, *dst_hi, am_hi));
1979 addInstr(env, s390_insn_load(8, *dst_hi, am_lo));
2003 s390_isel_float128_expr(&op1_hi, &op1_lo, env, left); /* 1st operand */
2004 s390_isel_float128_expr(&op2_hi, &op2_lo, env, right); /* 2nd operand */
2013 addInstr(env, s390_insn_move(8, f12, op1_hi));
2014 addInstr(env, s390_insn_move(8, f14, op1_lo));
2017 addInstr(env, s390_insn_move(8, f13, op2_hi));
2018 addInstr(env, s390_insn_move(8, f15, op2_lo));
2029 set_bfp_rounding_mode_in_fpc(env, triop->arg1);
2030 addInstr(env, s390_insn_bfp128_binop(16, bfpop, f12, f14, f13, f15));
2033 *dst_hi = newVRegF(env);
2034 *dst_lo = newVRegF(env);
2035 addInstr(env, s390_insn_move(8, *dst_hi, f12));
2036 addInstr(env, s390_insn_move(8, *dst_lo, f14));
2053 s390_isel_float128_expr(&op_hi, &op_lo, env, expr->Iex.Binop.arg2);
2056 addInstr(env, s390_insn_move(8, f13, op_hi));
2057 addInstr(env, s390_insn_move(8, f15, op_lo));
2059 set_bfp_rounding_mode_in_fpc(env, expr->Iex.Binop.arg1);
2060 addInstr(env, s390_insn_bfp128_unop(16, S390_BFP_SQRT, f12, f14,
2064 *dst_hi = newVRegF(env);
2065 *dst_lo = newVRegF(env);
2066 addInstr(env, s390_insn_move(8, *dst_hi, f12));
2067 addInstr(env, s390_insn_move(8, *dst_lo, f14));
2072 *dst_hi = s390_isel_float_expr(env, expr->Iex.Binop.arg1);
2073 *dst_lo = s390_isel_float_expr(env, expr->Iex.Binop.arg2);
2101 rm = get_dfp_rounding_mode(env, irrm);
2102 h1 = s390_isel_dfp_expr(env, left);
2103 addInstr(env, s390_insn_move(8, f4, h1));
2104 addInstr(env, s390_insn_fp128_convert(16, fpconv, f0, f2,
2107 *dst_hi = newVRegF(env);
2108 *dst_lo = newVRegF(env);
2109 addInstr(env, s390_insn_move(8, *dst_hi, f0));
2110 addInstr(env, s390_insn_move(8, *dst_lo, f2));
2130 rm = get_dfp_rounding_mode(env, irrm);
2131 s390_isel_dfp128_expr(&op_hi, &op_lo, env, left);
2133 addInstr(env, s390_insn_move(8, f4, op_hi));
2134 addInstr(env, s390_insn_move(8, f6, op_lo));
2135 addInstr(env, s390_insn_fp128_convert(16, S390_FP_D128_TO_F128, f0, f2,
2138 *dst_hi = newVRegF(env);
2139 *dst_lo = newVRegF(env);
2140 addInstr(env, s390_insn_move(8, *dst_hi, f0));
2141 addInstr(env, s390_insn_move(8, *dst_lo, f2));
2185 s390_isel_float128_expr(&op_hi, &op_lo, env, left);
2188 addInstr(env, s390_insn_move(8, f13, op_hi));
2189 addInstr(env, s390_insn_move(8, f15, op_lo));
2191 addInstr(env, s390_insn_bfp128_unop(16, bfpop, f12, f14, f13, f15));
2195 op = s390_isel_float_expr(env, left);
2196 addInstr(env, s390_insn_bfp128_convert_to(16, conv, f12, f14, op));
2200 op = s390_isel_int_expr(env, left);
2201 addInstr(env, s390_insn_bfp128_convert_to(16, conv, f12, f14, op));
2206 *dst_hi = newVRegF(env);
2207 *dst_lo = newVRegF(env);
2208 addInstr(env, s390_insn_move(8, *dst_hi, f12));
2209 addInstr(env, s390_insn_move(8, *dst_lo, f14));
2227 s390_isel_float128_expr(HReg *dst_hi, HReg *dst_lo, ISelEnv *env, IRExpr *expr)
2229 s390_isel_float128_expr_wrk(dst_hi, dst_lo, env, expr);
2244 s390_isel_float_expr_wrk(ISelEnv *env, IRExpr *expr)
2246 IRType ty = typeOfIRExpr(env->type_env, expr);
2256 return lookupIRTemp(env, expr->Iex.RdTmp.tmp);
2260 HReg dst = newVRegF(env);
2261 s390_amode *am = s390_isel_amode(env, expr->Iex.Load.addr);
2266 addInstr(env, s390_insn_load(size, dst, am));
2273 HReg dst = newVRegF(env);
2276 addInstr(env, s390_insn_load(size, dst, am));
2287 HReg dst = newVRegF(env);
2299 addInstr(env, s390_insn_load_immediate(size, dst, value));
2309 op3 = s390_isel_float_expr(env, expr->Iex.Qop.details->arg2);
2310 op2 = s390_isel_float_expr(env, expr->Iex.Qop.details->arg3);
2311 op1 = s390_isel_float_expr(env, expr->Iex.Qop.details->arg4);
2312 dst = newVRegF(env);
2313 addInstr(env, s390_insn_move(size, dst, op1));
2325 set_bfp_rounding_mode_in_fpc(env, expr->Iex.Qop.details->arg1);
2326 addInstr(env, s390_insn_bfp_triop(size, bfpop, dst, op2, op3));
2339 h1 = s390_isel_float_expr(env, left); /* Process 1st operand */
2340 op2 = s390_isel_float_expr(env, right); /* Process 2nd operand */
2341 dst = newVRegF(env);
2342 addInstr(env, s390_insn_move(size, dst, h1));
2357 set_bfp_rounding_mode_in_fpc(env, triop->arg1);
2358 addInstr(env, s390_insn_bfp_binop(size, bfpop, dst, op2));
2374 h1 = s390_isel_float_expr(env, left);
2375 dst = newVRegF(env);
2376 set_bfp_rounding_mode_in_fpc(env, irrm);
2377 addInstr(env, s390_insn_bfp_unop(size, S390_BFP_SQRT, dst, h1));
2395 h1 = s390_isel_float_expr(env, left);
2399 h1 = s390_isel_int_expr(env, left);
2406 dst = newVRegF(env);
2408 rounding_mode = get_bfp_rounding_mode(env, irrm);
2410 set_bfp_rounding_mode_in_fpc(env, irrm);
2413 addInstr(env, s390_insn_bfp_convert(size, conv, dst, h1,
2425 h1 = s390_isel_dfp_expr(env, left);
2426 dst = newVRegF(env);
2427 rm = get_dfp_rounding_mode(env, irrm);
2429 addInstr(env, s390_insn_move(8, f4, h1));
2430 addInstr(env, s390_insn_fp_convert(size, fpconv, f0, f4, r1, rm));
2432 addInstr(env, s390_insn_move(8, dst, f0));
2445 s390_isel_dfp128_expr(&op_hi, &op_lo, env, left);
2446 dst = newVRegF(env);
2447 rm = get_dfp_rounding_mode(env, irrm);
2449 addInstr(env, s390_insn_move(8, f4, op_hi));
2450 addInstr(env, s390_insn_move(8, f6, op_lo));
2451 addInstr(env, s390_insn_fp128_convert(16, fpconv, f0, INVALID_HREG,
2454 addInstr(env, s390_insn_move(8, dst, f0));
2469 s390_isel_float128_expr(&op_hi, &op_lo, env, left);
2478 addInstr(env, s390_insn_move(8, f13, op_hi));
2479 addInstr(env, s390_insn_move(8, f15, op_lo));
2486 rounding_mode = get_bfp_rounding_mode(env, irrm);
2488 set_bfp_rounding_mode_in_fpc(env, irrm);
2492 addInstr(env, s390_insn_bfp128_convert_from(size, conv, f12, f14,
2494 dst = newVRegF(env);
2495 addInstr(env, s390_insn_move(8, dst, f12));
2513 s390_isel_float128_expr(&dst_hi, &dst_lo, env, left);
2518 dst = newVRegF(env);
2519 h1 = s390_isel_int_expr(env, left); /* Process the operand */
2520 addInstr(env, s390_insn_move(size, dst, h1));
2546 h1 = s390_isel_float_expr(env, left);
2550 h1 = s390_isel_int_expr(env, left);
2554 dst = newVRegF(env);
2557 addInstr(env, s390_insn_bfp_convert(size, conv, dst, h1,
2566 h1 = s390_isel_float_expr(env, left);
2567 dst = newVRegF(env);
2568 addInstr(env, s390_insn_bfp_unop(size, bfpop, dst, h1));
2584 s390_isel_float_expr(ISelEnv *env, IRExpr *expr)
2586 HReg dst = s390_isel_float_expr_wrk(env, expr);
2600 s390_isel_dfp128_expr_wrk(HReg *dst_hi, HReg *dst_lo, ISelEnv *env,
2603 IRType ty = typeOfIRExpr(env->type_env, expr);
2610 lookupIRTemp128(dst_hi, dst_lo, env, expr->Iex.RdTmp.tmp);
2624 am_hi = s390_isel_amode(env, addr_hi);
2625 am_lo = s390_isel_amode(env, addr_lo);
2627 *dst_hi = newVRegF(env);
2628 *dst_lo = newVRegF(env);
2629 addInstr(env, s390_insn_load(8, *dst_hi, am_hi));
2630 addInstr(env, s390_insn_load(8, *dst_hi, am_lo));
2673 s390_isel_dfp128_expr(&op1_hi, &op1_lo, env, left);
2675 addInstr(env, s390_insn_move(8, f9, op1_hi));
2676 addInstr(env, s390_insn_move(8, f11, op1_lo));
2679 s390_isel_dfp128_expr(&op2_hi, &op2_lo, env, right);
2681 addInstr(env, s390_insn_move(8, f12, op2_hi));
2682 addInstr(env, s390_insn_move(8, f14, op2_lo));
2688 rounding_mode = get_dfp_rounding_mode(env, irrm);
2690 set_dfp_rounding_mode_in_fpc(env, irrm);
2693 addInstr(env, s390_insn_dfp128_binop(16, dfpop, f13, f15, f9, f11,
2696 *dst_hi = newVRegF(env);
2697 *dst_lo = newVRegF(env);
2698 addInstr(env, s390_insn_move(8, *dst_hi, f13));
2699 addInstr(env, s390_insn_move(8, *dst_lo, f15));
2705 HReg op1 = s390_isel_int_expr(env, left);
2707 s390_isel_dfp128_expr(&op2_hi, &op2_lo, env, right);
2709 addInstr(env, s390_insn_move(8, f12, op2_hi));
2710 addInstr(env, s390_insn_move(8, f14, op2_lo));
2712 rounding_mode = get_dfp_rounding_mode(env, irrm);
2713 addInstr(env, s390_insn_dfp128_reround(16, f13, f15, op1, f12, f14,
2716 *dst_hi = newVRegF(env);
2717 *dst_lo = newVRegF(env);
2718 addInstr(env, s390_insn_move(8, *dst_hi, f13));
2719 addInstr(env, s390_insn_move(8, *dst_lo, f15));
2733 *dst_hi = s390_isel_dfp_expr(env, expr->Iex.Binop.arg1);
2734 *dst_lo = s390_isel_dfp_expr(env, expr->Iex.Binop.arg2);
2772 s390_isel_dfp128_expr(&op1_hi, &op1_lo, env, dfp_op);
2774 addInstr(env, s390_insn_move(8, f9, op1_hi));
2775 addInstr(env, s390_insn_move(8, f11, op1_lo));
2777 op2 = s390_isel_int_expr(env, int_op); /* int operand */
2779 addInstr(env,
2783 *dst_hi = newVRegF(env);
2784 *dst_lo = newVRegF(env);
2785 addInstr(env, s390_insn_move(8, *dst_hi, f13));
2786 addInstr(env, s390_insn_move(8, *dst_lo, f15));
2815 rm = get_dfp_rounding_mode(env, irrm);
2816 h1 = s390_isel_float_expr(env, left);
2817 addInstr(env, s390_insn_move(8, f4, h1));
2818 addInstr(env, s390_insn_fp128_convert(16, fpconv, f0, f2,
2821 *dst_hi = newVRegF(env);
2822 *dst_lo = newVRegF(env);
2823 addInstr(env, s390_insn_move(8, *dst_hi, f0));
2824 addInstr(env, s390_insn_move(8, *dst_lo, f2));
2844 rm = get_dfp_rounding_mode(env, irrm);
2845 s390_isel_float128_expr(&op_hi, &op_lo, env, left);
2847 addInstr(env, s390_insn_move(8, f4, op_hi));
2848 addInstr(env, s390_insn_move(8, f6, op_lo));
2849 addInstr(env, s390_insn_fp128_convert(16, S390_FP_F128_TO_D128, f0, f2,
2852 *dst_hi = newVRegF(env);
2853 *dst_lo = newVRegF(env);
2854 addInstr(env, s390_insn_move(8, *dst_hi, f0));
2855 addInstr(env, s390_insn_move(8, *dst_lo, f2));
2886 op = s390_isel_dfp_expr(env, left);
2887 addInstr(env, s390_insn_dfp128_convert_to(16, conv, f12, f14, op));
2891 op = s390_isel_int_expr(env, left);
2892 addInstr(env, s390_insn_dfp128_convert_to(16, conv, f12, f14, op));
2897 *dst_hi = newVRegF(env);
2898 *dst_lo = newVRegF(env);
2899 addInstr(env, s390_insn_move(8, *dst_hi, f12));
2900 addInstr(env, s390_insn_move(8, *dst_lo, f14));
2920 s390_isel_dfp128_expr(HReg *dst_hi, HReg *dst_lo, ISelEnv *env, IRExpr *expr)
2922 s390_isel_dfp128_expr_wrk(dst_hi, dst_lo, env, expr);
2937 s390_isel_dfp_expr_wrk(ISelEnv *env, IRExpr *expr)
2939 IRType ty = typeOfIRExpr(env->type_env, expr);
2949 return lookupIRTemp(env, expr->Iex.RdTmp.tmp);
2953 HReg dst = newVRegF(env);
2954 s390_amode *am = s390_isel_amode(env, expr->Iex.Load.addr);
2959 addInstr(env, s390_insn_load(size, dst, am));
2966 HReg dst = newVRegF(env);
2969 addInstr(env, s390_insn_load(size, dst, am));
2995 h1 = s390_isel_dfp_expr(env, left);
2999 h1 = s390_isel_int_expr(env, left);
3006 dst = newVRegF(env);
3008 rounding_mode = get_dfp_rounding_mode(env, irrm);
3010 set_dfp_rounding_mode_in_fpc(env, irrm);
3013 addInstr(env, s390_insn_dfp_convert(size, conv, dst, h1,
3025 h1 = s390_isel_float_expr(env, left);
3026 dst = newVRegF(env);
3027 rm = get_dfp_rounding_mode(env, irrm);
3029 addInstr(env, s390_insn_move(8, f4, h1));
3030 addInstr(env, s390_insn_fp_convert(size, fpconv, f0, f4, r1, rm));
3032 addInstr(env, s390_insn_move(8, dst, f0));
3045 s390_isel_float128_expr(&op_hi, &op_lo, env, left);
3046 dst = newVRegF(env);
3047 rm = get_dfp_rounding_mode(env, irrm);
3049 addInstr(env, s390_insn_move(8, f4, op_hi));
3050 addInstr(env, s390_insn_move(8, f6, op_lo));
3051 addInstr(env, s390_insn_fp128_convert(16, fpconv, f0, INVALID_HREG,
3054 addInstr(env, s390_insn_move(8, dst, f0));
3064 s390_isel_dfp128_expr(&op_hi, &op_lo, env, left);
3073 addInstr(env, s390_insn_move(8, f13, op_hi));
3074 addInstr(env, s390_insn_move(8, f15, op_lo));
3081 rounding_mode = get_dfp_rounding_mode(env, irrm);
3083 set_dfp_rounding_mode_in_fpc(env, irrm);
3086 addInstr(env, s390_insn_dfp128_convert_from(size, conv, f12, f14,
3088 dst = newVRegF(env);
3089 addInstr(env, s390_insn_move(8, dst, f12));
3122 op2 = s390_isel_int_expr(env, int_op);
3123 op3 = s390_isel_dfp_expr(env, dfp_op);
3124 dst = newVRegF(env);
3126 addInstr(env, s390_insn_dfp_intop(size, intop, dst, op2, op3));
3145 s390_isel_dfp128_expr(&dst_hi, &dst_lo, env, left);
3150 dst = newVRegF(env);
3151 h1 = s390_isel_int_expr(env, left); /* Process the operand */
3152 addInstr(env, s390_insn_move(size, dst, h1));
3163 h1 = s390_isel_dfp_expr(env, left);
3167 h1 = s390_isel_int_expr(env, left);
3171 dst = newVRegF(env);
3174 addInstr(env, s390_insn_dfp_convert(size, conv, dst, h1,
3202 op2 = s390_isel_dfp_expr(env, left); /* Process 1st operand */
3203 op3 = s390_isel_dfp_expr(env, right); /* Process 2nd operand */
3204 dst = newVRegF(env);
3209 rounding_mode = get_dfp_rounding_mode(env, irrm);
3211 set_dfp_rounding_mode_in_fpc(env, irrm);
3214 addInstr(env, s390_insn_dfp_binop(size, dfpop, dst, op2, op3,
3220 op2 = s390_isel_int_expr(env, left); /* Process 1st operand */
3221 op3 = s390_isel_dfp_expr(env, right); /* Process 2nd operand */
3222 dst = newVRegF(env);
3223 rounding_mode = get_dfp_rounding_mode(env, irrm);
3224 addInstr(env, s390_insn_dfp_reround(size, dst, op2, op3,
3244 s390_isel_dfp_expr(ISelEnv *env, IRExpr *expr)
3246 HReg dst = s390_isel_dfp_expr_wrk(env, expr);
3262 s390_isel_cc(ISelEnv *env, IRExpr *cond)
3266 vassert(typeOfIRExpr(env->type_env, cond) == Ity_I1);
3280 HReg reg = lookupIRTemp(env, tmp);
3283 if (typeOfIRTemp(env->type_env, tmp) == Ity_I1)
3286 size = sizeofIRType(typeOfIRTemp(env->type_env, tmp));
3287 addInstr(env, s390_insn_test(size, s390_opnd_reg(reg)));
3298 return s390_cc_invert(s390_isel_cc(env, arg));
3303 HReg dst = newVRegI(env);
3304 HReg h1 = s390_isel_int_expr(env, arg);
3306 size = sizeofIRType(typeOfIRExpr(env->type_env, arg));
3308 addInstr(env, s390_insn_move(size, dst, h1));
3309 addInstr(env, s390_insn_alu(size, S390_ALU_AND, dst, s390_opnd_imm(1)));
3310 addInstr(env, s390_insn_test(size, s390_opnd_reg(dst)));
3322 dst = newVRegI(env);
3323 src = s390_isel_int_expr_RMI(env, arg);
3324 addInstr(env, s390_insn_unop(4, op, dst, src));
3325 addInstr(env, s390_insn_test(4, s390_opnd_reg(dst)));
3333 src = s390_isel_int_expr_RMI(env, arg);
3334 size = sizeofIRType(typeOfIRExpr(env->type_env, arg));
3335 addInstr(env, s390_insn_test(size, src));
3350 size = sizeofIRType(typeOfIRExpr(env->type_env, arg1));
3383 op1 = s390_isel_int_expr_RMI(env, arg1);
3384 reg1 = newVRegI(env);
3385 addInstr(env, s390_insn_unop(4, op, reg1, op1));
3387 op2 = s390_isel_int_expr_RMI(env, arg2);
3388 reg2 = newVRegI(env);
3389 addInstr(env, s390_insn_unop(4, op, reg2, op2)); /* zero extend */
3392 addInstr(env, s390_insn_compare(4, reg1, op2, False));
3417 op1 = s390_isel_int_expr(env, arg1);
3418 op2 = s390_isel_int_expr_RMI(env, arg2);
3420 addInstr(env, s390_insn_compare(size, op1, op2, False));
3432 op1 = s390_isel_int_expr(env, arg1);
3433 op2 = s390_isel_int_expr_RMI(env, arg2);
3435 addInstr(env, s390_insn_compare(size, op1, op2, True));
3448 op1 = s390_isel_int_expr(env, arg1);
3449 op2 = s390_isel_int_expr_RMI(env, arg2);
3451 addInstr(env, s390_insn_compare(size, op1, op2, False));
3473 s390_isel_stmt(ISelEnv *env, IRStmt *stmt)
3485 IRType tyd = typeOfIRExpr(env->type_env, stmt->Ist.Store.data);
3491 am = s390_isel_amode(env, stmt->Ist.Store.addr);
3503 addInstr(env, s390_insn_mimm(sizeofIRType(tyd), am, value));
3515 addInstr(env, s390_insn_memcpy(sizeofIRType(tyd), am, from));
3519 src = s390_isel_int_expr(env, stmt->Ist.Store.data);
3524 src = s390_isel_float_expr(env, stmt->Ist.Store.data);
3529 src = s390_isel_dfp_expr(env, stmt->Ist.Store.data);
3541 addInstr(env, s390_insn_store(sizeofIRType(tyd), am, src));
3547 IRType tyd = typeOfIRExpr(env->type_env, stmt->Ist.Put.data);
3568 env->old_value_valid[guest_reg] = False;
3578 old_value = env->old_value[guest_reg];
3580 env->old_value[guest_reg] = new_value;
3582 Bool old_value_is_valid = env->old_value_valid[guest_reg];
3583 env->old_value_valid[guest_reg] = True;
3599 addInstr(env, s390_insn_madd(sizeofIRType(tyd), am,
3607 addInstr(env, s390_insn_mimm(4, am, new_value & 0xFFFFFFFF));
3625 addInstr(env, s390_insn_mimm(sizeofIRType(tyd), am, value));
3635 s390_amode *from = s390_isel_amode(env, data);
3640 addInstr(env, s390_insn_memcpy(size, am, from));
3644 src = newVRegI(env);
3645 addInstr(env, s390_insn_load(size, src, from));
3658 addInstr(env, s390_insn_memcpy(size, am, from));
3665 src = s390_isel_int_expr(env, stmt->Ist.Put.data);
3670 src = s390_isel_float_expr(env, stmt->Ist.Put.data);
3680 src = s390_isel_dfp_expr(env, stmt->Ist.Put.data);
3687 addInstr(env, s390_insn_store(sizeofIRType(tyd), am, src));
3694 IRType tyd = typeOfIRTemp(env->type_env, tmp);
3701 s390_isel_int128_expr(&res_hi, &res_lo, env, stmt->Ist.WrTmp.data);
3702 lookupIRTemp128(&dst_hi, &dst_lo, env, tmp);
3704 addInstr(env, s390_insn_move(8, dst_hi, res_hi));
3705 addInstr(env, s390_insn_move(8, dst_lo, res_lo));
3713 src = s390_isel_int_expr(env, stmt->Ist.WrTmp.data);
3714 dst = lookupIRTemp(env, tmp);
3718 s390_cc_t cond = s390_isel_cc(env, stmt->Ist.WrTmp.data);
3719 dst = lookupIRTemp(env, tmp);
3720 addInstr(env, s390_insn_cc2bool(dst, cond));
3726 src = s390_isel_float_expr(env, stmt->Ist.WrTmp.data);
3727 dst = lookupIRTemp(env, tmp);
3733 s390_isel_float128_expr(&res_hi, &res_lo, env, stmt->Ist.WrTmp.data);
3734 lookupIRTemp128(&dst_hi, &dst_lo, env, tmp);
3736 addInstr(env, s390_insn_move(8, dst_hi, res_hi));
3737 addInstr(env, s390_insn_move(8, dst_lo, res_lo));
3743 src = s390_isel_dfp_expr(env, stmt->Ist.WrTmp.data);
3744 dst = lookupIRTemp(env, tmp);
3750 s390_isel_dfp128_expr(&res_hi, &res_lo, env, stmt->Ist.WrTmp.data);
3751 lookupIRTemp128(&dst_hi, &dst_lo, env, tmp);
3753 addInstr(env, s390_insn_move(8, dst_hi, res_hi));
3754 addInstr(env, s390_insn_move(8, dst_lo, res_lo));
3762 addInstr(env, s390_insn_move(sizeofIRType(tyd), dst, src));
3784 env->old_value_valid[guest_reg] = False;
3791 doHelperCall(&addToSp, &rloc, env, d->guard, d->cee, retty,
3800 retty = typeOfIRTemp(env->type_env, d->tmp);
3806 dst = lookupIRTemp(env, d->tmp);
3807 doHelperCall(&addToSp, &rloc, env, d->guard, d->cee, retty,
3812 addInstr(env, s390_insn_move(sizeof(ULong), dst, ret));
3822 s390_amode *op2 = s390_isel_amode_b12_b20(env, cas->addr);
3823 HReg op3 = s390_isel_int_expr(env, cas->dataLo); /* new value */
3824 HReg op1 = s390_isel_int_expr(env, cas->expdLo); /* expected value */
3825 HReg old = lookupIRTemp(env, cas->oldLo);
3827 if (typeOfIRTemp(env->type_env, cas->oldLo) == Ity_I32) {
3828 addInstr(env, s390_insn_cas(4, op1, op2, op3, old));
3830 addInstr(env, s390_insn_cas(8, op1, op2, op3, old));
3835 s390_amode *op2 = s390_isel_amode_b12_b20(env, cas->addr);
3837 HReg op3_high = s390_isel_int_expr(env, cas->dataHi); /* new value */
3838 HReg op3_low = s390_isel_int_expr(env, cas->dataLo); /* new value */
3839 HReg op1_high = s390_isel_int_expr(env, cas->expdHi); /* expected value */
3840 HReg op1_low = s390_isel_int_expr(env, cas->expdLo); /* expected value */
3841 HReg old_low = lookupIRTemp(env, cas->oldLo);
3842 HReg old_high = lookupIRTemp(env, cas->oldHi);
3848 addInstr(env, s390_insn_move(8, r8, op1_high));
3849 addInstr(env, s390_insn_move(8, r9, op1_low));
3855 addInstr(env, s390_insn_move(8, r10, op3_high));
3856 addInstr(env, s390_insn_move(8, r11, op3_low));
3861 if (typeOfIRTemp(env->type_env, cas->oldLo) == Ity_I32) {
3862 addInstr(env, s390_insn_cdas(4, r8, r9, op2, r10, r11,
3865 addInstr(env, s390_insn_cdas(8, r8, r9, op2, r10, r11,
3868 addInstr(env, s390_insn_move(8, op1_high, r8));
3869 addInstr(env, s390_insn_move(8, op1_low, r9));
3870 addInstr(env, s390_insn_move(8, op3_high, r10));
3871 addInstr(env, s390_insn_move(8, op3_low, r11));
3885 cond = s390_isel_cc(env, stmt->Ist.Exit.guard);
3889 if (env->chaining_allowed) {
3894 = ((Addr64)stmt->Ist.Exit.dst->Ico.U64) > env->max_ga;
3896 addInstr(env, s390_insn_xdirect(cond, stmt->Ist.Exit.dst->Ico.U64,
3902 HReg dst = s390_isel_int_expr(env,
3904 addInstr(env, s390_insn_xassisted(cond, dst, guest_IA, Ijk_Boring));
3920 HReg dst = s390_isel_int_expr(env, IRExpr_Const(stmt->Ist.Exit.dst));
3921 addInstr(env, s390_insn_xassisted(cond, dst, guest_IA,
3937 addInstr(env, s390_insn_mfence());
3967 iselNext(ISelEnv *env, IRExpr *next, IRJumpKind jk, Int offsIP)
3985 if (env->chaining_allowed) {
3990 = ((Addr64)cdst->Ico.U64) > env->max_ga;
3992 addInstr(env, s390_insn_xdirect(S390_CC_ALWAYS, cdst->Ico.U64,
3998 HReg dst = s390_isel_int_expr(env, next);
3999 addInstr(env, s390_insn_xassisted(S390_CC_ALWAYS, dst, guest_IA,
4011 HReg dst = s390_isel_int_expr(env, next);
4012 if (env->chaining_allowed) {
4013 addInstr(env, s390_insn_xindir(S390_CC_ALWAYS, dst, guest_IA));
4015 addInstr(env, s390_insn_xassisted(S390_CC_ALWAYS, dst, guest_IA,
4035 HReg dst = s390_isel_int_expr(env, next);
4036 addInstr(env, s390_insn_xassisted(S390_CC_ALWAYS, dst, guest_IA, jk));
4063 ISelEnv *env;
4073 env = LibVEX_Alloc_inline(sizeof(ISelEnv));
4074 env->vreg_ctr = 0;
4077 env->code = newHInstrArray();
4079 /* Copy BB's type env. */
4080 env->type_env = bb->tyenv;
4084 env->old_value[i] = 0; /* just something to have a defined value */
4085 env->old_value_valid[i] = False;
4094 env->n_vregmap = bb->tyenv->types_used;
4095 env->vregmap = LibVEX_Alloc_inline(env->n_vregmap * sizeof(HReg));
4096 env->vregmapHI = LibVEX_Alloc_inline(env->n_vregmap * sizeof(HReg));
4098 env->previous_bfp_rounding_mode = NULL;
4099 env->previous_dfp_rounding_mode = NULL;
4102 env->hwcaps = hwcaps_host;
4104 env->max_ga = max_ga;
4105 env->chaining_allowed = chaining_allowed;
4110 for (i = 0; i < env->n_vregmap; i++) {
4145 env->vregmap[i] = hreg;
4146 env->vregmapHI[i] = hregHI;
4148 env->vreg_ctr = j;
4154 addInstr(env, s390_insn_evcheck(counter, fail_addr));
4161 addInstr(env, s390_insn_profinc());
4167 s390_isel_stmt(env, bb->stmts[i]);
4169 iselNext(env, bb->next, bb->jumpkind, bb->offsIP);
4172 env->code->n_vregs = env->vreg_ctr;
4174 return env->code;
