← Back to branch summary

~bkerensa/ubuntu/raring/valgrind/merge-from-deb

« back to all changes in this revision

Viewing changes to VEX/priv/guest-x86/toIR.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-11-16 17:56:30 UTC
  • mfrom: (1.2.2 upstream)
  • mto: This revision was merged to the branch mainline in revision 14.
  • Revision ID: james.westby@ubuntu.com-20061116175630-hatkgajb0twz0upw
Tags: upstream-3.2.1
Import upstream version 3.2.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
VEX/priv/guest-x86/toIR.c
4274
4274
                              loadLE(Ity_I32, mkexpr(addr))));
4275
4275
               break;
4276
4276
 
 
4277
            case 1: /* FISTTPL m32 (SSE3) */
 
4278
               DIP("fisttpl %s\n", dis_buf);
 
4279
               storeLE( mkexpr(addr), 
 
4280
                        binop(Iop_F64toI32, mkU32(Irrm_ZERO), get_ST(0)) );
 
4281
               fp_pop();
 
4282
               break;
 
4283
 
4277
4284
            case 2: /* FIST m32 */
4278
4285
               DIP("fistl %s\n", dis_buf);
4279
4286
               storeLE( mkexpr(addr), 
4576
4583
               put_ST(0, loadLE(Ity_F64, mkexpr(addr)));
4577
4584
               break;
4578
4585
 
 
4586
            case 1: /* FISTTPQ m64 (SSE3) */
 
4587
               DIP("fistppll %s\n", dis_buf);
 
4588
               storeLE( mkexpr(addr), 
 
4589
                        binop(Iop_F64toI64, mkU32(Irrm_ZERO), get_ST(0)) );
 
4590
               fp_pop();
 
4591
               break;
 
4592
 
4579
4593
            case 2: /* FST double-real */
4580
4594
               DIP("fstl %s\n", dis_buf);
4581
4595
               storeLE(mkexpr(addr), get_ST(0));
4939
4953
                                   loadLE(Ity_I16, mkexpr(addr)))));
4940
4954
               break;
4941
4955
 
 
4956
            case 1: /* FISTTPS m16 (SSE3) */
 
4957
               DIP("fisttps %s\n", dis_buf);
 
4958
               storeLE( mkexpr(addr), 
 
4959
                        binop(Iop_F64toI16, mkU32(Irrm_ZERO), get_ST(0)) );
 
4960
               fp_pop();
 
4961
               break;
 
4962
 
4942
4963
            case 2: /* FIST m16 */
4943
4964
               DIP("fistp %s\n", dis_buf);
4944
4965
               storeLE( mkexpr(addr), 
10603
10624
      goto decode_success;
10604
10625
   }
10605
10626
 
 
10627
   /* F2 0F 12 = MOVDDUP -- move from E (mem or xmm) to G (xmm),
 
10628
      duplicating some lanes (0:1:0:1). */
 
10629
   if (sz == 4 && insn[0] == 0xF2 && insn[1] == 0x0F && insn[2] == 0x12) {
 
10630
      IRTemp sV = newTemp(Ity_V128);
 
10631
      IRTemp d0 = newTemp(Ity_I64);
 
10632
 
 
10633
      modrm = insn[3];
 
10634
      if (epartIsReg(modrm)) {
 
10635
         assign( sV, getXMMReg( eregOfRM(modrm)) );
 
10636
         DIP("movddup %s,%s\n", nameXMMReg(eregOfRM(modrm)),
 
10637
                                nameXMMReg(gregOfRM(modrm)));
 
10638
         delta += 3+1;
 
10639
         assign ( d0, unop(Iop_V128to64, mkexpr(sV)) );
 
10640
      } else {
 
10641
         addr = disAMode ( &alen, sorb, delta+3, dis_buf );
 
10642
         assign( d0, loadLE(Ity_I64, mkexpr(addr)) );
 
10643
         DIP("movddup %s,%s\n", dis_buf,
 
10644
                                nameXMMReg(gregOfRM(modrm)));
 
10645
         delta += 3+alen;
 
10646
      }
 
10647
 
 
10648
      putXMMReg( gregOfRM(modrm), binop(Iop_64HLtoV128,mkexpr(d0),mkexpr(d0)) );
 
10649
      goto decode_success;
 
10650
   }
 
10651
 
10606
10652
   /* F2 0F D0 = ADDSUBPS -- 32x4 +/-/+/- from E (mem or xmm) to G (xmm). */
10607
10653
   if (sz == 4 && insn[0] == 0xF2 && insn[1] == 0x0F && insn[2] == 0xD0) {
10608
10654
      IRTemp a3, a2, a1, a0, s3, s2, s1, s0;
10638
10684
      goto decode_success;
10639
10685
   }
10640
10686
 
 
10687
   /* 66 0F D0 = ADDSUBPD -- 64x4 +/- from E (mem or xmm) to G (xmm). */
 
