harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From var...@apache.org
Subject svn commit: r477525 [2/2] - in /harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf: ./ include/
Date Tue, 21 Nov 2006 06:23:40 GMT
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp?view=diff&rev=477525&r1=477524&r2=477525
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp Mon Nov 20 22:23:40 2006
@@ -28,8 +28,15 @@
 namespace Jitrino {
 namespace IPF {
 
-#define HEAPBASE   (opndManager->getHeapBase())
-#define VTABLEBASE (opndManager->getVtableBase())
+#define HEAPBASE      (opndManager->getHeapBase())
+#define HEAPBASEIMM   (opndManager->getHeapBaseImm())
+#define VTABLEBASE    (opndManager->getVtableBase())
+#define VTABLEBASEIMM (opndManager->getVtableBaseImm())
+
+#define IMM32(o)   ((int32)(((Opnd *)(o))->getValue()))
+#define IMM64(o)   ((int64)(((Opnd *)(o))->getValue()))
+#define IMM32U(o)  ((uint32)(((Opnd *)(o))->getValue()))
+#define IMM64U(o)  ((uint64)(((Opnd *)(o))->getValue()))
 
 //===========================================================================//
 // IpfInstCodeSelector
@@ -63,8 +70,21 @@
 
     IPF_LOG << "      add; opType=" << opType << endl;
 
-    RegOpnd *dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
-    add(dst, src1, src2);
+    Opnd *dst;
+    if (ipfConstantFolding && ((Opnd *)src1)->isImm() && ((Opnd *)src2)->isImm()) {
+        switch (opType) {
+        case ArithmeticOp::I4:
+        case ArithmeticOp::I:
+            dst = opndManager->newImm(IMM32(src1) + IMM32(src2)); break;
+        case ArithmeticOp::I8:
+            dst = opndManager->newImm(IMM64(src1) + IMM64(src2)); break;
+        default:
+            IPF_ASSERT(0); dst = NULL; break;
+        }
+    } else {
+        dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
+        add((RegOpnd *)dst, src1, src2);
+    }
     return dst;
 }
 
@@ -77,8 +97,21 @@
 
     IPF_LOG << "      sub" << endl;
 
-    RegOpnd *dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
-    sub(dst, src1, src2);
+    Opnd *dst;
+    if (ipfConstantFolding && ((Opnd *)src1)->isImm() && ((Opnd *)src2)->isImm()) {
+        switch (opType) {
+        case ArithmeticOp::I4:
+        case ArithmeticOp::I:
+            dst = opndManager->newImm(IMM32(src1) - IMM32(src2)); break;
+        case ArithmeticOp::I8:
+            dst = opndManager->newImm(IMM64(src1) - IMM64(src2)); break;
+        default:
+            IPF_ASSERT(0); dst = NULL; break;
+        }
+    } else {
+        dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
+        sub((RegOpnd *)dst, src1, src2);
+    }
     return dst;
 }
 
@@ -91,24 +124,37 @@
 
     IPF_LOG << "      mul" << endl;
     
-    RegOpnd *src1 = toRegOpnd(src1_);
-    RegOpnd *src2 = toRegOpnd(src2_);
-    RegOpnd *dst  = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));;
-    RegOpnd *f0   = opndManager->getF0();
-    
-    if (dst->isFloating()) {
-        Completer cmplt = CMPLT_PC_DYNAMIC;
-        
-        switch (dst->getDataKind()) {
-        case DATA_D: cmplt = CMPLT_PC_DOUBLE; break;
-        case DATA_S: cmplt = CMPLT_PC_SINGLE; break;
-        default: IPF_ERR << "bad data kind for float mul\n"; break;
+    Opnd *dst;
+    if (ipfConstantFolding && ((Opnd *)src1_)->isImm() && ((Opnd *)src2_)->isImm()) {
+        // imm is always integer
+        switch (opType) {
+        case ArithmeticOp::I4:
+        case ArithmeticOp::I:
+            dst = opndManager->newImm(IMM32(src1_) * IMM32(src2_)); break;
+        case ArithmeticOp::I8:
+            dst = opndManager->newImm(IMM64(src1_) * IMM64(src2_)); break;
+        default:
+            IPF_ASSERT(0); dst = NULL; break;
         }
-        addNewInst(INST_FMA, cmplt, p0, dst, src1, src2, f0);
     } else {
-        xma(INST_XMA_L, dst, src1, src2);
+        RegOpnd *src1 = toRegOpnd(src1_);
+        RegOpnd *src2 = toRegOpnd(src2_);
+        RegOpnd *f0   = opndManager->getF0();
+
+        dst  = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));;
+        if (dst->isFloating()) {
+            Completer cmplt = CMPLT_PC_DYNAMIC;
+            
+            switch (dst->getDataKind()) {
+            case DATA_D: cmplt = CMPLT_PC_DOUBLE; break;
+            case DATA_S: cmplt = CMPLT_PC_SINGLE; break;
+            default: IPF_ERR << "bad data kind for float mul\n"; break;
+            }
+            addNewInst(INST_FMA, cmplt, p0, dst, src1, src2, f0);
+        } else {
+            xma(INST_XMA_L, (RegOpnd *)dst, src1, src2);
+        }
     }
-
     return dst;
 }
 
@@ -120,6 +166,7 @@
                                            CG_OpndHandle          *intSrc) {
 
     IPF_LOG << "      addRef" << endl;
+    IPF_ASSERT(((Opnd *)refSrc)->isReg());
 
     RegOpnd *dst = opndManager->newRegOpnd(OPND_G_REG, toDataKind(opType));
     add(dst, refSrc, intSrc);
@@ -134,6 +181,7 @@
                                            CG_OpndHandle          *intSrc) {
 
     IPF_LOG << "      subRef" << endl;
+    IPF_ASSERT(((Opnd *)refSrc)->isReg());
 
     RegOpnd *dst = opndManager->newRegOpnd(OPND_G_REG, toDataKind(opType));
     sub(dst, refSrc, intSrc);
@@ -148,6 +196,8 @@
                                             CG_OpndHandle *src2) {
 
     IPF_LOG << "      diffRef" << endl;
+    IPF_ASSERT(((Opnd *)src1)->isReg());
+    IPF_ASSERT(((Opnd *)src2)->isReg());
 
     RegOpnd *dst = opndManager->newRegOpnd(OPND_G_REG, DATA_I64);
     sub(dst, src1, src2);
@@ -164,6 +214,8 @@
 
     IPF_LOG << "      scaledDiffRef" << endl;
     IPF_ASSERT(type1->isManagedPtr() && type1==type2);
+    IPF_ASSERT(((Opnd *)src1_)->isReg());
+    IPF_ASSERT(((Opnd *)src2_)->isReg());
 
     Opnd    *src1     = (Opnd *)src1_;
     Opnd    *src2     = (Opnd *)src2_;
@@ -196,18 +248,42 @@
                                             CG_OpndHandle *src2,
                                             CG_OpndHandle *tau_src1NonZero) {
 
-    IPF_LOG << "      tau_div" << endl;
-
-    RegOpnd *dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
-
-    switch (opType) {
-        case DivOp::I4: divInt   (dst, src1, src2); break;
-        case DivOp::I :  
-        case DivOp::I8: divLong  (dst, src1, src2); break;
-        case DivOp::F :   
-        case DivOp::D : divDouble(dst, src1, src2); break;
-        case DivOp::S : divFloat (dst, src1, src2); break;
-        default       : IPF_ERR << "unexpected type " << opType << endl;
+    IPF_LOG << "      tau_div" 
+        << "; opType=" << opType
+        << ", src1=" << IrPrinter::toString((Opnd *)src1)
+        << ", src2=" << IrPrinter::toString((Opnd *)src2)
+        << endl;
+
+    Opnd *dst = NULL;
+    if (ipfConstantFolding && ((Opnd *)src1)->isImm() && ((Opnd *)src2)->isImm() && IMM32(src2)!=0){
+        // imm is always integer
+        switch (opType) {
+        case DivOp::I4: 
+            dst = opndManager->newImm(IMM32(src1) / IMM32(src2)); break;
+        case DivOp::U4:
+            dst = opndManager->newImm(IMM32U(src1) / IMM32U(src2)); break;
+        case DivOp::I:
+        case DivOp::I8:
+            dst = opndManager->newImm(IMM64(src1) / IMM64(src2)); break;
+        case DivOp::U:
+        case DivOp::U8:
+            dst = opndManager->newImm(IMM64U(src1) / IMM64U(src2)); break;
+        default:
+            IPF_ASSERT(0);
+            dst = NULL;
+        }
+    } else {
+        dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
+    
+        switch (opType) {
+            case DivOp::I4: divInt((RegOpnd *)dst, toRegOpnd(src1), toRegOpnd(src2)); break;
+            case DivOp::I :  
+            case DivOp::I8: divLong((RegOpnd *)dst, toRegOpnd(src1), toRegOpnd(src2)); break;
+            case DivOp::F :   
+            case DivOp::D : divDouble((RegOpnd *)dst, src1, src2); break;
+            case DivOp::S : divFloat ((RegOpnd *)dst, src1, src2); break;
+            default       : IPF_ERR << "unexpected type " << opType << endl;
+        }
     }
     return dst;
 }
@@ -233,9 +309,9 @@
         }
     } else {
         if (dst->getSize() > 4) {
-            divLong(dst, src1, src2, true);
+            divLong(dst, toRegOpnd(src1), toRegOpnd(src2), true);
         } else {                   
-            divInt (dst, src1, src2, true);
+            divInt (dst, toRegOpnd(src1), toRegOpnd(src2), true);
         }
     }
 
