Add supprot for shufflevector

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@27513 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp
index a57cea8b7e517956a51f7519533ad1717084fc04..9328a251d8a817983fa609b42d8e9b44cbfec75a 100644 (file)
--- a/lib/Transforms/Scalar/SCCP.cpp
+++ b/lib/Transforms/Scalar/SCCP.cpp
@@ -330,6 +330,7 @@ private:
   void visitShiftInst(ShiftInst &I) { visitBinaryOperator(I); }
   void visitExtractElementInst(ExtractElementInst &I);
   void visitInsertElementInst(InsertElementInst &I);
+  void visitShuffleVectorInst(ShuffleVectorInst &I);
 
   // Instructions that cannot be folded away...
   void visitStoreInst     (Instruction &I);
@@ -782,6 +783,30 @@ void SCCPSolver::visitInsertElementInst(InsertElementInst &I) {
                                                     IdxState.getConstant()));
 }
 
+void SCCPSolver::visitShuffleVectorInst(ShuffleVectorInst &I) {
+  LatticeVal &V1State   = getValueState(I.getOperand(0));
+  LatticeVal &V2State   = getValueState(I.getOperand(1));
+  LatticeVal &MaskState = getValueState(I.getOperand(2));
+
+  if (MaskState.isUndefined() ||
+      (V1State.isUndefined() && V2State.isUndefined()))
+    return;  // Undefined output if mask or both inputs undefined.
+  
+  if (V1State.isOverdefined() || V2State.isOverdefined() ||
+      MaskState.isOverdefined()) {
+    markOverdefined(&I);
+  } else {
+    // A mix of constant/undef inputs.
+    Constant *V1 = V1State.isConstant() ? 
+        V1State.getConstant() : UndefValue::get(I.getType());
+    Constant *V2 = V2State.isConstant() ? 
+        V2State.getConstant() : UndefValue::get(I.getType());
+    Constant *Mask = MaskState.isConstant() ? 
+      MaskState.getConstant() : UndefValue::get(I.getOperand(2)->getType());
+    markConstant(&I, ConstantExpr::getShuffleVector(V1, V2, Mask));
+  }
+}
+
 // Handle getelementptr instructions... if all operands are constants then we
 // can turn this into a getelementptr ConstantExpr.
 //

diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp
index a35a1a69af1ae096251bd9d778197dfb58aa9431..a848e7461eb3f87f55578fe2ddfa16c2ab73f08f 100644 (file)
--- a/lib/Transforms/Utils/Local.cpp
+++ b/lib/Transforms/Utils/Local.cpp
@@ -107,6 +107,11 @@ Constant *llvm::ConstantFoldInstruction(Instruction *I) {
   case Instruction::InsertElement:
     if (Constant *Op2 = dyn_cast<Constant>(I->getOperand(2)))
       return ConstantExpr::getInsertElement(Op0, Op1, Op2);
+    return 0;
+  case Instruction::ShuffleVector:
+    if (Constant *Op2 = dyn_cast<Constant>(I->getOperand(2)))
+      return ConstantExpr::getShuffleVector(Op0, Op1, Op2);
+    return 0;
   case Instruction::GetElementPtr:
     std::vector<Constant*> IdxList;
     IdxList.reserve(I->getNumOperands()-1);

diff --git a/lib/Transforms/Utils/ValueMapper.cpp b/lib/Transforms/Utils/ValueMapper.cpp
index 3093acafab2b83e52b29a149786adc734695d49b..b309f9c0e2a7d715bf23f00d3425fff644f594ac 100644 (file)
--- a/lib/Transforms/Utils/ValueMapper.cpp
+++ b/lib/Transforms/Utils/ValueMapper.cpp
@@ -94,6 +94,11 @@ Value *llvm::MapValue(const Value *V, std::map<const Value*, Value*> &VM) {
         Constant *MV1 = cast<Constant>(MapValue(CE->getOperand(0), VM));
         Constant *MV2 = cast<Constant>(MapValue(CE->getOperand(1), VM));
         return VMSlot = ConstantExpr::getExtractElement(MV1, MV2);
+      } else if (CE->getOpcode() == Instruction::ShuffleVector) {
+        Constant *MV1 = cast<Constant>(MapValue(CE->getOperand(0), VM));
+        Constant *MV2 = cast<Constant>(MapValue(CE->getOperand(1), VM));
+        Constant *MV3 = cast<Constant>(CE->getOperand(2));
+        return VMSlot = ConstantExpr::getShuffleVector(MV1, MV2, MV3);
       } else {
         assert(CE->getNumOperands() == 2 && "Must be binary operator?");
         Constant *MV1 = cast<Constant>(MapValue(CE->getOperand(0), VM));