Home | History | Annotate | Download | only in Utils 
      1 //===- BuildLibCalls.cpp - Utility builder for libcalls -------------------===//
      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 some functions that will create standard C libcalls.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "llvm/Transforms/Utils/BuildLibCalls.h"
     15 #include "llvm/Constants.h"
     16 #include "llvm/Function.h"
     17 #include "llvm/IRBuilder.h"
     18 #include "llvm/Intrinsics.h"
     19 #include "llvm/Intrinsics.h"
     20 #include "llvm/LLVMContext.h"
     21 #include "llvm/LLVMContext.h"
     22 #include "llvm/Module.h"
     23 #include "llvm/Type.h"
     24 #include "llvm/ADT/SmallString.h"
     25 #include "llvm/Target/TargetData.h"
     26 #include "llvm/Target/TargetLibraryInfo.h"
     27 
     28 using namespace llvm;
     29 
     30 /// CastToCStr - Return V if it is an i8*, otherwise cast it to i8*.
     31 Value *llvm::CastToCStr(Value *V, IRBuilder<> &B) {
     32   return B.CreateBitCast(V, B.getInt8PtrTy(), "cstr");
     33 }
     34 
     35 /// EmitStrLen - Emit a call to the strlen function to the builder, for the
     36 /// specified pointer.  This always returns an integer value of size intptr_t.
     37 Value *llvm::EmitStrLen(Value *Ptr, IRBuilder<> &B, const TargetData *TD,
     38                         const TargetLibraryInfo *TLI) {
     39   if (!TLI->has(LibFunc::strlen))
     40     return 0;
     41 
     42   Module *M = B.GetInsertBlock()->getParent()->getParent();
     43   AttributeWithIndex AWI[2];
     44   AWI[0] = AttributeWithIndex::get(1, Attribute::NoCapture);
     45   AWI[1] = AttributeWithIndex::get(~0u, Attribute::ReadOnly |
     46                                    Attribute::NoUnwind);
     47 
     48   LLVMContext &Context = B.GetInsertBlock()->getContext();
     49   Constant *StrLen = M->getOrInsertFunction("strlen", AttrListPtr::get(AWI),
     50                                             TD->getIntPtrType(Context),
     51                                             B.getInt8PtrTy(),
     52                                             NULL);
     53   CallInst *CI = B.CreateCall(StrLen, CastToCStr(Ptr, B), "strlen");
     54   if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts()))
     55     CI->setCallingConv(F->getCallingConv());
     56 
     57   return CI;
     58 }
     59 
     60 /// EmitStrNLen - Emit a call to the strnlen function to the builder, for the
     61 /// specified pointer.  Ptr is required to be some pointer type, MaxLen must
     62 /// be of size_t type, and the return value has 'intptr_t' type.
     63 Value *llvm::EmitStrNLen(Value *Ptr, Value *MaxLen, IRBuilder<> &B,
     64                          const TargetData *TD, const TargetLibraryInfo *TLI) {
     65   if (!TLI->has(LibFunc::strnlen))
     66     return 0;
     67 
     68   Module *M = B.GetInsertBlock()->getParent()->getParent();
     69   AttributeWithIndex AWI[2];
     70   AWI[0] = AttributeWithIndex::get(1, Attribute::NoCapture);
     71   AWI[1] = AttributeWithIndex::get(~0u, Attribute::ReadOnly |
     72                                    Attribute::NoUnwind);
     73 
     74   LLVMContext &Context = B.GetInsertBlock()->getContext();
     75   Constant *StrNLen = M->getOrInsertFunction("strnlen", AttrListPtr::get(AWI),
     76                                              TD->getIntPtrType(Context),
     77                                              B.getInt8PtrTy(),
     78                                              TD->getIntPtrType(Context),
     79                                              NULL);
     80   CallInst *CI = B.CreateCall2(StrNLen, CastToCStr(Ptr, B), MaxLen, "strnlen");
     81   if (const Function *F = dyn_cast<Function>(StrNLen->stripPointerCasts()))
     82     CI->setCallingConv(F->getCallingConv());
     83 
     84   return CI;
     85 }
     86 
     87 /// EmitStrChr - Emit a call to the strchr function to the builder, for the
     88 /// specified pointer and character.  Ptr is required to be some pointer type,
     89 /// and the return value has 'i8*' type.
     90 Value *llvm::EmitStrChr(Value *Ptr, char C, IRBuilder<> &B,
     91                         const TargetData *TD, const TargetLibraryInfo *TLI) {
     92   if (!TLI->has(LibFunc::strchr))
     93     return 0;
     94 
     95   Module *M = B.GetInsertBlock()->getParent()->getParent();
     96   AttributeWithIndex AWI =
     97     AttributeWithIndex::get(~0u, Attribute::ReadOnly | Attribute::NoUnwind);
     98 
     99   Type *I8Ptr = B.getInt8PtrTy();
    100   Type *I32Ty = B.getInt32Ty();
    101   Constant *StrChr = M->getOrInsertFunction("strchr", AttrListPtr::get(AWI),
    102                                             I8Ptr, I8Ptr, I32Ty, NULL);
    103   CallInst *CI = B.CreateCall2(StrChr, CastToCStr(Ptr, B),
    104                                ConstantInt::get(I32Ty, C), "strchr");
    105   if (const Function *F = dyn_cast<Function>(StrChr->stripPointerCasts()))
    106     CI->setCallingConv(F->getCallingConv());
    107   return CI;
    108 }
    109 
    110 /// EmitStrNCmp - Emit a call to the strncmp function to the builder.
    111 Value *llvm::EmitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len,
    112                          IRBuilder<> &B, const TargetData *TD,
    113                          const TargetLibraryInfo *TLI) {
    114   if (!TLI->has(LibFunc::strncmp))
    115     return 0;
    116 
    117   Module *M = B.GetInsertBlock()->getParent()->getParent();
    118   AttributeWithIndex AWI[3];
    119   AWI[0] = AttributeWithIndex::get(1, Attribute::NoCapture);
    120   AWI[1] = AttributeWithIndex::get(2, Attribute::NoCapture);
    121   AWI[2] = AttributeWithIndex::get(~0u, Attribute::ReadOnly |
    122                                    Attribute::NoUnwind);
    123 
    124   LLVMContext &Context = B.GetInsertBlock()->getContext();
    125   Value *StrNCmp = M->getOrInsertFunction("strncmp", AttrListPtr::get(AWI),
    126                                           B.getInt32Ty(),
    127                                           B.getInt8PtrTy(),
    128                                           B.getInt8PtrTy(),
    129                                           TD->getIntPtrType(Context), NULL);
    130   CallInst *CI = B.CreateCall3(StrNCmp, CastToCStr(Ptr1, B),
    131                                CastToCStr(Ptr2, B), Len, "strncmp");
    132 
    133   if (const Function *F = dyn_cast<Function>(StrNCmp->stripPointerCasts()))
    134     CI->setCallingConv(F->getCallingConv());
    135 
    136   return CI;
    137 }
    138 
    139 /// EmitStrCpy - Emit a call to the strcpy function to the builder, for the
    140 /// specified pointer arguments.
    141 Value *llvm::EmitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
    142                         const TargetData *TD, const TargetLibraryInfo *TLI,
    143                         StringRef Name) {
    144   if (!TLI->has(LibFunc::strcpy))
    145     return 0;
    146 
    147   Module *M = B.GetInsertBlock()->getParent()->getParent();
    148   AttributeWithIndex AWI[2];
    149   AWI[0] = AttributeWithIndex::get(2, Attribute::NoCapture);
    150   AWI[1] = AttributeWithIndex::get(~0u, Attribute::NoUnwind);
    151   Type *I8Ptr = B.getInt8PtrTy();
    152   Value *StrCpy = M->getOrInsertFunction(Name, AttrListPtr::get(AWI),
    153                                          I8Ptr, I8Ptr, I8Ptr, NULL);
    154   CallInst *CI = B.CreateCall2(StrCpy, CastToCStr(Dst, B), CastToCStr(Src, B),
    155                                Name);
    156   if (const Function *F = dyn_cast<Function>(StrCpy->stripPointerCasts()))
    157     CI->setCallingConv(F->getCallingConv());
    158   return CI;
    159 }
    160 
    161 /// EmitStrNCpy - Emit a call to the strncpy function to the builder, for the
    162 /// specified pointer arguments.
    163 Value *llvm::EmitStrNCpy(Value *Dst, Value *Src, Value *Len,
    164                          IRBuilder<> &B, const TargetData *TD,
    165                          const TargetLibraryInfo *TLI, StringRef Name) {
    166   if (!TLI->has(LibFunc::strncpy))
    167     return 0;
    168 
    169   Module *M = B.GetInsertBlock()->getParent()->getParent();
    170   AttributeWithIndex AWI[2];
    171   AWI[0] = AttributeWithIndex::get(2, Attribute::NoCapture);
    172   AWI[1] = AttributeWithIndex::get(~0u, Attribute::NoUnwind);
    173   Type *I8Ptr = B.getInt8PtrTy();
    174   Value *StrNCpy = M->getOrInsertFunction(Name, AttrListPtr::get(AWI),
    175                                           I8Ptr, I8Ptr, I8Ptr,
    176                                           Len->getType(), NULL);
    177   CallInst *CI = B.CreateCall3(StrNCpy, CastToCStr(Dst, B), CastToCStr(Src, B),
    178                                Len, "strncpy");
    179   if (const Function *F = dyn_cast<Function>(StrNCpy->stripPointerCasts()))
    180     CI->setCallingConv(F->getCallingConv());
    181   return CI;
    182 }
    183 
    184 /// EmitMemCpyChk - Emit a call to the __memcpy_chk function to the builder.
    185 /// This expects that the Len and ObjSize have type 'intptr_t' and Dst/Src
    186 /// are pointers.
    187 Value *llvm::EmitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
    188                            IRBuilder<> &B, const TargetData *TD,
    189                            const TargetLibraryInfo *TLI) {
    190   if (!TLI->has(LibFunc::memcpy_chk))
    191     return 0;
    192 
    193   Module *M = B.GetInsertBlock()->getParent()->getParent();
    194   AttributeWithIndex AWI;
    195   AWI = AttributeWithIndex::get(~0u, Attribute::NoUnwind);
    196   LLVMContext &Context = B.GetInsertBlock()->getContext();
    197   Value *MemCpy = M->getOrInsertFunction("__memcpy_chk",
    198                                          AttrListPtr::get(AWI),
    199                                          B.getInt8PtrTy(),
    200                                          B.getInt8PtrTy(),
    201                                          B.getInt8PtrTy(),
    202                                          TD->getIntPtrType(Context),
    203                                          TD->getIntPtrType(Context), NULL);
    204   Dst = CastToCStr(Dst, B);
    205   Src = CastToCStr(Src, B);
    206   CallInst *CI = B.CreateCall4(MemCpy, Dst, Src, Len, ObjSize);
    207   if (const Function *F = dyn_cast<Function>(MemCpy->stripPointerCasts()))
    208     CI->setCallingConv(F->getCallingConv());
    209   return CI;
    210 }
    211 
    212 /// EmitMemChr - Emit a call to the memchr function.  This assumes that Ptr is
    213 /// a pointer, Val is an i32 value, and Len is an 'intptr_t' value.
    214 Value *llvm::EmitMemChr(Value *Ptr, Value *Val,
    215                         Value *Len, IRBuilder<> &B, const TargetData *TD,
    216                         const TargetLibraryInfo *TLI) {
    217   if (!TLI->has(LibFunc::memchr))
    218     return 0;
    219 
    220   Module *M = B.GetInsertBlock()->getParent()->getParent();
    221   AttributeWithIndex AWI;
    222   AWI = AttributeWithIndex::get(~0u, Attribute::ReadOnly | Attribute::NoUnwind);
    223   LLVMContext &Context = B.GetInsertBlock()->getContext();
    224   Value *MemChr = M->getOrInsertFunction("memchr", AttrListPtr::get(AWI),
    225                                          B.getInt8PtrTy(),
    226                                          B.getInt8PtrTy(),
    227                                          B.getInt32Ty(),
    228                                          TD->getIntPtrType(Context),
    229                                          NULL);
    230   CallInst *CI = B.CreateCall3(MemChr, CastToCStr(Ptr, B), Val, Len, "memchr");
    231 
    232   if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts()))
    233     CI->setCallingConv(F->getCallingConv());
    234 
    235   return CI;
    236 }
    237 
    238 /// EmitMemCmp - Emit a call to the memcmp function.
    239 Value *llvm::EmitMemCmp(Value *Ptr1, Value *Ptr2,
    240                         Value *Len, IRBuilder<> &B, const TargetData *TD,
    241                         const TargetLibraryInfo *TLI) {
    242   if (!TLI->has(LibFunc::memcmp))
    243     return 0;
    244 
    245   Module *M = B.GetInsertBlock()->getParent()->getParent();
    246   AttributeWithIndex AWI[3];
    247   AWI[0] = AttributeWithIndex::get(1, Attribute::NoCapture);
    248   AWI[1] = AttributeWithIndex::get(2, Attribute::NoCapture);
    249   AWI[2] = AttributeWithIndex::get(~0u, Attribute::ReadOnly |
    250                                    Attribute::NoUnwind);
    251 
    252   LLVMContext &Context = B.GetInsertBlock()->getContext();
    253   Value *MemCmp = M->getOrInsertFunction("memcmp", AttrListPtr::get(AWI),
    254                                          B.getInt32Ty(),
    255                                          B.getInt8PtrTy(),
    256                                          B.getInt8PtrTy(),
    257                                          TD->getIntPtrType(Context), NULL);
    258   CallInst *CI = B.CreateCall3(MemCmp, CastToCStr(Ptr1, B), CastToCStr(Ptr2, B),
    259                                Len, "memcmp");
    260 
    261   if (const Function *F = dyn_cast<Function>(MemCmp->stripPointerCasts()))
    262     CI->setCallingConv(F->getCallingConv());
    263 
    264   return CI;
    265 }
    266 
    267 /// EmitUnaryFloatFnCall - Emit a call to the unary function named 'Name' (e.g.
    268 /// 'floor').  This function is known to take a single of type matching 'Op' and
    269 /// returns one value with the same type.  If 'Op' is a long double, 'l' is
    270 /// added as the suffix of name, if 'Op' is a float, we add a 'f' suffix.
    271 Value *llvm::EmitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
    272                                   const AttrListPtr &Attrs) {
    273   SmallString<20> NameBuffer;
    274   if (!Op->getType()->isDoubleTy()) {
    275     // If we need to add a suffix, copy into NameBuffer.
    276     NameBuffer += Name;
    277     if (Op->getType()->isFloatTy())
    278       NameBuffer += 'f'; // floorf
    279     else
    280       NameBuffer += 'l'; // floorl
    281     Name = NameBuffer;
    282   }
    283 
    284   Module *M = B.GetInsertBlock()->getParent()->getParent();
    285   Value *Callee = M->getOrInsertFunction(Name, Op->getType(),
    286                                          Op->getType(), NULL);
    287   CallInst *CI = B.CreateCall(Callee, Op, Name);
    288   CI->setAttributes(Attrs);
    289   if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
    290     CI->setCallingConv(F->getCallingConv());
    291 
    292   return CI;
    293 }
    294 
    295 /// EmitPutChar - Emit a call to the putchar function.  This assumes that Char
    296 /// is an integer.
    297 Value *llvm::EmitPutChar(Value *Char, IRBuilder<> &B, const TargetData *TD,
    298                          const TargetLibraryInfo *TLI) {
    299   if (!TLI->has(LibFunc::putchar))
    300     return 0;
    301 
    302   Module *M = B.GetInsertBlock()->getParent()->getParent();
    303   Value *PutChar = M->getOrInsertFunction("putchar", B.getInt32Ty(),
    304                                           B.getInt32Ty(), NULL);
    305   CallInst *CI = B.CreateCall(PutChar,
    306                               B.CreateIntCast(Char,
    307                               B.getInt32Ty(),
    308                               /*isSigned*/true,
    309                               "chari"),
    310                               "putchar");
    311 
    312   if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts()))
    313     CI->setCallingConv(F->getCallingConv());
    314   return CI;
    315 }
    316 
    317 /// EmitPutS - Emit a call to the puts function.  This assumes that Str is
    318 /// some pointer.
    319 Value *llvm::EmitPutS(Value *Str, IRBuilder<> &B, const TargetData *TD,
    320                       const TargetLibraryInfo *TLI) {
    321   if (!TLI->has(LibFunc::puts))
    322     return 0;
    323 
    324   Module *M = B.GetInsertBlock()->getParent()->getParent();
    325   AttributeWithIndex AWI[2];
    326   AWI[0] = AttributeWithIndex::get(1, Attribute::NoCapture);
    327   AWI[1] = AttributeWithIndex::get(~0u, Attribute::NoUnwind);
    328 
    329   Value *PutS = M->getOrInsertFunction("puts", AttrListPtr::get(AWI),
    330                                        B.getInt32Ty(),
    331                                        B.getInt8PtrTy(),
    332                                        NULL);
    333   CallInst *CI = B.CreateCall(PutS, CastToCStr(Str, B), "puts");
    334   if (const Function *F = dyn_cast<Function>(PutS->stripPointerCasts()))
    335     CI->setCallingConv(F->getCallingConv());
    336   return CI;
    337 }
    338 
    339 /// EmitFPutC - Emit a call to the fputc function.  This assumes that Char is
    340 /// an integer and File is a pointer to FILE.
    341 Value *llvm::EmitFPutC(Value *Char, Value *File, IRBuilder<> &B,
    342                        const TargetData *TD, const TargetLibraryInfo *TLI) {
    343   if (!TLI->has(LibFunc::fputc))
    344     return 0;
    345 
    346   Module *M = B.GetInsertBlock()->getParent()->getParent();
    347   AttributeWithIndex AWI[2];
    348   AWI[0] = AttributeWithIndex::get(2, Attribute::NoCapture);
    349   AWI[1] = AttributeWithIndex::get(~0u, Attribute::NoUnwind);
    350   Constant *F;
    351   if (File->getType()->isPointerTy())
    352     F = M->getOrInsertFunction("fputc", AttrListPtr::get(AWI),
    353                                B.getInt32Ty(),
    354                                B.getInt32Ty(), File->getType(),
    355                                NULL);
    356   else
    357     F = M->getOrInsertFunction("fputc",
    358                                B.getInt32Ty(),
    359                                B.getInt32Ty(),
    360                                File->getType(), NULL);
    361   Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
    362                          "chari");
    363   CallInst *CI = B.CreateCall2(F, Char, File, "fputc");
    364 
    365   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
    366     CI->setCallingConv(Fn->getCallingConv());
    367   return CI;
    368 }
    369 
    370 /// EmitFPutS - Emit a call to the puts function.  Str is required to be a
    371 /// pointer and File is a pointer to FILE.
    372 Value *llvm::EmitFPutS(Value *Str, Value *File, IRBuilder<> &B,
    373                        const TargetData *TD, const TargetLibraryInfo *TLI) {
    374   if (!TLI->has(LibFunc::fputs))
    375     return 0;
    376 
    377   Module *M = B.GetInsertBlock()->getParent()->getParent();
    378   AttributeWithIndex AWI[3];
    379   AWI[0] = AttributeWithIndex::get(1, Attribute::NoCapture);
    380   AWI[1] = AttributeWithIndex::get(2, Attribute::NoCapture);
    381   AWI[2] = AttributeWithIndex::get(~0u, Attribute::NoUnwind);
    382   StringRef FPutsName = TLI->getName(LibFunc::fputs);
    383   Constant *F;
    384   if (File->getType()->isPointerTy())
    385     F = M->getOrInsertFunction(FPutsName, AttrListPtr::get(AWI),
    386                                B.getInt32Ty(),
    387                                B.getInt8PtrTy(),
    388                                File->getType(), NULL);
    389   else
    390     F = M->getOrInsertFunction(FPutsName, B.getInt32Ty(),
    391                                B.getInt8PtrTy(),
    392                                File->getType(), NULL);
    393   CallInst *CI = B.CreateCall2(F, CastToCStr(Str, B), File, "fputs");
    394 
    395   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
    396     CI->setCallingConv(Fn->getCallingConv());
    397   return CI;
    398 }
    399 
    400 /// EmitFWrite - Emit a call to the fwrite function.  This assumes that Ptr is
    401 /// a pointer, Size is an 'intptr_t', and File is a pointer to FILE.
    402 Value *llvm::EmitFWrite(Value *Ptr, Value *Size, Value *File,
    403                         IRBuilder<> &B, const TargetData *TD,
    404                         const TargetLibraryInfo *TLI) {
    405   if (!TLI->has(LibFunc::fwrite))
    406     return 0;
    407 
    408   Module *M = B.GetInsertBlock()->getParent()->getParent();
    409   AttributeWithIndex AWI[3];
    410   AWI[0] = AttributeWithIndex::get(1, Attribute::NoCapture);
    411   AWI[1] = AttributeWithIndex::get(4, Attribute::NoCapture);
    412   AWI[2] = AttributeWithIndex::get(~0u, Attribute::NoUnwind);
    413   LLVMContext &Context = B.GetInsertBlock()->getContext();
    414   StringRef FWriteName = TLI->getName(LibFunc::fwrite);
    415   Constant *F;
    416   if (File->getType()->isPointerTy())
    417     F = M->getOrInsertFunction(FWriteName, AttrListPtr::get(AWI),
    418                                TD->getIntPtrType(Context),
    419                                B.getInt8PtrTy(),
    420                                TD->getIntPtrType(Context),
    421                                TD->getIntPtrType(Context),
    422                                File->getType(), NULL);
    423   else
    424     F = M->getOrInsertFunction(FWriteName, TD->getIntPtrType(Context),
    425                                B.getInt8PtrTy(),
    426                                TD->getIntPtrType(Context),
    427                                TD->getIntPtrType(Context),
    428                                File->getType(), NULL);
    429   CallInst *CI = B.CreateCall4(F, CastToCStr(Ptr, B), Size,
    430                         ConstantInt::get(TD->getIntPtrType(Context), 1), File);
    431 
    432   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
    433     CI->setCallingConv(Fn->getCallingConv());
    434   return CI;
    435 }
    436 
    437 SimplifyFortifiedLibCalls::~SimplifyFortifiedLibCalls() { }
    438 
    439 bool SimplifyFortifiedLibCalls::fold(CallInst *CI, const TargetData *TD,
    440                                      const TargetLibraryInfo *TLI) {
    441   // We really need TargetData for later.
    442   if (!TD) return false;
    443 
    444   this->CI = CI;
    445   Function *Callee = CI->getCalledFunction();
    446   StringRef Name = Callee->getName();
    447   FunctionType *FT = Callee->getFunctionType();
    448   LLVMContext &Context = CI->getParent()->getContext();
    449   IRBuilder<> B(CI);
    450 
    451   if (Name == "__memcpy_chk") {
    452     // Check if this has the right signature.
    453     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
    454         !FT->getParamType(0)->isPointerTy() ||
    455         !FT->getParamType(1)->isPointerTy() ||
    456         FT->getParamType(2) != TD->getIntPtrType(Context) ||
    457         FT->getParamType(3) != TD->getIntPtrType(Context))
    458       return false;
    459 
    460     if (isFoldable(3, 2, false)) {
    461       B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
    462                      CI->getArgOperand(2), 1);
    463       replaceCall(CI->getArgOperand(0));
    464       return true;
    465     }
    466     return false;
    467   }
    468 
    469   // Should be similar to memcpy.
    470   if (Name == "__mempcpy_chk") {
    471     return false;
    472   }
    473 
    474   if (Name == "__memmove_chk") {
    475     // Check if this has the right signature.
    476     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
    477         !FT->getParamType(0)->isPointerTy() ||
    478         !FT->getParamType(1)->isPointerTy() ||
    479         FT->getParamType(2) != TD->getIntPtrType(Context) ||
    480         FT->getParamType(3) != TD->getIntPtrType(Context))
    481       return false;
    482 
    483     if (isFoldable(3, 2, false)) {
    484       B.CreateMemMove(CI->getArgOperand(0), CI->getArgOperand(1),
    485                       CI->getArgOperand(2), 1);
    486       replaceCall(CI->getArgOperand(0));
    487       return true;
    488     }
    489     return false;
    490   }
    491 
    492   if (Name == "__memset_chk") {
    493     // Check if this has the right signature.
    494     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
    495         !FT->getParamType(0)->isPointerTy() ||
    496         !FT->getParamType(1)->isIntegerTy() ||
    497         FT->getParamType(2) != TD->getIntPtrType(Context) ||
    498         FT->getParamType(3) != TD->getIntPtrType(Context))
    499       return false;
    500 
    501     if (isFoldable(3, 2, false)) {
    502       Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(),
    503                                    false);
    504       B.CreateMemSet(CI->getArgOperand(0), Val, CI->getArgOperand(2), 1);
    505       replaceCall(CI->getArgOperand(0));
    506       return true;
    507     }
    508     return false;
    509   }
    510 
    511   if (Name == "__strcpy_chk" || Name == "__stpcpy_chk") {
    512     // Check if this has the right signature.
    513     if (FT->getNumParams() != 3 ||
    514         FT->getReturnType() != FT->getParamType(0) ||
    515         FT->getParamType(0) != FT->getParamType(1) ||
    516         FT->getParamType(0) != Type::getInt8PtrTy(Context) ||
    517         FT->getParamType(2) != TD->getIntPtrType(Context))
    518       return 0;
    519 
    520 
    521     // If a) we don't have any length information, or b) we know this will
    522     // fit then just lower to a plain st[rp]cpy. Otherwise we'll keep our
    523     // st[rp]cpy_chk call which may fail at runtime if the size is too long.
    524     // TODO: It might be nice to get a maximum length out of the possible
    525     // string lengths for varying.
    526     if (isFoldable(2, 1, true)) {
    527       Value *Ret = EmitStrCpy(CI->getArgOperand(0), CI->getArgOperand(1), B, TD,
    528                               TLI, Name.substr(2, 6));
    529       if (!Ret)
    530         return false;
    531       replaceCall(Ret);
    532       return true;
    533     }
    534     return false;
    535   }
    536 
    537   if (Name == "__strncpy_chk" || Name == "__stpncpy_chk") {
    538     // Check if this has the right signature.
    539     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
    540         FT->getParamType(0) != FT->getParamType(1) ||
    541         FT->getParamType(0) != Type::getInt8PtrTy(Context) ||
    542         !FT->getParamType(2)->isIntegerTy() ||
    543         FT->getParamType(3) != TD->getIntPtrType(Context))
    544       return false;
    545 
    546     if (isFoldable(3, 2, false)) {
    547       Value *Ret = EmitStrNCpy(CI->getArgOperand(0), CI->getArgOperand(1),
    548                                CI->getArgOperand(2), B, TD, TLI,
    549                                Name.substr(2, 7));
    550       if (!Ret)
    551         return false;
    552       replaceCall(Ret);
    553       return true;
    554     }
    555     return false;
    556   }
    557 
    558   if (Name == "__strcat_chk") {
    559     return false;
    560   }
    561 
    562   if (Name == "__strncat_chk") {
    563     return false;
    564   }
    565 
    566   return false;
    567 }
    568