@@ -250,13 +326,26 @@
 
     IPF_LOG << "      neg" << endl;
 
-    RegOpnd *src = toRegOpnd(src_);
-    RegOpnd *dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
-    RegOpnd *r0  = opndManager->getR0();
-
-    if (dst->isFloating()) addNewInst(INST_FNEG, p0, dst, src);
-    else                   addNewInst(INST_SUB, p0, dst, r0, src);
-
+    Opnd *dst;
+    if (ipfConstantFolding && ((Opnd *)src_)->isImm()) {
+        switch (opType) {
+        case NegOp::I4: 
+            dst = opndManager->newImm((int32)0 - IMM32(src_)); break;
+        case NegOp::I:
+        case NegOp::I8: 
+            dst = opndManager->newImm(0 - IMM64(src_)); break;
+        default: 
+            IPF_ASSERT(0);
+            dst = NULL;
+        }
+    } else {
+        dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
+        RegOpnd *src = toRegOpnd(src_);
+        RegOpnd *r0  = opndManager->getR0();
+    
+        if (dst->isFloating()) addNewInst(INST_FNEG, p0, dst, src);
+        else                   addNewInst(INST_SUB, p0, dst, r0, src);
+    }
     return dst;
 }
 
@@ -268,9 +357,23 @@
                                            CG_OpndHandle *src2) {
 
     IPF_LOG << "      min_op" << endl;
-    RegOpnd *dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
-    
-    minMax(dst, src1, src2, false);
+
+    Opnd *dst;
+    if (ipfConstantFolding && ((Opnd *)src1)->isImm() && ((Opnd *)src2)->isImm()) {
+        switch (opType) {
+        case NegOp::I4: 
+            dst = opndManager->newImm(min(IMM32(src1), IMM32(src2))); break;
+        case NegOp::I:
+        case NegOp::I8: 
+            dst = opndManager->newImm(min(IMM64(src1), IMM64(src2))); break;
+        default: 
+            IPF_ASSERT(0);
+            dst = NULL;
+        }
+    } else {
+        dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
+        minMax((RegOpnd *)dst, src1, src2, false);
+    }
     return dst; 
 }
 
@@ -282,9 +385,23 @@
                                            CG_OpndHandle *src2) {
 
     IPF_LOG << "      max_op" << endl;
-    RegOpnd *dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
     
-    minMax(dst, src1, src2, true);
+    Opnd *dst;
+    if (ipfConstantFolding && ((Opnd *)src1)->isImm() && ((Opnd *)src2)->isImm()) {
+        switch (opType) {
+        case NegOp::I4: 
+            dst = opndManager->newImm(max(IMM32(src1), IMM32(src2))); break;
+        case NegOp::I:
+        case NegOp::I8: 
+            dst = opndManager->newImm(max(IMM64(src1), IMM64(src2))); break;
+        default: 
+            IPF_ASSERT(0);
+            dst = NULL;
+        }
+    } else {
+        dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
+        minMax((RegOpnd *)dst, src1, src2, true);
+    }
     return dst; 
 }
 
@@ -293,24 +410,41 @@
 
 CG_OpndHandle *IpfInstCodeSelector::abs_op(NegOp::Types  opType,
                                            CG_OpndHandle *src_) {
-    RegOpnd *src = toRegOpnd(src_);
-    RegOpnd *dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
-    
-    if (dst->isFloating()) {
-        // TODO: check all the peculiarities of Math.min/max
-         addNewInst(INST_FABS, p0, dst, src);
+    Opnd *dst;
+    if (ipfConstantFolding && ((Opnd *)src_)->isImm()) {
+        switch (opType) {
+        case NegOp::I4: 
+            dst = opndManager->newImm(abs(IMM32(src_))); break;
+        case NegOp::I:
+        case NegOp::I8: 
+            dst = opndManager->newImm(labs(IMM64(src_))); break;
+        default: 
+            IPF_ASSERT(0);
+            dst = NULL;
+        }
     } else {
-        // cmp.lt truePred, falsePred = src, 0
-        // (truePred)  dst = src
-        // (falsePred) dst = -src
-        RegOpnd *truePred  = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
-        RegOpnd *falsePred = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
-        RegOpnd *r0        = opndManager->getR0(src);
+        RegOpnd *src = toRegOpnd(src_);
+        dst = opndManager->newRegOpnd(toOpndKind(opType), toDataKind(opType));
         
-        cmp(CMPLT_CMP_CREL_LT, truePred, falsePred, src, r0);
-        addNewInst(INST_MOV, truePred, dst, src);
-        addNewInst(INST_SUB, falsePred, dst, r0, src);
-     }
+        if (dst->isFloating()) {
+            // TODO: check all the peculiarities of Math.min/max
+             addNewInst(INST_FABS, p0, dst, src);
+        } else {
+            // cmp.lt truePred, falsePred = src, 0
+            // (truePred)  dst = src
+            // (falsePred) dst = -src
+            RegOpnd *truePred  = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
+            RegOpnd *falsePred = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
+            RegOpnd *r0        = opndManager->getR0(src);
+            
+            addNewInst(INST_DEF, p0, dst);
+            addNewInst(INST_DEF, p0, src);
+
+            cmp(CMPLT_CMP_CREL_LT, truePred, falsePred, src, r0);
+            addNewInst(INST_MOV, truePred, dst, src);
+            addNewInst(INST_SUB, falsePred, dst, r0, src);
+        }
+    }
     return dst;
 }
 
@@ -322,9 +456,24 @@
                                          CG_OpndHandle    *src2) {
 
     IPF_LOG << "      and_ " << endl;
-    RegOpnd *dst = opndManager->newRegOpnd(OPND_G_REG, toDataKind(opType));
 
-    binOp(INST_AND, dst, src1, src2);
+    Opnd *dst;
+    if (ipfConstantFolding && ((Opnd *)src1)->isImm() && ((Opnd *)src2)->isImm()) {
+        switch (opType) {
+        case IntegerOp::I4:
+            dst = opndManager->newImm(IMM32(src1) & IMM32(src2)); break;
+        case IntegerOp::I8:
+            dst = opndManager->newImm(IMM64(src1) & IMM64(src2)); break;
+        case IntegerOp::I  : 
+            dst = opndManager->newImm(IMM64U(src1) & IMM64U(src2)); break;
+        default: 
+            IPF_ASSERT(0);
+            dst = NULL;
+        }
+    } else {
+        dst = opndManager->newRegOpnd(OPND_G_REG, toDataKind(opType));
+        binOp(INST_AND, (RegOpnd *)dst, src1, src2);
+    }
     return dst; 
 }
 
@@ -336,9 +485,24 @@
                                         CG_OpndHandle    *src2) {
 
     IPF_LOG << "      or_ " << endl;
-    RegOpnd *dst = opndManager->newRegOpnd(OPND_G_REG, toDataKind(opType));
 
-    binOp(INST_OR, dst, src1, src2);
+    Opnd *dst;
+    if (ipfConstantFolding && ((Opnd *)src1)->isImm() && ((Opnd *)src2)->isImm()) {
+        switch (opType) {
+        case IntegerOp::I4:
+            dst = opndManager->newImm(IMM32(src1) | IMM32(src2)); break;
+        case IntegerOp::I8:
+            dst = opndManager->newImm(IMM64(src1) | IMM64(src2)); break;
+        case IntegerOp::I  : 
+            dst = opndManager->newImm(IMM64U(src1) | IMM64U(src2)); break;
+        default: 
+            IPF_ASSERT(0);
+            dst = NULL;
+        }
+    } else {
+        dst = opndManager->newRegOpnd(OPND_G_REG, toDataKind(opType));
+        binOp(INST_OR, (RegOpnd *)dst, src1, src2);
+    }
     return dst; 
 }
 
@@ -350,9 +514,24 @@
                                          CG_OpndHandle    *src2) {
 
     IPF_LOG << "      xor_ " << endl;
-    RegOpnd *dst = opndManager->newRegOpnd(OPND_G_REG, toDataKind(opType));
 
-    binOp(INST_XOR, dst, src1, src2);
+    Opnd *dst;
+    if (ipfConstantFolding && ((Opnd *)src1)->isImm() && ((Opnd *)src2)->isImm()) {
+        switch (opType) {
+        case IntegerOp::I4:
+            dst = opndManager->newImm(IMM32(src1) ^ IMM32(src2)); break;
+        case IntegerOp::I8:
+            dst = opndManager->newImm(IMM64(src1) ^ IMM64(src2)); break;
+        case IntegerOp::I  : 
+            dst = opndManager->newImm(IMM64U(src1) ^ IMM64U(src2)); break;
+        default: 
+            IPF_ASSERT(0);
+            dst = NULL;
+        }
+    } else {
+        dst = opndManager->newRegOpnd(OPND_G_REG, toDataKind(opType));
+        binOp(INST_XOR, (RegOpnd *)dst, src1, src2);
+    }
     return dst; 
 }
 
@@ -364,14 +543,29 @@
 
     IPF_LOG << "      not_ " << endl;
     
