Lines Matching refs:mode64
61 GPR11 if mode64: not used - calls by ptr / env ptr for some langs
62 GPR12 if mode64: not used - exceptions / global linkage code
70 if (mode64)
85 if (mode64)
286 Bool mode64;
323 vassert(!env->mode64);
337 ppPPCInstr(instr, env->mode64);
345 = mkHReg(True/*vreg*/, HRcGPR(env->mode64), 0/*enc*/, env->vreg_ctr);
525 HReg sp = StackFramePtr(env->mode64);
533 HReg sp = StackFramePtr(env->mode64);
549 addInstr(env, mk_iMOVds_RR(r, StackFramePtr(env->mode64)));
555 PPCInstr_LI(align16, 0xFFFFFFFFFFFFFFF0ULL, env->mode64));
569 vassert(!env->mode64);
574 am_addr0 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
575 am_addr1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
578 addInstr(env, PPCInstr_Store( 4, am_addr0, r_srcHi, env->mode64 ));
579 addInstr(env, PPCInstr_Store( 4, am_addr1, r_srcLo, env->mode64 ));
594 vassert(env->mode64);
598 am_addr0 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
601 addInstr(env, PPCInstr_Store( 8, am_addr0, r_src, env->mode64 ));
676 env->mode64 ? False : True/*F:64-bit, T:32-bit shift*/,
684 PPCAMode_RR( GuestStatePtr(env->mode64), rtmp );
730 Bool mode64 = env->mode64;
746 (mode32:32 | mode64:64) integer bits in total can be passed.
747 In fact the only supported arg type is (mode32:I32 | mode64:I64).
813 argregs[0] = hregPPC_GPR3(mode64);
814 argregs[1] = hregPPC_GPR4(mode64);
815 argregs[2] = hregPPC_GPR5(mode64);
816 argregs[3] = hregPPC_GPR6(mode64);
817 argregs[4] = hregPPC_GPR7(mode64);
818 argregs[5] = hregPPC_GPR8(mode64);
819 argregs[6] = hregPPC_GPR9(mode64);
820 argregs[7] = hregPPC_GPR10(mode64);
884 GuestStatePtr(mode64) ));
890 if (!mode64) {
909 } else { // mode64
940 addInstr(env, mk_iMOVds_RR( r_vecRetAddr, StackFramePtr(mode64) ));
947 addInstr(env, mk_iMOVds_RR( r_vecRetAddr, StackFramePtr(mode64) ));
958 GuestStatePtr(mode64) ));
971 if (!mode64) {
984 } else { // mode64
1036 *retloc = mk_RetLoc_simple(mode64 ? RLPri_Int : RLPri_2Int);
1062 Addr64 target = mode64 ? (Addr)cee->addr
1084 // addInstr(env, PPCInstr_LI(r_src, 0x0, env->mode64));
1085 // if (env->mode64) {
1113 vassert(hregClass(r_rmIR) == HRcGPR(env->mode64));
1192 if (env->mode64) {
1205 addInstr( env, PPCInstr_LI( r_zero, 0, env->mode64 ) );
1305 addInstr(env, PPCInstr_LI(r_src, (Long)simm32, env->mode64));
1326 addInstr(env, PPCInstr_Store( num_bytes_to_store, am_offset, r_src, env->mode64 ));
1377 All results are returned in a (mode64 ? 64bit : 32bit) register.
1391 vassert(hregClass(r) == HRcGPR(env->mode64));
1400 Bool mode64 = env->mode64;
1406 ty == Ity_I32 || ((ty == Ity_I64) && mode64));
1424 r_dst, am_addr, mode64 ));
1491 if (!mode64)
1518 vassert(mode64);
1555 vassert(mode64);
1583 if (mode64
1628 vassert(mode64);
1655 vassert(mode64);
1659 addInstr(env, PPCInstr_LI(msk, 0xFFFFFFFF, mode64));
1749 /* This works in both mode64 and mode32. */
1750 HReg r1 = StackFramePtr(env->mode64);
1766 addInstr(env, PPCInstr_Load(4, idst, zero_r1, mode64));
1769 if (mode64)
1780 if (mode64) {
1781 HReg r1 = StackFramePtr(env->mode64);
1797 addInstr(env, PPCInstr_Load(8, idst, zero_r1, True/*mode64*/));
1807 HReg r1 = StackFramePtr(env->mode64);
1818 addInstr(env, PPCInstr_Load(8, idst, zero_r1, mode64));
1833 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
1843 addInstr(env, PPCInstr_Load(8, idst, zero_r1, True/*mode64*/));
1877 addInstr(env, PPCInstr_Load(2,r_dst,amode, mode64));
1899 vassert(mode64);
1927 vassert(mode64);
1939 vassert(mode64);
1951 if (op_unop == Iop_Not64) vassert(mode64);
1958 if (!mode64) {
1972 if (!mode64) {
1982 if (mode64) { /* This is a no-op. */
1998 if (mode64) {
2005 if (mode64) {
2014 if ((op_unop != Iop_1Uto64) || mode64) {
2037 if (mode64) {
2054 if (op_unop == Iop_Clz64 && !mode64)
2068 if (op_unop == Iop_Left64 && !mode64)
2090 if (!mode64) goto irreducible;
2125 PPCInstr_Load( 4, dst, am_off_word0, mode64 ));
2133 if (mode64) {
2163 mode64 ));
2180 if (mode64) {
2186 am_addr = PPCAMode_IR( 0, StackFramePtr(mode64) );
2192 addInstr(env, PPCInstr_Load( 8, r_dst, am_addr, mode64 ));
2210 am_addr = PPCAMode_IR( 0, StackFramePtr(mode64) );
2216 addInstr(env, PPCInstr_Load( 4, r_dst, am_addr, mode64 ));
2224 if (mode64) {
2230 am_addr = PPCAMode_IR( 0, StackFramePtr(mode64) );
2236 addInstr(env, PPCInstr_Load( 8, r_dst, am_addr, mode64 ));
2244 if (!mode64) break;
2254 argregs[0] = hregPPC_GPR3(mode64);
2280 if (!mode64) break;
2290 argregs[0] = hregPPC_GPR3(mode64);
2325 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
2331 addInstr(env, PPCInstr_Load(8, fr_dst, zero_r1, env->mode64));
2340 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
2349 addInstr(env, PPCInstr_Load(8, fr_dst, zero_r1, env->mode64));
2363 ty == Ity_I32 || ((ty == Ity_I64) && mode64)) {
2366 GuestStatePtr(mode64) );
2368 r_dst, am_addr, mode64 ));
2380 if (mode64 && ty == Ity_I64) {
2382 r_dst, src_am, mode64 ));
2385 if ((!mode64) && ty == Ity_I32) {
2387 r_dst, src_am, mode64 ));
2399 if (!(ty == Ity_I32 || (mode64 && ty == Ity_I64)))
2414 addInstr(env, mk_iMOVds_RR(r_dst, hregPPC_GPR3(mode64)));
2425 case Ico_U64: if (!mode64) goto irreducible;
2432 addInstr(env, PPCInstr_LI(r_dst, (ULong)l, mode64));
2439 ty == Ity_I32 || ((ty == Ity_I64) && mode64)) &&
2500 Bool mode64 = env->mode64;
2505 return toBool( hregClass(am->Pam.IR.base) == HRcGPR(mode64) &&
2509 return toBool( hregClass(am->Pam.RR.base) == HRcGPR(mode64) &&
2511 hregClass(am->Pam.RR.index) == HRcGPR(mode64) &&
2533 if (env->mode64) {
2622 vassert(hregClass(ri->Prh.Reg.reg) == HRcGPR(env->mode64));
2638 ty == Ity_I32 || ((ty == Ity_I64) && env->mode64));
2646 case Ico_U64: vassert(env->mode64);
2683 vassert(hregClass(ri->Pri.Reg) == HRcGPR(env->mode64));
2698 ty == Ity_I32 || ((ty == Ity_I64) && env->mode64));
2704 case Ico_U64: vassert(env->mode64);
2729 vassert(!env->mode64);
2738 vassert(hregClass(ri->Prh.Reg.reg) == HRcGPR(env->mode64));
2776 vassert(env->mode64);
2785 vassert(hregClass(ri->Prh.Reg.reg) == HRcGPR(env->mode64));
2837 addInstr(env, PPCInstr_LI(r_zero, 0, env->mode64));
2926 if (!env->mode64) {
2934 } else { // mode64
2956 vassert(env->mode64);
3018 vassert(env->mode64);
3023 vassert(hregClass(*rHi) == HRcGPR(env->mode64));
3025 vassert(hregClass(*rLo) == HRcGPR(env->mode64));
3098 vassert(!env->mode64);
3156 vassert(!env->mode64);
3180 vassert(!env->mode64);
3313 HReg r1 = StackFramePtr(env->mode64);
3320 vassert(!env->mode64);
3342 HReg r1 = StackFramePtr(env->mode64);
3348 vassert(!env->mode64);
3368 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
3369 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
3421 vassert(env->mode64 == False);
3422 addInstr(env, PPCInstr_LI(zero32, 0, env->mode64));
3451 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
3452 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
3472 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
3473 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
3657 Bool mode64 = env->mode64;
3659 argregs[0] = hregPPC_GPR3(mode64);
3660 argregs[1] = hregPPC_GPR4(mode64);
3681 target = mode64 ? (Addr)h_calc_BCDtoDPB :
3705 Bool mode64 = env->mode64;
3707 argregs[0] = hregPPC_GPR3(mode64);
3708 argregs[1] = hregPPC_GPR4(mode64);
3729 target = mode64 ? (Addr)h_calc_DPBtoBCD :
3775 Bool mode64 = env->mode64;
3797 GuestStatePtr(env->mode64) );
3833 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
3847 if (mode64) {
3850 HReg r1 = StackFramePtr(env->mode64);
3858 addInstr(env, PPCInstr_Store(8, zero_r1, isrc, True/*mode64*/));
3873 HReg r1 = StackFramePtr(env->mode64);
3947 Bool mode64 = env->mode64;
3973 if (!mode64) {
3976 addInstr(env, PPCInstr_LI(r_srcHi, u.u32x2[0], mode64));
3977 addInstr(env, PPCInstr_LI(r_srcLo, u.u32x2[1], mode64));
3979 } else { // mode64
3981 addInstr(env, PPCInstr_LI(r_src, u.u64, mode64));
4001 GuestStatePtr(mode64) );
4082 if (mode64) {
4085 HReg r1 = StackFramePtr(env->mode64);
4093 addInstr(env, PPCInstr_Store(8, zero_r1, isrc, True/*mode64*/));
4109 HReg r1 = StackFramePtr(env->mode64);
4164 if (!mode64) {
4185 am_addr = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4188 addInstr(env, PPCInstr_Store( 4, am_addr, src, env->mode64 ));
4238 Bool mode64 = env->mode64;
4248 GuestStatePtr(mode64) );
4290 Bool mode64 = env->mode64;
4305 GuestStatePtr(mode64) );
4332 if (!mode64) {
4411 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4417 if (mode64) {
4420 addInstr(env, PPCInstr_Store(8, zero_r1, tmp, True/*mode64*/));
4423 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
4463 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4466 if (env->mode64) {
4470 addInstr(env, PPCInstr_Store(8, zero_r1, tmp, True/*mode64*/));
4475 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
4479 addInstr(env, PPCInstr_Store(4, zero_r1, tmpHi, False/*!mode64*/));
4480 addInstr(env, PPCInstr_Store(4, four_r1, tmpLo, False/*!mode64*/));
4539 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4544 if (mode64)
4545 addInstr(env, PPCInstr_Store(8, zero_r1, i8_val, True/*mode64*/));
4589 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4592 if (env->mode64) {
4594 addInstr(env, PPCInstr_Store(8, zero_r1, tmp, True/*mode64*/));
4597 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
4693 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4701 if (env->mode64) {
4703 addInstr(env, PPCInstr_Store(8, zero_r1, tmp, True/*mode64*/));
4706 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
4792 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4793 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
4807 if (env->mode64)
4808 addInstr(env, PPCInstr_Store(4, four_r1, i8_val, True/*mode64*/));
4815 addInstr( env, PPCInstr_LI( r_zero, 0, env->mode64 ) );
4853 Bool mode64 = env->mode64;
4871 GuestStatePtr(mode64) )));
5014 addInstr(env, PPCInstr_LI(r_zeros, 0x0, mode64));
5016 addInstr(env, PPCInstr_Store( 4, am_off0, r_src, mode64 ));
5018 addInstr(env, PPCInstr_Store( 4, am_off0, r_zeros, mode64 ));
5019 addInstr(env, PPCInstr_Store( 4, am_off4, r_zeros, mode64 ));
5020 addInstr(env, PPCInstr_Store( 4, am_off8, r_zeros, mode64 ));
5024 addInstr(env, PPCInstr_Store( 4, am_off12, r_zeros, mode64 ));
5026 addInstr(env, PPCInstr_Store( 4, am_off12, r_src, mode64 ));
5073 if (!mode64) {
5089 addInstr(env, PPCInstr_Store( 4, am_off12, r0, mode64 ));
5090 addInstr(env, PPCInstr_Store( 4, am_off8, r1, mode64 ));
5093 addInstr(env, PPCInstr_Store( 4, am_off4, r2, mode64 ));
5094 addInstr(env, PPCInstr_Store( 4, am_off0, r3, mode64 ));
5117 addInstr(env, PPCInstr_Store( 8, am_off0, rLo, mode64 ));
5118 addInstr(env, PPCInstr_Store( 8, am_off8, rHi, mode64 ));
5120 addInstr(env, PPCInstr_Store( 8, am_off0, rHi, mode64 ));
5121 addInstr(env, PPCInstr_Store( 8, am_off8, rLo, mode64 ));
5448 LibVEX_ppVexHwCaps(mode64 ? VexArchPPC64 : VexArchPPC32,
5461 Bool mode64 = env->mode64;
5478 if (!mode64 && (tya != Ity_I32))
5480 if (mode64 && (tya != Ity_I64))
5484 (mode64 && (tyd == Ity_I64))) {
5490 am_addr, r_src, mode64 ));
5538 if (tyd == Ity_I64 && !mode64) {
5563 ty == Ity_I32 || ((ty == Ity_I64) && mode64)) {
5566 GuestStatePtr(mode64) );
5568 am_addr, r_src, mode64 ));
5571 if (!mode64 && ty == Ity_I64) {
5574 GuestStatePtr(mode64) );
5577 addInstr(env, PPCInstr_Store( 4, am_addr, rHi, mode64 ));
5578 addInstr(env, PPCInstr_Store( 4, am_addr4, rLo, mode64 ));
5586 GuestStatePtr(mode64) );
5594 GuestStatePtr(mode64) );
5603 GuestStatePtr(mode64) );
5611 GuestStatePtr(mode64) );
5628 if (mode64 && ty == Ity_I64) {
5631 dst_am, r_src, mode64 ));
5634 if ((!mode64) && ty == Ity_I32) {
5637 dst_am, r_src, mode64 ));
5648 ty == Ity_I32 || ((ty == Ity_I64) && mode64)) {
5654 if (!mode64 && ty == Ity_I64) {
5664 if (mode64 && ty == Ity_I128) {
5673 if (!mode64 && ty == Ity_I128) {
5748 if (!mode64 && (tyAddr != Ity_I32))
5750 if (mode64 && (tyAddr != Ity_I64))
5758 addInstr(env, PPCInstr_LoadL( 1, r_dst, r_addr, mode64 ));
5762 addInstr(env, PPCInstr_LoadL( 2, r_dst, r_addr, mode64 ));
5766 addInstr(env, PPCInstr_LoadL( 4, r_dst, r_addr, mode64 ));
5769 if (tyRes == Ity_I64 && mode64) {
5770 addInstr(env, PPCInstr_LoadL( 8, r_dst, r_addr, mode64 ));
5785 (tyData == Ity_I64 && mode64)) {
5798 r_a, r_src, mode64 ));
5802 env->mode64 ? False : True
5833 mode, so we don't need to inspect mode64 to make a
5869 addInstr(env, mk_iMOVds_RR(r_dst, hregPPC_GPR3(mode64)));
5875 if (mode64) {
5879 addInstr(env, mk_iMOVds_RR(r_dst, hregPPC_GPR3(mode64)));
5888 addInstr(env, mk_iMOVds_RR(r_dstHi, hregPPC_GPR3(mode64)));
5889 addInstr(env, mk_iMOVds_RR(r_dstLo, hregPPC_GPR4(mode64)));
5902 PPCAMode* am = PPCAMode_IR(rloc.spOff, StackFramePtr(mode64));
5943 if (!mode64 && dst->tag != Ico_U32)
5945 if (mode64 && dst->tag != Ico_U64)
5950 hregPPC_GPR31(mode64));
5961 = mode64
5966 mode64 ? (Addr64)stmt->Ist.Exit.dst->Ico.U64
6036 vassert(cdst->tag == (env->mode64 ? Ico_U64 :Ico_U32));
6039 PPCAMode* amCIA = PPCAMode_IR(offsIP, hregPPC_GPR31(env->mode64));
6045 = env->mode64
6050 env->mode64 ? (Addr64)cdst->Ico.U64
6069 PPCAMode* amCIA = PPCAMode_IR(offsIP, hregPPC_GPR31(env->mode64));
6096 PPCAMode* amCIA = PPCAMode_IR(offsIP, hregPPC_GPR31(env->mode64));
6133 Bool mode64 = False;
6139 mode64 = arch_host == VexArchPPC64;
6151 if (mode64) {
6171 env->mode64 = mode64;
6188 if (mode64) {
6213 if (mode64) {
6220 if (mode64) {
6228 if (mode64) {
6259 if (!mode64) {
6267 amCounter = PPCAMode_IR(offs_Host_EvC_Counter, hregPPC_GPR31(mode64));
6268 amFailAddr = PPCAMode_IR(offs_Host_EvC_FailAddr, hregPPC_GPR31(mode64));
