lib/Transforms/InstCombine/InstCombineCalls.cpp

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