-    uint64 val = 0;
-    if (opType == IntegerOp::I4) val = 0xFFFFFFFF;
-    else                         val = 0xFFFFFFFFFFFFFFFFL;
-
-    Opnd    *allOnes = opndManager->newImm(val);
-    RegOpnd *dst     = opndManager->newRegOpnd(OPND_G_REG, toDataKind(opType));
-
-    binOp(INST_XOR, dst, src, allOnes);
+    Opnd *dst;
+    if (ipfConstantFolding && ((Opnd *)src)->isImm()) {
+        switch (opType) {
+        case IntegerOp::I4:
+            dst = opndManager->newImm(~IMM32(src)); break;
+        case IntegerOp::I8:
+            dst = opndManager->newImm(~IMM64(src)); break;
+        case IntegerOp::I  : 
+            dst = opndManager->newImm(~IMM64U(src)); break;
+        default: 
+            IPF_ASSERT(0);
+            dst = NULL;
+        }
+    } else {
+        uint64 val = 0;
+        if (opType == IntegerOp::I4) val = 0xFFFFFFFF;
+        else                         val = 0xFFFFFFFFFFFFFFFFL;
+    
+        Opnd    *allOnes = opndManager->newImm(val);
+        dst     = opndManager->newRegOpnd(OPND_G_REG, toDataKind(opType));
+    
+        binOp(INST_XOR, (RegOpnd *)dst, src, allOnes);
+    }
     return dst; 
 }
 
@@ -384,6 +578,10 @@
 
     IPF_LOG << "      shl " << endl;
 
+    if (ipfConstantFolding && ((Opnd *)value)->isImm() && ((Opnd *)shiftAmount)->isImm()) {
+        return opndManager->newImm(((Opnd *)value)->getValue() << ((Opnd *)shiftAmount)->getValue());
+    }
+
     RegOpnd *dst = opndManager->newRegOpnd(OPND_G_REG, toDataKind(opType));
     Opnd *shiftcount = (Opnd *)shiftAmount;
     int bits = 5;
@@ -406,6 +604,11 @@
                                         CG_OpndHandle    *shiftAmount) {
 
     IPF_LOG << "      shr " << endl;
+
+    if (ipfConstantFolding && ((Opnd *)value)->isImm() && ((Opnd *)shiftAmount)->isImm()) {
+        return opndManager->newImm(((Opnd *)value)->getValue() >> ((Opnd *)shiftAmount)->getValue());
+    }
+
     RegOpnd *dst = opndManager->newRegOpnd(OPND_G_REG, toDataKind(opType));
     int bits = 5;
     
@@ -430,6 +633,15 @@
                                          CG_OpndHandle    *shiftAmount) {
 
     IPF_LOG << "      shru " << endl;
+    
+    if (ipfConstantFolding && ((Opnd *)value)->isImm() && ((Opnd *)shiftAmount)->isImm()) {
+        if (opType==IntegerOp::I4) {
+            return opndManager->newImm((uint64)((uint32)((int32)(((Opnd *)value)->getValue()))) >> ((Opnd *)shiftAmount)->getValue());
+        } else {
+            return opndManager->newImm((uint64)(((Opnd *)value)->getValue()) >> ((Opnd *)shiftAmount)->getValue());
+        }
+    }
+
     RegOpnd *dst = opndManager->newRegOpnd(OPND_G_REG, toDataKind(opType));
     int bits = 5;
     
@@ -457,6 +669,10 @@
     IPF_LOG << "      shladd " << endl;
     IPF_ASSERT(imm>=1 && imm<=4);
 
+    if (ipfConstantFolding && ((Opnd *)value_)->isImm() && ((Opnd *)addto_)->isImm()) {
+        return opndManager->newImm((((Opnd *)value_)->getValue() << imm) + ((Opnd *)addto_)->getValue());
+    }
+
     RegOpnd *value = toRegOpnd(value_);
     RegOpnd *addto = toRegOpnd(addto_);
     Opnd    *count = opndManager->newImm(imm);
@@ -477,11 +693,21 @@
                                               Type                        *dstType, 
                                               CG_OpndHandle               *src_) {
 
-    RegOpnd *src = toRegOpnd(src_);
-    IPF_LOG << "      convToInt " << IrPrinter::toString(src);
-    IPF_LOG << " to " << Type::tag2str(dstType->tag) ;
+    IPF_LOG << "      convToInt " << IrPrinter::toString((Opnd *)src_);
+    IPF_LOG << " to " << Type::tag2str(dstType->tag);
+    IPF_LOG << "; isSigned=" << isSigned;
     IPF_LOG << "; opType=" << opType << endl;
 
+    if (ipfConstantFolding && ((Opnd *)src_)->isImm()) {
+        switch (opType) {
+            case ConvertToIntOp::I1: break;
+            case ConvertToIntOp::I2: break;
+            case ConvertToIntOp::I4: break;
+            default                : return src_;
+        }
+    }
+
+    RegOpnd *src = toRegOpnd(src_);
     RegOpnd *dst = opndManager->newRegOpnd(OPND_G_REG, toDataKind(dstType->tag));
 
     if (src->isFloating()) {
@@ -498,7 +724,9 @@
             default                : break;
         }
 
-        InstCode instCode = dst->isSigned() ? INST_SXT : INST_ZXT;
+        InstCode instCode = dst->isSigned() 
+            ? INST_SXT 
+            : INST_ZXT;
         if (cmplt == CMPLT_INVALID) addNewInst(INST_MOV, p0, dst, src);
         else                        addNewInst(instCode, cmplt, p0, dst, src);
     }
