1b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner//===- InstCombineVectorOps.cpp -------------------------------------------===// 2b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner// 3b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner// The LLVM Compiler Infrastructure 4b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner// 5b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner// This file is distributed under the University of Illinois Open Source 6b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner// License. See LICENSE.TXT for details. 7b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner// 8b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner//===----------------------------------------------------------------------===// 9b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner// 10b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner// This file implements instcombine for ExtractElement, InsertElement and 11b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner// ShuffleVector. 12b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner// 13b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner//===----------------------------------------------------------------------===// 14b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner 15b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner#include "InstCombine.h" 16b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattnerusing namespace llvm; 17b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner 18b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner/// CheapToScalarize - Return true if the value is cheaper to scalarize than it 19bec2d03c4d774e67ebc586b3a00792d996f26140Chris Lattner/// is to leave as a vector operation. isConstant indicates whether we're 20bec2d03c4d774e67ebc586b3a00792d996f26140Chris Lattner/// extracting one known element. If false we're extracting a variable index. 21b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattnerstatic bool CheapToScalarize(Value *V, bool isConstant) { 22230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (Constant *C = dyn_cast<Constant>(V)) { 23b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (isConstant) return true; 24230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner 25230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner // If all elts are the same, we can extract it and use any of the values. 26230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner Constant *Op0 = C->getAggregateElement(0U); 27230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner for (unsigned i = 1, e = V->getType()->getVectorNumElements(); i != e; ++i) 28230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (C->getAggregateElement(i) != Op0) 29b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return false; 30b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return true; 31b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 32b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Instruction *I = dyn_cast<Instruction>(V); 33b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (!I) return false; 3409fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 35b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Insert element gets simplified to the inserted element or is deleted if 36b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // this is constant idx extract element and its a constant idx insertelt. 37b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (I->getOpcode() == Instruction::InsertElement && isConstant && 38b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner isa<ConstantInt>(I->getOperand(2))) 39b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return true; 40b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (I->getOpcode() == Instruction::Load && I->hasOneUse()) 41b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return true; 42b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (BinaryOperator *BO = dyn_cast<BinaryOperator>(I)) 43b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (BO->hasOneUse() && 44b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner (CheapToScalarize(BO->getOperand(0), isConstant) || 45b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner CheapToScalarize(BO->getOperand(1), isConstant))) 46b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return true; 47b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (CmpInst *CI = dyn_cast<CmpInst>(I)) 48b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (CI->hasOneUse() && 49b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner (CheapToScalarize(CI->getOperand(0), isConstant) || 50b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner CheapToScalarize(CI->getOperand(1), isConstant))) 51b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return true; 5209fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 53b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return false; 54b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner} 55b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner 56b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner/// FindScalarElement - Given a vector and an element number, see if the scalar 57b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner/// value is already around as a register, for example if it were inserted then 58b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner/// extracted from the vector. 59b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattnerstatic Value *FindScalarElement(Value *V, unsigned EltNo) { 601df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands assert(V->getType()->isVectorTy() && "Not looking at a vector?"); 61230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner VectorType *VTy = cast<VectorType>(V->getType()); 62230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner unsigned Width = VTy->getNumElements(); 63b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (EltNo >= Width) // Out of range access. 64230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return UndefValue::get(VTy->getElementType()); 6509fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 66230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (Constant *C = dyn_cast<Constant>(V)) 67230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return C->getAggregateElement(EltNo); 6809fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 69d5da27186350345794b82f036d75f6d1e9bfbbbdChris Lattner if (InsertElementInst *III = dyn_cast<InsertElementInst>(V)) { 70b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If this is an insert to a variable element, we don't know what it is. 7109fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson if (!isa<ConstantInt>(III->getOperand(2))) 72b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return 0; 73b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned IIElt = cast<ConstantInt>(III->getOperand(2))->getZExtValue(); 7409fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 75b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If this is an insert to the element we are looking for, return the 76b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // inserted value. 7709fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson if (EltNo == IIElt) 78b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return III->getOperand(1); 7909fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 80b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Otherwise, the insertelement doesn't modify the value, recurse on its 81b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // vector input. 82b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return FindScalarElement(III->getOperand(0), EltNo); 83d5da27186350345794b82f036d75f6d1e9bfbbbdChris Lattner } 8409fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 85d5da27186350345794b82f036d75f6d1e9bfbbbdChris Lattner if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(V)) { 86230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner unsigned LHSWidth = SVI->getOperand(0)->getType()->getVectorNumElements(); 878d992f5c2c90ebc8963679de51f461dc5d54fae1Eli Friedman int InEl = SVI->getMaskValue(EltNo); 8809fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson if (InEl < 0) 89230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return UndefValue::get(VTy->getElementType()); 90822cb58d087ab67804037807e130273481b86137Bob Wilson if (InEl < (int)LHSWidth) 91822cb58d087ab67804037807e130273481b86137Bob Wilson return FindScalarElement(SVI->getOperand(0), InEl); 92822cb58d087ab67804037807e130273481b86137Bob Wilson return FindScalarElement(SVI->getOperand(1), InEl - LHSWidth); 93b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 9409fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 95b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Otherwise, we don't know. 96b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return 0; 97b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner} 98b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner 99b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris LattnerInstruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) { 100230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner // If vector val is constant with all elements the same, replace EI with 101230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner // that element. We handle a known element # below. 102230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (Constant *C = dyn_cast<Constant>(EI.getOperand(0))) 103230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (CheapToScalarize(C, false)) 104230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return ReplaceInstUsesWith(EI, C->getAggregateElement(0U)); 10509fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 106b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If extracting a specified index from the vector, see if we can recursively 107b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // find a previously computed scalar that was inserted into the vector. 108b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (ConstantInt *IdxC = dyn_cast<ConstantInt>(EI.getOperand(1))) { 109b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned IndexVal = IdxC->getZExtValue(); 110b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned VectorWidth = EI.getVectorOperandType()->getNumElements(); 11109fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 112b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If this is extracting an invalid index, turn this into undef, to avoid 113b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // crashing the code below. 114b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (IndexVal >= VectorWidth) 115b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType())); 11609fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 117b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // This instruction only demands the single element from the input vector. 118b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If the input vector has a single use, simplify it based on this use 119b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // property. 120b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (EI.getOperand(0)->hasOneUse() && VectorWidth != 1) { 121b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner APInt UndefElts(VectorWidth, 0); 1228609fda0f7e4446de85f882755601ffcbd540324Chris Lattner APInt DemandedMask(VectorWidth, 0); 1237a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad DemandedMask.setBit(IndexVal); 124b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (Value *V = SimplifyDemandedVectorElts(EI.getOperand(0), 125b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner DemandedMask, UndefElts)) { 126b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner EI.setOperand(0, V); 127b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return &EI; 128b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 129b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 13009fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 131b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (Value *Elt = FindScalarElement(EI.getOperand(0), IndexVal)) 132b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return ReplaceInstUsesWith(EI, Elt); 13309fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 134b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If the this extractelement is directly using a bitcast from a vector of 135b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // the same number of elements, see if we can find the source element from 136b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // it. In this case, we will end up needing to bitcast the scalars. 137b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (BitCastInst *BCI = dyn_cast<BitCastInst>(EI.getOperand(0))) { 138230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (VectorType *VT = dyn_cast<VectorType>(BCI->getOperand(0)->getType())) 139b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (VT->getNumElements() == VectorWidth) 140b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (Value *Elt = FindScalarElement(BCI->getOperand(0), IndexVal)) 141b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return new BitCastInst(Elt, EI.getType()); 142b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 143b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 14409fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 145b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (Instruction *I = dyn_cast<Instruction>(EI.getOperand(0))) { 146b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Push extractelement into predecessor operation if legal and 147b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // profitable to do so 148b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (BinaryOperator *BO = dyn_cast<BinaryOperator>(I)) { 149b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (I->hasOneUse() && 150b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner CheapToScalarize(BO, isa<ConstantInt>(EI.getOperand(1)))) { 151b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *newEI0 = 152db1da8ed42cbe50945acfaca514864723999150aBob Wilson Builder->CreateExtractElement(BO->getOperand(0), EI.getOperand(1), 153db1da8ed42cbe50945acfaca514864723999150aBob Wilson EI.getName()+".lhs"); 154b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *newEI1 = 155db1da8ed42cbe50945acfaca514864723999150aBob Wilson Builder->CreateExtractElement(BO->getOperand(1), EI.getOperand(1), 156db1da8ed42cbe50945acfaca514864723999150aBob Wilson EI.getName()+".rhs"); 157b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return BinaryOperator::Create(BO->getOpcode(), newEI0, newEI1); 158b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 159b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } else if (InsertElementInst *IE = dyn_cast<InsertElementInst>(I)) { 160b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Extracting the inserted element? 161b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (IE->getOperand(2) == EI.getOperand(1)) 162b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return ReplaceInstUsesWith(EI, IE->getOperand(1)); 163b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If the inserted and extracted elements are constants, they must not 164b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // be the same value, extract from the pre-inserted value instead. 165b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (isa<Constant>(IE->getOperand(2)) && isa<Constant>(EI.getOperand(1))) { 166b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Worklist.AddValue(EI.getOperand(0)); 167b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner EI.setOperand(0, IE->getOperand(0)); 168b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return &EI; 169b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 170b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } else if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(I)) { 171b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If this is extracting an element from a shufflevector, figure out where 172b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // it came from and extract from the appropriate input element instead. 173b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (ConstantInt *Elt = dyn_cast<ConstantInt>(EI.getOperand(1))) { 1748d992f5c2c90ebc8963679de51f461dc5d54fae1Eli Friedman int SrcIdx = SVI->getMaskValue(Elt->getZExtValue()); 175b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *Src; 176b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned LHSWidth = 177230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner SVI->getOperand(0)->getType()->getVectorNumElements(); 17809fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 179822cb58d087ab67804037807e130273481b86137Bob Wilson if (SrcIdx < 0) 180822cb58d087ab67804037807e130273481b86137Bob Wilson return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType())); 181822cb58d087ab67804037807e130273481b86137Bob Wilson if (SrcIdx < (int)LHSWidth) 182b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Src = SVI->getOperand(0); 183822cb58d087ab67804037807e130273481b86137Bob Wilson else { 184b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner SrcIdx -= LHSWidth; 185b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Src = SVI->getOperand(1); 186b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 187db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Int32Ty = Type::getInt32Ty(EI.getContext()); 188b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return ExtractElementInst::Create(Src, 189f0b48f836e85e4e9ae3b5f94c47500d40e3dc16eBob Wilson ConstantInt::get(Int32Ty, 190b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner SrcIdx, false)); 191b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 1920ff8a4fa35db853dfc3dbe54535aa326d8e742a2Nadav Rotem } else if (CastInst *CI = dyn_cast<CastInst>(I)) { 1930ff8a4fa35db853dfc3dbe54535aa326d8e742a2Nadav Rotem // Canonicalize extractelement(cast) -> cast(extractelement) 1940ff8a4fa35db853dfc3dbe54535aa326d8e742a2Nadav Rotem // bitcasts can change the number of vector elements and they cost nothing 1950ff8a4fa35db853dfc3dbe54535aa326d8e742a2Nadav Rotem if (CI->hasOneUse() && EI.hasOneUse() && 1960ff8a4fa35db853dfc3dbe54535aa326d8e742a2Nadav Rotem (CI->getOpcode() != Instruction::BitCast)) { 1970ff8a4fa35db853dfc3dbe54535aa326d8e742a2Nadav Rotem Value *EE = Builder->CreateExtractElement(CI->getOperand(0), 1980ff8a4fa35db853dfc3dbe54535aa326d8e742a2Nadav Rotem EI.getIndexOperand()); 1990ff8a4fa35db853dfc3dbe54535aa326d8e742a2Nadav Rotem return CastInst::Create(CI->getOpcode(), EE, EI.getType()); 2000ff8a4fa35db853dfc3dbe54535aa326d8e742a2Nadav Rotem } 201b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 202b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 203b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return 0; 204b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner} 205b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner 206b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner/// CollectSingleShuffleElements - If V is a shuffle of values that ONLY returns 20709fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson/// elements from either LHS or RHS, return the shuffle mask and true. 208b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner/// Otherwise, return false. 209b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattnerstatic bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS, 210a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner SmallVectorImpl<Constant*> &Mask) { 211b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner assert(V->getType() == LHS->getType() && V->getType() == RHS->getType() && 212b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner "Invalid CollectSingleShuffleElements"); 213b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned NumElts = cast<VectorType>(V->getType())->getNumElements(); 21409fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 215b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (isa<UndefValue>(V)) { 216b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Mask.assign(NumElts, UndefValue::get(Type::getInt32Ty(V->getContext()))); 217b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return true; 218b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 21909fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 220b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (V == LHS) { 221b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner for (unsigned i = 0; i != NumElts; ++i) 222b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), i)); 223b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return true; 224b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 22509fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 226b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (V == RHS) { 227b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner for (unsigned i = 0; i != NumElts; ++i) 228b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), 229b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner i+NumElts)); 230b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return true; 231b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 23209fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 233b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (InsertElementInst *IEI = dyn_cast<InsertElementInst>(V)) { 234b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If this is an insert of an extract from some other vector, include it. 235b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *VecOp = IEI->getOperand(0); 236b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *ScalarOp = IEI->getOperand(1); 237b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *IdxOp = IEI->getOperand(2); 23809fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 239b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (!isa<ConstantInt>(IdxOp)) 240b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return false; 241b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue(); 24209fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 243b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (isa<UndefValue>(ScalarOp)) { // inserting undef into vector. 244b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Okay, we can handle this if the vector we are insertinting into is 245b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // transitively ok. 246b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask)) { 247b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If so, update the mask to reflect the inserted undef. 248b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Mask[InsertedIdx] = UndefValue::get(Type::getInt32Ty(V->getContext())); 249b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return true; 25009fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson } 251b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } else if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)){ 252b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (isa<ConstantInt>(EI->getOperand(1)) && 253b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner EI->getOperand(0)->getType() == V->getType()) { 254b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned ExtractedIdx = 255b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner cast<ConstantInt>(EI->getOperand(1))->getZExtValue(); 25609fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 257b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // This must be extracting from either LHS or RHS. 258b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (EI->getOperand(0) == LHS || EI->getOperand(0) == RHS) { 259b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Okay, we can handle this if the vector we are insertinting into is 260b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // transitively ok. 261b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask)) { 262b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If so, update the mask to reflect the inserted value. 263b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (EI->getOperand(0) == LHS) { 26409fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson Mask[InsertedIdx % NumElts] = 265b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner ConstantInt::get(Type::getInt32Ty(V->getContext()), 266b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner ExtractedIdx); 267b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } else { 268b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner assert(EI->getOperand(0) == RHS); 26909fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson Mask[InsertedIdx % NumElts] = 270b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner ConstantInt::get(Type::getInt32Ty(V->getContext()), 271b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner ExtractedIdx+NumElts); 272b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 273b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return true; 274b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 275b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 276b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 277b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 278b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 279b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // TODO: Handle shufflevector here! 28009fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 281b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return false; 282b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner} 283b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner 284b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner/// CollectShuffleElements - We are building a shuffle of V, using RHS as the 285b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner/// RHS of the shuffle instruction, if it is not null. Return a shuffle mask 286b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner/// that computes V and the LHS value of the shuffle. 287a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattnerstatic Value *CollectShuffleElements(Value *V, SmallVectorImpl<Constant*> &Mask, 288b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *&RHS) { 28909fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson assert(V->getType()->isVectorTy() && 290b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner (RHS == 0 || V->getType() == RHS->getType()) && 291b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner "Invalid shuffle!"); 292b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned NumElts = cast<VectorType>(V->getType())->getNumElements(); 29309fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 294b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (isa<UndefValue>(V)) { 295b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Mask.assign(NumElts, UndefValue::get(Type::getInt32Ty(V->getContext()))); 296b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return V; 297bec2d03c4d774e67ebc586b3a00792d996f26140Chris Lattner } 298bec2d03c4d774e67ebc586b3a00792d996f26140Chris Lattner 299bec2d03c4d774e67ebc586b3a00792d996f26140Chris Lattner if (isa<ConstantAggregateZero>(V)) { 300b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Mask.assign(NumElts, ConstantInt::get(Type::getInt32Ty(V->getContext()),0)); 301b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return V; 302bec2d03c4d774e67ebc586b3a00792d996f26140Chris Lattner } 303bec2d03c4d774e67ebc586b3a00792d996f26140Chris Lattner 304bec2d03c4d774e67ebc586b3a00792d996f26140Chris Lattner if (InsertElementInst *IEI = dyn_cast<InsertElementInst>(V)) { 305b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If this is an insert of an extract from some other vector, include it. 306b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *VecOp = IEI->getOperand(0); 307b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *ScalarOp = IEI->getOperand(1); 308b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *IdxOp = IEI->getOperand(2); 30909fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 310b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)) { 311b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp) && 312b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner EI->getOperand(0)->getType() == V->getType()) { 313b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned ExtractedIdx = 314db1da8ed42cbe50945acfaca514864723999150aBob Wilson cast<ConstantInt>(EI->getOperand(1))->getZExtValue(); 315b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue(); 31609fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 317b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Either the extracted from or inserted into vector must be RHSVec, 318b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // otherwise we'd end up with a shuffle of three inputs. 319b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (EI->getOperand(0) == RHS || RHS == 0) { 320b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner RHS = EI->getOperand(0); 321b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *V = CollectShuffleElements(VecOp, Mask, RHS); 32209fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson Mask[InsertedIdx % NumElts] = 323db1da8ed42cbe50945acfaca514864723999150aBob Wilson ConstantInt::get(Type::getInt32Ty(V->getContext()), 324db1da8ed42cbe50945acfaca514864723999150aBob Wilson NumElts+ExtractedIdx); 325b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return V; 326b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 32709fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 328b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (VecOp == RHS) { 329b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *V = CollectShuffleElements(EI->getOperand(0), Mask, RHS); 330b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Everything but the extracted element is replaced with the RHS. 331b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner for (unsigned i = 0; i != NumElts; ++i) { 332b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (i != InsertedIdx) 333b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Mask[i] = ConstantInt::get(Type::getInt32Ty(V->getContext()), 334b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner NumElts+i); 335b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 336b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return V; 337b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 33809fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 339b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If this insertelement is a chain that comes from exactly these two 340b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // vectors, return the vector and the effective shuffle. 341b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (CollectSingleShuffleElements(IEI, EI->getOperand(0), RHS, Mask)) 342b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return EI->getOperand(0); 343b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 344b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 345b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 346b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // TODO: Handle shufflevector here! 34709fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 348b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Otherwise, can't do anything fancy. Return an identity vector. 349b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner for (unsigned i = 0; i != NumElts; ++i) 350b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), i)); 351b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return V; 352b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner} 353b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner 354b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris LattnerInstruction *InstCombiner::visitInsertElementInst(InsertElementInst &IE) { 355b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *VecOp = IE.getOperand(0); 356b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *ScalarOp = IE.getOperand(1); 357b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *IdxOp = IE.getOperand(2); 35809fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 359b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Inserting an undef or into an undefined place, remove this. 360b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (isa<UndefValue>(ScalarOp) || isa<UndefValue>(IdxOp)) 361b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner ReplaceInstUsesWith(IE, VecOp); 36209fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 36309fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson // If the inserted element was extracted from some other vector, and if the 364b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // indexes are constant, try to turn this into a shufflevector operation. 365b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)) { 366b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp) && 367b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner EI->getOperand(0)->getType() == IE.getType()) { 368b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned NumVectorElts = IE.getType()->getNumElements(); 369b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned ExtractedIdx = 370db1da8ed42cbe50945acfaca514864723999150aBob Wilson cast<ConstantInt>(EI->getOperand(1))->getZExtValue(); 371b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue(); 37209fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 373b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (ExtractedIdx >= NumVectorElts) // Out of range extract. 374b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return ReplaceInstUsesWith(IE, VecOp); 37509fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 376b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (InsertedIdx >= NumVectorElts) // Out of range insert. 377b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return ReplaceInstUsesWith(IE, UndefValue::get(IE.getType())); 37809fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 379b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If we are extracting a value from a vector, then inserting it right 380b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // back into the same place, just use the input vector. 381b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (EI->getOperand(0) == VecOp && ExtractedIdx == InsertedIdx) 38209fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson return ReplaceInstUsesWith(IE, VecOp); 38309fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 384b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // If this insertelement isn't used by some other insertelement, turn it 385b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // (and any insertelements it points to), into one big shuffle. 386b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (!IE.hasOneUse() || !isa<InsertElementInst>(IE.use_back())) { 387a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner SmallVector<Constant*, 16> Mask; 388b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *RHS = 0; 389b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *LHS = CollectShuffleElements(&IE, Mask, RHS); 390b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (RHS == 0) RHS = UndefValue::get(LHS->getType()); 391b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // We now have a shuffle of LHS, RHS, Mask. 392db1da8ed42cbe50945acfaca514864723999150aBob Wilson return new ShuffleVectorInst(LHS, RHS, ConstantVector::get(Mask)); 393b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 394b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 395b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 39609fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 397b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner unsigned VWidth = cast<VectorType>(VecOp->getType())->getNumElements(); 398b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner APInt UndefElts(VWidth, 0); 399b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner APInt AllOnesEltMask(APInt::getAllOnesValue(VWidth)); 4001347623aaf25b7fe6486479353fc87bd7541a5f7Eli Friedman if (Value *V = SimplifyDemandedVectorElts(&IE, AllOnesEltMask, UndefElts)) { 4011347623aaf25b7fe6486479353fc87bd7541a5f7Eli Friedman if (V != &IE) 4021347623aaf25b7fe6486479353fc87bd7541a5f7Eli Friedman return ReplaceInstUsesWith(IE, V); 403b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return &IE; 4041347623aaf25b7fe6486479353fc87bd7541a5f7Eli Friedman } 40509fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 406b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return 0; 407b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner} 408b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner 409b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner 410b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris LattnerInstruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) { 411b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *LHS = SVI.getOperand(0); 412b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Value *RHS = SVI.getOperand(1); 413230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner SmallVector<int, 16> Mask = SVI.getShuffleMask(); 41409fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 415b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner bool MadeChange = false; 41609fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 417b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Undefined shuffle mask -> undefined value. 418b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (isa<UndefValue>(SVI.getOperand(2))) 419b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return ReplaceInstUsesWith(SVI, UndefValue::get(SVI.getType())); 42009fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 42168c23f861694f7b06df2ce39ced01d1d39fc5809Eric Christopher unsigned VWidth = cast<VectorType>(SVI.getType())->getNumElements(); 42209fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 423b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner APInt UndefElts(VWidth, 0); 424b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner APInt AllOnesEltMask(APInt::getAllOnesValue(VWidth)); 4251347623aaf25b7fe6486479353fc87bd7541a5f7Eli Friedman if (Value *V = SimplifyDemandedVectorElts(&SVI, AllOnesEltMask, UndefElts)) { 4261347623aaf25b7fe6486479353fc87bd7541a5f7Eli Friedman if (V != &SVI) 4271347623aaf25b7fe6486479353fc87bd7541a5f7Eli Friedman return ReplaceInstUsesWith(SVI, V); 428b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner LHS = SVI.getOperand(0); 429b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner RHS = SVI.getOperand(1); 430b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner MadeChange = true; 431b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 43209fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 433d2822e7572e75287db66acb14b2d988a80faebddEli Friedman unsigned LHSWidth = cast<VectorType>(LHS->getType())->getNumElements(); 434d2822e7572e75287db66acb14b2d988a80faebddEli Friedman 435b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Canonicalize shuffle(x ,x,mask) -> shuffle(x, undef,mask') 436b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Canonicalize shuffle(undef,x,mask) -> shuffle(x, undef,mask'). 437b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner if (LHS == RHS || isa<UndefValue>(LHS)) { 43868c23f861694f7b06df2ce39ced01d1d39fc5809Eric Christopher if (isa<UndefValue>(LHS) && LHS == RHS) { 43968c23f861694f7b06df2ce39ced01d1d39fc5809Eric Christopher // shuffle(undef,undef,mask) -> undef. 440d2822e7572e75287db66acb14b2d988a80faebddEli Friedman Value* result = (VWidth == LHSWidth) 441d2822e7572e75287db66acb14b2d988a80faebddEli Friedman ? LHS : UndefValue::get(SVI.getType()); 442d2822e7572e75287db66acb14b2d988a80faebddEli Friedman return ReplaceInstUsesWith(SVI, result); 44368c23f861694f7b06df2ce39ced01d1d39fc5809Eric Christopher } 44409fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 445b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner // Remap any references to RHS to use LHS. 446a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner SmallVector<Constant*, 16> Elts; 447d2822e7572e75287db66acb14b2d988a80faebddEli Friedman for (unsigned i = 0, e = LHSWidth; i != VWidth; ++i) { 448a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner if (Mask[i] < 0) { 449b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner Elts.push_back(UndefValue::get(Type::getInt32Ty(SVI.getContext()))); 450a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner continue; 451a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner } 452a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner 453a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner if ((Mask[i] >= (int)e && isa<UndefValue>(RHS)) || 454a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner (Mask[i] < (int)e && isa<UndefValue>(LHS))) { 455a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner Mask[i] = -1; // Turn into undef. 456a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner Elts.push_back(UndefValue::get(Type::getInt32Ty(SVI.getContext()))); 457a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner } else { 458a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner Mask[i] = Mask[i] % e; // Force to LHS. 459a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner Elts.push_back(ConstantInt::get(Type::getInt32Ty(SVI.getContext()), 460a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner Mask[i])); 461b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 462b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 463b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner SVI.setOperand(0, SVI.getOperand(1)); 464b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner SVI.setOperand(1, UndefValue::get(RHS->getType())); 465b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner SVI.setOperand(2, ConstantVector::get(Elts)); 466b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner LHS = SVI.getOperand(0); 467b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner RHS = SVI.getOperand(1); 468b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner MadeChange = true; 469b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner } 47009fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 471d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (VWidth == LHSWidth) { 472d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // Analyze the shuffle, are the LHS or RHS and identity shuffles? 473d2822e7572e75287db66acb14b2d988a80faebddEli Friedman bool isLHSID = true, isRHSID = true; 474d2822e7572e75287db66acb14b2d988a80faebddEli Friedman 475d2822e7572e75287db66acb14b2d988a80faebddEli Friedman for (unsigned i = 0, e = Mask.size(); i != e; ++i) { 476d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (Mask[i] < 0) continue; // Ignore undef values. 477d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // Is this an identity shuffle of the LHS value? 478d2822e7572e75287db66acb14b2d988a80faebddEli Friedman isLHSID &= (Mask[i] == (int)i); 47909fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 480d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // Is this an identity shuffle of the RHS value? 481d2822e7572e75287db66acb14b2d988a80faebddEli Friedman isRHSID &= (Mask[i]-e == i); 482d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } 48309fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 484d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // Eliminate identity shuffles. 485d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (isLHSID) return ReplaceInstUsesWith(SVI, LHS); 486d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (isRHSID) return ReplaceInstUsesWith(SVI, RHS); 48795743d8748a85bbb03aff3b3baae728c138acbabNate Begeman } 48809fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 48968c23f861694f7b06df2ce39ced01d1d39fc5809Eric Christopher // If the LHS is a shufflevector itself, see if we can combine it with this 490d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // one without producing an unusual shuffle. 491d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // Cases that might be simplified: 492d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // 1. 493d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // x1=shuffle(v1,v2,mask1) 494d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // x=shuffle(x1,undef,mask) 495d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // ==> 496d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // x=shuffle(v1,undef,newMask) 497d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // newMask[i] = (mask[i] < x1.size()) ? mask1[mask[i]] : -1 498d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // 2. 499d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // x1=shuffle(v1,undef,mask1) 500d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // x=shuffle(x1,x2,mask) 501d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // where v1.size() == mask1.size() 502d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // ==> 503d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // x=shuffle(v1,x2,newMask) 504d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // newMask[i] = (mask[i] < x1.size()) ? mask1[mask[i]] : mask[i] 505d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // 3. 506d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // x2=shuffle(v2,undef,mask2) 507d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // x=shuffle(x1,x2,mask) 508d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // where v2.size() == mask2.size() 509d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // ==> 510d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // x=shuffle(x1,v2,newMask) 511d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // newMask[i] = (mask[i] < x1.size()) 512d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // ? mask[i] : mask2[mask[i]-x1.size()]+x1.size() 513d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // 4. 514d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // x1=shuffle(v1,undef,mask1) 515d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // x2=shuffle(v2,undef,mask2) 516d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // x=shuffle(x1,x2,mask) 517d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // where v1.size() == v2.size() 518d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // ==> 519d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // x=shuffle(v1,v2,newMask) 520d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // newMask[i] = (mask[i] < x1.size()) 521d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // ? mask1[mask[i]] : mask2[mask[i]-x1.size()]+v1.size() 522d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // 523d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // Here we are really conservative: 52468c23f861694f7b06df2ce39ced01d1d39fc5809Eric Christopher // we are absolutely afraid of producing a shuffle mask not in the input 52568c23f861694f7b06df2ce39ced01d1d39fc5809Eric Christopher // program, because the code gen may not be smart enough to turn a merged 52668c23f861694f7b06df2ce39ced01d1d39fc5809Eric Christopher // shuffle into two specific shuffles: it may produce worse code. As such, 5274cac5facc3a95a81ffa2c85baae001a7c509146cBob Wilson // we only merge two shuffles if the result is either a splat or one of the 528d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // input shuffle masks. In this case, merging the shuffles just removes 5294cac5facc3a95a81ffa2c85baae001a7c509146cBob Wilson // one instruction, which we know is safe. This is good for things like 530d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // turning: (splat(splat)) -> splat, or 531d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // merge(V[0..n], V[n+1..2n]) -> V[0..2n] 532d2822e7572e75287db66acb14b2d988a80faebddEli Friedman ShuffleVectorInst* LHSShuffle = dyn_cast<ShuffleVectorInst>(LHS); 533d2822e7572e75287db66acb14b2d988a80faebddEli Friedman ShuffleVectorInst* RHSShuffle = dyn_cast<ShuffleVectorInst>(RHS); 534d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (LHSShuffle) 535d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (!isa<UndefValue>(LHSShuffle->getOperand(1)) && !isa<UndefValue>(RHS)) 536d2822e7572e75287db66acb14b2d988a80faebddEli Friedman LHSShuffle = NULL; 537d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (RHSShuffle) 538d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (!isa<UndefValue>(RHSShuffle->getOperand(1))) 539d2822e7572e75287db66acb14b2d988a80faebddEli Friedman RHSShuffle = NULL; 540d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (!LHSShuffle && !RHSShuffle) 541d2822e7572e75287db66acb14b2d988a80faebddEli Friedman return MadeChange ? &SVI : 0; 542d2822e7572e75287db66acb14b2d988a80faebddEli Friedman 543d2822e7572e75287db66acb14b2d988a80faebddEli Friedman Value* LHSOp0 = NULL; 544d2822e7572e75287db66acb14b2d988a80faebddEli Friedman Value* LHSOp1 = NULL; 545d2822e7572e75287db66acb14b2d988a80faebddEli Friedman Value* RHSOp0 = NULL; 546d2822e7572e75287db66acb14b2d988a80faebddEli Friedman unsigned LHSOp0Width = 0; 547d2822e7572e75287db66acb14b2d988a80faebddEli Friedman unsigned RHSOp0Width = 0; 548d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (LHSShuffle) { 549d2822e7572e75287db66acb14b2d988a80faebddEli Friedman LHSOp0 = LHSShuffle->getOperand(0); 550d2822e7572e75287db66acb14b2d988a80faebddEli Friedman LHSOp1 = LHSShuffle->getOperand(1); 551d2822e7572e75287db66acb14b2d988a80faebddEli Friedman LHSOp0Width = cast<VectorType>(LHSOp0->getType())->getNumElements(); 552d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } 553d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (RHSShuffle) { 554d2822e7572e75287db66acb14b2d988a80faebddEli Friedman RHSOp0 = RHSShuffle->getOperand(0); 555d2822e7572e75287db66acb14b2d988a80faebddEli Friedman RHSOp0Width = cast<VectorType>(RHSOp0->getType())->getNumElements(); 556d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } 557d2822e7572e75287db66acb14b2d988a80faebddEli Friedman Value* newLHS = LHS; 558d2822e7572e75287db66acb14b2d988a80faebddEli Friedman Value* newRHS = RHS; 559d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (LHSShuffle) { 560d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // case 1 56168c23f861694f7b06df2ce39ced01d1d39fc5809Eric Christopher if (isa<UndefValue>(RHS)) { 562d2822e7572e75287db66acb14b2d988a80faebddEli Friedman newLHS = LHSOp0; 563d2822e7572e75287db66acb14b2d988a80faebddEli Friedman newRHS = LHSOp1; 564d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } 565d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // case 2 or 4 566d2822e7572e75287db66acb14b2d988a80faebddEli Friedman else if (LHSOp0Width == LHSWidth) { 567d2822e7572e75287db66acb14b2d988a80faebddEli Friedman newLHS = LHSOp0; 568d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } 569d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } 570d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // case 3 or 4 571d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (RHSShuffle && RHSOp0Width == LHSWidth) { 572d2822e7572e75287db66acb14b2d988a80faebddEli Friedman newRHS = RHSOp0; 573d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } 574d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // case 4 575d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (LHSOp0 == RHSOp0) { 576d2822e7572e75287db66acb14b2d988a80faebddEli Friedman newLHS = LHSOp0; 577d2822e7572e75287db66acb14b2d988a80faebddEli Friedman newRHS = NULL; 578d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } 57909fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 580d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (newLHS == LHS && newRHS == RHS) 581d2822e7572e75287db66acb14b2d988a80faebddEli Friedman return MadeChange ? &SVI : 0; 582d2822e7572e75287db66acb14b2d988a80faebddEli Friedman 583d2822e7572e75287db66acb14b2d988a80faebddEli Friedman SmallVector<int, 16> LHSMask; 584d2822e7572e75287db66acb14b2d988a80faebddEli Friedman SmallVector<int, 16> RHSMask; 585230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (newLHS != LHS) 586230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner LHSMask = LHSShuffle->getShuffleMask(); 587230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (RHSShuffle && newRHS != RHS) 588230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner RHSMask = RHSShuffle->getShuffleMask(); 589230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner 590d2822e7572e75287db66acb14b2d988a80faebddEli Friedman unsigned newLHSWidth = (newLHS != LHS) ? LHSOp0Width : LHSWidth; 591d2822e7572e75287db66acb14b2d988a80faebddEli Friedman SmallVector<int, 16> newMask; 592d2822e7572e75287db66acb14b2d988a80faebddEli Friedman bool isSplat = true; 593d2822e7572e75287db66acb14b2d988a80faebddEli Friedman int SplatElt = -1; 594d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // Create a new mask for the new ShuffleVectorInst so that the new 595d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // ShuffleVectorInst is equivalent to the original one. 596d2822e7572e75287db66acb14b2d988a80faebddEli Friedman for (unsigned i = 0; i < VWidth; ++i) { 597d2822e7572e75287db66acb14b2d988a80faebddEli Friedman int eltMask; 598d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (Mask[i] == -1) { 599d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // This element is an undef value. 600d2822e7572e75287db66acb14b2d988a80faebddEli Friedman eltMask = -1; 601d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } else if (Mask[i] < (int)LHSWidth) { 602d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // This element is from left hand side vector operand. 603d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // 604d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // If LHS is going to be replaced (case 1, 2, or 4), calculate the 605d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // new mask value for the element. 606d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (newLHS != LHS) { 607d2822e7572e75287db66acb14b2d988a80faebddEli Friedman eltMask = LHSMask[Mask[i]]; 608d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // If the value selected is an undef value, explicitly specify it 609d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // with a -1 mask value. 610d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (eltMask >= (int)LHSOp0Width && isa<UndefValue>(LHSOp1)) 611d2822e7572e75287db66acb14b2d988a80faebddEli Friedman eltMask = -1; 612d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } 613d2822e7572e75287db66acb14b2d988a80faebddEli Friedman else 614d2822e7572e75287db66acb14b2d988a80faebddEli Friedman eltMask = Mask[i]; 615d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } else { 616d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // This element is from right hand side vector operand 617d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // 618d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // If the value selected is an undef value, explicitly specify it 619d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // with a -1 mask value. (case 1) 620d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (isa<UndefValue>(RHS)) 621d2822e7572e75287db66acb14b2d988a80faebddEli Friedman eltMask = -1; 622d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // If RHS is going to be replaced (case 3 or 4), calculate the 623d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // new mask value for the element. 624d2822e7572e75287db66acb14b2d988a80faebddEli Friedman else if (newRHS != RHS) { 625d2822e7572e75287db66acb14b2d988a80faebddEli Friedman eltMask = RHSMask[Mask[i]-LHSWidth]; 626d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // If the value selected is an undef value, explicitly specify it 627d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // with a -1 mask value. 628d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (eltMask >= (int)RHSOp0Width) { 629d2822e7572e75287db66acb14b2d988a80faebddEli Friedman assert(isa<UndefValue>(RHSShuffle->getOperand(1)) 630d2822e7572e75287db66acb14b2d988a80faebddEli Friedman && "should have been check above"); 631d2822e7572e75287db66acb14b2d988a80faebddEli Friedman eltMask = -1; 6327f1f4089a142e4f0081ac25699bf682a68247a35Nate Begeman } 6337f1f4089a142e4f0081ac25699bf682a68247a35Nate Begeman } 634d2822e7572e75287db66acb14b2d988a80faebddEli Friedman else 635d2822e7572e75287db66acb14b2d988a80faebddEli Friedman eltMask = Mask[i]-LHSWidth; 636d2822e7572e75287db66acb14b2d988a80faebddEli Friedman 637d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // If LHS's width is changed, shift the mask value accordingly. 638d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // If newRHS == NULL, i.e. LHSOp0 == RHSOp0, we want to remap any 639d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // references to RHSOp0 to LHSOp0, so we don't need to shift the mask. 640d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (eltMask >= 0 && newRHS != NULL) 641d2822e7572e75287db66acb14b2d988a80faebddEli Friedman eltMask += newLHSWidth; 642d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } 643d2822e7572e75287db66acb14b2d988a80faebddEli Friedman 644d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // Check if this could still be a splat. 645d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (eltMask >= 0) { 646d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (SplatElt >= 0 && SplatElt != eltMask) 647d2822e7572e75287db66acb14b2d988a80faebddEli Friedman isSplat = false; 648d2822e7572e75287db66acb14b2d988a80faebddEli Friedman SplatElt = eltMask; 649d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } 650d2822e7572e75287db66acb14b2d988a80faebddEli Friedman 651d2822e7572e75287db66acb14b2d988a80faebddEli Friedman newMask.push_back(eltMask); 652d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } 653d2822e7572e75287db66acb14b2d988a80faebddEli Friedman 654d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // If the result mask is equal to one of the original shuffle masks, 655d2822e7572e75287db66acb14b2d988a80faebddEli Friedman // or is a splat, do the replacement. 656d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (isSplat || newMask == LHSMask || newMask == RHSMask || newMask == Mask) { 657d2822e7572e75287db66acb14b2d988a80faebddEli Friedman SmallVector<Constant*, 16> Elts; 658d2822e7572e75287db66acb14b2d988a80faebddEli Friedman Type *Int32Ty = Type::getInt32Ty(SVI.getContext()); 659d2822e7572e75287db66acb14b2d988a80faebddEli Friedman for (unsigned i = 0, e = newMask.size(); i != e; ++i) { 660d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (newMask[i] < 0) { 661d2822e7572e75287db66acb14b2d988a80faebddEli Friedman Elts.push_back(UndefValue::get(Int32Ty)); 662d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } else { 663d2822e7572e75287db66acb14b2d988a80faebddEli Friedman Elts.push_back(ConstantInt::get(Int32Ty, newMask[i])); 664d2822e7572e75287db66acb14b2d988a80faebddEli Friedman } 6657f1f4089a142e4f0081ac25699bf682a68247a35Nate Begeman } 666d2822e7572e75287db66acb14b2d988a80faebddEli Friedman if (newRHS == NULL) 667d2822e7572e75287db66acb14b2d988a80faebddEli Friedman newRHS = UndefValue::get(newLHS->getType()); 668d2822e7572e75287db66acb14b2d988a80faebddEli Friedman return new ShuffleVectorInst(newLHS, newRHS, ConstantVector::get(Elts)); 6697f1f4089a142e4f0081ac25699bf682a68247a35Nate Begeman } 67009fd64644d5da2dacc0916790082ac0dd5d9696dBob Wilson 671b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner return MadeChange ? &SVI : 0; 672b8a5cecd6bc74d6c1c256263f857f79f383e53bdChris Lattner} 673