1753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner//===- InstCombineCalls.cpp -----------------------------------------------===// 2753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// 3753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// The LLVM Compiler Infrastructure 4753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// 5753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// This file is distributed under the University of Illinois Open Source 6753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// License. See LICENSE.TXT for details. 7753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// 8753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner//===----------------------------------------------------------------------===// 9753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// 10753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// This file implements the visitCall and visitInvoke functions. 11753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// 12753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner//===----------------------------------------------------------------------===// 13753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 14753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner#include "InstCombine.h" 15753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner#include "llvm/Support/CallSite.h" 16753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner#include "llvm/Target/TargetData.h" 17753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner#include "llvm/Analysis/MemoryBuiltins.h" 1827ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher#include "llvm/Transforms/Utils/BuildLibCalls.h" 19687140c818ba4b896329a83324714140b6580ef8Chris Lattner#include "llvm/Transforms/Utils/Local.h" 20753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattnerusing namespace llvm; 21753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 22753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner/// getPromotedType - Return the specified type promoted as it would be to pass 23753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner/// though a va_arg area. 24db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic Type *getPromotedType(Type *Ty) { 25db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (IntegerType* ITy = dyn_cast<IntegerType>(Ty)) { 26753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (ITy->getBitWidth() < 32) 27753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return Type::getInt32Ty(Ty->getContext()); 28753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 29753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return Ty; 30753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner} 31753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 32753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 33753a2b464d0628231bd3dce645edd05dfbaa3a06Chris LattnerInstruction *InstCombiner::SimplifyMemTransfer(MemIntrinsic *MI) { 34687140c818ba4b896329a83324714140b6580ef8Chris Lattner unsigned DstAlign = getKnownAlignment(MI->getArgOperand(0), TD); 35687140c818ba4b896329a83324714140b6580ef8Chris Lattner unsigned SrcAlign = getKnownAlignment(MI->getArgOperand(1), TD); 36753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner unsigned MinAlign = std::min(DstAlign, SrcAlign); 37753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner unsigned CopyAlign = MI->getAlignment(); 38753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 39753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (CopyAlign < MinAlign) { 4000e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach MI->setAlignment(ConstantInt::get(MI->getAlignmentType(), 41753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner MinAlign, false)); 42753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return MI; 43753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 4400e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 45753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If MemCpyInst length is 1/2/4/8 bytes then replace memcpy with 46753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // load/store. 47bcda85c74304ffada586a9c58ce9bcff93b69a86Gabor Greif ConstantInt *MemOpLength = dyn_cast<ConstantInt>(MI->getArgOperand(2)); 48753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (MemOpLength == 0) return 0; 4900e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 50753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Source and destination pointer types are always "i8*" for intrinsic. See 51753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // if the size is something we can handle with a single primitive load/store. 52753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // A single load+store correctly handles overlapping memory in the memmove 53753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // case. 549441ad0b6e02ee9558168b37a9620ef1afe79388Michael Liao uint64_t Size = MemOpLength->getLimitedValue(); 559441ad0b6e02ee9558168b37a9620ef1afe79388Michael Liao assert(Size && "0-sized memory transfering should be removed already."); 5600e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 57753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Size > 8 || (Size&(Size-1))) 58753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return 0; // If not 1/2/4/8 bytes, exit. 5900e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 60753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Use an integer load+store unless we can find something better. 6120adc9dc4650313f017b27d9818eb2176238113dMon P Wang unsigned SrcAddrSp = 62bcda85c74304ffada586a9c58ce9bcff93b69a86Gabor Greif cast<PointerType>(MI->getArgOperand(1)->getType())->getAddressSpace(); 634ec2258ffb495d7ce00177e447740ef1123a27dbGabor Greif unsigned DstAddrSp = 64bcda85c74304ffada586a9c58ce9bcff93b69a86Gabor Greif cast<PointerType>(MI->getArgOperand(0)->getType())->getAddressSpace(); 6520adc9dc4650313f017b27d9818eb2176238113dMon P Wang 66db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType* IntType = IntegerType::get(MI->getContext(), Size<<3); 6720adc9dc4650313f017b27d9818eb2176238113dMon P Wang Type *NewSrcPtrTy = PointerType::get(IntType, SrcAddrSp); 6820adc9dc4650313f017b27d9818eb2176238113dMon P Wang Type *NewDstPtrTy = PointerType::get(IntType, DstAddrSp); 6900e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 70753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Memcpy forces the use of i8* for the source and destination. That means 71753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // that if you're using memcpy to move one double around, you'll get a cast 72753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // from double* to i8*. We'd much rather use a double load+store rather than 73753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // an i64 load+store, here because this improves the odds that the source or 74753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // dest address will be promotable. See if we can find a better type than the 75753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // integer datatype. 76cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif Value *StrippedDest = MI->getArgOperand(0)->stripPointerCasts(); 77cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif if (StrippedDest != MI->getArgOperand(0)) { 78db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcETy = cast<PointerType>(StrippedDest->getType()) 79753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner ->getElementType(); 80753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (TD && SrcETy->isSized() && TD->getTypeStoreSize(SrcETy) == Size) { 81753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // The SrcETy might be something like {{{double}}} or [1 x double]. Rip 82753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // down through these levels if so. 83753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner while (!SrcETy->isSingleValueType()) { 84db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(SrcETy)) { 85753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (STy->getNumElements() == 1) 86753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner SrcETy = STy->getElementType(0); 87753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner else 88753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 89db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner } else if (ArrayType *ATy = dyn_cast<ArrayType>(SrcETy)) { 90753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (ATy->getNumElements() == 1) 91753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner SrcETy = ATy->getElementType(); 92753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner else 93753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 94753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } else 95753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 96753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 9700e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 9820adc9dc4650313f017b27d9818eb2176238113dMon P Wang if (SrcETy->isSingleValueType()) { 9920adc9dc4650313f017b27d9818eb2176238113dMon P Wang NewSrcPtrTy = PointerType::get(SrcETy, SrcAddrSp); 10020adc9dc4650313f017b27d9818eb2176238113dMon P Wang NewDstPtrTy = PointerType::get(SrcETy, DstAddrSp); 10120adc9dc4650313f017b27d9818eb2176238113dMon P Wang } 102753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 103753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 10400e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 10500e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 106753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If the memcpy/memmove provides better alignment info than we can 107753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // infer, use it. 108753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner SrcAlign = std::max(SrcAlign, CopyAlign); 109753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner DstAlign = std::max(DstAlign, CopyAlign); 11000e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 1119c68a7bb45ebf71cec5ab4eab7c73aacdfce16dfGabor Greif Value *Src = Builder->CreateBitCast(MI->getArgOperand(1), NewSrcPtrTy); 1129c68a7bb45ebf71cec5ab4eab7c73aacdfce16dfGabor Greif Value *Dest = Builder->CreateBitCast(MI->getArgOperand(0), NewDstPtrTy); 11359f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman LoadInst *L = Builder->CreateLoad(Src, MI->isVolatile()); 11459f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman L->setAlignment(SrcAlign); 11559f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman StoreInst *S = Builder->CreateStore(L, Dest, MI->isVolatile()); 11659f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman S->setAlignment(DstAlign); 117753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 118753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Set the size of the copy to 0, it will be deleted on the next iteration. 119a90c5c7605e0d8df96e61d4bf0cc47a7eaea92cfGabor Greif MI->setArgOperand(2, Constant::getNullValue(MemOpLength->getType())); 120753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return MI; 121753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner} 122753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 123753a2b464d0628231bd3dce645edd05dfbaa3a06Chris LattnerInstruction *InstCombiner::SimplifyMemSet(MemSetInst *MI) { 124ae47be1ea023e4b1e6bbbdc4687333eea54c84c8Chris Lattner unsigned Alignment = getKnownAlignment(MI->getDest(), TD); 125753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (MI->getAlignment() < Alignment) { 126753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner MI->setAlignment(ConstantInt::get(MI->getAlignmentType(), 127753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Alignment, false)); 128753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return MI; 129753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 13000e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 131753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Extract the length and alignment and fill if they are constant. 132753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner ConstantInt *LenC = dyn_cast<ConstantInt>(MI->getLength()); 133753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner ConstantInt *FillC = dyn_cast<ConstantInt>(MI->getValue()); 134b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands if (!LenC || !FillC || !FillC->getType()->isIntegerTy(8)) 135753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return 0; 1369441ad0b6e02ee9558168b37a9620ef1afe79388Michael Liao uint64_t Len = LenC->getLimitedValue(); 137753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Alignment = MI->getAlignment(); 1389441ad0b6e02ee9558168b37a9620ef1afe79388Michael Liao assert(Len && "0-sized memory setting should be removed already."); 13900e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 140753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // memset(s,c,n) -> store s, c (for n=1,2,4,8) 141753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Len <= 8 && isPowerOf2_32((uint32_t)Len)) { 142db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ITy = IntegerType::get(MI->getContext(), Len*8); // n=1 -> i8. 14300e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 144753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Value *Dest = MI->getDest(); 14555fb9b0fcf89501a0abe74808f4e08e0b3a17207Mon P Wang unsigned DstAddrSp = cast<PointerType>(Dest->getType())->getAddressSpace(); 14655fb9b0fcf89501a0abe74808f4e08e0b3a17207Mon P Wang Type *NewDstPtrTy = PointerType::get(ITy, DstAddrSp); 14755fb9b0fcf89501a0abe74808f4e08e0b3a17207Mon P Wang Dest = Builder->CreateBitCast(Dest, NewDstPtrTy); 148753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 149753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Alignment 0 is identity for alignment 1 for memset, but not store. 150753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Alignment == 0) Alignment = 1; 15100e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 152753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Extract the fill value and store. 153753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner uint64_t Fill = FillC->getZExtValue()*0x0101010101010101ULL; 15459f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman StoreInst *S = Builder->CreateStore(ConstantInt::get(ITy, Fill), Dest, 15559f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman MI->isVolatile()); 15659f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman S->setAlignment(Alignment); 15700e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 158753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Set the size of the copy to 0, it will be deleted on the next iteration. 159753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner MI->setLength(Constant::getNullValue(LenC->getType())); 160753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return MI; 161753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 162753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 163753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return 0; 164753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner} 165753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 16600e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach/// visitCallInst - CallInst simplification. This mostly only handles folding 167753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner/// of intrinsic instructions. For normal calls, it allows visitCallSite to do 168753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner/// the heavy lifting. 169753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner/// 170753a2b464d0628231bd3dce645edd05dfbaa3a06Chris LattnerInstruction *InstCombiner::visitCallInst(CallInst &CI) { 1718e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer if (isFreeCall(&CI, TLI)) 172753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return visitFree(CI); 173753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 174753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If the caller function is nounwind, mark the call as nounwind, even if the 175753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // callee isn't. 176753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (CI.getParent()->getParent()->doesNotThrow() && 177753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner !CI.doesNotThrow()) { 178753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner CI.setDoesNotThrow(); 179753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return &CI; 180753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 18100e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 182753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner IntrinsicInst *II = dyn_cast<IntrinsicInst>(&CI); 183753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!II) return visitCallSite(&CI); 184cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif 185753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Intrinsics cannot occur in an invoke, so handle them here instead of in 186753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // visitCallSite. 187753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(II)) { 188753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner bool Changed = false; 189753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 190753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // memmove/cpy/set of zero bytes is a noop. 191753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Constant *NumBytes = dyn_cast<Constant>(MI->getLength())) { 1926eff75104e660bae5b28963190a6940eeecb7484Chris Lattner if (NumBytes->isNullValue()) 1936eff75104e660bae5b28963190a6940eeecb7484Chris Lattner return EraseInstFromFunction(CI); 194753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 195753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes)) 196753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (CI->getZExtValue() == 1) { 197753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Replace the instruction with just byte operations. We would 198753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // transform other cases to loads/stores, but we don't know if 199753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // alignment is sufficient. 200753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 201753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 20200e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 2036eff75104e660bae5b28963190a6940eeecb7484Chris Lattner // No other transformations apply to volatile transfers. 2046eff75104e660bae5b28963190a6940eeecb7484Chris Lattner if (MI->isVolatile()) 2056eff75104e660bae5b28963190a6940eeecb7484Chris Lattner return 0; 206753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 207753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If we have a memmove and the source operation is a constant global, 208753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // then the source and dest pointers can't alias, so we can change this 209753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // into a call to memcpy. 210753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (MemMoveInst *MMI = dyn_cast<MemMoveInst>(MI)) { 211753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (GlobalVariable *GVSrc = dyn_cast<GlobalVariable>(MMI->getSource())) 212753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (GVSrc->isConstant()) { 213551754c4958086cc6910da7c950f2875e212f5cfEric Christopher Module *M = CI.getParent()->getParent()->getParent(); 214753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Intrinsic::ID MemCpyID = Intrinsic::memcpy; 2155fdd6c8793462549e3593890ec61573da06e3346Jay Foad Type *Tys[3] = { CI.getArgOperand(0)->getType(), 2165fdd6c8793462549e3593890ec61573da06e3346Jay Foad CI.getArgOperand(1)->getType(), 2175fdd6c8793462549e3593890ec61573da06e3346Jay Foad CI.getArgOperand(2)->getType() }; 218eb9a85f09e18b3fe88499710404b38d3a9128f62Benjamin Kramer CI.setCalledFunction(Intrinsic::getDeclaration(M, MemCpyID, Tys)); 219753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Changed = true; 220753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 221753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 222753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 223753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI)) { 224753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // memmove(x,x,size) -> noop. 225753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (MTI->getSource() == MTI->getDest()) 226753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return EraseInstFromFunction(CI); 227551754c4958086cc6910da7c950f2875e212f5cfEric Christopher } 228753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 229551754c4958086cc6910da7c950f2875e212f5cfEric Christopher // If we can determine a pointer alignment that is bigger than currently 230551754c4958086cc6910da7c950f2875e212f5cfEric Christopher // set, update the alignment. 231551754c4958086cc6910da7c950f2875e212f5cfEric Christopher if (isa<MemTransferInst>(MI)) { 232551754c4958086cc6910da7c950f2875e212f5cfEric Christopher if (Instruction *I = SimplifyMemTransfer(MI)) 233753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return I; 234753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } else if (MemSetInst *MSI = dyn_cast<MemSetInst>(MI)) { 235753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Instruction *I = SimplifyMemSet(MSI)) 236753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return I; 237753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 238c310fcc909c21c94d1e5b05a97763911568a3ed8Gabor Greif 239753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Changed) return II; 240753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 24100e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 242753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner switch (II->getIntrinsicID()) { 243753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner default: break; 244415326b4edcc967dfb03c5ab41923b195e7c3cb1Eric Christopher case Intrinsic::objectsize: { 2459e72a79ef4a9fcda482ce0b0e1f0bd6a4f16cffdNuno Lopes uint64_t Size; 2468e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer if (getObjectSize(II->getArgOperand(0), Size, TD, TLI)) 2479e72a79ef4a9fcda482ce0b0e1f0bd6a4f16cffdNuno Lopes return ReplaceInstUsesWith(CI, ConstantInt::get(CI.getType(), Size)); 2489e72a79ef4a9fcda482ce0b0e1f0bd6a4f16cffdNuno Lopes return 0; 249415326b4edcc967dfb03c5ab41923b195e7c3cb1Eric Christopher } 250753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::bswap: 251753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // bswap(bswap(x)) -> x 252cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif if (IntrinsicInst *Operand = dyn_cast<IntrinsicInst>(II->getArgOperand(0))) 253753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Operand->getIntrinsicID() == Intrinsic::bswap) 254cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif return ReplaceInstUsesWith(CI, Operand->getArgOperand(0)); 25500e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 256753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // bswap(trunc(bswap(x))) -> trunc(lshr(x, c)) 257cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif if (TruncInst *TI = dyn_cast<TruncInst>(II->getArgOperand(0))) { 258753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (IntrinsicInst *Operand = dyn_cast<IntrinsicInst>(TI->getOperand(0))) 259753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Operand->getIntrinsicID() == Intrinsic::bswap) { 260753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner unsigned C = Operand->getType()->getPrimitiveSizeInBits() - 261753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner TI->getType()->getPrimitiveSizeInBits(); 262753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Value *CV = ConstantInt::get(Operand->getType(), C); 263cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif Value *V = Builder->CreateLShr(Operand->getArgOperand(0), CV); 264753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return new TruncInst(V, TI->getType()); 265753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 266753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 26700e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 268753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 269753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::powi: 270cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif if (ConstantInt *Power = dyn_cast<ConstantInt>(II->getArgOperand(1))) { 271753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // powi(x, 0) -> 1.0 272753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Power->isZero()) 273753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return ReplaceInstUsesWith(CI, ConstantFP::get(CI.getType(), 1.0)); 274753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // powi(x, 1) -> x 275753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Power->isOne()) 276cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif return ReplaceInstUsesWith(CI, II->getArgOperand(0)); 277753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // powi(x, -1) -> 1/x 278753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Power->isAllOnesValue()) 279753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return BinaryOperator::CreateFDiv(ConstantFP::get(CI.getType(), 1.0), 280cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif II->getArgOperand(0)); 281753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 282753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 283753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::cttz: { 284753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If all bits below the first known one are known zero, 285753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // this value is constant. 286db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *IT = dyn_cast<IntegerType>(II->getArgOperand(0)->getType()); 287f1ac465b67d5fc11a0d9cd09b98ceb4ffa75dd97Owen Anderson // FIXME: Try to simplify vectors of integers. 288f1ac465b67d5fc11a0d9cd09b98ceb4ffa75dd97Owen Anderson if (!IT) break; 289753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner uint32_t BitWidth = IT->getBitWidth(); 290753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt KnownZero(BitWidth, 0); 291753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt KnownOne(BitWidth, 0); 29226c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola ComputeMaskedBits(II->getArgOperand(0), KnownZero, KnownOne); 293753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner unsigned TrailingZeros = KnownOne.countTrailingZeros(); 294753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt Mask(APInt::getLowBitsSet(BitWidth, TrailingZeros)); 295753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if ((Mask & KnownZero) == Mask) 296753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return ReplaceInstUsesWith(CI, ConstantInt::get(IT, 297753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt(BitWidth, TrailingZeros))); 29800e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 299753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 300753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 301753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::ctlz: { 302753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If all bits above the first known one are known zero, 303753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // this value is constant. 304db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *IT = dyn_cast<IntegerType>(II->getArgOperand(0)->getType()); 305f1ac465b67d5fc11a0d9cd09b98ceb4ffa75dd97Owen Anderson // FIXME: Try to simplify vectors of integers. 306f1ac465b67d5fc11a0d9cd09b98ceb4ffa75dd97Owen Anderson if (!IT) break; 307753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner uint32_t BitWidth = IT->getBitWidth(); 308753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt KnownZero(BitWidth, 0); 309753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt KnownOne(BitWidth, 0); 31026c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola ComputeMaskedBits(II->getArgOperand(0), KnownZero, KnownOne); 311753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner unsigned LeadingZeros = KnownOne.countLeadingZeros(); 312753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt Mask(APInt::getHighBitsSet(BitWidth, LeadingZeros)); 313753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if ((Mask & KnownZero) == Mask) 314753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return ReplaceInstUsesWith(CI, ConstantInt::get(IT, 315753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt(BitWidth, LeadingZeros))); 31600e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 317753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 318753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 319753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::uadd_with_overflow: { 320cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif Value *LHS = II->getArgOperand(0), *RHS = II->getArgOperand(1); 321db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *IT = cast<IntegerType>(II->getArgOperand(0)->getType()); 322753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner uint32_t BitWidth = IT->getBitWidth(); 323753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt LHSKnownZero(BitWidth, 0); 324753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt LHSKnownOne(BitWidth, 0); 32526c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola ComputeMaskedBits(LHS, LHSKnownZero, LHSKnownOne); 326753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner bool LHSKnownNegative = LHSKnownOne[BitWidth - 1]; 327753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner bool LHSKnownPositive = LHSKnownZero[BitWidth - 1]; 328753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 329753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (LHSKnownNegative || LHSKnownPositive) { 330753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt RHSKnownZero(BitWidth, 0); 331753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt RHSKnownOne(BitWidth, 0); 33226c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola ComputeMaskedBits(RHS, RHSKnownZero, RHSKnownOne); 333753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner bool RHSKnownNegative = RHSKnownOne[BitWidth - 1]; 334753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner bool RHSKnownPositive = RHSKnownZero[BitWidth - 1]; 335753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (LHSKnownNegative && RHSKnownNegative) { 336753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // The sign bit is set in both cases: this MUST overflow. 337753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Create a simple add instruction, and insert it into the struct. 33859f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman Value *Add = Builder->CreateAdd(LHS, RHS); 33959f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman Add->takeName(&CI); 340753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Constant *V[] = { 34159f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman UndefValue::get(LHS->getType()), 34259f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman ConstantInt::getTrue(II->getContext()) 343753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner }; 344db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner StructType *ST = cast<StructType>(II->getType()); 345b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner Constant *Struct = ConstantStruct::get(ST, V); 346753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return InsertValueInst::Create(Struct, Add, 0); 347753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 34859f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman 349753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (LHSKnownPositive && RHSKnownPositive) { 350753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // The sign bit is clear in both cases: this CANNOT overflow. 351753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Create a simple add instruction, and insert it into the struct. 35259f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman Value *Add = Builder->CreateNUWAdd(LHS, RHS); 35359f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman Add->takeName(&CI); 354753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Constant *V[] = { 355753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner UndefValue::get(LHS->getType()), 356753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner ConstantInt::getFalse(II->getContext()) 357753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner }; 358db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner StructType *ST = cast<StructType>(II->getType()); 359b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner Constant *Struct = ConstantStruct::get(ST, V); 360753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return InsertValueInst::Create(Struct, Add, 0); 361753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 362753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 363753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 364753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // FALL THROUGH uadd into sadd 365753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::sadd_with_overflow: 366753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Canonicalize constants into the RHS. 367a90c5c7605e0d8df96e61d4bf0cc47a7eaea92cfGabor Greif if (isa<Constant>(II->getArgOperand(0)) && 368a90c5c7605e0d8df96e61d4bf0cc47a7eaea92cfGabor Greif !isa<Constant>(II->getArgOperand(1))) { 369a90c5c7605e0d8df96e61d4bf0cc47a7eaea92cfGabor Greif Value *LHS = II->getArgOperand(0); 370a90c5c7605e0d8df96e61d4bf0cc47a7eaea92cfGabor Greif II->setArgOperand(0, II->getArgOperand(1)); 371a90c5c7605e0d8df96e61d4bf0cc47a7eaea92cfGabor Greif II->setArgOperand(1, LHS); 372753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return II; 373753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 374753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 375753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // X + undef -> undef 3769c68a7bb45ebf71cec5ab4eab7c73aacdfce16dfGabor Greif if (isa<UndefValue>(II->getArgOperand(1))) 377753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return ReplaceInstUsesWith(CI, UndefValue::get(II->getType())); 37800e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 3799c68a7bb45ebf71cec5ab4eab7c73aacdfce16dfGabor Greif if (ConstantInt *RHS = dyn_cast<ConstantInt>(II->getArgOperand(1))) { 380753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // X + 0 -> {X, false} 381753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (RHS->isZero()) { 382753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Constant *V[] = { 3834fffb345ed20bd144a31c1c1724cffb6f519b814Eli Friedman UndefValue::get(II->getArgOperand(0)->getType()), 384753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner ConstantInt::getFalse(II->getContext()) 385753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner }; 386b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner Constant *Struct = 387b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner ConstantStruct::get(cast<StructType>(II->getType()), V); 388cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif return InsertValueInst::Create(Struct, II->getArgOperand(0), 0); 389753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 390753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 391753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 392753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::usub_with_overflow: 393753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::ssub_with_overflow: 394753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // undef - X -> undef 395753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // X - undef -> undef 3969c68a7bb45ebf71cec5ab4eab7c73aacdfce16dfGabor Greif if (isa<UndefValue>(II->getArgOperand(0)) || 3979c68a7bb45ebf71cec5ab4eab7c73aacdfce16dfGabor Greif isa<UndefValue>(II->getArgOperand(1))) 398753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return ReplaceInstUsesWith(CI, UndefValue::get(II->getType())); 39900e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 4009c68a7bb45ebf71cec5ab4eab7c73aacdfce16dfGabor Greif if (ConstantInt *RHS = dyn_cast<ConstantInt>(II->getArgOperand(1))) { 401753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // X - 0 -> {X, false} 402753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (RHS->isZero()) { 403753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Constant *V[] = { 4049c68a7bb45ebf71cec5ab4eab7c73aacdfce16dfGabor Greif UndefValue::get(II->getArgOperand(0)->getType()), 405753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner ConstantInt::getFalse(II->getContext()) 406753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner }; 40700e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach Constant *Struct = 408b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner ConstantStruct::get(cast<StructType>(II->getType()), V); 4099c68a7bb45ebf71cec5ab4eab7c73aacdfce16dfGabor Greif return InsertValueInst::Create(Struct, II->getArgOperand(0), 0); 410753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 411753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 412753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 4136b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer case Intrinsic::umul_with_overflow: { 4146b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer Value *LHS = II->getArgOperand(0), *RHS = II->getArgOperand(1); 4156b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer unsigned BitWidth = cast<IntegerType>(LHS->getType())->getBitWidth(); 4166b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer 4176b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer APInt LHSKnownZero(BitWidth, 0); 4186b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer APInt LHSKnownOne(BitWidth, 0); 41926c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola ComputeMaskedBits(LHS, LHSKnownZero, LHSKnownOne); 4206b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer APInt RHSKnownZero(BitWidth, 0); 4216b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer APInt RHSKnownOne(BitWidth, 0); 42226c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola ComputeMaskedBits(RHS, RHSKnownZero, RHSKnownOne); 4236b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer 424d655e6e9dc0d21c3a2d76494dec255bb027572aeBenjamin Kramer // Get the largest possible values for each operand. 425d655e6e9dc0d21c3a2d76494dec255bb027572aeBenjamin Kramer APInt LHSMax = ~LHSKnownZero; 426d655e6e9dc0d21c3a2d76494dec255bb027572aeBenjamin Kramer APInt RHSMax = ~RHSKnownZero; 4276b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer 4286b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer // If multiplying the maximum values does not overflow then we can turn 4296b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer // this into a plain NUW mul. 430d655e6e9dc0d21c3a2d76494dec255bb027572aeBenjamin Kramer bool Overflow; 431d655e6e9dc0d21c3a2d76494dec255bb027572aeBenjamin Kramer LHSMax.umul_ov(RHSMax, Overflow); 432d655e6e9dc0d21c3a2d76494dec255bb027572aeBenjamin Kramer if (!Overflow) { 4336b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer Value *Mul = Builder->CreateNUWMul(LHS, RHS, "umul_with_overflow"); 4346b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer Constant *V[] = { 4356b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer UndefValue::get(LHS->getType()), 4366b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer Builder->getFalse() 4376b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer }; 438b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner Constant *Struct = ConstantStruct::get(cast<StructType>(II->getType()),V); 4396b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer return InsertValueInst::Create(Struct, Mul, 0); 4406b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer } 4416b96fe7e146f7eb594e67210c6bef511ad0a2058Benjamin Kramer } // FALL THROUGH 442753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::smul_with_overflow: 443753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Canonicalize constants into the RHS. 444a90c5c7605e0d8df96e61d4bf0cc47a7eaea92cfGabor Greif if (isa<Constant>(II->getArgOperand(0)) && 445a90c5c7605e0d8df96e61d4bf0cc47a7eaea92cfGabor Greif !isa<Constant>(II->getArgOperand(1))) { 446a90c5c7605e0d8df96e61d4bf0cc47a7eaea92cfGabor Greif Value *LHS = II->getArgOperand(0); 447a90c5c7605e0d8df96e61d4bf0cc47a7eaea92cfGabor Greif II->setArgOperand(0, II->getArgOperand(1)); 448a90c5c7605e0d8df96e61d4bf0cc47a7eaea92cfGabor Greif II->setArgOperand(1, LHS); 449753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return II; 450753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 451753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 452753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // X * undef -> undef 4539c68a7bb45ebf71cec5ab4eab7c73aacdfce16dfGabor Greif if (isa<UndefValue>(II->getArgOperand(1))) 454753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return ReplaceInstUsesWith(CI, UndefValue::get(II->getType())); 45500e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 4569c68a7bb45ebf71cec5ab4eab7c73aacdfce16dfGabor Greif if (ConstantInt *RHSI = dyn_cast<ConstantInt>(II->getArgOperand(1))) { 457753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // X*0 -> {0, false} 458753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (RHSI->isZero()) 459753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return ReplaceInstUsesWith(CI, Constant::getNullValue(II->getType())); 46000e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 461753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // X * 1 -> {X, false} 462753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (RHSI->equalsInt(1)) { 463753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Constant *V[] = { 464cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif UndefValue::get(II->getArgOperand(0)->getType()), 465753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner ConstantInt::getFalse(II->getContext()) 466753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner }; 46700e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach Constant *Struct = 468b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner ConstantStruct::get(cast<StructType>(II->getType()), V); 469cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif return InsertValueInst::Create(Struct, II->getArgOperand(0), 0); 470753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 471753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 472753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 473753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::ppc_altivec_lvx: 474753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::ppc_altivec_lvxl: 475f93f7b2446bec3febc30b7136e18704664bd98ccBill Wendling // Turn PPC lvx -> load if the pointer is known aligned. 476687140c818ba4b896329a83324714140b6580ef8Chris Lattner if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, TD) >= 16) { 477cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0), 478753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner PointerType::getUnqual(II->getType())); 479753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return new LoadInst(Ptr); 480753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 481753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 482753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::ppc_altivec_stvx: 483753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::ppc_altivec_stvxl: 484753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Turn stvx -> store if the pointer is known aligned. 485687140c818ba4b896329a83324714140b6580ef8Chris Lattner if (getOrEnforceKnownAlignment(II->getArgOperand(1), 16, TD) >= 16) { 48600e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach Type *OpPtrTy = 4872f1ab74e763ba7f10a058f62393d0987f6f7e298Gabor Greif PointerType::getUnqual(II->getArgOperand(0)->getType()); 4882f1ab74e763ba7f10a058f62393d0987f6f7e298Gabor Greif Value *Ptr = Builder->CreateBitCast(II->getArgOperand(1), OpPtrTy); 4892f1ab74e763ba7f10a058f62393d0987f6f7e298Gabor Greif return new StoreInst(II->getArgOperand(0), Ptr); 490753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 491753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 492753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::x86_sse_storeu_ps: 493753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::x86_sse2_storeu_pd: 494753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::x86_sse2_storeu_dq: 495753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Turn X86 storeu -> store if the pointer is known aligned. 496687140c818ba4b896329a83324714140b6580ef8Chris Lattner if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, TD) >= 16) { 49700e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach Type *OpPtrTy = 4982f1ab74e763ba7f10a058f62393d0987f6f7e298Gabor Greif PointerType::getUnqual(II->getArgOperand(1)->getType()); 4992f1ab74e763ba7f10a058f62393d0987f6f7e298Gabor Greif Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0), OpPtrTy); 5002f1ab74e763ba7f10a058f62393d0987f6f7e298Gabor Greif return new StoreInst(II->getArgOperand(1), Ptr); 501753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 502753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 5039cc9f50abc28f08fb6082b5ee4f5cc7e1af4969bChandler Carruth 5049cc9f50abc28f08fb6082b5ee4f5cc7e1af4969bChandler Carruth case Intrinsic::x86_sse_cvtss2si: 5059cc9f50abc28f08fb6082b5ee4f5cc7e1af4969bChandler Carruth case Intrinsic::x86_sse_cvtss2si64: 5069cc9f50abc28f08fb6082b5ee4f5cc7e1af4969bChandler Carruth case Intrinsic::x86_sse_cvttss2si: 5079cc9f50abc28f08fb6082b5ee4f5cc7e1af4969bChandler Carruth case Intrinsic::x86_sse_cvttss2si64: 5089cc9f50abc28f08fb6082b5ee4f5cc7e1af4969bChandler Carruth case Intrinsic::x86_sse2_cvtsd2si: 5099cc9f50abc28f08fb6082b5ee4f5cc7e1af4969bChandler Carruth case Intrinsic::x86_sse2_cvtsd2si64: 5109cc9f50abc28f08fb6082b5ee4f5cc7e1af4969bChandler Carruth case Intrinsic::x86_sse2_cvttsd2si: 5119cc9f50abc28f08fb6082b5ee4f5cc7e1af4969bChandler Carruth case Intrinsic::x86_sse2_cvttsd2si64: { 5129cc9f50abc28f08fb6082b5ee4f5cc7e1af4969bChandler Carruth // These intrinsics only demand the 0th element of their input vectors. If 513753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // we can simplify the input based on that, do so now. 514753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner unsigned VWidth = 5159c68a7bb45ebf71cec5ab4eab7c73aacdfce16dfGabor Greif cast<VectorType>(II->getArgOperand(0)->getType())->getNumElements(); 516753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt DemandedElts(VWidth, 1); 517753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner APInt UndefElts(VWidth, 0); 518a399781289092fcdceb58b21174229f4373c4191Gabor Greif if (Value *V = SimplifyDemandedVectorElts(II->getArgOperand(0), 519a399781289092fcdceb58b21174229f4373c4191Gabor Greif DemandedElts, UndefElts)) { 520a90c5c7605e0d8df96e61d4bf0cc47a7eaea92cfGabor Greif II->setArgOperand(0, V); 521753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return II; 522753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 523753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 524753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 5259cc9f50abc28f08fb6082b5ee4f5cc7e1af4969bChandler Carruth 526ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings 527ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings case Intrinsic::x86_sse41_pmovsxbw: 528ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings case Intrinsic::x86_sse41_pmovsxwd: 529ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings case Intrinsic::x86_sse41_pmovsxdq: 530ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings case Intrinsic::x86_sse41_pmovzxbw: 531ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings case Intrinsic::x86_sse41_pmovzxwd: 532ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings case Intrinsic::x86_sse41_pmovzxdq: { 533aaa7f499c1a2d46491a98d978ef45b0a06d73d31Evan Cheng // pmov{s|z}x ignores the upper half of their input vectors. 534ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings unsigned VWidth = 535ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings cast<VectorType>(II->getArgOperand(0)->getType())->getNumElements(); 536ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings unsigned LowHalfElts = VWidth / 2; 537d116611e0a884e53ea1524de3a1306c1eb447228Stuart Hastings APInt InputDemandedElts(APInt::getBitsSet(VWidth, 0, LowHalfElts)); 538ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings APInt UndefElts(VWidth, 0); 539ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings if (Value *TmpV = SimplifyDemandedVectorElts(II->getArgOperand(0), 540ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings InputDemandedElts, 541ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings UndefElts)) { 542ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings II->setArgOperand(0, TmpV); 543ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings return II; 544ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings } 545ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings break; 546ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings } 547ca1ef485854d668f794bf389154aa371aa2ed535Stuart Hastings 548753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::ppc_altivec_vperm: 549753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Turn vperm(V1,V2,mask) -> shuffle(V1,V2,mask) if mask is a constant. 550a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner if (Constant *Mask = dyn_cast<Constant>(II->getArgOperand(2))) { 551a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner assert(Mask->getType()->getVectorNumElements() == 16 && 552a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner "Bad type for intrinsic!"); 55300e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 554753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Check that all of the elements are integer constants or undefs. 555753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner bool AllEltsOk = true; 556753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner for (unsigned i = 0; i != 16; ++i) { 557a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner Constant *Elt = Mask->getAggregateElement(i); 558a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner if (Elt == 0 || 559a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner !(isa<ConstantInt>(Elt) || isa<UndefValue>(Elt))) { 560753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner AllEltsOk = false; 561753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 562753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 563753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 56400e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 565753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (AllEltsOk) { 566753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Cast the input vectors to byte vectors. 567a399781289092fcdceb58b21174229f4373c4191Gabor Greif Value *Op0 = Builder->CreateBitCast(II->getArgOperand(0), 568a399781289092fcdceb58b21174229f4373c4191Gabor Greif Mask->getType()); 569a399781289092fcdceb58b21174229f4373c4191Gabor Greif Value *Op1 = Builder->CreateBitCast(II->getArgOperand(1), 570a399781289092fcdceb58b21174229f4373c4191Gabor Greif Mask->getType()); 571753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Value *Result = UndefValue::get(Op0->getType()); 57200e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 573753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Only extract each element once. 574753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Value *ExtractedElts[32]; 575753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner memset(ExtractedElts, 0, sizeof(ExtractedElts)); 57600e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 577753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner for (unsigned i = 0; i != 16; ++i) { 578a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner if (isa<UndefValue>(Mask->getAggregateElement(i))) 579753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner continue; 58000e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach unsigned Idx = 581a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner cast<ConstantInt>(Mask->getAggregateElement(i))->getZExtValue(); 582753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Idx &= 31; // Match the hardware behavior. 58300e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 584753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (ExtractedElts[Idx] == 0) { 58500e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach ExtractedElts[Idx] = 586a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Builder->CreateExtractElement(Idx < 16 ? Op0 : Op1, 587a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Builder->getInt32(Idx&15)); 588753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 58900e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 590753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Insert this value into the result vector. 591753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Result = Builder->CreateInsertElement(Result, ExtractedElts[Idx], 592a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Builder->getInt32(i)); 593753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 594753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return CastInst::Create(Instruction::BitCast, Result, CI.getType()); 595753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 596753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 597753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 598753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 599364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vld1: 600364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vld2: 601364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vld3: 602364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vld4: 603364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vld2lane: 604364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vld3lane: 605364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vld4lane: 606364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vst1: 607364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vst2: 608364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vst3: 609364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vst4: 610364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vst2lane: 611364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vst3lane: 612364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson case Intrinsic::arm_neon_vst4lane: { 613ae47be1ea023e4b1e6bbbdc4687333eea54c84c8Chris Lattner unsigned MemAlign = getKnownAlignment(II->getArgOperand(0), TD); 614364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson unsigned AlignArg = II->getNumArgOperands() - 1; 615364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson ConstantInt *IntrAlign = dyn_cast<ConstantInt>(II->getArgOperand(AlignArg)); 616364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson if (IntrAlign && IntrAlign->getZExtValue() < MemAlign) { 617364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson II->setArgOperand(AlignArg, 618364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson ConstantInt::get(Type::getInt32Ty(II->getContext()), 619364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson MemAlign, false)); 620364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson return II; 621364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson } 622364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson break; 623364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson } 624364f17c47162a657bb0c3516588cdfc5297664f0Bob Wilson 625973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames case Intrinsic::arm_neon_vmulls: 626973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames case Intrinsic::arm_neon_vmullu: { 627973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames Value *Arg0 = II->getArgOperand(0); 628973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames Value *Arg1 = II->getArgOperand(1); 629973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames 630973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames // Handle mul by zero first: 631973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames if (isa<ConstantAggregateZero>(Arg0) || isa<ConstantAggregateZero>(Arg1)) { 632973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames return ReplaceInstUsesWith(CI, ConstantAggregateZero::get(II->getType())); 633973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames } 634973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames 635973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames // Check for constant LHS & RHS - in this case we just simplify. 636973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames bool Zext = (II->getIntrinsicID() == Intrinsic::arm_neon_vmullu); 637973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames VectorType *NewVT = cast<VectorType>(II->getType()); 638973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames unsigned NewWidth = NewVT->getElementType()->getIntegerBitWidth(); 639973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames if (ConstantDataVector *CV0 = dyn_cast<ConstantDataVector>(Arg0)) { 640973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames if (ConstantDataVector *CV1 = dyn_cast<ConstantDataVector>(Arg1)) { 641973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames VectorType* VT = cast<VectorType>(CV0->getType()); 642973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames SmallVector<Constant*, 4> NewElems; 643973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames for (unsigned i = 0; i < VT->getNumElements(); ++i) { 644973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames APInt CV0E = 645973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames (cast<ConstantInt>(CV0->getAggregateElement(i)))->getValue(); 646973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames CV0E = Zext ? CV0E.zext(NewWidth) : CV0E.sext(NewWidth); 647973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames APInt CV1E = 648973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames (cast<ConstantInt>(CV1->getAggregateElement(i)))->getValue(); 649973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames CV1E = Zext ? CV1E.zext(NewWidth) : CV1E.sext(NewWidth); 650973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames NewElems.push_back( 651973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames ConstantInt::get(NewVT->getElementType(), CV0E * CV1E)); 652973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames } 653973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames return ReplaceInstUsesWith(CI, ConstantVector::get(NewElems)); 654973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames } 655973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames 656973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames // Couldn't simplify - cannonicalize constant to the RHS. 657973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames std::swap(Arg0, Arg1); 658973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames } 659973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames 660973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames // Handle mul by one: 661973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames if (ConstantDataVector *CV1 = dyn_cast<ConstantDataVector>(Arg1)) { 662973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames if (ConstantInt *Splat = 663973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames dyn_cast_or_null<ConstantInt>(CV1->getSplatValue())) { 664973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames if (Splat->isOne()) { 665973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames if (Zext) 666973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames return CastInst::CreateZExtOrBitCast(Arg0, II->getType()); 667973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames // else 668973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames return CastInst::CreateSExtOrBitCast(Arg0, II->getType()); 669973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames } 670973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames } 671973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames } 672973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames 673973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames break; 674973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames } 675973f72a29aeafb1fdc4f8dafc3f6c6651cbb0c99Lang Hames 676753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner case Intrinsic::stackrestore: { 677753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If the save is right next to the restore, remove the restore. This can 678753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // happen when variable allocas are DCE'd. 679cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif if (IntrinsicInst *SS = dyn_cast<IntrinsicInst>(II->getArgOperand(0))) { 680753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (SS->getIntrinsicID() == Intrinsic::stacksave) { 681753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner BasicBlock::iterator BI = SS; 682753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (&*++BI == II) 683753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return EraseInstFromFunction(CI); 684753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 685753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 68600e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 687753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Scan down this block to see if there is another stack restore in the 688753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // same block without an intervening call/alloca. 689753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner BasicBlock::iterator BI = II; 690753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner TerminatorInst *TI = II->getParent()->getTerminator(); 691753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner bool CannotRemove = false; 692753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner for (++BI; &*BI != TI; ++BI) { 6939e72a79ef4a9fcda482ce0b0e1f0bd6a4f16cffdNuno Lopes if (isa<AllocaInst>(BI)) { 694753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner CannotRemove = true; 695753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 696753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 697753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (CallInst *BCI = dyn_cast<CallInst>(BI)) { 698753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(BCI)) { 699753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If there is a stackrestore below this one, remove this one. 700753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (II->getIntrinsicID() == Intrinsic::stackrestore) 701753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return EraseInstFromFunction(CI); 702753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Otherwise, ignore the intrinsic. 703753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } else { 704753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If we found a non-intrinsic call, we can't remove the stack 705753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // restore. 706753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner CannotRemove = true; 707753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 708753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 709753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 710753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 71100e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 712dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling // If the stack restore is in a return, resume, or unwind block and if there 713dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling // are no allocas or calls between the restore and the return, nuke the 714dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling // restore. 715aa5abe88d6aa445afa593476a665e3ab14b3524cBill Wendling if (!CannotRemove && (isa<ReturnInst>(TI) || isa<ResumeInst>(TI))) 716753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return EraseInstFromFunction(CI); 717753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 718753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 719753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 720753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 721753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return visitCallSite(II); 722753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner} 723753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 724753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// InvokeInst simplification 725753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// 726753a2b464d0628231bd3dce645edd05dfbaa3a06Chris LattnerInstruction *InstCombiner::visitInvokeInst(InvokeInst &II) { 727753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return visitCallSite(&II); 728753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner} 729753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 73000e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach/// isSafeToEliminateVarargsCast - If this cast does not affect the value 731753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner/// passed through the varargs area, we can eliminate the use of the cast. 732753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattnerstatic bool isSafeToEliminateVarargsCast(const CallSite CS, 733753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner const CastInst * const CI, 734753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner const TargetData * const TD, 735753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner const int ix) { 736753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!CI->isLosslessCast()) 737753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return false; 738753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 739753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // The size of ByVal arguments is derived from the type, so we 740753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // can't change to a type with a different size. If the size were 741753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // passed explicitly we could avoid this check. 742173862e5468fbcf4b022b9088d2c81b25c2d60c5Nick Lewycky if (!CS.isByValArgument(ix)) 743753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return true; 744753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 74500e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach Type* SrcTy = 746753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner cast<PointerType>(CI->getOperand(0)->getType())->getElementType(); 747db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type* DstTy = cast<PointerType>(CI->getType())->getElementType(); 748753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!SrcTy->isSized() || !DstTy->isSized()) 749753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return false; 750753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!TD || TD->getTypeAllocSize(SrcTy) != TD->getTypeAllocSize(DstTy)) 751753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return false; 752753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return true; 753753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner} 754753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 7550b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramernamespace { 7560b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramerclass InstCombineFortifiedLibCalls : public SimplifyFortifiedLibCalls { 7570b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer InstCombiner *IC; 7580b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramerprotected: 7590b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer void replaceCall(Value *With) { 7600b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer NewInstruction = IC->ReplaceInstUsesWith(*CI, With); 7610b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer } 7620b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer bool isFoldable(unsigned SizeCIOp, unsigned SizeArgOp, bool isString) const { 7638143a84c46b8d2fb58eddb46d84dd5d44d03cb6cBenjamin Kramer if (CI->getArgOperand(SizeCIOp) == CI->getArgOperand(SizeArgOp)) 7648143a84c46b8d2fb58eddb46d84dd5d44d03cb6cBenjamin Kramer return true; 765a399781289092fcdceb58b21174229f4373c4191Gabor Greif if (ConstantInt *SizeCI = 766a399781289092fcdceb58b21174229f4373c4191Gabor Greif dyn_cast<ConstantInt>(CI->getArgOperand(SizeCIOp))) { 7670b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer if (SizeCI->isAllOnesValue()) 7680b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer return true; 769b9b80c326847ccb1b0611e9b6dc4d372ecc158d3Eric Christopher if (isString) { 770b9b80c326847ccb1b0611e9b6dc4d372ecc158d3Eric Christopher uint64_t Len = GetStringLength(CI->getArgOperand(SizeArgOp)); 771b9b80c326847ccb1b0611e9b6dc4d372ecc158d3Eric Christopher // If the length is 0 we don't know how long it is and so we can't 772b9b80c326847ccb1b0611e9b6dc4d372ecc158d3Eric Christopher // remove the check. 773b9b80c326847ccb1b0611e9b6dc4d372ecc158d3Eric Christopher if (Len == 0) return false; 774b9b80c326847ccb1b0611e9b6dc4d372ecc158d3Eric Christopher return SizeCI->getZExtValue() >= Len; 775b9b80c326847ccb1b0611e9b6dc4d372ecc158d3Eric Christopher } 776a399781289092fcdceb58b21174229f4373c4191Gabor Greif if (ConstantInt *Arg = dyn_cast<ConstantInt>( 777a399781289092fcdceb58b21174229f4373c4191Gabor Greif CI->getArgOperand(SizeArgOp))) 7789d8f002d8f5a5aba665bb6f85c19eee77810043cEvan Cheng return SizeCI->getZExtValue() >= Arg->getZExtValue(); 7790b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer } 7800b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer return false; 7810b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer } 7820b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramerpublic: 7830b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer InstCombineFortifiedLibCalls(InstCombiner *IC) : IC(IC), NewInstruction(0) { } 7840b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer Instruction *NewInstruction; 7850b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer}; 7860b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer} // end anonymous namespace 7870b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer 78827ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher// Try to fold some different type of calls here. 78900e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach// Currently we're only working with the checking functions, memcpy_chk, 79027ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher// mempcpy_chk, memmove_chk, memset_chk, strcpy_chk, stpcpy_chk, strncpy_chk, 79127ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher// strcat_chk and strncat_chk. 79227ceaa13f820e33c44e29adc2095dd3e1e69d09fEric ChristopherInstruction *InstCombiner::tryOptimizeCall(CallInst *CI, const TargetData *TD) { 79327ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher if (CI->getCalledFunction() == 0) return 0; 79427ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher 7950b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer InstCombineFortifiedLibCalls Simplifier(this); 79651004dff923259c90591621e7151408ad94e0eb8Nuno Lopes Simplifier.fold(CI, TD, TLI); 7970b6cb507385c8bd10b6a51b5e45a9b99d8d94798Benjamin Kramer return Simplifier.NewInstruction; 79827ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher} 79927ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher 8004a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sandsstatic IntrinsicInst *FindInitTrampolineFromAlloca(Value *TrampMem) { 8014a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands // Strip off at most one level of pointer casts, looking for an alloca. This 8024a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands // is good enough in practice and simpler than handling any number of casts. 8034a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands Value *Underlying = TrampMem->stripPointerCasts(); 8044a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (Underlying != TrampMem && 8054a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands (!Underlying->hasOneUse() || *Underlying->use_begin() != TrampMem)) 8064a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return 0; 8074a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (!isa<AllocaInst>(Underlying)) 8084a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return 0; 8094a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands 8104a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands IntrinsicInst *InitTrampoline = 0; 8114a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands for (Value::use_iterator I = TrampMem->use_begin(), E = TrampMem->use_end(); 8124a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands I != E; I++) { 8134a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands IntrinsicInst *II = dyn_cast<IntrinsicInst>(*I); 8144a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (!II) 8154a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return 0; 8164a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (II->getIntrinsicID() == Intrinsic::init_trampoline) { 8174a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (InitTrampoline) 8184a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands // More than one init_trampoline writes to this value. Give up. 8194a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return 0; 8204a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands InitTrampoline = II; 8214a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands continue; 8224a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands } 8234a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (II->getIntrinsicID() == Intrinsic::adjust_trampoline) 8244a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands // Allow any number of calls to adjust.trampoline. 8254a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands continue; 8264a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return 0; 8274a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands } 8284a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands 8294a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands // No call to init.trampoline found. 8304a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (!InitTrampoline) 8314a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return 0; 8324a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands 8334a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands // Check that the alloca is being used in the expected way. 8344a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (InitTrampoline->getOperand(0) != TrampMem) 8354a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return 0; 8364a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands 8374a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return InitTrampoline; 8384a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands} 8394a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands 8404a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sandsstatic IntrinsicInst *FindInitTrampolineFromBB(IntrinsicInst *AdjustTramp, 8414a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands Value *TrampMem) { 8424a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands // Visit all the previous instructions in the basic block, and try to find a 8434a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands // init.trampoline which has a direct path to the adjust.trampoline. 8444a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands for (BasicBlock::iterator I = AdjustTramp, 8454a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands E = AdjustTramp->getParent()->begin(); I != E; ) { 8464a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands Instruction *Inst = --I; 8474a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) 8484a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (II->getIntrinsicID() == Intrinsic::init_trampoline && 8494a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands II->getOperand(0) == TrampMem) 8504a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return II; 8514a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (Inst->mayWriteToMemory()) 8524a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return 0; 8534a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands } 8544a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return 0; 8554a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands} 8564a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands 8574a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands// Given a call to llvm.adjust.trampoline, find and return the corresponding 8584a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands// call to llvm.init.trampoline if the call to the trampoline can be optimized 8594a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands// to a direct call to a function. Otherwise return NULL. 8604a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands// 8614a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sandsstatic IntrinsicInst *FindInitTrampoline(Value *Callee) { 8624a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands Callee = Callee->stripPointerCasts(); 8634a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands IntrinsicInst *AdjustTramp = dyn_cast<IntrinsicInst>(Callee); 8644a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (!AdjustTramp || 8654a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands AdjustTramp->getIntrinsicID() != Intrinsic::adjust_trampoline) 8664a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return 0; 8674a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands 8684a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands Value *TrampMem = AdjustTramp->getOperand(0); 8694a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands 8704a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (IntrinsicInst *IT = FindInitTrampolineFromAlloca(TrampMem)) 8714a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return IT; 8724a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (IntrinsicInst *IT = FindInitTrampolineFromBB(AdjustTramp, TrampMem)) 8734a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return IT; 8744a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return 0; 8754a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands} 8764a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands 877753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// visitCallSite - Improvements for call and invoke instructions. 878753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// 879753a2b464d0628231bd3dce645edd05dfbaa3a06Chris LattnerInstruction *InstCombiner::visitCallSite(CallSite CS) { 8808e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer if (isAllocLikeFn(CS.getInstruction(), TLI)) 88178f8ef42173a3a9867ed789073d4ddc652fb7ff2Nuno Lopes return visitAllocSite(*CS.getInstruction()); 8822b3e9580536dfb5666b9d91e99baebf6d45bfa5fNuno Lopes 883753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner bool Changed = false; 884753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 885ab215bc371677cdeac6eacb3e890e5af666d1ab4Chris Lattner // If the callee is a pointer to a function, attempt to move any casts to the 886ab215bc371677cdeac6eacb3e890e5af666d1ab4Chris Lattner // arguments of the call/invoke. 887753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Value *Callee = CS.getCalledValue(); 888ab215bc371677cdeac6eacb3e890e5af666d1ab4Chris Lattner if (!isa<Function>(Callee) && transformConstExprCastCall(CS)) 889ab215bc371677cdeac6eacb3e890e5af666d1ab4Chris Lattner return 0; 890753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 891753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Function *CalleeF = dyn_cast<Function>(Callee)) 892d569561835b0fa4dbbb0fca1b1f0a8de6c01439aChris Lattner // If the call and callee calling conventions don't match, this call must 893d569561835b0fa4dbbb0fca1b1f0a8de6c01439aChris Lattner // be unreachable, as the call is undefined. 894d569561835b0fa4dbbb0fca1b1f0a8de6c01439aChris Lattner if (CalleeF->getCallingConv() != CS.getCallingConv() && 895d569561835b0fa4dbbb0fca1b1f0a8de6c01439aChris Lattner // Only do this for calls to a function with a body. A prototype may 896d569561835b0fa4dbbb0fca1b1f0a8de6c01439aChris Lattner // not actually end up matching the implementation's calling conv for a 897d569561835b0fa4dbbb0fca1b1f0a8de6c01439aChris Lattner // variety of reasons (e.g. it may be written in assembly). 898d569561835b0fa4dbbb0fca1b1f0a8de6c01439aChris Lattner !CalleeF->isDeclaration()) { 899753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Instruction *OldCall = CS.getInstruction(); 900753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner new StoreInst(ConstantInt::getTrue(Callee->getContext()), 90100e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach UndefValue::get(Type::getInt1PtrTy(Callee->getContext())), 902753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner OldCall); 903753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If OldCall dues not return void then replaceAllUsesWith undef. 904753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // This allows ValueHandlers and custom metadata to adjust itself. 905753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!OldCall->getType()->isVoidTy()) 9063e22cb9ec30cd9b1be9b0f50e400f512124997e5Eli Friedman ReplaceInstUsesWith(*OldCall, UndefValue::get(OldCall->getType())); 907830f3f205d8a77acbf8838fe78c2c733ca924d9cChris Lattner if (isa<CallInst>(OldCall)) 908753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return EraseInstFromFunction(*OldCall); 90900e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 910830f3f205d8a77acbf8838fe78c2c733ca924d9cChris Lattner // We cannot remove an invoke, because it would change the CFG, just 911830f3f205d8a77acbf8838fe78c2c733ca924d9cChris Lattner // change the callee to a null pointer. 912654c06f6457f80428e40810ad251c412462731e4Gabor Greif cast<InvokeInst>(OldCall)->setCalledFunction( 913830f3f205d8a77acbf8838fe78c2c733ca924d9cChris Lattner Constant::getNullValue(CalleeF->getType())); 914753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return 0; 915753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 916753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 917753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (isa<ConstantPointerNull>(Callee) || isa<UndefValue>(Callee)) { 918cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif // If CS does not return void then replaceAllUsesWith undef. 919753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // This allows ValueHandlers and custom metadata to adjust itself. 920753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!CS.getInstruction()->getType()->isVoidTy()) 9213e22cb9ec30cd9b1be9b0f50e400f512124997e5Eli Friedman ReplaceInstUsesWith(*CS.getInstruction(), 9223e22cb9ec30cd9b1be9b0f50e400f512124997e5Eli Friedman UndefValue::get(CS.getInstruction()->getType())); 923753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 924f1fb6c836940d1b92c0e3df27f4c9ca6569ff968Nuno Lopes if (isa<InvokeInst>(CS.getInstruction())) { 925f1fb6c836940d1b92c0e3df27f4c9ca6569ff968Nuno Lopes // Can't remove an invoke because we cannot change the CFG. 926f1fb6c836940d1b92c0e3df27f4c9ca6569ff968Nuno Lopes return 0; 927753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 928f1fb6c836940d1b92c0e3df27f4c9ca6569ff968Nuno Lopes 929f1fb6c836940d1b92c0e3df27f4c9ca6569ff968Nuno Lopes // This instruction is not reachable, just remove it. We insert a store to 930f1fb6c836940d1b92c0e3df27f4c9ca6569ff968Nuno Lopes // undef so that we know that this code is not reachable, despite the fact 931f1fb6c836940d1b92c0e3df27f4c9ca6569ff968Nuno Lopes // that we can't modify the CFG here. 932f1fb6c836940d1b92c0e3df27f4c9ca6569ff968Nuno Lopes new StoreInst(ConstantInt::getTrue(Callee->getContext()), 933f1fb6c836940d1b92c0e3df27f4c9ca6569ff968Nuno Lopes UndefValue::get(Type::getInt1PtrTy(Callee->getContext())), 934f1fb6c836940d1b92c0e3df27f4c9ca6569ff968Nuno Lopes CS.getInstruction()); 935f1fb6c836940d1b92c0e3df27f4c9ca6569ff968Nuno Lopes 936753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return EraseInstFromFunction(*CS.getInstruction()); 937753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 938753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 9394a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands if (IntrinsicInst *II = FindInitTrampoline(Callee)) 9404a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands return transformCallThroughTrampoline(CS, II); 941753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 942db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *PTy = cast<PointerType>(Callee->getType()); 943db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 944753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (FTy->isVarArg()) { 945ba78c883d4c89bd807fa7ebea7ac6f22f3503223Eli Friedman int ix = FTy->getNumParams(); 946753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // See if we can optimize any arguments passed through the varargs area of 947753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // the call. 948753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner for (CallSite::arg_iterator I = CS.arg_begin()+FTy->getNumParams(), 949753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner E = CS.arg_end(); I != E; ++I, ++ix) { 950753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner CastInst *CI = dyn_cast<CastInst>(*I); 951753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (CI && isSafeToEliminateVarargsCast(CS, CI, TD, ix)) { 952753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner *I = CI->getOperand(0); 953753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Changed = true; 954753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 955753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 956753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 957753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 958753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (isa<InlineAsm>(Callee) && !CS.doesNotThrow()) { 959753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Inline asm calls cannot throw - mark them 'nounwind'. 960753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner CS.setDoesNotThrow(); 961753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Changed = true; 962753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 963753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 96427ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher // Try to optimize the call if possible, we require TargetData for most of 96527ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher // this. None of these calls are seen as possibly dead so go ahead and 96627ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher // delete the instruction now. 96727ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher if (CallInst *CI = dyn_cast<CallInst>(CS.getInstruction())) { 96827ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher Instruction *I = tryOptimizeCall(CI, TD); 9697b323a34fa034389e9e439f6c02eeb73e87ab9dbEric Christopher // If we changed something return the result, etc. Otherwise let 9707b323a34fa034389e9e439f6c02eeb73e87ab9dbEric Christopher // the fallthrough check. 9717b323a34fa034389e9e439f6c02eeb73e87ab9dbEric Christopher if (I) return EraseInstFromFunction(*I); 97227ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher } 97327ceaa13f820e33c44e29adc2095dd3e1e69d09fEric Christopher 974753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return Changed ? CS.getInstruction() : 0; 975753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner} 976753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 977753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// transformConstExprCastCall - If the callee is a constexpr cast of a function, 978753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// attempt to move the cast to the arguments of the call/invoke. 979753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// 980753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattnerbool InstCombiner::transformConstExprCastCall(CallSite CS) { 981ab215bc371677cdeac6eacb3e890e5af666d1ab4Chris Lattner Function *Callee = 982ab215bc371677cdeac6eacb3e890e5af666d1ab4Chris Lattner dyn_cast<Function>(CS.getCalledValue()->stripPointerCasts()); 983ab215bc371677cdeac6eacb3e890e5af666d1ab4Chris Lattner if (Callee == 0) 984753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return false; 985753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Instruction *Caller = CS.getInstruction(); 986753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner const AttrListPtr &CallerPAL = CS.getAttributes(); 987753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 988753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Okay, this is a cast from a function to a different type. Unless doing so 989753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // would cause a type conversion of one of our arguments, change this call to 990753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // be a direct call with arguments casted to the appropriate types. 991753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // 992db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner FunctionType *FT = Callee->getFunctionType(); 993db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OldRetTy = Caller->getType(); 994db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *NewRetTy = FT->getReturnType(); 995753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 9961df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (NewRetTy->isStructTy()) 997753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return false; // TODO: Handle multiple return values. 998753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 999753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Check to see if we are changing the return type... 1000753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (OldRetTy != NewRetTy) { 1001753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Callee->isDeclaration() && 1002753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Conversion is ok if changing from one pointer type to another or from 1003753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // a pointer to an integer of the same size. 10041df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands !((OldRetTy->isPointerTy() || !TD || 1005753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner OldRetTy == TD->getIntPtrType(Caller->getContext())) && 10061df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands (NewRetTy->isPointerTy() || !TD || 1007753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NewRetTy == TD->getIntPtrType(Caller->getContext())))) 1008753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return false; // Cannot transform this return value. 1009753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1010753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!Caller->use_empty() && 1011753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // void -> non-void is handled specially 1012753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner !NewRetTy->isVoidTy() && !CastInst::isCastable(NewRetTy, OldRetTy)) 1013753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return false; // Cannot transform this return value. 1014753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1015753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!CallerPAL.isEmpty() && !Caller->use_empty()) { 1016753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Attributes RAttrs = CallerPAL.getRetAttributes(); 1017753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (RAttrs & Attribute::typeIncompatible(NewRetTy)) 1018753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return false; // Attribute not compatible with transformed value. 1019753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1020753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1021753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If the callsite is an invoke instruction, and the return value is used by 1022753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // a PHI node in a successor, we cannot change the return type of the call 1023753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // because there is no place to put the cast instruction (without breaking 1024753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // the critical edge). Bail out in this case. 1025753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!Caller->use_empty()) 1026753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) 1027753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner for (Value::use_iterator UI = II->use_begin(), E = II->use_end(); 1028753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner UI != E; ++UI) 1029753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(*UI)) 1030753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (PN->getParent() == II->getNormalDest() || 1031753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner PN->getParent() == II->getUnwindDest()) 1032753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return false; 1033753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1034753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1035753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner unsigned NumActualArgs = unsigned(CS.arg_end()-CS.arg_begin()); 1036753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner unsigned NumCommonArgs = std::min(FT->getNumParams(), NumActualArgs); 1037753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1038753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner CallSite::arg_iterator AI = CS.arg_begin(); 1039753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner for (unsigned i = 0, e = NumCommonArgs; i != e; ++i, ++AI) { 1040db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ParamTy = FT->getParamType(i); 1041db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ActTy = (*AI)->getType(); 1042753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1043753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!CastInst::isCastable(ActTy, ParamTy)) 1044753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return false; // Cannot transform this parameter value. 1045753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1046164b86b4399559e45fab7846f1e3e09119cab4e2Kostya Serebryany Attributes Attrs = CallerPAL.getParamAttributes(i + 1); 10472b9375e44b0e99ce23d2cef8de78f66347eef88aChris Lattner if (Attrs & Attribute::typeIncompatible(ParamTy)) 1048753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return false; // Attribute not compatible with transformed value. 104900e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 10502b9375e44b0e99ce23d2cef8de78f66347eef88aChris Lattner // If the parameter is passed as a byval argument, then we have to have a 10512b9375e44b0e99ce23d2cef8de78f66347eef88aChris Lattner // sized type and the sized type has to have the same size as the old type. 10522b9375e44b0e99ce23d2cef8de78f66347eef88aChris Lattner if (ParamTy != ActTy && (Attrs & Attribute::ByVal)) { 1053db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy); 10542b9375e44b0e99ce23d2cef8de78f66347eef88aChris Lattner if (ParamPTy == 0 || !ParamPTy->getElementType()->isSized() || TD == 0) 10552b9375e44b0e99ce23d2cef8de78f66347eef88aChris Lattner return false; 105600e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 1057db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *CurElTy = cast<PointerType>(ActTy)->getElementType(); 10582b9375e44b0e99ce23d2cef8de78f66347eef88aChris Lattner if (TD->getTypeAllocSize(CurElTy) != 10592b9375e44b0e99ce23d2cef8de78f66347eef88aChris Lattner TD->getTypeAllocSize(ParamPTy->getElementType())) 10602b9375e44b0e99ce23d2cef8de78f66347eef88aChris Lattner return false; 10612b9375e44b0e99ce23d2cef8de78f66347eef88aChris Lattner } 1062753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1063753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Converting from one pointer type to another or between a pointer and an 1064753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // integer of the same size is safe even if we do not have a body. 1065753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner bool isConvertible = ActTy == ParamTy || 10661df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands (TD && ((ParamTy->isPointerTy() || 1067753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner ParamTy == TD->getIntPtrType(Caller->getContext())) && 10681df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands (ActTy->isPointerTy() || 1069753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner ActTy == TD->getIntPtrType(Caller->getContext())))); 1070753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Callee->isDeclaration() && !isConvertible) return false; 1071753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1072753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1073091b1e3c74fee17e33aa87478ab07bfbba0a2f78Chris Lattner if (Callee->isDeclaration()) { 1074091b1e3c74fee17e33aa87478ab07bfbba0a2f78Chris Lattner // Do not delete arguments unless we have a function body. 1075091b1e3c74fee17e33aa87478ab07bfbba0a2f78Chris Lattner if (FT->getNumParams() < NumActualArgs && !FT->isVarArg()) 1076091b1e3c74fee17e33aa87478ab07bfbba0a2f78Chris Lattner return false; 1077091b1e3c74fee17e33aa87478ab07bfbba0a2f78Chris Lattner 1078091b1e3c74fee17e33aa87478ab07bfbba0a2f78Chris Lattner // If the callee is just a declaration, don't change the varargsness of the 1079091b1e3c74fee17e33aa87478ab07bfbba0a2f78Chris Lattner // call. We don't want to introduce a varargs call where one doesn't 1080091b1e3c74fee17e33aa87478ab07bfbba0a2f78Chris Lattner // already exist. 1081db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *APTy = cast<PointerType>(CS.getCalledValue()->getType()); 1082091b1e3c74fee17e33aa87478ab07bfbba0a2f78Chris Lattner if (FT->isVarArg()!=cast<FunctionType>(APTy->getElementType())->isVarArg()) 1083091b1e3c74fee17e33aa87478ab07bfbba0a2f78Chris Lattner return false; 1084f374486659822e93054363bef05e781acee16f3bJim Grosbach 1085f374486659822e93054363bef05e781acee16f3bJim Grosbach // If both the callee and the cast type are varargs, we still have to make 1086f374486659822e93054363bef05e781acee16f3bJim Grosbach // sure the number of fixed parameters are the same or we have the same 1087f374486659822e93054363bef05e781acee16f3bJim Grosbach // ABI issues as if we introduce a varargs call. 1088871a2051f7d49827259d719a97b8cc86163edbd9Jim Grosbach if (FT->isVarArg() && 1089871a2051f7d49827259d719a97b8cc86163edbd9Jim Grosbach cast<FunctionType>(APTy->getElementType())->isVarArg() && 1090871a2051f7d49827259d719a97b8cc86163edbd9Jim Grosbach FT->getNumParams() != 1091f374486659822e93054363bef05e781acee16f3bJim Grosbach cast<FunctionType>(APTy->getElementType())->getNumParams()) 1092f374486659822e93054363bef05e781acee16f3bJim Grosbach return false; 1093091b1e3c74fee17e33aa87478ab07bfbba0a2f78Chris Lattner } 109400e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 1095d5917f0b4d8f87985bfdf130c269e1929d0085d1Jim Grosbach if (FT->getNumParams() < NumActualArgs && FT->isVarArg() && 1096d5917f0b4d8f87985bfdf130c269e1929d0085d1Jim Grosbach !CallerPAL.isEmpty()) 1097d5917f0b4d8f87985bfdf130c269e1929d0085d1Jim Grosbach // In this case we have more arguments than the new function type, but we 1098d5917f0b4d8f87985bfdf130c269e1929d0085d1Jim Grosbach // won't be dropping them. Check that these extra arguments have attributes 1099d5917f0b4d8f87985bfdf130c269e1929d0085d1Jim Grosbach // that are compatible with being a vararg call argument. 1100d5917f0b4d8f87985bfdf130c269e1929d0085d1Jim Grosbach for (unsigned i = CallerPAL.getNumSlots(); i; --i) { 1101d5917f0b4d8f87985bfdf130c269e1929d0085d1Jim Grosbach if (CallerPAL.getSlot(i - 1).Index <= FT->getNumParams()) 1102d5917f0b4d8f87985bfdf130c269e1929d0085d1Jim Grosbach break; 1103d5917f0b4d8f87985bfdf130c269e1929d0085d1Jim Grosbach Attributes PAttrs = CallerPAL.getSlot(i - 1).Attrs; 1104d5917f0b4d8f87985bfdf130c269e1929d0085d1Jim Grosbach if (PAttrs & Attribute::VarArgsIncompatible) 1105d5917f0b4d8f87985bfdf130c269e1929d0085d1Jim Grosbach return false; 1106d5917f0b4d8f87985bfdf130c269e1929d0085d1Jim Grosbach } 1107753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 110800e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach 1109753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Okay, we decided that this is a safe thing to do: go ahead and start 1110091b1e3c74fee17e33aa87478ab07bfbba0a2f78Chris Lattner // inserting cast instructions as necessary. 1111753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner std::vector<Value*> Args; 1112753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Args.reserve(NumActualArgs); 1113753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner SmallVector<AttributeWithIndex, 8> attrVec; 1114753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner attrVec.reserve(NumCommonArgs); 1115753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1116753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Get any return attributes. 1117753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Attributes RAttrs = CallerPAL.getRetAttributes(); 1118753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1119753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If the return value is not being used, the type may not be compatible 1120753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // with the existing attributes. Wipe out any problematic attributes. 1121753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner RAttrs &= ~Attribute::typeIncompatible(NewRetTy); 1122753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1123753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Add the new return attributes. 1124753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (RAttrs) 1125753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner attrVec.push_back(AttributeWithIndex::get(0, RAttrs)); 1126753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1127753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner AI = CS.arg_begin(); 1128753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner for (unsigned i = 0; i != NumCommonArgs; ++i, ++AI) { 1129db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ParamTy = FT->getParamType(i); 1130753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if ((*AI)->getType() == ParamTy) { 1131753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Args.push_back(*AI); 1132753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } else { 1133753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Instruction::CastOps opcode = CastInst::getCastOpcode(*AI, 1134753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner false, ParamTy, false); 1135a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Args.push_back(Builder->CreateCast(opcode, *AI, ParamTy)); 1136753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1137753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1138753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Add any parameter attributes. 1139753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Attributes PAttrs = CallerPAL.getParamAttributes(i + 1)) 1140753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner attrVec.push_back(AttributeWithIndex::get(i + 1, PAttrs)); 1141753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1142753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1143753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If the function takes more arguments than the call was taking, add them 1144753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // now. 1145753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner for (unsigned i = NumCommonArgs; i != FT->getNumParams(); ++i) 1146753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Args.push_back(Constant::getNullValue(FT->getParamType(i))); 1147753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1148753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If we are removing arguments to the function, emit an obnoxious warning. 1149753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (FT->getNumParams() < NumActualArgs) { 1150753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!FT->isVarArg()) { 1151753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner errs() << "WARNING: While resolving call to function '" 1152753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner << Callee->getName() << "' arguments were dropped!\n"; 1153753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } else { 1154753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Add all of the arguments in their promoted form to the arg list. 1155753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner for (unsigned i = FT->getNumParams(); i != NumActualArgs; ++i, ++AI) { 1156db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *PTy = getPromotedType((*AI)->getType()); 1157753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (PTy != (*AI)->getType()) { 1158753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Must promote to pass through va_arg area! 1159753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Instruction::CastOps opcode = 1160753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner CastInst::getCastOpcode(*AI, false, PTy, false); 1161a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Args.push_back(Builder->CreateCast(opcode, *AI, PTy)); 1162753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } else { 1163753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Args.push_back(*AI); 1164753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1165753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1166753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Add any parameter attributes. 1167753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Attributes PAttrs = CallerPAL.getParamAttributes(i + 1)) 1168753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner attrVec.push_back(AttributeWithIndex::get(i + 1, PAttrs)); 1169753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1170753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1171753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1172753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1173753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Attributes FnAttrs = CallerPAL.getFnAttributes()) 1174753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner attrVec.push_back(AttributeWithIndex::get(~0, FnAttrs)); 1175753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1176753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (NewRetTy->isVoidTy()) 1177753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Caller->setName(""); // Void type should not have a name. 1178753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1179d509d0b532ec2358b3f341d4a4cd1411cb8b5db2Chris Lattner const AttrListPtr &NewCallerPAL = AttrListPtr::get(attrVec); 1180753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1181753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Instruction *NC; 1182753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) { 1183ef819d0ed8c9df3da633e8c1240e582a7879bb94Eli Friedman NC = Builder->CreateInvoke(Callee, II->getNormalDest(), 1184a3efbb15ddd5aa9006564cd79086723640084878Jay Foad II->getUnwindDest(), Args); 1185ef819d0ed8c9df3da633e8c1240e582a7879bb94Eli Friedman NC->takeName(II); 1186753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner cast<InvokeInst>(NC)->setCallingConv(II->getCallingConv()); 1187753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner cast<InvokeInst>(NC)->setAttributes(NewCallerPAL); 1188753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } else { 1189753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner CallInst *CI = cast<CallInst>(Caller); 1190a3efbb15ddd5aa9006564cd79086723640084878Jay Foad NC = Builder->CreateCall(Callee, Args); 1191ef819d0ed8c9df3da633e8c1240e582a7879bb94Eli Friedman NC->takeName(CI); 1192753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (CI->isTailCall()) 1193753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner cast<CallInst>(NC)->setTailCall(); 1194753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner cast<CallInst>(NC)->setCallingConv(CI->getCallingConv()); 1195753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner cast<CallInst>(NC)->setAttributes(NewCallerPAL); 1196753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1197753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1198753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Insert a cast of the return type as necessary. 1199753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Value *NV = NC; 1200753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (OldRetTy != NV->getType() && !Caller->use_empty()) { 1201753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!NV->getType()->isVoidTy()) { 1202ab215bc371677cdeac6eacb3e890e5af666d1ab4Chris Lattner Instruction::CastOps opcode = 1203ab215bc371677cdeac6eacb3e890e5af666d1ab4Chris Lattner CastInst::getCastOpcode(NC, false, OldRetTy, false); 1204a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer NV = NC = CastInst::Create(opcode, NC, OldRetTy); 1205a311c34d2af7c750f016ef5e4c41bee77a1dfac7Eli Friedman NC->setDebugLoc(Caller->getDebugLoc()); 1206753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1207753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If this is an invoke instruction, we should insert it after the first 1208753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // non-phi, instruction in the normal successor block. 1209753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) { 121089d4411cef736898047aa7e3bc159da39cacf8e6Bill Wendling BasicBlock::iterator I = II->getNormalDest()->getFirstInsertionPt(); 1211753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner InsertNewInstBefore(NC, *I); 1212753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } else { 1213ab215bc371677cdeac6eacb3e890e5af666d1ab4Chris Lattner // Otherwise, it's a call, just insert cast right after the call. 1214753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner InsertNewInstBefore(NC, *Caller); 1215753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1216753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Worklist.AddUsersToWorkList(*Caller); 1217753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } else { 1218753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NV = UndefValue::get(Caller->getType()); 1219753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1220753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1221753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1222753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!Caller->use_empty()) 12233e22cb9ec30cd9b1be9b0f50e400f512124997e5Eli Friedman ReplaceInstUsesWith(*Caller, NV); 12243e22cb9ec30cd9b1be9b0f50e400f512124997e5Eli Friedman 1225753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner EraseInstFromFunction(*Caller); 1226753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return true; 1227753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner} 1228753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 12294a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands// transformCallThroughTrampoline - Turn a call to a function created by 12304a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands// init_trampoline / adjust_trampoline intrinsic pair into a direct call to the 12314a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands// underlying function. 1232753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner// 12334a544a79bd735967f1d33fe675ae4566dbd17813Duncan SandsInstruction * 12344a544a79bd735967f1d33fe675ae4566dbd17813Duncan SandsInstCombiner::transformCallThroughTrampoline(CallSite CS, 12354a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands IntrinsicInst *Tramp) { 1236753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Value *Callee = CS.getCalledValue(); 1237db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *PTy = cast<PointerType>(Callee->getType()); 1238db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 1239753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner const AttrListPtr &Attrs = CS.getAttributes(); 1240753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1241753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // If the call already has the 'nest' attribute somewhere then give up - 1242753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // otherwise 'nest' would occur twice after splicing in the chain. 1243753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Attrs.hasAttrSomewhere(Attribute::Nest)) 1244753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return 0; 1245753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 12464a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands assert(Tramp && 12474a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands "transformCallThroughTrampoline called with incorrect CallSite."); 1248753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1249a399781289092fcdceb58b21174229f4373c4191Gabor Greif Function *NestF =cast<Function>(Tramp->getArgOperand(1)->stripPointerCasts()); 1250db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *NestFPTy = cast<PointerType>(NestF->getType()); 1251db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner FunctionType *NestFTy = cast<FunctionType>(NestFPTy->getElementType()); 1252753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1253753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner const AttrListPtr &NestAttrs = NestF->getAttributes(); 1254753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (!NestAttrs.isEmpty()) { 1255753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner unsigned NestIdx = 1; 12565fdd6c8793462549e3593890ec61573da06e3346Jay Foad Type *NestTy = 0; 1257753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Attributes NestAttr = Attribute::None; 1258753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1259753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Look for a parameter marked with the 'nest' attribute. 1260753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner for (FunctionType::param_iterator I = NestFTy->param_begin(), 1261753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner E = NestFTy->param_end(); I != E; ++NestIdx, ++I) 1262753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (NestAttrs.paramHasAttr(NestIdx, Attribute::Nest)) { 1263753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Record the parameter type and any other attributes. 1264753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NestTy = *I; 1265753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NestAttr = NestAttrs.getParamAttributes(NestIdx); 1266753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 1267753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1268753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1269753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (NestTy) { 1270753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Instruction *Caller = CS.getInstruction(); 1271753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner std::vector<Value*> NewArgs; 1272753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NewArgs.reserve(unsigned(CS.arg_end()-CS.arg_begin())+1); 1273753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1274753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner SmallVector<AttributeWithIndex, 8> NewAttrs; 1275753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NewAttrs.reserve(Attrs.getNumSlots() + 1); 1276753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1277753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Insert the nest argument into the call argument list, which may 1278753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // mean appending it. Likewise for attributes. 1279753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1280753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Add any result attributes. 1281753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Attributes Attr = Attrs.getRetAttributes()) 1282753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NewAttrs.push_back(AttributeWithIndex::get(0, Attr)); 1283753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1284753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner { 1285753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner unsigned Idx = 1; 1286753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); 1287753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner do { 1288753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Idx == NestIdx) { 1289753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Add the chain argument and attributes. 1290cea7ac7c01c6a15eccb2cb7a181df1baf915de0dGabor Greif Value *NestVal = Tramp->getArgOperand(2); 1291753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (NestVal->getType() != NestTy) 1292e6f364b6c44eda14cd4ad54366ea5cc7246b9500Eli Friedman NestVal = Builder->CreateBitCast(NestVal, NestTy, "nest"); 1293753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NewArgs.push_back(NestVal); 1294753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NewAttrs.push_back(AttributeWithIndex::get(NestIdx, NestAttr)); 1295753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1296753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1297753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (I == E) 1298753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 1299753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1300753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Add the original argument and attributes. 1301753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NewArgs.push_back(*I); 1302753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Attributes Attr = Attrs.getParamAttributes(Idx)) 1303753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NewAttrs.push_back 1304753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner (AttributeWithIndex::get(Idx + (Idx >= NestIdx), Attr)); 1305753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1306753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner ++Idx, ++I; 1307753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } while (1); 1308753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1309753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1310753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Add any function attributes. 1311753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Attributes Attr = Attrs.getFnAttributes()) 1312753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NewAttrs.push_back(AttributeWithIndex::get(~0, Attr)); 1313753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1314753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // The trampoline may have been bitcast to a bogus type (FTy). 1315753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Handle this by synthesizing a new function type, equal to FTy 1316753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // with the chain parameter inserted. 1317753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 13185fdd6c8793462549e3593890ec61573da06e3346Jay Foad std::vector<Type*> NewTypes; 1319753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NewTypes.reserve(FTy->getNumParams()+1); 1320753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1321753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Insert the chain's type into the list of parameter types, which may 1322753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // mean appending it. 1323753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner { 1324753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner unsigned Idx = 1; 1325753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner FunctionType::param_iterator I = FTy->param_begin(), 1326753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner E = FTy->param_end(); 1327753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1328753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner do { 1329753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (Idx == NestIdx) 1330753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Add the chain's type. 1331753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NewTypes.push_back(NestTy); 1332753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1333753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (I == E) 1334753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner break; 1335753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1336753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Add the original type. 1337753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NewTypes.push_back(*I); 1338753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1339753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner ++Idx, ++I; 1340753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } while (1); 1341753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1342753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1343753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Replace the trampoline call with a direct call. Let the generic 1344753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // code sort out any function type mismatches. 134500e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach FunctionType *NewFTy = FunctionType::get(FTy->getReturnType(), NewTypes, 1346753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner FTy->isVarArg()); 1347753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Constant *NewCallee = 1348753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NestF->getType() == PointerType::getUnqual(NewFTy) ? 134900e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach NestF : ConstantExpr::getBitCast(NestF, 1350753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner PointerType::getUnqual(NewFTy)); 1351d509d0b532ec2358b3f341d4a4cd1411cb8b5db2Chris Lattner const AttrListPtr &NewPAL = AttrListPtr::get(NewAttrs); 1352753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1353753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Instruction *NewCaller; 1354753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) { 1355753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner NewCaller = InvokeInst::Create(NewCallee, 1356753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner II->getNormalDest(), II->getUnwindDest(), 1357a3efbb15ddd5aa9006564cd79086723640084878Jay Foad NewArgs); 1358753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner cast<InvokeInst>(NewCaller)->setCallingConv(II->getCallingConv()); 1359753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner cast<InvokeInst>(NewCaller)->setAttributes(NewPAL); 1360753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } else { 1361a3efbb15ddd5aa9006564cd79086723640084878Jay Foad NewCaller = CallInst::Create(NewCallee, NewArgs); 1362753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner if (cast<CallInst>(Caller)->isTailCall()) 1363753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner cast<CallInst>(NewCaller)->setTailCall(); 1364753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner cast<CallInst>(NewCaller)-> 1365753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner setCallingConv(cast<CallInst>(Caller)->getCallingConv()); 1366753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner cast<CallInst>(NewCaller)->setAttributes(NewPAL); 1367753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 136859f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman 136959f15918c28ad340bb9f0ef78e43c2952a5b5c1cEli Friedman return NewCaller; 1370753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1371753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner } 1372753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner 1373753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // Replace the trampoline call with a direct call. Since there is no 'nest' 1374753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // parameter, there is no need to adjust the argument list. Let the generic 1375753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner // code sort out any function type mismatches. 1376753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner Constant *NewCallee = 137700e403abe384b8f61dd012242d3d81a23541ca25Jim Grosbach NestF->getType() == PTy ? NestF : 1378753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner ConstantExpr::getBitCast(NestF, PTy); 1379753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner CS.setCalledFunction(NewCallee); 1380753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner return CS.getInstruction(); 1381753a2b464d0628231bd3dce645edd05dfbaa3a06Chris Lattner} 1382