@@ -530,7 +758,7 @@
     } else {
         // convert from int to fp
         bool     isSigned = (opType != ConvertToFpOp::FloatFromUnsigned);
-        InstCode instCode = (isSigned ? INST_FCVT_XUF : INST_FCVT_XF);
+        InstCode instCode = (isSigned ? INST_FCVT_XF : INST_FCVT_XUF);
         sxt(src, 8);
         addNewInst(INST_SETF_SIG, p0, dst, src);
         addNewInst(instCode, p0, dst, dst);
@@ -544,11 +772,15 @@
 
 CG_OpndHandle *IpfInstCodeSelector::ldc_i4(uint32 val) {
 
-    IPF_LOG << "      ldc_i4" << endl;
+    IPF_LOG << "      ldc_i4; val=" << val << endl;
     
-    RegOpnd *dst = opndManager->newRegOpnd(OPND_G_REG, DATA_I32);
-    ldc(dst, (int64)((int32)val));
-
+    Opnd *dst;
+    if (ipfConstantFolding) {
+        dst = opndManager->newImm((int64)((int32)val));
+    } else {
+        dst = opndManager->newRegOpnd(OPND_G_REG, DATA_I32);
+        ldc((RegOpnd *)dst, (int64)((int32)val));
+    }
     return dst;
 }
 
@@ -557,11 +789,15 @@
 
 CG_OpndHandle *IpfInstCodeSelector::ldc_i8(uint64 val) {
 
-    IPF_LOG << "      ldc_i8" << endl;
-
-    RegOpnd *dst = opndManager->newRegOpnd(OPND_G_REG, DATA_I64);
-    ldc(dst, (int64)val);
+    IPF_LOG << "      ldc_i8; val=" << val << endl;
 
+    Opnd *dst;
+    if (ipfConstantFolding) {
+        dst = opndManager->newImm((int64)val);
+    } else {
+        dst = opndManager->newRegOpnd(OPND_G_REG, DATA_I64);
+        ldc((RegOpnd *)dst, (int64)val);
+    }
     return dst;
 }
 
@@ -570,15 +806,36 @@
 
 CG_OpndHandle *IpfInstCodeSelector::ldc_s(float val) {
 
-    IPF_LOG << "      ldc_s" << endl;
+    IPF_LOG << "      ldc_s; val=" << val << endl;
 
-    FloatConstant *fc       = new(mm) FloatConstant(val);
-    ConstantRef   *constref = opndManager->newConstantRef(fc);
-    RegOpnd       *r3       = opndManager->newRegOpnd(OPND_G_REG, DATA_I64);
-    RegOpnd       *dst      = opndManager->newRegOpnd(OPND_F_REG, DATA_S);
-   
-    addNewInst(INST_MOVL, p0, r3, constref);
-    addNewInst(INST_LDF, CMPLT_FSZ_S, p0, dst, r3);
+    if (val==0) {
+        return opndManager->getF0();
+    } else if (val==1) {
+        return opndManager->getF1();
+    }
+
+    union {
+        float  fr;
+        uint32 gr;
+    } tmpVal;
+    
+    tmpVal.fr = val;
+    
+    RegOpnd  *dst      = opndManager->newRegOpnd(OPND_F_REG, DATA_S);
+    Opnd     *immOpnd  = opndManager->newImm(tmpVal.gr);
+    RegOpnd  *r3       = opndManager->newRegOpnd(OPND_G_REG, DATA_I64);
+    InstCode  instCode = immOpnd->isFoldableImm(22) ? INST_MOV : INST_MOVL;
+    
+    addNewInst(instCode, p0, r3, immOpnd);
+    addNewInst(INST_SETF_S, p0, dst, r3);
+
+    //FloatConstant *fc       = new(mm) FloatConstant(val);
+    //ConstantRef   *constref = opndManager->newConstantRef(fc);
+    //RegOpnd       *r3       = opndManager->newRegOpnd(OPND_G_REG, DATA_I64);
+    //RegOpnd       *dst      = opndManager->newRegOpnd(OPND_F_REG, DATA_S);
+    //   
+    //addNewInst(INST_MOVL, p0, r3, constref);
+    //addNewInst(INST_LDF, CMPLT_FSZ_S, p0, dst, r3);
 
     return dst;
 }
@@ -588,15 +845,36 @@
 
 CG_OpndHandle *IpfInstCodeSelector::ldc_d(double val) {
 
-    IPF_LOG << "      ldc_d" << endl;
-
-    DoubleConstant *fc       = new(mm) DoubleConstant(val);
-    ConstantRef    *constref = opndManager->newConstantRef(fc);
-    RegOpnd        *r3       = opndManager->newRegOpnd(OPND_G_REG, DATA_I64);
-    RegOpnd        *dst      = opndManager->newRegOpnd(OPND_F_REG, DATA_D);
+    IPF_LOG << "      ldc_d; val=" << val << endl;
 
-    addNewInst(INST_MOVL, p0, r3, constref);
-    addNewInst(INST_LDF,  CMPLT_FSZ_D, p0, dst, r3);
+    if (val==0) {
+        return opndManager->getF0();
+    } else if (val==1) {
+        return opndManager->getF1();
+    }
+
+    union {
+        double fr;
+        uint64 gr;
+    } tmpVal;
+    
+    tmpVal.fr = val;
+    
+    RegOpnd  *dst      = opndManager->newRegOpnd(OPND_F_REG, DATA_D);
+    Opnd     *immOpnd  = opndManager->newImm(tmpVal.gr);
+    RegOpnd  *r3       = opndManager->newRegOpnd(OPND_G_REG, DATA_I64);
+    InstCode  instCode = immOpnd->isFoldableImm(22) ? INST_MOV : INST_MOVL;
+    
+    addNewInst(instCode, p0, r3, immOpnd);
+    addNewInst(INST_SETF_D, p0, dst, r3);
+    
+    //DoubleConstant *fc       = new(mm) DoubleConstant(val);
+    //ConstantRef    *constref = opndManager->newConstantRef(fc);
+    //RegOpnd        *r3       = opndManager->newRegOpnd(OPND_G_REG, DATA_I64);
+    //RegOpnd        *dst      = opndManager->newRegOpnd(OPND_F_REG, DATA_D);
+    //
+    //addNewInst(INST_MOVL, p0, r3, constref);
+    //addNewInst(INST_LDF,  CMPLT_FSZ_D, p0, dst, r3);
 
     return dst;
 }
@@ -606,16 +884,28 @@
 
 CG_OpndHandle *IpfInstCodeSelector::ldnull(bool compressed) {
 
-    IPF_LOG << "      ldnull; compressed = " << boolalpha << compressed << endl;
+    IPF_LOG << "      ldnull; compressed=" << boolalpha << compressed << endl;
     
-    if (opndManager->areRefsCompressed() == false) {
-        return opndManager->getR0();
-    } 
-
-    if (compressed) {
-        return opndManager->getR0();
+    if (false && ipfConstantFolding) {
+        if (opndManager->areRefsCompressed() == false) {
+            return opndManager->newImm(0); // return opndManager->getR0();
+        } 
+    
+        if (compressed) {
+            return opndManager->newImm(0); // return opndManager->getR0();
+        } else {
+            return HEAPBASEIMM; // return HEAPBASE;
+        }
     } else {
-        return HEAPBASE;
+        if (opndManager->areRefsCompressed() == false) {
+            return opndManager->getR0();
+        } 
+    
+        if (compressed) {
+            return opndManager->getR0();
+        } else {
+            return HEAPBASE;
+        }
     }
 }
 
@@ -624,13 +914,17 @@
 
 CG_OpndHandle *IpfInstCodeSelector::ldVar(Type *dstType, uint32 varId) {
 
-    IPF_LOG << "      ldVar " << Type::tag2str(dstType->tag) << " " << varId << endl;
+    IPF_LOG << "      ldVar; dstType=" << Type::tag2str(dstType->tag) << ", varId=" << varId << endl;
 
     if (opnds[varId] == opndManager->getTau()) { 
         IPF_LOG << "        tau operation - ignore" << endl;
         return opndManager->getTau();
     }
 
+    if (ipfConstantFolding && opnds[varId]->isImm()) {
+        return opnds[varId];
+    }
+    
     RegOpnd *src = toRegOpnd(opnds[varId]);
     RegOpnd *dst = opndManager->newRegOpnd(toOpndKind(dstType->tag), toDataKind(dstType->tag));
 
@@ -642,17 +936,30 @@
 //----------------------------------------------------------------------------//
 // Store variable
 
-void IpfInstCodeSelector::stVar(CG_OpndHandle *src, uint32 varId) {
+void IpfInstCodeSelector::stVar(CG_OpndHandle *_src, uint32 varId) {
 
-    IPF_LOG << "      stVar" << endl;
+    IPF_LOG << "      stVar" 
+        << "; varId=" << varId
+        << "; src=" << IrPrinter::toString((Opnd *)_src)
+        << endl;
     
-    if (src==opndManager->getTau() || opnds[varId]==opndManager->getTau()) { 
+    if (_src==opndManager->getTau() || opnds[varId]==opndManager->getTau()) { 
         IPF_LOG << "        tau operation - ignore" << endl;
         return;
     }
 
+    if (ipfConstantFolding && opnds[varId]->isImm() && ((Opnd *)_src)->isImm()) {
+        opnds[varId]->setValue(((Opnd *)_src)->getValue());
+    }
+    
     IPF_ASSERT(opnds[varId]->isReg());
-    addNewInst(INST_MOV, p0, opnds[varId], src);
+    
+    Opnd *src = (Opnd *)_src;
+    if (src->isReg() || src->isImm(22)) {
+        addNewInst(INST_MOV, p0, opnds[varId], src);
+    } else {
+        addNewInst(INST_MOVL, p0, opnds[varId], src);
+    }
 }
 
 //----------------------------------------------------------------------------//
@@ -675,7 +982,6 @@
     RegOpnd *arg = opndManager->newRegOpnd(opndKind, dataKind, location);
     IPF_LOG << "      defArg " << IrPrinter::toString(arg) << " " << type->getName() << endl;
 
-//    addNewInst(INST_DEF, p0, arg);                        // artificial def for in arg opnd
     if (isFp) {
         RegOpnd *newarg = opndManager->newRegOpnd(opndKind, dataKind);
         addNewInst(INST_MOV, p0, newarg, arg);            // if fp arg crosses call site
@@ -693,7 +999,11 @@
                                         CG_OpndHandle        *src1,
                                         CG_OpndHandle        *src2) {
 
-    IPF_LOG << "      cmp; opType=" << opType << endl;
+    IPF_LOG << "      cmp" 
+        << "; opType=" << opType
+        << "; src1=" << IrPrinter::toString((Opnd *)src1)
+        << "; src2=" << IrPrinter::toString((Opnd *)src2)
+        << "\n";
 
     InstCode  instCode   = toInstCmp(opType);
     bool      isFloating = (instCode == INST_FCMP);
@@ -703,8 +1013,9 @@
     RegOpnd   *r0        = opndManager->getR0();
     RegOpnd   *dst       = opndManager->newRegOpnd(OPND_G_REG, DATA_I32);
     
+    addNewInst(INST_DEF, p0, dst);
+
     cmp(instCode, crel, truePred, falsePred, src1, src2);
-//    addNewInst(INST_DEF, p0, dst);
     addNewInst(INST_MOV, truePred, dst, opndManager->newImm(1));
     addNewInst(INST_MOV, falsePred, dst, r0);
     
@@ -717,7 +1028,9 @@
 CG_OpndHandle *IpfInstCodeSelector::czero(CompareZeroOp::Types opType,
                                           CG_OpndHandle        *src) {
 
-    IPF_LOG << "      czero" << endl;
+    IPF_LOG << "      czero" 
+        << "; src=" << IrPrinter::toString((Opnd *)src)
+        << endl;
 
     InstCode  instCode   = toInstCmp(opType);
     Completer crel       = CMPLT_CMP_CREL_EQ;
@@ -726,8 +1039,9 @@
     RegOpnd   *r0        = opndManager->getR0();
     RegOpnd   *dst       = opndManager->newRegOpnd(OPND_G_REG, DATA_I32);
     
+    addNewInst(INST_DEF, p0, dst);
+
     cmp(instCode, crel, truePred, falsePred, src, r0);
-//    addNewInst(INST_DEF, p0, dst);
     addNewInst(INST_MOV, truePred, dst, opndManager->newImm(1));
     addNewInst(INST_MOV, falsePred, dst, r0);
 
@@ -740,7 +1054,9 @@
 CG_OpndHandle *IpfInstCodeSelector::cnzero(CompareZeroOp::Types opType,
                                            CG_OpndHandle        *src) {
 
-    IPF_LOG << "      cnzero" << endl;
+    IPF_LOG << "      cnzero" 
+        << "; src=" << IrPrinter::toString((Opnd *)src)
+        << endl;
 
     InstCode  instCode   = toInstCmp(opType);
     Completer crel       = CMPLT_CMP_CREL_NE;
@@ -749,8 +1065,9 @@
     RegOpnd   *r0        = opndManager->getR0();
     RegOpnd   *dst       = opndManager->newRegOpnd(OPND_G_REG, DATA_I32);
     
+    addNewInst(INST_DEF, p0, dst);
+
     cmp(instCode, crel, truePred, falsePred, src, r0);
-//    addNewInst(INST_DEF, p0, dst);
     addNewInst(INST_MOV, truePred, dst, opndManager->newImm(1));
     addNewInst(INST_MOV, falsePred, dst, r0);
 
@@ -762,7 +1079,9 @@
 
 CG_OpndHandle *IpfInstCodeSelector::copy(CG_OpndHandle *src_) {
 
-    IPF_LOG << "      copy" << endl;
+    IPF_LOG << "      copy" 
+        << "; src_=" << IrPrinter::toString((Opnd *)src_)
+        << endl;
 
     if ((Opnd *)src_ == opndManager->getTau()) { 
         IPF_LOG << "        tau operation - ignore" << endl;
@@ -786,6 +1105,10 @@
 
     IPF_LOG << "      tau_staticCast" << endl;
 
+    if (((Opnd *)obj)->isImm()) {
+        return obj;
+    }
+    
     RegOpnd *dst = opndManager->newRegOpnd(OPND_G_REG, toDataKind(toType->tag));
     
     addNewInst(INST_MOV, p0, dst, obj);
@@ -800,16 +1123,40 @@
                                  CG_OpndHandle        *src1,
                                  CG_OpndHandle        *src2) {
 
-    IPF_LOG << "      branch" << endl;
-
-    InstCode  instCode   = toInstCmp(opType);
-    bool      isFloating = (instCode == INST_FCMP);
-    Completer crel       = toCmpltCrel(cmpOp, isFloating);
-    RegOpnd   *truePred  = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
-    NodeRef   *target    = opndManager->newNodeRef();
-
-    cmp(instCode, crel, truePred, p0, src1, src2);
-    addNewInst(INST_BR, CMPLT_BTYPE_COND, CMPLT_WH_DPNT, CMPLT_PH_FEW, truePred, target);
+    IPF_LOG << "      branch" 
+        << "; src1=" << IrPrinter::toString((Opnd *)src1)
+        << "; src2=" << IrPrinter::toString((Opnd *)src2)
+        << endl;
+
+    if (false // TODO: need update cfg: branch edge target and "br" instruction target are different
+            && ipfConstantFolding && ((Opnd *)src1)->isImm() && ((Opnd *)src2)->isImm()) {
+        RegOpnd   *truePred  = opndManager->getP0();
+        NodeRef   *target    = opndManager->newNodeRef();
+        int64      v1 = ((Opnd *)src1)->getValue(), v2 = ((Opnd *)src2)->getValue();
+        bool       cmpres = false;
+    
+        switch (cmpOp) {
+        case CompareOp::Eq  : cmpres = (v1 == v2); break;
+        case CompareOp::Ne  : cmpres = (v1 != v2); break;
+        case CompareOp::Gt  : cmpres = (v1 > v2); break;
+        case CompareOp::Gtu : cmpres = ((uint64)v1 > (uint64)v2); break;
+        case CompareOp::Ge  : cmpres = (v1 >= v2); break;
+        case CompareOp::Geu : cmpres = ((uint64)v1 >= (uint64)v2); break;
+        default             : IPF_ERR << "unexpected cmpOp type " << cmpOp << endl;
+        }
+        if (cmpres) {
+            addNewInst(INST_BR, CMPLT_BTYPE_COND, CMPLT_WH_SPTK, CMPLT_PH_MANY, truePred, target);
+        }
+    } else {
+        InstCode  instCode   = toInstCmp(opType);
+        bool      isFloating = (instCode == INST_FCMP);
+        Completer crel       = toCmpltCrel(cmpOp, isFloating);
+        RegOpnd   *truePred  = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
+        NodeRef   *target    = opndManager->newNodeRef();
+    
+        cmp(instCode, crel, truePred, p0, src1, src2);
+        addNewInst(INST_BR, CMPLT_BTYPE_COND, CMPLT_WH_DPTK, CMPLT_PH_MANY, truePred, target);
+    }
 }
 
 //----------------------------------------------------------------------------//
@@ -818,7 +1165,9 @@
 void IpfInstCodeSelector::bzero(CompareZeroOp::Types opType,
                                 CG_OpndHandle        *src) {
 
-    IPF_LOG << "      bzero" << endl;
+    IPF_LOG << "      bzero" 
+        << "; src=" << IrPrinter::toString((Opnd *)src)
+        << endl;
     IPF_ASSERT(((Opnd *)src)->isReg());
 
     InstCode instCode  = toInstCmp(opType);
@@ -833,7 +1182,7 @@
     }
 
     cmp(instCode, CMPLT_CMP_CREL_EQ, truePred, p0, src, zero);
-    addNewInst(INST_BR, CMPLT_BTYPE_COND, CMPLT_WH_DPNT, CMPLT_PH_FEW, truePred, target);
+    addNewInst(INST_BR, CMPLT_BTYPE_COND, CMPLT_WH_DPTK, CMPLT_PH_MANY, truePred, target);
 }
 
 //----------------------------------------------------------------------------//
@@ -842,7 +1191,9 @@
 void IpfInstCodeSelector::bnzero(CompareZeroOp::Types opType,
                                  CG_OpndHandle        *src) {
 
-    IPF_LOG << "      bnzero" << endl;
+    IPF_LOG << "      bnzero" 
+        << "; src=" << IrPrinter::toString((Opnd *)src)
+        << endl;
     IPF_ASSERT(((Opnd *)src)->isReg());
 
     InstCode instCode  = toInstCmp(opType);
@@ -857,7 +1208,7 @@
     } 
 
     cmp(instCode, CMPLT_CMP_CREL_NE, truePred, p0, src, zero);
-    addNewInst(INST_BR, CMPLT_BTYPE_COND, CMPLT_WH_DPNT, CMPLT_PH_FEW, truePred, target);
+    addNewInst(INST_BR, CMPLT_BTYPE_COND, CMPLT_WH_DPTK, CMPLT_PH_MANY, truePred, target);
 }
 
 //----------------------------------------------------------------------------//
@@ -900,6 +1251,11 @@
     Opnd *tgtAddr             = opndManager->newRegOpnd(OPND_G_REG, DATA_I64);
     Opnd *branchTgt           = opndManager->newRegOpnd(OPND_B_REG, DATA_I64);
     
+    addNewInst(INST_DEF, p0, tgt);
+    addNewInst(INST_DEF, p0, defTgt);
+    addNewInst(INST_DEF, p0, tgtAddr);
+    addNewInst(INST_DEF, p0, branchTgt);
+
     // mov to maxTgtValue, defTgtValue, fallThroughTgtValue to GRs
     addNewInst(INST_MOV, p0, tgt,            tgtValue);
     addNewInst(INST_MOV, p0, maxTgt,         maxTgtValue);
@@ -1120,7 +1476,7 @@
     RegOpnd *exceptionObj = opndManager->newRegOpnd(OPND_G_REG, DATA_U64, RET_G_REG);
     RegOpnd *dst          = opndManager->newRegOpnd(OPND_G_REG, DATA_U64);
     
-    addNewInst(INST_DEF, p0, exceptionObj);
+    addNewInst(INST_DEF, p0, exceptionObj); // DON'T REMOVE, THIS IS NOT FOR OPTIMIZATION
     addNewInst(INST_MOV, p0, dst, exceptionObj);
     return dst;
 }
@@ -1130,7 +1486,7 @@
 
 CG_OpndHandle *IpfInstCodeSelector::tau_checkNull(CG_OpndHandle *base, bool checksThisForInlinedMethod) {
     
-    IPF_LOG << "      tau_checkNull" << endl;
+    IPF_LOG << "      tau_checkNull; base=" << IrPrinter::toString((Opnd *)base) << endl;
     IPF_ASSERT(((Opnd *)base)->isReg());
 
     RegOpnd *truePred = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
@@ -1149,7 +1505,7 @@
     CompilationInterface::RuntimeHelperId hId = CompilationInterface::Helper_NullPtrException;
     uint64  address        = (uint64) compilationInterface.getRuntimeHelperAddress(hId);
     Opnd    *helperAddress = opndManager->newImm(address);
-    directCall(0, NULL, NULL, helperAddress, truePred, CMPLT_WH_SPNT);
+    directCall(0, NULL, NULL, helperAddress, truePred, CMPLT_WH_DPNT);
 
     return opndManager->getTau();    // return fake value (we do not use tau)
 }
@@ -1170,7 +1526,7 @@
     CompilationInterface::RuntimeHelperId hId = CompilationInterface::Helper_ArrayBoundsException;
     uint64  address        = (uint64) compilationInterface.getRuntimeHelperAddress(hId);
     Opnd    *helperAddress = opndManager->newImm(address);
-    directCall(0, NULL, NULL, helperAddress, truePred, CMPLT_WH_SPNT);
+    directCall(0, NULL, NULL, helperAddress, truePred, CMPLT_WH_DPNT);
 
     return opndManager->getTau();    // return fake value (we do not use tau);
 }
@@ -1191,7 +1547,7 @@
     CompilationInterface::RuntimeHelperId hId = CompilationInterface::Helper_ArrayBoundsException;
     uint64  address        = (uint64) compilationInterface.getRuntimeHelperAddress(hId);
     Opnd    *helperAddress = opndManager->newImm(address);
-    directCall(0, NULL, NULL, helperAddress, truePred, CMPLT_WH_SPNT);
+    directCall(0, NULL, NULL, helperAddress, truePred, CMPLT_WH_DPNT);
 
     return opndManager->getTau();    // return fake value (we do not use tau);
 }
@@ -1212,7 +1568,7 @@
     CompilationInterface::RuntimeHelperId hId = CompilationInterface::Helper_ArrayBoundsException;
     uint64  address        = (uint64) compilationInterface.getRuntimeHelperAddress(hId);
     Opnd    *helperAddress = opndManager->newImm(address);
-    directCall(0, NULL, NULL, helperAddress, truePred, CMPLT_WH_SPNT);
+    directCall(0, NULL, NULL, helperAddress, truePred, CMPLT_WH_DPNT);
 
     return opndManager->getTau();    // return fake value (we do not use tau);
 }
@@ -1252,7 +1608,7 @@
     hId     = CompilationInterface::Helper_ElemTypeException;
     address = (uint64) compilationInterface.getRuntimeHelperAddress(hId);
     Opnd    *helperAddress2 = opndManager->newImm(address);
-    directCall(0, NULL, NULL, helperAddress2, truePred, CMPLT_WH_SPNT);
+    directCall(0, NULL, NULL, helperAddress2, truePred, CMPLT_WH_DPNT);
     
     return opndManager->getTau();    // return fake value (we do not use tau);
 }
@@ -1262,7 +1618,7 @@
 
 CG_OpndHandle *IpfInstCodeSelector::tau_checkZero(CG_OpndHandle *src_) {
 
-    IPF_LOG << "      tau_checkZero" << endl;
+    IPF_LOG << "      tau_checkZero; src=" << IrPrinter::toString((Opnd *)src_) << endl;
 
     // p0  cmp.eq  p2, p0 = base, r0
     RegOpnd *src      = toRegOpnd(src_);
@@ -1274,7 +1630,7 @@
     CompilationInterface::RuntimeHelperId hId = CompilationInterface::Helper_DivideByZeroException;
     uint64  address        = (uint64) compilationInterface.getRuntimeHelperAddress(hId);
     Opnd    *helperAddress = opndManager->newImm(address);
-    directCall(0, NULL, NULL, helperAddress, truePred, CMPLT_WH_SPNT);
+    directCall(0, NULL, NULL, helperAddress, truePred, CMPLT_WH_DPNT);
 
     return opndManager->getTau();    // return fake value (we do not use tau)
 }
@@ -1514,7 +1870,9 @@
                                                 FieldDesc     *fieldDesc) {
 
     IPF_LOG << "      ldFieldAddr " << fieldDesc->getName() 
-        << "(" << Type::tag2str(fieldRefType->tag) << ")" << endl;
+        << "(" << Type::tag2str(fieldRefType->tag) << ")"
+        << "; base=" << IrPrinter::toString((Opnd *)base)
+        << endl;
 
     Opnd    *fieldOffset  = opndManager->newImm(fieldDesc->getOffset());
     RegOpnd *fieldAddress = opndManager->newRegOpnd(OPND_G_REG, DATA_MPTR);
@@ -1888,6 +2246,7 @@
         }
 
         Opnd *outArg = opndManager->newRegOpnd(opndKind, dataKind, location);
+
         addNewInst(instCode, pred, outArg, opnd); 
         callInst->addOpnd(outArg);                                    // add the opnd in call opnds list (for data flow analysis)
     }
