InstCombineCalls.cpp revision 9cc9f50abc28f08fb6082b5ee4f5cc7e1af4969b
1e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall//===- InstCombineCalls.cpp -----------------------------------------------===// 2e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// 3e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// The LLVM Compiler Infrastructure 4e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// 5e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// This file is distributed under the University of Illinois Open Source 6e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// License. See LICENSE.TXT for details. 7e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// 8e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall//===----------------------------------------------------------------------===// 9e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// 10e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// This file implements the visitCall and visitInvoke functions. 11e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// 12e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall//===----------------------------------------------------------------------===// 13e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 14e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall#include "InstCombine.h" 15e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall#include "llvm/IntrinsicInst.h" 16e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall#include "llvm/Support/CallSite.h" 17e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall#include "llvm/Target/TargetData.h" 18e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall#include "llvm/Analysis/MemoryBuiltins.h" 19e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall#include "llvm/Transforms/Utils/BuildLibCalls.h" 20e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall#include "llvm/Transforms/Utils/Local.h" 21e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrallusing namespace llvm; 22e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 23e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall/// getPromotedType - Return the specified type promoted as it would be to pass 24e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall/// though a va_arg area. 25e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrallstatic const Type *getPromotedType(const Type *Ty) { 26e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty)) { 27e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ITy->getBitWidth() < 32) 28e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return Type::getInt32Ty(Ty->getContext()); 29e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 30e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return Ty; 31e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall} 32e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 33e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 34e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP AbgrallInstruction *InstCombiner::SimplifyMemTransfer(MemIntrinsic *MI) { 35e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned DstAlign = getKnownAlignment(MI->getArgOperand(0), TD); 36e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned SrcAlign = getKnownAlignment(MI->getArgOperand(1), TD); 37e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned MinAlign = std::min(DstAlign, SrcAlign); 38e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned CopyAlign = MI->getAlignment(); 39e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 40e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (CopyAlign < MinAlign) { 41e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall MI->setAlignment(ConstantInt::get(MI->getAlignmentType(), 42e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall MinAlign, false)); 43e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return MI; 44e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 45e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 46e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If MemCpyInst length is 1/2/4/8 bytes then replace memcpy with 47e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // load/store. 48e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ConstantInt *MemOpLength = dyn_cast<ConstantInt>(MI->getArgOperand(2)); 49e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (MemOpLength == 0) return 0; 50e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 51e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Source and destination pointer types are always "i8*" for intrinsic. See 52e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // if the size is something we can handle with a single primitive load/store. 53e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // A single load+store correctly handles overlapping memory in the memmove 54e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // case. 55e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned Size = MemOpLength->getZExtValue(); 56e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Size == 0) return MI; // Delete this mem transfer. 57e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 58e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Size > 8 || (Size&(Size-1))) 59e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return 0; // If not 1/2/4/8 bytes, exit. 60e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 61e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Use an integer load+store unless we can find something better. 62e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned SrcAddrSp = 63e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<PointerType>(MI->getArgOperand(1)->getType())->getAddressSpace(); 64e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned DstAddrSp = 65e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<PointerType>(MI->getArgOperand(0)->getType())->getAddressSpace(); 66e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 67e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const IntegerType* IntType = IntegerType::get(MI->getContext(), Size<<3); 68e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Type *NewSrcPtrTy = PointerType::get(IntType, SrcAddrSp); 69e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Type *NewDstPtrTy = PointerType::get(IntType, DstAddrSp); 70e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 71e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Memcpy forces the use of i8* for the source and destination. That means 72e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // that if you're using memcpy to move one double around, you'll get a cast 73e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // from double* to i8*. We'd much rather use a double load+store rather than 74e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // an i64 load+store, here because this improves the odds that the source or 75e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // dest address will be promotable. See if we can find a better type than the 76e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // integer datatype. 77e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *StrippedDest = MI->getArgOperand(0)->stripPointerCasts(); 78e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (StrippedDest != MI->getArgOperand(0)) { 79e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *SrcETy = cast<PointerType>(StrippedDest->getType()) 80e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ->getElementType(); 81e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (TD && SrcETy->isSized() && TD->getTypeStoreSize(SrcETy) == Size) { 82e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // The SrcETy might be something like {{{double}}} or [1 x double]. Rip 83e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // down through these levels if so. 84e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall while (!SrcETy->isSingleValueType()) { 85e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (const StructType *STy = dyn_cast<StructType>(SrcETy)) { 86e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (STy->getNumElements() == 1) 87e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall SrcETy = STy->getElementType(0); 88e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall else 89e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 90e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else if (const ArrayType *ATy = dyn_cast<ArrayType>(SrcETy)) { 91e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ATy->getNumElements() == 1) 92e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall SrcETy = ATy->getElementType(); 93e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall else 94e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 95e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else 96e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 97e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 98e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 99e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (SrcETy->isSingleValueType()) { 100e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewSrcPtrTy = PointerType::get(SrcETy, SrcAddrSp); 101e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewDstPtrTy = PointerType::get(SrcETy, DstAddrSp); 102e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 103e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 104e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 105e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 106e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 107e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If the memcpy/memmove provides better alignment info than we can 108e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // infer, use it. 109e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall SrcAlign = std::max(SrcAlign, CopyAlign); 110e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall DstAlign = std::max(DstAlign, CopyAlign); 111e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 112e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *Src = Builder->CreateBitCast(MI->getArgOperand(1), NewSrcPtrTy); 113e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *Dest = Builder->CreateBitCast(MI->getArgOperand(0), NewDstPtrTy); 114e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Instruction *L = new LoadInst(Src, "tmp", MI->isVolatile(), SrcAlign); 115e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall InsertNewInstBefore(L, *MI); 116e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall InsertNewInstBefore(new StoreInst(L, Dest, MI->isVolatile(), DstAlign), 117e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall *MI); 118e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 119e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Set the size of the copy to 0, it will be deleted on the next iteration. 120e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall MI->setArgOperand(2, Constant::getNullValue(MemOpLength->getType())); 121e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return MI; 122e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall} 123e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 124e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP AbgrallInstruction *InstCombiner::SimplifyMemSet(MemSetInst *MI) { 125e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned Alignment = getKnownAlignment(MI->getDest(), TD); 126e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (MI->getAlignment() < Alignment) { 127e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall MI->setAlignment(ConstantInt::get(MI->getAlignmentType(), 128e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Alignment, false)); 129e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return MI; 130e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 131e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 132e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Extract the length and alignment and fill if they are constant. 133e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ConstantInt *LenC = dyn_cast<ConstantInt>(MI->getLength()); 134e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ConstantInt *FillC = dyn_cast<ConstantInt>(MI->getValue()); 135e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!LenC || !FillC || !FillC->getType()->isIntegerTy(8)) 136e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return 0; 137e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall uint64_t Len = LenC->getZExtValue(); 138e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Alignment = MI->getAlignment(); 139e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 140e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If the length is zero, this is a no-op 141e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Len == 0) return MI; // memset(d,c,0,a) -> noop 142e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 143e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // memset(s,c,n) -> store s, c (for n=1,2,4,8) 144e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Len <= 8 && isPowerOf2_32((uint32_t)Len)) { 145e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *ITy = IntegerType::get(MI->getContext(), Len*8); // n=1 -> i8. 146e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 147e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *Dest = MI->getDest(); 148e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned DstAddrSp = cast<PointerType>(Dest->getType())->getAddressSpace(); 149e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Type *NewDstPtrTy = PointerType::get(ITy, DstAddrSp); 150e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Dest = Builder->CreateBitCast(Dest, NewDstPtrTy); 151e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 152e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Alignment 0 is identity for alignment 1 for memset, but not store. 153e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Alignment == 0) Alignment = 1; 154e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 155e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Extract the fill value and store. 156e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall uint64_t Fill = FillC->getZExtValue()*0x0101010101010101ULL; 157e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall InsertNewInstBefore(new StoreInst(ConstantInt::get(ITy, Fill), 158e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Dest, false, Alignment), *MI); 159e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 160e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Set the size of the copy to 0, it will be deleted on the next iteration. 161e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall MI->setLength(Constant::getNullValue(LenC->getType())); 162e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return MI; 163e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 164e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 165e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return 0; 166e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall} 167e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 168e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall/// visitCallInst - CallInst simplification. This mostly only handles folding 169e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall/// of intrinsic instructions. For normal calls, it allows visitCallSite to do 170e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall/// the heavy lifting. 171e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall/// 172e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP AbgrallInstruction *InstCombiner::visitCallInst(CallInst &CI) { 173e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isFreeCall(&CI)) 174e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return visitFree(CI); 175e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isMalloc(&CI)) 176e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return visitMalloc(CI); 177e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 178e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If the caller function is nounwind, mark the call as nounwind, even if the 179e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // callee isn't. 180e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (CI.getParent()->getParent()->doesNotThrow() && 181e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall !CI.doesNotThrow()) { 182e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CI.setDoesNotThrow(); 183e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return &CI; 184e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 185e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 186e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall IntrinsicInst *II = dyn_cast<IntrinsicInst>(&CI); 187e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!II) return visitCallSite(&CI); 188e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 189e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Intrinsics cannot occur in an invoke, so handle them here instead of in 190e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // visitCallSite. 191e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(II)) { 192e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall bool Changed = false; 193e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 194e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // memmove/cpy/set of zero bytes is a noop. 195e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Constant *NumBytes = dyn_cast<Constant>(MI->getLength())) { 196e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (NumBytes->isNullValue()) 197e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return EraseInstFromFunction(CI); 198e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 199e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes)) 200e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (CI->getZExtValue() == 1) { 201e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Replace the instruction with just byte operations. We would 202e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // transform other cases to loads/stores, but we don't know if 203e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // alignment is sufficient. 204e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 205e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 206e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 207e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // No other transformations apply to volatile transfers. 208e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (MI->isVolatile()) 209e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return 0; 210e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 211e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If we have a memmove and the source operation is a constant global, 212e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // then the source and dest pointers can't alias, so we can change this 213e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // into a call to memcpy. 214e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (MemMoveInst *MMI = dyn_cast<MemMoveInst>(MI)) { 215e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (GlobalVariable *GVSrc = dyn_cast<GlobalVariable>(MMI->getSource())) 216e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (GVSrc->isConstant()) { 217e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Module *M = CI.getParent()->getParent()->getParent(); 218e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Intrinsic::ID MemCpyID = Intrinsic::memcpy; 219e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *Tys[3] = { CI.getArgOperand(0)->getType(), 220e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CI.getArgOperand(1)->getType(), 221e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CI.getArgOperand(2)->getType() }; 222e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CI.setCalledFunction(Intrinsic::getDeclaration(M, MemCpyID, Tys, 3)); 223e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Changed = true; 224e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 225e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 226e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 227e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI)) { 228e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // memmove(x,x,size) -> noop. 229e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (MTI->getSource() == MTI->getDest()) 230e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return EraseInstFromFunction(CI); 231e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 232e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 233e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If we can determine a pointer alignment that is bigger than currently 234e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // set, update the alignment. 235e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isa<MemTransferInst>(MI)) { 236e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Instruction *I = SimplifyMemTransfer(MI)) 237e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return I; 238e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else if (MemSetInst *MSI = dyn_cast<MemSetInst>(MI)) { 239e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Instruction *I = SimplifyMemSet(MSI)) 240e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return I; 241e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 242e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 243e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Changed) return II; 244e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 245e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 246e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall switch (II->getIntrinsicID()) { 247e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall default: break; 248e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::objectsize: { 249e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // We need target data for just about everything so depend on it. 250e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!TD) break; 251e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 252e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *ReturnTy = CI.getType(); 253e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall uint64_t DontKnow = II->getArgOperand(1) == Builder->getTrue() ? 0 : -1ULL; 254e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 255e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Get to the real allocated thing and offset as fast as possible. 256e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *Op1 = II->getArgOperand(0)->stripPointerCasts(); 257e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 258e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall uint64_t Offset = 0; 259e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall uint64_t Size = -1ULL; 260e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 261e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Try to look through constant GEPs. 262e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (GEPOperator *GEP = dyn_cast<GEPOperator>(Op1)) { 263e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!GEP->hasAllConstantIndices()) break; 264e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 265e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Get the current byte offset into the thing. Use the original 266e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // operand in case we're looking through a bitcast. 267e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall SmallVector<Value*, 8> Ops(GEP->idx_begin(), GEP->idx_end()); 268e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Offset = TD->getIndexedOffset(GEP->getPointerOperandType(), 269e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Ops.data(), Ops.size()); 270e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 271e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Op1 = GEP->getPointerOperand()->stripPointerCasts(); 272e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 273e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Make sure we're not a constant offset from an external 274e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // global. 275e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Op1)) 276e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!GV->hasDefinitiveInitializer()) break; 277e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 278e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 279e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If we've stripped down to a single global variable that we 280e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // can know the size of then just return that. 281e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Op1)) { 282e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (GV->hasDefinitiveInitializer()) { 283e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *C = GV->getInitializer(); 284e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Size = TD->getTypeAllocSize(C->getType()); 285e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else { 286e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Can't determine size of the GV. 287e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *RetVal = ConstantInt::get(ReturnTy, DontKnow); 288e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return ReplaceInstUsesWith(CI, RetVal); 289e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 290e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else if (AllocaInst *AI = dyn_cast<AllocaInst>(Op1)) { 291e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Get alloca size. 292e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (AI->getAllocatedType()->isSized()) { 293e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Size = TD->getTypeAllocSize(AI->getAllocatedType()); 294e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (AI->isArrayAllocation()) { 295e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const ConstantInt *C = dyn_cast<ConstantInt>(AI->getArraySize()); 296e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!C) break; 297e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Size *= C->getZExtValue(); 298e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 299e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 300e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else if (CallInst *MI = extractMallocCall(Op1)) { 301e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Get allocation size. 302e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type* MallocType = getMallocAllocatedType(MI); 303e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (MallocType && MallocType->isSized()) 304e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Value *NElems = getMallocArraySize(MI, TD, true)) 305e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ConstantInt *NElements = dyn_cast<ConstantInt>(NElems)) 306e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Size = NElements->getZExtValue() * TD->getTypeAllocSize(MallocType); 307e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 308e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 309e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Do not return "I don't know" here. Later optimization passes could 310e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // make it possible to evaluate objectsize to a constant. 311e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Size == -1ULL) 312e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 313e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 314e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Size < Offset) { 315e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Out of bound reference? Negative index normalized to large 316e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // index? Just return "I don't know". 317e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return ReplaceInstUsesWith(CI, ConstantInt::get(ReturnTy, DontKnow)); 318e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 319e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return ReplaceInstUsesWith(CI, ConstantInt::get(ReturnTy, Size-Offset)); 320e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 321e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::bswap: 322e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // bswap(bswap(x)) -> x 323e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (IntrinsicInst *Operand = dyn_cast<IntrinsicInst>(II->getArgOperand(0))) 324e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Operand->getIntrinsicID() == Intrinsic::bswap) 325e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return ReplaceInstUsesWith(CI, Operand->getArgOperand(0)); 326e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 327e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // bswap(trunc(bswap(x))) -> trunc(lshr(x, c)) 328e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (TruncInst *TI = dyn_cast<TruncInst>(II->getArgOperand(0))) { 329e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (IntrinsicInst *Operand = dyn_cast<IntrinsicInst>(TI->getOperand(0))) 330e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Operand->getIntrinsicID() == Intrinsic::bswap) { 331e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned C = Operand->getType()->getPrimitiveSizeInBits() - 332e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall TI->getType()->getPrimitiveSizeInBits(); 333e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *CV = ConstantInt::get(Operand->getType(), C); 334e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *V = Builder->CreateLShr(Operand->getArgOperand(0), CV); 335e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return new TruncInst(V, TI->getType()); 336e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 337e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 338e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 339e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 340e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::powi: 341e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ConstantInt *Power = dyn_cast<ConstantInt>(II->getArgOperand(1))) { 342e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // powi(x, 0) -> 1.0 343e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Power->isZero()) 344e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return ReplaceInstUsesWith(CI, ConstantFP::get(CI.getType(), 1.0)); 345e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // powi(x, 1) -> x 346e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Power->isOne()) 347e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return ReplaceInstUsesWith(CI, II->getArgOperand(0)); 348e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // powi(x, -1) -> 1/x 349e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Power->isAllOnesValue()) 350e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return BinaryOperator::CreateFDiv(ConstantFP::get(CI.getType(), 1.0), 351e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall II->getArgOperand(0)); 352e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 353e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 354e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::cttz: { 355e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If all bits below the first known one are known zero, 356e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // this value is constant. 357e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const IntegerType *IT = cast<IntegerType>(II->getArgOperand(0)->getType()); 358e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall uint32_t BitWidth = IT->getBitWidth(); 359e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt KnownZero(BitWidth, 0); 360e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt KnownOne(BitWidth, 0); 361e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ComputeMaskedBits(II->getArgOperand(0), APInt::getAllOnesValue(BitWidth), 362e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall KnownZero, KnownOne); 363e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned TrailingZeros = KnownOne.countTrailingZeros(); 364e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt Mask(APInt::getLowBitsSet(BitWidth, TrailingZeros)); 365e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if ((Mask & KnownZero) == Mask) 366e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return ReplaceInstUsesWith(CI, ConstantInt::get(IT, 367e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt(BitWidth, TrailingZeros))); 368e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 369e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 370e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 371e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::ctlz: { 372e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If all bits above the first known one are known zero, 373e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // this value is constant. 374e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const IntegerType *IT = cast<IntegerType>(II->getArgOperand(0)->getType()); 375e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall uint32_t BitWidth = IT->getBitWidth(); 376e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt KnownZero(BitWidth, 0); 377e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt KnownOne(BitWidth, 0); 378e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ComputeMaskedBits(II->getArgOperand(0), APInt::getAllOnesValue(BitWidth), 379e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall KnownZero, KnownOne); 380e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned LeadingZeros = KnownOne.countLeadingZeros(); 381e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt Mask(APInt::getHighBitsSet(BitWidth, LeadingZeros)); 382e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if ((Mask & KnownZero) == Mask) 383e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return ReplaceInstUsesWith(CI, ConstantInt::get(IT, 384e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt(BitWidth, LeadingZeros))); 385e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 386e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 387e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 388e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::uadd_with_overflow: { 389e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *LHS = II->getArgOperand(0), *RHS = II->getArgOperand(1); 390e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const IntegerType *IT = cast<IntegerType>(II->getArgOperand(0)->getType()); 391e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall uint32_t BitWidth = IT->getBitWidth(); 392e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt Mask = APInt::getSignBit(BitWidth); 393e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt LHSKnownZero(BitWidth, 0); 394e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt LHSKnownOne(BitWidth, 0); 395e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ComputeMaskedBits(LHS, Mask, LHSKnownZero, LHSKnownOne); 396e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall bool LHSKnownNegative = LHSKnownOne[BitWidth - 1]; 397e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall bool LHSKnownPositive = LHSKnownZero[BitWidth - 1]; 398e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 399e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (LHSKnownNegative || LHSKnownPositive) { 400e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt RHSKnownZero(BitWidth, 0); 401e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt RHSKnownOne(BitWidth, 0); 402e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ComputeMaskedBits(RHS, Mask, RHSKnownZero, RHSKnownOne); 403e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall bool RHSKnownNegative = RHSKnownOne[BitWidth - 1]; 404e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall bool RHSKnownPositive = RHSKnownZero[BitWidth - 1]; 405e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (LHSKnownNegative && RHSKnownNegative) { 406e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // The sign bit is set in both cases: this MUST overflow. 407e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Create a simple add instruction, and insert it into the struct. 408e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Instruction *Add = BinaryOperator::CreateAdd(LHS, RHS, "", &CI); 409e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Worklist.Add(Add); 410e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *V[] = { 411e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall UndefValue::get(LHS->getType()),ConstantInt::getTrue(II->getContext()) 412e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall }; 413e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *Struct = ConstantStruct::get(II->getContext(), V, 2, false); 414e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return InsertValueInst::Create(Struct, Add, 0); 415e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 416e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 417e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (LHSKnownPositive && RHSKnownPositive) { 418e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // The sign bit is clear in both cases: this CANNOT overflow. 419e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Create a simple add instruction, and insert it into the struct. 420e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Instruction *Add = BinaryOperator::CreateNUWAdd(LHS, RHS, "", &CI); 421e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Worklist.Add(Add); 422e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *V[] = { 423e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall UndefValue::get(LHS->getType()), 424e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ConstantInt::getFalse(II->getContext()) 425e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall }; 426e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *Struct = ConstantStruct::get(II->getContext(), V, 2, false); 427e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return InsertValueInst::Create(Struct, Add, 0); 428e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 429e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 430e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 431e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // FALL THROUGH uadd into sadd 432e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::sadd_with_overflow: 433e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Canonicalize constants into the RHS. 434e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isa<Constant>(II->getArgOperand(0)) && 435e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall !isa<Constant>(II->getArgOperand(1))) { 436e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *LHS = II->getArgOperand(0); 437e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall II->setArgOperand(0, II->getArgOperand(1)); 438e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall II->setArgOperand(1, LHS); 439e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return II; 440e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 441e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 442e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // X + undef -> undef 443e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isa<UndefValue>(II->getArgOperand(1))) 444e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return ReplaceInstUsesWith(CI, UndefValue::get(II->getType())); 445e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 446e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ConstantInt *RHS = dyn_cast<ConstantInt>(II->getArgOperand(1))) { 447e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // X + 0 -> {X, false} 448e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (RHS->isZero()) { 449e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *V[] = { 450e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall UndefValue::get(II->getArgOperand(0)->getType()), 451e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ConstantInt::getFalse(II->getContext()) 452e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall }; 453e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *Struct = ConstantStruct::get(II->getContext(), V, 2, false); 454e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return InsertValueInst::Create(Struct, II->getArgOperand(0), 0); 455e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 456e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 457e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 458e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::usub_with_overflow: 459e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::ssub_with_overflow: 460e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // undef - X -> undef 461e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // X - undef -> undef 462e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isa<UndefValue>(II->getArgOperand(0)) || 463e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall isa<UndefValue>(II->getArgOperand(1))) 464e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return ReplaceInstUsesWith(CI, UndefValue::get(II->getType())); 465e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 466e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ConstantInt *RHS = dyn_cast<ConstantInt>(II->getArgOperand(1))) { 467e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // X - 0 -> {X, false} 468e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (RHS->isZero()) { 469e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *V[] = { 470e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall UndefValue::get(II->getArgOperand(0)->getType()), 471e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ConstantInt::getFalse(II->getContext()) 472e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall }; 473e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *Struct = ConstantStruct::get(II->getContext(), V, 2, false); 474e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return InsertValueInst::Create(Struct, II->getArgOperand(0), 0); 475e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 476e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 477e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 478e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::umul_with_overflow: 479e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::smul_with_overflow: 480e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Canonicalize constants into the RHS. 481e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isa<Constant>(II->getArgOperand(0)) && 482e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall !isa<Constant>(II->getArgOperand(1))) { 483e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *LHS = II->getArgOperand(0); 484e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall II->setArgOperand(0, II->getArgOperand(1)); 485e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall II->setArgOperand(1, LHS); 486e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return II; 487e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 488e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 489e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // X * undef -> undef 490e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isa<UndefValue>(II->getArgOperand(1))) 491e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return ReplaceInstUsesWith(CI, UndefValue::get(II->getType())); 492e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 493e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ConstantInt *RHSI = dyn_cast<ConstantInt>(II->getArgOperand(1))) { 494e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // X*0 -> {0, false} 495e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (RHSI->isZero()) 496e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return ReplaceInstUsesWith(CI, Constant::getNullValue(II->getType())); 497e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 498e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // X * 1 -> {X, false} 499e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (RHSI->equalsInt(1)) { 500e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *V[] = { 501e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall UndefValue::get(II->getArgOperand(0)->getType()), 502e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ConstantInt::getFalse(II->getContext()) 503e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall }; 504e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *Struct = ConstantStruct::get(II->getContext(), V, 2, false); 505e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return InsertValueInst::Create(Struct, II->getArgOperand(0), 0); 506e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 507e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 508e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 509e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::ppc_altivec_lvx: 510e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::ppc_altivec_lvxl: 511e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse_loadu_ps: 512e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse2_loadu_pd: 513e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse2_loadu_dq: 514e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Turn PPC lvx -> load if the pointer is known aligned. 515e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Turn X86 loadups -> load if the pointer is known aligned. 516e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, TD) >= 16) { 517e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0), 518e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall PointerType::getUnqual(II->getType())); 519e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return new LoadInst(Ptr); 520e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 521e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 522e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::ppc_altivec_stvx: 523e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::ppc_altivec_stvxl: 524e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Turn stvx -> store if the pointer is known aligned. 525e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (getOrEnforceKnownAlignment(II->getArgOperand(1), 16, TD) >= 16) { 526e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *OpPtrTy = 527e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall PointerType::getUnqual(II->getArgOperand(0)->getType()); 528e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *Ptr = Builder->CreateBitCast(II->getArgOperand(1), OpPtrTy); 529e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return new StoreInst(II->getArgOperand(0), Ptr); 530e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 531e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 532e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse_storeu_ps: 533e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse2_storeu_pd: 534e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse2_storeu_dq: 535e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Turn X86 storeu -> store if the pointer is known aligned. 536e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, TD) >= 16) { 537e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *OpPtrTy = 538e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall PointerType::getUnqual(II->getArgOperand(1)->getType()); 539e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0), OpPtrTy); 540e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return new StoreInst(II->getArgOperand(1), Ptr); 541e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 542e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 543e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 544e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse_cvtss2si: 545e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse_cvtss2si64: 546e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse_cvttss2si: 547e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse_cvttss2si64: 548e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse2_cvtsd2si: 549e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse2_cvtsd2si64: 550e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse2_cvttsd2si: 551e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::x86_sse2_cvttsd2si64: { 552e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // These intrinsics only demand the 0th element of their input vectors. If 553e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // we can simplify the input based on that, do so now. 554e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned VWidth = 555e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<VectorType>(II->getArgOperand(0)->getType())->getNumElements(); 556e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt DemandedElts(VWidth, 1); 557e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall APInt UndefElts(VWidth, 0); 558e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Value *V = SimplifyDemandedVectorElts(II->getArgOperand(0), 559e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall DemandedElts, UndefElts)) { 560e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall II->setArgOperand(0, V); 561e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return II; 562e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 563e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 564e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 565e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 566e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::ppc_altivec_vperm: 567e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Turn vperm(V1,V2,mask) -> shuffle(V1,V2,mask) if mask is a constant. 568e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ConstantVector *Mask = dyn_cast<ConstantVector>(II->getArgOperand(2))) { 569e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall assert(Mask->getNumOperands() == 16 && "Bad type for intrinsic!"); 570e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 571e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Check that all of the elements are integer constants or undefs. 572e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall bool AllEltsOk = true; 573e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall for (unsigned i = 0; i != 16; ++i) { 574e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!isa<ConstantInt>(Mask->getOperand(i)) && 575e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall !isa<UndefValue>(Mask->getOperand(i))) { 576e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall AllEltsOk = false; 577e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 578e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 579e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 580e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 581e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (AllEltsOk) { 582e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Cast the input vectors to byte vectors. 583e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *Op0 = Builder->CreateBitCast(II->getArgOperand(0), 584e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Mask->getType()); 585e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *Op1 = Builder->CreateBitCast(II->getArgOperand(1), 586e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Mask->getType()); 587e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *Result = UndefValue::get(Op0->getType()); 588e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 589e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Only extract each element once. 590e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *ExtractedElts[32]; 591e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall memset(ExtractedElts, 0, sizeof(ExtractedElts)); 592e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 593e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall for (unsigned i = 0; i != 16; ++i) { 594e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isa<UndefValue>(Mask->getOperand(i))) 595e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall continue; 596e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned Idx=cast<ConstantInt>(Mask->getOperand(i))->getZExtValue(); 597e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Idx &= 31; // Match the hardware behavior. 598e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 599e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ExtractedElts[Idx] == 0) { 600e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ExtractedElts[Idx] = 601e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Builder->CreateExtractElement(Idx < 16 ? Op0 : Op1, 602e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ConstantInt::get(Type::getInt32Ty(II->getContext()), 603e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Idx&15, false), "tmp"); 604e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 605e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 606e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Insert this value into the result vector. 607e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Result = Builder->CreateInsertElement(Result, ExtractedElts[Idx], 608e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ConstantInt::get(Type::getInt32Ty(II->getContext()), 609e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall i, false), "tmp"); 610e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 611e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return CastInst::Create(Instruction::BitCast, Result, CI.getType()); 612e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 613e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 614e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 615e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 616e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vld1: 617e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vld2: 618e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vld3: 619e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vld4: 620e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vld2lane: 621e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vld3lane: 622e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vld4lane: 623e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vst1: 624e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vst2: 625e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vst3: 626e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vst4: 627e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vst2lane: 628e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vst3lane: 629e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::arm_neon_vst4lane: { 630e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned MemAlign = getKnownAlignment(II->getArgOperand(0), TD); 631e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned AlignArg = II->getNumArgOperands() - 1; 632e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ConstantInt *IntrAlign = dyn_cast<ConstantInt>(II->getArgOperand(AlignArg)); 633e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (IntrAlign && IntrAlign->getZExtValue() < MemAlign) { 634e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall II->setArgOperand(AlignArg, 635e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ConstantInt::get(Type::getInt32Ty(II->getContext()), 636e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall MemAlign, false)); 637e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return II; 638e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 639e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 640e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 641e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 642e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall case Intrinsic::stackrestore: { 643e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If the save is right next to the restore, remove the restore. This can 644e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // happen when variable allocas are DCE'd. 645e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (IntrinsicInst *SS = dyn_cast<IntrinsicInst>(II->getArgOperand(0))) { 646e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (SS->getIntrinsicID() == Intrinsic::stacksave) { 647e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall BasicBlock::iterator BI = SS; 648e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (&*++BI == II) 649e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return EraseInstFromFunction(CI); 650e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 651e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 652e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 653e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Scan down this block to see if there is another stack restore in the 654e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // same block without an intervening call/alloca. 655e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall BasicBlock::iterator BI = II; 656e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall TerminatorInst *TI = II->getParent()->getTerminator(); 657e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall bool CannotRemove = false; 658e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall for (++BI; &*BI != TI; ++BI) { 659e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isa<AllocaInst>(BI) || isMalloc(BI)) { 660e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CannotRemove = true; 661e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 662e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 663e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (CallInst *BCI = dyn_cast<CallInst>(BI)) { 664e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(BCI)) { 665e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If there is a stackrestore below this one, remove this one. 666e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (II->getIntrinsicID() == Intrinsic::stackrestore) 667e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return EraseInstFromFunction(CI); 668e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Otherwise, ignore the intrinsic. 669e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else { 670e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If we found a non-intrinsic call, we can't remove the stack 671e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // restore. 672e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CannotRemove = true; 673e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 674e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 675e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 676e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 677e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 678e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If the stack restore is in a return/unwind block and if there are no 679e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // allocas or calls between the restore and the return, nuke the restore. 680e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!CannotRemove && (isa<ReturnInst>(TI) || isa<UnwindInst>(TI))) 681e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return EraseInstFromFunction(CI); 682e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 683e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 684e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 685e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 686e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return visitCallSite(II); 687e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall} 688e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 689e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// InvokeInst simplification 690e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// 691e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP AbgrallInstruction *InstCombiner::visitInvokeInst(InvokeInst &II) { 692e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return visitCallSite(&II); 693e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall} 694e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 695e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall/// isSafeToEliminateVarargsCast - If this cast does not affect the value 696e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall/// passed through the varargs area, we can eliminate the use of the cast. 697e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrallstatic bool isSafeToEliminateVarargsCast(const CallSite CS, 698e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const CastInst * const CI, 699e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const TargetData * const TD, 700e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const int ix) { 701e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!CI->isLosslessCast()) 702e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; 703e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 704e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // The size of ByVal arguments is derived from the type, so we 705e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // can't change to a type with a different size. If the size were 706e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // passed explicitly we could avoid this check. 707e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!CS.paramHasAttr(ix, Attribute::ByVal)) 708e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return true; 709e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 710e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type* SrcTy = 711e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<PointerType>(CI->getOperand(0)->getType())->getElementType(); 712e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type* DstTy = cast<PointerType>(CI->getType())->getElementType(); 713e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!SrcTy->isSized() || !DstTy->isSized()) 714e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; 715e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!TD || TD->getTypeAllocSize(SrcTy) != TD->getTypeAllocSize(DstTy)) 716e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; 717e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return true; 718e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall} 719e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 720e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrallnamespace { 721e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrallclass InstCombineFortifiedLibCalls : public SimplifyFortifiedLibCalls { 722e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall InstCombiner *IC; 723e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrallprotected: 724e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall void replaceCall(Value *With) { 725e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewInstruction = IC->ReplaceInstUsesWith(*CI, With); 726e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 727e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall bool isFoldable(unsigned SizeCIOp, unsigned SizeArgOp, bool isString) const { 728e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (CI->getArgOperand(SizeCIOp) == CI->getArgOperand(SizeArgOp)) 729e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return true; 730e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ConstantInt *SizeCI = 731e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall dyn_cast<ConstantInt>(CI->getArgOperand(SizeCIOp))) { 732e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (SizeCI->isAllOnesValue()) 733e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return true; 734e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isString) 735e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return SizeCI->getZExtValue() >= 736e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall GetStringLength(CI->getArgOperand(SizeArgOp)); 737e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ConstantInt *Arg = dyn_cast<ConstantInt>( 738e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CI->getArgOperand(SizeArgOp))) 739e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return SizeCI->getZExtValue() >= Arg->getZExtValue(); 740e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 741e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; 742e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 743e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrallpublic: 744e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall InstCombineFortifiedLibCalls(InstCombiner *IC) : IC(IC), NewInstruction(0) { } 745e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Instruction *NewInstruction; 746e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall}; 747e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall} // end anonymous namespace 748e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 749e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// Try to fold some different type of calls here. 750e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// Currently we're only working with the checking functions, memcpy_chk, 751e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// mempcpy_chk, memmove_chk, memset_chk, strcpy_chk, stpcpy_chk, strncpy_chk, 752e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// strcat_chk and strncat_chk. 753e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP AbgrallInstruction *InstCombiner::tryOptimizeCall(CallInst *CI, const TargetData *TD) { 754e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (CI->getCalledFunction() == 0) return 0; 755e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 756e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall InstCombineFortifiedLibCalls Simplifier(this); 757e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Simplifier.fold(CI, TD); 758e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return Simplifier.NewInstruction; 759e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall} 760e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 761e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// visitCallSite - Improvements for call and invoke instructions. 762e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// 763e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP AbgrallInstruction *InstCombiner::visitCallSite(CallSite CS) { 764e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall bool Changed = false; 765e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 766e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If the callee is a pointer to a function, attempt to move any casts to the 767e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // arguments of the call/invoke. 768e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *Callee = CS.getCalledValue(); 769e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!isa<Function>(Callee) && transformConstExprCastCall(CS)) 770e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return 0; 771e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 772e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Function *CalleeF = dyn_cast<Function>(Callee)) 773e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If the call and callee calling conventions don't match, this call must 774e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // be unreachable, as the call is undefined. 775e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (CalleeF->getCallingConv() != CS.getCallingConv() && 776e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Only do this for calls to a function with a body. A prototype may 777e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // not actually end up matching the implementation's calling conv for a 778e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // variety of reasons (e.g. it may be written in assembly). 779e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall !CalleeF->isDeclaration()) { 780e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Instruction *OldCall = CS.getInstruction(); 781e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall new StoreInst(ConstantInt::getTrue(Callee->getContext()), 782e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall UndefValue::get(Type::getInt1PtrTy(Callee->getContext())), 783e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall OldCall); 784e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If OldCall dues not return void then replaceAllUsesWith undef. 785e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // This allows ValueHandlers and custom metadata to adjust itself. 786e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!OldCall->getType()->isVoidTy()) 787e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall OldCall->replaceAllUsesWith(UndefValue::get(OldCall->getType())); 788e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isa<CallInst>(OldCall)) 789e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return EraseInstFromFunction(*OldCall); 790e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 791e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // We cannot remove an invoke, because it would change the CFG, just 792e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // change the callee to a null pointer. 793e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<InvokeInst>(OldCall)->setCalledFunction( 794e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant::getNullValue(CalleeF->getType())); 795e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return 0; 796e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 797e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 798e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isa<ConstantPointerNull>(Callee) || isa<UndefValue>(Callee)) { 799e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // This instruction is not reachable, just remove it. We insert a store to 800e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // undef so that we know that this code is not reachable, despite the fact 801e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // that we can't modify the CFG here. 802e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall new StoreInst(ConstantInt::getTrue(Callee->getContext()), 803e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall UndefValue::get(Type::getInt1PtrTy(Callee->getContext())), 804e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CS.getInstruction()); 805e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 806e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If CS does not return void then replaceAllUsesWith undef. 807e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // This allows ValueHandlers and custom metadata to adjust itself. 808e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!CS.getInstruction()->getType()->isVoidTy()) 809e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CS.getInstruction()-> 810e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall replaceAllUsesWith(UndefValue::get(CS.getInstruction()->getType())); 811e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 812e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (InvokeInst *II = dyn_cast<InvokeInst>(CS.getInstruction())) { 813e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Don't break the CFG, insert a dummy cond branch. 814e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall BranchInst::Create(II->getNormalDest(), II->getUnwindDest(), 815e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ConstantInt::getTrue(Callee->getContext()), II); 816e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 817e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return EraseInstFromFunction(*CS.getInstruction()); 818e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 819e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 820e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (BitCastInst *BC = dyn_cast<BitCastInst>(Callee)) 821e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (IntrinsicInst *In = dyn_cast<IntrinsicInst>(BC->getOperand(0))) 822e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (In->getIntrinsicID() == Intrinsic::init_trampoline) 823e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return transformCallThroughTrampoline(CS); 824e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 825e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const PointerType *PTy = cast<PointerType>(Callee->getType()); 826e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 827e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (FTy->isVarArg()) { 828e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall int ix = FTy->getNumParams() + (isa<InvokeInst>(Callee) ? 3 : 1); 829e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // See if we can optimize any arguments passed through the varargs area of 830e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // the call. 831e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall for (CallSite::arg_iterator I = CS.arg_begin()+FTy->getNumParams(), 832e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall E = CS.arg_end(); I != E; ++I, ++ix) { 833e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CastInst *CI = dyn_cast<CastInst>(*I); 834e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (CI && isSafeToEliminateVarargsCast(CS, CI, TD, ix)) { 835e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall *I = CI->getOperand(0); 836e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Changed = true; 837e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 838e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 839e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 840e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 841e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (isa<InlineAsm>(Callee) && !CS.doesNotThrow()) { 842e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Inline asm calls cannot throw - mark them 'nounwind'. 843e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CS.setDoesNotThrow(); 844e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Changed = true; 845e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 846e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 847e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Try to optimize the call if possible, we require TargetData for most of 848e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // this. None of these calls are seen as possibly dead so go ahead and 849e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // delete the instruction now. 850e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (CallInst *CI = dyn_cast<CallInst>(CS.getInstruction())) { 851e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Instruction *I = tryOptimizeCall(CI, TD); 852e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If we changed something return the result, etc. Otherwise let 853e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // the fallthrough check. 854e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (I) return EraseInstFromFunction(*I); 855e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 856e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 857e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return Changed ? CS.getInstruction() : 0; 858e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall} 859e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 860e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// transformConstExprCastCall - If the callee is a constexpr cast of a function, 861e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// attempt to move the cast to the arguments of the call/invoke. 862e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// 863e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrallbool InstCombiner::transformConstExprCastCall(CallSite CS) { 864e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Function *Callee = 865e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall dyn_cast<Function>(CS.getCalledValue()->stripPointerCasts()); 866e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Callee == 0) 867e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; 868e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Instruction *Caller = CS.getInstruction(); 869e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const AttrListPtr &CallerPAL = CS.getAttributes(); 870e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 871e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Okay, this is a cast from a function to a different type. Unless doing so 872e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // would cause a type conversion of one of our arguments, change this call to 873e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // be a direct call with arguments casted to the appropriate types. 874e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // 875e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const FunctionType *FT = Callee->getFunctionType(); 876e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *OldRetTy = Caller->getType(); 877e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *NewRetTy = FT->getReturnType(); 878e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 879e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (NewRetTy->isStructTy()) 880e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; // TODO: Handle multiple return values. 881e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 882e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Check to see if we are changing the return type... 883e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (OldRetTy != NewRetTy) { 884e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Callee->isDeclaration() && 885e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Conversion is ok if changing from one pointer type to another or from 886e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // a pointer to an integer of the same size. 887e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall !((OldRetTy->isPointerTy() || !TD || 888e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall OldRetTy == TD->getIntPtrType(Caller->getContext())) && 889e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall (NewRetTy->isPointerTy() || !TD || 890e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewRetTy == TD->getIntPtrType(Caller->getContext())))) 891e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; // Cannot transform this return value. 892e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 893e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!Caller->use_empty() && 894e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // void -> non-void is handled specially 895e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall !NewRetTy->isVoidTy() && !CastInst::isCastable(NewRetTy, OldRetTy)) 896e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; // Cannot transform this return value. 897e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 898e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!CallerPAL.isEmpty() && !Caller->use_empty()) { 899e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Attributes RAttrs = CallerPAL.getRetAttributes(); 900e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (RAttrs & Attribute::typeIncompatible(NewRetTy)) 901e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; // Attribute not compatible with transformed value. 902e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 903e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 904e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If the callsite is an invoke instruction, and the return value is used by 905e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // a PHI node in a successor, we cannot change the return type of the call 906e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // because there is no place to put the cast instruction (without breaking 907e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // the critical edge). Bail out in this case. 908e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!Caller->use_empty()) 909e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) 910e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall for (Value::use_iterator UI = II->use_begin(), E = II->use_end(); 911e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall UI != E; ++UI) 912e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (PHINode *PN = dyn_cast<PHINode>(*UI)) 913e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (PN->getParent() == II->getNormalDest() || 914e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall PN->getParent() == II->getUnwindDest()) 915e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; 916e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 917e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 918e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned NumActualArgs = unsigned(CS.arg_end()-CS.arg_begin()); 919e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned NumCommonArgs = std::min(FT->getNumParams(), NumActualArgs); 920e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 921e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CallSite::arg_iterator AI = CS.arg_begin(); 922e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall for (unsigned i = 0, e = NumCommonArgs; i != e; ++i, ++AI) { 923e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *ParamTy = FT->getParamType(i); 924e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *ActTy = (*AI)->getType(); 925e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 926e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!CastInst::isCastable(ActTy, ParamTy)) 927e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; // Cannot transform this parameter value. 928e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 929e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned Attrs = CallerPAL.getParamAttributes(i + 1); 930e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Attrs & Attribute::typeIncompatible(ParamTy)) 931e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; // Attribute not compatible with transformed value. 932e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 933e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If the parameter is passed as a byval argument, then we have to have a 934e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // sized type and the sized type has to have the same size as the old type. 935e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ParamTy != ActTy && (Attrs & Attribute::ByVal)) { 936e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy); 937e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (ParamPTy == 0 || !ParamPTy->getElementType()->isSized() || TD == 0) 938e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; 939e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 940e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *CurElTy = cast<PointerType>(ActTy)->getElementType(); 941e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (TD->getTypeAllocSize(CurElTy) != 942e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall TD->getTypeAllocSize(ParamPTy->getElementType())) 943e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; 944e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 945e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 946e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Converting from one pointer type to another or between a pointer and an 947e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // integer of the same size is safe even if we do not have a body. 948e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall bool isConvertible = ActTy == ParamTy || 949e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall (TD && ((ParamTy->isPointerTy() || 950e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ParamTy == TD->getIntPtrType(Caller->getContext())) && 951e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall (ActTy->isPointerTy() || 952e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ActTy == TD->getIntPtrType(Caller->getContext())))); 953e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Callee->isDeclaration() && !isConvertible) return false; 954e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 955e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 956e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (FT->getNumParams() < NumActualArgs && !FT->isVarArg() && 957e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Callee->isDeclaration()) 958e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; // Do not delete arguments unless we have a function body. 959e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 960e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (FT->getNumParams() < NumActualArgs && FT->isVarArg() && 961e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall !CallerPAL.isEmpty()) 962e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // In this case we have more arguments than the new function type, but we 963e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // won't be dropping them. Check that these extra arguments have attributes 964e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // that are compatible with being a vararg call argument. 965e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall for (unsigned i = CallerPAL.getNumSlots(); i; --i) { 966e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (CallerPAL.getSlot(i - 1).Index <= FT->getNumParams()) 967e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 968e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Attributes PAttrs = CallerPAL.getSlot(i - 1).Attrs; 969e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (PAttrs & Attribute::VarArgsIncompatible) 970e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return false; 971e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 972e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 973e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Okay, we decided that this is a safe thing to do: go ahead and start 974e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // inserting cast instructions as necessary... 975e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall std::vector<Value*> Args; 976e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Args.reserve(NumActualArgs); 977e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall SmallVector<AttributeWithIndex, 8> attrVec; 978e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall attrVec.reserve(NumCommonArgs); 979e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 980e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Get any return attributes. 981e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Attributes RAttrs = CallerPAL.getRetAttributes(); 982e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 983e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If the return value is not being used, the type may not be compatible 984e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // with the existing attributes. Wipe out any problematic attributes. 985e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall RAttrs &= ~Attribute::typeIncompatible(NewRetTy); 986e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 987e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Add the new return attributes. 988e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (RAttrs) 989e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall attrVec.push_back(AttributeWithIndex::get(0, RAttrs)); 990e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 991e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall AI = CS.arg_begin(); 992e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall for (unsigned i = 0; i != NumCommonArgs; ++i, ++AI) { 993e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *ParamTy = FT->getParamType(i); 994e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if ((*AI)->getType() == ParamTy) { 995e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Args.push_back(*AI); 996e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else { 997e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Instruction::CastOps opcode = CastInst::getCastOpcode(*AI, 998e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall false, ParamTy, false); 999e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Args.push_back(Builder->CreateCast(opcode, *AI, ParamTy, "tmp")); 1000e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1001e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1002e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Add any parameter attributes. 1003e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Attributes PAttrs = CallerPAL.getParamAttributes(i + 1)) 1004e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall attrVec.push_back(AttributeWithIndex::get(i + 1, PAttrs)); 1005e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1006e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1007e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If the function takes more arguments than the call was taking, add them 1008e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // now. 1009e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall for (unsigned i = NumCommonArgs; i != FT->getNumParams(); ++i) 1010e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Args.push_back(Constant::getNullValue(FT->getParamType(i))); 1011e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1012e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If we are removing arguments to the function, emit an obnoxious warning. 1013e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (FT->getNumParams() < NumActualArgs) { 1014e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!FT->isVarArg()) { 1015e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall errs() << "WARNING: While resolving call to function '" 1016e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall << Callee->getName() << "' arguments were dropped!\n"; 1017e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else { 1018e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Add all of the arguments in their promoted form to the arg list. 1019e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall for (unsigned i = FT->getNumParams(); i != NumActualArgs; ++i, ++AI) { 1020e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *PTy = getPromotedType((*AI)->getType()); 1021e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (PTy != (*AI)->getType()) { 1022e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Must promote to pass through va_arg area! 1023e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Instruction::CastOps opcode = 1024e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CastInst::getCastOpcode(*AI, false, PTy, false); 1025e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Args.push_back(Builder->CreateCast(opcode, *AI, PTy, "tmp")); 1026e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else { 1027e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Args.push_back(*AI); 1028e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1029e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1030e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Add any parameter attributes. 1031e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Attributes PAttrs = CallerPAL.getParamAttributes(i + 1)) 1032e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall attrVec.push_back(AttributeWithIndex::get(i + 1, PAttrs)); 1033e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1034e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1035e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1036e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1037e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Attributes FnAttrs = CallerPAL.getFnAttributes()) 1038e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall attrVec.push_back(AttributeWithIndex::get(~0, FnAttrs)); 1039e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1040e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (NewRetTy->isVoidTy()) 1041e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Caller->setName(""); // Void type should not have a name. 1042e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1043e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const AttrListPtr &NewCallerPAL = AttrListPtr::get(attrVec.begin(), 1044e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall attrVec.end()); 1045e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1046e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Instruction *NC; 1047e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) { 1048e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NC = InvokeInst::Create(Callee, II->getNormalDest(), II->getUnwindDest(), 1049e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Args.begin(), Args.end(), 1050e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Caller->getName(), Caller); 1051e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<InvokeInst>(NC)->setCallingConv(II->getCallingConv()); 1052e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<InvokeInst>(NC)->setAttributes(NewCallerPAL); 1053e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else { 1054e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NC = CallInst::Create(Callee, Args.begin(), Args.end(), 1055e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Caller->getName(), Caller); 1056e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CallInst *CI = cast<CallInst>(Caller); 1057e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (CI->isTailCall()) 1058e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<CallInst>(NC)->setTailCall(); 1059e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<CallInst>(NC)->setCallingConv(CI->getCallingConv()); 1060e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<CallInst>(NC)->setAttributes(NewCallerPAL); 1061e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1062e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1063e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Insert a cast of the return type as necessary. 1064e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *NV = NC; 1065e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (OldRetTy != NV->getType() && !Caller->use_empty()) { 1066e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!NV->getType()->isVoidTy()) { 1067e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Instruction::CastOps opcode = 1068e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CastInst::getCastOpcode(NC, false, OldRetTy, false); 1069e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NV = NC = CastInst::Create(opcode, NC, OldRetTy, "tmp"); 1070e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1071e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If this is an invoke instruction, we should insert it after the first 1072e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // non-phi, instruction in the normal successor block. 1073e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) { 1074e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall BasicBlock::iterator I = II->getNormalDest()->getFirstNonPHI(); 1075e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall InsertNewInstBefore(NC, *I); 1076e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else { 1077e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Otherwise, it's a call, just insert cast right after the call. 1078e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall InsertNewInstBefore(NC, *Caller); 1079e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1080e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Worklist.AddUsersToWorkList(*Caller); 1081e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else { 1082e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NV = UndefValue::get(Caller->getType()); 1083e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1084e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1085e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1086e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!Caller->use_empty()) 1087e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Caller->replaceAllUsesWith(NV); 1088e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1089e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall EraseInstFromFunction(*Caller); 1090e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return true; 1091e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall} 1092e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1093e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// transformCallThroughTrampoline - Turn a call to a function created by the 1094e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// init_trampoline intrinsic into a direct call to the underlying function. 1095e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall// 1096e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP AbgrallInstruction *InstCombiner::transformCallThroughTrampoline(CallSite CS) { 1097e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *Callee = CS.getCalledValue(); 1098e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const PointerType *PTy = cast<PointerType>(Callee->getType()); 1099e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 1100e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const AttrListPtr &Attrs = CS.getAttributes(); 1101e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1102e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // If the call already has the 'nest' attribute somewhere then give up - 1103e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // otherwise 'nest' would occur twice after splicing in the chain. 1104e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Attrs.hasAttrSomewhere(Attribute::Nest)) 1105e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return 0; 1106e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1107e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall IntrinsicInst *Tramp = 1108e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<IntrinsicInst>(cast<BitCastInst>(Callee)->getOperand(0)); 1109e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1110e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Function *NestF =cast<Function>(Tramp->getArgOperand(1)->stripPointerCasts()); 1111e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const PointerType *NestFPTy = cast<PointerType>(NestF->getType()); 1112e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const FunctionType *NestFTy = cast<FunctionType>(NestFPTy->getElementType()); 1113e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1114e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const AttrListPtr &NestAttrs = NestF->getAttributes(); 1115e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!NestAttrs.isEmpty()) { 1116e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned NestIdx = 1; 1117e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const Type *NestTy = 0; 1118e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Attributes NestAttr = Attribute::None; 1119e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1120e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Look for a parameter marked with the 'nest' attribute. 1121e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall for (FunctionType::param_iterator I = NestFTy->param_begin(), 1122e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall E = NestFTy->param_end(); I != E; ++NestIdx, ++I) 1123e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (NestAttrs.paramHasAttr(NestIdx, Attribute::Nest)) { 1124e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Record the parameter type and any other attributes. 1125e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NestTy = *I; 1126e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NestAttr = NestAttrs.getParamAttributes(NestIdx); 1127e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 1128e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1129e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1130e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (NestTy) { 1131e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Instruction *Caller = CS.getInstruction(); 1132e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall std::vector<Value*> NewArgs; 1133e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewArgs.reserve(unsigned(CS.arg_end()-CS.arg_begin())+1); 1134e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1135e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall SmallVector<AttributeWithIndex, 8> NewAttrs; 1136e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewAttrs.reserve(Attrs.getNumSlots() + 1); 1137e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1138e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Insert the nest argument into the call argument list, which may 1139e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // mean appending it. Likewise for attributes. 1140e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1141e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Add any result attributes. 1142e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Attributes Attr = Attrs.getRetAttributes()) 1143e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewAttrs.push_back(AttributeWithIndex::get(0, Attr)); 1144e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1145e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall { 1146e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned Idx = 1; 1147e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); 1148e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall do { 1149e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Idx == NestIdx) { 1150e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Add the chain argument and attributes. 1151e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Value *NestVal = Tramp->getArgOperand(2); 1152e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (NestVal->getType() != NestTy) 1153e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NestVal = new BitCastInst(NestVal, NestTy, "nest", Caller); 1154e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewArgs.push_back(NestVal); 1155e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewAttrs.push_back(AttributeWithIndex::get(NestIdx, NestAttr)); 1156e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1157e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1158e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (I == E) 1159e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 1160e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1161e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Add the original argument and attributes. 1162e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewArgs.push_back(*I); 1163e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Attributes Attr = Attrs.getParamAttributes(Idx)) 1164e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewAttrs.push_back 1165e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall (AttributeWithIndex::get(Idx + (Idx >= NestIdx), Attr)); 1166e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1167e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ++Idx, ++I; 1168e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } while (1); 1169e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1170e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1171e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Add any function attributes. 1172e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Attributes Attr = Attrs.getFnAttributes()) 1173e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewAttrs.push_back(AttributeWithIndex::get(~0, Attr)); 1174e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1175e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // The trampoline may have been bitcast to a bogus type (FTy). 1176e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Handle this by synthesizing a new function type, equal to FTy 1177e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // with the chain parameter inserted. 1178e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1179e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall std::vector<const Type*> NewTypes; 1180e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewTypes.reserve(FTy->getNumParams()+1); 1181e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1182e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Insert the chain's type into the list of parameter types, which may 1183e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // mean appending it. 1184e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall { 1185e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall unsigned Idx = 1; 1186e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall FunctionType::param_iterator I = FTy->param_begin(), 1187e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall E = FTy->param_end(); 1188e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1189e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall do { 1190e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (Idx == NestIdx) 1191e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Add the chain's type. 1192e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewTypes.push_back(NestTy); 1193e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1194e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (I == E) 1195e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall break; 1196e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1197e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Add the original type. 1198e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewTypes.push_back(*I); 1199e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1200e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ++Idx, ++I; 1201e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } while (1); 1202e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1203e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1204e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Replace the trampoline call with a direct call. Let the generic 1205e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // code sort out any function type mismatches. 1206e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall FunctionType *NewFTy = FunctionType::get(FTy->getReturnType(), NewTypes, 1207e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall FTy->isVarArg()); 1208e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *NewCallee = 1209e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NestF->getType() == PointerType::getUnqual(NewFTy) ? 1210e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NestF : ConstantExpr::getBitCast(NestF, 1211e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall PointerType::getUnqual(NewFTy)); 1212e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall const AttrListPtr &NewPAL = AttrListPtr::get(NewAttrs.begin(), 1213e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewAttrs.end()); 1214e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1215e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Instruction *NewCaller; 1216e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) { 1217e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewCaller = InvokeInst::Create(NewCallee, 1218e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall II->getNormalDest(), II->getUnwindDest(), 1219e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewArgs.begin(), NewArgs.end(), 1220e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Caller->getName(), Caller); 1221e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<InvokeInst>(NewCaller)->setCallingConv(II->getCallingConv()); 1222e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<InvokeInst>(NewCaller)->setAttributes(NewPAL); 1223e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } else { 1224e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NewCaller = CallInst::Create(NewCallee, NewArgs.begin(), NewArgs.end(), 1225e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Caller->getName(), Caller); 1226e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (cast<CallInst>(Caller)->isTailCall()) 1227e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<CallInst>(NewCaller)->setTailCall(); 1228e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<CallInst>(NewCaller)-> 1229e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall setCallingConv(cast<CallInst>(Caller)->getCallingConv()); 1230e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall cast<CallInst>(NewCaller)->setAttributes(NewPAL); 1231e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1232e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall if (!Caller->getType()->isVoidTy()) 1233e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Caller->replaceAllUsesWith(NewCaller); 1234e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Caller->eraseFromParent(); 1235e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Worklist.Remove(Caller); 1236e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return 0; 1237e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1238e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall } 1239e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1240e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // Replace the trampoline call with a direct call. Since there is no 'nest' 1241e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // parameter, there is no need to adjust the argument list. Let the generic 1242e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall // code sort out any function type mismatches. 1243e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall Constant *NewCallee = 1244e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall NestF->getType() == PTy ? NestF : 1245e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall ConstantExpr::getBitCast(NestF, PTy); 1246e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall CS.setCalledFunction(NewCallee); 1247e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall return CS.getInstruction(); 1248e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall} 1249e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall 1250e0ed7404719a9ddd2ba427a80db5365c8bad18c0JP Abgrall