10688
   if (sz == 2 && insn[0] == 0x0F && insn[1] == 0xD0) {
 
10689
      IRTemp eV   = newTemp(Ity_V128);
 
10690
      IRTemp gV   = newTemp(Ity_V128);
 
10691
      IRTemp addV = newTemp(Ity_V128);
 
10692
      IRTemp subV = newTemp(Ity_V128);
 
10693
      IRTemp a1     = newTemp(Ity_I64);
 
10694
      IRTemp s0     = newTemp(Ity_I64);
 
10695
 
 
10696
      modrm = insn[2];
 
10697
      if (epartIsReg(modrm)) {
 
10698
         assign( eV, getXMMReg( eregOfRM(modrm)) );
 
10699
         DIP("addsubpd %s,%s\n", nameXMMReg(eregOfRM(modrm)),
 
10700
                                 nameXMMReg(gregOfRM(modrm)));
 
10701
         delta += 2+1;
 
10702
      } else {
 
10703
         addr = disAMode ( &alen, sorb, delta+2, dis_buf );
 
10704
         assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
 
10705
         DIP("addsubpd %s,%s\n", dis_buf,
 
10706
                                 nameXMMReg(gregOfRM(modrm)));
 
10707
         delta += 2+alen;
 
10708
      }
 
10709
 
 
10710
      assign( gV, getXMMReg(gregOfRM(modrm)) );
 
10711
 
 
10712
      assign( addV, binop(Iop_Add64Fx2, mkexpr(gV), mkexpr(eV)) );
 
10713
      assign( subV, binop(Iop_Sub64Fx2, mkexpr(gV), mkexpr(eV)) );
 
10714
 
 
10715
      assign( a1, unop(Iop_V128HIto64, mkexpr(addV) ));
 
10716
      assign( s0, unop(Iop_V128to64,   mkexpr(subV) ));
 
10717
 
 
10718
      putXMMReg( gregOfRM(modrm), 
 
10719
                 binop(Iop_64HLtoV128, mkexpr(a1), mkexpr(s0)) );
 
10720
      goto decode_success;
 
10721
   }
 
10722
 
 
10723
   /* F2 0F 7D = HSUBPS -- 32x4 sub across from E (mem or xmm) to G (xmm). */
 
10724
   /* F2 0F 7C = HADDPS -- 32x4 add across from E (mem or xmm) to G (xmm). */
 
10725
   if (sz == 4 && insn[0] == 0xF2 && insn[1] == 0x0F 
 
10726
       && (insn[2] == 0x7C || insn[2] == 0x7D)) {
 
10727
      IRTemp e3, e2, e1, e0, g3, g2, g1, g0;
 
10728
      IRTemp eV     = newTemp(Ity_V128);
 
10729
      IRTemp gV     = newTemp(Ity_V128);
 
10730
      IRTemp leftV  = newTemp(Ity_V128);
 
10731
      IRTemp rightV = newTemp(Ity_V128);
 
10732
      Bool   isAdd  = insn[2] == 0x7C;
 
10733
      HChar* str    = isAdd ? "add" : "sub";
 
10734
      e3 = e2 = e1 = e0 = g3 = g2 = g1 = g0 = IRTemp_INVALID;
 
10735
 
 
10736
      modrm = insn[3];
 
10737
      if (epartIsReg(modrm)) {
 
10738
         assign( eV, getXMMReg( eregOfRM(modrm)) );
 
10739
         DIP("h%sps %s,%s\n", str, nameXMMReg(eregOfRM(modrm)),
 
10740
                                   nameXMMReg(gregOfRM(modrm)));
 
10741
         delta += 3+1;
 
10742
      } else {
 
10743
         addr = disAMode ( &alen, sorb, delta+3, dis_buf );
 
10744
         assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
 
10745
         DIP("h%sps %s,%s\n", str, dis_buf,
 
10746
                                   nameXMMReg(gregOfRM(modrm)));
 
10747
         delta += 3+alen;
 
10748
      }
 
10749
 
 
10750
      assign( gV, getXMMReg(gregOfRM(modrm)) );
 
10751
 
 
10752
      breakup128to32s( eV, &e3, &e2, &e1, &e0 );
 
10753
      breakup128to32s( gV, &g3, &g2, &g1, &g0 );
 
10754
 
 
10755
      assign( leftV,  mk128from32s( e2, e0, g2, g0 ) );
 
10756
      assign( rightV, mk128from32s( e3, e1, g3, g1 ) );
 
10757
 
 
10758
      putXMMReg( gregOfRM(modrm), 
 
10759
                 binop(isAdd ? Iop_Add32Fx4 : Iop_Sub32Fx4, 
 
10760
                       mkexpr(leftV), mkexpr(rightV) ) );
 
10761
      goto decode_success;
 
10762
   }
 
10763
 
 
10764
   /* 66 0F 7D = HSUBPD -- 64x2 sub across from E (mem or xmm) to G (xmm). */
 
10765
   /* 66 0F 7C = HADDPD -- 64x2 add across from E (mem or xmm) to G (xmm). */
 