@@ -1996,18 +2355,23 @@
 
 //----------------------------------------------------------------------------//
 // If opnd is imm this method generates "mov" from imm to gr
-
+// if imm==0 then return r0
+//
 RegOpnd *IpfInstCodeSelector::toRegOpnd(CG_OpndHandle *opnd_) {
 
     if(((Opnd *)opnd_)->isReg()) return (RegOpnd *)opnd_;
     IPF_ASSERT(((Opnd *)opnd_)->isImm());
 
     Opnd     *opnd    = (Opnd *)opnd_;
-    RegOpnd  *dst     = opndManager->newRegOpnd(OPND_G_REG, DATA_I64);
-    InstCode instCode = opnd->isFoldableImm(22) ? INST_MOV : INST_MOVL;
-    
-    addNewInst(instCode, p0, dst, opnd);
-    return dst;
+    if (opnd->getValue()==0) {
+        return opndManager->getR0();
+    } else {
+        RegOpnd  *dst     = opndManager->newRegOpnd(OPND_G_REG, DATA_I64);
+        InstCode instCode = opnd->isFoldableImm(22) ? INST_MOV : INST_MOVL;
+        
+        addNewInst(instCode, p0, dst, opnd);
+        return dst;
+    }
 }
 
 //----------------------------------------------------------------------------//
@@ -2084,8 +2448,7 @@
 
     // imm opnd must be on first position
     if(src2->isImm()) {
-        Opnd *buf = src1;
-        src1      = src2;
+        Opnd *buf = src2;
         src2      = toRegOpnd(buf);
     }
     
@@ -2121,6 +2484,8 @@
     Opnd    *src1 = (Opnd *)src1_;
     Opnd    *src2 = (Opnd *)src2_;
 
+    IPF_ASSERT(src1->isReg() || src2->isReg());
+
     // imm opnd must be on first position
     if(src2->isImm()) {
         Opnd *buf = src1;
@@ -2250,6 +2615,9 @@
                               CG_OpndHandle *src1, 
                               CG_OpndHandle *src2) {
 
+    IPF_ASSERT(((Opnd *)src1)->isReg());
+    IPF_ASSERT(((Opnd *)src2)->isReg());
+
     RegOpnd *f0   = opndManager->getF0();
     RegOpnd *buf1 = opndManager->newRegOpnd(OPND_F_REG, DATA_D);
     RegOpnd *buf2 = opndManager->newRegOpnd(OPND_F_REG, DATA_D);
@@ -2323,37 +2691,73 @@
 //      sxt4     dst = t2
 // (p1) shr.u    dst = t1, 33
 // (p2) shl      dst = t1, 31
+//
+// New code
+//             ldfd       tf = MAXINT4
+//             fcmp.lt    p11,p10 = src, tf
+// (p10)       movl       dst = 0x7fffffff
+// (p10)       cmp.ne     p10 = r0,r0
+//
+// (p11)       ldfd       tf = MININT4
+// (p11)       fcmp.gt    p11,p10 = src, tf
+// (p10)       movl       dst = 0x80000000
+//
+// (p11)       fcvt.fx    tf = src
+// (p11)       getf.sig   dst = tf
 
 void IpfInstCodeSelector::saturatingConv4(RegOpnd *dst, CG_OpndHandle *src_) {
 
+    IPF_LOG << "      saturatingConv4" << endl;
+
     IPF_ASSERT(((Opnd *)src_)->isFloating());
     
+    union {
+        float  fr;
+        uint32 gr;
+    } fval;
+    union {
+        double fr;
+        uint64 gr;
+    } dval;
+    
+    RegOpnd *r0  = opndManager->getR0();
     RegOpnd *src = (RegOpnd *)src_;
-    RegOpnd *p1  = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
-    RegOpnd *p2  = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
-    RegOpnd *t1  = opndManager->newRegOpnd(OPND_G_REG, DATA_U64);
-    RegOpnd *t2  = opndManager->newRegOpnd(OPND_G_REG, DATA_U64);
-    RegOpnd *tf1 = NULL;
-    RegOpnd *tf2 = NULL;
-    RegOpnd *tf3 = opndManager->newRegOpnd(OPND_F_REG, src->getDataKind());
+    RegOpnd *p11 = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
+    RegOpnd *p10 = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
+    RegOpnd *tf  = NULL;
+    RegOpnd *tr  = opndManager->newRegOpnd(OPND_G_REG, DATA_I64);
+
+    if (src->getDataKind() == DATA_S) {
+        tf = opndManager->newRegOpnd(OPND_F_REG, DATA_S);
+        fval.fr = (float)0x7fffffff;
+        addNewInst(INST_MOVL, p0, tr, opndManager->newImm(fval.gr));
+        addNewInst(INST_SETF_S, p0, tf, tr);
+    } else {
+        tf = opndManager->newRegOpnd(OPND_F_REG, DATA_D);
+        dval.fr = (double)0x7fffffff;
+        addNewInst(INST_MOVL, p0, tr, opndManager->newImm(dval.gr));
+        addNewInst(INST_SETF_D, p0, tf, tr);
+    }
+    addNewInst(INST_FCMP, CMPLT_CMP_CREL_LT, p0, p11, p10, src, tf);
+    addNewInst(INST_MOVL, p10, dst, opndManager->newImm(0x7fffffff));
+    addNewInst(INST_CMP, CMPLT_CMP_CREL_NE, p10, p10, p0, r0, r0);
 
     if (src->getDataKind() == DATA_S) {
-        tf1 = (RegOpnd *)ldc_s((float)0x7fffffff);
-        tf2 = (RegOpnd *)ldc_s((float)((int) 0x80000000));
+        fval.fr = (float)((int)0x80000000);
+        addNewInst(INST_MOVL, p11, tr, opndManager->newImm(fval.gr));
+        addNewInst(INST_SETF_S, p11, tf, tr);
     } else {
-        tf1 = (RegOpnd *)ldc_d((double)0x7fffffff);
-        tf2 = (RegOpnd *)ldc_d((double)((int) 0x80000000));
+        tf = opndManager->newRegOpnd(OPND_F_REG, DATA_D);
+        dval.fr = (double)((int) 0x80000000);
+        addNewInst(INST_MOVL, p11, tr, opndManager->newImm(dval.gr));
+        addNewInst(INST_SETF_D, p11, tf, tr);
     }
+    addNewInst(INST_FCMP, CMPLT_CMP_CREL_GT, p11, p11, p10, src, tf);
+    addNewInst(INST_MOVL, p10, dst, opndManager->newImm(0x80000000));
+
+    addNewInst(INST_FCVT_FX_TRUNC, p11, tf, src);
+    addNewInst(INST_GETF_SIG, p11, dst, tf);
 
-    sxt(src, 8);    // sxt src if appropriate
-    addNewInst(INST_MOV, p0, t1, opndManager->newImm(-1));
-    addNewInst(INST_FCVT_FX_TRUNC, p0, tf3, src);
-    addNewInst(INST_FCMP, CMPLT_CMP_CREL_GT, p0, p1, p0, src, tf1);
-    addNewInst(INST_FCMP, CMPLT_CMP_CREL_LT, p0, p2, p0, src, tf2);
-    addNewInst(INST_GETF_SIG, p0, t2, tf3);
-    addNewInst(INST_SXT, CMPLT_XSZ_4, p0, dst, t2);
-    addNewInst(INST_SHR_U, p1, dst, t1, opndManager->newImm(33));
-    addNewInst(INST_SHL, p2, dst, t1, opndManager->newImm(31));
 }
 
 //----------------------------------------------------------------------------//
@@ -2375,6 +2779,12 @@
 
     sxt(src1, 8);
     sxt(src2, 8);
+
+    addNewInst(INST_DEF,                    p0,f6 );
+    addNewInst(INST_DEF,                    p0,f7 );
+    addNewInst(INST_DEF,                    p0,f8 );
+    addNewInst(INST_DEF,                    p0,f9 );
+    addNewInst(INST_DEF,                    p0,f10);
     
     addNewInst(INST_SETF_SIG, p0, f10, src1);
     addNewInst(INST_SETF_SIG, p0, f9,  src2);
@@ -2410,9 +2820,9 @@
     IPF_ASSERT(((Opnd *)src1)->isReg());
     IPF_ASSERT(((Opnd *)src2)->isReg());
     
-    RegOpnd *p6   = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
     RegOpnd *f0   = opndManager->getF0();
     RegOpnd *f1   = opndManager->getF1();
+    RegOpnd *p6   = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
     RegOpnd *f6   = opndManager->newRegOpnd(OPND_F_REG, DATA_D);
     RegOpnd *f7   = opndManager->newRegOpnd(OPND_F_REG, DATA_D);
     RegOpnd *f8   = opndManager->newRegOpnd(OPND_F_REG, DATA_D);
@@ -2421,6 +2831,12 @@
 
     sxt(src1, 8);
     sxt(src2, 8);
+
+    addNewInst(INST_DEF,                    p0,f6 );
+    addNewInst(INST_DEF,                    p0,f7 );
+    addNewInst(INST_DEF,                    p0,f8 );
+    addNewInst(INST_DEF,                    p0,f9 );
+    addNewInst(INST_DEF,                    p0,f10);
     
     addNewInst(INST_SETF_SIG, p0, f10, src1);
     addNewInst(INST_SETF_SIG, p0, f9, src2);
@@ -2496,6 +2912,18 @@
         //  Group 6
         //      (pX) fma.d.s0   fRes  = fr,fy3,fq3
         //
+        addNewInst(INST_DEF,                    p0, fe );
+        addNewInst(INST_DEF,                    p0, fq0);
+        addNewInst(INST_DEF,                    p0, fq1);
+        addNewInst(INST_DEF,                    p0, fe2);
+        addNewInst(INST_DEF,                    p0, fy1);
+        addNewInst(INST_DEF,                    p0, fe4);
+        addNewInst(INST_DEF,                    p0, fq2);
+        addNewInst(INST_DEF,                    p0, fy2);
+        addNewInst(INST_DEF,                    p0, fq3);
+        addNewInst(INST_DEF,                    p0, fy3);
+        addNewInst(INST_DEF,                    p0, fr );
+
         addNewInst(INST_FRCPA,                CMPLT_SF0, p0, fRes, pX,   fA,   fB);
 
         addNewInst(INST_FNMA,                 CMPLT_SF1, pX, fe,   fRes, fB,   f1);
@@ -2542,8 +2970,8 @@
         RegOpnd *f1 = opndManager->getF1();
 
         RegOpnd *fRes = dst, *fA = (RegOpnd *)src1, *fB = (RegOpnd *)src2;
-        RegOpnd *pX = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
-        RegOpnd *fe = opndManager->newRegOpnd(OPND_F_REG, DATA_F); 
+        RegOpnd *pX  = opndManager->newRegOpnd(OPND_P_REG, DATA_P);
+        RegOpnd *fe  = opndManager->newRegOpnd(OPND_F_REG, DATA_F); 
         RegOpnd *fq0 = opndManager->newRegOpnd(OPND_F_REG, DATA_F); 
         RegOpnd *fq1 = opndManager->newRegOpnd(OPND_F_REG, DATA_F); 
         RegOpnd *fe2 = opndManager->newRegOpnd(OPND_F_REG, DATA_F); 
@@ -2567,7 +2995,15 @@
         //      (pX) fma.d.s1   fq3   = fq2,fe4,fq2
         //      (pX) fnorm.s.s0 fRes  = fq3
         //
-        // Group 0
+
+        addNewInst(INST_DEF,                    p0, fe );
+        addNewInst(INST_DEF,                    p0, fq0);
+        addNewInst(INST_DEF,                    p0, fq1);
+        addNewInst(INST_DEF,                    p0, fe2);
+        addNewInst(INST_DEF,                    p0, fe4);
+        addNewInst(INST_DEF,                    p0, fq2);
+        addNewInst(INST_DEF,                    p0, fq3);
+        
         addNewInst(INST_FRCPA,                  CMPLT_SF0, p0, fRes, pX,   fA,   fB);
 
         addNewInst(INST_FNMA,                   CMPLT_SF1, pX, fe,   fRes, fB,   f1);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfIrPrinter.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfIrPrinter.cpp?view=diff&rev=477525&r1=477524&r2=477525
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfIrPrinter.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfIrPrinter.cpp Mon Nov 20 22:23:40 2006
@@ -169,6 +169,7 @@
     *ofs << "  fontpath=\"c:\\winnt\\fonts\";" << ::std::endl;
     *ofs << "  node [shape=record,fontname=\"Courier\",fontsize=9];" << ::std::endl;
     *ofs << "  edge [fontname=\"Courier\",fontsize=9];" << ::std::endl;
+
 }
 
 //----------------------------------------------------------------------------------------//

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpndManager.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpndManager.cpp?view=diff&rev=477525&r1=477524&r2=477525
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpndManager.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpndManager.cpp Mon Nov 20 22:23:40 2006
@@ -249,7 +249,9 @@
     refsCompressed       = compilationInterface.areReferencesCompressed();
     vtablePtrsCompressed = compilationInterface.areVTablePtrsCompressed();
     heapBase             = NULL;
+    heapBaseImm          = NULL;
     vtableBase           = NULL;
+    vtableBaseImm        = NULL;
     vtableOffset         = NULL;
 }
 
@@ -309,6 +311,11 @@
     return heapBase; 
 } 
 
+Opnd *OpndManager::getHeapBaseImm() { 
+    if (heapBaseImm == NULL) heapBaseImm = newImm(0x7777777777777777);
+    return heapBaseImm;
+} 
+
 //----------------------------------------------------------------------------------------//
 
 RegOpnd *OpndManager::getVtableBase() {
@@ -316,6 +323,11 @@
     return vtableBase;
 } 
 
+Opnd *OpndManager::getVtableBaseImm() {
+    if (vtableBaseImm == NULL) vtableBaseImm = newImm(0x7777777777777777);
+    return vtableBaseImm;
+}
+
 //----------------------------------------------------------------------------------------//
 
 Opnd *OpndManager::getVtableOffset() { 
@@ -338,18 +350,26 @@
 
     if (heapBase != NULL) {
         baseValue  = (uint64) compilationInterface.getHeapBase();
+        
         baseImm    = newImm(baseValue);
         Inst *inst = new(mm) Inst(mm, INST_MOVL, p0, heapBase, baseImm);
         insts.insert(insts.begin(), inst);
         IPF_LOG << "    HeapBase initialization code inserted" << endl;
     }
-
+    if (heapBaseImm != NULL) {
+        heapBaseImm->setValue((uint64)compilationInterface.getHeapBase());
+    }
+        
     if (vtableBase != NULL) {
         baseValue  = (uint64) compilationInterface.getVTableBase();
+
         baseImm    = newImm(baseValue);
         Inst *inst = new(mm) Inst(mm, INST_MOVL, p0, vtableBase, baseImm);
         insts.insert(insts.begin(), inst);
         IPF_LOG << "    VtableBase initialization code inserted" << endl;
+    }
+    if (vtableBaseImm != NULL) {
+        vtableBaseImm->setValue((uint64)compilationInterface.getVTableBase());
     }
 }
 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfType.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfType.cpp?view=diff&rev=477525&r1=477524&r2=477525
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfType.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfType.cpp Mon Nov 20 22:23:40 2006
@@ -27,6 +27,7 @@
 
 bool ipfLogIsOn = false;
 bool ipfVerifyIsOn = true;
+bool ipfConstantFolding = true;
 
 //============================================================================//
 // IpfType
@@ -74,6 +75,46 @@
         case OPND_A_REG   : 
         case OPND_IP_REG  : 
         case OPND_UM_REG  : return true;
+        case OPND_IMM     : return false;
+        case OPND_INVALID : break;
+    }
+
+    IPF_ERR << " unexpected opndKind " << opndKind << endl;
+    return 0;
+}
+    
+//----------------------------------------------------------------------------------------//
+
+bool IpfType::isGReg(OpndKind opndKind) { 
+
+    switch(opndKind) {
+        case OPND_G_REG   : return true; 
+        case OPND_F_REG   : 
+        case OPND_P_REG   : 
+        case OPND_B_REG   : 
+        case OPND_A_REG   : 
+        case OPND_IP_REG  : 
+        case OPND_UM_REG  :
+        case OPND_IMM     : return false;
+        case OPND_INVALID : break;
+    }
+
+    IPF_ERR << " unexpected opndKind " << opndKind << endl;
+    return 0;
+}
+    
+//----------------------------------------------------------------------------------------//
+
+bool IpfType::isFReg(OpndKind opndKind) { 
+
+    switch(opndKind) {
+        case OPND_G_REG   : return false; 
+        case OPND_F_REG   : return true;
+        case OPND_P_REG   : 
+        case OPND_B_REG   : 
+        case OPND_A_REG   : 
+        case OPND_IP_REG  : 
+        case OPND_UM_REG  :
         case OPND_IMM     : return false;
         case OPND_INVALID : break;
     }

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfVerifier.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfVerifier.cpp?view=diff&rev=477525&r1=477524&r2=477525
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfVerifier.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfVerifier.cpp Mon Nov 20 22:23:40 2006
@@ -144,6 +144,9 @@
                 << (res->empty() ? "" : " : ") << *res
                 << "\n";
             ret = false;
+#ifndef NDEBUG
+            verifyInst(res, inst);  // verify again for debugger
+#endif
         }
     }
 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h?view=diff&rev=477525&r1=477524&r2=477525
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h Mon Nov 20 22:23:40 2006
@@ -144,6 +144,8 @@
     virtual int64   getValue()                      { return value; }
 
     bool            isReg()                         { return IpfType::isReg(opndKind); }
+    bool            isGReg()                        { return IpfType::isGReg(opndKind); }
+    bool            isFReg()                        { return IpfType::isFReg(opndKind); }
     bool            isImm()                         { return IpfType::isImm(opndKind); }
     bool            isFloating()                    { return IpfType::isFloating(dataKind); }
     bool            isSigned()                      { return IpfType::isSigned(dataKind); }
@@ -151,9 +153,9 @@
     bool            isWritable();
     bool            isConstant();
     bool            isMem();
-    bool            isImm(int);
 
-    bool            isFoldableImm(int16 size)       { return isFoldableImm(value, size); }
+    bool            isFoldableImm(int16 size) { return isFoldableImm(value, size); }
+    bool            isImm(int);
     static bool     isFoldableImm(int64 value, int16 size);
     
 protected:

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfEmitter.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfEmitter.h?view=diff&rev=477525&r1=477524&r2=477525
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfEmitter.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfEmitter.h Mon Nov 20 22:23:40 2006
@@ -47,19 +47,22 @@
 //========================================================================================//
 
 //
-//  Constants that describe cache on IPF
+//  Constants that describe cache on Itanium2
 //
 
 //
 //  Level 1 cache
 //
-#define L1_CACHE_LINE_SIZE 64       
+#define L1I_CACHE_LINE_SIZE 64       
+#define L1I_CACHE_BANK_SIZE 16384
+#define L1D_CACHE_LINE_SIZE 64       
+#define L1D_CACHE_BANK_SIZE 16384
 
 //
 //  Level 2 cache
 //
-#define L2_CACHE_BANK_SIZE 16
-#define NUM_L2_CACHE_BANKS 16
+#define L2_CACHE_LINE_SIZE 128
+#define L2_CACHE_BANK_SIZE 262144
 
 
 #define PR(n)  (opndManager->newRegOpnd(OPND_P_REG, DATA_P, n))
@@ -128,7 +131,9 @@
     
     Inst   * getSlot(int si) { return slot[si]; };
     uint32   getTmplIndex() { return indxtmpl; };
-    uint32   getTmpl();
+    uint32   getTmpl() { return BundleDesc[indxtmpl].tmpl; };
+    bool     hasStop() { uint32 t = getTmpl(); 
+                         if (t%2==1 || t==0x2 || t==0xa) return true; return false; };
     void     emitBundleGeneral(void *);
     void     emitBundleExtended(void *);
     void     emitBundleBranch(void *, int *);
@@ -137,6 +142,8 @@
     uint64   getSlotBitsBranch(int, int);
     uint64 * getSlotBitsExtended(uint64 *, void *);
 
+    static const BundleDescription BundleDesc[TEMPLATES_COUNT];
+
   protected:
     uint32  indxtmpl;
     Inst   *slot[IPF_SLOTS_COUNT];
@@ -174,6 +181,7 @@
     vectorregs   * rregs;
     BundleVector * bundles;
     vectorconst  * consts;
+    bool           istarget;
     
     long           bsize;
     char         * codeoff;   // offset in full code block
@@ -200,8 +208,7 @@
     void registerDirectCall(Inst *, uint64);
 
     static InstructionType getExecUnitType(int, int);
-
-    static const BundleDescription BundleDesc[TEMPLATES_COUNT];
+    static const char Itanium2_DualIssueBundles[30][30];
     
   protected:
     static void getTmpl(int, BundleDescription &, Inst *, Inst *, Inst *, bool, bool, bool);
@@ -210,6 +217,7 @@
     static void getReadDpndBitset(Inst *, RegistersBitset *);
     static bool tricking(InstVector & insts, MemoryManager& mm, Cfg& cfg);
     static int  removeUselessInst(Cfg &, CompilationInterface &);
+    static int  removeIgnoreTypeInst(Cfg &, CompilationInterface &);
     bool    parsing();
     bool    parsing(int);
     bool    stopping();
@@ -219,8 +227,10 @@
     bool    emitData();
     bool    emitCode();
     bool    fixSwitchTables();
+    void    checkForDualIssueBundles();
     bool    isBranchBundle(Bundle *, char *, char *, int *);
     bool    isExtendedBundle(Bundle *bundle) { if (bundle->getTmpl()>=0x4 && bundle->getTmpl()<=0x5) return true; return false; };
+    int     getBbNodeIndex(BbNode * node);
     char  * getBbNodeOff(BbNode * node);
 
     MemoryManager& mm;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfOpndManager.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfOpndManager.h?view=diff&rev=477525&r1=477524&r2=477525
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfOpndManager.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfOpndManager.h Mon Nov 20 22:23:40 2006
@@ -204,7 +204,9 @@
     bool         areRefsCompressed()       { return refsCompressed; }
     bool         areVtablePtrsCompressed() { return vtablePtrsCompressed; }
     RegOpnd      *getHeapBase();
+    Opnd         *getHeapBaseImm();
     RegOpnd      *getVtableBase();
+    Opnd         *getVtableBaseImm();
     Opnd         *getVtableOffset();
     void         initCompBases(BbNode*);
     
@@ -234,8 +236,10 @@
     RegOpnd      *f8;                  // return value (floating point)
     RegOpnd      *tau;                 // opnd ignored
     
-    RegOpnd      *heapBase;            // opnd containing base for references decompression
-    RegOpnd      *vtableBase;          // opnd containing base for vtable pointers decompression
+    RegOpnd      *heapBase;            // Reg opnd containing base for references decompression
+    Opnd         *heapBaseImm;         // Imm opnd containing base for references decompression
+    RegOpnd      *vtableBase;          // Reg opnd containing base for vtable pointers decompression
+    Opnd         *vtableBaseImm;       // Imm opnd containing base for vtable pointers decompression
     Opnd         *vtableOffset;        // opnd containing vtable offset inside class object
 
     bool         containCall;          // method contains call instruction

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfType.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfType.h?view=diff&rev=477525&r1=477524&r2=477525
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfType.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfType.h Mon Nov 20 22:23:40 2006
@@ -109,10 +109,11 @@
 #define IPF_LOG   if (LOG_ON) LOG_OUT
 #define IPF_STAT  if (STAT_ON) LOG_OUT
 #define IPF_ERR   cerr << IPF_ERROR 
-#define IPF_ASSERT(condition) if (LOG_ON && !(condition)) { IPF_ERR << (#condition) << endl; }
+#define IPF_ASSERT(condition) if (VERIFY_ON && !(condition)) { IPF_ERR << (#condition) << endl; }
 
 extern bool ipfLogIsOn;
 extern bool ipfVerifyIsOn;
+extern bool ipfConstantFolding;
 
 //========================================================================================//
 // Enums
@@ -237,6 +238,8 @@
 
     static int16    getSize(DataKind);     // opnd value size in bytes
     static bool     isReg(OpndKind);       // is opnd resides on register
+    static bool     isGReg(OpndKind);      // is opnd resides on general register
+    static bool     isFReg(OpndKind);      // is opnd resides on general register
     static bool     isImm(OpndKind);       // is opnd resides in imm
     static bool     isSigned(DataKind);    // is opnd value is signed
     static bool     isFloating(DataKind);  // is opnd value can be placed in fp reg



Mime
View raw message