Lines Matching defs: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);
344 HReg reg = mkHReg(env->vreg_ctr, HRcGPR(env->mode64),
492 HReg sp = StackFramePtr(env->mode64);
500 HReg sp = StackFramePtr(env->mode64);
516 addInstr(env, mk_iMOVds_RR(r, StackFramePtr(env->mode64)));
522 PPCInstr_LI(align16, 0xFFFFFFFFFFFFFFF0ULL, env->mode64));
536 vassert(!env->mode64);
541 am_addr0 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
542 am_addr1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
545 addInstr(env, PPCInstr_Store( 4, am_addr0, r_srcHi, env->mode64 ));
546 addInstr(env, PPCInstr_Store( 4, am_addr1, r_srcLo, env->mode64 ));
561 vassert(env->mode64);
565 am_addr0 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
568 addInstr(env, PPCInstr_Store( 8, am_addr0, r_src, env->mode64 ));
643 env->mode64 ? False : True/*F:64-bit, T:32-bit shift*/,
651 PPCAMode_RR( GuestStatePtr(env->mode64), rtmp );
696 Bool mode64 = env->mode64;
711 = (!mode64) && env->vbi->host_ppc32_regalign_int64_args;
718 (mode32:32 | mode64:64) integer bits in total can be passed.
719 In fact the only supported arg type is (mode32:I32 | mode64:I64).
785 argregs[0] = hregPPC_GPR3(mode64);
786 argregs[1] = hregPPC_GPR4(mode64);
787 argregs[2] = hregPPC_GPR5(mode64);
788 argregs[3] = hregPPC_GPR6(mode64);
789 argregs[4] = hregPPC_GPR7(mode64);
790 argregs[5] = hregPPC_GPR8(mode64);
791 argregs[6] = hregPPC_GPR9(mode64);
792 argregs[7] = hregPPC_GPR10(mode64);
856 GuestStatePtr(mode64) ));
862 if (!mode64) {
880 } else { // mode64
910 addInstr(env, mk_iMOVds_RR( r_vecRetAddr, StackFramePtr(mode64) ));
917 addInstr(env, mk_iMOVds_RR( r_vecRetAddr, StackFramePtr(mode64) ));
928 GuestStatePtr(mode64) ));
941 if (!mode64) {
954 } else { // mode64
1006 *retloc = mk_RetLoc_simple(mode64 ? RLPri_Int : RLPri_2Int);
1032 ULong target = mode64 ? Ptr_to_ULong(cee->addr)
1054 // addInstr(env, PPCInstr_LI(r_src, 0x0, env->mode64));
1055 // if (env->mode64) {
1083 vassert(hregClass(r_rmIR) == HRcGPR(env->mode64));
1161 if (env->mode64) {
1174 addInstr( env, PPCInstr_LI( r_zero, 0, env->mode64 ) );
1272 addInstr(env, PPCInstr_LI(r_src, (Long)simm32, env->mode64));
1293 addInstr(env, PPCInstr_Store( 4, am_off12, r_src, env->mode64 ));
1345 All results are returned in a (mode64 ? 64bit : 32bit) register.
1359 vassert(hregClass(r) == HRcGPR(env->mode64));
1367 Bool mode64 = env->mode64;
1373 ty == Ity_I32 || ((ty == Ity_I64) && mode64));
1390 r_dst, am_addr, mode64 ));
1457 if (!mode64)
1484 vassert(mode64);
1521 vassert(mode64);
1549 if (mode64
1592 vassert(mode64);
1619 vassert(mode64);
1623 addInstr(env, PPCInstr_LI(msk, 0xFFFFFFFF, mode64));
1711 /* This works in both mode64 and mode32. */
1712 HReg r1 = StackFramePtr(env->mode64);
1728 addInstr(env, PPCInstr_Load(4, idst, zero_r1, mode64));
1731 if (mode64)
1742 if (mode64) {
1743 HReg r1 = StackFramePtr(env->mode64);
1758 addInstr(env, PPCInstr_Load(8, idst, zero_r1, True/*mode64*/));
1768 HReg r1 = StackFramePtr(env->mode64);
1779 addInstr(env, PPCInstr_Load(8, idst, zero_r1, mode64));
1794 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
1803 addInstr(env, PPCInstr_Load(8, idst, zero_r1, True/*mode64*/));
1836 addInstr(env, PPCInstr_Load(2,r_dst,amode, mode64));
1858 vassert(mode64);
1886 vassert(mode64);
1898 vassert(mode64);
1910 if (op_unop == Iop_Not64) vassert(mode64);
1917 if (!mode64) {
1931 if (!mode64) {
1941 if (mode64) { /* This is a no-op. */
1957 if (mode64) {
1964 if (mode64) {
1973 if ((op_unop != Iop_1Uto64) || mode64) {
1996 if (mode64) {
2013 if (op_unop == Iop_Clz64 && !mode64)
2027 if (op_unop == Iop_Left64 && !mode64)
2049 if (!mode64) goto irreducible;
2073 PPCInstr_Load( 4, dst, am_off12, mode64 ));
2081 if (mode64) {
2100 mode64 ));
2117 if (mode64) {
2123 am_addr = PPCAMode_IR( 0, StackFramePtr(mode64) );
2129 addInstr(env, PPCInstr_Load( 8, r_dst, am_addr, mode64 ));
2147 am_addr = PPCAMode_IR( 0, StackFramePtr(mode64) );
2153 mode64 ));
2161 if (mode64) {
2167 am_addr = PPCAMode_IR( 0, StackFramePtr(mode64) );
2173 addInstr(env, PPCInstr_Load( 8, r_dst, am_addr, mode64 ));
2181 if (!mode64) break;
2192 argregs[0] = hregPPC_GPR3(mode64);
2210 if (!mode64) break;
2221 argregs[0] = hregPPC_GPR3(mode64);
2247 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
2253 addInstr(env, PPCInstr_Load(8, fr_dst, zero_r1, env->mode64));
2262 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
2270 addInstr(env, PPCInstr_Load(8, fr_dst, zero_r1, env->mode64));
2284 ty == Ity_I32 || ((ty == Ity_I64) && mode64)) {
2287 GuestStatePtr(mode64) );
2289 r_dst, am_addr, mode64 ));
2300 if (mode64 && ty == Ity_I64) {
2302 r_dst, src_am, mode64 ));
2305 if ((!mode64) && ty == Ity_I32) {
2307 r_dst, src_am, mode64 ));
2319 if (!(ty == Ity_I32 || (mode64 && ty == Ity_I64)))
2333 addInstr(env, mk_iMOVds_RR(r_dst, hregPPC_GPR3(mode64)));
2344 case Ico_U64: if (!mode64) goto irreducible;
2351 addInstr(env, PPCInstr_LI(r_dst, (ULong)l, mode64));
2358 ty == Ity_I32 || ((ty == Ity_I64) && mode64)) &&
2419 Bool mode64 = env->mode64;
2424 return toBool( hregClass(am->Pam.IR.base) == HRcGPR(mode64) &&
2428 return toBool( hregClass(am->Pam.RR.base) == HRcGPR(mode64) &&
2430 hregClass(am->Pam.RR.index) == HRcGPR(mode64) &&
2450 if (env->mode64) {
2536 vassert(hregClass(ri->Prh.Reg.reg) == HRcGPR(env->mode64));
2551 ty == Ity_I32 || ((ty == Ity_I64) && env->mode64));
2559 case Ico_U64: vassert(env->mode64);
2596 vassert(hregClass(ri->Pri.Reg) == HRcGPR(env->mode64));
2610 ty == Ity_I32 || ((ty == Ity_I64) && env->mode64));
2616 case Ico_U64: vassert(env->mode64);
2640 mode64);
2649 vassert(hregClass(ri->Prh.Reg.reg) == HRcGPR(env->mode64));
2685 vassert(env->mode64);
2694 vassert(hregClass(ri->Prh.Reg.reg) == HRcGPR(env->mode64));
2743 addInstr(env, PPCInstr_LI(r_zero, 0, env->mode64));
2832 if (!env->mode64) {
2840 } else { // mode64
2862 vassert(env->mode64);
2924 vassert(env->mode64);
2929 vassert(hregClass(*rHi) == HRcGPR(env->mode64));
2931 vassert(hregClass(*rLo) == HRcGPR(env->mode64));
3003 vassert(!env->mode64);
3059 vassert(!env->mode64);
3082 vassert(!env->mode64);
3213 HReg r1 = StackFramePtr(env->mode64);
3219 vassert(!env->mode64);
3241 HReg r1 = StackFramePtr(env->mode64);
3247 vassert(!env->mode64);
3267 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
3268 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
3319 vassert(env->mode64 == False);
3320 addInstr(env, PPCInstr_LI(zero32, 0, env->mode64));
3349 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
3350 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
3370 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
3371 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
3556 Bool mode64 = env->mode64;
3558 argregs[0] = hregPPC_GPR3(mode64);
3559 argregs[1] = hregPPC_GPR4(mode64);
3596 Bool mode64 = env->mode64;
3598 argregs[0] = hregPPC_GPR3(mode64);
3599 argregs[1] = hregPPC_GPR4(mode64);
3658 Bool mode64 = env->mode64;
3679 GuestStatePtr(env->mode64) );
3715 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
3729 if (mode64) {
3732 HReg r1 = StackFramePtr(env->mode64);
3740 addInstr(env, PPCInstr_Store(8, zero_r1, isrc, True/*mode64*/));
3755 HReg r1 = StackFramePtr(env->mode64);
3829 Bool mode64 = env->mode64;
3855 if (!mode64) {
3858 addInstr(env, PPCInstr_LI(r_srcHi, u.u32x2[0], mode64));
3859 addInstr(env, PPCInstr_LI(r_srcLo, u.u32x2[1], mode64));
3861 } else { // mode64
3863 addInstr(env, PPCInstr_LI(r_src, u.u64, mode64));
3882 GuestStatePtr(mode64) );
3960 if (mode64) {
3963 HReg r1 = StackFramePtr(env->mode64);
3971 addInstr(env, PPCInstr_Store(8, zero_r1, isrc, True/*mode64*/));
3987 HReg r1 = StackFramePtr(env->mode64);
4041 if (!mode64) {
4061 am_addr = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4064 addInstr(env, PPCInstr_Store( 4, am_addr, src, env->mode64 ));
4114 Bool mode64 = env->mode64;
4124 GuestStatePtr(mode64) );
4165 Bool mode64 = env->mode64;
4180 GuestStatePtr(mode64) );
4206 if (!mode64) {
4281 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4287 if (mode64) {
4290 addInstr(env, PPCInstr_Store(8, zero_r1, tmp, True/*mode64*/));
4293 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
4332 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4335 if (env->mode64) {
4339 addInstr(env, PPCInstr_Store(8, zero_r1, tmp, True/*mode64*/));
4344 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
4347 addInstr(env, PPCInstr_Store(4, zero_r1, tmpHi, False/*!mode64*/));
4348 addInstr(env, PPCInstr_Store(4, four_r1, tmpLo, False/*!mode64*/));
4407 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4412 if (mode64)
4413 addInstr(env, PPCInstr_Store(8, zero_r1, i8_val, True/*mode64*/));
4455 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4458 if (env->mode64) {
4460 addInstr(env, PPCInstr_Store(8, zero_r1, tmp, True/*mode64*/));
4463 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
4555 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4562 if (env->mode64) {
4564 addInstr(env, PPCInstr_Store(8, zero_r1, tmp, True/*mode64*/));
4567 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
4652 PPCAMode* zero_r1 = PPCAMode_IR( 0, StackFramePtr(env->mode64) );
4653 PPCAMode* four_r1 = PPCAMode_IR( 4, StackFramePtr(env->mode64) );
4667 if (env->mode64)
4668 addInstr(env, PPCInstr_Store(4, four_r1, i8_val, True/*mode64*/));
4675 addInstr( env, PPCInstr_LI( r_zero, 0, env->mode64 ) );
4713 Bool mode64 = env->mode64;
4731 GuestStatePtr(mode64) )));
4828 addInstr(env, PPCInstr_LI(r_zeros, 0x0, mode64));
4829 addInstr(env, PPCInstr_Store( 4, am_off0, r_zeros, mode64 ));
4830 addInstr(env, PPCInstr_Store( 4, am_off4, r_zeros, mode64 ));
4831 addInstr(env, PPCInstr_Store( 4, am_off8, r_zeros, mode64 ));
4834 addInstr(env, PPCInstr_Store( 4, am_off12, r_src, mode64 ));
4878 if (!mode64) {
4894 addInstr(env, PPCInstr_Store( 4, am_off12, r0, mode64 ));
4895 addInstr(env, PPCInstr_Store( 4, am_off8, r1, mode64 ));
4898 addInstr(env, PPCInstr_Store( 4, am_off4, r2, mode64 ));
4899 addInstr(env, PPCInstr_Store( 4, am_off0, r3, mode64 ));
4921 addInstr(env, PPCInstr_Store( 8, am_off0, rHi, mode64 ));
4922 addInstr(env, PPCInstr_Store( 8, am_off8, rLo, mode64 ));
5249 LibVEX_ppVexHwCaps(mode64 ? VexArchPPC64 : VexArchPPC32,
5262 Bool mode64 = env->mode64;
5279 if (!mode64 && (tya != Ity_I32))
5281 if (mode64 && (tya != Ity_I64))
5285 (mode64 && (tyd == Ity_I64))) {
5290 am_addr, r_src, mode64 ));
5333 if (tyd == Ity_I64 && !mode64) {
5357 ty == Ity_I32 || ((ty == Ity_I64) && mode64)) {
5360 GuestStatePtr(mode64) );
5362 am_addr, r_src, mode64 ));
5365 if (!mode64 && ty == Ity_I64) {
5368 GuestStatePtr(mode64) );
5371 addInstr(env, PPCInstr_Store( 4, am_addr, rHi, mode64 ));
5372 addInstr(env, PPCInstr_Store( 4, am_addr4, rLo, mode64 ));
5380 GuestStatePtr(mode64) );
5388 GuestStatePtr(mode64) );
5397 GuestStatePtr(mode64) );
5405 GuestStatePtr(mode64) );
5421 if (mode64 && ty == Ity_I64) {
5424 dst_am, r_src, mode64 ));
5427 if ((!mode64) && ty == Ity_I32) {
5430 dst_am, r_src, mode64 ));
5441 ty == Ity_I32 || ((ty == Ity_I64) && mode64)) {
5447 if (!mode64 && ty == Ity_I64) {
5456 if (mode64 && ty == Ity_I128) {
5464 if (!mode64 && ty == Ity_I128) {
5537 if (!mode64 && (tyAddr != Ity_I32))
5539 if (mode64 && (tyAddr != Ity_I64))
5547 addInstr(env, PPCInstr_LoadL( 4, r_dst, r_addr, mode64 ));
5550 if (tyRes == Ity_I64 && mode64) {
5551 addInstr(env, PPCInstr_LoadL( 8, r_dst, r_addr, mode64 ));
5564 if (tyData == Ity_I32 || (tyData == Ity_I64 && mode64)) {
5566 r_a, r_src, mode64 ));
5570 env->mode64 ? False : True
5601 if (mode64) {
5644 addInstr(env, mk_iMOVds_RR(r_dst, hregPPC_GPR3(mode64)));
5650 if (mode64) {
5654 addInstr(env, mk_iMOVds_RR(r_dst, hregPPC_GPR3(mode64)));
5663 addInstr(env, mk_iMOVds_RR(r_dstHi, hregPPC_GPR3(mode64)));
5664 addInstr(env, mk_iMOVds_RR(r_dstLo, hregPPC_GPR4(mode64)));
5677 PPCAMode* am = PPCAMode_IR(rloc.spOff, StackFramePtr(mode64));
5718 if (!mode64 && dst->tag != Ico_U32)
5720 if (mode64 && dst->tag != Ico_U64)
5725 hregPPC_GPR31(mode64));
5736 = mode64
5741 mode64 ? (Addr64)stmt->Ist.Exit.dst->Ico.U64
5808 vassert(cdst->tag == (env->mode64 ? Ico_U64 :Ico_U32));
5811 PPCAMode* amCIA = PPCAMode_IR(offsIP, hregPPC_GPR31(env->mode64));
5817 = env->mode64
5822 env->mode64 ? (Addr64)cdst->Ico.U64
5841 PPCAMode* amCIA = PPCAMode_IR(offsIP, hregPPC_GPR31(env->mode64));
5868 PPCAMode* amCIA = PPCAMode_IR(offsIP, hregPPC_GPR31(env->mode64));
5904 Bool mode64 = False;
5910 mode64 = arch_host == VexArchPPC64;
5911 if (!mode64) vassert(max_ga <= 0xFFFFFFFFULL);
5923 if (mode64) {
5934 env->mode64 = mode64;
5951 if (mode64) {
5976 if (mode64) { hregLo = mkHReg(j++, HRcInt64, True); break;
5980 if (mode64) { hregLo = mkHReg(j++, HRcInt64, True); break;
5985 if (mode64) { hregLo = mkHReg(j++, HRcInt64, True);
6005 if (!mode64) {
6013 amCounter = PPCAMode_IR(offs_Host_EvC_Counter, hregPPC_GPR31(mode64));
6014 amFailAddr = PPCAMode_IR(offs_Host_EvC_FailAddr, hregPPC_GPR31(mode64));