10766
   if (sz == 2 && insn[0] == 0x0F && (insn[1] == 0x7C || insn[1] == 0x7D)) {
 
10767
      IRTemp e1     = newTemp(Ity_I64);
 
10768
      IRTemp e0     = newTemp(Ity_I64);
 
10769
      IRTemp g1     = newTemp(Ity_I64);
 
10770
      IRTemp g0     = newTemp(Ity_I64);
 
10771
      IRTemp eV     = newTemp(Ity_V128);
 
10772
      IRTemp gV     = newTemp(Ity_V128);
 
10773
      IRTemp leftV  = newTemp(Ity_V128);
 
10774
      IRTemp rightV = newTemp(Ity_V128);
 
10775
      Bool   isAdd  = insn[1] == 0x7C;
 
10776
      HChar* str    = isAdd ? "add" : "sub";
 
10777
 
 
10778
      modrm = insn[2];
 
10779
      if (epartIsReg(modrm)) {
 
10780
         assign( eV, getXMMReg( eregOfRM(modrm)) );
 
10781
         DIP("h%spd %s,%s\n", str, nameXMMReg(eregOfRM(modrm)),
 
10782
                                   nameXMMReg(gregOfRM(modrm)));
 
10783
         delta += 2+1;
 
10784
      } else {
 
10785
         addr = disAMode ( &alen, sorb, delta+2, dis_buf );
 
10786
         assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
 
10787
         DIP("h%spd %s,%s\n", str, dis_buf,
 
10788
                              nameXMMReg(gregOfRM(modrm)));
 
10789
         delta += 2+alen;
 
10790
      }
 
10791
 
 
10792
      assign( gV, getXMMReg(gregOfRM(modrm)) );
 
10793
 
 
10794
      assign( e1, unop(Iop_V128HIto64, mkexpr(eV) ));
 
10795
      assign( e0, unop(Iop_V128to64, mkexpr(eV) ));
 
10796
      assign( g1, unop(Iop_V128HIto64, mkexpr(gV) ));
 
10797
      assign( g0, unop(Iop_V128to64, mkexpr(gV) ));
 
10798
 
 
10799
      assign( leftV,  binop(Iop_64HLtoV128, mkexpr(e0),mkexpr(g0)) );
 
10800
      assign( rightV, binop(Iop_64HLtoV128, mkexpr(e1),mkexpr(g1)) );
 
10801
 
 
10802
      putXMMReg( gregOfRM(modrm), 
 
10803
                 binop(isAdd ? Iop_Add64Fx2 : Iop_Sub64Fx2, 
 
10804
                       mkexpr(leftV), mkexpr(rightV) ) );
 
10805
      goto decode_success;
 
10806
   }
 
10807
 
 
10808
   /* F2 0F F0 = LDDQU -- move from E (mem or xmm) to G (xmm). */
 
10809
   if (sz == 4 && insn[0] == 0xF2 && insn[1] == 0x0F && insn[2] == 0xF0) {
 
10810
      modrm = getIByte(delta+3);
 
10811
      if (epartIsReg(modrm)) {
 
10812
         goto decode_failure;
 
10813
      } else {
 
10814
         addr = disAMode ( &alen, sorb, delta+3, dis_buf );
 
10815
         putXMMReg( gregOfRM(modrm), 
 
10816
                    loadLE(Ity_V128, mkexpr(addr)) );
 
10817
         DIP("lddqu %s,%s\n", dis_buf,
 
10818
                              nameXMMReg(gregOfRM(modrm)));
 
10819
         delta += 3+alen;
 
10820
      }
 
10821
      goto decode_success;
 
10822
   }
 
10823
 
10641
10824
   /* ---------------------------------------------------- */
10642
10825
   /* --- end of the SSE3 decoder.                     --- */
10643
10826
   /* ---------------------------------------------------- */
11545
11728
      t1 = newTemp(Ity_I32); t2 = newTemp(ty);
11546
11729
      assign( t1, binop(Iop_Sub32,getIReg(4,R_ESP),mkU32(sz)) );
11547
11730
      putIReg(4, R_ESP, mkexpr(t1) );
 
11731
      /* stop mkU16 asserting if d32 is a negative 16-bit number
 
11732
         (bug #132813) */
 
11733
      if (ty == Ity_I16)
 
11734
         d32 &= 0xFFFF;
11548
11735
      storeLE( mkexpr(t1), mkU(ty,d32) );
11549
11736
      DIP("push%c $0x%x\n", nameISize(sz), d32);
11550
11737
      break;
12388
12575
         delta = dis_mul_E_G ( sorb, sz, delta );
12389
12576
         break;
12390
12577
 
 
12578
      /* =-=-=-=-=-=-=-=-=- NOPs =-=-=-=-=-=-=-=-=-=-=-= */
 
12579
 
 
12580
      case 0x1F:
 
12581
         modrm = getUChar(delta);
 
12582
         if (epartIsReg(modrm)) goto decode_failure;
 
12583
         addr = disAMode ( &alen, sorb, delta, dis_buf );
 
12584
         delta += alen;
 
12585
         DIP("nop%c %s\n", nameISize(sz), dis_buf);
 
12586
         break;
 
12587
 
12391
12588
      /* =-=-=-=-=-=-=-=-=- Jcond d32 -=-=-=-=-=-=-=-=-= */
12392
12589
      case 0x80:
12393
12590
      case 0x81: